X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fplugins%2Favf%2Fdevice.c;h=8d44bd0422a542983832de099b7c21dbeaa2f83f;hb=d4d2e59d0d4409a8695b66c4102fb734e8744115;hp=543a54e60caccb7f040fd2ed1199efed4de9b7db;hpb=705b29624371ef75f38f914aa955e1b8c168f094;p=vpp.git diff --git a/src/plugins/avf/device.c b/src/plugins/avf/device.c index 543a54e60ca..8d44bd0422a 100644 --- a/src/plugins/avf/device.c +++ b/src/plugins/avf/device.c @@ -27,7 +27,7 @@ #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 @@ -49,14 +49,15 @@ const static char *virtchnl_event_names[] = { #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; @@ -65,45 +66,52 @@ avf_irq_0_disable (avf_device_t * 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_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); } @@ -115,7 +123,7 @@ avf_aq_desc_enq (vlib_main_t * vm, avf_device_t * ad, avf_aq_desc_t * dt, { 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)); @@ -144,12 +152,13 @@ avf_aq_desc_enq (vlib_main_t * vm, avf_device_t * ad, avf_aq_desc_t * dt, 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; @@ -387,8 +396,7 @@ avf_send_to_pf (vlib_main_t * vm, avf_device_t * ad, virtchnl_ops_t op, 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 @@ -399,14 +407,20 @@ avf_send_to_pf (vlib_main_t * vm, avf_device_t * ad, virtchnl_ops_t op, 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; } @@ -425,7 +439,9 @@ 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; } @@ -519,7 +535,8 @@ avf_op_get_vf_resources (vlib_main_t * vm, avf_device_t * ad, 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, @@ -606,12 +623,14 @@ avf_op_disable_vlan_stripping (vlib_main_t * vm, avf_device_t * ad) } 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", @@ -661,11 +680,11 @@ avf_op_config_vsi_queues (vlib_main_t * vm, avf_device_t * ad) 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); } @@ -681,23 +700,29 @@ avf_op_config_vsi_queues (vlib_main_t * vm, avf_device_t * ad) 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; + + 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);; - imi->vecmap[0].vector_id = 1; - imi->vecmap[0].vsi_id = ad->vsi_id; - imi->vecmap[0].rxq_map = 1; + 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); @@ -777,7 +802,7 @@ avf_device_reset (vlib_main_t * vm, avf_device_t * ad) 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"); @@ -786,19 +811,26 @@ avf_device_reset (vlib_main_t * vm, avf_device_t * ad) 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; } @@ -808,7 +840,7 @@ avf_request_queues (vlib_main_t * vm, avf_device_t * ad, u16 num_queue_pairs) 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; @@ -828,16 +860,23 @@ avf_request_queues (vlib_main_t * vm, avf_device_t * ad, u16 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: @@ -852,12 +891,12 @@ avf_device_init (vlib_main_t * vm, avf_main_t * am, avf_device_t * ad, 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); @@ -895,6 +934,7 @@ avf_device_init (vlib_main_t * vm, avf_main_t * am, avf_device_t * ad, 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); @@ -904,9 +944,6 @@ avf_device_init (vlib_main_t * vm, avf_main_t * am, avf_device_t * ad, if ((error = avf_op_disable_vlan_stripping (vm, ad))) return error; - if ((error = avf_config_promisc_mode (vm, ad))) - return error; - /* * Init Queues */ @@ -929,6 +966,15 @@ avf_device_init (vlib_main_t * vm, avf_main_t * am, avf_device_t * ad, 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; @@ -943,9 +989,11 @@ avf_device_init (vlib_main_t * vm, avf_main_t * am, avf_device_t * ad, 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; @@ -1005,38 +1053,45 @@ avf_process_one_device (vlib_main_t * vm, avf_device_t * ad, int is_irq) 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_5GB) - kbps = 5000000; - else if (speed == VIRTCHNL_LINK_SPEED_2_5GB) - kbps = 2500000; - 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) { @@ -1049,19 +1104,19 @@ avf_process_one_device (vlib_main_t * vm, avf_device_t * ad, int is_irq) 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 @@ -1100,8 +1155,28 @@ error: 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); + if (ETHERNET_INTERFACE_FLAG_CONFIG_PROMISC (flags)) + { + clib_error_t *error; + int promisc_enabled = (flags & ETHERNET_INTERFACE_FLAG_ACCEPT_ALL) != 0; + u32 new_flags = promisc_enabled ? + ad->flags | AVF_DEVICE_F_PROMISC : ad->flags & ~AVF_DEVICE_F_PROMISC; + + if (new_flags == ad->flags) + return flags; + + 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; + } + + ad->flags = new_flags; + } return 0; } @@ -1193,7 +1268,7 @@ avf_irq_0_handler (vlib_main_t * vm, vlib_pci_dev_handle_t h, u16 line) 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)) @@ -1208,8 +1283,6 @@ avf_irq_n_handler (vlib_main_t * vm, vlib_pci_dev_handle_t h, u16 line) 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) { @@ -1231,11 +1304,11 @@ avf_irq_n_handler (vlib_main_t * vm, vlib_pci_dev_handle_t h, u16 line) 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 @@ -1348,17 +1421,6 @@ avf_create_if (vlib_main_t * vm, avf_create_if_args_t * args) 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, @@ -1411,15 +1473,26 @@ avf_create_if (vlib_main_t * vm, avf_create_if_args_t * args) 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, @@ -1488,9 +1561,24 @@ avf_interface_rx_mode_change (vnet_main_t * vnm, u32 hw_if_index, u32 qid, 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; }