1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41#include <linux/version.h>
42#include <linux/module.h>
43#include <linux/kernel.h>
44#include <linux/init.h>
45#include <linux/etherdevice.h>
46
47#include "nfp_net_ctrl.h"
48#include "nfp_net.h"
49
50const char nfp_net_driver_name[] = "nfp_netvf";
51const char nfp_net_driver_version[] = "0.1";
52#define PCI_DEVICE_NFP6000VF 0x6003
53static const struct pci_device_id nfp_netvf_pci_device_ids[] = {
54 { PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_NFP6000VF,
55 PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID,
56 PCI_ANY_ID, 0,
57 },
58 { 0, }
59};
60MODULE_DEVICE_TABLE(pci, nfp_netvf_pci_device_ids);
61
62static void nfp_netvf_get_mac_addr(struct nfp_net *nn)
63{
64 u8 mac_addr[ETH_ALEN];
65
66 put_unaligned_be32(nn_readl(nn, NFP_NET_CFG_MACADDR + 0), &mac_addr[0]);
67
68 put_unaligned_be16(nn_readl(nn, NFP_NET_CFG_MACADDR + 4) >> 16,
69 &mac_addr[4]);
70
71 if (!is_valid_ether_addr(mac_addr)) {
72 eth_hw_addr_random(nn->netdev);
73 return;
74 }
75
76 ether_addr_copy(nn->netdev->dev_addr, mac_addr);
77 ether_addr_copy(nn->netdev->perm_addr, mac_addr);
78}
79
80static int nfp_netvf_pci_probe(struct pci_dev *pdev,
81 const struct pci_device_id *pci_id)
82{
83 struct nfp_net_fw_version fw_ver;
84 int max_tx_rings, max_rx_rings;
85 u32 tx_bar_off, rx_bar_off;
86 u32 tx_bar_sz, rx_bar_sz;
87 int tx_bar_no, rx_bar_no;
88 u8 __iomem *ctrl_bar;
89 struct nfp_net *nn;
90 int is_nfp3200;
91 u32 startq;
92 int stride;
93 int err;
94
95 err = pci_enable_device_mem(pdev);
96 if (err)
97 return err;
98
99 err = pci_request_regions(pdev, nfp_net_driver_name);
100 if (err) {
101 dev_err(&pdev->dev, "Unable to allocate device memory.\n");
102 goto err_pci_disable;
103 }
104
105 switch (pdev->device) {
106 case PCI_DEVICE_NFP6000VF:
107 is_nfp3200 = 0;
108 break;
109 default:
110 err = -ENODEV;
111 goto err_pci_regions;
112 }
113
114 pci_set_master(pdev);
115
116 err = dma_set_mask_and_coherent(&pdev->dev,
117 DMA_BIT_MASK(NFP_NET_MAX_DMA_BITS));
118 if (err)
119 goto err_pci_regions;
120
121
122
123
124
125
126
127 ctrl_bar = ioremap_nocache(pci_resource_start(pdev, NFP_NET_CRTL_BAR),
128 NFP_NET_CFG_BAR_SZ);
129 if (!ctrl_bar) {
130 dev_err(&pdev->dev,
131 "Failed to map resource %d\n", NFP_NET_CRTL_BAR);
132 err = -EIO;
133 goto err_pci_regions;
134 }
135
136 nfp_net_get_fw_version(&fw_ver, ctrl_bar);
137 if (fw_ver.class != NFP_NET_CFG_VERSION_CLASS_GENERIC) {
138 dev_err(&pdev->dev, "Unknown Firmware ABI %d.%d.%d.%d\n",
139 fw_ver.resv, fw_ver.class, fw_ver.major, fw_ver.minor);
140 err = -EINVAL;
141 goto err_ctrl_unmap;
142 }
143
144
145 if (nfp_net_fw_ver_eq(&fw_ver, 0, 0, 0, 0) ||
146 nfp_net_fw_ver_eq(&fw_ver, 0, 0, 0, 1) ||
147 nfp_net_fw_ver_eq(&fw_ver, 0, 0, 0x12, 0x48)) {
148 stride = 2;
149 tx_bar_no = NFP_NET_Q0_BAR;
150 rx_bar_no = NFP_NET_Q1_BAR;
151 dev_warn(&pdev->dev, "OBSOLETE Firmware detected - VF isolation not available\n");
152 } else {
153 switch (fw_ver.major) {
154 case 1 ... 3:
155 if (is_nfp3200) {
156 stride = 2;
157 tx_bar_no = NFP_NET_Q0_BAR;
158 rx_bar_no = NFP_NET_Q1_BAR;
159 } else {
160 stride = 4;
161 tx_bar_no = NFP_NET_Q0_BAR;
162 rx_bar_no = tx_bar_no;
163 }
164 break;
165 default:
166 dev_err(&pdev->dev, "Unsupported Firmware ABI %d.%d.%d.%d\n",
167 fw_ver.resv, fw_ver.class,
168 fw_ver.major, fw_ver.minor);
169 err = -EINVAL;
170 goto err_ctrl_unmap;
171 }
172 }
173
174
175 max_tx_rings = readl(ctrl_bar + NFP_NET_CFG_MAX_TXRINGS);
176 max_rx_rings = readl(ctrl_bar + NFP_NET_CFG_MAX_RXRINGS);
177
178 tx_bar_sz = NFP_QCP_QUEUE_ADDR_SZ * max_tx_rings * stride;
179 rx_bar_sz = NFP_QCP_QUEUE_ADDR_SZ * max_rx_rings * stride;
180
181
182 if (tx_bar_sz > pci_resource_len(pdev, tx_bar_no)) {
183 dev_err(&pdev->dev,
184 "TX BAR too small for number of TX rings. Adjusting\n");
185 tx_bar_sz = pci_resource_len(pdev, tx_bar_no);
186 max_tx_rings = (tx_bar_sz / NFP_QCP_QUEUE_ADDR_SZ) / 2;
187 }
188 if (rx_bar_sz > pci_resource_len(pdev, rx_bar_no)) {
189 dev_err(&pdev->dev,
190 "RX BAR too small for number of RX rings. Adjusting\n");
191 rx_bar_sz = pci_resource_len(pdev, rx_bar_no);
192 max_rx_rings = (rx_bar_sz / NFP_QCP_QUEUE_ADDR_SZ) / 2;
193 }
194
195
196
197
198 switch (pdev->device) {
199 case PCI_DEVICE_NFP6000VF:
200 startq = readl(ctrl_bar + NFP_NET_CFG_START_TXQ);
201 tx_bar_off = NFP_PCIE_QUEUE(startq);
202 startq = readl(ctrl_bar + NFP_NET_CFG_START_RXQ);
203 rx_bar_off = NFP_PCIE_QUEUE(startq);
204 break;
205 default:
206 err = -ENODEV;
207 goto err_ctrl_unmap;
208 }
209
210
211 nn = nfp_net_netdev_alloc(pdev, max_tx_rings, max_rx_rings);
212 if (IS_ERR(nn)) {
213 err = PTR_ERR(nn);
214 goto err_ctrl_unmap;
215 }
216
217 nn->fw_ver = fw_ver;
218 nn->ctrl_bar = ctrl_bar;
219 nn->is_vf = 1;
220 nn->is_nfp3200 = is_nfp3200;
221 nn->stride_tx = stride;
222 nn->stride_rx = stride;
223
224 if (rx_bar_no == tx_bar_no) {
225 u32 bar_off, bar_sz;
226 resource_size_t map_addr;
227
228
229 if (tx_bar_off < rx_bar_off)
230 bar_off = tx_bar_off;
231 else
232 bar_off = rx_bar_off;
233
234 if ((tx_bar_off + tx_bar_sz) > (rx_bar_off + rx_bar_sz))
235 bar_sz = (tx_bar_off + tx_bar_sz) - bar_off;
236 else
237 bar_sz = (rx_bar_off + rx_bar_sz) - bar_off;
238
239 map_addr = pci_resource_start(pdev, tx_bar_no) + bar_off;
240 nn->q_bar = ioremap_nocache(map_addr, bar_sz);
241 if (!nn->q_bar) {
242 nn_err(nn, "Failed to map resource %d\n", tx_bar_no);
243 err = -EIO;
244 goto err_netdev_free;
245 }
246
247
248 nn->tx_bar = nn->q_bar + (tx_bar_off - bar_off);
249
250 nn->rx_bar = nn->q_bar + (rx_bar_off - bar_off);
251 } else {
252 resource_size_t map_addr;
253
254
255 map_addr = pci_resource_start(pdev, tx_bar_no) + tx_bar_off;
256 nn->tx_bar = ioremap_nocache(map_addr, tx_bar_sz);
257 if (!nn->tx_bar) {
258 nn_err(nn, "Failed to map resource %d\n", tx_bar_no);
259 err = -EIO;
260 goto err_netdev_free;
261 }
262
263
264 map_addr = pci_resource_start(pdev, rx_bar_no) + rx_bar_off;
265 nn->rx_bar = ioremap_nocache(map_addr, rx_bar_sz);
266 if (!nn->rx_bar) {
267 nn_err(nn, "Failed to map resource %d\n", rx_bar_no);
268 err = -EIO;
269 goto err_unmap_tx;
270 }
271 }
272
273 nfp_netvf_get_mac_addr(nn);
274
275 err = nfp_net_irqs_alloc(nn);
276 if (!err) {
277 nn_warn(nn, "Unable to allocate MSI-X Vectors. Exiting\n");
278 err = -EIO;
279 goto err_unmap_rx;
280 }
281
282
283
284
285
286 nn->me_freq_mhz = 1200;
287
288 err = nfp_net_netdev_init(nn->netdev);
289 if (err)
290 goto err_irqs_disable;
291
292 pci_set_drvdata(pdev, nn);
293
294 nfp_net_info(nn);
295 nfp_net_debugfs_adapter_add(nn);
296
297 return 0;
298
299err_irqs_disable:
300 nfp_net_irqs_disable(nn);
301err_unmap_rx:
302 if (!nn->q_bar)
303 iounmap(nn->rx_bar);
304err_unmap_tx:
305 if (!nn->q_bar)
306 iounmap(nn->tx_bar);
307 else
308 iounmap(nn->q_bar);
309err_netdev_free:
310 pci_set_drvdata(pdev, NULL);
311 nfp_net_netdev_free(nn);
312err_ctrl_unmap:
313 iounmap(ctrl_bar);
314err_pci_regions:
315 pci_release_regions(pdev);
316err_pci_disable:
317 pci_disable_device(pdev);
318 return err;
319}
320
321static void nfp_netvf_pci_remove(struct pci_dev *pdev)
322{
323 struct nfp_net *nn = pci_get_drvdata(pdev);
324
325
326
327
328 nfp_net_debugfs_adapter_del(nn);
329
330 nfp_net_netdev_clean(nn->netdev);
331
332 nfp_net_irqs_disable(nn);
333
334 if (!nn->q_bar) {
335 iounmap(nn->rx_bar);
336 iounmap(nn->tx_bar);
337 } else {
338 iounmap(nn->q_bar);
339 }
340 iounmap(nn->ctrl_bar);
341
342 pci_set_drvdata(pdev, NULL);
343
344 nfp_net_netdev_free(nn);
345
346 pci_release_regions(pdev);
347 pci_disable_device(pdev);
348}
349
350static struct pci_driver nfp_netvf_pci_driver = {
351 .name = nfp_net_driver_name,
352 .id_table = nfp_netvf_pci_device_ids,
353 .probe = nfp_netvf_pci_probe,
354 .remove = nfp_netvf_pci_remove,
355};
356
357static int __init nfp_netvf_init(void)
358{
359 int err;
360
361 pr_info("%s: NFP VF Network driver, Copyright (C) 2014-2015 Netronome Systems\n",
362 nfp_net_driver_name);
363
364 nfp_net_debugfs_create();
365 err = pci_register_driver(&nfp_netvf_pci_driver);
366 if (err) {
367 nfp_net_debugfs_destroy();
368 return err;
369 }
370
371 return 0;
372}
373
374static void __exit nfp_netvf_exit(void)
375{
376 pci_unregister_driver(&nfp_netvf_pci_driver);
377 nfp_net_debugfs_destroy();
378}
379
380module_init(nfp_netvf_init);
381module_exit(nfp_netvf_exit);
382
383MODULE_AUTHOR("Netronome Systems <oss-drivers@netronome.com>");
384MODULE_LICENSE("GPL");
385MODULE_DESCRIPTION("NFP VF network device driver");
386