?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: be more explicit in __put_user_x.
[linux-2.6/linux-loongson.git] / drivers / net / tg3.c
blobcc4bde8525421e614c90a49acd60ef8bed66f30c
1 /*
2 * tg3.c: Broadcom Tigon3 ethernet driver.
3 *
4 * Copyright (C) 2001, 2002, 2003, 2004 David S. Miller (davem@redhat.com)
5 * Copyright (C) 2001, 2002, 2003 Jeff Garzik (jgarzik@pobox.com)
6 * Copyright (C) 2004 Sun Microsystems Inc.
7 * Copyright (C) 2005-2007 Broadcom Corporation.
8 *
9 * Firmware is:
10 * Derived from proprietary unpublished source code,
11 * Copyright (C) 2000-2003 Broadcom Corporation.
12 *
13 * Permission is hereby granted for the distribution of this firmware
14 * data in hexadecimal or equivalent format, provided this copyright
15 * notice is accompanying it.
16 */
17
18
19 #include <linux/module.h>
20 #include <linux/moduleparam.h>
21 #include <linux/kernel.h>
22 #include <linux/types.h>
23 #include <linux/compiler.h>
24 #include <linux/slab.h>
25 #include <linux/delay.h>
26 #include <linux/in.h>
27 #include <linux/init.h>
28 #include <linux/ioport.h>
29 #include <linux/pci.h>
30 #include <linux/netdevice.h>
31 #include <linux/etherdevice.h>
32 #include <linux/skbuff.h>
33 #include <linux/ethtool.h>
34 #include <linux/mii.h>
35 #include <linux/if_vlan.h>
36 #include <linux/ip.h>
37 #include <linux/tcp.h>
38 #include <linux/workqueue.h>
39 #include <linux/prefetch.h>
40 #include <linux/dma-mapping.h>
41
42 #include <net/checksum.h>
43 #include <net/ip.h>
44
45 #include <asm/system.h>
46 #include <asm/io.h>
47 #include <asm/byteorder.h>
48 #include <asm/uaccess.h>
49
50 #ifdef CONFIG_SPARC
51 #include <asm/idprom.h>
52 #include <asm/prom.h>
53 #endif
54
55 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
56 #define TG3_VLAN_TAG_USED 1
57 #else
58 #define TG3_VLAN_TAG_USED 0
59 #endif
60
61 #define TG3_TSO_SUPPORT 1
62
63 #include "tg3.h"
64
65 #define DRV_MODULE_NAME "tg3"
66 #define PFX DRV_MODULE_NAME ": "
67 #define DRV_MODULE_VERSION "3.92.1"
68 #define DRV_MODULE_RELDATE "June 9, 2008"
69
70 #define TG3_DEF_MAC_MODE 0
71 #define TG3_DEF_RX_MODE 0
72 #define TG3_DEF_TX_MODE 0
73 #define TG3_DEF_MSG_ENABLE \
74 (NETIF_MSG_DRV | \
75 NETIF_MSG_PROBE | \
76 NETIF_MSG_LINK | \
77 NETIF_MSG_TIMER | \
78 NETIF_MSG_IFDOWN | \
79 NETIF_MSG_IFUP | \
80 NETIF_MSG_RX_ERR | \
81 NETIF_MSG_TX_ERR)
82
83 /* length of time before we decide the hardware is borked,
84 * and dev->tx_timeout() should be called to fix the problem
85 */
86 #define TG3_TX_TIMEOUT (5 * HZ)
87
88 /* hardware minimum and maximum for a single frame's data payload */
89 #define TG3_MIN_MTU 60
90 #define TG3_MAX_MTU(tp) \
91 ((tp->tg3_flags2 & TG3_FLG2_JUMBO_CAPABLE) ? 9000 : 1500)
92
93 /* These numbers seem to be hard coded in the NIC firmware somehow.
94 * You can't change the ring sizes, but you can change where you place
95 * them in the NIC onboard memory.
96 */
97 #define TG3_RX_RING_SIZE 512
98 #define TG3_DEF_RX_RING_PENDING 200
99 #define TG3_RX_JUMBO_RING_SIZE 256
100 #define TG3_DEF_RX_JUMBO_RING_PENDING 100
101
102 /* Do not place this n-ring entries value into the tp struct itself,
103 * we really want to expose these constants to GCC so that modulo et
104 * al. operations are done with shifts and masks instead of with
105 * hw multiply/modulo instructions. Another solution would be to
106 * replace things like '% foo' with '& (foo - 1)'.
107 */
108 #define TG3_RX_RCB_RING_SIZE(tp) \
109 ((tp->tg3_flags2 & TG3_FLG2_5705_PLUS) ? 512 : 1024)
110
111 #define TG3_TX_RING_SIZE 512
112 #define TG3_DEF_TX_RING_PENDING (TG3_TX_RING_SIZE - 1)
113
114 #define TG3_RX_RING_BYTES (sizeof(struct tg3_rx_buffer_desc) * \
115 TG3_RX_RING_SIZE)
116 #define TG3_RX_JUMBO_RING_BYTES (sizeof(struct tg3_rx_buffer_desc) * \
117 TG3_RX_JUMBO_RING_SIZE)
118 #define TG3_RX_RCB_RING_BYTES(tp) (sizeof(struct tg3_rx_buffer_desc) * \
119 TG3_RX_RCB_RING_SIZE(tp))
120 #define TG3_TX_RING_BYTES (sizeof(struct tg3_tx_buffer_desc) * \
121 TG3_TX_RING_SIZE)
122 #define NEXT_TX(N) (((N) + 1) & (TG3_TX_RING_SIZE - 1))
123
124 #define RX_PKT_BUF_SZ (1536 + tp->rx_offset + 64)
125 #define RX_JUMBO_PKT_BUF_SZ (9046 + tp->rx_offset + 64)
126
127 /* minimum number of free TX descriptors required to wake up TX process */
128 #define TG3_TX_WAKEUP_THRESH(tp) ((tp)->tx_pending / 4)
129
130 /* number of ETHTOOL_GSTATS u64's */
131 #define TG3_NUM_STATS (sizeof(struct tg3_ethtool_stats)/sizeof(u64))
132
133 #define TG3_NUM_TEST 6
134
135 static char version[] __devinitdata =
136 DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
137
138 MODULE_AUTHOR("David S. Miller (davem@redhat.com) and Jeff Garzik (jgarzik@pobox.com)");
139 MODULE_DESCRIPTION("Broadcom Tigon3 ethernet driver");
140 MODULE_LICENSE("GPL");
141 MODULE_VERSION(DRV_MODULE_VERSION);
142
143 static int tg3_debug = -1; /* -1 == use TG3_DEF_MSG_ENABLE as value */
144 module_param(tg3_debug, int, 0);
145 MODULE_PARM_DESC(tg3_debug, "Tigon3 bitmapped debugging message enable value");
146
147 static struct pci_device_id tg3_pci_tbl[] = {
148 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5700)},
149 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5701)},
150 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702)},
151 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5703)},
152 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5704)},
153 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702FE)},
154 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705)},
155 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705_2)},
156 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705M)},
157 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705M_2)},
158 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702X)},
159 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5703X)},
160 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5704S)},
161 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702A3)},
162 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5703A3)},
163 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5782)},
164 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5788)},
165 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5789)},
166 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5901)},
167 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5901_2)},
168 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5704S_2)},
169 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705F)},
170 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5720)},
171 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5721)},
172 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5722)},
173 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5750)},
174 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5751)},
175 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5750M)},
176 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5751M)},
177 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5751F)},
178 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5752)},
179 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5752M)},
180 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753)},
181 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753M)},
182 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753F)},
183 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5754)},
184 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5754M)},
185 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5755)},
186 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5755M)},
187 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5756)},
188 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5786)},
189 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787)},
190 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787M)},
191 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787F)},
192 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5714)},
193 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5714S)},
194 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5715)},
195 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5715S)},
196 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5780)},
197 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5780S)},
198 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5781)},
199 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5906)},
200 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5906M)},
201 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5784)},
202 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5764)},
203 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5723)},
204 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5761)},
205 {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5761E)},
206 {PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_9DXX)},
207 {PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_9MXX)},
208 {PCI_DEVICE(PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC1000)},
209 {PCI_DEVICE(PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC1001)},
210 {PCI_DEVICE(PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC1003)},
211 {PCI_DEVICE(PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC9100)},
212 {PCI_DEVICE(PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_TIGON3)},
213 {}
214 };
215
216 MODULE_DEVICE_TABLE(pci, tg3_pci_tbl);
217
218 static const struct {
219 const char string[ETH_GSTRING_LEN];
220 } ethtool_stats_keys[TG3_NUM_STATS] = {
221 { "rx_octets" },
222 { "rx_fragments" },
223 { "rx_ucast_packets" },
224 { "rx_mcast_packets" },
225 { "rx_bcast_packets" },
226 { "rx_fcs_errors" },
227 { "rx_align_errors" },
228 { "rx_xon_pause_rcvd" },
229 { "rx_xoff_pause_rcvd" },
230 { "rx_mac_ctrl_rcvd" },
231 { "rx_xoff_entered" },
232 { "rx_frame_too_long_errors" },
233 { "rx_jabbers" },
234 { "rx_undersize_packets" },
235 { "rx_in_length_errors" },
236 { "rx_out_length_errors" },
237 { "rx_64_or_less_octet_packets" },
238 { "rx_65_to_127_octet_packets" },
239 { "rx_128_to_255_octet_packets" },
240 { "rx_256_to_511_octet_packets" },
241 { "rx_512_to_1023_octet_packets" },
242 { "rx_1024_to_1522_octet_packets" },
243 { "rx_1523_to_2047_octet_packets" },
244 { "rx_2048_to_4095_octet_packets" },
245 { "rx_4096_to_8191_octet_packets" },
246 { "rx_8192_to_9022_octet_packets" },
247
248 { "tx_octets" },
249 { "tx_collisions" },
250
251 { "tx_xon_sent" },
252 { "tx_xoff_sent" },
253 { "tx_flow_control" },
254 { "tx_mac_errors" },
255 { "tx_single_collisions" },
256 { "tx_mult_collisions" },
257 { "tx_deferred" },
258 { "tx_excessive_collisions" },
259 { "tx_late_collisions" },
260 { "tx_collide_2times" },
261 { "tx_collide_3times" },
262 { "tx_collide_4times" },
263 { "tx_collide_5times" },
264 { "tx_collide_6times" },
265 { "tx_collide_7times" },
266 { "tx_collide_8times" },
267 { "tx_collide_9times" },
268 { "tx_collide_10times" },
269 { "tx_collide_11times" },
270 { "tx_collide_12times" },
271 { "tx_collide_13times" },
272 { "tx_collide_14times" },
273 { "tx_collide_15times" },
274 { "tx_ucast_packets" },
275 { "tx_mcast_packets" },
276 { "tx_bcast_packets" },
277 { "tx_carrier_sense_errors" },
278 { "tx_discards" },
279 { "tx_errors" },
280
281 { "dma_writeq_full" },
282 { "dma_write_prioq_full" },
283 { "rxbds_empty" },
284 { "rx_discards" },
285 { "rx_errors" },
286 { "rx_threshold_hit" },
287
288 { "dma_readq_full" },
289 { "dma_read_prioq_full" },
290 { "tx_comp_queue_full" },
291
292 { "ring_set_send_prod_index" },
293 { "ring_status_update" },
294 { "nic_irqs" },
295 { "nic_avoided_irqs" },
296 { "nic_tx_threshold_hit" }
297 };
298
299 static const struct {
300 const char string[ETH_GSTRING_LEN];
301 } ethtool_test_keys[TG3_NUM_TEST] = {
302 { "nvram test (online) " },
303 { "link test (online) " },
304 { "register test (offline)" },
305 { "memory test (offline)" },
306 { "loopback test (offline)" },
307 { "interrupt test (offline)" },
308 };
309
310 static void tg3_write32(struct tg3 *tp, u32 off, u32 val)
311 {
312 writel(val, tp->regs + off);
313 }
314
315 static u32 tg3_read32(struct tg3 *tp, u32 off)
316 {
317 return (readl(tp->regs + off));
318 }
319
320 static void tg3_ape_write32(struct tg3 *tp, u32 off, u32 val)
321 {
322 writel(val, tp->aperegs + off);
323 }
324
325 static u32 tg3_ape_read32(struct tg3 *tp, u32 off)
326 {
327 return (readl(tp->aperegs + off));
328 }
329
330 static void tg3_write_indirect_reg32(struct tg3 *tp, u32 off, u32 val)
331 {
332 unsigned long flags;
333
334 spin_lock_irqsave(&tp->indirect_lock, flags);
335 pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off);
336 pci_write_config_dword(tp->pdev, TG3PCI_REG_DATA, val);
337 spin_unlock_irqrestore(&tp->indirect_lock, flags);
338 }
339
340 static void tg3_write_flush_reg32(struct tg3 *tp, u32 off, u32 val)
341 {
342 writel(val, tp->regs + off);
343 readl(tp->regs + off);
344 }
345
346 static u32 tg3_read_indirect_reg32(struct tg3 *tp, u32 off)
347 {
348 unsigned long flags;
349 u32 val;
350
351 spin_lock_irqsave(&tp->indirect_lock, flags);
352 pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off);
353 pci_read_config_dword(tp->pdev, TG3PCI_REG_DATA, &val);
354 spin_unlock_irqrestore(&tp->indirect_lock, flags);
355 return val;
356 }
357
358 static void tg3_write_indirect_mbox(struct tg3 *tp, u32 off, u32 val)
359 {
360 unsigned long flags;
361
362 if (off == (MAILBOX_RCVRET_CON_IDX_0 + TG3_64BIT_REG_LOW)) {
363 pci_write_config_dword(tp->pdev, TG3PCI_RCV_RET_RING_CON_IDX +
364 TG3_64BIT_REG_LOW, val);
365 return;
366 }
367 if (off == (MAILBOX_RCV_STD_PROD_IDX + TG3_64BIT_REG_LOW)) {
368 pci_write_config_dword(tp->pdev, TG3PCI_STD_RING_PROD_IDX +
369 TG3_64BIT_REG_LOW, val);
370 return;
371 }
372
373 spin_lock_irqsave(&tp->indirect_lock, flags);
374 pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off + 0x5600);
375 pci_write_config_dword(tp->pdev, TG3PCI_REG_DATA, val);
376 spin_unlock_irqrestore(&tp->indirect_lock, flags);
377
378 /* In indirect mode when disabling interrupts, we also need
379 * to clear the interrupt bit in the GRC local ctrl register.
380 */
381 if ((off == (MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW)) &&
382 (val == 0x1)) {
383 pci_write_config_dword(tp->pdev, TG3PCI_MISC_LOCAL_CTRL,
384 tp->grc_local_ctrl|GRC_LCLCTRL_CLEARINT);
385 }
386 }
387
388 static u32 tg3_read_indirect_mbox(struct tg3 *tp, u32 off)
389 {
390 unsigned long flags;
391 u32 val;
392
393 spin_lock_irqsave(&tp->indirect_lock, flags);
394 pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off + 0x5600);
395 pci_read_config_dword(tp->pdev, TG3PCI_REG_DATA, &val);
396 spin_unlock_irqrestore(&tp->indirect_lock, flags);
397 return val;
398 }
399
400 /* usec_wait specifies the wait time in usec when writing to certain registers
401 * where it is unsafe to read back the register without some delay.
402 * GRC_LOCAL_CTRL is one example if the GPIOs are toggled to switch power.
403 * TG3PCI_CLOCK_CTRL is another example if the clock frequencies are changed.
404 */
405 static void _tw32_flush(struct tg3 *tp, u32 off, u32 val, u32 usec_wait)
406 {
407 if ((tp->tg3_flags & TG3_FLAG_PCIX_TARGET_HWBUG) ||
408 (tp->tg3_flags2 & TG3_FLG2_ICH_WORKAROUND))
409 /* Non-posted methods */
410 tp->write32(tp, off, val);
411 else {
412 /* Posted method */
413 tg3_write32(tp, off, val);
414 if (usec_wait)
415 udelay(usec_wait);
416 tp->read32(tp, off);
417 }
418 /* Wait again after the read for the posted method to guarantee that
419 * the wait time is met.
420 */
421 if (usec_wait)
422 udelay(usec_wait);
423 }
424
425 static inline void tw32_mailbox_flush(struct tg3 *tp, u32 off, u32 val)
426 {
427 tp->write32_mbox(tp, off, val);
428 if (!(tp->tg3_flags & TG3_FLAG_MBOX_WRITE_REORDER) &&
429 !(tp->tg3_flags2 & TG3_FLG2_ICH_WORKAROUND))
430 tp->read32_mbox(tp, off);
431 }
432
433 static void tg3_write32_tx_mbox(struct tg3 *tp, u32 off, u32 val)
434 {
435 void __iomem *mbox = tp->regs + off;
436 writel(val, mbox);
437 if (tp->tg3_flags & TG3_FLAG_TXD_MBOX_HWBUG)
438 writel(val, mbox);
439 if (tp->tg3_flags & TG3_FLAG_MBOX_WRITE_REORDER)
440 readl(mbox);
441 }
442
443 static u32 tg3_read32_mbox_5906(struct tg3 *tp, u32 off)
444 {
445 return (readl(tp->regs + off + GRCMBOX_BASE));
446 }
447
448 static void tg3_write32_mbox_5906(struct tg3 *tp, u32 off, u32 val)
449 {
450 writel(val, tp->regs + off + GRCMBOX_BASE);
451 }
452
453 #define tw32_mailbox(reg, val) tp->write32_mbox(tp, reg, val)
454 #define tw32_mailbox_f(reg, val) tw32_mailbox_flush(tp, (reg), (val))
455 #define tw32_rx_mbox(reg, val) tp->write32_rx_mbox(tp, reg, val)
456 #define tw32_tx_mbox(reg, val) tp->write32_tx_mbox(tp, reg, val)
457 #define tr32_mailbox(reg) tp->read32_mbox(tp, reg)
458
459 #define tw32(reg,val) tp->write32(tp, reg, val)
460 #define tw32_f(reg,val) _tw32_flush(tp,(reg),(val), 0)
461 #define tw32_wait_f(reg,val,us) _tw32_flush(tp,(reg),(val), (us))
462 #define tr32(reg) tp->read32(tp, reg)
463
464 static void tg3_write_mem(struct tg3 *tp, u32 off, u32 val)
465 {
466 unsigned long flags;
467
468 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) &&
469 (off >= NIC_SRAM_STATS_BLK) && (off < NIC_SRAM_TX_BUFFER_DESC))
470 return;
471
472 spin_lock_irqsave(&tp->indirect_lock, flags);
473 if (tp->tg3_flags & TG3_FLAG_SRAM_USE_CONFIG) {
474 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, off);
475 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_DATA, val);
476
477 /* Always leave this as zero. */
478 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, 0);
479 } else {
480 tw32_f(TG3PCI_MEM_WIN_BASE_ADDR, off);
481 tw32_f(TG3PCI_MEM_WIN_DATA, val);
482
483 /* Always leave this as zero. */
484 tw32_f(TG3PCI_MEM_WIN_BASE_ADDR, 0);
485 }
486 spin_unlock_irqrestore(&tp->indirect_lock, flags);
487 }
488
489 static void tg3_read_mem(struct tg3 *tp, u32 off, u32 *val)
490 {
491 unsigned long flags;
492
493 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) &&
494 (off >= NIC_SRAM_STATS_BLK) && (off < NIC_SRAM_TX_BUFFER_DESC)) {
495 *val = 0;
496 return;
497 }
498
499 spin_lock_irqsave(&tp->indirect_lock, flags);
500 if (tp->tg3_flags & TG3_FLAG_SRAM_USE_CONFIG) {
501 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, off);
502 pci_read_config_dword(tp->pdev, TG3PCI_MEM_WIN_DATA, val);
503
504 /* Always leave this as zero. */
505 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, 0);
506 } else {
507 tw32_f(TG3PCI_MEM_WIN_BASE_ADDR, off);
508 *val = tr32(TG3PCI_MEM_WIN_DATA);
509
510 /* Always leave this as zero. */
511 tw32_f(TG3PCI_MEM_WIN_BASE_ADDR, 0);
512 }
513 spin_unlock_irqrestore(&tp->indirect_lock, flags);
514 }
515
516 static void tg3_ape_lock_init(struct tg3 *tp)
517 {
518 int i;
519
520 /* Make sure the driver hasn't any stale locks. */
521 for (i = 0; i < 8; i++)
522 tg3_ape_write32(tp, TG3_APE_LOCK_GRANT + 4 * i,
523 APE_LOCK_GRANT_DRIVER);
524 }
525
526 static int tg3_ape_lock(struct tg3 *tp, int locknum)
527 {
528 int i, off;
529 int ret = 0;
530 u32 status;
531
532 if (!(tp->tg3_flags3 & TG3_FLG3_ENABLE_APE))
533 return 0;
534
535 switch (locknum) {
536 case TG3_APE_LOCK_MEM:
537 break;
538 default:
539 return -EINVAL;
540 }
541
542 off = 4 * locknum;
543
544 tg3_ape_write32(tp, TG3_APE_LOCK_REQ + off, APE_LOCK_REQ_DRIVER);
545
546 /* Wait for up to 1 millisecond to acquire lock. */
547 for (i = 0; i < 100; i++) {
548 status = tg3_ape_read32(tp, TG3_APE_LOCK_GRANT + off);
549 if (status == APE_LOCK_GRANT_DRIVER)
550 break;
551 udelay(10);
552 }
553
554 if (status != APE_LOCK_GRANT_DRIVER) {
555 /* Revoke the lock request. */
556 tg3_ape_write32(tp, TG3_APE_LOCK_GRANT + off,
557 APE_LOCK_GRANT_DRIVER);
558
559 ret = -EBUSY;
560 }
561
562 return ret;
563 }
564
565 static void tg3_ape_unlock(struct tg3 *tp, int locknum)
566 {
567 int off;
568
569 if (!(tp->tg3_flags3 & TG3_FLG3_ENABLE_APE))
570 return;
571
572 switch (locknum) {
573 case TG3_APE_LOCK_MEM:
574 break;
575 default:
576 return;
577 }
578
579 off = 4 * locknum;
580 tg3_ape_write32(tp, TG3_APE_LOCK_GRANT + off, APE_LOCK_GRANT_DRIVER);
581 }
582
583 static void tg3_disable_ints(struct tg3 *tp)
584 {
585 tw32(TG3PCI_MISC_HOST_CTRL,
586 (tp->misc_host_ctrl | MISC_HOST_CTRL_MASK_PCI_INT));
587 tw32_mailbox_f(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0x00000001);
588 }
589
590 static inline void tg3_cond_int(struct tg3 *tp)
591 {
592 if (!(tp->tg3_flags & TG3_FLAG_TAGGED_STATUS) &&
593 (tp->hw_status->status & SD_STATUS_UPDATED))
594 tw32(GRC_LOCAL_CTRL, tp->grc_local_ctrl | GRC_LCLCTRL_SETINT);
595 else
596 tw32(HOSTCC_MODE, tp->coalesce_mode |
597 (HOSTCC_MODE_ENABLE | HOSTCC_MODE_NOW));
598 }
599
600 static void tg3_enable_ints(struct tg3 *tp)
601 {
602 tp->irq_sync = 0;
603 wmb();
604
605 tw32(TG3PCI_MISC_HOST_CTRL,
606 (tp->misc_host_ctrl & ~MISC_HOST_CTRL_MASK_PCI_INT));
607 tw32_mailbox_f(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
608 (tp->last_tag << 24));
609 if (tp->tg3_flags2 & TG3_FLG2_1SHOT_MSI)
610 tw32_mailbox_f(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
611 (tp->last_tag << 24));
612 tg3_cond_int(tp);
613 }
614
615 static inline unsigned int tg3_has_work(struct tg3 *tp)
616 {
617 struct tg3_hw_status *sblk = tp->hw_status;
618 unsigned int work_exists = 0;
619
620 /* check for phy events */
621 if (!(tp->tg3_flags &
622 (TG3_FLAG_USE_LINKCHG_REG |
623 TG3_FLAG_POLL_SERDES))) {
624 if (sblk->status & SD_STATUS_LINK_CHG)
625 work_exists = 1;
626 }
627 /* check for RX/TX work to do */
628 if (sblk->idx[0].tx_consumer != tp->tx_cons ||
629 sblk->idx[0].rx_producer != tp->rx_rcb_ptr)
630 work_exists = 1;
631
632 return work_exists;
633 }
634
635 /* tg3_restart_ints
636 * similar to tg3_enable_ints, but it accurately determines whether there
637 * is new work pending and can return without flushing the PIO write
638 * which reenables interrupts
639 */
640 static void tg3_restart_ints(struct tg3 *tp)
641 {
642 tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
643 tp->last_tag << 24);
644 mmiowb();
645
646 /* When doing tagged status, this work check is unnecessary.
647 * The last_tag we write above tells the chip which piece of
648 * work we've completed.
649 */
650 if (!(tp->tg3_flags & TG3_FLAG_TAGGED_STATUS) &&
651 tg3_has_work(tp))
652 tw32(HOSTCC_MODE, tp->coalesce_mode |
653 (HOSTCC_MODE_ENABLE | HOSTCC_MODE_NOW));
654 }
655
656 static inline void tg3_netif_stop(struct tg3 *tp)
657 {
658 tp->dev->trans_start = jiffies; /* prevent tx timeout */
659 napi_disable(&tp->napi);
660 netif_tx_disable(tp->dev);
661 }
662
663 static inline void tg3_netif_start(struct tg3 *tp)
664 {
665 netif_wake_queue(tp->dev);
666 /* NOTE: unconditional netif_wake_queue is only appropriate
667 * so long as all callers are assured to have free tx slots
668 * (such as after tg3_init_hw)
669 */
670 napi_enable(&tp->napi);
671 tp->hw_status->status |= SD_STATUS_UPDATED;
672 tg3_enable_ints(tp);
673 }
674
675 static void tg3_switch_clocks(struct tg3 *tp)
676 {
677 u32 clock_ctrl = tr32(TG3PCI_CLOCK_CTRL);
678 u32 orig_clock_ctrl;
679
680 if ((tp->tg3_flags & TG3_FLAG_CPMU_PRESENT) ||
681 (tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
682 return;
683
684 orig_clock_ctrl = clock_ctrl;
685 clock_ctrl &= (CLOCK_CTRL_FORCE_CLKRUN |
686 CLOCK_CTRL_CLKRUN_OENABLE |
687 0x1f);
688 tp->pci_clock_ctrl = clock_ctrl;
689
690 if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
691 if (orig_clock_ctrl & CLOCK_CTRL_625_CORE) {
692 tw32_wait_f(TG3PCI_CLOCK_CTRL,
693 clock_ctrl | CLOCK_CTRL_625_CORE, 40);
694 }
695 } else if ((orig_clock_ctrl & CLOCK_CTRL_44MHZ_CORE) != 0) {
696 tw32_wait_f(TG3PCI_CLOCK_CTRL,
697 clock_ctrl |
698 (CLOCK_CTRL_44MHZ_CORE | CLOCK_CTRL_ALTCLK),
699 40);
700 tw32_wait_f(TG3PCI_CLOCK_CTRL,
701 clock_ctrl | (CLOCK_CTRL_ALTCLK),
702 40);
703 }
704 tw32_wait_f(TG3PCI_CLOCK_CTRL, clock_ctrl, 40);
705 }
706
707 #define PHY_BUSY_LOOPS 5000
708
709 static int tg3_readphy(struct tg3 *tp, int reg, u32 *val)
710 {
711 u32 frame_val;
712 unsigned int loops;
713 int ret;
714
715 if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
716 tw32_f(MAC_MI_MODE,
717 (tp->mi_mode & ~MAC_MI_MODE_AUTO_POLL));
718 udelay(80);
719 }
720
721 *val = 0x0;
722
723 frame_val = ((PHY_ADDR << MI_COM_PHY_ADDR_SHIFT) &
724 MI_COM_PHY_ADDR_MASK);
725 frame_val |= ((reg << MI_COM_REG_ADDR_SHIFT) &
726 MI_COM_REG_ADDR_MASK);
727 frame_val |= (MI_COM_CMD_READ | MI_COM_START);
728
729 tw32_f(MAC_MI_COM, frame_val);
730
731 loops = PHY_BUSY_LOOPS;
732 while (loops != 0) {
733 udelay(10);
734 frame_val = tr32(MAC_MI_COM);
735
736 if ((frame_val & MI_COM_BUSY) == 0) {
737 udelay(5);
738 frame_val = tr32(MAC_MI_COM);
739 break;
740 }
741 loops -= 1;
742 }
743
744 ret = -EBUSY;
745 if (loops != 0) {
746 *val = frame_val & MI_COM_DATA_MASK;
747 ret = 0;
748 }
749
750 if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
751 tw32_f(MAC_MI_MODE, tp->mi_mode);
752 udelay(80);
753 }
754
755 return ret;
756 }
757
758 static int tg3_writephy(struct tg3 *tp, int reg, u32 val)
759 {
760 u32 frame_val;
761 unsigned int loops;
762 int ret;
763
764 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906 &&
765 (reg == MII_TG3_CTRL || reg == MII_TG3_AUX_CTRL))
766 return 0;
767
768 if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
769 tw32_f(MAC_MI_MODE,
770 (tp->mi_mode & ~MAC_MI_MODE_AUTO_POLL));
771 udelay(80);
772 }
773
774 frame_val = ((PHY_ADDR << MI_COM_PHY_ADDR_SHIFT) &
775 MI_COM_PHY_ADDR_MASK);
776 frame_val |= ((reg << MI_COM_REG_ADDR_SHIFT) &
777 MI_COM_REG_ADDR_MASK);
778 frame_val |= (val & MI_COM_DATA_MASK);
779 frame_val |= (MI_COM_CMD_WRITE | MI_COM_START);
780
781 tw32_f(MAC_MI_COM, frame_val);
782
783 loops = PHY_BUSY_LOOPS;
784 while (loops != 0) {
785 udelay(10);
786 frame_val = tr32(MAC_MI_COM);
787 if ((frame_val & MI_COM_BUSY) == 0) {
788 udelay(5);
789 frame_val = tr32(MAC_MI_COM);
790 break;
791 }
792 loops -= 1;
793 }
794
795 ret = -EBUSY;
796 if (loops != 0)
797 ret = 0;
798
799 if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
800 tw32_f(MAC_MI_MODE, tp->mi_mode);
801 udelay(80);
802 }
803
804 return ret;
805 }
806
807 static void tg3_phydsp_write(struct tg3 *tp, u32 reg, u32 val)
808 {
809 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, reg);
810 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, val);
811 }
812
813 static void tg3_phy_toggle_automdix(struct tg3 *tp, int enable)
814 {
815 u32 phy;
816
817 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS) ||
818 (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES))
819 return;
820
821 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
822 u32 ephy;
823
824 if (!tg3_readphy(tp, MII_TG3_EPHY_TEST, &ephy)) {
825 tg3_writephy(tp, MII_TG3_EPHY_TEST,
826 ephy | MII_TG3_EPHY_SHADOW_EN);
827 if (!tg3_readphy(tp, MII_TG3_EPHYTST_MISCCTRL, &phy)) {
828 if (enable)
829 phy |= MII_TG3_EPHYTST_MISCCTRL_MDIX;
830 else
831 phy &= ~MII_TG3_EPHYTST_MISCCTRL_MDIX;
832 tg3_writephy(tp, MII_TG3_EPHYTST_MISCCTRL, phy);
833 }
834 tg3_writephy(tp, MII_TG3_EPHY_TEST, ephy);
835 }
836 } else {
837 phy = MII_TG3_AUXCTL_MISC_RDSEL_MISC |
838 MII_TG3_AUXCTL_SHDWSEL_MISC;
839 if (!tg3_writephy(tp, MII_TG3_AUX_CTRL, phy) &&
840 !tg3_readphy(tp, MII_TG3_AUX_CTRL, &phy)) {
841 if (enable)
842 phy |= MII_TG3_AUXCTL_MISC_FORCE_AMDIX;
843 else
844 phy &= ~MII_TG3_AUXCTL_MISC_FORCE_AMDIX;
845 phy |= MII_TG3_AUXCTL_MISC_WREN;
846 tg3_writephy(tp, MII_TG3_AUX_CTRL, phy);
847 }
848 }
849 }
850
851 static void tg3_phy_set_wirespeed(struct tg3 *tp)
852 {
853 u32 val;
854
855 if (tp->tg3_flags2 & TG3_FLG2_NO_ETH_WIRE_SPEED)
856 return;
857
858 if (!tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x7007) &&
859 !tg3_readphy(tp, MII_TG3_AUX_CTRL, &val))
860 tg3_writephy(tp, MII_TG3_AUX_CTRL,
861 (val | (1 << 15) | (1 << 4)));
862 }
863
864 static int tg3_bmcr_reset(struct tg3 *tp)
865 {
866 u32 phy_control;
867 int limit, err;
868
869 /* OK, reset it, and poll the BMCR_RESET bit until it
870 * clears or we time out.
871 */
872 phy_control = BMCR_RESET;
873 err = tg3_writephy(tp, MII_BMCR, phy_control);
874 if (err != 0)
875 return -EBUSY;
876
877 limit = 5000;
878 while (limit--) {
879 err = tg3_readphy(tp, MII_BMCR, &phy_control);
880 if (err != 0)
881 return -EBUSY;
882
883 if ((phy_control & BMCR_RESET) == 0) {
884 udelay(40);
885 break;
886 }
887 udelay(10);
888 }
889 if (limit <= 0)
890 return -EBUSY;
891
892 return 0;
893 }
894
895 static void tg3_phy_apply_otp(struct tg3 *tp)
896 {
897 u32 otp, phy;
898
899 if (!tp->phy_otp)
900 return;
901
902 otp = tp->phy_otp;
903
904 /* Enable SM_DSP clock and tx 6dB coding. */
905 phy = MII_TG3_AUXCTL_SHDWSEL_AUXCTL |
906 MII_TG3_AUXCTL_ACTL_SMDSP_ENA |
907 MII_TG3_AUXCTL_ACTL_TX_6DB;
908 tg3_writephy(tp, MII_TG3_AUX_CTRL, phy);
909
910 phy = ((otp & TG3_OTP_AGCTGT_MASK) >> TG3_OTP_AGCTGT_SHIFT);
911 phy |= MII_TG3_DSP_TAP1_AGCTGT_DFLT;
912 tg3_phydsp_write(tp, MII_TG3_DSP_TAP1, phy);
913
914 phy = ((otp & TG3_OTP_HPFFLTR_MASK) >> TG3_OTP_HPFFLTR_SHIFT) |
915 ((otp & TG3_OTP_HPFOVER_MASK) >> TG3_OTP_HPFOVER_SHIFT);
916 tg3_phydsp_write(tp, MII_TG3_DSP_AADJ1CH0, phy);
917
918 phy = ((otp & TG3_OTP_LPFDIS_MASK) >> TG3_OTP_LPFDIS_SHIFT);
919 phy |= MII_TG3_DSP_AADJ1CH3_ADCCKADJ;
920 tg3_phydsp_write(tp, MII_TG3_DSP_AADJ1CH3, phy);
921
922 phy = ((otp & TG3_OTP_VDAC_MASK) >> TG3_OTP_VDAC_SHIFT);
923 tg3_phydsp_write(tp, MII_TG3_DSP_EXP75, phy);
924
925 phy = ((otp & TG3_OTP_10BTAMP_MASK) >> TG3_OTP_10BTAMP_SHIFT);
926 tg3_phydsp_write(tp, MII_TG3_DSP_EXP96, phy);
927
928 phy = ((otp & TG3_OTP_ROFF_MASK) >> TG3_OTP_ROFF_SHIFT) |
929 ((otp & TG3_OTP_RCOFF_MASK) >> TG3_OTP_RCOFF_SHIFT);
930 tg3_phydsp_write(tp, MII_TG3_DSP_EXP97, phy);
931
932 /* Turn off SM_DSP clock. */
933 phy = MII_TG3_AUXCTL_SHDWSEL_AUXCTL |
934 MII_TG3_AUXCTL_ACTL_TX_6DB;
935 tg3_writephy(tp, MII_TG3_AUX_CTRL, phy);
936 }
937
938 static int tg3_wait_macro_done(struct tg3 *tp)
939 {
940 int limit = 100;
941
942 while (limit--) {
943 u32 tmp32;
944
945 if (!tg3_readphy(tp, 0x16, &tmp32)) {
946 if ((tmp32 & 0x1000) == 0)
947 break;
948 }
949 }
950 if (limit <= 0)
951 return -EBUSY;
952
953 return 0;
954 }
955
956 static int tg3_phy_write_and_check_testpat(struct tg3 *tp, int *resetp)
957 {
958 static const u32 test_pat[4][6] = {
959 { 0x00005555, 0x00000005, 0x00002aaa, 0x0000000a, 0x00003456, 0x00000003 },
960 { 0x00002aaa, 0x0000000a, 0x00003333, 0x00000003, 0x0000789a, 0x00000005 },
961 { 0x00005a5a, 0x00000005, 0x00002a6a, 0x0000000a, 0x00001bcd, 0x00000003 },
962 { 0x00002a5a, 0x0000000a, 0x000033c3, 0x00000003, 0x00002ef1, 0x00000005 }
963 };
964 int chan;
965
966 for (chan = 0; chan < 4; chan++) {
967 int i;
968
969 tg3_writephy(tp, MII_TG3_DSP_ADDRESS,
970 (chan * 0x2000) | 0x0200);
971 tg3_writephy(tp, 0x16, 0x0002);
972
973 for (i = 0; i < 6; i++)
974 tg3_writephy(tp, MII_TG3_DSP_RW_PORT,
975 test_pat[chan][i]);
976
977 tg3_writephy(tp, 0x16, 0x0202);
978 if (tg3_wait_macro_done(tp)) {
979 *resetp = 1;
980 return -EBUSY;
981 }
982
983 tg3_writephy(tp, MII_TG3_DSP_ADDRESS,
984 (chan * 0x2000) | 0x0200);
985 tg3_writephy(tp, 0x16, 0x0082);
986 if (tg3_wait_macro_done(tp)) {
987 *resetp = 1;
988 return -EBUSY;
989 }
990
991 tg3_writephy(tp, 0x16, 0x0802);
992 if (tg3_wait_macro_done(tp)) {
993 *resetp = 1;
994 return -EBUSY;
995 }
996
997 for (i = 0; i < 6; i += 2) {
998 u32 low, high;
999
1000 if (tg3_readphy(tp, MII_TG3_DSP_RW_PORT, &low) ||
1001 tg3_readphy(tp, MII_TG3_DSP_RW_PORT, &high) ||
1002 tg3_wait_macro_done(tp)) {
1003 *resetp = 1;
1004 return -EBUSY;
1005 }
1006 low &= 0x7fff;
1007 high &= 0x000f;
1008 if (low != test_pat[chan][i] ||
1009 high != test_pat[chan][i+1]) {
1010 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x000b);
1011 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x4001);
1012 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x4005);
1013
1014 return -EBUSY;
1015 }
1016 }
1017 }
1018
1019 return 0;
1020 }
1021
1022 static int tg3_phy_reset_chanpat(struct tg3 *tp)
1023 {
1024 int chan;
1025
1026 for (chan = 0; chan < 4; chan++) {
1027 int i;
1028
1029 tg3_writephy(tp, MII_TG3_DSP_ADDRESS,
1030 (chan * 0x2000) | 0x0200);
1031 tg3_writephy(tp, 0x16, 0x0002);
1032 for (i = 0; i < 6; i++)
1033 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x000);
1034 tg3_writephy(tp, 0x16, 0x0202);
1035 if (tg3_wait_macro_done(tp))
1036 return -EBUSY;
1037 }
1038
1039 return 0;
1040 }
1041
1042 static int tg3_phy_reset_5703_4_5(struct tg3 *tp)
1043 {
1044 u32 reg32, phy9_orig;
1045 int retries, do_phy_reset, err;
1046
1047 retries = 10;
1048 do_phy_reset = 1;
1049 do {
1050 if (do_phy_reset) {
1051 err = tg3_bmcr_reset(tp);
1052 if (err)
1053 return err;
1054 do_phy_reset = 0;
1055 }
1056
1057 /* Disable transmitter and interrupt. */
1058 if (tg3_readphy(tp, MII_TG3_EXT_CTRL, &reg32))
1059 continue;
1060
1061 reg32 |= 0x3000;
1062 tg3_writephy(tp, MII_TG3_EXT_CTRL, reg32);
1063
1064 /* Set full-duplex, 1000 mbps. */
1065 tg3_writephy(tp, MII_BMCR,
1066 BMCR_FULLDPLX | TG3_BMCR_SPEED1000);
1067
1068 /* Set to master mode. */
1069 if (tg3_readphy(tp, MII_TG3_CTRL, &phy9_orig))
1070 continue;
1071
1072 tg3_writephy(tp, MII_TG3_CTRL,
1073 (MII_TG3_CTRL_AS_MASTER |
1074 MII_TG3_CTRL_ENABLE_AS_MASTER));
1075
1076 /* Enable SM_DSP_CLOCK and 6dB. */
1077 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0c00);
1078
1079 /* Block the PHY control access. */
1080 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x8005);
1081 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x0800);
1082
1083 err = tg3_phy_write_and_check_testpat(tp, &do_phy_reset);
1084 if (!err)
1085 break;
1086 } while (--retries);
1087
1088 err = tg3_phy_reset_chanpat(tp);
1089 if (err)
1090 return err;
1091
1092 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x8005);
1093 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x0000);
1094
1095 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x8200);
1096 tg3_writephy(tp, 0x16, 0x0000);
1097
1098 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
1099 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) {
1100 /* Set Extended packet length bit for jumbo frames */
1101 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x4400);
1102 }
1103 else {
1104 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0400);
1105 }
1106
1107 tg3_writephy(tp, MII_TG3_CTRL, phy9_orig);
1108
1109 if (!tg3_readphy(tp, MII_TG3_EXT_CTRL, &reg32)) {
1110 reg32 &= ~0x3000;
1111 tg3_writephy(tp, MII_TG3_EXT_CTRL, reg32);
1112 } else if (!err)
1113 err = -EBUSY;
1114
1115 return err;
1116 }
1117
1118 static void tg3_link_report(struct tg3 *);
1119
1120 /* This will reset the tigon3 PHY if there is no valid
1121 * link unless the FORCE argument is non-zero.
1122 */
1123 static int tg3_phy_reset(struct tg3 *tp)
1124 {
1125 u32 cpmuctrl;
1126 u32 phy_status;
1127 int err;
1128
1129 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
1130 u32 val;
1131
1132 val = tr32(GRC_MISC_CFG);
1133 tw32_f(GRC_MISC_CFG, val & ~GRC_MISC_CFG_EPHY_IDDQ);
1134 udelay(40);
1135 }
1136 err = tg3_readphy(tp, MII_BMSR, &phy_status);
1137 err |= tg3_readphy(tp, MII_BMSR, &phy_status);
1138 if (err != 0)
1139 return -EBUSY;
1140
1141 if (netif_running(tp->dev) && netif_carrier_ok(tp->dev)) {
1142 netif_carrier_off(tp->dev);
1143 tg3_link_report(tp);
1144 }
1145
1146 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
1147 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 ||
1148 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) {
1149 err = tg3_phy_reset_5703_4_5(tp);
1150 if (err)
1151 return err;
1152 goto out;
1153 }
1154
1155 cpmuctrl = 0;
1156 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 &&
1157 GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5784_AX) {
1158 cpmuctrl = tr32(TG3_CPMU_CTRL);
1159 if (cpmuctrl & CPMU_CTRL_GPHY_10MB_RXONLY)
1160 tw32(TG3_CPMU_CTRL,
1161 cpmuctrl & ~CPMU_CTRL_GPHY_10MB_RXONLY);
1162 }
1163
1164 err = tg3_bmcr_reset(tp);
1165 if (err)
1166 return err;
1167
1168 if (cpmuctrl & CPMU_CTRL_GPHY_10MB_RXONLY) {
1169 u32 phy;
1170
1171 phy = MII_TG3_DSP_EXP8_AEDW | MII_TG3_DSP_EXP8_REJ2MHz;
1172 tg3_phydsp_write(tp, MII_TG3_DSP_EXP8, phy);
1173
1174 tw32(TG3_CPMU_CTRL, cpmuctrl);
1175 }
1176
1177 if (tp->tg3_flags3 & TG3_FLG3_5761_5784_AX_FIXES) {
1178 u32 val;
1179
1180 val = tr32(TG3_CPMU_LSPD_1000MB_CLK);
1181 if ((val & CPMU_LSPD_1000MB_MACCLK_MASK) ==
1182 CPMU_LSPD_1000MB_MACCLK_12_5) {
1183 val &= ~CPMU_LSPD_1000MB_MACCLK_MASK;
1184 udelay(40);
1185 tw32_f(TG3_CPMU_LSPD_1000MB_CLK, val);
1186 }
1187
1188 /* Disable GPHY autopowerdown. */
1189 tg3_writephy(tp, MII_TG3_MISC_SHDW,
1190 MII_TG3_MISC_SHDW_WREN |
1191 MII_TG3_MISC_SHDW_APD_SEL |
1192 MII_TG3_MISC_SHDW_APD_WKTM_84MS);
1193 }
1194
1195 tg3_phy_apply_otp(tp);
1196
1197 out:
1198 if (tp->tg3_flags2 & TG3_FLG2_PHY_ADC_BUG) {
1199 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0c00);
1200 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x201f);
1201 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x2aaa);
1202 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x000a);
1203 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x0323);
1204 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0400);
1205 }
1206 if (tp->tg3_flags2 & TG3_FLG2_PHY_5704_A0_BUG) {
1207 tg3_writephy(tp, 0x1c, 0x8d68);
1208 tg3_writephy(tp, 0x1c, 0x8d68);
1209 }
1210 if (tp->tg3_flags2 & TG3_FLG2_PHY_BER_BUG) {
1211 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0c00);
1212 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x000a);
1213 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x310b);
1214 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x201f);
1215 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x9506);
1216 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x401f);
1217 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x14e2);
1218 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0400);
1219 }
1220 else if (tp->tg3_flags2 & TG3_FLG2_PHY_JITTER_BUG) {
1221 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0c00);
1222 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x000a);
1223 if (tp->tg3_flags2 & TG3_FLG2_PHY_ADJUST_TRIM) {
1224 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x110b);
1225 tg3_writephy(tp, MII_TG3_TEST1,
1226 MII_TG3_TEST1_TRIM_EN | 0x4);
1227 } else
1228 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x010b);
1229 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0400);
1230 }
1231 /* Set Extended packet length bit (bit 14) on all chips that */
1232 /* support jumbo frames */
1233 if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401) {
1234 /* Cannot do read-modify-write on 5401 */
1235 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x4c20);
1236 } else if (tp->tg3_flags2 & TG3_FLG2_JUMBO_CAPABLE) {
1237 u32 phy_reg;
1238
1239 /* Set bit 14 with read-modify-write to preserve other bits */
1240 if (!tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0007) &&
1241 !tg3_readphy(tp, MII_TG3_AUX_CTRL, &phy_reg))
1242 tg3_writephy(tp, MII_TG3_AUX_CTRL, phy_reg | 0x4000);
1243 }
1244
1245 /* Set phy register 0x10 bit 0 to high fifo elasticity to support
1246 * jumbo frames transmission.
1247 */
1248 if (tp->tg3_flags2 & TG3_FLG2_JUMBO_CAPABLE) {
1249 u32 phy_reg;
1250
1251 if (!tg3_readphy(tp, MII_TG3_EXT_CTRL, &phy_reg))
1252 tg3_writephy(tp, MII_TG3_EXT_CTRL,
1253 phy_reg | MII_TG3_EXT_CTRL_FIFO_ELASTIC);
1254 }
1255
1256 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
1257 /* adjust output voltage */
1258 tg3_writephy(tp, MII_TG3_EPHY_PTEST, 0x12);
1259 }
1260
1261 tg3_phy_toggle_automdix(tp, 1);
1262 tg3_phy_set_wirespeed(tp);
1263 return 0;
1264 }
1265
1266 static void tg3_frob_aux_power(struct tg3 *tp)
1267 {
1268 struct tg3 *tp_peer = tp;
1269
1270 if ((tp->tg3_flags2 & TG3_FLG2_IS_NIC) == 0)
1271 return;
1272
1273 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) ||
1274 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714)) {
1275 struct net_device *dev_peer;
1276
1277 dev_peer = pci_get_drvdata(tp->pdev_peer);
1278 /* remove_one() may have been run on the peer. */
1279 if (!dev_peer)
1280 tp_peer = tp;
1281 else
1282 tp_peer = netdev_priv(dev_peer);
1283 }
1284
1285 if ((tp->tg3_flags & TG3_FLAG_WOL_ENABLE) != 0 ||
1286 (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) != 0 ||
1287 (tp_peer->tg3_flags & TG3_FLAG_WOL_ENABLE) != 0 ||
1288 (tp_peer->tg3_flags & TG3_FLAG_ENABLE_ASF) != 0) {
1289 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
1290 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701) {
1291 tw32_wait_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
1292 (GRC_LCLCTRL_GPIO_OE0 |
1293 GRC_LCLCTRL_GPIO_OE1 |
1294 GRC_LCLCTRL_GPIO_OE2 |
1295 GRC_LCLCTRL_GPIO_OUTPUT0 |
1296 GRC_LCLCTRL_GPIO_OUTPUT1),
1297 100);
1298 } else if (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5761) {
1299 /* The 5761 non-e device swaps GPIO 0 and GPIO 2. */
1300 u32 grc_local_ctrl = GRC_LCLCTRL_GPIO_OE0 |
1301 GRC_LCLCTRL_GPIO_OE1 |
1302 GRC_LCLCTRL_GPIO_OE2 |
1303 GRC_LCLCTRL_GPIO_OUTPUT0 |
1304 GRC_LCLCTRL_GPIO_OUTPUT1 |
1305 tp->grc_local_ctrl;
1306 tw32_wait_f(GRC_LOCAL_CTRL, grc_local_ctrl, 100);
1307
1308 grc_local_ctrl |= GRC_LCLCTRL_GPIO_OUTPUT2;
1309 tw32_wait_f(GRC_LOCAL_CTRL, grc_local_ctrl, 100);
1310
1311 grc_local_ctrl &= ~GRC_LCLCTRL_GPIO_OUTPUT0;
1312 tw32_wait_f(GRC_LOCAL_CTRL, grc_local_ctrl, 100);
1313 } else {
1314 u32 no_gpio2;
1315 u32 grc_local_ctrl = 0;
1316
1317 if (tp_peer != tp &&
1318 (tp_peer->tg3_flags & TG3_FLAG_INIT_COMPLETE) != 0)
1319 return;
1320
1321 /* Workaround to prevent overdrawing Amps. */
1322 if (GET_ASIC_REV(tp->pci_chip_rev_id) ==
1323 ASIC_REV_5714) {
1324 grc_local_ctrl |= GRC_LCLCTRL_GPIO_OE3;
1325 tw32_wait_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
1326 grc_local_ctrl, 100);
1327 }
1328
1329 /* On 5753 and variants, GPIO2 cannot be used. */
1330 no_gpio2 = tp->nic_sram_data_cfg &
1331 NIC_SRAM_DATA_CFG_NO_GPIO2;
1332
1333 grc_local_ctrl |= GRC_LCLCTRL_GPIO_OE0 |
1334 GRC_LCLCTRL_GPIO_OE1 |
1335 GRC_LCLCTRL_GPIO_OE2 |
1336 GRC_LCLCTRL_GPIO_OUTPUT1 |
1337 GRC_LCLCTRL_GPIO_OUTPUT2;
1338 if (no_gpio2) {
1339 grc_local_ctrl &= ~(GRC_LCLCTRL_GPIO_OE2 |
1340 GRC_LCLCTRL_GPIO_OUTPUT2);
1341 }
1342 tw32_wait_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
1343 grc_local_ctrl, 100);
1344
1345 grc_local_ctrl |= GRC_LCLCTRL_GPIO_OUTPUT0;
1346
1347 tw32_wait_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
1348 grc_local_ctrl, 100);
1349
1350 if (!no_gpio2) {
1351 grc_local_ctrl &= ~GRC_LCLCTRL_GPIO_OUTPUT2;
1352 tw32_wait_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
1353 grc_local_ctrl, 100);
1354 }
1355 }
1356 } else {
1357 if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700 &&
1358 GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701) {
1359 if (tp_peer != tp &&
1360 (tp_peer->tg3_flags & TG3_FLAG_INIT_COMPLETE) != 0)
1361 return;
1362
1363 tw32_wait_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
1364 (GRC_LCLCTRL_GPIO_OE1 |
1365 GRC_LCLCTRL_GPIO_OUTPUT1), 100);
1366
1367 tw32_wait_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
1368 GRC_LCLCTRL_GPIO_OE1, 100);
1369
1370 tw32_wait_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
1371 (GRC_LCLCTRL_GPIO_OE1 |
1372 GRC_LCLCTRL_GPIO_OUTPUT1), 100);
1373 }
1374 }
1375 }
1376
1377 static int tg3_5700_link_polarity(struct tg3 *tp, u32 speed)
1378 {
1379 if (tp->led_ctrl == LED_CTRL_MODE_PHY_2)
1380 return 1;
1381 else if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5411) {
1382 if (speed != SPEED_10)
1383 return 1;
1384 } else if (speed == SPEED_10)
1385 return 1;
1386
1387 return 0;
1388 }
1389
1390 static int tg3_setup_phy(struct tg3 *, int);
1391
1392 #define RESET_KIND_SHUTDOWN 0
1393 #define RESET_KIND_INIT 1
1394 #define RESET_KIND_SUSPEND 2
1395
1396 static void tg3_write_sig_post_reset(struct tg3 *, int);
1397 static int tg3_halt_cpu(struct tg3 *, u32);
1398 static int tg3_nvram_lock(struct tg3 *);
1399 static void tg3_nvram_unlock(struct tg3 *);
1400
1401 static void tg3_power_down_phy(struct tg3 *tp)
1402 {
1403 u32 val;
1404
1405 if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
1406 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) {
1407 u32 sg_dig_ctrl = tr32(SG_DIG_CTRL);
1408 u32 serdes_cfg = tr32(MAC_SERDES_CFG);
1409
1410 sg_dig_ctrl |=
1411 SG_DIG_USING_HW_AUTONEG | SG_DIG_SOFT_RESET;
1412 tw32(SG_DIG_CTRL, sg_dig_ctrl);
1413 tw32(MAC_SERDES_CFG, serdes_cfg | (1 << 15));
1414 }
1415 return;
1416 }
1417
1418 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
1419 tg3_bmcr_reset(tp);
1420 val = tr32(GRC_MISC_CFG);
1421 tw32_f(GRC_MISC_CFG, val | GRC_MISC_CFG_EPHY_IDDQ);
1422 udelay(40);
1423 return;
1424 } else {
1425 tg3_writephy(tp, MII_TG3_EXT_CTRL,
1426 MII_TG3_EXT_CTRL_FORCE_LED_OFF);
1427 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x01b2);
1428 }
1429
1430 /* The PHY should not be powered down on some chips because
1431 * of bugs.
1432 */
1433 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
1434 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 ||
1435 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780 &&
1436 (tp->tg3_flags2 & TG3_FLG2_MII_SERDES)))
1437 return;
1438
1439 if (tp->tg3_flags3 & TG3_FLG3_5761_5784_AX_FIXES) {
1440 val = tr32(TG3_CPMU_LSPD_1000MB_CLK);
1441 val &= ~CPMU_LSPD_1000MB_MACCLK_MASK;
1442 val |= CPMU_LSPD_1000MB_MACCLK_12_5;
1443 tw32_f(TG3_CPMU_LSPD_1000MB_CLK, val);
1444 }
1445
1446 tg3_writephy(tp, MII_BMCR, BMCR_PDOWN);
1447 }
1448
1449 static int tg3_set_power_state(struct tg3 *tp, pci_power_t state)
1450 {
1451 u32 misc_host_ctrl;
1452 u16 power_control, power_caps;
1453 int pm = tp->pm_cap;
1454
1455 /* Make sure register accesses (indirect or otherwise)
1456 * will function correctly.
1457 */
1458 pci_write_config_dword(tp->pdev,
1459 TG3PCI_MISC_HOST_CTRL,
1460 tp->misc_host_ctrl);
1461
1462 pci_read_config_word(tp->pdev,
1463 pm + PCI_PM_CTRL,
1464 &power_control);
1465 power_control |= PCI_PM_CTRL_PME_STATUS;
1466 power_control &= ~(PCI_PM_CTRL_STATE_MASK);
1467 switch (state) {
1468 case PCI_D0:
1469 power_control |= 0;
1470 pci_write_config_word(tp->pdev,
1471 pm + PCI_PM_CTRL,
1472 power_control);
1473 udelay(100); /* Delay after power state change */
1474
1475 /* Switch out of Vaux if it is a NIC */
1476 if (tp->tg3_flags2 & TG3_FLG2_IS_NIC)
1477 tw32_wait_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl, 100);
1478
1479 return 0;
1480
1481 case PCI_D1:
1482 power_control |= 1;
1483 break;
1484
1485 case PCI_D2:
1486 power_control |= 2;
1487 break;
1488
1489 case PCI_D3hot:
1490 power_control |= 3;
1491 break;
1492
1493 default:
1494 printk(KERN_WARNING PFX "%s: Invalid power state (%d) "
1495 "requested.\n",
1496 tp->dev->name, state);
1497 return -EINVAL;
1498 };
1499
1500 power_control |= PCI_PM_CTRL_PME_ENABLE;
1501
1502 misc_host_ctrl = tr32(TG3PCI_MISC_HOST_CTRL);
1503 tw32(TG3PCI_MISC_HOST_CTRL,
1504 misc_host_ctrl | MISC_HOST_CTRL_MASK_PCI_INT);
1505
1506 if (tp->link_config.phy_is_low_power == 0) {
1507 tp->link_config.phy_is_low_power = 1;
1508 tp->link_config.orig_speed = tp->link_config.speed;
1509 tp->link_config.orig_duplex = tp->link_config.duplex;
1510 tp->link_config.orig_autoneg = tp->link_config.autoneg;
1511 }
1512
1513 if (!(tp->tg3_flags2 & TG3_FLG2_ANY_SERDES)) {
1514 tp->link_config.speed = SPEED_10;
1515 tp->link_config.duplex = DUPLEX_HALF;
1516 tp->link_config.autoneg = AUTONEG_ENABLE;
1517 tg3_setup_phy(tp, 0);
1518 }
1519
1520 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
1521 u32 val;
1522
1523 val = tr32(GRC_VCPU_EXT_CTRL);
1524 tw32(GRC_VCPU_EXT_CTRL, val | GRC_VCPU_EXT_CTRL_DISABLE_WOL);
1525 } else if (!(tp->tg3_flags & TG3_FLAG_ENABLE_ASF)) {
1526 int i;
1527 u32 val;
1528
1529 for (i = 0; i < 200; i++) {
1530 tg3_read_mem(tp, NIC_SRAM_FW_ASF_STATUS_MBOX, &val);
1531 if (val == ~NIC_SRAM_FIRMWARE_MBOX_MAGIC1)
1532 break;
1533 msleep(1);
1534 }
1535 }
1536 if (tp->tg3_flags & TG3_FLAG_WOL_CAP)
1537 tg3_write_mem(tp, NIC_SRAM_WOL_MBOX, WOL_SIGNATURE |
1538 WOL_DRV_STATE_SHUTDOWN |
1539 WOL_DRV_WOL |
1540 WOL_SET_MAGIC_PKT);
1541
1542 pci_read_config_word(tp->pdev, pm + PCI_PM_PMC, &power_caps);
1543
1544 if (tp->tg3_flags & TG3_FLAG_WOL_ENABLE) {
1545 u32 mac_mode;
1546
1547 if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)) {
1548 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x5a);
1549 udelay(40);
1550
1551 if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES)
1552 mac_mode = MAC_MODE_PORT_MODE_GMII;
1553 else
1554 mac_mode = MAC_MODE_PORT_MODE_MII;
1555
1556 mac_mode |= tp->mac_mode & MAC_MODE_LINK_POLARITY;
1557 if (GET_ASIC_REV(tp->pci_chip_rev_id) ==
1558 ASIC_REV_5700) {
1559 u32 speed = (tp->tg3_flags &
1560 TG3_FLAG_WOL_SPEED_100MB) ?
1561 SPEED_100 : SPEED_10;
1562 if (tg3_5700_link_polarity(tp, speed))
1563 mac_mode |= MAC_MODE_LINK_POLARITY;
1564 else
1565 mac_mode &= ~MAC_MODE_LINK_POLARITY;
1566 }
1567 } else {
1568 mac_mode = MAC_MODE_PORT_MODE_TBI;
1569 }
1570
1571 if (!(tp->tg3_flags2 & TG3_FLG2_5750_PLUS))
1572 tw32(MAC_LED_CTRL, tp->led_ctrl);
1573
1574 if (((power_caps & PCI_PM_CAP_PME_D3cold) &&
1575 (tp->tg3_flags & TG3_FLAG_WOL_ENABLE)))
1576 mac_mode |= MAC_MODE_MAGIC_PKT_ENABLE;
1577
1578 tw32_f(MAC_MODE, mac_mode);
1579 udelay(100);
1580
1581 tw32_f(MAC_RX_MODE, RX_MODE_ENABLE);
1582 udelay(10);
1583 }
1584
1585 if (!(tp->tg3_flags & TG3_FLAG_WOL_SPEED_100MB) &&
1586 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
1587 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701)) {
1588 u32 base_val;
1589
1590 base_val = tp->pci_clock_ctrl;
1591 base_val |= (CLOCK_CTRL_RXCLK_DISABLE |
1592 CLOCK_CTRL_TXCLK_DISABLE);
1593
1594 tw32_wait_f(TG3PCI_CLOCK_CTRL, base_val | CLOCK_CTRL_ALTCLK |
1595 CLOCK_CTRL_PWRDOWN_PLL133, 40);
1596 } else if ((tp->tg3_flags2 & TG3_FLG2_5780_CLASS) ||
1597 (tp->tg3_flags & TG3_FLAG_CPMU_PRESENT) ||
1598 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)) {
1599 /* do nothing */
1600 } else if (!((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
1601 (tp->tg3_flags & TG3_FLAG_ENABLE_ASF))) {
1602 u32 newbits1, newbits2;
1603
1604 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
1605 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701) {
1606 newbits1 = (CLOCK_CTRL_RXCLK_DISABLE |
1607 CLOCK_CTRL_TXCLK_DISABLE |
1608 CLOCK_CTRL_ALTCLK);
1609 newbits2 = newbits1 | CLOCK_CTRL_44MHZ_CORE;
1610 } else if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
1611 newbits1 = CLOCK_CTRL_625_CORE;
1612 newbits2 = newbits1 | CLOCK_CTRL_ALTCLK;
1613 } else {
1614 newbits1 = CLOCK_CTRL_ALTCLK;
1615 newbits2 = newbits1 | CLOCK_CTRL_44MHZ_CORE;
1616 }
1617
1618 tw32_wait_f(TG3PCI_CLOCK_CTRL, tp->pci_clock_ctrl | newbits1,
1619 40);
1620
1621 tw32_wait_f(TG3PCI_CLOCK_CTRL, tp->pci_clock_ctrl | newbits2,
1622 40);
1623
1624 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
1625 u32 newbits3;
1626
1627 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
1628 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701) {
1629 newbits3 = (CLOCK_CTRL_RXCLK_DISABLE |
1630 CLOCK_CTRL_TXCLK_DISABLE |
1631 CLOCK_CTRL_44MHZ_CORE);
1632 } else {
1633 newbits3 = CLOCK_CTRL_44MHZ_CORE;
1634 }
1635
1636 tw32_wait_f(TG3PCI_CLOCK_CTRL,
1637 tp->pci_clock_ctrl | newbits3, 40);
1638 }
1639 }
1640
1641 if (!(tp->tg3_flags & TG3_FLAG_WOL_ENABLE) &&
1642 !(tp->tg3_flags & TG3_FLAG_ENABLE_ASF) &&
1643 !(tp->tg3_flags3 & TG3_FLG3_ENABLE_APE))
1644 tg3_power_down_phy(tp);
1645
1646 tg3_frob_aux_power(tp);
1647
1648 /* Workaround for unstable PLL clock */
1649 if ((GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5750_AX) ||
1650 (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5750_BX)) {
1651 u32 val = tr32(0x7d00);
1652
1653 val &= ~((1 << 16) | (1 << 4) | (1 << 2) | (1 << 1) | 1);
1654 tw32(0x7d00, val);
1655 if (!(tp->tg3_flags & TG3_FLAG_ENABLE_ASF)) {
1656 int err;
1657
1658 err = tg3_nvram_lock(tp);
1659 tg3_halt_cpu(tp, RX_CPU_BASE);
1660 if (!err)
1661 tg3_nvram_unlock(tp);
1662 }
1663 }
1664
1665 tg3_write_sig_post_reset(tp, RESET_KIND_SHUTDOWN);
1666
1667 /* Finally, set the new power state. */
1668 pci_write_config_word(tp->pdev, pm + PCI_PM_CTRL, power_control);
1669 udelay(100); /* Delay after power state change */
1670
1671 return 0;
1672 }
1673
1674 /* tp->lock is held. */
1675 static void tg3_wait_for_event_ack(struct tg3 *tp)
1676 {
1677 int i;
1678
1679 /* Wait for up to 2.5 milliseconds */
1680 for (i = 0; i < 250000; i++) {
1681 if (!(tr32(GRC_RX_CPU_EVENT) & GRC_RX_CPU_DRIVER_EVENT))
1682 break;
1683 udelay(10);
1684 }
1685 }
1686
1687 /* tp->lock is held. */
1688 static void tg3_ump_link_report(struct tg3 *tp)
1689 {
1690 u32 reg;
1691 u32 val;
1692
1693 if (!(tp->tg3_flags2 & TG3_FLG2_5780_CLASS) ||
1694 !(tp->tg3_flags & TG3_FLAG_ENABLE_ASF))
1695 return;
1696
1697 tg3_wait_for_event_ack(tp);
1698
1699 tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX, FWCMD_NICDRV_LINK_UPDATE);
1700
1701 tg3_write_mem(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 14);
1702
1703 val = 0;
1704 if (!tg3_readphy(tp, MII_BMCR, &reg))
1705 val = reg << 16;
1706 if (!tg3_readphy(tp, MII_BMSR, &reg))
1707 val |= (reg & 0xffff);
1708 tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX, val);
1709
1710 val = 0;
1711 if (!tg3_readphy(tp, MII_ADVERTISE, &reg))
1712 val = reg << 16;
1713 if (!tg3_readphy(tp, MII_LPA, &reg))
1714 val |= (reg & 0xffff);
1715 tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 4, val);
1716
1717 val = 0;
1718 if (!(tp->tg3_flags2 & TG3_FLG2_MII_SERDES)) {
1719 if (!tg3_readphy(tp, MII_CTRL1000, &reg))
1720 val = reg << 16;
1721 if (!tg3_readphy(tp, MII_STAT1000, &reg))
1722 val |= (reg & 0xffff);
1723 }
1724 tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 8, val);
1725
1726 if (!tg3_readphy(tp, MII_PHYADDR, &reg))
1727 val = reg << 16;
1728 else
1729 val = 0;
1730 tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 12, val);
1731
1732 val = tr32(GRC_RX_CPU_EVENT);
1733 val |= GRC_RX_CPU_DRIVER_EVENT;
1734 tw32_f(GRC_RX_CPU_EVENT, val);
1735 }
1736
1737 static void tg3_link_report(struct tg3 *tp)
1738 {
1739 if (!netif_carrier_ok(tp->dev)) {
1740 if (netif_msg_link(tp))
1741 printk(KERN_INFO PFX "%s: Link is down.\n",
1742 tp->dev->name);
1743 tg3_ump_link_report(tp);
1744 } else if (netif_msg_link(tp)) {
1745 printk(KERN_INFO PFX "%s: Link is up at %d Mbps, %s duplex.\n",
1746 tp->dev->name,
1747 (tp->link_config.active_speed == SPEED_1000 ?
1748 1000 :
1749 (tp->link_config.active_speed == SPEED_100 ?
1750 100 : 10)),
1751 (tp->link_config.active_duplex == DUPLEX_FULL ?
1752 "full" : "half"));
1753
1754 printk(KERN_INFO PFX
1755 "%s: Flow control is %s for TX and %s for RX.\n",
1756 tp->dev->name,
1757 (tp->link_config.active_flowctrl & TG3_FLOW_CTRL_TX) ?
1758 "on" : "off",
1759 (tp->link_config.active_flowctrl & TG3_FLOW_CTRL_RX) ?
1760 "on" : "off");
1761 tg3_ump_link_report(tp);
1762 }
1763 }
1764
1765 static u16 tg3_advert_flowctrl_1000T(u8 flow_ctrl)
1766 {
1767 u16 miireg;
1768
1769 if ((flow_ctrl & TG3_FLOW_CTRL_TX) && (flow_ctrl & TG3_FLOW_CTRL_RX))
1770 miireg = ADVERTISE_PAUSE_CAP;
1771 else if (flow_ctrl & TG3_FLOW_CTRL_TX)
1772 miireg = ADVERTISE_PAUSE_ASYM;
1773 else if (flow_ctrl & TG3_FLOW_CTRL_RX)
1774 miireg = ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
1775 else
1776 miireg = 0;
1777
1778 return miireg;
1779 }
1780
1781 static u16 tg3_advert_flowctrl_1000X(u8 flow_ctrl)
1782 {
1783 u16 miireg;
1784
1785 if ((flow_ctrl & TG3_FLOW_CTRL_TX) && (flow_ctrl & TG3_FLOW_CTRL_RX))
1786 miireg = ADVERTISE_1000XPAUSE;
1787 else if (flow_ctrl & TG3_FLOW_CTRL_TX)
1788 miireg = ADVERTISE_1000XPSE_ASYM;
1789 else if (flow_ctrl & TG3_FLOW_CTRL_RX)
1790 miireg = ADVERTISE_1000XPAUSE | ADVERTISE_1000XPSE_ASYM;
1791 else
1792 miireg = 0;
1793
1794 return miireg;
1795 }
1796
1797 static u8 tg3_resolve_flowctrl_1000T(u16 lcladv, u16 rmtadv)
1798 {
1799 u8 cap = 0;
1800
1801 if (lcladv & ADVERTISE_PAUSE_CAP) {
1802 if (lcladv & ADVERTISE_PAUSE_ASYM) {
1803 if (rmtadv & LPA_PAUSE_CAP)
1804 cap = TG3_FLOW_CTRL_TX | TG3_FLOW_CTRL_RX;
1805 else if (rmtadv & LPA_PAUSE_ASYM)
1806 cap = TG3_FLOW_CTRL_RX;
1807 } else {
1808 if (rmtadv & LPA_PAUSE_CAP)
1809 cap = TG3_FLOW_CTRL_TX | TG3_FLOW_CTRL_RX;
1810 }
1811 } else if (lcladv & ADVERTISE_PAUSE_ASYM) {
1812 if ((rmtadv & LPA_PAUSE_CAP) && (rmtadv & LPA_PAUSE_ASYM))
1813 cap = TG3_FLOW_CTRL_TX;
1814 }
1815
1816 return cap;
1817 }
1818
1819 static u8 tg3_resolve_flowctrl_1000X(u16 lcladv, u16 rmtadv)
1820 {
1821 u8 cap = 0;
1822
1823 if (lcladv & ADVERTISE_1000XPAUSE) {
1824 if (lcladv & ADVERTISE_1000XPSE_ASYM) {
1825 if (rmtadv & LPA_1000XPAUSE)
1826 cap = TG3_FLOW_CTRL_TX | TG3_FLOW_CTRL_RX;
1827 else if (rmtadv & LPA_1000XPAUSE_ASYM)
1828 cap = TG3_FLOW_CTRL_RX;
1829 } else {
1830 if (rmtadv & LPA_1000XPAUSE)
1831 cap = TG3_FLOW_CTRL_TX | TG3_FLOW_CTRL_RX;
1832 }
1833 } else if (lcladv & ADVERTISE_1000XPSE_ASYM) {
1834 if ((rmtadv & LPA_1000XPAUSE) && (rmtadv & LPA_1000XPAUSE_ASYM))
1835 cap = TG3_FLOW_CTRL_TX;
1836 }
1837
1838 return cap;
1839 }
1840
1841 static void tg3_setup_flow_control(struct tg3 *tp, u32 local_adv, u32 remote_adv)
1842 {
1843 u8 new_tg3_flags = 0;
1844 u32 old_rx_mode = tp->rx_mode;
1845 u32 old_tx_mode = tp->tx_mode;
1846
1847 if (tp->link_config.autoneg == AUTONEG_ENABLE &&
1848 (tp->tg3_flags & TG3_FLAG_PAUSE_AUTONEG)) {
1849 if (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES)
1850 new_tg3_flags = tg3_resolve_flowctrl_1000X(local_adv,
1851 remote_adv);
1852 else
1853 new_tg3_flags = tg3_resolve_flowctrl_1000T(local_adv,
1854 remote_adv);
1855 } else {
1856 new_tg3_flags = tp->link_config.flowctrl;
1857 }
1858
1859 tp->link_config.active_flowctrl = new_tg3_flags;
1860
1861 if (new_tg3_flags & TG3_FLOW_CTRL_RX)
1862 tp->rx_mode |= RX_MODE_FLOW_CTRL_ENABLE;
1863 else
1864 tp->rx_mode &= ~RX_MODE_FLOW_CTRL_ENABLE;
1865
1866 if (old_rx_mode != tp->rx_mode) {
1867 tw32_f(MAC_RX_MODE, tp->rx_mode);
1868 }
1869
1870 if (new_tg3_flags & TG3_FLOW_CTRL_TX)
1871 tp->tx_mode |= TX_MODE_FLOW_CTRL_ENABLE;
1872 else
1873 tp->tx_mode &= ~TX_MODE_FLOW_CTRL_ENABLE;
1874
1875 if (old_tx_mode != tp->tx_mode) {
1876 tw32_f(MAC_TX_MODE, tp->tx_mode);
1877 }
1878 }
1879
1880 static void tg3_aux_stat_to_speed_duplex(struct tg3 *tp, u32 val, u16 *speed, u8 *duplex)
1881 {
1882 switch (val & MII_TG3_AUX_STAT_SPDMASK) {
1883 case MII_TG3_AUX_STAT_10HALF:
1884 *speed = SPEED_10;
1885 *duplex = DUPLEX_HALF;
1886 break;
1887
1888 case MII_TG3_AUX_STAT_10FULL:
1889 *speed = SPEED_10;
1890 *duplex = DUPLEX_FULL;
1891 break;
1892
1893 case MII_TG3_AUX_STAT_100HALF:
1894 *speed = SPEED_100;
1895 *duplex = DUPLEX_HALF;
1896 break;
1897
1898 case MII_TG3_AUX_STAT_100FULL:
1899 *speed = SPEED_100;
1900 *duplex = DUPLEX_FULL;
1901 break;
1902
1903 case MII_TG3_AUX_STAT_1000HALF:
1904 *speed = SPEED_1000;
1905 *duplex = DUPLEX_HALF;
1906 break;
1907
1908 case MII_TG3_AUX_STAT_1000FULL:
1909 *speed = SPEED_1000;
1910 *duplex = DUPLEX_FULL;
1911 break;
1912
1913 default:
1914 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
1915 *speed = (val & MII_TG3_AUX_STAT_100) ? SPEED_100 :
1916 SPEED_10;
1917 *duplex = (val & MII_TG3_AUX_STAT_FULL) ? DUPLEX_FULL :
1918 DUPLEX_HALF;
1919 break;
1920 }
1921 *speed = SPEED_INVALID;
1922 *duplex = DUPLEX_INVALID;
1923 break;
1924 };
1925 }
1926
1927 static void tg3_phy_copper_begin(struct tg3 *tp)
1928 {
1929 u32 new_adv;
1930 int i;
1931
1932 if (tp->link_config.phy_is_low_power) {
1933 /* Entering low power mode. Disable gigabit and
1934 * 100baseT advertisements.
1935 */
1936 tg3_writephy(tp, MII_TG3_CTRL, 0);
1937
1938 new_adv = (ADVERTISE_10HALF | ADVERTISE_10FULL |
1939 ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
1940 if (tp->tg3_flags & TG3_FLAG_WOL_SPEED_100MB)
1941 new_adv |= (ADVERTISE_100HALF | ADVERTISE_100FULL);
1942
1943 tg3_writephy(tp, MII_ADVERTISE, new_adv);
1944 } else if (tp->link_config.speed == SPEED_INVALID) {
1945 if (tp->tg3_flags & TG3_FLAG_10_100_ONLY)
1946 tp->link_config.advertising &=
1947 ~(ADVERTISED_1000baseT_Half |
1948 ADVERTISED_1000baseT_Full);
1949
1950 new_adv = ADVERTISE_CSMA;
1951 if (tp->link_config.advertising & ADVERTISED_10baseT_Half)
1952 new_adv |= ADVERTISE_10HALF;
1953 if (tp->link_config.advertising & ADVERTISED_10baseT_Full)
1954 new_adv |= ADVERTISE_10FULL;
1955 if (tp->link_config.advertising & ADVERTISED_100baseT_Half)
1956 new_adv |= ADVERTISE_100HALF;
1957 if (tp->link_config.advertising & ADVERTISED_100baseT_Full)
1958 new_adv |= ADVERTISE_100FULL;
1959
1960 new_adv |= tg3_advert_flowctrl_1000T(tp->link_config.flowctrl);
1961
1962 tg3_writephy(tp, MII_ADVERTISE, new_adv);
1963
1964 if (tp->link_config.advertising &
1965 (ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full)) {
1966 new_adv = 0;
1967 if (tp->link_config.advertising & ADVERTISED_1000baseT_Half)
1968 new_adv |= MII_TG3_CTRL_ADV_1000_HALF;
1969 if (tp->link_config.advertising & ADVERTISED_1000baseT_Full)
1970 new_adv |= MII_TG3_CTRL_ADV_1000_FULL;
1971 if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY) &&
1972 (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0 ||
1973 tp->pci_chip_rev_id == CHIPREV_ID_5701_B0))
1974 new_adv |= (MII_TG3_CTRL_AS_MASTER |
1975 MII_TG3_CTRL_ENABLE_AS_MASTER);
1976 tg3_writephy(tp, MII_TG3_CTRL, new_adv);
1977 } else {
1978 tg3_writephy(tp, MII_TG3_CTRL, 0);
1979 }
1980 } else {
1981 new_adv = tg3_advert_flowctrl_1000T(tp->link_config.flowctrl);
1982 new_adv |= ADVERTISE_CSMA;
1983
1984 /* Asking for a specific link mode. */
1985 if (tp->link_config.speed == SPEED_1000) {
1986 tg3_writephy(tp, MII_ADVERTISE, new_adv);
1987
1988 if (tp->link_config.duplex == DUPLEX_FULL)
1989 new_adv = MII_TG3_CTRL_ADV_1000_FULL;
1990 else
1991 new_adv = MII_TG3_CTRL_ADV_1000_HALF;
1992 if (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0 ||
1993 tp->pci_chip_rev_id == CHIPREV_ID_5701_B0)
1994 new_adv |= (MII_TG3_CTRL_AS_MASTER |
1995 MII_TG3_CTRL_ENABLE_AS_MASTER);
1996 } else {
1997 if (tp->link_config.speed == SPEED_100) {
1998 if (tp->link_config.duplex == DUPLEX_FULL)
1999 new_adv |= ADVERTISE_100FULL;
2000 else
2001 new_adv |= ADVERTISE_100HALF;
2002 } else {
2003 if (tp->link_config.duplex == DUPLEX_FULL)
2004 new_adv |= ADVERTISE_10FULL;
2005 else
2006 new_adv |= ADVERTISE_10HALF;
2007 }
2008 tg3_writephy(tp, MII_ADVERTISE, new_adv);
2009
2010 new_adv = 0;
2011 }
2012
2013 tg3_writephy(tp, MII_TG3_CTRL, new_adv);
2014 }
2015
2016 if (tp->link_config.autoneg == AUTONEG_DISABLE &&
2017 tp->link_config.speed != SPEED_INVALID) {
2018 u32 bmcr, orig_bmcr;
2019
2020 tp->link_config.active_speed = tp->link_config.speed;
2021 tp->link_config.active_duplex = tp->link_config.duplex;
2022
2023 bmcr = 0;
2024 switch (tp->link_config.speed) {
2025 default:
2026 case SPEED_10:
2027 break;
2028
2029 case SPEED_100:
2030 bmcr |= BMCR_SPEED100;
2031 break;
2032
2033 case SPEED_1000:
2034 bmcr |= TG3_BMCR_SPEED1000;
2035 break;
2036 };
2037
2038 if (tp->link_config.duplex == DUPLEX_FULL)
2039 bmcr |= BMCR_FULLDPLX;
2040
2041 if (!tg3_readphy(tp, MII_BMCR, &orig_bmcr) &&
2042 (bmcr != orig_bmcr)) {
2043 tg3_writephy(tp, MII_BMCR, BMCR_LOOPBACK);
2044 for (i = 0; i < 1500; i++) {
2045 u32 tmp;
2046
2047 udelay(10);
2048 if (tg3_readphy(tp, MII_BMSR, &tmp) ||
2049 tg3_readphy(tp, MII_BMSR, &tmp))
2050 continue;
2051 if (!(tmp & BMSR_LSTATUS)) {
2052 udelay(40);
2053 break;
2054 }
2055 }
2056 tg3_writephy(tp, MII_BMCR, bmcr);
2057 udelay(40);
2058 }
2059 } else {
2060 tg3_writephy(tp, MII_BMCR,
2061 BMCR_ANENABLE | BMCR_ANRESTART);
2062 }
2063 }
2064
2065 static int tg3_init_5401phy_dsp(struct tg3 *tp)
2066 {
2067 int err;
2068
2069 /* Turn off tap power management. */
2070 /* Set Extended packet length bit */
2071 err = tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x4c20);
2072
2073 err |= tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x0012);
2074 err |= tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x1804);
2075
2076 err |= tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x0013);
2077 err |= tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x1204);
2078
2079 err |= tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x8006);
2080 err |= tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x0132);
2081
2082 err |= tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x8006);
2083 err |= tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x0232);
2084
2085 err |= tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x201f);
2086 err |= tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x0a20);
2087
2088 udelay(40);
2089
2090 return err;
2091 }
2092
2093 static int tg3_copper_is_advertising_all(struct tg3 *tp, u32 mask)
2094 {
2095 u32 adv_reg, all_mask = 0;
2096
2097 if (mask & ADVERTISED_10baseT_Half)
2098 all_mask |= ADVERTISE_10HALF;
2099 if (mask & ADVERTISED_10baseT_Full)
2100 all_mask |= ADVERTISE_10FULL;
2101 if (mask & ADVERTISED_100baseT_Half)
2102 all_mask |= ADVERTISE_100HALF;
2103 if (mask & ADVERTISED_100baseT_Full)
2104 all_mask |= ADVERTISE_100FULL;
2105
2106 if (tg3_readphy(tp, MII_ADVERTISE, &adv_reg))
2107 return 0;
2108
2109 if ((adv_reg & all_mask) != all_mask)
2110 return 0;
2111 if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY)) {
2112 u32 tg3_ctrl;
2113
2114 all_mask = 0;
2115 if (mask & ADVERTISED_1000baseT_Half)
2116 all_mask |= ADVERTISE_1000HALF;
2117 if (mask & ADVERTISED_1000baseT_Full)
2118 all_mask |= ADVERTISE_1000FULL;
2119
2120 if (tg3_readphy(tp, MII_TG3_CTRL, &tg3_ctrl))
2121 return 0;
2122
2123 if ((tg3_ctrl & all_mask) != all_mask)
2124 return 0;
2125 }
2126 return 1;
2127 }
2128
2129 static int tg3_adv_1000T_flowctrl_ok(struct tg3 *tp, u32 *lcladv, u32 *rmtadv)
2130 {
2131 u32 curadv, reqadv;
2132
2133 if (tg3_readphy(tp, MII_ADVERTISE, lcladv))
2134 return 1;
2135
2136 curadv = *lcladv & (ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM);
2137 reqadv = tg3_advert_flowctrl_1000T(tp->link_config.flowctrl);
2138
2139 if (tp->link_config.active_duplex == DUPLEX_FULL) {
2140 if (curadv != reqadv)
2141 return 0;
2142
2143 if (tp->tg3_flags & TG3_FLAG_PAUSE_AUTONEG)
2144 tg3_readphy(tp, MII_LPA, rmtadv);
2145 } else {
2146 /* Reprogram the advertisement register, even if it
2147 * does not affect the current link. If the link
2148 * gets renegotiated in the future, we can save an
2149 * additional renegotiation cycle by advertising
2150 * it correctly in the first place.
2151 */
2152 if (curadv != reqadv) {
2153 *lcladv &= ~(ADVERTISE_PAUSE_CAP |
2154 ADVERTISE_PAUSE_ASYM);
2155 tg3_writephy(tp, MII_ADVERTISE, *lcladv | reqadv);
2156 }
2157 }
2158
2159 return 1;
2160 }
2161
2162 static int tg3_setup_copper_phy(struct tg3 *tp, int force_reset)
2163 {
2164 int current_link_up;
2165 u32 bmsr, dummy;
2166 u32 lcl_adv, rmt_adv;
2167 u16 current_speed;
2168 u8 current_duplex;
2169 int i, err;
2170
2171 tw32(MAC_EVENT, 0);
2172
2173 tw32_f(MAC_STATUS,
2174 (MAC_STATUS_SYNC_CHANGED |
2175 MAC_STATUS_CFG_CHANGED |
2176 MAC_STATUS_MI_COMPLETION |
2177 MAC_STATUS_LNKSTATE_CHANGED));
2178 udelay(40);
2179
2180 if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
2181 tw32_f(MAC_MI_MODE,
2182 (tp->mi_mode & ~MAC_MI_MODE_AUTO_POLL));
2183 udelay(80);
2184 }
2185
2186 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x02);
2187
2188 /* Some third-party PHYs need to be reset on link going
2189 * down.
2190 */
2191 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
2192 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 ||
2193 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) &&
2194 netif_carrier_ok(tp->dev)) {
2195 tg3_readphy(tp, MII_BMSR, &bmsr);
2196 if (!tg3_readphy(tp, MII_BMSR, &bmsr) &&
2197 !(bmsr & BMSR_LSTATUS))
2198 force_reset = 1;
2199 }
2200 if (force_reset)
2201 tg3_phy_reset(tp);
2202
2203 if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401) {
2204 tg3_readphy(tp, MII_BMSR, &bmsr);
2205 if (tg3_readphy(tp, MII_BMSR, &bmsr) ||
2206 !(tp->tg3_flags & TG3_FLAG_INIT_COMPLETE))
2207 bmsr = 0;
2208
2209 if (!(bmsr & BMSR_LSTATUS)) {
2210 err = tg3_init_5401phy_dsp(tp);
2211 if (err)
2212 return err;
2213
2214 tg3_readphy(tp, MII_BMSR, &bmsr);
2215 for (i = 0; i < 1000; i++) {
2216 udelay(10);
2217 if (!tg3_readphy(tp, MII_BMSR, &bmsr) &&
2218 (bmsr & BMSR_LSTATUS)) {
2219 udelay(40);
2220 break;
2221 }
2222 }
2223
2224 if ((tp->phy_id & PHY_ID_REV_MASK) == PHY_REV_BCM5401_B0 &&
2225 !(bmsr & BMSR_LSTATUS) &&
2226 tp->link_config.active_speed == SPEED_1000) {
2227 err = tg3_phy_reset(tp);
2228 if (!err)
2229 err = tg3_init_5401phy_dsp(tp);
2230 if (err)
2231 return err;
2232 }
2233 }
2234 } else if (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0 ||
2235 tp->pci_chip_rev_id == CHIPREV_ID_5701_B0) {
2236 /* 5701 {A0,B0} CRC bug workaround */
2237 tg3_writephy(tp, 0x15, 0x0a75);
2238 tg3_writephy(tp, 0x1c, 0x8c68);
2239 tg3_writephy(tp, 0x1c, 0x8d68);
2240 tg3_writephy(tp, 0x1c, 0x8c68);
2241 }
2242
2243 /* Clear pending interrupts... */
2244 tg3_readphy(tp, MII_TG3_ISTAT, &dummy);
2245 tg3_readphy(tp, MII_TG3_ISTAT, &dummy);
2246
2247 if (tp->tg3_flags & TG3_FLAG_USE_MI_INTERRUPT)
2248 tg3_writephy(tp, MII_TG3_IMASK, ~MII_TG3_INT_LINKCHG);
2249 else if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5906)
2250 tg3_writephy(tp, MII_TG3_IMASK, ~0);
2251
2252 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
2253 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701) {
2254 if (tp->led_ctrl == LED_CTRL_MODE_PHY_1)
2255 tg3_writephy(tp, MII_TG3_EXT_CTRL,
2256 MII_TG3_EXT_CTRL_LNK3_LED_MODE);
2257 else
2258 tg3_writephy(tp, MII_TG3_EXT_CTRL, 0);
2259 }
2260
2261 current_link_up = 0;
2262 current_speed = SPEED_INVALID;
2263 current_duplex = DUPLEX_INVALID;
2264
2265 if (tp->tg3_flags2 & TG3_FLG2_CAPACITIVE_COUPLING) {
2266 u32 val;
2267
2268 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x4007);
2269 tg3_readphy(tp, MII_TG3_AUX_CTRL, &val);
2270 if (!(val & (1 << 10))) {
2271 val |= (1 << 10);
2272 tg3_writephy(tp, MII_TG3_AUX_CTRL, val);
2273 goto relink;
2274 }
2275 }
2276
2277 bmsr = 0;
2278 for (i = 0; i < 100; i++) {
2279 tg3_readphy(tp, MII_BMSR, &bmsr);
2280 if (!tg3_readphy(tp, MII_BMSR, &bmsr) &&
2281 (bmsr & BMSR_LSTATUS))
2282 break;
2283 udelay(40);
2284 }
2285
2286 if (bmsr & BMSR_LSTATUS) {
2287 u32 aux_stat, bmcr;
2288
2289 tg3_readphy(tp, MII_TG3_AUX_STAT, &aux_stat);
2290 for (i = 0; i < 2000; i++) {
2291 udelay(10);
2292 if (!tg3_readphy(tp, MII_TG3_AUX_STAT, &aux_stat) &&
2293 aux_stat)
2294 break;
2295 }
2296
2297 tg3_aux_stat_to_speed_duplex(tp, aux_stat,
2298 &current_speed,
2299 &current_duplex);
2300
2301 bmcr = 0;
2302 for (i = 0; i < 200; i++) {
2303 tg3_readphy(tp, MII_BMCR, &bmcr);
2304 if (tg3_readphy(tp, MII_BMCR, &bmcr))
2305 continue;
2306 if (bmcr && bmcr != 0x7fff)
2307 break;
2308 udelay(10);
2309 }
2310
2311 lcl_adv = 0;
2312 rmt_adv = 0;
2313
2314 tp->link_config.active_speed = current_speed;
2315 tp->link_config.active_duplex = current_duplex;
2316
2317 if (tp->link_config.autoneg == AUTONEG_ENABLE) {
2318 if ((bmcr & BMCR_ANENABLE) &&
2319 tg3_copper_is_advertising_all(tp,
2320 tp->link_config.advertising)) {
2321 if (tg3_adv_1000T_flowctrl_ok(tp, &lcl_adv,
2322 &rmt_adv))
2323 current_link_up = 1;
2324 }
2325 } else {
2326 if (!(bmcr & BMCR_ANENABLE) &&
2327 tp->link_config.speed == current_speed &&
2328 tp->link_config.duplex == current_duplex &&
2329 tp->link_config.flowctrl ==
2330 tp->link_config.active_flowctrl) {
2331 current_link_up = 1;
2332 }
2333 }
2334
2335 if (current_link_up == 1 &&
2336 tp->link_config.active_duplex == DUPLEX_FULL)
2337 tg3_setup_flow_control(tp, lcl_adv, rmt_adv);
2338 }
2339
2340 relink:
2341 if (current_link_up == 0 || tp->link_config.phy_is_low_power) {
2342 u32 tmp;
2343
2344 tg3_phy_copper_begin(tp);
2345
2346 tg3_readphy(tp, MII_BMSR, &tmp);
2347 if (!tg3_readphy(tp, MII_BMSR, &tmp) &&
2348 (tmp & BMSR_LSTATUS))
2349 current_link_up = 1;
2350 }
2351
2352 tp->mac_mode &= ~MAC_MODE_PORT_MODE_MASK;
2353 if (current_link_up == 1) {
2354 if (tp->link_config.active_speed == SPEED_100 ||
2355 tp->link_config.active_speed == SPEED_10)
2356 tp->mac_mode |= MAC_MODE_PORT_MODE_MII;
2357 else
2358 tp->mac_mode |= MAC_MODE_PORT_MODE_GMII;
2359 } else
2360 tp->mac_mode |= MAC_MODE_PORT_MODE_GMII;
2361
2362 tp->mac_mode &= ~MAC_MODE_HALF_DUPLEX;
2363 if (tp->link_config.active_duplex == DUPLEX_HALF)
2364 tp->mac_mode |= MAC_MODE_HALF_DUPLEX;
2365
2366 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700) {
2367 if (current_link_up == 1 &&
2368 tg3_5700_link_polarity(tp, tp->link_config.active_speed))
2369 tp->mac_mode |= MAC_MODE_LINK_POLARITY;
2370 else
2371 tp->mac_mode &= ~MAC_MODE_LINK_POLARITY;
2372 }
2373
2374 /* ??? Without this setting Netgear GA302T PHY does not
2375 * ??? send/receive packets...
2376 */
2377 if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5411 &&
2378 tp->pci_chip_rev_id == CHIPREV_ID_5700_ALTIMA) {
2379 tp->mi_mode |= MAC_MI_MODE_AUTO_POLL;
2380 tw32_f(MAC_MI_MODE, tp->mi_mode);
2381 udelay(80);
2382 }
2383
2384 tw32_f(MAC_MODE, tp->mac_mode);
2385 udelay(40);
2386
2387 if (tp->tg3_flags & TG3_FLAG_USE_LINKCHG_REG) {
2388 /* Polled via timer. */
2389 tw32_f(MAC_EVENT, 0);
2390 } else {
2391 tw32_f(MAC_EVENT, MAC_EVENT_LNKSTATE_CHANGED);
2392 }
2393 udelay(40);
2394
2395 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 &&
2396 current_link_up == 1 &&
2397 tp->link_config.active_speed == SPEED_1000 &&
2398 ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) ||
2399 (tp->tg3_flags & TG3_FLAG_PCI_HIGH_SPEED))) {
2400 udelay(120);
2401 tw32_f(MAC_STATUS,
2402 (MAC_STATUS_SYNC_CHANGED |
2403 MAC_STATUS_CFG_CHANGED));
2404 udelay(40);
2405 tg3_write_mem(tp,
2406 NIC_SRAM_FIRMWARE_MBOX,
2407 NIC_SRAM_FIRMWARE_MBOX_MAGIC2);
2408 }
2409
2410 if (current_link_up != netif_carrier_ok(tp->dev)) {
2411 if (current_link_up)
2412 netif_carrier_on(tp->dev);
2413 else
2414 netif_carrier_off(tp->dev);
2415 tg3_link_report(tp);
2416 }
2417
2418 return 0;
2419 }
2420
2421 struct tg3_fiber_aneginfo {
2422 int state;
2423 #define ANEG_STATE_UNKNOWN 0
2424 #define ANEG_STATE_AN_ENABLE 1
2425 #define ANEG_STATE_RESTART_INIT 2
2426 #define ANEG_STATE_RESTART 3
2427 #define ANEG_STATE_DISABLE_LINK_OK 4
2428 #define ANEG_STATE_ABILITY_DETECT_INIT 5
2429 #define ANEG_STATE_ABILITY_DETECT 6
2430 #define ANEG_STATE_ACK_DETECT_INIT 7
2431 #define ANEG_STATE_ACK_DETECT 8
2432 #define ANEG_STATE_COMPLETE_ACK_INIT 9
2433 #define ANEG_STATE_COMPLETE_ACK 10
2434 #define ANEG_STATE_IDLE_DETECT_INIT 11
2435 #define ANEG_STATE_IDLE_DETECT 12
2436 #define ANEG_STATE_LINK_OK 13
2437 #define ANEG_STATE_NEXT_PAGE_WAIT_INIT 14
2438 #define ANEG_STATE_NEXT_PAGE_WAIT 15
2439
2440 u32 flags;
2441 #define MR_AN_ENABLE 0x00000001
2442 #define MR_RESTART_AN 0x00000002
2443 #define MR_AN_COMPLETE 0x00000004
2444 #define MR_PAGE_RX 0x00000008
2445 #define MR_NP_LOADED 0x00000010
2446 #define MR_TOGGLE_TX 0x00000020
2447 #define MR_LP_ADV_FULL_DUPLEX 0x00000040
2448 #define MR_LP_ADV_HALF_DUPLEX 0x00000080
2449 #define MR_LP_ADV_SYM_PAUSE 0x00000100
2450 #define MR_LP_ADV_ASYM_PAUSE 0x00000200
2451 #define MR_LP_ADV_REMOTE_FAULT1 0x00000400
2452 #define MR_LP_ADV_REMOTE_FAULT2 0x00000800
2453 #define MR_LP_ADV_NEXT_PAGE 0x00001000
2454 #define MR_TOGGLE_RX 0x00002000
2455 #define MR_NP_RX 0x00004000
2456
2457 #define MR_LINK_OK 0x80000000
2458
2459 unsigned long link_time, cur_time;
2460
2461 u32 ability_match_cfg;
2462 int ability_match_count;
2463
2464 char ability_match, idle_match, ack_match;
2465
2466 u32 txconfig, rxconfig;
2467 #define ANEG_CFG_NP 0x00000080
2468 #define ANEG_CFG_ACK 0x00000040
2469 #define ANEG_CFG_RF2 0x00000020
2470 #define ANEG_CFG_RF1 0x00000010
2471 #define ANEG_CFG_PS2 0x00000001
2472 #define ANEG_CFG_PS1 0x00008000
2473 #define ANEG_CFG_HD 0x00004000
2474 #define ANEG_CFG_FD 0x00002000
2475 #define ANEG_CFG_INVAL 0x00001f06
2476
2477 };
2478 #define ANEG_OK 0
2479 #define ANEG_DONE 1
2480 #define ANEG_TIMER_ENAB 2
2481 #define ANEG_FAILED -1
2482
2483 #define ANEG_STATE_SETTLE_TIME 10000
2484
2485 static int tg3_fiber_aneg_smachine(struct tg3 *tp,
2486 struct tg3_fiber_aneginfo *ap)
2487 {
2488 u16 flowctrl;
2489 unsigned long delta;
2490 u32 rx_cfg_reg;
2491 int ret;
2492
2493 if (ap->state == ANEG_STATE_UNKNOWN) {
2494 ap->rxconfig = 0;
2495 ap->link_time = 0;
2496 ap->cur_time = 0;
2497 ap->ability_match_cfg = 0;
2498 ap->ability_match_count = 0;
2499 ap->ability_match = 0;
2500 ap->idle_match = 0;
2501 ap->ack_match = 0;
2502 }
2503 ap->cur_time++;
2504
2505 if (tr32(MAC_STATUS) & MAC_STATUS_RCVD_CFG) {
2506 rx_cfg_reg = tr32(MAC_RX_AUTO_NEG);
2507
2508 if (rx_cfg_reg != ap->ability_match_cfg) {
2509 ap->ability_match_cfg = rx_cfg_reg;
2510 ap->ability_match = 0;
2511 ap->ability_match_count = 0;
2512 } else {
2513 if (++ap->ability_match_count > 1) {
2514 ap->ability_match = 1;
2515 ap->ability_match_cfg = rx_cfg_reg;
2516 }
2517 }
2518 if (rx_cfg_reg & ANEG_CFG_ACK)
2519 ap->ack_match = 1;
2520 else
2521 ap->ack_match = 0;
2522
2523 ap->idle_match = 0;
2524 } else {
2525 ap->idle_match = 1;
2526 ap->ability_match_cfg = 0;
2527 ap->ability_match_count = 0;
2528 ap->ability_match = 0;
2529 ap->ack_match = 0;
2530
2531 rx_cfg_reg = 0;
2532 }
2533
2534 ap->rxconfig = rx_cfg_reg;
2535 ret = ANEG_OK;
2536
2537 switch(ap->state) {
2538 case ANEG_STATE_UNKNOWN:
2539 if (ap->flags & (MR_AN_ENABLE | MR_RESTART_AN))
2540 ap->state = ANEG_STATE_AN_ENABLE;
2541
2542 /* fallthru */
2543 case ANEG_STATE_AN_ENABLE:
2544 ap->flags &= ~(MR_AN_COMPLETE | MR_PAGE_RX);
2545 if (ap->flags & MR_AN_ENABLE) {
2546 ap->link_time = 0;
2547 ap->cur_time = 0;
2548 ap->ability_match_cfg = 0;
2549 ap->ability_match_count = 0;
2550 ap->ability_match = 0;
2551 ap->idle_match = 0;
2552 ap->ack_match = 0;
2553
2554 ap->state = ANEG_STATE_RESTART_INIT;
2555 } else {
2556 ap->state = ANEG_STATE_DISABLE_LINK_OK;
2557 }
2558 break;
2559
2560 case ANEG_STATE_RESTART_INIT:
2561 ap->link_time = ap->cur_time;
2562 ap->flags &= ~(MR_NP_LOADED);
2563 ap->txconfig = 0;
2564 tw32(MAC_TX_AUTO_NEG, 0);
2565 tp->mac_mode |= MAC_MODE_SEND_CONFIGS;
2566 tw32_f(MAC_MODE, tp->mac_mode);
2567 udelay(40);
2568
2569 ret = ANEG_TIMER_ENAB;
2570 ap->state = ANEG_STATE_RESTART;
2571
2572 /* fallthru */
2573 case ANEG_STATE_RESTART:
2574 delta = ap->cur_time - ap->link_time;
2575 if (delta > ANEG_STATE_SETTLE_TIME) {
2576 ap->state = ANEG_STATE_ABILITY_DETECT_INIT;
2577 } else {
2578 ret = ANEG_TIMER_ENAB;
2579 }
2580 break;
2581
2582 case ANEG_STATE_DISABLE_LINK_OK:
2583 ret = ANEG_DONE;
2584 break;
2585
2586 case ANEG_STATE_ABILITY_DETECT_INIT:
2587 ap->flags &= ~(MR_TOGGLE_TX);
2588 ap->txconfig = ANEG_CFG_FD;
2589 flowctrl = tg3_advert_flowctrl_1000X(tp->link_config.flowctrl);
2590 if (flowctrl & ADVERTISE_1000XPAUSE)
2591 ap->txconfig |= ANEG_CFG_PS1;
2592 if (flowctrl & ADVERTISE_1000XPSE_ASYM)
2593 ap->txconfig |= ANEG_CFG_PS2;
2594 tw32(MAC_TX_AUTO_NEG, ap->txconfig);
2595 tp->mac_mode |= MAC_MODE_SEND_CONFIGS;
2596 tw32_f(MAC_MODE, tp->mac_mode);
2597 udelay(40);
2598
2599 ap->state = ANEG_STATE_ABILITY_DETECT;
2600 break;
2601
2602 case ANEG_STATE_ABILITY_DETECT:
2603 if (ap->ability_match != 0 && ap->rxconfig != 0) {
2604 ap->state = ANEG_STATE_ACK_DETECT_INIT;
2605 }
2606 break;
2607
2608 case ANEG_STATE_ACK_DETECT_INIT:
2609 ap->txconfig |= ANEG_CFG_ACK;
2610 tw32(MAC_TX_AUTO_NEG, ap->txconfig);
2611 tp->mac_mode |= MAC_MODE_SEND_CONFIGS;
2612 tw32_f(MAC_MODE, tp->mac_mode);
2613 udelay(40);
2614
2615 ap->state = ANEG_STATE_ACK_DETECT;
2616
2617 /* fallthru */
2618 case ANEG_STATE_ACK_DETECT:
2619 if (ap->ack_match != 0) {
2620 if ((ap->rxconfig & ~ANEG_CFG_ACK) ==
2621 (ap->ability_match_cfg & ~ANEG_CFG_ACK)) {
2622 ap->state = ANEG_STATE_COMPLETE_ACK_INIT;
2623 } else {
2624 ap->state = ANEG_STATE_AN_ENABLE;
2625 }
2626 } else if (ap->ability_match != 0 &&
2627 ap->rxconfig == 0) {
2628 ap->state = ANEG_STATE_AN_ENABLE;
2629 }
2630 break;
2631
2632 case ANEG_STATE_COMPLETE_ACK_INIT:
2633 if (ap->rxconfig & ANEG_CFG_INVAL) {
2634 ret = ANEG_FAILED;
2635 break;
2636 }
2637 ap->flags &= ~(MR_LP_ADV_FULL_DUPLEX |
2638 MR_LP_ADV_HALF_DUPLEX |
2639 MR_LP_ADV_SYM_PAUSE |
2640 MR_LP_ADV_ASYM_PAUSE |
2641 MR_LP_ADV_REMOTE_FAULT1 |
2642 MR_LP_ADV_REMOTE_FAULT2 |
2643 MR_LP_ADV_NEXT_PAGE |
2644 MR_TOGGLE_RX |
2645 MR_NP_RX);
2646 if (ap->rxconfig & ANEG_CFG_FD)
2647 ap->flags |= MR_LP_ADV_FULL_DUPLEX;
2648 if (ap->rxconfig & ANEG_CFG_HD)
2649 ap->flags |= MR_LP_ADV_HALF_DUPLEX;
2650 if (ap->rxconfig & ANEG_CFG_PS1)
2651 ap->flags |= MR_LP_ADV_SYM_PAUSE;
2652 if (ap->rxconfig & ANEG_CFG_PS2)
2653 ap->flags |= MR_LP_ADV_ASYM_PAUSE;
2654 if (ap->rxconfig & ANEG_CFG_RF1)
2655 ap->flags |= MR_LP_ADV_REMOTE_FAULT1;
2656 if (ap->rxconfig & ANEG_CFG_RF2)
2657 ap->flags |= MR_LP_ADV_REMOTE_FAULT2;
2658 if (ap->rxconfig & ANEG_CFG_NP)
2659 ap->flags |= MR_LP_ADV_NEXT_PAGE;
2660
2661 ap->link_time = ap->cur_time;
2662
2663 ap->flags ^= (MR_TOGGLE_TX);
2664 if (ap->rxconfig & 0x0008)
2665 ap->flags |= MR_TOGGLE_RX;
2666 if (ap->rxconfig & ANEG_CFG_NP)
2667 ap->flags |= MR_NP_RX;
2668 ap->flags |= MR_PAGE_RX;
2669
2670 ap->state = ANEG_STATE_COMPLETE_ACK;
2671 ret = ANEG_TIMER_ENAB;
2672 break;
2673
2674 case ANEG_STATE_COMPLETE_ACK:
2675 if (ap->ability_match != 0 &&
2676 ap->rxconfig == 0) {
2677 ap->state = ANEG_STATE_AN_ENABLE;
2678 break;
2679 }
2680 delta = ap->cur_time - ap->link_time;
2681 if (delta > ANEG_STATE_SETTLE_TIME) {
2682 if (!(ap->flags & (MR_LP_ADV_NEXT_PAGE))) {
2683 ap->state = ANEG_STATE_IDLE_DETECT_INIT;
2684 } else {
2685 if ((ap->txconfig & ANEG_CFG_NP) == 0 &&
2686 !(ap->flags & MR_NP_RX)) {
2687 ap->state = ANEG_STATE_IDLE_DETECT_INIT;
2688 } else {
2689 ret = ANEG_FAILED;
2690 }
2691 }
2692 }
2693 break;
2694
2695 case ANEG_STATE_IDLE_DETECT_INIT:
2696 ap->link_time = ap->cur_time;
2697 tp->mac_mode &= ~MAC_MODE_SEND_CONFIGS;
2698 tw32_f(MAC_MODE, tp->mac_mode);
2699 udelay(40);
2700
2701 ap->state = ANEG_STATE_IDLE_DETECT;
2702 ret = ANEG_TIMER_ENAB;
2703 break;
2704
2705 case ANEG_STATE_IDLE_DETECT:
2706 if (ap->ability_match != 0 &&
2707 ap->rxconfig == 0) {
2708 ap->state = ANEG_STATE_AN_ENABLE;
2709 break;
2710 }
2711 delta = ap->cur_time - ap->link_time;
2712 if (delta > ANEG_STATE_SETTLE_TIME) {
2713 /* XXX another gem from the Broadcom driver :( */
2714 ap->state = ANEG_STATE_LINK_OK;
2715 }
2716 break;
2717
2718 case ANEG_STATE_LINK_OK:
2719 ap->flags |= (MR_AN_COMPLETE | MR_LINK_OK);
2720 ret = ANEG_DONE;
2721 break;
2722
2723 case ANEG_STATE_NEXT_PAGE_WAIT_INIT:
2724 /* ??? unimplemented */
2725 break;
2726
2727 case ANEG_STATE_NEXT_PAGE_WAIT:
2728 /* ??? unimplemented */
2729 break;
2730
2731 default:
2732 ret = ANEG_FAILED;
2733 break;
2734 };
2735
2736 return ret;
2737 }
2738
2739 static int fiber_autoneg(struct tg3 *tp, u32 *txflags, u32 *rxflags)
2740 {
2741 int res = 0;
2742 struct tg3_fiber_aneginfo aninfo;
2743 int status = ANEG_FAILED;
2744 unsigned int tick;
2745 u32 tmp;
2746
2747 tw32_f(MAC_TX_AUTO_NEG, 0);
2748
2749 tmp = tp->mac_mode & ~MAC_MODE_PORT_MODE_MASK;
2750 tw32_f(MAC_MODE, tmp | MAC_MODE_PORT_MODE_GMII);
2751 udelay(40);
2752
2753 tw32_f(MAC_MODE, tp->mac_mode | MAC_MODE_SEND_CONFIGS);
2754 udelay(40);
2755
2756 memset(&aninfo, 0, sizeof(aninfo));
2757 aninfo.flags |= MR_AN_ENABLE;
2758 aninfo.state = ANEG_STATE_UNKNOWN;
2759 aninfo.cur_time = 0;
2760 tick = 0;
2761 while (++tick < 195000) {
2762 status = tg3_fiber_aneg_smachine(tp, &aninfo);
2763 if (status == ANEG_DONE || status == ANEG_FAILED)
2764 break;
2765
2766 udelay(1);
2767 }
2768
2769 tp->mac_mode &= ~MAC_MODE_SEND_CONFIGS;
2770 tw32_f(MAC_MODE, tp->mac_mode);
2771 udelay(40);
2772
2773 *txflags = aninfo.txconfig;
2774 *rxflags = aninfo.flags;
2775
2776 if (status == ANEG_DONE &&
2777 (aninfo.flags & (MR_AN_COMPLETE | MR_LINK_OK |
2778 MR_LP_ADV_FULL_DUPLEX)))
2779 res = 1;
2780
2781 return res;
2782 }
2783
2784 static void tg3_init_bcm8002(struct tg3 *tp)
2785 {
2786 u32 mac_status = tr32(MAC_STATUS);
2787 int i;
2788
2789 /* Reset when initting first time or we have a link. */
2790 if ((tp->tg3_flags & TG3_FLAG_INIT_COMPLETE) &&
2791 !(mac_status & MAC_STATUS_PCS_SYNCED))
2792 return;
2793
2794 /* Set PLL lock range. */
2795 tg3_writephy(tp, 0x16, 0x8007);
2796
2797 /* SW reset */
2798 tg3_writephy(tp, MII_BMCR, BMCR_RESET);
2799
2800 /* Wait for reset to complete. */
2801 /* XXX schedule_timeout() ... */
2802 for (i = 0; i < 500; i++)
2803 udelay(10);
2804
2805 /* Config mode; select PMA/Ch 1 regs. */
2806 tg3_writephy(tp, 0x10, 0x8411);
2807
2808 /* Enable auto-lock and comdet, select txclk for tx. */
2809 tg3_writephy(tp, 0x11, 0x0a10);
2810
2811 tg3_writephy(tp, 0x18, 0x00a0);
2812 tg3_writephy(tp, 0x16, 0x41ff);
2813
2814 /* Assert and deassert POR. */
2815 tg3_writephy(tp, 0x13, 0x0400);
2816 udelay(40);
2817 tg3_writephy(tp, 0x13, 0x0000);
2818
2819 tg3_writephy(tp, 0x11, 0x0a50);
2820 udelay(40);
2821 tg3_writephy(tp, 0x11, 0x0a10);
2822
2823 /* Wait for signal to stabilize */
2824 /* XXX schedule_timeout() ... */
2825 for (i = 0; i < 15000; i++)
2826 udelay(10);
2827
2828 /* Deselect the channel register so we can read the PHYID
2829 * later.
2830 */
2831 tg3_writephy(tp, 0x10, 0x8011);
2832 }
2833
2834 static int tg3_setup_fiber_hw_autoneg(struct tg3 *tp, u32 mac_status)
2835 {
2836 u16 flowctrl;
2837 u32 sg_dig_ctrl, sg_dig_status;
2838 u32 serdes_cfg, expected_sg_dig_ctrl;
2839 int workaround, port_a;
2840 int current_link_up;
2841
2842 serdes_cfg = 0;
2843 expected_sg_dig_ctrl = 0;
2844 workaround = 0;
2845 port_a = 1;
2846 current_link_up = 0;
2847
2848 if (tp->pci_chip_rev_id != CHIPREV_ID_5704_A0 &&
2849 tp->pci_chip_rev_id != CHIPREV_ID_5704_A1) {
2850 workaround = 1;
2851 if (tr32(TG3PCI_DUAL_MAC_CTRL) & DUAL_MAC_CTRL_ID)
2852 port_a = 0;
2853
2854 /* preserve bits 0-11,13,14 for signal pre-emphasis */
2855 /* preserve bits 20-23 for voltage regulator */
2856 serdes_cfg = tr32(MAC_SERDES_CFG) & 0x00f06fff;
2857 }
2858
2859 sg_dig_ctrl = tr32(SG_DIG_CTRL);
2860
2861 if (tp->link_config.autoneg != AUTONEG_ENABLE) {
2862 if (sg_dig_ctrl & SG_DIG_USING_HW_AUTONEG) {
2863 if (workaround) {
2864 u32 val = serdes_cfg;
2865
2866 if (port_a)
2867 val |= 0xc010000;
2868 else
2869 val |= 0x4010000;
2870 tw32_f(MAC_SERDES_CFG, val);
2871 }
2872
2873 tw32_f(SG_DIG_CTRL, SG_DIG_COMMON_SETUP);
2874 }
2875 if (mac_status & MAC_STATUS_PCS_SYNCED) {
2876 tg3_setup_flow_control(tp, 0, 0);
2877 current_link_up = 1;
2878 }
2879 goto out;
2880 }
2881
2882 /* Want auto-negotiation. */
2883 expected_sg_dig_ctrl = SG_DIG_USING_HW_AUTONEG | SG_DIG_COMMON_SETUP;
2884
2885 flowctrl = tg3_advert_flowctrl_1000X(tp->link_config.flowctrl);
2886 if (flowctrl & ADVERTISE_1000XPAUSE)
2887 expected_sg_dig_ctrl |= SG_DIG_PAUSE_CAP;
2888 if (flowctrl & ADVERTISE_1000XPSE_ASYM)
2889 expected_sg_dig_ctrl |= SG_DIG_ASYM_PAUSE;
2890
2891 if (sg_dig_ctrl != expected_sg_dig_ctrl) {
2892 if ((tp->tg3_flags2 & TG3_FLG2_PARALLEL_DETECT) &&
2893 tp->serdes_counter &&
2894 ((mac_status & (MAC_STATUS_PCS_SYNCED |
2895 MAC_STATUS_RCVD_CFG)) ==
2896 MAC_STATUS_PCS_SYNCED)) {
2897 tp->serdes_counter--;
2898 current_link_up = 1;
2899 goto out;
2900 }
2901 restart_autoneg:
2902 if (workaround)
2903 tw32_f(MAC_SERDES_CFG, serdes_cfg | 0xc011000);
2904 tw32_f(SG_DIG_CTRL, expected_sg_dig_ctrl | SG_DIG_SOFT_RESET);
2905 udelay(5);
2906 tw32_f(SG_DIG_CTRL, expected_sg_dig_ctrl);
2907
2908 tp->serdes_counter = SERDES_AN_TIMEOUT_5704S;
2909 tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
2910 } else if (mac_status & (MAC_STATUS_PCS_SYNCED |
2911 MAC_STATUS_SIGNAL_DET)) {
2912 sg_dig_status = tr32(SG_DIG_STATUS);
2913 mac_status = tr32(MAC_STATUS);
2914
2915 if ((sg_dig_status & SG_DIG_AUTONEG_COMPLETE) &&
2916 (mac_status & MAC_STATUS_PCS_SYNCED)) {
2917 u32 local_adv = 0, remote_adv = 0;
2918
2919 if (sg_dig_ctrl & SG_DIG_PAUSE_CAP)
2920 local_adv |= ADVERTISE_1000XPAUSE;
2921 if (sg_dig_ctrl & SG_DIG_ASYM_PAUSE)
2922 local_adv |= ADVERTISE_1000XPSE_ASYM;
2923
2924 if (sg_dig_status & SG_DIG_PARTNER_PAUSE_CAPABLE)
2925 remote_adv |= LPA_1000XPAUSE;
2926 if (sg_dig_status & SG_DIG_PARTNER_ASYM_PAUSE)
2927 remote_adv |= LPA_1000XPAUSE_ASYM;
2928
2929 tg3_setup_flow_control(tp, local_adv, remote_adv);
2930 current_link_up = 1;
2931 tp->serdes_counter = 0;
2932 tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
2933 } else if (!(sg_dig_status & SG_DIG_AUTONEG_COMPLETE)) {
2934 if (tp->serdes_counter)
2935 tp->serdes_counter--;
2936 else {
2937 if (workaround) {
2938 u32 val = serdes_cfg;
2939
2940 if (port_a)
2941 val |= 0xc010000;
2942 else
2943 val |= 0x4010000;
2944
2945 tw32_f(MAC_SERDES_CFG, val);
2946 }
2947
2948 tw32_f(SG_DIG_CTRL, SG_DIG_COMMON_SETUP);
2949 udelay(40);
2950
2951 /* Link parallel detection - link is up */
2952 /* only if we have PCS_SYNC and not */
2953 /* receiving config code words */
2954 mac_status = tr32(MAC_STATUS);
2955 if ((mac_status & MAC_STATUS_PCS_SYNCED) &&
2956 !(mac_status & MAC_STATUS_RCVD_CFG)) {
2957 tg3_setup_flow_control(tp, 0, 0);
2958 current_link_up = 1;
2959 tp->tg3_flags2 |=
2960 TG3_FLG2_PARALLEL_DETECT;
2961 tp->serdes_counter =
2962 SERDES_PARALLEL_DET_TIMEOUT;
2963 } else
2964 goto restart_autoneg;
2965 }
2966 }
2967 } else {
2968 tp->serdes_counter = SERDES_AN_TIMEOUT_5704S;
2969 tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
2970 }
2971
2972 out:
2973 return current_link_up;
2974 }
2975
2976 static int tg3_setup_fiber_by_hand(struct tg3 *tp, u32 mac_status)
2977 {
2978 int current_link_up = 0;
2979
2980 if (!(mac_status & MAC_STATUS_PCS_SYNCED))
2981 goto out;
2982
2983 if (tp->link_config.autoneg == AUTONEG_ENABLE) {
2984 u32 txflags, rxflags;
2985 int i;
2986
2987 if (fiber_autoneg(tp, &txflags, &rxflags)) {
2988 u32 local_adv = 0, remote_adv = 0;
2989
2990 if (txflags & ANEG_CFG_PS1)
2991 local_adv |= ADVERTISE_1000XPAUSE;
2992 if (txflags & ANEG_CFG_PS2)
2993 local_adv |= ADVERTISE_1000XPSE_ASYM;
2994
2995 if (rxflags & MR_LP_ADV_SYM_PAUSE)
2996 remote_adv |= LPA_1000XPAUSE;
2997 if (rxflags & MR_LP_ADV_ASYM_PAUSE)
2998 remote_adv |= LPA_1000XPAUSE_ASYM;
2999
3000 tg3_setup_flow_control(tp, local_adv, remote_adv);
3001
3002 current_link_up = 1;
3003 }
3004 for (i = 0; i < 30; i++) {
3005 udelay(20);
3006 tw32_f(MAC_STATUS,
3007 (MAC_STATUS_SYNC_CHANGED |
3008 MAC_STATUS_CFG_CHANGED));
3009 udelay(40);
3010 if ((tr32(MAC_STATUS) &
3011 (MAC_STATUS_SYNC_CHANGED |
3012 MAC_STATUS_CFG_CHANGED)) == 0)
3013 break;
3014 }
3015
3016 mac_status = tr32(MAC_STATUS);
3017 if (current_link_up == 0 &&
3018 (mac_status & MAC_STATUS_PCS_SYNCED) &&
3019 !(mac_status & MAC_STATUS_RCVD_CFG))
3020 current_link_up = 1;
3021 } else {
3022 tg3_setup_flow_control(tp, 0, 0);
3023
3024 /* Forcing 1000FD link up. */
3025 current_link_up = 1;
3026
3027 tw32_f(MAC_MODE, (tp->mac_mode | MAC_MODE_SEND_CONFIGS));
3028 udelay(40);
3029
3030 tw32_f(MAC_MODE, tp->mac_mode);
3031 udelay(40);
3032 }
3033
3034 out:
3035 return current_link_up;
3036 }
3037
3038 static int tg3_setup_fiber_phy(struct tg3 *tp, int force_reset)
3039 {
3040 u32 orig_pause_cfg;
3041 u16 orig_active_speed;
3042 u8 orig_active_duplex;
3043 u32 mac_status;
3044 int current_link_up;
3045 int i;
3046
3047 orig_pause_cfg = tp->link_config.active_flowctrl;
3048 orig_active_speed = tp->link_config.active_speed;
3049 orig_active_duplex = tp->link_config.active_duplex;
3050
3051 if (!(tp->tg3_flags2 & TG3_FLG2_HW_AUTONEG) &&
3052 netif_carrier_ok(tp->dev) &&
3053 (tp->tg3_flags & TG3_FLAG_INIT_COMPLETE)) {
3054 mac_status = tr32(MAC_STATUS);
3055 mac_status &= (MAC_STATUS_PCS_SYNCED |
3056 MAC_STATUS_SIGNAL_DET |
3057 MAC_STATUS_CFG_CHANGED |
3058 MAC_STATUS_RCVD_CFG);
3059 if (mac_status == (MAC_STATUS_PCS_SYNCED |
3060 MAC_STATUS_SIGNAL_DET)) {
3061 tw32_f(MAC_STATUS, (MAC_STATUS_SYNC_CHANGED |
3062 MAC_STATUS_CFG_CHANGED));
3063 return 0;
3064 }
3065 }
3066
3067 tw32_f(MAC_TX_AUTO_NEG, 0);
3068
3069 tp->mac_mode &= ~(MAC_MODE_PORT_MODE_MASK | MAC_MODE_HALF_DUPLEX);
3070 tp->mac_mode |= MAC_MODE_PORT_MODE_TBI;
3071 tw32_f(MAC_MODE, tp->mac_mode);
3072 udelay(40);
3073
3074 if (tp->phy_id == PHY_ID_BCM8002)
3075 tg3_init_bcm8002(tp);
3076
3077 /* Enable link change event even when serdes polling. */
3078 tw32_f(MAC_EVENT, MAC_EVENT_LNKSTATE_CHANGED);
3079 udelay(40);
3080
3081 current_link_up = 0;
3082 mac_status = tr32(MAC_STATUS);
3083
3084 if (tp->tg3_flags2 & TG3_FLG2_HW_AUTONEG)
3085 current_link_up = tg3_setup_fiber_hw_autoneg(tp, mac_status);
3086 else
3087 current_link_up = tg3_setup_fiber_by_hand(tp, mac_status);
3088
3089 tp->hw_status->status =
3090 (SD_STATUS_UPDATED |
3091 (tp->hw_status->status & ~SD_STATUS_LINK_CHG));
3092
3093 for (i = 0; i < 100; i++) {
3094 tw32_f(MAC_STATUS, (MAC_STATUS_SYNC_CHANGED |
3095 MAC_STATUS_CFG_CHANGED));
3096 udelay(5);
3097 if ((tr32(MAC_STATUS) & (MAC_STATUS_SYNC_CHANGED |
3098 MAC_STATUS_CFG_CHANGED |
3099 MAC_STATUS_LNKSTATE_CHANGED)) == 0)
3100 break;
3101 }
3102
3103 mac_status = tr32(MAC_STATUS);
3104 if ((mac_status & MAC_STATUS_PCS_SYNCED) == 0) {
3105 current_link_up = 0;
3106 if (tp->link_config.autoneg == AUTONEG_ENABLE &&
3107 tp->serdes_counter == 0) {
3108 tw32_f(MAC_MODE, (tp->mac_mode |
3109 MAC_MODE_SEND_CONFIGS));
3110 udelay(1);
3111 tw32_f(MAC_MODE, tp->mac_mode);
3112 }
3113 }
3114
3115 if (current_link_up == 1) {
3116 tp->link_config.active_speed = SPEED_1000;
3117 tp->link_config.active_duplex = DUPLEX_FULL;
3118 tw32(MAC_LED_CTRL, (tp->led_ctrl |
3119 LED_CTRL_LNKLED_OVERRIDE |
3120 LED_CTRL_1000MBPS_ON));
3121 } else {
3122 tp->link_config.active_speed = SPEED_INVALID;
3123 tp->link_config.active_duplex = DUPLEX_INVALID;
3124 tw32(MAC_LED_CTRL, (tp->led_ctrl |
3125 LED_CTRL_LNKLED_OVERRIDE |
3126 LED_CTRL_TRAFFIC_OVERRIDE));
3127 }
3128
3129 if (current_link_up != netif_carrier_ok(tp->dev)) {
3130 if (current_link_up)
3131 netif_carrier_on(tp->dev);
3132 else
3133 netif_carrier_off(tp->dev);
3134 tg3_link_report(tp);
3135 } else {
3136 u32 now_pause_cfg = tp->link_config.active_flowctrl;
3137 if (orig_pause_cfg != now_pause_cfg ||
3138 orig_active_speed != tp->link_config.active_speed ||
3139 orig_active_duplex != tp->link_config.active_duplex)
3140 tg3_link_report(tp);
3141 }
3142
3143 return 0;
3144 }
3145
3146 static int tg3_setup_fiber_mii_phy(struct tg3 *tp, int force_reset)
3147 {
3148 int current_link_up, err = 0;
3149 u32 bmsr, bmcr;
3150 u16 current_speed;
3151 u8 current_duplex;
3152 u32 local_adv, remote_adv;
3153
3154 tp->mac_mode |= MAC_MODE_PORT_MODE_GMII;
3155 tw32_f(MAC_MODE, tp->mac_mode);
3156 udelay(40);
3157
3158 tw32(MAC_EVENT, 0);
3159
3160 tw32_f(MAC_STATUS,
3161 (MAC_STATUS_SYNC_CHANGED |
3162 MAC_STATUS_CFG_CHANGED |
3163 MAC_STATUS_MI_COMPLETION |
3164 MAC_STATUS_LNKSTATE_CHANGED));
3165 udelay(40);
3166
3167 if (force_reset)
3168 tg3_phy_reset(tp);
3169
3170 current_link_up = 0;
3171 current_speed = SPEED_INVALID;
3172 current_duplex = DUPLEX_INVALID;
3173
3174 err |= tg3_readphy(tp, MII_BMSR, &bmsr);
3175 err |= tg3_readphy(tp, MII_BMSR, &bmsr);
3176 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714) {
3177 if (tr32(MAC_TX_STATUS) & TX_STATUS_LINK_UP)
3178 bmsr |= BMSR_LSTATUS;
3179 else
3180 bmsr &= ~BMSR_LSTATUS;
3181 }
3182
3183 err |= tg3_readphy(tp, MII_BMCR, &bmcr);
3184
3185 if ((tp->link_config.autoneg == AUTONEG_ENABLE) && !force_reset &&
3186 (tp->tg3_flags2 & TG3_FLG2_PARALLEL_DETECT)) {
3187 /* do nothing, just check for link up at the end */
3188 } else if (tp->link_config.autoneg == AUTONEG_ENABLE) {
3189 u32 adv, new_adv;
3190
3191 err |= tg3_readphy(tp, MII_ADVERTISE, &adv);
3192 new_adv = adv & ~(ADVERTISE_1000XFULL | ADVERTISE_1000XHALF |
3193 ADVERTISE_1000XPAUSE |
3194 ADVERTISE_1000XPSE_ASYM |
3195 ADVERTISE_SLCT);
3196
3197 new_adv |= tg3_advert_flowctrl_1000X(tp->link_config.flowctrl);
3198
3199 if (tp->link_config.advertising & ADVERTISED_1000baseT_Half)
3200 new_adv |= ADVERTISE_1000XHALF;
3201 if (tp->link_config.advertising & ADVERTISED_1000baseT_Full)
3202 new_adv |= ADVERTISE_1000XFULL;
3203
3204 if ((new_adv != adv) || !(bmcr & BMCR_ANENABLE)) {
3205 tg3_writephy(tp, MII_ADVERTISE, new_adv);
3206 bmcr |= BMCR_ANENABLE | BMCR_ANRESTART;
3207 tg3_writephy(tp, MII_BMCR, bmcr);
3208
3209 tw32_f(MAC_EVENT, MAC_EVENT_LNKSTATE_CHANGED);
3210 tp->serdes_counter = SERDES_AN_TIMEOUT_5714S;
3211 tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
3212
3213 return err;
3214 }
3215 } else {
3216 u32 new_bmcr;
3217
3218 bmcr &= ~BMCR_SPEED1000;
3219 new_bmcr = bmcr & ~(BMCR_ANENABLE | BMCR_FULLDPLX);
3220
3221 if (tp->link_config.duplex == DUPLEX_FULL)
3222 new_bmcr |= BMCR_FULLDPLX;
3223
3224 if (new_bmcr != bmcr) {
3225 /* BMCR_SPEED1000 is a reserved bit that needs
3226 * to be set on write.
3227 */
3228 new_bmcr |= BMCR_SPEED1000;
3229
3230 /* Force a linkdown */
3231 if (netif_carrier_ok(tp->dev)) {
3232 u32 adv;
3233
3234 err |= tg3_readphy(tp, MII_ADVERTISE, &adv);
3235 adv &= ~(ADVERTISE_1000XFULL |
3236 ADVERTISE_1000XHALF |
3237 ADVERTISE_SLCT);
3238 tg3_writephy(tp, MII_ADVERTISE, adv);
3239 tg3_writephy(tp, MII_BMCR, bmcr |
3240 BMCR_ANRESTART |
3241 BMCR_ANENABLE);
3242 udelay(10);
3243 netif_carrier_off(tp->dev);
3244 }
3245 tg3_writephy(tp, MII_BMCR, new_bmcr);
3246 bmcr = new_bmcr;
3247 err |= tg3_readphy(tp, MII_BMSR, &bmsr);
3248 err |= tg3_readphy(tp, MII_BMSR, &bmsr);
3249 if (GET_ASIC_REV(tp->pci_chip_rev_id) ==
3250 ASIC_REV_5714) {
3251 if (tr32(MAC_TX_STATUS) & TX_STATUS_LINK_UP)
3252 bmsr |= BMSR_LSTATUS;
3253 else
3254 bmsr &= ~BMSR_LSTATUS;
3255 }
3256 tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
3257 }
3258 }
3259
3260 if (bmsr & BMSR_LSTATUS) {
3261 current_speed = SPEED_1000;
3262 current_link_up = 1;
3263 if (bmcr & BMCR_FULLDPLX)
3264 current_duplex = DUPLEX_FULL;
3265 else
3266 current_duplex = DUPLEX_HALF;
3267
3268 local_adv = 0;
3269 remote_adv = 0;
3270
3271 if (bmcr & BMCR_ANENABLE) {
3272 u32 common;
3273
3274 err |= tg3_readphy(tp, MII_ADVERTISE, &local_adv);
3275 err |= tg3_readphy(tp, MII_LPA, &remote_adv);
3276 common = local_adv & remote_adv;
3277 if (common & (ADVERTISE_1000XHALF |
3278 ADVERTISE_1000XFULL)) {
3279 if (common & ADVERTISE_1000XFULL)
3280 current_duplex = DUPLEX_FULL;
3281 else
3282 current_duplex = DUPLEX_HALF;
3283 }
3284 else
3285 current_link_up = 0;
3286 }
3287 }
3288
3289 if (current_link_up == 1 && current_duplex == DUPLEX_FULL)
3290 tg3_setup_flow_control(tp, local_adv, remote_adv);
3291
3292 tp->mac_mode &= ~MAC_MODE_HALF_DUPLEX;
3293 if (tp->link_config.active_duplex == DUPLEX_HALF)
3294 tp->mac_mode |= MAC_MODE_HALF_DUPLEX;
3295
3296 tw32_f(MAC_MODE, tp->mac_mode);
3297 udelay(40);
3298
3299 tw32_f(MAC_EVENT, MAC_EVENT_LNKSTATE_CHANGED);
3300
3301 tp->link_config.active_speed = current_speed;
3302 tp->link_config.active_duplex = current_duplex;
3303
3304 if (current_link_up != netif_carrier_ok(tp->dev)) {
3305 if (current_link_up)
3306 netif_carrier_on(tp->dev);
3307 else {
3308 netif_carrier_off(tp->dev);
3309 tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
3310 }
3311 tg3_link_report(tp);
3312 }
3313 return err;
3314 }
3315
3316 static void tg3_serdes_parallel_detect(struct tg3 *tp)
3317 {
3318 if (tp->serdes_counter) {
3319 /* Give autoneg time to complete. */
3320 tp->serdes_counter--;
3321 return;
3322 }
3323 if (!netif_carrier_ok(tp->dev) &&
3324 (tp->link_config.autoneg == AUTONEG_ENABLE)) {
3325 u32 bmcr;
3326
3327 tg3_readphy(tp, MII_BMCR, &bmcr);
3328 if (bmcr & BMCR_ANENABLE) {
3329 u32 phy1, phy2;
3330
3331 /* Select shadow register 0x1f */
3332 tg3_writephy(tp, 0x1c, 0x7c00);
3333 tg3_readphy(tp, 0x1c, &phy1);
3334
3335 /* Select expansion interrupt status register */
3336 tg3_writephy(tp, 0x17, 0x0f01);
3337 tg3_readphy(tp, 0x15, &phy2);
3338 tg3_readphy(tp, 0x15, &phy2);
3339
3340 if ((phy1 & 0x10) && !(phy2 & 0x20)) {
3341 /* We have signal detect and not receiving
3342 * config code words, link is up by parallel
3343 * detection.
3344 */
3345
3346 bmcr &= ~BMCR_ANENABLE;
3347 bmcr |= BMCR_SPEED1000 | BMCR_FULLDPLX;
3348 tg3_writephy(tp, MII_BMCR, bmcr);
3349 tp->tg3_flags2 |= TG3_FLG2_PARALLEL_DETECT;
3350 }
3351 }
3352 }
3353 else if (netif_carrier_ok(tp->dev) &&
3354 (tp->link_config.autoneg == AUTONEG_ENABLE) &&
3355 (tp->tg3_flags2 & TG3_FLG2_PARALLEL_DETECT)) {
3356 u32 phy2;
3357
3358 /* Select expansion interrupt status register */
3359 tg3_writephy(tp, 0x17, 0x0f01);
3360 tg3_readphy(tp, 0x15, &phy2);
3361 if (phy2 & 0x20) {
3362 u32 bmcr;
3363
3364 /* Config code words received, turn on autoneg. */
3365 tg3_readphy(tp, MII_BMCR, &bmcr);
3366 tg3_writephy(tp, MII_BMCR, bmcr | BMCR_ANENABLE);
3367
3368 tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
3369
3370 }
3371 }
3372 }
3373
3374 static int tg3_setup_phy(struct tg3 *tp, int force_reset)
3375 {
3376 int err;
3377
3378 if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
3379 err = tg3_setup_fiber_phy(tp, force_reset);
3380 } else if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES) {
3381 err = tg3_setup_fiber_mii_phy(tp, force_reset);
3382 } else {
3383 err = tg3_setup_copper_phy(tp, force_reset);
3384 }
3385
3386 if (tp->pci_chip_rev_id == CHIPREV_ID_5784_A0 ||
3387 tp->pci_chip_rev_id == CHIPREV_ID_5784_A1) {
3388 u32 val, scale;
3389
3390 val = tr32(TG3_CPMU_CLCK_STAT) & CPMU_CLCK_STAT_MAC_CLCK_MASK;
3391 if (val == CPMU_CLCK_STAT_MAC_CLCK_62_5)
3392 scale = 65;
3393 else if (val == CPMU_CLCK_STAT_MAC_CLCK_6_25)
3394 scale = 6;
3395 else
3396 scale = 12;
3397
3398 val = tr32(GRC_MISC_CFG) & ~GRC_MISC_CFG_PRESCALAR_MASK;
3399 val |= (scale << GRC_MISC_CFG_PRESCALAR_SHIFT);
3400 tw32(GRC_MISC_CFG, val);
3401 }
3402
3403 if (tp->link_config.active_speed == SPEED_1000 &&
3404 tp->link_config.active_duplex == DUPLEX_HALF)
3405 tw32(MAC_TX_LENGTHS,
3406 ((2 << TX_LENGTHS_IPG_CRS_SHIFT) |
3407 (6 << TX_LENGTHS_IPG_SHIFT) |
3408 (0xff << TX_LENGTHS_SLOT_TIME_SHIFT)));
3409 else
3410 tw32(MAC_TX_LENGTHS,
3411 ((2 << TX_LENGTHS_IPG_CRS_SHIFT) |
3412 (6 << TX_LENGTHS_IPG_SHIFT) |
3413 (32 << TX_LENGTHS_SLOT_TIME_SHIFT)));
3414
3415 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
3416 if (netif_carrier_ok(tp->dev)) {
3417 tw32(HOSTCC_STAT_COAL_TICKS,
3418 tp->coal.stats_block_coalesce_usecs);
3419 } else {
3420 tw32(HOSTCC_STAT_COAL_TICKS, 0);
3421 }
3422 }
3423
3424 if (tp->tg3_flags & TG3_FLAG_ASPM_WORKAROUND) {
3425 u32 val = tr32(PCIE_PWR_MGMT_THRESH);
3426 if (!netif_carrier_ok(tp->dev))
3427 val = (val & ~PCIE_PWR_MGMT_L1_THRESH_MSK) |
3428 tp->pwrmgmt_thresh;
3429 else
3430 val |= PCIE_PWR_MGMT_L1_THRESH_MSK;
3431 tw32(PCIE_PWR_MGMT_THRESH, val);
3432 }
3433
3434 return err;
3435 }
3436
3437 /* This is called whenever we suspect that the system chipset is re-
3438 * ordering the sequence of MMIO to the tx send mailbox. The symptom
3439 * is bogus tx completions. We try to recover by setting the
3440 * TG3_FLAG_MBOX_WRITE_REORDER flag and resetting the chip later
3441 * in the workqueue.
3442 */
3443 static void tg3_tx_recover(struct tg3 *tp)
3444 {
3445 BUG_ON((tp->tg3_flags & TG3_FLAG_MBOX_WRITE_REORDER) ||
3446 tp->write32_tx_mbox == tg3_write_indirect_mbox);
3447
3448 printk(KERN_WARNING PFX "%s: The system may be re-ordering memory-"
3449 "mapped I/O cycles to the network device, attempting to "
3450 "recover. Please report the problem to the driver maintainer "
3451 "and include system chipset information.\n", tp->dev->name);
3452
3453 spin_lock(&tp->lock);
3454 tp->tg3_flags |= TG3_FLAG_TX_RECOVERY_PENDING;
3455 spin_unlock(&tp->lock);
3456 }
3457
3458 static inline u32 tg3_tx_avail(struct tg3 *tp)
3459 {
3460 smp_mb();
3461 return (tp->tx_pending -
3462 ((tp->tx_prod - tp->tx_cons) & (TG3_TX_RING_SIZE - 1)));
3463 }
3464
3465 /* Tigon3 never reports partial packet sends. So we do not
3466 * need special logic to handle SKBs that have not had all
3467 * of their frags sent yet, like SunGEM does.
3468 */
3469 static void tg3_tx(struct tg3 *tp)
3470 {
3471 u32 hw_idx = tp->hw_status->idx[0].tx_consumer;
3472 u32 sw_idx = tp->tx_cons;
3473
3474 while (sw_idx != hw_idx) {
3475 struct tx_ring_info *ri = &tp->tx_buffers[sw_idx];
3476 struct sk_buff *skb = ri->skb;
3477 int i, tx_bug = 0;
3478
3479 if (unlikely(skb == NULL)) {
3480 tg3_tx_recover(tp);
3481 return;
3482 }
3483
3484 pci_unmap_single(tp->pdev,
3485 pci_unmap_addr(ri, mapping),
3486 skb_headlen(skb),
3487 PCI_DMA_TODEVICE);
3488
3489 ri->skb = NULL;
3490
3491 sw_idx = NEXT_TX(sw_idx);
3492
3493 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
3494 ri = &tp->tx_buffers[sw_idx];
3495 if (unlikely(ri->skb != NULL || sw_idx == hw_idx))
3496 tx_bug = 1;
3497
3498 pci_unmap_page(tp->pdev,
3499 pci_unmap_addr(ri, mapping),
3500 skb_shinfo(skb)->frags[i].size,
3501 PCI_DMA_TODEVICE);
3502
3503 sw_idx = NEXT_TX(sw_idx);
3504 }
3505
3506 dev_kfree_skb(skb);
3507
3508 if (unlikely(tx_bug)) {
3509 tg3_tx_recover(tp);
3510 return;
3511 }
3512 }
3513
3514 tp->tx_cons = sw_idx;
3515
3516 /* Need to make the tx_cons update visible to tg3_start_xmit()
3517 * before checking for netif_queue_stopped(). Without the
3518 * memory barrier, there is a small possibility that tg3_start_xmit()
3519 * will miss it and cause the queue to be stopped forever.
3520 */
3521 smp_mb();
3522
3523 if (unlikely(netif_queue_stopped(tp->dev) &&
3524 (tg3_tx_avail(tp) > TG3_TX_WAKEUP_THRESH(tp)))) {
3525 netif_tx_lock(tp->dev);
3526 if (netif_queue_stopped(tp->dev) &&
3527 (tg3_tx_avail(tp) > TG3_TX_WAKEUP_THRESH(tp)))
3528 netif_wake_queue(tp->dev);
3529 netif_tx_unlock(tp->dev);
3530 }
3531 }
3532
3533 /* Returns size of skb allocated or < 0 on error.
3534 *
3535 * We only need to fill in the address because the other members
3536 * of the RX descriptor are invariant, see tg3_init_rings.
3537 *
3538 * Note the purposeful assymetry of cpu vs. chip accesses. For
3539 * posting buffers we only dirty the first cache line of the RX
3540 * descriptor (containing the address). Whereas for the RX status
3541 * buffers the cpu only reads the last cacheline of the RX descriptor
3542 * (to fetch the error flags, vlan tag, checksum, and opaque cookie).
3543 */
3544 static int tg3_alloc_rx_skb(struct tg3 *tp, u32 opaque_key,
3545 int src_idx, u32 dest_idx_unmasked)
3546 {
3547 struct tg3_rx_buffer_desc *desc;
3548 struct ring_info *map, *src_map;
3549 struct sk_buff *skb;
3550 dma_addr_t mapping;
3551 int skb_size, dest_idx;
3552
3553 src_map = NULL;
3554 switch (opaque_key) {
3555 case RXD_OPAQUE_RING_STD:
3556 dest_idx = dest_idx_unmasked % TG3_RX_RING_SIZE;
3557 desc = &tp->rx_std[dest_idx];
3558 map = &tp->rx_std_buffers[dest_idx];
3559 if (src_idx >= 0)
3560 src_map = &tp->rx_std_buffers[src_idx];
3561 skb_size = tp->rx_pkt_buf_sz;
3562 break;
3563
3564 case RXD_OPAQUE_RING_JUMBO:
3565 dest_idx = dest_idx_unmasked % TG3_RX_JUMBO_RING_SIZE;
3566 desc = &tp->rx_jumbo[dest_idx];
3567 map = &tp->rx_jumbo_buffers[dest_idx];
3568 if (src_idx >= 0)
3569 src_map = &tp->rx_jumbo_buffers[src_idx];
3570 skb_size = RX_JUMBO_PKT_BUF_SZ;
3571 break;
3572
3573 default:
3574 return -EINVAL;
3575 };
3576
3577 /* Do not overwrite any of the map or rp information
3578 * until we are sure we can commit to a new buffer.
3579 *
3580 * Callers depend upon this behavior and assume that
3581 * we leave everything unchanged if we fail.
3582 */
3583 skb = netdev_alloc_skb(tp->dev, skb_size);
3584 if (skb == NULL)
3585 return -ENOMEM;
3586
3587 skb_reserve(skb, tp->rx_offset);
3588
3589 mapping = pci_map_single(tp->pdev, skb->data,
3590 skb_size - tp->rx_offset,
3591 PCI_DMA_FROMDEVICE);
3592
3593 map->skb = skb;
3594 pci_unmap_addr_set(map, mapping, mapping);
3595
3596 if (src_map != NULL)
3597 src_map->skb = NULL;
3598
3599 desc->addr_hi = ((u64)mapping >> 32);
3600 desc->addr_lo = ((u64)mapping & 0xffffffff);
3601
3602 return skb_size;
3603 }
3604
3605 /* We only need to move over in the address because the other
3606 * members of the RX descriptor are invariant. See notes above
3607 * tg3_alloc_rx_skb for full details.
3608 */
3609 static void tg3_recycle_rx(struct tg3 *tp, u32 opaque_key,
3610 int src_idx, u32 dest_idx_unmasked)
3611 {
3612 struct tg3_rx_buffer_desc *src_desc, *dest_desc;
3613 struct ring_info *src_map, *dest_map;
3614 int dest_idx;
3615
3616 switch (opaque_key) {
3617 case RXD_OPAQUE_RING_STD:
3618 dest_idx = dest_idx_unmasked % TG3_RX_RING_SIZE;
3619 dest_desc = &tp->rx_std[dest_idx];
3620 dest_map = &tp->rx_std_buffers[dest_idx];
3621 src_desc = &tp->rx_std[src_idx];
3622 src_map = &tp->rx_std_buffers[src_idx];
3623 break;
3624
3625 case RXD_OPAQUE_RING_JUMBO:
3626 dest_idx = dest_idx_unmasked % TG3_RX_JUMBO_RING_SIZE;
3627 dest_desc = &tp->rx_jumbo[dest_idx];
3628 dest_map = &tp->rx_jumbo_buffers[dest_idx];
3629 src_desc = &tp->rx_jumbo[src_idx];
3630 src_map = &tp->rx_jumbo_buffers[src_idx];
3631 break;
3632
3633 default:
3634 return;
3635 };
3636
3637 dest_map->skb = src_map->skb;
3638 pci_unmap_addr_set(dest_map, mapping,
3639 pci_unmap_addr(src_map, mapping));
3640 dest_desc->addr_hi = src_desc->addr_hi;
3641 dest_desc->addr_lo = src_desc->addr_lo;
3642
3643 src_map->skb = NULL;
3644 }
3645
3646 #if TG3_VLAN_TAG_USED
3647 static int tg3_vlan_rx(struct tg3 *tp, struct sk_buff *skb, u16 vlan_tag)
3648 {
3649 return vlan_hwaccel_receive_skb(skb, tp->vlgrp, vlan_tag);
3650 }
3651 #endif
3652
3653 /* The RX ring scheme is composed of multiple rings which post fresh
3654 * buffers to the chip, and one special ring the chip uses to report
3655 * status back to the host.
3656 *
3657 * The special ring reports the status of received packets to the
3658 * host. The chip does not write into the original descriptor the
3659 * RX buffer was obtained from. The chip simply takes the original
3660 * descriptor as provided by the host, updates the status and length
3661 * field, then writes this into the next status ring entry.
3662 *
3663 * Each ring the host uses to post buffers to the chip is described
3664 * by a TG3_BDINFO entry in the chips SRAM area. When a packet arrives,
3665 * it is first placed into the on-chip ram. When the packet's length
3666 * is known, it walks down the TG3_BDINFO entries to select the ring.
3667 * Each TG3_BDINFO specifies a MAXLEN field and the first TG3_BDINFO
3668 * which is within the range of the new packet's length is chosen.
3669 *
3670 * The "separate ring for rx status" scheme may sound queer, but it makes
3671 * sense from a cache coherency perspective. If only the host writes
3672 * to the buffer post rings, and only the chip writes to the rx status
3673 * rings, then cache lines never move beyond shared-modified state.
3674 * If both the host and chip were to write into the same ring, cache line
3675 * eviction could occur since both entities want it in an exclusive state.
3676 */
3677 static int tg3_rx(struct tg3 *tp, int budget)
3678 {
3679 u32 work_mask, rx_std_posted = 0;
3680 u32 sw_idx = tp->rx_rcb_ptr;
3681 u16 hw_idx;
3682 int received;
3683
3684 hw_idx = tp->hw_status->idx[0].rx_producer;
3685 /*
3686 * We need to order the read of hw_idx and the read of
3687 * the opaque cookie.
3688 */
3689 rmb();
3690 work_mask = 0;
3691 received = 0;
3692 while (sw_idx != hw_idx && budget > 0) {
3693 struct tg3_rx_buffer_desc *desc = &tp->rx_rcb[sw_idx];
3694 unsigned int len;
3695 struct sk_buff *skb;
3696 dma_addr_t dma_addr;
3697 u32 opaque_key, desc_idx, *post_ptr;
3698
3699 desc_idx = desc->opaque & RXD_OPAQUE_INDEX_MASK;
3700 opaque_key = desc->opaque & RXD_OPAQUE_RING_MASK;
3701 if (opaque_key == RXD_OPAQUE_RING_STD) {
3702 dma_addr = pci_unmap_addr(&tp->rx_std_buffers[desc_idx],
3703 mapping);
3704 skb = tp->rx_std_buffers[desc_idx].skb;
3705 post_ptr = &tp->rx_std_ptr;
3706 rx_std_posted++;
3707 } else if (opaque_key == RXD_OPAQUE_RING_JUMBO) {
3708 dma_addr = pci_unmap_addr(&tp->rx_jumbo_buffers[desc_idx],
3709 mapping);
3710 skb = tp->rx_jumbo_buffers[desc_idx].skb;
3711 post_ptr = &tp->rx_jumbo_ptr;
3712 }
3713 else {
3714 goto next_pkt_nopost;
3715 }
3716
3717 work_mask |= opaque_key;
3718
3719 if ((desc->err_vlan & RXD_ERR_MASK) != 0 &&
3720 (desc->err_vlan != RXD_ERR_ODD_NIBBLE_RCVD_MII)) {
3721 drop_it:
3722 tg3_recycle_rx(tp, opaque_key,
3723 desc_idx, *post_ptr);
3724 drop_it_no_recycle:
3725 /* Other statistics kept track of by card. */
3726 tp->net_stats.rx_dropped++;
3727 goto next_pkt;
3728 }
3729
3730 len = ((desc->idx_len & RXD_LEN_MASK) >> RXD_LEN_SHIFT) - 4; /* omit crc */
3731
3732 if (len > RX_COPY_THRESHOLD
3733 && tp->rx_offset == 2
3734 /* rx_offset != 2 iff this is a 5701 card running
3735 * in PCI-X mode [see tg3_get_invariants()] */
3736 ) {
3737 int skb_size;
3738
3739 skb_size = tg3_alloc_rx_skb(tp, opaque_key,
3740 desc_idx, *post_ptr);
3741 if (skb_size < 0)
3742 goto drop_it;
3743
3744 pci_unmap_single(tp->pdev, dma_addr,
3745 skb_size - tp->rx_offset,
3746 PCI_DMA_FROMDEVICE);
3747
3748 skb_put(skb, len);
3749 } else {
3750 struct sk_buff *copy_skb;
3751
3752 tg3_recycle_rx(tp, opaque_key,
3753 desc_idx, *post_ptr);
3754
3755 copy_skb = netdev_alloc_skb(tp->dev, len + 2);
3756 if (copy_skb == NULL)
3757 goto drop_it_no_recycle;
3758
3759 skb_reserve(copy_skb, 2);
3760 skb_put(copy_skb, len);
3761 pci_dma_sync_single_for_cpu(tp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
3762 skb_copy_from_linear_data(skb, copy_skb->data, len);
3763 pci_dma_sync_single_for_device(tp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
3764
3765 /* We'll reuse the original ring buffer. */
3766 skb = copy_skb;
3767 }
3768
3769 if ((tp->tg3_flags & TG3_FLAG_RX_CHECKSUMS) &&
3770 (desc->type_flags & RXD_FLAG_TCPUDP_CSUM) &&
3771 (((desc->ip_tcp_csum & RXD_TCPCSUM_MASK)
3772 >> RXD_TCPCSUM_SHIFT) == 0xffff))
3773 skb->ip_summed = CHECKSUM_UNNECESSARY;
3774 else
3775 skb->ip_summed = CHECKSUM_NONE;
3776
3777 skb->protocol = eth_type_trans(skb, tp->dev);
3778 #if TG3_VLAN_TAG_USED
3779 if (tp->vlgrp != NULL &&
3780 desc->type_flags & RXD_FLAG_VLAN) {
3781 tg3_vlan_rx(tp, skb,
3782 desc->err_vlan & RXD_VLAN_MASK);
3783 } else
3784 #endif
3785 netif_receive_skb(skb);
3786
3787 tp->dev->last_rx = jiffies;
3788 received++;
3789 budget--;
3790
3791 next_pkt:
3792 (*post_ptr)++;
3793
3794 if (unlikely(rx_std_posted >= tp->rx_std_max_post)) {
3795 u32 idx = *post_ptr % TG3_RX_RING_SIZE;
3796
3797 tw32_rx_mbox(MAILBOX_RCV_STD_PROD_IDX +
3798 TG3_64BIT_REG_LOW, idx);
3799 work_mask &= ~RXD_OPAQUE_RING_STD;
3800 rx_std_posted = 0;
3801 }
3802 next_pkt_nopost:
3803 sw_idx++;
3804 sw_idx &= (TG3_RX_RCB_RING_SIZE(tp) - 1);
3805
3806 /* Refresh hw_idx to see if there is new work */
3807 if (sw_idx == hw_idx) {
3808 hw_idx = tp->hw_status->idx[0].rx_producer;
3809 rmb();
3810 }
3811 }
3812
3813 /* ACK the status ring. */
3814 tp->rx_rcb_ptr = sw_idx;
3815 tw32_rx_mbox(MAILBOX_RCVRET_CON_IDX_0 + TG3_64BIT_REG_LOW, sw_idx);
3816
3817 /* Refill RX ring(s). */
3818 if (work_mask & RXD_OPAQUE_RING_STD) {
3819 sw_idx = tp->rx_std_ptr % TG3_RX_RING_SIZE;
3820 tw32_rx_mbox(MAILBOX_RCV_STD_PROD_IDX + TG3_64BIT_REG_LOW,
3821 sw_idx);
3822 }
3823 if (work_mask & RXD_OPAQUE_RING_JUMBO) {
3824 sw_idx = tp->rx_jumbo_ptr % TG3_RX_JUMBO_RING_SIZE;
3825 tw32_rx_mbox(MAILBOX_RCV_JUMBO_PROD_IDX + TG3_64BIT_REG_LOW,
3826 sw_idx);
3827 }
3828 mmiowb();
3829
3830 return received;
3831 }
3832
3833 static int tg3_poll_work(struct tg3 *tp, int work_done, int budget)
3834 {
3835 struct tg3_hw_status *sblk = tp->hw_status;
3836
3837 /* handle link change and other phy events */
3838 if (!(tp->tg3_flags &
3839 (TG3_FLAG_USE_LINKCHG_REG |
3840 TG3_FLAG_POLL_SERDES))) {
3841 if (sblk->status & SD_STATUS_LINK_CHG) {
3842 sblk->status = SD_STATUS_UPDATED |
3843 (sblk->status & ~SD_STATUS_LINK_CHG);
3844 spin_lock(&tp->lock);
3845 tg3_setup_phy(tp, 0);
3846 spin_unlock(&tp->lock);
3847 }
3848 }
3849
3850 /* run TX completion thread */
3851 if (sblk->idx[0].tx_consumer != tp->tx_cons) {
3852 tg3_tx(tp);
3853 if (unlikely(tp->tg3_flags & TG3_FLAG_TX_RECOVERY_PENDING))
3854 return work_done;
3855 }
3856
3857 /* run RX thread, within the bounds set by NAPI.
3858 * All RX "locking" is done by ensuring outside
3859 * code synchronizes with tg3->napi.poll()
3860 */
3861 if (sblk->idx[0].rx_producer != tp->rx_rcb_ptr)
3862 work_done += tg3_rx(tp, budget - work_done);
3863
3864 return work_done;
3865 }
3866
3867 static int tg3_poll(struct napi_struct *napi, int budget)
3868 {
3869 struct tg3 *tp = container_of(napi, struct tg3, napi);
3870 int work_done = 0;
3871 struct tg3_hw_status *sblk = tp->hw_status;
3872
3873 while (1) {
3874 work_done = tg3_poll_work(tp, work_done, budget);
3875
3876 if (unlikely(tp->tg3_flags & TG3_FLAG_TX_RECOVERY_PENDING))
3877 goto tx_recovery;
3878
3879 if (unlikely(work_done >= budget))
3880 break;
3881
3882 if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS) {
3883 /* tp->last_tag is used in tg3_restart_ints() below
3884 * to tell the hw how much work has been processed,
3885 * so we must read it before checking for more work.
3886 */
3887 tp->last_tag = sblk->status_tag;
3888 rmb();
3889 } else
3890 sblk->status &= ~SD_STATUS_UPDATED;
3891
3892 if (likely(!tg3_has_work(tp))) {
3893 netif_rx_complete(tp->dev, napi);
3894 tg3_restart_ints(tp);
3895 break;
3896 }
3897 }
3898
3899 return work_done;
3900
3901 tx_recovery:
3902 /* work_done is guaranteed to be less than budget. */
3903 netif_rx_complete(tp->dev, napi);
3904 schedule_work(&tp->reset_task);
3905 return work_done;
3906 }
3907
3908 static void tg3_irq_quiesce(struct tg3 *tp)
3909 {
3910 BUG_ON(tp->irq_sync);
3911
3912 tp->irq_sync = 1;
3913 smp_mb();
3914
3915 synchronize_irq(tp->pdev->irq);
3916 }
3917
3918 static inline int tg3_irq_sync(struct tg3 *tp)
3919 {
3920 return tp->irq_sync;
3921 }
3922
3923 /* Fully shutdown all tg3 driver activity elsewhere in the system.
3924 * If irq_sync is non-zero, then the IRQ handler must be synchronized
3925 * with as well. Most of the time, this is not necessary except when
3926 * shutting down the device.
3927 */
3928 static inline void tg3_full_lock(struct tg3 *tp, int irq_sync)
3929 {
3930 spin_lock_bh(&tp->lock);
3931 if (irq_sync)
3932 tg3_irq_quiesce(tp);
3933 }
3934
3935 static inline void tg3_full_unlock(struct tg3 *tp)
3936 {
3937 spin_unlock_bh(&tp->lock);
3938 }
3939
3940 /* One-shot MSI handler - Chip automatically disables interrupt
3941 * after sending MSI so driver doesn't have to do it.
3942 */
3943 static irqreturn_t tg3_msi_1shot(int irq, void *dev_id)
3944 {
3945 struct net_device *dev = dev_id;
3946 struct tg3 *tp = netdev_priv(dev);
3947
3948 prefetch(tp->hw_status);
3949 prefetch(&tp->rx_rcb[tp->rx_rcb_ptr]);
3950
3951 if (likely(!tg3_irq_sync(tp)))
3952 netif_rx_schedule(dev, &tp->napi);
3953
3954 return IRQ_HANDLED;
3955 }
3956
3957 /* MSI ISR - No need to check for interrupt sharing and no need to
3958 * flush status block and interrupt mailbox. PCI ordering rules
3959 * guarantee that MSI will arrive after the status block.
3960 */
3961 static irqreturn_t tg3_msi(int irq, void *dev_id)
3962 {
3963 struct net_device *dev = dev_id;
3964 struct tg3 *tp = netdev_priv(dev);
3965
3966 prefetch(tp->hw_status);
3967 prefetch(&tp->rx_rcb[tp->rx_rcb_ptr]);
3968 /*
3969 * Writing any value to intr-mbox-0 clears PCI INTA# and
3970 * chip-internal interrupt pending events.
3971 * Writing non-zero to intr-mbox-0 additional tells the
3972 * NIC to stop sending us irqs, engaging "in-intr-handler"
3973 * event coalescing.
3974 */
3975 tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0x00000001);
3976 if (likely(!tg3_irq_sync(tp)))
3977 netif_rx_schedule(dev, &tp->napi);
3978
3979 return IRQ_RETVAL(1);
3980 }
3981
3982 static irqreturn_t tg3_interrupt(int irq, void *dev_id)
3983 {
3984 struct net_device *dev = dev_id;
3985 struct tg3 *tp = netdev_priv(dev);
3986 struct tg3_hw_status *sblk = tp->hw_status;
3987 unsigned int handled = 1;
3988
3989 /* In INTx mode, it is possible for the interrupt to arrive at
3990 * the CPU before the status block posted prior to the interrupt.
3991 * Reading the PCI State register will confirm whether the
3992 * interrupt is ours and will flush the status block.
3993 */
3994 if (unlikely(!(sblk->status & SD_STATUS_UPDATED))) {
3995 if ((tp->tg3_flags & TG3_FLAG_CHIP_RESETTING) ||
3996 (tr32(TG3PCI_PCISTATE) & PCISTATE_INT_NOT_ACTIVE)) {
3997 handled = 0;
3998 goto out;
3999 }
4000 }
4001
4002 /*
4003 * Writing any value to intr-mbox-0 clears PCI INTA# and
4004 * chip-internal interrupt pending events.
4005 * Writing non-zero to intr-mbox-0 additional tells the
4006 * NIC to stop sending us irqs, engaging "in-intr-handler"
4007 * event coalescing.
4008 *
4009 * Flush the mailbox to de-assert the IRQ immediately to prevent
4010 * spurious interrupts. The flush impacts performance but
4011 * excessive spurious interrupts can be worse in some cases.
4012 */
4013 tw32_mailbox_f(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0x00000001);
4014 if (tg3_irq_sync(tp))
4015 goto out;
4016 sblk->status &= ~SD_STATUS_UPDATED;
4017 if (likely(tg3_has_work(tp))) {
4018 prefetch(&tp->rx_rcb[tp->rx_rcb_ptr]);
4019 netif_rx_schedule(dev, &tp->napi);
4020 } else {
4021 /* No work, shared interrupt perhaps? re-enable
4022 * interrupts, and flush that PCI write
4023 */
4024 tw32_mailbox_f(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
4025 0x00000000);
4026 }
4027 out:
4028 return IRQ_RETVAL(handled);
4029 }
4030
4031 static irqreturn_t tg3_interrupt_tagged(int irq, void *dev_id)
4032 {
4033 struct net_device *dev = dev_id;
4034 struct tg3 *tp = netdev_priv(dev);
4035 struct tg3_hw_status *sblk = tp->hw_status;
4036 unsigned int handled = 1;
4037
4038 /* In INTx mode, it is possible for the interrupt to arrive at
4039 * the CPU before the status block posted prior to the interrupt.
4040 * Reading the PCI State register will confirm whether the
4041 * interrupt is ours and will flush the status block.
4042 */
4043 if (unlikely(sblk->status_tag == tp->last_tag)) {
4044 if ((tp->tg3_flags & TG3_FLAG_CHIP_RESETTING) ||
4045 (tr32(TG3PCI_PCISTATE) & PCISTATE_INT_NOT_ACTIVE)) {
4046 handled = 0;
4047 goto out;
4048 }
4049 }
4050
4051 /*
4052 * writing any value to intr-mbox-0 clears PCI INTA# and
4053 * chip-internal interrupt pending events.
4054 * writing non-zero to intr-mbox-0 additional tells the
4055 * NIC to stop sending us irqs, engaging "in-intr-handler"
4056 * event coalescing.
4057 *
4058 * Flush the mailbox to de-assert the IRQ immediately to prevent
4059 * spurious interrupts. The flush impacts performance but
4060 * excessive spurious interrupts can be worse in some cases.
4061 */
4062 tw32_mailbox_f(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0x00000001);
4063 if (tg3_irq_sync(tp))
4064 goto out;
4065 if (netif_rx_schedule_prep(dev, &tp->napi)) {
4066 prefetch(&tp->rx_rcb[tp->rx_rcb_ptr]);
4067 /* Update last_tag to mark that this status has been
4068 * seen. Because interrupt may be shared, we may be
4069 * racing with tg3_poll(), so only update last_tag
4070 * if tg3_poll() is not scheduled.
4071 */
4072 tp->last_tag = sblk->status_tag;
4073 __netif_rx_schedule(dev, &tp->napi);
4074 }
4075 out:
4076 return IRQ_RETVAL(handled);
4077 }
4078
4079 /* ISR for interrupt test */
4080 static irqreturn_t tg3_test_isr(int irq, void *dev_id)
4081 {
4082 struct net_device *dev = dev_id;
4083 struct tg3 *tp = netdev_priv(dev);
4084 struct tg3_hw_status *sblk = tp->hw_status;
4085
4086 if ((sblk->status & SD_STATUS_UPDATED) ||
4087 !(tr32(TG3PCI_PCISTATE) & PCISTATE_INT_NOT_ACTIVE)) {
4088 tg3_disable_ints(tp);
4089 return IRQ_RETVAL(1);
4090 }
4091 return IRQ_RETVAL(0);
4092 }
4093
4094 static int tg3_init_hw(struct tg3 *, int);
4095 static int tg3_halt(struct tg3 *, int, int);
4096
4097 /* Restart hardware after configuration changes, self-test, etc.
4098 * Invoked with tp->lock held.
4099 */
4100 static int tg3_restart_hw(struct tg3 *tp, int reset_phy)
4101 __releases(tp->lock)
4102 __acquires(tp->lock)
4103 {
4104 int err;
4105
4106 err = tg3_init_hw(tp, reset_phy);
4107 if (err) {
4108 printk(KERN_ERR PFX "%s: Failed to re-initialize device, "
4109 "aborting.\n", tp->dev->name);
4110 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
4111 tg3_full_unlock(tp);
4112 del_timer_sync(&tp->timer);
4113 tp->irq_sync = 0;
4114 napi_enable(&tp->napi);
4115 dev_close(tp->dev);
4116 tg3_full_lock(tp, 0);
4117 }
4118 return err;
4119 }
4120
4121 #ifdef CONFIG_NET_POLL_CONTROLLER
4122 static void tg3_poll_controller(struct net_device *dev)
4123 {
4124 struct tg3 *tp = netdev_priv(dev);
4125
4126 tg3_interrupt(tp->pdev->irq, dev);
4127 }
4128 #endif
4129
4130 static void tg3_reset_task(struct work_struct *work)
4131 {
4132 struct tg3 *tp = container_of(work, struct tg3, reset_task);
4133 unsigned int restart_timer;
4134
4135 tg3_full_lock(tp, 0);
4136
4137 if (!netif_running(tp->dev)) {
4138 tg3_full_unlock(tp);
4139 return;
4140 }
4141
4142 tg3_full_unlock(tp);
4143
4144 tg3_netif_stop(tp);
4145
4146 tg3_full_lock(tp, 1);
4147
4148 restart_timer = tp->tg3_flags2 & TG3_FLG2_RESTART_TIMER;
4149 tp->tg3_flags2 &= ~TG3_FLG2_RESTART_TIMER;
4150
4151 if (tp->tg3_flags & TG3_FLAG_TX_RECOVERY_PENDING) {
4152 tp->write32_tx_mbox = tg3_write32_tx_mbox;
4153 tp->write32_rx_mbox = tg3_write_flush_reg32;
4154 tp->tg3_flags |= TG3_FLAG_MBOX_WRITE_REORDER;
4155 tp->tg3_flags &= ~TG3_FLAG_TX_RECOVERY_PENDING;
4156 }
4157
4158 tg3_halt(tp, RESET_KIND_SHUTDOWN, 0);
4159 if (tg3_init_hw(tp, 1))
4160 goto out;
4161
4162 tg3_netif_start(tp);
4163
4164 if (restart_timer)
4165 mod_timer(&tp->timer, jiffies + 1);
4166
4167 out:
4168 tg3_full_unlock(tp);
4169 }
4170
4171 static void tg3_dump_short_state(struct tg3 *tp)
4172 {
4173 printk(KERN_ERR PFX "DEBUG: MAC_TX_STATUS[%08x] MAC_RX_STATUS[%08x]\n",
4174 tr32(MAC_TX_STATUS), tr32(MAC_RX_STATUS));
4175 printk(KERN_ERR PFX "DEBUG: RDMAC_STATUS[%08x] WDMAC_STATUS[%08x]\n",
4176 tr32(RDMAC_STATUS), tr32(WDMAC_STATUS));
4177 }
4178
4179 static void tg3_tx_timeout(struct net_device *dev)
4180 {
4181 struct tg3 *tp = netdev_priv(dev);
4182
4183 if (netif_msg_tx_err(tp)) {
4184 printk(KERN_ERR PFX "%s: transmit timed out, resetting\n",
4185 dev->name);
4186 tg3_dump_short_state(tp);
4187 }
4188
4189 schedule_work(&tp->reset_task);
4190 }
4191
4192 /* Test for DMA buffers crossing any 4GB boundaries: 4G, 8G, etc */
4193 static inline int tg3_4g_overflow_test(dma_addr_t mapping, int len)
4194 {
4195 u32 base = (u32) mapping & 0xffffffff;
4196
4197 return ((base > 0xffffdcc0) &&
4198 (base + len + 8 < base));
4199 }
4200
4201 /* Test for DMA addresses > 40-bit */
4202 static inline int tg3_40bit_overflow_test(struct tg3 *tp, dma_addr_t mapping,
4203 int len)
4204 {
4205 #if defined(CONFIG_HIGHMEM) && (BITS_PER_LONG == 64)
4206 if (tp->tg3_flags & TG3_FLAG_40BIT_DMA_BUG)
4207 return (((u64) mapping + len) > DMA_40BIT_MASK);
4208 return 0;
4209 #else
4210 return 0;
4211 #endif
4212 }
4213
4214 static void tg3_set_txd(struct tg3 *, int, dma_addr_t, int, u32, u32);
4215
4216 /* Workaround 4GB and 40-bit hardware DMA bugs. */
4217 static int tigon3_dma_hwbug_workaround(struct tg3 *tp, struct sk_buff *skb,
4218 u32 last_plus_one, u32 *start,
4219 u32 base_flags, u32 mss)
4220 {
4221 struct sk_buff *new_skb;
4222 dma_addr_t new_addr = 0;
4223 u32 entry = *start;
4224 int i, ret = 0;
4225
4226 if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701)
4227 new_skb = skb_copy(skb, GFP_ATOMIC);
4228 else {
4229 int more_headroom = 4 - ((unsigned long)skb->data & 3);
4230
4231 new_skb = skb_copy_expand(skb,
4232 skb_headroom(skb) + more_headroom,
4233 skb_tailroom(skb), GFP_ATOMIC);
4234 }
4235
4236 if (!new_skb) {
4237 ret = -1;
4238 } else {
4239 /* New SKB is guaranteed to be linear. */
4240 entry = *start;
4241 new_addr = pci_map_single(tp->pdev, new_skb->data, new_skb->len,
4242 PCI_DMA_TODEVICE);
4243 /* Make sure new skb does not cross any 4G boundaries.
4244 * Drop the packet if it does.
4245 */
4246 if (tg3_4g_overflow_test(new_addr, new_skb->len)) {
4247 ret = -1;
4248 dev_kfree_skb(new_skb);
4249 new_skb = NULL;
4250 } else {
4251 tg3_set_txd(tp, entry, new_addr, new_skb->len,
4252 base_flags, 1 | (mss << 1));
4253 *start = NEXT_TX(entry);
4254 }
4255 }
4256
4257 /* Now clean up the sw ring entries. */
4258 i = 0;
4259 while (entry != last_plus_one) {
4260 int len;
4261
4262 if (i == 0)
4263 len = skb_headlen(skb);
4264 else
4265 len = skb_shinfo(skb)->frags[i-1].size;
4266 pci_unmap_single(tp->pdev,
4267 pci_unmap_addr(&tp->tx_buffers[entry], mapping),
4268 len, PCI_DMA_TODEVICE);
4269 if (i == 0) {
4270 tp->tx_buffers[entry].skb = new_skb;
4271 pci_unmap_addr_set(&tp->tx_buffers[entry], mapping, new_addr);
4272 } else {
4273 tp->tx_buffers[entry].skb = NULL;
4274 }
4275 entry = NEXT_TX(entry);
4276 i++;
4277 }
4278
4279 dev_kfree_skb(skb);
4280
4281 return ret;
4282 }
4283
4284 static void tg3_set_txd(struct tg3 *tp, int entry,
4285 dma_addr_t mapping, int len, u32 flags,
4286 u32 mss_and_is_end)
4287 {
4288 struct tg3_tx_buffer_desc *txd = &tp->tx_ring[entry];
4289 int is_end = (mss_and_is_end & 0x1);
4290 u32 mss = (mss_and_is_end >> 1);
4291 u32 vlan_tag = 0;
4292
4293 if (is_end)
4294 flags |= TXD_FLAG_END;
4295 if (flags & TXD_FLAG_VLAN) {
4296 vlan_tag = flags >> 16;
4297 flags &= 0xffff;
4298 }
4299 vlan_tag |= (mss << TXD_MSS_SHIFT);
4300
4301 txd->addr_hi = ((u64) mapping >> 32);
4302 txd->addr_lo = ((u64) mapping & 0xffffffff);
4303 txd->len_flags = (len << TXD_LEN_SHIFT) | flags;
4304 txd->vlan_tag = vlan_tag << TXD_VLAN_TAG_SHIFT;
4305 }
4306
4307 /* hard_start_xmit for devices that don't have any bugs and
4308 * support TG3_FLG2_HW_TSO_2 only.
4309 */
4310 static int tg3_start_xmit(struct sk_buff *skb, struct net_device *dev)
4311 {
4312 struct tg3 *tp = netdev_priv(dev);
4313 dma_addr_t mapping;
4314 u32 len, entry, base_flags, mss;
4315
4316 len = skb_headlen(skb);
4317
4318 /* We are running in BH disabled context with netif_tx_lock
4319 * and TX reclaim runs via tp->napi.poll inside of a software
4320 * interrupt. Furthermore, IRQ processing runs lockless so we have
4321 * no IRQ context deadlocks to worry about either. Rejoice!
4322 */
4323 if (unlikely(tg3_tx_avail(tp) <= (skb_shinfo(skb)->nr_frags + 1))) {
4324 if (!netif_queue_stopped(dev)) {
4325 netif_stop_queue(dev);
4326
4327 /* This is a hard error, log it. */
4328 printk(KERN_ERR PFX "%s: BUG! Tx Ring full when "
4329 "queue awake!\n", dev->name);
4330 }
4331 return NETDEV_TX_BUSY;
4332 }
4333
4334 entry = tp->tx_prod;
4335 base_flags = 0;
4336 mss = 0;
4337 if ((mss = skb_shinfo(skb)->gso_size) != 0) {
4338 int tcp_opt_len, ip_tcp_len;
4339
4340 if (skb_header_cloned(skb) &&
4341 pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) {
4342 dev_kfree_skb(skb);
4343 goto out_unlock;
4344 }
4345
4346 if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6)
4347 mss |= (skb_headlen(skb) - ETH_HLEN) << 9;
4348 else {
4349 struct iphdr *iph = ip_hdr(skb);
4350
4351 tcp_opt_len = tcp_optlen(skb);
4352 ip_tcp_len = ip_hdrlen(skb) + sizeof(struct tcphdr);
4353
4354 iph->check = 0;
4355 iph->tot_len = htons(mss + ip_tcp_len + tcp_opt_len);
4356 mss |= (ip_tcp_len + tcp_opt_len) << 9;
4357 }
4358
4359 base_flags |= (TXD_FLAG_CPU_PRE_DMA |
4360 TXD_FLAG_CPU_POST_DMA);
4361
4362 tcp_hdr(skb)->check = 0;
4363
4364 }
4365 else if (skb->ip_summed == CHECKSUM_PARTIAL)
4366 base_flags |= TXD_FLAG_TCPUDP_CSUM;
4367 #if TG3_VLAN_TAG_USED
4368 if (tp->vlgrp != NULL && vlan_tx_tag_present(skb))
4369 base_flags |= (TXD_FLAG_VLAN |
4370 (vlan_tx_tag_get(skb) << 16));
4371 #endif
4372
4373 /* Queue skb data, a.k.a. the main skb fragment. */
4374 mapping = pci_map_single(tp->pdev, skb->data, len, PCI_DMA_TODEVICE);
4375
4376 tp->tx_buffers[entry].skb = skb;
4377 pci_unmap_addr_set(&tp->tx_buffers[entry], mapping, mapping);
4378
4379 tg3_set_txd(tp, entry, mapping, len, base_flags,
4380 (skb_shinfo(skb)->nr_frags == 0) | (mss << 1));
4381
4382 entry = NEXT_TX(entry);
4383
4384 /* Now loop through additional data fragments, and queue them. */
4385 if (skb_shinfo(skb)->nr_frags > 0) {
4386 unsigned int i, last;
4387
4388 last = skb_shinfo(skb)->nr_frags - 1;
4389 for (i = 0; i <= last; i++) {
4390 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
4391
4392 len = frag->size;
4393 mapping = pci_map_page(tp->pdev,
4394 frag->page,
4395 frag->page_offset,
4396 len, PCI_DMA_TODEVICE);
4397
4398 tp->tx_buffers[entry].skb = NULL;
4399 pci_unmap_addr_set(&tp->tx_buffers[entry], mapping, mapping);
4400
4401 tg3_set_txd(tp, entry, mapping, len,
4402 base_flags, (i == last) | (mss << 1));
4403
4404 entry = NEXT_TX(entry);
4405 }
4406 }
4407
4408 /* Packets are ready, update Tx producer idx local and on card. */
4409 tw32_tx_mbox((MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW), entry);
4410
4411 tp->tx_prod = entry;
4412 if (unlikely(tg3_tx_avail(tp) <= (MAX_SKB_FRAGS + 1))) {
4413 netif_stop_queue(dev);
4414 if (tg3_tx_avail(tp) > TG3_TX_WAKEUP_THRESH(tp))
4415 netif_wake_queue(tp->dev);
4416 }
4417
4418 out_unlock:
4419 mmiowb();
4420
4421 dev->trans_start = jiffies;
4422
4423 return NETDEV_TX_OK;
4424 }
4425
4426 static int tg3_start_xmit_dma_bug(struct sk_buff *, struct net_device *);
4427
4428 /* Use GSO to workaround a rare TSO bug that may be triggered when the
4429 * TSO header is greater than 80 bytes.
4430 */
4431 static int tg3_tso_bug(struct tg3 *tp, struct sk_buff *skb)
4432 {
4433 struct sk_buff *segs, *nskb;
4434
4435 /* Estimate the number of fragments in the worst case */
4436 if (unlikely(tg3_tx_avail(tp) <= (skb_shinfo(skb)->gso_segs * 3))) {
4437 netif_stop_queue(tp->dev);
4438 if (tg3_tx_avail(tp) <= (skb_shinfo(skb)->gso_segs * 3))
4439 return NETDEV_TX_BUSY;
4440
4441 netif_wake_queue(tp->dev);
4442 }
4443
4444 segs = skb_gso_segment(skb, tp->dev->features & ~NETIF_F_TSO);
4445 if (IS_ERR(segs))
4446 goto tg3_tso_bug_end;
4447
4448 do {
4449 nskb = segs;
4450 segs = segs->next;
4451 nskb->next = NULL;
4452 tg3_start_xmit_dma_bug(nskb, tp->dev);
4453 } while (segs);
4454
4455 tg3_tso_bug_end:
4456 dev_kfree_skb(skb);
4457
4458 return NETDEV_TX_OK;
4459 }
4460
4461 /* hard_start_xmit for devices that have the 4G bug and/or 40-bit bug and
4462 * support TG3_FLG2_HW_TSO_1 or firmware TSO only.
4463 */
4464 static int tg3_start_xmit_dma_bug(struct sk_buff *skb, struct net_device *dev)
4465 {
4466 struct tg3 *tp = netdev_priv(dev);
4467 dma_addr_t mapping;
4468 u32 len, entry, base_flags, mss;
4469 int would_hit_hwbug;
4470
4471 len = skb_headlen(skb);
4472
4473 /* We are running in BH disabled context with netif_tx_lock
4474 * and TX reclaim runs via tp->napi.poll inside of a software
4475 * interrupt. Furthermore, IRQ processing runs lockless so we have
4476 * no IRQ context deadlocks to worry about either. Rejoice!
4477 */
4478 if (unlikely(tg3_tx_avail(tp) <= (skb_shinfo(skb)->nr_frags + 1))) {
4479 if (!netif_queue_stopped(dev)) {
4480 netif_stop_queue(dev);
4481
4482 /* This is a hard error, log it. */
4483 printk(KERN_ERR PFX "%s: BUG! Tx Ring full when "
4484 "queue awake!\n", dev->name);
4485 }
4486 return NETDEV_TX_BUSY;
4487 }
4488
4489 entry = tp->tx_prod;
4490 base_flags = 0;
4491 if (skb->ip_summed == CHECKSUM_PARTIAL)
4492 base_flags |= TXD_FLAG_TCPUDP_CSUM;
4493 mss = 0;
4494 if ((mss = skb_shinfo(skb)->gso_size) != 0) {
4495 struct iphdr *iph;
4496 int tcp_opt_len, ip_tcp_len, hdr_len;
4497
4498 if (skb_header_cloned(skb) &&
4499 pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) {
4500 dev_kfree_skb(skb);
4501 goto out_unlock;
4502 }
4503
4504 tcp_opt_len = tcp_optlen(skb);
4505 ip_tcp_len = ip_hdrlen(skb) + sizeof(struct tcphdr);
4506
4507 hdr_len = ip_tcp_len + tcp_opt_len;
4508 if (unlikely((ETH_HLEN + hdr_len) > 80) &&
4509 (tp->tg3_flags2 & TG3_FLG2_TSO_BUG))
4510 return (tg3_tso_bug(tp, skb));
4511
4512 base_flags |= (TXD_FLAG_CPU_PRE_DMA |
4513 TXD_FLAG_CPU_POST_DMA);
4514
4515 iph = ip_hdr(skb);
4516 iph->check = 0;
4517 iph->tot_len = htons(mss + hdr_len);
4518 if (tp->tg3_flags2 & TG3_FLG2_HW_TSO) {
4519 tcp_hdr(skb)->check = 0;
4520 base_flags &= ~TXD_FLAG_TCPUDP_CSUM;
4521 } else
4522 tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
4523 iph->daddr, 0,
4524 IPPROTO_TCP,
4525 0);
4526
4527 if ((tp->tg3_flags2 & TG3_FLG2_HW_TSO) ||
4528 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705)) {
4529 if (tcp_opt_len || iph->ihl > 5) {
4530 int tsflags;
4531
4532 tsflags = (iph->ihl - 5) + (tcp_opt_len >> 2);
4533 mss |= (tsflags << 11);
4534 }
4535 } else {
4536 if (tcp_opt_len || iph->ihl > 5) {
4537 int tsflags;
4538
4539 tsflags = (iph->ihl - 5) + (tcp_opt_len >> 2);
4540 base_flags |= tsflags << 12;
4541 }
4542 }
4543 }
4544 #if TG3_VLAN_TAG_USED
4545 if (tp->vlgrp != NULL && vlan_tx_tag_present(skb))
4546 base_flags |= (TXD_FLAG_VLAN |
4547 (vlan_tx_tag_get(skb) << 16));
4548 #endif
4549
4550 /* Queue skb data, a.k.a. the main skb fragment. */
4551 mapping = pci_map_single(tp->pdev, skb->data, len, PCI_DMA_TODEVICE);
4552
4553 tp->tx_buffers[entry].skb = skb;
4554 pci_unmap_addr_set(&tp->tx_buffers[entry], mapping, mapping);
4555
4556 would_hit_hwbug = 0;
4557
4558 if (tp->tg3_flags3 & TG3_FLG3_5701_DMA_BUG)
4559 would_hit_hwbug = 1;
4560 else if (tg3_4g_overflow_test(mapping, len))
4561 would_hit_hwbug = 1;
4562
4563 tg3_set_txd(tp, entry, mapping, len, base_flags,
4564 (skb_shinfo(skb)->nr_frags == 0) | (mss << 1));
4565
4566 entry = NEXT_TX(entry);
4567
4568 /* Now loop through additional data fragments, and queue them. */
4569 if (skb_shinfo(skb)->nr_frags > 0) {
4570 unsigned int i, last;
4571
4572 last = skb_shinfo(skb)->nr_frags - 1;
4573 for (i = 0; i <= last; i++) {
4574 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
4575
4576 len = frag->size;
4577 mapping = pci_map_page(tp->pdev,
4578 frag->page,
4579 frag->page_offset,
4580 len, PCI_DMA_TODEVICE);
4581
4582 tp->tx_buffers[entry].skb = NULL;
4583 pci_unmap_addr_set(&tp->tx_buffers[entry], mapping, mapping);
4584
4585 if (tg3_4g_overflow_test(mapping, len))
4586 would_hit_hwbug = 1;
4587
4588 if (tg3_40bit_overflow_test(tp, mapping, len))
4589 would_hit_hwbug = 1;
4590
4591 if (tp->tg3_flags2 & TG3_FLG2_HW_TSO)
4592 tg3_set_txd(tp, entry, mapping, len,
4593 base_flags, (i == last)|(mss << 1));
4594 else
4595 tg3_set_txd(tp, entry, mapping, len,
4596 base_flags, (i == last));
4597
4598 entry = NEXT_TX(entry);
4599 }
4600 }
4601
4602 if (would_hit_hwbug) {
4603 u32 last_plus_one = entry;
4604 u32 start;
4605
4606 start = entry - 1 - skb_shinfo(skb)->nr_frags;
4607 start &= (TG3_TX_RING_SIZE - 1);
4608
4609 /* If the workaround fails due to memory/mapping
4610 * failure, silently drop this packet.
4611 */
4612 if (tigon3_dma_hwbug_workaround(tp, skb, last_plus_one,
4613 &start, base_flags, mss))
4614 goto out_unlock;
4615
4616 entry = start;
4617 }
4618
4619 /* Packets are ready, update Tx producer idx local and on card. */
4620 tw32_tx_mbox((MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW), entry);
4621
4622 tp->tx_prod = entry;
4623 if (unlikely(tg3_tx_avail(tp) <= (MAX_SKB_FRAGS + 1))) {
4624 netif_stop_queue(dev);
4625 if (tg3_tx_avail(tp) > TG3_TX_WAKEUP_THRESH(tp))
4626 netif_wake_queue(tp->dev);
4627 }
4628
4629 out_unlock:
4630 mmiowb();
4631
4632 dev->trans_start = jiffies;
4633
4634 return NETDEV_TX_OK;
4635 }
4636
4637 static inline void tg3_set_mtu(struct net_device *dev, struct tg3 *tp,
4638 int new_mtu)
4639 {
4640 dev->mtu = new_mtu;
4641
4642 if (new_mtu > ETH_DATA_LEN) {
4643 if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS) {
4644 tp->tg3_flags2 &= ~TG3_FLG2_TSO_CAPABLE;
4645 ethtool_op_set_tso(dev, 0);
4646 }
4647 else
4648 tp->tg3_flags |= TG3_FLAG_JUMBO_RING_ENABLE;
4649 } else {
4650 if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)
4651 tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE;
4652 tp->tg3_flags &= ~TG3_FLAG_JUMBO_RING_ENABLE;
4653 }
4654 }
4655
4656 static int tg3_change_mtu(struct net_device *dev, int new_mtu)
4657 {
4658 struct tg3 *tp = netdev_priv(dev);
4659 int err;
4660
4661 if (new_mtu < TG3_MIN_MTU || new_mtu > TG3_MAX_MTU(tp))
4662 return -EINVAL;
4663
4664 if (!netif_running(dev)) {
4665 /* We'll just catch it later when the
4666 * device is up'd.
4667 */
4668 tg3_set_mtu(dev, tp, new_mtu);
4669 return 0;
4670 }
4671
4672 tg3_netif_stop(tp);
4673
4674 tg3_full_lock(tp, 1);
4675
4676 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
4677
4678 tg3_set_mtu(dev, tp, new_mtu);
4679
4680 err = tg3_restart_hw(tp, 0);
4681
4682 if (!err)
4683 tg3_netif_start(tp);
4684
4685 tg3_full_unlock(tp);
4686
4687 return err;
4688 }
4689
4690 /* Free up pending packets in all rx/tx rings.
4691 *
4692 * The chip has been shut down and the driver detached from
4693 * the networking, so no interrupts or new tx packets will
4694 * end up in the driver. tp->{tx,}lock is not held and we are not
4695 * in an interrupt context and thus may sleep.
4696 */
4697 static void tg3_free_rings(struct tg3 *tp)
4698 {
4699 struct ring_info *rxp;
4700 int i;
4701
4702 for (i = 0; i < TG3_RX_RING_SIZE; i++) {
4703 rxp = &tp->rx_std_buffers[i];
4704
4705 if (rxp->skb == NULL)
4706 continue;
4707 pci_unmap_single(tp->pdev,
4708 pci_unmap_addr(rxp, mapping),
4709 tp->rx_pkt_buf_sz - tp->rx_offset,
4710 PCI_DMA_FROMDEVICE);
4711 dev_kfree_skb_any(rxp->skb);
4712 rxp->skb = NULL;
4713 }
4714
4715 for (i = 0; i < TG3_RX_JUMBO_RING_SIZE; i++) {
4716 rxp = &tp->rx_jumbo_buffers[i];
4717
4718 if (rxp->skb == NULL)
4719 continue;
4720 pci_unmap_single(tp->pdev,
4721 pci_unmap_addr(rxp, mapping),
4722 RX_JUMBO_PKT_BUF_SZ - tp->rx_offset,
4723 PCI_DMA_FROMDEVICE);
4724 dev_kfree_skb_any(rxp->skb);
4725 rxp->skb = NULL;
4726 }
4727
4728 for (i = 0; i < TG3_TX_RING_SIZE; ) {
4729 struct tx_ring_info *txp;
4730 struct sk_buff *skb;
4731 int j;
4732
4733 txp = &tp->tx_buffers[i];
4734 skb = txp->skb;
4735
4736 if (skb == NULL) {
4737 i++;
4738 continue;
4739 }
4740
4741 pci_unmap_single(tp->pdev,
4742 pci_unmap_addr(txp, mapping),
4743 skb_headlen(skb),
4744 PCI_DMA_TODEVICE);
4745 txp->skb = NULL;
4746
4747 i++;
4748
4749 for (j = 0; j < skb_shinfo(skb)->nr_frags; j++) {
4750 txp = &tp->tx_buffers[i & (TG3_TX_RING_SIZE - 1)];
4751 pci_unmap_page(tp->pdev,
4752 pci_unmap_addr(txp, mapping),
4753 skb_shinfo(skb)->frags[j].size,
4754 PCI_DMA_TODEVICE);
4755 i++;
4756 }
4757
4758 dev_kfree_skb_any(skb);
4759 }
4760 }
4761
4762 /* Initialize tx/rx rings for packet processing.
4763 *
4764 * The chip has been shut down and the driver detached from
4765 * the networking, so no interrupts or new tx packets will
4766 * end up in the driver. tp->{tx,}lock are held and thus
4767 * we may not sleep.
4768 */
4769 static int tg3_init_rings(struct tg3 *tp)
4770 {
4771 u32 i;
4772
4773 /* Free up all the SKBs. */
4774 tg3_free_rings(tp);
4775
4776 /* Zero out all descriptors. */
4777 memset(tp->rx_std, 0, TG3_RX_RING_BYTES);
4778 memset(tp->rx_jumbo, 0, TG3_RX_JUMBO_RING_BYTES);
4779 memset(tp->rx_rcb, 0, TG3_RX_RCB_RING_BYTES(tp));
4780 memset(tp->tx_ring, 0, TG3_TX_RING_BYTES);
4781
4782 tp->rx_pkt_buf_sz = RX_PKT_BUF_SZ;
4783 if ((tp->tg3_flags2 & TG3_FLG2_5780_CLASS) &&
4784 (tp->dev->mtu > ETH_DATA_LEN))
4785 tp->rx_pkt_buf_sz = RX_JUMBO_PKT_BUF_SZ;
4786
4787 /* Initialize invariants of the rings, we only set this
4788 * stuff once. This works because the card does not
4789 * write into the rx buffer posting rings.
4790 */
4791 for (i = 0; i < TG3_RX_RING_SIZE; i++) {
4792 struct tg3_rx_buffer_desc *rxd;
4793
4794 rxd = &tp->rx_std[i];
4795 rxd->idx_len = (tp->rx_pkt_buf_sz - tp->rx_offset - 64)
4796 << RXD_LEN_SHIFT;
4797 rxd->type_flags = (RXD_FLAG_END << RXD_FLAGS_SHIFT);
4798 rxd->opaque = (RXD_OPAQUE_RING_STD |
4799 (i << RXD_OPAQUE_INDEX_SHIFT));
4800 }
4801
4802 if (tp->tg3_flags & TG3_FLAG_JUMBO_RING_ENABLE) {
4803 for (i = 0; i < TG3_RX_JUMBO_RING_SIZE; i++) {
4804 struct tg3_rx_buffer_desc *rxd;
4805
4806 rxd = &tp->rx_jumbo[i];
4807 rxd->idx_len = (RX_JUMBO_PKT_BUF_SZ - tp->rx_offset - 64)
4808 << RXD_LEN_SHIFT;
4809 rxd->type_flags = (RXD_FLAG_END << RXD_FLAGS_SHIFT) |
4810 RXD_FLAG_JUMBO;
4811 rxd->opaque = (RXD_OPAQUE_RING_JUMBO |
4812 (i << RXD_OPAQUE_INDEX_SHIFT));
4813 }
4814 }
4815
4816 /* Now allocate fresh SKBs for each rx ring. */
4817 for (i = 0; i < tp->rx_pending; i++) {
4818 if (tg3_alloc_rx_skb(tp, RXD_OPAQUE_RING_STD, -1, i) < 0) {
4819 printk(KERN_WARNING PFX
4820 "%s: Using a smaller RX standard ring, "
4821 "only %d out of %d buffers were allocated "
4822 "successfully.\n",
4823 tp->dev->name, i, tp->rx_pending);
4824 if (i == 0)
4825 return -ENOMEM;
4826 tp->rx_pending = i;
4827 break;
4828 }
4829 }
4830
4831 if (tp->tg3_flags & TG3_FLAG_JUMBO_RING_ENABLE) {
4832 for (i = 0; i < tp->rx_jumbo_pending; i++) {
4833 if (tg3_alloc_rx_skb(tp, RXD_OPAQUE_RING_JUMBO,
4834 -1, i) < 0) {
4835 printk(KERN_WARNING PFX
4836 "%s: Using a smaller RX jumbo ring, "
4837 "only %d out of %d buffers were "
4838 "allocated successfully.\n",
4839 tp->dev->name, i, tp->rx_jumbo_pending);
4840 if (i == 0) {
4841 tg3_free_rings(tp);
4842 return -ENOMEM;
4843 }
4844 tp->rx_jumbo_pending = i;
4845 break;
4846 }
4847 }
4848 }
4849 return 0;
4850 }
4851
4852 /*
4853 * Must not be invoked with interrupt sources disabled and
4854 * the hardware shutdown down.
4855 */
4856 static void tg3_free_consistent(struct tg3 *tp)
4857 {
4858 kfree(tp->rx_std_buffers);
4859 tp->rx_std_buffers = NULL;
4860 if (tp->rx_std) {
4861 pci_free_consistent(tp->pdev, TG3_RX_RING_BYTES,
4862 tp->rx_std, tp->rx_std_mapping);
4863 tp->rx_std = NULL;
4864 }
4865 if (tp->rx_jumbo) {
4866 pci_free_consistent(tp->pdev, TG3_RX_JUMBO_RING_BYTES,
4867 tp->rx_jumbo, tp->rx_jumbo_mapping);
4868 tp->rx_jumbo = NULL;
4869 }
4870 if (tp->rx_rcb) {
4871 pci_free_consistent(tp->pdev, TG3_RX_RCB_RING_BYTES(tp),
4872 tp->rx_rcb, tp->rx_rcb_mapping);
4873 tp->rx_rcb = NULL;
4874 }
4875 if (tp->tx_ring) {
4876 pci_free_consistent(tp->pdev, TG3_TX_RING_BYTES,
4877 tp->tx_ring, tp->tx_desc_mapping);
4878 tp->tx_ring = NULL;
4879 }
4880 if (tp->hw_status) {
4881 pci_free_consistent(tp->pdev, TG3_HW_STATUS_SIZE,
4882 tp->hw_status, tp->status_mapping);
4883 tp->hw_status = NULL;
4884 }
4885 if (tp->hw_stats) {
4886 pci_free_consistent(tp->pdev, sizeof(struct tg3_hw_stats),
4887 tp->hw_stats, tp->stats_mapping);
4888 tp->hw_stats = NULL;
4889 }
4890 }
4891
4892 /*
4893 * Must not be invoked with interrupt sources disabled and
4894 * the hardware shutdown down. Can sleep.
4895 */
4896 static int tg3_alloc_consistent(struct tg3 *tp)
4897 {
4898 tp->rx_std_buffers = kzalloc((sizeof(struct ring_info) *
4899 (TG3_RX_RING_SIZE +
4900 TG3_RX_JUMBO_RING_SIZE)) +
4901 (sizeof(struct tx_ring_info) *
4902 TG3_TX_RING_SIZE),
4903 GFP_KERNEL);
4904 if (!tp->rx_std_buffers)
4905 return -ENOMEM;
4906
4907 tp->rx_jumbo_buffers = &tp->rx_std_buffers[TG3_RX_RING_SIZE];
4908 tp->tx_buffers = (struct tx_ring_info *)
4909 &tp->rx_jumbo_buffers[TG3_RX_JUMBO_RING_SIZE];
4910
4911 tp->rx_std = pci_alloc_consistent(tp->pdev, TG3_RX_RING_BYTES,
4912 &tp->rx_std_mapping);
4913 if (!tp->rx_std)
4914 goto err_out;
4915
4916 tp->rx_jumbo = pci_alloc_consistent(tp->pdev, TG3_RX_JUMBO_RING_BYTES,
4917 &tp->rx_jumbo_mapping);
4918
4919 if (!tp->rx_jumbo)
4920 goto err_out;
4921
4922 tp->rx_rcb = pci_alloc_consistent(tp->pdev, TG3_RX_RCB_RING_BYTES(tp),
4923 &tp->rx_rcb_mapping);
4924 if (!tp->rx_rcb)
4925 goto err_out;
4926
4927 tp->tx_ring = pci_alloc_consistent(tp->pdev, TG3_TX_RING_BYTES,
4928 &tp->tx_desc_mapping);
4929 if (!tp->tx_ring)
4930 goto err_out;
4931
4932 tp->hw_status = pci_alloc_consistent(tp->pdev,
4933 TG3_HW_STATUS_SIZE,
4934 &tp->status_mapping);
4935 if (!tp->hw_status)
4936 goto err_out;
4937
4938 tp->hw_stats = pci_alloc_consistent(tp->pdev,
4939 sizeof(struct tg3_hw_stats),
4940 &tp->stats_mapping);
4941 if (!tp->hw_stats)
4942 goto err_out;
4943
4944 memset(tp->hw_status, 0, TG3_HW_STATUS_SIZE);
4945 memset(tp->hw_stats, 0, sizeof(struct tg3_hw_stats));
4946
4947 return 0;
4948
4949 err_out:
4950 tg3_free_consistent(tp);
4951 return -ENOMEM;
4952 }
4953
4954 #define MAX_WAIT_CNT 1000
4955
4956 /* To stop a block, clear the enable bit and poll till it
4957 * clears. tp->lock is held.
4958 */
4959 static int tg3_stop_block(struct tg3 *tp, unsigned long ofs, u32 enable_bit, int silent)
4960 {
4961 unsigned int i;
4962 u32 val;
4963
4964 if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
4965 switch (ofs) {
4966 case RCVLSC_MODE:
4967 case DMAC_MODE:
4968 case MBFREE_MODE:
4969 case BUFMGR_MODE:
4970 case MEMARB_MODE:
4971 /* We can't enable/disable these bits of the
4972 * 5705/5750, just say success.
4973 */
4974 return 0;
4975
4976 default:
4977 break;
4978 };
4979 }
4980
4981 val = tr32(ofs);
4982 val &= ~enable_bit;
4983 tw32_f(ofs, val);
4984
4985 for (i = 0; i < MAX_WAIT_CNT; i++) {
4986 udelay(100);
4987 val = tr32(ofs);
4988 if ((val & enable_bit) == 0)
4989 break;
4990 }
4991
4992 if (i == MAX_WAIT_CNT && !silent) {
4993 printk(KERN_ERR PFX "tg3_stop_block timed out, "
4994 "ofs=%lx enable_bit=%x\n",
4995 ofs, enable_bit);
4996 return -ENODEV;
4997 }
4998
4999 return 0;
5000 }
5001
5002 /* tp->lock is held. */
5003 static int tg3_abort_hw(struct tg3 *tp, int silent)
5004 {
5005 int i, err;
5006
5007 tg3_disable_ints(tp);
5008
5009 tp->rx_mode &= ~RX_MODE_ENABLE;
5010 tw32_f(MAC_RX_MODE, tp->rx_mode);
5011 udelay(10);
5012
5013 err = tg3_stop_block(tp, RCVBDI_MODE, RCVBDI_MODE_ENABLE, silent);
5014 err |= tg3_stop_block(tp, RCVLPC_MODE, RCVLPC_MODE_ENABLE, silent);
5015 err |= tg3_stop_block(tp, RCVLSC_MODE, RCVLSC_MODE_ENABLE, silent);
5016 err |= tg3_stop_block(tp, RCVDBDI_MODE, RCVDBDI_MODE_ENABLE, silent);
5017 err |= tg3_stop_block(tp, RCVDCC_MODE, RCVDCC_MODE_ENABLE, silent);
5018 err |= tg3_stop_block(tp, RCVCC_MODE, RCVCC_MODE_ENABLE, silent);
5019
5020 err |= tg3_stop_block(tp, SNDBDS_MODE, SNDBDS_MODE_ENABLE, silent);
5021 err |= tg3_stop_block(tp, SNDBDI_MODE, SNDBDI_MODE_ENABLE, silent);
5022 err |= tg3_stop_block(tp, SNDDATAI_MODE, SNDDATAI_MODE_ENABLE, silent);
5023 err |= tg3_stop_block(tp, RDMAC_MODE, RDMAC_MODE_ENABLE, silent);
5024 err |= tg3_stop_block(tp, SNDDATAC_MODE, SNDDATAC_MODE_ENABLE, silent);
5025 err |= tg3_stop_block(tp, DMAC_MODE, DMAC_MODE_ENABLE, silent);
5026 err |= tg3_stop_block(tp, SNDBDC_MODE, SNDBDC_MODE_ENABLE, silent);
5027
5028 tp->mac_mode &= ~MAC_MODE_TDE_ENABLE;
5029 tw32_f(MAC_MODE, tp->mac_mode);
5030 udelay(40);
5031
5032 tp->tx_mode &= ~TX_MODE_ENABLE;
5033 tw32_f(MAC_TX_MODE, tp->tx_mode);
5034
5035 for (i = 0; i < MAX_WAIT_CNT; i++) {
5036 udelay(100);
5037 if (!(tr32(MAC_TX_MODE) & TX_MODE_ENABLE))
5038 break;
5039 }
5040 if (i >= MAX_WAIT_CNT) {
5041 printk(KERN_ERR PFX "tg3_abort_hw timed out for %s, "
5042 "TX_MODE_ENABLE will not clear MAC_TX_MODE=%08x\n",
5043 tp->dev->name, tr32(MAC_TX_MODE));
5044 err |= -ENODEV;
5045 }
5046
5047 err |= tg3_stop_block(tp, HOSTCC_MODE, HOSTCC_MODE_ENABLE, silent);
5048 err |= tg3_stop_block(tp, WDMAC_MODE, WDMAC_MODE_ENABLE, silent);
5049 err |= tg3_stop_block(tp, MBFREE_MODE, MBFREE_MODE_ENABLE, silent);
5050
5051 tw32(FTQ_RESET, 0xffffffff);
5052 tw32(FTQ_RESET, 0x00000000);
5053
5054 err |= tg3_stop_block(tp, BUFMGR_MODE, BUFMGR_MODE_ENABLE, silent);
5055 err |= tg3_stop_block(tp, MEMARB_MODE, MEMARB_MODE_ENABLE, silent);
5056
5057 if (tp->hw_status)
5058 memset(tp->hw_status, 0, TG3_HW_STATUS_SIZE);
5059 if (tp->hw_stats)
5060 memset(tp->hw_stats, 0, sizeof(struct tg3_hw_stats));
5061
5062 return err;
5063 }
5064
5065 /* tp->lock is held. */
5066 static int tg3_nvram_lock(struct tg3 *tp)
5067 {
5068 if (tp->tg3_flags & TG3_FLAG_NVRAM) {
5069 int i;
5070
5071 if (tp->nvram_lock_cnt == 0) {
5072 tw32(NVRAM_SWARB, SWARB_REQ_SET1);
5073 for (i = 0; i < 8000; i++) {
5074 if (tr32(NVRAM_SWARB) & SWARB_GNT1)
5075 break;
5076 udelay(20);
5077 }
5078 if (i == 8000) {
5079 tw32(NVRAM_SWARB, SWARB_REQ_CLR1);
5080 return -ENODEV;
5081 }
5082 }
5083 tp->nvram_lock_cnt++;
5084 }
5085 return 0;
5086 }
5087
5088 /* tp->lock is held. */
5089 static void tg3_nvram_unlock(struct tg3 *tp)
5090 {
5091 if (tp->tg3_flags & TG3_FLAG_NVRAM) {
5092 if (tp->nvram_lock_cnt > 0)
5093 tp->nvram_lock_cnt--;
5094 if (tp->nvram_lock_cnt == 0)
5095 tw32_f(NVRAM_SWARB, SWARB_REQ_CLR1);
5096 }
5097 }
5098
5099 /* tp->lock is held. */
5100 static void tg3_enable_nvram_access(struct tg3 *tp)
5101 {
5102 if ((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
5103 !(tp->tg3_flags2 & TG3_FLG2_PROTECTED_NVRAM)) {
5104 u32 nvaccess = tr32(NVRAM_ACCESS);
5105
5106 tw32(NVRAM_ACCESS, nvaccess | ACCESS_ENABLE);
5107 }
5108 }
5109
5110 /* tp->lock is held. */
5111 static void tg3_disable_nvram_access(struct tg3 *tp)
5112 {
5113 if ((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
5114 !(tp->tg3_flags2 & TG3_FLG2_PROTECTED_NVRAM)) {
5115 u32 nvaccess = tr32(NVRAM_ACCESS);
5116
5117 tw32(NVRAM_ACCESS, nvaccess & ~ACCESS_ENABLE);
5118 }
5119 }
5120
5121 static void tg3_ape_send_event(struct tg3 *tp, u32 event)
5122 {
5123 int i;
5124 u32 apedata;
5125
5126 apedata = tg3_ape_read32(tp, TG3_APE_SEG_SIG);
5127 if (apedata != APE_SEG_SIG_MAGIC)
5128 return;
5129
5130 apedata = tg3_ape_read32(tp, TG3_APE_FW_STATUS);
5131 if (apedata != APE_FW_STATUS_READY)
5132 return;
5133
5134 /* Wait for up to 1 millisecond for APE to service previous event. */
5135 for (i = 0; i < 10; i++) {
5136 if (tg3_ape_lock(tp, TG3_APE_LOCK_MEM))
5137 return;
5138
5139 apedata = tg3_ape_read32(tp, TG3_APE_EVENT_STATUS);
5140
5141 if (!(apedata & APE_EVENT_STATUS_EVENT_PENDING))
5142 tg3_ape_write32(tp, TG3_APE_EVENT_STATUS,
5143 event | APE_EVENT_STATUS_EVENT_PENDING);
5144
5145 tg3_ape_unlock(tp, TG3_APE_LOCK_MEM);
5146
5147 if (!(apedata & APE_EVENT_STATUS_EVENT_PENDING))
5148 break;
5149
5150 udelay(100);
5151 }
5152
5153 if (!(apedata & APE_EVENT_STATUS_EVENT_PENDING))
5154 tg3_ape_write32(tp, TG3_APE_EVENT, APE_EVENT_1);
5155 }
5156
5157 static void tg3_ape_driver_state_change(struct tg3 *tp, int kind)
5158 {
5159 u32 event;
5160 u32 apedata;
5161
5162 if (!(tp->tg3_flags3 & TG3_FLG3_ENABLE_APE))
5163 return;
5164
5165 switch (kind) {
5166 case RESET_KIND_INIT:
5167 tg3_ape_write32(tp, TG3_APE_HOST_SEG_SIG,
5168 APE_HOST_SEG_SIG_MAGIC);
5169 tg3_ape_write32(tp, TG3_APE_HOST_SEG_LEN,
5170 APE_HOST_SEG_LEN_MAGIC);
5171 apedata = tg3_ape_read32(tp, TG3_APE_HOST_INIT_COUNT);
5172 tg3_ape_write32(tp, TG3_APE_HOST_INIT_COUNT, ++apedata);
5173 tg3_ape_write32(tp, TG3_APE_HOST_DRIVER_ID,
5174 APE_HOST_DRIVER_ID_MAGIC);
5175 tg3_ape_write32(tp, TG3_APE_HOST_BEHAVIOR,
5176 APE_HOST_BEHAV_NO_PHYLOCK);
5177
5178 event = APE_EVENT_STATUS_STATE_START;
5179 break;
5180 case RESET_KIND_SHUTDOWN:
5181 event = APE_EVENT_STATUS_STATE_UNLOAD;
5182 break;
5183 case RESET_KIND_SUSPEND:
5184 event = APE_EVENT_STATUS_STATE_SUSPEND;
5185 break;
5186 default:
5187 return;
5188 }
5189
5190 event |= APE_EVENT_STATUS_DRIVER_EVNT | APE_EVENT_STATUS_STATE_CHNGE;
5191
5192 tg3_ape_send_event(tp, event);
5193 }
5194
5195 /* tp->lock is held. */
5196 static void tg3_write_sig_pre_reset(struct tg3 *tp, int kind)
5197 {
5198 tg3_write_mem(tp, NIC_SRAM_FIRMWARE_MBOX,
5199 NIC_SRAM_FIRMWARE_MBOX_MAGIC1);
5200
5201 if (tp->tg3_flags2 & TG3_FLG2_ASF_NEW_HANDSHAKE) {
5202 switch (kind) {
5203 case RESET_KIND_INIT:
5204 tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
5205 DRV_STATE_START);
5206 break;
5207
5208 case RESET_KIND_SHUTDOWN:
5209 tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
5210 DRV_STATE_UNLOAD);
5211 break;
5212
5213 case RESET_KIND_SUSPEND:
5214 tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
5215 DRV_STATE_SUSPEND);
5216 break;
5217
5218 default:
5219 break;
5220 };
5221 }
5222
5223 if (kind == RESET_KIND_INIT ||
5224 kind == RESET_KIND_SUSPEND)
5225 tg3_ape_driver_state_change(tp, kind);
5226 }
5227
5228 /* tp->lock is held. */
5229 static void tg3_write_sig_post_reset(struct tg3 *tp, int kind)
5230 {
5231 if (tp->tg3_flags2 & TG3_FLG2_ASF_NEW_HANDSHAKE) {
5232 switch (kind) {
5233 case RESET_KIND_INIT:
5234 tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
5235 DRV_STATE_START_DONE);
5236 break;
5237
5238 case RESET_KIND_SHUTDOWN:
5239 tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
5240 DRV_STATE_UNLOAD_DONE);
5241 break;
5242
5243 default:
5244 break;
5245 };
5246 }
5247
5248 if (kind == RESET_KIND_SHUTDOWN)
5249 tg3_ape_driver_state_change(tp, kind);
5250 }
5251
5252 /* tp->lock is held. */
5253 static void tg3_write_sig_legacy(struct tg3 *tp, int kind)
5254 {
5255 if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) {
5256 switch (kind) {
5257 case RESET_KIND_INIT:
5258 tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
5259 DRV_STATE_START);
5260 break;
5261
5262 case RESET_KIND_SHUTDOWN:
5263 tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
5264 DRV_STATE_UNLOAD);
5265 break;
5266
5267 case RESET_KIND_SUSPEND:
5268 tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
5269 DRV_STATE_SUSPEND);
5270 break;
5271
5272 default:
5273 break;
5274 };
5275 }
5276 }
5277
5278 static int tg3_poll_fw(struct tg3 *tp)
5279 {
5280 int i;
5281 u32 val;
5282
5283 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
5284 /* Wait up to 20ms for init done. */
5285 for (i = 0; i < 200; i++) {
5286 if (tr32(VCPU_STATUS) & VCPU_STATUS_INIT_DONE)
5287 return 0;
5288 udelay(100);
5289 }
5290 return -ENODEV;
5291 }
5292
5293 /* Wait for firmware initialization to complete. */
5294 for (i = 0; i < 100000; i++) {
5295 tg3_read_mem(tp, NIC_SRAM_FIRMWARE_MBOX, &val);
5296 if (val == ~NIC_SRAM_FIRMWARE_MBOX_MAGIC1)
5297 break;
5298 udelay(10);
5299 }
5300
5301 /* Chip might not be fitted with firmware. Some Sun onboard
5302 * parts are configured like that. So don't signal the timeout
5303 * of the above loop as an error, but do report the lack of
5304 * running firmware once.
5305 */
5306 if (i >= 100000 &&
5307 !(tp->tg3_flags2 & TG3_FLG2_NO_FWARE_REPORTED)) {
5308 tp->tg3_flags2 |= TG3_FLG2_NO_FWARE_REPORTED;
5309
5310 printk(KERN_INFO PFX "%s: No firmware running.\n",
5311 tp->dev->name);
5312 }
5313
5314 return 0;
5315 }
5316
5317 /* Save PCI command register before chip reset */
5318 static void tg3_save_pci_state(struct tg3 *tp)
5319 {
5320 pci_read_config_word(tp->pdev, PCI_COMMAND, &tp->pci_cmd);
5321 }
5322
5323 /* Restore PCI state after chip reset */
5324 static void tg3_restore_pci_state(struct tg3 *tp)
5325 {
5326 u32 val;
5327
5328 /* Re-enable indirect register accesses. */
5329 pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
5330 tp->misc_host_ctrl);
5331
5332 /* Set MAX PCI retry to zero. */
5333 val = (PCISTATE_ROM_ENABLE | PCISTATE_ROM_RETRY_ENABLE);
5334 if (tp->pci_chip_rev_id == CHIPREV_ID_5704_A0 &&
5335 (tp->tg3_flags & TG3_FLAG_PCIX_MODE))
5336 val |= PCISTATE_RETRY_SAME_DMA;
5337 /* Allow reads and writes to the APE register and memory space. */
5338 if (tp->tg3_flags3 & TG3_FLG3_ENABLE_APE)
5339 val |= PCISTATE_ALLOW_APE_CTLSPC_WR |
5340 PCISTATE_ALLOW_APE_SHMEM_WR;
5341 pci_write_config_dword(tp->pdev, TG3PCI_PCISTATE, val);
5342
5343 pci_write_config_word(tp->pdev, PCI_COMMAND, tp->pci_cmd);
5344
5345 if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS)
5346 pcie_set_readrq(tp->pdev, 4096);
5347 else {
5348 pci_write_config_byte(tp->pdev, PCI_CACHE_LINE_SIZE,
5349 tp->pci_cacheline_sz);
5350 pci_write_config_byte(tp->pdev, PCI_LATENCY_TIMER,
5351 tp->pci_lat_timer);
5352 }
5353
5354 /* Make sure PCI-X relaxed ordering bit is clear. */
5355 if (tp->pcix_cap) {
5356 u16 pcix_cmd;
5357
5358 pci_read_config_word(tp->pdev, tp->pcix_cap + PCI_X_CMD,
5359 &pcix_cmd);
5360 pcix_cmd &= ~PCI_X_CMD_ERO;
5361 pci_write_config_word(tp->pdev, tp->pcix_cap + PCI_X_CMD,
5362 pcix_cmd);
5363 }
5364
5365 if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS) {
5366
5367 /* Chip reset on 5780 will reset MSI enable bit,
5368 * so need to restore it.
5369 */
5370 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
5371 u16 ctrl;
5372
5373 pci_read_config_word(tp->pdev,
5374 tp->msi_cap + PCI_MSI_FLAGS,
5375 &ctrl);
5376 pci_write_config_word(tp->pdev,
5377 tp->msi_cap + PCI_MSI_FLAGS,
5378 ctrl | PCI_MSI_FLAGS_ENABLE);
5379 val = tr32(MSGINT_MODE);
5380 tw32(MSGINT_MODE, val | MSGINT_MODE_ENABLE);
5381 }
5382 }
5383 }
5384
5385 static void tg3_stop_fw(struct tg3 *);
5386
5387 /* tp->lock is held. */
5388 static int tg3_chip_reset(struct tg3 *tp)
5389 {
5390 u32 val;
5391 void (*write_op)(struct tg3 *, u32, u32);
5392 int err;
5393
5394 tg3_nvram_lock(tp);
5395
5396 /* No matching tg3_nvram_unlock() after this because
5397 * chip reset below will undo the nvram lock.
5398 */
5399 tp->nvram_lock_cnt = 0;
5400
5401 /* GRC_MISC_CFG core clock reset will clear the memory
5402 * enable bit in PCI register 4 and the MSI enable bit
5403 * on some chips, so we save relevant registers here.
5404 */
5405 tg3_save_pci_state(tp);
5406
5407 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 ||
5408 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
5409 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
5410 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
5411 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761)
5412 tw32(GRC_FASTBOOT_PC, 0);
5413
5414 /*
5415 * We must avoid the readl() that normally takes place.
5416 * It locks machines, causes machine checks, and other
5417 * fun things. So, temporarily disable the 5701
5418 * hardware workaround, while we do the reset.
5419 */
5420 write_op = tp->write32;
5421 if (write_op == tg3_write_flush_reg32)
5422 tp->write32 = tg3_write32;
5423
5424 /* Prevent the irq handler from reading or writing PCI registers
5425 * during chip reset when the memory enable bit in the PCI command
5426 * register may be cleared. The chip does not generate interrupt
5427 * at this time, but the irq handler may still be called due to irq
5428 * sharing or irqpoll.
5429 */
5430 tp->tg3_flags |= TG3_FLAG_CHIP_RESETTING;
5431 if (tp->hw_status) {
5432 tp->hw_status->status = 0;
5433 tp->hw_status->status_tag = 0;
5434 }
5435 tp->last_tag = 0;
5436 smp_mb();
5437 synchronize_irq(tp->pdev->irq);
5438
5439 /* do the reset */
5440 val = GRC_MISC_CFG_CORECLK_RESET;
5441
5442 if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
5443 if (tr32(0x7e2c) == 0x60) {
5444 tw32(0x7e2c, 0x20);
5445 }
5446 if (tp->pci_chip_rev_id != CHIPREV_ID_5750_A0) {
5447 tw32(GRC_MISC_CFG, (1 << 29));
5448 val |= (1 << 29);
5449 }
5450 }
5451
5452 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
5453 tw32(VCPU_STATUS, tr32(VCPU_STATUS) | VCPU_STATUS_DRV_RESET);
5454 tw32(GRC_VCPU_EXT_CTRL,
5455 tr32(GRC_VCPU_EXT_CTRL) & ~GRC_VCPU_EXT_CTRL_HALT_CPU);
5456 }
5457
5458 if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)
5459 val |= GRC_MISC_CFG_KEEP_GPHY_POWER;
5460 tw32(GRC_MISC_CFG, val);
5461
5462 /* restore 5701 hardware bug workaround write method */
5463 tp->write32 = write_op;
5464
5465 /* Unfortunately, we have to delay before the PCI read back.
5466 * Some 575X chips even will not respond to a PCI cfg access
5467 * when the reset command is given to the chip.
5468 *
5469 * How do these hardware designers expect things to work
5470 * properly if the PCI write is posted for a long period
5471 * of time? It is always necessary to have some method by
5472 * which a register read back can occur to push the write
5473 * out which does the reset.
5474 *
5475 * For most tg3 variants the trick below was working.
5476 * Ho hum...
5477 */
5478 udelay(120);
5479
5480 /* Flush PCI posted writes. The normal MMIO registers
5481 * are inaccessible at this time so this is the only
5482 * way to make this reliably (actually, this is no longer
5483 * the case, see above). I tried to use indirect
5484 * register read/write but this upset some 5701 variants.
5485 */
5486 pci_read_config_dword(tp->pdev, PCI_COMMAND, &val);
5487
5488 udelay(120);
5489
5490 if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
5491 if (tp->pci_chip_rev_id == CHIPREV_ID_5750_A0) {
5492 int i;
5493 u32 cfg_val;
5494
5495 /* Wait for link training to complete. */
5496 for (i = 0; i < 5000; i++)
5497 udelay(100);
5498
5499 pci_read_config_dword(tp->pdev, 0xc4, &cfg_val);
5500 pci_write_config_dword(tp->pdev, 0xc4,
5501 cfg_val | (1 << 15));
5502 }
5503 /* Set PCIE max payload size and clear error status. */
5504 pci_write_config_dword(tp->pdev, 0xd8, 0xf5000);
5505 }
5506
5507 tg3_restore_pci_state(tp);
5508
5509 tp->tg3_flags &= ~TG3_FLAG_CHIP_RESETTING;
5510
5511 val = 0;
5512 if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)
5513 val = tr32(MEMARB_MODE);
5514 tw32(MEMARB_MODE, val | MEMARB_MODE_ENABLE);
5515
5516 if (tp->pci_chip_rev_id == CHIPREV_ID_5750_A3) {
5517 tg3_stop_fw(tp);
5518 tw32(0x5000, 0x400);
5519 }
5520
5521 tw32(GRC_MODE, tp->grc_mode);
5522
5523 if (tp->pci_chip_rev_id == CHIPREV_ID_5705_A0) {
5524 val = tr32(0xc4);
5525
5526 tw32(0xc4, val | (1 << 15));
5527 }
5528
5529 if ((tp->nic_sram_data_cfg & NIC_SRAM_DATA_CFG_MINI_PCI) != 0 &&
5530 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) {
5531 tp->pci_clock_ctrl |= CLOCK_CTRL_CLKRUN_OENABLE;
5532 if (tp->pci_chip_rev_id == CHIPREV_ID_5705_A0)
5533 tp->pci_clock_ctrl |= CLOCK_CTRL_FORCE_CLKRUN;
5534 tw32(TG3PCI_CLOCK_CTRL, tp->pci_clock_ctrl);
5535 }
5536
5537 if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
5538 tp->mac_mode = MAC_MODE_PORT_MODE_TBI;
5539 tw32_f(MAC_MODE, tp->mac_mode);
5540 } else if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES) {
5541 tp->mac_mode = MAC_MODE_PORT_MODE_GMII;
5542 tw32_f(MAC_MODE, tp->mac_mode);
5543 } else
5544 tw32_f(MAC_MODE, 0);
5545 udelay(40);
5546
5547 err = tg3_poll_fw(tp);
5548 if (err)
5549 return err;
5550
5551 if ((tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) &&
5552 tp->pci_chip_rev_id != CHIPREV_ID_5750_A0) {
5553 val = tr32(0x7c00);
5554
5555 tw32(0x7c00, val | (1 << 25));
5556 }
5557
5558 /* Reprobe ASF enable state. */
5559 tp->tg3_flags &= ~TG3_FLAG_ENABLE_ASF;
5560 tp->tg3_flags2 &= ~TG3_FLG2_ASF_NEW_HANDSHAKE;
5561 tg3_read_mem(tp, NIC_SRAM_DATA_SIG, &val);
5562 if (val == NIC_SRAM_DATA_SIG_MAGIC) {
5563 u32 nic_cfg;
5564
5565 tg3_read_mem(tp, NIC_SRAM_DATA_CFG, &nic_cfg);
5566 if (nic_cfg & NIC_SRAM_DATA_CFG_ASF_ENABLE) {
5567 tp->tg3_flags |= TG3_FLAG_ENABLE_ASF;
5568 if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
5569 tp->tg3_flags2 |= TG3_FLG2_ASF_NEW_HANDSHAKE;
5570 }
5571 }
5572
5573 return 0;
5574 }
5575
5576 /* tp->lock is held. */
5577 static void tg3_stop_fw(struct tg3 *tp)
5578 {
5579 if ((tp->tg3_flags & TG3_FLAG_ENABLE_ASF) &&
5580 !(tp->tg3_flags3 & TG3_FLG3_ENABLE_APE)) {
5581 u32 val;
5582
5583 /* Wait for RX cpu to ACK the previous event. */
5584 tg3_wait_for_event_ack(tp);
5585
5586 tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX, FWCMD_NICDRV_PAUSE_FW);
5587 val = tr32(GRC_RX_CPU_EVENT);
5588 val |= GRC_RX_CPU_DRIVER_EVENT;
5589 tw32(GRC_RX_CPU_EVENT, val);
5590
5591 /* Wait for RX cpu to ACK this event. */
5592 tg3_wait_for_event_ack(tp);
5593 }
5594 }
5595
5596 /* tp->lock is held. */
5597 static int tg3_halt(struct tg3 *tp, int kind, int silent)
5598 {
5599 int err;
5600
5601 tg3_stop_fw(tp);
5602
5603 tg3_write_sig_pre_reset(tp, kind);
5604
5605 tg3_abort_hw(tp, silent);
5606 err = tg3_chip_reset(tp);
5607
5608 tg3_write_sig_legacy(tp, kind);
5609 tg3_write_sig_post_reset(tp, kind);
5610
5611 if (err)
5612 return err;
5613
5614 return 0;
5615 }
5616
5617 #define TG3_FW_RELEASE_MAJOR 0x0
5618 #define TG3_FW_RELASE_MINOR 0x0
5619 #define TG3_FW_RELEASE_FIX 0x0
5620 #define TG3_FW_START_ADDR 0x08000000
5621 #define TG3_FW_TEXT_ADDR 0x08000000
5622 #define TG3_FW_TEXT_LEN 0x9c0
5623 #define TG3_FW_RODATA_ADDR 0x080009c0
5624 #define TG3_FW_RODATA_LEN 0x60
5625 #define TG3_FW_DATA_ADDR 0x08000a40
5626 #define TG3_FW_DATA_LEN 0x20
5627 #define TG3_FW_SBSS_ADDR 0x08000a60
5628 #define TG3_FW_SBSS_LEN 0xc
5629 #define TG3_FW_BSS_ADDR 0x08000a70
5630 #define TG3_FW_BSS_LEN 0x10
5631
5632 static const u32 tg3FwText[(TG3_FW_TEXT_LEN / sizeof(u32)) + 1] = {
5633 0x00000000, 0x10000003, 0x00000000, 0x0000000d, 0x0000000d, 0x3c1d0800,
5634 0x37bd3ffc, 0x03a0f021, 0x3c100800, 0x26100000, 0x0e000018, 0x00000000,
5635 0x0000000d, 0x3c1d0800, 0x37bd3ffc, 0x03a0f021, 0x3c100800, 0x26100034,
5636 0x0e00021c, 0x00000000, 0x0000000d, 0x00000000, 0x00000000, 0x00000000,
5637 0x27bdffe0, 0x3c1cc000, 0xafbf0018, 0xaf80680c, 0x0e00004c, 0x241b2105,
5638 0x97850000, 0x97870002, 0x9782002c, 0x9783002e, 0x3c040800, 0x248409c0,
5639 0xafa00014, 0x00021400, 0x00621825, 0x00052c00, 0xafa30010, 0x8f860010,
5640 0x00e52825, 0x0e000060, 0x24070102, 0x3c02ac00, 0x34420100, 0x3c03ac01,
5641 0x34630100, 0xaf820490, 0x3c02ffff, 0xaf820494, 0xaf830498, 0xaf82049c,
5642 0x24020001, 0xaf825ce0, 0x0e00003f, 0xaf825d00, 0x0e000140, 0x00000000,
5643 0x8fbf0018, 0x03e00008, 0x27bd0020, 0x2402ffff, 0xaf825404, 0x8f835400,
5644 0x34630400, 0xaf835400, 0xaf825404, 0x3c020800, 0x24420034, 0xaf82541c,
5645 0x03e00008, 0xaf805400, 0x00000000, 0x00000000, 0x3c020800, 0x34423000,
5646 0x3c030800, 0x34633000, 0x3c040800, 0x348437ff, 0x3c010800, 0xac220a64,
5647 0x24020040, 0x3c010800, 0xac220a68, 0x3c010800, 0xac200a60, 0xac600000,
5648 0x24630004, 0x0083102b, 0x5040fffd, 0xac600000, 0x03e00008, 0x00000000,
5649 0x00804821, 0x8faa0010, 0x3c020800, 0x8c420a60, 0x3c040800, 0x8c840a68,
5650 0x8fab0014, 0x24430001, 0x0044102b, 0x3c010800, 0xac230a60, 0x14400003,
5651 0x00004021, 0x3c010800, 0xac200a60, 0x3c020800, 0x8c420a60, 0x3c030800,
5652 0x8c630a64, 0x91240000, 0x00021140, 0x00431021, 0x00481021, 0x25080001,
5653 0xa0440000, 0x29020008, 0x1440fff4, 0x25290001, 0x3c020800, 0x8c420a60,
5654 0x3c030800, 0x8c630a64, 0x8f84680c, 0x00021140, 0x00431021, 0xac440008,
5655 0xac45000c, 0xac460010, 0xac470014, 0xac4a0018, 0x03e00008, 0xac4b001c,
5656 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5657 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5658 0, 0, 0, 0, 0, 0,
5659 0x02000008, 0x00000000, 0x0a0001e3, 0x3c0a0001, 0x0a0001e3, 0x3c0a0002,
5660 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000,
5661 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000,
5662 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000,
5663 0x0a0001e3, 0x3c0a0007, 0x0a0001e3, 0x3c0a0008, 0x0a0001e3, 0x3c0a0009,
5664 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x3c0a000b,
5665 0x0a0001e3, 0x3c0a000c, 0x0a0001e3, 0x3c0a000d, 0x0a0001e3, 0x00000000,
5666 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x3c0a000e, 0x0a0001e3, 0x00000000,
5667 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000,
5668 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000,
5669 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x3c0a0013, 0x0a0001e3, 0x3c0a0014,
5670 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5671 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5672 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5673 0x27bdffe0, 0x00001821, 0x00001021, 0xafbf0018, 0xafb10014, 0xafb00010,
5674 0x3c010800, 0x00220821, 0xac200a70, 0x3c010800, 0x00220821, 0xac200a74,
5675 0x3c010800, 0x00220821, 0xac200a78, 0x24630001, 0x1860fff5, 0x2442000c,
5676 0x24110001, 0x8f906810, 0x32020004, 0x14400005, 0x24040001, 0x3c020800,
5677 0x8c420a78, 0x18400003, 0x00002021, 0x0e000182, 0x00000000, 0x32020001,
5678 0x10400003, 0x00000000, 0x0e000169, 0x00000000, 0x0a000153, 0xaf915028,
5679 0x8fbf0018, 0x8fb10014, 0x8fb00010, 0x03e00008, 0x27bd0020, 0x3c050800,
5680 0x8ca50a70, 0x3c060800, 0x8cc60a80, 0x3c070800, 0x8ce70a78, 0x27bdffe0,
5681 0x3c040800, 0x248409d0, 0xafbf0018, 0xafa00010, 0x0e000060, 0xafa00014,
5682 0x0e00017b, 0x00002021, 0x8fbf0018, 0x03e00008, 0x27bd0020, 0x24020001,
5683 0x8f836810, 0x00821004, 0x00021027, 0x00621824, 0x03e00008, 0xaf836810,
5684 0x27bdffd8, 0xafbf0024, 0x1080002e, 0xafb00020, 0x8f825cec, 0xafa20018,
5685 0x8f825cec, 0x3c100800, 0x26100a78, 0xafa2001c, 0x34028000, 0xaf825cec,
5686 0x8e020000, 0x18400016, 0x00000000, 0x3c020800, 0x94420a74, 0x8fa3001c,
5687 0x000221c0, 0xac830004, 0x8fa2001c, 0x3c010800, 0x0e000201, 0xac220a74,
5688 0x10400005, 0x00000000, 0x8e020000, 0x24420001, 0x0a0001df, 0xae020000,
5689 0x3c020800, 0x8c420a70, 0x00021c02, 0x000321c0, 0x0a0001c5, 0xafa2001c,
5690 0x0e000201, 0x00000000, 0x1040001f, 0x00000000, 0x8e020000, 0x8fa3001c,
5691 0x24420001, 0x3c010800, 0xac230a70, 0x3c010800, 0xac230a74, 0x0a0001df,
5692 0xae020000, 0x3c100800, 0x26100a78, 0x8e020000, 0x18400028, 0x00000000,
5693 0x0e000201, 0x00000000, 0x14400024, 0x00000000, 0x8e020000, 0x3c030800,
5694 0x8c630a70, 0x2442ffff, 0xafa3001c, 0x18400006, 0xae020000, 0x00031402,
5695 0x000221c0, 0x8c820004, 0x3c010800, 0xac220a70, 0x97a2001e, 0x2442ff00,
5696 0x2c420300, 0x1440000b, 0x24024000, 0x3c040800, 0x248409dc, 0xafa00010,
5697 0xafa00014, 0x8fa6001c, 0x24050008, 0x0e000060, 0x00003821, 0x0a0001df,
5698 0x00000000, 0xaf825cf8, 0x3c020800, 0x8c420a40, 0x8fa3001c, 0x24420001,
5699 0xaf835cf8, 0x3c010800, 0xac220a40, 0x8fbf0024, 0x8fb00020, 0x03e00008,
5700 0x27bd0028, 0x27bdffe0, 0x3c040800, 0x248409e8, 0x00002821, 0x00003021,
5701 0x00003821, 0xafbf0018, 0xafa00010, 0x0e000060, 0xafa00014, 0x8fbf0018,
5702 0x03e00008, 0x27bd0020, 0x8f82680c, 0x8f85680c, 0x00021827, 0x0003182b,
5703 0x00031823, 0x00431024, 0x00441021, 0x00a2282b, 0x10a00006, 0x00000000,
5704 0x00401821, 0x8f82680c, 0x0043102b, 0x1440fffd, 0x00000000, 0x03e00008,
5705 0x00000000, 0x3c040800, 0x8c840000, 0x3c030800, 0x8c630a40, 0x0064102b,
5706 0x54400002, 0x00831023, 0x00641023, 0x2c420008, 0x03e00008, 0x38420001,
5707 0x27bdffe0, 0x00802821, 0x3c040800, 0x24840a00, 0x00003021, 0x00003821,
5708 0xafbf0018, 0xafa00010, 0x0e000060, 0xafa00014, 0x0a000216, 0x00000000,
5709 0x8fbf0018, 0x03e00008, 0x27bd0020, 0x00000000, 0x27bdffe0, 0x3c1cc000,
5710 0xafbf0018, 0x0e00004c, 0xaf80680c, 0x3c040800, 0x24840a10, 0x03802821,
5711 0x00003021, 0x00003821, 0xafa00010, 0x0e000060, 0xafa00014, 0x2402ffff,
5712 0xaf825404, 0x3c0200aa, 0x0e000234, 0xaf825434, 0x8fbf0018, 0x03e00008,
5713 0x27bd0020, 0x00000000, 0x00000000, 0x00000000, 0x27bdffe8, 0xafb00010,
5714 0x24100001, 0xafbf0014, 0x3c01c003, 0xac200000, 0x8f826810, 0x30422000,
5715 0x10400003, 0x00000000, 0x0e000246, 0x00000000, 0x0a00023a, 0xaf905428,
5716 0x8fbf0014, 0x8fb00010, 0x03e00008, 0x27bd0018, 0x27bdfff8, 0x8f845d0c,
5717 0x3c0200ff, 0x3c030800, 0x8c630a50, 0x3442fff8, 0x00821024, 0x1043001e,
5718 0x3c0500ff, 0x34a5fff8, 0x3c06c003, 0x3c074000, 0x00851824, 0x8c620010,
5719 0x3c010800, 0xac230a50, 0x30420008, 0x10400005, 0x00871025, 0x8cc20000,
5720 0x24420001, 0xacc20000, 0x00871025, 0xaf825d0c, 0x8fa20000, 0x24420001,
5721 0xafa20000, 0x8fa20000, 0x8fa20000, 0x24420001, 0xafa20000, 0x8fa20000,
5722 0x8f845d0c, 0x3c030800, 0x8c630a50, 0x00851024, 0x1443ffe8, 0x00851824,
5723 0x27bd0008, 0x03e00008, 0x00000000, 0x00000000, 0x00000000
5724 };
5725
5726 static const u32 tg3FwRodata[(TG3_FW_RODATA_LEN / sizeof(u32)) + 1] = {
5727 0x35373031, 0x726c7341, 0x00000000, 0x00000000, 0x53774576, 0x656e7430,
5728 0x00000000, 0x726c7045, 0x76656e74, 0x31000000, 0x556e6b6e, 0x45766e74,
5729 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x66617461, 0x6c457272,
5730 0x00000000, 0x00000000, 0x4d61696e, 0x43707542, 0x00000000, 0x00000000,
5731 0x00000000
5732 };
5733
5734 #if 0 /* All zeros, don't eat up space with it. */
5735 u32 tg3FwData[(TG3_FW_DATA_LEN / sizeof(u32)) + 1] = {
5736 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
5737 0x00000000, 0x00000000, 0x00000000, 0x00000000
5738 };
5739 #endif
5740
5741 #define RX_CPU_SCRATCH_BASE 0x30000
5742 #define RX_CPU_SCRATCH_SIZE 0x04000
5743 #define TX_CPU_SCRATCH_BASE 0x34000
5744 #define TX_CPU_SCRATCH_SIZE 0x04000
5745
5746 /* tp->lock is held. */
5747 static int tg3_halt_cpu(struct tg3 *tp, u32 offset)
5748 {
5749 int i;
5750
5751 BUG_ON(offset == TX_CPU_BASE &&
5752 (tp->tg3_flags2 & TG3_FLG2_5705_PLUS));
5753
5754 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
5755 u32 val = tr32(GRC_VCPU_EXT_CTRL);
5756
5757 tw32(GRC_VCPU_EXT_CTRL, val | GRC_VCPU_EXT_CTRL_HALT_CPU);
5758 return 0;
5759 }
5760 if (offset == RX_CPU_BASE) {
5761 for (i = 0; i < 10000; i++) {
5762 tw32(offset + CPU_STATE, 0xffffffff);
5763 tw32(offset + CPU_MODE, CPU_MODE_HALT);
5764 if (tr32(offset + CPU_MODE) & CPU_MODE_HALT)
5765 break;
5766 }
5767
5768 tw32(offset + CPU_STATE, 0xffffffff);
5769 tw32_f(offset + CPU_MODE, CPU_MODE_HALT);
5770 udelay(10);
5771 } else {
5772 for (i = 0; i < 10000; i++) {
5773 tw32(offset + CPU_STATE, 0xffffffff);
5774 tw32(offset + CPU_MODE, CPU_MODE_HALT);
5775 if (tr32(offset + CPU_MODE) & CPU_MODE_HALT)
5776 break;
5777 }
5778 }
5779
5780 if (i >= 10000) {
5781 printk(KERN_ERR PFX "tg3_reset_cpu timed out for %s, "
5782 "and %s CPU\n",
5783 tp->dev->name,
5784 (offset == RX_CPU_BASE ? "RX" : "TX"));
5785 return -ENODEV;
5786 }
5787
5788 /* Clear firmware's nvram arbitration. */
5789 if (tp->tg3_flags & TG3_FLAG_NVRAM)
5790 tw32(NVRAM_SWARB, SWARB_REQ_CLR0);
5791 return 0;
5792 }
5793
5794 struct fw_info {
5795 unsigned int text_base;
5796 unsigned int text_len;
5797 const u32 *text_data;
5798 unsigned int rodata_base;
5799 unsigned int rodata_len;
5800 const u32 *rodata_data;
5801 unsigned int data_base;
5802 unsigned int data_len;
5803 const u32 *data_data;
5804 };
5805
5806 /* tp->lock is held. */
5807 static int tg3_load_firmware_cpu(struct tg3 *tp, u32 cpu_base, u32 cpu_scratch_base,
5808 int cpu_scratch_size, struct fw_info *info)
5809 {
5810 int err, lock_err, i;
5811 void (*write_op)(struct tg3 *, u32, u32);
5812
5813 if (cpu_base == TX_CPU_BASE &&
5814 (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
5815 printk(KERN_ERR PFX "tg3_load_firmware_cpu: Trying to load "
5816 "TX cpu firmware on %s which is 5705.\n",
5817 tp->dev->name);
5818 return -EINVAL;
5819 }
5820
5821 if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)
5822 write_op = tg3_write_mem;
5823 else
5824 write_op = tg3_write_indirect_reg32;
5825
5826 /* It is possible that bootcode is still loading at this point.
5827 * Get the nvram lock first before halting the cpu.
5828 */
5829 lock_err = tg3_nvram_lock(tp);
5830 err = tg3_halt_cpu(tp, cpu_base);
5831 if (!lock_err)
5832 tg3_nvram_unlock(tp);
5833 if (err)
5834 goto out;
5835
5836 for (i = 0; i < cpu_scratch_size; i += sizeof(u32))
5837 write_op(tp, cpu_scratch_base + i, 0);
5838 tw32(cpu_base + CPU_STATE, 0xffffffff);
5839 tw32(cpu_base + CPU_MODE, tr32(cpu_base+CPU_MODE)|CPU_MODE_HALT);
5840 for (i = 0; i < (info->text_len / sizeof(u32)); i++)
5841 write_op(tp, (cpu_scratch_base +
5842 (info->text_base & 0xffff) +
5843 (i * sizeof(u32))),
5844 (info->text_data ?
5845 info->text_data[i] : 0));
5846 for (i = 0; i < (info->rodata_len / sizeof(u32)); i++)
5847 write_op(tp, (cpu_scratch_base +
5848 (info->rodata_base & 0xffff) +
5849 (i * sizeof(u32))),
5850 (info->rodata_data ?
5851 info->rodata_data[i] : 0));
5852 for (i = 0; i < (info->data_len / sizeof(u32)); i++)
5853 write_op(tp, (cpu_scratch_base +
5854 (info->data_base & 0xffff) +
5855 (i * sizeof(u32))),
5856 (info->data_data ?
5857 info->data_data[i] : 0));
5858
5859 err = 0;
5860
5861 out:
5862 return err;
5863 }
5864
5865 /* tp->lock is held. */
5866 static int tg3_load_5701_a0_firmware_fix(struct tg3 *tp)
5867 {
5868 struct fw_info info;
5869 int err, i;
5870
5871 info.text_base = TG3_FW_TEXT_ADDR;
5872 info.text_len = TG3_FW_TEXT_LEN;
5873 info.text_data = &tg3FwText[0];
5874 info.rodata_base = TG3_FW_RODATA_ADDR;
5875 info.rodata_len = TG3_FW_RODATA_LEN;
5876 info.rodata_data = &tg3FwRodata[0];
5877 info.data_base = TG3_FW_DATA_ADDR;
5878 info.data_len = TG3_FW_DATA_LEN;
5879 info.data_data = NULL;
5880
5881 err = tg3_load_firmware_cpu(tp, RX_CPU_BASE,
5882 RX_CPU_SCRATCH_BASE, RX_CPU_SCRATCH_SIZE,
5883 &info);
5884 if (err)
5885 return err;
5886
5887 err = tg3_load_firmware_cpu(tp, TX_CPU_BASE,
5888 TX_CPU_SCRATCH_BASE, TX_CPU_SCRATCH_SIZE,
5889 &info);
5890 if (err)
5891 return err;
5892
5893 /* Now startup only the RX cpu. */
5894 tw32(RX_CPU_BASE + CPU_STATE, 0xffffffff);
5895 tw32_f(RX_CPU_BASE + CPU_PC, TG3_FW_TEXT_ADDR);
5896
5897 for (i = 0; i < 5; i++) {
5898 if (tr32(RX_CPU_BASE + CPU_PC) == TG3_FW_TEXT_ADDR)
5899 break;
5900 tw32(RX_CPU_BASE + CPU_STATE, 0xffffffff);
5901 tw32(RX_CPU_BASE + CPU_MODE, CPU_MODE_HALT);
5902 tw32_f(RX_CPU_BASE + CPU_PC, TG3_FW_TEXT_ADDR);
5903 udelay(1000);
5904 }
5905 if (i >= 5) {
5906 printk(KERN_ERR PFX "tg3_load_firmware fails for %s "
5907 "to set RX CPU PC, is %08x should be %08x\n",
5908 tp->dev->name, tr32(RX_CPU_BASE + CPU_PC),
5909 TG3_FW_TEXT_ADDR);
5910 return -ENODEV;
5911 }
5912 tw32(RX_CPU_BASE + CPU_STATE, 0xffffffff);
5913 tw32_f(RX_CPU_BASE + CPU_MODE, 0x00000000);
5914
5915 return 0;
5916 }
5917
5918
5919 #define TG3_TSO_FW_RELEASE_MAJOR 0x1
5920 #define TG3_TSO_FW_RELASE_MINOR 0x6
5921 #define TG3_TSO_FW_RELEASE_FIX 0x0
5922 #define TG3_TSO_FW_START_ADDR 0x08000000
5923 #define TG3_TSO_FW_TEXT_ADDR 0x08000000
5924 #define TG3_TSO_FW_TEXT_LEN 0x1aa0
5925 #define TG3_TSO_FW_RODATA_ADDR 0x08001aa0
5926 #define TG3_TSO_FW_RODATA_LEN 0x60
5927 #define TG3_TSO_FW_DATA_ADDR 0x08001b20
5928 #define TG3_TSO_FW_DATA_LEN 0x30
5929 #define TG3_TSO_FW_SBSS_ADDR 0x08001b50
5930 #define TG3_TSO_FW_SBSS_LEN 0x2c
5931 #define TG3_TSO_FW_BSS_ADDR 0x08001b80
5932 #define TG3_TSO_FW_BSS_LEN 0x894
5933
5934 static const u32 tg3TsoFwText[(TG3_TSO_FW_TEXT_LEN / 4) + 1] = {
5935 0x0e000003, 0x00000000, 0x08001b24, 0x00000000, 0x10000003, 0x00000000,
5936 0x0000000d, 0x0000000d, 0x3c1d0800, 0x37bd4000, 0x03a0f021, 0x3c100800,
5937 0x26100000, 0x0e000010, 0x00000000, 0x0000000d, 0x27bdffe0, 0x3c04fefe,
5938 0xafbf0018, 0x0e0005d8, 0x34840002, 0x0e000668, 0x00000000, 0x3c030800,
5939 0x90631b68, 0x24020002, 0x3c040800, 0x24841aac, 0x14620003, 0x24050001,
5940 0x3c040800, 0x24841aa0, 0x24060006, 0x00003821, 0xafa00010, 0x0e00067c,
5941 0xafa00014, 0x8f625c50, 0x34420001, 0xaf625c50, 0x8f625c90, 0x34420001,
5942 0xaf625c90, 0x2402ffff, 0x0e000034, 0xaf625404, 0x8fbf0018, 0x03e00008,
5943 0x27bd0020, 0x00000000, 0x00000000, 0x00000000, 0x27bdffe0, 0xafbf001c,
5944 0xafb20018, 0xafb10014, 0x0e00005b, 0xafb00010, 0x24120002, 0x24110001,
5945 0x8f706820, 0x32020100, 0x10400003, 0x00000000, 0x0e0000bb, 0x00000000,
5946 0x8f706820, 0x32022000, 0x10400004, 0x32020001, 0x0e0001f0, 0x24040001,
5947 0x32020001, 0x10400003, 0x00000000, 0x0e0000a3, 0x00000000, 0x3c020800,
5948 0x90421b98, 0x14520003, 0x00000000, 0x0e0004c0, 0x00000000, 0x0a00003c,
5949 0xaf715028, 0x8fbf001c, 0x8fb20018, 0x8fb10014, 0x8fb00010, 0x03e00008,
5950 0x27bd0020, 0x27bdffe0, 0x3c040800, 0x24841ac0, 0x00002821, 0x00003021,
5951 0x00003821, 0xafbf0018, 0xafa00010, 0x0e00067c, 0xafa00014, 0x3c040800,
5952 0x248423d8, 0xa4800000, 0x3c010800, 0xa0201b98, 0x3c010800, 0xac201b9c,
5953 0x3c010800, 0xac201ba0, 0x3c010800, 0xac201ba4, 0x3c010800, 0xac201bac,
5954 0x3c010800, 0xac201bb8, 0x3c010800, 0xac201bbc, 0x8f624434, 0x3c010800,
5955 0xac221b88, 0x8f624438, 0x3c010800, 0xac221b8c, 0x8f624410, 0xac80f7a8,
5956 0x3c010800, 0xac201b84, 0x3c010800, 0xac2023e0, 0x3c010800, 0xac2023c8,
5957 0x3c010800, 0xac2023cc, 0x3c010800, 0xac202400, 0x3c010800, 0xac221b90,
5958 0x8f620068, 0x24030007, 0x00021702, 0x10430005, 0x00000000, 0x8f620068,
5959 0x00021702, 0x14400004, 0x24020001, 0x3c010800, 0x0a000097, 0xac20240c,
5960 0xac820034, 0x3c040800, 0x24841acc, 0x3c050800, 0x8ca5240c, 0x00003021,
5961 0x00003821, 0xafa00010, 0x0e00067c, 0xafa00014, 0x8fbf0018, 0x03e00008,
5962 0x27bd0020, 0x27bdffe0, 0x3c040800, 0x24841ad8, 0x00002821, 0x00003021,
5963 0x00003821, 0xafbf0018, 0xafa00010, 0x0e00067c, 0xafa00014, 0x0e00005b,
5964 0x00000000, 0x0e0000b4, 0x00002021, 0x8fbf0018, 0x03e00008, 0x27bd0020,
5965 0x24020001, 0x8f636820, 0x00821004, 0x00021027, 0x00621824, 0x03e00008,
5966 0xaf636820, 0x27bdffd0, 0xafbf002c, 0xafb60028, 0xafb50024, 0xafb40020,
5967 0xafb3001c, 0xafb20018, 0xafb10014, 0xafb00010, 0x8f675c5c, 0x3c030800,
5968 0x24631bbc, 0x8c620000, 0x14470005, 0x3c0200ff, 0x3c020800, 0x90421b98,
5969 0x14400119, 0x3c0200ff, 0x3442fff8, 0x00e28824, 0xac670000, 0x00111902,
5970 0x306300ff, 0x30e20003, 0x000211c0, 0x00622825, 0x00a04021, 0x00071602,
5971 0x3c030800, 0x90631b98, 0x3044000f, 0x14600036, 0x00804821, 0x24020001,
5972 0x3c010800, 0xa0221b98, 0x00051100, 0x00821025, 0x3c010800, 0xac201b9c,
5973 0x3c010800, 0xac201ba0, 0x3c010800, 0xac201ba4, 0x3c010800, 0xac201bac,
5974 0x3c010800, 0xac201bb8, 0x3c010800, 0xac201bb0, 0x3c010800, 0xac201bb4,
5975 0x3c010800, 0xa42223d8, 0x9622000c, 0x30437fff, 0x3c010800, 0xa4222410,
5976 0x30428000, 0x3c010800, 0xa4231bc6, 0x10400005, 0x24020001, 0x3c010800,
5977 0xac2223f4, 0x0a000102, 0x2406003e, 0x24060036, 0x3c010800, 0xac2023f4,
5978 0x9622000a, 0x3c030800, 0x94631bc6, 0x3c010800, 0xac2023f0, 0x3c010800,
5979 0xac2023f8, 0x00021302, 0x00021080, 0x00c21021, 0x00621821, 0x3c010800,
5980 0xa42223d0, 0x3c010800, 0x0a000115, 0xa4231b96, 0x9622000c, 0x3c010800,
5981 0xa42223ec, 0x3c040800, 0x24841b9c, 0x8c820000, 0x00021100, 0x3c010800,
5982 0x00220821, 0xac311bc8, 0x8c820000, 0x00021100, 0x3c010800, 0x00220821,
5983 0xac271bcc, 0x8c820000, 0x25030001, 0x306601ff, 0x00021100, 0x3c010800,
5984 0x00220821, 0xac261bd0, 0x8c820000, 0x00021100, 0x3c010800, 0x00220821,
5985 0xac291bd4, 0x96230008, 0x3c020800, 0x8c421bac, 0x00432821, 0x3c010800,
5986 0xac251bac, 0x9622000a, 0x30420004, 0x14400018, 0x00061100, 0x8f630c14,
5987 0x3063000f, 0x2c620002, 0x1440000b, 0x3c02c000, 0x8f630c14, 0x3c020800,
5988 0x8c421b40, 0x3063000f, 0x24420001, 0x3c010800, 0xac221b40, 0x2c620002,
5989 0x1040fff7, 0x3c02c000, 0x00e21825, 0xaf635c5c, 0x8f625c50, 0x30420002,
5990 0x10400014, 0x00000000, 0x0a000147, 0x00000000, 0x3c030800, 0x8c631b80,
5991 0x3c040800, 0x94841b94, 0x01221025, 0x3c010800, 0xa42223da, 0x24020001,
5992 0x3c010800, 0xac221bb8, 0x24630001, 0x0085202a, 0x3c010800, 0x10800003,
5993 0xac231b80, 0x3c010800, 0xa4251b94, 0x3c060800, 0x24c61b9c, 0x8cc20000,
5994 0x24420001, 0xacc20000, 0x28420080, 0x14400005, 0x00000000, 0x0e000656,
5995 0x24040002, 0x0a0001e6, 0x00000000, 0x3c020800, 0x8c421bb8, 0x10400078,
5996 0x24020001, 0x3c050800, 0x90a51b98, 0x14a20072, 0x00000000, 0x3c150800,
5997 0x96b51b96, 0x3c040800, 0x8c841bac, 0x32a3ffff, 0x0083102a, 0x1440006c,
5998 0x00000000, 0x14830003, 0x00000000, 0x3c010800, 0xac2523f0, 0x1060005c,
5999 0x00009021, 0x24d60004, 0x0060a021, 0x24d30014, 0x8ec20000, 0x00028100,
6000 0x3c110800, 0x02308821, 0x0e000625, 0x8e311bc8, 0x00402821, 0x10a00054,
6001 0x00000000, 0x9628000a, 0x31020040, 0x10400005, 0x2407180c, 0x8e22000c,
6002 0x2407188c, 0x00021400, 0xaca20018, 0x3c030800, 0x00701821, 0x8c631bd0,
6003 0x3c020800, 0x00501021, 0x8c421bd4, 0x00031d00, 0x00021400, 0x00621825,
6004 0xaca30014, 0x8ec30004, 0x96220008, 0x00432023, 0x3242ffff, 0x3083ffff,
6005 0x00431021, 0x0282102a, 0x14400002, 0x02b23023, 0x00803021, 0x8e620000,
6006 0x30c4ffff, 0x00441021, 0xae620000, 0x8e220000, 0xaca20000, 0x8e220004,
6007 0x8e63fff4, 0x00431021, 0xaca20004, 0xa4a6000e, 0x8e62fff4, 0x00441021,
6008 0xae62fff4, 0x96230008, 0x0043102a, 0x14400005, 0x02469021, 0x8e62fff0,
6009 0xae60fff4, 0x24420001, 0xae62fff0, 0xaca00008, 0x3242ffff, 0x14540008,
6010 0x24020305, 0x31020080, 0x54400001, 0x34e70010, 0x24020905, 0xa4a2000c,
6011 0x0a0001cb, 0x34e70020, 0xa4a2000c, 0x3c020800, 0x8c4223f0, 0x10400003,
6012 0x3c024b65, 0x0a0001d3, 0x34427654, 0x3c02b49a, 0x344289ab, 0xaca2001c,
6013 0x30e2ffff, 0xaca20010, 0x0e0005a2, 0x00a02021, 0x3242ffff, 0x0054102b,
6014 0x1440ffa9, 0x00000000, 0x24020002, 0x3c010800, 0x0a0001e6, 0xa0221b98,
6015 0x8ec2083c, 0x24420001, 0x0a0001e6, 0xaec2083c, 0x0e0004c0, 0x00000000,
6016 0x8fbf002c, 0x8fb60028, 0x8fb50024, 0x8fb40020, 0x8fb3001c, 0x8fb20018,
6017 0x8fb10014, 0x8fb00010, 0x03e00008, 0x27bd0030, 0x27bdffd0, 0xafbf0028,
6018 0xafb30024, 0xafb20020, 0xafb1001c, 0xafb00018, 0x8f725c9c, 0x3c0200ff,
6019 0x3442fff8, 0x3c070800, 0x24e71bb4, 0x02428824, 0x9623000e, 0x8ce20000,
6020 0x00431021, 0xace20000, 0x8e220010, 0x30420020, 0x14400011, 0x00809821,
6021 0x0e00063b, 0x02202021, 0x3c02c000, 0x02421825, 0xaf635c9c, 0x8f625c90,
6022 0x30420002, 0x1040011e, 0x00000000, 0xaf635c9c, 0x8f625c90, 0x30420002,
6023 0x10400119, 0x00000000, 0x0a00020d, 0x00000000, 0x8e240008, 0x8e230014,
6024 0x00041402, 0x000231c0, 0x00031502, 0x304201ff, 0x2442ffff, 0x3042007f,
6025 0x00031942, 0x30637800, 0x00021100, 0x24424000, 0x00624821, 0x9522000a,
6026 0x3084ffff, 0x30420008, 0x104000b0, 0x000429c0, 0x3c020800, 0x8c422400,
6027 0x14400024, 0x24c50008, 0x94c20014, 0x3c010800, 0xa42223d0, 0x8cc40010,
6028 0x00041402, 0x3c010800, 0xa42223d2, 0x3c010800, 0xa42423d4, 0x94c2000e,
6029 0x3083ffff, 0x00431023, 0x3c010800, 0xac222408, 0x94c2001a, 0x3c010800,
6030 0xac262400, 0x3c010800, 0xac322404, 0x3c010800, 0xac2223fc, 0x3c02c000,
6031 0x02421825, 0xaf635c9c, 0x8f625c90, 0x30420002, 0x104000e5, 0x00000000,
6032 0xaf635c9c, 0x8f625c90, 0x30420002, 0x104000e0, 0x00000000, 0x0a000246,
6033 0x00000000, 0x94c2000e, 0x3c030800, 0x946323d4, 0x00434023, 0x3103ffff,
6034 0x2c620008, 0x1040001c, 0x00000000, 0x94c20014, 0x24420028, 0x00a22821,
6035 0x00031042, 0x1840000b, 0x00002021, 0x24e60848, 0x00403821, 0x94a30000,
6036 0x8cc20000, 0x24840001, 0x00431021, 0xacc20000, 0x0087102a, 0x1440fff9,
6037 0x24a50002, 0x31020001, 0x1040001f, 0x3c024000, 0x3c040800, 0x248423fc,
6038 0xa0a00001, 0x94a30000, 0x8c820000, 0x00431021, 0x0a000285, 0xac820000,
6039 0x8f626800, 0x3c030010, 0x00431024, 0x10400009, 0x00000000, 0x94c2001a,
6040 0x3c030800, 0x8c6323fc, 0x00431021, 0x3c010800, 0xac2223fc, 0x0a000286,
6041 0x3c024000, 0x94c2001a, 0x94c4001c, 0x3c030800, 0x8c6323fc, 0x00441023,
6042 0x00621821, 0x3c010800, 0xac2323fc, 0x3c024000, 0x02421825, 0xaf635c9c,
6043 0x8f625c90, 0x30420002, 0x1440fffc, 0x00000000, 0x9522000a, 0x30420010,
6044 0x1040009b, 0x00000000, 0x3c030800, 0x946323d4, 0x3c070800, 0x24e72400,
6045 0x8ce40000, 0x8f626800, 0x24630030, 0x00832821, 0x3c030010, 0x00431024,
6046 0x1440000a, 0x00000000, 0x94a20004, 0x3c040800, 0x8c842408, 0x3c030800,
6047 0x8c6323fc, 0x00441023, 0x00621821, 0x3c010800, 0xac2323fc, 0x3c040800,
6048 0x8c8423fc, 0x00041c02, 0x3082ffff, 0x00622021, 0x00041402, 0x00822021,
6049 0x00041027, 0xa4a20006, 0x3c030800, 0x8c632404, 0x3c0200ff, 0x3442fff8,
6050 0x00628824, 0x96220008, 0x24050001, 0x24034000, 0x000231c0, 0x00801021,
6051 0xa4c2001a, 0xa4c0001c, 0xace00000, 0x3c010800, 0xac251b60, 0xaf635cb8,
6052 0x8f625cb0, 0x30420002, 0x10400003, 0x00000000, 0x3c010800, 0xac201b60,
6053 0x8e220008, 0xaf625cb8, 0x8f625cb0, 0x30420002, 0x10400003, 0x00000000,
6054 0x3c010800, 0xac201b60, 0x3c020800, 0x8c421b60, 0x1040ffec, 0x00000000,
6055 0x3c040800, 0x0e00063b, 0x8c842404, 0x0a00032a, 0x00000000, 0x3c030800,
6056 0x90631b98, 0x24020002, 0x14620003, 0x3c034b65, 0x0a0002e1, 0x00008021,
6057 0x8e22001c, 0x34637654, 0x10430002, 0x24100002, 0x24100001, 0x00c02021,
6058 0x0e000350, 0x02003021, 0x24020003, 0x3c010800, 0xa0221b98, 0x24020002,
6059 0x1202000a, 0x24020001, 0x3c030800, 0x8c6323f0, 0x10620006, 0x00000000,
6060 0x3c020800, 0x944223d8, 0x00021400, 0x0a00031f, 0xae220014, 0x3c040800,
6061 0x248423da, 0x94820000, 0x00021400, 0xae220014, 0x3c020800, 0x8c421bbc,
6062 0x3c03c000, 0x3c010800, 0xa0201b98, 0x00431025, 0xaf625c5c, 0x8f625c50,
6063 0x30420002, 0x10400009, 0x00000000, 0x2484f7e2, 0x8c820000, 0x00431025,
6064 0xaf625c5c, 0x8f625c50, 0x30420002, 0x1440fffa, 0x00000000, 0x3c020800,
6065 0x24421b84, 0x8c430000, 0x24630001, 0xac430000, 0x8f630c14, 0x3063000f,
6066 0x2c620002, 0x1440000c, 0x3c024000, 0x8f630c14, 0x3c020800, 0x8c421b40,
6067 0x3063000f, 0x24420001, 0x3c010800, 0xac221b40, 0x2c620002, 0x1040fff7,
6068 0x00000000, 0x3c024000, 0x02421825, 0xaf635c9c, 0x8f625c90, 0x30420002,
6069 0x1440fffc, 0x00000000, 0x12600003, 0x00000000, 0x0e0004c0, 0x00000000,
6070 0x8fbf0028, 0x8fb30024, 0x8fb20020, 0x8fb1001c, 0x8fb00018, 0x03e00008,
6071 0x27bd0030, 0x8f634450, 0x3c040800, 0x24841b88, 0x8c820000, 0x00031c02,
6072 0x0043102b, 0x14400007, 0x3c038000, 0x8c840004, 0x8f624450, 0x00021c02,
6073 0x0083102b, 0x1040fffc, 0x3c038000, 0xaf634444, 0x8f624444, 0x00431024,
6074 0x1440fffd, 0x00000000, 0x8f624448, 0x03e00008, 0x3042ffff, 0x3c024000,
6075 0x00822025, 0xaf645c38, 0x8f625c30, 0x30420002, 0x1440fffc, 0x00000000,
6076 0x03e00008, 0x00000000, 0x27bdffe0, 0x00805821, 0x14c00011, 0x256e0008,
6077 0x3c020800, 0x8c4223f4, 0x10400007, 0x24020016, 0x3c010800, 0xa42223d2,
6078 0x2402002a, 0x3c010800, 0x0a000364, 0xa42223d4, 0x8d670010, 0x00071402,
6079 0x3c010800, 0xa42223d2, 0x3c010800, 0xa42723d4, 0x3c040800, 0x948423d4,
6080 0x3c030800, 0x946323d2, 0x95cf0006, 0x3c020800, 0x944223d0, 0x00832023,
6081 0x01e2c023, 0x3065ffff, 0x24a20028, 0x01c24821, 0x3082ffff, 0x14c0001a,
6082 0x01226021, 0x9582000c, 0x3042003f, 0x3c010800, 0xa42223d6, 0x95820004,
6083 0x95830006, 0x3c010800, 0xac2023e4, 0x3c010800, 0xac2023e8, 0x00021400,
6084 0x00431025, 0x3c010800, 0xac221bc0, 0x95220004, 0x3c010800, 0xa4221bc4,
6085 0x95230002, 0x01e51023, 0x0043102a, 0x10400010, 0x24020001, 0x3c010800,
6086 0x0a000398, 0xac2223f8, 0x3c030800, 0x8c6323e8, 0x3c020800, 0x94421bc4,
6087 0x00431021, 0xa5220004, 0x3c020800, 0x94421bc0, 0xa5820004, 0x3c020800,
6088 0x8c421bc0, 0xa5820006, 0x3c020800, 0x8c4223f0, 0x3c0d0800, 0x8dad23e4,
6089 0x3c0a0800, 0x144000e5, 0x8d4a23e8, 0x3c020800, 0x94421bc4, 0x004a1821,
6090 0x3063ffff, 0x0062182b, 0x24020002, 0x10c2000d, 0x01435023, 0x3c020800,
6091 0x944223d6, 0x30420009, 0x10400008, 0x00000000, 0x9582000c, 0x3042fff6,
6092 0xa582000c, 0x3c020800, 0x944223d6, 0x30420009, 0x01a26823, 0x3c020800,
6093 0x8c4223f8, 0x1040004a, 0x01203821, 0x3c020800, 0x944223d2, 0x00004021,
6094 0xa520000a, 0x01e21023, 0xa5220002, 0x3082ffff, 0x00021042, 0x18400008,
6095 0x00003021, 0x00401821, 0x94e20000, 0x25080001, 0x00c23021, 0x0103102a,
6096 0x1440fffb, 0x24e70002, 0x00061c02, 0x30c2ffff, 0x00623021, 0x00061402,
6097 0x00c23021, 0x00c02821, 0x00061027, 0xa522000a, 0x00003021, 0x2527000c,
6098 0x00004021, 0x94e20000, 0x25080001, 0x00c23021, 0x2d020004, 0x1440fffb,
6099 0x24e70002, 0x95220002, 0x00004021, 0x91230009, 0x00442023, 0x01803821,
6100 0x3082ffff, 0xa4e00010, 0x00621821, 0x00021042, 0x18400010, 0x00c33021,
6101 0x00404821, 0x94e20000, 0x24e70002, 0x00c23021, 0x30e2007f, 0x14400006,
6102 0x25080001, 0x8d630000, 0x3c02007f, 0x3442ff80, 0x00625824, 0x25670008,
6103 0x0109102a, 0x1440fff3, 0x00000000, 0x30820001, 0x10400005, 0x00061c02,
6104 0xa0e00001, 0x94e20000, 0x00c23021, 0x00061c02, 0x30c2ffff, 0x00623021,
6105 0x00061402, 0x00c23021, 0x0a00047d, 0x30c6ffff, 0x24020002, 0x14c20081,
6106 0x00000000, 0x3c020800, 0x8c42240c, 0x14400007, 0x00000000, 0x3c020800,
6107 0x944223d2, 0x95230002, 0x01e21023, 0x10620077, 0x00000000, 0x3c020800,
6108 0x944223d2, 0x01e21023, 0xa5220002, 0x3c020800, 0x8c42240c, 0x1040001a,
6109 0x31e3ffff, 0x8dc70010, 0x3c020800, 0x94421b96, 0x00e04021, 0x00072c02,
6110 0x00aa2021, 0x00431023, 0x00823823, 0x00072402, 0x30e2ffff, 0x00823821,
6111 0x00071027, 0xa522000a, 0x3102ffff, 0x3c040800, 0x948423d4, 0x00453023,
6112 0x00e02821, 0x00641823, 0x006d1821, 0x00c33021, 0x00061c02, 0x30c2ffff,
6113 0x0a00047d, 0x00623021, 0x01203821, 0x00004021, 0x3082ffff, 0x00021042,
6114 0x18400008, 0x00003021, 0x00401821, 0x94e20000, 0x25080001, 0x00c23021,
6115 0x0103102a, 0x1440fffb, 0x24e70002, 0x00061c02, 0x30c2ffff, 0x00623021,
6116 0x00061402, 0x00c23021, 0x00c02821, 0x00061027, 0xa522000a, 0x00003021,
6117 0x2527000c, 0x00004021, 0x94e20000, 0x25080001, 0x00c23021, 0x2d020004,
6118 0x1440fffb, 0x24e70002, 0x95220002, 0x00004021, 0x91230009, 0x00442023,
6119 0x01803821, 0x3082ffff, 0xa4e00010, 0x3c040800, 0x948423d4, 0x00621821,
6120 0x00c33021, 0x00061c02, 0x30c2ffff, 0x00623021, 0x00061c02, 0x3c020800,
6121 0x944223d0, 0x00c34821, 0x00441023, 0x00021fc2, 0x00431021, 0x00021043,
6122 0x18400010, 0x00003021, 0x00402021, 0x94e20000, 0x24e70002, 0x00c23021,
6123 0x30e2007f, 0x14400006, 0x25080001, 0x8d630000, 0x3c02007f, 0x3442ff80,
6124 0x00625824, 0x25670008, 0x0104102a, 0x1440fff3, 0x00000000, 0x3c020800,
6125 0x944223ec, 0x00c23021, 0x3122ffff, 0x00c23021, 0x00061c02, 0x30c2ffff,
6126 0x00623021, 0x00061402, 0x00c23021, 0x00c04021, 0x00061027, 0xa5820010,
6127 0xadc00014, 0x0a00049d, 0xadc00000, 0x8dc70010, 0x00e04021, 0x11400007,
6128 0x00072c02, 0x00aa3021, 0x00061402, 0x30c3ffff, 0x00433021, 0x00061402,
6129 0x00c22821, 0x00051027, 0xa522000a, 0x3c030800, 0x946323d4, 0x3102ffff,
6130 0x01e21021, 0x00433023, 0x00cd3021, 0x00061c02, 0x30c2ffff, 0x00623021,
6131 0x00061402, 0x00c23021, 0x00c04021, 0x00061027, 0xa5820010, 0x3102ffff,
6132 0x00051c00, 0x00431025, 0xadc20010, 0x3c020800, 0x8c4223f4, 0x10400005,
6133 0x2de205eb, 0x14400002, 0x25e2fff2, 0x34028870, 0xa5c20034, 0x3c030800,
6134 0x246323e8, 0x8c620000, 0x24420001, 0xac620000, 0x3c040800, 0x8c8423e4,
6135 0x3c020800, 0x8c421bc0, 0x3303ffff, 0x00832021, 0x00431821, 0x0062102b,
6136 0x3c010800, 0xac2423e4, 0x10400003, 0x2482ffff, 0x3c010800, 0xac2223e4,
6137 0x3c010800, 0xac231bc0, 0x03e00008, 0x27bd0020, 0x27bdffb8, 0x3c050800,
6138 0x24a51b96, 0xafbf0044, 0xafbe0040, 0xafb7003c, 0xafb60038, 0xafb50034,
6139 0xafb40030, 0xafb3002c, 0xafb20028, 0xafb10024, 0xafb00020, 0x94a90000,
6140 0x3c020800, 0x944223d0, 0x3c030800, 0x8c631bb0, 0x3c040800, 0x8c841bac,
6141 0x01221023, 0x0064182a, 0xa7a9001e, 0x106000be, 0xa7a20016, 0x24be0022,
6142 0x97b6001e, 0x24b3001a, 0x24b70016, 0x8fc20000, 0x14400008, 0x00000000,
6143 0x8fc2fff8, 0x97a30016, 0x8fc4fff4, 0x00431021, 0x0082202a, 0x148000b0,
6144 0x00000000, 0x97d50818, 0x32a2ffff, 0x104000a3, 0x00009021, 0x0040a021,
6145 0x00008821, 0x0e000625, 0x00000000, 0x00403021, 0x14c00007, 0x00000000,
6146 0x3c020800, 0x8c4223dc, 0x24420001, 0x3c010800, 0x0a000596, 0xac2223dc,
6147 0x3c100800, 0x02118021, 0x8e101bc8, 0x9608000a, 0x31020040, 0x10400005,
6148 0x2407180c, 0x8e02000c, 0x2407188c, 0x00021400, 0xacc20018, 0x31020080,
6149 0x54400001, 0x34e70010, 0x3c020800, 0x00511021, 0x8c421bd0, 0x3c030800,
6150 0x00711821, 0x8c631bd4, 0x00021500, 0x00031c00, 0x00431025, 0xacc20014,
6151 0x96040008, 0x3242ffff, 0x00821021, 0x0282102a, 0x14400002, 0x02b22823,
6152 0x00802821, 0x8e020000, 0x02459021, 0xacc20000, 0x8e020004, 0x00c02021,
6153 0x26310010, 0xac820004, 0x30e2ffff, 0xac800008, 0xa485000e, 0xac820010,
6154 0x24020305, 0x0e0005a2, 0xa482000c, 0x3242ffff, 0x0054102b, 0x1440ffc5,
6155 0x3242ffff, 0x0a00058e, 0x00000000, 0x8e620000, 0x8e63fffc, 0x0043102a,
6156 0x10400067, 0x00000000, 0x8e62fff0, 0x00028900, 0x3c100800, 0x02118021,
6157 0x0e000625, 0x8e101bc8, 0x00403021, 0x14c00005, 0x00000000, 0x8e62082c,
6158 0x24420001, 0x0a000596, 0xae62082c, 0x9608000a, 0x31020040, 0x10400005,
6159 0x2407180c, 0x8e02000c, 0x2407188c, 0x00021400, 0xacc20018, 0x3c020800,
6160 0x00511021, 0x8c421bd0, 0x3c030800, 0x00711821, 0x8c631bd4, 0x00021500,
6161 0x00031c00, 0x00431025, 0xacc20014, 0x8e63fff4, 0x96020008, 0x00432023,
6162 0x3242ffff, 0x3083ffff, 0x00431021, 0x02c2102a, 0x10400003, 0x00802821,
6163 0x97a9001e, 0x01322823, 0x8e620000, 0x30a4ffff, 0x00441021, 0xae620000,
6164 0xa4c5000e, 0x8e020000, 0xacc20000, 0x8e020004, 0x8e63fff4, 0x00431021,
6165 0xacc20004, 0x8e63fff4, 0x96020008, 0x00641821, 0x0062102a, 0x14400006,
6166 0x02459021, 0x8e62fff0, 0xae60fff4, 0x24420001, 0x0a000571, 0xae62fff0,
6167 0xae63fff4, 0xacc00008, 0x3242ffff, 0x10560003, 0x31020004, 0x10400006,
6168 0x24020305, 0x31020080, 0x54400001, 0x34e70010, 0x34e70020, 0x24020905,
6169 0xa4c2000c, 0x8ee30000, 0x8ee20004, 0x14620007, 0x3c02b49a, 0x8ee20860,
6170 0x54400001, 0x34e70400, 0x3c024b65, 0x0a000588, 0x34427654, 0x344289ab,
6171 0xacc2001c, 0x30e2ffff, 0xacc20010, 0x0e0005a2, 0x00c02021, 0x3242ffff,
6172 0x0056102b, 0x1440ff9b, 0x00000000, 0x8e620000, 0x8e63fffc, 0x0043102a,
6173 0x1440ff48, 0x00000000, 0x8fbf0044, 0x8fbe0040, 0x8fb7003c, 0x8fb60038,
6174 0x8fb50034, 0x8fb40030, 0x8fb3002c, 0x8fb20028, 0x8fb10024, 0x8fb00020,
6175 0x03e00008, 0x27bd0048, 0x27bdffe8, 0xafbf0014, 0xafb00010, 0x8f624450,
6176 0x8f634410, 0x0a0005b1, 0x00808021, 0x8f626820, 0x30422000, 0x10400003,
6177 0x00000000, 0x0e0001f0, 0x00002021, 0x8f624450, 0x8f634410, 0x3042ffff,
6178 0x0043102b, 0x1440fff5, 0x00000000, 0x8f630c14, 0x3063000f, 0x2c620002,
6179 0x1440000b, 0x00000000, 0x8f630c14, 0x3c020800, 0x8c421b40, 0x3063000f,
6180 0x24420001, 0x3c010800, 0xac221b40, 0x2c620002, 0x1040fff7, 0x00000000,
6181 0xaf705c18, 0x8f625c10, 0x30420002, 0x10400009, 0x00000000, 0x8f626820,
6182 0x30422000, 0x1040fff8, 0x00000000, 0x0e0001f0, 0x00002021, 0x0a0005c4,
6183 0x00000000, 0x8fbf0014, 0x8fb00010, 0x03e00008, 0x27bd0018, 0x00000000,
6184 0x00000000, 0x00000000, 0x27bdffe8, 0x3c1bc000, 0xafbf0014, 0xafb00010,
6185 0xaf60680c, 0x8f626804, 0x34420082, 0xaf626804, 0x8f634000, 0x24020b50,
6186 0x3c010800, 0xac221b54, 0x24020b78, 0x3c010800, 0xac221b64, 0x34630002,
6187 0xaf634000, 0x0e000605, 0x00808021, 0x3c010800, 0xa0221b68, 0x304200ff,
6188 0x24030002, 0x14430005, 0x00000000, 0x3c020800, 0x8c421b54, 0x0a0005f8,
6189 0xac5000c0, 0x3c020800, 0x8c421b54, 0xac5000bc, 0x8f624434, 0x8f634438,
6190 0x8f644410, 0x3c010800, 0xac221b5c, 0x3c010800, 0xac231b6c, 0x3c010800,
6191 0xac241b58, 0x8fbf0014, 0x8fb00010, 0x03e00008, 0x27bd0018, 0x3c040800,
6192 0x8c870000, 0x3c03aa55, 0x3463aa55, 0x3c06c003, 0xac830000, 0x8cc20000,
6193 0x14430007, 0x24050002, 0x3c0355aa, 0x346355aa, 0xac830000, 0x8cc20000,
6194 0x50430001, 0x24050001, 0x3c020800, 0xac470000, 0x03e00008, 0x00a01021,
6195 0x27bdfff8, 0x18800009, 0x00002821, 0x8f63680c, 0x8f62680c, 0x1043fffe,
6196 0x00000000, 0x24a50001, 0x00a4102a, 0x1440fff9, 0x00000000, 0x03e00008,
6197 0x27bd0008, 0x8f634450, 0x3c020800, 0x8c421b5c, 0x00031c02, 0x0043102b,
6198 0x14400008, 0x3c038000, 0x3c040800, 0x8c841b6c, 0x8f624450, 0x00021c02,
6199 0x0083102b, 0x1040fffc, 0x3c038000, 0xaf634444, 0x8f624444, 0x00431024,
6200 0x1440fffd, 0x00000000, 0x8f624448, 0x03e00008, 0x3042ffff, 0x3082ffff,
6201 0x2442e000, 0x2c422001, 0x14400003, 0x3c024000, 0x0a000648, 0x2402ffff,
6202 0x00822025, 0xaf645c38, 0x8f625c30, 0x30420002, 0x1440fffc, 0x00001021,
6203 0x03e00008, 0x00000000, 0x8f624450, 0x3c030800, 0x8c631b58, 0x0a000651,
6204 0x3042ffff, 0x8f624450, 0x3042ffff, 0x0043102b, 0x1440fffc, 0x00000000,
6205 0x03e00008, 0x00000000, 0x27bdffe0, 0x00802821, 0x3c040800, 0x24841af0,
6206 0x00003021, 0x00003821, 0xafbf0018, 0xafa00010, 0x0e00067c, 0xafa00014,
6207 0x0a000660, 0x00000000, 0x8fbf0018, 0x03e00008, 0x27bd0020, 0x00000000,
6208 0x00000000, 0x00000000, 0x3c020800, 0x34423000, 0x3c030800, 0x34633000,
6209 0x3c040800, 0x348437ff, 0x3c010800, 0xac221b74, 0x24020040, 0x3c010800,
6210 0xac221b78, 0x3c010800, 0xac201b70, 0xac600000, 0x24630004, 0x0083102b,
6211 0x5040fffd, 0xac600000, 0x03e00008, 0x00000000, 0x00804821, 0x8faa0010,
6212 0x3c020800, 0x8c421b70, 0x3c040800, 0x8c841b78, 0x8fab0014, 0x24430001,
6213 0x0044102b, 0x3c010800, 0xac231b70, 0x14400003, 0x00004021, 0x3c010800,
6214 0xac201b70, 0x3c020800, 0x8c421b70, 0x3c030800, 0x8c631b74, 0x91240000,
6215 0x00021140, 0x00431021, 0x00481021, 0x25080001, 0xa0440000, 0x29020008,
6216 0x1440fff4, 0x25290001, 0x3c020800, 0x8c421b70, 0x3c030800, 0x8c631b74,
6217 0x8f64680c, 0x00021140, 0x00431021, 0xac440008, 0xac45000c, 0xac460010,
6218 0xac470014, 0xac4a0018, 0x03e00008, 0xac4b001c, 0x00000000, 0x00000000,
6219 };
6220
6221 static const u32 tg3TsoFwRodata[] = {
6222 0x4d61696e, 0x43707542, 0x00000000, 0x4d61696e, 0x43707541, 0x00000000,
6223 0x00000000, 0x00000000, 0x73746b6f, 0x66666c64, 0x496e0000, 0x73746b6f,
6224 0x66662a2a, 0x00000000, 0x53774576, 0x656e7430, 0x00000000, 0x00000000,
6225 0x00000000, 0x00000000, 0x66617461, 0x6c457272, 0x00000000, 0x00000000,
6226 0x00000000,
6227 };
6228
6229 static const u32 tg3TsoFwData[] = {
6230 0x00000000, 0x73746b6f, 0x66666c64, 0x5f76312e, 0x362e3000, 0x00000000,
6231 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
6232 0x00000000,
6233 };
6234
6235 /* 5705 needs a special version of the TSO firmware. */
6236 #define TG3_TSO5_FW_RELEASE_MAJOR 0x1
6237 #define TG3_TSO5_FW_RELASE_MINOR 0x2
6238 #define TG3_TSO5_FW_RELEASE_FIX 0x0
6239 #define TG3_TSO5_FW_START_ADDR 0x00010000
6240 #define TG3_TSO5_FW_TEXT_ADDR 0x00010000
6241 #define TG3_TSO5_FW_TEXT_LEN 0xe90
6242 #define TG3_TSO5_FW_RODATA_ADDR 0x00010e90
6243 #define TG3_TSO5_FW_RODATA_LEN 0x50
6244 #define TG3_TSO5_FW_DATA_ADDR 0x00010f00
6245 #define TG3_TSO5_FW_DATA_LEN 0x20
6246 #define TG3_TSO5_FW_SBSS_ADDR 0x00010f20
6247 #define TG3_TSO5_FW_SBSS_LEN 0x28
6248 #define TG3_TSO5_FW_BSS_ADDR 0x00010f50
6249 #define TG3_TSO5_FW_BSS_LEN 0x88
6250
6251 static const u32 tg3Tso5FwText[(TG3_TSO5_FW_TEXT_LEN / 4) + 1] = {
6252 0x0c004003, 0x00000000, 0x00010f04, 0x00000000, 0x10000003, 0x00000000,
6253 0x0000000d, 0x0000000d, 0x3c1d0001, 0x37bde000, 0x03a0f021, 0x3c100001,
6254 0x26100000, 0x0c004010, 0x00000000, 0x0000000d, 0x27bdffe0, 0x3c04fefe,
6255 0xafbf0018, 0x0c0042e8, 0x34840002, 0x0c004364, 0x00000000, 0x3c030001,
6256 0x90630f34, 0x24020002, 0x3c040001, 0x24840e9c, 0x14620003, 0x24050001,
6257 0x3c040001, 0x24840e90, 0x24060002, 0x00003821, 0xafa00010, 0x0c004378,
6258 0xafa00014, 0x0c00402c, 0x00000000, 0x8fbf0018, 0x03e00008, 0x27bd0020,
6259 0x00000000, 0x00000000, 0x27bdffe0, 0xafbf001c, 0xafb20018, 0xafb10014,
6260 0x0c0042d4, 0xafb00010, 0x3c128000, 0x24110001, 0x8f706810, 0x32020400,
6261 0x10400007, 0x00000000, 0x8f641008, 0x00921024, 0x14400003, 0x00000000,
6262 0x0c004064, 0x00000000, 0x3c020001, 0x90420f56, 0x10510003, 0x32020200,
6263 0x1040fff1, 0x00000000, 0x0c0041b4, 0x00000000, 0x08004034, 0x00000000,
6264 0x8fbf001c, 0x8fb20018, 0x8fb10014, 0x8fb00010, 0x03e00008, 0x27bd0020,
6265 0x27bdffe0, 0x3c040001, 0x24840eb0, 0x00002821, 0x00003021, 0x00003821,
6266 0xafbf0018, 0xafa00010, 0x0c004378, 0xafa00014, 0x0000d021, 0x24020130,
6267 0xaf625000, 0x3c010001, 0xa4200f50, 0x3c010001, 0xa0200f57, 0x8fbf0018,
6268 0x03e00008, 0x27bd0020, 0x00000000, 0x00000000, 0x3c030001, 0x24630f60,
6269 0x90620000, 0x27bdfff0, 0x14400003, 0x0080c021, 0x08004073, 0x00004821,
6270 0x3c022000, 0x03021024, 0x10400003, 0x24090002, 0x08004073, 0xa0600000,
6271 0x24090001, 0x00181040, 0x30431f80, 0x346f8008, 0x1520004b, 0x25eb0028,
6272 0x3c040001, 0x00832021, 0x8c848010, 0x3c050001, 0x24a50f7a, 0x00041402,
6273 0xa0a20000, 0x3c010001, 0xa0240f7b, 0x3c020001, 0x00431021, 0x94428014,
6274 0x3c010001, 0xa0220f7c, 0x3c0c0001, 0x01836021, 0x8d8c8018, 0x304200ff,
6275 0x24420008, 0x000220c3, 0x24020001, 0x3c010001, 0xa0220f60, 0x0124102b,
6276 0x1040000c, 0x00003821, 0x24a6000e, 0x01602821, 0x8ca20000, 0x8ca30004,
6277 0x24a50008, 0x24e70001, 0xacc20000, 0xacc30004, 0x00e4102b, 0x1440fff8,
6278 0x24c60008, 0x00003821, 0x3c080001, 0x25080f7b, 0x91060000, 0x3c020001,
6279 0x90420f7c, 0x2503000d, 0x00c32821, 0x00461023, 0x00021fc2, 0x00431021,
6280 0x00021043, 0x1840000c, 0x00002021, 0x91020001, 0x00461023, 0x00021fc2,
6281 0x00431021, 0x00021843, 0x94a20000, 0x24e70001, 0x00822021, 0x00e3102a,
6282 0x1440fffb, 0x24a50002, 0x00041c02, 0x3082ffff, 0x00622021, 0x00041402,
6283 0x00822021, 0x3c02ffff, 0x01821024, 0x3083ffff, 0x00431025, 0x3c010001,
6284 0x080040fa, 0xac220f80, 0x3c050001, 0x24a50f7c, 0x90a20000, 0x3c0c0001,
6285 0x01836021, 0x8d8c8018, 0x000220c2, 0x1080000e, 0x00003821, 0x01603021,
6286 0x24a5000c, 0x8ca20000, 0x8ca30004, 0x24a50008, 0x24e70001, 0xacc20000,
6287 0xacc30004, 0x00e4102b, 0x1440fff8, 0x24c60008, 0x3c050001, 0x24a50f7c,
6288 0x90a20000, 0x30430007, 0x24020004, 0x10620011, 0x28620005, 0x10400005,
6289 0x24020002, 0x10620008, 0x000710c0, 0x080040fa, 0x00000000, 0x24020006,
6290 0x1062000e, 0x000710c0, 0x080040fa, 0x00000000, 0x00a21821, 0x9463000c,
6291 0x004b1021, 0x080040fa, 0xa4430000, 0x000710c0, 0x00a21821, 0x8c63000c,
6292 0x004b1021, 0x080040fa, 0xac430000, 0x00a21821, 0x8c63000c, 0x004b2021,
6293 0x00a21021, 0xac830000, 0x94420010, 0xa4820004, 0x95e70006, 0x3c020001,
6294 0x90420f7c, 0x3c030001, 0x90630f7a, 0x00e2c823, 0x3c020001, 0x90420f7b,
6295 0x24630028, 0x01e34021, 0x24420028, 0x15200012, 0x01e23021, 0x94c2000c,
6296 0x3c010001, 0xa4220f78, 0x94c20004, 0x94c30006, 0x3c010001, 0xa4200f76,
6297 0x3c010001, 0xa4200f72, 0x00021400, 0x00431025, 0x3c010001, 0xac220f6c,
6298 0x95020004, 0x3c010001, 0x08004124, 0xa4220f70, 0x3c020001, 0x94420f70,
6299 0x3c030001, 0x94630f72, 0x00431021, 0xa5020004, 0x3c020001, 0x94420f6c,
6300 0xa4c20004, 0x3c020001, 0x8c420f6c, 0xa4c20006, 0x3c040001, 0x94840f72,
6301 0x3c020001, 0x94420f70, 0x3c0a0001, 0x954a0f76, 0x00441821, 0x3063ffff,
6302 0x0062182a, 0x24020002, 0x1122000b, 0x00832023, 0x3c030001, 0x94630f78,
6303 0x30620009, 0x10400006, 0x3062fff6, 0xa4c2000c, 0x3c020001, 0x94420f78,
6304 0x30420009, 0x01425023, 0x24020001, 0x1122001b, 0x29220002, 0x50400005,
6305 0x24020002, 0x11200007, 0x31a2ffff, 0x08004197, 0x00000000, 0x1122001d,
6306 0x24020016, 0x08004197, 0x31a2ffff, 0x3c0e0001, 0x95ce0f80, 0x10800005,
6307 0x01806821, 0x01c42021, 0x00041c02, 0x3082ffff, 0x00627021, 0x000e1027,
6308 0xa502000a, 0x3c030001, 0x90630f7b, 0x31a2ffff, 0x00e21021, 0x0800418d,
6309 0x00432023, 0x3c020001, 0x94420f80, 0x00442021, 0x00041c02, 0x3082ffff,
6310 0x00622021, 0x00807021, 0x00041027, 0x08004185, 0xa502000a, 0x3c050001,
6311 0x24a50f7a, 0x90a30000, 0x14620002, 0x24e2fff2, 0xa5e20034, 0x90a20000,
6312 0x00e21023, 0xa5020002, 0x3c030001, 0x94630f80, 0x3c020001, 0x94420f5a,
6313 0x30e5ffff, 0x00641821, 0x00451023, 0x00622023, 0x00041c02, 0x3082ffff,
6314 0x00622021, 0x00041027, 0xa502000a, 0x3c030001, 0x90630f7c, 0x24620001,
6315 0x14a20005, 0x00807021, 0x01631021, 0x90420000, 0x08004185, 0x00026200,
6316 0x24620002, 0x14a20003, 0x306200fe, 0x004b1021, 0x944c0000, 0x3c020001,
6317 0x94420f82, 0x3183ffff, 0x3c040001, 0x90840f7b, 0x00431021, 0x00e21021,
6318 0x00442023, 0x008a2021, 0x00041c02, 0x3082ffff, 0x00622021, 0x00041402,
6319 0x00822021, 0x00806821, 0x00041027, 0xa4c20010, 0x31a2ffff, 0x000e1c00,
6320 0x00431025, 0x3c040001, 0x24840f72, 0xade20010, 0x94820000, 0x3c050001,
6321 0x94a50f76, 0x3c030001, 0x8c630f6c, 0x24420001, 0x00b92821, 0xa4820000,
6322 0x3322ffff, 0x00622021, 0x0083182b, 0x3c010001, 0xa4250f76, 0x10600003,
6323 0x24a2ffff, 0x3c010001, 0xa4220f76, 0x3c024000, 0x03021025, 0x3c010001,
6324 0xac240f6c, 0xaf621008, 0x03e00008, 0x27bd0010, 0x3c030001, 0x90630f56,
6325 0x27bdffe8, 0x24020001, 0xafbf0014, 0x10620026, 0xafb00010, 0x8f620cf4,
6326 0x2442ffff, 0x3042007f, 0x00021100, 0x8c434000, 0x3c010001, 0xac230f64,
6327 0x8c434008, 0x24444000, 0x8c5c4004, 0x30620040, 0x14400002, 0x24020088,
6328 0x24020008, 0x3c010001, 0xa4220f68, 0x30620004, 0x10400005, 0x24020001,
6329 0x3c010001, 0xa0220f57, 0x080041d5, 0x00031402, 0x3c010001, 0xa0200f57,
6330 0x00031402, 0x3c010001, 0xa4220f54, 0x9483000c, 0x24020001, 0x3c010001,
6331 0xa4200f50, 0x3c010001, 0xa0220f56, 0x3c010001, 0xa4230f62, 0x24020001,
6332 0x1342001e, 0x00000000, 0x13400005, 0x24020003, 0x13420067, 0x00000000,
6333 0x080042cf, 0x00000000, 0x3c020001, 0x94420f62, 0x241a0001, 0x3c010001,
6334 0xa4200f5e, 0x3c010001, 0xa4200f52, 0x304407ff, 0x00021bc2, 0x00031823,
6335 0x3063003e, 0x34630036, 0x00021242, 0x3042003c, 0x00621821, 0x3c010001,
6336 0xa4240f58, 0x00832021, 0x24630030, 0x3c010001, 0xa4240f5a, 0x3c010001,
6337 0xa4230f5c, 0x3c060001, 0x24c60f52, 0x94c50000, 0x94c30002, 0x3c040001,
6338 0x94840f5a, 0x00651021, 0x0044102a, 0x10400013, 0x3c108000, 0x00a31021,
6339 0xa4c20000, 0x3c02a000, 0xaf620cf4, 0x3c010001, 0xa0200f56, 0x8f641008,
6340 0x00901024, 0x14400003, 0x00000000, 0x0c004064, 0x00000000, 0x8f620cf4,
6341 0x00501024, 0x104000b7, 0x00000000, 0x0800420f, 0x00000000, 0x3c030001,
6342 0x94630f50, 0x00851023, 0xa4c40000, 0x00621821, 0x3042ffff, 0x3c010001,
6343 0xa4230f50, 0xaf620ce8, 0x3c020001, 0x94420f68, 0x34420024, 0xaf620cec,
6344 0x94c30002, 0x3c020001, 0x94420f50, 0x14620012, 0x3c028000, 0x3c108000,
6345 0x3c02a000, 0xaf620cf4, 0x3c010001, 0xa0200f56, 0x8f641008, 0x00901024,
6346 0x14400003, 0x00000000, 0x0c004064, 0x00000000, 0x8f620cf4, 0x00501024,
6347 0x1440fff7, 0x00000000, 0x080042cf, 0x241a0003, 0xaf620cf4, 0x3c108000,
6348 0x8f641008, 0x00901024, 0x14400003, 0x00000000, 0x0c004064, 0x00000000,
6349 0x8f620cf4, 0x00501024, 0x1440fff7, 0x00000000, 0x080042cf, 0x241a0003,
6350 0x3c070001, 0x24e70f50, 0x94e20000, 0x03821021, 0xaf620ce0, 0x3c020001,
6351 0x8c420f64, 0xaf620ce4, 0x3c050001, 0x94a50f54, 0x94e30000, 0x3c040001,
6352 0x94840f58, 0x3c020001, 0x94420f5e, 0x00a32823, 0x00822023, 0x30a6ffff,
6353 0x3083ffff, 0x00c3102b, 0x14400043, 0x00000000, 0x3c020001, 0x94420f5c,
6354 0x00021400, 0x00621025, 0xaf620ce8, 0x94e20000, 0x3c030001, 0x94630f54,
6355 0x00441021, 0xa4e20000, 0x3042ffff, 0x14430021, 0x3c020008, 0x3c020001,
6356 0x90420f57, 0x10400006, 0x3c03000c, 0x3c020001, 0x94420f68, 0x34630624,
6357 0x0800427c, 0x0000d021, 0x3c020001, 0x94420f68, 0x3c030008, 0x34630624,
6358 0x00431025, 0xaf620cec, 0x3c108000, 0x3c02a000, 0xaf620cf4, 0x3c010001,
6359 0xa0200f56, 0x8f641008, 0x00901024, 0x14400003, 0x00000000, 0x0c004064,
6360 0x00000000, 0x8f620cf4, 0x00501024, 0x10400015, 0x00000000, 0x08004283,
6361 0x00000000, 0x3c030001, 0x94630f68, 0x34420624, 0x3c108000, 0x00621825,
6362 0x3c028000, 0xaf630cec, 0xaf620cf4, 0x8f641008, 0x00901024, 0x14400003,
6363 0x00000000, 0x0c004064, 0x00000000, 0x8f620cf4, 0x00501024, 0x1440fff7,
6364 0x00000000, 0x3c010001, 0x080042cf, 0xa4200f5e, 0x3c020001, 0x94420f5c,
6365 0x00021400, 0x00c21025, 0xaf620ce8, 0x3c020001, 0x90420f57, 0x10400009,
6366 0x3c03000c, 0x3c020001, 0x94420f68, 0x34630624, 0x0000d021, 0x00431025,
6367 0xaf620cec, 0x080042c1, 0x3c108000, 0x3c020001, 0x94420f68, 0x3c030008,
6368 0x34630604, 0x00431025, 0xaf620cec, 0x3c020001, 0x94420f5e, 0x00451021,
6369 0x3c010001, 0xa4220f5e, 0x3c108000, 0x3c02a000, 0xaf620cf4, 0x3c010001,
6370 0xa0200f56, 0x8f641008, 0x00901024, 0x14400003, 0x00000000, 0x0c004064,
6371 0x00000000, 0x8f620cf4, 0x00501024, 0x1440fff7, 0x00000000, 0x8fbf0014,
6372 0x8fb00010, 0x03e00008, 0x27bd0018, 0x00000000, 0x27bdffe0, 0x3c040001,
6373 0x24840ec0, 0x00002821, 0x00003021, 0x00003821, 0xafbf0018, 0xafa00010,
6374 0x0c004378, 0xafa00014, 0x0000d021, 0x24020130, 0xaf625000, 0x3c010001,
6375 0xa4200f50, 0x3c010001, 0xa0200f57, 0x8fbf0018, 0x03e00008, 0x27bd0020,
6376 0x27bdffe8, 0x3c1bc000, 0xafbf0014, 0xafb00010, 0xaf60680c, 0x8f626804,
6377 0x34420082, 0xaf626804, 0x8f634000, 0x24020b50, 0x3c010001, 0xac220f20,
6378 0x24020b78, 0x3c010001, 0xac220f30, 0x34630002, 0xaf634000, 0x0c004315,
6379 0x00808021, 0x3c010001, 0xa0220f34, 0x304200ff, 0x24030002, 0x14430005,
6380 0x00000000, 0x3c020001, 0x8c420f20, 0x08004308, 0xac5000c0, 0x3c020001,
6381 0x8c420f20, 0xac5000bc, 0x8f624434, 0x8f634438, 0x8f644410, 0x3c010001,
6382 0xac220f28, 0x3c010001, 0xac230f38, 0x3c010001, 0xac240f24, 0x8fbf0014,
6383 0x8fb00010, 0x03e00008, 0x27bd0018, 0x03e00008, 0x24020001, 0x27bdfff8,
6384 0x18800009, 0x00002821, 0x8f63680c, 0x8f62680c, 0x1043fffe, 0x00000000,
6385 0x24a50001, 0x00a4102a, 0x1440fff9, 0x00000000, 0x03e00008, 0x27bd0008,
6386 0x8f634450, 0x3c020001, 0x8c420f28, 0x00031c02, 0x0043102b, 0x14400008,
6387 0x3c038000, 0x3c040001, 0x8c840f38, 0x8f624450, 0x00021c02, 0x0083102b,
6388 0x1040fffc, 0x3c038000, 0xaf634444, 0x8f624444, 0x00431024, 0x1440fffd,
6389 0x00000000, 0x8f624448, 0x03e00008, 0x3042ffff, 0x3082ffff, 0x2442e000,
6390 0x2c422001, 0x14400003, 0x3c024000, 0x08004347, 0x2402ffff, 0x00822025,
6391 0xaf645c38, 0x8f625c30, 0x30420002, 0x1440fffc, 0x00001021, 0x03e00008,
6392 0x00000000, 0x8f624450, 0x3c030001, 0x8c630f24, 0x08004350, 0x3042ffff,
6393 0x8f624450, 0x3042ffff, 0x0043102b, 0x1440fffc, 0x00000000, 0x03e00008,
6394 0x00000000, 0x27bdffe0, 0x00802821, 0x3c040001, 0x24840ed0, 0x00003021,
6395 0x00003821, 0xafbf0018, 0xafa00010, 0x0c004378, 0xafa00014, 0x0800435f,
6396 0x00000000, 0x8fbf0018, 0x03e00008, 0x27bd0020, 0x3c020001, 0x3442d600,
6397 0x3c030001, 0x3463d600, 0x3c040001, 0x3484ddff, 0x3c010001, 0xac220f40,
6398 0x24020040, 0x3c010001, 0xac220f44, 0x3c010001, 0xac200f3c, 0xac600000,
6399 0x24630004, 0x0083102b, 0x5040fffd, 0xac600000, 0x03e00008, 0x00000000,
6400 0x00804821, 0x8faa0010, 0x3c020001, 0x8c420f3c, 0x3c040001, 0x8c840f44,
6401 0x8fab0014, 0x24430001, 0x0044102b, 0x3c010001, 0xac230f3c, 0x14400003,
6402 0x00004021, 0x3c010001, 0xac200f3c, 0x3c020001, 0x8c420f3c, 0x3c030001,
6403 0x8c630f40, 0x91240000, 0x00021140, 0x00431021, 0x00481021, 0x25080001,
6404 0xa0440000, 0x29020008, 0x1440fff4, 0x25290001, 0x3c020001, 0x8c420f3c,
6405 0x3c030001, 0x8c630f40, 0x8f64680c, 0x00021140, 0x00431021, 0xac440008,
6406 0xac45000c, 0xac460010, 0xac470014, 0xac4a0018, 0x03e00008, 0xac4b001c,
6407 0x00000000, 0x00000000, 0x00000000,
6408 };
6409
6410 static const u32 tg3Tso5FwRodata[(TG3_TSO5_FW_RODATA_LEN / 4) + 1] = {
6411 0x4d61696e, 0x43707542, 0x00000000, 0x4d61696e, 0x43707541, 0x00000000,
6412 0x00000000, 0x00000000, 0x73746b6f, 0x66666c64, 0x00000000, 0x00000000,
6413 0x73746b6f, 0x66666c64, 0x00000000, 0x00000000, 0x66617461, 0x6c457272,
6414 0x00000000, 0x00000000, 0x00000000,
6415 };
6416
6417 static const u32 tg3Tso5FwData[(TG3_TSO5_FW_DATA_LEN / 4) + 1] = {
6418 0x00000000, 0x73746b6f, 0x66666c64, 0x5f76312e, 0x322e3000, 0x00000000,
6419 0x00000000, 0x00000000, 0x00000000,
6420 };
6421
6422 /* tp->lock is held. */
6423 static int tg3_load_tso_firmware(struct tg3 *tp)
6424 {
6425 struct fw_info info;
6426 unsigned long cpu_base, cpu_scratch_base, cpu_scratch_size;
6427 int err, i;
6428
6429 if (tp->tg3_flags2 & TG3_FLG2_HW_TSO)
6430 return 0;
6431
6432 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) {
6433 info.text_base = TG3_TSO5_FW_TEXT_ADDR;
6434 info.text_len = TG3_TSO5_FW_TEXT_LEN;
6435 info.text_data = &tg3Tso5FwText[0];
6436 info.rodata_base = TG3_TSO5_FW_RODATA_ADDR;
6437 info.rodata_len = TG3_TSO5_FW_RODATA_LEN;
6438 info.rodata_data = &tg3Tso5FwRodata[0];
6439 info.data_base = TG3_TSO5_FW_DATA_ADDR;
6440 info.data_len = TG3_TSO5_FW_DATA_LEN;
6441 info.data_data = &tg3Tso5FwData[0];
6442 cpu_base = RX_CPU_BASE;
6443 cpu_scratch_base = NIC_SRAM_MBUF_POOL_BASE5705;
6444 cpu_scratch_size = (info.text_len +
6445 info.rodata_len +
6446 info.data_len +
6447 TG3_TSO5_FW_SBSS_LEN +
6448 TG3_TSO5_FW_BSS_LEN);
6449 } else {
6450 info.text_base = TG3_TSO_FW_TEXT_ADDR;
6451 info.text_len = TG3_TSO_FW_TEXT_LEN;
6452 info.text_data = &tg3TsoFwText[0];
6453 info.rodata_base = TG3_TSO_FW_RODATA_ADDR;
6454 info.rodata_len = TG3_TSO_FW_RODATA_LEN;
6455 info.rodata_data = &tg3TsoFwRodata[0];
6456 info.data_base = TG3_TSO_FW_DATA_ADDR;
6457 info.data_len = TG3_TSO_FW_DATA_LEN;
6458 info.data_data = &tg3TsoFwData[0];
6459 cpu_base = TX_CPU_BASE;
6460 cpu_scratch_base = TX_CPU_SCRATCH_BASE;
6461 cpu_scratch_size = TX_CPU_SCRATCH_SIZE;
6462 }
6463
6464 err = tg3_load_firmware_cpu(tp, cpu_base,
6465 cpu_scratch_base, cpu_scratch_size,
6466 &info);
6467 if (err)
6468 return err;
6469
6470 /* Now startup the cpu. */
6471 tw32(cpu_base + CPU_STATE, 0xffffffff);
6472 tw32_f(cpu_base + CPU_PC, info.text_base);
6473
6474 for (i = 0; i < 5; i++) {
6475 if (tr32(cpu_base + CPU_PC) == info.text_base)
6476 break;
6477 tw32(cpu_base + CPU_STATE, 0xffffffff);
6478 tw32(cpu_base + CPU_MODE, CPU_MODE_HALT);
6479 tw32_f(cpu_base + CPU_PC, info.text_base);
6480 udelay(1000);
6481 }
6482 if (i >= 5) {
6483 printk(KERN_ERR PFX "tg3_load_tso_firmware fails for %s "
6484 "to set CPU PC, is %08x should be %08x\n",
6485 tp->dev->name, tr32(cpu_base + CPU_PC),
6486 info.text_base);
6487 return -ENODEV;
6488 }
6489 tw32(cpu_base + CPU_STATE, 0xffffffff);
6490 tw32_f(cpu_base + CPU_MODE, 0x00000000);
6491 return 0;
6492 }
6493
6494
6495 /* tp->lock is held. */
6496 static void __tg3_set_mac_addr(struct tg3 *tp, int skip_mac_1)
6497 {
6498 u32 addr_high, addr_low;
6499 int i;
6500
6501 addr_high = ((tp->dev->dev_addr[0] << 8) |
6502 tp->dev->dev_addr[1]);
6503 addr_low = ((tp->dev->dev_addr[2] << 24) |
6504 (tp->dev->dev_addr[3] << 16) |
6505 (tp->dev->dev_addr[4] << 8) |
6506 (tp->dev->dev_addr[5] << 0));
6507 for (i = 0; i < 4; i++) {
6508 if (i == 1 && skip_mac_1)
6509 continue;
6510 tw32(MAC_ADDR_0_HIGH + (i * 8), addr_high);
6511 tw32(MAC_ADDR_0_LOW + (i * 8), addr_low);
6512 }
6513
6514 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
6515 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) {
6516 for (i = 0; i < 12; i++) {
6517 tw32(MAC_EXTADDR_0_HIGH + (i * 8), addr_high);
6518 tw32(MAC_EXTADDR_0_LOW + (i * 8), addr_low);
6519 }
6520 }
6521
6522 addr_high = (tp->dev->dev_addr[0] +
6523 tp->dev->dev_addr[1] +
6524 tp->dev->dev_addr[2] +
6525 tp->dev->dev_addr[3] +
6526 tp->dev->dev_addr[4] +
6527 tp->dev->dev_addr[5]) &
6528 TX_BACKOFF_SEED_MASK;
6529 tw32(MAC_TX_BACKOFF_SEED, addr_high);
6530 }
6531
6532 static int tg3_set_mac_addr(struct net_device *dev, void *p)
6533 {
6534 struct tg3 *tp = netdev_priv(dev);
6535 struct sockaddr *addr = p;
6536 int err = 0, skip_mac_1 = 0;
6537
6538 if (!is_valid_ether_addr(addr->sa_data))
6539 return -EINVAL;
6540
6541 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
6542
6543 if (!netif_running(dev))
6544 return 0;
6545
6546 if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) {
6547 u32 addr0_high, addr0_low, addr1_high, addr1_low;
6548
6549 addr0_high = tr32(MAC_ADDR_0_HIGH);
6550 addr0_low = tr32(MAC_ADDR_0_LOW);
6551 addr1_high = tr32(MAC_ADDR_1_HIGH);
6552 addr1_low = tr32(MAC_ADDR_1_LOW);
6553
6554 /* Skip MAC addr 1 if ASF is using it. */
6555 if ((addr0_high != addr1_high || addr0_low != addr1_low) &&
6556 !(addr1_high == 0 && addr1_low == 0))
6557 skip_mac_1 = 1;
6558 }
6559 spin_lock_bh(&tp->lock);
6560 __tg3_set_mac_addr(tp, skip_mac_1);
6561 spin_unlock_bh(&tp->lock);
6562
6563 return err;
6564 }
6565
6566 /* tp->lock is held. */
6567 static void tg3_set_bdinfo(struct tg3 *tp, u32 bdinfo_addr,
6568 dma_addr_t mapping, u32 maxlen_flags,
6569 u32 nic_addr)
6570 {
6571 tg3_write_mem(tp,
6572 (bdinfo_addr + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_HIGH),
6573 ((u64) mapping >> 32));
6574 tg3_write_mem(tp,
6575 (bdinfo_addr + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_LOW),
6576 ((u64) mapping & 0xffffffff));
6577 tg3_write_mem(tp,
6578 (bdinfo_addr + TG3_BDINFO_MAXLEN_FLAGS),
6579 maxlen_flags);
6580
6581 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS))
6582 tg3_write_mem(tp,
6583 (bdinfo_addr + TG3_BDINFO_NIC_ADDR),
6584 nic_addr);
6585 }
6586
6587 static void __tg3_set_rx_mode(struct net_device *);
6588 static void __tg3_set_coalesce(struct tg3 *tp, struct ethtool_coalesce *ec)
6589 {
6590 tw32(HOSTCC_RXCOL_TICKS, ec->rx_coalesce_usecs);
6591 tw32(HOSTCC_TXCOL_TICKS, ec->tx_coalesce_usecs);
6592 tw32(HOSTCC_RXMAX_FRAMES, ec->rx_max_coalesced_frames);
6593 tw32(HOSTCC_TXMAX_FRAMES, ec->tx_max_coalesced_frames);
6594 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
6595 tw32(HOSTCC_RXCOAL_TICK_INT, ec->rx_coalesce_usecs_irq);
6596 tw32(HOSTCC_TXCOAL_TICK_INT, ec->tx_coalesce_usecs_irq);
6597 }
6598 tw32(HOSTCC_RXCOAL_MAXF_INT, ec->rx_max_coalesced_frames_irq);
6599 tw32(HOSTCC_TXCOAL_MAXF_INT, ec->tx_max_coalesced_frames_irq);
6600 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
6601 u32 val = ec->stats_block_coalesce_usecs;
6602
6603 if (!netif_carrier_ok(tp->dev))
6604 val = 0;
6605
6606 tw32(HOSTCC_STAT_COAL_TICKS, val);
6607 }
6608 }
6609
6610 /* tp->lock is held. */
6611 static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
6612 {
6613 u32 val, rdmac_mode;
6614 int i, err, limit;
6615
6616 tg3_disable_ints(tp);
6617
6618 tg3_stop_fw(tp);
6619
6620 tg3_write_sig_pre_reset(tp, RESET_KIND_INIT);
6621
6622 if (tp->tg3_flags & TG3_FLAG_INIT_COMPLETE) {
6623 tg3_abort_hw(tp, 1);
6624 }
6625
6626 if (reset_phy)
6627 tg3_phy_reset(tp);
6628
6629 err = tg3_chip_reset(tp);
6630 if (err)
6631 return err;
6632
6633 tg3_write_sig_legacy(tp, RESET_KIND_INIT);
6634
6635 if (tp->pci_chip_rev_id == CHIPREV_ID_5784_A0 ||
6636 tp->pci_chip_rev_id == CHIPREV_ID_5784_A1) {
6637 val = tr32(TG3_CPMU_CTRL);
6638 val &= ~(CPMU_CTRL_LINK_AWARE_MODE | CPMU_CTRL_LINK_IDLE_MODE);
6639 tw32(TG3_CPMU_CTRL, val);
6640
6641 val = tr32(TG3_CPMU_LSPD_10MB_CLK);
6642 val &= ~CPMU_LSPD_10MB_MACCLK_MASK;
6643 val |= CPMU_LSPD_10MB_MACCLK_6_25;
6644 tw32(TG3_CPMU_LSPD_10MB_CLK, val);
6645
6646 val = tr32(TG3_CPMU_LNK_AWARE_PWRMD);
6647 val &= ~CPMU_LNK_AWARE_MACCLK_MASK;
6648 val |= CPMU_LNK_AWARE_MACCLK_6_25;
6649 tw32(TG3_CPMU_LNK_AWARE_PWRMD, val);
6650
6651 val = tr32(TG3_CPMU_HST_ACC);
6652 val &= ~CPMU_HST_ACC_MACCLK_MASK;
6653 val |= CPMU_HST_ACC_MACCLK_6_25;
6654 tw32(TG3_CPMU_HST_ACC, val);
6655 }
6656
6657 /* This works around an issue with Athlon chipsets on
6658 * B3 tigon3 silicon. This bit has no effect on any
6659 * other revision. But do not set this on PCI Express
6660 * chips and don't even touch the clocks if the CPMU is present.
6661 */
6662 if (!(tp->tg3_flags & TG3_FLAG_CPMU_PRESENT)) {
6663 if (!(tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS))
6664 tp->pci_clock_ctrl |= CLOCK_CTRL_DELAY_PCI_GRANT;
6665 tw32_f(TG3PCI_CLOCK_CTRL, tp->pci_clock_ctrl);
6666 }
6667
6668 if (tp->pci_chip_rev_id == CHIPREV_ID_5704_A0 &&
6669 (tp->tg3_flags & TG3_FLAG_PCIX_MODE)) {
6670 val = tr32(TG3PCI_PCISTATE);
6671 val |= PCISTATE_RETRY_SAME_DMA;
6672 tw32(TG3PCI_PCISTATE, val);
6673 }
6674
6675 if (tp->tg3_flags3 & TG3_FLG3_ENABLE_APE) {
6676 /* Allow reads and writes to the
6677 * APE register and memory space.
6678 */
6679 val = tr32(TG3PCI_PCISTATE);
6680 val |= PCISTATE_ALLOW_APE_CTLSPC_WR |
6681 PCISTATE_ALLOW_APE_SHMEM_WR;
6682 tw32(TG3PCI_PCISTATE, val);
6683 }
6684
6685 if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5704_BX) {
6686 /* Enable some hw fixes. */
6687 val = tr32(TG3PCI_MSI_DATA);
6688 val |= (1 << 26) | (1 << 28) | (1 << 29);
6689 tw32(TG3PCI_MSI_DATA, val);
6690 }
6691
6692 /* Descriptor ring init may make accesses to the
6693 * NIC SRAM area to setup the TX descriptors, so we
6694 * can only do this after the hardware has been
6695 * successfully reset.
6696 */
6697 err = tg3_init_rings(tp);
6698 if (err)
6699 return err;
6700
6701 if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5784 &&
6702 GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5761) {
6703 /* This value is determined during the probe time DMA
6704 * engine test, tg3_test_dma.
6705 */
6706 tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
6707 }
6708
6709 tp->grc_mode &= ~(GRC_MODE_HOST_SENDBDS |
6710 GRC_MODE_4X_NIC_SEND_RINGS |
6711 GRC_MODE_NO_TX_PHDR_CSUM |
6712 GRC_MODE_NO_RX_PHDR_CSUM);
6713 tp->grc_mode |= GRC_MODE_HOST_SENDBDS;
6714
6715 /* Pseudo-header checksum is done by hardware logic and not
6716 * the offload processers, so make the chip do the pseudo-
6717 * header checksums on receive. For transmit it is more
6718 * convenient to do the pseudo-header checksum in software
6719 * as Linux does that on transmit for us in all cases.
6720 */
6721 tp->grc_mode |= GRC_MODE_NO_TX_PHDR_CSUM;
6722
6723 tw32(GRC_MODE,
6724 tp->grc_mode |
6725 (GRC_MODE_IRQ_ON_MAC_ATTN | GRC_MODE_HOST_STACKUP));
6726
6727 /* Setup the timer prescalar register. Clock is always 66Mhz. */
6728 val = tr32(GRC_MISC_CFG);
6729 val &= ~0xff;
6730 val |= (65 << GRC_MISC_CFG_PRESCALAR_SHIFT);
6731 tw32(GRC_MISC_CFG, val);
6732
6733 /* Initialize MBUF/DESC pool. */
6734 if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS) {
6735 /* Do nothing. */
6736 } else if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5705) {
6737 tw32(BUFMGR_MB_POOL_ADDR, NIC_SRAM_MBUF_POOL_BASE);
6738 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704)
6739 tw32(BUFMGR_MB_POOL_SIZE, NIC_SRAM_MBUF_POOL_SIZE64);
6740 else
6741 tw32(BUFMGR_MB_POOL_SIZE, NIC_SRAM_MBUF_POOL_SIZE96);
6742 tw32(BUFMGR_DMA_DESC_POOL_ADDR, NIC_SRAM_DMA_DESC_POOL_BASE);
6743 tw32(BUFMGR_DMA_DESC_POOL_SIZE, NIC_SRAM_DMA_DESC_POOL_SIZE);
6744 }
6745 else if (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE) {
6746 int fw_len;
6747
6748 fw_len = (TG3_TSO5_FW_TEXT_LEN +
6749 TG3_TSO5_FW_RODATA_LEN +
6750 TG3_TSO5_FW_DATA_LEN +
6751 TG3_TSO5_FW_SBSS_LEN +
6752 TG3_TSO5_FW_BSS_LEN);
6753 fw_len = (fw_len + (0x80 - 1)) & ~(0x80 - 1);
6754 tw32(BUFMGR_MB_POOL_ADDR,
6755 NIC_SRAM_MBUF_POOL_BASE5705 + fw_len);
6756 tw32(BUFMGR_MB_POOL_SIZE,
6757 NIC_SRAM_MBUF_POOL_SIZE5705 - fw_len - 0xa00);
6758 }
6759
6760 if (tp->dev->mtu <= ETH_DATA_LEN) {
6761 tw32(BUFMGR_MB_RDMA_LOW_WATER,
6762 tp->bufmgr_config.mbuf_read_dma_low_water);
6763 tw32(BUFMGR_MB_MACRX_LOW_WATER,
6764 tp->bufmgr_config.mbuf_mac_rx_low_water);
6765 tw32(BUFMGR_MB_HIGH_WATER,
6766 tp->bufmgr_config.mbuf_high_water);
6767 } else {
6768 tw32(BUFMGR_MB_RDMA_LOW_WATER,
6769 tp->bufmgr_config.mbuf_read_dma_low_water_jumbo);
6770 tw32(BUFMGR_MB_MACRX_LOW_WATER,
6771 tp->bufmgr_config.mbuf_mac_rx_low_water_jumbo);
6772 tw32(BUFMGR_MB_HIGH_WATER,
6773 tp->bufmgr_config.mbuf_high_water_jumbo);
6774 }
6775 tw32(BUFMGR_DMA_LOW_WATER,
6776 tp->bufmgr_config.dma_low_water);
6777 tw32(BUFMGR_DMA_HIGH_WATER,
6778 tp->bufmgr_config.dma_high_water);
6779
6780 tw32(BUFMGR_MODE, BUFMGR_MODE_ENABLE | BUFMGR_MODE_ATTN_ENABLE);
6781 for (i = 0; i < 2000; i++) {
6782 if (tr32(BUFMGR_MODE) & BUFMGR_MODE_ENABLE)
6783 break;
6784 udelay(10);
6785 }
6786 if (i >= 2000) {
6787 printk(KERN_ERR PFX "tg3_reset_hw cannot enable BUFMGR for %s.\n",
6788 tp->dev->name);
6789 return -ENODEV;
6790 }
6791
6792 /* Setup replenish threshold. */
6793 val = tp->rx_pending / 8;
6794 if (val == 0)
6795 val = 1;
6796 else if (val > tp->rx_std_max_post)
6797 val = tp->rx_std_max_post;
6798 else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
6799 if (tp->pci_chip_rev_id == CHIPREV_ID_5906_A1)
6800 tw32(ISO_PKT_TX, (tr32(ISO_PKT_TX) & ~0x3) | 0x2);
6801
6802 if (val > (TG3_RX_INTERNAL_RING_SZ_5906 / 2))
6803 val = TG3_RX_INTERNAL_RING_SZ_5906 / 2;
6804 }
6805
6806 tw32(RCVBDI_STD_THRESH, val);
6807
6808 /* Initialize TG3_BDINFO's at:
6809 * RCVDBDI_STD_BD: standard eth size rx ring
6810 * RCVDBDI_JUMBO_BD: jumbo frame rx ring
6811 * RCVDBDI_MINI_BD: small frame rx ring (??? does not work)
6812 *
6813 * like so:
6814 * TG3_BDINFO_HOST_ADDR: high/low parts of DMA address of ring
6815 * TG3_BDINFO_MAXLEN_FLAGS: (rx max buffer size << 16) |
6816 * ring attribute flags
6817 * TG3_BDINFO_NIC_ADDR: location of descriptors in nic SRAM
6818 *
6819 * Standard receive ring @ NIC_SRAM_RX_BUFFER_DESC, 512 entries.
6820 * Jumbo receive ring @ NIC_SRAM_RX_JUMBO_BUFFER_DESC, 256 entries.
6821 *
6822 * The size of each ring is fixed in the firmware, but the location is
6823 * configurable.
6824 */
6825 tw32(RCVDBDI_STD_BD + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_HIGH,
6826 ((u64) tp->rx_std_mapping >> 32));
6827 tw32(RCVDBDI_STD_BD + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_LOW,
6828 ((u64) tp->rx_std_mapping & 0xffffffff));
6829 tw32(RCVDBDI_STD_BD + TG3_BDINFO_NIC_ADDR,
6830 NIC_SRAM_RX_BUFFER_DESC);
6831
6832 /* Don't even try to program the JUMBO/MINI buffer descriptor
6833 * configs on 5705.
6834 */
6835 if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
6836 tw32(RCVDBDI_STD_BD + TG3_BDINFO_MAXLEN_FLAGS,
6837 RX_STD_MAX_SIZE_5705 << BDINFO_FLAGS_MAXLEN_SHIFT);
6838 } else {
6839 tw32(RCVDBDI_STD_BD + TG3_BDINFO_MAXLEN_FLAGS,
6840 RX_STD_MAX_SIZE << BDINFO_FLAGS_MAXLEN_SHIFT);
6841
6842 tw32(RCVDBDI_MINI_BD + TG3_BDINFO_MAXLEN_FLAGS,
6843 BDINFO_FLAGS_DISABLED);
6844
6845 /* Setup replenish threshold. */
6846 tw32(RCVBDI_JUMBO_THRESH, tp->rx_jumbo_pending / 8);
6847
6848 if (tp->tg3_flags & TG3_FLAG_JUMBO_RING_ENABLE) {
6849 tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_HIGH,
6850 ((u64) tp->rx_jumbo_mapping >> 32));
6851 tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_LOW,
6852 ((u64) tp->rx_jumbo_mapping & 0xffffffff));
6853 tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_MAXLEN_FLAGS,
6854 RX_JUMBO_MAX_SIZE << BDINFO_FLAGS_MAXLEN_SHIFT);
6855 tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_NIC_ADDR,
6856 NIC_SRAM_RX_JUMBO_BUFFER_DESC);
6857 } else {
6858 tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_MAXLEN_FLAGS,
6859 BDINFO_FLAGS_DISABLED);
6860 }
6861
6862 }
6863
6864 /* There is only one send ring on 5705/5750, no need to explicitly
6865 * disable the others.
6866 */
6867 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
6868 /* Clear out send RCB ring in SRAM. */
6869 for (i = NIC_SRAM_SEND_RCB; i < NIC_SRAM_RCV_RET_RCB; i += TG3_BDINFO_SIZE)
6870 tg3_write_mem(tp, i + TG3_BDINFO_MAXLEN_FLAGS,
6871 BDINFO_FLAGS_DISABLED);
6872 }
6873
6874 tp->tx_prod = 0;
6875 tp->tx_cons = 0;
6876 tw32_mailbox(MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW, 0);
6877 tw32_tx_mbox(MAILBOX_SNDNIC_PROD_IDX_0 + TG3_64BIT_REG_LOW, 0);
6878
6879 tg3_set_bdinfo(tp, NIC_SRAM_SEND_RCB,
6880 tp->tx_desc_mapping,
6881 (TG3_TX_RING_SIZE <<
6882 BDINFO_FLAGS_MAXLEN_SHIFT),
6883 NIC_SRAM_TX_BUFFER_DESC);
6884
6885 /* There is only one receive return ring on 5705/5750, no need
6886 * to explicitly disable the others.
6887 */
6888 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
6889 for (i = NIC_SRAM_RCV_RET_RCB; i < NIC_SRAM_STATS_BLK;
6890 i += TG3_BDINFO_SIZE) {
6891 tg3_write_mem(tp, i + TG3_BDINFO_MAXLEN_FLAGS,
6892 BDINFO_FLAGS_DISABLED);
6893 }
6894 }
6895
6896 tp->rx_rcb_ptr = 0;
6897 tw32_rx_mbox(MAILBOX_RCVRET_CON_IDX_0 + TG3_64BIT_REG_LOW, 0);
6898
6899 tg3_set_bdinfo(tp, NIC_SRAM_RCV_RET_RCB,
6900 tp->rx_rcb_mapping,
6901 (TG3_RX_RCB_RING_SIZE(tp) <<
6902 BDINFO_FLAGS_MAXLEN_SHIFT),
6903 0);
6904
6905 tp->rx_std_ptr = tp->rx_pending;
6906 tw32_rx_mbox(MAILBOX_RCV_STD_PROD_IDX + TG3_64BIT_REG_LOW,
6907 tp->rx_std_ptr);
6908
6909 tp->rx_jumbo_ptr = (tp->tg3_flags & TG3_FLAG_JUMBO_RING_ENABLE) ?
6910 tp->rx_jumbo_pending : 0;
6911 tw32_rx_mbox(MAILBOX_RCV_JUMBO_PROD_IDX + TG3_64BIT_REG_LOW,
6912 tp->rx_jumbo_ptr);
6913
6914 /* Initialize MAC address and backoff seed. */
6915 __tg3_set_mac_addr(tp, 0);
6916
6917 /* MTU + ethernet header + FCS + optional VLAN tag */
6918 tw32(MAC_RX_MTU_SIZE, tp->dev->mtu + ETH_HLEN + 8);
6919
6920 /* The slot time is changed by tg3_setup_phy if we
6921 * run at gigabit with half duplex.
6922 */
6923 tw32(MAC_TX_LENGTHS,
6924 (2 << TX_LENGTHS_IPG_CRS_SHIFT) |
6925 (6 << TX_LENGTHS_IPG_SHIFT) |
6926 (32 << TX_LENGTHS_SLOT_TIME_SHIFT));
6927
6928 /* Receive rules. */
6929 tw32(MAC_RCV_RULE_CFG, RCV_RULE_CFG_DEFAULT_CLASS);
6930 tw32(RCVLPC_CONFIG, 0x0181);
6931
6932 /* Calculate RDMAC_MODE setting early, we need it to determine
6933 * the RCVLPC_STATE_ENABLE mask.
6934 */
6935 rdmac_mode = (RDMAC_MODE_ENABLE | RDMAC_MODE_TGTABORT_ENAB |
6936 RDMAC_MODE_MSTABORT_ENAB | RDMAC_MODE_PARITYERR_ENAB |
6937 RDMAC_MODE_ADDROFLOW_ENAB | RDMAC_MODE_FIFOOFLOW_ENAB |
6938 RDMAC_MODE_FIFOURUN_ENAB | RDMAC_MODE_FIFOOREAD_ENAB |
6939 RDMAC_MODE_LNGREAD_ENAB);
6940
6941 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784)
6942 rdmac_mode |= RDMAC_MODE_BD_SBD_CRPT_ENAB |
6943 RDMAC_MODE_MBUF_RBD_CRPT_ENAB |
6944 RDMAC_MODE_MBUF_SBD_CRPT_ENAB;
6945
6946 /* If statement applies to 5705 and 5750 PCI devices only */
6947 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 &&
6948 tp->pci_chip_rev_id != CHIPREV_ID_5705_A0) ||
6949 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750)) {
6950 if (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE &&
6951 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) {
6952 rdmac_mode |= RDMAC_MODE_FIFO_SIZE_128;
6953 } else if (!(tr32(TG3PCI_PCISTATE) & PCISTATE_BUS_SPEED_HIGH) &&
6954 !(tp->tg3_flags2 & TG3_FLG2_IS_5788)) {
6955 rdmac_mode |= RDMAC_MODE_FIFO_LONG_BURST;
6956 }
6957 }
6958
6959 if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS)
6960 rdmac_mode |= RDMAC_MODE_FIFO_LONG_BURST;
6961
6962 if (tp->tg3_flags2 & TG3_FLG2_HW_TSO)
6963 rdmac_mode |= (1 << 27);
6964
6965 /* Receive/send statistics. */
6966 if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS) {
6967 val = tr32(RCVLPC_STATS_ENABLE);
6968 val &= ~RCVLPC_STATSENAB_DACK_FIX;
6969 tw32(RCVLPC_STATS_ENABLE, val);
6970 } else if ((rdmac_mode & RDMAC_MODE_FIFO_SIZE_128) &&
6971 (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE)) {
6972 val = tr32(RCVLPC_STATS_ENABLE);
6973 val &= ~RCVLPC_STATSENAB_LNGBRST_RFIX;
6974 tw32(RCVLPC_STATS_ENABLE, val);
6975 } else {
6976 tw32(RCVLPC_STATS_ENABLE, 0xffffff);
6977 }
6978 tw32(RCVLPC_STATSCTRL, RCVLPC_STATSCTRL_ENABLE);
6979 tw32(SNDDATAI_STATSENAB, 0xffffff);
6980 tw32(SNDDATAI_STATSCTRL,
6981 (SNDDATAI_SCTRL_ENABLE |
6982 SNDDATAI_SCTRL_FASTUPD));
6983
6984 /* Setup host coalescing engine. */
6985 tw32(HOSTCC_MODE, 0);
6986 for (i = 0; i < 2000; i++) {
6987 if (!(tr32(HOSTCC_MODE) & HOSTCC_MODE_ENABLE))
6988 break;
6989 udelay(10);
6990 }
6991
6992 __tg3_set_coalesce(tp, &tp->coal);
6993
6994 /* set status block DMA address */
6995 tw32(HOSTCC_STATUS_BLK_HOST_ADDR + TG3_64BIT_REG_HIGH,
6996 ((u64) tp->status_mapping >> 32));
6997 tw32(HOSTCC_STATUS_BLK_HOST_ADDR + TG3_64BIT_REG_LOW,
6998 ((u64) tp->status_mapping & 0xffffffff));
6999
7000 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
7001 /* Status/statistics block address. See tg3_timer,
7002 * the tg3_periodic_fetch_stats call there, and
7003 * tg3_get_stats to see how this works for 5705/5750 chips.
7004 */
7005 tw32(HOSTCC_STATS_BLK_HOST_ADDR + TG3_64BIT_REG_HIGH,
7006 ((u64) tp->stats_mapping >> 32));
7007 tw32(HOSTCC_STATS_BLK_HOST_ADDR + TG3_64BIT_REG_LOW,
7008 ((u64) tp->stats_mapping & 0xffffffff));
7009 tw32(HOSTCC_STATS_BLK_NIC_ADDR, NIC_SRAM_STATS_BLK);
7010 tw32(HOSTCC_STATUS_BLK_NIC_ADDR, NIC_SRAM_STATUS_BLK);
7011 }
7012
7013 tw32(HOSTCC_MODE, HOSTCC_MODE_ENABLE | tp->coalesce_mode);
7014
7015 tw32(RCVCC_MODE, RCVCC_MODE_ENABLE | RCVCC_MODE_ATTN_ENABLE);
7016 tw32(RCVLPC_MODE, RCVLPC_MODE_ENABLE);
7017 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS))
7018 tw32(RCVLSC_MODE, RCVLSC_MODE_ENABLE | RCVLSC_MODE_ATTN_ENABLE);
7019
7020 /* Clear statistics/status block in chip, and status block in ram. */
7021 for (i = NIC_SRAM_STATS_BLK;
7022 i < NIC_SRAM_STATUS_BLK + TG3_HW_STATUS_SIZE;
7023 i += sizeof(u32)) {
7024 tg3_write_mem(tp, i, 0);
7025 udelay(40);
7026 }
7027 memset(tp->hw_status, 0, TG3_HW_STATUS_SIZE);
7028
7029 if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES) {
7030 tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
7031 /* reset to prevent losing 1st rx packet intermittently */
7032 tw32_f(MAC_RX_MODE, RX_MODE_RESET);
7033 udelay(10);
7034 }
7035
7036 tp->mac_mode = MAC_MODE_TXSTAT_ENABLE | MAC_MODE_RXSTAT_ENABLE |
7037 MAC_MODE_TDE_ENABLE | MAC_MODE_RDE_ENABLE | MAC_MODE_FHDE_ENABLE;
7038 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS) &&
7039 !(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) &&
7040 GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700)
7041 tp->mac_mode |= MAC_MODE_LINK_POLARITY;
7042 tw32_f(MAC_MODE, tp->mac_mode | MAC_MODE_RXSTAT_CLEAR | MAC_MODE_TXSTAT_CLEAR);
7043 udelay(40);
7044
7045 /* tp->grc_local_ctrl is partially set up during tg3_get_invariants().
7046 * If TG3_FLG2_IS_NIC is zero, we should read the
7047 * register to preserve the GPIO settings for LOMs. The GPIOs,
7048 * whether used as inputs or outputs, are set by boot code after
7049 * reset.
7050 */
7051 if (!(tp->tg3_flags2 & TG3_FLG2_IS_NIC)) {
7052 u32 gpio_mask;
7053
7054 gpio_mask = GRC_LCLCTRL_GPIO_OE0 | GRC_LCLCTRL_GPIO_OE1 |
7055 GRC_LCLCTRL_GPIO_OE2 | GRC_LCLCTRL_GPIO_OUTPUT0 |
7056 GRC_LCLCTRL_GPIO_OUTPUT1 | GRC_LCLCTRL_GPIO_OUTPUT2;
7057
7058 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752)
7059 gpio_mask |= GRC_LCLCTRL_GPIO_OE3 |
7060 GRC_LCLCTRL_GPIO_OUTPUT3;
7061
7062 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755)
7063 gpio_mask |= GRC_LCLCTRL_GPIO_UART_SEL;
7064
7065 tp->grc_local_ctrl &= ~gpio_mask;
7066 tp->grc_local_ctrl |= tr32(GRC_LOCAL_CTRL) & gpio_mask;
7067
7068 /* GPIO1 must be driven high for eeprom write protect */
7069 if (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT)
7070 tp->grc_local_ctrl |= (GRC_LCLCTRL_GPIO_OE1 |
7071 GRC_LCLCTRL_GPIO_OUTPUT1);
7072 }
7073 tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
7074 udelay(100);
7075
7076 tw32_mailbox_f(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0);
7077 tp->last_tag = 0;
7078
7079 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
7080 tw32_f(DMAC_MODE, DMAC_MODE_ENABLE);
7081 udelay(40);
7082 }
7083
7084 val = (WDMAC_MODE_ENABLE | WDMAC_MODE_TGTABORT_ENAB |
7085 WDMAC_MODE_MSTABORT_ENAB | WDMAC_MODE_PARITYERR_ENAB |
7086 WDMAC_MODE_ADDROFLOW_ENAB | WDMAC_MODE_FIFOOFLOW_ENAB |
7087 WDMAC_MODE_FIFOURUN_ENAB | WDMAC_MODE_FIFOOREAD_ENAB |
7088 WDMAC_MODE_LNGREAD_ENAB);
7089
7090 /* If statement applies to 5705 and 5750 PCI devices only */
7091 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 &&
7092 tp->pci_chip_rev_id != CHIPREV_ID_5705_A0) ||
7093 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) {
7094 if ((tp->tg3_flags & TG3_FLG2_TSO_CAPABLE) &&
7095 (tp->pci_chip_rev_id == CHIPREV_ID_5705_A1 ||
7096 tp->pci_chip_rev_id == CHIPREV_ID_5705_A2)) {
7097 /* nothing */
7098 } else if (!(tr32(TG3PCI_PCISTATE) & PCISTATE_BUS_SPEED_HIGH) &&
7099 !(tp->tg3_flags2 & TG3_FLG2_IS_5788) &&
7100 !(tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS)) {
7101 val |= WDMAC_MODE_RX_ACCEL;
7102 }
7103 }
7104
7105 /* Enable host coalescing bug fix */
7106 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755) ||
7107 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787) ||
7108 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784) ||
7109 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761))
7110 val |= (1 << 29);
7111
7112 tw32_f(WDMAC_MODE, val);
7113 udelay(40);
7114
7115 if (tp->tg3_flags & TG3_FLAG_PCIX_MODE) {
7116 u16 pcix_cmd;
7117
7118 pci_read_config_word(tp->pdev, tp->pcix_cap + PCI_X_CMD,
7119 &pcix_cmd);
7120 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703) {
7121 pcix_cmd &= ~PCI_X_CMD_MAX_READ;
7122 pcix_cmd |= PCI_X_CMD_READ_2K;
7123 } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) {
7124 pcix_cmd &= ~(PCI_X_CMD_MAX_SPLIT | PCI_X_CMD_MAX_READ);
7125 pcix_cmd |= PCI_X_CMD_READ_2K;
7126 }
7127 pci_write_config_word(tp->pdev, tp->pcix_cap + PCI_X_CMD,
7128 pcix_cmd);
7129 }
7130
7131 tw32_f(RDMAC_MODE, rdmac_mode);
7132 udelay(40);
7133
7134 tw32(RCVDCC_MODE, RCVDCC_MODE_ENABLE | RCVDCC_MODE_ATTN_ENABLE);
7135 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS))
7136 tw32(MBFREE_MODE, MBFREE_MODE_ENABLE);
7137
7138 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761)
7139 tw32(SNDDATAC_MODE,
7140 SNDDATAC_MODE_ENABLE | SNDDATAC_MODE_CDELAY);
7141 else
7142 tw32(SNDDATAC_MODE, SNDDATAC_MODE_ENABLE);
7143
7144 tw32(SNDBDC_MODE, SNDBDC_MODE_ENABLE | SNDBDC_MODE_ATTN_ENABLE);
7145 tw32(RCVBDI_MODE, RCVBDI_MODE_ENABLE | RCVBDI_MODE_RCB_ATTN_ENAB);
7146 tw32(RCVDBDI_MODE, RCVDBDI_MODE_ENABLE | RCVDBDI_MODE_INV_RING_SZ);
7147 tw32(SNDDATAI_MODE, SNDDATAI_MODE_ENABLE);
7148 if (tp->tg3_flags2 & TG3_FLG2_HW_TSO)
7149 tw32(SNDDATAI_MODE, SNDDATAI_MODE_ENABLE | 0x8);
7150 tw32(SNDBDI_MODE, SNDBDI_MODE_ENABLE | SNDBDI_MODE_ATTN_ENABLE);
7151 tw32(SNDBDS_MODE, SNDBDS_MODE_ENABLE | SNDBDS_MODE_ATTN_ENABLE);
7152
7153 if (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0) {
7154 err = tg3_load_5701_a0_firmware_fix(tp);
7155 if (err)
7156 return err;
7157 }
7158
7159 if (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE) {
7160 err = tg3_load_tso_firmware(tp);
7161 if (err)
7162 return err;
7163 }
7164
7165 tp->tx_mode = TX_MODE_ENABLE;
7166 tw32_f(MAC_TX_MODE, tp->tx_mode);
7167 udelay(100);
7168
7169 tp->rx_mode = RX_MODE_ENABLE;
7170 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
7171 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761)
7172 tp->rx_mode |= RX_MODE_IPV6_CSUM_ENABLE;
7173
7174 tw32_f(MAC_RX_MODE, tp->rx_mode);
7175 udelay(10);
7176
7177 if (tp->link_config.phy_is_low_power) {
7178 tp->link_config.phy_is_low_power = 0;
7179 tp->link_config.speed = tp->link_config.orig_speed;
7180 tp->link_config.duplex = tp->link_config.orig_duplex;
7181 tp->link_config.autoneg = tp->link_config.orig_autoneg;
7182 }
7183
7184 tp->mi_mode &= ~MAC_MI_MODE_AUTO_POLL;
7185 tw32_f(MAC_MI_MODE, tp->mi_mode);
7186 udelay(80);
7187
7188 tw32(MAC_LED_CTRL, tp->led_ctrl);
7189
7190 tw32(MAC_MI_STAT, MAC_MI_STAT_LNKSTAT_ATTN_ENAB);
7191 if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
7192 tw32_f(MAC_RX_MODE, RX_MODE_RESET);
7193 udelay(10);
7194 }
7195 tw32_f(MAC_RX_MODE, tp->rx_mode);
7196 udelay(10);
7197
7198 if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
7199 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) &&
7200 !(tp->tg3_flags2 & TG3_FLG2_SERDES_PREEMPHASIS)) {
7201 /* Set drive transmission level to 1.2V */
7202 /* only if the signal pre-emphasis bit is not set */
7203 val = tr32(MAC_SERDES_CFG);
7204 val &= 0xfffff000;
7205 val |= 0x880;
7206 tw32(MAC_SERDES_CFG, val);
7207 }
7208 if (tp->pci_chip_rev_id == CHIPREV_ID_5703_A1)
7209 tw32(MAC_SERDES_CFG, 0x616000);
7210 }
7211
7212 /* Prevent chip from dropping frames when flow control
7213 * is enabled.
7214 */
7215 tw32_f(MAC_LOW_WMARK_MAX_RX_FRAME, 2);
7216
7217 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 &&
7218 (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)) {
7219 /* Use hardware link auto-negotiation */
7220 tp->tg3_flags2 |= TG3_FLG2_HW_AUTONEG;
7221 }
7222
7223 if ((tp->tg3_flags2 & TG3_FLG2_MII_SERDES) &&
7224 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714)) {
7225 u32 tmp;
7226
7227 tmp = tr32(SERDES_RX_CTRL);
7228 tw32(SERDES_RX_CTRL, tmp | SERDES_RX_SIG_DETECT);
7229 tp->grc_local_ctrl &= ~GRC_LCLCTRL_USE_EXT_SIG_DETECT;
7230 tp->grc_local_ctrl |= GRC_LCLCTRL_USE_SIG_DETECT;
7231 tw32(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
7232 }
7233
7234 err = tg3_setup_phy(tp, 0);
7235 if (err)
7236 return err;
7237
7238 if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) &&
7239 GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5906) {
7240 u32 tmp;
7241
7242 /* Clear CRC stats. */
7243 if (!tg3_readphy(tp, MII_TG3_TEST1, &tmp)) {
7244 tg3_writephy(tp, MII_TG3_TEST1,
7245 tmp | MII_TG3_TEST1_CRC_EN);
7246 tg3_readphy(tp, 0x14, &tmp);
7247 }
7248 }
7249
7250 __tg3_set_rx_mode(tp->dev);
7251
7252 /* Initialize receive rules. */
7253 tw32(MAC_RCV_RULE_0, 0xc2000000 & RCV_RULE_DISABLE_MASK);
7254 tw32(MAC_RCV_VALUE_0, 0xffffffff & RCV_RULE_DISABLE_MASK);
7255 tw32(MAC_RCV_RULE_1, 0x86000004 & RCV_RULE_DISABLE_MASK);
7256 tw32(MAC_RCV_VALUE_1, 0xffffffff & RCV_RULE_DISABLE_MASK);
7257
7258 if ((tp->tg3_flags2 & TG3_FLG2_5705_PLUS) &&
7259 !(tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
7260 limit = 8;
7261 else
7262 limit = 16;
7263 if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF)
7264 limit -= 4;
7265 switch (limit) {
7266 case 16:
7267 tw32(MAC_RCV_RULE_15, 0); tw32(MAC_RCV_VALUE_15, 0);
7268 case 15:
7269 tw32(MAC_RCV_RULE_14, 0); tw32(MAC_RCV_VALUE_14, 0);
7270 case 14:
7271 tw32(MAC_RCV_RULE_13, 0); tw32(MAC_RCV_VALUE_13, 0);
7272 case 13:
7273 tw32(MAC_RCV_RULE_12, 0); tw32(MAC_RCV_VALUE_12, 0);
7274 case 12:
7275 tw32(MAC_RCV_RULE_11, 0); tw32(MAC_RCV_VALUE_11, 0);
7276 case 11:
7277 tw32(MAC_RCV_RULE_10, 0); tw32(MAC_RCV_VALUE_10, 0);
7278 case 10:
7279 tw32(MAC_RCV_RULE_9, 0); tw32(MAC_RCV_VALUE_9, 0);
7280 case 9:
7281 tw32(MAC_RCV_RULE_8, 0); tw32(MAC_RCV_VALUE_8, 0);
7282 case 8:
7283 tw32(MAC_RCV_RULE_7, 0); tw32(MAC_RCV_VALUE_7, 0);
7284 case 7:
7285 tw32(MAC_RCV_RULE_6, 0); tw32(MAC_RCV_VALUE_6, 0);
7286 case 6:
7287 tw32(MAC_RCV_RULE_5, 0); tw32(MAC_RCV_VALUE_5, 0);
7288 case 5:
7289 tw32(MAC_RCV_RULE_4, 0); tw32(MAC_RCV_VALUE_4, 0);
7290 case 4:
7291 /* tw32(MAC_RCV_RULE_3, 0); tw32(MAC_RCV_VALUE_3, 0); */
7292 case 3:
7293 /* tw32(MAC_RCV_RULE_2, 0); tw32(MAC_RCV_VALUE_2, 0); */
7294 case 2:
7295 case 1:
7296
7297 default:
7298 break;
7299 };
7300
7301 if (tp->tg3_flags3 & TG3_FLG3_ENABLE_APE)
7302 /* Write our heartbeat update interval to APE. */
7303 tg3_ape_write32(tp, TG3_APE_HOST_HEARTBEAT_INT_MS,
7304 APE_HOST_HEARTBEAT_INT_DISABLE);
7305
7306 tg3_write_sig_post_reset(tp, RESET_KIND_INIT);
7307
7308 return 0;
7309 }
7310
7311 /* Called at device open time to get the chip ready for
7312 * packet processing. Invoked with tp->lock held.
7313 */
7314 static int tg3_init_hw(struct tg3 *tp, int reset_phy)
7315 {
7316 int err;
7317
7318 /* Force the chip into D0. */
7319 err = tg3_set_power_state(tp, PCI_D0);
7320 if (err)
7321 goto out;
7322
7323 tg3_switch_clocks(tp);
7324
7325 tw32(TG3PCI_MEM_WIN_BASE_ADDR, 0);
7326
7327 err = tg3_reset_hw(tp, reset_phy);
7328
7329 out:
7330 return err;
7331 }
7332
7333 #define TG3_STAT_ADD32(PSTAT, REG) \
7334 do { u32 __val = tr32(REG); \
7335 (PSTAT)->low += __val; \
7336 if ((PSTAT)->low < __val) \
7337 (PSTAT)->high += 1; \
7338 } while (0)
7339
7340 static void tg3_periodic_fetch_stats(struct tg3 *tp)
7341 {
7342 struct tg3_hw_stats *sp = tp->hw_stats;
7343
7344 if (!netif_carrier_ok(tp->dev))
7345 return;
7346
7347 TG3_STAT_ADD32(&sp->tx_octets, MAC_TX_STATS_OCTETS);
7348 TG3_STAT_ADD32(&sp->tx_collisions, MAC_TX_STATS_COLLISIONS);
7349 TG3_STAT_ADD32(&sp->tx_xon_sent, MAC_TX_STATS_XON_SENT);
7350 TG3_STAT_ADD32(&sp->tx_xoff_sent, MAC_TX_STATS_XOFF_SENT);
7351 TG3_STAT_ADD32(&sp->tx_mac_errors, MAC_TX_STATS_MAC_ERRORS);
7352 TG3_STAT_ADD32(&sp->tx_single_collisions, MAC_TX_STATS_SINGLE_COLLISIONS);
7353 TG3_STAT_ADD32(&sp->tx_mult_collisions, MAC_TX_STATS_MULT_COLLISIONS);
7354 TG3_STAT_ADD32(&sp->tx_deferred, MAC_TX_STATS_DEFERRED);
7355 TG3_STAT_ADD32(&sp->tx_excessive_collisions, MAC_TX_STATS_EXCESSIVE_COL);
7356 TG3_STAT_ADD32(&sp->tx_late_collisions, MAC_TX_STATS_LATE_COL);
7357 TG3_STAT_ADD32(&sp->tx_ucast_packets, MAC_TX_STATS_UCAST);
7358 TG3_STAT_ADD32(&sp->tx_mcast_packets, MAC_TX_STATS_MCAST);
7359 TG3_STAT_ADD32(&sp->tx_bcast_packets, MAC_TX_STATS_BCAST);
7360
7361 TG3_STAT_ADD32(&sp->rx_octets, MAC_RX_STATS_OCTETS);
7362 TG3_STAT_ADD32(&sp->rx_fragments, MAC_RX_STATS_FRAGMENTS);
7363 TG3_STAT_ADD32(&sp->rx_ucast_packets, MAC_RX_STATS_UCAST);
7364 TG3_STAT_ADD32(&sp->rx_mcast_packets, MAC_RX_STATS_MCAST);
7365 TG3_STAT_ADD32(&sp->rx_bcast_packets, MAC_RX_STATS_BCAST);
7366 TG3_STAT_ADD32(&sp->rx_fcs_errors, MAC_RX_STATS_FCS_ERRORS);
7367 TG3_STAT_ADD32(&sp->rx_align_errors, MAC_RX_STATS_ALIGN_ERRORS);
7368 TG3_STAT_ADD32(&sp->rx_xon_pause_rcvd, MAC_RX_STATS_XON_PAUSE_RECVD);
7369 TG3_STAT_ADD32(&sp->rx_xoff_pause_rcvd, MAC_RX_STATS_XOFF_PAUSE_RECVD);
7370 TG3_STAT_ADD32(&sp->rx_mac_ctrl_rcvd, MAC_RX_STATS_MAC_CTRL_RECVD);
7371 TG3_STAT_ADD32(&sp->rx_xoff_entered, MAC_RX_STATS_XOFF_ENTERED);
7372 TG3_STAT_ADD32(&sp->rx_frame_too_long_errors, MAC_RX_STATS_FRAME_TOO_LONG);
7373 TG3_STAT_ADD32(&sp->rx_jabbers, MAC_RX_STATS_JABBERS);
7374 TG3_STAT_ADD32(&sp->rx_undersize_packets, MAC_RX_STATS_UNDERSIZE);
7375
7376 TG3_STAT_ADD32(&sp->rxbds_empty, RCVLPC_NO_RCV_BD_CNT);
7377 TG3_STAT_ADD32(&sp->rx_discards, RCVLPC_IN_DISCARDS_CNT);
7378 TG3_STAT_ADD32(&sp->rx_errors, RCVLPC_IN_ERRORS_CNT);
7379 }
7380
7381 static void tg3_timer(unsigned long __opaque)
7382 {
7383 struct tg3 *tp = (struct tg3 *) __opaque;
7384
7385 if (tp->irq_sync)
7386 goto restart_timer;
7387
7388 spin_lock(&tp->lock);
7389
7390 if (!(tp->tg3_flags & TG3_FLAG_TAGGED_STATUS)) {
7391 /* All of this garbage is because when using non-tagged
7392 * IRQ status the mailbox/status_block protocol the chip
7393 * uses with the cpu is race prone.
7394 */
7395 if (tp->hw_status->status & SD_STATUS_UPDATED) {
7396 tw32(GRC_LOCAL_CTRL,
7397 tp->grc_local_ctrl | GRC_LCLCTRL_SETINT);
7398 } else {
7399 tw32(HOSTCC_MODE, tp->coalesce_mode |
7400 (HOSTCC_MODE_ENABLE | HOSTCC_MODE_NOW));
7401 }
7402
7403 if (!(tr32(WDMAC_MODE) & WDMAC_MODE_ENABLE)) {
7404 tp->tg3_flags2 |= TG3_FLG2_RESTART_TIMER;
7405 spin_unlock(&tp->lock);
7406 schedule_work(&tp->reset_task);
7407 return;
7408 }
7409 }
7410
7411 /* This part only runs once per second. */
7412 if (!--tp->timer_counter) {
7413 if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)
7414 tg3_periodic_fetch_stats(tp);
7415
7416 if (tp->tg3_flags & TG3_FLAG_USE_LINKCHG_REG) {
7417 u32 mac_stat;
7418 int phy_event;
7419
7420 mac_stat = tr32(MAC_STATUS);
7421
7422 phy_event = 0;
7423 if (tp->tg3_flags & TG3_FLAG_USE_MI_INTERRUPT) {
7424 if (mac_stat & MAC_STATUS_MI_INTERRUPT)
7425 phy_event = 1;
7426 } else if (mac_stat & MAC_STATUS_LNKSTATE_CHANGED)
7427 phy_event = 1;
7428
7429 if (phy_event)
7430 tg3_setup_phy(tp, 0);
7431 } else if (tp->tg3_flags & TG3_FLAG_POLL_SERDES) {
7432 u32 mac_stat = tr32(MAC_STATUS);
7433 int need_setup = 0;
7434
7435 if (netif_carrier_ok(tp->dev) &&
7436 (mac_stat & MAC_STATUS_LNKSTATE_CHANGED)) {
7437 need_setup = 1;
7438 }
7439 if (! netif_carrier_ok(tp->dev) &&
7440 (mac_stat & (MAC_STATUS_PCS_SYNCED |
7441 MAC_STATUS_SIGNAL_DET))) {
7442 need_setup = 1;
7443 }
7444 if (need_setup) {
7445 if (!tp->serdes_counter) {
7446 tw32_f(MAC_MODE,
7447 (tp->mac_mode &
7448 ~MAC_MODE_PORT_MODE_MASK));
7449 udelay(40);
7450 tw32_f(MAC_MODE, tp->mac_mode);
7451 udelay(40);
7452 }
7453 tg3_setup_phy(tp, 0);
7454 }
7455 } else if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES)
7456 tg3_serdes_parallel_detect(tp);
7457
7458 tp->timer_counter = tp->timer_multiplier;
7459 }
7460
7461 /* Heartbeat is only sent once every 2 seconds.
7462 *
7463 * The heartbeat is to tell the ASF firmware that the host
7464 * driver is still alive. In the event that the OS crashes,
7465 * ASF needs to reset the hardware to free up the FIFO space
7466 * that may be filled with rx packets destined for the host.
7467 * If the FIFO is full, ASF will no longer function properly.
7468 *
7469 * Unintended resets have been reported on real time kernels
7470 * where the timer doesn't run on time. Netpoll will also have
7471 * same problem.
7472 *
7473 * The new FWCMD_NICDRV_ALIVE3 command tells the ASF firmware
7474 * to check the ring condition when the heartbeat is expiring
7475 * before doing the reset. This will prevent most unintended
7476 * resets.
7477 */
7478 if (!--tp->asf_counter) {
7479 if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) {
7480 u32 val;
7481
7482 tg3_wait_for_event_ack(tp);
7483
7484 tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX,
7485 FWCMD_NICDRV_ALIVE3);
7486 tg3_write_mem(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 4);
7487 /* 5 seconds timeout */
7488 tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX, 5);
7489 val = tr32(GRC_RX_CPU_EVENT);
7490 val |= GRC_RX_CPU_DRIVER_EVENT;
7491 tw32_f(GRC_RX_CPU_EVENT, val);
7492 }
7493 tp->asf_counter = tp->asf_multiplier;
7494 }
7495
7496 spin_unlock(&tp->lock);
7497
7498 restart_timer:
7499 tp->timer.expires = jiffies + tp->timer_offset;
7500 add_timer(&tp->timer);
7501 }
7502
7503 static int tg3_request_irq(struct tg3 *tp)
7504 {
7505 irq_handler_t fn;
7506 unsigned long flags;
7507 struct net_device *dev = tp->dev;
7508
7509 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
7510 fn = tg3_msi;
7511 if (tp->tg3_flags2 & TG3_FLG2_1SHOT_MSI)
7512 fn = tg3_msi_1shot;
7513 flags = IRQF_SAMPLE_RANDOM;
7514 } else {
7515 fn = tg3_interrupt;
7516 if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS)
7517 fn = tg3_interrupt_tagged;
7518 flags = IRQF_SHARED | IRQF_SAMPLE_RANDOM;
7519 }
7520 return (request_irq(tp->pdev->irq, fn, flags, dev->name, dev));
7521 }
7522
7523 static int tg3_test_interrupt(struct tg3 *tp)
7524 {
7525 struct net_device *dev = tp->dev;
7526 int err, i, intr_ok = 0;
7527
7528 if (!netif_running(dev))
7529 return -ENODEV;
7530
7531 tg3_disable_ints(tp);
7532
7533 free_irq(tp->pdev->irq, dev);
7534
7535 err = request_irq(tp->pdev->irq, tg3_test_isr,
7536 IRQF_SHARED | IRQF_SAMPLE_RANDOM, dev->name, dev);
7537 if (err)
7538 return err;
7539
7540 tp->hw_status->status &= ~SD_STATUS_UPDATED;
7541 tg3_enable_ints(tp);
7542
7543 tw32_f(HOSTCC_MODE, tp->coalesce_mode | HOSTCC_MODE_ENABLE |
7544 HOSTCC_MODE_NOW);
7545
7546 for (i = 0; i < 5; i++) {
7547 u32 int_mbox, misc_host_ctrl;
7548
7549 int_mbox = tr32_mailbox(MAILBOX_INTERRUPT_0 +
7550 TG3_64BIT_REG_LOW);
7551 misc_host_ctrl = tr32(TG3PCI_MISC_HOST_CTRL);
7552
7553 if ((int_mbox != 0) ||
7554 (misc_host_ctrl & MISC_HOST_CTRL_MASK_PCI_INT)) {
7555 intr_ok = 1;
7556 break;
7557 }
7558
7559 msleep(10);
7560 }
7561
7562 tg3_disable_ints(tp);
7563
7564 free_irq(tp->pdev->irq, dev);
7565
7566 err = tg3_request_irq(tp);
7567
7568 if (err)
7569 return err;
7570
7571 if (intr_ok)
7572 return 0;
7573
7574 return -EIO;
7575 }
7576
7577 /* Returns 0 if MSI test succeeds or MSI test fails and INTx mode is
7578 * successfully restored
7579 */
7580 static int tg3_test_msi(struct tg3 *tp)
7581 {
7582 struct net_device *dev = tp->dev;
7583 int err;
7584 u16 pci_cmd;
7585
7586 if (!(tp->tg3_flags2 & TG3_FLG2_USING_MSI))
7587 return 0;
7588
7589 /* Turn off SERR reporting in case MSI terminates with Master
7590 * Abort.
7591 */
7592 pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
7593 pci_write_config_word(tp->pdev, PCI_COMMAND,
7594 pci_cmd & ~PCI_COMMAND_SERR);
7595
7596 err = tg3_test_interrupt(tp);
7597
7598 pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
7599
7600 if (!err)
7601 return 0;
7602
7603 /* other failures */
7604 if (err != -EIO)
7605 return err;
7606
7607 /* MSI test failed, go back to INTx mode */
7608 printk(KERN_WARNING PFX "%s: No interrupt was generated using MSI, "
7609 "switching to INTx mode. Please report this failure to "
7610 "the PCI maintainer and include system chipset information.\n",
7611 tp->dev->name);
7612
7613 free_irq(tp->pdev->irq, dev);
7614 pci_disable_msi(tp->pdev);
7615
7616 tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
7617
7618 err = tg3_request_irq(tp);
7619 if (err)
7620 return err;
7621
7622 /* Need to reset the chip because the MSI cycle may have terminated
7623 * with Master Abort.
7624 */
7625 tg3_full_lock(tp, 1);
7626
7627 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
7628 err = tg3_init_hw(tp, 1);
7629
7630 tg3_full_unlock(tp);
7631
7632 if (err)
7633 free_irq(tp->pdev->irq, dev);
7634
7635 return err;
7636 }
7637
7638 static int tg3_open(struct net_device *dev)
7639 {
7640 struct tg3 *tp = netdev_priv(dev);
7641 int err;
7642
7643 netif_carrier_off(tp->dev);
7644
7645 tg3_full_lock(tp, 0);
7646
7647 err = tg3_set_power_state(tp, PCI_D0);
7648 if (err) {
7649 tg3_full_unlock(tp);
7650 return err;
7651 }
7652
7653 tg3_disable_ints(tp);
7654 tp->tg3_flags &= ~TG3_FLAG_INIT_COMPLETE;
7655
7656 tg3_full_unlock(tp);
7657
7658 /* The placement of this call is tied
7659 * to the setup and use of Host TX descriptors.
7660 */
7661 err = tg3_alloc_consistent(tp);
7662 if (err)
7663 return err;
7664
7665 if (tp->tg3_flags & TG3_FLAG_SUPPORT_MSI) {
7666 /* All MSI supporting chips should support tagged
7667 * status. Assert that this is the case.
7668 */
7669 if (!(tp->tg3_flags & TG3_FLAG_TAGGED_STATUS)) {
7670 printk(KERN_WARNING PFX "%s: MSI without TAGGED? "
7671 "Not using MSI.\n", tp->dev->name);
7672 } else if (pci_enable_msi(tp->pdev) == 0) {
7673 u32 msi_mode;
7674
7675 msi_mode = tr32(MSGINT_MODE);
7676 tw32(MSGINT_MODE, msi_mode | MSGINT_MODE_ENABLE);
7677 tp->tg3_flags2 |= TG3_FLG2_USING_MSI;
7678 }
7679 }
7680 err = tg3_request_irq(tp);
7681
7682 if (err) {
7683 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
7684 pci_disable_msi(tp->pdev);
7685 tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
7686 }
7687 tg3_free_consistent(tp);
7688 return err;
7689 }
7690
7691 napi_enable(&tp->napi);
7692
7693 tg3_full_lock(tp, 0);
7694
7695 err = tg3_init_hw(tp, 1);
7696 if (err) {
7697 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
7698 tg3_free_rings(tp);
7699 } else {
7700 if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS)
7701 tp->timer_offset = HZ;
7702 else
7703 tp->timer_offset = HZ / 10;
7704
7705 BUG_ON(tp->timer_offset > HZ);
7706 tp->timer_counter = tp->timer_multiplier =
7707 (HZ / tp->timer_offset);
7708 tp->asf_counter = tp->asf_multiplier =
7709 ((HZ / tp->timer_offset) * 2);
7710
7711 init_timer(&tp->timer);
7712 tp->timer.expires = jiffies + tp->timer_offset;
7713 tp->timer.data = (unsigned long) tp;
7714 tp->timer.function = tg3_timer;
7715 }
7716
7717 tg3_full_unlock(tp);
7718
7719 if (err) {
7720 napi_disable(&tp->napi);
7721 free_irq(tp->pdev->irq, dev);
7722 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
7723 pci_disable_msi(tp->pdev);
7724 tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
7725 }
7726 tg3_free_consistent(tp);
7727 return err;
7728 }
7729
7730 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
7731 err = tg3_test_msi(tp);
7732
7733 if (err) {
7734 tg3_full_lock(tp, 0);
7735
7736 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
7737 pci_disable_msi(tp->pdev);
7738 tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
7739 }
7740 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
7741 tg3_free_rings(tp);
7742 tg3_free_consistent(tp);
7743
7744 tg3_full_unlock(tp);
7745
7746 napi_disable(&tp->napi);
7747
7748 return err;
7749 }
7750
7751 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
7752 if (tp->tg3_flags2 & TG3_FLG2_1SHOT_MSI) {
7753 u32 val = tr32(PCIE_TRANSACTION_CFG);
7754
7755 tw32(PCIE_TRANSACTION_CFG,
7756 val | PCIE_TRANS_CFG_1SHOT_MSI);
7757 }
7758 }
7759 }
7760
7761 tg3_full_lock(tp, 0);
7762
7763 add_timer(&tp->timer);
7764 tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
7765 tg3_enable_ints(tp);
7766
7767 tg3_full_unlock(tp);
7768
7769 netif_start_queue(dev);
7770
7771 return 0;
7772 }
7773
7774 #if 0
7775 /*static*/ void tg3_dump_state(struct tg3 *tp)
7776 {
7777 u32 val32, val32_2, val32_3, val32_4, val32_5;
7778 u16 val16;
7779 int i;
7780
7781 pci_read_config_word(tp->pdev, PCI_STATUS, &val16);
7782 pci_read_config_dword(tp->pdev, TG3PCI_PCISTATE, &val32);
7783 printk("DEBUG: PCI status [%04x] TG3PCI state[%08x]\n",
7784 val16, val32);
7785
7786 /* MAC block */
7787 printk("DEBUG: MAC_MODE[%08x] MAC_STATUS[%08x]\n",
7788 tr32(MAC_MODE), tr32(MAC_STATUS));
7789 printk(" MAC_EVENT[%08x] MAC_LED_CTRL[%08x]\n",
7790 tr32(MAC_EVENT), tr32(MAC_LED_CTRL));
7791 printk("DEBUG: MAC_TX_MODE[%08x] MAC_TX_STATUS[%08x]\n",
7792 tr32(MAC_TX_MODE), tr32(MAC_TX_STATUS));
7793 printk(" MAC_RX_MODE[%08x] MAC_RX_STATUS[%08x]\n",
7794 tr32(MAC_RX_MODE), tr32(MAC_RX_STATUS));
7795
7796 /* Send data initiator control block */
7797 printk("DEBUG: SNDDATAI_MODE[%08x] SNDDATAI_STATUS[%08x]\n",
7798 tr32(SNDDATAI_MODE), tr32(SNDDATAI_STATUS));
7799 printk(" SNDDATAI_STATSCTRL[%08x]\n",
7800 tr32(SNDDATAI_STATSCTRL));
7801
7802 /* Send data completion control block */
7803 printk("DEBUG: SNDDATAC_MODE[%08x]\n", tr32(SNDDATAC_MODE));
7804
7805 /* Send BD ring selector block */
7806 printk("DEBUG: SNDBDS_MODE[%08x] SNDBDS_STATUS[%08x]\n",
7807 tr32(SNDBDS_MODE), tr32(SNDBDS_STATUS));
7808
7809 /* Send BD initiator control block */
7810 printk("DEBUG: SNDBDI_MODE[%08x] SNDBDI_STATUS[%08x]\n",
7811 tr32(SNDBDI_MODE), tr32(SNDBDI_STATUS));
7812
7813 /* Send BD completion control block */
7814 printk("DEBUG: SNDBDC_MODE[%08x]\n", tr32(SNDBDC_MODE));
7815
7816 /* Receive list placement control block */
7817 printk("DEBUG: RCVLPC_MODE[%08x] RCVLPC_STATUS[%08x]\n",
7818 tr32(RCVLPC_MODE), tr32(RCVLPC_STATUS));
7819 printk(" RCVLPC_STATSCTRL[%08x]\n",
7820 tr32(RCVLPC_STATSCTRL));
7821
7822 /* Receive data and receive BD initiator control block */
7823 printk("DEBUG: RCVDBDI_MODE[%08x] RCVDBDI_STATUS[%08x]\n",
7824 tr32(RCVDBDI_MODE), tr32(RCVDBDI_STATUS));
7825
7826 /* Receive data completion control block */
7827 printk("DEBUG: RCVDCC_MODE[%08x]\n",
7828 tr32(RCVDCC_MODE));
7829
7830 /* Receive BD initiator control block */
7831 printk("DEBUG: RCVBDI_MODE[%08x] RCVBDI_STATUS[%08x]\n",
7832 tr32(RCVBDI_MODE), tr32(RCVBDI_STATUS));
7833
7834 /* Receive BD completion control block */
7835 printk("DEBUG: RCVCC_MODE[%08x] RCVCC_STATUS[%08x]\n",
7836 tr32(RCVCC_MODE), tr32(RCVCC_STATUS));
7837
7838 /* Receive list selector control block */
7839 printk("DEBUG: RCVLSC_MODE[%08x] RCVLSC_STATUS[%08x]\n",
7840 tr32(RCVLSC_MODE), tr32(RCVLSC_STATUS));
7841
7842 /* Mbuf cluster free block */
7843 printk("DEBUG: MBFREE_MODE[%08x] MBFREE_STATUS[%08x]\n",
7844 tr32(MBFREE_MODE), tr32(MBFREE_STATUS));
7845
7846 /* Host coalescing control block */
7847 printk("DEBUG: HOSTCC_MODE[%08x] HOSTCC_STATUS[%08x]\n",
7848 tr32(HOSTCC_MODE), tr32(HOSTCC_STATUS));
7849 printk("DEBUG: HOSTCC_STATS_BLK_HOST_ADDR[%08x%08x]\n",
7850 tr32(HOSTCC_STATS_BLK_HOST_ADDR + TG3_64BIT_REG_HIGH),
7851 tr32(HOSTCC_STATS_BLK_HOST_ADDR + TG3_64BIT_REG_LOW));
7852 printk("DEBUG: HOSTCC_STATUS_BLK_HOST_ADDR[%08x%08x]\n",
7853 tr32(HOSTCC_STATUS_BLK_HOST_ADDR + TG3_64BIT_REG_HIGH),
7854 tr32(HOSTCC_STATUS_BLK_HOST_ADDR + TG3_64BIT_REG_LOW));
7855 printk("DEBUG: HOSTCC_STATS_BLK_NIC_ADDR[%08x]\n",
7856 tr32(HOSTCC_STATS_BLK_NIC_ADDR));
7857 printk("DEBUG: HOSTCC_STATUS_BLK_NIC_ADDR[%08x]\n",
7858 tr32(HOSTCC_STATUS_BLK_NIC_ADDR));
7859
7860 /* Memory arbiter control block */
7861 printk("DEBUG: MEMARB_MODE[%08x] MEMARB_STATUS[%08x]\n",
7862 tr32(MEMARB_MODE), tr32(MEMARB_STATUS));
7863
7864 /* Buffer manager control block */
7865 printk("DEBUG: BUFMGR_MODE[%08x] BUFMGR_STATUS[%08x]\n",
7866 tr32(BUFMGR_MODE), tr32(BUFMGR_STATUS));
7867 printk("DEBUG: BUFMGR_MB_POOL_ADDR[%08x] BUFMGR_MB_POOL_SIZE[%08x]\n",
7868 tr32(BUFMGR_MB_POOL_ADDR), tr32(BUFMGR_MB_POOL_SIZE));
7869 printk("DEBUG: BUFMGR_DMA_DESC_POOL_ADDR[%08x] "
7870 "BUFMGR_DMA_DESC_POOL_SIZE[%08x]\n",
7871 tr32(BUFMGR_DMA_DESC_POOL_ADDR),
7872 tr32(BUFMGR_DMA_DESC_POOL_SIZE));
7873
7874 /* Read DMA control block */
7875 printk("DEBUG: RDMAC_MODE[%08x] RDMAC_STATUS[%08x]\n",
7876 tr32(RDMAC_MODE), tr32(RDMAC_STATUS));
7877
7878 /* Write DMA control block */
7879 printk("DEBUG: WDMAC_MODE[%08x] WDMAC_STATUS[%08x]\n",
7880 tr32(WDMAC_MODE), tr32(WDMAC_STATUS));
7881
7882 /* DMA completion block */
7883 printk("DEBUG: DMAC_MODE[%08x]\n",
7884 tr32(DMAC_MODE));
7885
7886 /* GRC block */
7887 printk("DEBUG: GRC_MODE[%08x] GRC_MISC_CFG[%08x]\n",
7888 tr32(GRC_MODE), tr32(GRC_MISC_CFG));
7889 printk("DEBUG: GRC_LOCAL_CTRL[%08x]\n",
7890 tr32(GRC_LOCAL_CTRL));
7891
7892 /* TG3_BDINFOs */
7893 printk("DEBUG: RCVDBDI_JUMBO_BD[%08x%08x:%08x:%08x]\n",
7894 tr32(RCVDBDI_JUMBO_BD + 0x0),
7895 tr32(RCVDBDI_JUMBO_BD + 0x4),
7896 tr32(RCVDBDI_JUMBO_BD + 0x8),
7897 tr32(RCVDBDI_JUMBO_BD + 0xc));
7898 printk("DEBUG: RCVDBDI_STD_BD[%08x%08x:%08x:%08x]\n",
7899 tr32(RCVDBDI_STD_BD + 0x0),
7900 tr32(RCVDBDI_STD_BD + 0x4),
7901 tr32(RCVDBDI_STD_BD + 0x8),
7902 tr32(RCVDBDI_STD_BD + 0xc));
7903 printk("DEBUG: RCVDBDI_MINI_BD[%08x%08x:%08x:%08x]\n",
7904 tr32(RCVDBDI_MINI_BD + 0x0),
7905 tr32(RCVDBDI_MINI_BD + 0x4),
7906 tr32(RCVDBDI_MINI_BD + 0x8),
7907 tr32(RCVDBDI_MINI_BD + 0xc));
7908
7909 tg3_read_mem(tp, NIC_SRAM_SEND_RCB + 0x0, &val32);
7910 tg3_read_mem(tp, NIC_SRAM_SEND_RCB + 0x4, &val32_2);
7911 tg3_read_mem(tp, NIC_SRAM_SEND_RCB + 0x8, &val32_3);
7912 tg3_read_mem(tp, NIC_SRAM_SEND_RCB + 0xc, &val32_4);
7913 printk("DEBUG: SRAM_SEND_RCB_0[%08x%08x:%08x:%08x]\n",
7914 val32, val32_2, val32_3, val32_4);
7915
7916 tg3_read_mem(tp, NIC_SRAM_RCV_RET_RCB + 0x0, &val32);
7917 tg3_read_mem(tp, NIC_SRAM_RCV_RET_RCB + 0x4, &val32_2);
7918 tg3_read_mem(tp, NIC_SRAM_RCV_RET_RCB + 0x8, &val32_3);
7919 tg3_read_mem(tp, NIC_SRAM_RCV_RET_RCB + 0xc, &val32_4);
7920 printk("DEBUG: SRAM_RCV_RET_RCB_0[%08x%08x:%08x:%08x]\n",
7921 val32, val32_2, val32_3, val32_4);
7922
7923 tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0x0, &val32);
7924 tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0x4, &val32_2);
7925 tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0x8, &val32_3);
7926 tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0xc, &val32_4);
7927 tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0x10, &val32_5);
7928 printk("DEBUG: SRAM_STATUS_BLK[%08x:%08x:%08x:%08x:%08x]\n",
7929 val32, val32_2, val32_3, val32_4, val32_5);
7930
7931 /* SW status block */
7932 printk("DEBUG: Host status block [%08x:%08x:(%04x:%04x:%04x):(%04x:%04x)]\n",
7933 tp->hw_status->status,
7934 tp->hw_status->status_tag,
7935 tp->hw_status->rx_jumbo_consumer,
7936 tp->hw_status->rx_consumer,
7937 tp->hw_status->rx_mini_consumer,
7938 tp->hw_status->idx[0].rx_producer,
7939 tp->hw_status->idx[0].tx_consumer);
7940
7941 /* SW statistics block */
7942 printk("DEBUG: Host statistics block [%08x:%08x:%08x:%08x]\n",
7943 ((u32 *)tp->hw_stats)[0],
7944 ((u32 *)tp->hw_stats)[1],
7945 ((u32 *)tp->hw_stats)[2],
7946 ((u32 *)tp->hw_stats)[3]);
7947
7948 /* Mailboxes */
7949 printk("DEBUG: SNDHOST_PROD[%08x%08x] SNDNIC_PROD[%08x%08x]\n",
7950 tr32_mailbox(MAILBOX_SNDHOST_PROD_IDX_0 + 0x0),
7951 tr32_mailbox(MAILBOX_SNDHOST_PROD_IDX_0 + 0x4),
7952 tr32_mailbox(MAILBOX_SNDNIC_PROD_IDX_0 + 0x0),
7953 tr32_mailbox(MAILBOX_SNDNIC_PROD_IDX_0 + 0x4));
7954
7955 /* NIC side send descriptors. */
7956 for (i = 0; i < 6; i++) {
7957 unsigned long txd;
7958
7959 txd = tp->regs + NIC_SRAM_WIN_BASE + NIC_SRAM_TX_BUFFER_DESC
7960 + (i * sizeof(struct tg3_tx_buffer_desc));
7961 printk("DEBUG: NIC TXD(%d)[%08x:%08x:%08x:%08x]\n",
7962 i,
7963 readl(txd + 0x0), readl(txd + 0x4),
7964 readl(txd + 0x8), readl(txd + 0xc));
7965 }
7966
7967 /* NIC side RX descriptors. */
7968 for (i = 0; i < 6; i++) {
7969 unsigned long rxd;
7970
7971 rxd = tp->regs + NIC_SRAM_WIN_BASE + NIC_SRAM_RX_BUFFER_DESC
7972 + (i * sizeof(struct tg3_rx_buffer_desc));
7973 printk("DEBUG: NIC RXD_STD(%d)[0][%08x:%08x:%08x:%08x]\n",
7974 i,
7975 readl(rxd + 0x0), readl(rxd + 0x4),
7976 readl(rxd + 0x8), readl(rxd + 0xc));
7977 rxd += (4 * sizeof(u32));
7978 printk("DEBUG: NIC RXD_STD(%d)[1][%08x:%08x:%08x:%08x]\n",
7979 i,
7980 readl(rxd + 0x0), readl(rxd + 0x4),
7981 readl(rxd + 0x8), readl(rxd + 0xc));
7982 }
7983
7984 for (i = 0; i < 6; i++) {
7985 unsigned long rxd;
7986
7987 rxd = tp->regs + NIC_SRAM_WIN_BASE + NIC_SRAM_RX_JUMBO_BUFFER_DESC
7988 + (i * sizeof(struct tg3_rx_buffer_desc));
7989 printk("DEBUG: NIC RXD_JUMBO(%d)[0][%08x:%08x:%08x:%08x]\n",
7990 i,
7991 readl(rxd + 0x0), readl(rxd + 0x4),
7992 readl(rxd + 0x8), readl(rxd + 0xc));
7993 rxd += (4 * sizeof(u32));
7994 printk("DEBUG: NIC RXD_JUMBO(%d)[1][%08x:%08x:%08x:%08x]\n",
7995 i,
7996 readl(rxd + 0x0), readl(rxd + 0x4),
7997 readl(rxd + 0x8), readl(rxd + 0xc));
7998 }
7999 }
8000 #endif
8001
8002 static struct net_device_stats *tg3_get_stats(struct net_device *);
8003 static struct tg3_ethtool_stats *tg3_get_estats(struct tg3 *);
8004
8005 static int tg3_close(struct net_device *dev)
8006 {
8007 struct tg3 *tp = netdev_priv(dev);
8008
8009 napi_disable(&tp->napi);
8010 cancel_work_sync(&tp->reset_task);
8011
8012 netif_stop_queue(dev);
8013
8014 del_timer_sync(&tp->timer);
8015
8016 tg3_full_lock(tp, 1);
8017 #if 0
8018 tg3_dump_state(tp);
8019 #endif
8020
8021 tg3_disable_ints(tp);
8022
8023 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
8024 tg3_free_rings(tp);
8025 tp->tg3_flags &= ~TG3_FLAG_INIT_COMPLETE;
8026
8027 tg3_full_unlock(tp);
8028
8029 free_irq(tp->pdev->irq, dev);
8030 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
8031 pci_disable_msi(tp->pdev);
8032 tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
8033 }
8034
8035 memcpy(&tp->net_stats_prev, tg3_get_stats(tp->dev),
8036 sizeof(tp->net_stats_prev));
8037 memcpy(&tp->estats_prev, tg3_get_estats(tp),
8038 sizeof(tp->estats_prev));
8039
8040 tg3_free_consistent(tp);
8041
8042 tg3_set_power_state(tp, PCI_D3hot);
8043
8044 netif_carrier_off(tp->dev);
8045
8046 return 0;
8047 }
8048
8049 static inline unsigned long get_stat64(tg3_stat64_t *val)
8050 {
8051 unsigned long ret;
8052
8053 #if (BITS_PER_LONG == 32)
8054 ret = val->low;
8055 #else
8056 ret = ((u64)val->high << 32) | ((u64)val->low);
8057 #endif
8058 return ret;
8059 }
8060
8061 static unsigned long calc_crc_errors(struct tg3 *tp)
8062 {
8063 struct tg3_hw_stats *hw_stats = tp->hw_stats;
8064
8065 if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) &&
8066 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
8067 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701)) {
8068 u32 val;
8069
8070 spin_lock_bh(&tp->lock);
8071 if (!tg3_readphy(tp, MII_TG3_TEST1, &val)) {
8072 tg3_writephy(tp, MII_TG3_TEST1,
8073 val | MII_TG3_TEST1_CRC_EN);
8074 tg3_readphy(tp, 0x14, &val);
8075 } else
8076 val = 0;
8077 spin_unlock_bh(&tp->lock);
8078
8079 tp->phy_crc_errors += val;
8080
8081 return tp->phy_crc_errors;
8082 }
8083
8084 return get_stat64(&hw_stats->rx_fcs_errors);
8085 }
8086
8087 #define ESTAT_ADD(member) \
8088 estats->member = old_estats->member + \
8089 get_stat64(&hw_stats->member)
8090
8091 static struct tg3_ethtool_stats *tg3_get_estats(struct tg3 *tp)
8092 {
8093 struct tg3_ethtool_stats *estats = &tp->estats;
8094 struct tg3_ethtool_stats *old_estats = &tp->estats_prev;
8095 struct tg3_hw_stats *hw_stats = tp->hw_stats;
8096
8097 if (!hw_stats)
8098 return old_estats;
8099
8100 ESTAT_ADD(rx_octets);
8101 ESTAT_ADD(rx_fragments);
8102 ESTAT_ADD(rx_ucast_packets);
8103 ESTAT_ADD(rx_mcast_packets);
8104 ESTAT_ADD(rx_bcast_packets);
8105 ESTAT_ADD(rx_fcs_errors);
8106 ESTAT_ADD(rx_align_errors);
8107 ESTAT_ADD(rx_xon_pause_rcvd);
8108 ESTAT_ADD(rx_xoff_pause_rcvd);
8109 ESTAT_ADD(rx_mac_ctrl_rcvd);
8110 ESTAT_ADD(rx_xoff_entered);
8111 ESTAT_ADD(rx_frame_too_long_errors);
8112 ESTAT_ADD(rx_jabbers);
8113 ESTAT_ADD(rx_undersize_packets);
8114 ESTAT_ADD(rx_in_length_errors);
8115 ESTAT_ADD(rx_out_length_errors);
8116 ESTAT_ADD(rx_64_or_less_octet_packets);
8117 ESTAT_ADD(rx_65_to_127_octet_packets);
8118 ESTAT_ADD(rx_128_to_255_octet_packets);
8119 ESTAT_ADD(rx_256_to_511_octet_packets);
8120 ESTAT_ADD(rx_512_to_1023_octet_packets);
8121 ESTAT_ADD(rx_1024_to_1522_octet_packets);
8122 ESTAT_ADD(rx_1523_to_2047_octet_packets);
8123 ESTAT_ADD(rx_2048_to_4095_octet_packets);
8124 ESTAT_ADD(rx_4096_to_8191_octet_packets);
8125 ESTAT_ADD(rx_8192_to_9022_octet_packets);
8126
8127 ESTAT_ADD(tx_octets);
8128 ESTAT_ADD(tx_collisions);
8129 ESTAT_ADD(tx_xon_sent);
8130 ESTAT_ADD(tx_xoff_sent);
8131 ESTAT_ADD(tx_flow_control);
8132 ESTAT_ADD(tx_mac_errors);
8133 ESTAT_ADD(tx_single_collisions);
8134 ESTAT_ADD(tx_mult_collisions);
8135 ESTAT_ADD(tx_deferred);
8136 ESTAT_ADD(tx_excessive_collisions);
8137 ESTAT_ADD(tx_late_collisions);
8138 ESTAT_ADD(tx_collide_2times);
8139 ESTAT_ADD(tx_collide_3times);
8140 ESTAT_ADD(tx_collide_4times);
8141 ESTAT_ADD(tx_collide_5times);
8142 ESTAT_ADD(tx_collide_6times);
8143 ESTAT_ADD(tx_collide_7times);
8144 ESTAT_ADD(tx_collide_8times);
8145 ESTAT_ADD(tx_collide_9times);
8146 ESTAT_ADD(tx_collide_10times);
8147 ESTAT_ADD(tx_collide_11times);
8148 ESTAT_ADD(tx_collide_12times);
8149 ESTAT_ADD(tx_collide_13times);
8150 ESTAT_ADD(tx_collide_14times);
8151 ESTAT_ADD(tx_collide_15times);
8152 ESTAT_ADD(tx_ucast_packets);
8153 ESTAT_ADD(tx_mcast_packets);
8154 ESTAT_ADD(tx_bcast_packets);
8155 ESTAT_ADD(tx_carrier_sense_errors);
8156 ESTAT_ADD(tx_discards);
8157 ESTAT_ADD(tx_errors);
8158
8159 ESTAT_ADD(dma_writeq_full);
8160 ESTAT_ADD(dma_write_prioq_full);
8161 ESTAT_ADD(rxbds_empty);
8162 ESTAT_ADD(rx_discards);
8163 ESTAT_ADD(rx_errors);
8164 ESTAT_ADD(rx_threshold_hit);
8165
8166 ESTAT_ADD(dma_readq_full);
8167 ESTAT_ADD(dma_read_prioq_full);
8168 ESTAT_ADD(tx_comp_queue_full);
8169
8170 ESTAT_ADD(ring_set_send_prod_index);
8171 ESTAT_ADD(ring_status_update);
8172 ESTAT_ADD(nic_irqs);
8173 ESTAT_ADD(nic_avoided_irqs);
8174 ESTAT_ADD(nic_tx_threshold_hit);
8175
8176 return estats;
8177 }
8178
8179 static struct net_device_stats *tg3_get_stats(struct net_device *dev)
8180 {
8181 struct tg3 *tp = netdev_priv(dev);
8182 struct net_device_stats *stats = &tp->net_stats;
8183 struct net_device_stats *old_stats = &tp->net_stats_prev;
8184 struct tg3_hw_stats *hw_stats = tp->hw_stats;
8185
8186 if (!hw_stats)
8187 return old_stats;
8188
8189 stats->rx_packets = old_stats->rx_packets +
8190 get_stat64(&hw_stats->rx_ucast_packets) +
8191 get_stat64(&hw_stats->rx_mcast_packets) +
8192 get_stat64(&hw_stats->rx_bcast_packets);
8193
8194 stats->tx_packets = old_stats->tx_packets +
8195 get_stat64(&hw_stats->tx_ucast_packets) +
8196 get_stat64(&hw_stats->tx_mcast_packets) +
8197 get_stat64(&hw_stats->tx_bcast_packets);
8198
8199 stats->rx_bytes = old_stats->rx_bytes +
8200 get_stat64(&hw_stats->rx_octets);
8201 stats->tx_bytes = old_stats->tx_bytes +
8202 get_stat64(&hw_stats->tx_octets);
8203
8204 stats->rx_errors = old_stats->rx_errors +
8205 get_stat64(&hw_stats->rx_errors);
8206 stats->tx_errors = old_stats->tx_errors +
8207 get_stat64(&hw_stats->tx_errors) +
8208 get_stat64(&hw_stats->tx_mac_errors) +
8209 get_stat64(&hw_stats->tx_carrier_sense_errors) +
8210 get_stat64(&hw_stats->tx_discards);
8211
8212 stats->multicast = old_stats->multicast +
8213 get_stat64(&hw_stats->rx_mcast_packets);
8214 stats->collisions = old_stats->collisions +
8215 get_stat64(&hw_stats->tx_collisions);
8216
8217 stats->rx_length_errors = old_stats->rx_length_errors +
8218 get_stat64(&hw_stats->rx_frame_too_long_errors) +
8219 get_stat64(&hw_stats->rx_undersize_packets);
8220
8221 stats->rx_over_errors = old_stats->rx_over_errors +
8222 get_stat64(&hw_stats->rxbds_empty);
8223 stats->rx_frame_errors = old_stats->rx_frame_errors +
8224 get_stat64(&hw_stats->rx_align_errors);
8225 stats->tx_aborted_errors = old_stats->tx_aborted_errors +
8226 get_stat64(&hw_stats->tx_discards);
8227 stats->tx_carrier_errors = old_stats->tx_carrier_errors +
8228 get_stat64(&hw_stats->tx_carrier_sense_errors);
8229
8230 stats->rx_crc_errors = old_stats->rx_crc_errors +
8231 calc_crc_errors(tp);
8232
8233 stats->rx_missed_errors = old_stats->rx_missed_errors +
8234 get_stat64(&hw_stats->rx_discards);
8235
8236 return stats;
8237 }
8238
8239 static inline u32 calc_crc(unsigned char *buf, int len)
8240 {
8241 u32 reg;
8242 u32 tmp;
8243 int j, k;
8244
8245 reg = 0xffffffff;
8246
8247 for (j = 0; j < len; j++) {
8248 reg ^= buf[j];
8249
8250 for (k = 0; k < 8; k++) {
8251 tmp = reg & 0x01;
8252
8253 reg >>= 1;
8254
8255 if (tmp) {
8256 reg ^= 0xedb88320;
8257 }
8258 }
8259 }
8260
8261 return ~reg;
8262 }
8263
8264 static void tg3_set_multi(struct tg3 *tp, unsigned int accept_all)
8265 {
8266 /* accept or reject all multicast frames */
8267 tw32(MAC_HASH_REG_0, accept_all ? 0xffffffff : 0);
8268 tw32(MAC_HASH_REG_1, accept_all ? 0xffffffff : 0);
8269 tw32(MAC_HASH_REG_2, accept_all ? 0xffffffff : 0);
8270 tw32(MAC_HASH_REG_3, accept_all ? 0xffffffff : 0);
8271 }
8272
8273 static void __tg3_set_rx_mode(struct net_device *dev)
8274 {
8275 struct tg3 *tp = netdev_priv(dev);
8276 u32 rx_mode;
8277
8278 rx_mode = tp->rx_mode & ~(RX_MODE_PROMISC |
8279 RX_MODE_KEEP_VLAN_TAG);
8280
8281 /* When ASF is in use, we always keep the RX_MODE_KEEP_VLAN_TAG
8282 * flag clear.
8283 */
8284 #if TG3_VLAN_TAG_USED
8285 if (!tp->vlgrp &&
8286 !(tp->tg3_flags & TG3_FLAG_ENABLE_ASF))
8287 rx_mode |= RX_MODE_KEEP_VLAN_TAG;
8288 #else
8289 /* By definition, VLAN is disabled always in this
8290 * case.
8291 */
8292 if (!(tp->tg3_flags & TG3_FLAG_ENABLE_ASF))
8293 rx_mode |= RX_MODE_KEEP_VLAN_TAG;
8294 #endif
8295
8296 if (dev->flags & IFF_PROMISC) {
8297 /* Promiscuous mode. */
8298 rx_mode |= RX_MODE_PROMISC;
8299 } else if (dev->flags & IFF_ALLMULTI) {
8300 /* Accept all multicast. */
8301 tg3_set_multi (tp, 1);
8302 } else if (dev->mc_count < 1) {
8303 /* Reject all multicast. */
8304 tg3_set_multi (tp, 0);
8305 } else {
8306 /* Accept one or more multicast(s). */
8307 struct dev_mc_list *mclist;
8308 unsigned int i;
8309 u32 mc_filter[4] = { 0, };
8310 u32 regidx;
8311 u32 bit;
8312 u32 crc;
8313
8314 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
8315 i++, mclist = mclist->next) {
8316
8317 crc = calc_crc (mclist->dmi_addr, ETH_ALEN);
8318 bit = ~crc & 0x7f;
8319 regidx = (bit & 0x60) >> 5;
8320 bit &= 0x1f;
8321 mc_filter[regidx] |= (1 << bit);
8322 }
8323
8324 tw32(MAC_HASH_REG_0, mc_filter[0]);
8325 tw32(MAC_HASH_REG_1, mc_filter[1]);
8326 tw32(MAC_HASH_REG_2, mc_filter[2]);
8327 tw32(MAC_HASH_REG_3, mc_filter[3]);
8328 }
8329
8330 if (rx_mode != tp->rx_mode) {
8331 tp->rx_mode = rx_mode;
8332 tw32_f(MAC_RX_MODE, rx_mode);
8333 udelay(10);
8334 }
8335 }
8336
8337 static void tg3_set_rx_mode(struct net_device *dev)
8338 {
8339 struct tg3 *tp = netdev_priv(dev);
8340
8341 if (!netif_running(dev))
8342 return;
8343
8344 tg3_full_lock(tp, 0);
8345 __tg3_set_rx_mode(dev);
8346 tg3_full_unlock(tp);
8347 }
8348
8349 #define TG3_REGDUMP_LEN (32 * 1024)
8350
8351 static int tg3_get_regs_len(struct net_device *dev)
8352 {
8353 return TG3_REGDUMP_LEN;
8354 }
8355
8356 static void tg3_get_regs(struct net_device *dev,
8357 struct ethtool_regs *regs, void *_p)
8358 {
8359 u32 *p = _p;
8360 struct tg3 *tp = netdev_priv(dev);
8361 u8 *orig_p = _p;
8362 int i;
8363
8364 regs->version = 0;
8365
8366 memset(p, 0, TG3_REGDUMP_LEN);
8367
8368 if (tp->link_config.phy_is_low_power)
8369 return;
8370
8371 tg3_full_lock(tp, 0);
8372
8373 #define __GET_REG32(reg) (*(p)++ = tr32(reg))
8374 #define GET_REG32_LOOP(base,len) \
8375 do { p = (u32 *)(orig_p + (base)); \
8376 for (i = 0; i < len; i += 4) \
8377 __GET_REG32((base) + i); \
8378 } while (0)
8379 #define GET_REG32_1(reg) \
8380 do { p = (u32 *)(orig_p + (reg)); \
8381 __GET_REG32((reg)); \
8382 } while (0)
8383
8384 GET_REG32_LOOP(TG3PCI_VENDOR, 0xb0);
8385 GET_REG32_LOOP(MAILBOX_INTERRUPT_0, 0x200);
8386 GET_REG32_LOOP(MAC_MODE, 0x4f0);
8387 GET_REG32_LOOP(SNDDATAI_MODE, 0xe0);
8388 GET_REG32_1(SNDDATAC_MODE);
8389 GET_REG32_LOOP(SNDBDS_MODE, 0x80);
8390 GET_REG32_LOOP(SNDBDI_MODE, 0x48);
8391 GET_REG32_1(SNDBDC_MODE);
8392 GET_REG32_LOOP(RCVLPC_MODE, 0x20);
8393 GET_REG32_LOOP(RCVLPC_SELLST_BASE, 0x15c);
8394 GET_REG32_LOOP(RCVDBDI_MODE, 0x0c);
8395 GET_REG32_LOOP(RCVDBDI_JUMBO_BD, 0x3c);
8396 GET_REG32_LOOP(RCVDBDI_BD_PROD_IDX_0, 0x44);
8397 GET_REG32_1(RCVDCC_MODE);
8398 GET_REG32_LOOP(RCVBDI_MODE, 0x20);
8399 GET_REG32_LOOP(RCVCC_MODE, 0x14);
8400 GET_REG32_LOOP(RCVLSC_MODE, 0x08);
8401 GET_REG32_1(MBFREE_MODE);
8402 GET_REG32_LOOP(HOSTCC_MODE, 0x100);
8403 GET_REG32_LOOP(MEMARB_MODE, 0x10);
8404 GET_REG32_LOOP(BUFMGR_MODE, 0x58);
8405 GET_REG32_LOOP(RDMAC_MODE, 0x08);
8406 GET_REG32_LOOP(WDMAC_MODE, 0x08);
8407 GET_REG32_1(RX_CPU_MODE);
8408 GET_REG32_1(RX_CPU_STATE);
8409 GET_REG32_1(RX_CPU_PGMCTR);
8410 GET_REG32_1(RX_CPU_HWBKPT);
8411 GET_REG32_1(TX_CPU_MODE);
8412 GET_REG32_1(TX_CPU_STATE);
8413 GET_REG32_1(TX_CPU_PGMCTR);
8414 GET_REG32_LOOP(GRCMBOX_INTERRUPT_0, 0x110);
8415 GET_REG32_LOOP(FTQ_RESET, 0x120);
8416 GET_REG32_LOOP(MSGINT_MODE, 0x0c);
8417 GET_REG32_1(DMAC_MODE);
8418 GET_REG32_LOOP(GRC_MODE, 0x4c);
8419 if (tp->tg3_flags & TG3_FLAG_NVRAM)
8420 GET_REG32_LOOP(NVRAM_CMD, 0x24);
8421
8422 #undef __GET_REG32
8423 #undef GET_REG32_LOOP
8424 #undef GET_REG32_1
8425
8426 tg3_full_unlock(tp);
8427 }
8428
8429 static int tg3_get_eeprom_len(struct net_device *dev)
8430 {
8431 struct tg3 *tp = netdev_priv(dev);
8432
8433 return tp->nvram_size;
8434 }
8435
8436 static int tg3_nvram_read(struct tg3 *tp, u32 offset, u32 *val);
8437 static int tg3_nvram_read_le(struct tg3 *tp, u32 offset, __le32 *val);
8438 static int tg3_nvram_read_swab(struct tg3 *tp, u32 offset, u32 *val);
8439
8440 static int tg3_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, u8 *data)
8441 {
8442 struct tg3 *tp = netdev_priv(dev);
8443 int ret;
8444 u8 *pd;
8445 u32 i, offset, len, b_offset, b_count;
8446 __le32 val;
8447
8448 if (tp->link_config.phy_is_low_power)
8449 return -EAGAIN;
8450
8451 offset = eeprom->offset;
8452 len = eeprom->len;
8453 eeprom->len = 0;
8454
8455 eeprom->magic = TG3_EEPROM_MAGIC;
8456
8457 if (offset & 3) {
8458 /* adjustments to start on required 4 byte boundary */
8459 b_offset = offset & 3;
8460 b_count = 4 - b_offset;
8461 if (b_count > len) {
8462 /* i.e. offset=1 len=2 */
8463 b_count = len;
8464 }
8465 ret = tg3_nvram_read_le(tp, offset-b_offset, &val);
8466 if (ret)
8467 return ret;
8468 memcpy(data, ((char*)&val) + b_offset, b_count);
8469 len -= b_count;
8470 offset += b_count;
8471 eeprom->len += b_count;
8472 }
8473
8474 /* read bytes upto the last 4 byte boundary */
8475 pd = &data[eeprom->len];
8476 for (i = 0; i < (len - (len & 3)); i += 4) {
8477 ret = tg3_nvram_read_le(tp, offset + i, &val);
8478 if (ret) {
8479 eeprom->len += i;
8480 return ret;
8481 }
8482 memcpy(pd + i, &val, 4);
8483 }
8484 eeprom->len += i;
8485
8486 if (len & 3) {
8487 /* read last bytes not ending on 4 byte boundary */
8488 pd = &data[eeprom->len];
8489 b_count = len & 3;
8490 b_offset = offset + len - b_count;
8491 ret = tg3_nvram_read_le(tp, b_offset, &val);
8492 if (ret)
8493 return ret;
8494 memcpy(pd, &val, b_count);
8495 eeprom->len += b_count;
8496 }
8497 return 0;
8498 }
8499
8500 static int tg3_nvram_write_block(struct tg3 *tp, u32 offset, u32 len, u8 *buf);
8501
8502 static int tg3_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, u8 *data)
8503 {
8504 struct tg3 *tp = netdev_priv(dev);
8505 int ret;
8506 u32 offset, len, b_offset, odd_len;
8507 u8 *buf;
8508 __le32 start, end;
8509
8510 if (tp->link_config.phy_is_low_power)
8511 return -EAGAIN;
8512
8513 if (eeprom->magic != TG3_EEPROM_MAGIC)
8514 return -EINVAL;
8515
8516 offset = eeprom->offset;
8517 len = eeprom->len;
8518
8519 if ((b_offset = (offset & 3))) {
8520 /* adjustments to start on required 4 byte boundary */
8521 ret = tg3_nvram_read_le(tp, offset-b_offset, &start);
8522 if (ret)
8523 return ret;
8524 len += b_offset;
8525 offset &= ~3;
8526 if (len < 4)
8527 len = 4;
8528 }
8529
8530 odd_len = 0;
8531 if (len & 3) {
8532 /* adjustments to end on required 4 byte boundary */
8533 odd_len = 1;
8534 len = (len + 3) & ~3;
8535 ret = tg3_nvram_read_le(tp, offset+len-4, &end);
8536 if (ret)
8537 return ret;
8538 }
8539
8540 buf = data;
8541 if (b_offset || odd_len) {
8542 buf = kmalloc(len, GFP_KERNEL);
8543 if (!buf)
8544 return -ENOMEM;
8545 if (b_offset)
8546 memcpy(buf, &start, 4);
8547 if (odd_len)
8548 memcpy(buf+len-4, &end, 4);
8549 memcpy(buf + b_offset, data, eeprom->len);
8550 }
8551
8552 ret = tg3_nvram_write_block(tp, offset, len, buf);
8553
8554 if (buf != data)
8555 kfree(buf);
8556
8557 return ret;
8558 }
8559
8560 static int tg3_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
8561 {
8562 struct tg3 *tp = netdev_priv(dev);
8563
8564 cmd->supported = (SUPPORTED_Autoneg);
8565
8566 if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY))
8567 cmd->supported |= (SUPPORTED_1000baseT_Half |
8568 SUPPORTED_1000baseT_Full);
8569
8570 if (!(tp->tg3_flags2 & TG3_FLG2_ANY_SERDES)) {
8571 cmd->supported |= (SUPPORTED_100baseT_Half |
8572 SUPPORTED_100baseT_Full |
8573 SUPPORTED_10baseT_Half |
8574 SUPPORTED_10baseT_Full |
8575 SUPPORTED_TP);
8576 cmd->port = PORT_TP;
8577 } else {
8578 cmd->supported |= SUPPORTED_FIBRE;
8579 cmd->port = PORT_FIBRE;
8580 }
8581
8582 cmd->advertising = tp->link_config.advertising;
8583 if (netif_running(dev)) {
8584 cmd->speed = tp->link_config.active_speed;
8585 cmd->duplex = tp->link_config.active_duplex;
8586 }
8587 cmd->phy_address = PHY_ADDR;
8588 cmd->transceiver = 0;
8589 cmd->autoneg = tp->link_config.autoneg;
8590 cmd->maxtxpkt = 0;
8591 cmd->maxrxpkt = 0;
8592 return 0;
8593 }
8594
8595 static int tg3_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
8596 {
8597 struct tg3 *tp = netdev_priv(dev);
8598
8599 if (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES) {
8600 /* These are the only valid advertisement bits allowed. */
8601 if (cmd->autoneg == AUTONEG_ENABLE &&
8602 (cmd->advertising & ~(ADVERTISED_1000baseT_Half |
8603 ADVERTISED_1000baseT_Full |
8604 ADVERTISED_Autoneg |
8605 ADVERTISED_FIBRE)))
8606 return -EINVAL;
8607 /* Fiber can only do SPEED_1000. */
8608 else if ((cmd->autoneg != AUTONEG_ENABLE) &&
8609 (cmd->speed != SPEED_1000))
8610 return -EINVAL;
8611 /* Copper cannot force SPEED_1000. */
8612 } else if ((cmd->autoneg != AUTONEG_ENABLE) &&
8613 (cmd->speed == SPEED_1000))
8614 return -EINVAL;
8615 else if ((cmd->speed == SPEED_1000) &&
8616 (tp->tg3_flags & TG3_FLAG_10_100_ONLY))
8617 return -EINVAL;
8618
8619 tg3_full_lock(tp, 0);
8620
8621 tp->link_config.autoneg = cmd->autoneg;
8622 if (cmd->autoneg == AUTONEG_ENABLE) {
8623 tp->link_config.advertising = (cmd->advertising |
8624 ADVERTISED_Autoneg);
8625 tp->link_config.speed = SPEED_INVALID;
8626 tp->link_config.duplex = DUPLEX_INVALID;
8627 } else {
8628 tp->link_config.advertising = 0;
8629 tp->link_config.speed = cmd->speed;
8630 tp->link_config.duplex = cmd->duplex;
8631 }
8632
8633 tp->link_config.orig_speed = tp->link_config.speed;
8634 tp->link_config.orig_duplex = tp->link_config.duplex;
8635 tp->link_config.orig_autoneg = tp->link_config.autoneg;
8636
8637 if (netif_running(dev))
8638 tg3_setup_phy(tp, 1);
8639
8640 tg3_full_unlock(tp);
8641
8642 return 0;
8643 }
8644
8645 static void tg3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
8646 {
8647 struct tg3 *tp = netdev_priv(dev);
8648
8649 strcpy(info->driver, DRV_MODULE_NAME);
8650 strcpy(info->version, DRV_MODULE_VERSION);
8651 strcpy(info->fw_version, tp->fw_ver);
8652 strcpy(info->bus_info, pci_name(tp->pdev));
8653 }
8654
8655 static void tg3_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
8656 {
8657 struct tg3 *tp = netdev_priv(dev);
8658
8659 if (tp->tg3_flags & TG3_FLAG_WOL_CAP)
8660 wol->supported = WAKE_MAGIC;
8661 else
8662 wol->supported = 0;
8663 wol->wolopts = 0;
8664 if (tp->tg3_flags & TG3_FLAG_WOL_ENABLE)
8665 wol->wolopts = WAKE_MAGIC;
8666 memset(&wol->sopass, 0, sizeof(wol->sopass));
8667 }
8668
8669 static int tg3_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
8670 {
8671 struct tg3 *tp = netdev_priv(dev);
8672
8673 if (wol->wolopts & ~WAKE_MAGIC)
8674 return -EINVAL;
8675 if ((wol->wolopts & WAKE_MAGIC) &&
8676 !(tp->tg3_flags & TG3_FLAG_WOL_CAP))
8677 return -EINVAL;
8678
8679 spin_lock_bh(&tp->lock);
8680 if (wol->wolopts & WAKE_MAGIC)
8681 tp->tg3_flags |= TG3_FLAG_WOL_ENABLE;
8682 else
8683 tp->tg3_flags &= ~TG3_FLAG_WOL_ENABLE;
8684 spin_unlock_bh(&tp->lock);
8685
8686 return 0;
8687 }
8688
8689 static u32 tg3_get_msglevel(struct net_device *dev)
8690 {
8691 struct tg3 *tp = netdev_priv(dev);
8692 return tp->msg_enable;
8693 }
8694
8695 static void tg3_set_msglevel(struct net_device *dev, u32 value)
8696 {
8697 struct tg3 *tp = netdev_priv(dev);
8698 tp->msg_enable = value;
8699 }
8700
8701 static int tg3_set_tso(struct net_device *dev, u32 value)
8702 {
8703 struct tg3 *tp = netdev_priv(dev);
8704
8705 if (!(tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE)) {
8706 if (value)
8707 return -EINVAL;
8708 return 0;
8709 }
8710 if ((tp->tg3_flags2 & TG3_FLG2_HW_TSO_2) &&
8711 (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5906)) {
8712 if (value) {
8713 dev->features |= NETIF_F_TSO6;
8714 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761)
8715 dev->features |= NETIF_F_TSO_ECN;
8716 } else
8717 dev->features &= ~(NETIF_F_TSO6 | NETIF_F_TSO_ECN);
8718 }
8719 return ethtool_op_set_tso(dev, value);
8720 }
8721
8722 static int tg3_nway_reset(struct net_device *dev)
8723 {
8724 struct tg3 *tp = netdev_priv(dev);
8725 u32 bmcr;
8726 int r;
8727
8728 if (!netif_running(dev))
8729 return -EAGAIN;
8730
8731 if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
8732 return -EINVAL;
8733
8734 spin_lock_bh(&tp->lock);
8735 r = -EINVAL;
8736 tg3_readphy(tp, MII_BMCR, &bmcr);
8737 if (!tg3_readphy(tp, MII_BMCR, &bmcr) &&
8738 ((bmcr & BMCR_ANENABLE) ||
8739 (tp->tg3_flags2 & TG3_FLG2_PARALLEL_DETECT))) {
8740 tg3_writephy(tp, MII_BMCR, bmcr | BMCR_ANRESTART |
8741 BMCR_ANENABLE);
8742 r = 0;
8743 }
8744 spin_unlock_bh(&tp->lock);
8745
8746 return r;
8747 }
8748
8749 static void tg3_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
8750 {
8751 struct tg3 *tp = netdev_priv(dev);
8752
8753 ering->rx_max_pending = TG3_RX_RING_SIZE - 1;
8754 ering->rx_mini_max_pending = 0;
8755 if (tp->tg3_flags & TG3_FLAG_JUMBO_RING_ENABLE)
8756 ering->rx_jumbo_max_pending = TG3_RX_JUMBO_RING_SIZE - 1;
8757 else
8758 ering->rx_jumbo_max_pending = 0;
8759
8760 ering->tx_max_pending = TG3_TX_RING_SIZE - 1;
8761
8762 ering->rx_pending = tp->rx_pending;
8763 ering->rx_mini_pending = 0;
8764 if (tp->tg3_flags & TG3_FLAG_JUMBO_RING_ENABLE)
8765 ering->rx_jumbo_pending = tp->rx_jumbo_pending;
8766 else
8767 ering->rx_jumbo_pending = 0;
8768
8769 ering->tx_pending = tp->tx_pending;
8770 }
8771
8772 static int tg3_set_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
8773 {
8774 struct tg3 *tp = netdev_priv(dev);
8775 int irq_sync = 0, err = 0;
8776
8777 if ((ering->rx_pending > TG3_RX_RING_SIZE - 1) ||
8778 (ering->rx_jumbo_pending > TG3_RX_JUMBO_RING_SIZE - 1) ||
8779 (ering->tx_pending > TG3_TX_RING_SIZE - 1) ||
8780 (ering->tx_pending <= MAX_SKB_FRAGS) ||
8781 ((tp->tg3_flags2 & TG3_FLG2_TSO_BUG) &&
8782 (ering->tx_pending <= (MAX_SKB_FRAGS * 3))))
8783 return -EINVAL;
8784
8785 if (netif_running(dev)) {
8786 tg3_netif_stop(tp);
8787 irq_sync = 1;
8788 }
8789
8790 tg3_full_lock(tp, irq_sync);
8791
8792 tp->rx_pending = ering->rx_pending;
8793
8794 if ((tp->tg3_flags2 & TG3_FLG2_MAX_RXPEND_64) &&
8795 tp->rx_pending > 63)
8796 tp->rx_pending = 63;
8797 tp->rx_jumbo_pending = ering->rx_jumbo_pending;
8798 tp->tx_pending = ering->tx_pending;
8799
8800 if (netif_running(dev)) {
8801 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
8802 err = tg3_restart_hw(tp, 1);
8803 if (!err)
8804 tg3_netif_start(tp);
8805 }
8806
8807 tg3_full_unlock(tp);
8808
8809 return err;
8810 }
8811
8812 static void tg3_get_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
8813 {
8814 struct tg3 *tp = netdev_priv(dev);
8815
8816 epause->autoneg = (tp->tg3_flags & TG3_FLAG_PAUSE_AUTONEG) != 0;
8817
8818 if (tp->link_config.active_flowctrl & TG3_FLOW_CTRL_RX)
8819 epause->rx_pause = 1;
8820 else
8821 epause->rx_pause = 0;
8822
8823 if (tp->link_config.active_flowctrl & TG3_FLOW_CTRL_TX)
8824 epause->tx_pause = 1;
8825 else
8826 epause->tx_pause = 0;
8827 }
8828
8829 static int tg3_set_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
8830 {
8831 struct tg3 *tp = netdev_priv(dev);
8832 int irq_sync = 0, err = 0;
8833
8834 if (netif_running(dev)) {
8835 tg3_netif_stop(tp);
8836 irq_sync = 1;
8837 }
8838
8839 tg3_full_lock(tp, irq_sync);
8840
8841 if (epause->autoneg)
8842 tp->tg3_flags |= TG3_FLAG_PAUSE_AUTONEG;
8843 else
8844 tp->tg3_flags &= ~TG3_FLAG_PAUSE_AUTONEG;
8845 if (epause->rx_pause)
8846 tp->link_config.flowctrl |= TG3_FLOW_CTRL_RX;
8847 else
8848 tp->link_config.flowctrl &= ~TG3_FLOW_CTRL_RX;
8849 if (epause->tx_pause)
8850 tp->link_config.flowctrl |= TG3_FLOW_CTRL_TX;
8851 else
8852 tp->link_config.flowctrl &= ~TG3_FLOW_CTRL_TX;
8853
8854 if (netif_running(dev)) {
8855 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
8856 err = tg3_restart_hw(tp, 1);
8857 if (!err)
8858 tg3_netif_start(tp);
8859 }
8860
8861 tg3_full_unlock(tp);
8862
8863 return err;
8864 }
8865
8866 static u32 tg3_get_rx_csum(struct net_device *dev)
8867 {
8868 struct tg3 *tp = netdev_priv(dev);
8869 return (tp->tg3_flags & TG3_FLAG_RX_CHECKSUMS) != 0;
8870 }
8871
8872 static int tg3_set_rx_csum(struct net_device *dev, u32 data)
8873 {
8874 struct tg3 *tp = netdev_priv(dev);
8875
8876 if (tp->tg3_flags & TG3_FLAG_BROKEN_CHECKSUMS) {
8877 if (data != 0)
8878 return -EINVAL;
8879 return 0;
8880 }
8881
8882 spin_lock_bh(&tp->lock);
8883 if (data)
8884 tp->tg3_flags |= TG3_FLAG_RX_CHECKSUMS;
8885 else
8886 tp->tg3_flags &= ~TG3_FLAG_RX_CHECKSUMS;
8887 spin_unlock_bh(&tp->lock);
8888
8889 return 0;
8890 }
8891
8892 static int tg3_set_tx_csum(struct net_device *dev, u32 data)
8893 {
8894 struct tg3 *tp = netdev_priv(dev);
8895
8896 if (tp->tg3_flags & TG3_FLAG_BROKEN_CHECKSUMS) {
8897 if (data != 0)
8898 return -EINVAL;
8899 return 0;
8900 }
8901
8902 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
8903 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
8904 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
8905 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761)
8906 ethtool_op_set_tx_ipv6_csum(dev, data);
8907 else
8908 ethtool_op_set_tx_csum(dev, data);
8909
8910 return 0;
8911 }
8912
8913 static int tg3_get_sset_count (struct net_device *dev, int sset)
8914 {
8915 switch (sset) {
8916 case ETH_SS_TEST:
8917 return TG3_NUM_TEST;
8918 case ETH_SS_STATS:
8919 return TG3_NUM_STATS;
8920 default:
8921 return -EOPNOTSUPP;
8922 }
8923 }
8924
8925 static void tg3_get_strings (struct net_device *dev, u32 stringset, u8 *buf)
8926 {
8927 switch (stringset) {
8928 case ETH_SS_STATS:
8929 memcpy(buf, &ethtool_stats_keys, sizeof(ethtool_stats_keys));
8930 break;
8931 case ETH_SS_TEST:
8932 memcpy(buf, &ethtool_test_keys, sizeof(ethtool_test_keys));
8933 break;
8934 default:
8935 WARN_ON(1); /* we need a WARN() */
8936 break;
8937 }
8938 }
8939
8940 static int tg3_phys_id(struct net_device *dev, u32 data)
8941 {
8942 struct tg3 *tp = netdev_priv(dev);
8943 int i;
8944
8945 if (!netif_running(tp->dev))
8946 return -EAGAIN;
8947
8948 if (data == 0)
8949 data = UINT_MAX / 2;
8950
8951 for (i = 0; i < (data * 2); i++) {
8952 if ((i % 2) == 0)
8953 tw32(MAC_LED_CTRL, LED_CTRL_LNKLED_OVERRIDE |
8954 LED_CTRL_1000MBPS_ON |
8955 LED_CTRL_100MBPS_ON |
8956 LED_CTRL_10MBPS_ON |
8957 LED_CTRL_TRAFFIC_OVERRIDE |
8958 LED_CTRL_TRAFFIC_BLINK |
8959 LED_CTRL_TRAFFIC_LED);
8960
8961 else
8962 tw32(MAC_LED_CTRL, LED_CTRL_LNKLED_OVERRIDE |
8963 LED_CTRL_TRAFFIC_OVERRIDE);
8964
8965 if (msleep_interruptible(500))
8966 break;
8967 }
8968 tw32(MAC_LED_CTRL, tp->led_ctrl);
8969 return 0;
8970 }
8971
8972 static void tg3_get_ethtool_stats (struct net_device *dev,
8973 struct ethtool_stats *estats, u64 *tmp_stats)
8974 {
8975 struct tg3 *tp = netdev_priv(dev);
8976 memcpy(tmp_stats, tg3_get_estats(tp), sizeof(tp->estats));
8977 }
8978
8979 #define NVRAM_TEST_SIZE 0x100
8980 #define NVRAM_SELFBOOT_FORMAT1_0_SIZE 0x14
8981 #define NVRAM_SELFBOOT_FORMAT1_2_SIZE 0x18
8982 #define NVRAM_SELFBOOT_FORMAT1_3_SIZE 0x1c
8983 #define NVRAM_SELFBOOT_HW_SIZE 0x20
8984 #define NVRAM_SELFBOOT_DATA_SIZE 0x1c
8985
8986 static int tg3_test_nvram(struct tg3 *tp)
8987 {
8988 u32 csum, magic;
8989 __le32 *buf;
8990 int i, j, k, err = 0, size;
8991
8992 if (tg3_nvram_read_swab(tp, 0, &magic) != 0)
8993 return -EIO;
8994
8995 if (magic == TG3_EEPROM_MAGIC)
8996 size = NVRAM_TEST_SIZE;
8997 else if ((magic & TG3_EEPROM_MAGIC_FW_MSK) == TG3_EEPROM_MAGIC_FW) {
8998 if ((magic & TG3_EEPROM_SB_FORMAT_MASK) ==
8999 TG3_EEPROM_SB_FORMAT_1) {
9000 switch (magic & TG3_EEPROM_SB_REVISION_MASK) {
9001 case TG3_EEPROM_SB_REVISION_0:
9002 size = NVRAM_SELFBOOT_FORMAT1_0_SIZE;
9003 break;
9004 case TG3_EEPROM_SB_REVISION_2:
9005 size = NVRAM_SELFBOOT_FORMAT1_2_SIZE;
9006 break;
9007 case TG3_EEPROM_SB_REVISION_3:
9008 size = NVRAM_SELFBOOT_FORMAT1_3_SIZE;
9009 break;
9010 default:
9011 return 0;
9012 }
9013 } else
9014 return 0;
9015 } else if ((magic & TG3_EEPROM_MAGIC_HW_MSK) == TG3_EEPROM_MAGIC_HW)
9016 size = NVRAM_SELFBOOT_HW_SIZE;
9017 else
9018 return -EIO;
9019
9020 buf = kmalloc(size, GFP_KERNEL);
9021 if (buf == NULL)
9022 return -ENOMEM;
9023
9024 err = -EIO;
9025 for (i = 0, j = 0; i < size; i += 4, j++) {
9026 if ((err = tg3_nvram_read_le(tp, i, &buf[j])) != 0)
9027 break;
9028 }
9029 if (i < size)
9030 goto out;
9031
9032 /* Selfboot format */
9033 magic = swab32(le32_to_cpu(buf[0]));
9034 if ((magic & TG3_EEPROM_MAGIC_FW_MSK) ==
9035 TG3_EEPROM_MAGIC_FW) {
9036 u8 *buf8 = (u8 *) buf, csum8 = 0;
9037
9038 if ((magic & TG3_EEPROM_SB_REVISION_MASK) ==
9039 TG3_EEPROM_SB_REVISION_2) {
9040 /* For rev 2, the csum doesn't include the MBA. */
9041 for (i = 0; i < TG3_EEPROM_SB_F1R2_MBA_OFF; i++)
9042 csum8 += buf8[i];
9043 for (i = TG3_EEPROM_SB_F1R2_MBA_OFF + 4; i < size; i++)
9044 csum8 += buf8[i];
9045 } else {
9046 for (i = 0; i < size; i++)
9047 csum8 += buf8[i];
9048 }
9049
9050 if (csum8 == 0) {
9051 err = 0;
9052 goto out;
9053 }
9054
9055 err = -EIO;
9056 goto out;
9057 }
9058
9059 if ((magic & TG3_EEPROM_MAGIC_HW_MSK) ==
9060 TG3_EEPROM_MAGIC_HW) {
9061 u8 data[NVRAM_SELFBOOT_DATA_SIZE];
9062 u8 parity[NVRAM_SELFBOOT_DATA_SIZE];
9063 u8 *buf8 = (u8 *) buf;
9064
9065 /* Separate the parity bits and the data bytes. */
9066 for (i = 0, j = 0, k = 0; i < NVRAM_SELFBOOT_HW_SIZE; i++) {
9067 if ((i == 0) || (i == 8)) {
9068 int l;
9069 u8 msk;
9070
9071 for (l = 0, msk = 0x80; l < 7; l++, msk >>= 1)
9072 parity[k++] = buf8[i] & msk;
9073 i++;
9074 }
9075 else if (i == 16) {
9076 int l;
9077 u8 msk;
9078
9079 for (l = 0, msk = 0x20; l < 6; l++, msk >>= 1)
9080 parity[k++] = buf8[i] & msk;
9081 i++;
9082
9083 for (l = 0, msk = 0x80; l < 8; l++, msk >>= 1)
9084 parity[k++] = buf8[i] & msk;
9085 i++;
9086 }
9087 data[j++] = buf8[i];
9088 }
9089
9090 err = -EIO;
9091 for (i = 0; i < NVRAM_SELFBOOT_DATA_SIZE; i++) {
9092 u8 hw8 = hweight8(data[i]);
9093
9094 if ((hw8 & 0x1) && parity[i])
9095 goto out;
9096 else if (!(hw8 & 0x1) && !parity[i])
9097 goto out;
9098 }
9099 err = 0;
9100 goto out;
9101 }
9102
9103 /* Bootstrap checksum at offset 0x10 */
9104 csum = calc_crc((unsigned char *) buf, 0x10);
9105 if(csum != le32_to_cpu(buf[0x10/4]))
9106 goto out;
9107
9108 /* Manufacturing block starts at offset 0x74, checksum at 0xfc */
9109 csum = calc_crc((unsigned char *) &buf[0x74/4], 0x88);
9110 if (csum != le32_to_cpu(buf[0xfc/4]))
9111 goto out;
9112
9113 err = 0;
9114
9115 out:
9116 kfree(buf);
9117 return err;
9118 }
9119
9120 #define TG3_SERDES_TIMEOUT_SEC 2
9121 #define TG3_COPPER_TIMEOUT_SEC 6
9122
9123 static int tg3_test_link(struct tg3 *tp)
9124 {
9125 int i, max;
9126
9127 if (!netif_running(tp->dev))
9128 return -ENODEV;
9129
9130 if (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES)
9131 max = TG3_SERDES_TIMEOUT_SEC;
9132 else
9133 max = TG3_COPPER_TIMEOUT_SEC;
9134
9135 for (i = 0; i < max; i++) {
9136 if (netif_carrier_ok(tp->dev))
9137 return 0;
9138
9139 if (msleep_interruptible(1000))
9140 break;
9141 }
9142
9143 return -EIO;
9144 }
9145
9146 /* Only test the commonly used registers */
9147 static int tg3_test_registers(struct tg3 *tp)
9148 {
9149 int i, is_5705, is_5750;
9150 u32 offset, read_mask, write_mask, val, save_val, read_val;
9151 static struct {
9152 u16 offset;
9153 u16 flags;
9154 #define TG3_FL_5705 0x1
9155 #define TG3_FL_NOT_5705 0x2
9156 #define TG3_FL_NOT_5788 0x4
9157 #define TG3_FL_NOT_5750 0x8
9158 u32 read_mask;
9159 u32 write_mask;
9160 } reg_tbl[] = {
9161 /* MAC Control Registers */
9162 { MAC_MODE, TG3_FL_NOT_5705,
9163 0x00000000, 0x00ef6f8c },
9164 { MAC_MODE, TG3_FL_5705,
9165 0x00000000, 0x01ef6b8c },
9166 { MAC_STATUS, TG3_FL_NOT_5705,
9167 0x03800107, 0x00000000 },
9168 { MAC_STATUS, TG3_FL_5705,
9169 0x03800100, 0x00000000 },
9170 { MAC_ADDR_0_HIGH, 0x0000,
9171 0x00000000, 0x0000ffff },
9172 { MAC_ADDR_0_LOW, 0x0000,
9173 0x00000000, 0xffffffff },
9174 { MAC_RX_MTU_SIZE, 0x0000,
9175 0x00000000, 0x0000ffff },
9176 { MAC_TX_MODE, 0x0000,
9177 0x00000000, 0x00000070 },
9178 { MAC_TX_LENGTHS, 0x0000,
9179 0x00000000, 0x00003fff },
9180 { MAC_RX_MODE, TG3_FL_NOT_5705,
9181 0x00000000, 0x000007fc },
9182 { MAC_RX_MODE, TG3_FL_5705,
9183 0x00000000, 0x000007dc },
9184 { MAC_HASH_REG_0, 0x0000,
9185 0x00000000, 0xffffffff },
9186 { MAC_HASH_REG_1, 0x0000,
9187 0x00000000, 0xffffffff },
9188 { MAC_HASH_REG_2, 0x0000,
9189 0x00000000, 0xffffffff },
9190 { MAC_HASH_REG_3, 0x0000,
9191 0x00000000, 0xffffffff },
9192
9193 /* Receive Data and Receive BD Initiator Control Registers. */
9194 { RCVDBDI_JUMBO_BD+0, TG3_FL_NOT_5705,
9195 0x00000000, 0xffffffff },
9196 { RCVDBDI_JUMBO_BD+4, TG3_FL_NOT_5705,
9197 0x00000000, 0xffffffff },
9198 { RCVDBDI_JUMBO_BD+8, TG3_FL_NOT_5705,
9199 0x00000000, 0x00000003 },
9200 { RCVDBDI_JUMBO_BD+0xc, TG3_FL_NOT_5705,
9201 0x00000000, 0xffffffff },
9202 { RCVDBDI_STD_BD+0, 0x0000,
9203 0x00000000, 0xffffffff },
9204 { RCVDBDI_STD_BD+4, 0x0000,
9205 0x00000000, 0xffffffff },
9206 { RCVDBDI_STD_BD+8, 0x0000,
9207 0x00000000, 0xffff0002 },
9208 { RCVDBDI_STD_BD+0xc, 0x0000,
9209 0x00000000, 0xffffffff },
9210
9211 /* Receive BD Initiator Control Registers. */
9212 { RCVBDI_STD_THRESH, TG3_FL_NOT_5705,
9213 0x00000000, 0xffffffff },
9214 { RCVBDI_STD_THRESH, TG3_FL_5705,
9215 0x00000000, 0x000003ff },
9216 { RCVBDI_JUMBO_THRESH, TG3_FL_NOT_5705,
9217 0x00000000, 0xffffffff },
9218
9219 /* Host Coalescing Control Registers. */
9220 { HOSTCC_MODE, TG3_FL_NOT_5705,
9221 0x00000000, 0x00000004 },
9222 { HOSTCC_MODE, TG3_FL_5705,
9223 0x00000000, 0x000000f6 },
9224 { HOSTCC_RXCOL_TICKS, TG3_FL_NOT_5705,
9225 0x00000000, 0xffffffff },
9226 { HOSTCC_RXCOL_TICKS, TG3_FL_5705,
9227 0x00000000, 0x000003ff },
9228 { HOSTCC_TXCOL_TICKS, TG3_FL_NOT_5705,
9229 0x00000000, 0xffffffff },
9230 { HOSTCC_TXCOL_TICKS, TG3_FL_5705,
9231 0x00000000, 0x000003ff },
9232 { HOSTCC_RXMAX_FRAMES, TG3_FL_NOT_5705,
9233 0x00000000, 0xffffffff },
9234 { HOSTCC_RXMAX_FRAMES, TG3_FL_5705 | TG3_FL_NOT_5788,
9235 0x00000000, 0x000000ff },
9236 { HOSTCC_TXMAX_FRAMES, TG3_FL_NOT_5705,
9237 0x00000000, 0xffffffff },
9238 { HOSTCC_TXMAX_FRAMES, TG3_FL_5705 | TG3_FL_NOT_5788,
9239 0x00000000, 0x000000ff },
9240 { HOSTCC_RXCOAL_TICK_INT, TG3_FL_NOT_5705,
9241 0x00000000, 0xffffffff },
9242 { HOSTCC_TXCOAL_TICK_INT, TG3_FL_NOT_5705,
9243 0x00000000, 0xffffffff },
9244 { HOSTCC_RXCOAL_MAXF_INT, TG3_FL_NOT_5705,
9245 0x00000000, 0xffffffff },
9246 { HOSTCC_RXCOAL_MAXF_INT, TG3_FL_5705 | TG3_FL_NOT_5788,
9247 0x00000000, 0x000000ff },
9248 { HOSTCC_TXCOAL_MAXF_INT, TG3_FL_NOT_5705,
9249 0x00000000, 0xffffffff },
9250 { HOSTCC_TXCOAL_MAXF_INT, TG3_FL_5705 | TG3_FL_NOT_5788,
9251 0x00000000, 0x000000ff },
9252 { HOSTCC_STAT_COAL_TICKS, TG3_FL_NOT_5705,
9253 0x00000000, 0xffffffff },
9254 { HOSTCC_STATS_BLK_HOST_ADDR, TG3_FL_NOT_5705,
9255 0x00000000, 0xffffffff },
9256 { HOSTCC_STATS_BLK_HOST_ADDR+4, TG3_FL_NOT_5705,
9257 0x00000000, 0xffffffff },
9258 { HOSTCC_STATUS_BLK_HOST_ADDR, 0x0000,
9259 0x00000000, 0xffffffff },
9260 { HOSTCC_STATUS_BLK_HOST_ADDR+4, 0x0000,
9261 0x00000000, 0xffffffff },
9262 { HOSTCC_STATS_BLK_NIC_ADDR, 0x0000,
9263 0xffffffff, 0x00000000 },
9264 { HOSTCC_STATUS_BLK_NIC_ADDR, 0x0000,
9265 0xffffffff, 0x00000000 },
9266
9267 /* Buffer Manager Control Registers. */
9268 { BUFMGR_MB_POOL_ADDR, TG3_FL_NOT_5750,
9269 0x00000000, 0x007fff80 },
9270 { BUFMGR_MB_POOL_SIZE, TG3_FL_NOT_5750,
9271 0x00000000, 0x007fffff },
9272 { BUFMGR_MB_RDMA_LOW_WATER, 0x0000,
9273 0x00000000, 0x0000003f },
9274 { BUFMGR_MB_MACRX_LOW_WATER, 0x0000,
9275 0x00000000, 0x000001ff },
9276 { BUFMGR_MB_HIGH_WATER, 0x0000,
9277 0x00000000, 0x000001ff },
9278 { BUFMGR_DMA_DESC_POOL_ADDR, TG3_FL_NOT_5705,
9279 0xffffffff, 0x00000000 },
9280 { BUFMGR_DMA_DESC_POOL_SIZE, TG3_FL_NOT_5705,
9281 0xffffffff, 0x00000000 },
9282
9283 /* Mailbox Registers */
9284 { GRCMBOX_RCVSTD_PROD_IDX+4, 0x0000,
9285 0x00000000, 0x000001ff },
9286 { GRCMBOX_RCVJUMBO_PROD_IDX+4, TG3_FL_NOT_5705,
9287 0x00000000, 0x000001ff },
9288 { GRCMBOX_RCVRET_CON_IDX_0+4, 0x0000,
9289 0x00000000, 0x000007ff },
9290 { GRCMBOX_SNDHOST_PROD_IDX_0+4, 0x0000,
9291 0x00000000, 0x000001ff },
9292
9293 { 0xffff, 0x0000, 0x00000000, 0x00000000 },
9294 };
9295
9296 is_5705 = is_5750 = 0;
9297 if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
9298 is_5705 = 1;
9299 if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
9300 is_5750 = 1;
9301 }
9302
9303 for (i = 0; reg_tbl[i].offset != 0xffff; i++) {
9304 if (is_5705 && (reg_tbl[i].flags & TG3_FL_NOT_5705))
9305 continue;
9306
9307 if (!is_5705 && (reg_tbl[i].flags & TG3_FL_5705))
9308 continue;
9309
9310 if ((tp->tg3_flags2 & TG3_FLG2_IS_5788) &&
9311 (reg_tbl[i].flags & TG3_FL_NOT_5788))
9312 continue;
9313
9314 if (is_5750 && (reg_tbl[i].flags & TG3_FL_NOT_5750))
9315 continue;
9316
9317 offset = (u32) reg_tbl[i].offset;
9318 read_mask = reg_tbl[i].read_mask;
9319 write_mask = reg_tbl[i].write_mask;
9320
9321 /* Save the original register content */
9322 save_val = tr32(offset);
9323
9324 /* Determine the read-only value. */
9325 read_val = save_val & read_mask;
9326
9327 /* Write zero to the register, then make sure the read-only bits
9328 * are not changed and the read/write bits are all zeros.
9329 */
9330 tw32(offset, 0);
9331
9332 val = tr32(offset);
9333
9334 /* Test the read-only and read/write bits. */
9335 if (((val & read_mask) != read_val) || (val & write_mask))
9336 goto out;
9337
9338 /* Write ones to all the bits defined by RdMask and WrMask, then
9339 * make sure the read-only bits are not changed and the
9340 * read/write bits are all ones.
9341 */
9342 tw32(offset, read_mask | write_mask);
9343
9344 val = tr32(offset);
9345
9346 /* Test the read-only bits. */
9347 if ((val & read_mask) != read_val)
9348 goto out;
9349
9350 /* Test the read/write bits. */
9351 if ((val & write_mask) != write_mask)
9352 goto out;
9353
9354 tw32(offset, save_val);
9355 }
9356
9357 return 0;
9358
9359 out:
9360 if (netif_msg_hw(tp))
9361 printk(KERN_ERR PFX "Register test failed at offset %x\n",
9362 offset);
9363 tw32(offset, save_val);
9364 return -EIO;
9365 }
9366
9367 static int tg3_do_mem_test(struct tg3 *tp, u32 offset, u32 len)
9368 {
9369 static const u32 test_pattern[] = { 0x00000000, 0xffffffff, 0xaa55a55a };
9370 int i;
9371 u32 j;
9372
9373 for (i = 0; i < ARRAY_SIZE(test_pattern); i++) {
9374 for (j = 0; j < len; j += 4) {
9375 u32 val;
9376
9377 tg3_write_mem(tp, offset + j, test_pattern[i]);
9378 tg3_read_mem(tp, offset + j, &val);
9379 if (val != test_pattern[i])
9380 return -EIO;
9381 }
9382 }
9383 return 0;
9384 }
9385
9386 static int tg3_test_memory(struct tg3 *tp)
9387 {
9388 static struct mem_entry {
9389 u32 offset;
9390 u32 len;
9391 } mem_tbl_570x[] = {
9392 { 0x00000000, 0x00b50},
9393 { 0x00002000, 0x1c000},
9394 { 0xffffffff, 0x00000}
9395 }, mem_tbl_5705[] = {
9396 { 0x00000100, 0x0000c},
9397 { 0x00000200, 0x00008},
9398 { 0x00004000, 0x00800},
9399 { 0x00006000, 0x01000},
9400 { 0x00008000, 0x02000},
9401 { 0x00010000, 0x0e000},
9402 { 0xffffffff, 0x00000}
9403 }, mem_tbl_5755[] = {
9404 { 0x00000200, 0x00008},
9405 { 0x00004000, 0x00800},
9406 { 0x00006000, 0x00800},
9407 { 0x00008000, 0x02000},
9408 { 0x00010000, 0x0c000},
9409 { 0xffffffff, 0x00000}
9410 }, mem_tbl_5906[] = {
9411 { 0x00000200, 0x00008},
9412 { 0x00004000, 0x00400},
9413 { 0x00006000, 0x00400},
9414 { 0x00008000, 0x01000},
9415 { 0x00010000, 0x01000},
9416 { 0xffffffff, 0x00000}
9417 };
9418 struct mem_entry *mem_tbl;
9419 int err = 0;
9420 int i;
9421
9422 if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
9423 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
9424 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
9425 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
9426 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761)
9427 mem_tbl = mem_tbl_5755;
9428 else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
9429 mem_tbl = mem_tbl_5906;
9430 else
9431 mem_tbl = mem_tbl_5705;
9432 } else
9433 mem_tbl = mem_tbl_570x;
9434
9435 for (i = 0; mem_tbl[i].offset != 0xffffffff; i++) {
9436 if ((err = tg3_do_mem_test(tp, mem_tbl[i].offset,
9437 mem_tbl[i].len)) != 0)
9438 break;
9439 }
9440
9441 return err;
9442 }
9443
9444 #define TG3_MAC_LOOPBACK 0
9445 #define TG3_PHY_LOOPBACK 1
9446
9447 static int tg3_run_loopback(struct tg3 *tp, int loopback_mode)
9448 {
9449 u32 mac_mode, rx_start_idx, rx_idx, tx_idx, opaque_key;
9450 u32 desc_idx;
9451 struct sk_buff *skb, *rx_skb;
9452 u8 *tx_data;
9453 dma_addr_t map;
9454 int num_pkts, tx_len, rx_len, i, err;
9455 struct tg3_rx_buffer_desc *desc;
9456
9457 if (loopback_mode == TG3_MAC_LOOPBACK) {
9458 /* HW errata - mac loopback fails in some cases on 5780.
9459 * Normal traffic and PHY loopback are not affected by
9460 * errata.
9461 */
9462 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
9463 return 0;
9464
9465 mac_mode = (tp->mac_mode & ~MAC_MODE_PORT_MODE_MASK) |
9466 MAC_MODE_PORT_INT_LPBACK;
9467 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS))
9468 mac_mode |= MAC_MODE_LINK_POLARITY;
9469 if (tp->tg3_flags & TG3_FLAG_10_100_ONLY)
9470 mac_mode |= MAC_MODE_PORT_MODE_MII;
9471 else
9472 mac_mode |= MAC_MODE_PORT_MODE_GMII;
9473 tw32(MAC_MODE, mac_mode);
9474 } else if (loopback_mode == TG3_PHY_LOOPBACK) {
9475 u32 val;
9476
9477 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
9478 u32 phytest;
9479
9480 if (!tg3_readphy(tp, MII_TG3_EPHY_TEST, &phytest)) {
9481 u32 phy;
9482
9483 tg3_writephy(tp, MII_TG3_EPHY_TEST,
9484 phytest | MII_TG3_EPHY_SHADOW_EN);
9485 if (!tg3_readphy(tp, 0x1b, &phy))
9486 tg3_writephy(tp, 0x1b, phy & ~0x20);
9487 tg3_writephy(tp, MII_TG3_EPHY_TEST, phytest);
9488 }
9489 val = BMCR_LOOPBACK | BMCR_FULLDPLX | BMCR_SPEED100;
9490 } else
9491 val = BMCR_LOOPBACK | BMCR_FULLDPLX | BMCR_SPEED1000;
9492
9493 tg3_phy_toggle_automdix(tp, 0);
9494
9495 tg3_writephy(tp, MII_BMCR, val);
9496 udelay(40);
9497
9498 mac_mode = tp->mac_mode & ~MAC_MODE_PORT_MODE_MASK;
9499 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
9500 tg3_writephy(tp, MII_TG3_EPHY_PTEST, 0x1800);
9501 mac_mode |= MAC_MODE_PORT_MODE_MII;
9502 } else
9503 mac_mode |= MAC_MODE_PORT_MODE_GMII;
9504
9505 /* reset to prevent losing 1st rx packet intermittently */
9506 if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES) {
9507 tw32_f(MAC_RX_MODE, RX_MODE_RESET);
9508 udelay(10);
9509 tw32_f(MAC_RX_MODE, tp->rx_mode);
9510 }
9511 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700) {
9512 if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401)
9513 mac_mode &= ~MAC_MODE_LINK_POLARITY;
9514 else if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5411)
9515 mac_mode |= MAC_MODE_LINK_POLARITY;
9516 tg3_writephy(tp, MII_TG3_EXT_CTRL,
9517 MII_TG3_EXT_CTRL_LNK3_LED_MODE);
9518 }
9519 tw32(MAC_MODE, mac_mode);
9520 }
9521 else
9522 return -EINVAL;
9523
9524 err = -EIO;
9525
9526 tx_len = 1514;
9527 skb = netdev_alloc_skb(tp->dev, tx_len);
9528 if (!skb)
9529 return -ENOMEM;
9530
9531 tx_data = skb_put(skb, tx_len);
9532 memcpy(tx_data, tp->dev->dev_addr, 6);
9533 memset(tx_data + 6, 0x0, 8);
9534
9535 tw32(MAC_RX_MTU_SIZE, tx_len + 4);
9536
9537 for (i = 14; i < tx_len; i++)
9538 tx_data[i] = (u8) (i & 0xff);
9539
9540 map = pci_map_single(tp->pdev, skb->data, tx_len, PCI_DMA_TODEVICE);
9541
9542 tw32_f(HOSTCC_MODE, tp->coalesce_mode | HOSTCC_MODE_ENABLE |
9543 HOSTCC_MODE_NOW);
9544
9545 udelay(10);
9546
9547 rx_start_idx = tp->hw_status->idx[0].rx_producer;
9548
9549 num_pkts = 0;
9550
9551 tg3_set_txd(tp, tp->tx_prod, map, tx_len, 0, 1);
9552
9553 tp->tx_prod++;
9554 num_pkts++;
9555
9556 tw32_tx_mbox(MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW,
9557 tp->tx_prod);
9558 tr32_mailbox(MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW);
9559
9560 udelay(10);
9561
9562 /* 250 usec to allow enough time on some 10/100 Mbps devices. */
9563 for (i = 0; i < 25; i++) {
9564 tw32_f(HOSTCC_MODE, tp->coalesce_mode | HOSTCC_MODE_ENABLE |
9565 HOSTCC_MODE_NOW);
9566
9567 udelay(10);
9568
9569 tx_idx = tp->hw_status->idx[0].tx_consumer;
9570 rx_idx = tp->hw_status->idx[0].rx_producer;
9571 if ((tx_idx == tp->tx_prod) &&
9572 (rx_idx == (rx_start_idx + num_pkts)))
9573 break;
9574 }
9575
9576 pci_unmap_single(tp->pdev, map, tx_len, PCI_DMA_TODEVICE);
9577 dev_kfree_skb(skb);
9578
9579 if (tx_idx != tp->tx_prod)
9580 goto out;
9581
9582 if (rx_idx != rx_start_idx + num_pkts)
9583 goto out;
9584
9585 desc = &tp->rx_rcb[rx_start_idx];
9586 desc_idx = desc->opaque & RXD_OPAQUE_INDEX_MASK;
9587 opaque_key = desc->opaque & RXD_OPAQUE_RING_MASK;
9588 if (opaque_key != RXD_OPAQUE_RING_STD)
9589 goto out;
9590
9591 if ((desc->err_vlan & RXD_ERR_MASK) != 0 &&
9592 (desc->err_vlan != RXD_ERR_ODD_NIBBLE_RCVD_MII))
9593 goto out;
9594
9595 rx_len = ((desc->idx_len & RXD_LEN_MASK) >> RXD_LEN_SHIFT) - 4;
9596 if (rx_len != tx_len)
9597 goto out;
9598
9599 rx_skb = tp->rx_std_buffers[desc_idx].skb;
9600
9601 map = pci_unmap_addr(&tp->rx_std_buffers[desc_idx], mapping);
9602 pci_dma_sync_single_for_cpu(tp->pdev, map, rx_len, PCI_DMA_FROMDEVICE);
9603
9604 for (i = 14; i < tx_len; i++) {
9605 if (*(rx_skb->data + i) != (u8) (i & 0xff))
9606 goto out;
9607 }
9608 err = 0;
9609
9610 /* tg3_free_rings will unmap and free the rx_skb */
9611 out:
9612 return err;
9613 }
9614
9615 #define TG3_MAC_LOOPBACK_FAILED 1
9616 #define TG3_PHY_LOOPBACK_FAILED 2
9617 #define TG3_LOOPBACK_FAILED (TG3_MAC_LOOPBACK_FAILED | \
9618 TG3_PHY_LOOPBACK_FAILED)
9619
9620 static int tg3_test_loopback(struct tg3 *tp)
9621 {
9622 int err = 0;
9623 u32 cpmuctrl = 0;
9624
9625 if (!netif_running(tp->dev))
9626 return TG3_LOOPBACK_FAILED;
9627
9628 err = tg3_reset_hw(tp, 1);
9629 if (err)
9630 return TG3_LOOPBACK_FAILED;
9631
9632 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
9633 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761) {
9634 int i;
9635 u32 status;
9636
9637 tw32(TG3_CPMU_MUTEX_REQ, CPMU_MUTEX_REQ_DRIVER);
9638
9639 /* Wait for up to 40 microseconds to acquire lock. */
9640 for (i = 0; i < 4; i++) {
9641 status = tr32(TG3_CPMU_MUTEX_GNT);
9642 if (status == CPMU_MUTEX_GNT_DRIVER)
9643 break;
9644 udelay(10);
9645 }
9646
9647 if (status != CPMU_MUTEX_GNT_DRIVER)
9648 return TG3_LOOPBACK_FAILED;
9649
9650 /* Turn off link-based power management. */
9651 cpmuctrl = tr32(TG3_CPMU_CTRL);
9652 tw32(TG3_CPMU_CTRL,
9653 cpmuctrl & ~(CPMU_CTRL_LINK_SPEED_MODE |
9654 CPMU_CTRL_LINK_AWARE_MODE));
9655 }
9656
9657 if (tg3_run_loopback(tp, TG3_MAC_LOOPBACK))
9658 err |= TG3_MAC_LOOPBACK_FAILED;
9659
9660 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
9661 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761) {
9662 tw32(TG3_CPMU_CTRL, cpmuctrl);
9663
9664 /* Release the mutex */
9665 tw32(TG3_CPMU_MUTEX_GNT, CPMU_MUTEX_GNT_DRIVER);
9666 }
9667
9668 if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)) {
9669 if (tg3_run_loopback(tp, TG3_PHY_LOOPBACK))
9670 err |= TG3_PHY_LOOPBACK_FAILED;
9671 }
9672
9673 return err;
9674 }
9675
9676 static void tg3_self_test(struct net_device *dev, struct ethtool_test *etest,
9677 u64 *data)
9678 {
9679 struct tg3 *tp = netdev_priv(dev);
9680
9681 if (tp->link_config.phy_is_low_power)
9682 tg3_set_power_state(tp, PCI_D0);
9683
9684 memset(data, 0, sizeof(u64) * TG3_NUM_TEST);
9685
9686 if (tg3_test_nvram(tp) != 0) {
9687 etest->flags |= ETH_TEST_FL_FAILED;
9688 data[0] = 1;
9689 }
9690 if (tg3_test_link(tp) != 0) {
9691 etest->flags |= ETH_TEST_FL_FAILED;
9692 data[1] = 1;
9693 }
9694 if (etest->flags & ETH_TEST_FL_OFFLINE) {
9695 int err, irq_sync = 0;
9696
9697 if (netif_running(dev)) {
9698 tg3_netif_stop(tp);
9699 irq_sync = 1;
9700 }
9701
9702 tg3_full_lock(tp, irq_sync);
9703
9704 tg3_halt(tp, RESET_KIND_SUSPEND, 1);
9705 err = tg3_nvram_lock(tp);
9706 tg3_halt_cpu(tp, RX_CPU_BASE);
9707 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS))
9708 tg3_halt_cpu(tp, TX_CPU_BASE);
9709 if (!err)
9710 tg3_nvram_unlock(tp);
9711
9712 if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES)
9713 tg3_phy_reset(tp);
9714
9715 if (tg3_test_registers(tp) != 0) {
9716 etest->flags |= ETH_TEST_FL_FAILED;
9717 data[2] = 1;
9718 }
9719 if (tg3_test_memory(tp) != 0) {
9720 etest->flags |= ETH_TEST_FL_FAILED;
9721 data[3] = 1;
9722 }
9723 if ((data[4] = tg3_test_loopback(tp)) != 0)
9724 etest->flags |= ETH_TEST_FL_FAILED;
9725
9726 tg3_full_unlock(tp);
9727
9728 if (tg3_test_interrupt(tp) != 0) {
9729 etest->flags |= ETH_TEST_FL_FAILED;
9730 data[5] = 1;
9731 }
9732
9733 tg3_full_lock(tp, 0);
9734
9735 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
9736 if (netif_running(dev)) {
9737 tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
9738 if (!tg3_restart_hw(tp, 1))
9739 tg3_netif_start(tp);
9740 }
9741
9742 tg3_full_unlock(tp);
9743 }
9744 if (tp->link_config.phy_is_low_power)
9745 tg3_set_power_state(tp, PCI_D3hot);
9746
9747 }
9748
9749 static int tg3_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
9750 {
9751 struct mii_ioctl_data *data = if_mii(ifr);
9752 struct tg3 *tp = netdev_priv(dev);
9753 int err;
9754
9755 switch(cmd) {
9756 case SIOCGMIIPHY:
9757 data->phy_id = PHY_ADDR;
9758
9759 /* fallthru */
9760 case SIOCGMIIREG: {
9761 u32 mii_regval;
9762
9763 if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
9764 break; /* We have no PHY */
9765
9766 if (tp->link_config.phy_is_low_power)
9767 return -EAGAIN;
9768
9769 spin_lock_bh(&tp->lock);
9770 err = tg3_readphy(tp, data->reg_num & 0x1f, &mii_regval);
9771 spin_unlock_bh(&tp->lock);
9772
9773 data->val_out = mii_regval;
9774
9775 return err;
9776 }
9777
9778 case SIOCSMIIREG:
9779 if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
9780 break; /* We have no PHY */
9781
9782 if (!capable(CAP_NET_ADMIN))
9783 return -EPERM;
9784
9785 if (tp->link_config.phy_is_low_power)
9786 return -EAGAIN;
9787
9788 spin_lock_bh(&tp->lock);
9789 err = tg3_writephy(tp, data->reg_num & 0x1f, data->val_in);
9790 spin_unlock_bh(&tp->lock);
9791
9792 return err;
9793
9794 default:
9795 /* do nothing */
9796 break;
9797 }
9798 return -EOPNOTSUPP;
9799 }
9800
9801 #if TG3_VLAN_TAG_USED
9802 static void tg3_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
9803 {
9804 struct tg3 *tp = netdev_priv(dev);
9805
9806 if (netif_running(dev))
9807 tg3_netif_stop(tp);
9808
9809 tg3_full_lock(tp, 0);
9810
9811 tp->vlgrp = grp;
9812
9813 /* Update RX_MODE_KEEP_VLAN_TAG bit in RX_MODE register. */
9814 __tg3_set_rx_mode(dev);
9815
9816 if (netif_running(dev))
9817 tg3_netif_start(tp);
9818
9819 tg3_full_unlock(tp);
9820 }
9821 #endif
9822
9823 static int tg3_get_coalesce(struct net_device *dev, struct ethtool_coalesce *ec)
9824 {
9825 struct tg3 *tp = netdev_priv(dev);
9826
9827 memcpy(ec, &tp->coal, sizeof(*ec));
9828 return 0;
9829 }
9830
9831 static int tg3_set_coalesce(struct net_device *dev, struct ethtool_coalesce *ec)
9832 {
9833 struct tg3 *tp = netdev_priv(dev);
9834 u32 max_rxcoal_tick_int = 0, max_txcoal_tick_int = 0;
9835 u32 max_stat_coal_ticks = 0, min_stat_coal_ticks = 0;
9836
9837 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
9838 max_rxcoal_tick_int = MAX_RXCOAL_TICK_INT;
9839 max_txcoal_tick_int = MAX_TXCOAL_TICK_INT;
9840 max_stat_coal_ticks = MAX_STAT_COAL_TICKS;
9841 min_stat_coal_ticks = MIN_STAT_COAL_TICKS;
9842 }
9843
9844 if ((ec->rx_coalesce_usecs > MAX_RXCOL_TICKS) ||
9845 (ec->tx_coalesce_usecs > MAX_TXCOL_TICKS) ||
9846 (ec->rx_max_coalesced_frames > MAX_RXMAX_FRAMES) ||
9847 (ec->tx_max_coalesced_frames > MAX_TXMAX_FRAMES) ||
9848 (ec->rx_coalesce_usecs_irq > max_rxcoal_tick_int) ||
9849 (ec->tx_coalesce_usecs_irq > max_txcoal_tick_int) ||
9850 (ec->rx_max_coalesced_frames_irq > MAX_RXCOAL_MAXF_INT) ||
9851 (ec->tx_max_coalesced_frames_irq > MAX_TXCOAL_MAXF_INT) ||
9852 (ec->stats_block_coalesce_usecs > max_stat_coal_ticks) ||
9853 (ec->stats_block_coalesce_usecs < min_stat_coal_ticks))
9854 return -EINVAL;
9855
9856 /* No rx interrupts will be generated if both are zero */
9857 if ((ec->rx_coalesce_usecs == 0) &&
9858 (ec->rx_max_coalesced_frames == 0))
9859 return -EINVAL;
9860
9861 /* No tx interrupts will be generated if both are zero */
9862 if ((ec->tx_coalesce_usecs == 0) &&
9863 (ec->tx_max_coalesced_frames == 0))
9864 return -EINVAL;
9865
9866 /* Only copy relevant parameters, ignore all others. */
9867 tp->coal.rx_coalesce_usecs = ec->rx_coalesce_usecs;
9868 tp->coal.tx_coalesce_usecs = ec->tx_coalesce_usecs;
9869 tp->coal.rx_max_coalesced_frames = ec->rx_max_coalesced_frames;
9870 tp->coal.tx_max_coalesced_frames = ec->tx_max_coalesced_frames;
9871 tp->coal.rx_coalesce_usecs_irq = ec->rx_coalesce_usecs_irq;
9872 tp->coal.tx_coalesce_usecs_irq = ec->tx_coalesce_usecs_irq;
9873 tp->coal.rx_max_coalesced_frames_irq = ec->rx_max_coalesced_frames_irq;
9874 tp->coal.tx_max_coalesced_frames_irq = ec->tx_max_coalesced_frames_irq;
9875 tp->coal.stats_block_coalesce_usecs = ec->stats_block_coalesce_usecs;
9876
9877 if (netif_running(dev)) {
9878 tg3_full_lock(tp, 0);
9879 __tg3_set_coalesce(tp, &tp->coal);
9880 tg3_full_unlock(tp);
9881 }
9882 return 0;
9883 }
9884
9885 static const struct ethtool_ops tg3_ethtool_ops = {
9886 .get_settings = tg3_get_settings,
9887 .set_settings = tg3_set_settings,
9888 .get_drvinfo = tg3_get_drvinfo,
9889 .get_regs_len = tg3_get_regs_len,
9890 .get_regs = tg3_get_regs,
9891 .get_wol = tg3_get_wol,
9892 .set_wol = tg3_set_wol,
9893 .get_msglevel = tg3_get_msglevel,
9894 .set_msglevel = tg3_set_msglevel,
9895 .nway_reset = tg3_nway_reset,
9896 .get_link = ethtool_op_get_link,
9897 .get_eeprom_len = tg3_get_eeprom_len,
9898 .get_eeprom = tg3_get_eeprom,
9899 .set_eeprom = tg3_set_eeprom,
9900 .get_ringparam = tg3_get_ringparam,
9901 .set_ringparam = tg3_set_ringparam,
9902 .get_pauseparam = tg3_get_pauseparam,
9903 .set_pauseparam = tg3_set_pauseparam,
9904 .get_rx_csum = tg3_get_rx_csum,
9905 .set_rx_csum = tg3_set_rx_csum,
9906 .set_tx_csum = tg3_set_tx_csum,
9907 .set_sg = ethtool_op_set_sg,
9908 .set_tso = tg3_set_tso,
9909 .self_test = tg3_self_test,
9910 .get_strings = tg3_get_strings,
9911 .phys_id = tg3_phys_id,
9912 .get_ethtool_stats = tg3_get_ethtool_stats,
9913 .get_coalesce = tg3_get_coalesce,
9914 .set_coalesce = tg3_set_coalesce,
9915 .get_sset_count = tg3_get_sset_count,
9916 };
9917
9918 static void __devinit tg3_get_eeprom_size(struct tg3 *tp)
9919 {
9920 u32 cursize, val, magic;
9921
9922 tp->nvram_size = EEPROM_CHIP_SIZE;
9923
9924 if (tg3_nvram_read_swab(tp, 0, &magic) != 0)
9925 return;
9926
9927 if ((magic != TG3_EEPROM_MAGIC) &&
9928 ((magic & TG3_EEPROM_MAGIC_FW_MSK) != TG3_EEPROM_MAGIC_FW) &&
9929 ((magic & TG3_EEPROM_MAGIC_HW_MSK) != TG3_EEPROM_MAGIC_HW))
9930 return;
9931
9932 /*
9933 * Size the chip by reading offsets at increasing powers of two.
9934 * When we encounter our validation signature, we know the addressing
9935 * has wrapped around, and thus have our chip size.
9936 */
9937 cursize = 0x10;
9938
9939 while (cursize < tp->nvram_size) {
9940 if (tg3_nvram_read_swab(tp, cursize, &val) != 0)
9941 return;
9942
9943 if (val == magic)
9944 break;
9945
9946 cursize <<= 1;
9947 }
9948
9949 tp->nvram_size = cursize;
9950 }
9951
9952 static void __devinit tg3_get_nvram_size(struct tg3 *tp)
9953 {
9954 u32 val;
9955
9956 if (tg3_nvram_read_swab(tp, 0, &val) != 0)
9957 return;
9958
9959 /* Selfboot format */
9960 if (val != TG3_EEPROM_MAGIC) {
9961 tg3_get_eeprom_size(tp);
9962 return;
9963 }
9964
9965 if (tg3_nvram_read(tp, 0xf0, &val) == 0) {
9966 if (val != 0) {
9967 tp->nvram_size = (val >> 16) * 1024;
9968 return;
9969 }
9970 }
9971 tp->nvram_size = TG3_NVRAM_SIZE_512KB;
9972 }
9973
9974 static void __devinit tg3_get_nvram_info(struct tg3 *tp)
9975 {
9976 u32 nvcfg1;
9977
9978 nvcfg1 = tr32(NVRAM_CFG1);
9979 if (nvcfg1 & NVRAM_CFG1_FLASHIF_ENAB) {
9980 tp->tg3_flags2 |= TG3_FLG2_FLASH;
9981 }
9982 else {
9983 nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
9984 tw32(NVRAM_CFG1, nvcfg1);
9985 }
9986
9987 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) ||
9988 (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)) {
9989 switch (nvcfg1 & NVRAM_CFG1_VENDOR_MASK) {
9990 case FLASH_VENDOR_ATMEL_FLASH_BUFFERED:
9991 tp->nvram_jedecnum = JEDEC_ATMEL;
9992 tp->nvram_pagesize = ATMEL_AT45DB0X1B_PAGE_SIZE;
9993 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
9994 break;
9995 case FLASH_VENDOR_ATMEL_FLASH_UNBUFFERED:
9996 tp->nvram_jedecnum = JEDEC_ATMEL;
9997 tp->nvram_pagesize = ATMEL_AT25F512_PAGE_SIZE;
9998 break;
9999 case FLASH_VENDOR_ATMEL_EEPROM:
10000 tp->nvram_jedecnum = JEDEC_ATMEL;
10001 tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
10002 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
10003 break;
10004 case FLASH_VENDOR_ST:
10005 tp->nvram_jedecnum = JEDEC_ST;
10006 tp->nvram_pagesize = ST_M45PEX0_PAGE_SIZE;
10007 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
10008 break;
10009 case FLASH_VENDOR_SAIFUN:
10010 tp->nvram_jedecnum = JEDEC_SAIFUN;
10011 tp->nvram_pagesize = SAIFUN_SA25F0XX_PAGE_SIZE;
10012 break;
10013 case FLASH_VENDOR_SST_SMALL:
10014 case FLASH_VENDOR_SST_LARGE:
10015 tp->nvram_jedecnum = JEDEC_SST;
10016 tp->nvram_pagesize = SST_25VF0X0_PAGE_SIZE;
10017 break;
10018 }
10019 }
10020 else {
10021 tp->nvram_jedecnum = JEDEC_ATMEL;
10022 tp->nvram_pagesize = ATMEL_AT45DB0X1B_PAGE_SIZE;
10023 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
10024 }
10025 }
10026
10027 static void __devinit tg3_get_5752_nvram_info(struct tg3 *tp)
10028 {
10029 u32 nvcfg1;
10030
10031 nvcfg1 = tr32(NVRAM_CFG1);
10032
10033 /* NVRAM protection for TPM */
10034 if (nvcfg1 & (1 << 27))
10035 tp->tg3_flags2 |= TG3_FLG2_PROTECTED_NVRAM;
10036
10037 switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
10038 case FLASH_5752VENDOR_ATMEL_EEPROM_64KHZ:
10039 case FLASH_5752VENDOR_ATMEL_EEPROM_376KHZ:
10040 tp->nvram_jedecnum = JEDEC_ATMEL;
10041 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
10042 break;
10043 case FLASH_5752VENDOR_ATMEL_FLASH_BUFFERED:
10044 tp->nvram_jedecnum = JEDEC_ATMEL;
10045 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
10046 tp->tg3_flags2 |= TG3_FLG2_FLASH;
10047 break;
10048 case FLASH_5752VENDOR_ST_M45PE10:
10049 case FLASH_5752VENDOR_ST_M45PE20:
10050 case FLASH_5752VENDOR_ST_M45PE40:
10051 tp->nvram_jedecnum = JEDEC_ST;
10052 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
10053 tp->tg3_flags2 |= TG3_FLG2_FLASH;
10054 break;
10055 }
10056
10057 if (tp->tg3_flags2 & TG3_FLG2_FLASH) {
10058 switch (nvcfg1 & NVRAM_CFG1_5752PAGE_SIZE_MASK) {
10059 case FLASH_5752PAGE_SIZE_256:
10060 tp->nvram_pagesize = 256;
10061 break;
10062 case FLASH_5752PAGE_SIZE_512:
10063 tp->nvram_pagesize = 512;
10064 break;
10065 case FLASH_5752PAGE_SIZE_1K:
10066 tp->nvram_pagesize = 1024;
10067 break;
10068 case FLASH_5752PAGE_SIZE_2K:
10069 tp->nvram_pagesize = 2048;
10070 break;
10071 case FLASH_5752PAGE_SIZE_4K:
10072 tp->nvram_pagesize = 4096;
10073 break;
10074 case FLASH_5752PAGE_SIZE_264:
10075 tp->nvram_pagesize = 264;
10076 break;
10077 }
10078 }
10079 else {
10080 /* For eeprom, set pagesize to maximum eeprom size */
10081 tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
10082
10083 nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
10084 tw32(NVRAM_CFG1, nvcfg1);
10085 }
10086 }
10087
10088 static void __devinit tg3_get_5755_nvram_info(struct tg3 *tp)
10089 {
10090 u32 nvcfg1, protect = 0;
10091
10092 nvcfg1 = tr32(NVRAM_CFG1);
10093
10094 /* NVRAM protection for TPM */
10095 if (nvcfg1 & (1 << 27)) {
10096 tp->tg3_flags2 |= TG3_FLG2_PROTECTED_NVRAM;
10097 protect = 1;
10098 }
10099
10100 nvcfg1 &= NVRAM_CFG1_5752VENDOR_MASK;
10101 switch (nvcfg1) {
10102 case FLASH_5755VENDOR_ATMEL_FLASH_1:
10103 case FLASH_5755VENDOR_ATMEL_FLASH_2:
10104 case FLASH_5755VENDOR_ATMEL_FLASH_3:
10105 case FLASH_5755VENDOR_ATMEL_FLASH_5:
10106 tp->nvram_jedecnum = JEDEC_ATMEL;
10107 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
10108 tp->tg3_flags2 |= TG3_FLG2_FLASH;
10109 tp->nvram_pagesize = 264;
10110 if (nvcfg1 == FLASH_5755VENDOR_ATMEL_FLASH_1 ||
10111 nvcfg1 == FLASH_5755VENDOR_ATMEL_FLASH_5)
10112 tp->nvram_size = (protect ? 0x3e200 :
10113 TG3_NVRAM_SIZE_512KB);
10114 else if (nvcfg1 == FLASH_5755VENDOR_ATMEL_FLASH_2)
10115 tp->nvram_size = (protect ? 0x1f200 :
10116 TG3_NVRAM_SIZE_256KB);
10117 else
10118 tp->nvram_size = (protect ? 0x1f200 :
10119 TG3_NVRAM_SIZE_128KB);
10120 break;
10121 case FLASH_5752VENDOR_ST_M45PE10:
10122 case FLASH_5752VENDOR_ST_M45PE20:
10123 case FLASH_5752VENDOR_ST_M45PE40:
10124 tp->nvram_jedecnum = JEDEC_ST;
10125 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
10126 tp->tg3_flags2 |= TG3_FLG2_FLASH;
10127 tp->nvram_pagesize = 256;
10128 if (nvcfg1 == FLASH_5752VENDOR_ST_M45PE10)
10129 tp->nvram_size = (protect ?
10130 TG3_NVRAM_SIZE_64KB :
10131 TG3_NVRAM_SIZE_128KB);
10132 else if (nvcfg1 == FLASH_5752VENDOR_ST_M45PE20)
10133 tp->nvram_size = (protect ?
10134 TG3_NVRAM_SIZE_64KB :
10135 TG3_NVRAM_SIZE_256KB);
10136 else
10137 tp->nvram_size = (protect ?
10138 TG3_NVRAM_SIZE_128KB :
10139 TG3_NVRAM_SIZE_512KB);
10140 break;
10141 }
10142 }
10143
10144 static void __devinit tg3_get_5787_nvram_info(struct tg3 *tp)
10145 {
10146 u32 nvcfg1;
10147
10148 nvcfg1 = tr32(NVRAM_CFG1);
10149
10150 switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
10151 case FLASH_5787VENDOR_ATMEL_EEPROM_64KHZ:
10152 case FLASH_5787VENDOR_ATMEL_EEPROM_376KHZ:
10153 case FLASH_5787VENDOR_MICRO_EEPROM_64KHZ:
10154 case FLASH_5787VENDOR_MICRO_EEPROM_376KHZ:
10155 tp->nvram_jedecnum = JEDEC_ATMEL;
10156 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
10157 tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
10158
10159 nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
10160 tw32(NVRAM_CFG1, nvcfg1);
10161 break;
10162 case FLASH_5752VENDOR_ATMEL_FLASH_BUFFERED:
10163 case FLASH_5755VENDOR_ATMEL_FLASH_1:
10164 case FLASH_5755VENDOR_ATMEL_FLASH_2:
10165 case FLASH_5755VENDOR_ATMEL_FLASH_3:
10166 tp->nvram_jedecnum = JEDEC_ATMEL;
10167 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
10168 tp->tg3_flags2 |= TG3_FLG2_FLASH;
10169 tp->nvram_pagesize = 264;
10170 break;
10171 case FLASH_5752VENDOR_ST_M45PE10:
10172 case FLASH_5752VENDOR_ST_M45PE20:
10173 case FLASH_5752VENDOR_ST_M45PE40:
10174 tp->nvram_jedecnum = JEDEC_ST;
10175 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
10176 tp->tg3_flags2 |= TG3_FLG2_FLASH;
10177 tp->nvram_pagesize = 256;
10178 break;
10179 }
10180 }
10181
10182 static void __devinit tg3_get_5761_nvram_info(struct tg3 *tp)
10183 {
10184 u32 nvcfg1, protect = 0;
10185
10186 nvcfg1 = tr32(NVRAM_CFG1);
10187
10188 /* NVRAM protection for TPM */
10189 if (nvcfg1 & (1 << 27)) {
10190 tp->tg3_flags2 |= TG3_FLG2_PROTECTED_NVRAM;
10191 protect = 1;
10192 }
10193
10194 nvcfg1 &= NVRAM_CFG1_5752VENDOR_MASK;
10195 switch (nvcfg1) {
10196 case FLASH_5761VENDOR_ATMEL_ADB021D:
10197 case FLASH_5761VENDOR_ATMEL_ADB041D:
10198 case FLASH_5761VENDOR_ATMEL_ADB081D:
10199 case FLASH_5761VENDOR_ATMEL_ADB161D:
10200 case FLASH_5761VENDOR_ATMEL_MDB021D:
10201 case FLASH_5761VENDOR_ATMEL_MDB041D:
10202 case FLASH_5761VENDOR_ATMEL_MDB081D:
10203 case FLASH_5761VENDOR_ATMEL_MDB161D:
10204 tp->nvram_jedecnum = JEDEC_ATMEL;
10205 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
10206 tp->tg3_flags2 |= TG3_FLG2_FLASH;
10207 tp->tg3_flags3 |= TG3_FLG3_NO_NVRAM_ADDR_TRANS;
10208 tp->nvram_pagesize = 256;
10209 break;
10210 case FLASH_5761VENDOR_ST_A_M45PE20:
10211 case FLASH_5761VENDOR_ST_A_M45PE40:
10212 case FLASH_5761VENDOR_ST_A_M45PE80:
10213 case FLASH_5761VENDOR_ST_A_M45PE16:
10214 case FLASH_5761VENDOR_ST_M_M45PE20:
10215 case FLASH_5761VENDOR_ST_M_M45PE40:
10216 case FLASH_5761VENDOR_ST_M_M45PE80:
10217 case FLASH_5761VENDOR_ST_M_M45PE16:
10218 tp->nvram_jedecnum = JEDEC_ST;
10219 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
10220 tp->tg3_flags2 |= TG3_FLG2_FLASH;
10221 tp->nvram_pagesize = 256;
10222 break;
10223 }
10224
10225 if (protect) {
10226 tp->nvram_size = tr32(NVRAM_ADDR_LOCKOUT);
10227 } else {
10228 switch (nvcfg1) {
10229 case FLASH_5761VENDOR_ATMEL_ADB161D:
10230 case FLASH_5761VENDOR_ATMEL_MDB161D:
10231 case FLASH_5761VENDOR_ST_A_M45PE16:
10232 case FLASH_5761VENDOR_ST_M_M45PE16:
10233 tp->nvram_size = TG3_NVRAM_SIZE_2MB;
10234 break;
10235 case FLASH_5761VENDOR_ATMEL_ADB081D:
10236 case FLASH_5761VENDOR_ATMEL_MDB081D:
10237 case FLASH_5761VENDOR_ST_A_M45PE80:
10238 case FLASH_5761VENDOR_ST_M_M45PE80:
10239 tp->nvram_size = TG3_NVRAM_SIZE_1MB;
10240 break;
10241 case FLASH_5761VENDOR_ATMEL_ADB041D:
10242 case FLASH_5761VENDOR_ATMEL_MDB041D:
10243 case FLASH_5761VENDOR_ST_A_M45PE40:
10244 case FLASH_5761VENDOR_ST_M_M45PE40:
10245 tp->nvram_size = TG3_NVRAM_SIZE_512KB;
10246 break;
10247 case FLASH_5761VENDOR_ATMEL_ADB021D:
10248 case FLASH_5761VENDOR_ATMEL_MDB021D:
10249 case FLASH_5761VENDOR_ST_A_M45PE20:
10250 case FLASH_5761VENDOR_ST_M_M45PE20:
10251 tp->nvram_size = TG3_NVRAM_SIZE_256KB;
10252 break;
10253 }
10254 }
10255 }
10256
10257 static void __devinit tg3_get_5906_nvram_info(struct tg3 *tp)
10258 {
10259 tp->nvram_jedecnum = JEDEC_ATMEL;
10260 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
10261 tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
10262 }
10263
10264 /* Chips other than 5700/5701 use the NVRAM for fetching info. */
10265 static void __devinit tg3_nvram_init(struct tg3 *tp)
10266 {
10267 tw32_f(GRC_EEPROM_ADDR,
10268 (EEPROM_ADDR_FSM_RESET |
10269 (EEPROM_DEFAULT_CLOCK_PERIOD <<
10270 EEPROM_ADDR_CLKPERD_SHIFT)));
10271
10272 msleep(1);
10273
10274 /* Enable seeprom accesses. */
10275 tw32_f(GRC_LOCAL_CTRL,
10276 tr32(GRC_LOCAL_CTRL) | GRC_LCLCTRL_AUTO_SEEPROM);
10277 udelay(100);
10278
10279 if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700 &&
10280 GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701) {
10281 tp->tg3_flags |= TG3_FLAG_NVRAM;
10282
10283 if (tg3_nvram_lock(tp)) {
10284 printk(KERN_WARNING PFX "%s: Cannot get nvarm lock, "
10285 "tg3_nvram_init failed.\n", tp->dev->name);
10286 return;
10287 }
10288 tg3_enable_nvram_access(tp);
10289
10290 tp->nvram_size = 0;
10291
10292 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752)
10293 tg3_get_5752_nvram_info(tp);
10294 else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755)
10295 tg3_get_5755_nvram_info(tp);
10296 else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
10297 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784)
10298 tg3_get_5787_nvram_info(tp);
10299 else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761)
10300 tg3_get_5761_nvram_info(tp);
10301 else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
10302 tg3_get_5906_nvram_info(tp);
10303 else
10304 tg3_get_nvram_info(tp);
10305
10306 if (tp->nvram_size == 0)
10307 tg3_get_nvram_size(tp);
10308
10309 tg3_disable_nvram_access(tp);
10310 tg3_nvram_unlock(tp);
10311
10312 } else {
10313 tp->tg3_flags &= ~(TG3_FLAG_NVRAM | TG3_FLAG_NVRAM_BUFFERED);
10314
10315 tg3_get_eeprom_size(tp);
10316 }
10317 }
10318
10319 static int tg3_nvram_read_using_eeprom(struct tg3 *tp,
10320 u32 offset, u32 *val)
10321 {
10322 u32 tmp;
10323 int i;
10324
10325 if (offset > EEPROM_ADDR_ADDR_MASK ||
10326 (offset % 4) != 0)
10327 return -EINVAL;
10328
10329 tmp = tr32(GRC_EEPROM_ADDR) & ~(EEPROM_ADDR_ADDR_MASK |
10330 EEPROM_ADDR_DEVID_MASK |
10331 EEPROM_ADDR_READ);
10332 tw32(GRC_EEPROM_ADDR,
10333 tmp |
10334 (0 << EEPROM_ADDR_DEVID_SHIFT) |
10335 ((offset << EEPROM_ADDR_ADDR_SHIFT) &
10336 EEPROM_ADDR_ADDR_MASK) |
10337 EEPROM_ADDR_READ | EEPROM_ADDR_START);
10338
10339 for (i = 0; i < 1000; i++) {
10340 tmp = tr32(GRC_EEPROM_ADDR);
10341
10342 if (tmp & EEPROM_ADDR_COMPLETE)
10343 break;
10344 msleep(1);
10345 }
10346 if (!(tmp & EEPROM_ADDR_COMPLETE))
10347 return -EBUSY;
10348
10349 *val = tr32(GRC_EEPROM_DATA);
10350 return 0;
10351 }
10352
10353 #define NVRAM_CMD_TIMEOUT 10000
10354
10355 static int tg3_nvram_exec_cmd(struct tg3 *tp, u32 nvram_cmd)
10356 {
10357 int i;
10358
10359 tw32(NVRAM_CMD, nvram_cmd);
10360 for (i = 0; i < NVRAM_CMD_TIMEOUT; i++) {
10361 udelay(10);
10362 if (tr32(NVRAM_CMD) & NVRAM_CMD_DONE) {
10363 udelay(10);
10364 break;
10365 }
10366 }
10367 if (i == NVRAM_CMD_TIMEOUT) {
10368 return -EBUSY;
10369 }
10370 return 0;
10371 }
10372
10373 static u32 tg3_nvram_phys_addr(struct tg3 *tp, u32 addr)
10374 {
10375 if ((tp->tg3_flags & TG3_FLAG_NVRAM) &&
10376 (tp->tg3_flags & TG3_FLAG_NVRAM_BUFFERED) &&
10377 (tp->tg3_flags2 & TG3_FLG2_FLASH) &&
10378 !(tp->tg3_flags3 & TG3_FLG3_NO_NVRAM_ADDR_TRANS) &&
10379 (tp->nvram_jedecnum == JEDEC_ATMEL))
10380
10381 addr = ((addr / tp->nvram_pagesize) <<
10382 ATMEL_AT45DB0X1B_PAGE_POS) +
10383 (addr % tp->nvram_pagesize);
10384
10385 return addr;
10386 }
10387
10388 static u32 tg3_nvram_logical_addr(struct tg3 *tp, u32 addr)
10389 {
10390 if ((tp->tg3_flags & TG3_FLAG_NVRAM) &&
10391 (tp->tg3_flags & TG3_FLAG_NVRAM_BUFFERED) &&
10392 (tp->tg3_flags2 & TG3_FLG2_FLASH) &&
10393 !(tp->tg3_flags3 & TG3_FLG3_NO_NVRAM_ADDR_TRANS) &&
10394 (tp->nvram_jedecnum == JEDEC_ATMEL))
10395
10396 addr = ((addr >> ATMEL_AT45DB0X1B_PAGE_POS) *
10397 tp->nvram_pagesize) +
10398 (addr & ((1 << ATMEL_AT45DB0X1B_PAGE_POS) - 1));
10399
10400 return addr;
10401 }
10402
10403 static int tg3_nvram_read(struct tg3 *tp, u32 offset, u32 *val)
10404 {
10405 int ret;
10406
10407 if (!(tp->tg3_flags & TG3_FLAG_NVRAM))
10408 return tg3_nvram_read_using_eeprom(tp, offset, val);
10409
10410 offset = tg3_nvram_phys_addr(tp, offset);
10411
10412 if (offset > NVRAM_ADDR_MSK)
10413 return -EINVAL;
10414
10415 ret = tg3_nvram_lock(tp);
10416 if (ret)
10417 return ret;
10418
10419 tg3_enable_nvram_access(tp);
10420
10421 tw32(NVRAM_ADDR, offset);
10422 ret = tg3_nvram_exec_cmd(tp, NVRAM_CMD_RD | NVRAM_CMD_GO |
10423 NVRAM_CMD_FIRST | NVRAM_CMD_LAST | NVRAM_CMD_DONE);
10424
10425 if (ret == 0)
10426 *val = swab32(tr32(NVRAM_RDDATA));
10427
10428 tg3_disable_nvram_access(tp);
10429
10430 tg3_nvram_unlock(tp);
10431
10432 return ret;
10433 }
10434
10435 static int tg3_nvram_read_le(struct tg3 *tp, u32 offset, __le32 *val)
10436 {
10437 u32 v;
10438 int res = tg3_nvram_read(tp, offset, &v);
10439 if (!res)
10440 *val = cpu_to_le32(v);
10441 return res;
10442 }
10443
10444 static int tg3_nvram_read_swab(struct tg3 *tp, u32 offset, u32 *val)
10445 {
10446 int err;
10447 u32 tmp;
10448
10449 err = tg3_nvram_read(tp, offset, &tmp);
10450 *val = swab32(tmp);
10451 return err;
10452 }
10453
10454 static int tg3_nvram_write_block_using_eeprom(struct tg3 *tp,
10455 u32 offset, u32 len, u8 *buf)
10456 {
10457 int i, j, rc = 0;
10458 u32 val;
10459
10460 for (i = 0; i < len; i += 4) {
10461 u32 addr;
10462 __le32 data;
10463
10464 addr = offset + i;
10465
10466 memcpy(&data, buf + i, 4);
10467
10468 tw32(GRC_EEPROM_DATA, le32_to_cpu(data));
10469
10470 val = tr32(GRC_EEPROM_ADDR);
10471 tw32(GRC_EEPROM_ADDR, val | EEPROM_ADDR_COMPLETE);
10472
10473 val &= ~(EEPROM_ADDR_ADDR_MASK | EEPROM_ADDR_DEVID_MASK |
10474 EEPROM_ADDR_READ);
10475 tw32(GRC_EEPROM_ADDR, val |
10476 (0 << EEPROM_ADDR_DEVID_SHIFT) |
10477 (addr & EEPROM_ADDR_ADDR_MASK) |
10478 EEPROM_ADDR_START |
10479 EEPROM_ADDR_WRITE);
10480
10481 for (j = 0; j < 1000; j++) {
10482 val = tr32(GRC_EEPROM_ADDR);
10483
10484 if (val & EEPROM_ADDR_COMPLETE)
10485 break;
10486 msleep(1);
10487 }
10488 if (!(val & EEPROM_ADDR_COMPLETE)) {
10489 rc = -EBUSY;
10490 break;
10491 }
10492 }
10493
10494 return rc;
10495 }
10496
10497 /* offset and length are dword aligned */
10498 static int tg3_nvram_write_block_unbuffered(struct tg3 *tp, u32 offset, u32 len,
10499 u8 *buf)
10500 {
10501 int ret = 0;
10502 u32 pagesize = tp->nvram_pagesize;
10503 u32 pagemask = pagesize - 1;
10504 u32 nvram_cmd;
10505 u8 *tmp;
10506
10507 tmp = kmalloc(pagesize, GFP_KERNEL);
10508 if (tmp == NULL)
10509 return -ENOMEM;
10510
10511 while (len) {
10512 int j;
10513 u32 phy_addr, page_off, size;
10514
10515 phy_addr = offset & ~pagemask;
10516
10517 for (j = 0; j < pagesize; j += 4) {
10518 if ((ret = tg3_nvram_read_le(tp, phy_addr + j,
10519 (__le32 *) (tmp + j))))
10520 break;
10521 }
10522 if (ret)
10523 break;
10524
10525 page_off = offset & pagemask;
10526 size = pagesize;
10527 if (len < size)
10528 size = len;
10529
10530 len -= size;
10531
10532 memcpy(tmp + page_off, buf, size);
10533
10534 offset = offset + (pagesize - page_off);
10535
10536 tg3_enable_nvram_access(tp);
10537
10538 /*
10539 * Before we can erase the flash page, we need
10540 * to issue a special "write enable" command.
10541 */
10542 nvram_cmd = NVRAM_CMD_WREN | NVRAM_CMD_GO | NVRAM_CMD_DONE;
10543
10544 if (tg3_nvram_exec_cmd(tp, nvram_cmd))
10545 break;
10546
10547 /* Erase the target page */
10548 tw32(NVRAM_ADDR, phy_addr);
10549
10550 nvram_cmd = NVRAM_CMD_GO | NVRAM_CMD_DONE | NVRAM_CMD_WR |
10551 NVRAM_CMD_FIRST | NVRAM_CMD_LAST | NVRAM_CMD_ERASE;
10552
10553 if (tg3_nvram_exec_cmd(tp, nvram_cmd))
10554 break;
10555
10556 /* Issue another write enable to start the write. */
10557 nvram_cmd = NVRAM_CMD_WREN | NVRAM_CMD_GO | NVRAM_CMD_DONE;
10558
10559 if (tg3_nvram_exec_cmd(tp, nvram_cmd))
10560 break;
10561
10562 for (j = 0; j < pagesize; j += 4) {
10563 __be32 data;
10564
10565 data = *((__be32 *) (tmp + j));
10566 /* swab32(le32_to_cpu(data)), actually */
10567 tw32(NVRAM_WRDATA, be32_to_cpu(data));
10568
10569 tw32(NVRAM_ADDR, phy_addr + j);
10570
10571 nvram_cmd = NVRAM_CMD_GO | NVRAM_CMD_DONE |
10572 NVRAM_CMD_WR;
10573
10574 if (j == 0)
10575 nvram_cmd |= NVRAM_CMD_FIRST;
10576 else if (j == (pagesize - 4))
10577 nvram_cmd |= NVRAM_CMD_LAST;
10578
10579 if ((ret = tg3_nvram_exec_cmd(tp, nvram_cmd)))
10580 break;
10581 }
10582 if (ret)
10583 break;
10584 }
10585
10586 nvram_cmd = NVRAM_CMD_WRDI | NVRAM_CMD_GO | NVRAM_CMD_DONE;
10587 tg3_nvram_exec_cmd(tp, nvram_cmd);
10588
10589 kfree(tmp);
10590
10591 return ret;
10592 }
10593
10594 /* offset and length are dword aligned */
10595 static int tg3_nvram_write_block_buffered(struct tg3 *tp, u32 offset, u32 len,
10596 u8 *buf)
10597 {
10598 int i, ret = 0;
10599
10600 for (i = 0; i < len; i += 4, offset += 4) {
10601 u32 page_off, phy_addr, nvram_cmd;
10602 __be32 data;
10603
10604 memcpy(&data, buf + i, 4);
10605 tw32(NVRAM_WRDATA, be32_to_cpu(data));
10606
10607 page_off = offset % tp->nvram_pagesize;
10608
10609 phy_addr = tg3_nvram_phys_addr(tp, offset);
10610
10611 tw32(NVRAM_ADDR, phy_addr);
10612
10613 nvram_cmd = NVRAM_CMD_GO | NVRAM_CMD_DONE | NVRAM_CMD_WR;
10614
10615 if ((page_off == 0) || (i == 0))
10616 nvram_cmd |= NVRAM_CMD_FIRST;
10617 if (page_off == (tp->nvram_pagesize - 4))
10618 nvram_cmd |= NVRAM_CMD_LAST;
10619
10620 if (i == (len - 4))
10621 nvram_cmd |= NVRAM_CMD_LAST;
10622
10623 if ((GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5752) &&
10624 (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5755) &&
10625 (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5787) &&
10626 (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5784) &&
10627 (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5761) &&
10628 (tp->nvram_jedecnum == JEDEC_ST) &&
10629 (nvram_cmd & NVRAM_CMD_FIRST)) {
10630
10631 if ((ret = tg3_nvram_exec_cmd(tp,
10632 NVRAM_CMD_WREN | NVRAM_CMD_GO |
10633 NVRAM_CMD_DONE)))
10634
10635 break;
10636 }
10637 if (!(tp->tg3_flags2 & TG3_FLG2_FLASH)) {
10638 /* We always do complete word writes to eeprom. */
10639 nvram_cmd |= (NVRAM_CMD_FIRST | NVRAM_CMD_LAST);
10640 }
10641
10642 if ((ret = tg3_nvram_exec_cmd(tp, nvram_cmd)))
10643 break;
10644 }
10645 return ret;
10646 }
10647
10648 /* offset and length are dword aligned */
10649 static int tg3_nvram_write_block(struct tg3 *tp, u32 offset, u32 len, u8 *buf)
10650 {
10651 int ret;
10652
10653 if (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT) {
10654 tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl &
10655 ~GRC_LCLCTRL_GPIO_OUTPUT1);
10656 udelay(40);
10657 }
10658
10659 if (!(tp->tg3_flags & TG3_FLAG_NVRAM)) {
10660 ret = tg3_nvram_write_block_using_eeprom(tp, offset, len, buf);
10661 }
10662 else {
10663 u32 grc_mode;
10664
10665 ret = tg3_nvram_lock(tp);
10666 if (ret)
10667 return ret;
10668
10669 tg3_enable_nvram_access(tp);
10670 if ((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
10671 !(tp->tg3_flags2 & TG3_FLG2_PROTECTED_NVRAM))
10672 tw32(NVRAM_WRITE1, 0x406);
10673
10674 grc_mode = tr32(GRC_MODE);
10675 tw32(GRC_MODE, grc_mode | GRC_MODE_NVRAM_WR_ENABLE);
10676
10677 if ((tp->tg3_flags & TG3_FLAG_NVRAM_BUFFERED) ||
10678 !(tp->tg3_flags2 & TG3_FLG2_FLASH)) {
10679
10680 ret = tg3_nvram_write_block_buffered(tp, offset, len,
10681 buf);
10682 }
10683 else {
10684 ret = tg3_nvram_write_block_unbuffered(tp, offset, len,
10685 buf);
10686 }
10687
10688 grc_mode = tr32(GRC_MODE);
10689 tw32(GRC_MODE, grc_mode & ~GRC_MODE_NVRAM_WR_ENABLE);
10690
10691 tg3_disable_nvram_access(tp);
10692 tg3_nvram_unlock(tp);
10693 }
10694
10695 if (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT) {
10696 tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
10697 udelay(40);
10698 }
10699
10700 return ret;
10701 }
10702
10703 struct subsys_tbl_ent {
10704 u16 subsys_vendor, subsys_devid;
10705 u32 phy_id;
10706 };
10707
10708 static struct subsys_tbl_ent subsys_id_to_phy_id[] = {
10709 /* Broadcom boards. */
10710 { PCI_VENDOR_ID_BROADCOM, 0x1644, PHY_ID_BCM5401 }, /* BCM95700A6 */
10711 { PCI_VENDOR_ID_BROADCOM, 0x0001, PHY_ID_BCM5701 }, /* BCM95701A5 */
10712 { PCI_VENDOR_ID_BROADCOM, 0x0002, PHY_ID_BCM8002 }, /* BCM95700T6 */
10713 { PCI_VENDOR_ID_BROADCOM, 0x0003, 0 }, /* BCM95700A9 */
10714 { PCI_VENDOR_ID_BROADCOM, 0x0005, PHY_ID_BCM5701 }, /* BCM95701T1 */
10715 { PCI_VENDOR_ID_BROADCOM, 0x0006, PHY_ID_BCM5701 }, /* BCM95701T8 */
10716 { PCI_VENDOR_ID_BROADCOM, 0x0007, 0 }, /* BCM95701A7 */
10717 { PCI_VENDOR_ID_BROADCOM, 0x0008, PHY_ID_BCM5701 }, /* BCM95701A10 */
10718 { PCI_VENDOR_ID_BROADCOM, 0x8008, PHY_ID_BCM5701 }, /* BCM95701A12 */
10719 { PCI_VENDOR_ID_BROADCOM, 0x0009, PHY_ID_BCM5703 }, /* BCM95703Ax1 */
10720 { PCI_VENDOR_ID_BROADCOM, 0x8009, PHY_ID_BCM5703 }, /* BCM95703Ax2 */
10721
10722 /* 3com boards. */
10723 { PCI_VENDOR_ID_3COM, 0x1000, PHY_ID_BCM5401 }, /* 3C996T */
10724 { PCI_VENDOR_ID_3COM, 0x1006, PHY_ID_BCM5701 }, /* 3C996BT */
10725 { PCI_VENDOR_ID_3COM, 0x1004, 0 }, /* 3C996SX */
10726 { PCI_VENDOR_ID_3COM, 0x1007, PHY_ID_BCM5701 }, /* 3C1000T */
10727 { PCI_VENDOR_ID_3COM, 0x1008, PHY_ID_BCM5701 }, /* 3C940BR01 */
10728
10729 /* DELL boards. */
10730 { PCI_VENDOR_ID_DELL, 0x00d1, PHY_ID_BCM5401 }, /* VIPER */
10731 { PCI_VENDOR_ID_DELL, 0x0106, PHY_ID_BCM5401 }, /* JAGUAR */
10732 { PCI_VENDOR_ID_DELL, 0x0109, PHY_ID_BCM5411 }, /* MERLOT */
10733 { PCI_VENDOR_ID_DELL, 0x010a, PHY_ID_BCM5411 }, /* SLIM_MERLOT */
10734
10735 /* Compaq boards. */
10736 { PCI_VENDOR_ID_COMPAQ, 0x007c, PHY_ID_BCM5701 }, /* BANSHEE */
10737 { PCI_VENDOR_ID_COMPAQ, 0x009a, PHY_ID_BCM5701 }, /* BANSHEE_2 */
10738 { PCI_VENDOR_ID_COMPAQ, 0x007d, 0 }, /* CHANGELING */
10739 { PCI_VENDOR_ID_COMPAQ, 0x0085, PHY_ID_BCM5701 }, /* NC7780 */
10740 { PCI_VENDOR_ID_COMPAQ, 0x0099, PHY_ID_BCM5701 }, /* NC7780_2 */
10741
10742 /* IBM boards. */
10743 { PCI_VENDOR_ID_IBM, 0x0281, 0 } /* IBM??? */
10744 };
10745
10746 static inline struct subsys_tbl_ent *lookup_by_subsys(struct tg3 *tp)
10747 {
10748 int i;
10749
10750 for (i = 0; i < ARRAY_SIZE(subsys_id_to_phy_id); i++) {
10751 if ((subsys_id_to_phy_id[i].subsys_vendor ==
10752 tp->pdev->subsystem_vendor) &&
10753 (subsys_id_to_phy_id[i].subsys_devid ==
10754 tp->pdev->subsystem_device))
10755 return &subsys_id_to_phy_id[i];
10756 }
10757 return NULL;
10758 }
10759
10760 static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp)
10761 {
10762 u32 val;
10763 u16 pmcsr;
10764
10765 /* On some early chips the SRAM cannot be accessed in D3hot state,
10766 * so need make sure we're in D0.
10767 */
10768 pci_read_config_word(tp->pdev, tp->pm_cap + PCI_PM_CTRL, &pmcsr);
10769 pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
10770 pci_write_config_word(tp->pdev, tp->pm_cap + PCI_PM_CTRL, pmcsr);
10771 msleep(1);
10772
10773 /* Make sure register accesses (indirect or otherwise)
10774 * will function correctly.
10775 */
10776 pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
10777 tp->misc_host_ctrl);
10778
10779 /* The memory arbiter has to be enabled in order for SRAM accesses
10780 * to succeed. Normally on powerup the tg3 chip firmware will make
10781 * sure it is enabled, but other entities such as system netboot
10782 * code might disable it.
10783 */
10784 val = tr32(MEMARB_MODE);
10785 tw32(MEMARB_MODE, val | MEMARB_MODE_ENABLE);
10786
10787 tp->phy_id = PHY_ID_INVALID;
10788 tp->led_ctrl = LED_CTRL_MODE_PHY_1;
10789
10790 /* Assume an onboard device and WOL capable by default. */
10791 tp->tg3_flags |= TG3_FLAG_EEPROM_WRITE_PROT | TG3_FLAG_WOL_CAP;
10792
10793 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
10794 if (!(tr32(PCIE_TRANSACTION_CFG) & PCIE_TRANS_CFG_LOM)) {
10795 tp->tg3_flags &= ~TG3_FLAG_EEPROM_WRITE_PROT;
10796 tp->tg3_flags2 |= TG3_FLG2_IS_NIC;
10797 }
10798 val = tr32(VCPU_CFGSHDW);
10799 if (val & VCPU_CFGSHDW_ASPM_DBNC)
10800 tp->tg3_flags |= TG3_FLAG_ASPM_WORKAROUND;
10801 if ((val & VCPU_CFGSHDW_WOL_ENABLE) &&
10802 (val & VCPU_CFGSHDW_WOL_MAGPKT))
10803 tp->tg3_flags |= TG3_FLAG_WOL_ENABLE;
10804 return;
10805 }
10806
10807 tg3_read_mem(tp, NIC_SRAM_DATA_SIG, &val);
10808 if (val == NIC_SRAM_DATA_SIG_MAGIC) {
10809 u32 nic_cfg, led_cfg;
10810 u32 nic_phy_id, ver, cfg2 = 0, eeprom_phy_id;
10811 int eeprom_phy_serdes = 0;
10812
10813 tg3_read_mem(tp, NIC_SRAM_DATA_CFG, &nic_cfg);
10814 tp->nic_sram_data_cfg = nic_cfg;
10815
10816 tg3_read_mem(tp, NIC_SRAM_DATA_VER, &ver);
10817 ver >>= NIC_SRAM_DATA_VER_SHIFT;
10818 if ((GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700) &&
10819 (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701) &&
10820 (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5703) &&
10821 (ver > 0) && (ver < 0x100))
10822 tg3_read_mem(tp, NIC_SRAM_DATA_CFG_2, &cfg2);
10823
10824 if ((nic_cfg & NIC_SRAM_DATA_CFG_PHY_TYPE_MASK) ==
10825 NIC_SRAM_DATA_CFG_PHY_TYPE_FIBER)
10826 eeprom_phy_serdes = 1;
10827
10828 tg3_read_mem(tp, NIC_SRAM_DATA_PHY_ID, &nic_phy_id);
10829 if (nic_phy_id != 0) {
10830 u32 id1 = nic_phy_id & NIC_SRAM_DATA_PHY_ID1_MASK;
10831 u32 id2 = nic_phy_id & NIC_SRAM_DATA_PHY_ID2_MASK;
10832
10833 eeprom_phy_id = (id1 >> 16) << 10;
10834 eeprom_phy_id |= (id2 & 0xfc00) << 16;
10835 eeprom_phy_id |= (id2 & 0x03ff) << 0;
10836 } else
10837 eeprom_phy_id = 0;
10838
10839 tp->phy_id = eeprom_phy_id;
10840 if (eeprom_phy_serdes) {
10841 if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)
10842 tp->tg3_flags2 |= TG3_FLG2_MII_SERDES;
10843 else
10844 tp->tg3_flags2 |= TG3_FLG2_PHY_SERDES;
10845 }
10846
10847 if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
10848 led_cfg = cfg2 & (NIC_SRAM_DATA_CFG_LED_MODE_MASK |
10849 SHASTA_EXT_LED_MODE_MASK);
10850 else
10851 led_cfg = nic_cfg & NIC_SRAM_DATA_CFG_LED_MODE_MASK;
10852
10853 switch (led_cfg) {
10854 default:
10855 case NIC_SRAM_DATA_CFG_LED_MODE_PHY_1:
10856 tp->led_ctrl = LED_CTRL_MODE_PHY_1;
10857 break;
10858
10859 case NIC_SRAM_DATA_CFG_LED_MODE_PHY_2:
10860 tp->led_ctrl = LED_CTRL_MODE_PHY_2;
10861 break;
10862
10863 case NIC_SRAM_DATA_CFG_LED_MODE_MAC:
10864 tp->led_ctrl = LED_CTRL_MODE_MAC;
10865
10866 /* Default to PHY_1_MODE if 0 (MAC_MODE) is
10867 * read on some older 5700/5701 bootcode.
10868 */
10869 if (GET_ASIC_REV(tp->pci_chip_rev_id) ==
10870 ASIC_REV_5700 ||
10871 GET_ASIC_REV(tp->pci_chip_rev_id) ==
10872 ASIC_REV_5701)
10873 tp->led_ctrl = LED_CTRL_MODE_PHY_1;
10874
10875 break;
10876
10877 case SHASTA_EXT_LED_SHARED:
10878 tp->led_ctrl = LED_CTRL_MODE_SHARED;
10879 if (tp->pci_chip_rev_id != CHIPREV_ID_5750_A0 &&
10880 tp->pci_chip_rev_id != CHIPREV_ID_5750_A1)
10881 tp->led_ctrl |= (LED_CTRL_MODE_PHY_1 |
10882 LED_CTRL_MODE_PHY_2);
10883 break;
10884
10885 case SHASTA_EXT_LED_MAC:
10886 tp->led_ctrl = LED_CTRL_MODE_SHASTA_MAC;
10887 break;
10888
10889 case SHASTA_EXT_LED_COMBO:
10890 tp->led_ctrl = LED_CTRL_MODE_COMBO;
10891 if (tp->pci_chip_rev_id != CHIPREV_ID_5750_A0)
10892 tp->led_ctrl |= (LED_CTRL_MODE_PHY_1 |
10893 LED_CTRL_MODE_PHY_2);
10894 break;
10895
10896 };
10897
10898 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
10899 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701) &&
10900 tp->pdev->subsystem_vendor == PCI_VENDOR_ID_DELL)
10901 tp->led_ctrl = LED_CTRL_MODE_PHY_2;
10902
10903 if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5784_AX)
10904 tp->led_ctrl = LED_CTRL_MODE_PHY_1;
10905
10906 if (nic_cfg & NIC_SRAM_DATA_CFG_EEPROM_WP) {
10907 tp->tg3_flags |= TG3_FLAG_EEPROM_WRITE_PROT;
10908 if ((tp->pdev->subsystem_vendor ==
10909 PCI_VENDOR_ID_ARIMA) &&
10910 (tp->pdev->subsystem_device == 0x205a ||
10911 tp->pdev->subsystem_device == 0x2063))
10912 tp->tg3_flags &= ~TG3_FLAG_EEPROM_WRITE_PROT;
10913 } else {
10914 tp->tg3_flags &= ~TG3_FLAG_EEPROM_WRITE_PROT;
10915 tp->tg3_flags2 |= TG3_FLG2_IS_NIC;
10916 }
10917
10918 if (nic_cfg & NIC_SRAM_DATA_CFG_ASF_ENABLE) {
10919 tp->tg3_flags |= TG3_FLAG_ENABLE_ASF;
10920 if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
10921 tp->tg3_flags2 |= TG3_FLG2_ASF_NEW_HANDSHAKE;
10922 }
10923 if (nic_cfg & NIC_SRAM_DATA_CFG_APE_ENABLE)
10924 tp->tg3_flags3 |= TG3_FLG3_ENABLE_APE;
10925 if (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES &&
10926 !(nic_cfg & NIC_SRAM_DATA_CFG_FIBER_WOL))
10927 tp->tg3_flags &= ~TG3_FLAG_WOL_CAP;
10928
10929 if (tp->tg3_flags & TG3_FLAG_WOL_CAP &&
10930 nic_cfg & NIC_SRAM_DATA_CFG_WOL_ENABLE)
10931 tp->tg3_flags |= TG3_FLAG_WOL_ENABLE;
10932
10933 if (cfg2 & (1 << 17))
10934 tp->tg3_flags2 |= TG3_FLG2_CAPACITIVE_COUPLING;
10935
10936 /* serdes signal pre-emphasis in register 0x590 set by */
10937 /* bootcode if bit 18 is set */
10938 if (cfg2 & (1 << 18))
10939 tp->tg3_flags2 |= TG3_FLG2_SERDES_PREEMPHASIS;
10940
10941 if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
10942 u32 cfg3;
10943
10944 tg3_read_mem(tp, NIC_SRAM_DATA_CFG_3, &cfg3);
10945 if (cfg3 & NIC_SRAM_ASPM_DEBOUNCE)
10946 tp->tg3_flags |= TG3_FLAG_ASPM_WORKAROUND;
10947 }
10948 }
10949 }
10950
10951 static int __devinit tg3_issue_otp_command(struct tg3 *tp, u32 cmd)
10952 {
10953 int i;
10954 u32 val;
10955
10956 tw32(OTP_CTRL, cmd | OTP_CTRL_OTP_CMD_START);
10957 tw32(OTP_CTRL, cmd);
10958
10959 /* Wait for up to 1 ms for command to execute. */
10960 for (i = 0; i < 100; i++) {
10961 val = tr32(OTP_STATUS);
10962 if (val & OTP_STATUS_CMD_DONE)
10963 break;
10964 udelay(10);
10965 }
10966
10967 return (val & OTP_STATUS_CMD_DONE) ? 0 : -EBUSY;
10968 }
10969
10970 /* Read the gphy configuration from the OTP region of the chip. The gphy
10971 * configuration is a 32-bit value that straddles the alignment boundary.
10972 * We do two 32-bit reads and then shift and merge the results.
10973 */
10974 static u32 __devinit tg3_read_otp_phycfg(struct tg3 *tp)
10975 {
10976 u32 bhalf_otp, thalf_otp;
10977
10978 tw32(OTP_MODE, OTP_MODE_OTP_THRU_GRC);
10979
10980 if (tg3_issue_otp_command(tp, OTP_CTRL_OTP_CMD_INIT))
10981 return 0;
10982
10983 tw32(OTP_ADDRESS, OTP_ADDRESS_MAGIC1);
10984
10985 if (tg3_issue_otp_command(tp, OTP_CTRL_OTP_CMD_READ))
10986 return 0;
10987
10988 thalf_otp = tr32(OTP_READ_DATA);
10989
10990 tw32(OTP_ADDRESS, OTP_ADDRESS_MAGIC2);
10991
10992 if (tg3_issue_otp_command(tp, OTP_CTRL_OTP_CMD_READ))
10993 return 0;
10994
10995 bhalf_otp = tr32(OTP_READ_DATA);
10996
10997 return ((thalf_otp & 0x0000ffff) << 16) | (bhalf_otp >> 16);
10998 }
10999
11000 static int __devinit tg3_phy_probe(struct tg3 *tp)
11001 {
11002 u32 hw_phy_id_1, hw_phy_id_2;
11003 u32 hw_phy_id, hw_phy_id_masked;
11004 int err;
11005
11006 /* Reading the PHY ID register can conflict with ASF
11007 * firwmare access to the PHY hardware.
11008 */
11009 err = 0;
11010 if ((tp->tg3_flags & TG3_FLAG_ENABLE_ASF) ||
11011 (tp->tg3_flags3 & TG3_FLG3_ENABLE_APE)) {
11012 hw_phy_id = hw_phy_id_masked = PHY_ID_INVALID;
11013 } else {
11014 /* Now read the physical PHY_ID from the chip and verify
11015 * that it is sane. If it doesn't look good, we fall back
11016 * to either the hard-coded table based PHY_ID and failing
11017 * that the value found in the eeprom area.
11018 */
11019 err |= tg3_readphy(tp, MII_PHYSID1, &hw_phy_id_1);
11020 err |= tg3_readphy(tp, MII_PHYSID2, &hw_phy_id_2);
11021
11022 hw_phy_id = (hw_phy_id_1 & 0xffff) << 10;
11023 hw_phy_id |= (hw_phy_id_2 & 0xfc00) << 16;
11024 hw_phy_id |= (hw_phy_id_2 & 0x03ff) << 0;
11025
11026 hw_phy_id_masked = hw_phy_id & PHY_ID_MASK;
11027 }
11028
11029 if (!err && KNOWN_PHY_ID(hw_phy_id_masked)) {
11030 tp->phy_id = hw_phy_id;
11031 if (hw_phy_id_masked == PHY_ID_BCM8002)
11032 tp->tg3_flags2 |= TG3_FLG2_PHY_SERDES;
11033 else
11034 tp->tg3_flags2 &= ~TG3_FLG2_PHY_SERDES;
11035 } else {
11036 if (tp->phy_id != PHY_ID_INVALID) {
11037 /* Do nothing, phy ID already set up in
11038 * tg3_get_eeprom_hw_cfg().
11039 */
11040 } else {
11041 struct subsys_tbl_ent *p;
11042
11043 /* No eeprom signature? Try the hardcoded
11044 * subsys device table.
11045 */
11046 p = lookup_by_subsys(tp);
11047 if (!p)
11048 return -ENODEV;
11049
11050 tp->phy_id = p->phy_id;
11051 if (!tp->phy_id ||
11052 tp->phy_id == PHY_ID_BCM8002)
11053 tp->tg3_flags2 |= TG3_FLG2_PHY_SERDES;
11054 }
11055 }
11056
11057 if (!(tp->tg3_flags2 & TG3_FLG2_ANY_SERDES) &&
11058 !(tp->tg3_flags3 & TG3_FLG3_ENABLE_APE) &&
11059 !(tp->tg3_flags & TG3_FLAG_ENABLE_ASF)) {
11060 u32 bmsr, adv_reg, tg3_ctrl, mask;
11061
11062 tg3_readphy(tp, MII_BMSR, &bmsr);
11063 if (!tg3_readphy(tp, MII_BMSR, &bmsr) &&
11064 (bmsr & BMSR_LSTATUS))
11065 goto skip_phy_reset;
11066
11067 err = tg3_phy_reset(tp);
11068 if (err)
11069 return err;
11070
11071 adv_reg = (ADVERTISE_10HALF | ADVERTISE_10FULL |
11072 ADVERTISE_100HALF | ADVERTISE_100FULL |
11073 ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
11074 tg3_ctrl = 0;
11075 if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY)) {
11076 tg3_ctrl = (MII_TG3_CTRL_ADV_1000_HALF |
11077 MII_TG3_CTRL_ADV_1000_FULL);
11078 if (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0 ||
11079 tp->pci_chip_rev_id == CHIPREV_ID_5701_B0)
11080 tg3_ctrl |= (MII_TG3_CTRL_AS_MASTER |
11081 MII_TG3_CTRL_ENABLE_AS_MASTER);
11082 }
11083
11084 mask = (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full |
11085 ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full |
11086 ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full);
11087 if (!tg3_copper_is_advertising_all(tp, mask)) {
11088 tg3_writephy(tp, MII_ADVERTISE, adv_reg);
11089
11090 if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY))
11091 tg3_writephy(tp, MII_TG3_CTRL, tg3_ctrl);
11092
11093 tg3_writephy(tp, MII_BMCR,
11094 BMCR_ANENABLE | BMCR_ANRESTART);
11095 }
11096 tg3_phy_set_wirespeed(tp);
11097
11098 tg3_writephy(tp, MII_ADVERTISE, adv_reg);
11099 if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY))
11100 tg3_writephy(tp, MII_TG3_CTRL, tg3_ctrl);
11101 }
11102
11103 skip_phy_reset:
11104 if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401) {
11105 err = tg3_init_5401phy_dsp(tp);
11106 if (err)
11107 return err;
11108 }
11109
11110 if (!err && ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401)) {
11111 err = tg3_init_5401phy_dsp(tp);
11112 }
11113
11114 if (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES)
11115 tp->link_config.advertising =
11116 (ADVERTISED_1000baseT_Half |
11117 ADVERTISED_1000baseT_Full |
11118 ADVERTISED_Autoneg |
11119 ADVERTISED_FIBRE);
11120 if (tp->tg3_flags & TG3_FLAG_10_100_ONLY)
11121 tp->link_config.advertising &=
11122 ~(ADVERTISED_1000baseT_Half |
11123 ADVERTISED_1000baseT_Full);
11124
11125 return err;
11126 }
11127
11128 static void __devinit tg3_read_partno(struct tg3 *tp)
11129 {
11130 unsigned char vpd_data[256];
11131 unsigned int i;
11132 u32 magic;
11133
11134 if (tg3_nvram_read_swab(tp, 0x0, &magic))
11135 goto out_not_found;
11136
11137 if (magic == TG3_EEPROM_MAGIC) {
11138 for (i = 0; i < 256; i += 4) {
11139 u32 tmp;
11140
11141 if (tg3_nvram_read(tp, 0x100 + i, &tmp))
11142 goto out_not_found;
11143
11144 vpd_data[i + 0] = ((tmp >> 0) & 0xff);
11145 vpd_data[i + 1] = ((tmp >> 8) & 0xff);
11146 vpd_data[i + 2] = ((tmp >> 16) & 0xff);
11147 vpd_data[i + 3] = ((tmp >> 24) & 0xff);
11148 }
11149 } else {
11150 int vpd_cap;
11151
11152 vpd_cap = pci_find_capability(tp->pdev, PCI_CAP_ID_VPD);
11153 for (i = 0; i < 256; i += 4) {
11154 u32 tmp, j = 0;
11155 __le32 v;
11156 u16 tmp16;
11157
11158 pci_write_config_word(tp->pdev, vpd_cap + PCI_VPD_ADDR,
11159 i);
11160 while (j++ < 100) {
11161 pci_read_config_word(tp->pdev, vpd_cap +
11162 PCI_VPD_ADDR, &tmp16);
11163 if (tmp16 & 0x8000)
11164 break;
11165 msleep(1);
11166 }
11167 if (!(tmp16 & 0x8000))
11168 goto out_not_found;
11169
11170 pci_read_config_dword(tp->pdev, vpd_cap + PCI_VPD_DATA,
11171 &tmp);
11172 v = cpu_to_le32(tmp);
11173 memcpy(&vpd_data[i], &v, 4);
11174 }
11175 }
11176
11177 /* Now parse and find the part number. */
11178 for (i = 0; i < 254; ) {
11179 unsigned char val = vpd_data[i];
11180 unsigned int block_end;
11181
11182 if (val == 0x82 || val == 0x91) {
11183 i = (i + 3 +
11184 (vpd_data[i + 1] +
11185 (vpd_data[i + 2] << 8)));
11186 continue;
11187 }
11188
11189 if (val != 0x90)
11190 goto out_not_found;
11191
11192 block_end = (i + 3 +
11193 (vpd_data[i + 1] +
11194 (vpd_data[i + 2] << 8)));
11195 i += 3;
11196
11197 if (block_end > 256)
11198 goto out_not_found;
11199
11200 while (i < (block_end - 2)) {
11201 if (vpd_data[i + 0] == 'P' &&
11202 vpd_data[i + 1] == 'N') {
11203 int partno_len = vpd_data[i + 2];
11204
11205 i += 3;
11206 if (partno_len > 24 || (partno_len + i) > 256)
11207 goto out_not_found;
11208
11209 memcpy(tp->board_part_number,
11210 &vpd_data[i], partno_len);
11211
11212 /* Success. */
11213 return;
11214 }
11215 i += 3 + vpd_data[i + 2];
11216 }
11217
11218 /* Part number not found. */
11219 goto out_not_found;
11220 }
11221
11222 out_not_found:
11223 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
11224 strcpy(tp->board_part_number, "BCM95906");
11225 else
11226 strcpy(tp->board_part_number, "none");
11227 }
11228
11229 static int __devinit tg3_fw_img_is_valid(struct tg3 *tp, u32 offset)
11230 {
11231 u32 val;
11232
11233 if (tg3_nvram_read_swab(tp, offset, &val) ||
11234 (val & 0xfc000000) != 0x0c000000 ||
11235 tg3_nvram_read_swab(tp, offset + 4, &val) ||
11236 val != 0)
11237 return 0;
11238
11239 return 1;
11240 }
11241
11242 static void __devinit tg3_read_fw_ver(struct tg3 *tp)
11243 {
11244 u32 val, offset, start;
11245 u32 ver_offset;
11246 int i, bcnt;
11247
11248 if (tg3_nvram_read_swab(tp, 0, &val))
11249 return;
11250
11251 if (val != TG3_EEPROM_MAGIC)
11252 return;
11253
11254 if (tg3_nvram_read_swab(tp, 0xc, &offset) ||
11255 tg3_nvram_read_swab(tp, 0x4, &start))
11256 return;
11257
11258 offset = tg3_nvram_logical_addr(tp, offset);
11259
11260 if (!tg3_fw_img_is_valid(tp, offset) ||
11261 tg3_nvram_read_swab(tp, offset + 8, &ver_offset))
11262 return;
11263
11264 offset = offset + ver_offset - start;
11265 for (i = 0; i < 16; i += 4) {
11266 __le32 v;
11267 if (tg3_nvram_read_le(tp, offset + i, &v))
11268 return;
11269
11270 memcpy(tp->fw_ver + i, &v, 4);
11271 }
11272
11273 if (!(tp->tg3_flags & TG3_FLAG_ENABLE_ASF) ||
11274 (tp->tg3_flags3 & TG3_FLG3_ENABLE_APE))
11275 return;
11276
11277 for (offset = TG3_NVM_DIR_START;
11278 offset < TG3_NVM_DIR_END;
11279 offset += TG3_NVM_DIRENT_SIZE) {
11280 if (tg3_nvram_read_swab(tp, offset, &val))
11281 return;
11282
11283 if ((val >> TG3_NVM_DIRTYPE_SHIFT) == TG3_NVM_DIRTYPE_ASFINI)
11284 break;
11285 }
11286
11287 if (offset == TG3_NVM_DIR_END)
11288 return;
11289
11290 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS))
11291 start = 0x08000000;
11292 else if (tg3_nvram_read_swab(tp, offset - 4, &start))
11293 return;
11294
11295 if (tg3_nvram_read_swab(tp, offset + 4, &offset) ||
11296 !tg3_fw_img_is_valid(tp, offset) ||
11297 tg3_nvram_read_swab(tp, offset + 8, &val))
11298 return;
11299
11300 offset += val - start;
11301
11302 bcnt = strlen(tp->fw_ver);
11303
11304 tp->fw_ver[bcnt++] = ',';
11305 tp->fw_ver[bcnt++] = ' ';
11306
11307 for (i = 0; i < 4; i++) {
11308 __le32 v;
11309 if (tg3_nvram_read_le(tp, offset, &v))
11310 return;
11311
11312 offset += sizeof(v);
11313
11314 if (bcnt > TG3_VER_SIZE - sizeof(v)) {
11315 memcpy(&tp->fw_ver[bcnt], &v, TG3_VER_SIZE - bcnt);
11316 break;
11317 }
11318
11319 memcpy(&tp->fw_ver[bcnt], &v, sizeof(v));
11320 bcnt += sizeof(v);
11321 }
11322
11323 tp->fw_ver[TG3_VER_SIZE - 1] = 0;
11324 }
11325
11326 static struct pci_dev * __devinit tg3_find_peer(struct tg3 *);
11327
11328 static int __devinit tg3_get_invariants(struct tg3 *tp)
11329 {
11330 static struct pci_device_id write_reorder_chipsets[] = {
11331 { PCI_DEVICE(PCI_VENDOR_ID_AMD,
11332 PCI_DEVICE_ID_AMD_FE_GATE_700C) },
11333 { PCI_DEVICE(PCI_VENDOR_ID_AMD,
11334 PCI_DEVICE_ID_AMD_8131_BRIDGE) },
11335 { PCI_DEVICE(PCI_VENDOR_ID_VIA,
11336 PCI_DEVICE_ID_VIA_8385_0) },
11337 { },
11338 };
11339 u32 misc_ctrl_reg;
11340 u32 cacheline_sz_reg;
11341 u32 pci_state_reg, grc_misc_cfg;
11342 u32 val;
11343 u16 pci_cmd;
11344 int err, pcie_cap;
11345
11346 /* Force memory write invalidate off. If we leave it on,
11347 * then on 5700_BX chips we have to enable a workaround.
11348 * The workaround is to set the TG3PCI_DMA_RW_CTRL boundary
11349 * to match the cacheline size. The Broadcom driver have this
11350 * workaround but turns MWI off all the times so never uses
11351 * it. This seems to suggest that the workaround is insufficient.
11352 */
11353 pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
11354 pci_cmd &= ~PCI_COMMAND_INVALIDATE;
11355 pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
11356
11357 /* It is absolutely critical that TG3PCI_MISC_HOST_CTRL
11358 * has the register indirect write enable bit set before
11359 * we try to access any of the MMIO registers. It is also
11360 * critical that the PCI-X hw workaround situation is decided
11361 * before that as well.
11362 */
11363 pci_read_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
11364 &misc_ctrl_reg);
11365
11366 tp->pci_chip_rev_id = (misc_ctrl_reg >>
11367 MISC_HOST_CTRL_CHIPREV_SHIFT);
11368 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_USE_PROD_ID_REG) {
11369 u32 prod_id_asic_rev;
11370
11371 pci_read_config_dword(tp->pdev, TG3PCI_PRODID_ASICREV,
11372 &prod_id_asic_rev);
11373 tp->pci_chip_rev_id = prod_id_asic_rev & PROD_ID_ASIC_REV_MASK;
11374 }
11375
11376 /* Wrong chip ID in 5752 A0. This code can be removed later
11377 * as A0 is not in production.
11378 */
11379 if (tp->pci_chip_rev_id == CHIPREV_ID_5752_A0_HW)
11380 tp->pci_chip_rev_id = CHIPREV_ID_5752_A0;
11381
11382 /* If we have 5702/03 A1 or A2 on certain ICH chipsets,
11383 * we need to disable memory and use config. cycles
11384 * only to access all registers. The 5702/03 chips
11385 * can mistakenly decode the special cycles from the
11386 * ICH chipsets as memory write cycles, causing corruption
11387 * of register and memory space. Only certain ICH bridges
11388 * will drive special cycles with non-zero data during the
11389 * address phase which can fall within the 5703's address
11390 * range. This is not an ICH bug as the PCI spec allows
11391 * non-zero address during special cycles. However, only
11392 * these ICH bridges are known to drive non-zero addresses
11393 * during special cycles.
11394 *
11395 * Since special cycles do not cross PCI bridges, we only
11396 * enable this workaround if the 5703 is on the secondary
11397 * bus of these ICH bridges.
11398 */
11399 if ((tp->pci_chip_rev_id == CHIPREV_ID_5703_A1) ||
11400 (tp->pci_chip_rev_id == CHIPREV_ID_5703_A2)) {
11401 static struct tg3_dev_id {
11402 u32 vendor;
11403 u32 device;
11404 u32 rev;
11405 } ich_chipsets[] = {
11406 { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_8,
11407 PCI_ANY_ID },
11408 { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_8,
11409 PCI_ANY_ID },
11410 { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_11,
11411 0xa },
11412 { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_6,
11413 PCI_ANY_ID },
11414 { },
11415 };
11416 struct tg3_dev_id *pci_id = &ich_chipsets[0];
11417 struct pci_dev *bridge = NULL;
11418
11419 while (pci_id->vendor != 0) {
11420 bridge = pci_get_device(pci_id->vendor, pci_id->device,
11421 bridge);
11422 if (!bridge) {
11423 pci_id++;
11424 continue;
11425 }
11426 if (pci_id->rev != PCI_ANY_ID) {
11427 if (bridge->revision > pci_id->rev)
11428 continue;
11429 }
11430 if (bridge->subordinate &&
11431 (bridge->subordinate->number ==
11432 tp->pdev->bus->number)) {
11433
11434 tp->tg3_flags2 |= TG3_FLG2_ICH_WORKAROUND;
11435 pci_dev_put(bridge);
11436 break;
11437 }
11438 }
11439 }
11440
11441 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701)) {
11442 static struct tg3_dev_id {
11443 u32 vendor;
11444 u32 device;
11445 } bridge_chipsets[] = {
11446 { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PXH_0 },
11447 { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PXH_1 },
11448 { },
11449 };
11450 struct tg3_dev_id *pci_id = &bridge_chipsets[0];
11451 struct pci_dev *bridge = NULL;
11452
11453 while (pci_id->vendor != 0) {
11454 bridge = pci_get_device(pci_id->vendor,
11455 pci_id->device,
11456 bridge);
11457 if (!bridge) {
11458 pci_id++;
11459 continue;
11460 }
11461 if (bridge->subordinate &&
11462 (bridge->subordinate->number <=
11463 tp->pdev->bus->number) &&
11464 (bridge->subordinate->subordinate >=
11465 tp->pdev->bus->number)) {
11466 tp->tg3_flags3 |= TG3_FLG3_5701_DMA_BUG;
11467 pci_dev_put(bridge);
11468 break;
11469 }
11470 }
11471 }
11472
11473 /* The EPB bridge inside 5714, 5715, and 5780 cannot support
11474 * DMA addresses > 40-bit. This bridge may have other additional
11475 * 57xx devices behind it in some 4-port NIC designs for example.
11476 * Any tg3 device found behind the bridge will also need the 40-bit
11477 * DMA workaround.
11478 */
11479 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780 ||
11480 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714) {
11481 tp->tg3_flags2 |= TG3_FLG2_5780_CLASS;
11482 tp->tg3_flags |= TG3_FLAG_40BIT_DMA_BUG;
11483 tp->msi_cap = pci_find_capability(tp->pdev, PCI_CAP_ID_MSI);
11484 }
11485 else {
11486 struct pci_dev *bridge = NULL;
11487
11488 do {
11489 bridge = pci_get_device(PCI_VENDOR_ID_SERVERWORKS,
11490 PCI_DEVICE_ID_SERVERWORKS_EPB,
11491 bridge);
11492 if (bridge && bridge->subordinate &&
11493 (bridge->subordinate->number <=
11494 tp->pdev->bus->number) &&
11495 (bridge->subordinate->subordinate >=
11496 tp->pdev->bus->number)) {
11497 tp->tg3_flags |= TG3_FLAG_40BIT_DMA_BUG;
11498 pci_dev_put(bridge);
11499 break;
11500 }
11501 } while (bridge);
11502 }
11503
11504 /* Initialize misc host control in PCI block. */
11505 tp->misc_host_ctrl |= (misc_ctrl_reg &
11506 MISC_HOST_CTRL_CHIPREV);
11507 pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
11508 tp->misc_host_ctrl);
11509
11510 pci_read_config_dword(tp->pdev, TG3PCI_CACHELINESZ,
11511 &cacheline_sz_reg);
11512
11513 tp->pci_cacheline_sz = (cacheline_sz_reg >> 0) & 0xff;
11514 tp->pci_lat_timer = (cacheline_sz_reg >> 8) & 0xff;
11515 tp->pci_hdr_type = (cacheline_sz_reg >> 16) & 0xff;
11516 tp->pci_bist = (cacheline_sz_reg >> 24) & 0xff;
11517
11518 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) ||
11519 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714))
11520 tp->pdev_peer = tg3_find_peer(tp);
11521
11522 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750 ||
11523 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 ||
11524 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
11525 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
11526 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
11527 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761 ||
11528 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906 ||
11529 (tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
11530 tp->tg3_flags2 |= TG3_FLG2_5750_PLUS;
11531
11532 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) ||
11533 (tp->tg3_flags2 & TG3_FLG2_5750_PLUS))
11534 tp->tg3_flags2 |= TG3_FLG2_5705_PLUS;
11535
11536 if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS) {
11537 tp->tg3_flags |= TG3_FLAG_SUPPORT_MSI;
11538 if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5750_AX ||
11539 GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5750_BX ||
11540 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714 &&
11541 tp->pci_chip_rev_id <= CHIPREV_ID_5714_A2 &&
11542 tp->pdev_peer == tp->pdev))
11543 tp->tg3_flags &= ~TG3_FLAG_SUPPORT_MSI;
11544
11545 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
11546 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
11547 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
11548 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761 ||
11549 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
11550 tp->tg3_flags2 |= TG3_FLG2_HW_TSO_2;
11551 tp->tg3_flags2 |= TG3_FLG2_1SHOT_MSI;
11552 } else {
11553 tp->tg3_flags2 |= TG3_FLG2_HW_TSO_1 | TG3_FLG2_TSO_BUG;
11554 if (GET_ASIC_REV(tp->pci_chip_rev_id) ==
11555 ASIC_REV_5750 &&
11556 tp->pci_chip_rev_id >= CHIPREV_ID_5750_C2)
11557 tp->tg3_flags2 &= ~TG3_FLG2_TSO_BUG;
11558 }
11559 }
11560
11561 if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5705 &&
11562 GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5750 &&
11563 GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5752 &&
11564 GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5755 &&
11565 GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5787 &&
11566 GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5784 &&
11567 GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5761 &&
11568 GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5906)
11569 tp->tg3_flags2 |= TG3_FLG2_JUMBO_CAPABLE;
11570
11571 pcie_cap = pci_find_capability(tp->pdev, PCI_CAP_ID_EXP);
11572 if (pcie_cap != 0) {
11573 tp->tg3_flags2 |= TG3_FLG2_PCI_EXPRESS;
11574
11575 pcie_set_readrq(tp->pdev, 4096);
11576
11577 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
11578 u16 lnkctl;
11579
11580 pci_read_config_word(tp->pdev,
11581 pcie_cap + PCI_EXP_LNKCTL,
11582 &lnkctl);
11583 if (lnkctl & PCI_EXP_LNKCTL_CLKREQ_EN)
11584 tp->tg3_flags2 &= ~TG3_FLG2_HW_TSO_2;
11585 }
11586 }
11587
11588 /* If we have an AMD 762 or VIA K8T800 chipset, write
11589 * reordering to the mailbox registers done by the host
11590 * controller can cause major troubles. We read back from
11591 * every mailbox register write to force the writes to be
11592 * posted to the chip in order.
11593 */
11594 if (pci_dev_present(write_reorder_chipsets) &&
11595 !(tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS))
11596 tp->tg3_flags |= TG3_FLAG_MBOX_WRITE_REORDER;
11597
11598 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 &&
11599 tp->pci_lat_timer < 64) {
11600 tp->pci_lat_timer = 64;
11601
11602 cacheline_sz_reg = ((tp->pci_cacheline_sz & 0xff) << 0);
11603 cacheline_sz_reg |= ((tp->pci_lat_timer & 0xff) << 8);
11604 cacheline_sz_reg |= ((tp->pci_hdr_type & 0xff) << 16);
11605 cacheline_sz_reg |= ((tp->pci_bist & 0xff) << 24);
11606
11607 pci_write_config_dword(tp->pdev, TG3PCI_CACHELINESZ,
11608 cacheline_sz_reg);
11609 }
11610
11611 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS) ||
11612 (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)) {
11613 tp->pcix_cap = pci_find_capability(tp->pdev, PCI_CAP_ID_PCIX);
11614 if (!tp->pcix_cap) {
11615 printk(KERN_ERR PFX "Cannot find PCI-X "
11616 "capability, aborting.\n");
11617 return -EIO;
11618 }
11619 }
11620
11621 pci_read_config_dword(tp->pdev, TG3PCI_PCISTATE,
11622 &pci_state_reg);
11623
11624 if (tp->pcix_cap && (pci_state_reg & PCISTATE_CONV_PCI_MODE) == 0) {
11625 tp->tg3_flags |= TG3_FLAG_PCIX_MODE;
11626
11627 /* If this is a 5700 BX chipset, and we are in PCI-X
11628 * mode, enable register write workaround.
11629 *
11630 * The workaround is to use indirect register accesses
11631 * for all chip writes not to mailbox registers.
11632 */
11633 if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5700_BX) {
11634 u32 pm_reg;
11635
11636 tp->tg3_flags |= TG3_FLAG_PCIX_TARGET_HWBUG;
11637
11638 /* The chip can have it's power management PCI config
11639 * space registers clobbered due to this bug.
11640 * So explicitly force the chip into D0 here.
11641 */
11642 pci_read_config_dword(tp->pdev,
11643 tp->pm_cap + PCI_PM_CTRL,
11644 &pm_reg);
11645 pm_reg &= ~PCI_PM_CTRL_STATE_MASK;
11646 pm_reg |= PCI_PM_CTRL_PME_ENABLE | 0 /* D0 */;
11647 pci_write_config_dword(tp->pdev,
11648 tp->pm_cap + PCI_PM_CTRL,
11649 pm_reg);
11650
11651 /* Also, force SERR#/PERR# in PCI command. */
11652 pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
11653 pci_cmd |= PCI_COMMAND_PARITY | PCI_COMMAND_SERR;
11654 pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
11655 }
11656 }
11657
11658 /* 5700 BX chips need to have their TX producer index mailboxes
11659 * written twice to workaround a bug.
11660 */
11661 if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5700_BX)
11662 tp->tg3_flags |= TG3_FLAG_TXD_MBOX_HWBUG;
11663
11664 if ((pci_state_reg & PCISTATE_BUS_SPEED_HIGH) != 0)
11665 tp->tg3_flags |= TG3_FLAG_PCI_HIGH_SPEED;
11666 if ((pci_state_reg & PCISTATE_BUS_32BIT) != 0)
11667 tp->tg3_flags |= TG3_FLAG_PCI_32BIT;
11668
11669 /* Chip-specific fixup from Broadcom driver */
11670 if ((tp->pci_chip_rev_id == CHIPREV_ID_5704_A0) &&
11671 (!(pci_state_reg & PCISTATE_RETRY_SAME_DMA))) {
11672 pci_state_reg |= PCISTATE_RETRY_SAME_DMA;
11673 pci_write_config_dword(tp->pdev, TG3PCI_PCISTATE, pci_state_reg);
11674 }
11675
11676 /* Default fast path register access methods */
11677 tp->read32 = tg3_read32;
11678 tp->write32 = tg3_write32;
11679 tp->read32_mbox = tg3_read32;
11680 tp->write32_mbox = tg3_write32;
11681 tp->write32_tx_mbox = tg3_write32;
11682 tp->write32_rx_mbox = tg3_write32;
11683
11684 /* Various workaround register access methods */
11685 if (tp->tg3_flags & TG3_FLAG_PCIX_TARGET_HWBUG)
11686 tp->write32 = tg3_write_indirect_reg32;
11687 else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701 ||
11688 ((tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) &&
11689 tp->pci_chip_rev_id == CHIPREV_ID_5750_A0)) {
11690 /*
11691 * Back to back register writes can cause problems on these
11692 * chips, the workaround is to read back all reg writes
11693 * except those to mailbox regs.
11694 *
11695 * See tg3_write_indirect_reg32().
11696 */
11697 tp->write32 = tg3_write_flush_reg32;
11698 }
11699
11700
11701 if ((tp->tg3_flags & TG3_FLAG_TXD_MBOX_HWBUG) ||
11702 (tp->tg3_flags & TG3_FLAG_MBOX_WRITE_REORDER)) {
11703 tp->write32_tx_mbox = tg3_write32_tx_mbox;
11704 if (tp->tg3_flags & TG3_FLAG_MBOX_WRITE_REORDER)
11705 tp->write32_rx_mbox = tg3_write_flush_reg32;
11706 }
11707
11708 if (tp->tg3_flags2 & TG3_FLG2_ICH_WORKAROUND) {
11709 tp->read32 = tg3_read_indirect_reg32;
11710 tp->write32 = tg3_write_indirect_reg32;
11711 tp->read32_mbox = tg3_read_indirect_mbox;
11712 tp->write32_mbox = tg3_write_indirect_mbox;
11713 tp->write32_tx_mbox = tg3_write_indirect_mbox;
11714 tp->write32_rx_mbox = tg3_write_indirect_mbox;
11715
11716 iounmap(tp->regs);
11717 tp->regs = NULL;
11718
11719 pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
11720 pci_cmd &= ~PCI_COMMAND_MEMORY;
11721 pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
11722 }
11723 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
11724 tp->read32_mbox = tg3_read32_mbox_5906;
11725 tp->write32_mbox = tg3_write32_mbox_5906;
11726 tp->write32_tx_mbox = tg3_write32_mbox_5906;
11727 tp->write32_rx_mbox = tg3_write32_mbox_5906;
11728 }
11729
11730 if (tp->write32 == tg3_write_indirect_reg32 ||
11731 ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) &&
11732 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
11733 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701)))
11734 tp->tg3_flags |= TG3_FLAG_SRAM_USE_CONFIG;
11735
11736 /* Get eeprom hw config before calling tg3_set_power_state().
11737 * In particular, the TG3_FLG2_IS_NIC flag must be
11738 * determined before calling tg3_set_power_state() so that
11739 * we know whether or not to switch out of Vaux power.
11740 * When the flag is set, it means that GPIO1 is used for eeprom
11741 * write protect and also implies that it is a LOM where GPIOs
11742 * are not used to switch power.
11743 */
11744 tg3_get_eeprom_hw_cfg(tp);
11745
11746 if (tp->tg3_flags3 & TG3_FLG3_ENABLE_APE) {
11747 /* Allow reads and writes to the
11748 * APE register and memory space.
11749 */
11750 pci_state_reg |= PCISTATE_ALLOW_APE_CTLSPC_WR |
11751 PCISTATE_ALLOW_APE_SHMEM_WR;
11752 pci_write_config_dword(tp->pdev, TG3PCI_PCISTATE,
11753 pci_state_reg);
11754 }
11755
11756 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
11757 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761) {
11758 tp->tg3_flags |= TG3_FLAG_CPMU_PRESENT;
11759
11760 if (tp->pci_chip_rev_id == CHIPREV_ID_5784_A0 ||
11761 tp->pci_chip_rev_id == CHIPREV_ID_5784_A1 ||
11762 tp->pci_chip_rev_id == CHIPREV_ID_5761_A0 ||
11763 tp->pci_chip_rev_id == CHIPREV_ID_5761_A1)
11764 tp->tg3_flags3 |= TG3_FLG3_5761_5784_AX_FIXES;
11765 }
11766
11767 /* Set up tp->grc_local_ctrl before calling tg3_set_power_state().
11768 * GPIO1 driven high will bring 5700's external PHY out of reset.
11769 * It is also used as eeprom write protect on LOMs.
11770 */
11771 tp->grc_local_ctrl = GRC_LCLCTRL_INT_ON_ATTN | GRC_LCLCTRL_AUTO_SEEPROM;
11772 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700) ||
11773 (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT))
11774 tp->grc_local_ctrl |= (GRC_LCLCTRL_GPIO_OE1 |
11775 GRC_LCLCTRL_GPIO_OUTPUT1);
11776 /* Unused GPIO3 must be driven as output on 5752 because there
11777 * are no pull-up resistors on unused GPIO pins.
11778 */
11779 else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752)
11780 tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_OE3;
11781
11782 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755)
11783 tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_UART_SEL;
11784
11785 if (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5761) {
11786 /* Turn off the debug UART. */
11787 tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_UART_SEL;
11788 if (tp->tg3_flags2 & TG3_FLG2_IS_NIC)
11789 /* Keep VMain power. */
11790 tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_OE0 |
11791 GRC_LCLCTRL_GPIO_OUTPUT0;
11792 }
11793
11794 /* Force the chip into D0. */
11795 err = tg3_set_power_state(tp, PCI_D0);
11796 if (err) {
11797 printk(KERN_ERR PFX "(%s) transition to D0 failed\n",
11798 pci_name(tp->pdev));
11799 return err;
11800 }
11801
11802 /* 5700 B0 chips do not support checksumming correctly due
11803 * to hardware bugs.
11804 */
11805 if (tp->pci_chip_rev_id == CHIPREV_ID_5700_B0)
11806 tp->tg3_flags |= TG3_FLAG_BROKEN_CHECKSUMS;
11807
11808 /* Derive initial jumbo mode from MTU assigned in
11809 * ether_setup() via the alloc_etherdev() call
11810 */
11811 if (tp->dev->mtu > ETH_DATA_LEN &&
11812 !(tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
11813 tp->tg3_flags |= TG3_FLAG_JUMBO_RING_ENABLE;
11814
11815 /* Determine WakeOnLan speed to use. */
11816 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
11817 tp->pci_chip_rev_id == CHIPREV_ID_5701_A0 ||
11818 tp->pci_chip_rev_id == CHIPREV_ID_5701_B0 ||
11819 tp->pci_chip_rev_id == CHIPREV_ID_5701_B2) {
11820 tp->tg3_flags &= ~(TG3_FLAG_WOL_SPEED_100MB);
11821 } else {
11822 tp->tg3_flags |= TG3_FLAG_WOL_SPEED_100MB;
11823 }
11824
11825 /* A few boards don't want Ethernet@WireSpeed phy feature */
11826 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700) ||
11827 ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) &&
11828 (tp->pci_chip_rev_id != CHIPREV_ID_5705_A0) &&
11829 (tp->pci_chip_rev_id != CHIPREV_ID_5705_A1)) ||
11830 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) ||
11831 (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES))
11832 tp->tg3_flags2 |= TG3_FLG2_NO_ETH_WIRE_SPEED;
11833
11834 if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5703_AX ||
11835 GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5704_AX)
11836 tp->tg3_flags2 |= TG3_FLG2_PHY_ADC_BUG;
11837 if (tp->pci_chip_rev_id == CHIPREV_ID_5704_A0)
11838 tp->tg3_flags2 |= TG3_FLG2_PHY_5704_A0_BUG;
11839
11840 if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
11841 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
11842 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
11843 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
11844 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761) {
11845 if (tp->pdev->device != PCI_DEVICE_ID_TIGON3_5756 &&
11846 tp->pdev->device != PCI_DEVICE_ID_TIGON3_5722)
11847 tp->tg3_flags2 |= TG3_FLG2_PHY_JITTER_BUG;
11848 if (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5755M)
11849 tp->tg3_flags2 |= TG3_FLG2_PHY_ADJUST_TRIM;
11850 } else if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5906)
11851 tp->tg3_flags2 |= TG3_FLG2_PHY_BER_BUG;
11852 }
11853
11854 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 &&
11855 GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5784_AX) {
11856 tp->phy_otp = tg3_read_otp_phycfg(tp);
11857 if (tp->phy_otp == 0)
11858 tp->phy_otp = TG3_OTP_DEFAULT;
11859 }
11860
11861 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
11862 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761)
11863 tp->mi_mode = MAC_MI_MODE_500KHZ_CONST;
11864 else
11865 tp->mi_mode = MAC_MI_MODE_BASE;
11866
11867 tp->coalesce_mode = 0;
11868 if (GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5700_AX &&
11869 GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5700_BX)
11870 tp->coalesce_mode |= HOSTCC_MODE_32BYTE;
11871
11872 /* Initialize MAC MI mode, polling disabled. */
11873 tw32_f(MAC_MI_MODE, tp->mi_mode);
11874 udelay(80);
11875
11876 /* Initialize data/descriptor byte/word swapping. */
11877 val = tr32(GRC_MODE);
11878 val &= GRC_MODE_HOST_STACKUP;
11879 tw32(GRC_MODE, val | tp->grc_mode);
11880
11881 tg3_switch_clocks(tp);
11882
11883 /* Clear this out for sanity. */
11884 tw32(TG3PCI_MEM_WIN_BASE_ADDR, 0);
11885
11886 pci_read_config_dword(tp->pdev, TG3PCI_PCISTATE,
11887 &pci_state_reg);
11888 if ((pci_state_reg & PCISTATE_CONV_PCI_MODE) == 0 &&
11889 (tp->tg3_flags & TG3_FLAG_PCIX_TARGET_HWBUG) == 0) {
11890 u32 chiprevid = GET_CHIP_REV_ID(tp->misc_host_ctrl);
11891
11892 if (chiprevid == CHIPREV_ID_5701_A0 ||
11893 chiprevid == CHIPREV_ID_5701_B0 ||
11894 chiprevid == CHIPREV_ID_5701_B2 ||
11895 chiprevid == CHIPREV_ID_5701_B5) {
11896 void __iomem *sram_base;
11897
11898 /* Write some dummy words into the SRAM status block
11899 * area, see if it reads back correctly. If the return
11900 * value is bad, force enable the PCIX workaround.
11901 */
11902 sram_base = tp->regs + NIC_SRAM_WIN_BASE + NIC_SRAM_STATS_BLK;
11903
11904 writel(0x00000000, sram_base);
11905 writel(0x00000000, sram_base + 4);
11906 writel(0xffffffff, sram_base + 4);
11907 if (readl(sram_base) != 0x00000000)
11908 tp->tg3_flags |= TG3_FLAG_PCIX_TARGET_HWBUG;
11909 }
11910 }
11911
11912 udelay(50);
11913 tg3_nvram_init(tp);
11914
11915 grc_misc_cfg = tr32(GRC_MISC_CFG);
11916 grc_misc_cfg &= GRC_MISC_CFG_BOARD_ID_MASK;
11917
11918 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 &&
11919 (grc_misc_cfg == GRC_MISC_CFG_BOARD_ID_5788 ||
11920 grc_misc_cfg == GRC_MISC_CFG_BOARD_ID_5788M))
11921 tp->tg3_flags2 |= TG3_FLG2_IS_5788;
11922
11923 if (!(tp->tg3_flags2 & TG3_FLG2_IS_5788) &&
11924 (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700))
11925 tp->tg3_flags |= TG3_FLAG_TAGGED_STATUS;
11926 if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS) {
11927 tp->coalesce_mode |= (HOSTCC_MODE_CLRTICK_RXBD |
11928 HOSTCC_MODE_CLRTICK_TXBD);
11929
11930 tp->misc_host_ctrl |= MISC_HOST_CTRL_TAGGED_STATUS;
11931 pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
11932 tp->misc_host_ctrl);
11933 }
11934
11935 /* these are limited to 10/100 only */
11936 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 &&
11937 (grc_misc_cfg == 0x8000 || grc_misc_cfg == 0x4000)) ||
11938 (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 &&
11939 tp->pdev->vendor == PCI_VENDOR_ID_BROADCOM &&
11940 (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5901 ||
11941 tp->pdev->device == PCI_DEVICE_ID_TIGON3_5901_2 ||
11942 tp->pdev->device == PCI_DEVICE_ID_TIGON3_5705F)) ||
11943 (tp->pdev->vendor == PCI_VENDOR_ID_BROADCOM &&
11944 (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5751F ||
11945 tp->pdev->device == PCI_DEVICE_ID_TIGON3_5753F ||
11946 tp->pdev->device == PCI_DEVICE_ID_TIGON3_5787F)) ||
11947 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
11948 tp->tg3_flags |= TG3_FLAG_10_100_ONLY;
11949
11950 err = tg3_phy_probe(tp);
11951 if (err) {
11952 printk(KERN_ERR PFX "(%s) phy probe failed, err %d\n",
11953 pci_name(tp->pdev), err);
11954 /* ... but do not return immediately ... */
11955 }
11956
11957 tg3_read_partno(tp);
11958 tg3_read_fw_ver(tp);
11959
11960 if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
11961 tp->tg3_flags &= ~TG3_FLAG_USE_MI_INTERRUPT;
11962 } else {
11963 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700)
11964 tp->tg3_flags |= TG3_FLAG_USE_MI_INTERRUPT;
11965 else
11966 tp->tg3_flags &= ~TG3_FLAG_USE_MI_INTERRUPT;
11967 }
11968
11969 /* 5700 {AX,BX} chips have a broken status block link
11970 * change bit implementation, so we must use the
11971 * status register in those cases.
11972 */
11973 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700)
11974 tp->tg3_flags |= TG3_FLAG_USE_LINKCHG_REG;
11975 else
11976 tp->tg3_flags &= ~TG3_FLAG_USE_LINKCHG_REG;
11977
11978 /* The led_ctrl is set during tg3_phy_probe, here we might
11979 * have to force the link status polling mechanism based
11980 * upon subsystem IDs.
11981 */
11982 if (tp->pdev->subsystem_vendor == PCI_VENDOR_ID_DELL &&
11983 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701 &&
11984 !(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)) {
11985 tp->tg3_flags |= (TG3_FLAG_USE_MI_INTERRUPT |
11986 TG3_FLAG_USE_LINKCHG_REG);
11987 }
11988
11989 /* For all SERDES we poll the MAC status register. */
11990 if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
11991 tp->tg3_flags |= TG3_FLAG_POLL_SERDES;
11992 else
11993 tp->tg3_flags &= ~TG3_FLAG_POLL_SERDES;
11994
11995 /* All chips before 5787 can get confused if TX buffers
11996 * straddle the 4GB address boundary in some cases.
11997 */
11998 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
11999 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
12000 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
12001 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761 ||
12002 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
12003 tp->dev->hard_start_xmit = tg3_start_xmit;
12004 else
12005 tp->dev->hard_start_xmit = tg3_start_xmit_dma_bug;
12006
12007 tp->rx_offset = 2;
12008 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701 &&
12009 (tp->tg3_flags & TG3_FLAG_PCIX_MODE) != 0)
12010 tp->rx_offset = 0;
12011
12012 tp->rx_std_max_post = TG3_RX_RING_SIZE;
12013
12014 /* Increment the rx prod index on the rx std ring by at most
12015 * 8 for these chips to workaround hw errata.
12016 */
12017 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750 ||
12018 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 ||
12019 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755)
12020 tp->rx_std_max_post = 8;
12021
12022 if (tp->tg3_flags & TG3_FLAG_ASPM_WORKAROUND)
12023 tp->pwrmgmt_thresh = tr32(PCIE_PWR_MGMT_THRESH) &
12024 PCIE_PWR_MGMT_L1_THRESH_MSK;
12025
12026 return err;
12027 }
12028
12029 #ifdef CONFIG_SPARC
12030 static int __devinit tg3_get_macaddr_sparc(struct tg3 *tp)
12031 {
12032 struct net_device *dev = tp->dev;
12033 struct pci_dev *pdev = tp->pdev;
12034 struct device_node *dp = pci_device_to_OF_node(pdev);
12035 const unsigned char *addr;
12036 int len;
12037
12038 addr = of_get_property(dp, "local-mac-address", &len);
12039 if (addr && len == 6) {
12040 memcpy(dev->dev_addr, addr, 6);
12041 memcpy(dev->perm_addr, dev->dev_addr, 6);
12042 return 0;
12043 }
12044 return -ENODEV;
12045 }
12046
12047 static int __devinit tg3_get_default_macaddr_sparc(struct tg3 *tp)
12048 {
12049 struct net_device *dev = tp->dev;
12050
12051 memcpy(dev->dev_addr, idprom->id_ethaddr, 6);
12052 memcpy(dev->perm_addr, idprom->id_ethaddr, 6);
12053 return 0;
12054 }
12055 #endif
12056
12057 static int __devinit tg3_get_device_address(struct tg3 *tp)
12058 {
12059 struct net_device *dev = tp->dev;
12060 u32 hi, lo, mac_offset;
12061 int addr_ok = 0;
12062
12063 #ifdef CONFIG_SPARC
12064 if (!tg3_get_macaddr_sparc(tp))
12065 return 0;
12066 #endif
12067
12068 mac_offset = 0x7c;
12069 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) ||
12070 (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)) {
12071 if (tr32(TG3PCI_DUAL_MAC_CTRL) & DUAL_MAC_CTRL_ID)
12072 mac_offset = 0xcc;
12073 if (tg3_nvram_lock(tp))
12074 tw32_f(NVRAM_CMD, NVRAM_CMD_RESET);
12075 else
12076 tg3_nvram_unlock(tp);
12077 }
12078 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
12079 mac_offset = 0x10;
12080
12081 /* First try to get it from MAC address mailbox. */
12082 tg3_read_mem(tp, NIC_SRAM_MAC_ADDR_HIGH_MBOX, &hi);
12083 if ((hi >> 16) == 0x484b) {
12084 dev->dev_addr[0] = (hi >> 8) & 0xff;
12085 dev->dev_addr[1] = (hi >> 0) & 0xff;
12086
12087 tg3_read_mem(tp, NIC_SRAM_MAC_ADDR_LOW_MBOX, &lo);
12088 dev->dev_addr[2] = (lo >> 24) & 0xff;
12089 dev->dev_addr[3] = (lo >> 16) & 0xff;
12090 dev->dev_addr[4] = (lo >> 8) & 0xff;
12091 dev->dev_addr[5] = (lo >> 0) & 0xff;
12092
12093 /* Some old bootcode may report a 0 MAC address in SRAM */
12094 addr_ok = is_valid_ether_addr(&dev->dev_addr[0]);
12095 }
12096 if (!addr_ok) {
12097 /* Next, try NVRAM. */
12098 if (!tg3_nvram_read(tp, mac_offset + 0, &hi) &&
12099 !tg3_nvram_read(tp, mac_offset + 4, &lo)) {
12100 dev->dev_addr[0] = ((hi >> 16) & 0xff);
12101 dev->dev_addr[1] = ((hi >> 24) & 0xff);
12102 dev->dev_addr[2] = ((lo >> 0) & 0xff);
12103 dev->dev_addr[3] = ((lo >> 8) & 0xff);
12104 dev->dev_addr[4] = ((lo >> 16) & 0xff);
12105 dev->dev_addr[5] = ((lo >> 24) & 0xff);
12106 }
12107 /* Finally just fetch it out of the MAC control regs. */
12108 else {
12109 hi = tr32(MAC_ADDR_0_HIGH);
12110 lo = tr32(MAC_ADDR_0_LOW);
12111
12112 dev->dev_addr[5] = lo & 0xff;
12113 dev->dev_addr[4] = (lo >> 8) & 0xff;
12114 dev->dev_addr[3] = (lo >> 16) & 0xff;
12115 dev->dev_addr[2] = (lo >> 24) & 0xff;
12116 dev->dev_addr[1] = hi & 0xff;
12117 dev->dev_addr[0] = (hi >> 8) & 0xff;
12118 }
12119 }
12120
12121 if (!is_valid_ether_addr(&dev->dev_addr[0])) {
12122 #ifdef CONFIG_SPARC
12123 if (!tg3_get_default_macaddr_sparc(tp))
12124 return 0;
12125 #endif
12126 return -EINVAL;
12127 }
12128 memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
12129 return 0;
12130 }
12131
12132 #define BOUNDARY_SINGLE_CACHELINE 1
12133 #define BOUNDARY_MULTI_CACHELINE 2
12134
12135 static u32 __devinit tg3_calc_dma_bndry(struct tg3 *tp, u32 val)
12136 {
12137 int cacheline_size;
12138 u8 byte;
12139 int goal;
12140
12141 pci_read_config_byte(tp->pdev, PCI_CACHE_LINE_SIZE, &byte);
12142 if (byte == 0)
12143 cacheline_size = 1024;
12144 else
12145 cacheline_size = (int) byte * 4;
12146
12147 /* On 5703 and later chips, the boundary bits have no
12148 * effect.
12149 */
12150 if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700 &&
12151 GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701 &&
12152 !(tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS))
12153 goto out;
12154
12155 #if defined(CONFIG_PPC64) || defined(CONFIG_IA64) || defined(CONFIG_PARISC)
12156 goal = BOUNDARY_MULTI_CACHELINE;
12157 #else
12158 #if defined(CONFIG_SPARC64) || defined(CONFIG_ALPHA)
12159 goal = BOUNDARY_SINGLE_CACHELINE;
12160 #else
12161 goal = 0;
12162 #endif
12163 #endif
12164
12165 if (!goal)
12166 goto out;
12167
12168 /* PCI controllers on most RISC systems tend to disconnect
12169 * when a device tries to burst across a cache-line boundary.
12170 * Therefore, letting tg3 do so just wastes PCI bandwidth.
12171 *
12172 * Unfortunately, for PCI-E there are only limited
12173 * write-side controls for this, and thus for reads
12174 * we will still get the disconnects. We'll also waste
12175 * these PCI cycles for both read and write for chips
12176 * other than 5700 and 5701 which do not implement the
12177 * boundary bits.
12178 */
12179 if ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) &&
12180 !(tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS)) {
12181 switch (cacheline_size) {
12182 case 16:
12183 case 32:
12184 case 64:
12185 case 128:
12186 if (goal == BOUNDARY_SINGLE_CACHELINE) {
12187 val |= (DMA_RWCTRL_READ_BNDRY_128_PCIX |
12188 DMA_RWCTRL_WRITE_BNDRY_128_PCIX);
12189 } else {
12190 val |= (DMA_RWCTRL_READ_BNDRY_384_PCIX |
12191 DMA_RWCTRL_WRITE_BNDRY_384_PCIX);
12192 }
12193 break;
12194
12195 case 256:
12196 val |= (DMA_RWCTRL_READ_BNDRY_256_PCIX |
12197 DMA_RWCTRL_WRITE_BNDRY_256_PCIX);
12198 break;
12199
12200 default:
12201 val |= (DMA_RWCTRL_READ_BNDRY_384_PCIX |
12202 DMA_RWCTRL_WRITE_BNDRY_384_PCIX);
12203 break;
12204 };
12205 } else if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
12206 switch (cacheline_size) {
12207 case 16:
12208 case 32:
12209 case 64:
12210 if (goal == BOUNDARY_SINGLE_CACHELINE) {
12211 val &= ~DMA_RWCTRL_WRITE_BNDRY_DISAB_PCIE;
12212 val |= DMA_RWCTRL_WRITE_BNDRY_64_PCIE;
12213 break;
12214 }
12215 /* fallthrough */
12216 case 128:
12217 default:
12218 val &= ~DMA_RWCTRL_WRITE_BNDRY_DISAB_PCIE;
12219 val |= DMA_RWCTRL_WRITE_BNDRY_128_PCIE;
12220 break;
12221 };
12222 } else {
12223 switch (cacheline_size) {
12224 case 16:
12225 if (goal == BOUNDARY_SINGLE_CACHELINE) {
12226 val |= (DMA_RWCTRL_READ_BNDRY_16 |
12227 DMA_RWCTRL_WRITE_BNDRY_16);
12228 break;
12229 }
12230 /* fallthrough */
12231 case 32:
12232 if (goal == BOUNDARY_SINGLE_CACHELINE) {
12233 val |= (DMA_RWCTRL_READ_BNDRY_32 |
12234 DMA_RWCTRL_WRITE_BNDRY_32);
12235 break;
12236 }
12237 /* fallthrough */
12238 case 64:
12239 if (goal == BOUNDARY_SINGLE_CACHELINE) {
12240 val |= (DMA_RWCTRL_READ_BNDRY_64 |
12241 DMA_RWCTRL_WRITE_BNDRY_64);
12242 break;
12243 }
12244 /* fallthrough */
12245 case 128:
12246 if (goal == BOUNDARY_SINGLE_CACHELINE) {
12247 val |= (DMA_RWCTRL_READ_BNDRY_128 |
12248 DMA_RWCTRL_WRITE_BNDRY_128);
12249 break;
12250 }
12251 /* fallthrough */
12252 case 256:
12253 val |= (DMA_RWCTRL_READ_BNDRY_256 |
12254 DMA_RWCTRL_WRITE_BNDRY_256);
12255 break;
12256 case 512:
12257 val |= (DMA_RWCTRL_READ_BNDRY_512 |
12258 DMA_RWCTRL_WRITE_BNDRY_512);
12259 break;
12260 case 1024:
12261 default:
12262 val |= (DMA_RWCTRL_READ_BNDRY_1024 |
12263 DMA_RWCTRL_WRITE_BNDRY_1024);
12264 break;
12265 };
12266 }
12267
12268 out:
12269 return val;
12270 }
12271
12272 static int __devinit tg3_do_test_dma(struct tg3 *tp, u32 *buf, dma_addr_t buf_dma, int size, int to_device)
12273 {
12274 struct tg3_internal_buffer_desc test_desc;
12275 u32 sram_dma_descs;
12276 int i, ret;
12277
12278 sram_dma_descs = NIC_SRAM_DMA_DESC_POOL_BASE;
12279
12280 tw32(FTQ_RCVBD_COMP_FIFO_ENQDEQ, 0);
12281 tw32(FTQ_RCVDATA_COMP_FIFO_ENQDEQ, 0);
12282 tw32(RDMAC_STATUS, 0);
12283 tw32(WDMAC_STATUS, 0);
12284
12285 tw32(BUFMGR_MODE, 0);
12286 tw32(FTQ_RESET, 0);
12287
12288 test_desc.addr_hi = ((u64) buf_dma) >> 32;
12289 test_desc.addr_lo = buf_dma & 0xffffffff;
12290 test_desc.nic_mbuf = 0x00002100;
12291 test_desc.len = size;
12292
12293 /*
12294 * HP ZX1 was seeing test failures for 5701 cards running at 33Mhz
12295 * the *second* time the tg3 driver was getting loaded after an
12296 * initial scan.
12297 *
12298 * Broadcom tells me:
12299 * ...the DMA engine is connected to the GRC block and a DMA
12300 * reset may affect the GRC block in some unpredictable way...
12301 * The behavior of resets to individual blocks has not been tested.
12302 *
12303 * Broadcom noted the GRC reset will also reset all sub-components.
12304 */
12305 if (to_device) {
12306 test_desc.cqid_sqid = (13 << 8) | 2;
12307
12308 tw32_f(RDMAC_MODE, RDMAC_MODE_ENABLE);
12309 udelay(40);
12310 } else {
12311 test_desc.cqid_sqid = (16 << 8) | 7;
12312
12313 tw32_f(WDMAC_MODE, WDMAC_MODE_ENABLE);
12314 udelay(40);
12315 }
12316 test_desc.flags = 0x00000005;
12317
12318 for (i = 0; i < (sizeof(test_desc) / sizeof(u32)); i++) {
12319 u32 val;
12320
12321 val = *(((u32 *)&test_desc) + i);
12322 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR,
12323 sram_dma_descs + (i * sizeof(u32)));
12324 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_DATA, val);
12325 }
12326 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, 0);
12327
12328 if (to_device) {
12329 tw32(FTQ_DMA_HIGH_READ_FIFO_ENQDEQ, sram_dma_descs);
12330 } else {
12331 tw32(FTQ_DMA_HIGH_WRITE_FIFO_ENQDEQ, sram_dma_descs);
12332 }
12333
12334 ret = -ENODEV;
12335 for (i = 0; i < 40; i++) {
12336 u32 val;
12337
12338 if (to_device)
12339 val = tr32(FTQ_RCVBD_COMP_FIFO_ENQDEQ);
12340 else
12341 val = tr32(FTQ_RCVDATA_COMP_FIFO_ENQDEQ);
12342 if ((val & 0xffff) == sram_dma_descs) {
12343 ret = 0;
12344 break;
12345 }
12346
12347 udelay(100);
12348 }
12349
12350 return ret;
12351 }
12352
12353 #define TEST_BUFFER_SIZE 0x2000
12354
12355 static int __devinit tg3_test_dma(struct tg3 *tp)
12356 {
12357 dma_addr_t buf_dma;
12358 u32 *buf, saved_dma_rwctrl;
12359 int ret;
12360
12361 buf = pci_alloc_consistent(tp->pdev, TEST_BUFFER_SIZE, &buf_dma);
12362 if (!buf) {
12363 ret = -ENOMEM;
12364 goto out_nofree;
12365 }
12366
12367 tp->dma_rwctrl = ((0x7 << DMA_RWCTRL_PCI_WRITE_CMD_SHIFT) |
12368 (0x6 << DMA_RWCTRL_PCI_READ_CMD_SHIFT));
12369
12370 tp->dma_rwctrl = tg3_calc_dma_bndry(tp, tp->dma_rwctrl);
12371
12372 if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
12373 /* DMA read watermark not used on PCIE */
12374 tp->dma_rwctrl |= 0x00180000;
12375 } else if (!(tp->tg3_flags & TG3_FLAG_PCIX_MODE)) {
12376 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 ||
12377 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750)
12378 tp->dma_rwctrl |= 0x003f0000;
12379 else
12380 tp->dma_rwctrl |= 0x003f000f;
12381 } else {
12382 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
12383 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) {
12384 u32 ccval = (tr32(TG3PCI_CLOCK_CTRL) & 0x1f);
12385 u32 read_water = 0x7;
12386
12387 /* If the 5704 is behind the EPB bridge, we can
12388 * do the less restrictive ONE_DMA workaround for
12389 * better performance.
12390 */
12391 if ((tp->tg3_flags & TG3_FLAG_40BIT_DMA_BUG) &&
12392 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704)
12393 tp->dma_rwctrl |= 0x8000;
12394 else if (ccval == 0x6 || ccval == 0x7)
12395 tp->dma_rwctrl |= DMA_RWCTRL_ONE_DMA;
12396
12397 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703)
12398 read_water = 4;
12399 /* Set bit 23 to enable PCIX hw bug fix */
12400 tp->dma_rwctrl |=
12401 (read_water << DMA_RWCTRL_READ_WATER_SHIFT) |
12402 (0x3 << DMA_RWCTRL_WRITE_WATER_SHIFT) |
12403 (1 << 23);
12404 } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
12405 /* 5780 always in PCIX mode */
12406 tp->dma_rwctrl |= 0x00144000;
12407 } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714) {
12408 /* 5714 always in PCIX mode */
12409 tp->dma_rwctrl |= 0x00148000;
12410 } else {
12411 tp->dma_rwctrl |= 0x001b000f;
12412 }
12413 }
12414
12415 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
12416 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704)
12417 tp->dma_rwctrl &= 0xfffffff0;
12418
12419 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
12420 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701) {
12421 /* Remove this if it causes problems for some boards. */
12422 tp->dma_rwctrl |= DMA_RWCTRL_USE_MEM_READ_MULT;
12423
12424 /* On 5700/5701 chips, we need to set this bit.
12425 * Otherwise the chip will issue cacheline transactions
12426 * to streamable DMA memory with not all the byte
12427 * enables turned on. This is an error on several
12428 * RISC PCI controllers, in particular sparc64.
12429 *
12430 * On 5703/5704 chips, this bit has been reassigned
12431 * a different meaning. In particular, it is used
12432 * on those chips to enable a PCI-X workaround.
12433 */
12434 tp->dma_rwctrl |= DMA_RWCTRL_ASSERT_ALL_BE;
12435 }
12436
12437 tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
12438
12439 #if 0
12440 /* Unneeded, already done by tg3_get_invariants. */
12441 tg3_switch_clocks(tp);
12442 #endif
12443
12444 ret = 0;
12445 if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700 &&
12446 GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701)
12447 goto out;
12448
12449 /* It is best to perform DMA test with maximum write burst size
12450 * to expose the 5700/5701 write DMA bug.
12451 */
12452 saved_dma_rwctrl = tp->dma_rwctrl;
12453 tp->dma_rwctrl &= ~DMA_RWCTRL_WRITE_BNDRY_MASK;
12454 tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
12455
12456 while (1) {
12457 u32 *p = buf, i;
12458
12459 for (i = 0; i < TEST_BUFFER_SIZE / sizeof(u32); i++)
12460 p[i] = i;
12461
12462 /* Send the buffer to the chip. */
12463 ret = tg3_do_test_dma(tp, buf, buf_dma, TEST_BUFFER_SIZE, 1);
12464 if (ret) {
12465 printk(KERN_ERR "tg3_test_dma() Write the buffer failed %d\n", ret);
12466 break;
12467 }
12468
12469 #if 0
12470 /* validate data reached card RAM correctly. */
12471 for (i = 0; i < TEST_BUFFER_SIZE / sizeof(u32); i++) {
12472 u32 val;
12473 tg3_read_mem(tp, 0x2100 + (i*4), &val);
12474 if (le32_to_cpu(val) != p[i]) {
12475 printk(KERN_ERR " tg3_test_dma() Card buffer corrupted on write! (%d != %d)\n", val, i);
12476 /* ret = -ENODEV here? */
12477 }
12478 p[i] = 0;
12479 }
12480 #endif
12481 /* Now read it back. */
12482 ret = tg3_do_test_dma(tp, buf, buf_dma, TEST_BUFFER_SIZE, 0);
12483 if (ret) {
12484 printk(KERN_ERR "tg3_test_dma() Read the buffer failed %d\n", ret);
12485
12486 break;
12487 }
12488
12489 /* Verify it. */
12490 for (i = 0; i < TEST_BUFFER_SIZE / sizeof(u32); i++) {
12491 if (p[i] == i)
12492 continue;
12493
12494 if ((tp->dma_rwctrl & DMA_RWCTRL_WRITE_BNDRY_MASK) !=
12495 DMA_RWCTRL_WRITE_BNDRY_16) {
12496 tp->dma_rwctrl &= ~DMA_RWCTRL_WRITE_BNDRY_MASK;
12497 tp->dma_rwctrl |= DMA_RWCTRL_WRITE_BNDRY_16;
12498 tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
12499 break;
12500 } else {
12501 printk(KERN_ERR "tg3_test_dma() buffer corrupted on read back! (%d != %d)\n", p[i], i);
12502 ret = -ENODEV;
12503 goto out;
12504 }
12505 }
12506
12507 if (i == (TEST_BUFFER_SIZE / sizeof(u32))) {
12508 /* Success. */
12509 ret = 0;
12510 break;
12511 }
12512 }
12513 if ((tp->dma_rwctrl & DMA_RWCTRL_WRITE_BNDRY_MASK) !=
12514 DMA_RWCTRL_WRITE_BNDRY_16) {
12515 static struct pci_device_id dma_wait_state_chipsets[] = {
12516 { PCI_DEVICE(PCI_VENDOR_ID_APPLE,
12517 PCI_DEVICE_ID_APPLE_UNI_N_PCI15) },
12518 { },
12519 };
12520
12521 /* DMA test passed without adjusting DMA boundary,
12522 * now look for chipsets that are known to expose the
12523 * DMA bug without failing the test.
12524 */
12525 if (pci_dev_present(dma_wait_state_chipsets)) {
12526 tp->dma_rwctrl &= ~DMA_RWCTRL_WRITE_BNDRY_MASK;
12527 tp->dma_rwctrl |= DMA_RWCTRL_WRITE_BNDRY_16;
12528 }
12529 else
12530 /* Safe to use the calculated DMA boundary. */
12531 tp->dma_rwctrl = saved_dma_rwctrl;
12532
12533 tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
12534 }
12535
12536 out:
12537 pci_free_consistent(tp->pdev, TEST_BUFFER_SIZE, buf, buf_dma);
12538 out_nofree:
12539 return ret;
12540 }
12541
12542 static void __devinit tg3_init_link_config(struct tg3 *tp)
12543 {
12544 tp->link_config.advertising =
12545 (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full |
12546 ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full |
12547 ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full |
12548 ADVERTISED_Autoneg | ADVERTISED_MII);
12549 tp->link_config.speed = SPEED_INVALID;
12550 tp->link_config.duplex = DUPLEX_INVALID;
12551 tp->link_config.autoneg = AUTONEG_ENABLE;
12552 tp->link_config.active_speed = SPEED_INVALID;
12553 tp->link_config.active_duplex = DUPLEX_INVALID;
12554 tp->link_config.phy_is_low_power = 0;
12555 tp->link_config.orig_speed = SPEED_INVALID;
12556 tp->link_config.orig_duplex = DUPLEX_INVALID;
12557 tp->link_config.orig_autoneg = AUTONEG_INVALID;
12558 }
12559
12560 static void __devinit tg3_init_bufmgr_config(struct tg3 *tp)
12561 {
12562 if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
12563 tp->bufmgr_config.mbuf_read_dma_low_water =
12564 DEFAULT_MB_RDMA_LOW_WATER_5705;
12565 tp->bufmgr_config.mbuf_mac_rx_low_water =
12566 DEFAULT_MB_MACRX_LOW_WATER_5705;
12567 tp->bufmgr_config.mbuf_high_water =
12568 DEFAULT_MB_HIGH_WATER_5705;
12569 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
12570 tp->bufmgr_config.mbuf_mac_rx_low_water =
12571 DEFAULT_MB_MACRX_LOW_WATER_5906;
12572 tp->bufmgr_config.mbuf_high_water =
12573 DEFAULT_MB_HIGH_WATER_5906;
12574 }
12575
12576 tp->bufmgr_config.mbuf_read_dma_low_water_jumbo =
12577 DEFAULT_MB_RDMA_LOW_WATER_JUMBO_5780;
12578 tp->bufmgr_config.mbuf_mac_rx_low_water_jumbo =
12579 DEFAULT_MB_MACRX_LOW_WATER_JUMBO_5780;
12580 tp->bufmgr_config.mbuf_high_water_jumbo =
12581 DEFAULT_MB_HIGH_WATER_JUMBO_5780;
12582 } else {
12583 tp->bufmgr_config.mbuf_read_dma_low_water =
12584 DEFAULT_MB_RDMA_LOW_WATER;
12585 tp->bufmgr_config.mbuf_mac_rx_low_water =
12586 DEFAULT_MB_MACRX_LOW_WATER;
12587 tp->bufmgr_config.mbuf_high_water =
12588 DEFAULT_MB_HIGH_WATER;
12589
12590 tp->bufmgr_config.mbuf_read_dma_low_water_jumbo =
12591 DEFAULT_MB_RDMA_LOW_WATER_JUMBO;
12592 tp->bufmgr_config.mbuf_mac_rx_low_water_jumbo =
12593 DEFAULT_MB_MACRX_LOW_WATER_JUMBO;
12594 tp->bufmgr_config.mbuf_high_water_jumbo =
12595 DEFAULT_MB_HIGH_WATER_JUMBO;
12596 }
12597
12598 tp->bufmgr_config.dma_low_water = DEFAULT_DMA_LOW_WATER;
12599 tp->bufmgr_config.dma_high_water = DEFAULT_DMA_HIGH_WATER;
12600 }
12601
12602 static char * __devinit tg3_phy_string(struct tg3 *tp)
12603 {
12604 switch (tp->phy_id & PHY_ID_MASK) {
12605 case PHY_ID_BCM5400: return "5400";
12606 case PHY_ID_BCM5401: return "5401";
12607 case PHY_ID_BCM5411: return "5411";
12608 case PHY_ID_BCM5701: return "5701";
12609 case PHY_ID_BCM5703: return "5703";
12610 case PHY_ID_BCM5704: return "5704";
12611 case PHY_ID_BCM5705: return "5705";
12612 case PHY_ID_BCM5750: return "5750";
12613 case PHY_ID_BCM5752: return "5752";
12614 case PHY_ID_BCM5714: return "5714";
12615 case PHY_ID_BCM5780: return "5780";
12616 case PHY_ID_BCM5755: return "5755";
12617 case PHY_ID_BCM5787: return "5787";
12618 case PHY_ID_BCM5784: return "5784";
12619 case PHY_ID_BCM5756: return "5722/5756";
12620 case PHY_ID_BCM5906: return "5906";
12621 case PHY_ID_BCM5761: return "5761";
12622 case PHY_ID_BCM8002: return "8002/serdes";
12623 case 0: return "serdes";
12624 default: return "unknown";
12625 };
12626 }
12627
12628 static char * __devinit tg3_bus_string(struct tg3 *tp, char *str)
12629 {
12630 if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
12631 strcpy(str, "PCI Express");
12632 return str;
12633 } else if (tp->tg3_flags & TG3_FLAG_PCIX_MODE) {
12634 u32 clock_ctrl = tr32(TG3PCI_CLOCK_CTRL) & 0x1f;
12635
12636 strcpy(str, "PCIX:");
12637
12638 if ((clock_ctrl == 7) ||
12639 ((tr32(GRC_MISC_CFG) & GRC_MISC_CFG_BOARD_ID_MASK) ==
12640 GRC_MISC_CFG_BOARD_ID_5704CIOBE))
12641 strcat(str, "133MHz");
12642 else if (clock_ctrl == 0)
12643 strcat(str, "33MHz");
12644 else if (clock_ctrl == 2)
12645 strcat(str, "50MHz");
12646 else if (clock_ctrl == 4)
12647 strcat(str, "66MHz");
12648 else if (clock_ctrl == 6)
12649 strcat(str, "100MHz");
12650 } else {
12651 strcpy(str, "PCI:");
12652 if (tp->tg3_flags & TG3_FLAG_PCI_HIGH_SPEED)
12653 strcat(str, "66MHz");
12654 else
12655 strcat(str, "33MHz");
12656 }
12657 if (tp->tg3_flags & TG3_FLAG_PCI_32BIT)
12658 strcat(str, ":32-bit");
12659 else
12660 strcat(str, ":64-bit");
12661 return str;
12662 }
12663
12664 static struct pci_dev * __devinit tg3_find_peer(struct tg3 *tp)
12665 {
12666 struct pci_dev *peer;
12667 unsigned int func, devnr = tp->pdev->devfn & ~7;
12668
12669 for (func = 0; func < 8; func++) {
12670 peer = pci_get_slot(tp->pdev->bus, devnr | func);
12671 if (peer && peer != tp->pdev)
12672 break;
12673 pci_dev_put(peer);
12674 }
12675 /* 5704 can be configured in single-port mode, set peer to
12676 * tp->pdev in that case.
12677 */
12678 if (!peer) {
12679 peer = tp->pdev;
12680 return peer;
12681 }
12682
12683 /*
12684 * We don't need to keep the refcount elevated; there's no way
12685 * to remove one half of this device without removing the other
12686 */
12687 pci_dev_put(peer);
12688
12689 return peer;
12690 }
12691
12692 static void __devinit tg3_init_coal(struct tg3 *tp)
12693 {
12694 struct ethtool_coalesce *ec = &tp->coal;
12695
12696 memset(ec, 0, sizeof(*ec));
12697 ec->cmd = ETHTOOL_GCOALESCE;
12698 ec->rx_coalesce_usecs = LOW_RXCOL_TICKS;
12699 ec->tx_coalesce_usecs = LOW_TXCOL_TICKS;
12700 ec->rx_max_coalesced_frames = LOW_RXMAX_FRAMES;
12701 ec->tx_max_coalesced_frames = LOW_TXMAX_FRAMES;
12702 ec->rx_coalesce_usecs_irq = DEFAULT_RXCOAL_TICK_INT;
12703 ec->tx_coalesce_usecs_irq = DEFAULT_TXCOAL_TICK_INT;
12704 ec->rx_max_coalesced_frames_irq = DEFAULT_RXCOAL_MAXF_INT;
12705 ec->tx_max_coalesced_frames_irq = DEFAULT_TXCOAL_MAXF_INT;
12706 ec->stats_block_coalesce_usecs = DEFAULT_STAT_COAL_TICKS;
12707
12708 if (tp->coalesce_mode & (HOSTCC_MODE_CLRTICK_RXBD |
12709 HOSTCC_MODE_CLRTICK_TXBD)) {
12710 ec->rx_coalesce_usecs = LOW_RXCOL_TICKS_CLRTCKS;
12711 ec->rx_coalesce_usecs_irq = DEFAULT_RXCOAL_TICK_INT_CLRTCKS;
12712 ec->tx_coalesce_usecs = LOW_TXCOL_TICKS_CLRTCKS;
12713 ec->tx_coalesce_usecs_irq = DEFAULT_TXCOAL_TICK_INT_CLRTCKS;
12714 }
12715
12716 if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
12717 ec->rx_coalesce_usecs_irq = 0;
12718 ec->tx_coalesce_usecs_irq = 0;
12719 ec->stats_block_coalesce_usecs = 0;
12720 }
12721 }
12722
12723 static int __devinit tg3_init_one(struct pci_dev *pdev,
12724 const struct pci_device_id *ent)
12725 {
12726 static int tg3_version_printed = 0;
12727 resource_size_t tg3reg_base;
12728 unsigned long tg3reg_len;
12729 struct net_device *dev;
12730 struct tg3 *tp;
12731 int err, pm_cap;
12732 char str[40];
12733 u64 dma_mask, persist_dma_mask;
12734 DECLARE_MAC_BUF(mac);
12735
12736 if (tg3_version_printed++ == 0)
12737 printk(KERN_INFO "%s", version);
12738
12739 err = pci_enable_device(pdev);
12740 if (err) {
12741 printk(KERN_ERR PFX "Cannot enable PCI device, "
12742 "aborting.\n");
12743 return err;
12744 }
12745
12746 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
12747 printk(KERN_ERR PFX "Cannot find proper PCI device "
12748 "base address, aborting.\n");
12749 err = -ENODEV;
12750 goto err_out_disable_pdev;
12751 }
12752
12753 err = pci_request_regions(pdev, DRV_MODULE_NAME);
12754 if (err) {
12755 printk(KERN_ERR PFX "Cannot obtain PCI resources, "
12756 "aborting.\n");
12757 goto err_out_disable_pdev;
12758 }
12759
12760 pci_set_master(pdev);
12761
12762 /* Find power-management capability. */
12763 pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM);
12764 if (pm_cap == 0) {
12765 printk(KERN_ERR PFX "Cannot find PowerManagement capability, "
12766 "aborting.\n");
12767 err = -EIO;
12768 goto err_out_free_res;
12769 }
12770
12771 tg3reg_base = pci_resource_start(pdev, 0);
12772 tg3reg_len = pci_resource_len(pdev, 0);
12773
12774 dev = alloc_etherdev(sizeof(*tp));
12775 if (!dev) {
12776 printk(KERN_ERR PFX "Etherdev alloc failed, aborting.\n");
12777 err = -ENOMEM;
12778 goto err_out_free_res;
12779 }
12780
12781 SET_NETDEV_DEV(dev, &pdev->dev);
12782
12783 #if TG3_VLAN_TAG_USED
12784 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
12785 dev->vlan_rx_register = tg3_vlan_rx_register;
12786 #endif
12787
12788 tp = netdev_priv(dev);
12789 tp->pdev = pdev;
12790 tp->dev = dev;
12791 tp->pm_cap = pm_cap;
12792 tp->mac_mode = TG3_DEF_MAC_MODE;
12793 tp->rx_mode = TG3_DEF_RX_MODE;
12794 tp->tx_mode = TG3_DEF_TX_MODE;
12795
12796 if (tg3_debug > 0)
12797 tp->msg_enable = tg3_debug;
12798 else
12799 tp->msg_enable = TG3_DEF_MSG_ENABLE;
12800
12801 /* The word/byte swap controls here control register access byte
12802 * swapping. DMA data byte swapping is controlled in the GRC_MODE
12803 * setting below.
12804 */
12805 tp->misc_host_ctrl =
12806 MISC_HOST_CTRL_MASK_PCI_INT |
12807 MISC_HOST_CTRL_WORD_SWAP |
12808 MISC_HOST_CTRL_INDIR_ACCESS |
12809 MISC_HOST_CTRL_PCISTATE_RW;
12810
12811 /* The NONFRM (non-frame) byte/word swap controls take effect
12812 * on descriptor entries, anything which isn't packet data.
12813 *
12814 * The StrongARM chips on the board (one for tx, one for rx)
12815 * are running in big-endian mode.
12816 */
12817 tp->grc_mode = (GRC_MODE_WSWAP_DATA | GRC_MODE_BSWAP_DATA |
12818 GRC_MODE_WSWAP_NONFRM_DATA);
12819 #ifdef __BIG_ENDIAN
12820 tp->grc_mode |= GRC_MODE_BSWAP_NONFRM_DATA;
12821 #endif
12822 spin_lock_init(&tp->lock);
12823 spin_lock_init(&tp->indirect_lock);
12824 INIT_WORK(&tp->reset_task, tg3_reset_task);
12825
12826 tp->regs = ioremap_nocache(tg3reg_base, tg3reg_len);
12827 if (!tp->regs) {
12828 printk(KERN_ERR PFX "Cannot map device registers, "
12829 "aborting.\n");
12830 err = -ENOMEM;
12831 goto err_out_free_dev;
12832 }
12833
12834 tg3_init_link_config(tp);
12835
12836 tp->rx_pending = TG3_DEF_RX_RING_PENDING;
12837 tp->rx_jumbo_pending = TG3_DEF_RX_JUMBO_RING_PENDING;
12838 tp->tx_pending = TG3_DEF_TX_RING_PENDING;
12839
12840 dev->open = tg3_open;
12841 dev->stop = tg3_close;
12842 dev->get_stats = tg3_get_stats;
12843 dev->set_multicast_list = tg3_set_rx_mode;
12844 dev->set_mac_address = tg3_set_mac_addr;
12845 dev->do_ioctl = tg3_ioctl;
12846 dev->tx_timeout = tg3_tx_timeout;
12847 netif_napi_add(dev, &tp->napi, tg3_poll, 64);
12848 dev->ethtool_ops = &tg3_ethtool_ops;
12849 dev->watchdog_timeo = TG3_TX_TIMEOUT;
12850 dev->change_mtu = tg3_change_mtu;
12851 dev->irq = pdev->irq;
12852 #ifdef CONFIG_NET_POLL_CONTROLLER
12853 dev->poll_controller = tg3_poll_controller;
12854 #endif
12855
12856 err = tg3_get_invariants(tp);
12857 if (err) {
12858 printk(KERN_ERR PFX "Problem fetching invariants of chip, "
12859 "aborting.\n");
12860 goto err_out_iounmap;
12861 }
12862
12863 /* The EPB bridge inside 5714, 5715, and 5780 and any
12864 * device behind the EPB cannot support DMA addresses > 40-bit.
12865 * On 64-bit systems with IOMMU, use 40-bit dma_mask.
12866 * On 64-bit systems without IOMMU, use 64-bit dma_mask and
12867 * do DMA address check in tg3_start_xmit().
12868 */
12869 if (tp->tg3_flags2 & TG3_FLG2_IS_5788)
12870 persist_dma_mask = dma_mask = DMA_32BIT_MASK;
12871 else if (tp->tg3_flags & TG3_FLAG_40BIT_DMA_BUG) {
12872 persist_dma_mask = dma_mask = DMA_40BIT_MASK;
12873 #ifdef CONFIG_HIGHMEM
12874 dma_mask = DMA_64BIT_MASK;
12875 #endif
12876 } else
12877 persist_dma_mask = dma_mask = DMA_64BIT_MASK;
12878
12879 /* Configure DMA attributes. */
12880 if (dma_mask > DMA_32BIT_MASK) {
12881 err = pci_set_dma_mask(pdev, dma_mask);
12882 if (!err) {
12883 dev->features |= NETIF_F_HIGHDMA;
12884 err = pci_set_consistent_dma_mask(pdev,
12885 persist_dma_mask);
12886 if (err < 0) {
12887 printk(KERN_ERR PFX "Unable to obtain 64 bit "
12888 "DMA for consistent allocations\n");
12889 goto err_out_iounmap;
12890 }
12891 }
12892 }
12893 if (err || dma_mask == DMA_32BIT_MASK) {
12894 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
12895 if (err) {
12896 printk(KERN_ERR PFX "No usable DMA configuration, "
12897 "aborting.\n");
12898 goto err_out_iounmap;
12899 }
12900 }
12901
12902 tg3_init_bufmgr_config(tp);
12903
12904 if (tp->tg3_flags2 & TG3_FLG2_HW_TSO) {
12905 tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE;
12906 }
12907 else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
12908 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701 ||
12909 tp->pci_chip_rev_id == CHIPREV_ID_5705_A0 ||
12910 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906 ||
12911 (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) != 0) {
12912 tp->tg3_flags2 &= ~TG3_FLG2_TSO_CAPABLE;
12913 } else {
12914 tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE | TG3_FLG2_TSO_BUG;
12915 }
12916
12917 /* TSO is on by default on chips that support hardware TSO.
12918 * Firmware TSO on older chips gives lower performance, so it
12919 * is off by default, but can be enabled using ethtool.
12920 */
12921 if (tp->tg3_flags2 & TG3_FLG2_HW_TSO) {
12922 dev->features |= NETIF_F_TSO;
12923 if ((tp->tg3_flags2 & TG3_FLG2_HW_TSO_2) &&
12924 (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5906))
12925 dev->features |= NETIF_F_TSO6;
12926 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761)
12927 dev->features |= NETIF_F_TSO_ECN;
12928 }
12929
12930
12931 if (tp->pci_chip_rev_id == CHIPREV_ID_5705_A1 &&
12932 !(tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE) &&
12933 !(tr32(TG3PCI_PCISTATE) & PCISTATE_BUS_SPEED_HIGH)) {
12934 tp->tg3_flags2 |= TG3_FLG2_MAX_RXPEND_64;
12935 tp->rx_pending = 63;
12936 }
12937
12938 err = tg3_get_device_address(tp);
12939 if (err) {
12940 printk(KERN_ERR PFX "Could not obtain valid ethernet address, "
12941 "aborting.\n");
12942 goto err_out_iounmap;
12943 }
12944
12945 if (tp->tg3_flags3 & TG3_FLG3_ENABLE_APE) {
12946 if (!(pci_resource_flags(pdev, 2) & IORESOURCE_MEM)) {
12947 printk(KERN_ERR PFX "Cannot find proper PCI device "
12948 "base address for APE, aborting.\n");
12949 err = -ENODEV;
12950 goto err_out_iounmap;
12951 }
12952
12953 tg3reg_base = pci_resource_start(pdev, 2);
12954 tg3reg_len = pci_resource_len(pdev, 2);
12955
12956 tp->aperegs = ioremap_nocache(tg3reg_base, tg3reg_len);
12957 if (!tp->aperegs) {
12958 printk(KERN_ERR PFX "Cannot map APE registers, "
12959 "aborting.\n");
12960 err = -ENOMEM;
12961 goto err_out_iounmap;
12962 }
12963
12964 tg3_ape_lock_init(tp);
12965 }
12966
12967 /*
12968 * Reset chip in case UNDI or EFI driver did not shutdown
12969 * DMA self test will enable WDMAC and we'll see (spurious)
12970 * pending DMA on the PCI bus at that point.
12971 */
12972 if ((tr32(HOSTCC_MODE) & HOSTCC_MODE_ENABLE) ||
12973 (tr32(WDMAC_MODE) & WDMAC_MODE_ENABLE)) {
12974 tw32(MEMARB_MODE, MEMARB_MODE_ENABLE);
12975 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
12976 }
12977
12978 err = tg3_test_dma(tp);
12979 if (err) {
12980 printk(KERN_ERR PFX "DMA engine test failed, aborting.\n");
12981 goto err_out_apeunmap;
12982 }
12983
12984 /* Tigon3 can do ipv4 only... and some chips have buggy
12985 * checksumming.
12986 */
12987 if ((tp->tg3_flags & TG3_FLAG_BROKEN_CHECKSUMS) == 0) {
12988 dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
12989 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
12990 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
12991 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
12992 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761)
12993 dev->features |= NETIF_F_IPV6_CSUM;
12994
12995 tp->tg3_flags |= TG3_FLAG_RX_CHECKSUMS;
12996 } else
12997 tp->tg3_flags &= ~TG3_FLAG_RX_CHECKSUMS;
12998
12999 /* flow control autonegotiation is default behavior */
13000 tp->tg3_flags |= TG3_FLAG_PAUSE_AUTONEG;
13001 tp->link_config.flowctrl = TG3_FLOW_CTRL_TX | TG3_FLOW_CTRL_RX;
13002
13003 tg3_init_coal(tp);
13004
13005 pci_set_drvdata(pdev, dev);
13006
13007 err = register_netdev(dev);
13008 if (err) {
13009 printk(KERN_ERR PFX "Cannot register net device, "
13010 "aborting.\n");
13011 goto err_out_apeunmap;
13012 }
13013
13014 printk(KERN_INFO "%s: Tigon3 [partno(%s) rev %04x PHY(%s)] "
13015 "(%s) %s Ethernet %s\n",
13016 dev->name,
13017 tp->board_part_number,
13018 tp->pci_chip_rev_id,
13019 tg3_phy_string(tp),
13020 tg3_bus_string(tp, str),
13021 ((tp->tg3_flags & TG3_FLAG_10_100_ONLY) ? "10/100Base-TX" :
13022 ((tp->tg3_flags2 & TG3_FLG2_ANY_SERDES) ? "1000Base-SX" :
13023 "10/100/1000Base-T")),
13024 print_mac(mac, dev->dev_addr));
13025
13026 printk(KERN_INFO "%s: RXcsums[%d] LinkChgREG[%d] "
13027 "MIirq[%d] ASF[%d] WireSpeed[%d] TSOcap[%d]\n",
13028 dev->name,
13029 (tp->tg3_flags & TG3_FLAG_RX_CHECKSUMS) != 0,
13030 (tp->tg3_flags & TG3_FLAG_USE_LINKCHG_REG) != 0,
13031 (tp->tg3_flags & TG3_FLAG_USE_MI_INTERRUPT) != 0,
13032 (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) != 0,
13033 (tp->tg3_flags2 & TG3_FLG2_NO_ETH_WIRE_SPEED) == 0,
13034 (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE) != 0);
13035 printk(KERN_INFO "%s: dma_rwctrl[%08x] dma_mask[%d-bit]\n",
13036 dev->name, tp->dma_rwctrl,
13037 (pdev->dma_mask == DMA_32BIT_MASK) ? 32 :
13038 (((u64) pdev->dma_mask == DMA_40BIT_MASK) ? 40 : 64));
13039
13040 return 0;
13041
13042 err_out_apeunmap:
13043 if (tp->aperegs) {
13044 iounmap(tp->aperegs);
13045 tp->aperegs = NULL;
13046 }
13047
13048 err_out_iounmap:
13049 if (tp->regs) {
13050 iounmap(tp->regs);
13051 tp->regs = NULL;
13052 }
13053
13054 err_out_free_dev:
13055 free_netdev(dev);
13056
13057 err_out_free_res:
13058 pci_release_regions(pdev);
13059
13060 err_out_disable_pdev:
13061 pci_disable_device(pdev);
13062 pci_set_drvdata(pdev, NULL);
13063 return err;
13064 }
13065
13066 static void __devexit tg3_remove_one(struct pci_dev *pdev)
13067 {
13068 struct net_device *dev = pci_get_drvdata(pdev);
13069
13070 if (dev) {
13071 struct tg3 *tp = netdev_priv(dev);
13072
13073 flush_scheduled_work();
13074 unregister_netdev(dev);
13075 if (tp->aperegs) {
13076 iounmap(tp->aperegs);
13077 tp->aperegs = NULL;
13078 }
13079 if (tp->regs) {
13080 iounmap(tp->regs);
13081 tp->regs = NULL;
13082 }
13083 free_netdev(dev);
13084 pci_release_regions(pdev);
13085 pci_disable_device(pdev);
13086 pci_set_drvdata(pdev, NULL);
13087 }
13088 }
13089
13090 static int tg3_suspend(struct pci_dev *pdev, pm_message_t state)
13091 {
13092 struct net_device *dev = pci_get_drvdata(pdev);
13093 struct tg3 *tp = netdev_priv(dev);
13094 int err;
13095
13096 /* PCI register 4 needs to be saved whether netif_running() or not.
13097 * MSI address and data need to be saved if using MSI and
13098 * netif_running().
13099 */
13100 pci_save_state(pdev);
13101
13102 if (!netif_running(dev))
13103 return 0;
13104
13105 flush_scheduled_work();
13106 tg3_netif_stop(tp);
13107
13108 del_timer_sync(&tp->timer);
13109
13110 tg3_full_lock(tp, 1);
13111 tg3_disable_ints(tp);
13112 tg3_full_unlock(tp);
13113
13114 netif_device_detach(dev);
13115
13116 tg3_full_lock(tp, 0);
13117 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
13118 tp->tg3_flags &= ~TG3_FLAG_INIT_COMPLETE;
13119 tg3_full_unlock(tp);
13120
13121 err = tg3_set_power_state(tp, pci_choose_state(pdev, state));
13122 if (err) {
13123 tg3_full_lock(tp, 0);
13124
13125 tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
13126 if (tg3_restart_hw(tp, 1))
13127 goto out;
13128
13129 tp->timer.expires = jiffies + tp->timer_offset;
13130 add_timer(&tp->timer);
13131
13132 netif_device_attach(dev);
13133 tg3_netif_start(tp);
13134
13135 out:
13136 tg3_full_unlock(tp);
13137 }
13138
13139 return err;
13140 }
13141
13142 static int tg3_resume(struct pci_dev *pdev)
13143 {
13144 struct net_device *dev = pci_get_drvdata(pdev);
13145 struct tg3 *tp = netdev_priv(dev);
13146 int err;
13147
13148 pci_restore_state(tp->pdev);
13149
13150 if (!netif_running(dev))
13151 return 0;
13152
13153 err = tg3_set_power_state(tp, PCI_D0);
13154 if (err)
13155 return err;
13156
13157 netif_device_attach(dev);
13158
13159 tg3_full_lock(tp, 0);
13160
13161 tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
13162 err = tg3_restart_hw(tp, 1);
13163 if (err)
13164 goto out;
13165
13166 tp->timer.expires = jiffies + tp->timer_offset;
13167 add_timer(&tp->timer);
13168
13169 tg3_netif_start(tp);
13170
13171 out:
13172 tg3_full_unlock(tp);
13173
13174 return err;
13175 }
13176
13177 static struct pci_driver tg3_driver = {
13178 .name = DRV_MODULE_NAME,
13179 .id_table = tg3_pci_tbl,
13180 .probe = tg3_init_one,
13181 .remove = __devexit_p(tg3_remove_one),
13182 .suspend = tg3_suspend,
13183 .resume = tg3_resume
13184 };
13185
13186 static int __init tg3_init(void)
13187 {
13188 return pci_register_driver(&tg3_driver);
13189 }
13190
13191 static void __exit tg3_cleanup(void)
13192 {
13193 pci_unregister_driver(&tg3_driver);
13194 }
13195
13196 module_init(tg3_init);
13197 module_exit(tg3_cleanup);
linux kernel for loongson