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