xref: /openbmc/linux/drivers/net/ethernet/sfc/efx.c (revision f97769fd)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /****************************************************************************
3  * Driver for Solarflare network controllers and boards
4  * Copyright 2005-2006 Fen Systems Ltd.
5  * Copyright 2005-2013 Solarflare Communications Inc.
6  */
7 
8 #include <linux/module.h>
9 #include <linux/pci.h>
10 #include <linux/netdevice.h>
11 #include <linux/etherdevice.h>
12 #include <linux/delay.h>
13 #include <linux/notifier.h>
14 #include <linux/ip.h>
15 #include <linux/tcp.h>
16 #include <linux/in.h>
17 #include <linux/ethtool.h>
18 #include <linux/topology.h>
19 #include <linux/gfp.h>
20 #include <linux/aer.h>
21 #include <linux/interrupt.h>
22 #include "net_driver.h"
23 #include <net/gre.h>
24 #include <net/udp_tunnel.h>
25 #include "efx.h"
26 #include "efx_common.h"
27 #include "efx_channels.h"
28 #include "ef100.h"
29 #include "rx_common.h"
30 #include "tx_common.h"
31 #include "nic.h"
32 #include "io.h"
33 #include "selftest.h"
34 #include "sriov.h"
35 
36 #include "mcdi.h"
37 #include "mcdi_pcol.h"
38 #include "workarounds.h"
39 
40 /**************************************************************************
41  *
42  * Configurable values
43  *
44  *************************************************************************/
45 
46 module_param_named(interrupt_mode, efx_interrupt_mode, uint, 0444);
47 MODULE_PARM_DESC(interrupt_mode,
48 		 "Interrupt mode (0=>MSIX 1=>MSI 2=>legacy)");
49 
50 module_param(rss_cpus, uint, 0444);
51 MODULE_PARM_DESC(rss_cpus, "Number of CPUs to use for Receive-Side Scaling");
52 
53 /*
54  * Use separate channels for TX and RX events
55  *
56  * Set this to 1 to use separate channels for TX and RX. It allows us
57  * to control interrupt affinity separately for TX and RX.
58  *
59  * This is only used in MSI-X interrupt mode
60  */
61 bool efx_separate_tx_channels;
62 module_param(efx_separate_tx_channels, bool, 0444);
63 MODULE_PARM_DESC(efx_separate_tx_channels,
64 		 "Use separate channels for TX and RX");
65 
66 /* Initial interrupt moderation settings.  They can be modified after
67  * module load with ethtool.
68  *
69  * The default for RX should strike a balance between increasing the
70  * round-trip latency and reducing overhead.
71  */
72 static unsigned int rx_irq_mod_usec = 60;
73 
74 /* Initial interrupt moderation settings.  They can be modified after
75  * module load with ethtool.
76  *
77  * This default is chosen to ensure that a 10G link does not go idle
78  * while a TX queue is stopped after it has become full.  A queue is
79  * restarted when it drops below half full.  The time this takes (assuming
80  * worst case 3 descriptors per packet and 1024 descriptors) is
81  *   512 / 3 * 1.2 = 205 usec.
82  */
83 static unsigned int tx_irq_mod_usec = 150;
84 
85 static bool phy_flash_cfg;
86 module_param(phy_flash_cfg, bool, 0644);
87 MODULE_PARM_DESC(phy_flash_cfg, "Set PHYs into reflash mode initially");
88 
89 static unsigned debug = (NETIF_MSG_DRV | NETIF_MSG_PROBE |
90 			 NETIF_MSG_LINK | NETIF_MSG_IFDOWN |
91 			 NETIF_MSG_IFUP | NETIF_MSG_RX_ERR |
92 			 NETIF_MSG_TX_ERR | NETIF_MSG_HW);
93 module_param(debug, uint, 0);
94 MODULE_PARM_DESC(debug, "Bitmapped debugging message enable value");
95 
96 /**************************************************************************
97  *
98  * Utility functions and prototypes
99  *
100  *************************************************************************/
101 
102 static void efx_remove_port(struct efx_nic *efx);
103 static int efx_xdp_setup_prog(struct efx_nic *efx, struct bpf_prog *prog);
104 static int efx_xdp(struct net_device *dev, struct netdev_bpf *xdp);
105 static int efx_xdp_xmit(struct net_device *dev, int n, struct xdp_frame **xdpfs,
106 			u32 flags);
107 
108 #define EFX_ASSERT_RESET_SERIALISED(efx)		\
109 	do {						\
110 		if ((efx->state == STATE_READY) ||	\
111 		    (efx->state == STATE_RECOVERY) ||	\
112 		    (efx->state == STATE_DISABLED))	\
113 			ASSERT_RTNL();			\
114 	} while (0)
115 
116 /**************************************************************************
117  *
118  * Port handling
119  *
120  **************************************************************************/
121 
122 static void efx_fini_port(struct efx_nic *efx);
123 
124 static int efx_probe_port(struct efx_nic *efx)
125 {
126 	int rc;
127 
128 	netif_dbg(efx, probe, efx->net_dev, "create port\n");
129 
130 	if (phy_flash_cfg)
131 		efx->phy_mode = PHY_MODE_SPECIAL;
132 
133 	/* Connect up MAC/PHY operations table */
134 	rc = efx->type->probe_port(efx);
135 	if (rc)
136 		return rc;
137 
138 	/* Initialise MAC address to permanent address */
139 	ether_addr_copy(efx->net_dev->dev_addr, efx->net_dev->perm_addr);
140 
141 	return 0;
142 }
143 
144 static int efx_init_port(struct efx_nic *efx)
145 {
146 	int rc;
147 
148 	netif_dbg(efx, drv, efx->net_dev, "init port\n");
149 
150 	mutex_lock(&efx->mac_lock);
151 
152 	rc = efx->phy_op->init(efx);
153 	if (rc)
154 		goto fail1;
155 
156 	efx->port_initialized = true;
157 
158 	/* Ensure the PHY advertises the correct flow control settings */
159 	rc = efx->phy_op->reconfigure(efx);
160 	if (rc && rc != -EPERM)
161 		goto fail2;
162 
163 	mutex_unlock(&efx->mac_lock);
164 	return 0;
165 
166 fail2:
167 	efx->phy_op->fini(efx);
168 fail1:
169 	mutex_unlock(&efx->mac_lock);
170 	return rc;
171 }
172 
173 static void efx_fini_port(struct efx_nic *efx)
174 {
175 	netif_dbg(efx, drv, efx->net_dev, "shut down port\n");
176 
177 	if (!efx->port_initialized)
178 		return;
179 
180 	efx->phy_op->fini(efx);
181 	efx->port_initialized = false;
182 
183 	efx->link_state.up = false;
184 	efx_link_status_changed(efx);
185 }
186 
187 static void efx_remove_port(struct efx_nic *efx)
188 {
189 	netif_dbg(efx, drv, efx->net_dev, "destroying port\n");
190 
191 	efx->type->remove_port(efx);
192 }
193 
194 /**************************************************************************
195  *
196  * NIC handling
197  *
198  **************************************************************************/
199 
200 static LIST_HEAD(efx_primary_list);
201 static LIST_HEAD(efx_unassociated_list);
202 
203 static bool efx_same_controller(struct efx_nic *left, struct efx_nic *right)
204 {
205 	return left->type == right->type &&
206 		left->vpd_sn && right->vpd_sn &&
207 		!strcmp(left->vpd_sn, right->vpd_sn);
208 }
209 
210 static void efx_associate(struct efx_nic *efx)
211 {
212 	struct efx_nic *other, *next;
213 
214 	if (efx->primary == efx) {
215 		/* Adding primary function; look for secondaries */
216 
217 		netif_dbg(efx, probe, efx->net_dev, "adding to primary list\n");
218 		list_add_tail(&efx->node, &efx_primary_list);
219 
220 		list_for_each_entry_safe(other, next, &efx_unassociated_list,
221 					 node) {
222 			if (efx_same_controller(efx, other)) {
223 				list_del(&other->node);
224 				netif_dbg(other, probe, other->net_dev,
225 					  "moving to secondary list of %s %s\n",
226 					  pci_name(efx->pci_dev),
227 					  efx->net_dev->name);
228 				list_add_tail(&other->node,
229 					      &efx->secondary_list);
230 				other->primary = efx;
231 			}
232 		}
233 	} else {
234 		/* Adding secondary function; look for primary */
235 
236 		list_for_each_entry(other, &efx_primary_list, node) {
237 			if (efx_same_controller(efx, other)) {
238 				netif_dbg(efx, probe, efx->net_dev,
239 					  "adding to secondary list of %s %s\n",
240 					  pci_name(other->pci_dev),
241 					  other->net_dev->name);
242 				list_add_tail(&efx->node,
243 					      &other->secondary_list);
244 				efx->primary = other;
245 				return;
246 			}
247 		}
248 
249 		netif_dbg(efx, probe, efx->net_dev,
250 			  "adding to unassociated list\n");
251 		list_add_tail(&efx->node, &efx_unassociated_list);
252 	}
253 }
254 
255 static void efx_dissociate(struct efx_nic *efx)
256 {
257 	struct efx_nic *other, *next;
258 
259 	list_del(&efx->node);
260 	efx->primary = NULL;
261 
262 	list_for_each_entry_safe(other, next, &efx->secondary_list, node) {
263 		list_del(&other->node);
264 		netif_dbg(other, probe, other->net_dev,
265 			  "moving to unassociated list\n");
266 		list_add_tail(&other->node, &efx_unassociated_list);
267 		other->primary = NULL;
268 	}
269 }
270 
271 static int efx_probe_nic(struct efx_nic *efx)
272 {
273 	int rc;
274 
275 	netif_dbg(efx, probe, efx->net_dev, "creating NIC\n");
276 
277 	/* Carry out hardware-type specific initialisation */
278 	rc = efx->type->probe(efx);
279 	if (rc)
280 		return rc;
281 
282 	do {
283 		if (!efx->max_channels || !efx->max_tx_channels) {
284 			netif_err(efx, drv, efx->net_dev,
285 				  "Insufficient resources to allocate"
286 				  " any channels\n");
287 			rc = -ENOSPC;
288 			goto fail1;
289 		}
290 
291 		/* Determine the number of channels and queues by trying
292 		 * to hook in MSI-X interrupts.
293 		 */
294 		rc = efx_probe_interrupts(efx);
295 		if (rc)
296 			goto fail1;
297 
298 		rc = efx_set_channels(efx);
299 		if (rc)
300 			goto fail1;
301 
302 		/* dimension_resources can fail with EAGAIN */
303 		rc = efx->type->dimension_resources(efx);
304 		if (rc != 0 && rc != -EAGAIN)
305 			goto fail2;
306 
307 		if (rc == -EAGAIN)
308 			/* try again with new max_channels */
309 			efx_remove_interrupts(efx);
310 
311 	} while (rc == -EAGAIN);
312 
313 	if (efx->n_channels > 1)
314 		netdev_rss_key_fill(efx->rss_context.rx_hash_key,
315 				    sizeof(efx->rss_context.rx_hash_key));
316 	efx_set_default_rx_indir_table(efx, &efx->rss_context);
317 
318 	/* Initialise the interrupt moderation settings */
319 	efx->irq_mod_step_us = DIV_ROUND_UP(efx->timer_quantum_ns, 1000);
320 	efx_init_irq_moderation(efx, tx_irq_mod_usec, rx_irq_mod_usec, true,
321 				true);
322 
323 	return 0;
324 
325 fail2:
326 	efx_remove_interrupts(efx);
327 fail1:
328 	efx->type->remove(efx);
329 	return rc;
330 }
331 
332 static void efx_remove_nic(struct efx_nic *efx)
333 {
334 	netif_dbg(efx, drv, efx->net_dev, "destroying NIC\n");
335 
336 	efx_remove_interrupts(efx);
337 	efx->type->remove(efx);
338 }
339 
340 /**************************************************************************
341  *
342  * NIC startup/shutdown
343  *
344  *************************************************************************/
345 
346 static int efx_probe_all(struct efx_nic *efx)
347 {
348 	int rc;
349 
350 	rc = efx_probe_nic(efx);
351 	if (rc) {
352 		netif_err(efx, probe, efx->net_dev, "failed to create NIC\n");
353 		goto fail1;
354 	}
355 
356 	rc = efx_probe_port(efx);
357 	if (rc) {
358 		netif_err(efx, probe, efx->net_dev, "failed to create port\n");
359 		goto fail2;
360 	}
361 
362 	BUILD_BUG_ON(EFX_DEFAULT_DMAQ_SIZE < EFX_RXQ_MIN_ENT);
363 	if (WARN_ON(EFX_DEFAULT_DMAQ_SIZE < EFX_TXQ_MIN_ENT(efx))) {
364 		rc = -EINVAL;
365 		goto fail3;
366 	}
367 
368 #ifdef CONFIG_SFC_SRIOV
369 	rc = efx->type->vswitching_probe(efx);
370 	if (rc) /* not fatal; the PF will still work fine */
371 		netif_warn(efx, probe, efx->net_dev,
372 			   "failed to setup vswitching rc=%d;"
373 			   " VFs may not function\n", rc);
374 #endif
375 
376 	rc = efx_probe_filters(efx);
377 	if (rc) {
378 		netif_err(efx, probe, efx->net_dev,
379 			  "failed to create filter tables\n");
380 		goto fail4;
381 	}
382 
383 	rc = efx_probe_channels(efx);
384 	if (rc)
385 		goto fail5;
386 
387 	return 0;
388 
389  fail5:
390 	efx_remove_filters(efx);
391  fail4:
392 #ifdef CONFIG_SFC_SRIOV
393 	efx->type->vswitching_remove(efx);
394 #endif
395  fail3:
396 	efx_remove_port(efx);
397  fail2:
398 	efx_remove_nic(efx);
399  fail1:
400 	return rc;
401 }
402 
403 static void efx_remove_all(struct efx_nic *efx)
404 {
405 	rtnl_lock();
406 	efx_xdp_setup_prog(efx, NULL);
407 	rtnl_unlock();
408 
409 	efx_remove_channels(efx);
410 	efx_remove_filters(efx);
411 #ifdef CONFIG_SFC_SRIOV
412 	efx->type->vswitching_remove(efx);
413 #endif
414 	efx_remove_port(efx);
415 	efx_remove_nic(efx);
416 }
417 
418 /**************************************************************************
419  *
420  * Interrupt moderation
421  *
422  **************************************************************************/
423 unsigned int efx_usecs_to_ticks(struct efx_nic *efx, unsigned int usecs)
424 {
425 	if (usecs == 0)
426 		return 0;
427 	if (usecs * 1000 < efx->timer_quantum_ns)
428 		return 1; /* never round down to 0 */
429 	return usecs * 1000 / efx->timer_quantum_ns;
430 }
431 
432 unsigned int efx_ticks_to_usecs(struct efx_nic *efx, unsigned int ticks)
433 {
434 	/* We must round up when converting ticks to microseconds
435 	 * because we round down when converting the other way.
436 	 */
437 	return DIV_ROUND_UP(ticks * efx->timer_quantum_ns, 1000);
438 }
439 
440 /* Set interrupt moderation parameters */
441 int efx_init_irq_moderation(struct efx_nic *efx, unsigned int tx_usecs,
442 			    unsigned int rx_usecs, bool rx_adaptive,
443 			    bool rx_may_override_tx)
444 {
445 	struct efx_channel *channel;
446 	unsigned int timer_max_us;
447 
448 	EFX_ASSERT_RESET_SERIALISED(efx);
449 
450 	timer_max_us = efx->timer_max_ns / 1000;
451 
452 	if (tx_usecs > timer_max_us || rx_usecs > timer_max_us)
453 		return -EINVAL;
454 
455 	if (tx_usecs != rx_usecs && efx->tx_channel_offset == 0 &&
456 	    !rx_may_override_tx) {
457 		netif_err(efx, drv, efx->net_dev, "Channels are shared. "
458 			  "RX and TX IRQ moderation must be equal\n");
459 		return -EINVAL;
460 	}
461 
462 	efx->irq_rx_adaptive = rx_adaptive;
463 	efx->irq_rx_moderation_us = rx_usecs;
464 	efx_for_each_channel(channel, efx) {
465 		if (efx_channel_has_rx_queue(channel))
466 			channel->irq_moderation_us = rx_usecs;
467 		else if (efx_channel_has_tx_queues(channel))
468 			channel->irq_moderation_us = tx_usecs;
469 		else if (efx_channel_is_xdp_tx(channel))
470 			channel->irq_moderation_us = tx_usecs;
471 	}
472 
473 	return 0;
474 }
475 
476 void efx_get_irq_moderation(struct efx_nic *efx, unsigned int *tx_usecs,
477 			    unsigned int *rx_usecs, bool *rx_adaptive)
478 {
479 	*rx_adaptive = efx->irq_rx_adaptive;
480 	*rx_usecs = efx->irq_rx_moderation_us;
481 
482 	/* If channels are shared between RX and TX, so is IRQ
483 	 * moderation.  Otherwise, IRQ moderation is the same for all
484 	 * TX channels and is not adaptive.
485 	 */
486 	if (efx->tx_channel_offset == 0) {
487 		*tx_usecs = *rx_usecs;
488 	} else {
489 		struct efx_channel *tx_channel;
490 
491 		tx_channel = efx->channel[efx->tx_channel_offset];
492 		*tx_usecs = tx_channel->irq_moderation_us;
493 	}
494 }
495 
496 /**************************************************************************
497  *
498  * ioctls
499  *
500  *************************************************************************/
501 
502 /* Net device ioctl
503  * Context: process, rtnl_lock() held.
504  */
505 static int efx_ioctl(struct net_device *net_dev, struct ifreq *ifr, int cmd)
506 {
507 	struct efx_nic *efx = netdev_priv(net_dev);
508 	struct mii_ioctl_data *data = if_mii(ifr);
509 
510 	if (cmd == SIOCSHWTSTAMP)
511 		return efx_ptp_set_ts_config(efx, ifr);
512 	if (cmd == SIOCGHWTSTAMP)
513 		return efx_ptp_get_ts_config(efx, ifr);
514 
515 	/* Convert phy_id from older PRTAD/DEVAD format */
516 	if ((cmd == SIOCGMIIREG || cmd == SIOCSMIIREG) &&
517 	    (data->phy_id & 0xfc00) == 0x0400)
518 		data->phy_id ^= MDIO_PHY_ID_C45 | 0x0400;
519 
520 	return mdio_mii_ioctl(&efx->mdio, data, cmd);
521 }
522 
523 /**************************************************************************
524  *
525  * Kernel net device interface
526  *
527  *************************************************************************/
528 
529 /* Context: process, rtnl_lock() held. */
530 int efx_net_open(struct net_device *net_dev)
531 {
532 	struct efx_nic *efx = netdev_priv(net_dev);
533 	int rc;
534 
535 	netif_dbg(efx, ifup, efx->net_dev, "opening device on CPU %d\n",
536 		  raw_smp_processor_id());
537 
538 	rc = efx_check_disabled(efx);
539 	if (rc)
540 		return rc;
541 	if (efx->phy_mode & PHY_MODE_SPECIAL)
542 		return -EBUSY;
543 	if (efx_mcdi_poll_reboot(efx) && efx_reset(efx, RESET_TYPE_ALL))
544 		return -EIO;
545 
546 	/* Notify the kernel of the link state polled during driver load,
547 	 * before the monitor starts running */
548 	efx_link_status_changed(efx);
549 
550 	efx_start_all(efx);
551 	if (efx->state == STATE_DISABLED || efx->reset_pending)
552 		netif_device_detach(efx->net_dev);
553 	efx_selftest_async_start(efx);
554 	return 0;
555 }
556 
557 /* Context: process, rtnl_lock() held.
558  * Note that the kernel will ignore our return code; this method
559  * should really be a void.
560  */
561 int efx_net_stop(struct net_device *net_dev)
562 {
563 	struct efx_nic *efx = netdev_priv(net_dev);
564 
565 	netif_dbg(efx, ifdown, efx->net_dev, "closing on CPU %d\n",
566 		  raw_smp_processor_id());
567 
568 	/* Stop the device and flush all the channels */
569 	efx_stop_all(efx);
570 
571 	return 0;
572 }
573 
574 static int efx_vlan_rx_add_vid(struct net_device *net_dev, __be16 proto, u16 vid)
575 {
576 	struct efx_nic *efx = netdev_priv(net_dev);
577 
578 	if (efx->type->vlan_rx_add_vid)
579 		return efx->type->vlan_rx_add_vid(efx, proto, vid);
580 	else
581 		return -EOPNOTSUPP;
582 }
583 
584 static int efx_vlan_rx_kill_vid(struct net_device *net_dev, __be16 proto, u16 vid)
585 {
586 	struct efx_nic *efx = netdev_priv(net_dev);
587 
588 	if (efx->type->vlan_rx_kill_vid)
589 		return efx->type->vlan_rx_kill_vid(efx, proto, vid);
590 	else
591 		return -EOPNOTSUPP;
592 }
593 
594 static const struct net_device_ops efx_netdev_ops = {
595 	.ndo_open		= efx_net_open,
596 	.ndo_stop		= efx_net_stop,
597 	.ndo_get_stats64	= efx_net_stats,
598 	.ndo_tx_timeout		= efx_watchdog,
599 	.ndo_start_xmit		= efx_hard_start_xmit,
600 	.ndo_validate_addr	= eth_validate_addr,
601 	.ndo_do_ioctl		= efx_ioctl,
602 	.ndo_change_mtu		= efx_change_mtu,
603 	.ndo_set_mac_address	= efx_set_mac_address,
604 	.ndo_set_rx_mode	= efx_set_rx_mode,
605 	.ndo_set_features	= efx_set_features,
606 	.ndo_vlan_rx_add_vid	= efx_vlan_rx_add_vid,
607 	.ndo_vlan_rx_kill_vid	= efx_vlan_rx_kill_vid,
608 #ifdef CONFIG_SFC_SRIOV
609 	.ndo_set_vf_mac		= efx_sriov_set_vf_mac,
610 	.ndo_set_vf_vlan	= efx_sriov_set_vf_vlan,
611 	.ndo_set_vf_spoofchk	= efx_sriov_set_vf_spoofchk,
612 	.ndo_get_vf_config	= efx_sriov_get_vf_config,
613 	.ndo_set_vf_link_state  = efx_sriov_set_vf_link_state,
614 #endif
615 	.ndo_get_phys_port_id   = efx_get_phys_port_id,
616 	.ndo_get_phys_port_name	= efx_get_phys_port_name,
617 	.ndo_setup_tc		= efx_setup_tc,
618 #ifdef CONFIG_RFS_ACCEL
619 	.ndo_rx_flow_steer	= efx_filter_rfs,
620 #endif
621 	.ndo_udp_tunnel_add	= udp_tunnel_nic_add_port,
622 	.ndo_udp_tunnel_del	= udp_tunnel_nic_del_port,
623 	.ndo_xdp_xmit		= efx_xdp_xmit,
624 	.ndo_bpf		= efx_xdp
625 };
626 
627 static int efx_xdp_setup_prog(struct efx_nic *efx, struct bpf_prog *prog)
628 {
629 	struct bpf_prog *old_prog;
630 
631 	if (efx->xdp_rxq_info_failed) {
632 		netif_err(efx, drv, efx->net_dev,
633 			  "Unable to bind XDP program due to previous failure of rxq_info\n");
634 		return -EINVAL;
635 	}
636 
637 	if (prog && efx->net_dev->mtu > efx_xdp_max_mtu(efx)) {
638 		netif_err(efx, drv, efx->net_dev,
639 			  "Unable to configure XDP with MTU of %d (max: %d)\n",
640 			  efx->net_dev->mtu, efx_xdp_max_mtu(efx));
641 		return -EINVAL;
642 	}
643 
644 	old_prog = rtnl_dereference(efx->xdp_prog);
645 	rcu_assign_pointer(efx->xdp_prog, prog);
646 	/* Release the reference that was originally passed by the caller. */
647 	if (old_prog)
648 		bpf_prog_put(old_prog);
649 
650 	return 0;
651 }
652 
653 /* Context: process, rtnl_lock() held. */
654 static int efx_xdp(struct net_device *dev, struct netdev_bpf *xdp)
655 {
656 	struct efx_nic *efx = netdev_priv(dev);
657 
658 	switch (xdp->command) {
659 	case XDP_SETUP_PROG:
660 		return efx_xdp_setup_prog(efx, xdp->prog);
661 	default:
662 		return -EINVAL;
663 	}
664 }
665 
666 static int efx_xdp_xmit(struct net_device *dev, int n, struct xdp_frame **xdpfs,
667 			u32 flags)
668 {
669 	struct efx_nic *efx = netdev_priv(dev);
670 
671 	if (!netif_running(dev))
672 		return -EINVAL;
673 
674 	return efx_xdp_tx_buffers(efx, n, xdpfs, flags & XDP_XMIT_FLUSH);
675 }
676 
677 static void efx_update_name(struct efx_nic *efx)
678 {
679 	strcpy(efx->name, efx->net_dev->name);
680 	efx_mtd_rename(efx);
681 	efx_set_channel_names(efx);
682 }
683 
684 static int efx_netdev_event(struct notifier_block *this,
685 			    unsigned long event, void *ptr)
686 {
687 	struct net_device *net_dev = netdev_notifier_info_to_dev(ptr);
688 
689 	if ((net_dev->netdev_ops == &efx_netdev_ops) &&
690 	    event == NETDEV_CHANGENAME)
691 		efx_update_name(netdev_priv(net_dev));
692 
693 	return NOTIFY_DONE;
694 }
695 
696 static struct notifier_block efx_netdev_notifier = {
697 	.notifier_call = efx_netdev_event,
698 };
699 
700 static ssize_t
701 show_phy_type(struct device *dev, struct device_attribute *attr, char *buf)
702 {
703 	struct efx_nic *efx = dev_get_drvdata(dev);
704 	return sprintf(buf, "%d\n", efx->phy_type);
705 }
706 static DEVICE_ATTR(phy_type, 0444, show_phy_type, NULL);
707 
708 static int efx_register_netdev(struct efx_nic *efx)
709 {
710 	struct net_device *net_dev = efx->net_dev;
711 	struct efx_channel *channel;
712 	int rc;
713 
714 	net_dev->watchdog_timeo = 5 * HZ;
715 	net_dev->irq = efx->pci_dev->irq;
716 	net_dev->netdev_ops = &efx_netdev_ops;
717 	if (efx_nic_rev(efx) >= EFX_REV_HUNT_A0)
718 		net_dev->priv_flags |= IFF_UNICAST_FLT;
719 	net_dev->ethtool_ops = &efx_ethtool_ops;
720 	net_dev->gso_max_segs = EFX_TSO_MAX_SEGS;
721 	net_dev->min_mtu = EFX_MIN_MTU;
722 	net_dev->max_mtu = EFX_MAX_MTU;
723 
724 	rtnl_lock();
725 
726 	/* Enable resets to be scheduled and check whether any were
727 	 * already requested.  If so, the NIC is probably hosed so we
728 	 * abort.
729 	 */
730 	efx->state = STATE_READY;
731 	smp_mb(); /* ensure we change state before checking reset_pending */
732 	if (efx->reset_pending) {
733 		netif_err(efx, probe, efx->net_dev,
734 			  "aborting probe due to scheduled reset\n");
735 		rc = -EIO;
736 		goto fail_locked;
737 	}
738 
739 	rc = dev_alloc_name(net_dev, net_dev->name);
740 	if (rc < 0)
741 		goto fail_locked;
742 	efx_update_name(efx);
743 
744 	/* Always start with carrier off; PHY events will detect the link */
745 	netif_carrier_off(net_dev);
746 
747 	rc = register_netdevice(net_dev);
748 	if (rc)
749 		goto fail_locked;
750 
751 	efx_for_each_channel(channel, efx) {
752 		struct efx_tx_queue *tx_queue;
753 		efx_for_each_channel_tx_queue(tx_queue, channel)
754 			efx_init_tx_queue_core_txq(tx_queue);
755 	}
756 
757 	efx_associate(efx);
758 
759 	rtnl_unlock();
760 
761 	rc = device_create_file(&efx->pci_dev->dev, &dev_attr_phy_type);
762 	if (rc) {
763 		netif_err(efx, drv, efx->net_dev,
764 			  "failed to init net dev attributes\n");
765 		goto fail_registered;
766 	}
767 
768 	efx_init_mcdi_logging(efx);
769 
770 	return 0;
771 
772 fail_registered:
773 	rtnl_lock();
774 	efx_dissociate(efx);
775 	unregister_netdevice(net_dev);
776 fail_locked:
777 	efx->state = STATE_UNINIT;
778 	rtnl_unlock();
779 	netif_err(efx, drv, efx->net_dev, "could not register net dev\n");
780 	return rc;
781 }
782 
783 static void efx_unregister_netdev(struct efx_nic *efx)
784 {
785 	if (!efx->net_dev)
786 		return;
787 
788 	BUG_ON(netdev_priv(efx->net_dev) != efx);
789 
790 	if (efx_dev_registered(efx)) {
791 		strlcpy(efx->name, pci_name(efx->pci_dev), sizeof(efx->name));
792 		efx_fini_mcdi_logging(efx);
793 		device_remove_file(&efx->pci_dev->dev, &dev_attr_phy_type);
794 		unregister_netdev(efx->net_dev);
795 	}
796 }
797 
798 /**************************************************************************
799  *
800  * List of NICs we support
801  *
802  **************************************************************************/
803 
804 /* PCI device ID table */
805 static const struct pci_device_id efx_pci_table[] = {
806 	{PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x0803),	/* SFC9020 */
807 	 .driver_data = (unsigned long) &siena_a0_nic_type},
808 	{PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x0813),	/* SFL9021 */
809 	 .driver_data = (unsigned long) &siena_a0_nic_type},
810 	{PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x0903),  /* SFC9120 PF */
811 	 .driver_data = (unsigned long) &efx_hunt_a0_nic_type},
812 	{PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x1903),  /* SFC9120 VF */
813 	 .driver_data = (unsigned long) &efx_hunt_a0_vf_nic_type},
814 	{PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x0923),  /* SFC9140 PF */
815 	 .driver_data = (unsigned long) &efx_hunt_a0_nic_type},
816 	{PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x1923),  /* SFC9140 VF */
817 	 .driver_data = (unsigned long) &efx_hunt_a0_vf_nic_type},
818 	{PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x0a03),  /* SFC9220 PF */
819 	 .driver_data = (unsigned long) &efx_hunt_a0_nic_type},
820 	{PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x1a03),  /* SFC9220 VF */
821 	 .driver_data = (unsigned long) &efx_hunt_a0_vf_nic_type},
822 	{PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x0b03),  /* SFC9250 PF */
823 	 .driver_data = (unsigned long) &efx_hunt_a0_nic_type},
824 	{PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE, 0x1b03),  /* SFC9250 VF */
825 	 .driver_data = (unsigned long) &efx_hunt_a0_vf_nic_type},
826 	{0}			/* end of list */
827 };
828 
829 /**************************************************************************
830  *
831  * Data housekeeping
832  *
833  **************************************************************************/
834 
835 void efx_update_sw_stats(struct efx_nic *efx, u64 *stats)
836 {
837 	u64 n_rx_nodesc_trunc = 0;
838 	struct efx_channel *channel;
839 
840 	efx_for_each_channel(channel, efx)
841 		n_rx_nodesc_trunc += channel->n_rx_nodesc_trunc;
842 	stats[GENERIC_STAT_rx_nodesc_trunc] = n_rx_nodesc_trunc;
843 	stats[GENERIC_STAT_rx_noskb_drops] = atomic_read(&efx->n_rx_noskb_drops);
844 }
845 
846 /**************************************************************************
847  *
848  * PCI interface
849  *
850  **************************************************************************/
851 
852 /* Main body of final NIC shutdown code
853  * This is called only at module unload (or hotplug removal).
854  */
855 static void efx_pci_remove_main(struct efx_nic *efx)
856 {
857 	/* Flush reset_work. It can no longer be scheduled since we
858 	 * are not READY.
859 	 */
860 	BUG_ON(efx->state == STATE_READY);
861 	efx_flush_reset_workqueue(efx);
862 
863 	efx_disable_interrupts(efx);
864 	efx_clear_interrupt_affinity(efx);
865 	efx_nic_fini_interrupt(efx);
866 	efx_fini_port(efx);
867 	efx->type->fini(efx);
868 	efx_fini_napi(efx);
869 	efx_remove_all(efx);
870 }
871 
872 /* Final NIC shutdown
873  * This is called only at module unload (or hotplug removal).  A PF can call
874  * this on its VFs to ensure they are unbound first.
875  */
876 static void efx_pci_remove(struct pci_dev *pci_dev)
877 {
878 	struct efx_nic *efx;
879 
880 	efx = pci_get_drvdata(pci_dev);
881 	if (!efx)
882 		return;
883 
884 	/* Mark the NIC as fini, then stop the interface */
885 	rtnl_lock();
886 	efx_dissociate(efx);
887 	dev_close(efx->net_dev);
888 	efx_disable_interrupts(efx);
889 	efx->state = STATE_UNINIT;
890 	rtnl_unlock();
891 
892 	if (efx->type->sriov_fini)
893 		efx->type->sriov_fini(efx);
894 
895 	efx_unregister_netdev(efx);
896 
897 	efx_mtd_remove(efx);
898 
899 	efx_pci_remove_main(efx);
900 
901 	efx_fini_io(efx);
902 	netif_dbg(efx, drv, efx->net_dev, "shutdown successful\n");
903 
904 	efx_fini_struct(efx);
905 	free_netdev(efx->net_dev);
906 
907 	pci_disable_pcie_error_reporting(pci_dev);
908 };
909 
910 /* NIC VPD information
911  * Called during probe to display the part number of the
912  * installed NIC.  VPD is potentially very large but this should
913  * always appear within the first 512 bytes.
914  */
915 #define SFC_VPD_LEN 512
916 static void efx_probe_vpd_strings(struct efx_nic *efx)
917 {
918 	struct pci_dev *dev = efx->pci_dev;
919 	char vpd_data[SFC_VPD_LEN];
920 	ssize_t vpd_size;
921 	int ro_start, ro_size, i, j;
922 
923 	/* Get the vpd data from the device */
924 	vpd_size = pci_read_vpd(dev, 0, sizeof(vpd_data), vpd_data);
925 	if (vpd_size <= 0) {
926 		netif_err(efx, drv, efx->net_dev, "Unable to read VPD\n");
927 		return;
928 	}
929 
930 	/* Get the Read only section */
931 	ro_start = pci_vpd_find_tag(vpd_data, 0, vpd_size, PCI_VPD_LRDT_RO_DATA);
932 	if (ro_start < 0) {
933 		netif_err(efx, drv, efx->net_dev, "VPD Read-only not found\n");
934 		return;
935 	}
936 
937 	ro_size = pci_vpd_lrdt_size(&vpd_data[ro_start]);
938 	j = ro_size;
939 	i = ro_start + PCI_VPD_LRDT_TAG_SIZE;
940 	if (i + j > vpd_size)
941 		j = vpd_size - i;
942 
943 	/* Get the Part number */
944 	i = pci_vpd_find_info_keyword(vpd_data, i, j, "PN");
945 	if (i < 0) {
946 		netif_err(efx, drv, efx->net_dev, "Part number not found\n");
947 		return;
948 	}
949 
950 	j = pci_vpd_info_field_size(&vpd_data[i]);
951 	i += PCI_VPD_INFO_FLD_HDR_SIZE;
952 	if (i + j > vpd_size) {
953 		netif_err(efx, drv, efx->net_dev, "Incomplete part number\n");
954 		return;
955 	}
956 
957 	netif_info(efx, drv, efx->net_dev,
958 		   "Part Number : %.*s\n", j, &vpd_data[i]);
959 
960 	i = ro_start + PCI_VPD_LRDT_TAG_SIZE;
961 	j = ro_size;
962 	i = pci_vpd_find_info_keyword(vpd_data, i, j, "SN");
963 	if (i < 0) {
964 		netif_err(efx, drv, efx->net_dev, "Serial number not found\n");
965 		return;
966 	}
967 
968 	j = pci_vpd_info_field_size(&vpd_data[i]);
969 	i += PCI_VPD_INFO_FLD_HDR_SIZE;
970 	if (i + j > vpd_size) {
971 		netif_err(efx, drv, efx->net_dev, "Incomplete serial number\n");
972 		return;
973 	}
974 
975 	efx->vpd_sn = kmalloc(j + 1, GFP_KERNEL);
976 	if (!efx->vpd_sn)
977 		return;
978 
979 	snprintf(efx->vpd_sn, j + 1, "%s", &vpd_data[i]);
980 }
981 
982 
983 /* Main body of NIC initialisation
984  * This is called at module load (or hotplug insertion, theoretically).
985  */
986 static int efx_pci_probe_main(struct efx_nic *efx)
987 {
988 	int rc;
989 
990 	/* Do start-of-day initialisation */
991 	rc = efx_probe_all(efx);
992 	if (rc)
993 		goto fail1;
994 
995 	efx_init_napi(efx);
996 
997 	down_write(&efx->filter_sem);
998 	rc = efx->type->init(efx);
999 	up_write(&efx->filter_sem);
1000 	if (rc) {
1001 		netif_err(efx, probe, efx->net_dev,
1002 			  "failed to initialise NIC\n");
1003 		goto fail3;
1004 	}
1005 
1006 	rc = efx_init_port(efx);
1007 	if (rc) {
1008 		netif_err(efx, probe, efx->net_dev,
1009 			  "failed to initialise port\n");
1010 		goto fail4;
1011 	}
1012 
1013 	rc = efx_nic_init_interrupt(efx);
1014 	if (rc)
1015 		goto fail5;
1016 
1017 	efx_set_interrupt_affinity(efx);
1018 	rc = efx_enable_interrupts(efx);
1019 	if (rc)
1020 		goto fail6;
1021 
1022 	return 0;
1023 
1024  fail6:
1025 	efx_clear_interrupt_affinity(efx);
1026 	efx_nic_fini_interrupt(efx);
1027  fail5:
1028 	efx_fini_port(efx);
1029  fail4:
1030 	efx->type->fini(efx);
1031  fail3:
1032 	efx_fini_napi(efx);
1033 	efx_remove_all(efx);
1034  fail1:
1035 	return rc;
1036 }
1037 
1038 static int efx_pci_probe_post_io(struct efx_nic *efx)
1039 {
1040 	struct net_device *net_dev = efx->net_dev;
1041 	int rc = efx_pci_probe_main(efx);
1042 
1043 	if (rc)
1044 		return rc;
1045 
1046 	if (efx->type->sriov_init) {
1047 		rc = efx->type->sriov_init(efx);
1048 		if (rc)
1049 			netif_err(efx, probe, efx->net_dev,
1050 				  "SR-IOV can't be enabled rc %d\n", rc);
1051 	}
1052 
1053 	/* Determine netdevice features */
1054 	net_dev->features |= (efx->type->offload_features | NETIF_F_SG |
1055 			      NETIF_F_TSO | NETIF_F_RXCSUM | NETIF_F_RXALL);
1056 	if (efx->type->offload_features & (NETIF_F_IPV6_CSUM | NETIF_F_HW_CSUM))
1057 		net_dev->features |= NETIF_F_TSO6;
1058 	/* Check whether device supports TSO */
1059 	if (!efx->type->tso_versions || !efx->type->tso_versions(efx))
1060 		net_dev->features &= ~NETIF_F_ALL_TSO;
1061 	/* Mask for features that also apply to VLAN devices */
1062 	net_dev->vlan_features |= (NETIF_F_HW_CSUM | NETIF_F_SG |
1063 				   NETIF_F_HIGHDMA | NETIF_F_ALL_TSO |
1064 				   NETIF_F_RXCSUM);
1065 
1066 	net_dev->hw_features |= net_dev->features & ~efx->fixed_features;
1067 
1068 	/* Disable receiving frames with bad FCS, by default. */
1069 	net_dev->features &= ~NETIF_F_RXALL;
1070 
1071 	/* Disable VLAN filtering by default.  It may be enforced if
1072 	 * the feature is fixed (i.e. VLAN filters are required to
1073 	 * receive VLAN tagged packets due to vPort restrictions).
1074 	 */
1075 	net_dev->features &= ~NETIF_F_HW_VLAN_CTAG_FILTER;
1076 	net_dev->features |= efx->fixed_features;
1077 
1078 	rc = efx_register_netdev(efx);
1079 	if (!rc)
1080 		return 0;
1081 
1082 	efx_pci_remove_main(efx);
1083 	return rc;
1084 }
1085 
1086 /* NIC initialisation
1087  *
1088  * This is called at module load (or hotplug insertion,
1089  * theoretically).  It sets up PCI mappings, resets the NIC,
1090  * sets up and registers the network devices with the kernel and hooks
1091  * the interrupt service routine.  It does not prepare the device for
1092  * transmission; this is left to the first time one of the network
1093  * interfaces is brought up (i.e. efx_net_open).
1094  */
1095 static int efx_pci_probe(struct pci_dev *pci_dev,
1096 			 const struct pci_device_id *entry)
1097 {
1098 	struct net_device *net_dev;
1099 	struct efx_nic *efx;
1100 	int rc;
1101 
1102 	/* Allocate and initialise a struct net_device and struct efx_nic */
1103 	net_dev = alloc_etherdev_mqs(sizeof(*efx), EFX_MAX_CORE_TX_QUEUES,
1104 				     EFX_MAX_RX_QUEUES);
1105 	if (!net_dev)
1106 		return -ENOMEM;
1107 	efx = netdev_priv(net_dev);
1108 	efx->type = (const struct efx_nic_type *) entry->driver_data;
1109 	efx->fixed_features |= NETIF_F_HIGHDMA;
1110 
1111 	pci_set_drvdata(pci_dev, efx);
1112 	SET_NETDEV_DEV(net_dev, &pci_dev->dev);
1113 	rc = efx_init_struct(efx, pci_dev, net_dev);
1114 	if (rc)
1115 		goto fail1;
1116 
1117 	netif_info(efx, probe, efx->net_dev,
1118 		   "Solarflare NIC detected\n");
1119 
1120 	if (!efx->type->is_vf)
1121 		efx_probe_vpd_strings(efx);
1122 
1123 	/* Set up basic I/O (BAR mappings etc) */
1124 	rc = efx_init_io(efx, efx->type->mem_bar(efx), efx->type->max_dma_mask,
1125 			 efx->type->mem_map_size(efx));
1126 	if (rc)
1127 		goto fail2;
1128 
1129 	rc = efx_pci_probe_post_io(efx);
1130 	if (rc) {
1131 		/* On failure, retry once immediately.
1132 		 * If we aborted probe due to a scheduled reset, dismiss it.
1133 		 */
1134 		efx->reset_pending = 0;
1135 		rc = efx_pci_probe_post_io(efx);
1136 		if (rc) {
1137 			/* On another failure, retry once more
1138 			 * after a 50-305ms delay.
1139 			 */
1140 			unsigned char r;
1141 
1142 			get_random_bytes(&r, 1);
1143 			msleep((unsigned int)r + 50);
1144 			efx->reset_pending = 0;
1145 			rc = efx_pci_probe_post_io(efx);
1146 		}
1147 	}
1148 	if (rc)
1149 		goto fail3;
1150 
1151 	netif_dbg(efx, probe, efx->net_dev, "initialisation successful\n");
1152 
1153 	/* Try to create MTDs, but allow this to fail */
1154 	rtnl_lock();
1155 	rc = efx_mtd_probe(efx);
1156 	rtnl_unlock();
1157 	if (rc && rc != -EPERM)
1158 		netif_warn(efx, probe, efx->net_dev,
1159 			   "failed to create MTDs (%d)\n", rc);
1160 
1161 	(void)pci_enable_pcie_error_reporting(pci_dev);
1162 
1163 	if (efx->type->udp_tnl_push_ports)
1164 		efx->type->udp_tnl_push_ports(efx);
1165 
1166 	return 0;
1167 
1168  fail3:
1169 	efx_fini_io(efx);
1170  fail2:
1171 	efx_fini_struct(efx);
1172  fail1:
1173 	WARN_ON(rc > 0);
1174 	netif_dbg(efx, drv, efx->net_dev, "initialisation failed. rc=%d\n", rc);
1175 	free_netdev(net_dev);
1176 	return rc;
1177 }
1178 
1179 /* efx_pci_sriov_configure returns the actual number of Virtual Functions
1180  * enabled on success
1181  */
1182 #ifdef CONFIG_SFC_SRIOV
1183 static int efx_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
1184 {
1185 	int rc;
1186 	struct efx_nic *efx = pci_get_drvdata(dev);
1187 
1188 	if (efx->type->sriov_configure) {
1189 		rc = efx->type->sriov_configure(efx, num_vfs);
1190 		if (rc)
1191 			return rc;
1192 		else
1193 			return num_vfs;
1194 	} else
1195 		return -EOPNOTSUPP;
1196 }
1197 #endif
1198 
1199 static int efx_pm_freeze(struct device *dev)
1200 {
1201 	struct efx_nic *efx = dev_get_drvdata(dev);
1202 
1203 	rtnl_lock();
1204 
1205 	if (efx->state != STATE_DISABLED) {
1206 		efx->state = STATE_UNINIT;
1207 
1208 		efx_device_detach_sync(efx);
1209 
1210 		efx_stop_all(efx);
1211 		efx_disable_interrupts(efx);
1212 	}
1213 
1214 	rtnl_unlock();
1215 
1216 	return 0;
1217 }
1218 
1219 static int efx_pm_thaw(struct device *dev)
1220 {
1221 	int rc;
1222 	struct efx_nic *efx = dev_get_drvdata(dev);
1223 
1224 	rtnl_lock();
1225 
1226 	if (efx->state != STATE_DISABLED) {
1227 		rc = efx_enable_interrupts(efx);
1228 		if (rc)
1229 			goto fail;
1230 
1231 		mutex_lock(&efx->mac_lock);
1232 		efx->phy_op->reconfigure(efx);
1233 		mutex_unlock(&efx->mac_lock);
1234 
1235 		efx_start_all(efx);
1236 
1237 		efx_device_attach_if_not_resetting(efx);
1238 
1239 		efx->state = STATE_READY;
1240 
1241 		efx->type->resume_wol(efx);
1242 	}
1243 
1244 	rtnl_unlock();
1245 
1246 	/* Reschedule any quenched resets scheduled during efx_pm_freeze() */
1247 	efx_queue_reset_work(efx);
1248 
1249 	return 0;
1250 
1251 fail:
1252 	rtnl_unlock();
1253 
1254 	return rc;
1255 }
1256 
1257 static int efx_pm_poweroff(struct device *dev)
1258 {
1259 	struct pci_dev *pci_dev = to_pci_dev(dev);
1260 	struct efx_nic *efx = pci_get_drvdata(pci_dev);
1261 
1262 	efx->type->fini(efx);
1263 
1264 	efx->reset_pending = 0;
1265 
1266 	pci_save_state(pci_dev);
1267 	return pci_set_power_state(pci_dev, PCI_D3hot);
1268 }
1269 
1270 /* Used for both resume and restore */
1271 static int efx_pm_resume(struct device *dev)
1272 {
1273 	struct pci_dev *pci_dev = to_pci_dev(dev);
1274 	struct efx_nic *efx = pci_get_drvdata(pci_dev);
1275 	int rc;
1276 
1277 	rc = pci_set_power_state(pci_dev, PCI_D0);
1278 	if (rc)
1279 		return rc;
1280 	pci_restore_state(pci_dev);
1281 	rc = pci_enable_device(pci_dev);
1282 	if (rc)
1283 		return rc;
1284 	pci_set_master(efx->pci_dev);
1285 	rc = efx->type->reset(efx, RESET_TYPE_ALL);
1286 	if (rc)
1287 		return rc;
1288 	down_write(&efx->filter_sem);
1289 	rc = efx->type->init(efx);
1290 	up_write(&efx->filter_sem);
1291 	if (rc)
1292 		return rc;
1293 	rc = efx_pm_thaw(dev);
1294 	return rc;
1295 }
1296 
1297 static int efx_pm_suspend(struct device *dev)
1298 {
1299 	int rc;
1300 
1301 	efx_pm_freeze(dev);
1302 	rc = efx_pm_poweroff(dev);
1303 	if (rc)
1304 		efx_pm_resume(dev);
1305 	return rc;
1306 }
1307 
1308 static const struct dev_pm_ops efx_pm_ops = {
1309 	.suspend	= efx_pm_suspend,
1310 	.resume		= efx_pm_resume,
1311 	.freeze		= efx_pm_freeze,
1312 	.thaw		= efx_pm_thaw,
1313 	.poweroff	= efx_pm_poweroff,
1314 	.restore	= efx_pm_resume,
1315 };
1316 
1317 static struct pci_driver efx_pci_driver = {
1318 	.name		= KBUILD_MODNAME,
1319 	.id_table	= efx_pci_table,
1320 	.probe		= efx_pci_probe,
1321 	.remove		= efx_pci_remove,
1322 	.driver.pm	= &efx_pm_ops,
1323 	.err_handler	= &efx_err_handlers,
1324 #ifdef CONFIG_SFC_SRIOV
1325 	.sriov_configure = efx_pci_sriov_configure,
1326 #endif
1327 };
1328 
1329 /**************************************************************************
1330  *
1331  * Kernel module interface
1332  *
1333  *************************************************************************/
1334 
1335 static int __init efx_init_module(void)
1336 {
1337 	int rc;
1338 
1339 	printk(KERN_INFO "Solarflare NET driver v" EFX_DRIVER_VERSION "\n");
1340 
1341 	rc = register_netdevice_notifier(&efx_netdev_notifier);
1342 	if (rc)
1343 		goto err_notifier;
1344 
1345 #ifdef CONFIG_SFC_SRIOV
1346 	rc = efx_init_sriov();
1347 	if (rc)
1348 		goto err_sriov;
1349 #endif
1350 
1351 	rc = efx_create_reset_workqueue();
1352 	if (rc)
1353 		goto err_reset;
1354 
1355 	rc = pci_register_driver(&efx_pci_driver);
1356 	if (rc < 0)
1357 		goto err_pci;
1358 
1359 	rc = pci_register_driver(&ef100_pci_driver);
1360 	if (rc < 0)
1361 		goto err_pci_ef100;
1362 
1363 	return 0;
1364 
1365  err_pci_ef100:
1366 	pci_unregister_driver(&efx_pci_driver);
1367  err_pci:
1368 	efx_destroy_reset_workqueue();
1369  err_reset:
1370 #ifdef CONFIG_SFC_SRIOV
1371 	efx_fini_sriov();
1372  err_sriov:
1373 #endif
1374 	unregister_netdevice_notifier(&efx_netdev_notifier);
1375  err_notifier:
1376 	return rc;
1377 }
1378 
1379 static void __exit efx_exit_module(void)
1380 {
1381 	printk(KERN_INFO "Solarflare NET driver unloading\n");
1382 
1383 	pci_unregister_driver(&ef100_pci_driver);
1384 	pci_unregister_driver(&efx_pci_driver);
1385 	efx_destroy_reset_workqueue();
1386 #ifdef CONFIG_SFC_SRIOV
1387 	efx_fini_sriov();
1388 #endif
1389 	unregister_netdevice_notifier(&efx_netdev_notifier);
1390 
1391 }
1392 
1393 module_init(efx_init_module);
1394 module_exit(efx_exit_module);
1395 
1396 MODULE_AUTHOR("Solarflare Communications and "
1397 	      "Michael Brown <mbrown@fensystems.co.uk>");
1398 MODULE_DESCRIPTION("Solarflare network driver");
1399 MODULE_LICENSE("GPL");
1400 MODULE_DEVICE_TABLE(pci, efx_pci_table);
1401 MODULE_VERSION(EFX_DRIVER_VERSION);
1402