1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2015 - 2022 Beijing WangXun Technology Co., Ltd. */
3 
4 #include <linux/types.h>
5 #include <linux/module.h>
6 #include <linux/pci.h>
7 #include <linux/netdevice.h>
8 #include <linux/string.h>
9 #include <linux/etherdevice.h>
10 #include <linux/phylink.h>
11 #include <net/ip.h>
12 #include <linux/if_vlan.h>
13 
14 #include "../libwx/wx_type.h"
15 #include "../libwx/wx_lib.h"
16 #include "../libwx/wx_hw.h"
17 #include "txgbe_type.h"
18 #include "txgbe_hw.h"
19 #include "txgbe_phy.h"
20 #include "txgbe_ethtool.h"
21 
22 char txgbe_driver_name[] = "txgbe";
23 
24 /* txgbe_pci_tbl - PCI Device ID Table
25  *
26  * Wildcard entries (PCI_ANY_ID) should come last
27  * Last entry must be all 0s
28  *
29  * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
30  *   Class, Class Mask, private data (not used) }
31  */
32 static const struct pci_device_id txgbe_pci_tbl[] = {
33 	{ PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_SP1000), 0},
34 	{ PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_WX1820), 0},
35 	/* required last entry */
36 	{ .device = 0 }
37 };
38 
39 #define DEFAULT_DEBUG_LEVEL_SHIFT 3
40 
41 static void txgbe_check_minimum_link(struct wx *wx)
42 {
43 	struct pci_dev *pdev;
44 
45 	pdev = wx->pdev;
46 	pcie_print_link_status(pdev);
47 }
48 
49 /**
50  * txgbe_enumerate_functions - Get the number of ports this device has
51  * @wx: wx structure
52  *
53  * This function enumerates the phsyical functions co-located on a single slot,
54  * in order to determine how many ports a device has. This is most useful in
55  * determining the required GT/s of PCIe bandwidth necessary for optimal
56  * performance.
57  **/
58 static int txgbe_enumerate_functions(struct wx *wx)
59 {
60 	struct pci_dev *entry, *pdev = wx->pdev;
61 	int physfns = 0;
62 
63 	list_for_each_entry(entry, &pdev->bus->devices, bus_list) {
64 		/* When the devices on the bus don't all match our device ID,
65 		 * we can't reliably determine the correct number of
66 		 * functions. This can occur if a function has been direct
67 		 * attached to a virtual machine using VT-d.
68 		 */
69 		if (entry->vendor != pdev->vendor ||
70 		    entry->device != pdev->device)
71 			return -EINVAL;
72 
73 		physfns++;
74 	}
75 
76 	return physfns;
77 }
78 
79 /**
80  * txgbe_irq_enable - Enable default interrupt generation settings
81  * @wx: pointer to private structure
82  * @queues: enable irqs for queues
83  **/
84 static void txgbe_irq_enable(struct wx *wx, bool queues)
85 {
86 	wr32(wx, WX_PX_MISC_IEN, TXGBE_PX_MISC_IEN_MASK);
87 
88 	/* unmask interrupt */
89 	wx_intr_enable(wx, TXGBE_INTR_MISC(wx));
90 	if (queues)
91 		wx_intr_enable(wx, TXGBE_INTR_QALL(wx));
92 }
93 
94 /**
95  * txgbe_intr - msi/legacy mode Interrupt Handler
96  * @irq: interrupt number
97  * @data: pointer to a network interface device structure
98  **/
99 static irqreturn_t txgbe_intr(int __always_unused irq, void *data)
100 {
101 	struct wx_q_vector *q_vector;
102 	struct wx *wx  = data;
103 	struct pci_dev *pdev;
104 	u32 eicr;
105 
106 	q_vector = wx->q_vector[0];
107 	pdev = wx->pdev;
108 
109 	eicr = wx_misc_isb(wx, WX_ISB_VEC0);
110 	if (!eicr) {
111 		/* shared interrupt alert!
112 		 * the interrupt that we masked before the ICR read.
113 		 */
114 		if (netif_running(wx->netdev))
115 			txgbe_irq_enable(wx, true);
116 		return IRQ_NONE;        /* Not our interrupt */
117 	}
118 	wx->isb_mem[WX_ISB_VEC0] = 0;
119 	if (!(pdev->msi_enabled))
120 		wr32(wx, WX_PX_INTA, 1);
121 
122 	wx->isb_mem[WX_ISB_MISC] = 0;
123 	/* would disable interrupts here but it is auto disabled */
124 	napi_schedule_irqoff(&q_vector->napi);
125 
126 	/* re-enable link(maybe) and non-queue interrupts, no flush.
127 	 * txgbe_poll will re-enable the queue interrupts
128 	 */
129 	if (netif_running(wx->netdev))
130 		txgbe_irq_enable(wx, false);
131 
132 	return IRQ_HANDLED;
133 }
134 
135 /**
136  * txgbe_request_msix_irqs - Initialize MSI-X interrupts
137  * @wx: board private structure
138  *
139  * Allocate MSI-X vectors and request interrupts from the kernel.
140  **/
141 static int txgbe_request_msix_irqs(struct wx *wx)
142 {
143 	struct net_device *netdev = wx->netdev;
144 	int vector, err;
145 
146 	for (vector = 0; vector < wx->num_q_vectors; vector++) {
147 		struct wx_q_vector *q_vector = wx->q_vector[vector];
148 		struct msix_entry *entry = &wx->msix_entries[vector];
149 
150 		if (q_vector->tx.ring && q_vector->rx.ring)
151 			snprintf(q_vector->name, sizeof(q_vector->name) - 1,
152 				 "%s-TxRx-%d", netdev->name, entry->entry);
153 		else
154 			/* skip this unused q_vector */
155 			continue;
156 
157 		err = request_irq(entry->vector, wx_msix_clean_rings, 0,
158 				  q_vector->name, q_vector);
159 		if (err) {
160 			wx_err(wx, "request_irq failed for MSIX interrupt %s Error: %d\n",
161 			       q_vector->name, err);
162 			goto free_queue_irqs;
163 		}
164 	}
165 
166 	return 0;
167 
168 free_queue_irqs:
169 	while (vector) {
170 		vector--;
171 		free_irq(wx->msix_entries[vector].vector,
172 			 wx->q_vector[vector]);
173 	}
174 	wx_reset_interrupt_capability(wx);
175 	return err;
176 }
177 
178 /**
179  * txgbe_request_irq - initialize interrupts
180  * @wx: board private structure
181  *
182  * Attempt to configure interrupts using the best available
183  * capabilities of the hardware and kernel.
184  **/
185 static int txgbe_request_irq(struct wx *wx)
186 {
187 	struct net_device *netdev = wx->netdev;
188 	struct pci_dev *pdev = wx->pdev;
189 	int err;
190 
191 	if (pdev->msix_enabled)
192 		err = txgbe_request_msix_irqs(wx);
193 	else if (pdev->msi_enabled)
194 		err = request_irq(wx->pdev->irq, &txgbe_intr, 0,
195 				  netdev->name, wx);
196 	else
197 		err = request_irq(wx->pdev->irq, &txgbe_intr, IRQF_SHARED,
198 				  netdev->name, wx);
199 
200 	if (err)
201 		wx_err(wx, "request_irq failed, Error %d\n", err);
202 
203 	return err;
204 }
205 
206 static void txgbe_up_complete(struct wx *wx)
207 {
208 	struct net_device *netdev = wx->netdev;
209 	struct txgbe *txgbe;
210 
211 	wx_control_hw(wx, true);
212 	wx_configure_vectors(wx);
213 
214 	/* make sure to complete pre-operations */
215 	smp_mb__before_atomic();
216 	wx_napi_enable_all(wx);
217 
218 	txgbe = netdev_to_txgbe(netdev);
219 	phylink_start(txgbe->phylink);
220 
221 	/* clear any pending interrupts, may auto mask */
222 	rd32(wx, WX_PX_IC(0));
223 	rd32(wx, WX_PX_IC(1));
224 	rd32(wx, WX_PX_MISC_IC);
225 	txgbe_irq_enable(wx, true);
226 
227 	/* enable transmits */
228 	netif_tx_start_all_queues(netdev);
229 }
230 
231 static void txgbe_reset(struct wx *wx)
232 {
233 	struct net_device *netdev = wx->netdev;
234 	u8 old_addr[ETH_ALEN];
235 	int err;
236 
237 	err = txgbe_reset_hw(wx);
238 	if (err != 0)
239 		wx_err(wx, "Hardware Error: %d\n", err);
240 
241 	wx_start_hw(wx);
242 	/* do not flush user set addresses */
243 	memcpy(old_addr, &wx->mac_table[0].addr, netdev->addr_len);
244 	wx_flush_sw_mac_table(wx);
245 	wx_mac_set_default_filter(wx, old_addr);
246 }
247 
248 static void txgbe_disable_device(struct wx *wx)
249 {
250 	struct net_device *netdev = wx->netdev;
251 	u32 i;
252 
253 	wx_disable_pcie_master(wx);
254 	/* disable receives */
255 	wx_disable_rx(wx);
256 
257 	/* disable all enabled rx queues */
258 	for (i = 0; i < wx->num_rx_queues; i++)
259 		/* this call also flushes the previous write */
260 		wx_disable_rx_queue(wx, wx->rx_ring[i]);
261 
262 	netif_tx_stop_all_queues(netdev);
263 	netif_tx_disable(netdev);
264 
265 	wx_irq_disable(wx);
266 	wx_napi_disable_all(wx);
267 
268 	if (wx->bus.func < 2)
269 		wr32m(wx, TXGBE_MIS_PRB_CTL, TXGBE_MIS_PRB_CTL_LAN_UP(wx->bus.func), 0);
270 	else
271 		wx_err(wx, "%s: invalid bus lan id %d\n",
272 		       __func__, wx->bus.func);
273 
274 	if (!(((wx->subsystem_device_id & WX_NCSI_MASK) == WX_NCSI_SUP) ||
275 	      ((wx->subsystem_device_id & WX_WOL_MASK) == WX_WOL_SUP))) {
276 		/* disable mac transmiter */
277 		wr32m(wx, WX_MAC_TX_CFG, WX_MAC_TX_CFG_TE, 0);
278 	}
279 
280 	/* disable transmits in the hardware now that interrupts are off */
281 	for (i = 0; i < wx->num_tx_queues; i++) {
282 		u8 reg_idx = wx->tx_ring[i]->reg_idx;
283 
284 		wr32(wx, WX_PX_TR_CFG(reg_idx), WX_PX_TR_CFG_SWFLSH);
285 	}
286 
287 	/* Disable the Tx DMA engine */
288 	wr32m(wx, WX_TDM_CTL, WX_TDM_CTL_TE, 0);
289 }
290 
291 static void txgbe_down(struct wx *wx)
292 {
293 	struct txgbe *txgbe = netdev_to_txgbe(wx->netdev);
294 
295 	txgbe_disable_device(wx);
296 	txgbe_reset(wx);
297 	phylink_stop(txgbe->phylink);
298 
299 	wx_clean_all_tx_rings(wx);
300 	wx_clean_all_rx_rings(wx);
301 }
302 
303 /**
304  *  txgbe_init_type_code - Initialize the shared code
305  *  @wx: pointer to hardware structure
306  **/
307 static void txgbe_init_type_code(struct wx *wx)
308 {
309 	u8 device_type = wx->subsystem_device_id & 0xF0;
310 
311 	switch (wx->device_id) {
312 	case TXGBE_DEV_ID_SP1000:
313 	case TXGBE_DEV_ID_WX1820:
314 		wx->mac.type = wx_mac_sp;
315 		break;
316 	default:
317 		wx->mac.type = wx_mac_unknown;
318 		break;
319 	}
320 
321 	switch (device_type) {
322 	case TXGBE_ID_SFP:
323 		wx->media_type = sp_media_fiber;
324 		break;
325 	case TXGBE_ID_XAUI:
326 	case TXGBE_ID_SGMII:
327 		wx->media_type = sp_media_copper;
328 		break;
329 	case TXGBE_ID_KR_KX_KX4:
330 	case TXGBE_ID_MAC_XAUI:
331 	case TXGBE_ID_MAC_SGMII:
332 		wx->media_type = sp_media_backplane;
333 		break;
334 	case TXGBE_ID_SFI_XAUI:
335 		if (wx->bus.func == 0)
336 			wx->media_type = sp_media_fiber;
337 		else
338 			wx->media_type = sp_media_copper;
339 		break;
340 	default:
341 		wx->media_type = sp_media_unknown;
342 		break;
343 	}
344 }
345 
346 /**
347  * txgbe_sw_init - Initialize general software structures (struct wx)
348  * @wx: board private structure to initialize
349  **/
350 static int txgbe_sw_init(struct wx *wx)
351 {
352 	u16 msix_count = 0;
353 	int err;
354 
355 	wx->mac.num_rar_entries = TXGBE_SP_RAR_ENTRIES;
356 	wx->mac.max_tx_queues = TXGBE_SP_MAX_TX_QUEUES;
357 	wx->mac.max_rx_queues = TXGBE_SP_MAX_RX_QUEUES;
358 	wx->mac.mcft_size = TXGBE_SP_MC_TBL_SIZE;
359 	wx->mac.vft_size = TXGBE_SP_VFT_TBL_SIZE;
360 	wx->mac.rx_pb_size = TXGBE_SP_RX_PB_SIZE;
361 	wx->mac.tx_pb_size = TXGBE_SP_TDB_PB_SZ;
362 
363 	/* PCI config space info */
364 	err = wx_sw_init(wx);
365 	if (err < 0)
366 		return err;
367 
368 	txgbe_init_type_code(wx);
369 
370 	/* Set common capability flags and settings */
371 	wx->max_q_vectors = TXGBE_MAX_MSIX_VECTORS;
372 	err = wx_get_pcie_msix_counts(wx, &msix_count, TXGBE_MAX_MSIX_VECTORS);
373 	if (err)
374 		wx_err(wx, "Do not support MSI-X\n");
375 	wx->mac.max_msix_vectors = msix_count;
376 
377 	/* enable itr by default in dynamic mode */
378 	wx->rx_itr_setting = 1;
379 	wx->tx_itr_setting = 1;
380 
381 	/* set default ring sizes */
382 	wx->tx_ring_count = TXGBE_DEFAULT_TXD;
383 	wx->rx_ring_count = TXGBE_DEFAULT_RXD;
384 
385 	/* set default work limits */
386 	wx->tx_work_limit = TXGBE_DEFAULT_TX_WORK;
387 	wx->rx_work_limit = TXGBE_DEFAULT_RX_WORK;
388 
389 	return 0;
390 }
391 
392 /**
393  * txgbe_open - Called when a network interface is made active
394  * @netdev: network interface device structure
395  *
396  * Returns 0 on success, negative value on failure
397  *
398  * The open entry point is called when a network interface is made
399  * active by the system (IFF_UP).
400  **/
401 static int txgbe_open(struct net_device *netdev)
402 {
403 	struct wx *wx = netdev_priv(netdev);
404 	int err;
405 
406 	err = wx_setup_resources(wx);
407 	if (err)
408 		goto err_reset;
409 
410 	wx_configure(wx);
411 
412 	err = txgbe_request_irq(wx);
413 	if (err)
414 		goto err_free_isb;
415 
416 	/* Notify the stack of the actual queue counts. */
417 	err = netif_set_real_num_tx_queues(netdev, wx->num_tx_queues);
418 	if (err)
419 		goto err_free_irq;
420 
421 	err = netif_set_real_num_rx_queues(netdev, wx->num_rx_queues);
422 	if (err)
423 		goto err_free_irq;
424 
425 	txgbe_up_complete(wx);
426 
427 	return 0;
428 
429 err_free_irq:
430 	wx_free_irq(wx);
431 err_free_isb:
432 	wx_free_isb_resources(wx);
433 err_reset:
434 	txgbe_reset(wx);
435 
436 	return err;
437 }
438 
439 /**
440  * txgbe_close_suspend - actions necessary to both suspend and close flows
441  * @wx: the private wx struct
442  *
443  * This function should contain the necessary work common to both suspending
444  * and closing of the device.
445  */
446 static void txgbe_close_suspend(struct wx *wx)
447 {
448 	txgbe_disable_device(wx);
449 	wx_free_resources(wx);
450 }
451 
452 /**
453  * txgbe_close - Disables a network interface
454  * @netdev: network interface device structure
455  *
456  * Returns 0, this is not allowed to fail
457  *
458  * The close entry point is called when an interface is de-activated
459  * by the OS.  The hardware is still under the drivers control, but
460  * needs to be disabled.  A global MAC reset is issued to stop the
461  * hardware, and all transmit and receive resources are freed.
462  **/
463 static int txgbe_close(struct net_device *netdev)
464 {
465 	struct wx *wx = netdev_priv(netdev);
466 
467 	txgbe_down(wx);
468 	wx_free_irq(wx);
469 	wx_free_resources(wx);
470 	wx_control_hw(wx, false);
471 
472 	return 0;
473 }
474 
475 static void txgbe_dev_shutdown(struct pci_dev *pdev)
476 {
477 	struct wx *wx = pci_get_drvdata(pdev);
478 	struct net_device *netdev;
479 
480 	netdev = wx->netdev;
481 	netif_device_detach(netdev);
482 
483 	rtnl_lock();
484 	if (netif_running(netdev))
485 		txgbe_close_suspend(wx);
486 	rtnl_unlock();
487 
488 	wx_control_hw(wx, false);
489 
490 	pci_disable_device(pdev);
491 }
492 
493 static void txgbe_shutdown(struct pci_dev *pdev)
494 {
495 	txgbe_dev_shutdown(pdev);
496 
497 	if (system_state == SYSTEM_POWER_OFF) {
498 		pci_wake_from_d3(pdev, false);
499 		pci_set_power_state(pdev, PCI_D3hot);
500 	}
501 }
502 
503 static const struct net_device_ops txgbe_netdev_ops = {
504 	.ndo_open               = txgbe_open,
505 	.ndo_stop               = txgbe_close,
506 	.ndo_change_mtu         = wx_change_mtu,
507 	.ndo_start_xmit         = wx_xmit_frame,
508 	.ndo_set_rx_mode        = wx_set_rx_mode,
509 	.ndo_set_features       = wx_set_features,
510 	.ndo_validate_addr      = eth_validate_addr,
511 	.ndo_set_mac_address    = wx_set_mac,
512 	.ndo_get_stats64        = wx_get_stats64,
513 	.ndo_vlan_rx_add_vid    = wx_vlan_rx_add_vid,
514 	.ndo_vlan_rx_kill_vid   = wx_vlan_rx_kill_vid,
515 };
516 
517 /**
518  * txgbe_probe - Device Initialization Routine
519  * @pdev: PCI device information struct
520  * @ent: entry in txgbe_pci_tbl
521  *
522  * Returns 0 on success, negative on failure
523  *
524  * txgbe_probe initializes an adapter identified by a pci_dev structure.
525  * The OS initialization, configuring of the wx private structure,
526  * and a hardware reset occur.
527  **/
528 static int txgbe_probe(struct pci_dev *pdev,
529 		       const struct pci_device_id __always_unused *ent)
530 {
531 	struct net_device *netdev;
532 	int err, expected_gts;
533 	struct wx *wx = NULL;
534 	struct txgbe *txgbe;
535 
536 	u16 eeprom_verh = 0, eeprom_verl = 0, offset = 0;
537 	u16 eeprom_cfg_blkh = 0, eeprom_cfg_blkl = 0;
538 	u16 build = 0, major = 0, patch = 0;
539 	u8 part_str[TXGBE_PBANUM_LENGTH];
540 	u32 etrack_id = 0;
541 
542 	err = pci_enable_device_mem(pdev);
543 	if (err)
544 		return err;
545 
546 	err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
547 	if (err) {
548 		dev_err(&pdev->dev,
549 			"No usable DMA configuration, aborting\n");
550 		goto err_pci_disable_dev;
551 	}
552 
553 	err = pci_request_selected_regions(pdev,
554 					   pci_select_bars(pdev, IORESOURCE_MEM),
555 					   txgbe_driver_name);
556 	if (err) {
557 		dev_err(&pdev->dev,
558 			"pci_request_selected_regions failed 0x%x\n", err);
559 		goto err_pci_disable_dev;
560 	}
561 
562 	pci_set_master(pdev);
563 
564 	netdev = devm_alloc_etherdev_mqs(&pdev->dev,
565 					 sizeof(struct wx),
566 					 TXGBE_MAX_TX_QUEUES,
567 					 TXGBE_MAX_RX_QUEUES);
568 	if (!netdev) {
569 		err = -ENOMEM;
570 		goto err_pci_release_regions;
571 	}
572 
573 	SET_NETDEV_DEV(netdev, &pdev->dev);
574 
575 	wx = netdev_priv(netdev);
576 	wx->netdev = netdev;
577 	wx->pdev = pdev;
578 
579 	wx->msg_enable = (1 << DEFAULT_DEBUG_LEVEL_SHIFT) - 1;
580 
581 	wx->hw_addr = devm_ioremap(&pdev->dev,
582 				   pci_resource_start(pdev, 0),
583 				   pci_resource_len(pdev, 0));
584 	if (!wx->hw_addr) {
585 		err = -EIO;
586 		goto err_pci_release_regions;
587 	}
588 
589 	wx->driver_name = txgbe_driver_name;
590 	txgbe_set_ethtool_ops(netdev);
591 	netdev->netdev_ops = &txgbe_netdev_ops;
592 
593 	/* setup the private structure */
594 	err = txgbe_sw_init(wx);
595 	if (err)
596 		goto err_free_mac_table;
597 
598 	/* check if flash load is done after hw power up */
599 	err = wx_check_flash_load(wx, TXGBE_SPI_ILDR_STATUS_PERST);
600 	if (err)
601 		goto err_free_mac_table;
602 	err = wx_check_flash_load(wx, TXGBE_SPI_ILDR_STATUS_PWRRST);
603 	if (err)
604 		goto err_free_mac_table;
605 
606 	err = wx_mng_present(wx);
607 	if (err) {
608 		dev_err(&pdev->dev, "Management capability is not present\n");
609 		goto err_free_mac_table;
610 	}
611 
612 	err = txgbe_reset_hw(wx);
613 	if (err) {
614 		dev_err(&pdev->dev, "HW Init failed: %d\n", err);
615 		goto err_free_mac_table;
616 	}
617 
618 	netdev->features = NETIF_F_SG |
619 			   NETIF_F_TSO |
620 			   NETIF_F_TSO6 |
621 			   NETIF_F_RXHASH |
622 			   NETIF_F_RXCSUM |
623 			   NETIF_F_HW_CSUM;
624 
625 	netdev->gso_partial_features =  NETIF_F_GSO_ENCAP_ALL;
626 	netdev->features |= netdev->gso_partial_features;
627 	netdev->features |= NETIF_F_SCTP_CRC;
628 	netdev->vlan_features |= netdev->features | NETIF_F_TSO_MANGLEID;
629 	netdev->hw_enc_features |= netdev->vlan_features;
630 	netdev->features |= NETIF_F_VLAN_FEATURES;
631 	/* copy netdev features into list of user selectable features */
632 	netdev->hw_features |= netdev->features | NETIF_F_RXALL;
633 	netdev->hw_features |= NETIF_F_NTUPLE | NETIF_F_HW_TC;
634 	netdev->features |= NETIF_F_HIGHDMA;
635 	netdev->hw_features |= NETIF_F_GRO;
636 	netdev->features |= NETIF_F_GRO;
637 
638 	netdev->priv_flags |= IFF_UNICAST_FLT;
639 	netdev->priv_flags |= IFF_SUPP_NOFCS;
640 
641 	netdev->min_mtu = ETH_MIN_MTU;
642 	netdev->max_mtu = WX_MAX_JUMBO_FRAME_SIZE -
643 			  (ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN);
644 
645 	/* make sure the EEPROM is good */
646 	err = txgbe_validate_eeprom_checksum(wx, NULL);
647 	if (err != 0) {
648 		dev_err(&pdev->dev, "The EEPROM Checksum Is Not Valid\n");
649 		wr32(wx, WX_MIS_RST, WX_MIS_RST_SW_RST);
650 		err = -EIO;
651 		goto err_free_mac_table;
652 	}
653 
654 	eth_hw_addr_set(netdev, wx->mac.perm_addr);
655 	wx_mac_set_default_filter(wx, wx->mac.perm_addr);
656 
657 	err = wx_init_interrupt_scheme(wx);
658 	if (err)
659 		goto err_free_mac_table;
660 
661 	/* Save off EEPROM version number and Option Rom version which
662 	 * together make a unique identify for the eeprom
663 	 */
664 	wx_read_ee_hostif(wx,
665 			  wx->eeprom.sw_region_offset + TXGBE_EEPROM_VERSION_H,
666 			  &eeprom_verh);
667 	wx_read_ee_hostif(wx,
668 			  wx->eeprom.sw_region_offset + TXGBE_EEPROM_VERSION_L,
669 			  &eeprom_verl);
670 	etrack_id = (eeprom_verh << 16) | eeprom_verl;
671 
672 	wx_read_ee_hostif(wx,
673 			  wx->eeprom.sw_region_offset + TXGBE_ISCSI_BOOT_CONFIG,
674 			  &offset);
675 
676 	/* Make sure offset to SCSI block is valid */
677 	if (!(offset == 0x0) && !(offset == 0xffff)) {
678 		wx_read_ee_hostif(wx, offset + 0x84, &eeprom_cfg_blkh);
679 		wx_read_ee_hostif(wx, offset + 0x83, &eeprom_cfg_blkl);
680 
681 		/* Only display Option Rom if exist */
682 		if (eeprom_cfg_blkl && eeprom_cfg_blkh) {
683 			major = eeprom_cfg_blkl >> 8;
684 			build = (eeprom_cfg_blkl << 8) | (eeprom_cfg_blkh >> 8);
685 			patch = eeprom_cfg_blkh & 0x00ff;
686 
687 			snprintf(wx->eeprom_id, sizeof(wx->eeprom_id),
688 				 "0x%08x, %d.%d.%d", etrack_id, major, build,
689 				 patch);
690 		} else {
691 			snprintf(wx->eeprom_id, sizeof(wx->eeprom_id),
692 				 "0x%08x", etrack_id);
693 		}
694 	} else {
695 		snprintf(wx->eeprom_id, sizeof(wx->eeprom_id),
696 			 "0x%08x", etrack_id);
697 	}
698 
699 	if (etrack_id < 0x20010)
700 		dev_warn(&pdev->dev, "Please upgrade the firmware to 0x20010 or above.\n");
701 
702 	txgbe = devm_kzalloc(&pdev->dev, sizeof(*txgbe), GFP_KERNEL);
703 	if (!txgbe) {
704 		err = -ENOMEM;
705 		goto err_release_hw;
706 	}
707 
708 	txgbe->wx = wx;
709 	wx->priv = txgbe;
710 
711 	err = txgbe_init_phy(txgbe);
712 	if (err)
713 		goto err_release_hw;
714 
715 	err = register_netdev(netdev);
716 	if (err)
717 		goto err_remove_phy;
718 
719 	pci_set_drvdata(pdev, wx);
720 
721 	netif_tx_stop_all_queues(netdev);
722 
723 	/* calculate the expected PCIe bandwidth required for optimal
724 	 * performance. Note that some older parts will never have enough
725 	 * bandwidth due to being older generation PCIe parts. We clamp these
726 	 * parts to ensure that no warning is displayed, as this could confuse
727 	 * users otherwise.
728 	 */
729 	expected_gts = txgbe_enumerate_functions(wx) * 10;
730 
731 	/* don't check link if we failed to enumerate functions */
732 	if (expected_gts > 0)
733 		txgbe_check_minimum_link(wx);
734 	else
735 		dev_warn(&pdev->dev, "Failed to enumerate PF devices.\n");
736 
737 	/* First try to read PBA as a string */
738 	err = txgbe_read_pba_string(wx, part_str, TXGBE_PBANUM_LENGTH);
739 	if (err)
740 		strncpy(part_str, "Unknown", TXGBE_PBANUM_LENGTH);
741 
742 	netif_info(wx, probe, netdev, "%pM\n", netdev->dev_addr);
743 
744 	return 0;
745 
746 err_remove_phy:
747 	txgbe_remove_phy(txgbe);
748 err_release_hw:
749 	wx_clear_interrupt_scheme(wx);
750 	wx_control_hw(wx, false);
751 err_free_mac_table:
752 	kfree(wx->mac_table);
753 err_pci_release_regions:
754 	pci_release_selected_regions(pdev,
755 				     pci_select_bars(pdev, IORESOURCE_MEM));
756 err_pci_disable_dev:
757 	pci_disable_device(pdev);
758 	return err;
759 }
760 
761 /**
762  * txgbe_remove - Device Removal Routine
763  * @pdev: PCI device information struct
764  *
765  * txgbe_remove is called by the PCI subsystem to alert the driver
766  * that it should release a PCI device.  The could be caused by a
767  * Hot-Plug event, or because the driver is going to be removed from
768  * memory.
769  **/
770 static void txgbe_remove(struct pci_dev *pdev)
771 {
772 	struct wx *wx = pci_get_drvdata(pdev);
773 	struct txgbe *txgbe = wx->priv;
774 	struct net_device *netdev;
775 
776 	netdev = wx->netdev;
777 	unregister_netdev(netdev);
778 
779 	txgbe_remove_phy(txgbe);
780 
781 	pci_release_selected_regions(pdev,
782 				     pci_select_bars(pdev, IORESOURCE_MEM));
783 
784 	kfree(wx->mac_table);
785 	wx_clear_interrupt_scheme(wx);
786 
787 	pci_disable_device(pdev);
788 }
789 
790 static struct pci_driver txgbe_driver = {
791 	.name     = txgbe_driver_name,
792 	.id_table = txgbe_pci_tbl,
793 	.probe    = txgbe_probe,
794 	.remove   = txgbe_remove,
795 	.shutdown = txgbe_shutdown,
796 };
797 
798 module_pci_driver(txgbe_driver);
799 
800 MODULE_DEVICE_TABLE(pci, txgbe_pci_tbl);
801 MODULE_AUTHOR("Beijing WangXun Technology Co., Ltd, <software@trustnetic.com>");
802 MODULE_DESCRIPTION("WangXun(R) 10 Gigabit PCI Express Network Driver");
803 MODULE_LICENSE("GPL");
804