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