2 * Copyright (C) 2015 Netronome Systems, Inc.
4 * This software is dual licensed under the GNU General License Version 2,
5 * June 1991 as shown in the file COPYING in the top-level directory of this
6 * source tree or the BSD 2-Clause License provided below. You have the
7 * option to license this software under the complete terms of either license.
9 * The BSD 2-Clause License:
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
15 * 1. Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
19 * 2. Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
36 * Netronome virtual function network device driver: Main entry point
37 * Author: Jason McMullan <jason.mcmullan@netronome.com>
38 * Rolf Neugebauer <rolf.neugebauer@netronome.com>
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>
47 #include "nfp_net_ctrl.h"
50 const char nfp_net_driver_name
[] = "nfp_netvf";
51 const char nfp_net_driver_version
[] = "0.1";
52 #define PCI_DEVICE_NFP6000VF 0x6003
53 static 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
,
58 { 0, } /* Required last entry. */
60 MODULE_DEVICE_TABLE(pci
, nfp_netvf_pci_device_ids
);
62 static void nfp_netvf_get_mac_addr(struct nfp_net
*nn
)
64 u8 mac_addr
[ETH_ALEN
];
66 put_unaligned_be32(nn_readl(nn
, NFP_NET_CFG_MACADDR
+ 0), &mac_addr
[0]);
67 /* We can't do readw for NFP-3200 compatibility */
68 put_unaligned_be16(nn_readl(nn
, NFP_NET_CFG_MACADDR
+ 4) >> 16,
71 if (!is_valid_ether_addr(mac_addr
)) {
72 eth_hw_addr_random(nn
->netdev
);
76 ether_addr_copy(nn
->netdev
->dev_addr
, mac_addr
);
77 ether_addr_copy(nn
->netdev
->perm_addr
, mac_addr
);
80 static int nfp_netvf_pci_probe(struct pci_dev
*pdev
,
81 const struct pci_device_id
*pci_id
)
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
;
95 err
= pci_enable_device_mem(pdev
);
99 err
= pci_request_regions(pdev
, nfp_net_driver_name
);
101 dev_err(&pdev
->dev
, "Unable to allocate device memory.\n");
102 goto err_pci_disable
;
105 switch (pdev
->device
) {
106 case PCI_DEVICE_NFP6000VF
:
111 goto err_pci_regions
;
114 pci_set_master(pdev
);
116 err
= dma_set_mask_and_coherent(&pdev
->dev
,
117 DMA_BIT_MASK(NFP_NET_MAX_DMA_BITS
));
119 goto err_pci_regions
;
121 /* Map the Control BAR.
123 * Irrespective of the advertised BAR size we only map the
124 * first NFP_NET_CFG_BAR_SZ of the BAR. This keeps the code
125 * the identical for PF and VF drivers.
127 ctrl_bar
= ioremap_nocache(pci_resource_start(pdev
, NFP_NET_CTRL_BAR
),
131 "Failed to map resource %d\n", NFP_NET_CTRL_BAR
);
133 goto err_pci_regions
;
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
);
144 /* Determine stride */
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)) {
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");
153 switch (fw_ver
.major
) {
157 tx_bar_no
= NFP_NET_Q0_BAR
;
158 rx_bar_no
= NFP_NET_Q1_BAR
;
161 tx_bar_no
= NFP_NET_Q0_BAR
;
162 rx_bar_no
= tx_bar_no
;
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
);
174 /* Find out how many rings are supported */
175 max_tx_rings
= readl(ctrl_bar
+ NFP_NET_CFG_MAX_TXRINGS
);
176 max_rx_rings
= readl(ctrl_bar
+ NFP_NET_CFG_MAX_RXRINGS
);
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
;
182 if (tx_bar_sz
> pci_resource_len(pdev
, tx_bar_no
)) {
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;
188 if (rx_bar_sz
> pci_resource_len(pdev
, rx_bar_no
)) {
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;
195 /* XXX Implement a workaround for THB-350 here. Ideally, we
196 * have a different PCI ID for A rev VFs.
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
);
210 /* Allocate and initialise the netdev */
211 nn
= nfp_net_netdev_alloc(pdev
, max_tx_rings
, max_rx_rings
);
218 nn
->ctrl_bar
= ctrl_bar
;
220 nn
->is_nfp3200
= is_nfp3200
;
221 nn
->stride_tx
= stride
;
222 nn
->stride_rx
= stride
;
224 if (rx_bar_no
== tx_bar_no
) {
226 resource_size_t map_addr
;
228 /* Make a single overlapping BAR mapping */
229 if (tx_bar_off
< rx_bar_off
)
230 bar_off
= tx_bar_off
;
232 bar_off
= rx_bar_off
;
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
;
237 bar_sz
= (rx_bar_off
+ rx_bar_sz
) - bar_off
;
239 map_addr
= pci_resource_start(pdev
, tx_bar_no
) + bar_off
;
240 nn
->q_bar
= ioremap_nocache(map_addr
, bar_sz
);
242 nn_err(nn
, "Failed to map resource %d\n", tx_bar_no
);
244 goto err_netdev_free
;
248 nn
->tx_bar
= nn
->q_bar
+ (tx_bar_off
- bar_off
);
250 nn
->rx_bar
= nn
->q_bar
+ (rx_bar_off
- bar_off
);
252 resource_size_t map_addr
;
255 map_addr
= pci_resource_start(pdev
, tx_bar_no
) + tx_bar_off
;
256 nn
->tx_bar
= ioremap_nocache(map_addr
, tx_bar_sz
);
258 nn_err(nn
, "Failed to map resource %d\n", tx_bar_no
);
260 goto err_netdev_free
;
264 map_addr
= pci_resource_start(pdev
, rx_bar_no
) + rx_bar_off
;
265 nn
->rx_bar
= ioremap_nocache(map_addr
, rx_bar_sz
);
267 nn_err(nn
, "Failed to map resource %d\n", rx_bar_no
);
273 nfp_netvf_get_mac_addr(nn
);
275 err
= nfp_net_irqs_alloc(nn
);
277 nn_warn(nn
, "Unable to allocate MSI-X Vectors. Exiting\n");
282 /* Get ME clock frequency from ctrl BAR
283 * XXX for now frequency is hardcoded until we figure out how
284 * to get the value from nfp-hwinfo into ctrl bar
286 nn
->me_freq_mhz
= 1200;
288 err
= nfp_net_netdev_init(nn
->netdev
);
290 goto err_irqs_disable
;
292 pci_set_drvdata(pdev
, nn
);
295 nfp_net_debugfs_adapter_add(nn
);
300 nfp_net_irqs_disable(nn
);
310 pci_set_drvdata(pdev
, NULL
);
311 nfp_net_netdev_free(nn
);
315 pci_release_regions(pdev
);
317 pci_disable_device(pdev
);
321 static void nfp_netvf_pci_remove(struct pci_dev
*pdev
)
323 struct nfp_net
*nn
= pci_get_drvdata(pdev
);
325 /* Note, the order is slightly different from above as we need
326 * to keep the nn pointer around till we have freed everything.
328 nfp_net_debugfs_adapter_del(nn
);
330 nfp_net_netdev_clean(nn
->netdev
);
332 nfp_net_irqs_disable(nn
);
340 iounmap(nn
->ctrl_bar
);
342 pci_set_drvdata(pdev
, NULL
);
344 nfp_net_netdev_free(nn
);
346 pci_release_regions(pdev
);
347 pci_disable_device(pdev
);
350 static 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
,
357 static int __init
nfp_netvf_init(void)
361 pr_info("%s: NFP VF Network driver, Copyright (C) 2014-2015 Netronome Systems\n",
362 nfp_net_driver_name
);
364 nfp_net_debugfs_create();
365 err
= pci_register_driver(&nfp_netvf_pci_driver
);
367 nfp_net_debugfs_destroy();
374 static void __exit
nfp_netvf_exit(void)
376 pci_unregister_driver(&nfp_netvf_pci_driver
);
377 nfp_net_debugfs_destroy();
380 module_init(nfp_netvf_init
);
381 module_exit(nfp_netvf_exit
);
383 MODULE_AUTHOR("Netronome Systems <oss-drivers@netronome.com>");
384 MODULE_LICENSE("GPL");
385 MODULE_DESCRIPTION("NFP VF network device driver");