drivers/net/liquidio/lio_rxtx.h

   1 /*
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2017 Cavium, Inc.. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Cavium, Inc. nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #ifndef _LIO_RXTX_H_
  35 #define _LIO_RXTX_H_
  36
  37 #include <stdio.h>
  38 #include <stdint.h>
  39
  40 #include <rte_spinlock.h>
  41 #include <rte_memory.h>
  42
  43 #include "lio_struct.h"
  44
  45 #define LIO_STQUEUE_FIRST_ENTRY(ptr, type, elem)        \
  46         (type *)((char *)((ptr)->stqh_first) - offsetof(type, elem))
  47
  48 #define lio_check_timeout(cur_time, chk_time) ((cur_time) > (chk_time))
  49
  50 #define lio_uptime              \
  51         (size_t)(rte_get_timer_cycles() / rte_get_timer_hz())
  52
  53 struct lio_request_list {
  54         uint32_t reqtype;
  55         void *buf;
  56 };
  57
  58 /** The size of each buffer in soft command buffer pool */
  59 #define LIO_SOFT_COMMAND_BUFFER_SIZE    1536
  60
  61 /** Maximum number of buffers to allocate into soft command buffer pool */
  62 #define LIO_MAX_SOFT_COMMAND_BUFFERS    255
  63
  64 struct lio_soft_command {
  65         /** Soft command buffer info. */
  66         struct lio_stailq_node node;
  67         uint64_t dma_addr;
  68         uint32_t size;
  69
  70 #define LIO_COMPLETION_WORD_INIT        0xffffffffffffffffULL
  71         uint64_t *status_word;
  72
  73         /** Data buffer info */
  74         void *virtdptr;
  75         uint64_t dmadptr;
  76         uint32_t datasize;
  77
  78         /** Return buffer info */
  79         void *virtrptr;
  80         uint64_t dmarptr;
  81         uint32_t rdatasize;
  82
  83         /** Context buffer info */
  84         void *ctxptr;
  85         uint32_t ctxsize;
  86
  87         /** Time out and callback */
  88         size_t wait_time;
  89         size_t timeout;
  90         uint32_t iq_no;
  91         void (*callback)(uint32_t, void *);
  92         void *callback_arg;
  93         struct rte_mbuf *mbuf;
  94 };
  95
  96 int lio_setup_sc_buffer_pool(struct lio_device *lio_dev);
  97 void lio_free_sc_buffer_pool(struct lio_device *lio_dev);
  98
  99 struct lio_soft_command *
 100 lio_alloc_soft_command(struct lio_device *lio_dev,
 101                        uint32_t datasize, uint32_t rdatasize,
 102                        uint32_t ctxsize);
 103 void lio_free_soft_command(struct lio_soft_command *sc);
 104
 105 /** Maximum ordered requests to process in every invocation of
 106  *  lio_process_ordered_list(). The function will continue to process requests
 107  *  as long as it can find one that has finished processing. If it keeps
 108  *  finding requests that have completed, the function can run for ever. The
 109  *  value defined here sets an upper limit on the number of requests it can
 110  *  process before it returns control to the poll thread.
 111  */
 112 #define LIO_MAX_ORD_REQS_TO_PROCESS     4096
 113
 114 /** Error codes used in Octeon Host-Core communication.
 115  *
 116  *   31         16 15           0
 117  *   ----------------------------
 118  * |            |               |
 119  *   ----------------------------
 120  *   Error codes are 32-bit wide. The upper 16-bits, called Major Error Number,
 121  *   are reserved to identify the group to which the error code belongs. The
 122  *   lower 16-bits, called Minor Error Number, carry the actual code.
 123  *
 124  *   So error codes are (MAJOR NUMBER << 16)| MINOR_NUMBER.
 125  */
 126 /** Status for a request.
 127  *  If the request is successfully queued, the driver will return
 128  *  a LIO_REQUEST_PENDING status. LIO_REQUEST_TIMEOUT is only returned by
 129  *  the driver if the response for request failed to arrive before a
 130  *  time-out period or if the request processing * got interrupted due to
 131  *  a signal respectively.
 132  */
 133 enum {
 134         /** A value of 0x00000000 indicates no error i.e. success */
 135         LIO_REQUEST_DONE        = 0x00000000,
 136         /** (Major number: 0x0000; Minor Number: 0x0001) */
 137         LIO_REQUEST_PENDING     = 0x00000001,
 138         LIO_REQUEST_TIMEOUT     = 0x00000003,
 139
 140 };
 141
 142 /*------ Error codes used by firmware (bits 15..0 set by firmware */
 143 #define LIO_FIRMWARE_MAJOR_ERROR_CODE    0x0001
 144 #define LIO_FIRMWARE_STATUS_CODE(status) \
 145         ((LIO_FIRMWARE_MAJOR_ERROR_CODE << 16) | (status))
 146
 147 /** Initialize the response lists. The number of response lists to create is
 148  *  given by count.
 149  *  @param lio_dev - the lio device structure.
 150  */
 151 void lio_setup_response_list(struct lio_device *lio_dev);
 152
 153 /** Check the status of first entry in the ordered list. If the instruction at
 154  *  that entry finished processing or has timed-out, the entry is cleaned.
 155  *  @param lio_dev - the lio device structure.
 156  *  @return 1 if the ordered list is empty, 0 otherwise.
 157  */
 158 int lio_process_ordered_list(struct lio_device *lio_dev);
 159
 160 static inline void
 161 lio_swap_8B_data(uint64_t *data, uint32_t blocks)
 162 {
 163         while (blocks) {
 164                 *data = rte_cpu_to_be_64(*data);
 165                 blocks--;
 166                 data++;
 167         }
 168 }
 169
 170 /** Setup instruction queue zero for the device
 171  *  @param lio_dev which lio device to setup
 172  *
 173  *  @return 0 if success. -1 if fails
 174  */
 175 int lio_setup_instr_queue0(struct lio_device *lio_dev);
 176 void lio_free_instr_queue0(struct lio_device *lio_dev);
 177 #endif  /* _LIO_RXTX_H_ */