1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2018 Aquantia Corporation 3 */ 4 5 #include <rte_string_fns.h> 6 #include <rte_ethdev_pci.h> 7 8 #include "atl_ethdev.h" 9 #include "atl_common.h" 10 #include "atl_hw_regs.h" 11 #include "atl_logs.h" 12 #include "hw_atl/hw_atl_llh.h" 13 #include "hw_atl/hw_atl_b0.h" 14 #include "hw_atl/hw_atl_b0_internal.h" 15 16 static int eth_atl_dev_init(struct rte_eth_dev *eth_dev); 17 static int eth_atl_dev_uninit(struct rte_eth_dev *eth_dev); 18 19 static int atl_dev_configure(struct rte_eth_dev *dev); 20 static int atl_dev_start(struct rte_eth_dev *dev); 21 static void atl_dev_stop(struct rte_eth_dev *dev); 22 static int atl_dev_set_link_up(struct rte_eth_dev *dev); 23 static int atl_dev_set_link_down(struct rte_eth_dev *dev); 24 static void atl_dev_close(struct rte_eth_dev *dev); 25 static int atl_dev_reset(struct rte_eth_dev *dev); 26 static void atl_dev_promiscuous_enable(struct rte_eth_dev *dev); 27 static void atl_dev_promiscuous_disable(struct rte_eth_dev *dev); 28 static void atl_dev_allmulticast_enable(struct rte_eth_dev *dev); 29 static void atl_dev_allmulticast_disable(struct rte_eth_dev *dev); 30 static int atl_dev_link_update(struct rte_eth_dev *dev, int wait); 31 32 static int atl_dev_xstats_get_names(struct rte_eth_dev *dev __rte_unused, 33 struct rte_eth_xstat_name *xstats_names, 34 unsigned int size); 35 36 static int atl_dev_stats_get(struct rte_eth_dev *dev, 37 struct rte_eth_stats *stats); 38 39 static int atl_dev_xstats_get(struct rte_eth_dev *dev, 40 struct rte_eth_xstat *stats, unsigned int n); 41 42 static void atl_dev_stats_reset(struct rte_eth_dev *dev); 43 44 static int atl_fw_version_get(struct rte_eth_dev *dev, char *fw_version, 45 size_t fw_size); 46 47 static void atl_dev_info_get(struct rte_eth_dev *dev, 48 struct rte_eth_dev_info *dev_info); 49 50 static const uint32_t *atl_dev_supported_ptypes_get(struct rte_eth_dev *dev); 51 52 static int atl_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu); 53 54 /* VLAN stuff */ 55 static int atl_vlan_filter_set(struct rte_eth_dev *dev, 56 uint16_t vlan_id, int on); 57 58 static int atl_vlan_offload_set(struct rte_eth_dev *dev, int mask); 59 60 static void atl_vlan_strip_queue_set(struct rte_eth_dev *dev, 61 uint16_t queue_id, int on); 62 63 static int atl_vlan_tpid_set(struct rte_eth_dev *dev, 64 enum rte_vlan_type vlan_type, uint16_t tpid); 65 66 /* EEPROM */ 67 static int atl_dev_get_eeprom_length(struct rte_eth_dev *dev); 68 static int atl_dev_get_eeprom(struct rte_eth_dev *dev, 69 struct rte_dev_eeprom_info *eeprom); 70 static int atl_dev_set_eeprom(struct rte_eth_dev *dev, 71 struct rte_dev_eeprom_info *eeprom); 72 73 /* Regs */ 74 static int atl_dev_get_regs(struct rte_eth_dev *dev, 75 struct rte_dev_reg_info *regs); 76 77 /* Flow control */ 78 static int atl_flow_ctrl_get(struct rte_eth_dev *dev, 79 struct rte_eth_fc_conf *fc_conf); 80 static int atl_flow_ctrl_set(struct rte_eth_dev *dev, 81 struct rte_eth_fc_conf *fc_conf); 82 83 static void atl_dev_link_status_print(struct rte_eth_dev *dev); 84 85 /* Interrupts */ 86 static int atl_dev_rxq_interrupt_setup(struct rte_eth_dev *dev); 87 static int atl_dev_lsc_interrupt_setup(struct rte_eth_dev *dev, uint8_t on); 88 static int atl_dev_interrupt_get_status(struct rte_eth_dev *dev); 89 static int atl_dev_interrupt_action(struct rte_eth_dev *dev, 90 struct rte_intr_handle *handle); 91 static void atl_dev_interrupt_handler(void *param); 92 93 94 static int atl_add_mac_addr(struct rte_eth_dev *dev, 95 struct ether_addr *mac_addr, 96 uint32_t index, uint32_t pool); 97 static void atl_remove_mac_addr(struct rte_eth_dev *dev, uint32_t index); 98 static int atl_set_default_mac_addr(struct rte_eth_dev *dev, 99 struct ether_addr *mac_addr); 100 101 static int atl_dev_set_mc_addr_list(struct rte_eth_dev *dev, 102 struct ether_addr *mc_addr_set, 103 uint32_t nb_mc_addr); 104 105 /* RSS */ 106 static int atl_reta_update(struct rte_eth_dev *dev, 107 struct rte_eth_rss_reta_entry64 *reta_conf, 108 uint16_t reta_size); 109 static int atl_reta_query(struct rte_eth_dev *dev, 110 struct rte_eth_rss_reta_entry64 *reta_conf, 111 uint16_t reta_size); 112 static int atl_rss_hash_update(struct rte_eth_dev *dev, 113 struct rte_eth_rss_conf *rss_conf); 114 static int atl_rss_hash_conf_get(struct rte_eth_dev *dev, 115 struct rte_eth_rss_conf *rss_conf); 116 117 118 static int eth_atl_pci_probe(struct rte_pci_driver *pci_drv __rte_unused, 119 struct rte_pci_device *pci_dev); 120 static int eth_atl_pci_remove(struct rte_pci_device *pci_dev); 121 122 static void atl_dev_info_get(struct rte_eth_dev *dev, 123 struct rte_eth_dev_info *dev_info); 124 125 int atl_logtype_init; 126 int atl_logtype_driver; 127 128 /* 129 * The set of PCI devices this driver supports 130 */ 131 static const struct rte_pci_id pci_id_atl_map[] = { 132 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_0001) }, 133 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_D100) }, 134 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_D107) }, 135 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_D108) }, 136 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_D109) }, 137 138 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC100) }, 139 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC107) }, 140 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC108) }, 141 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC109) }, 142 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC111) }, 143 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC112) }, 144 145 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC100S) }, 146 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC107S) }, 147 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC108S) }, 148 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC109S) }, 149 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC111S) }, 150 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC112S) }, 151 152 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC111E) }, 153 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC112E) }, 154 { .vendor_id = 0, /* sentinel */ }, 155 }; 156 157 static struct rte_pci_driver rte_atl_pmd = { 158 .id_table = pci_id_atl_map, 159 .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_INTR_LSC | 160 RTE_PCI_DRV_IOVA_AS_VA, 161 .probe = eth_atl_pci_probe, 162 .remove = eth_atl_pci_remove, 163 }; 164 165 #define ATL_RX_OFFLOADS (DEV_RX_OFFLOAD_VLAN_STRIP \ 166 | DEV_RX_OFFLOAD_IPV4_CKSUM \ 167 | DEV_RX_OFFLOAD_UDP_CKSUM \ 168 | DEV_RX_OFFLOAD_TCP_CKSUM \ 169 | DEV_RX_OFFLOAD_JUMBO_FRAME \ 170 | DEV_RX_OFFLOAD_VLAN_FILTER) 171 172 #define ATL_TX_OFFLOADS (DEV_TX_OFFLOAD_VLAN_INSERT \ 173 | DEV_TX_OFFLOAD_IPV4_CKSUM \ 174 | DEV_TX_OFFLOAD_UDP_CKSUM \ 175 | DEV_TX_OFFLOAD_TCP_CKSUM \ 176 | DEV_TX_OFFLOAD_TCP_TSO \ 177 | DEV_TX_OFFLOAD_MULTI_SEGS) 178 179 static const struct rte_eth_desc_lim rx_desc_lim = { 180 .nb_max = ATL_MAX_RING_DESC, 181 .nb_min = ATL_MIN_RING_DESC, 182 .nb_align = ATL_RXD_ALIGN, 183 }; 184 185 static const struct rte_eth_desc_lim tx_desc_lim = { 186 .nb_max = ATL_MAX_RING_DESC, 187 .nb_min = ATL_MIN_RING_DESC, 188 .nb_align = ATL_TXD_ALIGN, 189 .nb_seg_max = ATL_TX_MAX_SEG, 190 .nb_mtu_seg_max = ATL_TX_MAX_SEG, 191 }; 192 193 #define ATL_XSTATS_FIELD(name) { \ 194 #name, \ 195 offsetof(struct aq_stats_s, name) \ 196 } 197 198 struct atl_xstats_tbl_s { 199 const char *name; 200 unsigned int offset; 201 }; 202 203 static struct atl_xstats_tbl_s atl_xstats_tbl[] = { 204 ATL_XSTATS_FIELD(uprc), 205 ATL_XSTATS_FIELD(mprc), 206 ATL_XSTATS_FIELD(bprc), 207 ATL_XSTATS_FIELD(erpt), 208 ATL_XSTATS_FIELD(uptc), 209 ATL_XSTATS_FIELD(mptc), 210 ATL_XSTATS_FIELD(bptc), 211 ATL_XSTATS_FIELD(erpr), 212 ATL_XSTATS_FIELD(ubrc), 213 ATL_XSTATS_FIELD(ubtc), 214 ATL_XSTATS_FIELD(mbrc), 215 ATL_XSTATS_FIELD(mbtc), 216 ATL_XSTATS_FIELD(bbrc), 217 ATL_XSTATS_FIELD(bbtc), 218 }; 219 220 static const struct eth_dev_ops atl_eth_dev_ops = { 221 .dev_configure = atl_dev_configure, 222 .dev_start = atl_dev_start, 223 .dev_stop = atl_dev_stop, 224 .dev_set_link_up = atl_dev_set_link_up, 225 .dev_set_link_down = atl_dev_set_link_down, 226 .dev_close = atl_dev_close, 227 .dev_reset = atl_dev_reset, 228 229 /* PROMISC */ 230 .promiscuous_enable = atl_dev_promiscuous_enable, 231 .promiscuous_disable = atl_dev_promiscuous_disable, 232 .allmulticast_enable = atl_dev_allmulticast_enable, 233 .allmulticast_disable = atl_dev_allmulticast_disable, 234 235 /* Link */ 236 .link_update = atl_dev_link_update, 237 238 .get_reg = atl_dev_get_regs, 239 240 /* Stats */ 241 .stats_get = atl_dev_stats_get, 242 .xstats_get = atl_dev_xstats_get, 243 .xstats_get_names = atl_dev_xstats_get_names, 244 .stats_reset = atl_dev_stats_reset, 245 .xstats_reset = atl_dev_stats_reset, 246 247 .fw_version_get = atl_fw_version_get, 248 .dev_infos_get = atl_dev_info_get, 249 .dev_supported_ptypes_get = atl_dev_supported_ptypes_get, 250 251 .mtu_set = atl_dev_mtu_set, 252 253 /* VLAN */ 254 .vlan_filter_set = atl_vlan_filter_set, 255 .vlan_offload_set = atl_vlan_offload_set, 256 .vlan_tpid_set = atl_vlan_tpid_set, 257 .vlan_strip_queue_set = atl_vlan_strip_queue_set, 258 259 /* Queue Control */ 260 .rx_queue_start = atl_rx_queue_start, 261 .rx_queue_stop = atl_rx_queue_stop, 262 .rx_queue_setup = atl_rx_queue_setup, 263 .rx_queue_release = atl_rx_queue_release, 264 265 .tx_queue_start = atl_tx_queue_start, 266 .tx_queue_stop = atl_tx_queue_stop, 267 .tx_queue_setup = atl_tx_queue_setup, 268 .tx_queue_release = atl_tx_queue_release, 269 270 .rx_queue_intr_enable = atl_dev_rx_queue_intr_enable, 271 .rx_queue_intr_disable = atl_dev_rx_queue_intr_disable, 272 273 .rx_queue_count = atl_rx_queue_count, 274 .rx_descriptor_status = atl_dev_rx_descriptor_status, 275 .tx_descriptor_status = atl_dev_tx_descriptor_status, 276 277 /* EEPROM */ 278 .get_eeprom_length = atl_dev_get_eeprom_length, 279 .get_eeprom = atl_dev_get_eeprom, 280 .set_eeprom = atl_dev_set_eeprom, 281 282 /* Flow Control */ 283 .flow_ctrl_get = atl_flow_ctrl_get, 284 .flow_ctrl_set = atl_flow_ctrl_set, 285 286 /* MAC */ 287 .mac_addr_add = atl_add_mac_addr, 288 .mac_addr_remove = atl_remove_mac_addr, 289 .mac_addr_set = atl_set_default_mac_addr, 290 .set_mc_addr_list = atl_dev_set_mc_addr_list, 291 .rxq_info_get = atl_rxq_info_get, 292 .txq_info_get = atl_txq_info_get, 293 294 .reta_update = atl_reta_update, 295 .reta_query = atl_reta_query, 296 .rss_hash_update = atl_rss_hash_update, 297 .rss_hash_conf_get = atl_rss_hash_conf_get, 298 }; 299 300 static inline int32_t 301 atl_reset_hw(struct aq_hw_s *hw) 302 { 303 return hw_atl_b0_hw_reset(hw); 304 } 305 306 static inline void 307 atl_enable_intr(struct rte_eth_dev *dev) 308 { 309 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 310 311 hw_atl_itr_irq_msk_setlsw_set(hw, 0xffffffff); 312 } 313 314 static void 315 atl_disable_intr(struct aq_hw_s *hw) 316 { 317 PMD_INIT_FUNC_TRACE(); 318 hw_atl_itr_irq_msk_clearlsw_set(hw, 0xffffffff); 319 } 320 321 static int 322 eth_atl_dev_init(struct rte_eth_dev *eth_dev) 323 { 324 struct atl_adapter *adapter = 325 (struct atl_adapter *)eth_dev->data->dev_private; 326 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev); 327 struct rte_intr_handle *intr_handle = &pci_dev->intr_handle; 328 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 329 int err = 0; 330 331 PMD_INIT_FUNC_TRACE(); 332 333 eth_dev->dev_ops = &atl_eth_dev_ops; 334 eth_dev->rx_pkt_burst = &atl_recv_pkts; 335 eth_dev->tx_pkt_burst = &atl_xmit_pkts; 336 eth_dev->tx_pkt_prepare = &atl_prep_pkts; 337 338 /* For secondary processes, the primary process has done all the work */ 339 if (rte_eal_process_type() != RTE_PROC_PRIMARY) 340 return 0; 341 342 /* Vendor and Device ID need to be set before init of shared code */ 343 hw->device_id = pci_dev->id.device_id; 344 hw->vendor_id = pci_dev->id.vendor_id; 345 hw->mmio = (void *)pci_dev->mem_resource[0].addr; 346 347 /* Hardware configuration - hardcode */ 348 adapter->hw_cfg.is_lro = false; 349 adapter->hw_cfg.wol = false; 350 adapter->hw_cfg.is_rss = false; 351 adapter->hw_cfg.num_rss_queues = HW_ATL_B0_RSS_MAX; 352 353 adapter->hw_cfg.link_speed_msk = AQ_NIC_RATE_10G | 354 AQ_NIC_RATE_5G | 355 AQ_NIC_RATE_2G5 | 356 AQ_NIC_RATE_1G | 357 AQ_NIC_RATE_100M; 358 359 adapter->hw_cfg.flow_control = (AQ_NIC_FC_RX | AQ_NIC_FC_TX); 360 adapter->hw_cfg.aq_rss.indirection_table_size = 361 HW_ATL_B0_RSS_REDIRECTION_MAX; 362 363 hw->aq_nic_cfg = &adapter->hw_cfg; 364 365 /* disable interrupt */ 366 atl_disable_intr(hw); 367 368 /* Allocate memory for storing MAC addresses */ 369 eth_dev->data->mac_addrs = rte_zmalloc("atlantic", ETHER_ADDR_LEN, 0); 370 if (eth_dev->data->mac_addrs == NULL) { 371 PMD_INIT_LOG(ERR, "MAC Malloc failed"); 372 return -ENOMEM; 373 } 374 375 err = hw_atl_utils_initfw(hw, &hw->aq_fw_ops); 376 if (err) 377 return err; 378 379 /* Copy the permanent MAC address */ 380 if (hw->aq_fw_ops->get_mac_permanent(hw, 381 eth_dev->data->mac_addrs->addr_bytes) != 0) 382 return -EINVAL; 383 384 /* Reset the hw statistics */ 385 atl_dev_stats_reset(eth_dev); 386 387 rte_intr_callback_register(intr_handle, 388 atl_dev_interrupt_handler, eth_dev); 389 390 /* enable uio/vfio intr/eventfd mapping */ 391 rte_intr_enable(intr_handle); 392 393 /* enable support intr */ 394 atl_enable_intr(eth_dev); 395 396 return err; 397 } 398 399 static int 400 eth_atl_dev_uninit(struct rte_eth_dev *eth_dev) 401 { 402 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev); 403 struct rte_intr_handle *intr_handle = &pci_dev->intr_handle; 404 struct aq_hw_s *hw; 405 406 PMD_INIT_FUNC_TRACE(); 407 408 if (rte_eal_process_type() != RTE_PROC_PRIMARY) 409 return -EPERM; 410 411 hw = ATL_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 412 413 if (hw->adapter_stopped == 0) 414 atl_dev_close(eth_dev); 415 416 eth_dev->dev_ops = NULL; 417 eth_dev->rx_pkt_burst = NULL; 418 eth_dev->tx_pkt_burst = NULL; 419 420 /* disable uio intr before callback unregister */ 421 rte_intr_disable(intr_handle); 422 rte_intr_callback_unregister(intr_handle, 423 atl_dev_interrupt_handler, eth_dev); 424 425 rte_free(eth_dev->data->mac_addrs); 426 eth_dev->data->mac_addrs = NULL; 427 428 return 0; 429 } 430 431 static int 432 eth_atl_pci_probe(struct rte_pci_driver *pci_drv __rte_unused, 433 struct rte_pci_device *pci_dev) 434 { 435 return rte_eth_dev_pci_generic_probe(pci_dev, 436 sizeof(struct atl_adapter), eth_atl_dev_init); 437 } 438 439 static int 440 eth_atl_pci_remove(struct rte_pci_device *pci_dev) 441 { 442 return rte_eth_dev_pci_generic_remove(pci_dev, eth_atl_dev_uninit); 443 } 444 445 static int 446 atl_dev_configure(struct rte_eth_dev *dev) 447 { 448 struct atl_interrupt *intr = 449 ATL_DEV_PRIVATE_TO_INTR(dev->data->dev_private); 450 451 PMD_INIT_FUNC_TRACE(); 452 453 /* set flag to update link status after init */ 454 intr->flags |= ATL_FLAG_NEED_LINK_UPDATE; 455 456 return 0; 457 } 458 459 /* 460 * Configure device link speed and setup link. 461 * It returns 0 on success. 462 */ 463 static int 464 atl_dev_start(struct rte_eth_dev *dev) 465 { 466 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 467 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev); 468 struct rte_intr_handle *intr_handle = &pci_dev->intr_handle; 469 uint32_t intr_vector = 0; 470 int status; 471 int err; 472 473 PMD_INIT_FUNC_TRACE(); 474 475 /* set adapter started */ 476 hw->adapter_stopped = 0; 477 478 if (dev->data->dev_conf.link_speeds & ETH_LINK_SPEED_FIXED) { 479 PMD_INIT_LOG(ERR, 480 "Invalid link_speeds for port %u, fix speed not supported", 481 dev->data->port_id); 482 return -EINVAL; 483 } 484 485 /* disable uio/vfio intr/eventfd mapping */ 486 rte_intr_disable(intr_handle); 487 488 /* reinitialize adapter 489 * this calls reset and start 490 */ 491 status = atl_reset_hw(hw); 492 if (status != 0) 493 return -EIO; 494 495 err = hw_atl_b0_hw_init(hw, dev->data->mac_addrs->addr_bytes); 496 497 hw_atl_b0_hw_start(hw); 498 /* check and configure queue intr-vector mapping */ 499 if ((rte_intr_cap_multiple(intr_handle) || 500 !RTE_ETH_DEV_SRIOV(dev).active) && 501 dev->data->dev_conf.intr_conf.rxq != 0) { 502 intr_vector = dev->data->nb_rx_queues; 503 if (intr_vector > ATL_MAX_INTR_QUEUE_NUM) { 504 PMD_INIT_LOG(ERR, "At most %d intr queues supported", 505 ATL_MAX_INTR_QUEUE_NUM); 506 return -ENOTSUP; 507 } 508 if (rte_intr_efd_enable(intr_handle, intr_vector)) { 509 PMD_INIT_LOG(ERR, "rte_intr_efd_enable failed"); 510 return -1; 511 } 512 } 513 514 if (rte_intr_dp_is_en(intr_handle) && !intr_handle->intr_vec) { 515 intr_handle->intr_vec = rte_zmalloc("intr_vec", 516 dev->data->nb_rx_queues * sizeof(int), 0); 517 if (intr_handle->intr_vec == NULL) { 518 PMD_INIT_LOG(ERR, "Failed to allocate %d rx_queues" 519 " intr_vec", dev->data->nb_rx_queues); 520 return -ENOMEM; 521 } 522 } 523 524 /* initialize transmission unit */ 525 atl_tx_init(dev); 526 527 /* This can fail when allocating mbufs for descriptor rings */ 528 err = atl_rx_init(dev); 529 if (err) { 530 PMD_INIT_LOG(ERR, "Unable to initialize RX hardware"); 531 goto error; 532 } 533 534 PMD_INIT_LOG(DEBUG, "FW version: %u.%u.%u", 535 hw->fw_ver_actual >> 24, 536 (hw->fw_ver_actual >> 16) & 0xFF, 537 hw->fw_ver_actual & 0xFFFF); 538 PMD_INIT_LOG(DEBUG, "Driver version: %s", ATL_PMD_DRIVER_VERSION); 539 540 err = atl_start_queues(dev); 541 if (err < 0) { 542 PMD_INIT_LOG(ERR, "Unable to start rxtx queues"); 543 goto error; 544 } 545 546 err = atl_dev_set_link_up(dev); 547 548 err = hw->aq_fw_ops->update_link_status(hw); 549 550 if (err) 551 goto error; 552 553 dev->data->dev_link.link_status = hw->aq_link_status.mbps != 0; 554 555 if (err) 556 goto error; 557 558 if (rte_intr_allow_others(intr_handle)) { 559 /* check if lsc interrupt is enabled */ 560 if (dev->data->dev_conf.intr_conf.lsc != 0) 561 atl_dev_lsc_interrupt_setup(dev, true); 562 else 563 atl_dev_lsc_interrupt_setup(dev, false); 564 } else { 565 rte_intr_callback_unregister(intr_handle, 566 atl_dev_interrupt_handler, dev); 567 if (dev->data->dev_conf.intr_conf.lsc != 0) 568 PMD_INIT_LOG(INFO, "lsc won't enable because of" 569 " no intr multiplex"); 570 } 571 572 /* check if rxq interrupt is enabled */ 573 if (dev->data->dev_conf.intr_conf.rxq != 0 && 574 rte_intr_dp_is_en(intr_handle)) 575 atl_dev_rxq_interrupt_setup(dev); 576 577 /* enable uio/vfio intr/eventfd mapping */ 578 rte_intr_enable(intr_handle); 579 580 /* resume enabled intr since hw reset */ 581 atl_enable_intr(dev); 582 583 return 0; 584 585 error: 586 atl_stop_queues(dev); 587 return -EIO; 588 } 589 590 /* 591 * Stop device: disable rx and tx functions to allow for reconfiguring. 592 */ 593 static void 594 atl_dev_stop(struct rte_eth_dev *dev) 595 { 596 struct rte_eth_link link; 597 struct aq_hw_s *hw = 598 ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 599 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev); 600 struct rte_intr_handle *intr_handle = &pci_dev->intr_handle; 601 602 PMD_INIT_FUNC_TRACE(); 603 604 /* disable interrupts */ 605 atl_disable_intr(hw); 606 607 /* reset the NIC */ 608 atl_reset_hw(hw); 609 hw->adapter_stopped = 1; 610 611 atl_stop_queues(dev); 612 613 /* Clear stored conf */ 614 dev->data->scattered_rx = 0; 615 dev->data->lro = 0; 616 617 /* Clear recorded link status */ 618 memset(&link, 0, sizeof(link)); 619 rte_eth_linkstatus_set(dev, &link); 620 621 if (!rte_intr_allow_others(intr_handle)) 622 /* resume to the default handler */ 623 rte_intr_callback_register(intr_handle, 624 atl_dev_interrupt_handler, 625 (void *)dev); 626 627 /* Clean datapath event and queue/vec mapping */ 628 rte_intr_efd_disable(intr_handle); 629 if (intr_handle->intr_vec != NULL) { 630 rte_free(intr_handle->intr_vec); 631 intr_handle->intr_vec = NULL; 632 } 633 } 634 635 /* 636 * Set device link up: enable tx. 637 */ 638 static int 639 atl_dev_set_link_up(struct rte_eth_dev *dev) 640 { 641 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 642 uint32_t link_speeds = dev->data->dev_conf.link_speeds; 643 uint32_t speed_mask = 0; 644 645 if (link_speeds == ETH_LINK_SPEED_AUTONEG) { 646 speed_mask = hw->aq_nic_cfg->link_speed_msk; 647 } else { 648 if (link_speeds & ETH_LINK_SPEED_10G) 649 speed_mask |= AQ_NIC_RATE_10G; 650 if (link_speeds & ETH_LINK_SPEED_5G) 651 speed_mask |= AQ_NIC_RATE_5G; 652 if (link_speeds & ETH_LINK_SPEED_1G) 653 speed_mask |= AQ_NIC_RATE_1G; 654 if (link_speeds & ETH_LINK_SPEED_2_5G) 655 speed_mask |= AQ_NIC_RATE_2G5; 656 if (link_speeds & ETH_LINK_SPEED_100M) 657 speed_mask |= AQ_NIC_RATE_100M; 658 } 659 660 return hw->aq_fw_ops->set_link_speed(hw, speed_mask); 661 } 662 663 /* 664 * Set device link down: disable tx. 665 */ 666 static int 667 atl_dev_set_link_down(struct rte_eth_dev *dev) 668 { 669 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 670 671 return hw->aq_fw_ops->set_link_speed(hw, 0); 672 } 673 674 /* 675 * Reset and stop device. 676 */ 677 static void 678 atl_dev_close(struct rte_eth_dev *dev) 679 { 680 PMD_INIT_FUNC_TRACE(); 681 682 atl_dev_stop(dev); 683 684 atl_free_queues(dev); 685 } 686 687 static int 688 atl_dev_reset(struct rte_eth_dev *dev) 689 { 690 int ret; 691 692 ret = eth_atl_dev_uninit(dev); 693 if (ret) 694 return ret; 695 696 ret = eth_atl_dev_init(dev); 697 698 return ret; 699 } 700 701 702 static int 703 atl_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats) 704 { 705 struct atl_adapter *adapter = ATL_DEV_TO_ADAPTER(dev); 706 struct aq_hw_s *hw = &adapter->hw; 707 struct atl_sw_stats *swstats = &adapter->sw_stats; 708 unsigned int i; 709 710 hw->aq_fw_ops->update_stats(hw); 711 712 /* Fill out the rte_eth_stats statistics structure */ 713 stats->ipackets = hw->curr_stats.dma_pkt_rc; 714 stats->ibytes = hw->curr_stats.dma_oct_rc; 715 stats->imissed = hw->curr_stats.dpc; 716 stats->ierrors = hw->curr_stats.erpt; 717 718 stats->opackets = hw->curr_stats.dma_pkt_tc; 719 stats->obytes = hw->curr_stats.dma_oct_tc; 720 stats->oerrors = 0; 721 722 stats->rx_nombuf = swstats->rx_nombuf; 723 724 for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS; i++) { 725 stats->q_ipackets[i] = swstats->q_ipackets[i]; 726 stats->q_opackets[i] = swstats->q_opackets[i]; 727 stats->q_ibytes[i] = swstats->q_ibytes[i]; 728 stats->q_obytes[i] = swstats->q_obytes[i]; 729 stats->q_errors[i] = swstats->q_errors[i]; 730 } 731 return 0; 732 } 733 734 static void 735 atl_dev_stats_reset(struct rte_eth_dev *dev) 736 { 737 struct atl_adapter *adapter = ATL_DEV_TO_ADAPTER(dev); 738 struct aq_hw_s *hw = &adapter->hw; 739 740 hw->aq_fw_ops->update_stats(hw); 741 742 /* Reset software totals */ 743 memset(&hw->curr_stats, 0, sizeof(hw->curr_stats)); 744 745 memset(&adapter->sw_stats, 0, sizeof(adapter->sw_stats)); 746 } 747 748 static int 749 atl_dev_xstats_get_names(struct rte_eth_dev *dev __rte_unused, 750 struct rte_eth_xstat_name *xstats_names, 751 unsigned int size) 752 { 753 unsigned int i; 754 755 if (!xstats_names) 756 return RTE_DIM(atl_xstats_tbl); 757 758 for (i = 0; i < size && i < RTE_DIM(atl_xstats_tbl); i++) 759 strlcpy(xstats_names[i].name, atl_xstats_tbl[i].name, 760 RTE_ETH_XSTATS_NAME_SIZE); 761 762 return i; 763 } 764 765 static int 766 atl_dev_xstats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *stats, 767 unsigned int n) 768 { 769 struct atl_adapter *adapter = ATL_DEV_TO_ADAPTER(dev); 770 struct aq_hw_s *hw = &adapter->hw; 771 unsigned int i; 772 773 if (!stats) 774 return 0; 775 776 for (i = 0; i < n && i < RTE_DIM(atl_xstats_tbl); i++) { 777 stats[i].id = i; 778 stats[i].value = *(u64 *)((uint8_t *)&hw->curr_stats + 779 atl_xstats_tbl[i].offset); 780 } 781 782 return i; 783 } 784 785 static int 786 atl_fw_version_get(struct rte_eth_dev *dev, char *fw_version, size_t fw_size) 787 { 788 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 789 uint32_t fw_ver = 0; 790 unsigned int ret = 0; 791 792 ret = hw_atl_utils_get_fw_version(hw, &fw_ver); 793 if (ret) 794 return -EIO; 795 796 ret = snprintf(fw_version, fw_size, "%u.%u.%u", fw_ver >> 24, 797 (fw_ver >> 16) & 0xFFU, fw_ver & 0xFFFFU); 798 799 ret += 1; /* add string null-terminator */ 800 801 if (fw_size < ret) 802 return ret; 803 804 return 0; 805 } 806 807 static void 808 atl_dev_info_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info) 809 { 810 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev); 811 812 dev_info->max_rx_queues = AQ_HW_MAX_RX_QUEUES; 813 dev_info->max_tx_queues = AQ_HW_MAX_TX_QUEUES; 814 815 dev_info->min_rx_bufsize = 1024; 816 dev_info->max_rx_pktlen = HW_ATL_B0_MTU_JUMBO; 817 dev_info->max_mac_addrs = HW_ATL_B0_MAC_MAX; 818 dev_info->max_vfs = pci_dev->max_vfs; 819 820 dev_info->max_hash_mac_addrs = 0; 821 dev_info->max_vmdq_pools = 0; 822 dev_info->vmdq_queue_num = 0; 823 824 dev_info->rx_offload_capa = ATL_RX_OFFLOADS; 825 826 dev_info->tx_offload_capa = ATL_TX_OFFLOADS; 827 828 829 dev_info->default_rxconf = (struct rte_eth_rxconf) { 830 .rx_free_thresh = ATL_DEFAULT_RX_FREE_THRESH, 831 }; 832 833 dev_info->default_txconf = (struct rte_eth_txconf) { 834 .tx_free_thresh = ATL_DEFAULT_TX_FREE_THRESH, 835 }; 836 837 dev_info->rx_desc_lim = rx_desc_lim; 838 dev_info->tx_desc_lim = tx_desc_lim; 839 840 dev_info->hash_key_size = HW_ATL_B0_RSS_HASHKEY_BITS / 8; 841 dev_info->reta_size = HW_ATL_B0_RSS_REDIRECTION_MAX; 842 dev_info->flow_type_rss_offloads = ATL_RSS_OFFLOAD_ALL; 843 844 dev_info->speed_capa = ETH_LINK_SPEED_1G | ETH_LINK_SPEED_10G; 845 dev_info->speed_capa |= ETH_LINK_SPEED_100M; 846 dev_info->speed_capa |= ETH_LINK_SPEED_2_5G; 847 dev_info->speed_capa |= ETH_LINK_SPEED_5G; 848 } 849 850 static const uint32_t * 851 atl_dev_supported_ptypes_get(struct rte_eth_dev *dev) 852 { 853 static const uint32_t ptypes[] = { 854 RTE_PTYPE_L2_ETHER, 855 RTE_PTYPE_L2_ETHER_ARP, 856 RTE_PTYPE_L2_ETHER_VLAN, 857 RTE_PTYPE_L3_IPV4, 858 RTE_PTYPE_L3_IPV6, 859 RTE_PTYPE_L4_TCP, 860 RTE_PTYPE_L4_UDP, 861 RTE_PTYPE_L4_SCTP, 862 RTE_PTYPE_L4_ICMP, 863 RTE_PTYPE_UNKNOWN 864 }; 865 866 if (dev->rx_pkt_burst == atl_recv_pkts) 867 return ptypes; 868 869 return NULL; 870 } 871 872 /* return 0 means link status changed, -1 means not changed */ 873 static int 874 atl_dev_link_update(struct rte_eth_dev *dev, int wait __rte_unused) 875 { 876 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 877 struct atl_interrupt *intr = 878 ATL_DEV_PRIVATE_TO_INTR(dev->data->dev_private); 879 struct rte_eth_link link, old; 880 int err = 0; 881 882 link.link_status = ETH_LINK_DOWN; 883 link.link_speed = 0; 884 link.link_duplex = ETH_LINK_FULL_DUPLEX; 885 link.link_autoneg = hw->is_autoneg ? ETH_LINK_AUTONEG : ETH_LINK_FIXED; 886 memset(&old, 0, sizeof(old)); 887 888 /* load old link status */ 889 rte_eth_linkstatus_get(dev, &old); 890 891 /* read current link status */ 892 err = hw->aq_fw_ops->update_link_status(hw); 893 894 if (err) 895 return 0; 896 897 if (hw->aq_link_status.mbps == 0) { 898 /* write default (down) link status */ 899 rte_eth_linkstatus_set(dev, &link); 900 if (link.link_status == old.link_status) 901 return -1; 902 return 0; 903 } 904 905 intr->flags &= ~ATL_FLAG_NEED_LINK_CONFIG; 906 907 link.link_status = ETH_LINK_UP; 908 link.link_duplex = ETH_LINK_FULL_DUPLEX; 909 link.link_speed = hw->aq_link_status.mbps; 910 911 rte_eth_linkstatus_set(dev, &link); 912 913 if (link.link_status == old.link_status) 914 return -1; 915 916 return 0; 917 } 918 919 static void 920 atl_dev_promiscuous_enable(struct rte_eth_dev *dev) 921 { 922 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 923 924 hw_atl_rpfl2promiscuous_mode_en_set(hw, true); 925 } 926 927 static void 928 atl_dev_promiscuous_disable(struct rte_eth_dev *dev) 929 { 930 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 931 932 hw_atl_rpfl2promiscuous_mode_en_set(hw, false); 933 } 934 935 static void 936 atl_dev_allmulticast_enable(struct rte_eth_dev *dev) 937 { 938 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 939 940 hw_atl_rpfl2_accept_all_mc_packets_set(hw, true); 941 } 942 943 static void 944 atl_dev_allmulticast_disable(struct rte_eth_dev *dev) 945 { 946 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 947 948 if (dev->data->promiscuous == 1) 949 return; /* must remain in all_multicast mode */ 950 951 hw_atl_rpfl2_accept_all_mc_packets_set(hw, false); 952 } 953 954 /** 955 * It clears the interrupt causes and enables the interrupt. 956 * It will be called once only during nic initialized. 957 * 958 * @param dev 959 * Pointer to struct rte_eth_dev. 960 * @param on 961 * Enable or Disable. 962 * 963 * @return 964 * - On success, zero. 965 * - On failure, a negative value. 966 */ 967 968 static int 969 atl_dev_lsc_interrupt_setup(struct rte_eth_dev *dev, uint8_t on __rte_unused) 970 { 971 atl_dev_link_status_print(dev); 972 return 0; 973 } 974 975 static int 976 atl_dev_rxq_interrupt_setup(struct rte_eth_dev *dev __rte_unused) 977 { 978 return 0; 979 } 980 981 982 static int 983 atl_dev_interrupt_get_status(struct rte_eth_dev *dev) 984 { 985 struct atl_interrupt *intr = 986 ATL_DEV_PRIVATE_TO_INTR(dev->data->dev_private); 987 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 988 u64 cause = 0; 989 990 hw_atl_b0_hw_irq_read(hw, &cause); 991 992 atl_disable_intr(hw); 993 intr->flags = cause & BIT(ATL_IRQ_CAUSE_LINK) ? 994 ATL_FLAG_NEED_LINK_UPDATE : 0; 995 996 return 0; 997 } 998 999 /** 1000 * It gets and then prints the link status. 1001 * 1002 * @param dev 1003 * Pointer to struct rte_eth_dev. 1004 * 1005 * @return 1006 * - On success, zero. 1007 * - On failure, a negative value. 1008 */ 1009 static void 1010 atl_dev_link_status_print(struct rte_eth_dev *dev) 1011 { 1012 struct rte_eth_link link; 1013 1014 memset(&link, 0, sizeof(link)); 1015 rte_eth_linkstatus_get(dev, &link); 1016 if (link.link_status) { 1017 PMD_DRV_LOG(INFO, "Port %d: Link Up - speed %u Mbps - %s", 1018 (int)(dev->data->port_id), 1019 (unsigned int)link.link_speed, 1020 link.link_duplex == ETH_LINK_FULL_DUPLEX ? 1021 "full-duplex" : "half-duplex"); 1022 } else { 1023 PMD_DRV_LOG(INFO, " Port %d: Link Down", 1024 (int)(dev->data->port_id)); 1025 } 1026 1027 1028 #ifdef DEBUG 1029 { 1030 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev); 1031 1032 PMD_DRV_LOG(DEBUG, "PCI Address: " PCI_PRI_FMT, 1033 pci_dev->addr.domain, 1034 pci_dev->addr.bus, 1035 pci_dev->addr.devid, 1036 pci_dev->addr.function); 1037 } 1038 #endif 1039 1040 PMD_DRV_LOG(INFO, "Link speed:%d", link.link_speed); 1041 } 1042 1043 /* 1044 * It executes link_update after knowing an interrupt occurred. 1045 * 1046 * @param dev 1047 * Pointer to struct rte_eth_dev. 1048 * 1049 * @return 1050 * - On success, zero. 1051 * - On failure, a negative value. 1052 */ 1053 static int 1054 atl_dev_interrupt_action(struct rte_eth_dev *dev, 1055 struct rte_intr_handle *intr_handle) 1056 { 1057 struct atl_interrupt *intr = 1058 ATL_DEV_PRIVATE_TO_INTR(dev->data->dev_private); 1059 1060 if (intr->flags & ATL_FLAG_NEED_LINK_UPDATE) { 1061 atl_dev_link_update(dev, 0); 1062 intr->flags &= ~ATL_FLAG_NEED_LINK_UPDATE; 1063 atl_dev_link_status_print(dev); 1064 _rte_eth_dev_callback_process(dev, 1065 RTE_ETH_EVENT_INTR_LSC, NULL); 1066 } 1067 1068 atl_enable_intr(dev); 1069 rte_intr_enable(intr_handle); 1070 1071 return 0; 1072 } 1073 1074 /** 1075 * Interrupt handler triggered by NIC for handling 1076 * specific interrupt. 1077 * 1078 * @param handle 1079 * Pointer to interrupt handle. 1080 * @param param 1081 * The address of parameter (struct rte_eth_dev *) regsitered before. 1082 * 1083 * @return 1084 * void 1085 */ 1086 static void 1087 atl_dev_interrupt_handler(void *param) 1088 { 1089 struct rte_eth_dev *dev = (struct rte_eth_dev *)param; 1090 1091 atl_dev_interrupt_get_status(dev); 1092 atl_dev_interrupt_action(dev, dev->intr_handle); 1093 } 1094 1095 #define SFP_EEPROM_SIZE 0xff 1096 1097 static int 1098 atl_dev_get_eeprom_length(struct rte_eth_dev *dev __rte_unused) 1099 { 1100 return SFP_EEPROM_SIZE; 1101 } 1102 1103 int atl_dev_get_eeprom(struct rte_eth_dev *dev, 1104 struct rte_dev_eeprom_info *eeprom) 1105 { 1106 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1107 uint32_t dev_addr = SMBUS_DEVICE_ID; 1108 1109 if (hw->aq_fw_ops->get_eeprom == NULL) 1110 return -ENOTSUP; 1111 1112 if (eeprom->length + eeprom->offset > SFP_EEPROM_SIZE || 1113 eeprom->data == NULL) 1114 return -EINVAL; 1115 1116 if (eeprom->magic) 1117 dev_addr = eeprom->magic; 1118 1119 return hw->aq_fw_ops->get_eeprom(hw, dev_addr, eeprom->data, 1120 eeprom->length, eeprom->offset); 1121 } 1122 1123 int atl_dev_set_eeprom(struct rte_eth_dev *dev, 1124 struct rte_dev_eeprom_info *eeprom) 1125 { 1126 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1127 uint32_t dev_addr = SMBUS_DEVICE_ID; 1128 1129 if (hw->aq_fw_ops->set_eeprom == NULL) 1130 return -ENOTSUP; 1131 1132 if (eeprom->length != SFP_EEPROM_SIZE || eeprom->data == NULL) 1133 return -EINVAL; 1134 1135 if (eeprom->magic) 1136 dev_addr = eeprom->magic; 1137 1138 return hw->aq_fw_ops->set_eeprom(hw, dev_addr, 1139 eeprom->data, eeprom->length); 1140 } 1141 1142 static int 1143 atl_dev_get_regs(struct rte_eth_dev *dev, struct rte_dev_reg_info *regs) 1144 { 1145 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1146 u32 mif_id; 1147 int err; 1148 1149 if (regs->data == NULL) { 1150 regs->length = hw_atl_utils_hw_get_reg_length(); 1151 regs->width = sizeof(u32); 1152 return 0; 1153 } 1154 1155 /* Only full register dump is supported */ 1156 if (regs->length && regs->length != hw_atl_utils_hw_get_reg_length()) 1157 return -ENOTSUP; 1158 1159 err = hw_atl_utils_hw_get_regs(hw, regs->data); 1160 1161 /* Device version */ 1162 mif_id = hw_atl_reg_glb_mif_id_get(hw); 1163 regs->version = mif_id & 0xFFU; 1164 1165 return err; 1166 } 1167 1168 static int 1169 atl_flow_ctrl_get(struct rte_eth_dev *dev, struct rte_eth_fc_conf *fc_conf) 1170 { 1171 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1172 1173 if (hw->aq_nic_cfg->flow_control == AQ_NIC_FC_OFF) 1174 fc_conf->mode = RTE_FC_NONE; 1175 else if (hw->aq_nic_cfg->flow_control & (AQ_NIC_FC_RX | AQ_NIC_FC_TX)) 1176 fc_conf->mode = RTE_FC_FULL; 1177 else if (hw->aq_nic_cfg->flow_control & AQ_NIC_FC_RX) 1178 fc_conf->mode = RTE_FC_RX_PAUSE; 1179 else if (hw->aq_nic_cfg->flow_control & AQ_NIC_FC_RX) 1180 fc_conf->mode = RTE_FC_TX_PAUSE; 1181 1182 return 0; 1183 } 1184 1185 static int 1186 atl_flow_ctrl_set(struct rte_eth_dev *dev, struct rte_eth_fc_conf *fc_conf) 1187 { 1188 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1189 uint32_t old_flow_control = hw->aq_nic_cfg->flow_control; 1190 1191 1192 if (hw->aq_fw_ops->set_flow_control == NULL) 1193 return -ENOTSUP; 1194 1195 if (fc_conf->mode == RTE_FC_NONE) 1196 hw->aq_nic_cfg->flow_control = AQ_NIC_FC_OFF; 1197 else if (fc_conf->mode == RTE_FC_RX_PAUSE) 1198 hw->aq_nic_cfg->flow_control = AQ_NIC_FC_RX; 1199 else if (fc_conf->mode == RTE_FC_TX_PAUSE) 1200 hw->aq_nic_cfg->flow_control = AQ_NIC_FC_TX; 1201 else if (fc_conf->mode == RTE_FC_FULL) 1202 hw->aq_nic_cfg->flow_control = (AQ_NIC_FC_RX | AQ_NIC_FC_TX); 1203 1204 if (old_flow_control != hw->aq_nic_cfg->flow_control) 1205 return hw->aq_fw_ops->set_flow_control(hw); 1206 1207 return 0; 1208 } 1209 1210 static int 1211 atl_update_mac_addr(struct rte_eth_dev *dev, uint32_t index, 1212 u8 *mac_addr, bool enable) 1213 { 1214 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1215 unsigned int h = 0U; 1216 unsigned int l = 0U; 1217 int err; 1218 1219 if (mac_addr) { 1220 h = (mac_addr[0] << 8) | (mac_addr[1]); 1221 l = (mac_addr[2] << 24) | (mac_addr[3] << 16) | 1222 (mac_addr[4] << 8) | mac_addr[5]; 1223 } 1224 1225 hw_atl_rpfl2_uc_flr_en_set(hw, 0U, index); 1226 hw_atl_rpfl2unicast_dest_addresslsw_set(hw, l, index); 1227 hw_atl_rpfl2unicast_dest_addressmsw_set(hw, h, index); 1228 1229 if (enable) 1230 hw_atl_rpfl2_uc_flr_en_set(hw, 1U, index); 1231 1232 err = aq_hw_err_from_flags(hw); 1233 1234 return err; 1235 } 1236 1237 static int 1238 atl_add_mac_addr(struct rte_eth_dev *dev, struct ether_addr *mac_addr, 1239 uint32_t index __rte_unused, uint32_t pool __rte_unused) 1240 { 1241 if (is_zero_ether_addr(mac_addr)) { 1242 PMD_DRV_LOG(ERR, "Invalid Ethernet Address"); 1243 return -EINVAL; 1244 } 1245 1246 return atl_update_mac_addr(dev, index, (u8 *)mac_addr, true); 1247 } 1248 1249 static void 1250 atl_remove_mac_addr(struct rte_eth_dev *dev, uint32_t index) 1251 { 1252 atl_update_mac_addr(dev, index, NULL, false); 1253 } 1254 1255 static int 1256 atl_set_default_mac_addr(struct rte_eth_dev *dev, struct ether_addr *addr) 1257 { 1258 atl_remove_mac_addr(dev, 0); 1259 atl_add_mac_addr(dev, addr, 0, 0); 1260 return 0; 1261 } 1262 1263 static int 1264 atl_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu) 1265 { 1266 struct rte_eth_dev_info dev_info; 1267 uint32_t frame_size = mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 1268 1269 atl_dev_info_get(dev, &dev_info); 1270 1271 if ((mtu < ETHER_MIN_MTU) || (frame_size > dev_info.max_rx_pktlen)) 1272 return -EINVAL; 1273 1274 /* update max frame size */ 1275 dev->data->dev_conf.rxmode.max_rx_pkt_len = frame_size; 1276 1277 return 0; 1278 } 1279 1280 static int 1281 atl_vlan_filter_set(struct rte_eth_dev *dev, uint16_t vlan_id, int on) 1282 { 1283 struct aq_hw_cfg_s *cfg = 1284 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private); 1285 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1286 int err = 0; 1287 int i = 0; 1288 1289 PMD_INIT_FUNC_TRACE(); 1290 1291 for (i = 0; i < HW_ATL_B0_MAX_VLAN_IDS; i++) { 1292 if (cfg->vlan_filter[i] == vlan_id) { 1293 if (!on) { 1294 /* Disable VLAN filter. */ 1295 hw_atl_rpf_vlan_flr_en_set(hw, 0U, i); 1296 1297 /* Clear VLAN filter entry */ 1298 cfg->vlan_filter[i] = 0; 1299 } 1300 break; 1301 } 1302 } 1303 1304 /* VLAN_ID was not found. So, nothing to delete. */ 1305 if (i == HW_ATL_B0_MAX_VLAN_IDS && !on) 1306 goto exit; 1307 1308 /* VLAN_ID already exist, or already removed above. Nothing to do. */ 1309 if (i != HW_ATL_B0_MAX_VLAN_IDS) 1310 goto exit; 1311 1312 /* Try to found free VLAN filter to add new VLAN_ID */ 1313 for (i = 0; i < HW_ATL_B0_MAX_VLAN_IDS; i++) { 1314 if (cfg->vlan_filter[i] == 0) 1315 break; 1316 } 1317 1318 if (i == HW_ATL_B0_MAX_VLAN_IDS) { 1319 /* We have no free VLAN filter to add new VLAN_ID*/ 1320 err = -ENOMEM; 1321 goto exit; 1322 } 1323 1324 cfg->vlan_filter[i] = vlan_id; 1325 hw_atl_rpf_vlan_flr_act_set(hw, 1U, i); 1326 hw_atl_rpf_vlan_id_flr_set(hw, vlan_id, i); 1327 hw_atl_rpf_vlan_flr_en_set(hw, 1U, i); 1328 1329 exit: 1330 /* Enable VLAN promisc mode if vlan_filter empty */ 1331 for (i = 0; i < HW_ATL_B0_MAX_VLAN_IDS; i++) { 1332 if (cfg->vlan_filter[i] != 0) 1333 break; 1334 } 1335 1336 hw_atl_rpf_vlan_prom_mode_en_set(hw, i == HW_ATL_B0_MAX_VLAN_IDS); 1337 1338 return err; 1339 } 1340 1341 static int 1342 atl_enable_vlan_filter(struct rte_eth_dev *dev, int en) 1343 { 1344 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1345 struct aq_hw_cfg_s *cfg = 1346 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private); 1347 int i; 1348 1349 PMD_INIT_FUNC_TRACE(); 1350 1351 for (i = 0; i < HW_ATL_B0_MAX_VLAN_IDS; i++) { 1352 if (cfg->vlan_filter[i]) 1353 hw_atl_rpf_vlan_flr_en_set(hw, en, i); 1354 } 1355 return 0; 1356 } 1357 1358 static int 1359 atl_vlan_offload_set(struct rte_eth_dev *dev, int mask) 1360 { 1361 struct aq_hw_cfg_s *cfg = 1362 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private); 1363 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1364 int ret = 0; 1365 int i; 1366 1367 PMD_INIT_FUNC_TRACE(); 1368 1369 ret = atl_enable_vlan_filter(dev, mask & ETH_VLAN_FILTER_MASK); 1370 1371 cfg->vlan_strip = !!(mask & ETH_VLAN_STRIP_MASK); 1372 1373 for (i = 0; i < dev->data->nb_rx_queues; i++) 1374 hw_atl_rpo_rx_desc_vlan_stripping_set(hw, cfg->vlan_strip, i); 1375 1376 if (mask & ETH_VLAN_EXTEND_MASK) 1377 ret = -ENOTSUP; 1378 1379 return ret; 1380 } 1381 1382 static int 1383 atl_vlan_tpid_set(struct rte_eth_dev *dev, enum rte_vlan_type vlan_type, 1384 uint16_t tpid) 1385 { 1386 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1387 int err = 0; 1388 1389 PMD_INIT_FUNC_TRACE(); 1390 1391 switch (vlan_type) { 1392 case ETH_VLAN_TYPE_INNER: 1393 hw_atl_rpf_vlan_inner_etht_set(hw, tpid); 1394 break; 1395 case ETH_VLAN_TYPE_OUTER: 1396 hw_atl_rpf_vlan_outer_etht_set(hw, tpid); 1397 break; 1398 default: 1399 PMD_DRV_LOG(ERR, "Unsupported VLAN type"); 1400 err = -ENOTSUP; 1401 } 1402 1403 return err; 1404 } 1405 1406 static void 1407 atl_vlan_strip_queue_set(struct rte_eth_dev *dev, uint16_t queue_id, int on) 1408 { 1409 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1410 1411 PMD_INIT_FUNC_TRACE(); 1412 1413 if (queue_id > dev->data->nb_rx_queues) { 1414 PMD_DRV_LOG(ERR, "Invalid queue id"); 1415 return; 1416 } 1417 1418 hw_atl_rpo_rx_desc_vlan_stripping_set(hw, on, queue_id); 1419 } 1420 1421 static int 1422 atl_dev_set_mc_addr_list(struct rte_eth_dev *dev, 1423 struct ether_addr *mc_addr_set, 1424 uint32_t nb_mc_addr) 1425 { 1426 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1427 u32 i; 1428 1429 if (nb_mc_addr > AQ_HW_MULTICAST_ADDRESS_MAX - HW_ATL_B0_MAC_MIN) 1430 return -EINVAL; 1431 1432 /* Update whole uc filters table */ 1433 for (i = 0; i < AQ_HW_MULTICAST_ADDRESS_MAX - HW_ATL_B0_MAC_MIN; i++) { 1434 u8 *mac_addr = NULL; 1435 u32 l = 0, h = 0; 1436 1437 if (i < nb_mc_addr) { 1438 mac_addr = mc_addr_set[i].addr_bytes; 1439 l = (mac_addr[2] << 24) | (mac_addr[3] << 16) | 1440 (mac_addr[4] << 8) | mac_addr[5]; 1441 h = (mac_addr[0] << 8) | mac_addr[1]; 1442 } 1443 1444 hw_atl_rpfl2_uc_flr_en_set(hw, 0U, HW_ATL_B0_MAC_MIN + i); 1445 hw_atl_rpfl2unicast_dest_addresslsw_set(hw, l, 1446 HW_ATL_B0_MAC_MIN + i); 1447 hw_atl_rpfl2unicast_dest_addressmsw_set(hw, h, 1448 HW_ATL_B0_MAC_MIN + i); 1449 hw_atl_rpfl2_uc_flr_en_set(hw, !!mac_addr, 1450 HW_ATL_B0_MAC_MIN + i); 1451 } 1452 1453 return 0; 1454 } 1455 1456 static int 1457 atl_reta_update(struct rte_eth_dev *dev, 1458 struct rte_eth_rss_reta_entry64 *reta_conf, 1459 uint16_t reta_size) 1460 { 1461 int i; 1462 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1463 struct aq_hw_cfg_s *cf = ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private); 1464 1465 for (i = 0; i < reta_size && i < cf->aq_rss.indirection_table_size; i++) 1466 cf->aq_rss.indirection_table[i] = min(reta_conf->reta[i], 1467 dev->data->nb_rx_queues - 1); 1468 1469 hw_atl_b0_hw_rss_set(hw, &cf->aq_rss); 1470 return 0; 1471 } 1472 1473 static int 1474 atl_reta_query(struct rte_eth_dev *dev, 1475 struct rte_eth_rss_reta_entry64 *reta_conf, 1476 uint16_t reta_size) 1477 { 1478 int i; 1479 struct aq_hw_cfg_s *cf = ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private); 1480 1481 for (i = 0; i < reta_size && i < cf->aq_rss.indirection_table_size; i++) 1482 reta_conf->reta[i] = cf->aq_rss.indirection_table[i]; 1483 reta_conf->mask = ~0U; 1484 return 0; 1485 } 1486 1487 static int 1488 atl_rss_hash_update(struct rte_eth_dev *dev, 1489 struct rte_eth_rss_conf *rss_conf) 1490 { 1491 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1492 struct aq_hw_cfg_s *cfg = 1493 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private); 1494 static u8 def_rss_key[40] = { 1495 0x1e, 0xad, 0x71, 0x87, 0x65, 0xfc, 0x26, 0x7d, 1496 0x0d, 0x45, 0x67, 0x74, 0xcd, 0x06, 0x1a, 0x18, 1497 0xb6, 0xc1, 0xf0, 0xc7, 0xbb, 0x18, 0xbe, 0xf8, 1498 0x19, 0x13, 0x4b, 0xa9, 0xd0, 0x3e, 0xfe, 0x70, 1499 0x25, 0x03, 0xab, 0x50, 0x6a, 0x8b, 0x82, 0x0c 1500 }; 1501 1502 cfg->is_rss = !!rss_conf->rss_hf; 1503 if (rss_conf->rss_key) { 1504 memcpy(cfg->aq_rss.hash_secret_key, rss_conf->rss_key, 1505 rss_conf->rss_key_len); 1506 cfg->aq_rss.hash_secret_key_size = rss_conf->rss_key_len; 1507 } else { 1508 memcpy(cfg->aq_rss.hash_secret_key, def_rss_key, 1509 sizeof(def_rss_key)); 1510 cfg->aq_rss.hash_secret_key_size = sizeof(def_rss_key); 1511 } 1512 1513 hw_atl_b0_hw_rss_set(hw, &cfg->aq_rss); 1514 hw_atl_b0_hw_rss_hash_set(hw, &cfg->aq_rss); 1515 return 0; 1516 } 1517 1518 static int 1519 atl_rss_hash_conf_get(struct rte_eth_dev *dev, 1520 struct rte_eth_rss_conf *rss_conf) 1521 { 1522 struct aq_hw_cfg_s *cfg = 1523 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private); 1524 1525 rss_conf->rss_hf = cfg->is_rss ? ATL_RSS_OFFLOAD_ALL : 0; 1526 if (rss_conf->rss_key) { 1527 rss_conf->rss_key_len = cfg->aq_rss.hash_secret_key_size; 1528 memcpy(rss_conf->rss_key, cfg->aq_rss.hash_secret_key, 1529 rss_conf->rss_key_len); 1530 } 1531 1532 return 0; 1533 } 1534 1535 RTE_PMD_REGISTER_PCI(net_atlantic, rte_atl_pmd); 1536 RTE_PMD_REGISTER_PCI_TABLE(net_atlantic, pci_id_atl_map); 1537 RTE_PMD_REGISTER_KMOD_DEP(net_atlantic, "* igb_uio | uio_pci_generic"); 1538 1539 RTE_INIT(atl_init_log) 1540 { 1541 atl_logtype_init = rte_log_register("pmd.net.atlantic.init"); 1542 if (atl_logtype_init >= 0) 1543 rte_log_set_level(atl_logtype_init, RTE_LOG_NOTICE); 1544 atl_logtype_driver = rte_log_register("pmd.net.atlantic.driver"); 1545 if (atl_logtype_driver >= 0) 1546 rte_log_set_level(atl_logtype_driver, RTE_LOG_NOTICE); 1547 } 1548 1549