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