26 #define AVF_MBOX_LEN 64 27 #define AVF_MBOX_BUF_SZ 512 28 #define AVF_RXQ_SZ 512 29 #define AVF_TXQ_SZ 512 30 #define AVF_ITR_INT 8160 32 #define PCI_VENDOR_ID_INTEL 0x8086 33 #define PCI_DEVICE_ID_INTEL_AVF 0x1889 34 #define PCI_DEVICE_ID_INTEL_X710_VF 0x154c 35 #define PCI_DEVICE_ID_INTEL_X722_VF 0x37cd 49 u32 dyn_ctl0 = 0, icr0_ena = 0;
61 u32 dyn_ctl0 = 0, icr0_ena = 0;
63 icr0_ena |= (1 << 30);
125 if (ad->
flags & AVF_DEVICE_F_ELOG)
154 if (ad->
flags & AVF_DEVICE_F_ELOG)
159 .format =
"avf[%d] aq enq: s_flags 0x%x r_flags 0x%x opcode 0x%x " 160 "datalen %d retval %d",
161 .format_args =
"i4i2i2i2i2i2",
174 ed->s_flags = dc.
flags;
175 ed->r_flags = d->
flags;
193 if (ad->
flags & AVF_DEVICE_F_ELOG)
198 .format =
"avf[%d] rx ctl reg write: reg 0x%x val 0x%x ",
199 .format_args =
"i4i4i4",
225 rxq->
size = rxq_size;
249 for (i = 0; i < n_alloc; i++)
252 if (ad->
flags & AVF_DEVICE_F_VA_DMA)
275 ad->
flags |= AVF_DEVICE_F_SHARED_TXQ_LOCK;
281 txq->
size = txq_size;
325 return (ad->
flags & AVF_DEVICE_F_VA_DMA) ?
368 void *in,
int in_len,
void *out,
int out_len)
398 if (d->
v_opcode == VIRTCHNL_OP_EVENT)
419 "unexpected message receiver [v_opcode = %u, " 420 "expected %u, v_retval %d]", d->
v_opcode, op,
445 if (ad->
flags & AVF_DEVICE_F_ELOG)
450 .format =
"avf[%d] send to pf: v_opcode %s (%d) v_retval 0x%x",
451 .format_args =
"i4t4i4i4",
454 #define _(v, n) [v] = #n, 469 ed->v_opcode_val = op;
500 u32 bitmap = (VIRTCHNL_VF_OFFLOAD_L2 | VIRTCHNL_VF_OFFLOAD_RSS_PF |
501 VIRTCHNL_VF_OFFLOAD_WB_ON_ITR | VIRTCHNL_VF_OFFLOAD_VLAN |
502 VIRTCHNL_VF_OFFLOAD_RX_POLLING);
504 return avf_send_to_pf (vm, ad, VIRTCHNL_OP_GET_VF_RESOURCES, &bitmap,
523 return avf_send_to_pf (vm, ad, VIRTCHNL_OP_CONFIG_RSS_LUT, msg, msg_len, 0,
543 return avf_send_to_pf (vm, ad, VIRTCHNL_OP_CONFIG_RSS_KEY, msg, msg_len, 0,
550 return avf_send_to_pf (vm, ad, VIRTCHNL_OP_DISABLE_VLAN_STRIPPING, 0, 0, 0,
561 return avf_send_to_pf (vm, ad, VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE, &pi,
581 for (i = 0; i < n_qp; i++)
608 return avf_send_to_pf (vm, ad, VIRTCHNL_OP_CONFIG_VSI_QUEUES, msg, msg_len,
628 return avf_send_to_pf (vm, ad, VIRTCHNL_OP_CONFIG_IRQ_MAP, msg, msg_len, 0,
646 for (i = 0; i <
count; i++)
648 return avf_send_to_pf (vm, ad, VIRTCHNL_OP_ADD_ETH_ADDR, msg, msg_len, 0,
702 if (rstat == 2 || rstat == 3)
721 error =
avf_send_to_pf (vm, ad, VIRTCHNL_OP_REQUEST_QUEUES, &res_req,
825 "queue pairs available. Using %u rx queues.",
829 for (i = 0; i < args->
rxq_num; i++)
862 ad->
flags |= AVF_DEVICE_F_INITIALIZED;
874 if (ad->
flags & AVF_DEVICE_F_ERROR)
877 if ((ad->
flags & AVF_DEVICE_F_INITIALIZED) == 0)
888 if ((r & 0xf0000000) != (1ULL << 31))
895 if ((r & 0xf0000000) != (1ULL << 31))
914 if (link_up && (ad->
flags & AVF_DEVICE_F_LINK_UP) == 0)
916 ad->
flags |= AVF_DEVICE_F_LINK_UP;
919 if (speed == VIRTCHNL_LINK_SPEED_40GB)
921 else if (speed == VIRTCHNL_LINK_SPEED_25GB)
923 else if (speed == VIRTCHNL_LINK_SPEED_10GB)
925 else if (speed == VIRTCHNL_LINK_SPEED_1GB)
927 else if (speed == VIRTCHNL_LINK_SPEED_100MB)
933 else if (!link_up && (ad->
flags & AVF_DEVICE_F_LINK_UP) != 0)
935 ad->
flags &= ~AVF_DEVICE_F_LINK_UP;
939 if (ad->
flags & AVF_DEVICE_F_ELOG)
943 .format =
"avf[%d] link change: link_status %d " 945 .format_args =
"i4i1i1",
955 ed->link_status = link_up;
956 ed->link_speed = speed;
961 if (ad->
flags & AVF_DEVICE_F_ELOG)
965 .format =
"avf[%d] unknown event: event %d severity %d",
966 .format_args =
"i4i4i1i1",
976 ed->event = e->
event;
987 ad->
flags |= AVF_DEVICE_F_ERROR;
1005 uword *event_data = 0, event_type;
1006 int enabled = 0, irq;
1007 f64 last_run_duration = 0;
1008 f64 last_periodic_time = 0;
1042 avf_process_one_device (vm, ad, irq);
1045 last_run_duration =
vlib_time_now (vm) - last_periodic_time;
1054 .name =
"avf-process",
1068 if (ad->
flags & AVF_DEVICE_F_ELOG)
1073 .format =
"avf[%d] irq 0: icr0 0x%x",
1074 .format_args =
"i4i4",
1091 if (icr0 & (1 << 30))
1106 if (ad->
flags & AVF_DEVICE_F_ELOG)
1111 .format =
"avf[%d] irq %d: received",
1112 .format_args =
"i4i2",
1207 args->
rv = VNET_API_ERROR_INVALID_VALUE;
1219 ad->
flags |= AVF_DEVICE_F_ELOG;
1225 args->
rv = VNET_API_ERROR_INVALID_INTERFACE;
1309 ad->
flags |= AVF_DEVICE_F_VA_DMA;
1341 args->
rv = VNET_API_ERROR_INVALID_INTERFACE;
1355 if (ad->
flags & AVF_DEVICE_F_ERROR)
1362 ad->
flags |= AVF_DEVICE_F_ADMIN_UP;
1367 ad->
flags &= ~AVF_DEVICE_F_ADMIN_UP;
1398 if (node_index == ~0)
1417 .name =
"Adaptive Virtual Function (AVF) interface",
static void avf_set_interface_next_node(vnet_main_t *vnm, u32 hw_if_index, u32 node_index)
vlib_log_class_t vlib_log_register_class(char *class, char *subclass)
clib_error_t * vlib_pci_device_open(vlib_main_t *vm, vlib_pci_addr_t *addr, pci_device_id_t ids[], vlib_pci_dev_handle_t *handle)
format_function_t format_vlib_pci_addr
#define vec_foreach_index(var, v)
Iterate over vector indices.
virtchnl_queue_pair_info_t qpair[1]
u8 * format_clib_error(u8 *s, va_list *va)
#define vlib_log_warn(...)
static clib_error_t * avf_interface_rx_mode_change(vnet_main_t *vnm, u32 hw_if_index, u32 qid, vnet_hw_interface_rx_mode mode)
static uword random_default_seed(void)
Default random seed (unix/linux user-mode)
static void * vlib_physmem_alloc_aligned_on_numa(vlib_main_t *vm, uword n_bytes, uword alignment, u32 numa_node)
static f64 vlib_process_wait_for_event_or_clock(vlib_main_t *vm, f64 dt)
Suspend a cooperative multi-tasking thread Waits for an event, or for the indicated number of seconds...
clib_error_t * avf_init(vlib_main_t *vm)
static uword * vlib_process_wait_for_event(vlib_main_t *vm)
clib_error_t * avf_send_to_pf(vlib_main_t *vm, avf_device_t *ad, virtchnl_ops_t op, void *in, int in_len, void *out, int out_len)
void ethernet_delete_interface(vnet_main_t *vnm, u32 hw_if_index)
static clib_error_t * vlib_pci_bus_master_enable(vlib_main_t *vm, vlib_pci_dev_handle_t h)
vnet_main_t * vnet_get_main(void)
void avf_arq_slot_init(avf_device_t *ad, u16 slot)
static uword vlib_buffer_get_pa(vlib_main_t *vm, vlib_buffer_t *b)
virtchnl_vsi_type_t vsi_type
virtchnl_vector_map_t vecmap[1]
#define clib_memcpy_fast(a, b, c)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static f64 vlib_time_now(vlib_main_t *vm)
#define clib_ring_new_aligned(ring, size, align)
virtchnl_link_speed_t link_speed
static clib_error_t * vlib_physmem_last_error(struct vlib_main_t *vm)
static void avf_adminq_init(vlib_main_t *vm, avf_device_t *ad)
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
format_function_t format_avf_device
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
#define vec_validate_aligned(V, I, A)
Make sure vector is long enough for given index (no header, specified alignment)
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
clib_error_t * avf_op_config_irq_map(vlib_main_t *vm, avf_device_t *ad)
static vlib_node_registration_t avf_process_node
(constructor) VLIB_REGISTER_NODE (avf_process_node)
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
vnet_device_class_t avf_device_class
clib_error_t * avf_device_reset(vlib_main_t *vm, avf_device_t *ad)
clib_error_t * avf_op_disable_vlan_stripping(vlib_main_t *vm, avf_device_t *ad)
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
static vnet_sw_interface_t * vnet_get_hw_sw_interface(vnet_main_t *vnm, u32 hw_if_index)
static uword vlib_process_suspend(vlib_main_t *vm, f64 dt)
Suspend a vlib cooperative multi-tasking thread for a period of time.
static uword avf_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
vnet_hw_interface_rx_mode
clib_error_t * avf_request_queues(vlib_main_t *vm, avf_device_t *ad, u16 num_queue_pairs)
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
#define VLIB_INIT_FUNCTION(x)
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type...
static uword pow2_mask(uword x)
#define PCI_DEVICE_ID_INTEL_AVF
static u32 avf_reg_read(avf_device_t *ad, u32 addr)
clib_error_t * avf_txq_init(vlib_main_t *vm, avf_device_t *ad, u16 qid, u16 txq_size)
static_always_inline void vnet_device_input_set_interrupt_pending(vnet_main_t *vnm, u32 hw_if_index, u16 queue_id)
vnet_hw_interface_flags_t flags
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
#define clib_error_return(e, args...)
clib_error_t * avf_config_promisc_mode(vlib_main_t *vm, avf_device_t *ad)
#define VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES
vlib_pci_dev_handle_t pci_dev_handle
#define vlib_call_init_function(vm, x)
virtchnl_ether_addr_t list[1]
#define vlib_log_debug(...)
static void avf_irq_n_handler(vlib_main_t *vm, vlib_pci_dev_handle_t h, u16 line)
static void clib_spinlock_init(clib_spinlock_t *p)
static void vlib_buffer_free_from_ring(vlib_main_t *vm, u32 *ring, u32 start, u32 ring_size, u32 n_buffers)
Free buffers from ring.
static heap_elt_t * first(heap_header_t *h)
void avf_process_one_device(vlib_main_t *vm, avf_device_t *ad, int is_irq)
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
clib_error_t * avf_device_init(vlib_main_t *vm, avf_main_t *am, avf_device_t *ad, avf_create_if_args_t *args)
static u32 avf_get_u32(void *start, int offset)
uword vlib_pci_get_private_data(vlib_main_t *vm, vlib_pci_dev_handle_t h)
u32 vlib_pci_dev_handle_t
#define pool_put(P, E)
Free an object E in pool P.
#define vec_dup(V)
Return copy of vector (no header, no alignment)
#define VIRTCHNL_VERSION_MAJOR
clib_error_t * avf_op_enable_queues(vlib_main_t *vm, avf_device_t *ad, u32 rx, u32 tx)
static void avf_reg_flush(avf_device_t *ad)
static char * avf_tx_func_error_strings[]
int vlib_pci_supports_virtual_addr_dma(vlib_main_t *vm, vlib_pci_dev_handle_t h)
clib_error_t * vlib_pci_enable_msix_irq(vlib_main_t *vm, vlib_pci_dev_handle_t h, u16 start, u16 count)
void avf_delete_if(vlib_main_t *vm, avf_device_t *ad)
clib_error_t * vlib_pci_map_region(vlib_main_t *vm, vlib_pci_dev_handle_t h, u32 resource, void **result)
static u32 avf_flag_change(vnet_main_t *vnm, vnet_hw_interface_t *hw, u32 flags)
static void avf_irq_0_enable(avf_device_t *ad)
#define VLIB_REGISTER_NODE(x,...)
static void vlib_physmem_free(vlib_main_t *vm, void *p)
vlib_node_registration_t avf_input_node
(constructor) VLIB_REGISTER_NODE (avf_input_node)
#define vec_free(V)
Free vector's memory (no header).
clib_error_t * pci_bus_init(vlib_main_t *vm)
static void avf_irq_0_disable(avf_device_t *ad)
u32 vlib_pci_get_numa_node(vlib_main_t *vm, vlib_pci_dev_handle_t h)
clib_error_t * avf_op_get_stats(vlib_main_t *vm, avf_device_t *ad, virtchnl_eth_stats_t *es)
vlib_log_class_t log_class
clib_error_t * vlib_pci_register_msix_handler(vlib_main_t *vm, vlib_pci_dev_handle_t h, u32 start, u32 count, pci_msix_handler_function_t *msix_handler)
#define ELOG_TYPE_DECLARE(f)
clib_error_t * avf_aq_desc_enq(vlib_main_t *vm, avf_device_t *ad, avf_aq_desc_t *dt, void *data, int len)
u32 per_interface_next_index
clib_error_t * avf_op_add_eth_addr(vlib_main_t *vm, avf_device_t *ad, u8 count, u8 *macs)
static clib_error_t * avf_interface_admin_up_down(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
virtchnl_status_code_t v_retval
void vnet_hw_interface_assign_rx_thread(vnet_main_t *vnm, u32 hw_if_index, u16 queue_id, uword thread_index)
#define PCI_DEVICE_ID_INTEL_X722_VF
#define AVFINT_DYN_CTLN(x)
clib_error_t * avf_op_config_rss_lut(vlib_main_t *vm, avf_device_t *ad)
static void avf_irq_n_enable(avf_device_t *ad, u8 line)
#define PCI_DEVICE_ID_INTEL_X710_VF
clib_error_t * ethernet_register_interface(vnet_main_t *vnm, u32 dev_class_index, u32 dev_instance, u8 *address, u32 *hw_if_index_return, ethernet_flag_change_function_t flag_change)
VNET_DEVICE_CLASS(bond_dev_class)
virtchnl_pf_event_t * events
virtchnl_event_codes_t event
static void avf_reg_write(avf_device_t *ad, u32 addr, u32 val)
clib_error_t * avf_op_version(vlib_main_t *vm, avf_device_t *ad, virtchnl_version_info_t *ver)
static uword pointer_to_uword(const void *p)
static uword avf_dma_addr(vlib_main_t *vm, avf_device_t *ad, void *p)
virtchnl_eth_stats_t eth_stats
static vlib_main_t * vlib_get_main(void)
static u64 vlib_physmem_get_pa(vlib_main_t *vm, void *mem)
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
format_function_t format_avf_device_name
clib_error_t * vnet_hw_interface_set_flags(vnet_main_t *vnm, u32 hw_if_index, vnet_hw_interface_flags_t flags)
#define foreach_virtchnl_op
#define foreach_avf_tx_func_error
clib_error_t * avf_rxq_init(vlib_main_t *vm, avf_device_t *ad, u16 qid, u16 rxq_size)
clib_error_t * vlib_pci_map_dma(vlib_main_t *vm, vlib_pci_dev_handle_t h, void *ptr)
union virtchnl_pf_event_t::@408 event_data
#define clib_error_free(e)
virtchnl_vsi_resource_t vsi_res[1]
int vnet_hw_interface_unassign_rx_thread(vnet_main_t *vnm, u32 hw_if_index, u16 queue_id)
static u32 random_u32(u32 *seed)
32-bit random number generator
vl_api_gbp_vxlan_tunnel_mode_t mode
avf_per_thread_data_t * per_thread_data
static uword vlib_buffer_get_va(vlib_buffer_t *b)
static vlib_thread_main_t * vlib_get_thread_main()
#define ETHERNET_MAX_PACKET_BYTES
#define vec_foreach(var, vec)
Vector iterator.
#define vlib_log_err(...)
#define CLIB_MEMORY_BARRIER()
void avf_create_if(vlib_main_t *vm, avf_create_if_args_t *args)
static void avf_irq_0_handler(vlib_main_t *vm, vlib_pci_dev_handle_t h, u16 line)
static clib_error_t * vlib_pci_intr_enable(vlib_main_t *vm, vlib_pci_dev_handle_t h)
#define CLIB_CACHE_LINE_BYTES
#define VIRTCHNL_VERSION_MINOR
void vlib_pci_set_private_data(vlib_main_t *vm, vlib_pci_dev_handle_t h, uword private_data)
static u32 vlib_buffer_alloc(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Allocate buffers into supplied array.
static void avf_irq_n_disable(avf_device_t *ad, u8 line)
#define clib_ring_free(f)
#define PCI_VENDOR_ID_INTEL
clib_error_t * avf_cmd_rx_ctl_reg_write(vlib_main_t *vm, avf_device_t *ad, u32 reg, u32 val)
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
static void vnet_hw_interface_set_link_speed(vnet_main_t *vnm, u32 hw_if_index, u32 link_speed)
static void vnet_hw_interface_set_input_node(vnet_main_t *vnm, u32 hw_if_index, u32 node_index)
clib_error_t * avf_op_config_rss_key(vlib_main_t *vm, avf_device_t *ad)
clib_error_t * avf_op_config_vsi_queues(vlib_main_t *vm, avf_device_t *ad)
clib_error_t * avf_op_get_vf_resources(vlib_main_t *vm, avf_device_t *ad, virtchnl_vf_resource_t *res)
void vlib_pci_device_close(vlib_main_t *vm, vlib_pci_dev_handle_t h)
struct virtchnl_pf_event_t::@408::@409 link_event
static uword pool_elts(void *v)
Number of active elements in a pool.