05f4704adf5a1334144481b472751cae41d66eb2
[dpdk.git] / 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 /** Descriptor format.
54  *  The descriptor ring is made of descriptors which have 2 64-bit values:
55  *  -# Physical (bus) address of the data buffer.
56  *  -# Physical (bus) address of a lio_droq_info structure.
57  *  The device DMA's incoming packets and its information at the address
58  *  given by these descriptor fields.
59  */
60 struct lio_droq_desc {
61         /** The buffer pointer */
62         uint64_t buffer_ptr;
63
64         /** The Info pointer */
65         uint64_t info_ptr;
66 };
67
68 #define LIO_DROQ_DESC_SIZE      (sizeof(struct lio_droq_desc))
69
70 /** Information about packet DMA'ed by Octeon.
71  *  The format of the information available at Info Pointer after Octeon
72  *  has posted a packet. Not all descriptors have valid information. Only
73  *  the Info field of the first descriptor for a packet has information
74  *  about the packet.
75  */
76 struct lio_droq_info {
77         /** The Output Receive Header. */
78         union octeon_rh rh;
79
80         /** The Length of the packet. */
81         uint64_t length;
82 };
83
84 #define LIO_DROQ_INFO_SIZE      (sizeof(struct lio_droq_info))
85
86 /** Pointer to data buffer.
87  *  Driver keeps a pointer to the data buffer that it made available to
88  *  the Octeon device. Since the descriptor ring keeps physical (bus)
89  *  addresses, this field is required for the driver to keep track of
90  *  the virtual address pointers.
91  */
92 struct lio_recv_buffer {
93         /** Packet buffer, including meta data. */
94         void *buffer;
95
96         /** Data in the packet buffer. */
97         uint8_t *data;
98
99 };
100
101 #define LIO_DROQ_RECVBUF_SIZE   (sizeof(struct lio_recv_buffer))
102
103 #define LIO_DROQ_SIZE           (sizeof(struct lio_droq))
104
105 #define LIO_IQ_SEND_OK          0
106 #define LIO_IQ_SEND_STOP        1
107 #define LIO_IQ_SEND_FAILED      -1
108
109 /* conditions */
110 #define LIO_REQTYPE_NONE                0
111 #define LIO_REQTYPE_NORESP_NET          1
112 #define LIO_REQTYPE_NORESP_NET_SG       2
113 #define LIO_REQTYPE_SOFT_COMMAND        3
114
115 struct lio_request_list {
116         uint32_t reqtype;
117         void *buf;
118 };
119
120 /*----------------------  INSTRUCTION FORMAT ----------------------------*/
121
122 struct lio_instr3_64B {
123         /** Pointer where the input data is available. */
124         uint64_t dptr;
125
126         /** Instruction Header. */
127         uint64_t ih3;
128
129         /** Instruction Header. */
130         uint64_t pki_ih3;
131
132         /** Input Request Header. */
133         uint64_t irh;
134
135         /** opcode/subcode specific parameters */
136         uint64_t ossp[2];
137
138         /** Return Data Parameters */
139         uint64_t rdp;
140
141         /** Pointer where the response for a RAW mode packet will be written
142          *  by Octeon.
143          */
144         uint64_t rptr;
145
146 };
147
148 union lio_instr_64B {
149         struct lio_instr3_64B cmd3;
150 };
151
152 /** The size of each buffer in soft command buffer pool */
153 #define LIO_SOFT_COMMAND_BUFFER_SIZE    1536
154
155 /** Maximum number of buffers to allocate into soft command buffer pool */
156 #define LIO_MAX_SOFT_COMMAND_BUFFERS    255
157
158 struct lio_soft_command {
159         /** Soft command buffer info. */
160         struct lio_stailq_node node;
161         uint64_t dma_addr;
162         uint32_t size;
163
164         /** Command and return status */
165         union lio_instr_64B cmd;
166
167 #define LIO_COMPLETION_WORD_INIT        0xffffffffffffffffULL
168         uint64_t *status_word;
169
170         /** Data buffer info */
171         void *virtdptr;
172         uint64_t dmadptr;
173         uint32_t datasize;
174
175         /** Return buffer info */
176         void *virtrptr;
177         uint64_t dmarptr;
178         uint32_t rdatasize;
179
180         /** Context buffer info */
181         void *ctxptr;
182         uint32_t ctxsize;
183
184         /** Time out and callback */
185         size_t wait_time;
186         size_t timeout;
187         uint32_t iq_no;
188         void (*callback)(uint32_t, void *);
189         void *callback_arg;
190         struct rte_mbuf *mbuf;
191 };
192
193 struct lio_iq_post_status {
194         int status;
195         int index;
196 };
197
198 /*   wqe
199  *  ---------------  0
200  * |  wqe  word0-3 |
201  *  ---------------  32
202  * |    PCI IH     |
203  *  ---------------  40
204  * |     RPTR      |
205  *  ---------------  48
206  * |    PCI IRH    |
207  *  ---------------  56
208  * |    OCTEON_CMD |
209  *  ---------------  64
210  * | Addtl 8-BData |
211  * |               |
212  *  ---------------
213  */
214
215 union octeon_cmd {
216         uint64_t cmd64;
217
218         struct  {
219 #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
220                 uint64_t cmd : 5;
221
222                 uint64_t more : 6; /* How many udd words follow the command */
223
224                 uint64_t reserved : 29;
225
226                 uint64_t param1 : 16;
227
228                 uint64_t param2 : 8;
229
230 #elif RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
231
232                 uint64_t param2 : 8;
233
234                 uint64_t param1 : 16;
235
236                 uint64_t reserved : 29;
237
238                 uint64_t more : 6;
239
240                 uint64_t cmd : 5;
241
242 #endif
243         } s;
244 };
245
246 #define OCTEON_CMD_SIZE (sizeof(union octeon_cmd))
247
248 /* Instruction Header */
249 struct octeon_instr_ih3 {
250 #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
251
252         /** Reserved3 */
253         uint64_t reserved3 : 1;
254
255         /** Gather indicator 1=gather*/
256         uint64_t gather : 1;
257
258         /** Data length OR no. of entries in gather list */
259         uint64_t dlengsz : 14;
260
261         /** Front Data size */
262         uint64_t fsz : 6;
263
264         /** Reserved2 */
265         uint64_t reserved2 : 4;
266
267         /** PKI port kind - PKIND */
268         uint64_t pkind : 6;
269
270         /** Reserved1 */
271         uint64_t reserved1 : 32;
272
273 #elif RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
274         /** Reserved1 */
275         uint64_t reserved1 : 32;
276
277         /** PKI port kind - PKIND */
278         uint64_t pkind : 6;
279
280         /** Reserved2 */
281         uint64_t reserved2 : 4;
282
283         /** Front Data size */
284         uint64_t fsz : 6;
285
286         /** Data length OR no. of entries in gather list */
287         uint64_t dlengsz : 14;
288
289         /** Gather indicator 1=gather*/
290         uint64_t gather : 1;
291
292         /** Reserved3 */
293         uint64_t reserved3 : 1;
294
295 #endif
296 };
297
298 /* PKI Instruction Header(PKI IH) */
299 struct octeon_instr_pki_ih3 {
300 #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
301
302         /** Wider bit */
303         uint64_t w : 1;
304
305         /** Raw mode indicator 1 = RAW */
306         uint64_t raw : 1;
307
308         /** Use Tag */
309         uint64_t utag : 1;
310
311         /** Use QPG */
312         uint64_t uqpg : 1;
313
314         /** Reserved2 */
315         uint64_t reserved2 : 1;
316
317         /** Parse Mode */
318         uint64_t pm : 3;
319
320         /** Skip Length */
321         uint64_t sl : 8;
322
323         /** Use Tag Type */
324         uint64_t utt : 1;
325
326         /** Tag type */
327         uint64_t tagtype : 2;
328
329         /** Reserved1 */
330         uint64_t reserved1 : 2;
331
332         /** QPG Value */
333         uint64_t qpg : 11;
334
335         /** Tag Value */
336         uint64_t tag : 32;
337
338 #elif RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
339
340         /** Tag Value */
341         uint64_t tag : 32;
342
343         /** QPG Value */
344         uint64_t qpg : 11;
345
346         /** Reserved1 */
347         uint64_t reserved1 : 2;
348
349         /** Tag type */
350         uint64_t tagtype : 2;
351
352         /** Use Tag Type */
353         uint64_t utt : 1;
354
355         /** Skip Length */
356         uint64_t sl : 8;
357
358         /** Parse Mode */
359         uint64_t pm : 3;
360
361         /** Reserved2 */
362         uint64_t reserved2 : 1;
363
364         /** Use QPG */
365         uint64_t uqpg : 1;
366
367         /** Use Tag */
368         uint64_t utag : 1;
369
370         /** Raw mode indicator 1 = RAW */
371         uint64_t raw : 1;
372
373         /** Wider bit */
374         uint64_t w : 1;
375 #endif
376 };
377
378 /** Input Request Header */
379 struct octeon_instr_irh {
380 #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
381         uint64_t opcode : 4;
382         uint64_t rflag : 1;
383         uint64_t subcode : 7;
384         uint64_t vlan : 12;
385         uint64_t priority : 3;
386         uint64_t reserved : 5;
387         uint64_t ossp : 32; /* opcode/subcode specific parameters */
388 #elif RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
389         uint64_t ossp : 32; /* opcode/subcode specific parameters */
390         uint64_t reserved : 5;
391         uint64_t priority : 3;
392         uint64_t vlan : 12;
393         uint64_t subcode : 7;
394         uint64_t rflag : 1;
395         uint64_t opcode : 4;
396 #endif
397 };
398
399 /* pkiih3 + irh + ossp[0] + ossp[1] + rdp + rptr = 40 bytes */
400 #define OCTEON_SOFT_CMD_RESP_IH3        (40 + 8)
401 /* pki_h3 + irh + ossp[0] + ossp[1] = 32 bytes */
402 #define OCTEON_PCI_CMD_O3               (24 + 8)
403
404 /** Return Data Parameters */
405 struct octeon_instr_rdp {
406 #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
407         uint64_t reserved : 49;
408         uint64_t pcie_port : 3;
409         uint64_t rlen : 12;
410 #elif RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
411         uint64_t rlen : 12;
412         uint64_t pcie_port : 3;
413         uint64_t reserved : 49;
414 #endif
415 };
416
417 int lio_setup_sc_buffer_pool(struct lio_device *lio_dev);
418 void lio_free_sc_buffer_pool(struct lio_device *lio_dev);
419
420 struct lio_soft_command *
421 lio_alloc_soft_command(struct lio_device *lio_dev,
422                        uint32_t datasize, uint32_t rdatasize,
423                        uint32_t ctxsize);
424 void lio_prepare_soft_command(struct lio_device *lio_dev,
425                               struct lio_soft_command *sc,
426                               uint8_t opcode, uint8_t subcode,
427                               uint32_t irh_ossp, uint64_t ossp0,
428                               uint64_t ossp1);
429 int lio_send_soft_command(struct lio_device *lio_dev,
430                           struct lio_soft_command *sc);
431 void lio_free_soft_command(struct lio_soft_command *sc);
432
433 /** Maximum ordered requests to process in every invocation of
434  *  lio_process_ordered_list(). The function will continue to process requests
435  *  as long as it can find one that has finished processing. If it keeps
436  *  finding requests that have completed, the function can run for ever. The
437  *  value defined here sets an upper limit on the number of requests it can
438  *  process before it returns control to the poll thread.
439  */
440 #define LIO_MAX_ORD_REQS_TO_PROCESS     4096
441
442 /** Error codes used in Octeon Host-Core communication.
443  *
444  *   31         16 15           0
445  *   ----------------------------
446  * |            |               |
447  *   ----------------------------
448  *   Error codes are 32-bit wide. The upper 16-bits, called Major Error Number,
449  *   are reserved to identify the group to which the error code belongs. The
450  *   lower 16-bits, called Minor Error Number, carry the actual code.
451  *
452  *   So error codes are (MAJOR NUMBER << 16)| MINOR_NUMBER.
453  */
454 /** Status for a request.
455  *  If the request is successfully queued, the driver will return
456  *  a LIO_REQUEST_PENDING status. LIO_REQUEST_TIMEOUT is only returned by
457  *  the driver if the response for request failed to arrive before a
458  *  time-out period or if the request processing * got interrupted due to
459  *  a signal respectively.
460  */
461 enum {
462         /** A value of 0x00000000 indicates no error i.e. success */
463         LIO_REQUEST_DONE        = 0x00000000,
464         /** (Major number: 0x0000; Minor Number: 0x0001) */
465         LIO_REQUEST_PENDING     = 0x00000001,
466         LIO_REQUEST_TIMEOUT     = 0x00000003,
467
468 };
469
470 /*------ Error codes used by firmware (bits 15..0 set by firmware */
471 #define LIO_FIRMWARE_MAJOR_ERROR_CODE    0x0001
472 #define LIO_FIRMWARE_STATUS_CODE(status) \
473         ((LIO_FIRMWARE_MAJOR_ERROR_CODE << 16) | (status))
474
475 /** Initialize the response lists. The number of response lists to create is
476  *  given by count.
477  *  @param lio_dev - the lio device structure.
478  */
479 void lio_setup_response_list(struct lio_device *lio_dev);
480
481 /** Check the status of first entry in the ordered list. If the instruction at
482  *  that entry finished processing or has timed-out, the entry is cleaned.
483  *  @param lio_dev - the lio device structure.
484  *  @return 1 if the ordered list is empty, 0 otherwise.
485  */
486 int lio_process_ordered_list(struct lio_device *lio_dev);
487
488 static inline void
489 lio_swap_8B_data(uint64_t *data, uint32_t blocks)
490 {
491         while (blocks) {
492                 *data = rte_cpu_to_be_64(*data);
493                 blocks--;
494                 data++;
495         }
496 }
497
498 /* Macro to increment index.
499  * Index is incremented by count; if the sum exceeds
500  * max, index is wrapped-around to the start.
501  */
502 static inline uint32_t
503 lio_incr_index(uint32_t index, uint32_t count, uint32_t max)
504 {
505         if ((index + count) >= max)
506                 index = index + count - max;
507         else
508                 index += count;
509
510         return index;
511 }
512
513 int lio_setup_droq(struct lio_device *lio_dev, int q_no, int num_descs,
514                    int desc_size, struct rte_mempool *mpool,
515                    unsigned int socket_id);
516
517 /** Setup instruction queue zero for the device
518  *  @param lio_dev which lio device to setup
519  *
520  *  @return 0 if success. -1 if fails
521  */
522 int lio_setup_instr_queue0(struct lio_device *lio_dev);
523 void lio_free_instr_queue0(struct lio_device *lio_dev);
524 #endif  /* _LIO_RXTX_H_ */