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 int  atl_dev_link_update(struct rte_eth_dev *dev, int wait);
  26
  27 static int atl_dev_xstats_get_names(struct rte_eth_dev *dev __rte_unused,
  28                                     struct rte_eth_xstat_name *xstats_names,
  29                                     unsigned int size);
  30
  31 static int atl_dev_stats_get(struct rte_eth_dev *dev,
  32                                 struct rte_eth_stats *stats);
  33
  34 static int atl_dev_xstats_get(struct rte_eth_dev *dev,
  35                               struct rte_eth_xstat *stats, unsigned int n);
  36
  37 static void atl_dev_stats_reset(struct rte_eth_dev *dev);
  38
  39 static int atl_fw_version_get(struct rte_eth_dev *dev, char *fw_version,
  40                               size_t fw_size);
  41
  42 static void atl_dev_info_get(struct rte_eth_dev *dev,
  43                                struct rte_eth_dev_info *dev_info);
  44
  45 static const uint32_t *atl_dev_supported_ptypes_get(struct rte_eth_dev *dev);
  46
  47 static void atl_dev_link_status_print(struct rte_eth_dev *dev);
  48
  49 /* Interrupts */
  50 static int atl_dev_rxq_interrupt_setup(struct rte_eth_dev *dev);
  51 static int atl_dev_lsc_interrupt_setup(struct rte_eth_dev *dev, uint8_t on);
  52 static int atl_dev_interrupt_get_status(struct rte_eth_dev *dev);
  53 static int atl_dev_interrupt_action(struct rte_eth_dev *dev,
  54                                     struct rte_intr_handle *handle);
  55 static void atl_dev_interrupt_handler(void *param);
  56
  57 static int eth_atl_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
  58         struct rte_pci_device *pci_dev);
  59 static int eth_atl_pci_remove(struct rte_pci_device *pci_dev);
  60
  61 static void atl_dev_info_get(struct rte_eth_dev *dev,
  62                                 struct rte_eth_dev_info *dev_info);
  63
  64 int atl_logtype_init;
  65 int atl_logtype_driver;
  66
  67 /*
  68  * The set of PCI devices this driver supports
  69  */
  70 static const struct rte_pci_id pci_id_atl_map[] = {
  71         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_0001) },
  72         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_D100) },
  73         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_D107) },
  74         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_D108) },
  75         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_D109) },
  76
  77         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC100) },
  78         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC107) },
  79         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC108) },
  80         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC109) },
  81         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC111) },
  82         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC112) },
  83
  84         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC100S) },
  85         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC107S) },
  86         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC108S) },
  87         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC109S) },
  88         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC111S) },
  89         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC112S) },
  90
  91         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC111E) },
  92         { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC112E) },
  93         { .vendor_id = 0, /* sentinel */ },
  94 };
  95
  96 static struct rte_pci_driver rte_atl_pmd = {
  97         .id_table = pci_id_atl_map,
  98         .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_INTR_LSC |
  99                      RTE_PCI_DRV_IOVA_AS_VA,
 100         .probe = eth_atl_pci_probe,
 101         .remove = eth_atl_pci_remove,
 102 };
 103
 104 #define ATL_RX_OFFLOADS (DEV_RX_OFFLOAD_VLAN_STRIP \
 105                         | DEV_RX_OFFLOAD_IPV4_CKSUM \
 106                         | DEV_RX_OFFLOAD_UDP_CKSUM \
 107                         | DEV_RX_OFFLOAD_TCP_CKSUM \
 108                         | DEV_RX_OFFLOAD_JUMBO_FRAME)
 109
 110 #define ATL_TX_OFFLOADS (DEV_TX_OFFLOAD_VLAN_INSERT \
 111                         | DEV_TX_OFFLOAD_IPV4_CKSUM \
 112                         | DEV_TX_OFFLOAD_UDP_CKSUM \
 113                         | DEV_TX_OFFLOAD_TCP_CKSUM \
 114                         | DEV_TX_OFFLOAD_TCP_TSO \
 115                         | DEV_TX_OFFLOAD_MULTI_SEGS)
 116
 117 static const struct rte_eth_desc_lim rx_desc_lim = {
 118         .nb_max = ATL_MAX_RING_DESC,
 119         .nb_min = ATL_MIN_RING_DESC,
 120         .nb_align = ATL_RXD_ALIGN,
 121 };
 122
 123 static const struct rte_eth_desc_lim tx_desc_lim = {
 124         .nb_max = ATL_MAX_RING_DESC,
 125         .nb_min = ATL_MIN_RING_DESC,
 126         .nb_align = ATL_TXD_ALIGN,
 127         .nb_seg_max = ATL_TX_MAX_SEG,
 128         .nb_mtu_seg_max = ATL_TX_MAX_SEG,
 129 };
 130
 131 #define ATL_XSTATS_FIELD(name) { \
 132         #name, \
 133         offsetof(struct aq_stats_s, name) \
 134 }
 135
 136 struct atl_xstats_tbl_s {
 137         const char *name;
 138         unsigned int offset;
 139 };
 140
 141 static struct atl_xstats_tbl_s atl_xstats_tbl[] = {
 142         ATL_XSTATS_FIELD(uprc),
 143         ATL_XSTATS_FIELD(mprc),
 144         ATL_XSTATS_FIELD(bprc),
 145         ATL_XSTATS_FIELD(erpt),
 146         ATL_XSTATS_FIELD(uptc),
 147         ATL_XSTATS_FIELD(mptc),
 148         ATL_XSTATS_FIELD(bptc),
 149         ATL_XSTATS_FIELD(erpr),
 150         ATL_XSTATS_FIELD(ubrc),
 151         ATL_XSTATS_FIELD(ubtc),
 152         ATL_XSTATS_FIELD(mbrc),
 153         ATL_XSTATS_FIELD(mbtc),
 154         ATL_XSTATS_FIELD(bbrc),
 155         ATL_XSTATS_FIELD(bbtc),
 156 };
 157
 158 static const struct eth_dev_ops atl_eth_dev_ops = {
 159         .dev_configure        = atl_dev_configure,
 160         .dev_start            = atl_dev_start,
 161         .dev_stop             = atl_dev_stop,
 162         .dev_set_link_up      = atl_dev_set_link_up,
 163         .dev_set_link_down    = atl_dev_set_link_down,
 164         .dev_close            = atl_dev_close,
 165         .dev_reset            = atl_dev_reset,
 166
 167         /* Link */
 168         .link_update          = atl_dev_link_update,
 169
 170         /* Stats */
 171         .stats_get            = atl_dev_stats_get,
 172         .xstats_get           = atl_dev_xstats_get,
 173         .xstats_get_names     = atl_dev_xstats_get_names,
 174         .stats_reset          = atl_dev_stats_reset,
 175         .xstats_reset         = atl_dev_stats_reset,
 176
 177         .fw_version_get       = atl_fw_version_get,
 178         .dev_infos_get        = atl_dev_info_get,
 179         .dev_supported_ptypes_get = atl_dev_supported_ptypes_get,
 180
 181         /* Queue Control */
 182         .rx_queue_start       = atl_rx_queue_start,
 183         .rx_queue_stop        = atl_rx_queue_stop,
 184         .rx_queue_setup       = atl_rx_queue_setup,
 185         .rx_queue_release     = atl_rx_queue_release,
 186
 187         .tx_queue_start       = atl_tx_queue_start,
 188         .tx_queue_stop        = atl_tx_queue_stop,
 189         .tx_queue_setup       = atl_tx_queue_setup,
 190         .tx_queue_release     = atl_tx_queue_release,
 191
 192         .rx_queue_intr_enable = atl_dev_rx_queue_intr_enable,
 193         .rx_queue_intr_disable = atl_dev_rx_queue_intr_disable,
 194 };
 195
 196 static inline int32_t
 197 atl_reset_hw(struct aq_hw_s *hw)
 198 {
 199         return hw_atl_b0_hw_reset(hw);
 200 }
 201
 202 static inline void
 203 atl_enable_intr(struct rte_eth_dev *dev)
 204 {
 205         struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 206
 207         hw_atl_itr_irq_msk_setlsw_set(hw, 0xffffffff);
 208 }
 209
 210 static void
 211 atl_disable_intr(struct aq_hw_s *hw)
 212 {
 213         PMD_INIT_FUNC_TRACE();
 214         hw_atl_itr_irq_msk_clearlsw_set(hw, 0xffffffff);
 215 }
 216
 217 static int
 218 eth_atl_dev_init(struct rte_eth_dev *eth_dev)
 219 {
 220         struct atl_adapter *adapter =
 221                 (struct atl_adapter *)eth_dev->data->dev_private;
 222         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 223         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 224         struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
 225         int err = 0;
 226
 227         PMD_INIT_FUNC_TRACE();
 228
 229         eth_dev->dev_ops = &atl_eth_dev_ops;
 230         eth_dev->rx_pkt_burst = &atl_recv_pkts;
 231         eth_dev->tx_pkt_burst = &atl_xmit_pkts;
 232         eth_dev->tx_pkt_prepare = &atl_prep_pkts;
 233
 234         /* For secondary processes, the primary process has done all the work */
 235         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
 236                 return 0;
 237
 238         /* Vendor and Device ID need to be set before init of shared code */
 239         hw->device_id = pci_dev->id.device_id;
 240         hw->vendor_id = pci_dev->id.vendor_id;
 241         hw->mmio = (void *)pci_dev->mem_resource[0].addr;
 242
 243         /* Hardware configuration - hardcode */
 244         adapter->hw_cfg.is_lro = false;
 245         adapter->hw_cfg.wol = false;
 246         adapter->hw_cfg.link_speed_msk = AQ_NIC_RATE_10G |
 247                           AQ_NIC_RATE_5G |
 248                           AQ_NIC_RATE_2G5 |
 249                           AQ_NIC_RATE_1G |
 250                           AQ_NIC_RATE_100M;
 251
 252         hw->aq_nic_cfg = &adapter->hw_cfg;
 253
 254         /* disable interrupt */
 255         atl_disable_intr(hw);
 256
 257         /* Allocate memory for storing MAC addresses */
 258         eth_dev->data->mac_addrs = rte_zmalloc("atlantic", ETHER_ADDR_LEN, 0);
 259         if (eth_dev->data->mac_addrs == NULL) {
 260                 PMD_INIT_LOG(ERR, "MAC Malloc failed");
 261                 return -ENOMEM;
 262         }
 263
 264         err = hw_atl_utils_initfw(hw, &hw->aq_fw_ops);
 265         if (err)
 266                 return err;
 267
 268         /* Copy the permanent MAC address */
 269         if (hw->aq_fw_ops->get_mac_permanent(hw,
 270                         eth_dev->data->mac_addrs->addr_bytes) != 0)
 271                 return -EINVAL;
 272
 273         /* Reset the hw statistics */
 274         atl_dev_stats_reset(eth_dev);
 275
 276         rte_intr_callback_register(intr_handle,
 277                                    atl_dev_interrupt_handler, eth_dev);
 278
 279         /* enable uio/vfio intr/eventfd mapping */
 280         rte_intr_enable(intr_handle);
 281
 282         /* enable support intr */
 283         atl_enable_intr(eth_dev);
 284
 285         return err;
 286 }
 287
 288 static int
 289 eth_atl_dev_uninit(struct rte_eth_dev *eth_dev)
 290 {
 291         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 292         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 293         struct aq_hw_s *hw;
 294
 295         PMD_INIT_FUNC_TRACE();
 296
 297         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
 298                 return -EPERM;
 299
 300         hw = ATL_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
 301
 302         if (hw->adapter_stopped == 0)
 303                 atl_dev_close(eth_dev);
 304
 305         eth_dev->dev_ops = NULL;
 306         eth_dev->rx_pkt_burst = NULL;
 307         eth_dev->tx_pkt_burst = NULL;
 308
 309         /* disable uio intr before callback unregister */
 310         rte_intr_disable(intr_handle);
 311         rte_intr_callback_unregister(intr_handle,
 312                                      atl_dev_interrupt_handler, eth_dev);
 313
 314         rte_free(eth_dev->data->mac_addrs);
 315         eth_dev->data->mac_addrs = NULL;
 316
 317         return 0;
 318 }
 319
 320 static int
 321 eth_atl_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
 322         struct rte_pci_device *pci_dev)
 323 {
 324         return rte_eth_dev_pci_generic_probe(pci_dev,
 325                 sizeof(struct atl_adapter), eth_atl_dev_init);
 326 }
 327
 328 static int
 329 eth_atl_pci_remove(struct rte_pci_device *pci_dev)
 330 {
 331         return rte_eth_dev_pci_generic_remove(pci_dev, eth_atl_dev_uninit);
 332 }
 333
 334 static int
 335 atl_dev_configure(struct rte_eth_dev *dev)
 336 {
 337         struct atl_interrupt *intr =
 338                 ATL_DEV_PRIVATE_TO_INTR(dev->data->dev_private);
 339
 340         PMD_INIT_FUNC_TRACE();
 341
 342         /* set flag to update link status after init */
 343         intr->flags |= ATL_FLAG_NEED_LINK_UPDATE;
 344
 345         return 0;
 346 }
 347
 348 /*
 349  * Configure device link speed and setup link.
 350  * It returns 0 on success.
 351  */
 352 static int
 353 atl_dev_start(struct rte_eth_dev *dev)
 354 {
 355         struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 356         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
 357         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 358         uint32_t intr_vector = 0;
 359         uint32_t *link_speeds;
 360         uint32_t speed = 0;
 361         int status;
 362         int err;
 363
 364         PMD_INIT_FUNC_TRACE();
 365
 366         /* set adapter started */
 367         hw->adapter_stopped = 0;
 368
 369         if (dev->data->dev_conf.link_speeds & ETH_LINK_SPEED_FIXED) {
 370                 PMD_INIT_LOG(ERR,
 371                 "Invalid link_speeds for port %u, fix speed not supported",
 372                                 dev->data->port_id);
 373                 return -EINVAL;
 374         }
 375
 376         /* disable uio/vfio intr/eventfd mapping */
 377         rte_intr_disable(intr_handle);
 378
 379         /* reinitialize adapter
 380          * this calls reset and start
 381          */
 382         status = atl_reset_hw(hw);
 383         if (status != 0)
 384                 return -EIO;
 385
 386         err = hw_atl_b0_hw_init(hw, dev->data->mac_addrs->addr_bytes);
 387
 388         hw_atl_b0_hw_start(hw);
 389         /* check and configure queue intr-vector mapping */
 390         if ((rte_intr_cap_multiple(intr_handle) ||
 391             !RTE_ETH_DEV_SRIOV(dev).active) &&
 392             dev->data->dev_conf.intr_conf.rxq != 0) {
 393                 intr_vector = dev->data->nb_rx_queues;
 394                 if (intr_vector > ATL_MAX_INTR_QUEUE_NUM) {
 395                         PMD_INIT_LOG(ERR, "At most %d intr queues supported",
 396                                         ATL_MAX_INTR_QUEUE_NUM);
 397                         return -ENOTSUP;
 398                 }
 399                 if (rte_intr_efd_enable(intr_handle, intr_vector)) {
 400                         PMD_INIT_LOG(ERR, "rte_intr_efd_enable failed");
 401                         return -1;
 402                 }
 403         }
 404
 405         if (rte_intr_dp_is_en(intr_handle) && !intr_handle->intr_vec) {
 406                 intr_handle->intr_vec = rte_zmalloc("intr_vec",
 407                                     dev->data->nb_rx_queues * sizeof(int), 0);
 408                 if (intr_handle->intr_vec == NULL) {
 409                         PMD_INIT_LOG(ERR, "Failed to allocate %d rx_queues"
 410                                      " intr_vec", dev->data->nb_rx_queues);
 411                         return -ENOMEM;
 412                 }
 413         }
 414
 415         /* initialize transmission unit */
 416         atl_tx_init(dev);
 417
 418         /* This can fail when allocating mbufs for descriptor rings */
 419         err = atl_rx_init(dev);
 420         if (err) {
 421                 PMD_INIT_LOG(ERR, "Unable to initialize RX hardware");
 422                 goto error;
 423         }
 424
 425         PMD_INIT_LOG(DEBUG, "FW version: %u.%u.%u",
 426                 hw->fw_ver_actual >> 24,
 427                 (hw->fw_ver_actual >> 16) & 0xFF,
 428                 hw->fw_ver_actual & 0xFFFF);
 429         PMD_INIT_LOG(DEBUG, "Driver version: %s", ATL_PMD_DRIVER_VERSION);
 430
 431         err = atl_start_queues(dev);
 432         if (err < 0) {
 433                 PMD_INIT_LOG(ERR, "Unable to start rxtx queues");
 434                 goto error;
 435         }
 436
 437         err = hw->aq_fw_ops->update_link_status(hw);
 438
 439         if (err)
 440                 goto error;
 441
 442         dev->data->dev_link.link_status = hw->aq_link_status.mbps != 0;
 443
 444         link_speeds = &dev->data->dev_conf.link_speeds;
 445
 446         speed = 0x0;
 447
 448         if (*link_speeds == ETH_LINK_SPEED_AUTONEG) {
 449                 speed = hw->aq_nic_cfg->link_speed_msk;
 450         } else {
 451                 if (*link_speeds & ETH_LINK_SPEED_10G)
 452                         speed |= AQ_NIC_RATE_10G;
 453                 if (*link_speeds & ETH_LINK_SPEED_5G)
 454                         speed |= AQ_NIC_RATE_5G;
 455                 if (*link_speeds & ETH_LINK_SPEED_1G)
 456                         speed |= AQ_NIC_RATE_1G;
 457                 if (*link_speeds & ETH_LINK_SPEED_2_5G)
 458                         speed |=  AQ_NIC_RATE_2G5;
 459                 if (*link_speeds & ETH_LINK_SPEED_100M)
 460                         speed |= AQ_NIC_RATE_100M;
 461         }
 462
 463         err = hw->aq_fw_ops->set_link_speed(hw, speed);
 464         if (err)
 465                 goto error;
 466
 467         if (rte_intr_allow_others(intr_handle)) {
 468                 /* check if lsc interrupt is enabled */
 469                 if (dev->data->dev_conf.intr_conf.lsc != 0)
 470                         atl_dev_lsc_interrupt_setup(dev, true);
 471                 else
 472                         atl_dev_lsc_interrupt_setup(dev, false);
 473         } else {
 474                 rte_intr_callback_unregister(intr_handle,
 475                                              atl_dev_interrupt_handler, dev);
 476                 if (dev->data->dev_conf.intr_conf.lsc != 0)
 477                         PMD_INIT_LOG(INFO, "lsc won't enable because of"
 478                                      " no intr multiplex");
 479         }
 480
 481         /* check if rxq interrupt is enabled */
 482         if (dev->data->dev_conf.intr_conf.rxq != 0 &&
 483             rte_intr_dp_is_en(intr_handle))
 484                 atl_dev_rxq_interrupt_setup(dev);
 485
 486         /* enable uio/vfio intr/eventfd mapping */
 487         rte_intr_enable(intr_handle);
 488
 489         /* resume enabled intr since hw reset */
 490         atl_enable_intr(dev);
 491
 492         return 0;
 493
 494 error:
 495         atl_stop_queues(dev);
 496         return -EIO;
 497 }
 498
 499 /*
 500  * Stop device: disable rx and tx functions to allow for reconfiguring.
 501  */
 502 static void
 503 atl_dev_stop(struct rte_eth_dev *dev)
 504 {
 505         struct rte_eth_link link;
 506         struct aq_hw_s *hw =
 507                 ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 508         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
 509         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 510
 511         PMD_INIT_FUNC_TRACE();
 512
 513         /* disable interrupts */
 514         atl_disable_intr(hw);
 515
 516         /* reset the NIC */
 517         atl_reset_hw(hw);
 518         hw->adapter_stopped = 1;
 519
 520         atl_stop_queues(dev);
 521
 522         /* Clear stored conf */
 523         dev->data->scattered_rx = 0;
 524         dev->data->lro = 0;
 525
 526         /* Clear recorded link status */
 527         memset(&link, 0, sizeof(link));
 528         rte_eth_linkstatus_set(dev, &link);
 529
 530         if (!rte_intr_allow_others(intr_handle))
 531                 /* resume to the default handler */
 532                 rte_intr_callback_register(intr_handle,
 533                                            atl_dev_interrupt_handler,
 534                                            (void *)dev);
 535
 536         /* Clean datapath event and queue/vec mapping */
 537         rte_intr_efd_disable(intr_handle);
 538         if (intr_handle->intr_vec != NULL) {
 539                 rte_free(intr_handle->intr_vec);
 540                 intr_handle->intr_vec = NULL;
 541         }
 542 }
 543
 544 /*
 545  * Set device link up: enable tx.
 546  */
 547 static int
 548 atl_dev_set_link_up(struct rte_eth_dev *dev)
 549 {
 550         struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 551
 552         return hw->aq_fw_ops->set_link_speed(hw,
 553                         hw->aq_nic_cfg->link_speed_msk);
 554 }
 555
 556 /*
 557  * Set device link down: disable tx.
 558  */
 559 static int
 560 atl_dev_set_link_down(struct rte_eth_dev *dev)
 561 {
 562         struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 563
 564         return hw->aq_fw_ops->set_link_speed(hw, 0);
 565 }
 566
 567 /*
 568  * Reset and stop device.
 569  */
 570 static void
 571 atl_dev_close(struct rte_eth_dev *dev)
 572 {
 573         PMD_INIT_FUNC_TRACE();
 574
 575         atl_dev_stop(dev);
 576
 577         atl_free_queues(dev);
 578 }
 579
 580 static int
 581 atl_dev_reset(struct rte_eth_dev *dev)
 582 {
 583         int ret;
 584
 585         ret = eth_atl_dev_uninit(dev);
 586         if (ret)
 587                 return ret;
 588
 589         ret = eth_atl_dev_init(dev);
 590
 591         return ret;
 592 }
 593
 594
 595 static int
 596 atl_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
 597 {
 598         struct atl_adapter *adapter = ATL_DEV_TO_ADAPTER(dev);
 599         struct aq_hw_s *hw = &adapter->hw;
 600         struct atl_sw_stats *swstats = &adapter->sw_stats;
 601         unsigned int i;
 602
 603         hw->aq_fw_ops->update_stats(hw);
 604
 605         /* Fill out the rte_eth_stats statistics structure */
 606         stats->ipackets = hw->curr_stats.dma_pkt_rc;
 607         stats->ibytes = hw->curr_stats.dma_oct_rc;
 608         stats->imissed = hw->curr_stats.dpc;
 609         stats->ierrors = hw->curr_stats.erpt;
 610
 611         stats->opackets = hw->curr_stats.dma_pkt_tc;
 612         stats->obytes = hw->curr_stats.dma_oct_tc;
 613         stats->oerrors = 0;
 614
 615         stats->rx_nombuf = swstats->rx_nombuf;
 616
 617         for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS; i++) {
 618                 stats->q_ipackets[i] = swstats->q_ipackets[i];
 619                 stats->q_opackets[i] = swstats->q_opackets[i];
 620                 stats->q_ibytes[i] = swstats->q_ibytes[i];
 621                 stats->q_obytes[i] = swstats->q_obytes[i];
 622                 stats->q_errors[i] = swstats->q_errors[i];
 623         }
 624         return 0;
 625 }
 626
 627 static void
 628 atl_dev_stats_reset(struct rte_eth_dev *dev)
 629 {
 630         struct atl_adapter *adapter = ATL_DEV_TO_ADAPTER(dev);
 631         struct aq_hw_s *hw = &adapter->hw;
 632
 633         hw->aq_fw_ops->update_stats(hw);
 634
 635         /* Reset software totals */
 636         memset(&hw->curr_stats, 0, sizeof(hw->curr_stats));
 637
 638         memset(&adapter->sw_stats, 0, sizeof(adapter->sw_stats));
 639 }
 640
 641 static int
 642 atl_dev_xstats_get_names(struct rte_eth_dev *dev __rte_unused,
 643                          struct rte_eth_xstat_name *xstats_names,
 644                          unsigned int size)
 645 {
 646         unsigned int i;
 647
 648         if (!xstats_names)
 649                 return RTE_DIM(atl_xstats_tbl);
 650
 651         for (i = 0; i < size && i < RTE_DIM(atl_xstats_tbl); i++)
 652                 snprintf(xstats_names[i].name, RTE_ETH_XSTATS_NAME_SIZE, "%s",
 653                         atl_xstats_tbl[i].name);
 654
 655         return size;
 656 }
 657
 658 static int
 659 atl_dev_xstats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *stats,
 660                    unsigned int n)
 661 {
 662         struct atl_adapter *adapter = ATL_DEV_TO_ADAPTER(dev);
 663         struct aq_hw_s *hw = &adapter->hw;
 664         unsigned int i;
 665
 666         if (!stats)
 667                 return 0;
 668
 669         for (i = 0; i < n && i < RTE_DIM(atl_xstats_tbl); i++) {
 670                 stats[i].id = i;
 671                 stats[i].value = *(u64 *)((uint8_t *)&hw->curr_stats +
 672                                         atl_xstats_tbl[i].offset);
 673         }
 674
 675         return n;
 676 }
 677
 678 static int
 679 atl_fw_version_get(struct rte_eth_dev *dev, char *fw_version, size_t fw_size)
 680 {
 681         struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 682         uint32_t fw_ver = 0;
 683         unsigned int ret = 0;
 684
 685         ret = hw_atl_utils_get_fw_version(hw, &fw_ver);
 686         if (ret)
 687                 return -EIO;
 688
 689         ret = snprintf(fw_version, fw_size, "%u.%u.%u", fw_ver >> 24,
 690                        (fw_ver >> 16) & 0xFFU, fw_ver & 0xFFFFU);
 691
 692         ret += 1; /* add string null-terminator */
 693
 694         if (fw_size < ret)
 695                 return ret;
 696
 697         return 0;
 698 }
 699
 700 static void
 701 atl_dev_info_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
 702 {
 703         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
 704
 705         dev_info->max_rx_queues = AQ_HW_MAX_RX_QUEUES;
 706         dev_info->max_tx_queues = AQ_HW_MAX_TX_QUEUES;
 707
 708         dev_info->min_rx_bufsize = 1024;
 709         dev_info->max_rx_pktlen = HW_ATL_B0_MTU_JUMBO;
 710         dev_info->max_mac_addrs = HW_ATL_B0_MAC_MAX;
 711         dev_info->max_vfs = pci_dev->max_vfs;
 712
 713         dev_info->max_hash_mac_addrs = 0;
 714         dev_info->max_vmdq_pools = 0;
 715         dev_info->vmdq_queue_num = 0;
 716
 717         dev_info->rx_offload_capa = ATL_RX_OFFLOADS;
 718
 719         dev_info->tx_offload_capa = ATL_TX_OFFLOADS;
 720
 721
 722         dev_info->default_rxconf = (struct rte_eth_rxconf) {
 723                 .rx_free_thresh = ATL_DEFAULT_RX_FREE_THRESH,
 724         };
 725
 726         dev_info->default_txconf = (struct rte_eth_txconf) {
 727                 .tx_free_thresh = ATL_DEFAULT_TX_FREE_THRESH,
 728         };
 729
 730         dev_info->rx_desc_lim = rx_desc_lim;
 731         dev_info->tx_desc_lim = tx_desc_lim;
 732
 733         dev_info->speed_capa = ETH_LINK_SPEED_1G | ETH_LINK_SPEED_10G;
 734         dev_info->speed_capa |= ETH_LINK_SPEED_100M;
 735         dev_info->speed_capa |= ETH_LINK_SPEED_2_5G;
 736         dev_info->speed_capa |= ETH_LINK_SPEED_5G;
 737 }
 738
 739 static const uint32_t *
 740 atl_dev_supported_ptypes_get(struct rte_eth_dev *dev)
 741 {
 742         static const uint32_t ptypes[] = {
 743                 RTE_PTYPE_L2_ETHER,
 744                 RTE_PTYPE_L2_ETHER_ARP,
 745                 RTE_PTYPE_L2_ETHER_VLAN,
 746                 RTE_PTYPE_L3_IPV4,
 747                 RTE_PTYPE_L3_IPV6,
 748                 RTE_PTYPE_L4_TCP,
 749                 RTE_PTYPE_L4_UDP,
 750                 RTE_PTYPE_L4_SCTP,
 751                 RTE_PTYPE_L4_ICMP,
 752                 RTE_PTYPE_UNKNOWN
 753         };
 754
 755         if (dev->rx_pkt_burst == atl_recv_pkts)
 756                 return ptypes;
 757
 758         return NULL;
 759 }
 760
 761 /* return 0 means link status changed, -1 means not changed */
 762 static int
 763 atl_dev_link_update(struct rte_eth_dev *dev, int wait __rte_unused)
 764 {
 765         struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 766         struct atl_interrupt *intr =
 767                 ATL_DEV_PRIVATE_TO_INTR(dev->data->dev_private);
 768         struct rte_eth_link link, old;
 769         int err = 0;
 770
 771         link.link_status = ETH_LINK_DOWN;
 772         link.link_speed = 0;
 773         link.link_duplex = ETH_LINK_FULL_DUPLEX;
 774         link.link_autoneg = hw->is_autoneg ? ETH_LINK_AUTONEG : ETH_LINK_FIXED;
 775         memset(&old, 0, sizeof(old));
 776
 777         /* load old link status */
 778         rte_eth_linkstatus_get(dev, &old);
 779
 780         /* read current link status */
 781         err = hw->aq_fw_ops->update_link_status(hw);
 782
 783         if (err)
 784                 return 0;
 785
 786         if (hw->aq_link_status.mbps == 0) {
 787                 /* write default (down) link status */
 788                 rte_eth_linkstatus_set(dev, &link);
 789                 if (link.link_status == old.link_status)
 790                         return -1;
 791                 return 0;
 792         }
 793
 794         intr->flags &= ~ATL_FLAG_NEED_LINK_CONFIG;
 795
 796         link.link_status = ETH_LINK_UP;
 797         link.link_duplex = ETH_LINK_FULL_DUPLEX;
 798         link.link_speed = hw->aq_link_status.mbps;
 799
 800         rte_eth_linkstatus_set(dev, &link);
 801
 802         if (link.link_status == old.link_status)
 803                 return -1;
 804
 805         return 0;
 806 }
 807
 808
 809 /**
 810  * It clears the interrupt causes and enables the interrupt.
 811  * It will be called once only during nic initialized.
 812  *
 813  * @param dev
 814  *  Pointer to struct rte_eth_dev.
 815  * @param on
 816  *  Enable or Disable.
 817  *
 818  * @return
 819  *  - On success, zero.
 820  *  - On failure, a negative value.
 821  */
 822
 823 static int
 824 atl_dev_lsc_interrupt_setup(struct rte_eth_dev *dev, uint8_t on __rte_unused)
 825 {
 826         atl_dev_link_status_print(dev);
 827         return 0;
 828 }
 829
 830 static int
 831 atl_dev_rxq_interrupt_setup(struct rte_eth_dev *dev __rte_unused)
 832 {
 833         return 0;
 834 }
 835
 836
 837 static int
 838 atl_dev_interrupt_get_status(struct rte_eth_dev *dev)
 839 {
 840         struct atl_interrupt *intr =
 841                 ATL_DEV_PRIVATE_TO_INTR(dev->data->dev_private);
 842         struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 843         u64 cause = 0;
 844
 845         hw_atl_b0_hw_irq_read(hw, &cause);
 846
 847         atl_disable_intr(hw);
 848         intr->flags = cause & BIT(ATL_IRQ_CAUSE_LINK) ?
 849                         ATL_FLAG_NEED_LINK_UPDATE : 0;
 850
 851         return 0;
 852 }
 853
 854 /**
 855  * It gets and then prints the link status.
 856  *
 857  * @param dev
 858  *  Pointer to struct rte_eth_dev.
 859  *
 860  * @return
 861  *  - On success, zero.
 862  *  - On failure, a negative value.
 863  */
 864 static void
 865 atl_dev_link_status_print(struct rte_eth_dev *dev)
 866 {
 867         struct rte_eth_link link;
 868
 869         memset(&link, 0, sizeof(link));
 870         rte_eth_linkstatus_get(dev, &link);
 871         if (link.link_status) {
 872                 PMD_DRV_LOG(INFO, "Port %d: Link Up - speed %u Mbps - %s",
 873                                         (int)(dev->data->port_id),
 874                                         (unsigned int)link.link_speed,
 875                         link.link_duplex == ETH_LINK_FULL_DUPLEX ?
 876                                         "full-duplex" : "half-duplex");
 877         } else {
 878                 PMD_DRV_LOG(INFO, " Port %d: Link Down",
 879                                 (int)(dev->data->port_id));
 880         }
 881
 882
 883 #ifdef DEBUG
 884 {
 885         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
 886
 887         PMD_DRV_LOG(DEBUG, "PCI Address: " PCI_PRI_FMT,
 888                                 pci_dev->addr.domain,
 889                                 pci_dev->addr.bus,
 890                                 pci_dev->addr.devid,
 891                                 pci_dev->addr.function);
 892 }
 893 #endif
 894
 895         PMD_DRV_LOG(INFO, "Link speed:%d", link.link_speed);
 896 }
 897
 898 /*
 899  * It executes link_update after knowing an interrupt occurred.
 900  *
 901  * @param dev
 902  *  Pointer to struct rte_eth_dev.
 903  *
 904  * @return
 905  *  - On success, zero.
 906  *  - On failure, a negative value.
 907  */
 908 static int
 909 atl_dev_interrupt_action(struct rte_eth_dev *dev,
 910                            struct rte_intr_handle *intr_handle)
 911 {
 912         struct atl_interrupt *intr =
 913                 ATL_DEV_PRIVATE_TO_INTR(dev->data->dev_private);
 914
 915         if (intr->flags & ATL_FLAG_NEED_LINK_UPDATE) {
 916                 atl_dev_link_update(dev, 0);
 917                 intr->flags &= ~ATL_FLAG_NEED_LINK_UPDATE;
 918                 atl_dev_link_status_print(dev);
 919                 _rte_eth_dev_callback_process(dev,
 920                         RTE_ETH_EVENT_INTR_LSC, NULL);
 921         }
 922
 923         atl_enable_intr(dev);
 924         rte_intr_enable(intr_handle);
 925
 926         return 0;
 927 }
 928
 929 /**
 930  * Interrupt handler triggered by NIC  for handling
 931  * specific interrupt.
 932  *
 933  * @param handle
 934  *  Pointer to interrupt handle.
 935  * @param param
 936  *  The address of parameter (struct rte_eth_dev *) regsitered before.
 937  *
 938  * @return
 939  *  void
 940  */
 941 static void
 942 atl_dev_interrupt_handler(void *param)
 943 {
 944         struct rte_eth_dev *dev = (struct rte_eth_dev *)param;
 945
 946         atl_dev_interrupt_get_status(dev);
 947         atl_dev_interrupt_action(dev, dev->intr_handle);
 948 }
 949
 950 RTE_PMD_REGISTER_PCI(net_atlantic, rte_atl_pmd);
 951 RTE_PMD_REGISTER_PCI_TABLE(net_atlantic, pci_id_atl_map);
 952 RTE_PMD_REGISTER_KMOD_DEP(net_atlantic, "* igb_uio | uio_pci_generic");
 953
 954 RTE_INIT(atl_init_log)
 955 {
 956         atl_logtype_init = rte_log_register("pmd.net.atlantic.init");
 957         if (atl_logtype_init >= 0)
 958                 rte_log_set_level(atl_logtype_init, RTE_LOG_NOTICE);
 959         atl_logtype_driver = rte_log_register("pmd.net.atlantic.driver");
 960         if (atl_logtype_driver >= 0)
 961                 rte_log_set_level(atl_logtype_driver, RTE_LOG_NOTICE);
 962 }
 963