drivers/net/cxgbe/cxgbevf_main.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Chelsio Communications.
   3  * All rights reserved.
   4  */
   5
   6 #include <rte_ethdev_driver.h>
   7 #include <rte_ethdev_pci.h>
   8 #include <rte_malloc.h>
   9
  10 #include "common.h"
  11 #include "t4_regs.h"
  12 #include "t4_msg.h"
  13 #include "cxgbe.h"
  14
  15 /*
  16  * Figure out how many Ports and Queue Sets we can support.  This depends on
  17  * knowing our Virtual Function Resources and may be called a second time if
  18  * we fall back from MSI-X to MSI Interrupt Mode.
  19  */
  20 static void size_nports_qsets(struct adapter *adapter)
  21 {
  22         struct vf_resources *vfres = &adapter->params.vfres;
  23         unsigned int ethqsets, pmask_nports;
  24
  25         /*
  26          * The number of "ports" which we support is equal to the number of
  27          * Virtual Interfaces with which we've been provisioned.
  28          */
  29         adapter->params.nports = vfres->nvi;
  30         if (adapter->params.nports > MAX_NPORTS) {
  31                 dev_warn(adapter->pdev_dev, "only using %d of %d maximum"
  32                          " allowed virtual interfaces\n", MAX_NPORTS,
  33                          adapter->params.nports);
  34                 adapter->params.nports = MAX_NPORTS;
  35         }
  36
  37         /*
  38          * We may have been provisioned with more VIs than the number of
  39          * ports we're allowed to access (our Port Access Rights Mask).
  40          * This is obviously a configuration conflict but we don't want to
  41          * do anything silly just because of that.
  42          */
  43         pmask_nports = hweight32(adapter->params.vfres.pmask);
  44         if (pmask_nports < adapter->params.nports) {
  45                 dev_warn(adapter->pdev_dev, "only using %d of %d provissioned"
  46                          " virtual interfaces; limited by Port Access Rights"
  47                          " mask %#x\n", pmask_nports, adapter->params.nports,
  48                          adapter->params.vfres.pmask);
  49                 adapter->params.nports = pmask_nports;
  50         }
  51
  52         /*
  53          * We need to reserve an Ingress Queue for the Asynchronous Firmware
  54          * Event Queue.
  55          *
  56          * For each Queue Set, we'll need the ability to allocate two Egress
  57          * Contexts -- one for the Ingress Queue Free List and one for the TX
  58          * Ethernet Queue.
  59          */
  60         ethqsets = vfres->niqflint - 1;
  61         if (vfres->nethctrl != ethqsets)
  62                 ethqsets = min(vfres->nethctrl, ethqsets);
  63         if (vfres->neq < ethqsets * 2)
  64                 ethqsets = vfres->neq / 2;
  65         if (ethqsets > MAX_ETH_QSETS)
  66                 ethqsets = MAX_ETH_QSETS;
  67         adapter->sge.max_ethqsets = ethqsets;
  68
  69         if (adapter->sge.max_ethqsets < adapter->params.nports) {
  70                 dev_warn(adapter->pdev_dev, "only using %d of %d available"
  71                          " virtual interfaces (too few Queue Sets)\n",
  72                          adapter->sge.max_ethqsets, adapter->params.nports);
  73                 adapter->params.nports = adapter->sge.max_ethqsets;
  74         }
  75 }
  76
  77 void cxgbevf_stats_get(struct port_info *pi, struct port_stats *stats)
  78 {
  79         t4vf_get_port_stats(pi->adapter, pi->pidx, stats);
  80 }
  81
  82 static int adap_init0vf(struct adapter *adapter)
  83 {
  84         u32 param, val = 0;
  85         int err;
  86
  87         err = t4vf_fw_reset(adapter);
  88         if (err < 0) {
  89                 dev_err(adapter->pdev_dev, "FW reset failed: err=%d\n", err);
  90                 return err;
  91         }
  92
  93         /*
  94          * Grab basic operational parameters.  These will predominantly have
  95          * been set up by the Physical Function Driver or will be hard coded
  96          * into the adapter.  We just have to live with them ...  Note that
  97          * we _must_ get our VPD parameters before our SGE parameters because
  98          * we need to know the adapter's core clock from the VPD in order to
  99          * properly decode the SGE Timer Values.
 100          */
 101         err = t4vf_get_dev_params(adapter);
 102         if (err) {
 103                 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
 104                         " device parameters: err=%d\n", err);
 105                 return err;
 106         }
 107
 108         err = t4vf_get_vpd_params(adapter);
 109         if (err) {
 110                 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
 111                         " VPD parameters: err=%d\n", err);
 112                 return err;
 113         }
 114
 115         adapter->pf = t4vf_get_pf_from_vf(adapter);
 116         err = t4vf_sge_init(adapter);
 117         if (err) {
 118                 dev_err(adapter->pdev_dev, "error in sge init\n");
 119                 return err;
 120         }
 121
 122         err = t4vf_get_rss_glb_config(adapter);
 123         if (err) {
 124                 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
 125                         " RSS parameters: err=%d\n", err);
 126                 return err;
 127         }
 128         if (adapter->params.rss.mode !=
 129             FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL) {
 130                 dev_err(adapter->pdev_dev, "unable to operate with global RSS"
 131                         " mode %d\n", adapter->params.rss.mode);
 132                 return -EINVAL;
 133         }
 134
 135         /* If we're running on newer firmware, let it know that we're
 136          * prepared to deal with encapsulated CPL messages.  Older
 137          * firmware won't understand this and we'll just get
 138          * unencapsulated messages ...
 139          */
 140         param = V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_PFVF) |
 141                 V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_PFVF_CPLFW4MSG_ENCAP);
 142         val = 1;
 143         t4vf_set_params(adapter, 1, &param, &val);
 144
 145         /*
 146          * Grab our Virtual Interface resource allocation, extract the
 147          * features that we're interested in and do a bit of sanity testing on
 148          * what we discover.
 149          */
 150         err = t4vf_get_vfres(adapter);
 151         if (err) {
 152                 dev_err(adapter->pdev_dev, "unable to get virtual interface"
 153                         " resources: err=%d\n", err);
 154                 return err;
 155         }
 156
 157         /*
 158          * Check for various parameter sanity issues.
 159          */
 160         if (adapter->params.vfres.pmask == 0) {
 161                 dev_err(adapter->pdev_dev, "no port access configured\n"
 162                         "usable!\n");
 163                 return -EINVAL;
 164         }
 165         if (adapter->params.vfres.nvi == 0) {
 166                 dev_err(adapter->pdev_dev, "no virtual interfaces configured/"
 167                         "usable!\n");
 168                 return -EINVAL;
 169         }
 170
 171         /*
 172          * Initialize nports and max_ethqsets now that we have our Virtual
 173          * Function Resources.
 174          */
 175         size_nports_qsets(adapter);
 176         adapter->flags |= FW_OK;
 177         return 0;
 178 }
 179
 180 int cxgbevf_probe(struct adapter *adapter)
 181 {
 182         struct port_info *pi;
 183         unsigned int pmask;
 184         int err = 0;
 185         int i;
 186
 187         t4_os_lock_init(&adapter->mbox_lock);
 188         TAILQ_INIT(&adapter->mbox_list);
 189         err = t4vf_prep_adapter(adapter);
 190         if (err)
 191                 return err;
 192
 193         if (!is_t4(adapter->params.chip)) {
 194                 adapter->bar2 = (void *)adapter->pdev->mem_resource[2].addr;
 195                 if (!adapter->bar2) {
 196                         dev_err(adapter, "cannot map device bar2 region\n");
 197                         err = -ENOMEM;
 198                         return err;
 199                 }
 200         }
 201
 202         err = adap_init0vf(adapter);
 203         if (err) {
 204                 dev_err(adapter, "%s: Adapter initialization failed, error %d\n",
 205                                 __func__, err);
 206                 goto out_free;
 207         }
 208
 209         pmask = adapter->params.vfres.pmask;
 210         for_each_port(adapter, i) {
 211                 const unsigned int numa_node = rte_socket_id();
 212                 char name[RTE_ETH_NAME_MAX_LEN];
 213                 struct rte_eth_dev *eth_dev;
 214                 int port_id;
 215
 216                 if (pmask == 0)
 217                         break;
 218                 port_id = ffs(pmask) - 1;
 219                 pmask &= ~(1 << port_id);
 220
 221                 snprintf(name, sizeof(name), "%s_%d",
 222                          adapter->pdev->device.name, i);
 223
 224                 if (i == 0) {
 225                         /* First port is already allocated by DPDK */
 226                         eth_dev = adapter->eth_dev;
 227                         goto allocate_mac;
 228                 }
 229
 230                 /*
 231                  * now do all data allocation - for eth_dev structure,
 232                  * and internal (private) data for the remaining ports
 233                  */
 234
 235                 /* reserve an ethdev entry */
 236                 eth_dev = rte_eth_dev_allocate(name);
 237                 if (!eth_dev) {
 238                         err = -ENOMEM;
 239                         goto out_free;
 240                 }
 241                 eth_dev->data->dev_private =
 242                         rte_zmalloc_socket(name, sizeof(struct port_info),
 243                                            RTE_CACHE_LINE_SIZE, numa_node);
 244                 if (!eth_dev->data->dev_private)
 245                         goto out_free;
 246
 247 allocate_mac:
 248                 pi = (struct port_info *)eth_dev->data->dev_private;
 249                 adapter->port[i] = pi;
 250                 pi->eth_dev = eth_dev;
 251                 pi->adapter = adapter;
 252                 pi->xact_addr_filt = -1;
 253                 pi->port_id = port_id;
 254                 pi->pidx = i;
 255
 256                 pi->eth_dev->device = &adapter->pdev->device;
 257                 pi->eth_dev->dev_ops = adapter->eth_dev->dev_ops;
 258                 pi->eth_dev->tx_pkt_burst = adapter->eth_dev->tx_pkt_burst;
 259                 pi->eth_dev->rx_pkt_burst = adapter->eth_dev->rx_pkt_burst;
 260
 261                 rte_eth_copy_pci_info(pi->eth_dev, adapter->pdev);
 262                 pi->eth_dev->data->mac_addrs = rte_zmalloc(name,
 263                                                            ETHER_ADDR_LEN, 0);
 264                 if (!pi->eth_dev->data->mac_addrs) {
 265                         dev_err(adapter, "%s: Mem allocation failed for storing mac addr, aborting\n",
 266                                 __func__);
 267                         err = -ENOMEM;
 268                         goto out_free;
 269                 }
 270
 271                 if (i > 0) {
 272                         /* First port will be notified by upper layer */
 273                         rte_eth_dev_probing_finish(eth_dev);
 274                 }
 275         }
 276
 277         if (adapter->flags & FW_OK) {
 278                 err = t4vf_port_init(adapter);
 279                 if (err) {
 280                         dev_err(adapter, "%s: t4_port_init failed with err %d\n",
 281                                 __func__, err);
 282                         goto out_free;
 283                 }
 284         }
 285
 286         cfg_queues(adapter->eth_dev);
 287         print_adapter_info(adapter);
 288         print_port_info(adapter);
 289
 290         err = init_rss(adapter);
 291         if (err)
 292                 goto out_free;
 293         return 0;
 294
 295 out_free:
 296         for_each_port(adapter, i) {
 297                 pi = adap2pinfo(adapter, i);
 298                 if (pi->viid != 0)
 299                         t4_free_vi(adapter, adapter->mbox, adapter->pf,
 300                                    0, pi->viid);
 301                 /* Skip first port since it'll be de-allocated by DPDK */
 302                 if (i == 0)
 303                         continue;
 304                 if (pi->eth_dev) {
 305                         if (pi->eth_dev->data->dev_private)
 306                                 rte_free(pi->eth_dev->data->dev_private);
 307                         rte_eth_dev_release_port(pi->eth_dev);
 308                 }
 309         }
 310         return -err;
 311 }