OpenWrt XBurst

OpenWrt XBurst Git Source Tree

Root/package/broadcom-57xx/src/b57um.c

1	/******************************************************************************/
2	/* */
3	/* Broadcom BCM5700 Linux Network Driver, Copyright (c) 2000 - 2005 Broadcom */
4	/* Corporation. */
5	/* All rights reserved. */
6	/* */
7	/* This program is free software; you can redistribute it and/or modify */
8	/* it under the terms of the GNU General Public License as published by */
9	/* the Free Software Foundation, located in the file LICENSE. */
10	/* */
11	/******************************************************************************/
12
13
14	char bcm5700_driver[] = "bcm57xx";
15	char bcm5700_version[] = "8.3.14";
16	char bcm5700_date[] = "(11/2/05)";
17
18	#define B57UM
19	#include "mm.h"
20	#include "linux/mii.h" //@.@jack add it 2006/06/28.
21	#include "typedefs.h"
22	#include "osl.h"
23	#include "bcmdefs.h"
24	#include "bcmdevs.h"
25	#include "sbconfig.h"
26	#include "sbutils.h"
27	#include "hndgige.h"
28	#include "bcmrobo.h"
29	#include "robo_register.c"
30
31	#include "bcmendian.h"
32	#include "bcmnvram.h"
33	#include "proto/ethernet.h"
34	#include "proto/vlan.h"
35	#include "proto/bcmtcp.h"
36	#include "proto/bcmip.h"
37	#define PKTDATA(osh, skb) (((struct sk_buff*)(skb))->data)
38
39	/* this is needed to get good and stable performances */
40	#define EXTRA_HDR BCMEXTRAHDROOM
41
42	#define SIOCGREG_STATUS 0x8996 /* Read Switch register (for debug)*/
43	#define SIOCSREG_STATUS 0x8997 /* Write Switch register(for debug)*/
44
45	/* This structure is used in SIOCXREG_STATUS ioctl calls*/
46	struct reg_ioctl_data {
47	u16 page_num;
48	u16 addr_num;
49	u16 len;
50	u16 val_in[4];
51	u16 val_out[4];
52	};
53
54	/* A few user-configurable values. */
55
56	#define MAX_UNITS 16
57	/* Used to pass the full-duplex flag, etc. */
58	static int line_speed[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
59	static int auto_speed[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
60	static int full_duplex[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
61	static int rx_flow_control[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
62	static int tx_flow_control[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
63	static int auto_flow_control[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
64	#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
65	static int mtu[MAX_UNITS] = {1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500}; /* Jumbo MTU for interfaces. */
66	#endif
67	static int tx_checksum[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
68	static int rx_checksum[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
69	static int scatter_gather[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
70	static int activate_gpio = -1;
71
72	#define TX_DESC_CNT DEFAULT_TX_PACKET_DESC_COUNT
73	static unsigned int tx_pkt_desc_cnt[MAX_UNITS] =
74	{TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,
75	TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,
76	TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,
77	TX_DESC_CNT};
78
79	#define RX_DESC_CNT DEFAULT_STD_RCV_DESC_COUNT
80	static unsigned int rx_std_desc_cnt[MAX_UNITS] =
81	{RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,
82	RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,
83	RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,
84	RX_DESC_CNT };
85
86	#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
87	#define JBO_DESC_CNT DEFAULT_JUMBO_RCV_DESC_COUNT
88	static unsigned int rx_jumbo_desc_cnt[MAX_UNITS] =
89	{JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,
90	JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,
91	JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,
92	JBO_DESC_CNT };
93	#endif
94
95	#ifdef BCM_INT_COAL
96	#ifdef BCM_NAPI_RXPOLL
97	static unsigned int adaptive_coalesce[MAX_UNITS] =
98	{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
99	#else
100	static unsigned int adaptive_coalesce[MAX_UNITS] =
101	{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
102	#endif
103
104	#define RX_COAL_TK DEFAULT_RX_COALESCING_TICKS
105	static unsigned int rx_coalesce_ticks[MAX_UNITS] =
106	{RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,
107	RX_COAL_TK, RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,
108	RX_COAL_TK,RX_COAL_TK, RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,
109	RX_COAL_TK};
110
111	#define RX_COAL_FM DEFAULT_RX_MAX_COALESCED_FRAMES
112	static unsigned int rx_max_coalesce_frames[MAX_UNITS] =
113	{RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,
114	RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,
115	RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,
116	RX_COAL_FM};
117
118	#define TX_COAL_TK DEFAULT_TX_COALESCING_TICKS
119	static unsigned int tx_coalesce_ticks[MAX_UNITS] =
120	{TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,
121	TX_COAL_TK, TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,
122	TX_COAL_TK,TX_COAL_TK, TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,
123	TX_COAL_TK};
124
125	#define TX_COAL_FM DEFAULT_TX_MAX_COALESCED_FRAMES
126	static unsigned int tx_max_coalesce_frames[MAX_UNITS] =
127	{TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,
128	TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,
129	TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,
130	TX_COAL_FM};
131
132	#define ST_COAL_TK DEFAULT_STATS_COALESCING_TICKS
133	static unsigned int stats_coalesce_ticks[MAX_UNITS] =
134	{ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,
135	ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,
136	ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,
137	ST_COAL_TK,};
138
139	#endif
140	#ifdef BCM_WOL
141	static int enable_wol[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
142	#endif
143	#ifdef BCM_TSO
144	static int enable_tso[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
145	#endif
146	#ifdef BCM_NIC_SEND_BD
147	static int nic_tx_bd[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
148	#endif
149	#ifdef BCM_ASF
150	static int vlan_tag_mode[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
151	#endif
152	static int delay_link[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
153	static int disable_d3hot[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
154
155	#if defined(CONFIG_PCI_MSI) \|\| defined(CONFIG_PCI_USE_VECTOR)
156	static int disable_msi[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
157	static int bcm_msi_chipset_bug = 0;
158	#endif
159
160	#define BCM_TIMER_GRANULARITY (1000000 / HZ)
161
162	/* Hack to hook the data path to the BCM WL dirver */
163	#ifdef BCM_WL_EMULATOR
164	#include "bcmnvram.h"
165	#include "wl_bcm57emu.h"
166	#ifdef SKB_MANAGER
167	int skb_old_alloc = 0;
168	#endif
169	#endif /* BCM_WL_EMULATOR */
170
171	/* Operational parameters that usually are not changed. */
172	/* Time in jiffies before concluding the transmitter is hung. */
173	#define TX_TIMEOUT (2*HZ)
174
175	#if (LINUX_VERSION_CODE < 0x02030d)
176	#define pci_resource_start(dev, bar) (dev->base_address[bar] & PCI_BASE_ADDRESS_MEM_MASK)
177	#elif (LINUX_VERSION_CODE < 0x02032b)
178	#define pci_resource_start(dev, bar) (dev->resource[bar] & PCI_BASE_ADDRESS_MEM_MASK)
179	#endif
180
181	#if (LINUX_VERSION_CODE < 0x02032b)
182	#define dev_kfree_skb_irq(skb) dev_kfree_skb(skb)
183	#define netif_wake_queue(dev) clear_bit(0, &dev->tbusy); mark_bh(NET_BH)
184	#define netif_stop_queue(dev) set_bit(0, &dev->tbusy)
185
186	static inline void netif_start_queue(struct net_device *dev)
187	{
188	dev->tbusy = 0;
189	dev->interrupt = 0;
190	dev->start = 1;
191	}
192
193	#define netif_queue_stopped(dev) dev->tbusy
194	#define netif_running(dev) dev->start
195
196	static inline void tasklet_schedule(struct tasklet_struct *tasklet)
197	{
198	queue_task(tasklet, &tq_immediate);
199	mark_bh(IMMEDIATE_BH);
200	}
201
202	static inline void tasklet_init(struct tasklet_struct *tasklet,
203	void (*func)(unsigned long),
204	unsigned long data)
205	{
206	tasklet->next = NULL;
207	tasklet->sync = 0;
208	tasklet->routine = (void ()(void ))func;
209	tasklet->data = (void *)data;
210	}
211
212	#define tasklet_kill(tasklet)
213
214	#endif
215
216	#if (LINUX_VERSION_CODE < 0x020300)
217	struct pci_device_id {
218	unsigned int vendor, device; /* Vendor and device ID or PCI_ANY_ID */
219	unsigned int subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */
220	unsigned int class, class_mask; /* (class,subclass,prog-if) triplet */
221	unsigned long driver_data; /* Data private to the driver */
222	};
223
224	#define PCI_ANY_ID 0
225
226	#define pci_set_drvdata(pdev, dev)
227	#define pci_get_drvdata(pdev) 0
228
229	#define pci_enable_device(pdev) 0
230
231	#define __devinit __init
232	#define __devinitdata __initdata
233	#define __devexit
234
235	#define SET_MODULE_OWNER(dev)
236	#define MODULE_DEVICE_TABLE(pci, pci_tbl)
237
238	#endif
239
240	#if (LINUX_VERSION_CODE < 0x020411)
241	#ifndef __devexit_p
242	#define __devexit_p(x) x
243	#endif
244	#endif
245
246	#ifndef MODULE_LICENSE
247	#define MODULE_LICENSE(license)
248	#endif
249
250	#ifndef IRQ_RETVAL
251	typedef void irqreturn_t;
252	#define IRQ_RETVAL(x)
253	#endif
254
255	#if (LINUX_VERSION_CODE < 0x02032a)
256	static inline void pci_alloc_consistent(struct pci_dev pdev, size_t size,
257	dma_addr_t *dma_handle)
258	{
259	void *virt_ptr;
260
261	/* Maximum in slab.c */
262	if (size > 131072)
263	return 0;
264
265	virt_ptr = kmalloc(size, GFP_KERNEL);
266	*dma_handle = virt_to_bus(virt_ptr);
267	return virt_ptr;
268	}
269	#define pci_free_consistent(dev, size, ptr, dma_ptr) kfree(ptr)
270
271	#endif /#if (LINUX_VERSION_CODE < 0x02032a) /
272
273
274	#if (LINUX_VERSION_CODE < 0x02040d)
275
276	#if (LINUX_VERSION_CODE >= 0x020409) && defined(RED_HAT_LINUX_KERNEL)
277
278	#define BCM_32BIT_DMA_MASK ((u64) 0x00000000ffffffffULL)
279	#define BCM_64BIT_DMA_MASK ((u64) 0xffffffffffffffffULL)
280
281	#else
282	/* pci_set_dma_mask is using dma_addr_t */
283
284	#define BCM_32BIT_DMA_MASK ((dma_addr_t) 0xffffffff)
285	#define BCM_64BIT_DMA_MASK ((dma_addr_t) 0xffffffff)
286
287	#endif
288
289	#else /* (LINUX_VERSION_CODE < 0x02040d) */
290
291	#define BCM_32BIT_DMA_MASK ((u64) 0x00000000ffffffffULL)
292	#define BCM_64BIT_DMA_MASK ((u64) 0xffffffffffffffffULL)
293	#endif
294
295	#if (LINUX_VERSION_CODE < 0x020329)
296	#define pci_set_dma_mask(pdev, mask) (0)
297	#else
298	#if (LINUX_VERSION_CODE < 0x020403)
299	int
300	pci_set_dma_mask(struct pci_dev *dev, dma_addr_t mask)
301	{
302	if(! pci_dma_supported(dev, mask))
303	return -EIO;
304
305	dev->dma_mask = mask;
306
307	return 0;
308	}
309	#endif
310	#endif
311
312	#if (LINUX_VERSION_CODE < 0x020547)
313	#define pci_set_consistent_dma_mask(pdev, mask) (0)
314	#endif
315
316	#if (LINUX_VERSION_CODE < 0x020402)
317	#define pci_request_regions(pdev, name) (0)
318	#define pci_release_regions(pdev)
319	#endif
320
321	#if !defined(spin_is_locked)
322	#define spin_is_locked(lock) (test_bit(0,(lock)))
323	#endif
324
325	#define BCM5700_LOCK(pUmDevice, flags) \
326	if ((pUmDevice)->do_global_lock) { \
327	spin_lock_irqsave(&(pUmDevice)->global_lock, flags); \
328	}
329
330	#define BCM5700_UNLOCK(pUmDevice, flags) \
331	if ((pUmDevice)->do_global_lock) { \
332	spin_unlock_irqrestore(&(pUmDevice)->global_lock, flags);\
333	}
334
335	inline void
336	bcm5700_intr_lock(PUM_DEVICE_BLOCK pUmDevice)
337	{
338	if (pUmDevice->do_global_lock) {
339	spin_lock(&pUmDevice->global_lock);
340	}
341	}
342
343	inline void
344	bcm5700_intr_unlock(PUM_DEVICE_BLOCK pUmDevice)
345	{
346	if (pUmDevice->do_global_lock) {
347	spin_unlock(&pUmDevice->global_lock);
348	}
349	}
350
351	void
352	bcm5700_intr_off(PUM_DEVICE_BLOCK pUmDevice)
353	{
354	atomic_inc(&pUmDevice->intr_sem);
355	LM_DisableInterrupt(&pUmDevice->lm_dev);
356	#if (LINUX_VERSION_CODE >= 0x2051c)
357	synchronize_irq(pUmDevice->dev->irq);
358	#else
359	synchronize_irq();
360	#endif
361	LM_DisableInterrupt(&pUmDevice->lm_dev);
362	}
363
364	void
365	bcm5700_intr_on(PUM_DEVICE_BLOCK pUmDevice)
366	{
367	if (atomic_dec_and_test(&pUmDevice->intr_sem)) {
368	LM_EnableInterrupt(&pUmDevice->lm_dev);
369	}
370	}
371
372
373	int MM_Packet_Desc_Size = sizeof(UM_PACKET);
374
375	#if defined(MODULE)
376	MODULE_AUTHOR("Michael Chan <mchan at broadcom dot com> and Gary Zambrano <zambrano at broadcom dot com>");
377	MODULE_DESCRIPTION("BCM5700 Driver");
378	MODULE_LICENSE("GPL");
379
380	#if (LINUX_VERSION_CODE < 0x020605)
381
382	MODULE_PARM(debug, "i");
383	MODULE_PARM(msglevel, "i");
384	MODULE_PARM(activate_gpio, "0-15i");
385	MODULE_PARM(line_speed, "1-" __MODULE_STRING(MAX_UNITS) "i");
386	MODULE_PARM(auto_speed, "1-" __MODULE_STRING(MAX_UNITS) "i");
387	MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
388	MODULE_PARM(rx_flow_control, "1-" __MODULE_STRING(MAX_UNITS) "i");
389	MODULE_PARM(tx_flow_control, "1-" __MODULE_STRING(MAX_UNITS) "i");
390	MODULE_PARM(auto_flow_control, "1-" __MODULE_STRING(MAX_UNITS) "i");
391	#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
392	MODULE_PARM(mtu, "1-" __MODULE_STRING(MAX_UNITS) "i");
393	#endif
394	MODULE_PARM(tx_checksum, "1-" __MODULE_STRING(MAX_UNITS) "i");
395	MODULE_PARM(rx_checksum, "1-" __MODULE_STRING(MAX_UNITS) "i");
396	MODULE_PARM(scatter_gather, "1-" __MODULE_STRING(MAX_UNITS) "i");
397	MODULE_PARM(tx_pkt_desc_cnt, "1-" __MODULE_STRING(MAX_UNITS) "i");
398	MODULE_PARM(rx_std_desc_cnt, "1-" __MODULE_STRING(MAX_UNITS) "i");
399	#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
400	MODULE_PARM(rx_jumbo_desc_cnt, "1-" __MODULE_STRING(MAX_UNITS) "i");
401	#endif
402	#ifdef BCM_INT_COAL
403	MODULE_PARM(adaptive_coalesce, "1-" __MODULE_STRING(MAX_UNITS) "i");
404	MODULE_PARM(rx_coalesce_ticks, "1-" __MODULE_STRING(MAX_UNITS) "i");
405	MODULE_PARM(rx_max_coalesce_frames, "1-" __MODULE_STRING(MAX_UNITS) "i");
406	MODULE_PARM(tx_coalesce_ticks, "1-" __MODULE_STRING(MAX_UNITS) "i");
407	MODULE_PARM(tx_max_coalesce_frames, "1-" __MODULE_STRING(MAX_UNITS) "i");
408	MODULE_PARM(stats_coalesce_ticks, "1-" __MODULE_STRING(MAX_UNITS) "i");
409	#endif
410	#ifdef BCM_WOL
411	MODULE_PARM(enable_wol, "1-" __MODULE_STRING(MAX_UNITS) "i");
412	#endif
413	#ifdef BCM_TSO
414	MODULE_PARM(enable_tso, "1-" __MODULE_STRING(MAX_UNITS) "i");
415	#endif
416	#ifdef BCM_NIC_SEND_BD
417	MODULE_PARM(nic_tx_bd, "1-" __MODULE_STRING(MAX_UNITS) "i");
418	#endif
419	#ifdef BCM_ASF
420	MODULE_PARM(vlan_tag_mode, "1-" __MODULE_STRING(MAX_UNITS) "i");
421	#endif
422	MODULE_PARM(delay_link, "1-" __MODULE_STRING(MAX_UNITS) "i");
423	MODULE_PARM(disable_d3hot, "1-" __MODULE_STRING(MAX_UNITS) "i");
424
425	#if defined(CONFIG_PCI_MSI) \|\| defined(CONFIG_PCI_USE_VECTOR)
426	MODULE_PARM(disable_msi, "1-" __MODULE_STRING(MAX_UNITS) "i");
427	#endif
428
429	#else /* parms*/
430
431	#if (LINUX_VERSION_CODE >= 0x020605) && (LINUX_VERSION_CODE < 0x02060a)
432
433	static int var;
434
435	#define numvar var
436
437	#endif
438
439	#if (LINUX_VERSION_CODE >= 0x2060a)
440
441	#define numvar NULL
442
443	#endif
444
445	module_param_array(line_speed, int, numvar, 0);
446	module_param_array(auto_speed, int, numvar, 0);
447	module_param_array(full_duplex, int, numvar, 0);
448	module_param_array(rx_flow_control, int, numvar, 0);
449	module_param_array(tx_flow_control, int, numvar, 0);
450	module_param_array(auto_flow_control, int, numvar, 0);
451	#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
452	module_param_array(mtu, int, numvar, 0);
453	#endif
454	module_param_array(tx_checksum, int, numvar, 0);
455	module_param_array(rx_checksum, int, numvar, 0);
456	module_param_array(scatter_gather, int, numvar, 0);
457	module_param_array(tx_pkt_desc_cnt, int, numvar, 0);
458	module_param_array(rx_std_desc_cnt, int, numvar, 0);
459	#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
460	module_param_array(rx_jumbo_desc_cnt, int, numvar, 0);
461	#endif
462	#ifdef BCM_INT_COAL
463	module_param_array(adaptive_coalesce, int, numvar, 0);
464	module_param_array(rx_coalesce_ticks, int, numvar, 0);
465	module_param_array(rx_max_coalesce_frames, int, numvar, 0);
466	module_param_array(tx_coalesce_ticks, int, numvar, 0);
467	module_param_array(tx_max_coalesce_frames, int, numvar, 0);
468	module_param_array(stats_coalesce_ticks, int, numvar, 0);
469	#endif
470	#ifdef BCM_WOL
471	module_param_array(enable_wol, int, numvar, 0);
472	#endif
473	#ifdef BCM_TSO
474	module_param_array(enable_tso, int, numvar, 0);
475	#endif
476	#ifdef BCM_NIC_SEND_BD
477	module_param_array(nic_tx_bd, int, numvar, 0);
478	#endif
479	#ifdef BCM_ASF
480	module_param_array(vlan_tag_mode, int, numvar, 0);
481	#endif
482	module_param_array(delay_link, int, numvar, 0);
483	module_param_array(disable_d3hot, int, numvar, 0);
484
485	#if defined(CONFIG_PCI_MSI) \|\| defined(CONFIG_PCI_USE_VECTOR)
486	module_param_array(disable_msi, int, numvar, 0);
487	#endif
488
489
490	#endif /* params */
491
492
493	#endif
494
495	#define RUN_AT(x) (jiffies + (x))
496
497	char kernel_version[] = UTS_RELEASE;
498
499	#define PCI_SUPPORT_VER2
500
501	#if !defined(CAP_NET_ADMIN)
502	#define capable(CAP_XXX) (suser())
503	#endif
504
505	#define tigon3_debug debug
506	#if TIGON3_DEBUG
507	static int tigon3_debug = TIGON3_DEBUG;
508	#else
509	static int tigon3_debug = 0;
510	#endif
511	static int msglevel = 0xdeadbeef;
512	int b57_msg_level;
513
514	int bcm5700_open(struct net_device *dev);
515	STATIC void bcm5700_timer(unsigned long data);
516	STATIC void bcm5700_stats_timer(unsigned long data);
517	STATIC void bcm5700_reset(struct net_device *dev);
518	STATIC int bcm5700_start_xmit(struct sk_buff skb, struct net_device dev);
519	STATIC irqreturn_t bcm5700_interrupt(int irq, void dev_instance, struct pt_regs regs);
520	#ifdef BCM_TASKLET
521	STATIC void bcm5700_tasklet(unsigned long data);
522	#endif
523	STATIC int bcm5700_close(struct net_device *dev);
524	STATIC struct net_device_stats bcm5700_get_stats(struct net_device dev);
525	STATIC int bcm5700_ioctl(struct net_device dev, struct ifreq rq, int cmd);
526	STATIC void bcm5700_do_rx_mode(struct net_device *dev);
527	STATIC void bcm5700_set_rx_mode(struct net_device *dev);
528	STATIC int bcm5700_set_mac_addr(struct net_device dev, void p);
529	#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
530	STATIC int bcm5700_change_mtu(struct net_device *dev, int new_mtu);
531	#endif
532	#ifdef BCM_NAPI_RXPOLL
533	STATIC int bcm5700_poll(struct net_device dev, int budget);
534	#endif
535	STATIC int replenish_rx_buffers(PUM_DEVICE_BLOCK pUmDevice, int max);
536	STATIC int bcm5700_freemem(struct net_device *dev);
537	#ifdef BCM_INT_COAL
538	#ifndef BCM_NAPI_RXPOLL
539	STATIC int bcm5700_adapt_coalesce(PUM_DEVICE_BLOCK pUmDevice);
540	#endif
541	#endif
542	STATIC void bcm5700_set_vlan_mode(UM_DEVICE_BLOCK *pUmDevice);
543	STATIC int bcm5700_init_counters(PUM_DEVICE_BLOCK pUmDevice);
544	#ifdef BCM_VLAN
545	STATIC void bcm5700_vlan_rx_register(struct net_device dev, struct vlan_group vlgrp);
546	STATIC void bcm5700_vlan_rx_kill_vid(struct net_device *dev, uint16_t vid);
547	#endif
548	void bcm5700_shutdown(UM_DEVICE_BLOCK *pUmDevice);
549	void bcm5700_free_remaining_rx_bufs(UM_DEVICE_BLOCK *pUmDevice);
550	void bcm5700_validate_param_range(UM_DEVICE_BLOCK pUmDevice, int param,
551	char *param_name, int min, int max, int deflt);
552
553	static int bcm5700_notify_reboot(struct notifier_block this, unsigned long event, void unused);
554	static struct notifier_block bcm5700_reboot_notifier = {
555	bcm5700_notify_reboot,
556	NULL,
557	0
558	};
559
560	#if defined(HAVE_POLL_CONTROLLER) \|\| defined(CONFIG_NET_POLL_CONTROLLER)
561	STATIC void poll_bcm5700(struct net_device *dev);
562	#endif
563
564	/* A list of all installed bcm5700 devices. */
565	static struct net_device *root_tigon3_dev = NULL;
566
567	#if defined(CONFIG_SPARC64) \|\| defined(CONFIG_X86_64) \|\|defined(CONFIG_PPC64)
568
569	#endif
570
571	typedef enum {
572	BCM5700A6 = 0,
573	BCM5700T6,
574	BCM5700A9,
575	BCM5700T9,
576	BCM5700,
577	BCM5701A5,
578	BCM5701T1,
579	BCM5701T8,
580	BCM5701A7,
581	BCM5701A10,
582	BCM5701A12,
583	BCM5701,
584	BCM5702,
585	BCM5703,
586	BCM5703A31,
587	BCM5703ARBUCKLE,
588	TC996T,
589	TC996ST,
590	TC996SSX,
591	TC996SX,
592	TC996BT,
593	TC997T,
594	TC997SX,
595	TC1000T,
596	TC1000BT,
597	TC940BR01,
598	TC942BR01,
599	TC998T,
600	TC998SX,
601	TC999T,
602	NC6770,
603	NC1020,
604	NC150T,
605	NC7760,
606	NC7761,
607	NC7770,
608	NC7771,
609	NC7780,
610	NC7781,
611	NC7772,
612	NC7782,
613	NC7783,
614	NC320T,
615	NC320I,
616	NC325I,
617	NC324I,
618	NC326I,
619	BCM5704CIOBE,
620	BCM5704,
621	BCM5704S,
622	BCM5705,
623	BCM5705M,
624	BCM5705F,
625	BCM5901,
626	BCM5782,
627	BCM5788,
628	BCM5789,
629	BCM5750,
630	BCM5750M,
631	BCM5720,
632	BCM5751,
633	BCM5751M,
634	BCM5751F,
635	BCM5721,
636	BCM5753,
637	BCM5753M,
638	BCM5753F,
639	BCM5781,
640	BCM5752,
641	BCM5752M,
642	BCM5714,
643	BCM5780,
644	BCM5780S,
645	BCM5715,
646	BCM4785,
647	BCM5903M,
648	UNK5788
649	} board_t;
650
651
652	/* indexed by board_t, above */
653	static struct {
654	char *name;
655	} board_info[] __devinitdata = {
656	{ "Broadcom BCM5700 1000Base-T" },
657	{ "Broadcom BCM5700 1000Base-SX" },
658	{ "Broadcom BCM5700 1000Base-SX" },
659	{ "Broadcom BCM5700 1000Base-T" },
660	{ "Broadcom BCM5700" },
661	{ "Broadcom BCM5701 1000Base-T" },
662	{ "Broadcom BCM5701 1000Base-T" },
663	{ "Broadcom BCM5701 1000Base-T" },
664	{ "Broadcom BCM5701 1000Base-SX" },
665	{ "Broadcom BCM5701 1000Base-T" },
666	{ "Broadcom BCM5701 1000Base-T" },
667	{ "Broadcom BCM5701" },
668	{ "Broadcom BCM5702 1000Base-T" },
669	{ "Broadcom BCM5703 1000Base-T" },
670	{ "Broadcom BCM5703 1000Base-SX" },
671	{ "Broadcom B5703 1000Base-SX" },
672	{ "3Com 3C996 10/100/1000 Server NIC" },
673	{ "3Com 3C996 10/100/1000 Server NIC" },
674	{ "3Com 3C996 Gigabit Fiber-SX Server NIC" },
675	{ "3Com 3C996 Gigabit Fiber-SX Server NIC" },
676	{ "3Com 3C996B Gigabit Server NIC" },
677	{ "3Com 3C997 Gigabit Server NIC" },
678	{ "3Com 3C997 Gigabit Fiber-SX Server NIC" },
679	{ "3Com 3C1000 Gigabit NIC" },
680	{ "3Com 3C1000B-T 10/100/1000 PCI" },
681	{ "3Com 3C940 Gigabit LOM (21X21)" },
682	{ "3Com 3C942 Gigabit LOM (31X31)" },
683	{ "3Com 3C998-T Dual Port 10/100/1000 PCI-X Server NIC" },
684	{ "3Com 3C998-SX Dual Port 1000-SX PCI-X Server NIC" },
685	{ "3Com 3C999-T Quad Port 10/100/1000 PCI-X Server NIC" },
686	{ "HP NC6770 Gigabit Server Adapter" },
687	{ "NC1020 HP ProLiant Gigabit Server Adapter 32 PCI" },
688	{ "HP ProLiant NC 150T PCI 4-port Gigabit Combo Switch Adapter" },
689	{ "HP NC7760 Gigabit Server Adapter" },
690	{ "HP NC7761 Gigabit Server Adapter" },
691	{ "HP NC7770 Gigabit Server Adapter" },
692	{ "HP NC7771 Gigabit Server Adapter" },
693	{ "HP NC7780 Gigabit Server Adapter" },
694	{ "HP NC7781 Gigabit Server Adapter" },
695	{ "HP NC7772 Gigabit Server Adapter" },
696	{ "HP NC7782 Gigabit Server Adapter" },
697	{ "HP NC7783 Gigabit Server Adapter" },
698	{ "HP ProLiant NC 320T PCI Express Gigabit Server Adapter" },
699	{ "HP ProLiant NC 320i PCI Express Gigabit Server Adapter" },
700	{ "HP NC325i Integrated Dual Port PCI Express Gigabit Server Adapter" },
701	{ "HP NC324i Integrated Dual Port PCI Express Gigabit Server Adapter" },
702	{ "HP NC326i Integrated Dual Port PCI Express Gigabit Server Adapter" },
703	{ "Broadcom BCM5704 CIOB-E 1000Base-T" },
704	{ "Broadcom BCM5704 1000Base-T" },
705	{ "Broadcom BCM5704 1000Base-SX" },
706	{ "Broadcom BCM5705 1000Base-T" },
707	{ "Broadcom BCM5705M 1000Base-T" },
708	{ "Broadcom 570x 10/100 Integrated Controller" },
709	{ "Broadcom BCM5901 100Base-TX" },
710	{ "Broadcom NetXtreme Gigabit Ethernet for hp" },
711	{ "Broadcom BCM5788 NetLink 1000Base-T" },
712	{ "Broadcom BCM5789 NetLink 1000Base-T PCI Express" },
713	{ "Broadcom BCM5750 1000Base-T PCI" },
714	{ "Broadcom BCM5750M 1000Base-T PCI" },
715	{ "Broadcom BCM5720 1000Base-T PCI" },
716	{ "Broadcom BCM5751 1000Base-T PCI Express" },
717	{ "Broadcom BCM5751M 1000Base-T PCI Express" },
718	{ "Broadcom BCM5751F 100Base-TX PCI Express" },
719	{ "Broadcom BCM5721 1000Base-T PCI Express" },
720	{ "Broadcom BCM5753 1000Base-T PCI Express" },
721	{ "Broadcom BCM5753M 1000Base-T PCI Express" },
722	{ "Broadcom BCM5753F 100Base-TX PCI Express" },
723	{ "Broadcom BCM5781 NetLink 1000Base-T PCI Express" },
724	{ "Broadcom BCM5752 1000Base-T PCI Express" },
725	{ "Broadcom BCM5752M 1000Base-T PCI Express" },
726	{ "Broadcom BCM5714 1000Base-T " },
727	{ "Broadcom BCM5780 1000Base-T" },
728	{ "Broadcom BCM5780S 1000Base-SX" },
729	{ "Broadcom BCM5715 1000Base-T " },
730	{ "Broadcom BCM4785 10/100/1000 Integrated Controller" },
731	{ "Broadcom BCM5903M Gigabit Ethernet " },
732	{ "Unknown BCM5788 Gigabit Ethernet " },
733	{ 0 }
734	};
735
736	static struct pci_device_id bcm5700_pci_tbl[] __devinitdata = {
737	{0x14e4, 0x1644, 0x14e4, 0x1644, 0, 0, BCM5700A6 },
738	{0x14e4, 0x1644, 0x14e4, 0x2, 0, 0, BCM5700T6 },
739	{0x14e4, 0x1644, 0x14e4, 0x3, 0, 0, BCM5700A9 },
740	{0x14e4, 0x1644, 0x14e4, 0x4, 0, 0, BCM5700T9 },
741	{0x14e4, 0x1644, 0x1028, 0xd1, 0, 0, BCM5700 },
742	{0x14e4, 0x1644, 0x1028, 0x0106, 0, 0, BCM5700 },
743	{0x14e4, 0x1644, 0x1028, 0x0109, 0, 0, BCM5700 },
744	{0x14e4, 0x1644, 0x1028, 0x010a, 0, 0, BCM5700 },
745	{0x14e4, 0x1644, 0x10b7, 0x1000, 0, 0, TC996T },
746	{0x14e4, 0x1644, 0x10b7, 0x1001, 0, 0, TC996ST },
747	{0x14e4, 0x1644, 0x10b7, 0x1002, 0, 0, TC996SSX },
748	{0x14e4, 0x1644, 0x10b7, 0x1003, 0, 0, TC997T },
749	{0x14e4, 0x1644, 0x10b7, 0x1005, 0, 0, TC997SX },
750	{0x14e4, 0x1644, 0x10b7, 0x1008, 0, 0, TC942BR01 },
751	{0x14e4, 0x1644, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5700 },
752	{0x14e4, 0x1645, 0x14e4, 1, 0, 0, BCM5701A5 },
753	{0x14e4, 0x1645, 0x14e4, 5, 0, 0, BCM5701T1 },
754	{0x14e4, 0x1645, 0x14e4, 6, 0, 0, BCM5701T8 },
755	{0x14e4, 0x1645, 0x14e4, 7, 0, 0, BCM5701A7 },
756	{0x14e4, 0x1645, 0x14e4, 8, 0, 0, BCM5701A10 },
757	{0x14e4, 0x1645, 0x14e4, 0x8008, 0, 0, BCM5701A12 },
758	{0x14e4, 0x1645, 0x0e11, 0xc1, 0, 0, NC6770 },
759	{0x14e4, 0x1645, 0x0e11, 0x7c, 0, 0, NC7770 },
760	{0x14e4, 0x1645, 0x0e11, 0x85, 0, 0, NC7780 },
761	{0x14e4, 0x1645, 0x1028, 0x0121, 0, 0, BCM5701 },
762	{0x14e4, 0x1645, 0x10b7, 0x1004, 0, 0, TC996SX },
763	{0x14e4, 0x1645, 0x10b7, 0x1006, 0, 0, TC996BT },
764	{0x14e4, 0x1645, 0x10b7, 0x1007, 0, 0, TC1000T },
765	{0x14e4, 0x1645, 0x10b7, 0x1008, 0, 0, TC940BR01 },
766	{0x14e4, 0x1645, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5701 },
767	{0x14e4, 0x1646, 0x14e4, 0x8009, 0, 0, BCM5702 },
768	{0x14e4, 0x1646, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5702 },
769	{0x14e4, 0x16a6, 0x14e4, 0x8009, 0, 0, BCM5702 },
770	{0x14e4, 0x16a6, 0x14e4, 0x000c, 0, 0, BCM5702 },
771	{0x14e4, 0x16a6, 0x0e11, 0xbb, 0, 0, NC7760 },
772	{0x14e4, 0x16a6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5702 },
773	{0x14e4, 0x16c6, 0x10b7, 0x1100, 0, 0, TC1000BT },
774	{0x14e4, 0x16c6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5702 },
775	{0x14e4, 0x1647, 0x14e4, 0x0009, 0, 0, BCM5703 },
776	{0x14e4, 0x1647, 0x14e4, 0x000a, 0, 0, BCM5703A31 },
777	{0x14e4, 0x1647, 0x14e4, 0x000b, 0, 0, BCM5703 },
778	{0x14e4, 0x1647, 0x14e4, 0x800a, 0, 0, BCM5703 },
779	{0x14e4, 0x1647, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5703 },
780	{0x14e4, 0x16a7, 0x14e4, 0x0009, 0, 0, BCM5703 },
781	{0x14e4, 0x16a7, 0x14e4, 0x000a, 0, 0, BCM5703A31 },
782	{0x14e4, 0x16a7, 0x14e4, 0x000b, 0, 0, BCM5703 },
783	{0x14e4, 0x16a7, 0x14e4, 0x800a, 0, 0, BCM5703 },
784	{0x14e4, 0x16a7, 0x0e11, 0xca, 0, 0, NC7771 },
785	{0x14e4, 0x16a7, 0x0e11, 0xcb, 0, 0, NC7781 },
786	{0x14e4, 0x16a7, 0x1014, 0x0281, 0, 0, BCM5703ARBUCKLE },
787	{0x14e4, 0x16a7, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5703 },
788	{0x14e4, 0x16c7, 0x14e4, 0x000a, 0, 0, BCM5703A31 },
789	{0x14e4, 0x16c7, 0x0e11, 0xca, 0, 0, NC7771 },
790	{0x14e4, 0x16c7, 0x0e11, 0xcb, 0, 0, NC7781 },
791	{0x14e4, 0x16c7, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5703 },
792	{0x14e4, 0x1648, 0x0e11, 0xcf, 0, 0, NC7772 },
793	{0x14e4, 0x1648, 0x0e11, 0xd0, 0, 0, NC7782 },
794	{0x14e4, 0x1648, 0x0e11, 0xd1, 0, 0, NC7783 },
795	{0x14e4, 0x1648, 0x10b7, 0x2000, 0, 0, TC998T },
796	{0x14e4, 0x1648, 0x10b7, 0x3000, 0, 0, TC999T },
797	{0x14e4, 0x1648, 0x1166, 0x1648, 0, 0, BCM5704CIOBE },
798	{0x14e4, 0x1648, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5704 },
799	{0x14e4, 0x1649, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5704S },
800	{0x14e4, 0x16a8, 0x14e4, 0x16a8, 0, 0, BCM5704S },
801	{0x14e4, 0x16a8, 0x10b7, 0x2001, 0, 0, TC998SX },
802	{0x14e4, 0x16a8, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5704S },
803	{0x14e4, 0x1653, 0x0e11, 0x00e3, 0, 0, NC7761 },
804	{0x14e4, 0x1653, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705 },
805	{0x14e4, 0x1654, 0x0e11, 0x00e3, 0, 0, NC7761 },
806	{0x14e4, 0x1654, 0x103c, 0x3100, 0, 0, NC1020 },
807	{0x14e4, 0x1654, 0x103c, 0x3226, 0, 0, NC150T },
808	{0x14e4, 0x1654, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705 },
809	{0x14e4, 0x165d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705M },
810	{0x14e4, 0x165e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705M },
811	{0x14e4, 0x166e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705F },
812	{0x14e4, 0x1696, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5782 },
813	{0x14e4, 0x169c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5788 },
814	{0x14e4, 0x169d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5789 },
815	{0x14e4, 0x170d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5901 },
816	{0x14e4, 0x170e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5901 },
817	{0x14e4, 0x1676, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5750 },
818	{0x14e4, 0x167c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5750M },
819	{0x14e4, 0x1677, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5751 },
820	{0x14e4, 0x167d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5751M },
821	{0x14e4, 0x167e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5751F },
822	{0x14e4, 0x1658, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5720 },
823	{0x14e4, 0x1659, 0x103c, 0x7031, 0, 0, NC320T },
824	{0x14e4, 0x1659, 0x103c, 0x7032, 0, 0, NC320T },
825	{0x14e4, 0x166a, 0x103c, 0x7035, 0, 0, NC325I },
826	{0x14e4, 0x166b, 0x103c, 0x7036, 0, 0, NC325I },
827	{0x14e4, 0x1668, 0x103c, 0x7039, 0, 0, NC324I },
828	{0x14e4, 0x1669, 0x103c, 0x703a, 0, 0, NC324I },
829	{0x14e4, 0x1678, 0x103c, 0x703e, 0, 0, NC326I },
830	{0x14e4, 0x1679, 0x103c, 0x703c, 0, 0, NC326I },
831	{0x14e4, 0x1659, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5721 },
832	{0x14e4, 0x16f7, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5753 },
833	{0x14e4, 0x16fd, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5753M },
834	{0x14e4, 0x16fe, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5753F },
835	{0x14e4, 0x16dd, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5781 },
836	{0x14e4, 0x1600, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5752 },
837	{0x14e4, 0x1601, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5752M },
838	{0x14e4, 0x1668, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5714 },
839	{0x14e4, 0x166a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5780 },
840	{0x14e4, 0x166b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5780S },
841	{0x14e4, 0x1678, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5715 },
842	{0x14e4, 0x471f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM4785 },
843	{0x14e4, 0x16ff, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5903M },
844	{0x173b, 0x03ed, PCI_ANY_ID, PCI_ANY_ID, 0, 0, UNK5788 },
845	{0,}
846	};
847
848	MODULE_DEVICE_TABLE(pci, bcm5700_pci_tbl);
849
850	#if (LINUX_VERSION_CODE >= 0x2060a)
851	static struct pci_device_id pci_AMD762id[]={
852	{ PCI_DEVICE(PCI_VENDOR_ID_AMD,
853	PCI_DEVICE_ID_AMD_FE_GATE_700C) },
854	{ }
855	};
856	#endif
857
858	static int sbgige = -1;
859
860	/*******************************************************************************
861	*******************************************************************************
862	*/
863
864	int get_csum_flag(LM_UINT32 ChipRevId)
865	{
866	return NETIF_F_IP_CSUM;
867	}
868
869	/*******************************************************************************
870	*******************************************************************************
871
872	This function returns true if the device passed to it is attached to an
873	ICH-ICH4. If the chip is not attached to an ICH, or is attached to an ICH5
874	or newer, it returns false.
875
876	This function determines which bridge it is attached to by scaning the pci
877	bus looking for bridge chips (hdr_type=1). When a bridge chip is detected,
878	the bridge's subordinate's secondary bus number is compared with this
879	devices bus number. If they match, then the device is attached to this
880	bridge. The bridge's device id is compared to a list of known device ids for
881	ICH-ICH4. Since many older ICH's (ICH2-ICH7) share the same device id, the
882	chip revision must also be checked to determine if the chip is older than an
883	ICH5.
884
885	To scan the bus, one of two functions is used depending on the kernel
886	version. For 2.4 kernels, the pci_find_device function is used. This
887	function has been depricated in the 2.6 kernel and replaced with the
888	fucntion pci_get_device. The macro walk_pci_bus determines which function to
889	use when the driver is built.
890	*/
891
892	#if (LINUX_VERSION_CODE >= 0x2060a)
893	#define walk_pci_bus(d) while ((d = pci_get_device( \
894	PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)
895
896	#define unwalk_pci_bus(d) pci_dev_put(d)
897
898	#else
899	#define walk_pci_bus(d) while ((d = pci_find_device( \
900	PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)
901	#define unwalk_pci_bus(d)
902
903	#endif
904
905	#define ICH5_CHIP_VERSION 0xc0
906
907	static struct pci_device_id pci_ICHtable[] = {
908	{0x8086, 0x2418}, /* PCI_DEVICE_ID_INTEL_82801AA_8 */
909	{0x8086, 0x2428}, /* PCI_DEVICE_ID_INTEL_82801AB_8 */
910	{0x8086, 0x244e}, /* PCI_DEVICE_ID_INTEL_82801BA_6 */
911	{0x8086, 0x2448}, /* PCI_DEVICE_ID_INTEL_82801BA_11 */
912	{0, 0}
913	};
914
915	int attached_to_ICH4_or_older( struct pci_dev *pdev)
916	{
917	struct pci_dev *tmp_pdev = NULL;
918	struct pci_device_id *ich_table;
919	u8 chip_rev;
920
921	walk_pci_bus (tmp_pdev) {
922	if ((tmp_pdev->hdr_type == 1) &&
923	(tmp_pdev->subordinate != NULL) &&
924	(tmp_pdev->subordinate->secondary == pdev->bus->number)) {
925
926	ich_table = pci_ICHtable;
927
928	while (ich_table->vendor) {
929	if ((ich_table->vendor == tmp_pdev->vendor) &&
930	(ich_table->device == tmp_pdev->device)) {
931
932	pci_read_config_byte( tmp_pdev,
933	PCI_REVISION_ID, &chip_rev);
934
935	if (chip_rev < ICH5_CHIP_VERSION) {
936	unwalk_pci_bus( tmp_pdev);
937	return 1;
938	}
939	}
940	ich_table++;
941	}
942	}
943	}
944	return 0;
945	}
946
947	static void robo_set_power_mode(void *h)
948	{
949	//int status = 0;
950	int i;
951	//uint8 mode8;
952	//uint16 mode16;
953	uint32 flags = 0, temp32 = 0,val32 = 0, savephyaddr = 0;
954	PUM_DEVICE_BLOCK pudev = (PUM_DEVICE_BLOCK)h;
955	PLM_DEVICE_BLOCK pdev = &pudev->lm_dev;
956
957	/Brcm,Alex,2006.7.20. Adding Phy power mode setting/
958	BCM5700_PHY_LOCK(pudev, flags);
959	savephyaddr = pdev->PhyAddr;
960
961	for(i = 0; i < 8; i++)
962	{
963	pdev->PhyAddr = i;
964	temp32 = 0x2007;
965	LM_WritePhy(pdev, 0x18, temp32);
966	LM_ReadPhy(pdev, 0x18, &val32);
967	// printk(KERN_DEBUG "Alex: port = %x, read value =%x\n",i, val32);
968	temp32 = 0xc042;
969	LM_WritePhy(pdev, 0x18, temp32);
970	/Read back/
971	temp32 = 0x2007;
972	val32 = 0;
973	LM_WritePhy(pdev, 0x18, temp32);
974	LM_ReadPhy(pdev, 0x18, &val32);
975	// printk(KERN_ERR "Alex: read back value =%x\n",val32);
976	}
977
978	pdev->PhyAddr = savephyaddr;
979	BCM5700_PHY_UNLOCK(pudev, flags);
980
981	/end of Brcm,Alex,2006.7.20. Adding Phy power mode setting/
982
983	}
984
985	static int
986	__devinit bcm5700_init_board(struct pci_dev pdev, struct net_device *dev_out, int board_idx)
987	{
988	struct net_device *dev;
989	PUM_DEVICE_BLOCK pUmDevice;
990	PLM_DEVICE_BLOCK pDevice;
991	bool rgmii = FALSE;
992	sb_t *sbh = NULL;
993	int rc;
994
995	*dev_out = NULL;
996
997	/* dev zeroed in init_etherdev */
998	#if (LINUX_VERSION_CODE >= 0x20600)
999	dev = alloc_etherdev(sizeof(*pUmDevice));
1000	#else
1001	dev = init_etherdev(NULL, sizeof(*pUmDevice));
1002	#endif
1003	if (dev == NULL) {
1004	printk(KERN_ERR "%s: unable to alloc new ethernet\n", bcm5700_driver);
1005	return -ENOMEM;
1006	}
1007	SET_MODULE_OWNER(dev);
1008	#if (LINUX_VERSION_CODE >= 0x20600)
1009	SET_NETDEV_DEV(dev, &pdev->dev);
1010	#endif
1011	pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
1012
1013	/* enable device (incl. PCI PM wakeup), and bus-mastering */
1014	rc = pci_enable_device(pdev);
1015	if (rc)
1016	goto err_out;
1017
1018	/* init core specific stuff */
1019	if (pdev->device == T3_PCI_DEVICE_ID(T3_PCI_ID_BCM471F)) {
1020	sbh = sb_kattach(SB_OSH);
1021	sb_gige_init(sbh, ++sbgige, &rgmii);
1022	}
1023
1024	rc = pci_request_regions(pdev, bcm5700_driver);
1025	if (rc) {
1026	if (!sbh)
1027	goto err_out;
1028	printk(KERN_INFO "bcm5700_init_board: pci_request_regions returned error %d\n"
1029	"This may be because the region is already requested by"
1030	" the SMBus driver. Ignore the PCI error messages.\n", rc);
1031	}
1032
1033	pci_set_master(pdev);
1034
1035	if (pci_set_dma_mask(pdev, BCM_64BIT_DMA_MASK) == 0) {
1036	pUmDevice->using_dac = 1;
1037	if (pci_set_consistent_dma_mask(pdev, BCM_64BIT_DMA_MASK) != 0) {
1038	printk(KERN_ERR "pci_set_consistent_dma_mask failed\n");
1039	pci_release_regions(pdev);
1040	goto err_out;
1041	}
1042	} else if (pci_set_dma_mask(pdev, BCM_32BIT_DMA_MASK) == 0) {
1043	pUmDevice->using_dac = 0;
1044	} else {
1045	printk(KERN_ERR "System does not support DMA\n");
1046	pci_release_regions(pdev);
1047	goto err_out;
1048	}
1049
1050	pUmDevice->dev = dev;
1051	pUmDevice->pdev = pdev;
1052	pUmDevice->mem_list_num = 0;
1053	pUmDevice->next_module = root_tigon3_dev;
1054	pUmDevice->index = board_idx;
1055	pUmDevice->sbh = (void *)sbh;
1056	root_tigon3_dev = dev;
1057
1058	spin_lock_init(&pUmDevice->global_lock);
1059
1060	spin_lock_init(&pUmDevice->undi_lock);
1061
1062	spin_lock_init(&pUmDevice->phy_lock);
1063
1064	pDevice = &pUmDevice->lm_dev;
1065	pDevice->Flags = 0;
1066	pDevice->FunctNum = PCI_FUNC(pUmDevice->pdev->devfn);
1067	pUmDevice->boardflags = getintvar(NULL, "boardflags");
1068	if (sbh) {
1069	if (pUmDevice->boardflags & BFL_ENETROBO)
1070	pDevice->Flags \|= ROBO_SWITCH_FLAG;
1071	pDevice->Flags \|= rgmii ? RGMII_MODE_FLAG : 0;
1072	if (sb_chip(sbh) == BCM4785_CHIP_ID && sb_chiprev(sbh) < 2)
1073	pDevice->Flags \|= ONE_DMA_AT_ONCE_FLAG;
1074	pDevice->Flags \|= SB_CORE_FLAG;
1075	if (sb_chip(sbh) == BCM4785_CHIP_ID)
1076	pDevice->Flags \|= FLUSH_POSTED_WRITE_FLAG;
1077	}
1078
1079	#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
1080	if (board_idx < MAX_UNITS) {
1081	bcm5700_validate_param_range(pUmDevice, &mtu[board_idx], "mtu", 1500, 9000, 1500);
1082	dev->mtu = mtu[board_idx];
1083	}
1084	#endif
1085
1086	if (attached_to_ICH4_or_older(pdev)) {
1087	pDevice->Flags \|= UNDI_FIX_FLAG;
1088	}
1089
1090	#if (LINUX_VERSION_CODE >= 0x2060a)
1091	if (pci_dev_present(pci_AMD762id)) {
1092	pDevice->Flags \|= FLUSH_POSTED_WRITE_FLAG;
1093	pDevice->Flags &= ~NIC_SEND_BD_FLAG;
1094	}
1095	#else
1096	if (pci_find_device(0x1022, 0x700c, NULL)) {
1097	/* AMD762 writes I/O out of order */
1098	/* Setting bit 1 in 762's register 0x4C still doesn't work */
1099	/* in all cases */
1100	pDevice->Flags \|= FLUSH_POSTED_WRITE_FLAG;
1101	pDevice->Flags &= ~NIC_SEND_BD_FLAG;
1102	}
1103	#endif
1104	if (LM_GetAdapterInfo(pDevice) != LM_STATUS_SUCCESS) {
1105	rc = -ENODEV;
1106	goto err_out_unmap;
1107	}
1108
1109	if (pDevice->Flags & ROBO_SWITCH_FLAG) {
1110	robo_info_t *robo;
1111
1112	if ((robo = bcm_robo_attach(sbh, pDevice, dev->name, NULL,
1113	robo_miird, robo_miiwr)) == NULL) {
1114	B57_ERR(("robo_setup: failed to attach robo switch \n"));
1115	goto robo_fail;
1116	}
1117
1118	if (bcm_robo_enable_device(robo)) {
1119	B57_ERR(("robo_setup: failed to enable robo switch \n"));
1120	robo_fail:
1121	bcm_robo_detach(robo);
1122	rc = -ENODEV;
1123	goto err_out_unmap;
1124	}
1125
1126	/* 5397 power mode setting */
1127	robo_set_power_mode(robo->h);
1128
1129	pUmDevice->robo = (void *)robo;
1130	}
1131
1132	if ((pDevice->Flags & JUMBO_CAPABLE_FLAG) == 0) {
1133	if (dev->mtu > 1500) {
1134	dev->mtu = 1500;
1135	printk(KERN_WARNING
1136	"%s-%d: Jumbo mtu sizes not supported, using mtu=1500\n",
1137	bcm5700_driver, pUmDevice->index);
1138	}
1139	}
1140
1141	pUmDevice->do_global_lock = 0;
1142	if (T3_ASIC_REV(pUmDevice->lm_dev.ChipRevId) == T3_ASIC_REV_5700) {
1143	/* The 5700 chip works best without interleaved register */
1144	/* accesses on certain machines. */
1145	pUmDevice->do_global_lock = 1;
1146	}
1147
1148	if ((T3_ASIC_REV(pUmDevice->lm_dev.ChipRevId) == T3_ASIC_REV_5701) &&
1149	((pDevice->PciState & T3_PCI_STATE_NOT_PCI_X_BUS) == 0)) {
1150
1151	pUmDevice->rx_buf_align = 0;
1152	} else {
1153	pUmDevice->rx_buf_align = 2;
1154	}
1155	dev->mem_start = pci_resource_start(pdev, 0);
1156	dev->mem_end = dev->mem_start + sizeof(T3_STD_MEM_MAP);
1157	dev->irq = pdev->irq;
1158
1159	*dev_out = dev;
1160	return 0;
1161
1162	err_out_unmap:
1163	pci_release_regions(pdev);
1164	bcm5700_freemem(dev);
1165
1166	err_out:
1167	#if (LINUX_VERSION_CODE < 0x020600)
1168	unregister_netdev(dev);
1169	kfree(dev);
1170	#else
1171	free_netdev(dev);
1172	#endif
1173	return rc;
1174	}
1175
1176	static int __devinit
1177	bcm5700_print_ver(void)
1178	{
1179	printk(KERN_INFO "Broadcom Gigabit Ethernet Driver %s ",
1180	bcm5700_driver);
1181	printk("ver. %s %s\n", bcm5700_version, bcm5700_date);
1182	return 0;
1183	}
1184
1185	static int __devinit
1186	bcm5700_init_one(struct pci_dev pdev, const struct pci_device_id ent)
1187	{
1188	struct net_device *dev = NULL;
1189	PUM_DEVICE_BLOCK pUmDevice;
1190	PLM_DEVICE_BLOCK pDevice;
1191	int i;
1192	static int board_idx = -1;
1193	static int printed_version = 0;
1194	struct pci_dev *pci_dev;
1195
1196	board_idx++;
1197
1198	if (!printed_version) {
1199	bcm5700_print_ver();
1200	printed_version = 1;
1201	}
1202
1203	i = bcm5700_init_board(pdev, &dev, board_idx);
1204	if (i < 0) {
1205	return i;
1206	}
1207
1208	if (dev == NULL)
1209	return -ENOMEM;
1210
1211	#ifdef BCM_IOCTL32
1212	if (atomic_read(&bcm5700_load_count) == 0) {
1213	register_ioctl32_conversion(SIOCNICE, bcm5700_ioctl32);
1214	}
1215	atomic_inc(&bcm5700_load_count);
1216	#endif
1217	dev->open = bcm5700_open;
1218	dev->hard_start_xmit = bcm5700_start_xmit;
1219	dev->stop = bcm5700_close;
1220	dev->get_stats = bcm5700_get_stats;
1221	dev->set_multicast_list = bcm5700_set_rx_mode;
1222	dev->do_ioctl = bcm5700_ioctl;
1223	dev->set_mac_address = &bcm5700_set_mac_addr;
1224	#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
1225	dev->change_mtu = &bcm5700_change_mtu;
1226	#endif
1227	#if (LINUX_VERSION_CODE >= 0x20400)
1228	dev->tx_timeout = bcm5700_reset;
1229	dev->watchdog_timeo = TX_TIMEOUT;
1230	#endif
1231	#ifdef BCM_VLAN
1232	dev->vlan_rx_register = &bcm5700_vlan_rx_register;
1233	dev->vlan_rx_kill_vid = &bcm5700_vlan_rx_kill_vid;
1234	#endif
1235	#ifdef BCM_NAPI_RXPOLL
1236	dev->poll = bcm5700_poll;
1237	dev->weight = 64;
1238	#endif
1239
1240	pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
1241	pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
1242
1243	dev->base_addr = pci_resource_start(pdev, 0);
1244	dev->irq = pdev->irq;
1245	#if defined(HAVE_POLL_CONTROLLER) \|\| defined(CONFIG_NET_POLL_CONTROLLER)
1246	dev->poll_controller = poll_bcm5700;
1247	#endif
1248
1249	#if (LINUX_VERSION_CODE >= 0x20600)
1250	if ((i = register_netdev(dev))) {
1251	printk(KERN_ERR "%s: Cannot register net device\n",
1252	bcm5700_driver);
1253	if (pUmDevice->lm_dev.pMappedMemBase)
1254	iounmap(pUmDevice->lm_dev.pMappedMemBase);
1255	pci_release_regions(pdev);
1256	bcm5700_freemem(dev);
1257	free_netdev(dev);
1258	return i;
1259	}
1260	#endif
1261
1262
1263	pci_set_drvdata(pdev, dev);
1264
1265	memcpy(dev->dev_addr, pDevice->NodeAddress, 6);
1266	pUmDevice->name = board_info[ent->driver_data].name,
1267	printk(KERN_INFO "%s: %s found at mem %lx, IRQ %d, ",
1268	dev->name, pUmDevice->name, dev->base_addr,
1269	dev->irq);
1270	printk("node addr ");
1271	for (i = 0; i < 6; i++) {
1272	printk("%2.2x", dev->dev_addr[i]);
1273	}
1274	printk("\n");
1275
1276	printk(KERN_INFO "%s: ", dev->name);
1277	if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5400_PHY_ID)
1278	printk("Broadcom BCM5400 Copper ");
1279	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5401_PHY_ID)
1280	printk("Broadcom BCM5401 Copper ");
1281	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5411_PHY_ID)
1282	printk("Broadcom BCM5411 Copper ");
1283	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5461_PHY_ID)
1284	printk("Broadcom BCM5461 Copper ");
1285	else if (((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5701_PHY_ID) &&
1286	!(pDevice->TbiFlags & ENABLE_TBI_FLAG)) {
1287	printk("Broadcom BCM5701 Integrated Copper ");
1288	}
1289	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5703_PHY_ID) {
1290	printk("Broadcom BCM5703 Integrated ");
1291	if (pDevice->TbiFlags & ENABLE_TBI_FLAG)
1292	printk("SerDes ");
1293	else
1294	printk("Copper ");
1295	}
1296	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5704_PHY_ID) {
1297	printk("Broadcom BCM5704 Integrated ");
1298	if (pDevice->TbiFlags & ENABLE_TBI_FLAG)
1299	printk("SerDes ");
1300	else
1301	printk("Copper ");
1302	}
1303	else if (pDevice->PhyFlags & PHY_IS_FIBER){
1304	if(( pDevice->PhyId & PHY_ID_MASK ) == PHY_BCM5780_PHY_ID)
1305	printk("Broadcom BCM5780S Integrated Serdes ");
1306
1307	}
1308	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5705_PHY_ID)
1309	printk("Broadcom BCM5705 Integrated Copper ");
1310	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5750_PHY_ID)
1311	printk("Broadcom BCM5750 Integrated Copper ");
1312
1313	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5714_PHY_ID)
1314	printk("Broadcom BCM5714 Integrated Copper ");
1315	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5780_PHY_ID)
1316	printk("Broadcom BCM5780 Integrated Copper ");
1317
1318	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5752_PHY_ID)
1319	printk("Broadcom BCM5752 Integrated Copper ");
1320	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM8002_PHY_ID)
1321	printk("Broadcom BCM8002 SerDes ");
1322	else if (pDevice->TbiFlags & ENABLE_TBI_FLAG) {
1323	if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5703) {
1324	printk("Broadcom BCM5703 Integrated SerDes ");
1325	}
1326	else if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5704) {
1327	printk("Broadcom BCM5704 Integrated SerDes ");
1328	}
1329	else {
1330	printk("Agilent HDMP-1636 SerDes ");
1331	}
1332	}
1333	else {
1334	printk("Unknown ");
1335	}
1336	printk("transceiver found\n");
1337
1338	#if (LINUX_VERSION_CODE >= 0x20400)
1339	if (scatter_gather[board_idx]) {
1340	dev->features \|= NETIF_F_SG;
1341	if (pUmDevice->using_dac && !(pDevice->Flags & BCM5788_FLAG))
1342	dev->features \|= NETIF_F_HIGHDMA;
1343	}
1344	if ((pDevice->TaskOffloadCap & LM_TASK_OFFLOAD_TX_TCP_CHECKSUM) &&
1345	tx_checksum[board_idx]) {
1346
1347	dev->features \|= get_csum_flag( pDevice->ChipRevId);
1348	}
1349	#ifdef BCM_VLAN
1350	dev->features \|= NETIF_F_HW_VLAN_TX \| NETIF_F_HW_VLAN_RX;
1351	#endif
1352	#ifdef BCM_TSO
1353	/* On 5714/15/80 chips, Jumbo Frames and TSO cannot both be enabled at
1354	the same time. Since only one of these features can be enable at a
1355	time, we'll enable only Jumbo Frames and disable TSO when the user
1356	tries to enable both.
1357	*/
1358	dev->features &= ~NETIF_F_TSO;
1359
1360	if ((pDevice->TaskToOffload & LM_TASK_OFFLOAD_TCP_SEGMENTATION) &&
1361	(enable_tso[board_idx])) {
1362	if (T3_ASIC_5714_FAMILY(pDevice->ChipRevId) &&
1363	(dev->mtu > 1500)) {
1364	printk(KERN_ALERT "%s: Jumbo Frames and TSO cannot simultaneously be enabled. Jumbo Frames enabled. TSO disabled.\n", dev->name);
1365	} else {
1366	dev->features \|= NETIF_F_TSO;
1367	}
1368	}
1369	#endif
1370	printk(KERN_INFO "%s: Scatter-gather %s, 64-bit DMA %s, Tx Checksum %s, ",
1371	dev->name,
1372	(char *) ((dev->features & NETIF_F_SG) ? "ON" : "OFF"),
1373	(char *) ((dev->features & NETIF_F_HIGHDMA) ? "ON" : "OFF"),
1374	(char *) ((dev->features & get_csum_flag( pDevice->ChipRevId)) ? "ON" : "OFF"));
1375	#endif
1376	if ((pDevice->ChipRevId != T3_CHIP_ID_5700_B0) &&
1377	rx_checksum[board_idx])
1378	printk("Rx Checksum ON");
1379	else
1380	printk("Rx Checksum OFF");
1381	#ifdef BCM_VLAN
1382	printk(", 802.1Q VLAN ON");
1383	#endif
1384	#ifdef BCM_TSO
1385	if (dev->features & NETIF_F_TSO) {
1386	printk(", TSO ON");
1387	}
1388	else
1389	#endif
1390	#ifdef BCM_NAPI_RXPOLL
1391	printk(", NAPI ON");
1392	#endif
1393	printk("\n");
1394
1395	register_reboot_notifier(&bcm5700_reboot_notifier);
1396	#ifdef BCM_TASKLET
1397	tasklet_init(&pUmDevice->tasklet, bcm5700_tasklet,
1398	(unsigned long) pUmDevice);
1399	#endif
1400	if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5704) {
1401	if ((REG_RD(pDevice, PciCfg.DualMacCtrl) &
1402	T3_DUAL_MAC_CH_CTRL_MASK) == 3) {
1403
1404	printk(KERN_WARNING "%s: Device is configured for Hardware Based Teaming which is not supported with this operating system. Please consult the user diagnostic guide to disable Turbo Teaming.\n", dev->name);
1405	}
1406	}
1407
1408	#if (LINUX_VERSION_CODE > 0x20605)
1409
1410	if ((pci_dev = pci_get_device(0x1022, 0x700c, NULL)))
1411	#else
1412	if ((pci_dev = pci_find_device(0x1022, 0x700c, NULL)))
1413	#endif
1414	{
1415	u32 val;
1416
1417	/* Found AMD 762 North bridge */
1418	pci_read_config_dword(pci_dev, 0x4c, &val);
1419	if ((val & 0x02) == 0) {
1420	pci_write_config_dword(pci_dev, 0x4c, val \| 0x02);
1421	printk(KERN_INFO "%s: Setting AMD762 Northbridge to enable PCI ordering compliance\n", bcm5700_driver);
1422	}
1423	}
1424
1425	#if (LINUX_VERSION_CODE > 0x20605)
1426
1427	pci_dev_put(pci_dev);
1428
1429	#if defined(CONFIG_PCI_MSI) \|\| defined(CONFIG_PCI_USE_VECTOR)
1430
1431	if ((pci_dev = pci_get_device(0x1066, 0x0017, NULL))) {
1432	bcm_msi_chipset_bug = 1;
1433	}
1434	pci_dev_put(pci_dev);
1435	#endif
1436	#endif
1437
1438	return 0;
1439	}
1440
1441
1442	static void __devexit
1443	bcm5700_remove_one (struct pci_dev *pdev)
1444	{
1445	struct net_device *dev = pci_get_drvdata (pdev);
1446	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
1447
1448	#ifdef BCM_IOCTL32
1449	atomic_dec(&bcm5700_load_count);
1450	if (atomic_read(&bcm5700_load_count) == 0)
1451	unregister_ioctl32_conversion(SIOCNICE);
1452	#endif
1453	unregister_netdev(dev);
1454
1455	if (pUmDevice->lm_dev.pMappedMemBase)
1456	iounmap(pUmDevice->lm_dev.pMappedMemBase);
1457
1458	pci_release_regions(pdev);
1459
1460	#if (LINUX_VERSION_CODE < 0x020600)
1461	kfree(dev);
1462	#else
1463	free_netdev(dev);
1464	#endif
1465
1466	pci_set_drvdata(pdev, NULL);
1467
1468	}
1469
1470	int b57_test_intr(UM_DEVICE_BLOCK *pUmDevice);
1471
1472	#ifdef BCM_WL_EMULATOR
1473	/* new transmit callback */
1474	static int bcm5700emu_start_xmit(struct sk_buff skb, struct net_device dev);
1475	/* keep track of the 2 gige devices */
1476	static PLM_DEVICE_BLOCK pDev1;
1477	static PLM_DEVICE_BLOCK pDev2;
1478
1479	static void
1480	bcm5700emu_open(struct net_device *dev)
1481	{
1482	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
1483	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
1484	static int instance = 0;
1485	static char *wlemu_if = NULL;
1486	char *wlemu_mode = NULL;
1487	//int wlemu_idx = 0;
1488	static int rx_enable = 0;
1489	static int tx_enable = 0;
1490
1491	/* which interface is the emulator ? */
1492	if(instance == 0) {
1493	wlemu_if = nvram_get("wlemu_if");
1494	/* do we emulate rx, tx or both */
1495	wlemu_mode = nvram_get("wlemu_mode");
1496	if(wlemu_mode) {
1497	if (!strcmp(wlemu_mode,"rx"))
1498	{
1499	rx_enable = 1;
1500	}
1501	else if (!strcmp(wlemu_mode,"tx"))
1502	{
1503
1504	tx_enable = 1;
1505
1506	}
1507	else if (!strcmp(wlemu_mode,"rx_tx"))
1508	{
1509
1510	rx_enable = 1;
1511	tx_enable = 1;
1512	}
1513	}
1514	}
1515
1516	instance++;
1517
1518	/* The context is used for accessing the OSL for emulating devices */
1519	pDevice->wlc = NULL;
1520
1521	/* determines if this device is an emulator */
1522	pDevice->wl_emulate_rx = 0;
1523	pDevice->wl_emulate_tx = 0;
1524
1525	if(wlemu_if && !strcmp(dev->name,wlemu_if))
1526	{
1527	/* create an emulator context. */
1528	pDevice->wlc = (void )wlcemu_wlccreate((void )dev);
1529	B57_INFO(("Using %s for wl emulation \n", dev->name));
1530	if(rx_enable)
1531	{
1532	B57_INFO(("Enabling wl RX emulation \n"));
1533	pDevice->wl_emulate_rx = 1;
1534	}
1535	/* re-direct transmit callback to emulator */
1536	if(tx_enable)
1537	{
1538	pDevice->wl_emulate_tx = 1;
1539	dev->hard_start_xmit = bcm5700emu_start_xmit;
1540	B57_INFO(("Enabling wl TX emulation \n"));
1541	}
1542	}
1543	/* for debug access to configured devices only */
1544	if(instance == 1)
1545	pDev1 = pDevice;
1546	else if (instance == 2)
1547	pDev2 = pDevice;
1548	}
1549
1550	/* Public API to get current emulation info */
1551	int bcm5700emu_get_info(char *buf)
1552	{
1553	int len = 0;
1554	PLM_DEVICE_BLOCK p;
1555
1556	/* look for an emulating device */
1557	if(pDev1->wlc) {
1558	p = pDev1;
1559	len += sprintf(buf+len,"emulation device : eth0\n");
1560	}
1561	else if (pDev2->wlc) {
1562	p = pDev2;
1563	len += sprintf(buf+len,"emulation device : eth1\n");
1564	}
1565	else {
1566	len += sprintf(buf+len,"emulation not activated\n");
1567	return len;
1568	}
1569	if(p->wl_emulate_rx)
1570	len += sprintf(buf+len,"RX emulation enabled\n");
1571	else
1572	len += sprintf(buf+len,"RX emulation disabled\n");
1573	if(p->wl_emulate_tx)
1574	len += sprintf(buf+len,"TX emulation enabled\n");
1575	else
1576	len += sprintf(buf+len,"TX emulation disabled\n");
1577	return len;
1578
1579	}
1580
1581
1582	/* Public API to access the bcm5700_start_xmit callback */
1583
1584	int
1585	bcm5700emu_forward_xmit(struct sk_buff skb, struct net_device dev)
1586	{
1587	return bcm5700_start_xmit(skb, dev);
1588	}
1589
1590
1591	/* hook to kernel txmit callback */
1592	STATIC int
1593	bcm5700emu_start_xmit(struct sk_buff skb, struct net_device dev)
1594	{
1595
1596	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
1597	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
1598	return wlcemu_start_xmit(skb,pDevice->wlc);
1599	}
1600
1601	#endif /* BCM_WL_EMULATOR */
1602
1603	int
1604	bcm5700_open(struct net_device *dev)
1605	{
1606	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
1607	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
1608	int rc;
1609
1610	if (pUmDevice->suspended){
1611	return -EAGAIN;
1612	}
1613
1614	#ifdef BCM_WL_EMULATOR
1615	bcm5700emu_open(dev);
1616	#endif
1617
1618	/* delay for 6 seconds */
1619	pUmDevice->delayed_link_ind = (6 * HZ) / pUmDevice->timer_interval;
1620
1621	#ifdef BCM_INT_COAL
1622	#ifndef BCM_NAPI_RXPOLL
1623	pUmDevice->adaptive_expiry = HZ / pUmDevice->timer_interval;
1624	#endif
1625	#endif
1626
1627	#ifdef INCLUDE_TBI_SUPPORT
1628	if ((pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
1629	(pDevice->TbiFlags & TBI_POLLING_FLAGS)) {
1630	pUmDevice->poll_tbi_interval = HZ / pUmDevice->timer_interval;
1631	if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5703) {
1632	pUmDevice->poll_tbi_interval /= 4;
1633	}
1634	pUmDevice->poll_tbi_expiry = pUmDevice->poll_tbi_interval;
1635	}
1636	#endif
1637	/* set this timer for 2 seconds */
1638	pUmDevice->asf_heartbeat = (2 * HZ) / pUmDevice->timer_interval;
1639
1640	#if defined(CONFIG_PCI_MSI) \|\| defined(CONFIG_PCI_USE_VECTOR)
1641
1642
1643	if ( ( (T3_ASIC_IS_575X_PLUS(pDevice->ChipRevId) ) &&
1644	(T3_ASIC_REV(pDevice->ChipRevId) != T3_ASIC_REV_5714_A0 ) &&
1645	(T3_CHIP_REV(pDevice->ChipRevId) != T3_CHIP_REV_5750_AX ) &&
1646	(T3_CHIP_REV(pDevice->ChipRevId) != T3_CHIP_REV_5750_BX ) ) &&
1647	!bcm_msi_chipset_bug ){
1648
1649	if (disable_msi[pUmDevice->index]==1){
1650	/* do nothing-it's not turned on */
1651	}else{
1652	pDevice->Flags \|= USING_MSI_FLAG;
1653
1654	REG_WR(pDevice, Msi.Mode, 2 );
1655
1656	rc = pci_enable_msi(pUmDevice->pdev);
1657
1658	if(rc!=0){
1659	pDevice->Flags &= ~ USING_MSI_FLAG;
1660	REG_WR(pDevice, Msi.Mode, 1 );
1661	}
1662	}
1663	}
1664
1665
1666	#endif
1667
1668	if ((rc= request_irq(pUmDevice->pdev->irq, &bcm5700_interrupt, SA_SHIRQ, dev->name, dev)))
1669	{
1670
1671	#if defined(CONFIG_PCI_MSI) \|\| defined(CONFIG_PCI_USE_VECTOR)
1672
1673	if(pDevice->Flags & USING_MSI_FLAG) {
1674
1675	pci_disable_msi(pUmDevice->pdev);
1676	pDevice->Flags &= ~USING_MSI_FLAG;
1677	REG_WR(pDevice, Msi.Mode, 1 );
1678
1679	}
1680	#endif
1681	return rc;
1682	}
1683
1684	pUmDevice->opened = 1;
1685	if (LM_InitializeAdapter(pDevice) != LM_STATUS_SUCCESS) {
1686	pUmDevice->opened = 0;
1687	free_irq(dev->irq, dev);
1688	bcm5700_freemem(dev);
1689	return -EAGAIN;
1690	}
1691
1692	bcm5700_set_vlan_mode(pUmDevice);
1693	bcm5700_init_counters(pUmDevice);
1694
1695	if (pDevice->Flags & UNDI_FIX_FLAG) {
1696	printk(KERN_INFO "%s: Using indirect register access\n", dev->name);
1697	}
1698
1699	if (memcmp(dev->dev_addr, pDevice->NodeAddress, 6))
1700	{
1701	/* Do not use invalid eth addrs: any multicast & all zeros */
1702	if( is_valid_ether_addr(dev->dev_addr) ){
1703	LM_SetMacAddress(pDevice, dev->dev_addr);
1704	}
1705	else
1706	{
1707	printk(KERN_INFO "%s: Invalid administered node address\n",dev->name);
1708	memcpy(dev->dev_addr, pDevice->NodeAddress, 6);
1709	}
1710	}
1711
1712	if (tigon3_debug > 1)
1713	printk(KERN_DEBUG "%s: tigon3_open() irq %d.\n", dev->name, dev->irq);
1714
1715	QQ_InitQueue(&pUmDevice->rx_out_of_buf_q.Container,
1716	MAX_RX_PACKET_DESC_COUNT);
1717
1718
1719	#if (LINUX_VERSION_CODE < 0x020300)
1720	MOD_INC_USE_COUNT;
1721	#endif
1722
1723	atomic_set(&pUmDevice->intr_sem, 0);
1724
1725	LM_EnableInterrupt(pDevice);
1726
1727	#if defined(CONFIG_PCI_MSI) \|\| defined(CONFIG_PCI_USE_VECTOR)
1728
1729	if (pDevice->Flags & USING_MSI_FLAG){
1730
1731	/* int test to check support on older machines */
1732	if (b57_test_intr(pUmDevice) != 1) {
1733
1734	LM_DisableInterrupt(pDevice);
1735	free_irq(pUmDevice->pdev->irq, dev);
1736	pci_disable_msi(pUmDevice->pdev);
1737	REG_WR(pDevice, Msi.Mode, 1 );
1738	pDevice->Flags &= ~USING_MSI_FLAG;
1739
1740	rc = LM_ResetAdapter(pDevice);
1741	printk(KERN_ALERT " The MSI support in this system is not functional.\n");
1742
1743	if (rc == LM_STATUS_SUCCESS)
1744	rc = 0;
1745	else
1746	rc = -ENODEV;
1747
1748	if(rc == 0){
1749	rc = request_irq(pUmDevice->pdev->irq, &bcm5700_interrupt,
1750	SA_SHIRQ, dev->name, dev);
1751	}
1752
1753	if(rc){
1754	LM_Halt(pDevice);
1755	bcm5700_freemem(dev);
1756	pUmDevice->opened = 0;
1757	return rc;
1758	}
1759
1760
1761	pDevice->InitDone = TRUE;
1762	atomic_set(&pUmDevice->intr_sem, 0);
1763	LM_EnableInterrupt(pDevice);
1764	}
1765	}
1766	#endif
1767
1768	init_timer(&pUmDevice->timer);
1769	pUmDevice->timer.expires = RUN_AT(pUmDevice->timer_interval);
1770	pUmDevice->timer.data = (unsigned long)dev;
1771	pUmDevice->timer.function = &bcm5700_timer;
1772	add_timer(&pUmDevice->timer);
1773
1774	if (T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)) {
1775	init_timer(&pUmDevice->statstimer);
1776	pUmDevice->statstimer.expires = RUN_AT(pUmDevice->statstimer_interval);
1777	pUmDevice->statstimer.data = (unsigned long)dev;
1778	pUmDevice->statstimer.function = &bcm5700_stats_timer;
1779	add_timer(&pUmDevice->statstimer);
1780	}
1781
1782	if(pDevice->Flags & USING_MSI_FLAG)
1783	printk(KERN_INFO "%s: Using Message Signaled Interrupt (MSI) \n", dev->name);
1784	else
1785	printk(KERN_INFO "%s: Using PCI INTX interrupt \n", dev->name);
1786
1787	netif_start_queue(dev);
1788
1789	return 0;
1790	}
1791
1792
1793	STATIC void
1794	bcm5700_stats_timer(unsigned long data)
1795	{
1796	struct net_device dev = (struct net_device )data;
1797	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
1798	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
1799	unsigned long flags = 0;
1800
1801	if (!pUmDevice->opened)
1802	return;
1803
1804	if (!atomic_read(&pUmDevice->intr_sem) &&
1805	!pUmDevice->suspended &&
1806	(pDevice->LinkStatus == LM_STATUS_LINK_ACTIVE)) {
1807	BCM5700_LOCK(pUmDevice, flags);
1808	LM_GetStats(pDevice);
1809	BCM5700_UNLOCK(pUmDevice, flags);
1810	}
1811
1812	pUmDevice->statstimer.expires = RUN_AT(pUmDevice->statstimer_interval);
1813
1814	add_timer(&pUmDevice->statstimer);
1815	}
1816
1817
1818	STATIC void
1819	bcm5700_timer(unsigned long data)
1820	{
1821	struct net_device dev = (struct net_device )data;
1822	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
1823	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
1824	unsigned long flags = 0;
1825	LM_UINT32 value32;
1826
1827	if (!pUmDevice->opened)
1828	return;
1829
1830	/* BCM4785: Flush posted writes from GbE to host memory. */
1831	if (pDevice->Flags & FLUSH_POSTED_WRITE_FLAG)
1832	REG_RD(pDevice, HostCoalesce.Mode);
1833
1834	if (atomic_read(&pUmDevice->intr_sem) \|\| pUmDevice->suspended) {
1835	pUmDevice->timer.expires = RUN_AT(pUmDevice->timer_interval);
1836	add_timer(&pUmDevice->timer);
1837	return;
1838	}
1839
1840	#ifdef INCLUDE_TBI_SUPPORT
1841	if ((pDevice->TbiFlags & TBI_POLLING_FLAGS) &&
1842	(--pUmDevice->poll_tbi_expiry <= 0)) {
1843
1844	BCM5700_PHY_LOCK(pUmDevice, flags);
1845	value32 = REG_RD(pDevice, MacCtrl.Status);
1846	if (((pDevice->LinkStatus == LM_STATUS_LINK_ACTIVE) &&
1847	((value32 & (MAC_STATUS_LINK_STATE_CHANGED \|
1848	MAC_STATUS_CFG_CHANGED)) \|\|
1849	!(value32 & MAC_STATUS_PCS_SYNCED)))
1850	\|\|
1851	((pDevice->LinkStatus != LM_STATUS_LINK_ACTIVE) &&
1852	(value32 & (MAC_STATUS_PCS_SYNCED \|
1853	MAC_STATUS_SIGNAL_DETECTED))))
1854	{
1855	LM_SetupPhy(pDevice);
1856	}
1857	BCM5700_PHY_UNLOCK(pUmDevice, flags);
1858	pUmDevice->poll_tbi_expiry = pUmDevice->poll_tbi_interval;
1859
1860	}
1861	#endif
1862
1863	if (pUmDevice->delayed_link_ind > 0) {
1864	if (pUmDevice->delayed_link_ind == 1)
1865	MM_IndicateStatus(pDevice, pDevice->LinkStatus);
1866	else
1867	pUmDevice->delayed_link_ind--;
1868	}
1869
1870	if (pUmDevice->crc_counter_expiry > 0)
1871	pUmDevice->crc_counter_expiry--;
1872
1873	if (!pUmDevice->interrupt) {
1874	if (!(pDevice->Flags & USE_TAGGED_STATUS_FLAG)) {
1875	BCM5700_LOCK(pUmDevice, flags);
1876	if (pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) {
1877	/* This will generate an interrupt */
1878	REG_WR(pDevice, Grc.LocalCtrl,
1879	pDevice->GrcLocalCtrl \|
1880	GRC_MISC_LOCAL_CTRL_SET_INT);
1881	}
1882	else {
1883	REG_WR(pDevice, HostCoalesce.Mode,
1884	pDevice->CoalesceMode \|
1885	HOST_COALESCE_ENABLE \|
1886	HOST_COALESCE_NOW);
1887	}
1888	if (!(REG_RD(pDevice, DmaWrite.Mode) &
1889	DMA_WRITE_MODE_ENABLE)) {
1890	BCM5700_UNLOCK(pUmDevice, flags);
1891	bcm5700_reset(dev);
1892	}
1893	else {
1894	BCM5700_UNLOCK(pUmDevice, flags);
1895	}
1896	if (pUmDevice->tx_queued) {
1897	pUmDevice->tx_queued = 0;
1898	netif_wake_queue(dev);
1899	}
1900	}
1901	#if (LINUX_VERSION_CODE < 0x02032b)
1902	if ((QQ_GetEntryCnt(&pDevice->TxPacketFreeQ.Container) !=
1903	pDevice->TxPacketDescCnt) &&
1904	((jiffies - dev->trans_start) > TX_TIMEOUT)) {
1905
1906	printk(KERN_WARNING "%s: Tx hung\n", dev->name);
1907	bcm5700_reset(dev);
1908	}
1909	#endif
1910	}
1911	#ifdef BCM_INT_COAL
1912	#ifndef BCM_NAPI_RXPOLL
1913	if (pUmDevice->adaptive_coalesce) {
1914	pUmDevice->adaptive_expiry--;
1915	if (pUmDevice->adaptive_expiry == 0) {
1916	pUmDevice->adaptive_expiry = HZ /
1917	pUmDevice->timer_interval;
1918	bcm5700_adapt_coalesce(pUmDevice);
1919	}
1920	}
1921	#endif
1922	#endif
1923	if (QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container) >
1924	(unsigned int) pUmDevice->rx_buf_repl_panic_thresh) {
1925	/* Generate interrupt and let isr allocate buffers */
1926	REG_WR(pDevice, HostCoalesce.Mode, pDevice->CoalesceMode \|
1927	HOST_COALESCE_ENABLE \| HOST_COALESCE_NOW);
1928	}
1929
1930	#ifdef BCM_ASF
1931	if (pDevice->AsfFlags & ASF_ENABLED) {
1932	pUmDevice->asf_heartbeat--;
1933	if (pUmDevice->asf_heartbeat == 0) {
1934	if( (pDevice->Flags & UNDI_FIX_FLAG) \|\|
1935	(pDevice->Flags & ENABLE_PCIX_FIX_FLAG)) {
1936	MEM_WR_OFFSET(pDevice, T3_CMD_MAILBOX,
1937	T3_CMD_NICDRV_ALIVE2);
1938	MEM_WR_OFFSET(pDevice, T3_CMD_LENGTH_MAILBOX,
1939	4);
1940	MEM_WR_OFFSET(pDevice, T3_CMD_DATA_MAILBOX, 5);
1941	} else {
1942	LM_RegWr(pDevice,
1943	(T3_NIC_MBUF_POOL_ADDR +
1944	T3_CMD_MAILBOX),
1945	T3_CMD_NICDRV_ALIVE2, 1);
1946	LM_RegWr(pDevice,
1947	(T3_NIC_MBUF_POOL_ADDR +
1948	T3_CMD_LENGTH_MAILBOX),4,1);
1949	LM_RegWr(pDevice,
1950	(T3_NIC_MBUF_POOL_ADDR +
1951	T3_CMD_DATA_MAILBOX),5,1);
1952	}
1953
1954	value32 = REG_RD(pDevice, Grc.RxCpuEvent);
1955	REG_WR(pDevice, Grc.RxCpuEvent, value32 \| BIT_14);
1956	pUmDevice->asf_heartbeat = (2 * HZ) /
1957	pUmDevice->timer_interval;
1958	}
1959	}
1960	#endif
1961
1962	if (pDevice->PhyFlags & PHY_IS_FIBER){
1963	BCM5700_PHY_LOCK(pUmDevice, flags);
1964	LM_5714_FamFiberCheckLink(pDevice);
1965	BCM5700_PHY_UNLOCK(pUmDevice, flags);
1966	}
1967
1968	pUmDevice->timer.expires = RUN_AT(pUmDevice->timer_interval);
1969	add_timer(&pUmDevice->timer);
1970	}
1971
1972	STATIC int
1973	bcm5700_init_counters(PUM_DEVICE_BLOCK pUmDevice)
1974	{
1975	#ifdef BCM_INT_COAL
1976	#ifndef BCM_NAPI_RXPOLL
1977	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
1978
1979	pUmDevice->rx_curr_coalesce_frames = pDevice->RxMaxCoalescedFrames;
1980	pUmDevice->rx_curr_coalesce_ticks = pDevice->RxCoalescingTicks;
1981	pUmDevice->tx_curr_coalesce_frames = pDevice->TxMaxCoalescedFrames;
1982	pUmDevice->rx_last_cnt = 0;
1983	pUmDevice->tx_last_cnt = 0;
1984	#endif
1985	#endif
1986	pUmDevice->phy_crc_count = 0;
1987	#if TIGON3_DEBUG
1988	pUmDevice->tx_zc_count = 0;
1989	pUmDevice->tx_chksum_count = 0;
1990	pUmDevice->tx_himem_count = 0;
1991	pUmDevice->rx_good_chksum_count = 0;
1992	pUmDevice->rx_bad_chksum_count = 0;
1993	#endif
1994	#ifdef BCM_TSO
1995	pUmDevice->tso_pkt_count = 0;
1996	#endif
1997	return 0;
1998	}
1999
2000	#ifdef BCM_INT_COAL
2001	#ifndef BCM_NAPI_RXPOLL
2002	STATIC int
2003	bcm5700_do_adapt_coalesce(PUM_DEVICE_BLOCK pUmDevice,
2004	int rx_frames, int rx_ticks, int tx_frames, int rx_frames_intr)
2005	{
2006	unsigned long flags = 0;
2007	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2008
2009	if (pUmDevice->do_global_lock) {
2010	if (spin_is_locked(&pUmDevice->global_lock))
2011	return 0;
2012	spin_lock_irqsave(&pUmDevice->global_lock, flags);
2013	}
2014	pUmDevice->rx_curr_coalesce_frames = rx_frames;
2015	pUmDevice->rx_curr_coalesce_ticks = rx_ticks;
2016	pUmDevice->tx_curr_coalesce_frames = tx_frames;
2017	pUmDevice->rx_curr_coalesce_frames_intr = rx_frames_intr;
2018	REG_WR(pDevice, HostCoalesce.RxMaxCoalescedFrames, rx_frames);
2019
2020	REG_WR(pDevice, HostCoalesce.RxCoalescingTicks, rx_ticks);
2021
2022	REG_WR(pDevice, HostCoalesce.TxMaxCoalescedFrames, tx_frames);
2023
2024	REG_WR(pDevice, HostCoalesce.RxMaxCoalescedFramesDuringInt,
2025	rx_frames_intr);
2026
2027	BCM5700_UNLOCK(pUmDevice, flags);
2028	return 0;
2029	}
2030
2031	STATIC int
2032	bcm5700_adapt_coalesce(PUM_DEVICE_BLOCK pUmDevice)
2033	{
2034	PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
2035	uint rx_curr_cnt, tx_curr_cnt, rx_delta, tx_delta, total_delta;
2036
2037	rx_curr_cnt = pDevice->pStatsBlkVirt->ifHCInUcastPkts.Low;
2038	tx_curr_cnt = pDevice->pStatsBlkVirt->ifHCOutUcastPkts.Low;
2039	if ((rx_curr_cnt <= pUmDevice->rx_last_cnt) \|\|
2040	(tx_curr_cnt < pUmDevice->tx_last_cnt)) {
2041
2042	/* skip if there is counter rollover */
2043	pUmDevice->rx_last_cnt = rx_curr_cnt;
2044	pUmDevice->tx_last_cnt = tx_curr_cnt;
2045	return 0;
2046	}
2047
2048	rx_delta = rx_curr_cnt - pUmDevice->rx_last_cnt;
2049	tx_delta = tx_curr_cnt - pUmDevice->tx_last_cnt;
2050	total_delta = (((rx_delta + rx_delta) + tx_delta) / 3) << 1;
2051
2052	pUmDevice->rx_last_cnt = rx_curr_cnt;
2053	pUmDevice->tx_last_cnt = tx_curr_cnt;
2054
2055	if (total_delta < ADAPTIVE_LO_PKT_THRESH) {
2056	if (pUmDevice->rx_curr_coalesce_frames !=
2057	ADAPTIVE_LO_RX_MAX_COALESCED_FRAMES) {
2058
2059	bcm5700_do_adapt_coalesce(pUmDevice,
2060	ADAPTIVE_LO_RX_MAX_COALESCED_FRAMES,
2061	ADAPTIVE_LO_RX_COALESCING_TICKS,
2062	ADAPTIVE_LO_TX_MAX_COALESCED_FRAMES,
2063	ADAPTIVE_LO_RX_MAX_COALESCED_FRAMES_DURING_INT);
2064	}
2065	}
2066	else if (total_delta < ADAPTIVE_HI_PKT_THRESH) {
2067	if (pUmDevice->rx_curr_coalesce_frames !=
2068	DEFAULT_RX_MAX_COALESCED_FRAMES) {
2069
2070	bcm5700_do_adapt_coalesce(pUmDevice,
2071	DEFAULT_RX_MAX_COALESCED_FRAMES,
2072	DEFAULT_RX_COALESCING_TICKS,
2073	DEFAULT_TX_MAX_COALESCED_FRAMES,
2074	DEFAULT_RX_MAX_COALESCED_FRAMES_DURING_INT);
2075	}
2076	}
2077	else {
2078	if (pUmDevice->rx_curr_coalesce_frames !=
2079	ADAPTIVE_HI_RX_MAX_COALESCED_FRAMES) {
2080
2081	bcm5700_do_adapt_coalesce(pUmDevice,
2082	ADAPTIVE_HI_RX_MAX_COALESCED_FRAMES,
2083	ADAPTIVE_HI_RX_COALESCING_TICKS,
2084	ADAPTIVE_HI_TX_MAX_COALESCED_FRAMES,
2085	ADAPTIVE_HI_RX_MAX_COALESCED_FRAMES_DURING_INT);
2086	}
2087	}
2088	return 0;
2089	}
2090	#endif
2091	#endif
2092
2093	STATIC void
2094	bcm5700_reset(struct net_device *dev)
2095	{
2096	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
2097	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
2098	unsigned long flags;
2099
2100	#ifdef BCM_TSO
2101
2102	if( (dev->features & NETIF_F_TSO) &&
2103	(pUmDevice->tx_full) ) {
2104
2105	dev->features &= ~NETIF_F_TSO;
2106	}
2107	#endif
2108
2109	netif_stop_queue(dev);
2110	bcm5700_intr_off(pUmDevice);
2111	BCM5700_PHY_LOCK(pUmDevice, flags);
2112	LM_ResetAdapter(pDevice);
2113	pDevice->InitDone = TRUE;
2114	bcm5700_do_rx_mode(dev);
2115	bcm5700_set_vlan_mode(pUmDevice);
2116	bcm5700_init_counters(pUmDevice);
2117	if (memcmp(dev->dev_addr, pDevice->NodeAddress, 6)) {
2118	LM_SetMacAddress(pDevice, dev->dev_addr);
2119	}
2120	BCM5700_PHY_UNLOCK(pUmDevice, flags);
2121	atomic_set(&pUmDevice->intr_sem, 1);
2122	bcm5700_intr_on(pUmDevice);
2123	netif_wake_queue(dev);
2124	}
2125
2126	STATIC void
2127	bcm5700_set_vlan_mode(UM_DEVICE_BLOCK *pUmDevice)
2128	{
2129	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2130	LM_UINT32 ReceiveMask = pDevice->ReceiveMask;
2131	int vlan_tag_mode = pUmDevice->vlan_tag_mode;
2132
2133	if (vlan_tag_mode == VLAN_TAG_MODE_AUTO_STRIP) {
2134	if (pDevice->AsfFlags & ASF_ENABLED) {
2135	vlan_tag_mode = VLAN_TAG_MODE_FORCED_STRIP;
2136	}
2137	else {
2138	vlan_tag_mode = VLAN_TAG_MODE_NORMAL_STRIP;
2139	}
2140	}
2141	if (vlan_tag_mode == VLAN_TAG_MODE_NORMAL_STRIP) {
2142	ReceiveMask \|= LM_KEEP_VLAN_TAG;
2143	#ifdef BCM_VLAN
2144	if (pUmDevice->vlgrp)
2145	ReceiveMask &= ~LM_KEEP_VLAN_TAG;
2146	#endif
2147	}
2148	else if (vlan_tag_mode == VLAN_TAG_MODE_FORCED_STRIP) {
2149	ReceiveMask &= ~LM_KEEP_VLAN_TAG;
2150	}
2151	if (ReceiveMask != pDevice->ReceiveMask)
2152	{
2153	LM_SetReceiveMask(pDevice, ReceiveMask);
2154	}
2155	}
2156
2157	static void
2158	bcm5700_poll_wait(UM_DEVICE_BLOCK *pUmDevice)
2159	{
2160	#ifdef BCM_NAPI_RXPOLL
2161	while (pUmDevice->lm_dev.RxPoll) {
2162	current->state = TASK_INTERRUPTIBLE;
2163	schedule_timeout(1);
2164	}
2165	#endif
2166	}
2167
2168
2169	#ifdef BCM_VLAN
2170	STATIC void
2171	bcm5700_vlan_rx_register(struct net_device dev, struct vlan_group vlgrp)
2172	{
2173	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
2174
2175	bcm5700_intr_off(pUmDevice);
2176	bcm5700_poll_wait(pUmDevice);
2177	pUmDevice->vlgrp = vlgrp;
2178	bcm5700_set_vlan_mode(pUmDevice);
2179	bcm5700_intr_on(pUmDevice);
2180	}
2181
2182	STATIC void
2183	bcm5700_vlan_rx_kill_vid(struct net_device *dev, uint16_t vid)
2184	{
2185	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
2186
2187	bcm5700_intr_off(pUmDevice);
2188	bcm5700_poll_wait(pUmDevice);
2189	if (pUmDevice->vlgrp) {
2190	pUmDevice->vlgrp->vlan_devices[vid] = NULL;
2191	}
2192	bcm5700_intr_on(pUmDevice);
2193	}
2194	#endif
2195
2196	STATIC int
2197	bcm5700_start_xmit(struct sk_buff skb, struct net_device dev)
2198	{
2199	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
2200	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
2201	PLM_PACKET pPacket;
2202	PUM_PACKET pUmPacket;
2203	unsigned long flags = 0;
2204	int frag_no;
2205	#ifdef BCM_TSO
2206	LM_UINT32 mss = 0 ;
2207	uint16_t ip_tcp_len, tcp_opt_len, tcp_seg_flags;
2208	#endif
2209
2210	if ((pDevice->LinkStatus == LM_STATUS_LINK_DOWN) \|\|
2211	!pDevice->InitDone \|\| pUmDevice->suspended)
2212	{
2213	dev_kfree_skb(skb);
2214	return 0;
2215	}
2216
2217	#if (LINUX_VERSION_CODE < 0x02032b)
2218	if (test_and_set_bit(0, &dev->tbusy)) {
2219	return 1;
2220	}
2221	#endif
2222
2223	if (pUmDevice->do_global_lock && pUmDevice->interrupt) {
2224	netif_stop_queue(dev);
2225	pUmDevice->tx_queued = 1;
2226	if (!pUmDevice->interrupt) {
2227	netif_wake_queue(dev);
2228	pUmDevice->tx_queued = 0;
2229	}
2230	return 1;
2231	}
2232
2233	pPacket = (PLM_PACKET)
2234	QQ_PopHead(&pDevice->TxPacketFreeQ.Container);
2235	if (pPacket == 0) {
2236	netif_stop_queue(dev);
2237	pUmDevice->tx_full = 1;
2238	if (QQ_GetEntryCnt(&pDevice->TxPacketFreeQ.Container)) {
2239	netif_wake_queue(dev);
2240	pUmDevice->tx_full = 0;
2241	}
2242	return 1;
2243	}
2244	pUmPacket = (PUM_PACKET) pPacket;
2245	pUmPacket->skbuff = skb;
2246	pUmDevice->stats.tx_bytes += skb->len;
2247
2248	if (skb->ip_summed == CHECKSUM_HW) {
2249	pPacket->Flags = SND_BD_FLAG_TCP_UDP_CKSUM;
2250	#if TIGON3_DEBUG
2251	pUmDevice->tx_chksum_count++;
2252	#endif
2253	}
2254	else {
2255	pPacket->Flags = 0;
2256	}
2257	#if MAX_SKB_FRAGS
2258	frag_no = skb_shinfo(skb)->nr_frags;
2259	#else
2260	frag_no = 0;
2261	#endif
2262	if (atomic_read(&pDevice->SendBdLeft) < (frag_no + 1)) {
2263	netif_stop_queue(dev);
2264	pUmDevice->tx_full = 1;
2265	QQ_PushHead(&pDevice->TxPacketFreeQ.Container, pPacket);
2266	if (atomic_read(&pDevice->SendBdLeft) >= (frag_no + 1)) {
2267	netif_wake_queue(dev);
2268	pUmDevice->tx_full = 0;
2269	}
2270	return 1;
2271	}
2272
2273	pPacket->u.Tx.FragCount = frag_no + 1;
2274	#if TIGON3_DEBUG
2275	if (pPacket->u.Tx.FragCount > 1)
2276	pUmDevice->tx_zc_count++;
2277	#endif
2278
2279	#ifdef BCM_VLAN
2280	if (pUmDevice->vlgrp && vlan_tx_tag_present(skb)) {
2281	pPacket->VlanTag = vlan_tx_tag_get(skb);
2282	pPacket->Flags \|= SND_BD_FLAG_VLAN_TAG;
2283	}
2284	#endif
2285
2286	#ifdef BCM_TSO
2287	if ((mss = (LM_UINT32) skb_shinfo(skb)->tso_size) &&
2288	(skb->len > pDevice->TxMtu)) {
2289
2290	#if (LINUX_VERSION_CODE >= 0x02060c)
2291
2292	if (skb_header_cloned(skb) &&
2293	pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) {
2294
2295	dev_kfree_skb(skb);
2296	return 0;
2297	}
2298	#endif
2299	pUmDevice->tso_pkt_count++;
2300
2301	pPacket->Flags \|= SND_BD_FLAG_CPU_PRE_DMA \|
2302	SND_BD_FLAG_CPU_POST_DMA;
2303
2304	tcp_opt_len = 0;
2305	if (skb->h.th->doff > 5) {
2306	tcp_opt_len = (skb->h.th->doff - 5) << 2;
2307	}
2308	ip_tcp_len = (skb->nh.iph->ihl << 2) + sizeof(struct tcphdr);
2309	skb->nh.iph->check = 0;
2310
2311	if ( T3_ASIC_IS_575X_PLUS(pDevice->ChipRevId) ){
2312	skb->h.th->check = 0;
2313	pPacket->Flags &= ~SND_BD_FLAG_TCP_UDP_CKSUM;
2314	}
2315	else {
2316	skb->h.th->check = ~csum_tcpudp_magic(
2317	skb->nh.iph->saddr, skb->nh.iph->daddr,
2318	0, IPPROTO_TCP, 0);
2319	}
2320
2321	skb->nh.iph->tot_len = htons(mss + ip_tcp_len + tcp_opt_len);
2322	tcp_seg_flags = 0;
2323
2324	if (tcp_opt_len \|\| (skb->nh.iph->ihl > 5)) {
2325	if ( T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId) ){
2326	tcp_seg_flags =
2327	((skb->nh.iph->ihl - 5) +
2328	(tcp_opt_len >> 2)) << 11;
2329	}
2330	else {
2331	pPacket->Flags \|=
2332	((skb->nh.iph->ihl - 5) +
2333	(tcp_opt_len >> 2)) << 12;
2334	}
2335	}
2336	pPacket->u.Tx.MaxSegmentSize = mss \| tcp_seg_flags;
2337	}
2338	else
2339	{
2340	pPacket->u.Tx.MaxSegmentSize = 0;
2341	}
2342	#endif
2343	BCM5700_LOCK(pUmDevice, flags);
2344	LM_SendPacket(pDevice, pPacket);
2345	BCM5700_UNLOCK(pUmDevice, flags);
2346
2347	#if (LINUX_VERSION_CODE < 0x02032b)
2348	netif_wake_queue(dev);
2349	#endif
2350	dev->trans_start = jiffies;
2351
2352
2353	return 0;
2354	}
2355
2356	#ifdef BCM_NAPI_RXPOLL
2357	STATIC int
2358	bcm5700_poll(struct net_device dev, int budget)
2359	{
2360	int orig_budget = *budget;
2361	int work_done;
2362	UM_DEVICE_BLOCK pUmDevice = (UM_DEVICE_BLOCK ) dev->priv;
2363	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2364	unsigned long flags = 0;
2365	LM_UINT32 tag;
2366
2367	if (orig_budget > dev->quota)
2368	orig_budget = dev->quota;
2369
2370	BCM5700_LOCK(pUmDevice, flags);
2371	/* BCM4785: Flush posted writes from GbE to host memory. */
2372	if (pDevice->Flags & FLUSH_POSTED_WRITE_FLAG)
2373	REG_RD(pDevice, HostCoalesce.Mode);
2374	work_done = LM_ServiceRxPoll(pDevice, orig_budget);
2375	*budget -= work_done;
2376	dev->quota -= work_done;
2377
2378	if (QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container)) {
2379	replenish_rx_buffers(pUmDevice, 0);
2380	}
2381	BCM5700_UNLOCK(pUmDevice, flags);
2382	if (work_done) {
2383	MM_IndicateRxPackets(pDevice);
2384	BCM5700_LOCK(pUmDevice, flags);
2385	LM_QueueRxPackets(pDevice);
2386	BCM5700_UNLOCK(pUmDevice, flags);
2387	}
2388	if ((work_done < orig_budget) \|\| atomic_read(&pUmDevice->intr_sem) \|\|
2389	pUmDevice->suspended) {
2390
2391	netif_rx_complete(dev);
2392	BCM5700_LOCK(pUmDevice, flags);
2393	REG_WR(pDevice, Grc.Mode, pDevice->GrcMode);
2394	pDevice->RxPoll = FALSE;
2395	if (pDevice->RxPoll) {
2396	BCM5700_UNLOCK(pUmDevice, flags);
2397	return 0;
2398	}
2399	/* Take care of possible missed rx interrupts */
2400	REG_RD_BACK(pDevice, Grc.Mode); /* flush the register write */
2401	tag = pDevice->pStatusBlkVirt->StatusTag;
2402	if ((pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) \|\|
2403	(pDevice->pStatusBlkVirt->Idx[0].RcvProdIdx !=
2404	pDevice->RcvRetConIdx)) {
2405
2406	REG_WR(pDevice, HostCoalesce.Mode,
2407	pDevice->CoalesceMode \| HOST_COALESCE_ENABLE \|
2408	HOST_COALESCE_NOW);
2409	}
2410	/* If a new status block is pending in the WDMA state machine */
2411	/* before the register write to enable the rx interrupt, */
2412	/* the new status block may DMA with no interrupt. In this */
2413	/* scenario, the tag read above will be older than the tag in */
2414	/* the pending status block and writing the older tag will */
2415	/* cause interrupt to be generated. */
2416	else if (pDevice->Flags & USE_TAGGED_STATUS_FLAG) {
2417	MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low,
2418	tag << 24);
2419	/* Make sure we service tx in case some tx interrupts */
2420	/* are cleared */
2421	if (atomic_read(&pDevice->SendBdLeft) <
2422	(T3_SEND_RCB_ENTRY_COUNT / 2)) {
2423	REG_WR(pDevice, HostCoalesce.Mode,
2424	pDevice->CoalesceMode \|
2425	HOST_COALESCE_ENABLE \|
2426	HOST_COALESCE_NOW);
2427	}
2428	}
2429	BCM5700_UNLOCK(pUmDevice, flags);
2430	return 0;
2431	}
2432	return 1;
2433	}
2434	#endif /* BCM_NAPI_RXPOLL */
2435
2436	STATIC irqreturn_t
2437	bcm5700_interrupt(int irq, void dev_instance, struct pt_regs regs)
2438	{
2439	struct net_device dev = (struct net_device )dev_instance;
2440	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
2441	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
2442	LM_UINT32 oldtag, newtag;
2443	int i, max_intr_loop;
2444	#ifdef BCM_TASKLET
2445	int repl_buf_count;
2446	#endif
2447	unsigned int handled = 1;
2448
2449	if (!pDevice->InitDone) {
2450	handled = 0;
2451	return IRQ_RETVAL(handled);
2452	}
2453
2454	bcm5700_intr_lock(pUmDevice);
2455	if (atomic_read(&pUmDevice->intr_sem)) {
2456	MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, 1);
2457	bcm5700_intr_unlock(pUmDevice);
2458	handled = 0;
2459	return IRQ_RETVAL(handled);
2460	}
2461
2462	if (test_and_set_bit(0, (void*)&pUmDevice->interrupt)) {
2463	printk(KERN_ERR "%s: Duplicate entry of the interrupt handler\n",
2464	dev->name);
2465	bcm5700_intr_unlock(pUmDevice);
2466	handled = 0;
2467	return IRQ_RETVAL(handled);
2468	}
2469
2470	/* BCM4785: Flush posted writes from GbE to host memory. */
2471	if (pDevice->Flags & FLUSH_POSTED_WRITE_FLAG)
2472	REG_RD(pDevice, HostCoalesce.Mode);
2473
2474	if ((pDevice->Flags & USING_MSI_FLAG) \|\|
2475	(pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) \|\|
2476	!(REG_RD(pDevice,PciCfg.PciState) & T3_PCI_STATE_INTERRUPT_NOT_ACTIVE) )
2477	{
2478
2479	if (pUmDevice->intr_test) {
2480	if (!(REG_RD(pDevice, PciCfg.PciState) &
2481	T3_PCI_STATE_INTERRUPT_NOT_ACTIVE) \|\|
2482	pDevice->Flags & USING_MSI_FLAG ) {
2483	pUmDevice->intr_test_result = 1;
2484	}
2485	pUmDevice->intr_test = 0;
2486	}
2487
2488	#ifdef BCM_NAPI_RXPOLL
2489	max_intr_loop = 1;
2490	#else
2491	max_intr_loop = 50;
2492	#endif
2493	if (pDevice->Flags & USE_TAGGED_STATUS_FLAG) {
2494	MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, 1);
2495	oldtag = pDevice->pStatusBlkVirt->StatusTag;
2496
2497	for (i = 0; ; i++) {
2498	pDevice->pStatusBlkVirt->Status &= ~STATUS_BLOCK_UPDATED;
2499
2500	LM_ServiceInterrupts(pDevice);
2501	/* BCM4785: Flush GbE posted writes to host memory. */
2502	if (pDevice->Flags & FLUSH_POSTED_WRITE_FLAG)
2503	MB_REG_RD(pDevice, Mailbox.Interrupt[0].Low);
2504	newtag = pDevice->pStatusBlkVirt->StatusTag;
2505	if ((newtag == oldtag) \|\| (i > max_intr_loop)) {
2506	MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, oldtag << 24);
2507	pDevice->LastTag = oldtag;
2508	if (pDevice->Flags & UNDI_FIX_FLAG) {
2509	REG_WR(pDevice, Grc.LocalCtrl,
2510	pDevice->GrcLocalCtrl \| 0x2);
2511	}
2512	break;
2513	}
2514	oldtag = newtag;
2515	}
2516	}
2517	else
2518	{
2519	i = 0;
2520	do {
2521	uint dummy;
2522
2523	MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, 1);
2524	pDevice->pStatusBlkVirt->Status &= ~STATUS_BLOCK_UPDATED;
2525	LM_ServiceInterrupts(pDevice);
2526	MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, 0);
2527	dummy = MB_REG_RD(pDevice, Mailbox.Interrupt[0].Low);
2528	i++;
2529	}
2530	while ((pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) &&
2531	(i < max_intr_loop));
2532
2533	if (pDevice->Flags & UNDI_FIX_FLAG) {
2534	REG_WR(pDevice, Grc.LocalCtrl,
2535	pDevice->GrcLocalCtrl \| 0x2);
2536	}
2537	}
2538	}
2539	else
2540	{
2541	/* not my interrupt */
2542	handled = 0;
2543	}
2544
2545	#ifdef BCM_TASKLET
2546	repl_buf_count = QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container);
2547	if (((repl_buf_count > pUmDevice->rx_buf_repl_panic_thresh) \|\|
2548	pDevice->QueueAgain) &&
2549	(!test_and_set_bit(0, &pUmDevice->tasklet_busy))) {
2550
2551	replenish_rx_buffers(pUmDevice, pUmDevice->rx_buf_repl_isr_limit);
2552	clear_bit(0, (void*)&pUmDevice->tasklet_busy);
2553	}
2554	else if ((repl_buf_count > pUmDevice->rx_buf_repl_thresh) &&
2555	!pUmDevice->tasklet_pending) {
2556
2557	pUmDevice->tasklet_pending = 1;
2558	tasklet_schedule(&pUmDevice->tasklet);
2559	}
2560	#else
2561	#ifdef BCM_NAPI_RXPOLL
2562	if (!pDevice->RxPoll &&
2563	QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container)) {
2564	pDevice->RxPoll = 1;
2565	MM_ScheduleRxPoll(pDevice);
2566	}
2567	#else
2568	if (QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container)) {
2569	replenish_rx_buffers(pUmDevice, 0);
2570	}
2571
2572	if (QQ_GetEntryCnt(&pDevice->RxPacketFreeQ.Container) \|\|
2573	pDevice->QueueAgain) {
2574
2575	LM_QueueRxPackets(pDevice);
2576	}
2577	#endif
2578	#endif
2579
2580	clear_bit(0, (void*)&pUmDevice->interrupt);
2581	bcm5700_intr_unlock(pUmDevice);
2582	if (pUmDevice->tx_queued) {
2583	pUmDevice->tx_queued = 0;
2584	netif_wake_queue(dev);
2585	}
2586	return IRQ_RETVAL(handled);
2587	}
2588
2589
2590	#ifdef BCM_TASKLET
2591	STATIC void
2592	bcm5700_tasklet(unsigned long data)
2593	{
2594	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)data;
2595	unsigned long flags = 0;
2596
2597	/* RH 7.2 Beta 3 tasklets are reentrant */
2598	if (test_and_set_bit(0, &pUmDevice->tasklet_busy)) {
2599	pUmDevice->tasklet_pending = 0;
2600	return;
2601	}
2602
2603	pUmDevice->tasklet_pending = 0;
2604	if (pUmDevice->opened && !pUmDevice->suspended) {
2605	BCM5700_LOCK(pUmDevice, flags);
2606	replenish_rx_buffers(pUmDevice, 0);
2607	BCM5700_UNLOCK(pUmDevice, flags);
2608	}
2609
2610	clear_bit(0, &pUmDevice->tasklet_busy);
2611	}
2612	#endif
2613
2614	STATIC int
2615	bcm5700_close(struct net_device *dev)
2616	{
2617
2618	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
2619	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
2620
2621	#if (LINUX_VERSION_CODE < 0x02032b)
2622	dev->start = 0;
2623	#endif
2624	netif_stop_queue(dev);
2625	pUmDevice->opened = 0;
2626
2627	#ifdef BCM_ASF
2628	if( !(pDevice->AsfFlags & ASF_ENABLED) )
2629	#endif
2630	#ifdef BCM_WOL
2631	if( enable_wol[pUmDevice->index] == 0 )
2632	#endif
2633	B57_INFO(("%s: %s NIC Link is DOWN\n", bcm5700_driver, dev->name));
2634
2635	if (tigon3_debug > 1)
2636	printk(KERN_DEBUG "%s: Shutting down Tigon3\n",
2637	dev->name);
2638
2639	LM_MulticastClear(pDevice);
2640	bcm5700_shutdown(pUmDevice);
2641
2642	if (T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)) {
2643	del_timer_sync(&pUmDevice->statstimer);
2644	}
2645
2646	del_timer_sync(&pUmDevice->timer);
2647
2648	free_irq(pUmDevice->pdev->irq, dev);
2649
2650	#if defined(CONFIG_PCI_MSI) \|\| defined(CONFIG_PCI_USE_VECTOR)
2651
2652	if(pDevice->Flags & USING_MSI_FLAG) {
2653	pci_disable_msi(pUmDevice->pdev);
2654	REG_WR(pDevice, Msi.Mode, 1 );
2655	pDevice->Flags &= ~USING_MSI_FLAG;
2656	}
2657
2658	#endif
2659
2660
2661	#if (LINUX_VERSION_CODE < 0x020300)
2662	MOD_DEC_USE_COUNT;
2663	#endif
2664	{
2665	/* BCM4785: Don't go to low-power state because it will power down the smbus block. */
2666	if (!(pDevice->Flags & SB_CORE_FLAG))
2667	LM_SetPowerState(pDevice, LM_POWER_STATE_D3);
2668	}
2669
2670	bcm5700_freemem(dev);
2671
2672	QQ_InitQueue(&pDevice->RxPacketFreeQ.Container,
2673	MAX_RX_PACKET_DESC_COUNT);
2674
2675	return 0;
2676	}
2677
2678	STATIC int
2679	bcm5700_freemem(struct net_device *dev)
2680	{
2681	int i;
2682	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
2683	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2684
2685	for (i = 0; i < pUmDevice->mem_list_num; i++) {
2686	if (pUmDevice->mem_size_list[i] == 0) {
2687	kfree(pUmDevice->mem_list[i]);
2688	}
2689	else {
2690	pci_free_consistent(pUmDevice->pdev,
2691	(size_t) pUmDevice->mem_size_list[i],
2692	pUmDevice->mem_list[i],
2693	pUmDevice->dma_list[i]);
2694	}
2695	}
2696
2697	pDevice->pStatusBlkVirt = 0;
2698	pDevice->pStatsBlkVirt = 0;
2699	pUmDevice->mem_list_num = 0;
2700
2701	return 0;
2702	}
2703
2704	uint64_t
2705	bcm5700_crc_count(PUM_DEVICE_BLOCK pUmDevice)
2706	{
2707	PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
2708	LM_UINT32 Value32;
2709	PT3_STATS_BLOCK pStats = (PT3_STATS_BLOCK) pDevice->pStatsBlkVirt;
2710	unsigned long flags;
2711
2712	if ((T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5700 \|\|
2713	T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5701) &&
2714	!(pDevice->TbiFlags & ENABLE_TBI_FLAG)) {
2715
2716	if (!pUmDevice->opened \|\| !pDevice->InitDone)
2717	{
2718
2719	return 0;
2720	}
2721
2722	/* regulate MDIO access during run time */
2723	if (pUmDevice->crc_counter_expiry > 0)
2724	return pUmDevice->phy_crc_count;
2725
2726	pUmDevice->crc_counter_expiry = (5 * HZ) /
2727	pUmDevice->timer_interval;
2728
2729	BCM5700_PHY_LOCK(pUmDevice, flags);
2730	LM_ReadPhy(pDevice, 0x1e, &Value32);
2731	if ((Value32 & 0x8000) == 0)
2732	LM_WritePhy(pDevice, 0x1e, Value32 \| 0x8000);
2733	LM_ReadPhy(pDevice, 0x14, &Value32);
2734	BCM5700_PHY_UNLOCK(pUmDevice, flags);
2735	/* Sometimes data on the MDIO bus can be corrupted */
2736	if (Value32 != 0xffff)
2737	pUmDevice->phy_crc_count += Value32;
2738	return pUmDevice->phy_crc_count;
2739	}
2740	else if (pStats == 0) {
2741	return 0;
2742	}
2743	else {
2744	return (MM_GETSTATS64(pStats->dot3StatsFCSErrors));
2745	}
2746	}
2747
2748	uint64_t
2749	bcm5700_rx_err_count(UM_DEVICE_BLOCK *pUmDevice)
2750	{
2751	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2752	T3_STATS_BLOCK pStats = (T3_STATS_BLOCK ) pDevice->pStatsBlkVirt;
2753
2754	if (pStats == 0)
2755	return 0;
2756	return (bcm5700_crc_count(pUmDevice) +
2757	MM_GETSTATS64(pStats->dot3StatsAlignmentErrors) +
2758	MM_GETSTATS64(pStats->etherStatsUndersizePkts) +
2759	MM_GETSTATS64(pStats->etherStatsFragments) +
2760	MM_GETSTATS64(pStats->dot3StatsFramesTooLong) +
2761	MM_GETSTATS64(pStats->etherStatsJabbers));
2762	}
2763
2764	STATIC struct net_device_stats *
2765	bcm5700_get_stats(struct net_device *dev)
2766	{
2767	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
2768	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
2769	PT3_STATS_BLOCK pStats = (PT3_STATS_BLOCK) pDevice->pStatsBlkVirt;
2770	struct net_device_stats *p_netstats = &pUmDevice->stats;
2771
2772	if (pStats == 0)
2773	return p_netstats;
2774
2775	/* Get stats from LM */
2776	p_netstats->rx_packets =
2777	MM_GETSTATS(pStats->ifHCInUcastPkts) +
2778	MM_GETSTATS(pStats->ifHCInMulticastPkts) +
2779	MM_GETSTATS(pStats->ifHCInBroadcastPkts);
2780	p_netstats->tx_packets =
2781	MM_GETSTATS(pStats->ifHCOutUcastPkts) +
2782	MM_GETSTATS(pStats->ifHCOutMulticastPkts) +
2783	MM_GETSTATS(pStats->ifHCOutBroadcastPkts);
2784	/* There counters seem to be innacurate. Use byte number accumulation
2785	instead.
2786	p_netstats->rx_bytes = MM_GETSTATS(pStats->ifHCInOctets);
2787	p_netstats->tx_bytes = MM_GETSTATS(pStats->ifHCOutOctets);
2788	*/
2789	p_netstats->tx_errors =
2790	MM_GETSTATS(pStats->dot3StatsInternalMacTransmitErrors) +
2791	MM_GETSTATS(pStats->dot3StatsCarrierSenseErrors) +
2792	MM_GETSTATS(pStats->ifOutDiscards) +
2793	MM_GETSTATS(pStats->ifOutErrors);
2794	p_netstats->multicast = MM_GETSTATS(pStats->ifHCInMulticastPkts);
2795	p_netstats->collisions = MM_GETSTATS(pStats->etherStatsCollisions);
2796	p_netstats->rx_length_errors =
2797	MM_GETSTATS(pStats->dot3StatsFramesTooLong) +
2798	MM_GETSTATS(pStats->etherStatsUndersizePkts);
2799	p_netstats->rx_over_errors = MM_GETSTATS(pStats->nicNoMoreRxBDs);
2800	p_netstats->rx_frame_errors =
2801	MM_GETSTATS(pStats->dot3StatsAlignmentErrors);
2802	p_netstats->rx_crc_errors = (unsigned long)
2803	bcm5700_crc_count(pUmDevice);
2804	p_netstats->rx_errors = (unsigned long)
2805	bcm5700_rx_err_count(pUmDevice);
2806
2807	p_netstats->tx_aborted_errors = MM_GETSTATS(pStats->ifOutDiscards);
2808	p_netstats->tx_carrier_errors =
2809	MM_GETSTATS(pStats->dot3StatsCarrierSenseErrors);
2810
2811	return p_netstats;
2812	}
2813
2814	void
2815	b57_suspend_chip(UM_DEVICE_BLOCK *pUmDevice)
2816	{
2817	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2818
2819	if (pUmDevice->opened) {
2820	bcm5700_intr_off(pUmDevice);
2821	netif_carrier_off(pUmDevice->dev);
2822	netif_stop_queue(pUmDevice->dev);
2823	#ifdef BCM_TASKLET
2824	tasklet_kill(&pUmDevice->tasklet);
2825	#endif
2826	bcm5700_poll_wait(pUmDevice);
2827	}
2828	pUmDevice->suspended = 1;
2829	LM_ShutdownChip(pDevice, LM_SUSPEND_RESET);
2830	}
2831
2832	void
2833	b57_resume_chip(UM_DEVICE_BLOCK *pUmDevice)
2834	{
2835	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2836
2837	if (pUmDevice->suspended) {
2838	pUmDevice->suspended = 0;
2839	if (pUmDevice->opened) {
2840	bcm5700_reset(pUmDevice->dev);
2841	}
2842	else {
2843	LM_ShutdownChip(pDevice, LM_SHUTDOWN_RESET);
2844	}
2845	}
2846	}
2847
2848	/* Returns 0 on failure, 1 on success */
2849	int
2850	b57_test_intr(UM_DEVICE_BLOCK *pUmDevice)
2851	{
2852	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2853	int j;
2854
2855	if (!pUmDevice->opened)
2856	return 0;
2857	pUmDevice->intr_test_result = 0;
2858	pUmDevice->intr_test = 1;
2859
2860	REG_WR(pDevice, HostCoalesce.Mode,
2861	pDevice->CoalesceMode \| HOST_COALESCE_ENABLE \|
2862	HOST_COALESCE_NOW);
2863
2864	for (j = 0; j < 10; j++) {
2865	if (pUmDevice->intr_test_result){
2866	break;
2867	}
2868
2869	REG_WR(pDevice, HostCoalesce.Mode,
2870	pDevice->CoalesceMode \| HOST_COALESCE_ENABLE \|
2871	HOST_COALESCE_NOW);
2872
2873	MM_Sleep(pDevice, 1);
2874	}
2875
2876	return pUmDevice->intr_test_result;
2877
2878	}
2879
2880	#ifdef SIOCETHTOOL
2881
2882	#ifdef ETHTOOL_GSTRINGS
2883
2884	#define ETH_NUM_STATS 30
2885	#define RX_CRC_IDX 5
2886	#define RX_MAC_ERR_IDX 14
2887
2888	struct {
2889	char string[ETH_GSTRING_LEN];
2890	} bcm5700_stats_str_arr[ETH_NUM_STATS] = {
2891	{ "rx_unicast_packets" },
2892	{ "rx_multicast_packets" },
2893	{ "rx_broadcast_packets" },
2894	{ "rx_bytes" },
2895	{ "rx_fragments" },
2896	{ "rx_crc_errors" }, /* this needs to be calculated */
2897	{ "rx_align_errors" },
2898	{ "rx_xon_frames" },
2899	{ "rx_xoff_frames" },
2900	{ "rx_long_frames" },
2901	{ "rx_short_frames" },
2902	{ "rx_jabber" },
2903	{ "rx_discards" },
2904	{ "rx_errors" },
2905	{ "rx_mac_errors" }, /* this needs to be calculated */
2906	{ "tx_unicast_packets" },
2907	{ "tx_multicast_packets" },
2908	{ "tx_broadcast_packets" },
2909	{ "tx_bytes" },
2910	{ "tx_deferred" },
2911	{ "tx_single_collisions" },
2912	{ "tx_multi_collisions" },
2913	{ "tx_total_collisions" },
2914	{ "tx_excess_collisions" },
2915	{ "tx_late_collisions" },
2916	{ "tx_xon_frames" },
2917	{ "tx_xoff_frames" },
2918	{ "tx_internal_mac_errors" },
2919	{ "tx_carrier_errors" },
2920	{ "tx_errors" },
2921	};
2922
2923	#define STATS_OFFSET(offset_name) ((OFFSETOF(T3_STATS_BLOCK, offset_name)) / sizeof(uint64_t))
2924
2925	#ifdef __BIG_ENDIAN
2926	#define SWAP_DWORD_64(x) (x)
2927	#else
2928	#define SWAP_DWORD_64(x) ((x << 32) \| (x >> 32))
2929	#endif
2930
2931	unsigned long bcm5700_stats_offset_arr[ETH_NUM_STATS] = {
2932	STATS_OFFSET(ifHCInUcastPkts),
2933	STATS_OFFSET(ifHCInMulticastPkts),
2934	STATS_OFFSET(ifHCInBroadcastPkts),
2935	STATS_OFFSET(ifHCInOctets),
2936	STATS_OFFSET(etherStatsFragments),
2937	0,
2938	STATS_OFFSET(dot3StatsAlignmentErrors),
2939	STATS_OFFSET(xonPauseFramesReceived),
2940	STATS_OFFSET(xoffPauseFramesReceived),
2941	STATS_OFFSET(dot3StatsFramesTooLong),
2942	STATS_OFFSET(etherStatsUndersizePkts),
2943	STATS_OFFSET(etherStatsJabbers),
2944	STATS_OFFSET(ifInDiscards),
2945	STATS_OFFSET(ifInErrors),
2946	0,
2947	STATS_OFFSET(ifHCOutUcastPkts),
2948	STATS_OFFSET(ifHCOutMulticastPkts),
2949	STATS_OFFSET(ifHCOutBroadcastPkts),
2950	STATS_OFFSET(ifHCOutOctets),
2951	STATS_OFFSET(dot3StatsDeferredTransmissions),
2952	STATS_OFFSET(dot3StatsSingleCollisionFrames),
2953	STATS_OFFSET(dot3StatsMultipleCollisionFrames),
2954	STATS_OFFSET(etherStatsCollisions),
2955	STATS_OFFSET(dot3StatsExcessiveCollisions),
2956	STATS_OFFSET(dot3StatsLateCollisions),
2957	STATS_OFFSET(outXonSent),
2958	STATS_OFFSET(outXoffSent),
2959	STATS_OFFSET(dot3StatsInternalMacTransmitErrors),
2960	STATS_OFFSET(dot3StatsCarrierSenseErrors),
2961	STATS_OFFSET(ifOutErrors),
2962	};
2963
2964	#endif /* ETHTOOL_GSTRINGS */
2965
2966
2967	#ifdef ETHTOOL_GREGS
2968	#if (LINUX_VERSION_CODE >= 0x02040f)
2969	static void
2970	bcm5700_get_reg_blk(UM_DEVICE_BLOCK pUmDevice, u32 *buf, u32 start, u32 end,
2971	int reserved)
2972	{
2973	u32 offset;
2974	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
2975
2976	if (reserved) {
2977	memset(*buf, 0, end - start);
2978	buf = buf + (end - start)/4;
2979	return;
2980	}
2981	for (offset = start; offset < end; offset+=4, buf = buf + 1) {
2982	if (T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)){
2983	if (((offset >= 0x3400) && (offset < 0x3c00)) \|\|
2984	((offset >= 0x5400) && (offset < 0x5800)) \|\|
2985	((offset >= 0x6400) && (offset < 0x6800))) {
2986	**buf = 0;
2987	continue;
2988	}
2989	}
2990	**buf = REG_RD_OFFSET(pDevice, offset);
2991	}
2992	}
2993	#endif
2994	#endif
2995
2996	static int netdev_ethtool_ioctl(struct net_device dev, void useraddr)
2997	{
2998	struct ethtool_cmd ethcmd;
2999	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
3000	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
3001
3002	if (mm_copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
3003	return -EFAULT;
3004
3005	switch (ethcmd.cmd) {
3006	#ifdef ETHTOOL_GDRVINFO
3007	case ETHTOOL_GDRVINFO: {
3008	struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
3009
3010	strcpy(info.driver, bcm5700_driver);
3011	#ifdef INCLUDE_5701_AX_FIX
3012	if(pDevice->ChipRevId == T3_CHIP_ID_5701_A0) {
3013	extern int t3FwReleaseMajor;
3014	extern int t3FwReleaseMinor;
3015	extern int t3FwReleaseFix;
3016
3017	sprintf(info.fw_version, "%i.%i.%i",
3018	t3FwReleaseMajor, t3FwReleaseMinor,
3019	t3FwReleaseFix);
3020	}
3021	#endif
3022	strcpy(info.fw_version, pDevice->BootCodeVer);
3023	strcpy(info.version, bcm5700_version);
3024	#if (LINUX_VERSION_CODE <= 0x020422)
3025	strcpy(info.bus_info, pUmDevice->pdev->slot_name);
3026	#else
3027	strcpy(info.bus_info, pci_name(pUmDevice->pdev));
3028	#endif
3029
3030
3031
3032	#ifdef ETHTOOL_GEEPROM
3033	BCM_EEDUMP_LEN(&info, pDevice->NvramSize);
3034	#endif
3035	#ifdef ETHTOOL_GREGS
3036	/* dump everything, including holes in the register space */
3037	info.regdump_len = 0x6c00;
3038	#endif
3039	#ifdef ETHTOOL_GSTATS
3040	info.n_stats = ETH_NUM_STATS;
3041	#endif
3042	if (mm_copy_to_user(useraddr, &info, sizeof(info)))
3043	return -EFAULT;
3044	return 0;
3045	}
3046	#endif
3047	case ETHTOOL_GSET: {
3048	if ((pDevice->TbiFlags & ENABLE_TBI_FLAG)\|\|
3049	(pDevice->PhyFlags & PHY_IS_FIBER)) {
3050	ethcmd.supported =
3051	(SUPPORTED_1000baseT_Full \|
3052	SUPPORTED_Autoneg);
3053	ethcmd.supported \|= SUPPORTED_FIBRE;
3054	ethcmd.port = PORT_FIBRE;
3055	} else {
3056	ethcmd.supported =
3057	(SUPPORTED_10baseT_Half \|
3058	SUPPORTED_10baseT_Full \|
3059	SUPPORTED_100baseT_Half \|
3060	SUPPORTED_100baseT_Full \|
3061	SUPPORTED_1000baseT_Half \|
3062	SUPPORTED_1000baseT_Full \|
3063	SUPPORTED_Autoneg);
3064	ethcmd.supported \|= SUPPORTED_TP;
3065	ethcmd.port = PORT_TP;
3066	}
3067
3068	ethcmd.transceiver = XCVR_INTERNAL;
3069	ethcmd.phy_address = 0;
3070
3071	if (pDevice->LineSpeed == LM_LINE_SPEED_1000MBPS)
3072	ethcmd.speed = SPEED_1000;
3073	else if (pDevice->LineSpeed == LM_LINE_SPEED_100MBPS)
3074	ethcmd.speed = SPEED_100;
3075	else if (pDevice->LineSpeed == LM_LINE_SPEED_10MBPS)
3076	ethcmd.speed = SPEED_10;
3077	else
3078	ethcmd.speed = 0;
3079
3080	if (pDevice->DuplexMode == LM_DUPLEX_MODE_FULL)
3081	ethcmd.duplex = DUPLEX_FULL;
3082	else
3083	ethcmd.duplex = DUPLEX_HALF;
3084
3085	if (pDevice->DisableAutoNeg == FALSE) {
3086	ethcmd.autoneg = AUTONEG_ENABLE;
3087	ethcmd.advertising = ADVERTISED_Autoneg;
3088	if ((pDevice->TbiFlags & ENABLE_TBI_FLAG) \|\|
3089	(pDevice->PhyFlags & PHY_IS_FIBER)) {
3090	ethcmd.advertising \|=
3091	ADVERTISED_1000baseT_Full \|
3092	ADVERTISED_FIBRE;
3093	}
3094	else {
3095	ethcmd.advertising \|=
3096	ADVERTISED_TP;
3097	if (pDevice->advertising &
3098	PHY_AN_AD_10BASET_HALF) {
3099
3100	ethcmd.advertising \|=
3101	ADVERTISED_10baseT_Half;
3102	}
3103	if (pDevice->advertising &
3104	PHY_AN_AD_10BASET_FULL) {
3105
3106	ethcmd.advertising \|=
3107	ADVERTISED_10baseT_Full;
3108	}
3109	if (pDevice->advertising &
3110	PHY_AN_AD_100BASETX_HALF) {
3111
3112	ethcmd.advertising \|=
3113	ADVERTISED_100baseT_Half;
3114	}
3115	if (pDevice->advertising &
3116	PHY_AN_AD_100BASETX_FULL) {
3117
3118	ethcmd.advertising \|=
3119	ADVERTISED_100baseT_Full;
3120	}
3121	if (pDevice->advertising1000 &
3122	BCM540X_AN_AD_1000BASET_HALF) {
3123
3124	ethcmd.advertising \|=
3125	ADVERTISED_1000baseT_Half;
3126	}
3127	if (pDevice->advertising1000 &
3128	BCM540X_AN_AD_1000BASET_FULL) {
3129
3130	ethcmd.advertising \|=
3131	ADVERTISED_1000baseT_Full;
3132	}
3133	}
3134	}
3135	else {
3136	ethcmd.autoneg = AUTONEG_DISABLE;
3137	ethcmd.advertising = 0;
3138	}
3139
3140	ethcmd.maxtxpkt = pDevice->TxMaxCoalescedFrames;
3141	ethcmd.maxrxpkt = pDevice->RxMaxCoalescedFrames;
3142
3143	if(mm_copy_to_user(useraddr, &ethcmd, sizeof(ethcmd)))
3144	return -EFAULT;
3145	return 0;
3146	}
3147	case ETHTOOL_SSET: {
3148	unsigned long flags;
3149
3150	if(!capable(CAP_NET_ADMIN))
3151	return -EPERM;
3152	if (ethcmd.autoneg == AUTONEG_ENABLE) {
3153	pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
3154	pDevice->RequestedDuplexMode = LM_DUPLEX_MODE_UNKNOWN;
3155	pDevice->DisableAutoNeg = FALSE;
3156	}
3157	else {
3158	if (ethcmd.speed == SPEED_1000 &&
3159	pDevice->PhyFlags & PHY_NO_GIGABIT)
3160	return -EINVAL;
3161
3162	if (ethcmd.speed == SPEED_1000 &&
3163	(pDevice->TbiFlags & ENABLE_TBI_FLAG \|\|
3164	pDevice->PhyFlags & PHY_IS_FIBER ) ) {
3165
3166	pDevice->RequestedLineSpeed =
3167	LM_LINE_SPEED_1000MBPS;
3168
3169	pDevice->RequestedDuplexMode =
3170	LM_DUPLEX_MODE_FULL;
3171	}
3172	else if (ethcmd.speed == SPEED_100 &&
3173	!(pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
3174	!(pDevice->PhyFlags & PHY_IS_FIBER)) {
3175
3176	pDevice->RequestedLineSpeed =
3177	LM_LINE_SPEED_100MBPS;
3178	}
3179	else if (ethcmd.speed == SPEED_10 &&
3180	!(pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
3181	!(pDevice->PhyFlags & PHY_IS_FIBER)) {
3182
3183	pDevice->RequestedLineSpeed =
3184	LM_LINE_SPEED_10MBPS;
3185	}
3186	else {
3187	return -EINVAL;
3188	}
3189
3190	pDevice->DisableAutoNeg = TRUE;
3191	if (ethcmd.duplex == DUPLEX_FULL) {
3192	pDevice->RequestedDuplexMode =
3193	LM_DUPLEX_MODE_FULL;
3194	}
3195	else {
3196	if (!(pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
3197	!(pDevice->PhyFlags & PHY_IS_FIBER) ) {
3198
3199	pDevice->RequestedDuplexMode =
3200	LM_DUPLEX_MODE_HALF;
3201	}
3202	}
3203	}
3204	if (netif_running(dev)) {
3205	BCM5700_PHY_LOCK(pUmDevice, flags);
3206	LM_SetupPhy(pDevice);
3207	BCM5700_PHY_UNLOCK(pUmDevice, flags);
3208	}
3209	return 0;
3210	}
3211	#ifdef ETHTOOL_GWOL
3212	#ifdef BCM_WOL
3213	case ETHTOOL_GWOL: {
3214	struct ethtool_wolinfo wol = {ETHTOOL_GWOL};
3215
3216	if (((pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
3217	!(pDevice->Flags & FIBER_WOL_CAPABLE_FLAG)) \|\|
3218	(pDevice->Flags & DISABLE_D3HOT_FLAG)) {
3219	wol.supported = 0;
3220	wol.wolopts = 0;
3221	}
3222	else {
3223	wol.supported = WAKE_MAGIC;
3224	if (pDevice->WakeUpMode == LM_WAKE_UP_MODE_MAGIC_PACKET)
3225	{
3226	wol.wolopts = WAKE_MAGIC;
3227	}
3228	else {
3229	wol.wolopts = 0;
3230	}
3231	}
3232	if (mm_copy_to_user(useraddr, &wol, sizeof(wol)))
3233	return -EFAULT;
3234	return 0;
3235	}
3236	case ETHTOOL_SWOL: {
3237	struct ethtool_wolinfo wol;
3238
3239	if(!capable(CAP_NET_ADMIN))
3240	return -EPERM;
3241	if (mm_copy_from_user(&wol, useraddr, sizeof(wol)))
3242	return -EFAULT;
3243	if ((((pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
3244	!(pDevice->Flags & FIBER_WOL_CAPABLE_FLAG)) \|\|
3245	(pDevice->Flags & DISABLE_D3HOT_FLAG)) &&
3246	wol.wolopts) {
3247	return -EINVAL;
3248	}
3249
3250	if ((wol.wolopts & ~WAKE_MAGIC) != 0) {
3251	return -EINVAL;
3252	}
3253	if (wol.wolopts & WAKE_MAGIC) {
3254	pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_MAGIC_PACKET;
3255	pDevice->WakeUpMode = LM_WAKE_UP_MODE_MAGIC_PACKET;
3256	}
3257	else {
3258	pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_NONE;
3259	pDevice->WakeUpMode = LM_WAKE_UP_MODE_NONE;
3260	}
3261	return 0;
3262	}
3263	#endif
3264	#endif
3265	#ifdef ETHTOOL_GLINK
3266	case ETHTOOL_GLINK: {
3267	struct ethtool_value edata = {ETHTOOL_GLINK};
3268
3269	/* ifup only waits for 5 seconds for link up */
3270	/* NIC may take more than 5 seconds to establish link */
3271	if ((pUmDevice->delayed_link_ind > 0) &&
3272	delay_link[pUmDevice->index])
3273	return -EOPNOTSUPP;
3274
3275	if (pDevice->LinkStatus == LM_STATUS_LINK_ACTIVE) {
3276	edata.data = 1;
3277	}
3278	else {
3279	edata.data = 0;
3280	}
3281	if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
3282	return -EFAULT;
3283	return 0;
3284	}
3285	#endif
3286	#ifdef ETHTOOL_NWAY_RST
3287	case ETHTOOL_NWAY_RST: {
3288	LM_UINT32 phyctrl;
3289	unsigned long flags;
3290
3291	if(!capable(CAP_NET_ADMIN))
3292	return -EPERM;
3293	if (pDevice->DisableAutoNeg) {
3294	return -EINVAL;
3295	}
3296	if (!netif_running(dev))
3297	return -EAGAIN;
3298	BCM5700_PHY_LOCK(pUmDevice, flags);
3299	if (pDevice->TbiFlags & ENABLE_TBI_FLAG) {
3300	pDevice->RequestedLineSpeed = LM_LINE_SPEED_1000MBPS;
3301	pDevice->DisableAutoNeg = TRUE;
3302	LM_SetupPhy(pDevice);
3303
3304	pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
3305	pDevice->DisableAutoNeg = FALSE;
3306	LM_SetupPhy(pDevice);
3307	}
3308	else {
3309	if ((T3_ASIC_REV(pDevice->ChipRevId) ==
3310	T3_ASIC_REV_5703) \|\|
3311	(T3_ASIC_REV(pDevice->ChipRevId) ==
3312	T3_ASIC_REV_5704) \|\|
3313	(T3_ASIC_REV(pDevice->ChipRevId) ==
3314	T3_ASIC_REV_5705))
3315	{
3316	LM_ResetPhy(pDevice);
3317	LM_SetupPhy(pDevice);
3318	}
3319	pDevice->PhyFlags &= ~PHY_FIBER_FALLBACK;
3320	LM_ReadPhy(pDevice, PHY_CTRL_REG, &phyctrl);
3321	LM_WritePhy(pDevice, PHY_CTRL_REG, phyctrl \|
3322	PHY_CTRL_AUTO_NEG_ENABLE \|
3323	PHY_CTRL_RESTART_AUTO_NEG);
3324	}
3325	BCM5700_PHY_UNLOCK(pUmDevice, flags);
3326	return 0;
3327	}
3328	#endif
3329	#ifdef ETHTOOL_GEEPROM
3330	case ETHTOOL_GEEPROM: {
3331	struct ethtool_eeprom eeprom;
3332	LM_UINT32 *buf = 0;
3333	LM_UINT32 buf1[64/4];
3334	int i, j, offset, len;
3335
3336	if (mm_copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
3337	return -EFAULT;
3338
3339	if (eeprom.offset >= pDevice->NvramSize)
3340	return -EFAULT;
3341
3342	/* maximum data limited */
3343	/* to read more, call again with a different offset */
3344	if (eeprom.len > 0x800) {
3345	eeprom.len = 0x800;
3346	if (mm_copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
3347	return -EFAULT;
3348	}
3349
3350	if (eeprom.len > 64) {
3351	buf = kmalloc(eeprom.len, GFP_KERNEL);
3352	if (!buf)
3353	return -ENOMEM;
3354	}
3355	else {
3356	buf = buf1;
3357	}
3358	useraddr += offsetof(struct ethtool_eeprom, data);
3359
3360	offset = eeprom.offset;
3361	len = eeprom.len;
3362	if (offset & 3) {
3363	offset &= 0xfffffffc;
3364	len += (offset & 3);
3365	}
3366	len = (len + 3) & 0xfffffffc;
3367	for (i = 0, j = 0; j < len; i++, j += 4) {
3368	if (LM_NvramRead(pDevice, offset + j, buf + i) !=
3369	LM_STATUS_SUCCESS) {
3370	break;
3371	}
3372	}
3373	if (j >= len) {
3374	buf += (eeprom.offset & 3);
3375	i = mm_copy_to_user(useraddr, buf, eeprom.len);
3376	}
3377	if (eeprom.len > 64) {
3378	kfree(buf);
3379	}
3380	if ((j < len) \|\| i)
3381	return -EFAULT;
3382	return 0;
3383	}
3384	case ETHTOOL_SEEPROM: {
3385	struct ethtool_eeprom eeprom;
3386	LM_UINT32 buf[64/4];
3387	int i, offset, len;
3388
3389	if(!capable(CAP_NET_ADMIN))
3390	return -EPERM;
3391	if (mm_copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
3392	return -EFAULT;
3393
3394	if ((eeprom.offset & 3) \|\| (eeprom.len & 3) \|\|
3395	(eeprom.offset >= pDevice->NvramSize)) {
3396	return -EFAULT;
3397	}
3398
3399	if ((eeprom.offset + eeprom.len) >= pDevice->NvramSize) {
3400	eeprom.len = pDevice->NvramSize - eeprom.offset;
3401	}
3402
3403	useraddr += offsetof(struct ethtool_eeprom, data);
3404
3405	len = eeprom.len;
3406	offset = eeprom.offset;
3407	for (; len > 0; ) {
3408	if (len < 64)
3409	i = len;
3410	else
3411	i = 64;
3412	if (mm_copy_from_user(&buf, useraddr, i))
3413	return -EFAULT;
3414
3415	bcm5700_intr_off(pUmDevice);
3416	/* Prevent race condition on Grc.Mode register */
3417	bcm5700_poll_wait(pUmDevice);
3418
3419	if (LM_NvramWriteBlock(pDevice, offset, buf, i/4) !=
3420	LM_STATUS_SUCCESS) {
3421	bcm5700_intr_on(pUmDevice);
3422	return -EFAULT;
3423	}
3424	bcm5700_intr_on(pUmDevice);
3425	len -= i;
3426	offset += i;
3427	useraddr += i;
3428	}
3429	return 0;
3430	}
3431	#endif
3432	#ifdef ETHTOOL_GREGS
3433	#if (LINUX_VERSION_CODE >= 0x02040f)
3434	case ETHTOOL_GREGS: {
3435	struct ethtool_regs eregs;
3436	LM_UINT32 buf, buf1;
3437	unsigned int i;
3438
3439	if(!capable(CAP_NET_ADMIN))
3440	return -EPERM;
3441	if (pDevice->Flags & UNDI_FIX_FLAG)
3442	return -EOPNOTSUPP;
3443	if (mm_copy_from_user(&eregs, useraddr, sizeof(eregs)))
3444	return -EFAULT;
3445	if (eregs.len > 0x6c00)
3446	eregs.len = 0x6c00;
3447	eregs.version = 0x0;
3448	if (mm_copy_to_user(useraddr, &eregs, sizeof(eregs)))
3449	return -EFAULT;
3450	buf = buf1 = kmalloc(eregs.len, GFP_KERNEL);
3451	if (!buf)
3452	return -ENOMEM;
3453	bcm5700_get_reg_blk(pUmDevice, &buf, 0, 0xb0, 0);
3454	bcm5700_get_reg_blk(pUmDevice, &buf, 0xb0, 0x200, 1);
3455	bcm5700_get_reg_blk(pUmDevice, &buf, 0x200, 0x8f0, 0);
3456	bcm5700_get_reg_blk(pUmDevice, &buf, 0x8f0, 0xc00, 1);
3457	bcm5700_get_reg_blk(pUmDevice, &buf, 0xc00, 0xce0, 0);
3458	bcm5700_get_reg_blk(pUmDevice, &buf, 0xce0, 0x1000, 1);
3459	bcm5700_get_reg_blk(pUmDevice, &buf, 0x1000, 0x1004, 0);
3460	bcm5700_get_reg_blk(pUmDevice, &buf, 0x1004, 0x1400, 1);
3461	bcm5700_get_reg_blk(pUmDevice, &buf, 0x1400, 0x1480, 0);
3462	bcm5700_get_reg_blk(pUmDevice, &buf, 0x1480, 0x1800, 1);
3463	bcm5700_get_reg_blk(pUmDevice, &buf, 0x1800, 0x1848, 0);
3464	bcm5700_get_reg_blk(pUmDevice, &buf, 0x1848, 0x1c00, 1);
3465	bcm5700_get_reg_blk(pUmDevice, &buf, 0x1c00, 0x1c04, 0);
3466	bcm5700_get_reg_blk(pUmDevice, &buf, 0x1c04, 0x2000, 1);
3467	bcm5700_get_reg_blk(pUmDevice, &buf, 0x2000, 0x225c, 0);
3468	bcm5700_get_reg_blk(pUmDevice, &buf, 0x225c, 0x2400, 1);
3469	bcm5700_get_reg_blk(pUmDevice, &buf, 0x2400, 0x24c4, 0);
3470	bcm5700_get_reg_blk(pUmDevice, &buf, 0x24c4, 0x2800, 1);
3471	bcm5700_get_reg_blk(pUmDevice, &buf, 0x2800, 0x2804, 0);
3472	bcm5700_get_reg_blk(pUmDevice, &buf, 0x2804, 0x2c00, 1);
3473	bcm5700_get_reg_blk(pUmDevice, &buf, 0x2c00, 0x2c20, 0);
3474	bcm5700_get_reg_blk(pUmDevice, &buf, 0x2c20, 0x3000, 1);
3475	bcm5700_get_reg_blk(pUmDevice, &buf, 0x3000, 0x3014, 0);
3476	bcm5700_get_reg_blk(pUmDevice, &buf, 0x3014, 0x3400, 1);
3477	bcm5700_get_reg_blk(pUmDevice, &buf, 0x3400, 0x3408, 0);
3478	bcm5700_get_reg_blk(pUmDevice, &buf, 0x3408, 0x3800, 1);
3479	bcm5700_get_reg_blk(pUmDevice, &buf, 0x3800, 0x3808, 0);
3480	bcm5700_get_reg_blk(pUmDevice, &buf, 0x3808, 0x3c00, 1);
3481	bcm5700_get_reg_blk(pUmDevice, &buf, 0x3c00, 0x3d00, 0);
3482	bcm5700_get_reg_blk(pUmDevice, &buf, 0x3d00, 0x4000, 1);
3483	bcm5700_get_reg_blk(pUmDevice, &buf, 0x4000, 0x4010, 0);
3484	bcm5700_get_reg_blk(pUmDevice, &buf, 0x4010, 0x4400, 1);
3485	bcm5700_get_reg_blk(pUmDevice, &buf, 0x4400, 0x4458, 0);
3486	bcm5700_get_reg_blk(pUmDevice, &buf, 0x4458, 0x4800, 1);
3487	bcm5700_get_reg_blk(pUmDevice, &buf, 0x4800, 0x4808, 0);
3488	bcm5700_get_reg_blk(pUmDevice, &buf, 0x4808, 0x4c00, 1);
3489	bcm5700_get_reg_blk(pUmDevice, &buf, 0x4c00, 0x4c08, 0);
3490	bcm5700_get_reg_blk(pUmDevice, &buf, 0x4c08, 0x5000, 1);
3491	bcm5700_get_reg_blk(pUmDevice, &buf, 0x5000, 0x5050, 0);
3492	bcm5700_get_reg_blk(pUmDevice, &buf, 0x5050, 0x5400, 1);
3493	bcm5700_get_reg_blk(pUmDevice, &buf, 0x5400, 0x5450, 0);
3494	bcm5700_get_reg_blk(pUmDevice, &buf, 0x5450, 0x5800, 1);
3495	bcm5700_get_reg_blk(pUmDevice, &buf, 0x5800, 0x5a10, 0);
3496	bcm5700_get_reg_blk(pUmDevice, &buf, 0x5a10, 0x6000, 1);
3497	bcm5700_get_reg_blk(pUmDevice, &buf, 0x6000, 0x600c, 0);
3498	bcm5700_get_reg_blk(pUmDevice, &buf, 0x600c, 0x6400, 1);
3499	bcm5700_get_reg_blk(pUmDevice, &buf, 0x6400, 0x6404, 0);
3500	bcm5700_get_reg_blk(pUmDevice, &buf, 0x6404, 0x6800, 1);
3501	bcm5700_get_reg_blk(pUmDevice, &buf, 0x6800, 0x6848, 0);
3502	bcm5700_get_reg_blk(pUmDevice, &buf, 0x6848, 0x6c00, 1);
3503
3504	i = mm_copy_to_user(useraddr + sizeof(eregs), buf1, eregs.len);
3505	kfree(buf1);
3506	if (i)
3507	return -EFAULT;
3508	return 0;
3509	}
3510	#endif
3511	#endif
3512	#ifdef ETHTOOL_GPAUSEPARAM
3513	case ETHTOOL_GPAUSEPARAM: {
3514	struct ethtool_pauseparam epause = { ETHTOOL_GPAUSEPARAM };
3515
3516	if (!pDevice->DisableAutoNeg) {
3517	epause.autoneg = (pDevice->FlowControlCap &
3518	LM_FLOW_CONTROL_AUTO_PAUSE) != 0;
3519	}
3520	else {
3521	epause.autoneg = 0;
3522	}
3523	epause.rx_pause =
3524	(pDevice->FlowControl &
3525	LM_FLOW_CONTROL_RECEIVE_PAUSE) != 0;
3526	epause.tx_pause =
3527	(pDevice->FlowControl &
3528	LM_FLOW_CONTROL_TRANSMIT_PAUSE) != 0;
3529	if (mm_copy_to_user(useraddr, &epause, sizeof(epause)))
3530	return -EFAULT;
3531
3532	return 0;
3533	}
3534	case ETHTOOL_SPAUSEPARAM: {
3535	struct ethtool_pauseparam epause;
3536	unsigned long flags;
3537
3538	if(!capable(CAP_NET_ADMIN))
3539	return -EPERM;
3540	if (mm_copy_from_user(&epause, useraddr, sizeof(epause)))
3541	return -EFAULT;
3542	pDevice->FlowControlCap = 0;
3543	if (epause.autoneg && !pDevice->DisableAutoNeg) {
3544	pDevice->FlowControlCap \|= LM_FLOW_CONTROL_AUTO_PAUSE;
3545	}
3546	if (epause.rx_pause) {
3547	pDevice->FlowControlCap \|=
3548	LM_FLOW_CONTROL_RECEIVE_PAUSE;
3549	}
3550	if (epause.tx_pause) {
3551	pDevice->FlowControlCap \|=
3552	LM_FLOW_CONTROL_TRANSMIT_PAUSE;
3553	}
3554	if (netif_running(dev)) {
3555	BCM5700_PHY_LOCK(pUmDevice, flags);
3556	LM_SetupPhy(pDevice);
3557	BCM5700_PHY_UNLOCK(pUmDevice, flags);
3558	}
3559
3560	return 0;
3561	}
3562	#endif
3563	#ifdef ETHTOOL_GRXCSUM
3564	case ETHTOOL_GRXCSUM: {
3565	struct ethtool_value edata = { ETHTOOL_GRXCSUM };
3566
3567	edata.data =
3568	(pDevice->TaskToOffload &
3569	LM_TASK_OFFLOAD_RX_TCP_CHECKSUM) != 0;
3570	if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
3571	return -EFAULT;
3572
3573	return 0;
3574	}
3575	case ETHTOOL_SRXCSUM: {
3576	struct ethtool_value edata;
3577
3578	if(!capable(CAP_NET_ADMIN))
3579	return -EPERM;
3580	if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
3581	return -EFAULT;
3582	if (edata.data) {
3583	if (!(pDevice->TaskOffloadCap &
3584	LM_TASK_OFFLOAD_TX_TCP_CHECKSUM)) {
3585
3586	return -EINVAL;
3587	}
3588	pDevice->TaskToOffload \|=
3589	LM_TASK_OFFLOAD_RX_TCP_CHECKSUM \|
3590	LM_TASK_OFFLOAD_RX_UDP_CHECKSUM;
3591	}
3592	else {
3593	pDevice->TaskToOffload &=
3594	~(LM_TASK_OFFLOAD_RX_TCP_CHECKSUM \|
3595	LM_TASK_OFFLOAD_RX_UDP_CHECKSUM);
3596	}
3597	return 0;
3598	}
3599	case ETHTOOL_GTXCSUM: {
3600	struct ethtool_value edata = { ETHTOOL_GTXCSUM };
3601
3602	edata.data =
3603	(dev->features & get_csum_flag( pDevice->ChipRevId)) != 0;
3604	if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
3605	return -EFAULT;
3606
3607	return 0;
3608	}
3609	case ETHTOOL_STXCSUM: {
3610	struct ethtool_value edata;
3611
3612	if(!capable(CAP_NET_ADMIN))
3613	return -EPERM;
3614	if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
3615	return -EFAULT;
3616	if (edata.data) {
3617	if (!(pDevice->TaskOffloadCap &
3618	LM_TASK_OFFLOAD_TX_TCP_CHECKSUM)) {
3619
3620	return -EINVAL;
3621	}
3622	dev->features \|= get_csum_flag( pDevice->ChipRevId);
3623	pDevice->TaskToOffload \|=
3624	LM_TASK_OFFLOAD_TX_TCP_CHECKSUM \|
3625	LM_TASK_OFFLOAD_TX_UDP_CHECKSUM;
3626	}
3627	else {
3628	dev->features &= ~get_csum_flag( pDevice->ChipRevId);
3629	pDevice->TaskToOffload &=
3630	~(LM_TASK_OFFLOAD_TX_TCP_CHECKSUM \|
3631	LM_TASK_OFFLOAD_TX_UDP_CHECKSUM);
3632	}
3633	return 0;
3634	}
3635	case ETHTOOL_GSG: {
3636	struct ethtool_value edata = { ETHTOOL_GSG };
3637
3638	edata.data =
3639	(dev->features & NETIF_F_SG) != 0;
3640	if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
3641	return -EFAULT;
3642	return 0;
3643	}
3644	case ETHTOOL_SSG: {
3645	struct ethtool_value edata;
3646
3647	if(!capable(CAP_NET_ADMIN))
3648	return -EPERM;
3649	if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
3650	return -EFAULT;
3651	if (edata.data) {
3652	dev->features \|= NETIF_F_SG;
3653	}
3654	else {
3655	dev->features &= ~NETIF_F_SG;
3656	}
3657	return 0;
3658	}
3659	#endif
3660	#ifdef ETHTOOL_GRINGPARAM
3661	case ETHTOOL_GRINGPARAM: {
3662	struct ethtool_ringparam ering = { ETHTOOL_GRINGPARAM };
3663
3664	ering.rx_max_pending = T3_STD_RCV_RCB_ENTRY_COUNT - 1;
3665	ering.rx_pending = pDevice->RxStdDescCnt;
3666	ering.rx_mini_max_pending = 0;
3667	ering.rx_mini_pending = 0;
3668	#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
3669	ering.rx_jumbo_max_pending = T3_JUMBO_RCV_RCB_ENTRY_COUNT - 1;
3670	ering.rx_jumbo_pending = pDevice->RxJumboDescCnt;
3671	#else
3672	ering.rx_jumbo_max_pending = 0;
3673	ering.rx_jumbo_pending = 0;
3674	#endif
3675	ering.tx_max_pending = MAX_TX_PACKET_DESC_COUNT - 1;
3676	ering.tx_pending = pDevice->TxPacketDescCnt;
3677	if (mm_copy_to_user(useraddr, &ering, sizeof(ering)))
3678	return -EFAULT;
3679	return 0;
3680	}
3681	#endif
3682	#ifdef ETHTOOL_PHYS_ID
3683	case ETHTOOL_PHYS_ID: {
3684	struct ethtool_value edata;
3685
3686	if(!capable(CAP_NET_ADMIN))
3687	return -EPERM;
3688	if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
3689	return -EFAULT;
3690	if (LM_BlinkLED(pDevice, edata.data) == LM_STATUS_SUCCESS)
3691	return 0;
3692	return -EINTR;
3693	}
3694	#endif
3695	#ifdef ETHTOOL_GSTRINGS
3696	case ETHTOOL_GSTRINGS: {
3697	struct ethtool_gstrings egstr = { ETHTOOL_GSTRINGS };
3698
3699	if (mm_copy_from_user(&egstr, useraddr, sizeof(egstr)))
3700	return -EFAULT;
3701	switch(egstr.string_set) {
3702	#ifdef ETHTOOL_GSTATS
3703	case ETH_SS_STATS:
3704	egstr.len = ETH_NUM_STATS;
3705	if (mm_copy_to_user(useraddr, &egstr, sizeof(egstr)))
3706	return -EFAULT;
3707	if (mm_copy_to_user(useraddr + sizeof(egstr),
3708	bcm5700_stats_str_arr,
3709	sizeof(bcm5700_stats_str_arr)))
3710	return -EFAULT;
3711	return 0;
3712	#endif
3713	default:
3714	return -EOPNOTSUPP;
3715	}
3716	}
3717	#endif
3718	#ifdef ETHTOOL_GSTATS
3719	case ETHTOOL_GSTATS: {
3720	struct ethtool_stats estats = { ETHTOOL_GSTATS };
3721	uint64_t stats[ETH_NUM_STATS];
3722	int i;
3723	uint64_t *pStats =
3724	(uint64_t *) pDevice->pStatsBlkVirt;
3725
3726	estats.n_stats = ETH_NUM_STATS;
3727	if (pStats == 0) {
3728	memset(stats, 0, sizeof(stats));
3729	}
3730	else {
3731
3732	for (i = 0; i < ETH_NUM_STATS; i++) {
3733	if (bcm5700_stats_offset_arr[i] != 0) {
3734	stats[i] = SWAP_DWORD_64(*(pStats +
3735	bcm5700_stats_offset_arr[i]));
3736	}
3737	else if (i == RX_CRC_IDX) {
3738	stats[i] =
3739	bcm5700_crc_count(pUmDevice);
3740	}
3741	else if (i == RX_MAC_ERR_IDX) {
3742	stats[i] =
3743	bcm5700_rx_err_count(pUmDevice);
3744	}
3745	}
3746	}
3747	if (mm_copy_to_user(useraddr, &estats, sizeof(estats))) {
3748	return -EFAULT;
3749	}
3750	if (mm_copy_to_user(useraddr + sizeof(estats), &stats,
3751	sizeof(stats))) {
3752	return -EFAULT;
3753	}
3754	return 0;
3755	}
3756	#endif
3757	#ifdef ETHTOOL_GTSO
3758	case ETHTOOL_GTSO: {
3759	struct ethtool_value edata = { ETHTOOL_GTSO };
3760
3761	#ifdef BCM_TSO
3762	edata.data =
3763	(dev->features & NETIF_F_TSO) != 0;
3764	#else
3765	edata.data = 0;
3766	#endif
3767	if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
3768	return -EFAULT;
3769	return 0;
3770	}
3771	#endif
3772	#ifdef ETHTOOL_STSO
3773	case ETHTOOL_STSO: {
3774	#ifdef BCM_TSO
3775	struct ethtool_value edata;
3776
3777	if (!capable(CAP_NET_ADMIN))
3778	return -EPERM;
3779
3780	if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
3781	return -EFAULT;
3782
3783	if (!(pDevice->TaskToOffload &
3784	LM_TASK_OFFLOAD_TCP_SEGMENTATION)) {
3785	return -EINVAL;
3786	}
3787
3788	dev->features &= ~NETIF_F_TSO;
3789
3790	if (edata.data) {
3791	if (T3_ASIC_5714_FAMILY(pDevice->ChipRevId) &&
3792	(dev->mtu > 1500)) {
3793	printk(KERN_ALERT "%s: Jumbo Frames and TSO cannot simultaneously be enabled. Jumbo Frames enabled. TSO disabled.\n", dev->name);
3794	return -EINVAL;
3795	} else {
3796	dev->features \|= NETIF_F_TSO;
3797	}
3798	}
3799	return 0;
3800	#else
3801	return -EINVAL;
3802	#endif
3803	}
3804	#endif
3805	}
3806
3807	return -EOPNOTSUPP;
3808	}
3809	#endif /* #ifdef SIOCETHTOOL */
3810
3811	#if (LINUX_VERSION_CODE >= 0x20400) && (LINUX_VERSION_CODE < 0x20600)
3812	#include <linux/iobuf.h>
3813	#endif
3814
3815	/* Provide ioctl() calls to examine the MII xcvr state. */
3816	STATIC int bcm5700_ioctl(struct net_device dev, struct ifreq rq, int cmd)
3817	{
3818	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
3819	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
3820	u16 data = (u16 )&rq->ifr_data;
3821	u32 value = 0;
3822	u16 page_num =0, addr_num =0, len =0;
3823	unsigned long flags;
3824
3825	switch(cmd) {
3826	case SIOCGREG_STATUS: //Get register
3827	{
3828	struct reg_ioctl_data rdata =(struct reg_ioctl_data )rq->ifr_data;
3829	robo_info_t robo = (robo_info_t )pUmDevice->robo;
3830	page_num = rdata->page_num;
3831	addr_num = rdata->addr_num;
3832	len = rdata->len;
3833	printk("b57um SIOCGREG_STATUS cmd page[0x%x]addr[0x%x]len[%d].\n",page_num,addr_num,len);
3834	if (len == 6)
3835	{
3836	ReadDataFromRegister(robo,page_num,addr_num,len,(void *)&rdata->val_out);
3837	printk("val[0x%04x-0x%04x-0x%04x].\n",rdata->val_out[0],rdata->val_out[1],rdata->val_out[2]);
3838	}
3839	else if (len == 8)
3840	{
3841	ReadDataFromRegister(robo,page_num,addr_num,len,(void *)&rdata->val_out);
3842	printk("val[0x%04x%04x-0x%04x%04x].\n",rdata->val_out[0],rdata->val_out[1],
3843	rdata->val_out[2],rdata->val_out[3]);
3844	}
3845	else if (len == 4)
3846	{
3847	ReadDataFromRegister(robo,page_num,addr_num,len,(void *)&rdata->val_out);
3848	printk("val[0x%04x%04x].\n",rdata->val_out[0],rdata->val_out[1]);
3849	}
3850	else
3851	{
3852	ReadDataFromRegister(robo,page_num,addr_num,len,(void *)&rdata->val_out);
3853	printk("val[0x%04x].\n",rdata->val_out[0]);
3854
3855	}
3856	if (mm_copy_to_user(rq->ifr_data, rdata, sizeof(struct reg_ioctl_data)))
3857	{
3858	printk("Fail mm_copy_to_user.\n");
3859	return -EFAULT;
3860	}
3861	return 0;
3862	}
3863	break;
3864	case SIOCSREG_STATUS://Set register
3865	{
3866	struct reg_ioctl_data * wdata =(struct reg_ioctl_data *)rq->ifr_data;
3867	len = wdata->len;
3868	page_num = wdata->page_num;
3869	addr_num = wdata->addr_num;
3870	robo_info_t robo = (robo_info_t )pUmDevice->robo;
3871	if (len == 6)
3872	{
3873	WriteDataToRegister(robo,page_num,addr_num,len,(void *)&wdata->val_in);
3874	//printk("val[0x%04x-0x%04x-0x%04x].\n",val48[0],val48[1],val48[2]);
3875	}
3876	else if (len == 8)
3877	{
3878	WriteDataToRegister(robo,page_num,addr_num,len,(void *)&wdata->val_in);
3879	//printk("val[0x%04x-0x%04x-0x%04x-0x%04x].\n",val64[0],val64[1],val64[2],val64[3]);
3880	}
3881	else if (len == 4)
3882	{
3883	WriteDataToRegister(robo,page_num,addr_num,len,(void *)&wdata->val_in);
3884	//printk("val[0x%08x].\n",value);
3885	}
3886	else
3887	{
3888	WriteDataToRegister(robo,page_num,addr_num,len,(void *)&wdata->val_in);
3889	//printk("len[%d] val[0x%04x].\n",len,val16);
3890	}
3891
3892	return 0;
3893	}
3894	break;
3895	#ifdef SIOCGMIIPHY
3896	case SIOCGMIIPHY: /* Get the address of the PHY in use. */
3897
3898	data[0] = pDevice->PhyAddr;
3899	return 0;
3900	#endif
3901
3902	#ifdef SIOCGMIIREG
3903	case SIOCGMIIREG: /* Read the specified MII register. */
3904	{
3905	uint32 savephyaddr = 0;
3906
3907	if (pDevice->TbiFlags & ENABLE_TBI_FLAG)
3908	return -EOPNOTSUPP;
3909
3910	/* ifup only waits for 5 seconds for link up */
3911	/* NIC may take more than 5 seconds to establish link */
3912	if ((pUmDevice->delayed_link_ind > 0) &&
3913	delay_link[pUmDevice->index]) {
3914	return -EAGAIN;
3915	}
3916
3917	BCM5700_PHY_LOCK(pUmDevice, flags);
3918	if (data[0] != 0xffff) {
3919	savephyaddr = pDevice->PhyAddr;
3920	pDevice->PhyAddr = data[0];
3921	}
3922	LM_ReadPhy(pDevice, data[1] & 0x1f, (LM_UINT32 *)&value);
3923	if (data[0] != 0xffff)
3924	pDevice->PhyAddr = savephyaddr;
3925	BCM5700_PHY_UNLOCK(pUmDevice, flags);
3926	data[3] = value & 0xffff;
3927	return 0;
3928	}
3929	#endif
3930
3931	#ifdef SIOCSMIIREG
3932	case SIOCSMIIREG: /* Write the specified MII register */
3933	{
3934	uint32 savephyaddr = 0;
3935
3936	if (!capable(CAP_NET_ADMIN))
3937	return -EPERM;
3938
3939	if (pDevice->TbiFlags & ENABLE_TBI_FLAG)
3940	return -EOPNOTSUPP;
3941
3942	BCM5700_PHY_LOCK(pUmDevice, flags);
3943	if (data[0] != 0xffff) {
3944	savephyaddr = pDevice->PhyAddr;
3945	pDevice->PhyAddr = data[0];
3946	}
3947	LM_WritePhy(pDevice, data[1] & 0x1f, data[2]);
3948	if (data[0] != 0xffff)
3949	pDevice->PhyAddr = savephyaddr;
3950	BCM5700_PHY_UNLOCK(pUmDevice, flags);
3951	data[3] = 0;
3952	return 0;
3953	}
3954	#endif
3955
3956	#ifdef SIOCETHTOOL
3957	case SIOCETHTOOL:
3958	return netdev_ethtool_ioctl(dev, (void *) rq->ifr_data);
3959	#endif
3960	default:
3961	return -EOPNOTSUPP;
3962	}
3963	return -EOPNOTSUPP;
3964	}
3965
3966	STATIC void bcm5700_do_rx_mode(struct net_device *dev)
3967	{
3968	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
3969	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
3970	int i;
3971	struct dev_mc_list *mclist;
3972
3973	LM_MulticastClear(pDevice);
3974	for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
3975	i++, mclist = mclist->next) {
3976	LM_MulticastAdd(pDevice, (PLM_UINT8) &mclist->dmi_addr);
3977	}
3978	if (dev->flags & IFF_ALLMULTI) {
3979	if (!(pDevice->ReceiveMask & LM_ACCEPT_ALL_MULTICAST)) {
3980	LM_SetReceiveMask(pDevice,
3981	pDevice->ReceiveMask \| LM_ACCEPT_ALL_MULTICAST);
3982	}
3983	}
3984	else if (pDevice->ReceiveMask & LM_ACCEPT_ALL_MULTICAST) {
3985	LM_SetReceiveMask(pDevice,
3986	pDevice->ReceiveMask & ~LM_ACCEPT_ALL_MULTICAST);
3987	}
3988	if (dev->flags & IFF_PROMISC) {
3989	if (!(pDevice->ReceiveMask & LM_PROMISCUOUS_MODE)) {
3990	LM_SetReceiveMask(pDevice,
3991	pDevice->ReceiveMask \| LM_PROMISCUOUS_MODE);
3992	}
3993	}
3994	else if (pDevice->ReceiveMask & LM_PROMISCUOUS_MODE) {
3995	LM_SetReceiveMask(pDevice,
3996	pDevice->ReceiveMask & ~LM_PROMISCUOUS_MODE);
3997	}
3998
3999	}
4000
4001	STATIC void bcm5700_set_rx_mode(struct net_device *dev)
4002	{
4003	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
4004	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
4005	int i;
4006	struct dev_mc_list *mclist;
4007	unsigned long flags;
4008
4009	BCM5700_PHY_LOCK(pUmDevice, flags);
4010
4011	LM_MulticastClear(pDevice);
4012	for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
4013	i++, mclist = mclist->next) {
4014	LM_MulticastAdd(pDevice, (PLM_UINT8) &mclist->dmi_addr);
4015	}
4016	if (dev->flags & IFF_ALLMULTI) {
4017	if (!(pDevice->ReceiveMask & LM_ACCEPT_ALL_MULTICAST)) {
4018	LM_SetReceiveMask(pDevice,
4019	pDevice->ReceiveMask \| LM_ACCEPT_ALL_MULTICAST);
4020	}
4021	}
4022	else if (pDevice->ReceiveMask & LM_ACCEPT_ALL_MULTICAST) {
4023	LM_SetReceiveMask(pDevice,
4024	pDevice->ReceiveMask & ~LM_ACCEPT_ALL_MULTICAST);
4025	}
4026	if (dev->flags & IFF_PROMISC) {
4027	if (!(pDevice->ReceiveMask & LM_PROMISCUOUS_MODE)) {
4028	LM_SetReceiveMask(pDevice,
4029	pDevice->ReceiveMask \| LM_PROMISCUOUS_MODE);
4030	}
4031	}
4032	else if (pDevice->ReceiveMask & LM_PROMISCUOUS_MODE) {
4033	LM_SetReceiveMask(pDevice,
4034	pDevice->ReceiveMask & ~LM_PROMISCUOUS_MODE);
4035	}
4036
4037	BCM5700_PHY_UNLOCK(pUmDevice, flags);
4038	}
4039
4040	/*
4041	* Set the hardware MAC address.
4042	*/
4043	STATIC int bcm5700_set_mac_addr(struct net_device dev, void p)
4044	{
4045	struct sockaddr *addr=p;
4046	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) dev->priv;
4047	UM_DEVICE_BLOCK pUmDevice = (UM_DEVICE_BLOCK ) pDevice;
4048
4049	if(is_valid_ether_addr(addr->sa_data)){
4050
4051	memcpy(dev->dev_addr, addr->sa_data,dev->addr_len);
4052	if (pUmDevice->opened)
4053	LM_SetMacAddress(pDevice, dev->dev_addr);
4054	bcm_robo_set_macaddr(pUmDevice->robo, dev->dev_addr);
4055	return 0;
4056	}
4057	return -EINVAL;
4058	}
4059
4060	#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
4061	STATIC int bcm5700_change_mtu(struct net_device *dev, int new_mtu)
4062	{
4063	int pkt_size = new_mtu + ETHERNET_PACKET_HEADER_SIZE;
4064	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
4065	PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
4066	unsigned long flags;
4067	int reinit = 0;
4068
4069	if ((pkt_size < MIN_ETHERNET_PACKET_SIZE_NO_CRC) \|\|
4070	(pkt_size > MAX_ETHERNET_JUMBO_PACKET_SIZE_NO_CRC)) {
4071
4072	return -EINVAL;
4073	}
4074	if ( !(pDevice->Flags & JUMBO_CAPABLE_FLAG) &&
4075	(pkt_size > MAX_ETHERNET_PACKET_SIZE_NO_CRC) ) {
4076
4077	return -EINVAL;
4078	}
4079	if (pUmDevice->suspended)
4080	return -EAGAIN;
4081
4082	if (pUmDevice->opened && (new_mtu != dev->mtu) &&
4083	(pDevice->Flags & JUMBO_CAPABLE_FLAG)) {
4084	reinit = 1;
4085	}
4086
4087	BCM5700_PHY_LOCK(pUmDevice, flags);
4088	if (reinit) {
4089	netif_stop_queue(dev);
4090	bcm5700_shutdown(pUmDevice);
4091	bcm5700_freemem(dev);
4092	}
4093
4094	dev->mtu = new_mtu;
4095	if (pkt_size < MAX_ETHERNET_PACKET_SIZE_NO_CRC) {
4096	pDevice->RxMtu = pDevice->TxMtu =
4097	MAX_ETHERNET_PACKET_SIZE_NO_CRC;
4098	}
4099	else {
4100	pDevice->RxMtu = pDevice->TxMtu = pkt_size;
4101	}
4102
4103	if (dev->mtu <= 1514) {
4104	pDevice->RxJumboDescCnt = 0;
4105	}
4106	else if (pDevice->Flags & JUMBO_CAPABLE_FLAG){
4107	pDevice->RxJumboDescCnt =
4108	rx_jumbo_desc_cnt[pUmDevice->index];
4109	}
4110	pDevice->RxPacketDescCnt = pDevice->RxJumboDescCnt +
4111	pDevice->RxStdDescCnt;
4112
4113	pDevice->RxJumboBufferSize = (pDevice->RxMtu + 8 /* CRC + VLAN */ +
4114	COMMON_CACHE_LINE_SIZE-1) & ~COMMON_CACHE_LINE_MASK;
4115
4116	#ifdef BCM_TSO
4117	if (T3_ASIC_5714_FAMILY(pDevice->ChipRevId) &&
4118	(dev->mtu > 1514) ) {
4119	if (dev->features & NETIF_F_TSO) {
4120	dev->features &= ~NETIF_F_TSO;
4121	printk(KERN_ALERT "%s: TSO previously enabled. Jumbo Frames and TSO cannot simultaneously be enabled. Jumbo Frames enabled. TSO disabled.\n", dev->name);
4122	}
4123	}
4124	#endif
4125
4126	if (reinit) {
4127	LM_InitializeAdapter(pDevice);
4128	bcm5700_do_rx_mode(dev);
4129	bcm5700_set_vlan_mode(pUmDevice);
4130	bcm5700_init_counters(pUmDevice);
4131	if (memcmp(dev->dev_addr, pDevice->NodeAddress, 6)) {
4132	LM_SetMacAddress(pDevice, dev->dev_addr);
4133	}
4134	netif_start_queue(dev);
4135	bcm5700_intr_on(pUmDevice);
4136	}
4137	BCM5700_PHY_UNLOCK(pUmDevice, flags);
4138
4139	return 0;
4140	}
4141	#endif
4142
4143
4144	#if (LINUX_VERSION_CODE < 0x020300)
4145	int
4146	bcm5700_probe(struct net_device *dev)
4147	{
4148	int cards_found = 0;
4149	struct pci_dev *pdev = NULL;
4150	struct pci_device_id *pci_tbl;
4151	u16 ssvid, ssid;
4152
4153	if ( ! pci_present())
4154	return -ENODEV;
4155
4156	pci_tbl = bcm5700_pci_tbl;
4157	while ((pdev = pci_find_class(PCI_CLASS_NETWORK_ETHERNET << 8, pdev))) {
4158	int idx;
4159
4160	pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &ssvid);
4161	pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &ssid);
4162	for (idx = 0; pci_tbl[idx].vendor; idx++) {
4163	if ((pci_tbl[idx].vendor == PCI_ANY_ID \|\|
4164	pci_tbl[idx].vendor == pdev->vendor) &&
4165	(pci_tbl[idx].device == PCI_ANY_ID \|\|
4166	pci_tbl[idx].device == pdev->device) &&
4167	(pci_tbl[idx].subvendor == PCI_ANY_ID \|\|
4168	pci_tbl[idx].subvendor == ssvid) &&
4169	(pci_tbl[idx].subdevice == PCI_ANY_ID \|\|
4170	pci_tbl[idx].subdevice == ssid))
4171	{
4172
4173	break;
4174	}
4175	}
4176	if (pci_tbl[idx].vendor == 0)
4177	continue;
4178
4179
4180	if (bcm5700_init_one(pdev, &pci_tbl[idx]) == 0)
4181	cards_found++;
4182	}
4183
4184	return cards_found ? 0 : -ENODEV;
4185	}
4186
4187	#ifdef MODULE
4188	int init_module(void)
4189	{
4190	return bcm5700_probe(NULL);
4191	}
4192
4193	void cleanup_module(void)
4194	{
4195	struct net_device *next_dev;
4196	PUM_DEVICE_BLOCK pUmDevice;
4197
4198	/* No need to check MOD_IN_USE, as sys_delete_module() checks. */
4199	while (root_tigon3_dev) {
4200	pUmDevice = (PUM_DEVICE_BLOCK)root_tigon3_dev->priv;
4201	next_dev = pUmDevice->next_module;
4202	unregister_netdev(root_tigon3_dev);
4203	if (pUmDevice->lm_dev.pMappedMemBase)
4204	iounmap(pUmDevice->lm_dev.pMappedMemBase);
4205	#if (LINUX_VERSION_CODE < 0x020600)
4206	kfree(root_tigon3_dev);
4207	#else
4208	free_netdev(root_tigon3_dev);
4209	#endif
4210	root_tigon3_dev = next_dev;
4211	}
4212	#ifdef BCM_IOCTL32
4213	unregister_ioctl32_conversion(SIOCNICE);
4214	#endif
4215	}
4216
4217	#endif /* MODULE */
4218	#else /* LINUX_VERSION_CODE < 0x020300 */
4219
4220	#if (LINUX_VERSION_CODE >= 0x020406)
4221	static int bcm5700_suspend (struct pci_dev *pdev, u32 state)
4222	#else
4223	static void bcm5700_suspend (struct pci_dev *pdev)
4224	#endif
4225	{
4226	struct net_device dev = (struct net_device ) pci_get_drvdata(pdev);
4227	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
4228	PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
4229
4230	if (!netif_running(dev))
4231	#if (LINUX_VERSION_CODE >= 0x020406)
4232	return 0;
4233	#else
4234	return;
4235	#endif
4236
4237	netif_device_detach (dev);
4238	bcm5700_shutdown(pUmDevice);
4239
4240	LM_SetPowerState(pDevice, LM_POWER_STATE_D3);
4241
4242	/* pci_power_off(pdev, -1);*/
4243	#if (LINUX_VERSION_CODE >= 0x020406)
4244	return 0;
4245	#endif
4246	}
4247
4248
4249	#if (LINUX_VERSION_CODE >= 0x020406)
4250	static int bcm5700_resume(struct pci_dev *pdev)
4251	#else
4252	static void bcm5700_resume(struct pci_dev *pdev)
4253	#endif
4254	{
4255	struct net_device dev = (struct net_device ) pci_get_drvdata(pdev);
4256	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
4257	PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
4258
4259	if (!netif_running(dev))
4260	#if (LINUX_VERSION_CODE >= 0x020406)
4261	return 0;
4262	#else
4263	return;
4264	#endif
4265	/* pci_power_on(pdev);*/
4266	netif_device_attach(dev);
4267	LM_SetPowerState(pDevice, LM_POWER_STATE_D0);
4268	MM_InitializeUmPackets(pDevice);
4269	bcm5700_reset(dev);
4270	#if (LINUX_VERSION_CODE >= 0x020406)
4271	return 0;
4272	#endif
4273	}
4274
4275
4276	static struct pci_driver bcm5700_pci_driver = {
4277	name: bcm5700_driver,
4278	id_table: bcm5700_pci_tbl,
4279	probe: bcm5700_init_one,
4280	remove: __devexit_p(bcm5700_remove_one),
4281	suspend: bcm5700_suspend,
4282	resume: bcm5700_resume,
4283	};
4284
4285	static int
4286	bcm5700_notify_reboot(struct notifier_block this, unsigned long event, void unused)
4287	{
4288	switch (event) {
4289	case SYS_HALT:
4290	case SYS_POWER_OFF:
4291	case SYS_RESTART:
4292	break;
4293	default:
4294	return NOTIFY_DONE;
4295	}
4296
4297	B57_INFO(("bcm5700 reboot notification\n"));
4298	pci_unregister_driver(&bcm5700_pci_driver);
4299	return NOTIFY_DONE;
4300	}
4301
4302	static int __init bcm5700_init_module (void)
4303	{
4304	int pin = 1 << 2;
4305
4306	if (nvram_match("disabled_5397", "1") \|\| (activate_gpio != -1)) {
4307	if ( activate_gpio != -1 ) pin = activate_gpio;
4308	printk("5397 switch GPIO-Reset (pin %d)\n", pin);
4309	sb_t *gpio_sbh;
4310	if (!(gpio_sbh = sb_kattach(SB_OSH))) return -ENODEV;
4311	sb_gpiosetcore(gpio_sbh);
4312	// sb_gpioreserve(gpio_sbh, 0x4, GPIO_HI_PRIORITY);
4313	sb_gpioouten(gpio_sbh, 0x4, 0x4, GPIO_HI_PRIORITY);
4314	sb_gpioout(gpio_sbh, 0x4, 0x4, GPIO_HI_PRIORITY);
4315	sb_detach(gpio_sbh);
4316	}
4317
4318	if (msglevel != 0xdeadbeef) {
4319	b57_msg_level = msglevel;
4320	printf("%s: msglevel set to 0x%x\n", __FUNCTION__, b57_msg_level);
4321	} else
4322	b57_msg_level = B57_ERR_VAL;
4323
4324	return pci_module_init(&bcm5700_pci_driver);
4325	}
4326
4327	static void __exit bcm5700_cleanup_module (void)
4328	{
4329	unregister_reboot_notifier(&bcm5700_reboot_notifier);
4330	pci_unregister_driver(&bcm5700_pci_driver);
4331	}
4332
4333	module_init(bcm5700_init_module);
4334	module_exit(bcm5700_cleanup_module);
4335	#endif
4336
4337	/*
4338	* Middle Module
4339	*
4340	*/
4341
4342
4343	#ifdef BCM_NAPI_RXPOLL
4344	LM_STATUS
4345	MM_ScheduleRxPoll(LM_DEVICE_BLOCK *pDevice)
4346	{
4347	struct net_device dev = ((UM_DEVICE_BLOCK ) pDevice)->dev;
4348
4349	if (netif_rx_schedule_prep(dev)) {
4350	__netif_rx_schedule(dev);
4351	return LM_STATUS_SUCCESS;
4352	}
4353	return LM_STATUS_FAILURE;
4354	}
4355	#endif
4356
4357	LM_STATUS
4358	MM_ReadConfig16(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset,
4359	LM_UINT16 *pValue16)
4360	{
4361	UM_DEVICE_BLOCK *pUmDevice;
4362
4363	pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
4364	pci_read_config_word(pUmDevice->pdev, Offset, (u16 *) pValue16);
4365	return LM_STATUS_SUCCESS;
4366	}
4367
4368	LM_STATUS
4369	MM_ReadConfig32(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset,
4370	LM_UINT32 *pValue32)
4371	{
4372	UM_DEVICE_BLOCK *pUmDevice;
4373
4374	pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
4375	pci_read_config_dword(pUmDevice->pdev, Offset, (u32 *) pValue32);
4376	return LM_STATUS_SUCCESS;
4377	}
4378
4379	LM_STATUS
4380	MM_WriteConfig16(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset,
4381	LM_UINT16 Value16)
4382	{
4383	UM_DEVICE_BLOCK *pUmDevice;
4384
4385	pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
4386	pci_write_config_word(pUmDevice->pdev, Offset, Value16);
4387	return LM_STATUS_SUCCESS;
4388	}
4389
4390	LM_STATUS
4391	MM_WriteConfig32(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset,
4392	LM_UINT32 Value32)
4393	{
4394	UM_DEVICE_BLOCK *pUmDevice;
4395
4396	pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
4397	pci_write_config_dword(pUmDevice->pdev, Offset, Value32);
4398	return LM_STATUS_SUCCESS;
4399	}
4400
4401	LM_STATUS
4402	MM_AllocateSharedMemory(PLM_DEVICE_BLOCK pDevice, LM_UINT32 BlockSize,
4403	PLM_VOID *pMemoryBlockVirt, PLM_PHYSICAL_ADDRESS pMemoryBlockPhy,
4404	LM_BOOL Cached)
4405	{
4406	PLM_VOID pvirt;
4407	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
4408	dma_addr_t mapping;
4409
4410	pvirt = pci_alloc_consistent(pUmDevice->pdev, BlockSize,
4411	&mapping);
4412	if (!pvirt) {
4413	return LM_STATUS_FAILURE;
4414	}
4415	pUmDevice->mem_list[pUmDevice->mem_list_num] = pvirt;
4416	pUmDevice->dma_list[pUmDevice->mem_list_num] = mapping;
4417	pUmDevice->mem_size_list[pUmDevice->mem_list_num++] = BlockSize;
4418	memset(pvirt, 0, BlockSize);
4419	*pMemoryBlockVirt = (PLM_VOID) pvirt;
4420	MM_SetAddr(pMemoryBlockPhy, mapping);
4421	return LM_STATUS_SUCCESS;
4422	}
4423
4424	LM_STATUS
4425	MM_AllocateMemory(PLM_DEVICE_BLOCK pDevice, LM_UINT32 BlockSize,
4426	PLM_VOID *pMemoryBlockVirt)
4427	{
4428	PLM_VOID pvirt;
4429	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
4430
4431
4432	/* Maximum in slab.c */
4433	if (BlockSize > 131072) {
4434	goto MM_Alloc_error;
4435	}
4436
4437	pvirt = kmalloc(BlockSize, GFP_ATOMIC);
4438	if (!pvirt) {
4439	goto MM_Alloc_error;
4440	}
4441	pUmDevice->mem_list[pUmDevice->mem_list_num] = pvirt;
4442	pUmDevice->dma_list[pUmDevice->mem_list_num] = 0;
4443	pUmDevice->mem_size_list[pUmDevice->mem_list_num++] = 0;
4444	/* mem_size_list[i] == 0 indicates that the memory should be freed */
4445	/* using kfree */
4446	memset(pvirt, 0, BlockSize);
4447	*pMemoryBlockVirt = pvirt;
4448	return LM_STATUS_SUCCESS;
4449
4450	MM_Alloc_error:
4451	printk(KERN_WARNING "%s: Memory allocation failed - buffer parameters may be set too high\n", pUmDevice->dev->name);
4452	return LM_STATUS_FAILURE;
4453	}
4454
4455	LM_STATUS
4456	MM_MapMemBase(PLM_DEVICE_BLOCK pDevice)
4457	{
4458	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
4459
4460	pDevice->pMappedMemBase = ioremap_nocache(
4461	pci_resource_start(pUmDevice->pdev, 0), sizeof(T3_STD_MEM_MAP));
4462	if (pDevice->pMappedMemBase == 0)
4463	return LM_STATUS_FAILURE;
4464
4465	return LM_STATUS_SUCCESS;
4466	}
4467
4468	LM_STATUS
4469	MM_InitializeUmPackets(PLM_DEVICE_BLOCK pDevice)
4470	{
4471	unsigned int i;
4472	struct sk_buff *skb;
4473	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
4474	PUM_PACKET pUmPacket;
4475	PLM_PACKET pPacket;
4476
4477	for (i = 0; i < pDevice->RxPacketDescCnt; i++) {
4478	pPacket = QQ_PopHead(&pDevice->RxPacketFreeQ.Container);
4479	pUmPacket = (PUM_PACKET) pPacket;
4480	if (pPacket == 0) {
4481	printk(KERN_DEBUG "Bad RxPacketFreeQ\n");
4482	}
4483	if (pUmPacket->skbuff == 0) {
4484	#ifdef BCM_WL_EMULATOR
4485	skb = (struct sk_buff *)wlcemu_pktget(pDevice->wlc,pPacket->u.Rx.RxBufferSize + 2);
4486	#else
4487	skb = dev_alloc_skb(pPacket->u.Rx.RxBufferSize + 2 + EXTRA_HDR);
4488	#endif
4489	if (skb == 0) {
4490	pUmPacket->skbuff = 0;
4491	QQ_PushTail(
4492	&pUmDevice->rx_out_of_buf_q.Container,
4493	pPacket);
4494	continue;
4495	}
4496	pUmPacket->skbuff = skb;
4497	skb->dev = pUmDevice->dev;
4498	#ifndef BCM_WL_EMULATOR
4499	skb_reserve(skb, EXTRA_HDR - pUmDevice->rx_buf_align);
4500	#endif
4501	}
4502	QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
4503	}
4504	if (T3_ASIC_REV(pUmDevice->lm_dev.ChipRevId) == T3_ASIC_REV_5700) {
4505	/* reallocate buffers in the ISR */
4506	pUmDevice->rx_buf_repl_thresh = 0;
4507	pUmDevice->rx_buf_repl_panic_thresh = 0;
4508	pUmDevice->rx_buf_repl_isr_limit = 0;
4509	}
4510	else {
4511	pUmDevice->rx_buf_repl_thresh = pDevice->RxPacketDescCnt / 8;
4512	pUmDevice->rx_buf_repl_panic_thresh =
4513	pDevice->RxPacketDescCnt * 7 / 8;
4514
4515	/* This limits the time spent in the ISR when the receiver */
4516	/* is in a steady state of being overrun. */
4517	pUmDevice->rx_buf_repl_isr_limit = pDevice->RxPacketDescCnt / 8;
4518
4519	#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
4520	if (pDevice->RxJumboDescCnt != 0) {
4521	if (pUmDevice->rx_buf_repl_thresh >=
4522	pDevice->RxJumboDescCnt) {
4523
4524	pUmDevice->rx_buf_repl_thresh =
4525	pUmDevice->rx_buf_repl_panic_thresh =
4526	pDevice->RxJumboDescCnt - 1;
4527	}
4528	if (pUmDevice->rx_buf_repl_thresh >=
4529	pDevice->RxStdDescCnt) {
4530
4531	pUmDevice->rx_buf_repl_thresh =
4532	pUmDevice->rx_buf_repl_panic_thresh =
4533	pDevice->RxStdDescCnt - 1;
4534	}
4535	}
4536	#endif
4537	}
4538	return LM_STATUS_SUCCESS;
4539	}
4540
4541	LM_STATUS
4542	MM_GetConfig(PLM_DEVICE_BLOCK pDevice)
4543	{
4544	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
4545	int index = pUmDevice->index;
4546	struct net_device *dev = pUmDevice->dev;
4547
4548	if (index >= MAX_UNITS)
4549	return LM_STATUS_SUCCESS;
4550
4551	#if LINUX_KERNEL_VERSION < 0x0020609
4552
4553	bcm5700_validate_param_range(pUmDevice, &auto_speed[index], "auto_speed",
4554	0, 1, 1);
4555	if (auto_speed[index] == 0)
4556	pDevice->DisableAutoNeg = TRUE;
4557	else
4558	pDevice->DisableAutoNeg = FALSE;
4559
4560	if (line_speed[index] == 0) {
4561	pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
4562	pDevice->DisableAutoNeg = FALSE;
4563	}
4564	else {
4565	bcm5700_validate_param_range(pUmDevice, &full_duplex[index],
4566	"full_duplex", 0, 1, 1);
4567	if (full_duplex[index]) {
4568	pDevice->RequestedDuplexMode = LM_DUPLEX_MODE_FULL;
4569	}
4570	else {
4571	pDevice->RequestedDuplexMode = LM_DUPLEX_MODE_HALF;
4572	}
4573
4574	if (line_speed[index] == 1000) {
4575	pDevice->RequestedLineSpeed = LM_LINE_SPEED_1000MBPS;
4576	if (pDevice->PhyFlags & PHY_NO_GIGABIT) {
4577	pDevice->RequestedLineSpeed =
4578	LM_LINE_SPEED_100MBPS;
4579	printk(KERN_WARNING "%s-%d: Invalid line_speed parameter (1000), using 100\n", bcm5700_driver, index);
4580	}
4581	else {
4582	if ((pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
4583	!full_duplex[index]) {
4584	printk(KERN_WARNING "%s-%d: Invalid full_duplex parameter (0) for fiber, using 1\n", bcm5700_driver, index);
4585	pDevice->RequestedDuplexMode =
4586	LM_DUPLEX_MODE_FULL;
4587	}
4588
4589	if (!(pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
4590	!auto_speed[index] && !(pDevice->PhyFlags & PHY_IS_FIBER) ) {
4591	printk(KERN_WARNING "%s-%d: Invalid auto_speed parameter (0) for copper, using 1\n", bcm5700_driver, index);
4592	pDevice->DisableAutoNeg = FALSE;
4593	}
4594	}
4595	}
4596	else if ((pDevice->TbiFlags & ENABLE_TBI_FLAG) \|\|
4597	(pDevice->PhyFlags & PHY_IS_FIBER)){
4598	pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
4599	pDevice->RequestedDuplexMode = LM_DUPLEX_MODE_FULL;
4600	pDevice->DisableAutoNeg = FALSE;
4601	printk(KERN_WARNING "%s-%d: Invalid line_speed parameter (%d), using auto\n", bcm5700_driver, index, line_speed[index]);
4602	}
4603	else if (line_speed[index] == 100) {
4604
4605	pDevice->RequestedLineSpeed = LM_LINE_SPEED_100MBPS;
4606	}
4607	else if (line_speed[index] == 10) {
4608
4609	pDevice->RequestedLineSpeed = LM_LINE_SPEED_10MBPS;
4610	}
4611	else {
4612	pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
4613	pDevice->DisableAutoNeg = FALSE;
4614	printk(KERN_WARNING "%s-%d: Invalid line_speed parameter (%d), using 0\n", bcm5700_driver, index, line_speed[index]);
4615	}
4616
4617	}
4618
4619	#endif /* LINUX_KERNEL_VERSION */
4620
4621	/* This is an unmanageable switch nic and will have link problems if
4622	not set to auto
4623	*/
4624	if(pDevice->SubsystemVendorId==0x103c && pDevice->SubsystemId==0x3226)
4625	{
4626	if(pDevice->RequestedLineSpeed != LM_LINE_SPEED_AUTO)
4627	{
4628	printk(KERN_WARNING "%s-%d: Invalid line_speed parameter (%d), using 0\n",
4629	bcm5700_driver, index, line_speed[index]);
4630	}
4631	pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
4632	pDevice->DisableAutoNeg = FALSE;
4633	}
4634
4635	#if LINUX_KERNEL_VERSION < 0x0020609
4636
4637	pDevice->FlowControlCap = 0;
4638	bcm5700_validate_param_range(pUmDevice, &rx_flow_control[index],
4639	"rx_flow_control", 0, 1, 0);
4640	if (rx_flow_control[index] != 0) {
4641	pDevice->FlowControlCap \|= LM_FLOW_CONTROL_RECEIVE_PAUSE;
4642	}
4643	bcm5700_validate_param_range(pUmDevice, &tx_flow_control[index],
4644	"tx_flow_control", 0, 1, 0);
4645	if (tx_flow_control[index] != 0) {
4646	pDevice->FlowControlCap \|= LM_FLOW_CONTROL_TRANSMIT_PAUSE;
4647	}
4648	bcm5700_validate_param_range(pUmDevice, &auto_flow_control[index],
4649	"auto_flow_control", 0, 1, 0);
4650	if (auto_flow_control[index] != 0) {
4651	if (pDevice->DisableAutoNeg == FALSE) {
4652
4653	pDevice->FlowControlCap \|= LM_FLOW_CONTROL_AUTO_PAUSE;
4654	if ((tx_flow_control[index] == 0) &&
4655	(rx_flow_control[index] == 0)) {
4656
4657	pDevice->FlowControlCap \|=
4658	LM_FLOW_CONTROL_TRANSMIT_PAUSE \|
4659	LM_FLOW_CONTROL_RECEIVE_PAUSE;
4660	}
4661	}
4662	}
4663
4664	if (dev->mtu > 1500) {
4665	#ifdef BCM_TSO
4666	if (T3_ASIC_5714_FAMILY(pDevice->ChipRevId) &&
4667	(dev->features & NETIF_F_TSO)) {
4668	dev->features &= ~NETIF_F_TSO;
4669	printk(KERN_ALERT "%s: TSO previously enabled. Jumbo Frames and TSO cannot simultaneously be enabled. Jumbo Frames enabled. TSO disabled.\n", dev->name);
4670	}
4671	#endif
4672	pDevice->RxMtu = dev->mtu + 14;
4673	}
4674
4675	if ((T3_ASIC_REV(pDevice->ChipRevId) != T3_ASIC_REV_5700) &&
4676	!(pDevice->Flags & BCM5788_FLAG)) {
4677	pDevice->Flags \|= USE_TAGGED_STATUS_FLAG;
4678	pUmDevice->timer_interval = HZ;
4679	if ((T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5703) &&
4680	(pDevice->TbiFlags & ENABLE_TBI_FLAG)) {
4681	pUmDevice->timer_interval = HZ/4;
4682	}
4683	}
4684	else {
4685	pUmDevice->timer_interval = HZ/10;
4686	}
4687
4688	bcm5700_validate_param_range(pUmDevice, &tx_pkt_desc_cnt[index],
4689	"tx_pkt_desc_cnt", 1, MAX_TX_PACKET_DESC_COUNT-1, TX_DESC_CNT);
4690	pDevice->TxPacketDescCnt = tx_pkt_desc_cnt[index];
4691	bcm5700_validate_param_range(pUmDevice, &rx_std_desc_cnt[index],
4692	"rx_std_desc_cnt", 1, T3_STD_RCV_RCB_ENTRY_COUNT-1,
4693	RX_DESC_CNT);
4694	pDevice->RxStdDescCnt = rx_std_desc_cnt[index];
4695
4696	#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
4697	bcm5700_validate_param_range(pUmDevice, &rx_jumbo_desc_cnt[index],
4698	"rx_jumbo_desc_cnt", 1, T3_JUMBO_RCV_RCB_ENTRY_COUNT-1,
4699	JBO_DESC_CNT);
4700
4701	if (mtu[index] <= 1514)
4702	pDevice->RxJumboDescCnt = 0;
4703	else if(!T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)){
4704	pDevice->RxJumboDescCnt = rx_jumbo_desc_cnt[index];
4705	}
4706	#endif
4707
4708	#ifdef BCM_INT_COAL
4709	bcm5700_validate_param_range(pUmDevice, &adaptive_coalesce[index],
4710	"adaptive_coalesce", 0, 1, 1);
4711	#ifdef BCM_NAPI_RXPOLL
4712	if (adaptive_coalesce[index]) {
4713	printk(KERN_WARNING "%s-%d: adaptive_coalesce not used in NAPI mode\n", bcm5700_driver, index);
4714	adaptive_coalesce[index] = 0;
4715
4716	}
4717	#endif
4718	pUmDevice->adaptive_coalesce = adaptive_coalesce[index];
4719	if (!pUmDevice->adaptive_coalesce) {
4720	bcm5700_validate_param_range(pUmDevice,
4721	&rx_coalesce_ticks[index], "rx_coalesce_ticks", 0,
4722	MAX_RX_COALESCING_TICKS, RX_COAL_TK);
4723	if ((rx_coalesce_ticks[index] == 0) &&
4724	(rx_max_coalesce_frames[index] == 0)) {
4725
4726	printk(KERN_WARNING "%s-%d: Conflicting rx_coalesce_ticks (0) and rx_max_coalesce_frames (0) parameters, using %d and %d respectively\n",
4727	bcm5700_driver, index, RX_COAL_TK, RX_COAL_FM);
4728
4729	rx_coalesce_ticks[index] = RX_COAL_TK;
4730	rx_max_coalesce_frames[index] = RX_COAL_FM;
4731	}
4732	pDevice->RxCoalescingTicks = pUmDevice->rx_curr_coalesce_ticks =
4733	rx_coalesce_ticks[index];
4734	#ifdef BCM_NAPI_RXPOLL
4735	pDevice->RxCoalescingTicksDuringInt = rx_coalesce_ticks[index];
4736	#endif
4737
4738	bcm5700_validate_param_range(pUmDevice,
4739	&rx_max_coalesce_frames[index],
4740	"rx_max_coalesce_frames", 0,
4741	MAX_RX_MAX_COALESCED_FRAMES, RX_COAL_FM);
4742
4743	pDevice->RxMaxCoalescedFrames =
4744	pUmDevice->rx_curr_coalesce_frames =
4745	rx_max_coalesce_frames[index];
4746	#ifdef BCM_NAPI_RXPOLL
4747	pDevice->RxMaxCoalescedFramesDuringInt =
4748	rx_max_coalesce_frames[index];
4749	#endif
4750
4751	bcm5700_validate_param_range(pUmDevice,
4752	&tx_coalesce_ticks[index], "tx_coalesce_ticks", 0,
4753	MAX_TX_COALESCING_TICKS, TX_COAL_TK);
4754	if ((tx_coalesce_ticks[index] == 0) &&
4755	(tx_max_coalesce_frames[index] == 0)) {
4756
4757	printk(KERN_WARNING "%s-%d: Conflicting tx_coalesce_ticks (0) and tx_max_coalesce_frames (0) parameters, using %d and %d respectively\n",
4758	bcm5700_driver, index, TX_COAL_TK, TX_COAL_FM);
4759
4760	tx_coalesce_ticks[index] = TX_COAL_TK;
4761	tx_max_coalesce_frames[index] = TX_COAL_FM;
4762	}
4763	pDevice->TxCoalescingTicks = tx_coalesce_ticks[index];
4764	bcm5700_validate_param_range(pUmDevice,
4765	&tx_max_coalesce_frames[index],
4766	"tx_max_coalesce_frames", 0,
4767	MAX_TX_MAX_COALESCED_FRAMES, TX_COAL_FM);
4768	pDevice->TxMaxCoalescedFrames = tx_max_coalesce_frames[index];
4769	pUmDevice->tx_curr_coalesce_frames =
4770	pDevice->TxMaxCoalescedFrames;
4771
4772	bcm5700_validate_param_range(pUmDevice,
4773	&stats_coalesce_ticks[index], "stats_coalesce_ticks",
4774	0, MAX_STATS_COALESCING_TICKS, ST_COAL_TK);
4775	if (adaptive_coalesce[index]) {
4776	printk(KERN_WARNING "%s-%d: Invalid stats_coalesce_ticks parameter set with with adaptive_coalesce parameter. Using adaptive_coalesce.\n", bcm5700_driver, index);
4777	}else{
4778	if ((stats_coalesce_ticks[index] > 0) &&
4779	(stats_coalesce_ticks[index] < 100)) {
4780	printk(KERN_WARNING "%s-%d: Invalid stats_coalesce_ticks parameter (%u), using 100\n", bcm5700_driver, index, (unsigned int) stats_coalesce_ticks[index]);
4781	stats_coalesce_ticks[index] = 100;
4782	pDevice->StatsCoalescingTicks = stats_coalesce_ticks[index];
4783	pDevice->StatsCoalescingTicks = stats_coalesce_ticks[index];
4784	}
4785	}
4786	}
4787	else {
4788	pUmDevice->rx_curr_coalesce_frames = RX_COAL_FM;
4789	pUmDevice->rx_curr_coalesce_ticks = RX_COAL_TK;
4790	pUmDevice->tx_curr_coalesce_frames = TX_COAL_FM;
4791	}
4792	#endif
4793
4794	if (T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)) {
4795	unsigned int tmpvar;
4796
4797	tmpvar = pDevice->StatsCoalescingTicks / BCM_TIMER_GRANULARITY;
4798
4799	/*
4800	* If the result is zero, the request is too demanding.
4801	*/
4802	if (tmpvar == 0) {
4803	tmpvar = 1;
4804	}
4805
4806	pDevice->StatsCoalescingTicks = tmpvar * BCM_TIMER_GRANULARITY;
4807
4808	pUmDevice->statstimer_interval = tmpvar;
4809	}
4810
4811	#ifdef BCM_WOL
4812	bcm5700_validate_param_range(pUmDevice, &enable_wol[index],
4813	"enable_wol", 0, 1, 0);
4814	if (enable_wol[index]) {
4815	pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_MAGIC_PACKET;
4816	pDevice->WakeUpMode = LM_WAKE_UP_MODE_MAGIC_PACKET;
4817	}
4818	#endif
4819	#ifdef INCLUDE_TBI_SUPPORT
4820	if (pDevice->TbiFlags & ENABLE_TBI_FLAG) {
4821	if ((T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5704) \|\|
4822	(T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5703)) {
4823	/* just poll since we have hardware autoneg. in 5704 */
4824	pDevice->TbiFlags \|= TBI_PURE_POLLING_FLAG;
4825	}
4826	else {
4827	pDevice->TbiFlags \|= TBI_POLLING_INTR_FLAG;
4828	}
4829	}
4830	#endif
4831	bcm5700_validate_param_range(pUmDevice, &scatter_gather[index],
4832	"scatter_gather", 0, 1, 1);
4833	bcm5700_validate_param_range(pUmDevice, &tx_checksum[index],
4834	"tx_checksum", 0, 1, 1);
4835	bcm5700_validate_param_range(pUmDevice, &rx_checksum[index],
4836	"rx_checksum", 0, 1, 1);
4837	if (!(pDevice->TaskOffloadCap & LM_TASK_OFFLOAD_TX_TCP_CHECKSUM)) {
4838	if (tx_checksum[index] \|\| rx_checksum[index]) {
4839
4840	pDevice->TaskToOffload = LM_TASK_OFFLOAD_NONE;
4841	printk(KERN_WARNING "%s-%d: Checksum offload not available on this NIC\n", bcm5700_driver, index);
4842	}
4843	}
4844	else {
4845	if (rx_checksum[index]) {
4846	pDevice->TaskToOffload \|=
4847	LM_TASK_OFFLOAD_RX_TCP_CHECKSUM \|
4848	LM_TASK_OFFLOAD_RX_UDP_CHECKSUM;
4849	}
4850	if (tx_checksum[index]) {
4851	pDevice->TaskToOffload \|=
4852	LM_TASK_OFFLOAD_TX_TCP_CHECKSUM \|
4853	LM_TASK_OFFLOAD_TX_UDP_CHECKSUM;
4854	pDevice->Flags \|= NO_TX_PSEUDO_HDR_CSUM_FLAG;
4855	}
4856	}
4857	#ifdef BCM_TSO
4858	bcm5700_validate_param_range(pUmDevice, &enable_tso[index],
4859	"enable_tso", 0, 1, 1);
4860
4861	/* Always enable TSO firmware if supported */
4862	/* This way we can turn it on or off on the fly */
4863	if (pDevice->TaskOffloadCap & LM_TASK_OFFLOAD_TCP_SEGMENTATION)
4864	{
4865	pDevice->TaskToOffload \|=
4866	LM_TASK_OFFLOAD_TCP_SEGMENTATION;
4867	}
4868	if (enable_tso[index] &&
4869	!(pDevice->TaskToOffload & LM_TASK_OFFLOAD_TCP_SEGMENTATION))
4870	{
4871	printk(KERN_WARNING "%s-%d: TSO not available on this NIC\n", bcm5700_driver, index);
4872	}
4873	#endif
4874	#ifdef BCM_ASF
4875	bcm5700_validate_param_range(pUmDevice, &vlan_tag_mode[index],
4876	"vlan_strip_mode", 0, 2, 0);
4877	pUmDevice->vlan_tag_mode = vlan_tag_mode[index];
4878	#else
4879	pUmDevice->vlan_tag_mode = VLAN_TAG_MODE_NORMAL_STRIP;
4880	#endif
4881
4882	#endif /* LINUX_KERNEL_VERSION */
4883
4884	#ifdef BCM_NIC_SEND_BD
4885	bcm5700_validate_param_range(pUmDevice, &nic_tx_bd[index], "nic_tx_bd",
4886	0, 1, 0);
4887	if (nic_tx_bd[index])
4888	pDevice->Flags \|= NIC_SEND_BD_FLAG;
4889	if ((pDevice->Flags & ENABLE_PCIX_FIX_FLAG) \|\|
4890	(T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5705)) {
4891	if (pDevice->Flags & NIC_SEND_BD_FLAG) {
4892	pDevice->Flags &= ~NIC_SEND_BD_FLAG;
4893	printk(KERN_WARNING "%s-%d: Nic Send BDs not available on this NIC or not possible on this system\n", bcm5700_driver, index);
4894	}
4895	}
4896	#endif
4897	#if defined(CONFIG_PCI_MSI) \|\| defined(CONFIG_PCI_USE_VECTOR)
4898	bcm5700_validate_param_range(pUmDevice, &disable_msi[pUmDevice->index],
4899	"disable_msi", 0, 1, 0);
4900	#endif
4901
4902	bcm5700_validate_param_range(pUmDevice, &delay_link[index],
4903	"delay_link", 0, 1, 0);
4904
4905	bcm5700_validate_param_range(pUmDevice, &disable_d3hot[index],
4906	"disable_d3hot", 0, 1, 0);
4907	if (disable_d3hot[index]) {
4908
4909	#ifdef BCM_WOL
4910	if (enable_wol[index]) {
4911	pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_NONE;
4912	pDevice->WakeUpMode = LM_WAKE_UP_MODE_NONE;
4913	printk(KERN_WARNING "%s-%d: Wake-On-Lan disabled because D3Hot is disabled\n", bcm5700_driver, index);
4914	}
4915	#endif
4916	pDevice->Flags \|= DISABLE_D3HOT_FLAG;
4917	}
4918
4919	return LM_STATUS_SUCCESS;
4920	}
4921
4922	/* From include/proto/ethernet.h */
4923	#define ETHER_TYPE_8021Q 0x8100 /* 802.1Q */
4924
4925	/* From include/proto/vlan.h */
4926	#define VLAN_PRI_MASK 7 /* 3 bits of priority */
4927	#define VLAN_PRI_SHIFT 13
4928
4929	/* Replace the priority in a vlan tag */
4930	#define UPD_VLANTAG_PRIO(tag, prio) do { \
4931	tag &= ~(VLAN_PRI_MASK << VLAN_PRI_SHIFT); \
4932	tag \|= prio << VLAN_PRI_SHIFT; \
4933	} while (0)
4934
4935	/* Takes an Ethernet frame and sets out-of-bound PKTPRIO.
4936	* Also updates the inplace vlan tag if requested.
4937	* For debugging, it returns an indication of what it did.
4938	*/
4939	#define PKTPRIO_VDSCP 0x100 /* DSCP prio found after VLAN tag */
4940	#define PKTPRIO_VLAN 0x200 /* VLAN prio found */
4941	#define PKTPRIO_UPD 0x400 /* DSCP used to update VLAN prio */
4942	#define PKTPRIO_DSCP 0x800 /* DSCP prio found */
4943	#define PKTSETPRIO(skb, x) (((struct sk_buff*)(skb))->priority = (x))
4944	static uint
4945	pktsetprio(void *pkt, bool update_vtag)
4946	{
4947	struct ether_header *eh;
4948	struct ethervlan_header *evh;
4949	uint8 *pktdata;
4950	int priority = 0;
4951	int rc = 0;
4952
4953	pktdata = (uint8 *) PKTDATA(NULL, pkt);
4954	ASSERT(ISALIGNED((uintptr)pktdata, sizeof(uint16)));
4955
4956	eh = (struct ether_header *) pktdata;
4957
4958	if (ntoh16(eh->ether_type) == ETHER_TYPE_8021Q) {
4959	uint16 vlan_tag;
4960	int vlan_prio, dscp_prio = 0;
4961
4962	evh = (struct ethervlan_header *)eh;
4963
4964	vlan_tag = ntoh16(evh->vlan_tag);
4965	vlan_prio = (int) (vlan_tag >> VLAN_PRI_SHIFT) & VLAN_PRI_MASK;
4966
4967	if (ntoh16(evh->ether_type) == ETHER_TYPE_IP) {
4968	uint8 *ip_body = pktdata + sizeof(struct ethervlan_header);
4969	uint8 tos_tc = IP_TOS(ip_body);
4970	dscp_prio = (int)(tos_tc >> IPV4_TOS_PREC_SHIFT);
4971	if ((IP_VER(ip_body) == IP_VER_4) && (IPV4_PROT(ip_body) == IP_PROT_TCP)) {
4972	int ip_len;
4973	int src_port;
4974	bool src_port_exc;
4975	uint8 *tcp_hdr;
4976
4977	ip_len = IPV4_PAYLOAD_LEN(ip_body);
4978	tcp_hdr = IPV4_NO_OPTIONS_PAYLOAD(ip_body);
4979	src_port = TCP_SRC_PORT(tcp_hdr);
4980	src_port_exc = (src_port == 10110) \|\| (src_port == 10120) \|\|
4981	(src_port == 10130) \|\| (src_port == 10140);
4982
4983	if ((ip_len == 40) && src_port_exc && TCP_IS_ACK(tcp_hdr)) {
4984	dscp_prio = 7;
4985	}
4986	}
4987	}
4988
4989	/* DSCP priority gets precedence over 802.1P (vlan tag) */
4990	if (dscp_prio != 0) {
4991	priority = dscp_prio;
4992	rc \|= PKTPRIO_VDSCP;
4993	} else {
4994	priority = vlan_prio;
4995	rc \|= PKTPRIO_VLAN;
4996	}
4997	/*
4998	* If the DSCP priority is not the same as the VLAN priority,
4999	* then overwrite the priority field in the vlan tag, with the
5000	* DSCP priority value. This is required for Linux APs because
5001	* the VLAN driver on Linux, overwrites the skb->priority field
5002	* with the priority value in the vlan tag
5003	*/
5004	if (update_vtag && (priority != vlan_prio)) {
5005	vlan_tag &= ~(VLAN_PRI_MASK << VLAN_PRI_SHIFT);
5006	vlan_tag \|= (uint16)priority << VLAN_PRI_SHIFT;
5007	evh->vlan_tag = hton16(vlan_tag);
5008	rc \|= PKTPRIO_UPD;
5009	}
5010	} else if (ntoh16(eh->ether_type) == ETHER_TYPE_IP) {
5011	uint8 *ip_body = pktdata + sizeof(struct ether_header);
5012	uint8 tos_tc = IP_TOS(ip_body);
5013	priority = (int)(tos_tc >> IPV4_TOS_PREC_SHIFT);
5014	rc \|= PKTPRIO_DSCP;
5015	if ((IP_VER(ip_body) == IP_VER_4) && (IPV4_PROT(ip_body) == IP_PROT_TCP)) {
5016	int ip_len;
5017	int src_port;
5018	bool src_port_exc;
5019	uint8 *tcp_hdr;
5020
5021	ip_len = IPV4_PAYLOAD_LEN(ip_body);
5022	tcp_hdr = IPV4_NO_OPTIONS_PAYLOAD(ip_body);
5023	src_port = TCP_SRC_PORT(tcp_hdr);
5024	src_port_exc = (src_port == 10110) \|\| (src_port == 10120) \|\|
5025	(src_port == 10130) \|\| (src_port == 10140);
5026
5027	if ((ip_len == 40) && src_port_exc && TCP_IS_ACK(tcp_hdr)) {
5028	priority = 7;
5029	}
5030	}
5031	}
5032
5033	ASSERT(priority >= 0 && priority <= MAXPRIO);
5034	PKTSETPRIO(pkt, priority);
5035	return (rc \| priority);
5036	}
5037
5038	LM_STATUS
5039	MM_IndicateRxPackets(PLM_DEVICE_BLOCK pDevice)
5040	{
5041	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
5042	PLM_PACKET pPacket;
5043	PUM_PACKET pUmPacket;
5044	struct sk_buff *skb;
5045	int size;
5046	int vlan_tag_size = 0;
5047	uint16 dscp_prio;
5048
5049	if (pDevice->ReceiveMask & LM_KEEP_VLAN_TAG)
5050	vlan_tag_size = 4;
5051
5052	while (1) {
5053	pPacket = (PLM_PACKET)
5054	QQ_PopHead(&pDevice->RxPacketReceivedQ.Container);
5055	if (pPacket == 0)
5056	break;
5057	pUmPacket = (PUM_PACKET) pPacket;
5058	#if !defined(NO_PCI_UNMAP)
5059	pci_unmap_single(pUmDevice->pdev,
5060	pci_unmap_addr(pUmPacket, map[0]),
5061	pPacket->u.Rx.RxBufferSize,
5062	PCI_DMA_FROMDEVICE);
5063	#endif
5064	if ((pPacket->PacketStatus != LM_STATUS_SUCCESS) \|\|
5065	((size = pPacket->PacketSize) >
5066	(pDevice->RxMtu + vlan_tag_size))) {
5067
5068	/* reuse skb */
5069	#ifdef BCM_TASKLET
5070	QQ_PushTail(&pUmDevice->rx_out_of_buf_q.Container, pPacket);
5071	#else
5072	QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
5073	#endif
5074	pUmDevice->rx_misc_errors++;
5075	continue;
5076	}
5077	skb = pUmPacket->skbuff;
5078	skb_put(skb, size);
5079	skb->pkt_type = 0;
5080	/* Extract priority from payload and put it in skb->priority */
5081	dscp_prio = 0;
5082	if (pUmDevice->qos) {
5083	uint rc;
5084
5085	rc = pktsetprio(skb, TRUE);
5086	if (rc & (PKTPRIO_VDSCP \| PKTPRIO_DSCP))
5087	dscp_prio = rc & VLAN_PRI_MASK;
5088	if (rc != 0)
5089	B57_INFO(("pktsetprio returned 0x%x, skb->priority: %d\n",
5090	rc, skb->priority));
5091	}
5092	skb->protocol = eth_type_trans(skb, skb->dev);
5093	if (size > pDevice->RxMtu) {
5094	/* Make sure we have a valid VLAN tag */
5095	if (htons(skb->protocol) != ETHER_TYPE_8021Q) {
5096	dev_kfree_skb_irq(skb);
5097	pUmDevice->rx_misc_errors++;
5098	goto drop_rx;
5099	}
5100	}
5101
5102	pUmDevice->stats.rx_bytes += skb->len;
5103
5104	if ((pPacket->Flags & RCV_BD_FLAG_TCP_UDP_CHKSUM_FIELD) &&
5105	(pDevice->TaskToOffload &
5106	LM_TASK_OFFLOAD_RX_TCP_CHECKSUM)) {
5107	if (pPacket->u.Rx.TcpUdpChecksum == 0xffff) {
5108
5109	skb->ip_summed = CHECKSUM_UNNECESSARY;
5110	#if TIGON3_DEBUG
5111	pUmDevice->rx_good_chksum_count++;
5112	#endif
5113	}
5114	else {
5115	skb->ip_summed = CHECKSUM_NONE;
5116	pUmDevice->rx_bad_chksum_count++;
5117	}
5118	}
5119	else {
5120	skb->ip_summed = CHECKSUM_NONE;
5121	}
5122	{
5123	#ifdef BCM_VLAN
5124	if (pUmDevice->vlgrp &&
5125	(pPacket->Flags & RCV_BD_FLAG_VLAN_TAG)) {
5126	/* Override vlan priority with dscp priority */
5127	if (dscp_prio)
5128	UPD_VLANTAG_PRIO(pPacket->VlanTag, dscp_prio);
5129	#ifdef BCM_NAPI_RXPOLL
5130	vlan_hwaccel_receive_skb(skb, pUmDevice->vlgrp,
5131	pPacket->VlanTag);
5132	#else
5133	vlan_hwaccel_rx(skb, pUmDevice->vlgrp,
5134	pPacket->VlanTag);
5135	#endif
5136	} else
5137	#endif
5138	{
5139	#ifdef BCM_WL_EMULATOR
5140	if(pDevice->wl_emulate_rx) {
5141	/* bcmstats("emu recv %d %d"); */
5142	wlcemu_receive_skb(pDevice->wlc, skb);
5143	/* bcmstats("emu recv end %d %d"); */
5144	}
5145	else
5146	#endif /* BCM_WL_EMULATOR */
5147	{
5148	#ifdef BCM_NAPI_RXPOLL
5149	netif_receive_skb(skb);
5150	#else
5151	netif_rx(skb);
5152	#endif
5153	}
5154	}
5155	}
5156	pUmDevice->dev->last_rx = jiffies;
5157
5158	drop_rx:
5159	#ifdef BCM_TASKLET
5160	pUmPacket->skbuff = 0;
5161	QQ_PushTail(&pUmDevice->rx_out_of_buf_q.Container, pPacket);
5162	#else
5163	#ifdef BCM_WL_EMULATOR
5164	skb = (struct sk_buff *)wlcemu_pktget(pDevice->wlc,pPacket->u.Rx.RxBufferSize + 2);
5165	#else
5166	skb = dev_alloc_skb(pPacket->u.Rx.RxBufferSize + 2 + EXTRA_HDR);
5167	#endif /* BCM_WL_EMULATOR */
5168	if (skb == 0) {
5169	pUmPacket->skbuff = 0;
5170	QQ_PushTail(&pUmDevice->rx_out_of_buf_q.Container, pPacket);
5171	}
5172	else {
5173	pUmPacket->skbuff = skb;
5174	skb->dev = pUmDevice->dev;
5175	#ifndef BCM_WL_EMULATOR
5176	skb_reserve(skb, EXTRA_HDR - pUmDevice->rx_buf_align);
5177	#endif
5178	QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
5179	}
5180	#endif
5181	}
5182	return LM_STATUS_SUCCESS;
5183	}
5184
5185	LM_STATUS
5186	MM_CoalesceTxBuffer(PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket)
5187	{
5188	PUM_PACKET pUmPacket = (PUM_PACKET) pPacket;
5189	struct sk_buff *skb = pUmPacket->skbuff;
5190	struct sk_buff *nskb;
5191	#if !defined(NO_PCI_UNMAP)
5192	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
5193
5194	pci_unmap_single(pUmDevice->pdev,
5195	pci_unmap_addr(pUmPacket, map[0]),
5196	pci_unmap_len(pUmPacket, map_len[0]),
5197	PCI_DMA_TODEVICE);
5198	#if MAX_SKB_FRAGS
5199	{
5200	int i;
5201
5202	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
5203	pci_unmap_page(pUmDevice->pdev,
5204	pci_unmap_addr(pUmPacket, map[i + 1]),
5205	pci_unmap_len(pUmPacket, map_len[i + 1]),
5206	PCI_DMA_TODEVICE);
5207	}
5208	}
5209	#endif
5210	#endif
5211	if ((nskb = skb_copy(skb, GFP_ATOMIC))) {
5212	pUmPacket->lm_packet.u.Tx.FragCount = 1;
5213	dev_kfree_skb(skb);
5214	pUmPacket->skbuff = nskb;
5215	return LM_STATUS_SUCCESS;
5216	}
5217	dev_kfree_skb(skb);
5218	pUmPacket->skbuff = 0;
5219	return LM_STATUS_FAILURE;
5220	}
5221
5222	/* Returns 1 if not all buffers are allocated */
5223	STATIC int
5224	replenish_rx_buffers(PUM_DEVICE_BLOCK pUmDevice, int max)
5225	{
5226	PLM_PACKET pPacket;
5227	PUM_PACKET pUmPacket;
5228	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
5229	struct sk_buff *skb;
5230	int queue_rx = 0;
5231	int alloc_cnt = 0;
5232	int ret = 0;
5233
5234	while ((pUmPacket = (PUM_PACKET)
5235	QQ_PopHead(&pUmDevice->rx_out_of_buf_q.Container)) != 0) {
5236	pPacket = (PLM_PACKET) pUmPacket;
5237	if (pUmPacket->skbuff) {
5238	/* reuse an old skb */
5239	QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
5240	queue_rx = 1;
5241	continue;
5242	}
5243	#ifdef BCM_WL_EMULATOR
5244	if ((skb = (struct sk_buff *)wlcemu_pktget(pDevice->wlc,pPacket->u.Rx.RxBufferSize + 2)) == 0)
5245	#else
5246	if ((skb = dev_alloc_skb(pPacket->u.Rx.RxBufferSize + 2 + EXTRA_HDR)) == 0)
5247	#endif /* BCM_WL_EMULATOR */
5248	{
5249	QQ_PushHead(&pUmDevice->rx_out_of_buf_q.Container,
5250	pPacket);
5251	ret = 1;
5252	break;
5253	}
5254	pUmPacket->skbuff = skb;
5255	skb->dev = pUmDevice->dev;
5256	#ifndef BCM_WL_EMULATOR
5257	skb_reserve(skb, EXTRA_HDR - pUmDevice->rx_buf_align);
5258	#endif
5259	QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
5260	queue_rx = 1;
5261	if (max > 0) {
5262	alloc_cnt++;
5263	if (alloc_cnt >= max)
5264	break;
5265	}
5266	}
5267	if (queue_rx \|\| pDevice->QueueAgain) {
5268	LM_QueueRxPackets(pDevice);
5269	}
5270	return ret;
5271	}
5272
5273	LM_STATUS
5274	MM_IndicateTxPackets(PLM_DEVICE_BLOCK pDevice)
5275	{
5276	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
5277	PLM_PACKET pPacket;
5278	PUM_PACKET pUmPacket;
5279	struct sk_buff *skb;
5280	#if !defined(NO_PCI_UNMAP) && MAX_SKB_FRAGS
5281	int i;
5282	#endif
5283
5284	while (1) {
5285	pPacket = (PLM_PACKET)
5286	QQ_PopHead(&pDevice->TxPacketXmittedQ.Container);
5287	if (pPacket == 0)
5288	break;
5289	pUmPacket = (PUM_PACKET) pPacket;
5290	skb = pUmPacket->skbuff;
5291	#if !defined(NO_PCI_UNMAP)
5292	pci_unmap_single(pUmDevice->pdev,
5293	pci_unmap_addr(pUmPacket, map[0]),
5294	pci_unmap_len(pUmPacket, map_len[0]),
5295	PCI_DMA_TODEVICE);
5296	#if MAX_SKB_FRAGS
5297	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
5298	pci_unmap_page(pUmDevice->pdev,
5299	pci_unmap_addr(pUmPacket, map[i + 1]),
5300	pci_unmap_len(pUmPacket, map_len[i + 1]),
5301	PCI_DMA_TODEVICE);
5302	}
5303	#endif
5304	#endif
5305	dev_kfree_skb_irq(skb);
5306	pUmPacket->skbuff = 0;
5307	QQ_PushTail(&pDevice->TxPacketFreeQ.Container, pPacket);
5308	}
5309	if (pUmDevice->tx_full) {
5310	if (QQ_GetEntryCnt(&pDevice->TxPacketFreeQ.Container) >=
5311	(pDevice->TxPacketDescCnt >> 1)) {
5312
5313	pUmDevice->tx_full = 0;
5314	netif_wake_queue(pUmDevice->dev);
5315	}
5316	}
5317	return LM_STATUS_SUCCESS;
5318	}
5319
5320	LM_STATUS
5321	MM_IndicateStatus(PLM_DEVICE_BLOCK pDevice, LM_STATUS Status)
5322	{
5323	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
5324	struct net_device *dev = pUmDevice->dev;
5325	LM_FLOW_CONTROL flow_control;
5326	int speed = 0;
5327
5328	if (!pUmDevice->opened)
5329	return LM_STATUS_SUCCESS;
5330
5331	if (!pUmDevice->suspended) {
5332	if (Status == LM_STATUS_LINK_DOWN) {
5333	netif_carrier_off(dev);
5334	}
5335	else if (Status == LM_STATUS_LINK_ACTIVE) {
5336	netif_carrier_on(dev);
5337	}
5338	}
5339
5340	if (pUmDevice->delayed_link_ind > 0) {
5341	pUmDevice->delayed_link_ind = 0;
5342	if (Status == LM_STATUS_LINK_DOWN) {
5343	B57_INFO(("%s: %s NIC Link is DOWN\n", bcm5700_driver, dev->name));
5344	}
5345	else if (Status == LM_STATUS_LINK_ACTIVE) {
5346	B57_INFO(("%s: %s NIC Link is UP, ", bcm5700_driver, dev->name));
5347	}
5348	}
5349	else {
5350	if (Status == LM_STATUS_LINK_DOWN) {
5351	B57_INFO(("%s: %s NIC Link is Down\n", bcm5700_driver, dev->name));
5352	}
5353	else if (Status == LM_STATUS_LINK_ACTIVE) {
5354	B57_INFO(("%s: %s NIC Link is Up, ", bcm5700_driver, dev->name));
5355	}
5356	}
5357
5358	if (Status == LM_STATUS_LINK_ACTIVE) {
5359	if (pDevice->LineSpeed == LM_LINE_SPEED_1000MBPS)
5360	speed = 1000;
5361	else if (pDevice->LineSpeed == LM_LINE_SPEED_100MBPS)
5362	speed = 100;
5363	else if (pDevice->LineSpeed == LM_LINE_SPEED_10MBPS)
5364	speed = 10;
5365
5366	B57_INFO(("%d Mbps ", speed));
5367
5368	if (pDevice->DuplexMode == LM_DUPLEX_MODE_FULL)
5369	B57_INFO(("full duplex"));
5370	else
5371	B57_INFO(("half duplex"));
5372
5373	flow_control = pDevice->FlowControl &
5374	(LM_FLOW_CONTROL_RECEIVE_PAUSE \|
5375	LM_FLOW_CONTROL_TRANSMIT_PAUSE);
5376	if (flow_control) {
5377	if (flow_control & LM_FLOW_CONTROL_RECEIVE_PAUSE) {
5378	B57_INFO((", receive "));
5379	if (flow_control & LM_FLOW_CONTROL_TRANSMIT_PAUSE)
5380	B57_INFO(("& transmit "));
5381	}
5382	else {
5383	B57_INFO((", transmit "));
5384	}
5385	B57_INFO(("flow control ON"));
5386	}
5387	B57_INFO(("\n"));
5388	}
5389	return LM_STATUS_SUCCESS;
5390	}
5391
5392	void
5393	MM_UnmapRxDma(LM_DEVICE_BLOCK pDevice, LM_PACKET pPacket)
5394	{
5395	#if !defined(NO_PCI_UNMAP)
5396	UM_DEVICE_BLOCK pUmDevice = (UM_DEVICE_BLOCK ) pDevice;
5397	UM_PACKET pUmPacket = (UM_PACKET ) pPacket;
5398
5399	if (!pUmPacket->skbuff)
5400	return;
5401
5402	pci_unmap_single(pUmDevice->pdev,
5403	pci_unmap_addr(pUmPacket, map[0]),
5404	pPacket->u.Rx.RxBufferSize,
5405	PCI_DMA_FROMDEVICE);
5406	#endif
5407	}
5408
5409	LM_STATUS
5410	MM_FreeRxBuffer(PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket)
5411	{
5412	PUM_PACKET pUmPacket;
5413	struct sk_buff *skb;
5414
5415	if (pPacket == 0)
5416	return LM_STATUS_SUCCESS;
5417	pUmPacket = (PUM_PACKET) pPacket;
5418	if ((skb = pUmPacket->skbuff)) {
5419	/* DMA address already unmapped */
5420	dev_kfree_skb(skb);
5421	}
5422	pUmPacket->skbuff = 0;
5423	return LM_STATUS_SUCCESS;
5424	}
5425
5426	LM_STATUS
5427	MM_Sleep(LM_DEVICE_BLOCK *pDevice, LM_UINT32 msec)
5428	{
5429	current->state = TASK_INTERRUPTIBLE;
5430	if (schedule_timeout(HZ * msec / 1000) != 0) {
5431	return LM_STATUS_FAILURE;
5432	}
5433	if (signal_pending(current))
5434	return LM_STATUS_FAILURE;
5435
5436	return LM_STATUS_SUCCESS;
5437	}
5438
5439	void
5440	bcm5700_shutdown(UM_DEVICE_BLOCK *pUmDevice)
5441	{
5442	LM_DEVICE_BLOCK pDevice = (LM_DEVICE_BLOCK ) pUmDevice;
5443
5444	bcm5700_intr_off(pUmDevice);
5445	netif_carrier_off(pUmDevice->dev);
5446	#ifdef BCM_TASKLET
5447	tasklet_kill(&pUmDevice->tasklet);
5448	#endif
5449	bcm5700_poll_wait(pUmDevice);
5450
5451	LM_Halt(pDevice);
5452
5453	pDevice->InitDone = 0;
5454	bcm5700_free_remaining_rx_bufs(pUmDevice);
5455	}
5456
5457	void
5458	bcm5700_free_remaining_rx_bufs(UM_DEVICE_BLOCK *pUmDevice)
5459	{
5460	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
5461	UM_PACKET *pUmPacket;
5462	int cnt, i;
5463
5464	cnt = QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container);
5465	for (i = 0; i < cnt; i++) {
5466	if ((pUmPacket =
5467	QQ_PopHead(&pUmDevice->rx_out_of_buf_q.Container))
5468	!= 0) {
5469
5470	MM_UnmapRxDma(pDevice, (LM_PACKET *) pUmPacket);
5471	MM_FreeRxBuffer(pDevice, &pUmPacket->lm_packet);
5472	QQ_PushTail(&pDevice->RxPacketFreeQ.Container,
5473	pUmPacket);
5474	}
5475	}
5476	}
5477
5478	void
5479	bcm5700_validate_param_range(UM_DEVICE_BLOCK pUmDevice, int param,
5480	char *param_name, int min, int max, int deflt)
5481	{
5482	if (((unsigned int) *param < (unsigned int) min) \|\|
5483	((unsigned int) *param > (unsigned int) max)) {
5484
5485	printk(KERN_WARNING "%s-%d: Invalid %s parameter (%u), using %u\n", bcm5700_driver, pUmDevice->index, param_name, (unsigned int) *param, (unsigned int) deflt);
5486	*param = deflt;
5487	}
5488	}
5489
5490	struct net_device *
5491	bcm5700_find_peer(struct net_device *dev)
5492	{
5493	struct net_device *tmp_dev;
5494	UM_DEVICE_BLOCK pUmDevice, pUmTmp;
5495	LM_DEVICE_BLOCK *pDevice;
5496
5497	tmp_dev = 0;
5498	pUmDevice = (UM_DEVICE_BLOCK *) dev->priv;
5499	pDevice = &pUmDevice->lm_dev;
5500	if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5704) {
5501	tmp_dev = root_tigon3_dev;
5502	while (tmp_dev) {
5503	pUmTmp = (PUM_DEVICE_BLOCK) tmp_dev->priv;
5504	if ((tmp_dev != dev) &&
5505	(pUmDevice->pdev->bus->number ==
5506	pUmTmp->pdev->bus->number) &&
5507	PCI_SLOT(pUmDevice->pdev->devfn) ==
5508	PCI_SLOT(pUmTmp->pdev->devfn)) {
5509
5510	break;
5511	}
5512	tmp_dev = pUmTmp->next_module;
5513	}
5514	}
5515	return tmp_dev;
5516	}
5517
5518	LM_DEVICE_BLOCK *
5519	MM_FindPeerDev(LM_DEVICE_BLOCK *pDevice)
5520	{
5521	UM_DEVICE_BLOCK pUmDevice = (UM_DEVICE_BLOCK ) pDevice;
5522	struct net_device *dev = pUmDevice->dev;
5523	struct net_device *peer_dev;
5524
5525	peer_dev = bcm5700_find_peer(dev);
5526	if (!peer_dev)
5527	return 0;
5528	return ((LM_DEVICE_BLOCK *) peer_dev->priv);
5529	}
5530
5531	int MM_FindCapability(LM_DEVICE_BLOCK *pDevice, int capability)
5532	{
5533	UM_DEVICE_BLOCK pUmDevice = (UM_DEVICE_BLOCK ) pDevice;
5534	return (pci_find_capability(pUmDevice->pdev, capability));
5535	}
5536
5537	#if defined(HAVE_POLL_CONTROLLER)\|\|defined(CONFIG_NET_POLL_CONTROLLER)
5538	STATIC void
5539	poll_bcm5700(struct net_device *dev)
5540	{
5541	UM_DEVICE_BLOCK *pUmDevice = dev->priv;
5542
5543	#if defined(RED_HAT_LINUX_KERNEL) && (LINUX_VERSION_CODE < 0x020605)
5544	if (netdump_mode) {
5545	bcm5700_interrupt(pUmDevice->pdev->irq, dev, NULL);
5546	#ifdef BCM_NAPI_RXPOLL
5547	if (dev->poll_list.prev) {
5548	int budget = 64;
5549
5550	bcm5700_poll(dev, &budget);
5551	}
5552	#endif
5553	}
5554	else
5555	#endif
5556	{
5557	disable_irq(pUmDevice->pdev->irq);
5558	bcm5700_interrupt(pUmDevice->pdev->irq, dev, NULL);
5559	enable_irq(pUmDevice->pdev->irq);
5560	}
5561	}
5562	#endif
5563

Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl

OpenWrt XBurst

OpenWrt XBurst Git Source Tree

Root/package/broadcom-57xx/src/b57um.c

interactive