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 uint32_t *link_speeds; 469 uint32_t speed = 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 = 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 link_speeds = &dev->data->dev_conf.link_speeds; 554 555 speed = 0x0; 556 557 if (*link_speeds == ETH_LINK_SPEED_AUTONEG) { 558 speed = hw->aq_nic_cfg->link_speed_msk; 559 } else { 560 if (*link_speeds & ETH_LINK_SPEED_10G) 561 speed |= AQ_NIC_RATE_10G; 562 if (*link_speeds & ETH_LINK_SPEED_5G) 563 speed |= AQ_NIC_RATE_5G; 564 if (*link_speeds & ETH_LINK_SPEED_1G) 565 speed |= AQ_NIC_RATE_1G; 566 if (*link_speeds & ETH_LINK_SPEED_2_5G) 567 speed |= AQ_NIC_RATE_2G5; 568 if (*link_speeds & ETH_LINK_SPEED_100M) 569 speed |= AQ_NIC_RATE_100M; 570 } 571 572 err = hw->aq_fw_ops->set_link_speed(hw, speed); 573 if (err) 574 goto error; 575 576 if (rte_intr_allow_others(intr_handle)) { 577 /* check if lsc interrupt is enabled */ 578 if (dev->data->dev_conf.intr_conf.lsc != 0) 579 atl_dev_lsc_interrupt_setup(dev, true); 580 else 581 atl_dev_lsc_interrupt_setup(dev, false); 582 } else { 583 rte_intr_callback_unregister(intr_handle, 584 atl_dev_interrupt_handler, dev); 585 if (dev->data->dev_conf.intr_conf.lsc != 0) 586 PMD_INIT_LOG(INFO, "lsc won't enable because of" 587 " no intr multiplex"); 588 } 589 590 /* check if rxq interrupt is enabled */ 591 if (dev->data->dev_conf.intr_conf.rxq != 0 && 592 rte_intr_dp_is_en(intr_handle)) 593 atl_dev_rxq_interrupt_setup(dev); 594 595 /* enable uio/vfio intr/eventfd mapping */ 596 rte_intr_enable(intr_handle); 597 598 /* resume enabled intr since hw reset */ 599 atl_enable_intr(dev); 600 601 return 0; 602 603 error: 604 atl_stop_queues(dev); 605 return -EIO; 606 } 607 608 /* 609 * Stop device: disable rx and tx functions to allow for reconfiguring. 610 */ 611 static void 612 atl_dev_stop(struct rte_eth_dev *dev) 613 { 614 struct rte_eth_link link; 615 struct aq_hw_s *hw = 616 ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 617 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev); 618 struct rte_intr_handle *intr_handle = &pci_dev->intr_handle; 619 620 PMD_INIT_FUNC_TRACE(); 621 622 /* disable interrupts */ 623 atl_disable_intr(hw); 624 625 /* reset the NIC */ 626 atl_reset_hw(hw); 627 hw->adapter_stopped = 1; 628 629 atl_stop_queues(dev); 630 631 /* Clear stored conf */ 632 dev->data->scattered_rx = 0; 633 dev->data->lro = 0; 634 635 /* Clear recorded link status */ 636 memset(&link, 0, sizeof(link)); 637 rte_eth_linkstatus_set(dev, &link); 638 639 if (!rte_intr_allow_others(intr_handle)) 640 /* resume to the default handler */ 641 rte_intr_callback_register(intr_handle, 642 atl_dev_interrupt_handler, 643 (void *)dev); 644 645 /* Clean datapath event and queue/vec mapping */ 646 rte_intr_efd_disable(intr_handle); 647 if (intr_handle->intr_vec != NULL) { 648 rte_free(intr_handle->intr_vec); 649 intr_handle->intr_vec = NULL; 650 } 651 } 652 653 /* 654 * Set device link up: enable tx. 655 */ 656 static int 657 atl_dev_set_link_up(struct rte_eth_dev *dev) 658 { 659 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 660 661 return hw->aq_fw_ops->set_link_speed(hw, 662 hw->aq_nic_cfg->link_speed_msk); 663 } 664 665 /* 666 * Set device link down: disable tx. 667 */ 668 static int 669 atl_dev_set_link_down(struct rte_eth_dev *dev) 670 { 671 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 672 673 return hw->aq_fw_ops->set_link_speed(hw, 0); 674 } 675 676 /* 677 * Reset and stop device. 678 */ 679 static void 680 atl_dev_close(struct rte_eth_dev *dev) 681 { 682 PMD_INIT_FUNC_TRACE(); 683 684 atl_dev_stop(dev); 685 686 atl_free_queues(dev); 687 } 688 689 static int 690 atl_dev_reset(struct rte_eth_dev *dev) 691 { 692 int ret; 693 694 ret = eth_atl_dev_uninit(dev); 695 if (ret) 696 return ret; 697 698 ret = eth_atl_dev_init(dev); 699 700 return ret; 701 } 702 703 704 static int 705 atl_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats) 706 { 707 struct atl_adapter *adapter = ATL_DEV_TO_ADAPTER(dev); 708 struct aq_hw_s *hw = &adapter->hw; 709 struct atl_sw_stats *swstats = &adapter->sw_stats; 710 unsigned int i; 711 712 hw->aq_fw_ops->update_stats(hw); 713 714 /* Fill out the rte_eth_stats statistics structure */ 715 stats->ipackets = hw->curr_stats.dma_pkt_rc; 716 stats->ibytes = hw->curr_stats.dma_oct_rc; 717 stats->imissed = hw->curr_stats.dpc; 718 stats->ierrors = hw->curr_stats.erpt; 719 720 stats->opackets = hw->curr_stats.dma_pkt_tc; 721 stats->obytes = hw->curr_stats.dma_oct_tc; 722 stats->oerrors = 0; 723 724 stats->rx_nombuf = swstats->rx_nombuf; 725 726 for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS; i++) { 727 stats->q_ipackets[i] = swstats->q_ipackets[i]; 728 stats->q_opackets[i] = swstats->q_opackets[i]; 729 stats->q_ibytes[i] = swstats->q_ibytes[i]; 730 stats->q_obytes[i] = swstats->q_obytes[i]; 731 stats->q_errors[i] = swstats->q_errors[i]; 732 } 733 return 0; 734 } 735 736 static void 737 atl_dev_stats_reset(struct rte_eth_dev *dev) 738 { 739 struct atl_adapter *adapter = ATL_DEV_TO_ADAPTER(dev); 740 struct aq_hw_s *hw = &adapter->hw; 741 742 hw->aq_fw_ops->update_stats(hw); 743 744 /* Reset software totals */ 745 memset(&hw->curr_stats, 0, sizeof(hw->curr_stats)); 746 747 memset(&adapter->sw_stats, 0, sizeof(adapter->sw_stats)); 748 } 749 750 static int 751 atl_dev_xstats_get_names(struct rte_eth_dev *dev __rte_unused, 752 struct rte_eth_xstat_name *xstats_names, 753 unsigned int size) 754 { 755 unsigned int i; 756 757 if (!xstats_names) 758 return RTE_DIM(atl_xstats_tbl); 759 760 for (i = 0; i < size && i < RTE_DIM(atl_xstats_tbl); i++) 761 snprintf(xstats_names[i].name, RTE_ETH_XSTATS_NAME_SIZE, "%s", 762 atl_xstats_tbl[i].name); 763 764 return size; 765 } 766 767 static int 768 atl_dev_xstats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *stats, 769 unsigned int n) 770 { 771 struct atl_adapter *adapter = ATL_DEV_TO_ADAPTER(dev); 772 struct aq_hw_s *hw = &adapter->hw; 773 unsigned int i; 774 775 if (!stats) 776 return 0; 777 778 for (i = 0; i < n && i < RTE_DIM(atl_xstats_tbl); i++) { 779 stats[i].id = i; 780 stats[i].value = *(u64 *)((uint8_t *)&hw->curr_stats + 781 atl_xstats_tbl[i].offset); 782 } 783 784 return n; 785 } 786 787 static int 788 atl_fw_version_get(struct rte_eth_dev *dev, char *fw_version, size_t fw_size) 789 { 790 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 791 uint32_t fw_ver = 0; 792 unsigned int ret = 0; 793 794 ret = hw_atl_utils_get_fw_version(hw, &fw_ver); 795 if (ret) 796 return -EIO; 797 798 ret = snprintf(fw_version, fw_size, "%u.%u.%u", fw_ver >> 24, 799 (fw_ver >> 16) & 0xFFU, fw_ver & 0xFFFFU); 800 801 ret += 1; /* add string null-terminator */ 802 803 if (fw_size < ret) 804 return ret; 805 806 return 0; 807 } 808 809 static void 810 atl_dev_info_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info) 811 { 812 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev); 813 814 dev_info->max_rx_queues = AQ_HW_MAX_RX_QUEUES; 815 dev_info->max_tx_queues = AQ_HW_MAX_TX_QUEUES; 816 817 dev_info->min_rx_bufsize = 1024; 818 dev_info->max_rx_pktlen = HW_ATL_B0_MTU_JUMBO; 819 dev_info->max_mac_addrs = HW_ATL_B0_MAC_MAX; 820 dev_info->max_vfs = pci_dev->max_vfs; 821 822 dev_info->max_hash_mac_addrs = 0; 823 dev_info->max_vmdq_pools = 0; 824 dev_info->vmdq_queue_num = 0; 825 826 dev_info->rx_offload_capa = ATL_RX_OFFLOADS; 827 828 dev_info->tx_offload_capa = ATL_TX_OFFLOADS; 829 830 831 dev_info->default_rxconf = (struct rte_eth_rxconf) { 832 .rx_free_thresh = ATL_DEFAULT_RX_FREE_THRESH, 833 }; 834 835 dev_info->default_txconf = (struct rte_eth_txconf) { 836 .tx_free_thresh = ATL_DEFAULT_TX_FREE_THRESH, 837 }; 838 839 dev_info->rx_desc_lim = rx_desc_lim; 840 dev_info->tx_desc_lim = tx_desc_lim; 841 842 dev_info->hash_key_size = HW_ATL_B0_RSS_HASHKEY_BITS / 8; 843 dev_info->reta_size = HW_ATL_B0_RSS_REDIRECTION_MAX; 844 dev_info->flow_type_rss_offloads = ATL_RSS_OFFLOAD_ALL; 845 846 dev_info->speed_capa = ETH_LINK_SPEED_1G | ETH_LINK_SPEED_10G; 847 dev_info->speed_capa |= ETH_LINK_SPEED_100M; 848 dev_info->speed_capa |= ETH_LINK_SPEED_2_5G; 849 dev_info->speed_capa |= ETH_LINK_SPEED_5G; 850 } 851 852 static const uint32_t * 853 atl_dev_supported_ptypes_get(struct rte_eth_dev *dev) 854 { 855 static const uint32_t ptypes[] = { 856 RTE_PTYPE_L2_ETHER, 857 RTE_PTYPE_L2_ETHER_ARP, 858 RTE_PTYPE_L2_ETHER_VLAN, 859 RTE_PTYPE_L3_IPV4, 860 RTE_PTYPE_L3_IPV6, 861 RTE_PTYPE_L4_TCP, 862 RTE_PTYPE_L4_UDP, 863 RTE_PTYPE_L4_SCTP, 864 RTE_PTYPE_L4_ICMP, 865 RTE_PTYPE_UNKNOWN 866 }; 867 868 if (dev->rx_pkt_burst == atl_recv_pkts) 869 return ptypes; 870 871 return NULL; 872 } 873 874 /* return 0 means link status changed, -1 means not changed */ 875 static int 876 atl_dev_link_update(struct rte_eth_dev *dev, int wait __rte_unused) 877 { 878 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 879 struct atl_interrupt *intr = 880 ATL_DEV_PRIVATE_TO_INTR(dev->data->dev_private); 881 struct rte_eth_link link, old; 882 int err = 0; 883 884 link.link_status = ETH_LINK_DOWN; 885 link.link_speed = 0; 886 link.link_duplex = ETH_LINK_FULL_DUPLEX; 887 link.link_autoneg = hw->is_autoneg ? ETH_LINK_AUTONEG : ETH_LINK_FIXED; 888 memset(&old, 0, sizeof(old)); 889 890 /* load old link status */ 891 rte_eth_linkstatus_get(dev, &old); 892 893 /* read current link status */ 894 err = hw->aq_fw_ops->update_link_status(hw); 895 896 if (err) 897 return 0; 898 899 if (hw->aq_link_status.mbps == 0) { 900 /* write default (down) link status */ 901 rte_eth_linkstatus_set(dev, &link); 902 if (link.link_status == old.link_status) 903 return -1; 904 return 0; 905 } 906 907 intr->flags &= ~ATL_FLAG_NEED_LINK_CONFIG; 908 909 link.link_status = ETH_LINK_UP; 910 link.link_duplex = ETH_LINK_FULL_DUPLEX; 911 link.link_speed = hw->aq_link_status.mbps; 912 913 rte_eth_linkstatus_set(dev, &link); 914 915 if (link.link_status == old.link_status) 916 return -1; 917 918 return 0; 919 } 920 921 static void 922 atl_dev_promiscuous_enable(struct rte_eth_dev *dev) 923 { 924 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 925 926 hw_atl_rpfl2promiscuous_mode_en_set(hw, true); 927 } 928 929 static void 930 atl_dev_promiscuous_disable(struct rte_eth_dev *dev) 931 { 932 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 933 934 hw_atl_rpfl2promiscuous_mode_en_set(hw, false); 935 } 936 937 static void 938 atl_dev_allmulticast_enable(struct rte_eth_dev *dev) 939 { 940 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 941 942 hw_atl_rpfl2_accept_all_mc_packets_set(hw, true); 943 } 944 945 static void 946 atl_dev_allmulticast_disable(struct rte_eth_dev *dev) 947 { 948 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 949 950 if (dev->data->promiscuous == 1) 951 return; /* must remain in all_multicast mode */ 952 953 hw_atl_rpfl2_accept_all_mc_packets_set(hw, false); 954 } 955 956 /** 957 * It clears the interrupt causes and enables the interrupt. 958 * It will be called once only during nic initialized. 959 * 960 * @param dev 961 * Pointer to struct rte_eth_dev. 962 * @param on 963 * Enable or Disable. 964 * 965 * @return 966 * - On success, zero. 967 * - On failure, a negative value. 968 */ 969 970 static int 971 atl_dev_lsc_interrupt_setup(struct rte_eth_dev *dev, uint8_t on __rte_unused) 972 { 973 atl_dev_link_status_print(dev); 974 return 0; 975 } 976 977 static int 978 atl_dev_rxq_interrupt_setup(struct rte_eth_dev *dev __rte_unused) 979 { 980 return 0; 981 } 982 983 984 static int 985 atl_dev_interrupt_get_status(struct rte_eth_dev *dev) 986 { 987 struct atl_interrupt *intr = 988 ATL_DEV_PRIVATE_TO_INTR(dev->data->dev_private); 989 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 990 u64 cause = 0; 991 992 hw_atl_b0_hw_irq_read(hw, &cause); 993 994 atl_disable_intr(hw); 995 intr->flags = cause & BIT(ATL_IRQ_CAUSE_LINK) ? 996 ATL_FLAG_NEED_LINK_UPDATE : 0; 997 998 return 0; 999 } 1000 1001 /** 1002 * It gets and then prints the link status. 1003 * 1004 * @param dev 1005 * Pointer to struct rte_eth_dev. 1006 * 1007 * @return 1008 * - On success, zero. 1009 * - On failure, a negative value. 1010 */ 1011 static void 1012 atl_dev_link_status_print(struct rte_eth_dev *dev) 1013 { 1014 struct rte_eth_link link; 1015 1016 memset(&link, 0, sizeof(link)); 1017 rte_eth_linkstatus_get(dev, &link); 1018 if (link.link_status) { 1019 PMD_DRV_LOG(INFO, "Port %d: Link Up - speed %u Mbps - %s", 1020 (int)(dev->data->port_id), 1021 (unsigned int)link.link_speed, 1022 link.link_duplex == ETH_LINK_FULL_DUPLEX ? 1023 "full-duplex" : "half-duplex"); 1024 } else { 1025 PMD_DRV_LOG(INFO, " Port %d: Link Down", 1026 (int)(dev->data->port_id)); 1027 } 1028 1029 1030 #ifdef DEBUG 1031 { 1032 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev); 1033 1034 PMD_DRV_LOG(DEBUG, "PCI Address: " PCI_PRI_FMT, 1035 pci_dev->addr.domain, 1036 pci_dev->addr.bus, 1037 pci_dev->addr.devid, 1038 pci_dev->addr.function); 1039 } 1040 #endif 1041 1042 PMD_DRV_LOG(INFO, "Link speed:%d", link.link_speed); 1043 } 1044 1045 /* 1046 * It executes link_update after knowing an interrupt occurred. 1047 * 1048 * @param dev 1049 * Pointer to struct rte_eth_dev. 1050 * 1051 * @return 1052 * - On success, zero. 1053 * - On failure, a negative value. 1054 */ 1055 static int 1056 atl_dev_interrupt_action(struct rte_eth_dev *dev, 1057 struct rte_intr_handle *intr_handle) 1058 { 1059 struct atl_interrupt *intr = 1060 ATL_DEV_PRIVATE_TO_INTR(dev->data->dev_private); 1061 1062 if (intr->flags & ATL_FLAG_NEED_LINK_UPDATE) { 1063 atl_dev_link_update(dev, 0); 1064 intr->flags &= ~ATL_FLAG_NEED_LINK_UPDATE; 1065 atl_dev_link_status_print(dev); 1066 _rte_eth_dev_callback_process(dev, 1067 RTE_ETH_EVENT_INTR_LSC, NULL); 1068 } 1069 1070 atl_enable_intr(dev); 1071 rte_intr_enable(intr_handle); 1072 1073 return 0; 1074 } 1075 1076 /** 1077 * Interrupt handler triggered by NIC for handling 1078 * specific interrupt. 1079 * 1080 * @param handle 1081 * Pointer to interrupt handle. 1082 * @param param 1083 * The address of parameter (struct rte_eth_dev *) regsitered before. 1084 * 1085 * @return 1086 * void 1087 */ 1088 static void 1089 atl_dev_interrupt_handler(void *param) 1090 { 1091 struct rte_eth_dev *dev = (struct rte_eth_dev *)param; 1092 1093 atl_dev_interrupt_get_status(dev); 1094 atl_dev_interrupt_action(dev, dev->intr_handle); 1095 } 1096 1097 #define SFP_EEPROM_SIZE 0xff 1098 1099 static int 1100 atl_dev_get_eeprom_length(struct rte_eth_dev *dev __rte_unused) 1101 { 1102 return SFP_EEPROM_SIZE; 1103 } 1104 1105 int atl_dev_get_eeprom(struct rte_eth_dev *dev, 1106 struct rte_dev_eeprom_info *eeprom) 1107 { 1108 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1109 uint32_t dev_addr = SMBUS_DEVICE_ID; 1110 1111 if (hw->aq_fw_ops->get_eeprom == NULL) 1112 return -ENOTSUP; 1113 1114 if (eeprom->length + eeprom->offset > SFP_EEPROM_SIZE || 1115 eeprom->data == NULL) 1116 return -EINVAL; 1117 1118 if (eeprom->magic) 1119 dev_addr = eeprom->magic; 1120 1121 return hw->aq_fw_ops->get_eeprom(hw, dev_addr, eeprom->data, 1122 eeprom->length, eeprom->offset); 1123 } 1124 1125 int atl_dev_set_eeprom(struct rte_eth_dev *dev, 1126 struct rte_dev_eeprom_info *eeprom) 1127 { 1128 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1129 uint32_t dev_addr = SMBUS_DEVICE_ID; 1130 1131 if (hw->aq_fw_ops->set_eeprom == NULL) 1132 return -ENOTSUP; 1133 1134 if (eeprom->length != SFP_EEPROM_SIZE || eeprom->data == NULL) 1135 return -EINVAL; 1136 1137 if (eeprom->magic) 1138 dev_addr = eeprom->magic; 1139 1140 return hw->aq_fw_ops->set_eeprom(hw, dev_addr, 1141 eeprom->data, eeprom->length); 1142 } 1143 1144 static int 1145 atl_dev_get_regs(struct rte_eth_dev *dev, struct rte_dev_reg_info *regs) 1146 { 1147 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1148 u32 mif_id; 1149 int err; 1150 1151 if (regs->data == NULL) { 1152 regs->length = hw_atl_utils_hw_get_reg_length(); 1153 regs->width = sizeof(u32); 1154 return 0; 1155 } 1156 1157 /* Only full register dump is supported */ 1158 if (regs->length && regs->length != hw_atl_utils_hw_get_reg_length()) 1159 return -ENOTSUP; 1160 1161 err = hw_atl_utils_hw_get_regs(hw, regs->data); 1162 1163 /* Device version */ 1164 mif_id = hw_atl_reg_glb_mif_id_get(hw); 1165 regs->version = mif_id & 0xFFU; 1166 1167 return err; 1168 } 1169 1170 static int 1171 atl_flow_ctrl_get(struct rte_eth_dev *dev, struct rte_eth_fc_conf *fc_conf) 1172 { 1173 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1174 1175 if (hw->aq_nic_cfg->flow_control == AQ_NIC_FC_OFF) 1176 fc_conf->mode = RTE_FC_NONE; 1177 else if (hw->aq_nic_cfg->flow_control & (AQ_NIC_FC_RX | AQ_NIC_FC_TX)) 1178 fc_conf->mode = RTE_FC_FULL; 1179 else if (hw->aq_nic_cfg->flow_control & AQ_NIC_FC_RX) 1180 fc_conf->mode = RTE_FC_RX_PAUSE; 1181 else if (hw->aq_nic_cfg->flow_control & AQ_NIC_FC_RX) 1182 fc_conf->mode = RTE_FC_TX_PAUSE; 1183 1184 return 0; 1185 } 1186 1187 static int 1188 atl_flow_ctrl_set(struct rte_eth_dev *dev, struct rte_eth_fc_conf *fc_conf) 1189 { 1190 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1191 uint32_t old_flow_control = hw->aq_nic_cfg->flow_control; 1192 1193 1194 if (hw->aq_fw_ops->set_flow_control == NULL) 1195 return -ENOTSUP; 1196 1197 if (fc_conf->mode == RTE_FC_NONE) 1198 hw->aq_nic_cfg->flow_control = AQ_NIC_FC_OFF; 1199 else if (fc_conf->mode == RTE_FC_RX_PAUSE) 1200 hw->aq_nic_cfg->flow_control = AQ_NIC_FC_RX; 1201 else if (fc_conf->mode == RTE_FC_TX_PAUSE) 1202 hw->aq_nic_cfg->flow_control = AQ_NIC_FC_TX; 1203 else if (fc_conf->mode == RTE_FC_FULL) 1204 hw->aq_nic_cfg->flow_control = (AQ_NIC_FC_RX | AQ_NIC_FC_TX); 1205 1206 if (old_flow_control != hw->aq_nic_cfg->flow_control) 1207 return hw->aq_fw_ops->set_flow_control(hw); 1208 1209 return 0; 1210 } 1211 1212 static int 1213 atl_update_mac_addr(struct rte_eth_dev *dev, uint32_t index, 1214 u8 *mac_addr, bool enable) 1215 { 1216 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1217 unsigned int h = 0U; 1218 unsigned int l = 0U; 1219 int err; 1220 1221 if (mac_addr) { 1222 h = (mac_addr[0] << 8) | (mac_addr[1]); 1223 l = (mac_addr[2] << 24) | (mac_addr[3] << 16) | 1224 (mac_addr[4] << 8) | mac_addr[5]; 1225 } 1226 1227 hw_atl_rpfl2_uc_flr_en_set(hw, 0U, index); 1228 hw_atl_rpfl2unicast_dest_addresslsw_set(hw, l, index); 1229 hw_atl_rpfl2unicast_dest_addressmsw_set(hw, h, index); 1230 1231 if (enable) 1232 hw_atl_rpfl2_uc_flr_en_set(hw, 1U, index); 1233 1234 err = aq_hw_err_from_flags(hw); 1235 1236 return err; 1237 } 1238 1239 static int 1240 atl_add_mac_addr(struct rte_eth_dev *dev, struct ether_addr *mac_addr, 1241 uint32_t index __rte_unused, uint32_t pool __rte_unused) 1242 { 1243 if (is_zero_ether_addr(mac_addr)) { 1244 PMD_DRV_LOG(ERR, "Invalid Ethernet Address"); 1245 return -EINVAL; 1246 } 1247 1248 return atl_update_mac_addr(dev, index, (u8 *)mac_addr, true); 1249 } 1250 1251 static void 1252 atl_remove_mac_addr(struct rte_eth_dev *dev, uint32_t index) 1253 { 1254 atl_update_mac_addr(dev, index, NULL, false); 1255 } 1256 1257 static int 1258 atl_set_default_mac_addr(struct rte_eth_dev *dev, struct ether_addr *addr) 1259 { 1260 atl_remove_mac_addr(dev, 0); 1261 atl_add_mac_addr(dev, addr, 0, 0); 1262 return 0; 1263 } 1264 1265 static int 1266 atl_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu) 1267 { 1268 struct rte_eth_dev_info dev_info; 1269 uint32_t frame_size = mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 1270 1271 atl_dev_info_get(dev, &dev_info); 1272 1273 if ((mtu < ETHER_MIN_MTU) || (frame_size > dev_info.max_rx_pktlen)) 1274 return -EINVAL; 1275 1276 /* update max frame size */ 1277 dev->data->dev_conf.rxmode.max_rx_pkt_len = frame_size; 1278 1279 return 0; 1280 } 1281 1282 static int 1283 atl_vlan_filter_set(struct rte_eth_dev *dev, uint16_t vlan_id, int on) 1284 { 1285 struct aq_hw_cfg_s *cfg = 1286 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private); 1287 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1288 int err = 0; 1289 int i = 0; 1290 1291 PMD_INIT_FUNC_TRACE(); 1292 1293 for (i = 0; i < HW_ATL_B0_MAX_VLAN_IDS; i++) { 1294 if (cfg->vlan_filter[i] == vlan_id) { 1295 if (!on) { 1296 /* Disable VLAN filter. */ 1297 hw_atl_rpf_vlan_flr_en_set(hw, 0U, i); 1298 1299 /* Clear VLAN filter entry */ 1300 cfg->vlan_filter[i] = 0; 1301 } 1302 break; 1303 } 1304 } 1305 1306 /* VLAN_ID was not found. So, nothing to delete. */ 1307 if (i == HW_ATL_B0_MAX_VLAN_IDS && !on) 1308 goto exit; 1309 1310 /* VLAN_ID already exist, or already removed above. Nothing to do. */ 1311 if (i != HW_ATL_B0_MAX_VLAN_IDS) 1312 goto exit; 1313 1314 /* Try to found free VLAN filter to add new VLAN_ID */ 1315 for (i = 0; i < HW_ATL_B0_MAX_VLAN_IDS; i++) { 1316 if (cfg->vlan_filter[i] == 0) 1317 break; 1318 } 1319 1320 if (i == HW_ATL_B0_MAX_VLAN_IDS) { 1321 /* We have no free VLAN filter to add new VLAN_ID*/ 1322 err = -ENOMEM; 1323 goto exit; 1324 } 1325 1326 cfg->vlan_filter[i] = vlan_id; 1327 hw_atl_rpf_vlan_flr_act_set(hw, 1U, i); 1328 hw_atl_rpf_vlan_id_flr_set(hw, vlan_id, i); 1329 hw_atl_rpf_vlan_flr_en_set(hw, 1U, i); 1330 1331 exit: 1332 /* Enable VLAN promisc mode if vlan_filter empty */ 1333 for (i = 0; i < HW_ATL_B0_MAX_VLAN_IDS; i++) { 1334 if (cfg->vlan_filter[i] != 0) 1335 break; 1336 } 1337 1338 hw_atl_rpf_vlan_prom_mode_en_set(hw, i == HW_ATL_B0_MAX_VLAN_IDS); 1339 1340 return err; 1341 } 1342 1343 static int 1344 atl_enable_vlan_filter(struct rte_eth_dev *dev, int en) 1345 { 1346 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1347 struct aq_hw_cfg_s *cfg = 1348 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private); 1349 int i; 1350 1351 PMD_INIT_FUNC_TRACE(); 1352 1353 for (i = 0; i < HW_ATL_B0_MAX_VLAN_IDS; i++) { 1354 if (cfg->vlan_filter[i]) 1355 hw_atl_rpf_vlan_flr_en_set(hw, en, i); 1356 } 1357 return 0; 1358 } 1359 1360 static int 1361 atl_vlan_offload_set(struct rte_eth_dev *dev, int mask) 1362 { 1363 struct aq_hw_cfg_s *cfg = 1364 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private); 1365 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1366 int ret = 0; 1367 int i; 1368 1369 PMD_INIT_FUNC_TRACE(); 1370 1371 ret = atl_enable_vlan_filter(dev, mask & ETH_VLAN_FILTER_MASK); 1372 1373 cfg->vlan_strip = !!(mask & ETH_VLAN_STRIP_MASK); 1374 1375 for (i = 0; i < dev->data->nb_rx_queues; i++) 1376 hw_atl_rpo_rx_desc_vlan_stripping_set(hw, cfg->vlan_strip, i); 1377 1378 if (mask & ETH_VLAN_EXTEND_MASK) 1379 ret = -ENOTSUP; 1380 1381 return ret; 1382 } 1383 1384 static int 1385 atl_vlan_tpid_set(struct rte_eth_dev *dev, enum rte_vlan_type vlan_type, 1386 uint16_t tpid) 1387 { 1388 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1389 int err = 0; 1390 1391 PMD_INIT_FUNC_TRACE(); 1392 1393 switch (vlan_type) { 1394 case ETH_VLAN_TYPE_INNER: 1395 hw_atl_rpf_vlan_inner_etht_set(hw, tpid); 1396 break; 1397 case ETH_VLAN_TYPE_OUTER: 1398 hw_atl_rpf_vlan_outer_etht_set(hw, tpid); 1399 break; 1400 default: 1401 PMD_DRV_LOG(ERR, "Unsupported VLAN type"); 1402 err = -ENOTSUP; 1403 } 1404 1405 return err; 1406 } 1407 1408 static void 1409 atl_vlan_strip_queue_set(struct rte_eth_dev *dev, uint16_t queue_id, int on) 1410 { 1411 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1412 1413 PMD_INIT_FUNC_TRACE(); 1414 1415 if (queue_id > dev->data->nb_rx_queues) { 1416 PMD_DRV_LOG(ERR, "Invalid queue id"); 1417 return; 1418 } 1419 1420 hw_atl_rpo_rx_desc_vlan_stripping_set(hw, on, queue_id); 1421 } 1422 1423 static int 1424 atl_dev_set_mc_addr_list(struct rte_eth_dev *dev, 1425 struct ether_addr *mc_addr_set, 1426 uint32_t nb_mc_addr) 1427 { 1428 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1429 u32 i; 1430 1431 if (nb_mc_addr > AQ_HW_MULTICAST_ADDRESS_MAX - HW_ATL_B0_MAC_MIN) 1432 return -EINVAL; 1433 1434 /* Update whole uc filters table */ 1435 for (i = 0; i < AQ_HW_MULTICAST_ADDRESS_MAX - HW_ATL_B0_MAC_MIN; i++) { 1436 u8 *mac_addr = NULL; 1437 u32 l = 0, h = 0; 1438 1439 if (i < nb_mc_addr) { 1440 mac_addr = mc_addr_set[i].addr_bytes; 1441 l = (mac_addr[2] << 24) | (mac_addr[3] << 16) | 1442 (mac_addr[4] << 8) | mac_addr[5]; 1443 h = (mac_addr[0] << 8) | mac_addr[1]; 1444 } 1445 1446 hw_atl_rpfl2_uc_flr_en_set(hw, 0U, HW_ATL_B0_MAC_MIN + i); 1447 hw_atl_rpfl2unicast_dest_addresslsw_set(hw, l, 1448 HW_ATL_B0_MAC_MIN + i); 1449 hw_atl_rpfl2unicast_dest_addressmsw_set(hw, h, 1450 HW_ATL_B0_MAC_MIN + i); 1451 hw_atl_rpfl2_uc_flr_en_set(hw, !!mac_addr, 1452 HW_ATL_B0_MAC_MIN + i); 1453 } 1454 1455 return 0; 1456 } 1457 1458 static int 1459 atl_reta_update(struct rte_eth_dev *dev, 1460 struct rte_eth_rss_reta_entry64 *reta_conf, 1461 uint16_t reta_size) 1462 { 1463 int i; 1464 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1465 struct aq_hw_cfg_s *cf = ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private); 1466 1467 for (i = 0; i < reta_size && i < cf->aq_rss.indirection_table_size; i++) 1468 cf->aq_rss.indirection_table[i] = min(reta_conf->reta[i], 1469 dev->data->nb_rx_queues - 1); 1470 1471 hw_atl_b0_hw_rss_set(hw, &cf->aq_rss); 1472 return 0; 1473 } 1474 1475 static int 1476 atl_reta_query(struct rte_eth_dev *dev, 1477 struct rte_eth_rss_reta_entry64 *reta_conf, 1478 uint16_t reta_size) 1479 { 1480 int i; 1481 struct aq_hw_cfg_s *cf = ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private); 1482 1483 for (i = 0; i < reta_size && i < cf->aq_rss.indirection_table_size; i++) 1484 reta_conf->reta[i] = cf->aq_rss.indirection_table[i]; 1485 reta_conf->mask = ~0U; 1486 return 0; 1487 } 1488 1489 static int 1490 atl_rss_hash_update(struct rte_eth_dev *dev, 1491 struct rte_eth_rss_conf *rss_conf) 1492 { 1493 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private); 1494 struct aq_hw_cfg_s *cfg = 1495 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private); 1496 static u8 def_rss_key[40] = { 1497 0x1e, 0xad, 0x71, 0x87, 0x65, 0xfc, 0x26, 0x7d, 1498 0x0d, 0x45, 0x67, 0x74, 0xcd, 0x06, 0x1a, 0x18, 1499 0xb6, 0xc1, 0xf0, 0xc7, 0xbb, 0x18, 0xbe, 0xf8, 1500 0x19, 0x13, 0x4b, 0xa9, 0xd0, 0x3e, 0xfe, 0x70, 1501 0x25, 0x03, 0xab, 0x50, 0x6a, 0x8b, 0x82, 0x0c 1502 }; 1503 1504 cfg->is_rss = !!rss_conf->rss_hf; 1505 if (rss_conf->rss_key) { 1506 memcpy(cfg->aq_rss.hash_secret_key, rss_conf->rss_key, 1507 rss_conf->rss_key_len); 1508 cfg->aq_rss.hash_secret_key_size = rss_conf->rss_key_len; 1509 } else { 1510 memcpy(cfg->aq_rss.hash_secret_key, def_rss_key, 1511 sizeof(def_rss_key)); 1512 cfg->aq_rss.hash_secret_key_size = sizeof(def_rss_key); 1513 } 1514 1515 hw_atl_b0_hw_rss_set(hw, &cfg->aq_rss); 1516 hw_atl_b0_hw_rss_hash_set(hw, &cfg->aq_rss); 1517 return 0; 1518 } 1519 1520 static int 1521 atl_rss_hash_conf_get(struct rte_eth_dev *dev, 1522 struct rte_eth_rss_conf *rss_conf) 1523 { 1524 struct aq_hw_cfg_s *cfg = 1525 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private); 1526 1527 rss_conf->rss_hf = cfg->is_rss ? ATL_RSS_OFFLOAD_ALL : 0; 1528 if (rss_conf->rss_key) { 1529 rss_conf->rss_key_len = cfg->aq_rss.hash_secret_key_size; 1530 memcpy(rss_conf->rss_key, cfg->aq_rss.hash_secret_key, 1531 rss_conf->rss_key_len); 1532 } 1533 1534 return 0; 1535 } 1536 1537 RTE_PMD_REGISTER_PCI(net_atlantic, rte_atl_pmd); 1538 RTE_PMD_REGISTER_PCI_TABLE(net_atlantic, pci_id_atl_map); 1539 RTE_PMD_REGISTER_KMOD_DEP(net_atlantic, "* igb_uio | uio_pci_generic"); 1540 1541 RTE_INIT(atl_init_log) 1542 { 1543 atl_logtype_init = rte_log_register("pmd.net.atlantic.init"); 1544 if (atl_logtype_init >= 0) 1545 rte_log_set_level(atl_logtype_init, RTE_LOG_NOTICE); 1546 atl_logtype_driver = rte_log_register("pmd.net.atlantic.driver"); 1547 if (atl_logtype_driver >= 0) 1548 rte_log_set_level(atl_logtype_driver, RTE_LOG_NOTICE); 1549 } 1550 1551