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