1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
2 /* Copyright 2017-2019 NXP */
3
4 #include <linux/module.h>
5 #include "enetc.h"
6
7 #define ENETC_DRV_NAME_STR "ENETC VF driver"
8
9 /* Messaging */
enetc_msg_vsi_write_msg(struct enetc_hw * hw,struct enetc_msg_swbd * msg)10 static void enetc_msg_vsi_write_msg(struct enetc_hw *hw,
11 struct enetc_msg_swbd *msg)
12 {
13 u32 val;
14
15 val = enetc_vsi_set_msize(msg->size) | lower_32_bits(msg->dma);
16 enetc_wr(hw, ENETC_VSIMSGSNDAR1, upper_32_bits(msg->dma));
17 enetc_wr(hw, ENETC_VSIMSGSNDAR0, val);
18 }
19
enetc_msg_dma_free(struct device * dev,struct enetc_msg_swbd * msg)20 static void enetc_msg_dma_free(struct device *dev, struct enetc_msg_swbd *msg)
21 {
22 if (msg->vaddr) {
23 dma_free_coherent(dev, msg->size, msg->vaddr, msg->dma);
24 msg->vaddr = NULL;
25 }
26 }
27
enetc_msg_vsi_send(struct enetc_si * si,struct enetc_msg_swbd * msg)28 static int enetc_msg_vsi_send(struct enetc_si *si, struct enetc_msg_swbd *msg)
29 {
30 struct device *dev = &si->pdev->dev;
31 int timeout = 100;
32 u32 vsimsgsr;
33
34 /* The VSI mailbox may be busy if last message was not yet processed
35 * by PSI. So need to check the mailbox status before sending.
36 */
37 vsimsgsr = enetc_rd(&si->hw, ENETC_VSIMSGSR);
38 if (vsimsgsr & ENETC_VSIMSGSR_MB) {
39 /* It is safe to free the DMA buffer here, the caller does
40 * not access the DMA buffer if enetc_msg_vsi_send() fails.
41 */
42 enetc_msg_dma_free(dev, msg);
43 dev_err(dev, "VSI mailbox is busy\n");
44 return -EIO;
45 }
46
47 /* Free the DMA buffer of the last message */
48 enetc_msg_dma_free(dev, &si->msg);
49 si->msg = *msg;
50 enetc_msg_vsi_write_msg(&si->hw, msg);
51
52 do {
53 vsimsgsr = enetc_rd(&si->hw, ENETC_VSIMSGSR);
54 if (!(vsimsgsr & ENETC_VSIMSGSR_MB))
55 break;
56
57 usleep_range(1000, 2000);
58 } while (--timeout);
59
60 if (!timeout) {
61 dev_err(dev, "VSI mailbox timeout\n");
62
63 return -ETIMEDOUT;
64 }
65
66 /* check for message delivery error */
67 if (vsimsgsr & ENETC_VSIMSGSR_MS) {
68 dev_err(dev, "VSI command execute error: %d\n",
69 ENETC_SIMSGSR_GET_MC(vsimsgsr));
70 return -EIO;
71 }
72
73 return 0;
74 }
75
enetc_msg_vsi_set_primary_mac_addr(struct enetc_ndev_priv * priv,struct sockaddr * saddr)76 static int enetc_msg_vsi_set_primary_mac_addr(struct enetc_ndev_priv *priv,
77 struct sockaddr *saddr)
78 {
79 struct enetc_msg_cmd_set_primary_mac *cmd;
80 struct enetc_msg_swbd msg;
81
82 msg.size = ALIGN(sizeof(struct enetc_msg_cmd_set_primary_mac), 64);
83 msg.vaddr = dma_alloc_coherent(priv->dev, msg.size, &msg.dma,
84 GFP_KERNEL);
85 if (!msg.vaddr) {
86 dev_err(priv->dev, "Failed to alloc Tx msg (size: %d)\n",
87 msg.size);
88 return -ENOMEM;
89 }
90
91 cmd = (struct enetc_msg_cmd_set_primary_mac *)msg.vaddr;
92 cmd->header.type = ENETC_MSG_CMD_MNG_MAC;
93 cmd->header.id = ENETC_MSG_CMD_MNG_ADD;
94 memcpy(&cmd->mac, saddr, sizeof(struct sockaddr));
95
96 /* send the command and wait */
97 return enetc_msg_vsi_send(priv->si, &msg);
98 }
99
enetc_vf_set_mac_addr(struct net_device * ndev,void * addr)100 static int enetc_vf_set_mac_addr(struct net_device *ndev, void *addr)
101 {
102 struct enetc_ndev_priv *priv = netdev_priv(ndev);
103 struct sockaddr *saddr = addr;
104 int err;
105
106 if (!is_valid_ether_addr(saddr->sa_data))
107 return -EADDRNOTAVAIL;
108
109 err = enetc_msg_vsi_set_primary_mac_addr(priv, saddr);
110 if (err)
111 return err;
112
113 eth_hw_addr_set(ndev, saddr->sa_data);
114
115 return 0;
116 }
117
enetc_vf_set_features(struct net_device * ndev,netdev_features_t features)118 static int enetc_vf_set_features(struct net_device *ndev,
119 netdev_features_t features)
120 {
121 enetc_set_features(ndev, features);
122
123 return 0;
124 }
125
enetc_vf_setup_tc(struct net_device * ndev,enum tc_setup_type type,void * type_data)126 static int enetc_vf_setup_tc(struct net_device *ndev, enum tc_setup_type type,
127 void *type_data)
128 {
129 switch (type) {
130 case TC_SETUP_QDISC_MQPRIO:
131 return enetc_setup_tc_mqprio(ndev, type_data);
132 default:
133 return -EOPNOTSUPP;
134 }
135 }
136
137 /* Probing/ Init */
138 static const struct net_device_ops enetc_ndev_ops = {
139 .ndo_open = enetc_open,
140 .ndo_stop = enetc_close,
141 .ndo_start_xmit = enetc_xmit,
142 .ndo_get_stats = enetc_get_stats,
143 .ndo_set_mac_address = enetc_vf_set_mac_addr,
144 .ndo_set_features = enetc_vf_set_features,
145 .ndo_eth_ioctl = enetc_ioctl,
146 .ndo_setup_tc = enetc_vf_setup_tc,
147 .ndo_hwtstamp_get = enetc_hwtstamp_get,
148 .ndo_hwtstamp_set = enetc_hwtstamp_set,
149 };
150
enetc_vf_netdev_setup(struct enetc_si * si,struct net_device * ndev,const struct net_device_ops * ndev_ops)151 static void enetc_vf_netdev_setup(struct enetc_si *si, struct net_device *ndev,
152 const struct net_device_ops *ndev_ops)
153 {
154 struct enetc_ndev_priv *priv = netdev_priv(ndev);
155
156 SET_NETDEV_DEV(ndev, &si->pdev->dev);
157 priv->ndev = ndev;
158 priv->si = si;
159 priv->dev = &si->pdev->dev;
160 si->ndev = ndev;
161
162 priv->msg_enable = (NETIF_MSG_IFUP << 1) - 1;
163 priv->sysclk_freq = si->drvdata->sysclk_freq;
164 priv->max_frags = si->drvdata->max_frags;
165 ndev->netdev_ops = ndev_ops;
166 enetc_set_ethtool_ops(ndev);
167 ndev->watchdog_timeo = 5 * HZ;
168 ndev->max_mtu = ENETC_MAX_MTU;
169
170 ndev->hw_features = NETIF_F_SG | NETIF_F_RXCSUM |
171 NETIF_F_HW_VLAN_CTAG_TX |
172 NETIF_F_HW_VLAN_CTAG_RX |
173 NETIF_F_HW_CSUM | NETIF_F_TSO | NETIF_F_TSO6 |
174 NETIF_F_GSO_UDP_L4;
175 ndev->features = NETIF_F_HIGHDMA | NETIF_F_SG | NETIF_F_RXCSUM |
176 NETIF_F_HW_VLAN_CTAG_TX |
177 NETIF_F_HW_VLAN_CTAG_RX |
178 NETIF_F_HW_CSUM | NETIF_F_TSO | NETIF_F_TSO6 |
179 NETIF_F_GSO_UDP_L4;
180 ndev->vlan_features = NETIF_F_SG | NETIF_F_HW_CSUM |
181 NETIF_F_TSO | NETIF_F_TSO6;
182
183 if (si->num_rss) {
184 ndev->hw_features |= NETIF_F_RXHASH;
185 ndev->features |= NETIF_F_RXHASH;
186 }
187
188 /* pick up primary MAC address from SI */
189 enetc_load_primary_mac_addr(&si->hw, ndev);
190 }
191
192 static const struct enetc_si_ops enetc_vsi_ops = {
193 .get_rss_table = enetc_get_rss_table,
194 .set_rss_table = enetc_set_rss_table,
195 };
196
enetc_vf_probe(struct pci_dev * pdev,const struct pci_device_id * ent)197 static int enetc_vf_probe(struct pci_dev *pdev,
198 const struct pci_device_id *ent)
199 {
200 struct enetc_ndev_priv *priv;
201 struct net_device *ndev;
202 struct enetc_si *si;
203 int err;
204
205 err = enetc_pci_probe(pdev, KBUILD_MODNAME, 0);
206 if (err)
207 return dev_err_probe(&pdev->dev, err, "PCI probing failed\n");
208
209 si = pci_get_drvdata(pdev);
210 si->revision = ENETC_REV_1_0;
211 si->ops = &enetc_vsi_ops;
212 err = enetc_get_driver_data(si);
213 if (err) {
214 dev_err_probe(&pdev->dev, err,
215 "Could not get VF driver data\n");
216 goto err_alloc_netdev;
217 }
218
219 enetc_get_si_caps(si);
220
221 ndev = alloc_etherdev_mq(sizeof(*priv), ENETC_MAX_NUM_TXQS);
222 if (!ndev) {
223 err = -ENOMEM;
224 dev_err(&pdev->dev, "netdev creation failed\n");
225 goto err_alloc_netdev;
226 }
227
228 enetc_vf_netdev_setup(si, ndev, &enetc_ndev_ops);
229
230 priv = netdev_priv(ndev);
231
232 enetc_init_si_rings_params(priv);
233
234 err = enetc_setup_cbdr(priv->dev, &si->hw, ENETC_CBDR_DEFAULT_SIZE,
235 &si->cbd_ring);
236 if (err)
237 goto err_setup_cbdr;
238
239 err = enetc_alloc_si_resources(priv);
240 if (err) {
241 dev_err(&pdev->dev, "SI resource alloc failed\n");
242 goto err_alloc_si_res;
243 }
244
245 err = enetc_configure_si(priv);
246 if (err) {
247 dev_err(&pdev->dev, "Failed to configure SI\n");
248 goto err_config_si;
249 }
250
251 err = enetc_alloc_msix(priv);
252 if (err) {
253 dev_err(&pdev->dev, "MSIX alloc failed\n");
254 goto err_alloc_msix;
255 }
256
257 err = register_netdev(ndev);
258 if (err)
259 goto err_reg_netdev;
260
261 netif_carrier_off(ndev);
262
263 return 0;
264
265 err_reg_netdev:
266 enetc_free_msix(priv);
267 err_config_si:
268 err_alloc_msix:
269 enetc_free_si_resources(priv);
270 err_alloc_si_res:
271 enetc_teardown_cbdr(&si->cbd_ring);
272 err_setup_cbdr:
273 si->ndev = NULL;
274 free_netdev(ndev);
275 err_alloc_netdev:
276 enetc_pci_remove(pdev);
277
278 return err;
279 }
280
enetc_vf_remove(struct pci_dev * pdev)281 static void enetc_vf_remove(struct pci_dev *pdev)
282 {
283 struct enetc_si *si = pci_get_drvdata(pdev);
284 struct enetc_ndev_priv *priv;
285 struct enetc_msg_swbd msg;
286
287 priv = netdev_priv(si->ndev);
288 unregister_netdev(si->ndev);
289
290 enetc_free_msix(priv);
291
292 enetc_free_si_resources(priv);
293 enetc_teardown_cbdr(&si->cbd_ring);
294
295 free_netdev(si->ndev);
296
297 msg = si->msg;
298 enetc_pci_remove(pdev);
299 enetc_msg_dma_free(&pdev->dev, &msg);
300 }
301
302 static const struct pci_device_id enetc_vf_id_table[] = {
303 { PCI_DEVICE(PCI_VENDOR_ID_FREESCALE, ENETC_DEV_ID_VF) },
304 { 0, } /* End of table. */
305 };
306 MODULE_DEVICE_TABLE(pci, enetc_vf_id_table);
307
308 static struct pci_driver enetc_vf_driver = {
309 .name = KBUILD_MODNAME,
310 .id_table = enetc_vf_id_table,
311 .probe = enetc_vf_probe,
312 .remove = enetc_vf_remove,
313 };
314 module_pci_driver(enetc_vf_driver);
315
316 MODULE_DESCRIPTION(ENETC_DRV_NAME_STR);
317 MODULE_LICENSE("Dual BSD/GPL");
318