drivers/net/atlantic/atl_ethdev.c

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