1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
2 /* Copyright 2017-2019 NXP */
3
4 #include <linux/iopoll.h>
5 #include <linux/module.h>
6 #include "enetc.h"
7
8 #define ENETC_DRV_NAME_STR "ENETC VF driver"
9
10 /* Note: This function should be called after filling the message body,
11 * because the CRC16 needs to be calculated after all the data has been
12 * filled.
13 */
enetc_msg_fill_common_hdr(struct enetc_msg_swbd * msg_swbd,u8 class_id,u8 cmd_id,u8 proto_ver,u8 cookie)14 static void enetc_msg_fill_common_hdr(struct enetc_msg_swbd *msg_swbd,
15 u8 class_id, u8 cmd_id, u8 proto_ver,
16 u8 cookie)
17 {
18 struct enetc_msg_header *hdr = msg_swbd->vaddr;
19 u8 *data_buf = ((u8 *)msg_swbd->vaddr) + 2; /* skip crc16 field */
20 u32 data_size = msg_swbd->size - 2;
21 u16 crc16;
22
23 hdr->class_id = class_id;
24 hdr->cmd_id = cmd_id;
25 hdr->len = ENETC_MSG_EXT_BODY_LEN(msg_swbd->size);
26 hdr->proto_ver = proto_ver;
27 hdr->cookie = FIELD_PREP(ENETC_VF_MSG_COOKIE, cookie);
28
29 crc16 = crc_itu_t(ENETC_CRC_INIT, data_buf, data_size);
30 hdr->crc16 = htons(crc16);
31 }
32
enetc_msg_vsi_write_msg(struct enetc_hw * hw,struct enetc_msg_swbd * msg)33 static void enetc_msg_vsi_write_msg(struct enetc_hw *hw,
34 struct enetc_msg_swbd *msg)
35 {
36 u32 val;
37
38 val = enetc_vsi_set_msize(msg->size) | lower_32_bits(msg->dma);
39 enetc_wr(hw, ENETC_VSIMSGSNDAR1, upper_32_bits(msg->dma));
40 enetc_wr(hw, ENETC_VSIMSGSNDAR0, val);
41 }
42
enetc_msg_dma_free(struct device * dev,struct enetc_msg_swbd * msg)43 static void enetc_msg_dma_free(struct device *dev, struct enetc_msg_swbd *msg)
44 {
45 if (msg->vaddr) {
46 dma_free_coherent(dev, msg->size, msg->vaddr, msg->dma);
47 msg->vaddr = NULL;
48 }
49 }
50
enetc_msg_vsi_send(struct enetc_si * si,struct enetc_msg_swbd * msg)51 static int enetc_msg_vsi_send(struct enetc_si *si, struct enetc_msg_swbd *msg)
52 {
53 struct device *dev = &si->pdev->dev;
54 u32 vsimsgsr;
55 u16 pf_msg;
56 int err;
57
58 /* The VSI mailbox may be busy if last message was not yet processed
59 * by PSI. So need to check the mailbox status before sending.
60 */
61 vsimsgsr = enetc_rd(&si->hw, ENETC_VSIMSGSR);
62 if (vsimsgsr & ENETC_VSIMSGSR_MB) {
63 /* It is safe to free the DMA buffer here, the caller does
64 * not access the DMA buffer if enetc_msg_vsi_send() fails.
65 */
66 enetc_msg_dma_free(dev, msg);
67 dev_err(dev, "VSI mailbox is busy\n");
68 return -EIO;
69 }
70
71 /* Free the DMA buffer of the last message */
72 enetc_msg_dma_free(dev, &si->msg);
73 si->msg = *msg;
74 enetc_msg_vsi_write_msg(&si->hw, msg);
75 err = read_poll_timeout(enetc_rd, vsimsgsr,
76 !(vsimsgsr & ENETC_VSIMSGSR_MB),
77 1000, 200000, false, &si->hw, ENETC_VSIMSGSR);
78 if (err) {
79 dev_err(dev, "VSI mailbox timeout\n");
80
81 return err;
82 }
83
84 /* check for message delivery error */
85 if (vsimsgsr & ENETC_VSIMSGSR_MS) {
86 dev_err(dev, "Transfer error when copying the data\n");
87 return -EIO;
88 }
89
90 pf_msg = ENETC_SIMSGSR_GET_MC(vsimsgsr);
91 /* Check the user-defined completion status. */
92 if (FIELD_GET(ENETC_PF_MSG_CLASS_ID, pf_msg) !=
93 ENETC_MSG_CLASS_ID_CMD_SUCCESS) {
94 switch (FIELD_GET(ENETC_PF_MSG_CLASS_ID, pf_msg)) {
95 case ENETC_MSG_CLASS_ID_PERMISSION_DENY:
96 /* Intentionally returning early to prevent excessive
97 * error logs due to permission issues.
98 */
99 return -EACCES;
100 case ENETC_MSG_CLASS_ID_CMD_NOT_SUPPORT:
101 case ENETC_MSG_CLASS_ID_PROTO_NOT_SUPPORT:
102 err = -EOPNOTSUPP;
103 break;
104 case ENETC_MSG_CLASS_ID_PSI_BUSY:
105 err = -EBUSY;
106 break;
107 case ENETC_MSG_CLASS_ID_CMD_TIMEOUT:
108 err = -ETIME;
109 break;
110 case ENETC_MSG_CLASS_ID_INVALID_MSG_LEN:
111 case ENETC_MSG_CLASS_ID_MAC_FILTER:
112 err = -EINVAL;
113 break;
114 case ENETC_MSG_CLASS_ID_CMD_NOT_PERMITTED:
115 err = -EPERM;
116 break;
117 case ENETC_MSG_CLASS_ID_IP_REVISION:
118 err = FIELD_GET(ENETC_PF_MSG_CLASS_CODE_U8, pf_msg);
119 break;
120 case ENETC_MSG_CLASS_ID_CMD_FAIL:
121 case ENETC_MSG_CLASS_ID_CRC_ERROR:
122 case ENETC_MSG_CLASS_ID_CMD_DEFERRED:
123 default:
124 err = -EIO;
125 }
126 }
127
128 if (err < 0)
129 dev_err(dev, "Return error code from PSI: 0x%04x\n", pf_msg);
130
131 return err;
132 }
133
enetc_msg_vsi_set_primary_mac_addr(struct enetc_ndev_priv * priv,struct sockaddr * saddr)134 static int enetc_msg_vsi_set_primary_mac_addr(struct enetc_ndev_priv *priv,
135 struct sockaddr *saddr)
136 {
137 struct enetc_msg_mac_exact_filter *msg;
138 struct enetc_msg_swbd msg_swbd;
139 u32 msg_size;
140
141 msg_size = struct_size(msg, mac, 1);
142 msg_swbd.size = ALIGN(msg_size, ENETC_MSG_ALIGN);
143 msg_swbd.vaddr = dma_alloc_coherent(priv->dev, msg_swbd.size,
144 &msg_swbd.dma, GFP_KERNEL);
145 if (!msg_swbd.vaddr)
146 return -ENOMEM;
147
148 msg = (struct enetc_msg_mac_exact_filter *)msg_swbd.vaddr;
149 memcpy(&msg->mac[0].addr, saddr->sa_data, ETH_ALEN);
150 enetc_msg_fill_common_hdr(&msg_swbd, ENETC_MSG_CLASS_ID_MAC_FILTER,
151 ENETC_MSG_SET_PRIMARY_MAC, 0, 0);
152
153 /* send the command and wait */
154 return enetc_msg_vsi_send(priv->si, &msg_swbd);
155 }
156
enetc_vf_get_ip_minor_revision(struct enetc_si * si)157 static int enetc_vf_get_ip_minor_revision(struct enetc_si *si)
158 {
159 struct device *dev = &si->pdev->dev;
160 struct enetc_msg_swbd msg_swbd;
161
162 msg_swbd.size = ALIGN(sizeof(struct enetc_msg_generic),
163 ENETC_MSG_ALIGN);
164 msg_swbd.vaddr = dma_alloc_coherent(dev, msg_swbd.size,
165 &msg_swbd.dma, GFP_KERNEL);
166 if (!msg_swbd.vaddr)
167 return -ENOMEM;
168
169 enetc_msg_fill_common_hdr(&msg_swbd, ENETC_MSG_CLASS_ID_IP_REVISION,
170 ENETC_MSG_GET_IP_MN, 0, 0);
171
172 return enetc_msg_vsi_send(si, &msg_swbd);
173 }
174
enetc_vf_set_mac_addr(struct net_device * ndev,void * addr)175 static int enetc_vf_set_mac_addr(struct net_device *ndev, void *addr)
176 {
177 struct enetc_ndev_priv *priv = netdev_priv(ndev);
178 struct sockaddr *saddr = addr;
179 int err;
180
181 if (!is_valid_ether_addr(saddr->sa_data))
182 return -EADDRNOTAVAIL;
183
184 err = enetc_msg_vsi_set_primary_mac_addr(priv, saddr);
185 if (err)
186 return err;
187
188 eth_hw_addr_set(ndev, saddr->sa_data);
189
190 return 0;
191 }
192
enetc_vf_set_features(struct net_device * ndev,netdev_features_t features)193 static int enetc_vf_set_features(struct net_device *ndev,
194 netdev_features_t features)
195 {
196 enetc_set_features(ndev, features);
197
198 return 0;
199 }
200
enetc_vf_setup_tc(struct net_device * ndev,enum tc_setup_type type,void * type_data)201 static int enetc_vf_setup_tc(struct net_device *ndev, enum tc_setup_type type,
202 void *type_data)
203 {
204 switch (type) {
205 case TC_SETUP_QDISC_MQPRIO:
206 return enetc_setup_tc_mqprio(ndev, type_data);
207 default:
208 return -EOPNOTSUPP;
209 }
210 }
211
212 /* Probing/ Init */
213 static const struct net_device_ops enetc_ndev_ops = {
214 .ndo_open = enetc_open,
215 .ndo_stop = enetc_close,
216 .ndo_start_xmit = enetc_xmit,
217 .ndo_get_stats = enetc_get_stats,
218 .ndo_set_mac_address = enetc_vf_set_mac_addr,
219 .ndo_set_features = enetc_vf_set_features,
220 .ndo_eth_ioctl = enetc_ioctl,
221 .ndo_setup_tc = enetc_vf_setup_tc,
222 .ndo_hwtstamp_get = enetc_hwtstamp_get,
223 .ndo_hwtstamp_set = enetc_hwtstamp_set,
224 };
225
enetc_vf_get_revision(struct enetc_si * si)226 static void enetc_vf_get_revision(struct enetc_si *si)
227 {
228 int ip_mn;
229
230 if (is_enetc_rev1(si)) {
231 si->revision = ENETC_REV_1_0;
232 return;
233 }
234
235 ip_mn = enetc_vf_get_ip_minor_revision(si);
236 if (ip_mn >= 0) {
237 si->revision = (si->pdev->revision << 8) | ip_mn;
238 return;
239 }
240
241 si->revision = ENETC_REV_4_1;
242 dev_info(&si->pdev->dev,
243 "Failed to get revision, use compatible revision: 0x%04x\n",
244 si->revision);
245 }
246
enetc_vf_netdev_setup(struct enetc_si * si,struct net_device * ndev,const struct net_device_ops * ndev_ops)247 static void enetc_vf_netdev_setup(struct enetc_si *si, struct net_device *ndev,
248 const struct net_device_ops *ndev_ops)
249 {
250 struct enetc_ndev_priv *priv = netdev_priv(ndev);
251
252 SET_NETDEV_DEV(ndev, &si->pdev->dev);
253 priv->ndev = ndev;
254 priv->si = si;
255 priv->dev = &si->pdev->dev;
256 si->ndev = ndev;
257
258 priv->msg_enable = (NETIF_MSG_IFUP << 1) - 1;
259 priv->sysclk_freq = si->drvdata->sysclk_freq;
260 priv->max_frags = si->drvdata->max_frags;
261 ndev->netdev_ops = ndev_ops;
262 enetc_set_ethtool_ops(ndev);
263 ndev->watchdog_timeo = 5 * HZ;
264 ndev->max_mtu = ENETC_MAX_MTU;
265
266 ndev->hw_features = NETIF_F_SG | NETIF_F_RXCSUM |
267 NETIF_F_HW_VLAN_CTAG_TX |
268 NETIF_F_HW_VLAN_CTAG_RX |
269 NETIF_F_HW_CSUM | NETIF_F_TSO | NETIF_F_TSO6 |
270 NETIF_F_GSO_UDP_L4;
271 ndev->features = NETIF_F_HIGHDMA | NETIF_F_SG | NETIF_F_RXCSUM |
272 NETIF_F_HW_VLAN_CTAG_TX |
273 NETIF_F_HW_VLAN_CTAG_RX |
274 NETIF_F_HW_CSUM | NETIF_F_TSO | NETIF_F_TSO6 |
275 NETIF_F_GSO_UDP_L4;
276 ndev->vlan_features = NETIF_F_SG | NETIF_F_HW_CSUM |
277 NETIF_F_TSO | NETIF_F_TSO6;
278
279 if (si->num_rss) {
280 ndev->hw_features |= NETIF_F_RXHASH;
281 ndev->features |= NETIF_F_RXHASH;
282 }
283
284 /* pick up primary MAC address from SI */
285 enetc_load_primary_mac_addr(&si->hw, ndev);
286 }
287
288 static const struct enetc_si_ops enetc_vsi_ops = {
289 .get_rss_table = enetc_get_rss_table,
290 .set_rss_table = enetc_set_rss_table,
291 .setup_cbdr = enetc_setup_cbdr,
292 .teardown_cbdr = enetc_teardown_cbdr,
293 };
294
enetc_vf_probe(struct pci_dev * pdev,const struct pci_device_id * ent)295 static int enetc_vf_probe(struct pci_dev *pdev,
296 const struct pci_device_id *ent)
297 {
298 struct enetc_ndev_priv *priv;
299 struct enetc_msg_swbd msg;
300 struct net_device *ndev;
301 struct enetc_si *si;
302 int err;
303
304 err = enetc_pci_probe(pdev, KBUILD_MODNAME, 0);
305 if (err)
306 return dev_err_probe(&pdev->dev, err, "PCI probing failed\n");
307
308 si = pci_get_drvdata(pdev);
309 enetc_vf_get_revision(si);
310 si->ops = &enetc_vsi_ops;
311 err = enetc_get_driver_data(si);
312 if (err) {
313 dev_err_probe(&pdev->dev, err,
314 "Could not get VF driver data\n");
315 goto err_get_driver_data;
316 }
317
318 enetc_get_si_caps(si);
319
320 /* Currently, the supported SoCs have a max of 6 CPUs and the VFs
321 * have less than 6 RX/TX rings. So no issues for these supported
322 * SoCs, but for future SoCs which have more CPUs or more TX/RX
323 * rings, all the related logic needs to be improved.
324 */
325 ndev = alloc_etherdev_mqs(sizeof(*priv),
326 min(si->num_tx_rings, ENETC_MAX_NUM_TXQS),
327 min(si->num_rx_rings, ENETC_MAX_NUM_TXQS));
328 if (!ndev) {
329 err = -ENOMEM;
330 dev_err(&pdev->dev, "netdev creation failed\n");
331 goto err_alloc_netdev;
332 }
333
334 enetc_vf_netdev_setup(si, ndev, &enetc_ndev_ops);
335
336 priv = netdev_priv(ndev);
337
338 enetc_init_si_rings_params(priv);
339
340 err = si->ops->setup_cbdr(si);
341 if (err)
342 goto err_setup_cbdr;
343
344 err = enetc_alloc_si_resources(priv);
345 if (err) {
346 dev_err(&pdev->dev, "SI resource alloc failed\n");
347 goto err_alloc_si_res;
348 }
349
350 err = enetc_configure_si(priv);
351 if (err) {
352 dev_err(&pdev->dev, "Failed to configure SI\n");
353 goto err_config_si;
354 }
355
356 err = enetc_alloc_msix(priv);
357 if (err) {
358 dev_err(&pdev->dev, "MSIX alloc failed\n");
359 goto err_alloc_msix;
360 }
361
362 err = register_netdev(ndev);
363 if (err)
364 goto err_reg_netdev;
365
366 netif_carrier_off(ndev);
367
368 return 0;
369
370 err_reg_netdev:
371 enetc_free_msix(priv);
372 err_config_si:
373 err_alloc_msix:
374 enetc_free_si_resources(priv);
375 err_alloc_si_res:
376 si->ops->teardown_cbdr(si);
377 err_setup_cbdr:
378 si->ndev = NULL;
379 free_netdev(ndev);
380 err_alloc_netdev:
381 err_get_driver_data:
382 msg = si->msg;
383 enetc_pci_remove(pdev);
384 enetc_msg_dma_free(&pdev->dev, &msg);
385
386 return err;
387 }
388
enetc_vf_remove(struct pci_dev * pdev)389 static void enetc_vf_remove(struct pci_dev *pdev)
390 {
391 struct enetc_si *si = pci_get_drvdata(pdev);
392 struct enetc_ndev_priv *priv;
393 struct enetc_msg_swbd msg;
394
395 priv = netdev_priv(si->ndev);
396 unregister_netdev(si->ndev);
397
398 enetc_free_msix(priv);
399
400 enetc_free_si_resources(priv);
401 si->ops->teardown_cbdr(si);
402
403 free_netdev(si->ndev);
404
405 msg = si->msg;
406 enetc_pci_remove(pdev);
407 enetc_msg_dma_free(&pdev->dev, &msg);
408 }
409
410 static const struct pci_device_id enetc_vf_id_table[] = {
411 { PCI_DEVICE(PCI_VENDOR_ID_FREESCALE, ENETC_DEV_ID_VF) },
412 { 0, } /* End of table. */
413 };
414 MODULE_DEVICE_TABLE(pci, enetc_vf_id_table);
415
416 static struct pci_driver enetc_vf_driver = {
417 .name = KBUILD_MODNAME,
418 .id_table = enetc_vf_id_table,
419 .probe = enetc_vf_probe,
420 .remove = enetc_vf_remove,
421 };
422 module_pci_driver(enetc_vf_driver);
423
424 MODULE_DESCRIPTION(ENETC_DRV_NAME_STR);
425 MODULE_LICENSE("Dual BSD/GPL");
426