2 * This file is provided under a dual BSD/GPLv2 license. When using or
3 * redistributing this file, you may do so under either license.
7 * Copyright(c) 2012 Intel Corporation. All rights reserved.
8 * Copyright (C) 2015 EMC Corporation. All Rights Reserved.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of version 2 of the GNU General Public License as
12 * published by the Free Software Foundation.
16 * Copyright(c) 2012 Intel Corporation. All rights reserved.
17 * Copyright (C) 2015 EMC Corporation. All Rights Reserved.
19 * Redistribution and use in source and binary forms, with or without
20 * modification, are permitted provided that the following conditions
23 * * Redistributions of source code must retain the above copyright
24 * notice, this list of conditions and the following disclaimer.
25 * * Redistributions in binary form must reproduce the above copy
26 * notice, this list of conditions and the following disclaimer in
27 * the documentation and/or other materials provided with the
29 * * Neither the name of Intel Corporation nor the names of its
30 * contributors may be used to endorse or promote products derived
31 * from this software without specific prior written permission.
33 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
34 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
35 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
36 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
37 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
38 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
39 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
40 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
41 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
42 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
43 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
45 * PCIe NTB Network Linux driver
47 * Contact Information:
48 * Jon Mason <jon.mason@intel.com>
50 #include <linux/etherdevice.h>
51 #include <linux/ethtool.h>
52 #include <linux/module.h>
53 #include <linux/pci.h>
54 #include <linux/ntb.h>
55 #include <linux/ntb_transport.h>
57 #define NTB_NETDEV_VER "0.7"
59 MODULE_DESCRIPTION(KBUILD_MODNAME
);
60 MODULE_VERSION(NTB_NETDEV_VER
);
61 MODULE_LICENSE("Dual BSD/GPL");
62 MODULE_AUTHOR("Intel Corporation");
65 struct list_head list
;
67 struct net_device
*ndev
;
68 struct ntb_transport_qp
*qp
;
71 #define NTB_TX_TIMEOUT_MS 1000
72 #define NTB_RXQ_SIZE 100
74 static LIST_HEAD(dev_list
);
76 static void ntb_netdev_event_handler(void *data
, int link_is_up
)
78 struct net_device
*ndev
= data
;
79 struct ntb_netdev
*dev
= netdev_priv(ndev
);
81 netdev_dbg(ndev
, "Event %x, Link %x\n", link_is_up
,
82 ntb_transport_link_query(dev
->qp
));
85 if (ntb_transport_link_query(dev
->qp
))
86 netif_carrier_on(ndev
);
88 netif_carrier_off(ndev
);
92 static void ntb_netdev_rx_handler(struct ntb_transport_qp
*qp
, void *qp_data
,
95 struct net_device
*ndev
= qp_data
;
103 netdev_dbg(ndev
, "%s: %d byte payload received\n", __func__
, len
);
106 ndev
->stats
.rx_errors
++;
107 ndev
->stats
.rx_length_errors
++;
112 skb
->protocol
= eth_type_trans(skb
, ndev
);
113 skb
->ip_summed
= CHECKSUM_NONE
;
115 if (netif_rx(skb
) == NET_RX_DROP
) {
116 ndev
->stats
.rx_errors
++;
117 ndev
->stats
.rx_dropped
++;
119 ndev
->stats
.rx_packets
++;
120 ndev
->stats
.rx_bytes
+= len
;
123 skb
= netdev_alloc_skb(ndev
, ndev
->mtu
+ ETH_HLEN
);
125 ndev
->stats
.rx_errors
++;
126 ndev
->stats
.rx_frame_errors
++;
131 rc
= ntb_transport_rx_enqueue(qp
, skb
, skb
->data
, ndev
->mtu
+ ETH_HLEN
);
134 ndev
->stats
.rx_errors
++;
135 ndev
->stats
.rx_fifo_errors
++;
139 static void ntb_netdev_tx_handler(struct ntb_transport_qp
*qp
, void *qp_data
,
142 struct net_device
*ndev
= qp_data
;
150 ndev
->stats
.tx_packets
++;
151 ndev
->stats
.tx_bytes
+= skb
->len
;
153 ndev
->stats
.tx_errors
++;
154 ndev
->stats
.tx_aborted_errors
++;
160 static netdev_tx_t
ntb_netdev_start_xmit(struct sk_buff
*skb
,
161 struct net_device
*ndev
)
163 struct ntb_netdev
*dev
= netdev_priv(ndev
);
166 rc
= ntb_transport_tx_enqueue(dev
->qp
, skb
, skb
->data
, skb
->len
);
173 ndev
->stats
.tx_dropped
++;
174 ndev
->stats
.tx_errors
++;
175 return NETDEV_TX_BUSY
;
178 static int ntb_netdev_open(struct net_device
*ndev
)
180 struct ntb_netdev
*dev
= netdev_priv(ndev
);
184 /* Add some empty rx bufs */
185 for (i
= 0; i
< NTB_RXQ_SIZE
; i
++) {
186 skb
= netdev_alloc_skb(ndev
, ndev
->mtu
+ ETH_HLEN
);
192 rc
= ntb_transport_rx_enqueue(dev
->qp
, skb
, skb
->data
,
193 ndev
->mtu
+ ETH_HLEN
);
200 netif_carrier_off(ndev
);
201 ntb_transport_link_up(dev
->qp
);
206 while ((skb
= ntb_transport_rx_remove(dev
->qp
, &len
)))
211 static int ntb_netdev_close(struct net_device
*ndev
)
213 struct ntb_netdev
*dev
= netdev_priv(ndev
);
217 ntb_transport_link_down(dev
->qp
);
219 while ((skb
= ntb_transport_rx_remove(dev
->qp
, &len
)))
225 static int ntb_netdev_change_mtu(struct net_device
*ndev
, int new_mtu
)
227 struct ntb_netdev
*dev
= netdev_priv(ndev
);
231 if (new_mtu
> ntb_transport_max_size(dev
->qp
) - ETH_HLEN
)
234 if (!netif_running(ndev
)) {
239 /* Bring down the link and dispose of posted rx entries */
240 ntb_transport_link_down(dev
->qp
);
242 if (ndev
->mtu
< new_mtu
) {
245 for (i
= 0; (skb
= ntb_transport_rx_remove(dev
->qp
, &len
)); i
++)
249 skb
= netdev_alloc_skb(ndev
, new_mtu
+ ETH_HLEN
);
255 rc
= ntb_transport_rx_enqueue(dev
->qp
, skb
, skb
->data
,
266 ntb_transport_link_up(dev
->qp
);
271 ntb_transport_link_down(dev
->qp
);
273 while ((skb
= ntb_transport_rx_remove(dev
->qp
, &len
)))
276 netdev_err(ndev
, "Error changing MTU, device inoperable\n");
280 static const struct net_device_ops ntb_netdev_ops
= {
281 .ndo_open
= ntb_netdev_open
,
282 .ndo_stop
= ntb_netdev_close
,
283 .ndo_start_xmit
= ntb_netdev_start_xmit
,
284 .ndo_change_mtu
= ntb_netdev_change_mtu
,
285 .ndo_set_mac_address
= eth_mac_addr
,
288 static void ntb_get_drvinfo(struct net_device
*ndev
,
289 struct ethtool_drvinfo
*info
)
291 struct ntb_netdev
*dev
= netdev_priv(ndev
);
293 strlcpy(info
->driver
, KBUILD_MODNAME
, sizeof(info
->driver
));
294 strlcpy(info
->version
, NTB_NETDEV_VER
, sizeof(info
->version
));
295 strlcpy(info
->bus_info
, pci_name(dev
->pdev
), sizeof(info
->bus_info
));
298 static int ntb_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
300 cmd
->supported
= SUPPORTED_Backplane
;
301 cmd
->advertising
= ADVERTISED_Backplane
;
302 ethtool_cmd_speed_set(cmd
, SPEED_UNKNOWN
);
303 cmd
->duplex
= DUPLEX_FULL
;
304 cmd
->port
= PORT_OTHER
;
305 cmd
->phy_address
= 0;
306 cmd
->transceiver
= XCVR_DUMMY1
;
307 cmd
->autoneg
= AUTONEG_ENABLE
;
314 static const struct ethtool_ops ntb_ethtool_ops
= {
315 .get_drvinfo
= ntb_get_drvinfo
,
316 .get_link
= ethtool_op_get_link
,
317 .get_settings
= ntb_get_settings
,
320 static const struct ntb_queue_handlers ntb_netdev_handlers
= {
321 .tx_handler
= ntb_netdev_tx_handler
,
322 .rx_handler
= ntb_netdev_rx_handler
,
323 .event_handler
= ntb_netdev_event_handler
,
326 static int ntb_netdev_probe(struct device
*client_dev
)
329 struct net_device
*ndev
;
330 struct pci_dev
*pdev
;
331 struct ntb_netdev
*dev
;
334 ntb
= dev_ntb(client_dev
->parent
);
339 ndev
= alloc_etherdev(sizeof(*dev
));
343 dev
= netdev_priv(ndev
);
346 ndev
->features
= NETIF_F_HIGHDMA
;
348 ndev
->priv_flags
|= IFF_LIVE_ADDR_CHANGE
;
350 ndev
->hw_features
= ndev
->features
;
351 ndev
->watchdog_timeo
= msecs_to_jiffies(NTB_TX_TIMEOUT_MS
);
353 random_ether_addr(ndev
->perm_addr
);
354 memcpy(ndev
->dev_addr
, ndev
->perm_addr
, ndev
->addr_len
);
356 ndev
->netdev_ops
= &ntb_netdev_ops
;
357 ndev
->ethtool_ops
= &ntb_ethtool_ops
;
359 dev
->qp
= ntb_transport_create_queue(ndev
, client_dev
,
360 &ntb_netdev_handlers
);
366 ndev
->mtu
= ntb_transport_max_size(dev
->qp
) - ETH_HLEN
;
368 rc
= register_netdev(ndev
);
372 list_add(&dev
->list
, &dev_list
);
373 dev_info(&pdev
->dev
, "%s created\n", ndev
->name
);
377 ntb_transport_free_queue(dev
->qp
);
383 static void ntb_netdev_remove(struct device
*client_dev
)
386 struct net_device
*ndev
;
387 struct pci_dev
*pdev
;
388 struct ntb_netdev
*dev
;
391 ntb
= dev_ntb(client_dev
->parent
);
394 list_for_each_entry(dev
, &dev_list
, list
) {
395 if (dev
->pdev
== pdev
) {
403 list_del(&dev
->list
);
407 unregister_netdev(ndev
);
408 ntb_transport_free_queue(dev
->qp
);
412 static struct ntb_transport_client ntb_netdev_client
= {
413 .driver
.name
= KBUILD_MODNAME
,
414 .driver
.owner
= THIS_MODULE
,
415 .probe
= ntb_netdev_probe
,
416 .remove
= ntb_netdev_remove
,
419 static int __init
ntb_netdev_init_module(void)
423 rc
= ntb_transport_register_client_dev(KBUILD_MODNAME
);
426 return ntb_transport_register_client(&ntb_netdev_client
);
428 module_init(ntb_netdev_init_module
);
430 static void __exit
ntb_netdev_exit_module(void)
432 ntb_transport_unregister_client(&ntb_netdev_client
);
433 ntb_transport_unregister_client_dev(KBUILD_MODNAME
);
435 module_exit(ntb_netdev_exit_module
);