#define AVF_MBOX_BUF_SZ 512
#define AVF_RXQ_SZ 512
#define AVF_TXQ_SZ 512
-#define AVF_ITR_INT 8160
+#define AVF_ITR_INT 250
#define PCI_VENDOR_ID_INTEL 0x8086
#define PCI_DEVICE_ID_INTEL_AVF 0x1889
#undef _
};
-const static char *virtchnl_link_speed_str[] = {
-#define _(v, n, s) [v] = s,
- foreach_virtchnl_link_speed
-#undef _
-};
+typedef enum
+{
+ AVF_IRQ_STATE_DISABLED,
+ AVF_IRQ_STATE_ENABLED,
+ AVF_IRQ_STATE_WB_ON_ITR,
+} avf_irq_state_t;
static inline void
-avf_irq_0_disable (avf_device_t * ad)
+avf_irq_0_set_state (avf_device_t * ad, avf_irq_state_t state)
{
u32 dyn_ctl0 = 0, icr0_ena = 0;
avf_reg_write (ad, AVFINT_ICR0_ENA1, icr0_ena);
avf_reg_write (ad, AVFINT_DYN_CTL0, dyn_ctl0);
avf_reg_flush (ad);
-}
-static inline void
-avf_irq_0_enable (avf_device_t * ad)
-{
- u32 dyn_ctl0 = 0, icr0_ena = 0;
+ if (state == AVF_IRQ_STATE_DISABLED)
+ return;
+
+ dyn_ctl0 = 0;
+ icr0_ena = 0;
icr0_ena |= (1 << 30); /* [30] Admin Queue Enable */
dyn_ctl0 |= (1 << 0); /* [0] Interrupt Enable */
dyn_ctl0 |= (1 << 1); /* [1] Clear PBA */
- //dyn_ctl0 |= (3 << 3); /* [4:3] ITR Index, 11b = No ITR update */
+ dyn_ctl0 |= (2 << 3); /* [4:3] ITR Index, 11b = No ITR update */
dyn_ctl0 |= ((AVF_ITR_INT / 2) << 5); /* [16:5] ITR Interval in 2us steps */
- avf_irq_0_disable (ad);
avf_reg_write (ad, AVFINT_ICR0_ENA1, icr0_ena);
avf_reg_write (ad, AVFINT_DYN_CTL0, dyn_ctl0);
avf_reg_flush (ad);
}
static inline void
-avf_irq_n_disable (avf_device_t * ad, u8 line)
+avf_irq_n_set_state (avf_device_t * ad, u8 line, avf_irq_state_t state)
{
u32 dyn_ctln = 0;
+ /* disable */
avf_reg_write (ad, AVFINT_DYN_CTLN (line), dyn_ctln);
avf_reg_flush (ad);
-}
-static inline void
-avf_irq_n_enable (avf_device_t * ad, u8 line)
-{
- u32 dyn_ctln = 0;
+ if (state == AVF_IRQ_STATE_DISABLED)
+ return;
- dyn_ctln |= (1 << 0); /* [0] Interrupt Enable */
dyn_ctln |= (1 << 1); /* [1] Clear PBA */
- dyn_ctln |= ((AVF_ITR_INT / 2) << 5); /* [16:5] ITR Interval in 2us steps */
+ if (state == AVF_IRQ_STATE_WB_ON_ITR)
+ {
+ /* minimal ITR interval, use ITR1 */
+ dyn_ctln |= (1 << 3); /* [4:3] ITR Index */
+ dyn_ctln |= ((32 / 2) << 5); /* [16:5] ITR Interval in 2us steps */
+ dyn_ctln |= (1 << 30); /* [30] Writeback on ITR */
+ }
+ else
+ {
+ /* configured ITR interval, use ITR0 */
+ dyn_ctln |= (1 << 0); /* [0] Interrupt Enable */
+ dyn_ctln |= ((AVF_ITR_INT / 2) << 5); /* [16:5] ITR Interval in 2us steps */
+ }
- avf_irq_n_disable (ad, line);
avf_reg_write (ad, AVFINT_DYN_CTLN (line), dyn_ctln);
avf_reg_flush (ad);
}
{
clib_error_t *err = 0;
avf_aq_desc_t *d, dc;
- f64 t0, wait_time, suspend_time = AVF_AQ_ENQ_SUSPEND_TIME;
+ f64 t0, suspend_time = AVF_AQ_ENQ_SUSPEND_TIME;
d = &ad->atq[ad->atq_next_slot];
clib_memcpy_fast (d, dt, sizeof (avf_aq_desc_t));
t0 = vlib_time_now (vm);
retry:
vlib_process_suspend (vm, suspend_time);
- wait_time = vlib_time_now (vm) - t0;
if (((d->flags & AVF_AQ_F_DD) == 0) || ((d->flags & AVF_AQ_F_CMP) == 0))
{
- if (wait_time > AVF_AQ_ENQ_MAX_WAIT_TIME)
+ f64 t = vlib_time_now (vm) - t0;
+ if (t > AVF_AQ_ENQ_MAX_WAIT_TIME)
{
+ avf_log_err (ad, "aq_desc_enq failed (timeout %.3fs)", t);
err = clib_error_return (0, "adminq enqueue timeout [opcode 0x%x]",
d->opcode);
goto done;
clib_error_t *err;
avf_aq_desc_t *d, dt = {.opcode = 0x801,.v_opcode = op };
u32 head;
- int n_retry = 5;
-
+ f64 t0, suspend_time = AVF_SEND_TO_PF_SUSPEND_TIME;
/* suppress interrupt in the next adminq receive slot
as we are going to wait for response
if ((err = avf_aq_desc_enq (vm, ad, &dt, in, in_len)))
return err;
+ t0 = vlib_time_now (vm);
retry:
head = avf_get_u32 (ad->bar0, AVF_ARQH);
if (ad->arq_next_slot == head)
{
- if (--n_retry == 0)
- return clib_error_return (0, "timeout");
- vlib_process_suspend (vm, 10e-3);
+ f64 t = vlib_time_now (vm) - t0;
+ if (t > AVF_SEND_TO_PF_MAX_WAIT_TIME)
+ {
+ avf_log_err (ad, "send_to_pf failed (timeout %.3fs)", t);
+ return clib_error_return (0, "timeout");
+ }
+ vlib_process_suspend (vm, suspend_time);
+ suspend_time *= 2;
goto retry;
}
clib_memcpy_fast (e, buf, sizeof (virtchnl_pf_event_t));
avf_arq_slot_init (ad, ad->arq_next_slot);
ad->arq_next_slot++;
- n_retry = 5;
+ /* reset timer */
+ t0 = vlib_time_now (vm);
+ suspend_time = AVF_SEND_TO_PF_SUSPEND_TIME;
goto retry;
}
clib_error_t *err = 0;
u32 bitmap = (VIRTCHNL_VF_OFFLOAD_L2 | VIRTCHNL_VF_OFFLOAD_RSS_PF |
VIRTCHNL_VF_OFFLOAD_WB_ON_ITR | VIRTCHNL_VF_OFFLOAD_VLAN |
- VIRTCHNL_VF_OFFLOAD_RX_POLLING);
+ VIRTCHNL_VF_OFFLOAD_RX_POLLING |
+ VIRTCHNL_VF_CAP_ADV_LINK_SPEED);
avf_log_debug (ad, "get_vf_reqources: bitmap 0x%x", bitmap);
err = avf_send_to_pf (vm, ad, VIRTCHNL_OP_GET_VF_RESOURCES, &bitmap,
}
clib_error_t *
-avf_config_promisc_mode (vlib_main_t * vm, avf_device_t * ad)
+avf_config_promisc_mode (vlib_main_t * vm, avf_device_t * ad, int is_enable)
{
virtchnl_promisc_info_t pi = { 0 };
pi.vsi_id = ad->vsi_id;
- pi.flags = FLAG_VF_UNICAST_PROMISC | FLAG_VF_MULTICAST_PROMISC;
+
+ if (is_enable)
+ pi.flags = FLAG_VF_UNICAST_PROMISC | FLAG_VF_MULTICAST_PROMISC;
avf_log_debug (ad, "config_promisc_mode: unicast %s multicast %s",
pi.flags & FLAG_VF_UNICAST_PROMISC ? "on" : "off",
i, rxq->max_pkt_size, rxq->ring_len,
rxq->databuffer_size, rxq->dma_ring_addr);
- avf_txq_t *q = vec_elt_at_index (ad->txqs, i);
txq->vsi_id = ad->vsi_id;
+ txq->queue_id = i;
if (i < vec_len (ad->txqs))
{
- txq->queue_id = i;
+ avf_txq_t *q = vec_elt_at_index (ad->txqs, i);
txq->ring_len = q->size;
txq->dma_ring_addr = avf_dma_addr (vm, ad, (void *) q->descs);
}
clib_error_t *
avf_op_config_irq_map (vlib_main_t * vm, avf_device_t * ad)
{
- int count = 1;
int msg_len = sizeof (virtchnl_irq_map_info_t) +
- count * sizeof (virtchnl_vector_map_t);
+ (ad->n_rx_irqs) * sizeof (virtchnl_vector_map_t);
u8 msg[msg_len];
virtchnl_irq_map_info_t *imi;
clib_memset (msg, 0, msg_len);
imi = (virtchnl_irq_map_info_t *) msg;
- imi->num_vectors = count;
+ imi->num_vectors = ad->n_rx_irqs;
- imi->vecmap[0].vector_id = 1;
- imi->vecmap[0].vsi_id = ad->vsi_id;
- imi->vecmap[0].rxq_map = 1;
+ for (int i = 0; i < ad->n_rx_irqs; i++)
+ {
+ imi->vecmap[i].vector_id = i + 1;
+ imi->vecmap[i].vsi_id = ad->vsi_id;
+ if (ad->n_rx_irqs == ad->n_rx_queues)
+ imi->vecmap[i].rxq_map = 1 << i;
+ else
+ imi->vecmap[i].rxq_map = pow2_mask (ad->n_rx_queues);;
+
+ avf_log_debug (ad, "config_irq_map[%u/%u]: vsi_id %u vector_id %u "
+ "rxq_map %u", i, ad->n_rx_irqs - 1, ad->vsi_id,
+ imi->vecmap[i].vector_id, imi->vecmap[i].rxq_map);
+ }
- avf_log_debug (ad, "config_irq_map: vsi_id %u vector_id %u rxq_map %u",
- ad->vsi_id, imi->vecmap[0].vector_id,
- imi->vecmap[0].rxq_map);
return avf_send_to_pf (vm, ad, VIRTCHNL_OP_CONFIG_IRQ_MAP, msg, msg_len, 0,
0);
avf_aq_desc_t d = { 0 };
clib_error_t *error;
u32 rstat;
- int n_retry = 20;
+ f64 t0, t = 0, suspend_time = AVF_RESET_SUSPEND_TIME;
avf_log_debug (ad, "reset");
if ((error = avf_aq_desc_enq (vm, ad, &d, 0, 0)))
return error;
+ t0 = vlib_time_now (vm);
retry:
- vlib_process_suspend (vm, 10e-3);
+ vlib_process_suspend (vm, suspend_time);
+
rstat = avf_get_u32 (ad->bar0, AVFGEN_RSTAT);
if (rstat == 2 || rstat == 3)
- return 0;
+ {
+ avf_log_debug (ad, "reset completed in %.3fs", t);
+ return 0;
+ }
- if (--n_retry == 0)
+ t = vlib_time_now (vm) - t0;
+ if (t > AVF_RESET_MAX_WAIT_TIME)
{
- avf_log_err (ad, "reset failed");
+ avf_log_err (ad, "reset failed (timeout %.3fs)", t);
return clib_error_return (0, "reset failed (timeout)");
}
+ suspend_time *= 2;
goto retry;
}
virtchnl_vf_res_request_t res_req = { 0 };
clib_error_t *error;
u32 rstat;
- int n_retry = 20;
+ f64 t0, t, suspend_time = AVF_RESET_SUSPEND_TIME;
res_req.num_queue_pairs = num_queue_pairs;
res_req.num_queue_pairs);
}
+ t0 = vlib_time_now (vm);
retry:
- vlib_process_suspend (vm, 10e-3);
+ vlib_process_suspend (vm, suspend_time);
+ t = vlib_time_now (vm) - t0;
+
rstat = avf_get_u32 (ad->bar0, AVFGEN_RSTAT);
if ((rstat == VIRTCHNL_VFR_COMPLETED) || (rstat == VIRTCHNL_VFR_VFACTIVE))
goto done;
- if (--n_retry == 0)
- return clib_error_return (0, "reset failed (timeout)");
+ if (t > AVF_RESET_MAX_WAIT_TIME)
+ {
+ avf_log_err (ad, "request queues failed (timeout %.3f seconds)", t);
+ return clib_error_return (0, "request queues failed (timeout)");
+ }
+ suspend_time *= 2;
goto retry;
done:
virtchnl_vf_resource_t res = { 0 };
clib_error_t *error;
vlib_thread_main_t *tm = vlib_get_thread_main ();
- int i;
+ int i, wb_on_itr;
avf_adminq_init (vm, ad);
- /* request more queues only if we need them */
- if ((error = avf_request_queues (vm, ad, tm->n_vlib_mains)))
+ if ((error = avf_request_queues (vm, ad, clib_max (tm->n_vlib_mains,
+ args->rxq_num))))
{
/* we failed to get more queues, but still we want to proceed */
clib_error_free (error);
ad->max_mtu = res.max_mtu;
ad->rss_key_size = res.rss_key_size;
ad->rss_lut_size = res.rss_lut_size;
+ wb_on_itr = (ad->feature_bitmap & VIRTCHNL_VF_OFFLOAD_WB_ON_ITR) != 0;
clib_memcpy_fast (ad->hwaddr, res.vsi_res[0].default_mac_addr, 6);
if ((error = avf_op_disable_vlan_stripping (vm, ad)))
return error;
- if ((error = avf_config_promisc_mode (vm, ad)))
- return error;
-
/*
* Init Queues
*/
if ((error = avf_txq_init (vm, ad, i, args->txq_size)))
return error;
+ if (ad->max_vectors > ad->n_rx_queues)
+ {
+ ad->flags |= AVF_DEVICE_F_RX_INT;
+ ad->n_rx_irqs = args->rxq_num;
+ }
+ else
+ ad->n_rx_irqs = 1;
+
+
if ((ad->feature_bitmap & VIRTCHNL_VF_OFFLOAD_RSS_PF) &&
(error = avf_op_config_rss_lut (vm, ad)))
return error;
if ((error = avf_op_config_irq_map (vm, ad)))
return error;
- avf_irq_0_enable (ad);
- for (i = 0; i < ad->n_rx_queues; i++)
- avf_irq_n_enable (ad, i);
+ avf_irq_0_set_state (ad, AVF_IRQ_STATE_ENABLED);
+
+ for (i = 0; i < ad->n_rx_irqs; i++)
+ avf_irq_n_set_state (ad, i, wb_on_itr ? AVF_IRQ_STATE_WB_ON_ITR :
+ AVF_IRQ_STATE_ENABLED);
if ((error = avf_op_add_eth_addr (vm, ad, 1, ad->hwaddr)))
return error;
virtchnl_event_names[e->event], e->event, e->severity);
if (e->event == VIRTCHNL_EVENT_LINK_CHANGE)
{
- int link_up = e->event_data.link_event.link_status;
+ int link_up;
virtchnl_link_speed_t speed = e->event_data.link_event.link_speed;
u32 flags = 0;
- u32 kbps = 0;
-
- avf_log_debug (ad, "event_link_change: status %d speed '%s' (%d)",
- link_up,
- speed < ARRAY_LEN (virtchnl_link_speed_str) ?
- virtchnl_link_speed_str[speed] : "unknown", speed);
+ u32 mbps = 0;
+
+ if (ad->feature_bitmap & VIRTCHNL_VF_CAP_ADV_LINK_SPEED)
+ link_up = e->event_data.link_event_adv.link_status;
+ else
+ link_up = e->event_data.link_event.link_status;
+
+ if (ad->feature_bitmap & VIRTCHNL_VF_CAP_ADV_LINK_SPEED)
+ mbps = e->event_data.link_event_adv.link_speed;
+ if (speed == VIRTCHNL_LINK_SPEED_40GB)
+ mbps = 40000;
+ else if (speed == VIRTCHNL_LINK_SPEED_25GB)
+ mbps = 25000;
+ else if (speed == VIRTCHNL_LINK_SPEED_10GB)
+ mbps = 10000;
+ else if (speed == VIRTCHNL_LINK_SPEED_5GB)
+ mbps = 5000;
+ else if (speed == VIRTCHNL_LINK_SPEED_2_5GB)
+ mbps = 2500;
+ else if (speed == VIRTCHNL_LINK_SPEED_1GB)
+ mbps = 1000;
+ else if (speed == VIRTCHNL_LINK_SPEED_100MB)
+ mbps = 100;
+
+ avf_log_debug (ad, "event_link_change: status %d speed %u mbps",
+ link_up, mbps);
if (link_up && (ad->flags & AVF_DEVICE_F_LINK_UP) == 0)
{
ad->flags |= AVF_DEVICE_F_LINK_UP;
flags |= (VNET_HW_INTERFACE_FLAG_FULL_DUPLEX |
VNET_HW_INTERFACE_FLAG_LINK_UP);
- if (speed == VIRTCHNL_LINK_SPEED_40GB)
- kbps = 40000000;
- else if (speed == VIRTCHNL_LINK_SPEED_25GB)
- kbps = 25000000;
- else if (speed == VIRTCHNL_LINK_SPEED_10GB)
- kbps = 10000000;
- else if (speed == VIRTCHNL_LINK_SPEED_1GB)
- kbps = 1000000;
- else if (speed == VIRTCHNL_LINK_SPEED_100MB)
- kbps = 100000;
vnet_hw_interface_set_flags (vnm, ad->hw_if_index, flags);
- vnet_hw_interface_set_link_speed (vnm, ad->hw_if_index, kbps);
- ad->link_speed = speed;
+ vnet_hw_interface_set_link_speed (vnm, ad->hw_if_index,
+ mbps * 1000);
+ ad->link_speed = mbps;
}
else if (!link_up && (ad->flags & AVF_DEVICE_F_LINK_UP) != 0)
{
ELOG_TYPE_DECLARE (el) =
{
.format = "avf[%d] link change: link_status %d "
- "link_speed %d",
- .format_args = "i4i1i1",
+ "link_speed %d mbps",
+ .format_args = "i4i1i4",
};
struct
{
u32 dev_instance;
u8 link_status;
- u8 link_speed;
+ u32 link_speed;
} *ed;
ed = ELOG_DATA (&vm->elog_main, el);
ed->dev_instance = ad->dev_instance;
ed->link_status = link_up;
- ed->link_speed = speed;
+ ed->link_speed = mbps;
}
}
else
static u32
avf_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hw, u32 flags)
{
+ vlib_main_t *vm = vlib_get_main ();
avf_main_t *am = &avf_main;
- vlib_log_warn (am->log_class, "TODO");
+ avf_device_t *ad = vec_elt_at_index (am->devices, hw->dev_instance);
+ clib_error_t *error;
+ u8 promisc_enabled;
+
+ switch (flags)
+ {
+ case ETHERNET_INTERFACE_FLAG_DEFAULT_L3:
+ ad->flags &= ~AVF_DEVICE_F_PROMISC;
+ break;
+ case ETHERNET_INTERFACE_FLAG_ACCEPT_ALL:
+ ad->flags |= AVF_DEVICE_F_PROMISC;
+ break;
+ default:
+ return ~0;
+ }
+
+ promisc_enabled = ((ad->flags & AVF_DEVICE_F_PROMISC) != 0);
+ if ((error = avf_config_promisc_mode (vm, ad, promisc_enabled)))
+ {
+ avf_log_err (ad, "%s: %U", format_clib_error, error);
+ clib_error_free (error);
+ return ~0;
+ }
+
return 0;
}
ed->icr0 = icr0;
}
- avf_irq_0_enable (ad);
+ avf_irq_0_set_state (ad, AVF_IRQ_STATE_ENABLED);
/* bit 30 - Send/Receive Admin queue interrupt indication */
if (icr0 & (1 << 30))
avf_main_t *am = &avf_main;
uword pd = vlib_pci_get_private_data (vm, h);
avf_device_t *ad = pool_elt_at_index (am->devices, pd);
- u16 qid;
- int i;
if (ad->flags & AVF_DEVICE_F_ELOG)
{
ed->line = line;
}
- qid = line - 1;
- if (vec_len (ad->rxqs) > qid && ad->rxqs[qid].int_mode != 0)
- vnet_device_input_set_interrupt_pending (vnm, ad->hw_if_index, qid);
- for (i = 0; i < vec_len (ad->rxqs); i++)
- avf_irq_n_enable (ad, i);
+ line--;
+
+ if (ad->flags & AVF_DEVICE_F_RX_INT && ad->rxqs[line].int_mode)
+ vnet_device_input_set_interrupt_pending (vnm, ad->hw_if_index, line);
+ avf_irq_n_set_state (ad, line, AVF_IRQ_STATE_ENABLED);
}
void
if ((error = vlib_pci_map_region (vm, h, 0, &ad->bar0)))
goto error;
- if ((error = vlib_pci_register_msix_handler (vm, h, 0, 1,
- &avf_irq_0_handler)))
- goto error;
-
- if ((error = vlib_pci_register_msix_handler (vm, h, 1, 1,
- &avf_irq_n_handler)))
- goto error;
-
- if ((error = vlib_pci_enable_msix_irq (vm, h, 0, 2)))
- goto error;
-
ad->atq = vlib_physmem_alloc_aligned_on_numa (vm, sizeof (avf_aq_desc_t) *
AVF_MBOX_LEN,
CLIB_CACHE_LINE_BYTES,
if ((error = vlib_pci_map_dma (vm, h, ad->arq_bufs)))
goto error;
- if ((error = vlib_pci_intr_enable (vm, h)))
- goto error;
-
if (vlib_pci_supports_virtual_addr_dma (vm, h))
ad->flags |= AVF_DEVICE_F_VA_DMA;
if ((error = avf_device_init (vm, am, ad, args)))
goto error;
+ if ((error = vlib_pci_register_msix_handler (vm, h, 0, 1,
+ &avf_irq_0_handler)))
+ goto error;
+
+ if ((error = vlib_pci_register_msix_handler (vm, h, 1, ad->n_rx_irqs,
+ &avf_irq_n_handler)))
+ goto error;
+
+ if ((error = vlib_pci_enable_msix_irq (vm, h, 0, ad->n_rx_irqs + 1)))
+ goto error;
+
+ if ((error = vlib_pci_intr_enable (vm, h)))
+ goto error;
+
/* create interface */
error = ethernet_register_interface (vnm, avf_device_class.index,
ad->dev_instance, ad->hwaddr,
if (error)
goto error;
+ /* Indicate ability to support L3 DMAC filtering and
+ * initialize interface to L3 non-promisc mode */
+ vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, ad->hw_if_index);
+ hi->flags |= VNET_HW_INTERFACE_FLAG_SUPPORTS_MAC_FILTER;
+ ethernet_set_flags (vnm, ad->hw_if_index,
+ ETHERNET_INTERFACE_FLAG_DEFAULT_L3);
+
vnet_sw_interface_t *sw = vnet_get_hw_sw_interface (vnm, ad->hw_if_index);
args->sw_if_index = ad->sw_if_index = sw->sw_if_index;
avf_rxq_t *rxq = vec_elt_at_index (ad->rxqs, qid);
if (mode == VNET_HW_INTERFACE_RX_MODE_POLLING)
- rxq->int_mode = 0;
+ {
+ if (rxq->int_mode == 0)
+ return 0;
+ if (ad->feature_bitmap & VIRTCHNL_VF_OFFLOAD_WB_ON_ITR)
+ avf_irq_n_set_state (ad, qid, AVF_IRQ_STATE_WB_ON_ITR);
+ else
+ avf_irq_n_set_state (ad, qid, AVF_IRQ_STATE_ENABLED);
+ rxq->int_mode = 0;
+ }
else
- rxq->int_mode = 1;
+ {
+ if (rxq->int_mode == 1)
+ return 0;
+ if (ad->n_rx_irqs != ad->n_rx_queues)
+ return clib_error_return (0, "not enough interrupt lines");
+ rxq->int_mode = 1;
+ avf_irq_n_set_state (ad, qid, AVF_IRQ_STATE_ENABLED);
+ }
return 0;
}
#undef _
};
+static void
+avf_clear_hw_interface_counters (u32 instance)
+{
+ avf_main_t *am = &avf_main;
+ avf_device_t *ad = vec_elt_at_index (am->devices, instance);
+ clib_memcpy_fast (&ad->last_cleared_eth_stats,
+ &ad->eth_stats, sizeof (ad->eth_stats));
+}
+
/* *INDENT-OFF* */
VNET_DEVICE_CLASS (avf_device_class,) =
{
.name = "Adaptive Virtual Function (AVF) interface",
+ .clear_counters = avf_clear_hw_interface_counters,
.format_device = format_avf_device,
.format_device_name = format_avf_device_name,
.admin_up_down_function = avf_interface_admin_up_down,
Code Review / vpp.git / blobdiff