293a1a89937b650e09e14e98855a1bb28c97cf54
[vpp.git] / src / plugins / avf / avf.h
1 /*
2  *------------------------------------------------------------------
3  * Copyright (c) 2018 Cisco and/or its affiliates.
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *------------------------------------------------------------------
16  */
17
18 #ifndef _AVF_H_
19 #define _AVF_H_
20
21 #include <avf/virtchnl.h>
22 #include <avf/avf_advanced_flow.h>
23
24 #include <vppinfra/types.h>
25 #include <vppinfra/error_bootstrap.h>
26 #include <vppinfra/lock.h>
27
28 #include <vlib/log.h>
29 #include <vlib/pci/pci.h>
30
31 #include <vnet/interface.h>
32
33 #include <vnet/devices/devices.h>
34 #include <vnet/flow/flow.h>
35
36 #define AVF_QUEUE_SZ_MAX                4096
37 #define AVF_QUEUE_SZ_MIN                64
38
39 #define AVF_AQ_ENQ_SUSPEND_TIME         50e-6
40 #define AVF_AQ_ENQ_MAX_WAIT_TIME        250e-3
41 #define AVF_AQ_BUF_SIZE                 4096
42
43 #define AVF_RESET_SUSPEND_TIME          20e-3
44 #define AVF_RESET_MAX_WAIT_TIME         1
45
46 #define AVF_SEND_TO_PF_SUSPEND_TIME     10e-3
47 #define AVF_SEND_TO_PF_MAX_WAIT_TIME    1
48
49 #define AVF_RXD_STATUS(x)               (1ULL << x)
50 #define AVF_RXD_STATUS_DD               AVF_RXD_STATUS(0)
51 #define AVF_RXD_STATUS_EOP              AVF_RXD_STATUS(1)
52 #define AVF_RXD_STATUS_FLM              AVF_RXD_STATUS (11)
53 #define AVF_RXD_ERROR_SHIFT             19
54 #define AVF_RXD_PTYPE_SHIFT             30
55 #define AVF_RXD_LEN_SHIFT               38
56 #define AVF_RX_MAX_DESC_IN_CHAIN        5
57
58 #define AVF_RXD_ERROR_IPE               (1ULL << (AVF_RXD_ERROR_SHIFT + 3))
59 #define AVF_RXD_ERROR_L4E               (1ULL << (AVF_RXD_ERROR_SHIFT + 4))
60
61 #define AVF_TXD_CMD(x)                  (1 << (x + 4))
62 #define AVF_TXD_CMD_EXT(x, val)         ((u64)val << (x + 4))
63 #define AVF_TXD_CMD_EOP                 AVF_TXD_CMD(0)
64 #define AVF_TXD_CMD_RS                  AVF_TXD_CMD(1)
65 #define AVF_TXD_CMD_RSV                 AVF_TXD_CMD(2)
66
67 #define AVF_TXD_CMD_IIPT_NONE           AVF_TXD_CMD_EXT(5, 0)
68 #define AVF_TXD_CMD_IIPT_IPV6           AVF_TXD_CMD_EXT(5, 1)
69 #define AVF_TXD_CMD_IIPT_IPV4_NO_CSUM   AVF_TXD_CMD_EXT(5, 2)
70 #define AVF_TXD_CMD_IIPT_IPV4           AVF_TXD_CMD_EXT(5, 3)
71
72 #define AVF_TXD_CMD_L4T_UNKNOWN         AVF_TXD_CMD_EXT(8, 0)
73 #define AVF_TXD_CMD_L4T_TCP             AVF_TXD_CMD_EXT(8, 1)
74 #define AVF_TXD_CMD_L4T_SCTP            AVF_TXD_CMD_EXT(8, 2)
75 #define AVF_TXD_CMD_L4T_UDP             AVF_TXD_CMD_EXT(8, 3)
76
77 #define AVF_TXD_OFFSET(x,factor,val)    (((u64)val/(u64)factor) << (16 + x))
78 #define AVF_TXD_OFFSET_MACLEN(val)      AVF_TXD_OFFSET( 0, 2, val)
79 #define AVF_TXD_OFFSET_IPLEN(val)       AVF_TXD_OFFSET( 7, 4, val)
80 #define AVF_TXD_OFFSET_L4LEN(val)       AVF_TXD_OFFSET(14, 4, val)
81
82 #define AVF_TXD_DTYP_CTX                0x1ULL
83 #define AVF_TXD_CTX_CMD_TSO             AVF_TXD_CMD(0)
84 #define AVF_TXD_CTX_SEG(val,x)          (((u64)val) << (30 + x))
85 #define AVF_TXD_CTX_SEG_TLEN(val)       AVF_TXD_CTX_SEG(val,0)
86 #define AVF_TXD_CTX_SEG_MSS(val)        AVF_TXD_CTX_SEG(val,20)
87
88
89 extern vlib_log_class_registration_t avf_log;
90 extern vlib_log_class_registration_t avf_stats_log;
91
92 #define avf_log_err(dev, f, ...)                        \
93   vlib_log (VLIB_LOG_LEVEL_ERR, avf_log.class, "%U: " f, \
94             format_vlib_pci_addr, &dev->pci_addr, \
95             ## __VA_ARGS__)
96
97 #define avf_log_warn(dev, f, ...)                        \
98   vlib_log (VLIB_LOG_LEVEL_WARNING, avf_log.class, "%U: " f, \
99             format_vlib_pci_addr, &dev->pci_addr, \
100             ## __VA_ARGS__)
101
102 #define avf_log_debug(dev, f, ...)                        \
103   vlib_log (VLIB_LOG_LEVEL_DEBUG, avf_log.class, "%U: " f, \
104             format_vlib_pci_addr, &dev->pci_addr, \
105             ## __VA_ARGS__)
106
107 #define avf_stats_log_debug(dev, f, ...)                                      \
108   vlib_log (VLIB_LOG_LEVEL_DEBUG, avf_stats_log.class, "%U: " f,              \
109             format_vlib_pci_addr, &dev->pci_addr, ##__VA_ARGS__)
110
111 #define foreach_avf_device_flags                                              \
112   _ (0, INITIALIZED, "initialized")                                           \
113   _ (1, ERROR, "error")                                                       \
114   _ (2, ADMIN_UP, "admin-up")                                                 \
115   _ (3, VA_DMA, "vaddr-dma")                                                  \
116   _ (4, LINK_UP, "link-up")                                                   \
117   _ (6, ELOG, "elog")                                                         \
118   _ (7, PROMISC, "promisc")                                                   \
119   _ (8, RX_INT, "rx-interrupts")                                              \
120   _ (9, RX_FLOW_OFFLOAD, "rx-flow-offload")
121
122 enum
123 {
124 #define _(a, b, c) AVF_DEVICE_F_##b = (1 << a),
125   foreach_avf_device_flags
126 #undef _
127 };
128
129 typedef volatile struct
130 {
131   union
132   {
133     struct
134     {
135       u64 mirr:13;
136       u64 rsv1:3;
137       u64 l2tag1:16;
138       u64 filter_status:32;
139       u64 status:19;
140       u64 error:8;
141       u64 rsv2:3;
142       u64 ptype:8;
143       u64 length:26;
144
145       u64 rsv3 : 64;
146       u32 flex_lo;
147       u32 fdid_flex_hi;
148     };
149     u64 qword[4];
150 #ifdef CLIB_HAVE_VEC256
151     u64x4 as_u64x4;
152 #endif
153   };
154 } avf_rx_desc_t;
155
156 STATIC_ASSERT_SIZEOF (avf_rx_desc_t, 32);
157
158 typedef struct
159 {
160   union
161   {
162     u64 qword[2];
163 #ifdef CLIB_HAVE_VEC128
164     u64x2 as_u64x2;
165 #endif
166   };
167 } avf_tx_desc_t;
168
169 STATIC_ASSERT_SIZEOF (avf_tx_desc_t, 16);
170
171 typedef struct
172 {
173   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
174   volatile u32 *qrx_tail;
175   u16 next;
176   u16 size;
177   avf_rx_desc_t *descs;
178   u32 *bufs;
179   u16 n_enqueued;
180   u8 int_mode;
181   u8 buffer_pool_index;
182   u32 queue_index;
183 } avf_rxq_t;
184
185 typedef struct
186 {
187   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
188   volatile u32 *qtx_tail;
189   u16 next;
190   u16 size;
191   u32 *ph_bufs;
192   clib_spinlock_t lock;
193   avf_tx_desc_t *descs;
194   u32 *bufs;
195   u16 n_enqueued;
196   u16 *rs_slots;
197
198   avf_tx_desc_t *tmp_descs;
199   u32 *tmp_bufs;
200   u32 queue_index;
201 } avf_txq_t;
202
203 typedef struct
204 {
205   u32 flow_index;
206   u32 mark;
207   u8 flow_type_flag;
208   struct avf_fdir_conf *rcfg;
209   struct virtchnl_rss_cfg *rss_cfg;
210 } avf_flow_entry_t;
211
212 typedef struct
213 {
214   u32 flow_id;
215   u16 next_index;
216   i16 buffer_advance;
217 } avf_flow_lookup_entry_t;
218
219 typedef struct
220 {
221   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
222   u32 flags;
223   u32 per_interface_next_index;
224
225   u32 dev_instance;
226   u32 sw_if_index;
227   u32 hw_if_index;
228   vlib_pci_dev_handle_t pci_dev_handle;
229   u32 numa_node;
230   void *bar0;
231   u8 *name;
232
233   /* queues */
234   avf_rxq_t *rxqs;
235   avf_txq_t *txqs;
236   u16 n_tx_queues;
237   u16 n_rx_queues;
238
239   /* Admin queues */
240   avf_aq_desc_t *atq;
241   avf_aq_desc_t *arq;
242   void *atq_bufs;
243   void *arq_bufs;
244   u64 atq_bufs_pa;
245   u64 arq_bufs_pa;
246   u16 atq_next_slot;
247   u16 arq_next_slot;
248   virtchnl_pf_event_t *events;
249
250   u16 vsi_id;
251   u32 cap_flags;
252   u8 hwaddr[6];
253   u16 num_queue_pairs;
254   u16 max_vectors;
255   u16 n_rx_irqs;
256   u16 max_mtu;
257   u32 rss_key_size;
258   u32 rss_lut_size;
259   virtchnl_link_speed_t link_speed;
260   vlib_pci_addr_t pci_addr;
261
262   /* flow */
263   avf_flow_entry_t *flow_entries;               /* pool */
264   avf_flow_lookup_entry_t *flow_lookup_entries; /* pool */
265
266   /* stats */
267   virtchnl_eth_stats_t eth_stats;
268   virtchnl_eth_stats_t last_cleared_eth_stats;
269
270   /* error */
271   clib_error_t *error;
272 } avf_device_t;
273
274 #define AVF_RX_VECTOR_SZ VLIB_FRAME_SIZE
275
276 typedef enum
277 {
278   AVF_PROCESS_EVENT_START = 1,
279   AVF_PROCESS_EVENT_DELETE_IF = 2,
280   AVF_PROCESS_EVENT_AQ_INT = 3,
281   AVF_PROCESS_EVENT_REQ = 4,
282 } avf_process_event_t;
283
284 typedef enum
285 {
286   AVF_PROCESS_REQ_ADD_DEL_ETH_ADDR = 1,
287   AVF_PROCESS_REQ_CONFIG_PROMISC_MDDE = 2,
288   AVF_PROCESS_REQ_PROGRAM_FLOW = 3,
289 } avf_process_req_type_t;
290
291 typedef struct
292 {
293   avf_process_req_type_t type;
294   u32 dev_instance;
295   u32 calling_process_index;
296   u8 eth_addr[6];
297   int is_add, is_enable;
298   enum virthnl_adv_ops vc_op;
299
300   /* below parameters are used for 'program flow' event */
301   u8 *rule;
302   u32 rule_len;
303   u8 *program_status;
304   u32 status_len;
305
306   clib_error_t *error;
307 } avf_process_req_t;
308
309 typedef struct
310 {
311   u64 qw1s[AVF_RX_MAX_DESC_IN_CHAIN - 1];
312   u32 buffers[AVF_RX_MAX_DESC_IN_CHAIN - 1];
313 } avf_rx_tail_t;
314
315 typedef struct
316 {
317   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
318   vlib_buffer_t *bufs[AVF_RX_VECTOR_SZ];
319   u16 next[AVF_RX_VECTOR_SZ];
320   u64 qw1s[AVF_RX_VECTOR_SZ];
321   u32 flow_ids[AVF_RX_VECTOR_SZ];
322   avf_rx_tail_t tails[AVF_RX_VECTOR_SZ];
323   vlib_buffer_t buffer_template;
324 } avf_per_thread_data_t;
325
326 typedef struct
327 {
328   u16 msg_id_base;
329
330   avf_device_t **devices;
331   avf_per_thread_data_t *per_thread_data;
332 } avf_main_t;
333
334 extern avf_main_t avf_main;
335
336 typedef struct
337 {
338   vlib_pci_addr_t addr;
339   u8 *name;
340   int enable_elog;
341   u16 rxq_num;
342   u16 txq_num;
343   u16 rxq_size;
344   u16 txq_size;
345   /* return */
346   int rv;
347   u32 sw_if_index;
348   clib_error_t *error;
349 } avf_create_if_args_t;
350
351 void avf_create_if (vlib_main_t * vm, avf_create_if_args_t * args);
352
353 extern vlib_node_registration_t avf_input_node;
354 extern vlib_node_registration_t avf_process_node;
355 extern vnet_device_class_t avf_device_class;
356
357 clib_error_t *avf_program_flow (u32 dev_instance, int is_add,
358                                 enum virthnl_adv_ops vc_op, u8 *rule,
359                                 u32 rule_len, u8 *program_status,
360                                 u32 status_len);
361
362 /* format.c */
363 format_function_t format_avf_device;
364 format_function_t format_avf_device_name;
365 format_function_t format_avf_input_trace;
366 format_function_t format_avf_vf_cap_flags;
367 format_function_t format_avf_vlan_supported_caps;
368 format_function_t format_avf_vlan_caps;
369 format_function_t format_avf_vlan_support;
370 format_function_t format_avf_eth_stats;
371 vnet_flow_dev_ops_function_t avf_flow_ops_fn;
372
373 static_always_inline avf_device_t *
374 avf_get_device (u32 dev_instance)
375 {
376   return pool_elt_at_index (avf_main.devices, dev_instance)[0];
377 }
378
379 /* elog.c */
380 void avf_elog_init ();
381 void avf_elog_reg (avf_device_t *ad, u32 addr, u32 val, int is_read);
382 void avf_elog_aq_enq_req (avf_device_t *ad, avf_aq_desc_t *d);
383 void avf_elog_aq_enq_resp (avf_device_t *ad, avf_aq_desc_t *d);
384 void avf_elog_arq_desc (avf_device_t *ad, avf_aq_desc_t *d);
385
386 static inline u32
387 avf_get_u32 (void *start, int offset)
388 {
389   return *(u32 *) (((u8 *) start) + offset);
390 }
391
392 static inline u64
393 avf_get_u64 (void *start, int offset)
394 {
395   return *(u64 *) (((u8 *) start) + offset);
396 }
397
398 static inline u32
399 avf_get_u32_bits (void *start, int offset, int first, int last)
400 {
401   u32 value = avf_get_u32 (start, offset);
402   if ((last == 0) && (first == 31))
403     return value;
404   value >>= last;
405   value &= (1 << (first - last + 1)) - 1;
406   return value;
407 }
408
409 static inline u64
410 avf_get_u64_bits (void *start, int offset, int first, int last)
411 {
412   u64 value = avf_get_u64 (start, offset);
413   if ((last == 0) && (first == 63))
414     return value;
415   value >>= last;
416   value &= (1 << (first - last + 1)) - 1;
417   return value;
418 }
419
420 static inline void
421 avf_set_u32 (void *start, int offset, u32 value)
422 {
423   (*(u32 *) (((u8 *) start) + offset)) = value;
424 }
425
426 static inline void
427 avf_reg_write (avf_device_t * ad, u32 addr, u32 val)
428 {
429   if (ad->flags & AVF_DEVICE_F_ELOG)
430     avf_elog_reg (ad, addr, val, 0);
431   *(volatile u32 *) ((u8 *) ad->bar0 + addr) = val;
432 }
433
434 static inline u32
435 avf_reg_read (avf_device_t * ad, u32 addr)
436 {
437   u32 val = *(volatile u32 *) (ad->bar0 + addr);
438
439   if (ad->flags & AVF_DEVICE_F_ELOG)
440     avf_elog_reg (ad, addr, val, 1);
441
442   return val;
443 }
444
445 static inline void
446 avf_reg_flush (avf_device_t * ad)
447 {
448   avf_reg_read (ad, AVFGEN_RSTAT);
449   asm volatile ("":::"memory");
450 }
451
452 static inline void
453 avf_tail_write (volatile u32 *addr, u32 val)
454 {
455 #ifdef __MOVDIRI__
456   _mm_sfence ();
457   _directstoreu_u32 ((void *) addr, val);
458 #else
459   clib_atomic_store_rel_n (addr, val);
460 #endif
461 }
462
463 static_always_inline int
464 avf_rxd_is_not_eop (avf_rx_desc_t * d)
465 {
466   return (d->qword[1] & AVF_RXD_STATUS_EOP) == 0;
467 }
468
469 static_always_inline int
470 avf_rxd_is_not_dd (avf_rx_desc_t * d)
471 {
472   return (d->qword[1] & AVF_RXD_STATUS_DD) == 0;
473 }
474
475 typedef struct
476 {
477   u16 qid;
478   u16 next_index;
479   u32 hw_if_index;
480   u32 flow_id;
481   u64 qw1s[AVF_RX_MAX_DESC_IN_CHAIN];
482 } avf_input_trace_t;
483
484 #define foreach_avf_tx_func_error              \
485   _(SEGMENT_SIZE_EXCEEDED, "segment size exceeded")     \
486   _(NO_FREE_SLOTS, "no free tx slots")
487
488 typedef enum
489 {
490 #define _(f,s) AVF_TX_ERROR_##f,
491   foreach_avf_tx_func_error
492 #undef _
493     AVF_TX_N_ERROR,
494 } avf_tx_func_error_t;
495
496 #endif /* AVF_H */
497
498 /*
499  * fd.io coding-style-patch-verification: ON
500  *
501  * Local Variables:
502  * eval: (c-set-style "gnu")
503  * End:
504  */