1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 Chelsio Communications.
6 #include <rte_ethdev_driver.h>
7 #include <rte_ethdev_pci.h>
8 #include <rte_malloc.h>
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.
20 static void size_nports_qsets(struct adapter *adapter)
22 struct vf_resources *vfres = &adapter->params.vfres;
23 unsigned int ethqsets, pmask_nports;
26 * The number of "ports" which we support is equal to the number of
27 * Virtual Interfaces with which we've been provisioned.
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;
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.
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;
53 * We need to reserve an Ingress Queue for the Asynchronous Firmware
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
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;
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;
77 void cxgbevf_stats_get(struct port_info *pi, struct port_stats *stats)
79 t4vf_get_port_stats(pi->adapter, pi->pidx, stats);
82 static int adap_init0vf(struct adapter *adapter)
87 err = t4vf_fw_reset(adapter);
89 dev_err(adapter->pdev_dev, "FW reset failed: err=%d\n", err);
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.
101 err = t4vf_get_dev_params(adapter);
103 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
104 " device parameters: err=%d\n", err);
108 err = t4vf_get_vpd_params(adapter);
110 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
111 " VPD parameters: err=%d\n", err);
115 adapter->pf = t4vf_get_pf_from_vf(adapter);
116 err = t4vf_sge_init(adapter);
118 dev_err(adapter->pdev_dev, "error in sge init\n");
122 err = t4vf_get_rss_glb_config(adapter);
124 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
125 " RSS parameters: err=%d\n", err);
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);
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 ...
140 param = V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_PFVF) |
141 V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_PFVF_CPLFW4MSG_ENCAP);
143 t4vf_set_params(adapter, 1, ¶m, &val);
146 * Grab our Virtual Interface resource allocation, extract the
147 * features that we're interested in and do a bit of sanity testing on
150 err = t4vf_get_vfres(adapter);
152 dev_err(adapter->pdev_dev, "unable to get virtual interface"
153 " resources: err=%d\n", err);
158 * Check for various parameter sanity issues.
160 if (adapter->params.vfres.pmask == 0) {
161 dev_err(adapter->pdev_dev, "no port access configured\n"
165 if (adapter->params.vfres.nvi == 0) {
166 dev_err(adapter->pdev_dev, "no virtual interfaces configured/"
172 * Initialize nports and max_ethqsets now that we have our Virtual
173 * Function Resources.
175 size_nports_qsets(adapter);
176 adapter->flags |= FW_OK;
180 int cxgbevf_probe(struct adapter *adapter)
182 struct port_info *pi;
187 t4_os_lock_init(&adapter->mbox_lock);
188 TAILQ_INIT(&adapter->mbox_list);
189 err = t4vf_prep_adapter(adapter);
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");
202 err = adap_init0vf(adapter);
204 dev_err(adapter, "%s: Adapter initialization failed, error %d\n",
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;
218 port_id = ffs(pmask) - 1;
219 pmask &= ~(1 << port_id);
221 snprintf(name, sizeof(name), "%s_%d",
222 adapter->pdev->device.name, i);
225 /* First port is already allocated by DPDK */
226 eth_dev = adapter->eth_dev;
231 * now do all data allocation - for eth_dev structure,
232 * and internal (private) data for the remaining ports
235 /* reserve an ethdev entry */
236 eth_dev = rte_eth_dev_allocate(name);
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)
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;
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;
261 rte_eth_copy_pci_info(pi->eth_dev, adapter->pdev);
262 pi->eth_dev->data->mac_addrs = rte_zmalloc(name,
264 if (!pi->eth_dev->data->mac_addrs) {
265 dev_err(adapter, "%s: Mem allocation failed for storing mac addr, aborting\n",
272 /* First port will be notified by upper layer */
273 rte_eth_dev_probing_finish(eth_dev);
277 if (adapter->flags & FW_OK) {
278 err = t4vf_port_init(adapter);
280 dev_err(adapter, "%s: t4_port_init failed with err %d\n",
286 cfg_queues(adapter->eth_dev);
287 print_adapter_info(adapter);
288 print_port_info(adapter);
290 err = init_rss(adapter);
296 for_each_port(adapter, i) {
297 pi = adap2pinfo(adapter, i);
299 t4_free_vi(adapter, adapter->mbox, adapter->pf,
301 /* Skip first port since it'll be de-allocated by DPDK */
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);