1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 Intel Corporation
5 #include <rte_ethdev_pci.h>
7 #include "base/ice_sched.h"
8 #include "ice_ethdev.h"
11 #define ICE_MAX_QP_NUM "max_queue_pair_num"
12 #define ICE_DFLT_OUTER_TAG_TYPE ICE_AQ_VSI_OUTER_TAG_VLAN_9100
15 int ice_logtype_driver;
17 static int ice_dev_configure(struct rte_eth_dev *dev);
18 static int ice_dev_start(struct rte_eth_dev *dev);
19 static void ice_dev_stop(struct rte_eth_dev *dev);
20 static void ice_dev_close(struct rte_eth_dev *dev);
21 static int ice_dev_reset(struct rte_eth_dev *dev);
22 static void ice_dev_info_get(struct rte_eth_dev *dev,
23 struct rte_eth_dev_info *dev_info);
24 static int ice_link_update(struct rte_eth_dev *dev,
25 int wait_to_complete);
26 static int ice_mtu_set(struct rte_eth_dev *dev, uint16_t mtu);
28 static const struct rte_pci_id pci_id_ice_map[] = {
29 { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E810C_BACKPLANE) },
30 { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E810C_QSFP) },
31 { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E810C_SFP) },
32 { .vendor_id = 0, /* sentinel */ },
35 static const struct eth_dev_ops ice_eth_dev_ops = {
36 .dev_configure = ice_dev_configure,
37 .dev_start = ice_dev_start,
38 .dev_stop = ice_dev_stop,
39 .dev_close = ice_dev_close,
40 .dev_reset = ice_dev_reset,
41 .rx_queue_start = ice_rx_queue_start,
42 .rx_queue_stop = ice_rx_queue_stop,
43 .tx_queue_start = ice_tx_queue_start,
44 .tx_queue_stop = ice_tx_queue_stop,
45 .rx_queue_setup = ice_rx_queue_setup,
46 .rx_queue_release = ice_rx_queue_release,
47 .tx_queue_setup = ice_tx_queue_setup,
48 .tx_queue_release = ice_tx_queue_release,
49 .dev_infos_get = ice_dev_info_get,
50 .dev_supported_ptypes_get = ice_dev_supported_ptypes_get,
51 .link_update = ice_link_update,
52 .mtu_set = ice_mtu_set,
53 .rxq_info_get = ice_rxq_info_get,
54 .txq_info_get = ice_txq_info_get,
55 .rx_queue_count = ice_rx_queue_count,
59 ice_init_controlq_parameter(struct ice_hw *hw)
61 /* fields for adminq */
62 hw->adminq.num_rq_entries = ICE_ADMINQ_LEN;
63 hw->adminq.num_sq_entries = ICE_ADMINQ_LEN;
64 hw->adminq.rq_buf_size = ICE_ADMINQ_BUF_SZ;
65 hw->adminq.sq_buf_size = ICE_ADMINQ_BUF_SZ;
67 /* fields for mailboxq, DPDK used as PF host */
68 hw->mailboxq.num_rq_entries = ICE_MAILBOXQ_LEN;
69 hw->mailboxq.num_sq_entries = ICE_MAILBOXQ_LEN;
70 hw->mailboxq.rq_buf_size = ICE_MAILBOXQ_BUF_SZ;
71 hw->mailboxq.sq_buf_size = ICE_MAILBOXQ_BUF_SZ;
75 ice_check_qp_num(const char *key, const char *qp_value,
76 __rte_unused void *opaque)
81 while (isblank(*qp_value))
84 num = strtoul(qp_value, &end, 10);
86 if (!num || (*end == '-') || errno) {
87 PMD_DRV_LOG(WARNING, "invalid value:\"%s\" for key:\"%s\", "
97 ice_config_max_queue_pair_num(struct rte_devargs *devargs)
99 struct rte_kvargs *kvlist;
100 const char *queue_num_key = ICE_MAX_QP_NUM;
106 kvlist = rte_kvargs_parse(devargs->args, NULL);
110 if (!rte_kvargs_count(kvlist, queue_num_key)) {
111 rte_kvargs_free(kvlist);
115 if (rte_kvargs_process(kvlist, queue_num_key,
116 ice_check_qp_num, NULL) < 0) {
117 rte_kvargs_free(kvlist);
120 ret = rte_kvargs_process(kvlist, queue_num_key,
121 ice_check_qp_num, NULL);
122 rte_kvargs_free(kvlist);
128 ice_res_pool_init(struct ice_res_pool_info *pool, uint32_t base,
131 struct pool_entry *entry;
136 entry = rte_zmalloc(NULL, sizeof(*entry), 0);
139 "Failed to allocate memory for resource pool");
143 /* queue heap initialize */
144 pool->num_free = num;
147 LIST_INIT(&pool->alloc_list);
148 LIST_INIT(&pool->free_list);
150 /* Initialize element */
154 LIST_INSERT_HEAD(&pool->free_list, entry, next);
159 ice_res_pool_alloc(struct ice_res_pool_info *pool,
162 struct pool_entry *entry, *valid_entry;
165 PMD_INIT_LOG(ERR, "Invalid parameter");
169 if (pool->num_free < num) {
170 PMD_INIT_LOG(ERR, "No resource. ask:%u, available:%u",
171 num, pool->num_free);
176 /* Lookup in free list and find most fit one */
177 LIST_FOREACH(entry, &pool->free_list, next) {
178 if (entry->len >= num) {
180 if (entry->len == num) {
185 valid_entry->len > entry->len)
190 /* Not find one to satisfy the request, return */
192 PMD_INIT_LOG(ERR, "No valid entry found");
196 * The entry have equal queue number as requested,
197 * remove it from alloc_list.
199 if (valid_entry->len == num) {
200 LIST_REMOVE(valid_entry, next);
203 * The entry have more numbers than requested,
204 * create a new entry for alloc_list and minus its
205 * queue base and number in free_list.
207 entry = rte_zmalloc(NULL, sizeof(*entry), 0);
210 "Failed to allocate memory for "
214 entry->base = valid_entry->base;
216 valid_entry->base += num;
217 valid_entry->len -= num;
221 /* Insert it into alloc list, not sorted */
222 LIST_INSERT_HEAD(&pool->alloc_list, valid_entry, next);
224 pool->num_free -= valid_entry->len;
225 pool->num_alloc += valid_entry->len;
227 return valid_entry->base + pool->base;
231 ice_res_pool_destroy(struct ice_res_pool_info *pool)
233 struct pool_entry *entry, *next_entry;
238 for (entry = LIST_FIRST(&pool->alloc_list);
239 entry && (next_entry = LIST_NEXT(entry, next), 1);
240 entry = next_entry) {
241 LIST_REMOVE(entry, next);
245 for (entry = LIST_FIRST(&pool->free_list);
246 entry && (next_entry = LIST_NEXT(entry, next), 1);
247 entry = next_entry) {
248 LIST_REMOVE(entry, next);
255 LIST_INIT(&pool->alloc_list);
256 LIST_INIT(&pool->free_list);
260 ice_vsi_config_default_rss(struct ice_aqc_vsi_props *info)
262 /* Set VSI LUT selection */
263 info->q_opt_rss = ICE_AQ_VSI_Q_OPT_RSS_LUT_VSI &
264 ICE_AQ_VSI_Q_OPT_RSS_LUT_M;
265 /* Set Hash scheme */
266 info->q_opt_rss |= ICE_AQ_VSI_Q_OPT_RSS_TPLZ &
267 ICE_AQ_VSI_Q_OPT_RSS_HASH_M;
269 info->q_opt_tc = ICE_AQ_VSI_Q_OPT_TC_OVR_M;
272 static enum ice_status
273 ice_vsi_config_tc_queue_mapping(struct ice_vsi *vsi,
274 struct ice_aqc_vsi_props *info,
275 uint8_t enabled_tcmap)
277 uint16_t bsf, qp_idx;
279 /* default tc 0 now. Multi-TC supporting need to be done later.
280 * Configure TC and queue mapping parameters, for enabled TC,
281 * allocate qpnum_per_tc queues to this traffic.
283 if (enabled_tcmap != 0x01) {
284 PMD_INIT_LOG(ERR, "only TC0 is supported");
288 vsi->nb_qps = RTE_MIN(vsi->nb_qps, ICE_MAX_Q_PER_TC);
289 bsf = rte_bsf32(vsi->nb_qps);
290 /* Adjust the queue number to actual queues that can be applied */
291 vsi->nb_qps = 0x1 << bsf;
294 /* Set tc and queue mapping with VSI */
295 info->tc_mapping[0] = rte_cpu_to_le_16((qp_idx <<
296 ICE_AQ_VSI_TC_Q_OFFSET_S) |
297 (bsf << ICE_AQ_VSI_TC_Q_NUM_S));
299 /* Associate queue number with VSI */
300 info->mapping_flags |= rte_cpu_to_le_16(ICE_AQ_VSI_Q_MAP_CONTIG);
301 info->q_mapping[0] = rte_cpu_to_le_16(vsi->base_queue);
302 info->q_mapping[1] = rte_cpu_to_le_16(vsi->nb_qps);
303 info->valid_sections |=
304 rte_cpu_to_le_16(ICE_AQ_VSI_PROP_RXQ_MAP_VALID);
305 /* Set the info.ingress_table and info.egress_table
306 * for UP translate table. Now just set it to 1:1 map by default
307 * -- 0b 111 110 101 100 011 010 001 000 == 0xFAC688
309 #define ICE_TC_QUEUE_TABLE_DFLT 0x00FAC688
310 info->ingress_table = rte_cpu_to_le_32(ICE_TC_QUEUE_TABLE_DFLT);
311 info->egress_table = rte_cpu_to_le_32(ICE_TC_QUEUE_TABLE_DFLT);
312 info->outer_up_table = rte_cpu_to_le_32(ICE_TC_QUEUE_TABLE_DFLT);
317 ice_init_mac_address(struct rte_eth_dev *dev)
319 struct ice_hw *hw = ICE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
321 if (!is_unicast_ether_addr
322 ((struct ether_addr *)hw->port_info[0].mac.lan_addr)) {
323 PMD_INIT_LOG(ERR, "Invalid MAC address");
327 ether_addr_copy((struct ether_addr *)hw->port_info[0].mac.lan_addr,
328 (struct ether_addr *)hw->port_info[0].mac.perm_addr);
330 dev->data->mac_addrs = rte_zmalloc(NULL, sizeof(struct ether_addr), 0);
331 if (!dev->data->mac_addrs) {
333 "Failed to allocate memory to store mac address");
336 /* store it to dev data */
337 ether_addr_copy((struct ether_addr *)hw->port_info[0].mac.perm_addr,
338 &dev->data->mac_addrs[0]);
344 ice_pf_enable_irq0(struct ice_hw *hw)
346 /* reset the registers */
347 ICE_WRITE_REG(hw, PFINT_OICR_ENA, 0);
348 ICE_READ_REG(hw, PFINT_OICR);
351 ICE_WRITE_REG(hw, PFINT_OICR_ENA,
352 (uint32_t)(PFINT_OICR_ENA_INT_ENA_M &
353 (~PFINT_OICR_LINK_STAT_CHANGE_M)));
355 ICE_WRITE_REG(hw, PFINT_OICR_CTL,
356 (0 & PFINT_OICR_CTL_MSIX_INDX_M) |
357 ((0 << PFINT_OICR_CTL_ITR_INDX_S) &
358 PFINT_OICR_CTL_ITR_INDX_M) |
359 PFINT_OICR_CTL_CAUSE_ENA_M);
361 ICE_WRITE_REG(hw, PFINT_FW_CTL,
362 (0 & PFINT_FW_CTL_MSIX_INDX_M) |
363 ((0 << PFINT_FW_CTL_ITR_INDX_S) &
364 PFINT_FW_CTL_ITR_INDX_M) |
365 PFINT_FW_CTL_CAUSE_ENA_M);
367 ICE_WRITE_REG(hw, PFINT_OICR_ENA, PFINT_OICR_ENA_INT_ENA_M);
370 ICE_WRITE_REG(hw, GLINT_DYN_CTL(0),
371 GLINT_DYN_CTL_INTENA_M |
372 GLINT_DYN_CTL_CLEARPBA_M |
373 GLINT_DYN_CTL_ITR_INDX_M);
380 ice_pf_disable_irq0(struct ice_hw *hw)
382 /* Disable all interrupt types */
383 ICE_WRITE_REG(hw, GLINT_DYN_CTL(0), GLINT_DYN_CTL_WB_ON_ITR_M);
389 ice_handle_aq_msg(struct rte_eth_dev *dev)
391 struct ice_hw *hw = ICE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
392 struct ice_ctl_q_info *cq = &hw->adminq;
393 struct ice_rq_event_info event;
394 uint16_t pending, opcode;
397 event.buf_len = ICE_AQ_MAX_BUF_LEN;
398 event.msg_buf = rte_zmalloc(NULL, event.buf_len, 0);
399 if (!event.msg_buf) {
400 PMD_DRV_LOG(ERR, "Failed to allocate mem");
406 ret = ice_clean_rq_elem(hw, cq, &event, &pending);
408 if (ret != ICE_SUCCESS) {
410 "Failed to read msg from AdminQ, "
412 hw->adminq.sq_last_status);
415 opcode = rte_le_to_cpu_16(event.desc.opcode);
418 case ice_aqc_opc_get_link_status:
419 ret = ice_link_update(dev, 0);
421 _rte_eth_dev_callback_process
422 (dev, RTE_ETH_EVENT_INTR_LSC, NULL);
425 PMD_DRV_LOG(DEBUG, "Request %u is not supported yet",
430 rte_free(event.msg_buf);
435 * Interrupt handler triggered by NIC for handling
436 * specific interrupt.
439 * Pointer to interrupt handle.
441 * The address of parameter (struct rte_eth_dev *) regsitered before.
447 ice_interrupt_handler(void *param)
449 struct rte_eth_dev *dev = (struct rte_eth_dev *)param;
450 struct ice_hw *hw = ICE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
460 /* Disable interrupt */
461 ice_pf_disable_irq0(hw);
463 /* read out interrupt causes */
464 oicr = ICE_READ_REG(hw, PFINT_OICR);
466 int_fw_ctl = ICE_READ_REG(hw, PFINT_FW_CTL);
469 /* No interrupt event indicated */
470 if (!(oicr & PFINT_OICR_INTEVENT_M)) {
471 PMD_DRV_LOG(INFO, "No interrupt event");
476 if (int_fw_ctl & PFINT_FW_CTL_INTEVENT_M) {
477 PMD_DRV_LOG(INFO, "FW_CTL: link state change event");
478 ice_handle_aq_msg(dev);
481 if (oicr & PFINT_OICR_LINK_STAT_CHANGE_M) {
482 PMD_DRV_LOG(INFO, "OICR: link state change event");
483 ice_link_update(dev, 0);
487 if (oicr & PFINT_OICR_MAL_DETECT_M) {
488 PMD_DRV_LOG(WARNING, "OICR: MDD event");
489 reg = ICE_READ_REG(hw, GL_MDET_TX_PQM);
490 if (reg & GL_MDET_TX_PQM_VALID_M) {
491 pf_num = (reg & GL_MDET_TX_PQM_PF_NUM_M) >>
492 GL_MDET_TX_PQM_PF_NUM_S;
493 event = (reg & GL_MDET_TX_PQM_MAL_TYPE_M) >>
494 GL_MDET_TX_PQM_MAL_TYPE_S;
495 queue = (reg & GL_MDET_TX_PQM_QNUM_M) >>
496 GL_MDET_TX_PQM_QNUM_S;
498 PMD_DRV_LOG(WARNING, "Malicious Driver Detection event "
499 "%d by PQM on TX queue %d PF# %d",
500 event, queue, pf_num);
503 reg = ICE_READ_REG(hw, GL_MDET_TX_TCLAN);
504 if (reg & GL_MDET_TX_TCLAN_VALID_M) {
505 pf_num = (reg & GL_MDET_TX_TCLAN_PF_NUM_M) >>
506 GL_MDET_TX_TCLAN_PF_NUM_S;
507 event = (reg & GL_MDET_TX_TCLAN_MAL_TYPE_M) >>
508 GL_MDET_TX_TCLAN_MAL_TYPE_S;
509 queue = (reg & GL_MDET_TX_TCLAN_QNUM_M) >>
510 GL_MDET_TX_TCLAN_QNUM_S;
512 PMD_DRV_LOG(WARNING, "Malicious Driver Detection event "
513 "%d by TCLAN on TX queue %d PF# %d",
514 event, queue, pf_num);
518 /* Enable interrupt */
519 ice_pf_enable_irq0(hw);
520 rte_intr_enable(dev->intr_handle);
523 /* Initialize SW parameters of PF */
525 ice_pf_sw_init(struct rte_eth_dev *dev)
527 struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private);
528 struct ice_hw *hw = ICE_PF_TO_HW(pf);
530 if (ice_config_max_queue_pair_num(dev->device->devargs) > 0)
532 ice_config_max_queue_pair_num(dev->device->devargs);
535 (uint16_t)RTE_MIN(hw->func_caps.common_cap.num_txq,
536 hw->func_caps.common_cap.num_rxq);
538 pf->lan_nb_qps = pf->lan_nb_qp_max;
543 static struct ice_vsi *
544 ice_setup_vsi(struct ice_pf *pf, enum ice_vsi_type type)
546 struct ice_hw *hw = ICE_PF_TO_HW(pf);
547 struct ice_vsi *vsi = NULL;
548 struct ice_vsi_ctx vsi_ctx;
550 uint16_t max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 };
551 uint8_t tc_bitmap = 0x1;
553 /* hw->num_lports = 1 in NIC mode */
554 vsi = rte_zmalloc(NULL, sizeof(struct ice_vsi), 0);
558 vsi->idx = pf->next_vsi_idx;
561 vsi->adapter = ICE_PF_TO_ADAPTER(pf);
562 vsi->max_macaddrs = ICE_NUM_MACADDR_MAX;
563 vsi->vlan_anti_spoof_on = 0;
564 vsi->vlan_filter_on = 1;
565 TAILQ_INIT(&vsi->mac_list);
566 TAILQ_INIT(&vsi->vlan_list);
568 memset(&vsi_ctx, 0, sizeof(vsi_ctx));
569 /* base_queue in used in queue mapping of VSI add/update command.
570 * Suppose vsi->base_queue is 0 now, don't consider SRIOV, VMDQ
571 * cases in the first stage. Only Main VSI.
576 vsi->nb_qps = pf->lan_nb_qps;
577 ice_vsi_config_default_rss(&vsi_ctx.info);
578 vsi_ctx.alloc_from_pool = true;
579 vsi_ctx.flags = ICE_AQ_VSI_TYPE_PF;
580 /* switch_id is queried by get_switch_config aq, which is done
583 vsi_ctx.info.sw_id = hw->port_info->sw_id;
584 vsi_ctx.info.sw_flags2 = ICE_AQ_VSI_SW_FLAG_LAN_ENA;
585 /* Allow all untagged or tagged packets */
586 vsi_ctx.info.vlan_flags = ICE_AQ_VSI_VLAN_MODE_ALL;
587 vsi_ctx.info.vlan_flags |= ICE_AQ_VSI_VLAN_EMOD_NOTHING;
588 vsi_ctx.info.q_opt_rss = ICE_AQ_VSI_Q_OPT_RSS_LUT_PF |
589 ICE_AQ_VSI_Q_OPT_RSS_TPLZ;
590 /* Enable VLAN/UP trip */
591 ret = ice_vsi_config_tc_queue_mapping(vsi,
596 "tc queue mapping with vsi failed, "
604 /* for other types of VSI */
605 PMD_INIT_LOG(ERR, "other types of VSI not supported");
609 /* VF has MSIX interrupt in VF range, don't allocate here */
610 if (type == ICE_VSI_PF) {
611 ret = ice_res_pool_alloc(&pf->msix_pool,
613 RTE_MAX_RXTX_INTR_VEC_ID));
615 PMD_INIT_LOG(ERR, "VSI MAIN %d get heap failed %d",
618 vsi->msix_intr = ret;
619 vsi->nb_msix = RTE_MIN(vsi->nb_qps, RTE_MAX_RXTX_INTR_VEC_ID);
624 ret = ice_add_vsi(hw, vsi->idx, &vsi_ctx, NULL);
625 if (ret != ICE_SUCCESS) {
626 PMD_INIT_LOG(ERR, "add vsi failed, err = %d", ret);
629 /* store vsi information is SW structure */
630 vsi->vsi_id = vsi_ctx.vsi_num;
631 vsi->info = vsi_ctx.info;
632 pf->vsis_allocated = vsi_ctx.vsis_allocd;
633 pf->vsis_unallocated = vsi_ctx.vsis_unallocated;
635 /* At the beginning, only TC0. */
636 /* What we need here is the maximam number of the TX queues.
637 * Currently vsi->nb_qps means it.
638 * Correct it if any change.
640 max_txqs[0] = vsi->nb_qps;
641 ret = ice_cfg_vsi_lan(hw->port_info, vsi->idx,
642 tc_bitmap, max_txqs);
643 if (ret != ICE_SUCCESS)
644 PMD_INIT_LOG(ERR, "Failed to config vsi sched");
654 ice_pf_setup(struct ice_pf *pf)
658 /* Clear all stats counters */
659 pf->offset_loaded = FALSE;
660 memset(&pf->stats, 0, sizeof(struct ice_hw_port_stats));
661 memset(&pf->stats_offset, 0, sizeof(struct ice_hw_port_stats));
662 memset(&pf->internal_stats, 0, sizeof(struct ice_eth_stats));
663 memset(&pf->internal_stats_offset, 0, sizeof(struct ice_eth_stats));
665 vsi = ice_setup_vsi(pf, ICE_VSI_PF);
667 PMD_INIT_LOG(ERR, "Failed to add vsi for PF");
677 ice_dev_init(struct rte_eth_dev *dev)
679 struct rte_pci_device *pci_dev;
680 struct rte_intr_handle *intr_handle;
681 struct ice_hw *hw = ICE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
682 struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private);
685 dev->dev_ops = &ice_eth_dev_ops;
686 dev->rx_pkt_burst = ice_recv_pkts;
687 dev->tx_pkt_burst = ice_xmit_pkts;
688 dev->tx_pkt_prepare = ice_prep_pkts;
690 ice_set_default_ptype_table(dev);
691 pci_dev = RTE_DEV_TO_PCI(dev->device);
692 intr_handle = &pci_dev->intr_handle;
694 pf->adapter = ICE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
695 pf->adapter->eth_dev = dev;
696 pf->dev_data = dev->data;
697 hw->back = pf->adapter;
698 hw->hw_addr = (uint8_t *)pci_dev->mem_resource[0].addr;
699 hw->vendor_id = pci_dev->id.vendor_id;
700 hw->device_id = pci_dev->id.device_id;
701 hw->subsystem_vendor_id = pci_dev->id.subsystem_vendor_id;
702 hw->subsystem_device_id = pci_dev->id.subsystem_device_id;
703 hw->bus.device = pci_dev->addr.devid;
704 hw->bus.func = pci_dev->addr.function;
706 ice_init_controlq_parameter(hw);
708 ret = ice_init_hw(hw);
710 PMD_INIT_LOG(ERR, "Failed to initialize HW");
714 PMD_INIT_LOG(INFO, "FW %d.%d.%05d API %d.%d",
715 hw->fw_maj_ver, hw->fw_min_ver, hw->fw_build,
716 hw->api_maj_ver, hw->api_min_ver);
719 ret = ice_init_mac_address(dev);
721 PMD_INIT_LOG(ERR, "Failed to initialize mac address");
725 ret = ice_res_pool_init(&pf->msix_pool, 1,
726 hw->func_caps.common_cap.num_msix_vectors - 1);
728 PMD_INIT_LOG(ERR, "Failed to init MSIX pool");
729 goto err_msix_pool_init;
732 ret = ice_pf_setup(pf);
734 PMD_INIT_LOG(ERR, "Failed to setup PF");
738 /* register callback func to eal lib */
739 rte_intr_callback_register(intr_handle,
740 ice_interrupt_handler, dev);
742 ice_pf_enable_irq0(hw);
744 /* enable uio intr after callback register */
745 rte_intr_enable(intr_handle);
750 ice_res_pool_destroy(&pf->msix_pool);
752 rte_free(dev->data->mac_addrs);
754 ice_sched_cleanup_all(hw);
755 rte_free(hw->port_info);
756 ice_shutdown_all_ctrlq(hw);
762 ice_release_vsi(struct ice_vsi *vsi)
765 struct ice_vsi_ctx vsi_ctx;
771 hw = ICE_VSI_TO_HW(vsi);
773 memset(&vsi_ctx, 0, sizeof(vsi_ctx));
775 vsi_ctx.vsi_num = vsi->vsi_id;
776 vsi_ctx.info = vsi->info;
777 ret = ice_free_vsi(hw, vsi->idx, &vsi_ctx, false, NULL);
778 if (ret != ICE_SUCCESS) {
779 PMD_INIT_LOG(ERR, "Failed to free vsi by aq, %u", vsi->vsi_id);
789 ice_dev_stop(struct rte_eth_dev *dev)
791 struct rte_eth_dev_data *data = dev->data;
792 struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private);
793 struct rte_pci_device *pci_dev = ICE_DEV_TO_PCI(dev);
794 struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
797 /* avoid stopping again */
798 if (pf->adapter_stopped)
801 /* stop and clear all Rx queues */
802 for (i = 0; i < data->nb_rx_queues; i++)
803 ice_rx_queue_stop(dev, i);
805 /* stop and clear all Tx queues */
806 for (i = 0; i < data->nb_tx_queues; i++)
807 ice_tx_queue_stop(dev, i);
809 /* Clear all queues and release mbufs */
810 ice_clear_queues(dev);
812 /* Clean datapath event and queue/vec mapping */
813 rte_intr_efd_disable(intr_handle);
814 if (intr_handle->intr_vec) {
815 rte_free(intr_handle->intr_vec);
816 intr_handle->intr_vec = NULL;
819 pf->adapter_stopped = true;
823 ice_dev_close(struct rte_eth_dev *dev)
825 struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private);
826 struct ice_hw *hw = ICE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
830 /* release all queue resource */
831 ice_free_queues(dev);
833 ice_res_pool_destroy(&pf->msix_pool);
834 ice_release_vsi(pf->main_vsi);
836 ice_shutdown_all_ctrlq(hw);
840 ice_dev_uninit(struct rte_eth_dev *dev)
842 struct ice_hw *hw = ICE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
843 struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private);
844 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
845 struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
850 dev->rx_pkt_burst = NULL;
851 dev->tx_pkt_burst = NULL;
853 rte_free(dev->data->mac_addrs);
854 dev->data->mac_addrs = NULL;
856 /* disable uio intr before callback unregister */
857 rte_intr_disable(intr_handle);
859 /* register callback func to eal lib */
860 rte_intr_callback_unregister(intr_handle,
861 ice_interrupt_handler, dev);
863 ice_release_vsi(pf->main_vsi);
864 ice_sched_cleanup_all(hw);
865 rte_free(hw->port_info);
866 ice_shutdown_all_ctrlq(hw);
872 ice_dev_configure(__rte_unused struct rte_eth_dev *dev)
874 struct ice_adapter *ad =
875 ICE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
877 /* Initialize to TRUE. If any of Rx queues doesn't meet the
878 * bulk allocation or vector Rx preconditions we will reset it.
880 ad->rx_bulk_alloc_allowed = true;
881 ad->tx_simple_allowed = true;
886 static int ice_init_rss(struct ice_pf *pf)
888 struct ice_hw *hw = ICE_PF_TO_HW(pf);
889 struct ice_vsi *vsi = pf->main_vsi;
890 struct rte_eth_dev *dev = pf->adapter->eth_dev;
891 struct rte_eth_rss_conf *rss_conf;
892 struct ice_aqc_get_set_rss_keys key;
896 rss_conf = &dev->data->dev_conf.rx_adv_conf.rss_conf;
897 nb_q = dev->data->nb_rx_queues;
898 vsi->rss_key_size = ICE_AQC_GET_SET_RSS_KEY_DATA_RSS_KEY_SIZE;
899 vsi->rss_lut_size = hw->func_caps.common_cap.rss_table_size;
902 vsi->rss_key = rte_zmalloc(NULL,
903 vsi->rss_key_size, 0);
905 vsi->rss_lut = rte_zmalloc(NULL,
906 vsi->rss_lut_size, 0);
908 /* configure RSS key */
909 if (!rss_conf->rss_key) {
910 /* Calculate the default hash key */
911 for (i = 0; i <= vsi->rss_key_size; i++)
912 vsi->rss_key[i] = (uint8_t)rte_rand();
914 rte_memcpy(vsi->rss_key, rss_conf->rss_key,
915 RTE_MIN(rss_conf->rss_key_len,
918 rte_memcpy(key.standard_rss_key, vsi->rss_key, vsi->rss_key_size);
919 ret = ice_aq_set_rss_key(hw, vsi->idx, &key);
923 /* init RSS LUT table */
924 for (i = 0; i < vsi->rss_lut_size; i++)
925 vsi->rss_lut[i] = i % nb_q;
927 ret = ice_aq_set_rss_lut(hw, vsi->idx,
928 ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF,
929 vsi->rss_lut, vsi->rss_lut_size);
937 ice_dev_start(struct rte_eth_dev *dev)
939 struct rte_eth_dev_data *data = dev->data;
940 struct ice_hw *hw = ICE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
941 struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private);
946 /* program Tx queues' context in hardware */
947 for (nb_txq = 0; nb_txq < data->nb_tx_queues; nb_txq++) {
948 ret = ice_tx_queue_start(dev, nb_txq);
950 PMD_DRV_LOG(ERR, "fail to start Tx queue %u", nb_txq);
955 /* program Rx queues' context in hardware*/
956 for (nb_rxq = 0; nb_rxq < data->nb_rx_queues; nb_rxq++) {
957 ret = ice_rx_queue_start(dev, nb_rxq);
959 PMD_DRV_LOG(ERR, "fail to start Rx queue %u", nb_rxq);
964 ret = ice_init_rss(pf);
966 PMD_DRV_LOG(ERR, "Failed to enable rss for PF");
970 ice_set_rx_function(dev);
972 ret = ice_aq_set_event_mask(hw, hw->port_info->lport,
973 ((u16)(ICE_AQ_LINK_EVENT_LINK_FAULT |
974 ICE_AQ_LINK_EVENT_PHY_TEMP_ALARM |
975 ICE_AQ_LINK_EVENT_EXCESSIVE_ERRORS |
976 ICE_AQ_LINK_EVENT_SIGNAL_DETECT |
977 ICE_AQ_LINK_EVENT_AN_COMPLETED |
978 ICE_AQ_LINK_EVENT_PORT_TX_SUSPENDED)),
980 if (ret != ICE_SUCCESS)
981 PMD_DRV_LOG(WARNING, "Fail to set phy mask");
983 /* Call get_link_info aq commond to enable/disable LSE */
984 ice_link_update(dev, 0);
986 pf->adapter_stopped = false;
990 /* stop the started queues if failed to start all queues */
992 for (i = 0; i < nb_rxq; i++)
993 ice_rx_queue_stop(dev, i);
995 for (i = 0; i < nb_txq; i++)
996 ice_tx_queue_stop(dev, i);
1002 ice_dev_reset(struct rte_eth_dev *dev)
1006 if (dev->data->sriov.active)
1009 ret = ice_dev_uninit(dev);
1011 PMD_INIT_LOG(ERR, "failed to uninit device, status = %d", ret);
1015 ret = ice_dev_init(dev);
1017 PMD_INIT_LOG(ERR, "failed to init device, status = %d", ret);
1025 ice_dev_info_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
1027 struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private);
1028 struct ice_hw *hw = ICE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1029 struct ice_vsi *vsi = pf->main_vsi;
1030 struct rte_pci_device *pci_dev = RTE_DEV_TO_PCI(dev->device);
1032 dev_info->min_rx_bufsize = ICE_BUF_SIZE_MIN;
1033 dev_info->max_rx_pktlen = ICE_FRAME_SIZE_MAX;
1034 dev_info->max_rx_queues = vsi->nb_qps;
1035 dev_info->max_tx_queues = vsi->nb_qps;
1036 dev_info->max_mac_addrs = vsi->max_macaddrs;
1037 dev_info->max_vfs = pci_dev->max_vfs;
1039 dev_info->rx_offload_capa =
1040 DEV_RX_OFFLOAD_IPV4_CKSUM |
1041 DEV_RX_OFFLOAD_UDP_CKSUM |
1042 DEV_RX_OFFLOAD_TCP_CKSUM |
1043 DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM |
1044 DEV_RX_OFFLOAD_JUMBO_FRAME |
1045 DEV_RX_OFFLOAD_KEEP_CRC;
1046 dev_info->tx_offload_capa =
1047 DEV_TX_OFFLOAD_IPV4_CKSUM |
1048 DEV_TX_OFFLOAD_UDP_CKSUM |
1049 DEV_TX_OFFLOAD_TCP_CKSUM |
1050 DEV_TX_OFFLOAD_SCTP_CKSUM |
1051 DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM |
1052 DEV_TX_OFFLOAD_TCP_TSO |
1053 DEV_TX_OFFLOAD_MULTI_SEGS;
1054 dev_info->rx_queue_offload_capa = 0;
1055 dev_info->tx_queue_offload_capa = 0;
1057 dev_info->reta_size = hw->func_caps.common_cap.rss_table_size;
1058 dev_info->hash_key_size = (VSIQF_HKEY_MAX_INDEX + 1) * sizeof(uint32_t);
1060 dev_info->default_rxconf = (struct rte_eth_rxconf) {
1062 .pthresh = ICE_DEFAULT_RX_PTHRESH,
1063 .hthresh = ICE_DEFAULT_RX_HTHRESH,
1064 .wthresh = ICE_DEFAULT_RX_WTHRESH,
1066 .rx_free_thresh = ICE_DEFAULT_RX_FREE_THRESH,
1071 dev_info->default_txconf = (struct rte_eth_txconf) {
1073 .pthresh = ICE_DEFAULT_TX_PTHRESH,
1074 .hthresh = ICE_DEFAULT_TX_HTHRESH,
1075 .wthresh = ICE_DEFAULT_TX_WTHRESH,
1077 .tx_free_thresh = ICE_DEFAULT_TX_FREE_THRESH,
1078 .tx_rs_thresh = ICE_DEFAULT_TX_RSBIT_THRESH,
1082 dev_info->rx_desc_lim = (struct rte_eth_desc_lim) {
1083 .nb_max = ICE_MAX_RING_DESC,
1084 .nb_min = ICE_MIN_RING_DESC,
1085 .nb_align = ICE_ALIGN_RING_DESC,
1088 dev_info->tx_desc_lim = (struct rte_eth_desc_lim) {
1089 .nb_max = ICE_MAX_RING_DESC,
1090 .nb_min = ICE_MIN_RING_DESC,
1091 .nb_align = ICE_ALIGN_RING_DESC,
1094 dev_info->speed_capa = ETH_LINK_SPEED_10M |
1095 ETH_LINK_SPEED_100M |
1097 ETH_LINK_SPEED_2_5G |
1099 ETH_LINK_SPEED_10G |
1100 ETH_LINK_SPEED_20G |
1101 ETH_LINK_SPEED_25G |
1104 dev_info->nb_rx_queues = dev->data->nb_rx_queues;
1105 dev_info->nb_tx_queues = dev->data->nb_tx_queues;
1107 dev_info->default_rxportconf.burst_size = ICE_RX_MAX_BURST;
1108 dev_info->default_txportconf.burst_size = ICE_TX_MAX_BURST;
1109 dev_info->default_rxportconf.nb_queues = 1;
1110 dev_info->default_txportconf.nb_queues = 1;
1111 dev_info->default_rxportconf.ring_size = ICE_BUF_SIZE_MIN;
1112 dev_info->default_txportconf.ring_size = ICE_BUF_SIZE_MIN;
1116 ice_atomic_read_link_status(struct rte_eth_dev *dev,
1117 struct rte_eth_link *link)
1119 struct rte_eth_link *dst = link;
1120 struct rte_eth_link *src = &dev->data->dev_link;
1122 if (rte_atomic64_cmpset((uint64_t *)dst, *(uint64_t *)dst,
1123 *(uint64_t *)src) == 0)
1130 ice_atomic_write_link_status(struct rte_eth_dev *dev,
1131 struct rte_eth_link *link)
1133 struct rte_eth_link *dst = &dev->data->dev_link;
1134 struct rte_eth_link *src = link;
1136 if (rte_atomic64_cmpset((uint64_t *)dst, *(uint64_t *)dst,
1137 *(uint64_t *)src) == 0)
1144 ice_link_update(struct rte_eth_dev *dev, __rte_unused int wait_to_complete)
1146 #define CHECK_INTERVAL 100 /* 100ms */
1147 #define MAX_REPEAT_TIME 10 /* 1s (10 * 100ms) in total */
1148 struct ice_hw *hw = ICE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1149 struct ice_link_status link_status;
1150 struct rte_eth_link link, old;
1152 unsigned int rep_cnt = MAX_REPEAT_TIME;
1153 bool enable_lse = dev->data->dev_conf.intr_conf.lsc ? true : false;
1155 memset(&link, 0, sizeof(link));
1156 memset(&old, 0, sizeof(old));
1157 memset(&link_status, 0, sizeof(link_status));
1158 ice_atomic_read_link_status(dev, &old);
1161 /* Get link status information from hardware */
1162 status = ice_aq_get_link_info(hw->port_info, enable_lse,
1163 &link_status, NULL);
1164 if (status != ICE_SUCCESS) {
1165 link.link_speed = ETH_SPEED_NUM_100M;
1166 link.link_duplex = ETH_LINK_FULL_DUPLEX;
1167 PMD_DRV_LOG(ERR, "Failed to get link info");
1171 link.link_status = link_status.link_info & ICE_AQ_LINK_UP;
1172 if (!wait_to_complete || link.link_status)
1175 rte_delay_ms(CHECK_INTERVAL);
1176 } while (--rep_cnt);
1178 if (!link.link_status)
1181 /* Full-duplex operation at all supported speeds */
1182 link.link_duplex = ETH_LINK_FULL_DUPLEX;
1184 /* Parse the link status */
1185 switch (link_status.link_speed) {
1186 case ICE_AQ_LINK_SPEED_10MB:
1187 link.link_speed = ETH_SPEED_NUM_10M;
1189 case ICE_AQ_LINK_SPEED_100MB:
1190 link.link_speed = ETH_SPEED_NUM_100M;
1192 case ICE_AQ_LINK_SPEED_1000MB:
1193 link.link_speed = ETH_SPEED_NUM_1G;
1195 case ICE_AQ_LINK_SPEED_2500MB:
1196 link.link_speed = ETH_SPEED_NUM_2_5G;
1198 case ICE_AQ_LINK_SPEED_5GB:
1199 link.link_speed = ETH_SPEED_NUM_5G;
1201 case ICE_AQ_LINK_SPEED_10GB:
1202 link.link_speed = ETH_SPEED_NUM_10G;
1204 case ICE_AQ_LINK_SPEED_20GB:
1205 link.link_speed = ETH_SPEED_NUM_20G;
1207 case ICE_AQ_LINK_SPEED_25GB:
1208 link.link_speed = ETH_SPEED_NUM_25G;
1210 case ICE_AQ_LINK_SPEED_40GB:
1211 link.link_speed = ETH_SPEED_NUM_40G;
1213 case ICE_AQ_LINK_SPEED_UNKNOWN:
1215 PMD_DRV_LOG(ERR, "Unknown link speed");
1216 link.link_speed = ETH_SPEED_NUM_NONE;
1220 link.link_autoneg = !(dev->data->dev_conf.link_speeds &
1221 ETH_LINK_SPEED_FIXED);
1224 ice_atomic_write_link_status(dev, &link);
1225 if (link.link_status == old.link_status)
1232 ice_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
1234 struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private);
1235 struct rte_eth_dev_data *dev_data = pf->dev_data;
1236 uint32_t frame_size = mtu + ETHER_HDR_LEN
1237 + ETHER_CRC_LEN + ICE_VLAN_TAG_SIZE;
1239 /* check if mtu is within the allowed range */
1240 if (mtu < ETHER_MIN_MTU || frame_size > ICE_FRAME_SIZE_MAX)
1243 /* mtu setting is forbidden if port is start */
1244 if (dev_data->dev_started) {
1246 "port %d must be stopped before configuration",
1251 if (frame_size > ETHER_MAX_LEN)
1252 dev_data->dev_conf.rxmode.offloads |=
1253 DEV_RX_OFFLOAD_JUMBO_FRAME;
1255 dev_data->dev_conf.rxmode.offloads &=
1256 ~DEV_RX_OFFLOAD_JUMBO_FRAME;
1258 dev_data->dev_conf.rxmode.max_rx_pkt_len = frame_size;
1264 ice_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
1265 struct rte_pci_device *pci_dev)
1267 return rte_eth_dev_pci_generic_probe(pci_dev,
1268 sizeof(struct ice_adapter),
1273 ice_pci_remove(struct rte_pci_device *pci_dev)
1275 return rte_eth_dev_pci_generic_remove(pci_dev, ice_dev_uninit);
1278 static struct rte_pci_driver rte_ice_pmd = {
1279 .id_table = pci_id_ice_map,
1280 .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_INTR_LSC |
1281 RTE_PCI_DRV_IOVA_AS_VA,
1282 .probe = ice_pci_probe,
1283 .remove = ice_pci_remove,
1287 * Driver initialization routine.
1288 * Invoked once at EAL init time.
1289 * Register itself as the [Poll Mode] Driver of PCI devices.
1291 RTE_PMD_REGISTER_PCI(net_ice, rte_ice_pmd);
1292 RTE_PMD_REGISTER_PCI_TABLE(net_ice, pci_id_ice_map);
1293 RTE_PMD_REGISTER_KMOD_DEP(net_ice, "* igb_uio | uio_pci_generic | vfio-pci");
1294 RTE_PMD_REGISTER_PARAM_STRING(net_ice,
1295 ICE_MAX_QP_NUM "=<int>");
1297 RTE_INIT(ice_init_log)
1299 ice_logtype_init = rte_log_register("pmd.net.ice.init");
1300 if (ice_logtype_init >= 0)
1301 rte_log_set_level(ice_logtype_init, RTE_LOG_NOTICE);
1302 ice_logtype_driver = rte_log_register("pmd.net.ice.driver");
1303 if (ice_logtype_driver >= 0)
1304 rte_log_set_level(ice_logtype_driver, RTE_LOG_NOTICE);