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 #include <avf/virtchnl.h>
  19
  20 #define foreach_avf_device_flags \
  21   _(0, INITIALIZED, "initialized") \
  22   _(1, ERROR, "error") \
  23   _(2, ADMIN_UP, "admin-up") \
  24   _(3, IOVA, "iova") \
  25   _(4, LINK_UP, "link-up") \
  26   _(5, SHARED_TXQ_LOCK, "shared-txq-lock") \
  27   _(6, ELOG, "elog")
  28
  29 enum
  30 {
  31 #define _(a, b, c) AVF_DEVICE_F_##b = (1 << a),
  32   foreach_avf_device_flags
  33 #undef _
  34 };
  35
  36 typedef struct
  37 {
  38   u64 qword[4];
  39 } avf_rx_desc_t;
  40
  41 STATIC_ASSERT_SIZEOF (avf_rx_desc_t, 32);
  42
  43 typedef struct
  44 {
  45   union
  46   {
  47     u64 qword[2];
  48     u64x2 as_u64x2;
  49   };
  50 } avf_tx_desc_t;
  51
  52 STATIC_ASSERT_SIZEOF (avf_tx_desc_t, 16);
  53
  54 typedef struct
  55 {
  56   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
  57   volatile u32 *qrx_tail;
  58   u16 next;
  59   u16 size;
  60   avf_rx_desc_t *descs;
  61   u32 *bufs;
  62   u16 n_bufs;
  63 } avf_rxq_t;
  64
  65 typedef struct
  66 {
  67   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
  68   volatile u32 *qtx_tail;
  69   u16 next;
  70   u16 size;
  71   clib_spinlock_t lock;
  72   avf_tx_desc_t *descs;
  73   u32 *bufs;
  74   u16 n_bufs;
  75 } avf_txq_t;
  76
  77 typedef struct
  78 {
  79   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
  80   u32 flags;
  81   u32 per_interface_next_index;
  82
  83   u32 dev_instance;
  84   u32 sw_if_index;
  85   u32 hw_if_index;
  86   vlib_pci_dev_handle_t pci_dev_handle;
  87   void *bar0;
  88
  89   /* queues */
  90   avf_rxq_t *rxqs;
  91   avf_txq_t *txqs;
  92
  93   /* Admin queues */
  94   avf_aq_desc_t *atq;
  95   avf_aq_desc_t *arq;
  96   void *atq_bufs;
  97   void *arq_bufs;
  98   u64 atq_bufs_pa;
  99   u64 arq_bufs_pa;
 100   u16 atq_next_slot;
 101   u16 arq_next_slot;
 102   virtchnl_pf_event_t *events;
 103
 104   u16 vsi_id;
 105   u32 feature_bitmap;
 106   u8 hwaddr[6];
 107   u16 num_queue_pairs;
 108   u16 max_vectors;
 109   u16 max_mtu;
 110   u32 rss_key_size;
 111   u32 rss_lut_size;
 112   virtchnl_link_speed_t link_speed;
 113
 114   /* stats */
 115   virtchnl_eth_stats_t eth_stats;
 116
 117   /* error */
 118   clib_error_t *error;
 119 } avf_device_t;
 120
 121 typedef struct
 122 {
 123   u32 bi;
 124   u32 status;
 125   u16 length;
 126   u16 tail_length;
 127   u8 ptype;
 128   u8 error;
 129 } avf_rx_vector_entry_t;
 130
 131 STATIC_ASSERT_SIZEOF (avf_rx_vector_entry_t, 16);
 132
 133 #define AVF_RX_VECTOR_SZ VLIB_FRAME_SIZE
 134
 135 enum
 136 {
 137   AVF_PROCESS_EVENT_START = 1,
 138   AVF_PROCESS_EVENT_STOP = 2,
 139   AVF_PROCESS_EVENT_AQ_INT = 3,
 140 } avf_process_event_t;
 141
 142 typedef struct
 143 {
 144   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
 145   avf_rx_vector_entry_t rx_vector[AVF_RX_VECTOR_SZ];
 146   u32 *to_free;
 147 } avf_per_thread_data_t;
 148
 149 typedef struct
 150 {
 151   u8 next_node;
 152   i8 buffer_advance;
 153   u32 flags;
 154 } avf_ptype_t;
 155
 156 STATIC_ASSERT (VNET_DEVICE_INPUT_N_NEXT_NODES < 256, "too many next nodes");
 157
 158 typedef struct
 159 {
 160   avf_device_t *devices;
 161   avf_per_thread_data_t *per_thread_data;
 162   vlib_physmem_region_index_t physmem_region;
 163   int physmem_region_alloc;
 164
 165   /* 256 element array for ptype based lookup */
 166   avf_ptype_t *ptypes;
 167 } avf_main_t;
 168
 169 extern avf_main_t avf_main;
 170
 171 typedef struct
 172 {
 173   vlib_pci_addr_t addr;
 174   int enable_elog;
 175   /* return */
 176   int rv;
 177   clib_error_t *error;
 178 } avf_create_if_args_t;
 179
 180 void avf_create_if (vlib_main_t * vm, avf_create_if_args_t * args);
 181 void avf_delete_if (vlib_main_t * vm, avf_device_t * ad);
 182
 183 extern vlib_node_registration_t avf_input_node;
 184 extern vnet_device_class_t avf_device_class;
 185 uword avf_interface_tx (vlib_main_t * vm, vlib_node_runtime_t * node,
 186                         vlib_frame_t * frame);
 187
 188 /* format.c */
 189 format_function_t format_avf_device;
 190 format_function_t format_avf_device_name;
 191 format_function_t format_avf_input_trace;
 192
 193 static inline u32
 194 avf_get_u32 (void *start, int offset)
 195 {
 196   return *(u32 *) (((u8 *) start) + offset);
 197 }
 198
 199 static inline u64
 200 avf_get_u64 (void *start, int offset)
 201 {
 202   return *(u64 *) (((u8 *) start) + offset);
 203 }
 204
 205 static inline u32
 206 avf_get_u32_bits (void *start, int offset, int first, int last)
 207 {
 208   u32 value = avf_get_u32 (start, offset);
 209   if ((last == 0) && (first == 31))
 210     return value;
 211   value >>= last;
 212   value &= (1 << (first - last + 1)) - 1;
 213   return value;
 214 }
 215
 216 static inline u64
 217 avf_get_u64_bits (void *start, int offset, int first, int last)
 218 {
 219   u64 value = avf_get_u64 (start, offset);
 220   if ((last == 0) && (first == 63))
 221     return value;
 222   value >>= last;
 223   value &= (1 << (first - last + 1)) - 1;
 224   return value;
 225 }
 226
 227 static inline void
 228 avf_set_u32 (void *start, int offset, u32 value)
 229 {
 230   (*(u32 *) (((u8 *) start) + offset)) = value;
 231 }
 232
 233 static inline void
 234 avf_reg_write (avf_device_t * ad, u32 addr, u32 val)
 235 {
 236   *(volatile u32 *) ((u8 *) ad->bar0 + addr) = val;
 237 }
 238
 239 static inline u32
 240 avf_reg_read (avf_device_t * ad, u32 addr)
 241 {
 242   return *(volatile u32 *) (ad->bar0 + addr);
 243 }
 244
 245 static inline void
 246 avf_reg_flush (avf_device_t * ad)
 247 {
 248   avf_reg_read (ad, AVFGEN_RSTAT);
 249   asm volatile ("":::"memory");
 250 }
 251
 252 typedef struct
 253 {
 254   u32 next_index;
 255   u32 hw_if_index;
 256   avf_rx_vector_entry_t rxve;
 257 } avf_input_trace_t;
 258
 259 /*
 260  * fd.io coding-style-patch-verification: ON
 261  *
 262  * Local Variables:
 263  * eval: (c-set-style "gnu")
 264  * End:
 265  */