]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/net/bnx2.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
tun: fallback if skb_alloc() fails on big packets
[net-next-2.6.git] / drivers / net / bnx2.c
CommitLineData
b6016b76
MC		 1/* bnx2.c: Broadcom NX2 network driver.
2 *
feebb331 3 * Copyright (c) 2004-2008 Broadcom Corporation
b6016b76
MC		 4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation.
8 *
9 * Written by: Michael Chan (mchan@broadcom.com)
10 */
11
f2a4f052
MC		 12
13#include <linux/module.h>
14#include <linux/moduleparam.h>
15
16#include <linux/kernel.h>
17#include <linux/timer.h>
18#include <linux/errno.h>
19#include <linux/ioport.h>
20#include <linux/slab.h>
21#include <linux/vmalloc.h>
22#include <linux/interrupt.h>
23#include <linux/pci.h>
24#include <linux/init.h>
25#include <linux/netdevice.h>
26#include <linux/etherdevice.h>
27#include <linux/skbuff.h>
28#include <linux/dma-mapping.h>
1977f032 29#include <linux/bitops.h>
f2a4f052
MC		 30#include <asm/io.h>
31#include <asm/irq.h>
32#include <linux/delay.h>
33#include <asm/byteorder.h>
c86a31f4 34#include <asm/page.h>
f2a4f052
MC		 35#include <linux/time.h>
36#include <linux/ethtool.h>
37#include <linux/mii.h>
729b85cd 38#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
f2a4f052
MC		 39#include <linux/if_vlan.h>
40#define BCM_VLAN 1
41#endif
f2a4f052 42#include <net/ip.h>
de081fa5 43#include <net/tcp.h>
f2a4f052 44#include <net/checksum.h>
f2a4f052
MC		 45#include <linux/workqueue.h>
46#include <linux/crc32.h>
47#include <linux/prefetch.h>
29b12174 48#include <linux/cache.h>
fba9fe91 49#include <linux/zlib.h>
706bf240 50#include <linux/log2.h>
f2a4f052 51
b6016b76
MC		 52#include "bnx2.h"
53#include "bnx2_fw.h"
d43584c8 54#include "bnx2_fw2.h"
b6016b76 55
110d0ef9 56#define FW_BUF_SIZE 0x10000
b3448b0b 57
b6016b76
MC		 58#define DRV_MODULE_NAME "bnx2"
59#define PFX DRV_MODULE_NAME ": "
0eb8b1fe
MC		 60#define DRV_MODULE_VERSION "1.8.0"
61#define DRV_MODULE_RELDATE "Aug 14, 2008"
b6016b76
MC		 62
63#define RUN_AT(x) (jiffies + (x))
64
65/* Time in jiffies before concluding the transmitter is hung. */
66#define TX_TIMEOUT (5*HZ)
67
fefa8645 68static char version[] __devinitdata =
b6016b76
MC		 69 "Broadcom NetXtreme II Gigabit Ethernet Driver " DRV_MODULE_NAME " v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
70
71MODULE_AUTHOR("Michael Chan <mchan@broadcom.com>");
8427f136 72MODULE_DESCRIPTION("Broadcom NetXtreme II BCM5706/5708/5709 Driver");
b6016b76
MC		 73MODULE_LICENSE("GPL");
74MODULE_VERSION(DRV_MODULE_VERSION);
75
76static int disable_msi = 0;
77
78module_param(disable_msi, int, 0);
79MODULE_PARM_DESC(disable_msi, "Disable Message Signaled Interrupt (MSI)");
80
81typedef enum {
82 BCM5706 = 0,
83 NC370T,
84 NC370I,
85 BCM5706S,
86 NC370F,
5b0c76ad
MC		 87 BCM5708,
88 BCM5708S,
bac0dff6 89 BCM5709,
27a005b8 90 BCM5709S,
7bb0a04f 91 BCM5716,
b6016b76
MC		 92} board_t;
93
94/* indexed by board_t, above */
fefa8645 95static struct {
b6016b76
MC		 96 char *name;
97} board_info[] __devinitdata = {
98 { "Broadcom NetXtreme II BCM5706 1000Base-T" },
99 { "HP NC370T Multifunction Gigabit Server Adapter" },
100 { "HP NC370i Multifunction Gigabit Server Adapter" },
101 { "Broadcom NetXtreme II BCM5706 1000Base-SX" },
102 { "HP NC370F Multifunction Gigabit Server Adapter" },
5b0c76ad
MC		 103 { "Broadcom NetXtreme II BCM5708 1000Base-T" },
104 { "Broadcom NetXtreme II BCM5708 1000Base-SX" },
bac0dff6 105 { "Broadcom NetXtreme II BCM5709 1000Base-T" },
27a005b8 106 { "Broadcom NetXtreme II BCM5709 1000Base-SX" },
7bb0a04f 107 { "Broadcom NetXtreme II BCM5716 1000Base-T" },
b6016b76
MC		 108 };
109
7bb0a04f 110static DEFINE_PCI_DEVICE_TABLE(bnx2_pci_tbl) = {
b6016b76
MC		 111 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706,
112 PCI_VENDOR_ID_HP, 0x3101, 0, 0, NC370T },
113 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706,
114 PCI_VENDOR_ID_HP, 0x3106, 0, 0, NC370I },
115 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706,
116 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5706 },
5b0c76ad
MC		 117 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5708,
118 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5708 },
b6016b76
MC		 119 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706S,
120 PCI_VENDOR_ID_HP, 0x3102, 0, 0, NC370F },
121 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706S,
122 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5706S },
5b0c76ad
MC		 123 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5708S,
124 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5708S },
bac0dff6
MC		 125 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5709,
126 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5709 },
27a005b8
MC		 127 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5709S,
128 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5709S },
7bb0a04f
MC		 129 { PCI_VENDOR_ID_BROADCOM, 0x163b,
130 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5716 },
b6016b76
MC		 131 { 0, }
132};
133
134static struct flash_spec flash_table[] =
135{
e30372c9
MC		 136#define BUFFERED_FLAGS (BNX2_NV_BUFFERED | BNX2_NV_TRANSLATE)
137#define NONBUFFERED_FLAGS (BNX2_NV_WREN)
b6016b76 138 /* Slow EEPROM */
37137709 139 {0x00000000, 0x40830380, 0x009f0081, 0xa184a053, 0xaf000400,
e30372c9 140 BUFFERED_FLAGS, SEEPROM_PAGE_BITS, SEEPROM_PAGE_SIZE,
b6016b76
MC		 141 SEEPROM_BYTE_ADDR_MASK, SEEPROM_TOTAL_SIZE,
142 "EEPROM - slow"},
37137709
MC		 143 /* Expansion entry 0001 */
144 {0x08000002, 0x4b808201, 0x00050081, 0x03840253, 0xaf020406,
e30372c9 145 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
37137709
MC		 146 SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
147 "Entry 0001"},
b6016b76
MC		 148 /* Saifun SA25F010 (non-buffered flash) */
149 /* strap, cfg1, & write1 need updates */
37137709 150 {0x04000001, 0x47808201, 0x00050081, 0x03840253, 0xaf020406,
e30372c9 151 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
b6016b76
MC		 152 SAIFUN_FLASH_BYTE_ADDR_MASK, SAIFUN_FLASH_BASE_TOTAL_SIZE*2,
153 "Non-buffered flash (128kB)"},
154 /* Saifun SA25F020 (non-buffered flash) */
155 /* strap, cfg1, & write1 need updates */
37137709 156 {0x0c000003, 0x4f808201, 0x00050081, 0x03840253, 0xaf020406,
e30372c9 157 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
b6016b76
MC		 158 SAIFUN_FLASH_BYTE_ADDR_MASK, SAIFUN_FLASH_BASE_TOTAL_SIZE*4,
159 "Non-buffered flash (256kB)"},
37137709
MC		 160 /* Expansion entry 0100 */
161 {0x11000000, 0x53808201, 0x00050081, 0x03840253, 0xaf020406,
e30372c9 162 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
37137709
MC		 163 SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
164 "Entry 0100"},
165 /* Entry 0101: ST M45PE10 (non-buffered flash, TetonII B0) */
6aa20a22 166 {0x19000002, 0x5b808201, 0x000500db, 0x03840253, 0xaf020406,
e30372c9 167 NONBUFFERED_FLAGS, ST_MICRO_FLASH_PAGE_BITS, ST_MICRO_FLASH_PAGE_SIZE,
37137709
MC		 168 ST_MICRO_FLASH_BYTE_ADDR_MASK, ST_MICRO_FLASH_BASE_TOTAL_SIZE*2,
169 "Entry 0101: ST M45PE10 (128kB non-bufferred)"},
170 /* Entry 0110: ST M45PE20 (non-buffered flash)*/
171 {0x15000001, 0x57808201, 0x000500db, 0x03840253, 0xaf020406,
e30372c9 172 NONBUFFERED_FLAGS, ST_MICRO_FLASH_PAGE_BITS, ST_MICRO_FLASH_PAGE_SIZE,
37137709
MC		 173 ST_MICRO_FLASH_BYTE_ADDR_MASK, ST_MICRO_FLASH_BASE_TOTAL_SIZE*4,
174 "Entry 0110: ST M45PE20 (256kB non-bufferred)"},
175 /* Saifun SA25F005 (non-buffered flash) */
176 /* strap, cfg1, & write1 need updates */
177 {0x1d000003, 0x5f808201, 0x00050081, 0x03840253, 0xaf020406,
e30372c9 178 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
37137709
MC		 179 SAIFUN_FLASH_BYTE_ADDR_MASK, SAIFUN_FLASH_BASE_TOTAL_SIZE,
180 "Non-buffered flash (64kB)"},
181 /* Fast EEPROM */
182 {0x22000000, 0x62808380, 0x009f0081, 0xa184a053, 0xaf000400,
e30372c9 183 BUFFERED_FLAGS, SEEPROM_PAGE_BITS, SEEPROM_PAGE_SIZE,
37137709
MC		 184 SEEPROM_BYTE_ADDR_MASK, SEEPROM_TOTAL_SIZE,
185 "EEPROM - fast"},
186 /* Expansion entry 1001 */
187 {0x2a000002, 0x6b808201, 0x00050081, 0x03840253, 0xaf020406,
e30372c9 188 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
37137709
MC		 189 SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
190 "Entry 1001"},
191 /* Expansion entry 1010 */
192 {0x26000001, 0x67808201, 0x00050081, 0x03840253, 0xaf020406,
e30372c9 193 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
37137709
MC		 194 SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
195 "Entry 1010"},
196 /* ATMEL AT45DB011B (buffered flash) */
197 {0x2e000003, 0x6e808273, 0x00570081, 0x68848353, 0xaf000400,
e30372c9 198 BUFFERED_FLAGS, BUFFERED_FLASH_PAGE_BITS, BUFFERED_FLASH_PAGE_SIZE,
37137709
MC		 199 BUFFERED_FLASH_BYTE_ADDR_MASK, BUFFERED_FLASH_TOTAL_SIZE,
200 "Buffered flash (128kB)"},
201 /* Expansion entry 1100 */
202 {0x33000000, 0x73808201, 0x00050081, 0x03840253, 0xaf020406,
e30372c9 203 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
37137709
MC		 204 SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
205 "Entry 1100"},
206 /* Expansion entry 1101 */
207 {0x3b000002, 0x7b808201, 0x00050081, 0x03840253, 0xaf020406,
e30372c9 208 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
37137709
MC		 209 SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
210 "Entry 1101"},
211 /* Ateml Expansion entry 1110 */
212 {0x37000001, 0x76808273, 0x00570081, 0x68848353, 0xaf000400,
e30372c9 213 BUFFERED_FLAGS, BUFFERED_FLASH_PAGE_BITS, BUFFERED_FLASH_PAGE_SIZE,
37137709
MC		 214 BUFFERED_FLASH_BYTE_ADDR_MASK, 0,
215 "Entry 1110 (Atmel)"},
216 /* ATMEL AT45DB021B (buffered flash) */
217 {0x3f000003, 0x7e808273, 0x00570081, 0x68848353, 0xaf000400,
e30372c9 218 BUFFERED_FLAGS, BUFFERED_FLASH_PAGE_BITS, BUFFERED_FLASH_PAGE_SIZE,
37137709
MC		 219 BUFFERED_FLASH_BYTE_ADDR_MASK, BUFFERED_FLASH_TOTAL_SIZE*2,
220 "Buffered flash (256kB)"},
b6016b76
MC		 221};
222
e30372c9
MC		 223static struct flash_spec flash_5709 = {
224 .flags = BNX2_NV_BUFFERED,
225 .page_bits = BCM5709_FLASH_PAGE_BITS,
226 .page_size = BCM5709_FLASH_PAGE_SIZE,
227 .addr_mask = BCM5709_FLASH_BYTE_ADDR_MASK,
228 .total_size = BUFFERED_FLASH_TOTAL_SIZE*2,
229 .name = "5709 Buffered flash (256kB)",
230};
231
b6016b76
MC		 232MODULE_DEVICE_TABLE(pci, bnx2_pci_tbl);
233
35e9010b 234static inline u32 bnx2_tx_avail(struct bnx2 *bp, struct bnx2_tx_ring_info *txr)
e89bbf10 235{
2f8af120 236 u32 diff;
e89bbf10 237
2f8af120 238 smp_mb();
faac9c4b
MC		 239
240 /* The ring uses 256 indices for 255 entries, one of them
241 * needs to be skipped.
242 */
35e9010b 243 diff = txr->tx_prod - txr->tx_cons;
faac9c4b
MC		 244 if (unlikely(diff >= TX_DESC_CNT)) {
245 diff &= 0xffff;
246 if (diff == TX_DESC_CNT)
247 diff = MAX_TX_DESC_CNT;
248 }
e89bbf10
MC		 249 return (bp->tx_ring_size - diff);
250}
251
b6016b76
MC		 252static u32
253bnx2_reg_rd_ind(struct bnx2 *bp, u32 offset)
254{
1b8227c4
MC		 255 u32 val;
256
257 spin_lock_bh(&bp->indirect_lock);
b6016b76 258 REG_WR(bp, BNX2_PCICFG_REG_WINDOW_ADDRESS, offset);
1b8227c4
MC		 259 val = REG_RD(bp, BNX2_PCICFG_REG_WINDOW);
260 spin_unlock_bh(&bp->indirect_lock);
261 return val;
b6016b76
MC		 262}
263
264static void
265bnx2_reg_wr_ind(struct bnx2 *bp, u32 offset, u32 val)
266{
1b8227c4 267 spin_lock_bh(&bp->indirect_lock);
b6016b76
MC		 268 REG_WR(bp, BNX2_PCICFG_REG_WINDOW_ADDRESS, offset);
269 REG_WR(bp, BNX2_PCICFG_REG_WINDOW, val);
1b8227c4 270 spin_unlock_bh(&bp->indirect_lock);
b6016b76
MC		 271}
272
2726d6e1
MC		 273static void
274bnx2_shmem_wr(struct bnx2 *bp, u32 offset, u32 val)
275{
276 bnx2_reg_wr_ind(bp, bp->shmem_base + offset, val);
277}
278
279static u32
280bnx2_shmem_rd(struct bnx2 *bp, u32 offset)
281{
282 return (bnx2_reg_rd_ind(bp, bp->shmem_base + offset));
283}
284
b6016b76
MC		 285static void
286bnx2_ctx_wr(struct bnx2 *bp, u32 cid_addr, u32 offset, u32 val)
287{
288 offset += cid_addr;
1b8227c4 289 spin_lock_bh(&bp->indirect_lock);
59b47d8a
MC		 290 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
291 int i;
292
293 REG_WR(bp, BNX2_CTX_CTX_DATA, val);
294 REG_WR(bp, BNX2_CTX_CTX_CTRL,
295 offset | BNX2_CTX_CTX_CTRL_WRITE_REQ);
296 for (i = 0; i < 5; i++) {
59b47d8a
MC		 297 val = REG_RD(bp, BNX2_CTX_CTX_CTRL);
298 if ((val & BNX2_CTX_CTX_CTRL_WRITE_REQ) == 0)
299 break;
300 udelay(5);
301 }
302 } else {
303 REG_WR(bp, BNX2_CTX_DATA_ADR, offset);
304 REG_WR(bp, BNX2_CTX_DATA, val);
305 }
1b8227c4 306 spin_unlock_bh(&bp->indirect_lock);
b6016b76
MC		 307}
308
309static int
310bnx2_read_phy(struct bnx2 *bp, u32 reg, u32 *val)
311{
312 u32 val1;
313 int i, ret;
314
583c28e5 315 if (bp->phy_flags & BNX2_PHY_FLAG_INT_MODE_AUTO_POLLING) {
b6016b76
MC		 316 val1 = REG_RD(bp, BNX2_EMAC_MDIO_MODE);
317 val1 &= ~BNX2_EMAC_MDIO_MODE_AUTO_POLL;
318
319 REG_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
320 REG_RD(bp, BNX2_EMAC_MDIO_MODE);
321
322 udelay(40);
323 }
324
325 val1 = (bp->phy_addr << 21) | (reg << 16) |
326 BNX2_EMAC_MDIO_COMM_COMMAND_READ | BNX2_EMAC_MDIO_COMM_DISEXT |
327 BNX2_EMAC_MDIO_COMM_START_BUSY;
328 REG_WR(bp, BNX2_EMAC_MDIO_COMM, val1);
329
330 for (i = 0; i < 50; i++) {
331 udelay(10);
332
333 val1 = REG_RD(bp, BNX2_EMAC_MDIO_COMM);
334 if (!(val1 & BNX2_EMAC_MDIO_COMM_START_BUSY)) {
335 udelay(5);
336
337 val1 = REG_RD(bp, BNX2_EMAC_MDIO_COMM);
338 val1 &= BNX2_EMAC_MDIO_COMM_DATA;
339
340 break;
341 }
342 }
343
344 if (val1 & BNX2_EMAC_MDIO_COMM_START_BUSY) {
345 *val = 0x0;
346 ret = -EBUSY;
347 }
348 else {
349 *val = val1;
350 ret = 0;
351 }
352
583c28e5 353 if (bp->phy_flags & BNX2_PHY_FLAG_INT_MODE_AUTO_POLLING) {
b6016b76
MC		 354 val1 = REG_RD(bp, BNX2_EMAC_MDIO_MODE);
355 val1 |= BNX2_EMAC_MDIO_MODE_AUTO_POLL;
356
357 REG_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
358 REG_RD(bp, BNX2_EMAC_MDIO_MODE);
359
360 udelay(40);
361 }
362
363 return ret;
364}
365
366static int
367bnx2_write_phy(struct bnx2 *bp, u32 reg, u32 val)
368{
369 u32 val1;
370 int i, ret;
371
583c28e5 372 if (bp->phy_flags & BNX2_PHY_FLAG_INT_MODE_AUTO_POLLING) {
b6016b76
MC		 373 val1 = REG_RD(bp, BNX2_EMAC_MDIO_MODE);
374 val1 &= ~BNX2_EMAC_MDIO_MODE_AUTO_POLL;
375
376 REG_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
377 REG_RD(bp, BNX2_EMAC_MDIO_MODE);
378
379 udelay(40);
380 }
381
382 val1 = (bp->phy_addr << 21) | (reg << 16) | val |
383 BNX2_EMAC_MDIO_COMM_COMMAND_WRITE |
384 BNX2_EMAC_MDIO_COMM_START_BUSY | BNX2_EMAC_MDIO_COMM_DISEXT;
385 REG_WR(bp, BNX2_EMAC_MDIO_COMM, val1);
6aa20a22 386
b6016b76
MC		 387 for (i = 0; i < 50; i++) {
388 udelay(10);
389
390 val1 = REG_RD(bp, BNX2_EMAC_MDIO_COMM);
391 if (!(val1 & BNX2_EMAC_MDIO_COMM_START_BUSY)) {
392 udelay(5);
393 break;
394 }
395 }
396
397 if (val1 & BNX2_EMAC_MDIO_COMM_START_BUSY)
398 ret = -EBUSY;
399 else
400 ret = 0;
401
583c28e5 402 if (bp->phy_flags & BNX2_PHY_FLAG_INT_MODE_AUTO_POLLING) {
b6016b76
MC		 403 val1 = REG_RD(bp, BNX2_EMAC_MDIO_MODE);
404 val1 |= BNX2_EMAC_MDIO_MODE_AUTO_POLL;
405
406 REG_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
407 REG_RD(bp, BNX2_EMAC_MDIO_MODE);
408
409 udelay(40);
410 }
411
412 return ret;
413}
414
415static void
416bnx2_disable_int(struct bnx2 *bp)
417{
b4b36042
MC		 418 int i;
419 struct bnx2_napi *bnapi;
420
421 for (i = 0; i < bp->irq_nvecs; i++) {
422 bnapi = &bp->bnx2_napi[i];
423 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD, bnapi->int_num |
424 BNX2_PCICFG_INT_ACK_CMD_MASK_INT);
425 }
b6016b76
MC		 426 REG_RD(bp, BNX2_PCICFG_INT_ACK_CMD);
427}
428
429static void
430bnx2_enable_int(struct bnx2 *bp)
431{
b4b36042
MC		 432 int i;
433 struct bnx2_napi *bnapi;
35efa7c1 434
b4b36042
MC		 435 for (i = 0; i < bp->irq_nvecs; i++) {
436 bnapi = &bp->bnx2_napi[i];
1269a8a6 437
b4b36042
MC		 438 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD, bnapi->int_num |
439 BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
440 BNX2_PCICFG_INT_ACK_CMD_MASK_INT |
441 bnapi->last_status_idx);
b6016b76 442
b4b36042
MC		 443 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD, bnapi->int_num |
444 BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
445 bnapi->last_status_idx);
446 }
bf5295bb 447 REG_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW);
b6016b76
MC		 448}
449
450static void
451bnx2_disable_int_sync(struct bnx2 *bp)
452{
b4b36042
MC		 453 int i;
454
b6016b76
MC		 455 atomic_inc(&bp->intr_sem);
456 bnx2_disable_int(bp);
b4b36042
MC		 457 for (i = 0; i < bp->irq_nvecs; i++)
458 synchronize_irq(bp->irq_tbl[i].vector);
b6016b76
MC		 459}
460
35efa7c1
MC		 461static void
462bnx2_napi_disable(struct bnx2 *bp)
463{
b4b36042
MC		 464 int i;
465
466 for (i = 0; i < bp->irq_nvecs; i++)
467 napi_disable(&bp->bnx2_napi[i].napi);
35efa7c1
MC		 468}
469
470static void
471bnx2_napi_enable(struct bnx2 *bp)
472{
b4b36042
MC		 473 int i;
474
475 for (i = 0; i < bp->irq_nvecs; i++)
476 napi_enable(&bp->bnx2_napi[i].napi);
35efa7c1
MC		 477}
478
b6016b76
MC		 479static void
480bnx2_netif_stop(struct bnx2 *bp)
481{
482 bnx2_disable_int_sync(bp);
483 if (netif_running(bp->dev)) {
35efa7c1 484 bnx2_napi_disable(bp);
b6016b76
MC		 485 netif_tx_disable(bp->dev);
486 bp->dev->trans_start = jiffies; /* prevent tx timeout */
487 }
488}
489
490static void
491bnx2_netif_start(struct bnx2 *bp)
492{
493 if (atomic_dec_and_test(&bp->intr_sem)) {
494 if (netif_running(bp->dev)) {
706bf240 495 netif_tx_wake_all_queues(bp->dev);
35efa7c1 496 bnx2_napi_enable(bp);
b6016b76
MC		 497 bnx2_enable_int(bp);
498 }
499 }
500}
501
35e9010b
MC		 502static void
503bnx2_free_tx_mem(struct bnx2 *bp)
504{
505 int i;
506
507 for (i = 0; i < bp->num_tx_rings; i++) {
508 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
509 struct bnx2_tx_ring_info *txr = &bnapi->tx_ring;
510
511 if (txr->tx_desc_ring) {
512 pci_free_consistent(bp->pdev, TXBD_RING_SIZE,
513 txr->tx_desc_ring,
514 txr->tx_desc_mapping);
515 txr->tx_desc_ring = NULL;
516 }
517 kfree(txr->tx_buf_ring);
518 txr->tx_buf_ring = NULL;
519 }
520}
521
bb4f98ab
MC		 522static void
523bnx2_free_rx_mem(struct bnx2 *bp)
524{
525 int i;
526
527 for (i = 0; i < bp->num_rx_rings; i++) {
528 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
529 struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
530 int j;
531
532 for (j = 0; j < bp->rx_max_ring; j++) {
533 if (rxr->rx_desc_ring[j])
534 pci_free_consistent(bp->pdev, RXBD_RING_SIZE,
535 rxr->rx_desc_ring[j],
536 rxr->rx_desc_mapping[j]);
537 rxr->rx_desc_ring[j] = NULL;
538 }
539 if (rxr->rx_buf_ring)
540 vfree(rxr->rx_buf_ring);
541 rxr->rx_buf_ring = NULL;
542
543 for (j = 0; j < bp->rx_max_pg_ring; j++) {
544 if (rxr->rx_pg_desc_ring[j])
545 pci_free_consistent(bp->pdev, RXBD_RING_SIZE,
546 rxr->rx_pg_desc_ring[i],
547 rxr->rx_pg_desc_mapping[i]);
548 rxr->rx_pg_desc_ring[i] = NULL;
549 }
550 if (rxr->rx_pg_ring)
551 vfree(rxr->rx_pg_ring);
552 rxr->rx_pg_ring = NULL;
553 }
554}
555
35e9010b
MC		 556static int
557bnx2_alloc_tx_mem(struct bnx2 *bp)
558{
559 int i;
560
561 for (i = 0; i < bp->num_tx_rings; i++) {
562 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
563 struct bnx2_tx_ring_info *txr = &bnapi->tx_ring;
564
565 txr->tx_buf_ring = kzalloc(SW_TXBD_RING_SIZE, GFP_KERNEL);
566 if (txr->tx_buf_ring == NULL)
567 return -ENOMEM;
568
569 txr->tx_desc_ring =
570 pci_alloc_consistent(bp->pdev, TXBD_RING_SIZE,
571 &txr->tx_desc_mapping);
572 if (txr->tx_desc_ring == NULL)
573 return -ENOMEM;
574 }
575 return 0;
576}
577
bb4f98ab
MC		 578static int
579bnx2_alloc_rx_mem(struct bnx2 *bp)
580{
581 int i;
582
583 for (i = 0; i < bp->num_rx_rings; i++) {
584 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
585 struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
586 int j;
587
588 rxr->rx_buf_ring =
589 vmalloc(SW_RXBD_RING_SIZE * bp->rx_max_ring);
590 if (rxr->rx_buf_ring == NULL)
591 return -ENOMEM;
592
593 memset(rxr->rx_buf_ring, 0,
594 SW_RXBD_RING_SIZE * bp->rx_max_ring);
595
596 for (j = 0; j < bp->rx_max_ring; j++) {
597 rxr->rx_desc_ring[j] =
598 pci_alloc_consistent(bp->pdev, RXBD_RING_SIZE,
599 &rxr->rx_desc_mapping[j]);
600 if (rxr->rx_desc_ring[j] == NULL)
601 return -ENOMEM;
602
603 }
604
605 if (bp->rx_pg_ring_size) {
606 rxr->rx_pg_ring = vmalloc(SW_RXPG_RING_SIZE *
607 bp->rx_max_pg_ring);
608 if (rxr->rx_pg_ring == NULL)
609 return -ENOMEM;
610
611 memset(rxr->rx_pg_ring, 0, SW_RXPG_RING_SIZE *
612 bp->rx_max_pg_ring);
613 }
614
615 for (j = 0; j < bp->rx_max_pg_ring; j++) {
616 rxr->rx_pg_desc_ring[j] =
617 pci_alloc_consistent(bp->pdev, RXBD_RING_SIZE,
618 &rxr->rx_pg_desc_mapping[j]);
619 if (rxr->rx_pg_desc_ring[j] == NULL)
620 return -ENOMEM;
621
622 }
623 }
624 return 0;
625}
626
b6016b76
MC		 627static void
628bnx2_free_mem(struct bnx2 *bp)
629{
13daffa2 630 int i;
43e80b89 631 struct bnx2_napi *bnapi = &bp->bnx2_napi[0];
13daffa2 632
35e9010b 633 bnx2_free_tx_mem(bp);
bb4f98ab 634 bnx2_free_rx_mem(bp);
35e9010b 635
59b47d8a
MC		 636 for (i = 0; i < bp->ctx_pages; i++) {
637 if (bp->ctx_blk[i]) {
638 pci_free_consistent(bp->pdev, BCM_PAGE_SIZE,
639 bp->ctx_blk[i],
640 bp->ctx_blk_mapping[i]);
641 bp->ctx_blk[i] = NULL;
642 }
643 }
43e80b89 644 if (bnapi->status_blk.msi) {
0f31f994 645 pci_free_consistent(bp->pdev, bp->status_stats_size,
43e80b89
MC		 646 bnapi->status_blk.msi,
647 bp->status_blk_mapping);
648 bnapi->status_blk.msi = NULL;
0f31f994 649 bp->stats_blk = NULL;
b6016b76 650 }
b6016b76
MC		 651}
652
653static int
654bnx2_alloc_mem(struct bnx2 *bp)
655{
35e9010b 656 int i, status_blk_size, err;
43e80b89
MC		 657 struct bnx2_napi *bnapi;
658 void *status_blk;
b6016b76 659
0f31f994
MC		 660 /* Combine status and statistics blocks into one allocation. */
661 status_blk_size = L1_CACHE_ALIGN(sizeof(struct status_block));
f86e82fb 662 if (bp->flags & BNX2_FLAG_MSIX_CAP)
b4b36042
MC		 663 status_blk_size = L1_CACHE_ALIGN(BNX2_MAX_MSIX_HW_VEC *
664 BNX2_SBLK_MSIX_ALIGN_SIZE);
0f31f994
MC		 665 bp->status_stats_size = status_blk_size +
666 sizeof(struct statistics_block);
667
43e80b89
MC		 668 status_blk = pci_alloc_consistent(bp->pdev, bp->status_stats_size,
669 &bp->status_blk_mapping);
670 if (status_blk == NULL)
b6016b76
MC		 671 goto alloc_mem_err;
672
43e80b89 673 memset(status_blk, 0, bp->status_stats_size);
b6016b76 674
43e80b89
MC		 675 bnapi = &bp->bnx2_napi[0];
676 bnapi->status_blk.msi = status_blk;
677 bnapi->hw_tx_cons_ptr =
678 &bnapi->status_blk.msi->status_tx_quick_consumer_index0;
679 bnapi->hw_rx_cons_ptr =
680 &bnapi->status_blk.msi->status_rx_quick_consumer_index0;
f86e82fb 681 if (bp->flags & BNX2_FLAG_MSIX_CAP) {
b4b36042 682 for (i = 1; i < BNX2_MAX_MSIX_VEC; i++) {
43e80b89
MC		 683 struct status_block_msix *sblk;
684
685 bnapi = &bp->bnx2_napi[i];
b4b36042 686
43e80b89
MC		 687 sblk = (void *) (status_blk +
688 BNX2_SBLK_MSIX_ALIGN_SIZE * i);
689 bnapi->status_blk.msix = sblk;
690 bnapi->hw_tx_cons_ptr =
691 &sblk->status_tx_quick_consumer_index;
692 bnapi->hw_rx_cons_ptr =
693 &sblk->status_rx_quick_consumer_index;
b4b36042
MC		 694 bnapi->int_num = i << 24;
695 }
696 }
35efa7c1 697
43e80b89 698 bp->stats_blk = status_blk + status_blk_size;
b6016b76 699
0f31f994 700 bp->stats_blk_mapping = bp->status_blk_mapping + status_blk_size;
b6016b76 701
59b47d8a
MC		 702 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
703 bp->ctx_pages = 0x2000 / BCM_PAGE_SIZE;
704 if (bp->ctx_pages == 0)
705 bp->ctx_pages = 1;
706 for (i = 0; i < bp->ctx_pages; i++) {
707 bp->ctx_blk[i] = pci_alloc_consistent(bp->pdev,
708 BCM_PAGE_SIZE,
709 &bp->ctx_blk_mapping[i]);
710 if (bp->ctx_blk[i] == NULL)
711 goto alloc_mem_err;
712 }
713 }
35e9010b 714
bb4f98ab
MC		 715 err = bnx2_alloc_rx_mem(bp);
716 if (err)
717 goto alloc_mem_err;
718
35e9010b
MC		 719 err = bnx2_alloc_tx_mem(bp);
720 if (err)
721 goto alloc_mem_err;
722
b6016b76
MC		 723 return 0;
724
725alloc_mem_err:
726 bnx2_free_mem(bp);
727 return -ENOMEM;
728}
729
e3648b3d
MC		 730static void
731bnx2_report_fw_link(struct bnx2 *bp)
732{
733 u32 fw_link_status = 0;
734
583c28e5 735 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
0d8a6571
MC		 736 return;
737
e3648b3d
MC		 738 if (bp->link_up) {
739 u32 bmsr;
740
741 switch (bp->line_speed) {
742 case SPEED_10:
743 if (bp->duplex == DUPLEX_HALF)
744 fw_link_status = BNX2_LINK_STATUS_10HALF;
745 else
746 fw_link_status = BNX2_LINK_STATUS_10FULL;
747 break;
748 case SPEED_100:
749 if (bp->duplex == DUPLEX_HALF)
750 fw_link_status = BNX2_LINK_STATUS_100HALF;
751 else
752 fw_link_status = BNX2_LINK_STATUS_100FULL;
753 break;
754 case SPEED_1000:
755 if (bp->duplex == DUPLEX_HALF)
756 fw_link_status = BNX2_LINK_STATUS_1000HALF;
757 else
758 fw_link_status = BNX2_LINK_STATUS_1000FULL;
759 break;
760 case SPEED_2500:
761 if (bp->duplex == DUPLEX_HALF)
762 fw_link_status = BNX2_LINK_STATUS_2500HALF;
763 else
764 fw_link_status = BNX2_LINK_STATUS_2500FULL;
765 break;
766 }
767
768 fw_link_status |= BNX2_LINK_STATUS_LINK_UP;
769
770 if (bp->autoneg) {
771 fw_link_status |= BNX2_LINK_STATUS_AN_ENABLED;
772
ca58c3af
MC		 773 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
774 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
e3648b3d
MC		 775
776 if (!(bmsr & BMSR_ANEGCOMPLETE) ||
583c28e5 777 bp->phy_flags & BNX2_PHY_FLAG_PARALLEL_DETECT)
e3648b3d
MC		 778 fw_link_status |= BNX2_LINK_STATUS_PARALLEL_DET;
779 else
780 fw_link_status |= BNX2_LINK_STATUS_AN_COMPLETE;
781 }
782 }
783 else
784 fw_link_status = BNX2_LINK_STATUS_LINK_DOWN;
785
2726d6e1 786 bnx2_shmem_wr(bp, BNX2_LINK_STATUS, fw_link_status);
e3648b3d
MC		 787}
788
9b1084b8
MC		 789static char *
790bnx2_xceiver_str(struct bnx2 *bp)
791{
792 return ((bp->phy_port == PORT_FIBRE) ? "SerDes" :
583c28e5 793 ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) ? "Remote Copper" :
9b1084b8
MC		 794 "Copper"));
795}
796
b6016b76
MC		 797static void
798bnx2_report_link(struct bnx2 *bp)
799{
800 if (bp->link_up) {
801 netif_carrier_on(bp->dev);
9b1084b8
MC		 802 printk(KERN_INFO PFX "%s NIC %s Link is Up, ", bp->dev->name,
803 bnx2_xceiver_str(bp));
b6016b76
MC		 804
805 printk("%d Mbps ", bp->line_speed);
806
807 if (bp->duplex == DUPLEX_FULL)
808 printk("full duplex");
809 else
810 printk("half duplex");
811
812 if (bp->flow_ctrl) {
813 if (bp->flow_ctrl & FLOW_CTRL_RX) {
814 printk(", receive ");
815 if (bp->flow_ctrl & FLOW_CTRL_TX)
816 printk("& transmit ");
817 }
818 else {
819 printk(", transmit ");
820 }
821 printk("flow control ON");
822 }
823 printk("\n");
824 }
825 else {
826 netif_carrier_off(bp->dev);
9b1084b8
MC		 827 printk(KERN_ERR PFX "%s NIC %s Link is Down\n", bp->dev->name,
828 bnx2_xceiver_str(bp));
b6016b76 829 }
e3648b3d
MC		 830
831 bnx2_report_fw_link(bp);
b6016b76
MC		 832}
833
834static void
835bnx2_resolve_flow_ctrl(struct bnx2 *bp)
836{
837 u32 local_adv, remote_adv;
838
839 bp->flow_ctrl = 0;
6aa20a22 840 if ((bp->autoneg & (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) !=
b6016b76
MC		 841 (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) {
842
843 if (bp->duplex == DUPLEX_FULL) {
844 bp->flow_ctrl = bp->req_flow_ctrl;
845 }
846 return;
847 }
848
849 if (bp->duplex != DUPLEX_FULL) {
850 return;
851 }
852
583c28e5 853 if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
5b0c76ad
MC		 854 (CHIP_NUM(bp) == CHIP_NUM_5708)) {
855 u32 val;
856
857 bnx2_read_phy(bp, BCM5708S_1000X_STAT1, &val);
858 if (val & BCM5708S_1000X_STAT1_TX_PAUSE)
859 bp->flow_ctrl |= FLOW_CTRL_TX;
860 if (val & BCM5708S_1000X_STAT1_RX_PAUSE)
861 bp->flow_ctrl |= FLOW_CTRL_RX;
862 return;
863 }
864
ca58c3af
MC		 865 bnx2_read_phy(bp, bp->mii_adv, &local_adv);
866 bnx2_read_phy(bp, bp->mii_lpa, &remote_adv);
b6016b76 867
583c28e5 868 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
b6016b76
MC		 869 u32 new_local_adv = 0;
870 u32 new_remote_adv = 0;
871
872 if (local_adv & ADVERTISE_1000XPAUSE)
873 new_local_adv |= ADVERTISE_PAUSE_CAP;
874 if (local_adv & ADVERTISE_1000XPSE_ASYM)
875 new_local_adv |= ADVERTISE_PAUSE_ASYM;
876 if (remote_adv & ADVERTISE_1000XPAUSE)
877 new_remote_adv |= ADVERTISE_PAUSE_CAP;
878 if (remote_adv & ADVERTISE_1000XPSE_ASYM)
879 new_remote_adv |= ADVERTISE_PAUSE_ASYM;
880
881 local_adv = new_local_adv;
882 remote_adv = new_remote_adv;
883 }
884
885 /* See Table 28B-3 of 802.3ab-1999 spec. */
886 if (local_adv & ADVERTISE_PAUSE_CAP) {
887 if(local_adv & ADVERTISE_PAUSE_ASYM) {
888 if (remote_adv & ADVERTISE_PAUSE_CAP) {
889 bp->flow_ctrl = FLOW_CTRL_TX | FLOW_CTRL_RX;
890 }
891 else if (remote_adv & ADVERTISE_PAUSE_ASYM) {
892 bp->flow_ctrl = FLOW_CTRL_RX;
893 }
894 }
895 else {
896 if (remote_adv & ADVERTISE_PAUSE_CAP) {
897 bp->flow_ctrl = FLOW_CTRL_TX | FLOW_CTRL_RX;
898 }
899 }
900 }
901 else if (local_adv & ADVERTISE_PAUSE_ASYM) {
902 if ((remote_adv & ADVERTISE_PAUSE_CAP) &&
903 (remote_adv & ADVERTISE_PAUSE_ASYM)) {
904
905 bp->flow_ctrl = FLOW_CTRL_TX;
906 }
907 }
908}
909
27a005b8
MC		 910static int
911bnx2_5709s_linkup(struct bnx2 *bp)
912{
913 u32 val, speed;
914
915 bp->link_up = 1;
916
917 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_GP_STATUS);
918 bnx2_read_phy(bp, MII_BNX2_GP_TOP_AN_STATUS1, &val);
919 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
920
921 if ((bp->autoneg & AUTONEG_SPEED) == 0) {
922 bp->line_speed = bp->req_line_speed;
923 bp->duplex = bp->req_duplex;
924 return 0;
925 }
926 speed = val & MII_BNX2_GP_TOP_AN_SPEED_MSK;
927 switch (speed) {
928 case MII_BNX2_GP_TOP_AN_SPEED_10:
929 bp->line_speed = SPEED_10;
930 break;
931 case MII_BNX2_GP_TOP_AN_SPEED_100:
932 bp->line_speed = SPEED_100;
933 break;
934 case MII_BNX2_GP_TOP_AN_SPEED_1G:
935 case MII_BNX2_GP_TOP_AN_SPEED_1GKV:
936 bp->line_speed = SPEED_1000;
937 break;
938 case MII_BNX2_GP_TOP_AN_SPEED_2_5G:
939 bp->line_speed = SPEED_2500;
940 break;
941 }
942 if (val & MII_BNX2_GP_TOP_AN_FD)
943 bp->duplex = DUPLEX_FULL;
944 else
945 bp->duplex = DUPLEX_HALF;
946 return 0;
947}
948
b6016b76 949static int
5b0c76ad
MC		 950bnx2_5708s_linkup(struct bnx2 *bp)
951{
952 u32 val;
953
954 bp->link_up = 1;
955 bnx2_read_phy(bp, BCM5708S_1000X_STAT1, &val);
956 switch (val & BCM5708S_1000X_STAT1_SPEED_MASK) {
957 case BCM5708S_1000X_STAT1_SPEED_10:
958 bp->line_speed = SPEED_10;
959 break;
960 case BCM5708S_1000X_STAT1_SPEED_100:
961 bp->line_speed = SPEED_100;
962 break;
963 case BCM5708S_1000X_STAT1_SPEED_1G:
964 bp->line_speed = SPEED_1000;
965 break;
966 case BCM5708S_1000X_STAT1_SPEED_2G5:
967 bp->line_speed = SPEED_2500;
968 break;
969 }
970 if (val & BCM5708S_1000X_STAT1_FD)
971 bp->duplex = DUPLEX_FULL;
972 else
973 bp->duplex = DUPLEX_HALF;
974
975 return 0;
976}
977
978static int
979bnx2_5706s_linkup(struct bnx2 *bp)
b6016b76
MC		 980{
981 u32 bmcr, local_adv, remote_adv, common;
982
983 bp->link_up = 1;
984 bp->line_speed = SPEED_1000;
985
ca58c3af 986 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
b6016b76
MC		 987 if (bmcr & BMCR_FULLDPLX) {
988 bp->duplex = DUPLEX_FULL;
989 }
990 else {
991 bp->duplex = DUPLEX_HALF;
992 }
993
994 if (!(bmcr & BMCR_ANENABLE)) {
995 return 0;
996 }
997
ca58c3af
MC		 998 bnx2_read_phy(bp, bp->mii_adv, &local_adv);
999 bnx2_read_phy(bp, bp->mii_lpa, &remote_adv);
b6016b76
MC		 1000
1001 common = local_adv & remote_adv;
1002 if (common & (ADVERTISE_1000XHALF | ADVERTISE_1000XFULL)) {
1003
1004 if (common & ADVERTISE_1000XFULL) {
1005 bp->duplex = DUPLEX_FULL;
1006 }
1007 else {
1008 bp->duplex = DUPLEX_HALF;
1009 }
1010 }
1011
1012 return 0;
1013}
1014
1015static int
1016bnx2_copper_linkup(struct bnx2 *bp)
1017{
1018 u32 bmcr;
1019
ca58c3af 1020 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
b6016b76
MC		 1021 if (bmcr & BMCR_ANENABLE) {
1022 u32 local_adv, remote_adv, common;
1023
1024 bnx2_read_phy(bp, MII_CTRL1000, &local_adv);
1025 bnx2_read_phy(bp, MII_STAT1000, &remote_adv);
1026
1027 common = local_adv & (remote_adv >> 2);
1028 if (common & ADVERTISE_1000FULL) {
1029 bp->line_speed = SPEED_1000;
1030 bp->duplex = DUPLEX_FULL;
1031 }
1032 else if (common & ADVERTISE_1000HALF) {
1033 bp->line_speed = SPEED_1000;
1034 bp->duplex = DUPLEX_HALF;
1035 }
1036 else {
ca58c3af
MC		 1037 bnx2_read_phy(bp, bp->mii_adv, &local_adv);
1038 bnx2_read_phy(bp, bp->mii_lpa, &remote_adv);
b6016b76
MC		 1039
1040 common = local_adv & remote_adv;
1041 if (common & ADVERTISE_100FULL) {
1042 bp->line_speed = SPEED_100;
1043 bp->duplex = DUPLEX_FULL;
1044 }
1045 else if (common & ADVERTISE_100HALF) {
1046 bp->line_speed = SPEED_100;
1047 bp->duplex = DUPLEX_HALF;
1048 }
1049 else if (common & ADVERTISE_10FULL) {
1050 bp->line_speed = SPEED_10;
1051 bp->duplex = DUPLEX_FULL;
1052 }
1053 else if (common & ADVERTISE_10HALF) {
1054 bp->line_speed = SPEED_10;
1055 bp->duplex = DUPLEX_HALF;
1056 }
1057 else {
1058 bp->line_speed = 0;
1059 bp->link_up = 0;
1060 }
1061 }
1062 }
1063 else {
1064 if (bmcr & BMCR_SPEED100) {
1065 bp->line_speed = SPEED_100;
1066 }
1067 else {
1068 bp->line_speed = SPEED_10;
1069 }
1070 if (bmcr & BMCR_FULLDPLX) {
1071 bp->duplex = DUPLEX_FULL;
1072 }
1073 else {
1074 bp->duplex = DUPLEX_HALF;
1075 }
1076 }
1077
1078 return 0;
1079}
1080
83e3fc89 1081static void
bb4f98ab 1082bnx2_init_rx_context(struct bnx2 *bp, u32 cid)
83e3fc89 1083{
bb4f98ab 1084 u32 val, rx_cid_addr = GET_CID_ADDR(cid);
83e3fc89
MC		 1085
1086 val = BNX2_L2CTX_CTX_TYPE_CTX_BD_CHN_TYPE_VALUE;
1087 val |= BNX2_L2CTX_CTX_TYPE_SIZE_L2;
1088 val |= 0x02 << 8;
1089
1090 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
1091 u32 lo_water, hi_water;
1092
1093 if (bp->flow_ctrl & FLOW_CTRL_TX)
1094 lo_water = BNX2_L2CTX_LO_WATER_MARK_DEFAULT;
1095 else
1096 lo_water = BNX2_L2CTX_LO_WATER_MARK_DIS;
1097 if (lo_water >= bp->rx_ring_size)
1098 lo_water = 0;
1099
1100 hi_water = bp->rx_ring_size / 4;
1101
1102 if (hi_water <= lo_water)
1103 lo_water = 0;
1104
1105 hi_water /= BNX2_L2CTX_HI_WATER_MARK_SCALE;
1106 lo_water /= BNX2_L2CTX_LO_WATER_MARK_SCALE;
1107
1108 if (hi_water > 0xf)
1109 hi_water = 0xf;
1110 else if (hi_water == 0)
1111 lo_water = 0;
1112 val |= lo_water | (hi_water << BNX2_L2CTX_HI_WATER_MARK_SHIFT);
1113 }
1114 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_CTX_TYPE, val);
1115}
1116
bb4f98ab
MC		 1117static void
1118bnx2_init_all_rx_contexts(struct bnx2 *bp)
1119{
1120 int i;
1121 u32 cid;
1122
1123 for (i = 0, cid = RX_CID; i < bp->num_rx_rings; i++, cid++) {
1124 if (i == 1)
1125 cid = RX_RSS_CID;
1126 bnx2_init_rx_context(bp, cid);
1127 }
1128}
1129
b6016b76
MC		 1130static int
1131bnx2_set_mac_link(struct bnx2 *bp)
1132{
1133 u32 val;
1134
1135 REG_WR(bp, BNX2_EMAC_TX_LENGTHS, 0x2620);
1136 if (bp->link_up && (bp->line_speed == SPEED_1000) &&
1137 (bp->duplex == DUPLEX_HALF)) {
1138 REG_WR(bp, BNX2_EMAC_TX_LENGTHS, 0x26ff);
1139 }
1140
1141 /* Configure the EMAC mode register. */
1142 val = REG_RD(bp, BNX2_EMAC_MODE);
1143
1144 val &= ~(BNX2_EMAC_MODE_PORT | BNX2_EMAC_MODE_HALF_DUPLEX |
5b0c76ad 1145 BNX2_EMAC_MODE_MAC_LOOP | BNX2_EMAC_MODE_FORCE_LINK |
59b47d8a 1146 BNX2_EMAC_MODE_25G_MODE);
b6016b76
MC		 1147
1148 if (bp->link_up) {
5b0c76ad
MC		 1149 switch (bp->line_speed) {
1150 case SPEED_10:
59b47d8a
MC		 1151 if (CHIP_NUM(bp) != CHIP_NUM_5706) {
1152 val |= BNX2_EMAC_MODE_PORT_MII_10M;
5b0c76ad
MC		 1153 break;
1154 }
1155 /* fall through */
1156 case SPEED_100:
1157 val |= BNX2_EMAC_MODE_PORT_MII;
1158 break;
1159 case SPEED_2500:
59b47d8a 1160 val |= BNX2_EMAC_MODE_25G_MODE;
5b0c76ad
MC		 1161 /* fall through */
1162 case SPEED_1000:
1163 val |= BNX2_EMAC_MODE_PORT_GMII;
1164 break;
1165 }
b6016b76
MC		 1166 }
1167 else {
1168 val |= BNX2_EMAC_MODE_PORT_GMII;
1169 }
1170
1171 /* Set the MAC to operate in the appropriate duplex mode. */
1172 if (bp->duplex == DUPLEX_HALF)
1173 val |= BNX2_EMAC_MODE_HALF_DUPLEX;
1174 REG_WR(bp, BNX2_EMAC_MODE, val);
1175
1176 /* Enable/disable rx PAUSE. */
1177 bp->rx_mode &= ~BNX2_EMAC_RX_MODE_FLOW_EN;
1178
1179 if (bp->flow_ctrl & FLOW_CTRL_RX)
1180 bp->rx_mode |= BNX2_EMAC_RX_MODE_FLOW_EN;
1181 REG_WR(bp, BNX2_EMAC_RX_MODE, bp->rx_mode);
1182
1183 /* Enable/disable tx PAUSE. */
1184 val = REG_RD(bp, BNX2_EMAC_TX_MODE);
1185 val &= ~BNX2_EMAC_TX_MODE_FLOW_EN;
1186
1187 if (bp->flow_ctrl & FLOW_CTRL_TX)
1188 val |= BNX2_EMAC_TX_MODE_FLOW_EN;
1189 REG_WR(bp, BNX2_EMAC_TX_MODE, val);
1190
1191 /* Acknowledge the interrupt. */
1192 REG_WR(bp, BNX2_EMAC_STATUS, BNX2_EMAC_STATUS_LINK_CHANGE);
1193
83e3fc89 1194 if (CHIP_NUM(bp) == CHIP_NUM_5709)
bb4f98ab 1195 bnx2_init_all_rx_contexts(bp);
83e3fc89 1196
b6016b76
MC		 1197 return 0;
1198}
1199
27a005b8
MC		 1200static void
1201bnx2_enable_bmsr1(struct bnx2 *bp)
1202{
583c28e5 1203 if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
27a005b8
MC		 1204 (CHIP_NUM(bp) == CHIP_NUM_5709))
1205 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1206 MII_BNX2_BLK_ADDR_GP_STATUS);
1207}
1208
1209static void
1210bnx2_disable_bmsr1(struct bnx2 *bp)
1211{
583c28e5 1212 if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
27a005b8
MC		 1213 (CHIP_NUM(bp) == CHIP_NUM_5709))
1214 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1215 MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1216}
1217
605a9e20
MC		 1218static int
1219bnx2_test_and_enable_2g5(struct bnx2 *bp)
1220{
1221 u32 up1;
1222 int ret = 1;
1223
583c28e5 1224 if (!(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
605a9e20
MC		 1225 return 0;
1226
1227 if (bp->autoneg & AUTONEG_SPEED)
1228 bp->advertising |= ADVERTISED_2500baseX_Full;
1229
27a005b8
MC		 1230 if (CHIP_NUM(bp) == CHIP_NUM_5709)
1231 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_OVER1G);
1232
605a9e20
MC		 1233 bnx2_read_phy(bp, bp->mii_up1, &up1);
1234 if (!(up1 & BCM5708S_UP1_2G5)) {
1235 up1 |= BCM5708S_UP1_2G5;
1236 bnx2_write_phy(bp, bp->mii_up1, up1);
1237 ret = 0;
1238 }
1239
27a005b8
MC		 1240 if (CHIP_NUM(bp) == CHIP_NUM_5709)
1241 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1242 MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1243
605a9e20
MC		 1244 return ret;
1245}
1246
1247static int
1248bnx2_test_and_disable_2g5(struct bnx2 *bp)
1249{
1250 u32 up1;
1251 int ret = 0;
1252
583c28e5 1253 if (!(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
605a9e20
MC		 1254 return 0;
1255
27a005b8
MC		 1256 if (CHIP_NUM(bp) == CHIP_NUM_5709)
1257 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_OVER1G);
1258
605a9e20
MC		 1259 bnx2_read_phy(bp, bp->mii_up1, &up1);
1260 if (up1 & BCM5708S_UP1_2G5) {
1261 up1 &= ~BCM5708S_UP1_2G5;
1262 bnx2_write_phy(bp, bp->mii_up1, up1);
1263 ret = 1;
1264 }
1265
27a005b8
MC		 1266 if (CHIP_NUM(bp) == CHIP_NUM_5709)
1267 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1268 MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1269
605a9e20
MC		 1270 return ret;
1271}
1272
1273static void
1274bnx2_enable_forced_2g5(struct bnx2 *bp)
1275{
1276 u32 bmcr;
1277
583c28e5 1278 if (!(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
605a9e20
MC		 1279 return;
1280
27a005b8
MC		 1281 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
1282 u32 val;
1283
1284 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1285 MII_BNX2_BLK_ADDR_SERDES_DIG);
1286 bnx2_read_phy(bp, MII_BNX2_SERDES_DIG_MISC1, &val);
1287 val &= ~MII_BNX2_SD_MISC1_FORCE_MSK;
1288 val |= MII_BNX2_SD_MISC1_FORCE | MII_BNX2_SD_MISC1_FORCE_2_5G;
1289 bnx2_write_phy(bp, MII_BNX2_SERDES_DIG_MISC1, val);
1290
1291 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1292 MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1293 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1294
1295 } else if (CHIP_NUM(bp) == CHIP_NUM_5708) {
605a9e20
MC		 1296 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1297 bmcr |= BCM5708S_BMCR_FORCE_2500;
1298 }
1299
1300 if (bp->autoneg & AUTONEG_SPEED) {
1301 bmcr &= ~BMCR_ANENABLE;
1302 if (bp->req_duplex == DUPLEX_FULL)
1303 bmcr |= BMCR_FULLDPLX;
1304 }
1305 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
1306}
1307
1308static void
1309bnx2_disable_forced_2g5(struct bnx2 *bp)
1310{
1311 u32 bmcr;
1312
583c28e5 1313 if (!(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
605a9e20
MC		 1314 return;
1315
27a005b8
MC		 1316 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
1317 u32 val;
1318
1319 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1320 MII_BNX2_BLK_ADDR_SERDES_DIG);
1321 bnx2_read_phy(bp, MII_BNX2_SERDES_DIG_MISC1, &val);
1322 val &= ~MII_BNX2_SD_MISC1_FORCE;
1323 bnx2_write_phy(bp, MII_BNX2_SERDES_DIG_MISC1, val);
1324
1325 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1326 MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1327 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1328
1329 } else if (CHIP_NUM(bp) == CHIP_NUM_5708) {
605a9e20
MC		 1330 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1331 bmcr &= ~BCM5708S_BMCR_FORCE_2500;
1332 }
1333
1334 if (bp->autoneg & AUTONEG_SPEED)
1335 bmcr |= BMCR_SPEED1000 | BMCR_ANENABLE | BMCR_ANRESTART;
1336 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
1337}
1338
b2fadeae
MC		 1339static void
1340bnx2_5706s_force_link_dn(struct bnx2 *bp, int start)
1341{
1342 u32 val;
1343
1344 bnx2_write_phy(bp, MII_BNX2_DSP_ADDRESS, MII_EXPAND_SERDES_CTL);
1345 bnx2_read_phy(bp, MII_BNX2_DSP_RW_PORT, &val);
1346 if (start)
1347 bnx2_write_phy(bp, MII_BNX2_DSP_RW_PORT, val & 0xff0f);
1348 else
1349 bnx2_write_phy(bp, MII_BNX2_DSP_RW_PORT, val | 0xc0);
1350}
1351
b6016b76
MC		 1352static int
1353bnx2_set_link(struct bnx2 *bp)
1354{
1355 u32 bmsr;
1356 u8 link_up;
1357
80be4434 1358 if (bp->loopback == MAC_LOOPBACK || bp->loopback == PHY_LOOPBACK) {
b6016b76
MC		 1359 bp->link_up = 1;
1360 return 0;
1361 }
1362
583c28e5 1363 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
0d8a6571
MC		 1364 return 0;
1365
b6016b76
MC		 1366 link_up = bp->link_up;
1367
27a005b8
MC		 1368 bnx2_enable_bmsr1(bp);
1369 bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
1370 bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
1371 bnx2_disable_bmsr1(bp);
b6016b76 1372
583c28e5 1373 if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
b6016b76 1374 (CHIP_NUM(bp) == CHIP_NUM_5706)) {
a2724e25 1375 u32 val, an_dbg;
b6016b76 1376
583c28e5 1377 if (bp->phy_flags & BNX2_PHY_FLAG_FORCED_DOWN) {
b2fadeae 1378 bnx2_5706s_force_link_dn(bp, 0);
583c28e5 1379 bp->phy_flags &= ~BNX2_PHY_FLAG_FORCED_DOWN;
b2fadeae 1380 }
b6016b76 1381 val = REG_RD(bp, BNX2_EMAC_STATUS);
a2724e25
MC		 1382
1383 bnx2_write_phy(bp, MII_BNX2_MISC_SHADOW, MISC_SHDW_AN_DBG);
1384 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &an_dbg);
1385 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &an_dbg);
1386
1387 if ((val & BNX2_EMAC_STATUS_LINK) &&
1388 !(an_dbg & MISC_SHDW_AN_DBG_NOSYNC))
b6016b76
MC		 1389 bmsr |= BMSR_LSTATUS;
1390 else
1391 bmsr &= ~BMSR_LSTATUS;
1392 }
1393
1394 if (bmsr & BMSR_LSTATUS) {
1395 bp->link_up = 1;
1396
583c28e5 1397 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
5b0c76ad
MC		 1398 if (CHIP_NUM(bp) == CHIP_NUM_5706)
1399 bnx2_5706s_linkup(bp);
1400 else if (CHIP_NUM(bp) == CHIP_NUM_5708)
1401 bnx2_5708s_linkup(bp);
27a005b8
MC		 1402 else if (CHIP_NUM(bp) == CHIP_NUM_5709)
1403 bnx2_5709s_linkup(bp);
b6016b76
MC		 1404 }
1405 else {
1406 bnx2_copper_linkup(bp);
1407 }
1408 bnx2_resolve_flow_ctrl(bp);
1409 }
1410 else {
583c28e5 1411 if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
605a9e20
MC		 1412 (bp->autoneg & AUTONEG_SPEED))
1413 bnx2_disable_forced_2g5(bp);
b6016b76 1414
583c28e5 1415 if (bp->phy_flags & BNX2_PHY_FLAG_PARALLEL_DETECT) {
b2fadeae
MC		 1416 u32 bmcr;
1417
1418 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1419 bmcr |= BMCR_ANENABLE;
1420 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
1421
583c28e5 1422 bp->phy_flags &= ~BNX2_PHY_FLAG_PARALLEL_DETECT;
b2fadeae 1423 }
b6016b76
MC		 1424 bp->link_up = 0;
1425 }
1426
1427 if (bp->link_up != link_up) {
1428 bnx2_report_link(bp);
1429 }
1430
1431 bnx2_set_mac_link(bp);
1432
1433 return 0;
1434}
1435
1436static int
1437bnx2_reset_phy(struct bnx2 *bp)
1438{
1439 int i;
1440 u32 reg;
1441
ca58c3af 1442 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_RESET);
b6016b76
MC		 1443
1444#define PHY_RESET_MAX_WAIT 100
1445 for (i = 0; i < PHY_RESET_MAX_WAIT; i++) {
1446 udelay(10);
1447
ca58c3af 1448 bnx2_read_phy(bp, bp->mii_bmcr, &reg);
b6016b76
MC		 1449 if (!(reg & BMCR_RESET)) {
1450 udelay(20);
1451 break;
1452 }
1453 }
1454 if (i == PHY_RESET_MAX_WAIT) {
1455 return -EBUSY;
1456 }
1457 return 0;
1458}
1459
1460static u32
1461bnx2_phy_get_pause_adv(struct bnx2 *bp)
1462{
1463 u32 adv = 0;
1464
1465 if ((bp->req_flow_ctrl & (FLOW_CTRL_RX | FLOW_CTRL_TX)) ==
1466 (FLOW_CTRL_RX | FLOW_CTRL_TX)) {
1467
583c28e5 1468 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
b6016b76
MC		 1469 adv = ADVERTISE_1000XPAUSE;
1470 }
1471 else {
1472 adv = ADVERTISE_PAUSE_CAP;
1473 }
1474 }
1475 else if (bp->req_flow_ctrl & FLOW_CTRL_TX) {
583c28e5 1476 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
b6016b76
MC		 1477 adv = ADVERTISE_1000XPSE_ASYM;
1478 }
1479 else {
1480 adv = ADVERTISE_PAUSE_ASYM;
1481 }
1482 }
1483 else if (bp->req_flow_ctrl & FLOW_CTRL_RX) {
583c28e5 1484 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
b6016b76
MC		 1485 adv = ADVERTISE_1000XPAUSE | ADVERTISE_1000XPSE_ASYM;
1486 }
1487 else {
1488 adv = ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
1489 }
1490 }
1491 return adv;
1492}
1493
a2f13890 1494static int bnx2_fw_sync(struct bnx2 *, u32, int, int);
0d8a6571 1495
b6016b76 1496static int
0d8a6571
MC		 1497bnx2_setup_remote_phy(struct bnx2 *bp, u8 port)
1498{
1499 u32 speed_arg = 0, pause_adv;
1500
1501 pause_adv = bnx2_phy_get_pause_adv(bp);
1502
1503 if (bp->autoneg & AUTONEG_SPEED) {
1504 speed_arg |= BNX2_NETLINK_SET_LINK_ENABLE_AUTONEG;
1505 if (bp->advertising & ADVERTISED_10baseT_Half)
1506 speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_10HALF;
1507 if (bp->advertising & ADVERTISED_10baseT_Full)
1508 speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_10FULL;
1509 if (bp->advertising & ADVERTISED_100baseT_Half)
1510 speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_100HALF;
1511 if (bp->advertising & ADVERTISED_100baseT_Full)
1512 speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_100FULL;
1513 if (bp->advertising & ADVERTISED_1000baseT_Full)
1514 speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_1GFULL;
1515 if (bp->advertising & ADVERTISED_2500baseX_Full)
1516 speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_2G5FULL;
1517 } else {
1518 if (bp->req_line_speed == SPEED_2500)
1519 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_2G5FULL;
1520 else if (bp->req_line_speed == SPEED_1000)
1521 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_1GFULL;
1522 else if (bp->req_line_speed == SPEED_100) {
1523 if (bp->req_duplex == DUPLEX_FULL)
1524 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_100FULL;
1525 else
1526 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_100HALF;
1527 } else if (bp->req_line_speed == SPEED_10) {
1528 if (bp->req_duplex == DUPLEX_FULL)
1529 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_10FULL;
1530 else
1531 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_10HALF;
1532 }
1533 }
1534
1535 if (pause_adv & (ADVERTISE_1000XPAUSE | ADVERTISE_PAUSE_CAP))
1536 speed_arg |= BNX2_NETLINK_SET_LINK_FC_SYM_PAUSE;
c26736ec 1537 if (pause_adv & (ADVERTISE_1000XPSE_ASYM | ADVERTISE_PAUSE_ASYM))
0d8a6571
MC		 1538 speed_arg |= BNX2_NETLINK_SET_LINK_FC_ASYM_PAUSE;
1539
1540 if (port == PORT_TP)
1541 speed_arg |= BNX2_NETLINK_SET_LINK_PHY_APP_REMOTE |
1542 BNX2_NETLINK_SET_LINK_ETH_AT_WIRESPEED;
1543
2726d6e1 1544 bnx2_shmem_wr(bp, BNX2_DRV_MB_ARG0, speed_arg);
0d8a6571
MC		 1545
1546 spin_unlock_bh(&bp->phy_lock);
a2f13890 1547 bnx2_fw_sync(bp, BNX2_DRV_MSG_CODE_CMD_SET_LINK, 1, 0);
0d8a6571
MC		 1548 spin_lock_bh(&bp->phy_lock);
1549
1550 return 0;
1551}
1552
1553static int
1554bnx2_setup_serdes_phy(struct bnx2 *bp, u8 port)
b6016b76 1555{
605a9e20 1556 u32 adv, bmcr;
b6016b76
MC		 1557 u32 new_adv = 0;
1558
583c28e5 1559 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
0d8a6571
MC		 1560 return (bnx2_setup_remote_phy(bp, port));
1561
b6016b76
MC		 1562 if (!(bp->autoneg & AUTONEG_SPEED)) {
1563 u32 new_bmcr;
5b0c76ad
MC		 1564 int force_link_down = 0;
1565
605a9e20
MC		 1566 if (bp->req_line_speed == SPEED_2500) {
1567 if (!bnx2_test_and_enable_2g5(bp))
1568 force_link_down = 1;
1569 } else if (bp->req_line_speed == SPEED_1000) {
1570 if (bnx2_test_and_disable_2g5(bp))
1571 force_link_down = 1;
1572 }
ca58c3af 1573 bnx2_read_phy(bp, bp->mii_adv, &adv);
80be4434
MC		 1574 adv &= ~(ADVERTISE_1000XFULL | ADVERTISE_1000XHALF);
1575
ca58c3af 1576 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
605a9e20 1577 new_bmcr = bmcr & ~BMCR_ANENABLE;
80be4434 1578 new_bmcr |= BMCR_SPEED1000;
605a9e20 1579
27a005b8
MC		 1580 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
1581 if (bp->req_line_speed == SPEED_2500)
1582 bnx2_enable_forced_2g5(bp);
1583 else if (bp->req_line_speed == SPEED_1000) {
1584 bnx2_disable_forced_2g5(bp);
1585 new_bmcr &= ~0x2000;
1586 }
1587
1588 } else if (CHIP_NUM(bp) == CHIP_NUM_5708) {
605a9e20
MC		 1589 if (bp->req_line_speed == SPEED_2500)
1590 new_bmcr |= BCM5708S_BMCR_FORCE_2500;
1591 else
1592 new_bmcr = bmcr & ~BCM5708S_BMCR_FORCE_2500;
5b0c76ad
MC		 1593 }
1594
b6016b76 1595 if (bp->req_duplex == DUPLEX_FULL) {
5b0c76ad 1596 adv |= ADVERTISE_1000XFULL;
b6016b76
MC		 1597 new_bmcr |= BMCR_FULLDPLX;
1598 }
1599 else {
5b0c76ad 1600 adv |= ADVERTISE_1000XHALF;
b6016b76
MC		 1601 new_bmcr &= ~BMCR_FULLDPLX;
1602 }
5b0c76ad 1603 if ((new_bmcr != bmcr) || (force_link_down)) {
b6016b76
MC		 1604 /* Force a link down visible on the other side */
1605 if (bp->link_up) {
ca58c3af 1606 bnx2_write_phy(bp, bp->mii_adv, adv &
5b0c76ad
MC		 1607 ~(ADVERTISE_1000XFULL |
1608 ADVERTISE_1000XHALF));
ca58c3af 1609 bnx2_write_phy(bp, bp->mii_bmcr, bmcr |
b6016b76
MC		 1610 BMCR_ANRESTART | BMCR_ANENABLE);
1611
1612 bp->link_up = 0;
1613 netif_carrier_off(bp->dev);
ca58c3af 1614 bnx2_write_phy(bp, bp->mii_bmcr, new_bmcr);
80be4434 1615 bnx2_report_link(bp);
b6016b76 1616 }
ca58c3af
MC		 1617 bnx2_write_phy(bp, bp->mii_adv, adv);
1618 bnx2_write_phy(bp, bp->mii_bmcr, new_bmcr);
605a9e20
MC		 1619 } else {
1620 bnx2_resolve_flow_ctrl(bp);
1621 bnx2_set_mac_link(bp);
b6016b76
MC		 1622 }
1623 return 0;
1624 }
1625
605a9e20 1626 bnx2_test_and_enable_2g5(bp);
5b0c76ad 1627
b6016b76
MC		 1628 if (bp->advertising & ADVERTISED_1000baseT_Full)
1629 new_adv |= ADVERTISE_1000XFULL;
1630
1631 new_adv |= bnx2_phy_get_pause_adv(bp);
1632
ca58c3af
MC		 1633 bnx2_read_phy(bp, bp->mii_adv, &adv);
1634 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
b6016b76
MC		 1635
1636 bp->serdes_an_pending = 0;
1637 if ((adv != new_adv) || ((bmcr & BMCR_ANENABLE) == 0)) {
1638 /* Force a link down visible on the other side */
1639 if (bp->link_up) {
ca58c3af 1640 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK);
80be4434
MC		 1641 spin_unlock_bh(&bp->phy_lock);
1642 msleep(20);
1643 spin_lock_bh(&bp->phy_lock);
b6016b76
MC		 1644 }
1645
ca58c3af
MC		 1646 bnx2_write_phy(bp, bp->mii_adv, new_adv);
1647 bnx2_write_phy(bp, bp->mii_bmcr, bmcr | BMCR_ANRESTART |
b6016b76 1648 BMCR_ANENABLE);
f8dd064e
MC		 1649 /* Speed up link-up time when the link partner
1650 * does not autonegotiate which is very common
1651 * in blade servers. Some blade servers use
1652 * IPMI for kerboard input and it's important
1653 * to minimize link disruptions. Autoneg. involves
1654 * exchanging base pages plus 3 next pages and
1655 * normally completes in about 120 msec.
1656 */
1657 bp->current_interval = SERDES_AN_TIMEOUT;
1658 bp->serdes_an_pending = 1;
1659 mod_timer(&bp->timer, jiffies + bp->current_interval);
605a9e20
MC		 1660 } else {
1661 bnx2_resolve_flow_ctrl(bp);
1662 bnx2_set_mac_link(bp);
b6016b76
MC		 1663 }
1664
1665 return 0;
1666}
1667
1668#define ETHTOOL_ALL_FIBRE_SPEED \
583c28e5 1669 (bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE) ? \
deaf391b
MC		 1670 (ADVERTISED_2500baseX_Full | ADVERTISED_1000baseT_Full) :\
1671 (ADVERTISED_1000baseT_Full)
b6016b76
MC		 1672
1673#define ETHTOOL_ALL_COPPER_SPEED \
1674 (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full | \
1675 ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full | \
1676 ADVERTISED_1000baseT_Full)
1677
1678#define PHY_ALL_10_100_SPEED (ADVERTISE_10HALF | ADVERTISE_10FULL | \
1679 ADVERTISE_100HALF | ADVERTISE_100FULL | ADVERTISE_CSMA)
6aa20a22 1680
b6016b76
MC		 1681#define PHY_ALL_1000_SPEED (ADVERTISE_1000HALF | ADVERTISE_1000FULL)
1682
0d8a6571
MC		 1683static void
1684bnx2_set_default_remote_link(struct bnx2 *bp)
1685{
1686 u32 link;
1687
1688 if (bp->phy_port == PORT_TP)
2726d6e1 1689 link = bnx2_shmem_rd(bp, BNX2_RPHY_COPPER_LINK);
0d8a6571 1690 else
2726d6e1 1691 link = bnx2_shmem_rd(bp, BNX2_RPHY_SERDES_LINK);
0d8a6571
MC		 1692
1693 if (link & BNX2_NETLINK_SET_LINK_ENABLE_AUTONEG) {
1694 bp->req_line_speed = 0;
1695 bp->autoneg |= AUTONEG_SPEED;
1696 bp->advertising = ADVERTISED_Autoneg;
1697 if (link & BNX2_NETLINK_SET_LINK_SPEED_10HALF)
1698 bp->advertising |= ADVERTISED_10baseT_Half;
1699 if (link & BNX2_NETLINK_SET_LINK_SPEED_10FULL)
1700 bp->advertising |= ADVERTISED_10baseT_Full;
1701 if (link & BNX2_NETLINK_SET_LINK_SPEED_100HALF)
1702 bp->advertising |= ADVERTISED_100baseT_Half;
1703 if (link & BNX2_NETLINK_SET_LINK_SPEED_100FULL)
1704 bp->advertising |= ADVERTISED_100baseT_Full;
1705 if (link & BNX2_NETLINK_SET_LINK_SPEED_1GFULL)
1706 bp->advertising |= ADVERTISED_1000baseT_Full;
1707 if (link & BNX2_NETLINK_SET_LINK_SPEED_2G5FULL)
1708 bp->advertising |= ADVERTISED_2500baseX_Full;
1709 } else {
1710 bp->autoneg = 0;
1711 bp->advertising = 0;
1712 bp->req_duplex = DUPLEX_FULL;
1713 if (link & BNX2_NETLINK_SET_LINK_SPEED_10) {
1714 bp->req_line_speed = SPEED_10;
1715 if (link & BNX2_NETLINK_SET_LINK_SPEED_10HALF)
1716 bp->req_duplex = DUPLEX_HALF;
1717 }
1718 if (link & BNX2_NETLINK_SET_LINK_SPEED_100) {
1719 bp->req_line_speed = SPEED_100;
1720 if (link & BNX2_NETLINK_SET_LINK_SPEED_100HALF)
1721 bp->req_duplex = DUPLEX_HALF;
1722 }
1723 if (link & BNX2_NETLINK_SET_LINK_SPEED_1GFULL)
1724 bp->req_line_speed = SPEED_1000;
1725 if (link & BNX2_NETLINK_SET_LINK_SPEED_2G5FULL)
1726 bp->req_line_speed = SPEED_2500;
1727 }
1728}
1729
deaf391b
MC		 1730static void
1731bnx2_set_default_link(struct bnx2 *bp)
1732{
ab59859d
HH		 1733 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) {
1734 bnx2_set_default_remote_link(bp);
1735 return;
1736 }
0d8a6571 1737
deaf391b
MC		 1738 bp->autoneg = AUTONEG_SPEED | AUTONEG_FLOW_CTRL;
1739 bp->req_line_speed = 0;
583c28e5 1740 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
deaf391b
MC		 1741 u32 reg;
1742
1743 bp->advertising = ETHTOOL_ALL_FIBRE_SPEED | ADVERTISED_Autoneg;
1744
2726d6e1 1745 reg = bnx2_shmem_rd(bp, BNX2_PORT_HW_CFG_CONFIG);
deaf391b
MC		 1746 reg &= BNX2_PORT_HW_CFG_CFG_DFLT_LINK_MASK;
1747 if (reg == BNX2_PORT_HW_CFG_CFG_DFLT_LINK_1G) {
1748 bp->autoneg = 0;
1749 bp->req_line_speed = bp->line_speed = SPEED_1000;
1750 bp->req_duplex = DUPLEX_FULL;
1751 }
1752 } else
1753 bp->advertising = ETHTOOL_ALL_COPPER_SPEED | ADVERTISED_Autoneg;
1754}
1755
df149d70
MC		 1756static void
1757bnx2_send_heart_beat(struct bnx2 *bp)
1758{
1759 u32 msg;
1760 u32 addr;
1761
1762 spin_lock(&bp->indirect_lock);
1763 msg = (u32) (++bp->fw_drv_pulse_wr_seq & BNX2_DRV_PULSE_SEQ_MASK);
1764 addr = bp->shmem_base + BNX2_DRV_PULSE_MB;
1765 REG_WR(bp, BNX2_PCICFG_REG_WINDOW_ADDRESS, addr);
1766 REG_WR(bp, BNX2_PCICFG_REG_WINDOW, msg);
1767 spin_unlock(&bp->indirect_lock);
1768}
1769
0d8a6571
MC		 1770static void
1771bnx2_remote_phy_event(struct bnx2 *bp)
1772{
1773 u32 msg;
1774 u8 link_up = bp->link_up;
1775 u8 old_port;
1776
2726d6e1 1777 msg = bnx2_shmem_rd(bp, BNX2_LINK_STATUS);
0d8a6571 1778
df149d70
MC		 1779 if (msg & BNX2_LINK_STATUS_HEART_BEAT_EXPIRED)
1780 bnx2_send_heart_beat(bp);
1781
1782 msg &= ~BNX2_LINK_STATUS_HEART_BEAT_EXPIRED;
1783
0d8a6571
MC		 1784 if ((msg & BNX2_LINK_STATUS_LINK_UP) == BNX2_LINK_STATUS_LINK_DOWN)
1785 bp->link_up = 0;
1786 else {
1787 u32 speed;
1788
1789 bp->link_up = 1;
1790 speed = msg & BNX2_LINK_STATUS_SPEED_MASK;
1791 bp->duplex = DUPLEX_FULL;
1792 switch (speed) {
1793 case BNX2_LINK_STATUS_10HALF:
1794 bp->duplex = DUPLEX_HALF;
1795 case BNX2_LINK_STATUS_10FULL:
1796 bp->line_speed = SPEED_10;
1797 break;
1798 case BNX2_LINK_STATUS_100HALF:
1799 bp->duplex = DUPLEX_HALF;
1800 case BNX2_LINK_STATUS_100BASE_T4:
1801 case BNX2_LINK_STATUS_100FULL:
1802 bp->line_speed = SPEED_100;
1803 break;
1804 case BNX2_LINK_STATUS_1000HALF:
1805 bp->duplex = DUPLEX_HALF;
1806 case BNX2_LINK_STATUS_1000FULL:
1807 bp->line_speed = SPEED_1000;
1808 break;
1809 case BNX2_LINK_STATUS_2500HALF:
1810 bp->duplex = DUPLEX_HALF;
1811 case BNX2_LINK_STATUS_2500FULL:
1812 bp->line_speed = SPEED_2500;
1813 break;
1814 default:
1815 bp->line_speed = 0;
1816 break;
1817 }
1818
0d8a6571
MC		 1819 bp->flow_ctrl = 0;
1820 if ((bp->autoneg & (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) !=
1821 (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) {
1822 if (bp->duplex == DUPLEX_FULL)
1823 bp->flow_ctrl = bp->req_flow_ctrl;
1824 } else {
1825 if (msg & BNX2_LINK_STATUS_TX_FC_ENABLED)
1826 bp->flow_ctrl |= FLOW_CTRL_TX;
1827 if (msg & BNX2_LINK_STATUS_RX_FC_ENABLED)
1828 bp->flow_ctrl |= FLOW_CTRL_RX;
1829 }
1830
1831 old_port = bp->phy_port;
1832 if (msg & BNX2_LINK_STATUS_SERDES_LINK)
1833 bp->phy_port = PORT_FIBRE;
1834 else
1835 bp->phy_port = PORT_TP;
1836
1837 if (old_port != bp->phy_port)
1838 bnx2_set_default_link(bp);
1839
0d8a6571
MC		 1840 }
1841 if (bp->link_up != link_up)
1842 bnx2_report_link(bp);
1843
1844 bnx2_set_mac_link(bp);
1845}
1846
1847static int
1848bnx2_set_remote_link(struct bnx2 *bp)
1849{
1850 u32 evt_code;
1851
2726d6e1 1852 evt_code = bnx2_shmem_rd(bp, BNX2_FW_EVT_CODE_MB);
0d8a6571
MC		 1853 switch (evt_code) {
1854 case BNX2_FW_EVT_CODE_LINK_EVENT:
1855 bnx2_remote_phy_event(bp);
1856 break;
1857 case BNX2_FW_EVT_CODE_SW_TIMER_EXPIRATION_EVENT:
1858 default:
df149d70 1859 bnx2_send_heart_beat(bp);
0d8a6571
MC		 1860 break;
1861 }
1862 return 0;
1863}
1864
b6016b76
MC		 1865static int
1866bnx2_setup_copper_phy(struct bnx2 *bp)
1867{
1868 u32 bmcr;
1869 u32 new_bmcr;
1870
ca58c3af 1871 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
b6016b76
MC		 1872
1873 if (bp->autoneg & AUTONEG_SPEED) {
1874 u32 adv_reg, adv1000_reg;
1875 u32 new_adv_reg = 0;
1876 u32 new_adv1000_reg = 0;
1877
ca58c3af 1878 bnx2_read_phy(bp, bp->mii_adv, &adv_reg);
b6016b76
MC		 1879 adv_reg &= (PHY_ALL_10_100_SPEED | ADVERTISE_PAUSE_CAP |
1880 ADVERTISE_PAUSE_ASYM);
1881
1882 bnx2_read_phy(bp, MII_CTRL1000, &adv1000_reg);
1883 adv1000_reg &= PHY_ALL_1000_SPEED;
1884
1885 if (bp->advertising & ADVERTISED_10baseT_Half)
1886 new_adv_reg |= ADVERTISE_10HALF;
1887 if (bp->advertising & ADVERTISED_10baseT_Full)
1888 new_adv_reg |= ADVERTISE_10FULL;
1889 if (bp->advertising & ADVERTISED_100baseT_Half)
1890 new_adv_reg |= ADVERTISE_100HALF;
1891 if (bp->advertising & ADVERTISED_100baseT_Full)
1892 new_adv_reg |= ADVERTISE_100FULL;
1893 if (bp->advertising & ADVERTISED_1000baseT_Full)
1894 new_adv1000_reg |= ADVERTISE_1000FULL;
6aa20a22 1895
b6016b76
MC		 1896 new_adv_reg |= ADVERTISE_CSMA;
1897
1898 new_adv_reg |= bnx2_phy_get_pause_adv(bp);
1899
1900 if ((adv1000_reg != new_adv1000_reg) ||
1901 (adv_reg != new_adv_reg) ||
1902 ((bmcr & BMCR_ANENABLE) == 0)) {
1903
ca58c3af 1904 bnx2_write_phy(bp, bp->mii_adv, new_adv_reg);
b6016b76 1905 bnx2_write_phy(bp, MII_CTRL1000, new_adv1000_reg);
ca58c3af 1906 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_ANRESTART |
b6016b76
MC		 1907 BMCR_ANENABLE);
1908 }
1909 else if (bp->link_up) {
1910 /* Flow ctrl may have changed from auto to forced */
1911 /* or vice-versa. */
1912
1913 bnx2_resolve_flow_ctrl(bp);
1914 bnx2_set_mac_link(bp);
1915 }
1916 return 0;
1917 }
1918
1919 new_bmcr = 0;
1920 if (bp->req_line_speed == SPEED_100) {
1921 new_bmcr |= BMCR_SPEED100;
1922 }
1923 if (bp->req_duplex == DUPLEX_FULL) {
1924 new_bmcr |= BMCR_FULLDPLX;
1925 }
1926 if (new_bmcr != bmcr) {
1927 u32 bmsr;
b6016b76 1928
ca58c3af
MC		 1929 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
1930 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
6aa20a22 1931
b6016b76
MC		 1932 if (bmsr & BMSR_LSTATUS) {
1933 /* Force link down */
ca58c3af 1934 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK);
a16dda0e
MC		 1935 spin_unlock_bh(&bp->phy_lock);
1936 msleep(50);
1937 spin_lock_bh(&bp->phy_lock);
1938
ca58c3af
MC		 1939 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
1940 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
b6016b76
MC		 1941 }
1942
ca58c3af 1943 bnx2_write_phy(bp, bp->mii_bmcr, new_bmcr);
b6016b76
MC		 1944
1945 /* Normally, the new speed is setup after the link has
1946 * gone down and up again. In some cases, link will not go
1947 * down so we need to set up the new speed here.
1948 */
1949 if (bmsr & BMSR_LSTATUS) {
1950 bp->line_speed = bp->req_line_speed;
1951 bp->duplex = bp->req_duplex;
1952 bnx2_resolve_flow_ctrl(bp);
1953 bnx2_set_mac_link(bp);
1954 }
27a005b8
MC		 1955 } else {
1956 bnx2_resolve_flow_ctrl(bp);
1957 bnx2_set_mac_link(bp);
b6016b76
MC		 1958 }
1959 return 0;
1960}
1961
1962static int
0d8a6571 1963bnx2_setup_phy(struct bnx2 *bp, u8 port)
b6016b76
MC		 1964{
1965 if (bp->loopback == MAC_LOOPBACK)
1966 return 0;
1967
583c28e5 1968 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
0d8a6571 1969 return (bnx2_setup_serdes_phy(bp, port));
b6016b76
MC		 1970 }
1971 else {
1972 return (bnx2_setup_copper_phy(bp));
1973 }
1974}
1975
27a005b8 1976static int
9a120bc5 1977bnx2_init_5709s_phy(struct bnx2 *bp, int reset_phy)
27a005b8
MC		 1978{
1979 u32 val;
1980
1981 bp->mii_bmcr = MII_BMCR + 0x10;
1982 bp->mii_bmsr = MII_BMSR + 0x10;
1983 bp->mii_bmsr1 = MII_BNX2_GP_TOP_AN_STATUS1;
1984 bp->mii_adv = MII_ADVERTISE + 0x10;
1985 bp->mii_lpa = MII_LPA + 0x10;
1986 bp->mii_up1 = MII_BNX2_OVER1G_UP1;
1987
1988 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_AER);
1989 bnx2_write_phy(bp, MII_BNX2_AER_AER, MII_BNX2_AER_AER_AN_MMD);
1990
1991 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
9a120bc5
MC		 1992 if (reset_phy)
1993 bnx2_reset_phy(bp);
27a005b8
MC		 1994
1995 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_SERDES_DIG);
1996
1997 bnx2_read_phy(bp, MII_BNX2_SERDES_DIG_1000XCTL1, &val);
1998 val &= ~MII_BNX2_SD_1000XCTL1_AUTODET;
1999 val |= MII_BNX2_SD_1000XCTL1_FIBER;
2000 bnx2_write_phy(bp, MII_BNX2_SERDES_DIG_1000XCTL1, val);
2001
2002 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_OVER1G);
2003 bnx2_read_phy(bp, MII_BNX2_OVER1G_UP1, &val);
583c28e5 2004 if (bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE)
27a005b8
MC		 2005 val |= BCM5708S_UP1_2G5;
2006 else
2007 val &= ~BCM5708S_UP1_2G5;
2008 bnx2_write_phy(bp, MII_BNX2_OVER1G_UP1, val);
2009
2010 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_BAM_NXTPG);
2011 bnx2_read_phy(bp, MII_BNX2_BAM_NXTPG_CTL, &val);
2012 val |= MII_BNX2_NXTPG_CTL_T2 | MII_BNX2_NXTPG_CTL_BAM;
2013 bnx2_write_phy(bp, MII_BNX2_BAM_NXTPG_CTL, val);
2014
2015 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_CL73_USERB0);
2016
2017 val = MII_BNX2_CL73_BAM_EN | MII_BNX2_CL73_BAM_STA_MGR_EN |
2018 MII_BNX2_CL73_BAM_NP_AFT_BP_EN;
2019 bnx2_write_phy(bp, MII_BNX2_CL73_BAM_CTL1, val);
2020
2021 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
2022
2023 return 0;
2024}
2025
b6016b76 2026static int
9a120bc5 2027bnx2_init_5708s_phy(struct bnx2 *bp, int reset_phy)
5b0c76ad
MC		 2028{
2029 u32 val;
2030
9a120bc5
MC		 2031 if (reset_phy)
2032 bnx2_reset_phy(bp);
27a005b8
MC		 2033
2034 bp->mii_up1 = BCM5708S_UP1;
2035
5b0c76ad
MC		 2036 bnx2_write_phy(bp, BCM5708S_BLK_ADDR, BCM5708S_BLK_ADDR_DIG3);
2037 bnx2_write_phy(bp, BCM5708S_DIG_3_0, BCM5708S_DIG_3_0_USE_IEEE);
2038 bnx2_write_phy(bp, BCM5708S_BLK_ADDR, BCM5708S_BLK_ADDR_DIG);
2039
2040 bnx2_read_phy(bp, BCM5708S_1000X_CTL1, &val);
2041 val |= BCM5708S_1000X_CTL1_FIBER_MODE | BCM5708S_1000X_CTL1_AUTODET_EN;
2042 bnx2_write_phy(bp, BCM5708S_1000X_CTL1, val);
2043
2044 bnx2_read_phy(bp, BCM5708S_1000X_CTL2, &val);
2045 val |= BCM5708S_1000X_CTL2_PLLEL_DET_EN;
2046 bnx2_write_phy(bp, BCM5708S_1000X_CTL2, val);
2047
583c28e5 2048 if (bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE) {
5b0c76ad
MC		 2049 bnx2_read_phy(bp, BCM5708S_UP1, &val);
2050 val |= BCM5708S_UP1_2G5;
2051 bnx2_write_phy(bp, BCM5708S_UP1, val);
2052 }
2053
2054 if ((CHIP_ID(bp) == CHIP_ID_5708_A0) ||
dda1e390
MC		 2055 (CHIP_ID(bp) == CHIP_ID_5708_B0) ||
2056 (CHIP_ID(bp) == CHIP_ID_5708_B1)) {
5b0c76ad
MC		 2057 /* increase tx signal amplitude */
2058 bnx2_write_phy(bp, BCM5708S_BLK_ADDR,
2059 BCM5708S_BLK_ADDR_TX_MISC);
2060 bnx2_read_phy(bp, BCM5708S_TX_ACTL1, &val);
2061 val &= ~BCM5708S_TX_ACTL1_DRIVER_VCM;
2062 bnx2_write_phy(bp, BCM5708S_TX_ACTL1, val);
2063 bnx2_write_phy(bp, BCM5708S_BLK_ADDR, BCM5708S_BLK_ADDR_DIG);
2064 }
2065
2726d6e1 2066 val = bnx2_shmem_rd(bp, BNX2_PORT_HW_CFG_CONFIG) &
5b0c76ad
MC		 2067 BNX2_PORT_HW_CFG_CFG_TXCTL3_MASK;
2068
2069 if (val) {
2070 u32 is_backplane;
2071
2726d6e1 2072 is_backplane = bnx2_shmem_rd(bp, BNX2_SHARED_HW_CFG_CONFIG);
5b0c76ad
MC		 2073 if (is_backplane & BNX2_SHARED_HW_CFG_PHY_BACKPLANE) {
2074 bnx2_write_phy(bp, BCM5708S_BLK_ADDR,
2075 BCM5708S_BLK_ADDR_TX_MISC);
2076 bnx2_write_phy(bp, BCM5708S_TX_ACTL3, val);
2077 bnx2_write_phy(bp, BCM5708S_BLK_ADDR,
2078 BCM5708S_BLK_ADDR_DIG);
2079 }
2080 }
2081 return 0;
2082}
2083
2084static int
9a120bc5 2085bnx2_init_5706s_phy(struct bnx2 *bp, int reset_phy)
b6016b76 2086{
9a120bc5
MC		 2087 if (reset_phy)
2088 bnx2_reset_phy(bp);
27a005b8 2089
583c28e5 2090 bp->phy_flags &= ~BNX2_PHY_FLAG_PARALLEL_DETECT;
b6016b76 2091
59b47d8a
MC		 2092 if (CHIP_NUM(bp) == CHIP_NUM_5706)
2093 REG_WR(bp, BNX2_MISC_GP_HW_CTL0, 0x300);
b6016b76
MC		 2094
2095 if (bp->dev->mtu > 1500) {
2096 u32 val;
2097
2098 /* Set extended packet length bit */
2099 bnx2_write_phy(bp, 0x18, 0x7);
2100 bnx2_read_phy(bp, 0x18, &val);
2101 bnx2_write_phy(bp, 0x18, (val & 0xfff8) | 0x4000);
2102
2103 bnx2_write_phy(bp, 0x1c, 0x6c00);
2104 bnx2_read_phy(bp, 0x1c, &val);
2105 bnx2_write_phy(bp, 0x1c, (val & 0x3ff) | 0xec02);
2106 }
2107 else {
2108 u32 val;
2109
2110 bnx2_write_phy(bp, 0x18, 0x7);
2111 bnx2_read_phy(bp, 0x18, &val);
2112 bnx2_write_phy(bp, 0x18, val & ~0x4007);
2113
2114 bnx2_write_phy(bp, 0x1c, 0x6c00);
2115 bnx2_read_phy(bp, 0x1c, &val);
2116 bnx2_write_phy(bp, 0x1c, (val & 0x3fd) | 0xec00);
2117 }
2118
2119 return 0;
2120}
2121
2122static int
9a120bc5 2123bnx2_init_copper_phy(struct bnx2 *bp, int reset_phy)
b6016b76 2124{
5b0c76ad
MC		 2125 u32 val;
2126
9a120bc5
MC		 2127 if (reset_phy)
2128 bnx2_reset_phy(bp);
27a005b8 2129
583c28e5 2130 if (bp->phy_flags & BNX2_PHY_FLAG_CRC_FIX) {
b6016b76
MC		 2131 bnx2_write_phy(bp, 0x18, 0x0c00);
2132 bnx2_write_phy(bp, 0x17, 0x000a);
2133 bnx2_write_phy(bp, 0x15, 0x310b);
2134 bnx2_write_phy(bp, 0x17, 0x201f);
2135 bnx2_write_phy(bp, 0x15, 0x9506);
2136 bnx2_write_phy(bp, 0x17, 0x401f);
2137 bnx2_write_phy(bp, 0x15, 0x14e2);
2138 bnx2_write_phy(bp, 0x18, 0x0400);
2139 }
2140
583c28e5 2141 if (bp->phy_flags & BNX2_PHY_FLAG_DIS_EARLY_DAC) {
b659f44e
MC		 2142 bnx2_write_phy(bp, MII_BNX2_DSP_ADDRESS,
2143 MII_BNX2_DSP_EXPAND_REG | 0x8);
2144 bnx2_read_phy(bp, MII_BNX2_DSP_RW_PORT, &val);
2145 val &= ~(1 << 8);
2146 bnx2_write_phy(bp, MII_BNX2_DSP_RW_PORT, val);
2147 }
2148
b6016b76 2149 if (bp->dev->mtu > 1500) {
b6016b76
MC		 2150 /* Set extended packet length bit */
2151 bnx2_write_phy(bp, 0x18, 0x7);
2152 bnx2_read_phy(bp, 0x18, &val);
2153 bnx2_write_phy(bp, 0x18, val | 0x4000);
2154
2155 bnx2_read_phy(bp, 0x10, &val);
2156 bnx2_write_phy(bp, 0x10, val | 0x1);
2157 }
2158 else {
b6016b76
MC		 2159 bnx2_write_phy(bp, 0x18, 0x7);
2160 bnx2_read_phy(bp, 0x18, &val);
2161 bnx2_write_phy(bp, 0x18, val & ~0x4007);
2162
2163 bnx2_read_phy(bp, 0x10, &val);
2164 bnx2_write_phy(bp, 0x10, val & ~0x1);
2165 }
2166
5b0c76ad
MC		 2167 /* ethernet@wirespeed */
2168 bnx2_write_phy(bp, 0x18, 0x7007);
2169 bnx2_read_phy(bp, 0x18, &val);
2170 bnx2_write_phy(bp, 0x18, val | (1 << 15) | (1 << 4));
b6016b76
MC		 2171 return 0;
2172}
2173
2174
2175static int
9a120bc5 2176bnx2_init_phy(struct bnx2 *bp, int reset_phy)
b6016b76
MC		 2177{
2178 u32 val;
2179 int rc = 0;
2180
583c28e5
MC		 2181 bp->phy_flags &= ~BNX2_PHY_FLAG_INT_MODE_MASK;
2182 bp->phy_flags |= BNX2_PHY_FLAG_INT_MODE_LINK_READY;
b6016b76 2183
ca58c3af
MC		 2184 bp->mii_bmcr = MII_BMCR;
2185 bp->mii_bmsr = MII_BMSR;
27a005b8 2186 bp->mii_bmsr1 = MII_BMSR;
ca58c3af
MC		 2187 bp->mii_adv = MII_ADVERTISE;
2188 bp->mii_lpa = MII_LPA;
2189
b6016b76
MC		 2190 REG_WR(bp, BNX2_EMAC_ATTENTION_ENA, BNX2_EMAC_ATTENTION_ENA_LINK);
2191
583c28e5 2192 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
0d8a6571
MC		 2193 goto setup_phy;
2194
b6016b76
MC		 2195 bnx2_read_phy(bp, MII_PHYSID1, &val);
2196 bp->phy_id = val << 16;
2197 bnx2_read_phy(bp, MII_PHYSID2, &val);
2198 bp->phy_id |= val & 0xffff;
2199
583c28e5 2200 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
5b0c76ad 2201 if (CHIP_NUM(bp) == CHIP_NUM_5706)
9a120bc5 2202 rc = bnx2_init_5706s_phy(bp, reset_phy);
5b0c76ad 2203 else if (CHIP_NUM(bp) == CHIP_NUM_5708)
9a120bc5 2204 rc = bnx2_init_5708s_phy(bp, reset_phy);
27a005b8 2205 else if (CHIP_NUM(bp) == CHIP_NUM_5709)
9a120bc5 2206 rc = bnx2_init_5709s_phy(bp, reset_phy);
b6016b76
MC		 2207 }
2208 else {
9a120bc5 2209 rc = bnx2_init_copper_phy(bp, reset_phy);
b6016b76
MC		 2210 }
2211
0d8a6571
MC		 2212setup_phy:
2213 if (!rc)
2214 rc = bnx2_setup_phy(bp, bp->phy_port);
b6016b76
MC		 2215
2216 return rc;
2217}
2218
2219static int
2220bnx2_set_mac_loopback(struct bnx2 *bp)
2221{
2222 u32 mac_mode;
2223
2224 mac_mode = REG_RD(bp, BNX2_EMAC_MODE);
2225 mac_mode &= ~BNX2_EMAC_MODE_PORT;
2226 mac_mode |= BNX2_EMAC_MODE_MAC_LOOP | BNX2_EMAC_MODE_FORCE_LINK;
2227 REG_WR(bp, BNX2_EMAC_MODE, mac_mode);
2228 bp->link_up = 1;
2229 return 0;
2230}
2231
bc5a0690
MC		 2232static int bnx2_test_link(struct bnx2 *);
2233
2234static int
2235bnx2_set_phy_loopback(struct bnx2 *bp)
2236{
2237 u32 mac_mode;
2238 int rc, i;
2239
2240 spin_lock_bh(&bp->phy_lock);
ca58c3af 2241 rc = bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK | BMCR_FULLDPLX |
bc5a0690
MC		 2242 BMCR_SPEED1000);
2243 spin_unlock_bh(&bp->phy_lock);
2244 if (rc)
2245 return rc;
2246
2247 for (i = 0; i < 10; i++) {
2248 if (bnx2_test_link(bp) == 0)
2249 break;
80be4434 2250 msleep(100);
bc5a0690
MC		 2251 }
2252
2253 mac_mode = REG_RD(bp, BNX2_EMAC_MODE);
2254 mac_mode &= ~(BNX2_EMAC_MODE_PORT | BNX2_EMAC_MODE_HALF_DUPLEX |
2255 BNX2_EMAC_MODE_MAC_LOOP | BNX2_EMAC_MODE_FORCE_LINK |
59b47d8a 2256 BNX2_EMAC_MODE_25G_MODE);
bc5a0690
MC		 2257
2258 mac_mode |= BNX2_EMAC_MODE_PORT_GMII;
2259 REG_WR(bp, BNX2_EMAC_MODE, mac_mode);
2260 bp->link_up = 1;
2261 return 0;
2262}
2263
b6016b76 2264static int
a2f13890 2265bnx2_fw_sync(struct bnx2 *bp, u32 msg_data, int ack, int silent)
b6016b76
MC		 2266{
2267 int i;
2268 u32 val;
2269
b6016b76
MC		 2270 bp->fw_wr_seq++;
2271 msg_data |= bp->fw_wr_seq;
2272
2726d6e1 2273 bnx2_shmem_wr(bp, BNX2_DRV_MB, msg_data);
b6016b76 2274
a2f13890
MC		 2275 if (!ack)
2276 return 0;
2277
b6016b76 2278 /* wait for an acknowledgement. */
b090ae2b
MC		 2279 for (i = 0; i < (FW_ACK_TIME_OUT_MS / 10); i++) {
2280 msleep(10);
b6016b76 2281
2726d6e1 2282 val = bnx2_shmem_rd(bp, BNX2_FW_MB);
b6016b76
MC		 2283
2284 if ((val & BNX2_FW_MSG_ACK) == (msg_data & BNX2_DRV_MSG_SEQ))
2285 break;
2286 }
b090ae2b
MC		 2287 if ((msg_data & BNX2_DRV_MSG_DATA) == BNX2_DRV_MSG_DATA_WAIT0)
2288 return 0;
b6016b76
MC		 2289
2290 /* If we timed out, inform the firmware that this is the case. */
b090ae2b
MC		 2291 if ((val & BNX2_FW_MSG_ACK) != (msg_data & BNX2_DRV_MSG_SEQ)) {
2292 if (!silent)
2293 printk(KERN_ERR PFX "fw sync timeout, reset code = "
2294 "%x\n", msg_data);
b6016b76
MC		 2295
2296 msg_data &= ~BNX2_DRV_MSG_CODE;
2297 msg_data |= BNX2_DRV_MSG_CODE_FW_TIMEOUT;
2298
2726d6e1 2299 bnx2_shmem_wr(bp, BNX2_DRV_MB, msg_data);
b6016b76 2300
b6016b76
MC		 2301 return -EBUSY;
2302 }
2303
b090ae2b
MC		 2304 if ((val & BNX2_FW_MSG_STATUS_MASK) != BNX2_FW_MSG_STATUS_OK)
2305 return -EIO;
2306
b6016b76
MC		 2307 return 0;
2308}
2309
59b47d8a
MC		 2310static int
2311bnx2_init_5709_context(struct bnx2 *bp)
2312{
2313 int i, ret = 0;
2314 u32 val;
2315
2316 val = BNX2_CTX_COMMAND_ENABLED | BNX2_CTX_COMMAND_MEM_INIT | (1 << 12);
2317 val |= (BCM_PAGE_BITS - 8) << 16;
2318 REG_WR(bp, BNX2_CTX_COMMAND, val);
641bdcd5
MC		 2319 for (i = 0; i < 10; i++) {
2320 val = REG_RD(bp, BNX2_CTX_COMMAND);
2321 if (!(val & BNX2_CTX_COMMAND_MEM_INIT))
2322 break;
2323 udelay(2);
2324 }
2325 if (val & BNX2_CTX_COMMAND_MEM_INIT)
2326 return -EBUSY;
2327
59b47d8a
MC		 2328 for (i = 0; i < bp->ctx_pages; i++) {
2329 int j;
2330
352f7687
MC		 2331 if (bp->ctx_blk[i])
2332 memset(bp->ctx_blk[i], 0, BCM_PAGE_SIZE);
2333 else
2334 return -ENOMEM;
2335
59b47d8a
MC		 2336 REG_WR(bp, BNX2_CTX_HOST_PAGE_TBL_DATA0,
2337 (bp->ctx_blk_mapping[i] & 0xffffffff) |
2338 BNX2_CTX_HOST_PAGE_TBL_DATA0_VALID);
2339 REG_WR(bp, BNX2_CTX_HOST_PAGE_TBL_DATA1,
2340 (u64) bp->ctx_blk_mapping[i] >> 32);
2341 REG_WR(bp, BNX2_CTX_HOST_PAGE_TBL_CTRL, i |
2342 BNX2_CTX_HOST_PAGE_TBL_CTRL_WRITE_REQ);
2343 for (j = 0; j < 10; j++) {
2344
2345 val = REG_RD(bp, BNX2_CTX_HOST_PAGE_TBL_CTRL);
2346 if (!(val & BNX2_CTX_HOST_PAGE_TBL_CTRL_WRITE_REQ))
2347 break;
2348 udelay(5);
2349 }
2350 if (val & BNX2_CTX_HOST_PAGE_TBL_CTRL_WRITE_REQ) {
2351 ret = -EBUSY;
2352 break;
2353 }
2354 }
2355 return ret;
2356}
2357
b6016b76
MC		 2358static void
2359bnx2_init_context(struct bnx2 *bp)
2360{
2361 u32 vcid;
2362
2363 vcid = 96;
2364 while (vcid) {
2365 u32 vcid_addr, pcid_addr, offset;
7947b20e 2366 int i;
b6016b76
MC		 2367
2368 vcid--;
2369
2370 if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
2371 u32 new_vcid;
2372
2373 vcid_addr = GET_PCID_ADDR(vcid);
2374 if (vcid & 0x8) {
2375 new_vcid = 0x60 + (vcid & 0xf0) + (vcid & 0x7);
2376 }
2377 else {
2378 new_vcid = vcid;
2379 }
2380 pcid_addr = GET_PCID_ADDR(new_vcid);
2381 }
2382 else {
2383 vcid_addr = GET_CID_ADDR(vcid);
2384 pcid_addr = vcid_addr;
2385 }
2386
7947b20e
MC		 2387 for (i = 0; i < (CTX_SIZE / PHY_CTX_SIZE); i++) {
2388 vcid_addr += (i << PHY_CTX_SHIFT);
2389 pcid_addr += (i << PHY_CTX_SHIFT);
b6016b76 2390
5d5d0015 2391 REG_WR(bp, BNX2_CTX_VIRT_ADDR, vcid_addr);
7947b20e 2392 REG_WR(bp, BNX2_CTX_PAGE_TBL, pcid_addr);
b6016b76 2393
7947b20e
MC		 2394 /* Zero out the context. */
2395 for (offset = 0; offset < PHY_CTX_SIZE; offset += 4)
62a8313c 2396 bnx2_ctx_wr(bp, vcid_addr, offset, 0);
7947b20e 2397 }
b6016b76
MC		 2398 }
2399}
2400
2401static int
2402bnx2_alloc_bad_rbuf(struct bnx2 *bp)
2403{
2404 u16 *good_mbuf;
2405 u32 good_mbuf_cnt;
2406 u32 val;
2407
2408 good_mbuf = kmalloc(512 * sizeof(u16), GFP_KERNEL);
2409 if (good_mbuf == NULL) {
2410 printk(KERN_ERR PFX "Failed to allocate memory in "
2411 "bnx2_alloc_bad_rbuf\n");
2412 return -ENOMEM;
2413 }
2414
2415 REG_WR(bp, BNX2_MISC_ENABLE_SET_BITS,
2416 BNX2_MISC_ENABLE_SET_BITS_RX_MBUF_ENABLE);
2417
2418 good_mbuf_cnt = 0;
2419
2420 /* Allocate a bunch of mbufs and save the good ones in an array. */
2726d6e1 2421 val = bnx2_reg_rd_ind(bp, BNX2_RBUF_STATUS1);
b6016b76 2422 while (val & BNX2_RBUF_STATUS1_FREE_COUNT) {
2726d6e1
MC		 2423 bnx2_reg_wr_ind(bp, BNX2_RBUF_COMMAND,
2424 BNX2_RBUF_COMMAND_ALLOC_REQ);
b6016b76 2425
2726d6e1 2426 val = bnx2_reg_rd_ind(bp, BNX2_RBUF_FW_BUF_ALLOC);
b6016b76
MC		 2427
2428 val &= BNX2_RBUF_FW_BUF_ALLOC_VALUE;
2429
2430 /* The addresses with Bit 9 set are bad memory blocks. */
2431 if (!(val & (1 << 9))) {
2432 good_mbuf[good_mbuf_cnt] = (u16) val;
2433 good_mbuf_cnt++;
2434 }
2435
2726d6e1 2436 val = bnx2_reg_rd_ind(bp, BNX2_RBUF_STATUS1);
b6016b76
MC		 2437 }
2438
2439 /* Free the good ones back to the mbuf pool thus discarding
2440 * all the bad ones. */
2441 while (good_mbuf_cnt) {
2442 good_mbuf_cnt--;
2443
2444 val = good_mbuf[good_mbuf_cnt];
2445 val = (val << 9) | val | 1;
2446
2726d6e1 2447 bnx2_reg_wr_ind(bp, BNX2_RBUF_FW_BUF_FREE, val);
b6016b76
MC		 2448 }
2449 kfree(good_mbuf);
2450 return 0;
2451}
2452
2453static void
5fcaed01 2454bnx2_set_mac_addr(struct bnx2 *bp, u8 *mac_addr, u32 pos)
b6016b76
MC		 2455{
2456 u32 val;
b6016b76
MC		 2457
2458 val = (mac_addr[0] << 8) | mac_addr[1];
2459
5fcaed01 2460 REG_WR(bp, BNX2_EMAC_MAC_MATCH0 + (pos * 8), val);
b6016b76 2461
6aa20a22 2462 val = (mac_addr[2] << 24) | (mac_addr[3] << 16) |
b6016b76
MC		 2463 (mac_addr[4] << 8) | mac_addr[5];
2464
5fcaed01 2465 REG_WR(bp, BNX2_EMAC_MAC_MATCH1 + (pos * 8), val);
b6016b76
MC		 2466}
2467
47bf4246 2468static inline int
bb4f98ab 2469bnx2_alloc_rx_page(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr, u16 index)
47bf4246
MC		 2470{
2471 dma_addr_t mapping;
bb4f98ab 2472 struct sw_pg *rx_pg = &rxr->rx_pg_ring[index];
47bf4246 2473 struct rx_bd *rxbd =
bb4f98ab 2474 &rxr->rx_pg_desc_ring[RX_RING(index)][RX_IDX(index)];
47bf4246
MC		 2475 struct page *page = alloc_page(GFP_ATOMIC);
2476
2477 if (!page)
2478 return -ENOMEM;
2479 mapping = pci_map_page(bp->pdev, page, 0, PAGE_SIZE,
2480 PCI_DMA_FROMDEVICE);
2481 rx_pg->page = page;
2482 pci_unmap_addr_set(rx_pg, mapping, mapping);
2483 rxbd->rx_bd_haddr_hi = (u64) mapping >> 32;
2484 rxbd->rx_bd_haddr_lo = (u64) mapping & 0xffffffff;
2485 return 0;
2486}
2487
2488static void
bb4f98ab 2489bnx2_free_rx_page(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr, u16 index)
47bf4246 2490{
bb4f98ab 2491 struct sw_pg *rx_pg = &rxr->rx_pg_ring[index];
47bf4246
MC		 2492 struct page *page = rx_pg->page;
2493
2494 if (!page)
2495 return;
2496
2497 pci_unmap_page(bp->pdev, pci_unmap_addr(rx_pg, mapping), PAGE_SIZE,
2498 PCI_DMA_FROMDEVICE);
2499
2500 __free_page(page);
2501 rx_pg->page = NULL;
2502}
2503
b6016b76 2504static inline int
bb4f98ab 2505bnx2_alloc_rx_skb(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr, u16 index)
b6016b76
MC		 2506{
2507 struct sk_buff *skb;
bb4f98ab 2508 struct sw_bd *rx_buf = &rxr->rx_buf_ring[index];
b6016b76 2509 dma_addr_t mapping;
bb4f98ab 2510 struct rx_bd *rxbd = &rxr->rx_desc_ring[RX_RING(index)][RX_IDX(index)];
b6016b76
MC		 2511 unsigned long align;
2512
932f3772 2513 skb = netdev_alloc_skb(bp->dev, bp->rx_buf_size);
b6016b76
MC		 2514 if (skb == NULL) {
2515 return -ENOMEM;
2516 }
2517
59b47d8a
MC		 2518 if (unlikely((align = (unsigned long) skb->data & (BNX2_RX_ALIGN - 1))))
2519 skb_reserve(skb, BNX2_RX_ALIGN - align);
b6016b76 2520
b6016b76
MC		 2521 mapping = pci_map_single(bp->pdev, skb->data, bp->rx_buf_use_size,
2522 PCI_DMA_FROMDEVICE);
2523
2524 rx_buf->skb = skb;
2525 pci_unmap_addr_set(rx_buf, mapping, mapping);
2526
2527 rxbd->rx_bd_haddr_hi = (u64) mapping >> 32;
2528 rxbd->rx_bd_haddr_lo = (u64) mapping & 0xffffffff;
2529
bb4f98ab 2530 rxr->rx_prod_bseq += bp->rx_buf_use_size;
b6016b76
MC		 2531
2532 return 0;
2533}
2534
da3e4fbe 2535static int
35efa7c1 2536bnx2_phy_event_is_set(struct bnx2 *bp, struct bnx2_napi *bnapi, u32 event)
b6016b76 2537{
43e80b89 2538 struct status_block *sblk = bnapi->status_blk.msi;
b6016b76 2539 u32 new_link_state, old_link_state;
da3e4fbe 2540 int is_set = 1;
b6016b76 2541
da3e4fbe
MC		 2542 new_link_state = sblk->status_attn_bits & event;
2543 old_link_state = sblk->status_attn_bits_ack & event;
b6016b76 2544 if (new_link_state != old_link_state) {
da3e4fbe
MC		 2545 if (new_link_state)
2546 REG_WR(bp, BNX2_PCICFG_STATUS_BIT_SET_CMD, event);
2547 else
2548 REG_WR(bp, BNX2_PCICFG_STATUS_BIT_CLEAR_CMD, event);
2549 } else
2550 is_set = 0;
2551
2552 return is_set;
2553}
2554
2555static void
35efa7c1 2556bnx2_phy_int(struct bnx2 *bp, struct bnx2_napi *bnapi)
da3e4fbe 2557{
74ecc62d
MC		 2558 spin_lock(&bp->phy_lock);
2559
2560 if (bnx2_phy_event_is_set(bp, bnapi, STATUS_ATTN_BITS_LINK_STATE))
b6016b76 2561 bnx2_set_link(bp);
35efa7c1 2562 if (bnx2_phy_event_is_set(bp, bnapi, STATUS_ATTN_BITS_TIMER_ABORT))
0d8a6571
MC		 2563 bnx2_set_remote_link(bp);
2564
74ecc62d
MC		 2565 spin_unlock(&bp->phy_lock);
2566
b6016b76
MC		 2567}
2568
ead7270b 2569static inline u16
35efa7c1 2570bnx2_get_hw_tx_cons(struct bnx2_napi *bnapi)
ead7270b
MC		 2571{
2572 u16 cons;
2573
43e80b89
MC		 2574 /* Tell compiler that status block fields can change. */
2575 barrier();
2576 cons = *bnapi->hw_tx_cons_ptr;
ead7270b
MC		 2577 if (unlikely((cons & MAX_TX_DESC_CNT) == MAX_TX_DESC_CNT))
2578 cons++;
2579 return cons;
2580}
2581
57851d84
MC		 2582static int
2583bnx2_tx_int(struct bnx2 *bp, struct bnx2_napi *bnapi, int budget)
b6016b76 2584{
35e9010b 2585 struct bnx2_tx_ring_info *txr = &bnapi->tx_ring;
b6016b76 2586 u16 hw_cons, sw_cons, sw_ring_cons;
706bf240
BL		 2587 int tx_pkt = 0, index;
2588 struct netdev_queue *txq;
2589
2590 index = (bnapi - bp->bnx2_napi);
2591 txq = netdev_get_tx_queue(bp->dev, index);
b6016b76 2592
35efa7c1 2593 hw_cons = bnx2_get_hw_tx_cons(bnapi);
35e9010b 2594 sw_cons = txr->tx_cons;
b6016b76
MC		 2595
2596 while (sw_cons != hw_cons) {
2597 struct sw_bd *tx_buf;
2598 struct sk_buff *skb;
2599 int i, last;
2600
2601 sw_ring_cons = TX_RING_IDX(sw_cons);
2602
35e9010b 2603 tx_buf = &txr->tx_buf_ring[sw_ring_cons];
b6016b76 2604 skb = tx_buf->skb;
1d39ed56 2605
b6016b76 2606 /* partial BD completions possible with TSO packets */
89114afd 2607 if (skb_is_gso(skb)) {
b6016b76
MC		 2608 u16 last_idx, last_ring_idx;
2609
2610 last_idx = sw_cons +
2611 skb_shinfo(skb)->nr_frags + 1;
2612 last_ring_idx = sw_ring_cons +
2613 skb_shinfo(skb)->nr_frags + 1;
2614 if (unlikely(last_ring_idx >= MAX_TX_DESC_CNT)) {
2615 last_idx++;
2616 }
2617 if (((s16) ((s16) last_idx - (s16) hw_cons)) > 0) {
2618 break;
2619 }
2620 }
1d39ed56 2621
b6016b76
MC		 2622 pci_unmap_single(bp->pdev, pci_unmap_addr(tx_buf, mapping),
2623 skb_headlen(skb), PCI_DMA_TODEVICE);
2624
2625 tx_buf->skb = NULL;
2626 last = skb_shinfo(skb)->nr_frags;
2627
2628 for (i = 0; i < last; i++) {
2629 sw_cons = NEXT_TX_BD(sw_cons);
2630
2631 pci_unmap_page(bp->pdev,
2632 pci_unmap_addr(
35e9010b 2633 &txr->tx_buf_ring[TX_RING_IDX(sw_cons)],
b6016b76
MC		 2634 mapping),
2635 skb_shinfo(skb)->frags[i].size,
2636 PCI_DMA_TODEVICE);
2637 }
2638
2639 sw_cons = NEXT_TX_BD(sw_cons);
2640
745720e5 2641 dev_kfree_skb(skb);
57851d84
MC		 2642 tx_pkt++;
2643 if (tx_pkt == budget)
2644 break;
b6016b76 2645
35efa7c1 2646 hw_cons = bnx2_get_hw_tx_cons(bnapi);
b6016b76
MC		 2647 }
2648
35e9010b
MC		 2649 txr->hw_tx_cons = hw_cons;
2650 txr->tx_cons = sw_cons;
706bf240 2651
2f8af120 2652 /* Need to make the tx_cons update visible to bnx2_start_xmit()
706bf240 2653 * before checking for netif_tx_queue_stopped(). Without the
2f8af120
MC		 2654 * memory barrier, there is a small possibility that bnx2_start_xmit()
2655 * will miss it and cause the queue to be stopped forever.
2656 */
2657 smp_mb();
b6016b76 2658
706bf240 2659 if (unlikely(netif_tx_queue_stopped(txq)) &&
35e9010b 2660 (bnx2_tx_avail(bp, txr) > bp->tx_wake_thresh)) {
706bf240
BL		 2661 __netif_tx_lock(txq, smp_processor_id());
2662 if ((netif_tx_queue_stopped(txq)) &&
35e9010b 2663 (bnx2_tx_avail(bp, txr) > bp->tx_wake_thresh))
706bf240
BL		 2664 netif_tx_wake_queue(txq);
2665 __netif_tx_unlock(txq);
b6016b76 2666 }
706bf240 2667
57851d84 2668 return tx_pkt;
b6016b76
MC		 2669}
2670
1db82f2a 2671static void
bb4f98ab 2672bnx2_reuse_rx_skb_pages(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr,
a1f60190 2673 struct sk_buff *skb, int count)
1db82f2a
MC		 2674{
2675 struct sw_pg *cons_rx_pg, *prod_rx_pg;
2676 struct rx_bd *cons_bd, *prod_bd;
2677 dma_addr_t mapping;
2678 int i;
bb4f98ab
MC		 2679 u16 hw_prod = rxr->rx_pg_prod, prod;
2680 u16 cons = rxr->rx_pg_cons;
1db82f2a
MC		 2681
2682 for (i = 0; i < count; i++) {
2683 prod = RX_PG_RING_IDX(hw_prod);
2684
bb4f98ab
MC		 2685 prod_rx_pg = &rxr->rx_pg_ring[prod];
2686 cons_rx_pg = &rxr->rx_pg_ring[cons];
2687 cons_bd = &rxr->rx_pg_desc_ring[RX_RING(cons)][RX_IDX(cons)];
2688 prod_bd = &rxr->rx_pg_desc_ring[RX_RING(prod)][RX_IDX(prod)];
1db82f2a
MC		 2689
2690 if (i == 0 && skb) {
2691 struct page *page;
2692 struct skb_shared_info *shinfo;
2693
2694 shinfo = skb_shinfo(skb);
2695 shinfo->nr_frags--;
2696 page = shinfo->frags[shinfo->nr_frags].page;
2697 shinfo->frags[shinfo->nr_frags].page = NULL;
2698 mapping = pci_map_page(bp->pdev, page, 0, PAGE_SIZE,
2699 PCI_DMA_FROMDEVICE);
2700 cons_rx_pg->page = page;
2701 pci_unmap_addr_set(cons_rx_pg, mapping, mapping);
2702 dev_kfree_skb(skb);
2703 }
2704 if (prod != cons) {
2705 prod_rx_pg->page = cons_rx_pg->page;
2706 cons_rx_pg->page = NULL;
2707 pci_unmap_addr_set(prod_rx_pg, mapping,
2708 pci_unmap_addr(cons_rx_pg, mapping));
2709
2710 prod_bd->rx_bd_haddr_hi = cons_bd->rx_bd_haddr_hi;
2711 prod_bd->rx_bd_haddr_lo = cons_bd->rx_bd_haddr_lo;
2712
2713 }
2714 cons = RX_PG_RING_IDX(NEXT_RX_BD(cons));
2715 hw_prod = NEXT_RX_BD(hw_prod);
2716 }
bb4f98ab
MC		 2717 rxr->rx_pg_prod = hw_prod;
2718 rxr->rx_pg_cons = cons;
1db82f2a
MC		 2719}
2720
b6016b76 2721static inline void
bb4f98ab
MC		 2722bnx2_reuse_rx_skb(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr,
2723 struct sk_buff *skb, u16 cons, u16 prod)
b6016b76 2724{
236b6394
MC		 2725 struct sw_bd *cons_rx_buf, *prod_rx_buf;
2726 struct rx_bd *cons_bd, *prod_bd;
2727
bb4f98ab
MC		 2728 cons_rx_buf = &rxr->rx_buf_ring[cons];
2729 prod_rx_buf = &rxr->rx_buf_ring[prod];
b6016b76
MC		 2730
2731 pci_dma_sync_single_for_device(bp->pdev,
2732 pci_unmap_addr(cons_rx_buf, mapping),
601d3d18 2733 BNX2_RX_OFFSET + BNX2_RX_COPY_THRESH, PCI_DMA_FROMDEVICE);
b6016b76 2734
bb4f98ab 2735 rxr->rx_prod_bseq += bp->rx_buf_use_size;
b6016b76 2736
236b6394 2737 prod_rx_buf->skb = skb;
b6016b76 2738
236b6394
MC		 2739 if (cons == prod)
2740 return;
b6016b76 2741
236b6394
MC		 2742 pci_unmap_addr_set(prod_rx_buf, mapping,
2743 pci_unmap_addr(cons_rx_buf, mapping));
2744
bb4f98ab
MC		 2745 cons_bd = &rxr->rx_desc_ring[RX_RING(cons)][RX_IDX(cons)];
2746 prod_bd = &rxr->rx_desc_ring[RX_RING(prod)][RX_IDX(prod)];
236b6394
MC		 2747 prod_bd->rx_bd_haddr_hi = cons_bd->rx_bd_haddr_hi;
2748 prod_bd->rx_bd_haddr_lo = cons_bd->rx_bd_haddr_lo;
b6016b76
MC		 2749}
2750
85833c62 2751static int
bb4f98ab 2752bnx2_rx_skb(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr, struct sk_buff *skb,
a1f60190
MC		 2753 unsigned int len, unsigned int hdr_len, dma_addr_t dma_addr,
2754 u32 ring_idx)
85833c62
MC		 2755{
2756 int err;
2757 u16 prod = ring_idx & 0xffff;
2758
bb4f98ab 2759 err = bnx2_alloc_rx_skb(bp, rxr, prod);
85833c62 2760 if (unlikely(err)) {
bb4f98ab 2761 bnx2_reuse_rx_skb(bp, rxr, skb, (u16) (ring_idx >> 16), prod);
1db82f2a
MC		 2762 if (hdr_len) {
2763 unsigned int raw_len = len + 4;
2764 int pages = PAGE_ALIGN(raw_len - hdr_len) >> PAGE_SHIFT;
2765
bb4f98ab 2766 bnx2_reuse_rx_skb_pages(bp, rxr, NULL, pages);
1db82f2a 2767 }
85833c62
MC		 2768 return err;
2769 }
2770
d89cb6af 2771 skb_reserve(skb, BNX2_RX_OFFSET);
85833c62
MC		 2772 pci_unmap_single(bp->pdev, dma_addr, bp->rx_buf_use_size,
2773 PCI_DMA_FROMDEVICE);
2774
1db82f2a
MC		 2775 if (hdr_len == 0) {
2776 skb_put(skb, len);
2777 return 0;
2778 } else {
2779 unsigned int i, frag_len, frag_size, pages;
2780 struct sw_pg *rx_pg;
bb4f98ab
MC		 2781 u16 pg_cons = rxr->rx_pg_cons;
2782 u16 pg_prod = rxr->rx_pg_prod;
1db82f2a
MC		 2783
2784 frag_size = len + 4 - hdr_len;
2785 pages = PAGE_ALIGN(frag_size) >> PAGE_SHIFT;
2786 skb_put(skb, hdr_len);
2787
2788 for (i = 0; i < pages; i++) {
2789 frag_len = min(frag_size, (unsigned int) PAGE_SIZE);
2790 if (unlikely(frag_len <= 4)) {
2791 unsigned int tail = 4 - frag_len;
2792
bb4f98ab
MC		 2793 rxr->rx_pg_cons = pg_cons;
2794 rxr->rx_pg_prod = pg_prod;
2795 bnx2_reuse_rx_skb_pages(bp, rxr, NULL,
a1f60190 2796 pages - i);
1db82f2a
MC		 2797 skb->len -= tail;
2798 if (i == 0) {
2799 skb->tail -= tail;
2800 } else {
2801 skb_frag_t *frag =
2802 &skb_shinfo(skb)->frags[i - 1];
2803 frag->size -= tail;
2804 skb->data_len -= tail;
2805 skb->truesize -= tail;
2806 }
2807 return 0;
2808 }
bb4f98ab 2809 rx_pg = &rxr->rx_pg_ring[pg_cons];
1db82f2a
MC		 2810
2811 pci_unmap_page(bp->pdev, pci_unmap_addr(rx_pg, mapping),
2812 PAGE_SIZE, PCI_DMA_FROMDEVICE);
2813
2814 if (i == pages - 1)
2815 frag_len -= 4;
2816
2817 skb_fill_page_desc(skb, i, rx_pg->page, 0, frag_len);
2818 rx_pg->page = NULL;
2819
bb4f98ab
MC		 2820 err = bnx2_alloc_rx_page(bp, rxr,
2821 RX_PG_RING_IDX(pg_prod));
1db82f2a 2822 if (unlikely(err)) {
bb4f98ab
MC		 2823 rxr->rx_pg_cons = pg_cons;
2824 rxr->rx_pg_prod = pg_prod;
2825 bnx2_reuse_rx_skb_pages(bp, rxr, skb,
a1f60190 2826 pages - i);
1db82f2a
MC		 2827 return err;
2828 }
2829
2830 frag_size -= frag_len;
2831 skb->data_len += frag_len;
2832 skb->truesize += frag_len;
2833 skb->len += frag_len;
2834
2835 pg_prod = NEXT_RX_BD(pg_prod);
2836 pg_cons = RX_PG_RING_IDX(NEXT_RX_BD(pg_cons));
2837 }
bb4f98ab
MC		 2838 rxr->rx_pg_prod = pg_prod;
2839 rxr->rx_pg_cons = pg_cons;
1db82f2a 2840 }
85833c62
MC		 2841 return 0;
2842}
2843
c09c2627 2844static inline u16
35efa7c1 2845bnx2_get_hw_rx_cons(struct bnx2_napi *bnapi)
c09c2627 2846{
bb4f98ab
MC		 2847 u16 cons;
2848
43e80b89
MC		 2849 /* Tell compiler that status block fields can change. */
2850 barrier();
2851 cons = *bnapi->hw_rx_cons_ptr;
c09c2627
MC		 2852 if (unlikely((cons & MAX_RX_DESC_CNT) == MAX_RX_DESC_CNT))
2853 cons++;
2854 return cons;
2855}
2856
b6016b76 2857static int
35efa7c1 2858bnx2_rx_int(struct bnx2 *bp, struct bnx2_napi *bnapi, int budget)
b6016b76 2859{
bb4f98ab 2860 struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
b6016b76
MC		 2861 u16 hw_cons, sw_cons, sw_ring_cons, sw_prod, sw_ring_prod;
2862 struct l2_fhdr *rx_hdr;
1db82f2a 2863 int rx_pkt = 0, pg_ring_used = 0;
b6016b76 2864
35efa7c1 2865 hw_cons = bnx2_get_hw_rx_cons(bnapi);
bb4f98ab
MC		 2866 sw_cons = rxr->rx_cons;
2867 sw_prod = rxr->rx_prod;
b6016b76
MC		 2868
2869 /* Memory barrier necessary as speculative reads of the rx
2870 * buffer can be ahead of the index in the status block
2871 */
2872 rmb();
2873 while (sw_cons != hw_cons) {
1db82f2a 2874 unsigned int len, hdr_len;
ade2bfe7 2875 u32 status;
b6016b76
MC		 2876 struct sw_bd *rx_buf;
2877 struct sk_buff *skb;
236b6394 2878 dma_addr_t dma_addr;
f22828e8
MC		 2879 u16 vtag = 0;
2880 int hw_vlan __maybe_unused = 0;
b6016b76
MC		 2881
2882 sw_ring_cons = RX_RING_IDX(sw_cons);
2883 sw_ring_prod = RX_RING_IDX(sw_prod);
2884
bb4f98ab 2885 rx_buf = &rxr->rx_buf_ring[sw_ring_cons];
b6016b76 2886 skb = rx_buf->skb;
236b6394
MC		 2887
2888 rx_buf->skb = NULL;
2889
2890 dma_addr = pci_unmap_addr(rx_buf, mapping);
2891
2892 pci_dma_sync_single_for_cpu(bp->pdev, dma_addr,
601d3d18
BL		 2893 BNX2_RX_OFFSET + BNX2_RX_COPY_THRESH,
2894 PCI_DMA_FROMDEVICE);
b6016b76
MC		 2895
2896 rx_hdr = (struct l2_fhdr *) skb->data;
1db82f2a 2897 len = rx_hdr->l2_fhdr_pkt_len;
b6016b76 2898
ade2bfe7 2899 if ((status = rx_hdr->l2_fhdr_status) &
b6016b76
MC		 2900 (L2_FHDR_ERRORS_BAD_CRC |
2901 L2_FHDR_ERRORS_PHY_DECODE |
2902 L2_FHDR_ERRORS_ALIGNMENT |
2903 L2_FHDR_ERRORS_TOO_SHORT |
2904 L2_FHDR_ERRORS_GIANT_FRAME)) {
2905
bb4f98ab 2906 bnx2_reuse_rx_skb(bp, rxr, skb, sw_ring_cons,
a1f60190 2907 sw_ring_prod);
85833c62 2908 goto next_rx;
b6016b76 2909 }
1db82f2a
MC		 2910 hdr_len = 0;
2911 if (status & L2_FHDR_STATUS_SPLIT) {
2912 hdr_len = rx_hdr->l2_fhdr_ip_xsum;
2913 pg_ring_used = 1;
2914 } else if (len > bp->rx_jumbo_thresh) {
2915 hdr_len = bp->rx_jumbo_thresh;
2916 pg_ring_used = 1;
2917 }
2918
2919 len -= 4;
b6016b76 2920
5d5d0015 2921 if (len <= bp->rx_copy_thresh) {
b6016b76
MC		 2922 struct sk_buff *new_skb;
2923
f22828e8 2924 new_skb = netdev_alloc_skb(bp->dev, len + 6);
85833c62 2925 if (new_skb == NULL) {
bb4f98ab 2926 bnx2_reuse_rx_skb(bp, rxr, skb, sw_ring_cons,
85833c62
MC		 2927 sw_ring_prod);
2928 goto next_rx;
2929 }
b6016b76
MC		 2930
2931 /* aligned copy */
d89cb6af 2932 skb_copy_from_linear_data_offset(skb,
f22828e8
MC		 2933 BNX2_RX_OFFSET - 6,
2934 new_skb->data, len + 6);
2935 skb_reserve(new_skb, 6);
b6016b76 2936 skb_put(new_skb, len);
b6016b76 2937
bb4f98ab 2938 bnx2_reuse_rx_skb(bp, rxr, skb,
b6016b76
MC		 2939 sw_ring_cons, sw_ring_prod);
2940
2941 skb = new_skb;
bb4f98ab 2942 } else if (unlikely(bnx2_rx_skb(bp, rxr, skb, len, hdr_len,
a1f60190 2943 dma_addr, (sw_ring_cons << 16) | sw_ring_prod)))
b6016b76 2944 goto next_rx;
b6016b76 2945
f22828e8
MC		 2946 if ((status & L2_FHDR_STATUS_L2_VLAN_TAG) &&
2947 !(bp->rx_mode & BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG)) {
2948 vtag = rx_hdr->l2_fhdr_vlan_tag;
2949#ifdef BCM_VLAN
2950 if (bp->vlgrp)
2951 hw_vlan = 1;
2952 else
2953#endif
2954 {
2955 struct vlan_ethhdr *ve = (struct vlan_ethhdr *)
2956 __skb_push(skb, 4);
2957
2958 memmove(ve, skb->data + 4, ETH_ALEN * 2);
2959 ve->h_vlan_proto = htons(ETH_P_8021Q);
2960 ve->h_vlan_TCI = htons(vtag);
2961 len += 4;
2962 }
2963 }
2964
b6016b76
MC		 2965 skb->protocol = eth_type_trans(skb, bp->dev);
2966
2967 if ((len > (bp->dev->mtu + ETH_HLEN)) &&
d1e100ba 2968 (ntohs(skb->protocol) != 0x8100)) {
b6016b76 2969
745720e5 2970 dev_kfree_skb(skb);
b6016b76
MC		 2971 goto next_rx;
2972
2973 }
2974
b6016b76
MC		 2975 skb->ip_summed = CHECKSUM_NONE;
2976 if (bp->rx_csum &&
2977 (status & (L2_FHDR_STATUS_TCP_SEGMENT |
2978 L2_FHDR_STATUS_UDP_DATAGRAM))) {
2979
ade2bfe7
MC		 2980 if (likely((status & (L2_FHDR_ERRORS_TCP_XSUM |
2981 L2_FHDR_ERRORS_UDP_XSUM)) == 0))
b6016b76
MC		 2982 skb->ip_summed = CHECKSUM_UNNECESSARY;
2983 }
2984
2985#ifdef BCM_VLAN
f22828e8
MC		 2986 if (hw_vlan)
2987 vlan_hwaccel_receive_skb(skb, bp->vlgrp, vtag);
b6016b76
MC		 2988 else
2989#endif
2990 netif_receive_skb(skb);
2991
2992 bp->dev->last_rx = jiffies;
2993 rx_pkt++;
2994
2995next_rx:
b6016b76
MC		 2996 sw_cons = NEXT_RX_BD(sw_cons);
2997 sw_prod = NEXT_RX_BD(sw_prod);
2998
2999 if ((rx_pkt == budget))
3000 break;
f4e418f7
MC		 3001
3002 /* Refresh hw_cons to see if there is new work */
3003 if (sw_cons == hw_cons) {
35efa7c1 3004 hw_cons = bnx2_get_hw_rx_cons(bnapi);
f4e418f7
MC		 3005 rmb();
3006 }
b6016b76 3007 }
bb4f98ab
MC		 3008 rxr->rx_cons = sw_cons;
3009 rxr->rx_prod = sw_prod;
b6016b76 3010
1db82f2a 3011 if (pg_ring_used)
bb4f98ab 3012 REG_WR16(bp, rxr->rx_pg_bidx_addr, rxr->rx_pg_prod);
1db82f2a 3013
bb4f98ab 3014 REG_WR16(bp, rxr->rx_bidx_addr, sw_prod);
b6016b76 3015
bb4f98ab 3016 REG_WR(bp, rxr->rx_bseq_addr, rxr->rx_prod_bseq);
b6016b76
MC		 3017
3018 mmiowb();
3019
3020 return rx_pkt;
3021
3022}
3023
3024/* MSI ISR - The only difference between this and the INTx ISR
3025 * is that the MSI interrupt is always serviced.
3026 */
3027static irqreturn_t
7d12e780 3028bnx2_msi(int irq, void *dev_instance)
b6016b76 3029{
f0ea2e63
MC		 3030 struct bnx2_napi *bnapi = dev_instance;
3031 struct bnx2 *bp = bnapi->bp;
3032 struct net_device *dev = bp->dev;
b6016b76 3033
43e80b89 3034 prefetch(bnapi->status_blk.msi);
b6016b76
MC		 3035 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3036 BNX2_PCICFG_INT_ACK_CMD_USE_INT_HC_PARAM |
3037 BNX2_PCICFG_INT_ACK_CMD_MASK_INT);
3038
3039 /* Return here if interrupt is disabled. */
73eef4cd
MC		 3040 if (unlikely(atomic_read(&bp->intr_sem) != 0))
3041 return IRQ_HANDLED;
b6016b76 3042
35efa7c1 3043 netif_rx_schedule(dev, &bnapi->napi);
b6016b76 3044
73eef4cd 3045 return IRQ_HANDLED;
b6016b76
MC		 3046}
3047
8e6a72c4
MC		 3048static irqreturn_t
3049bnx2_msi_1shot(int irq, void *dev_instance)
3050{
f0ea2e63
MC		 3051 struct bnx2_napi *bnapi = dev_instance;
3052 struct bnx2 *bp = bnapi->bp;
3053 struct net_device *dev = bp->dev;
8e6a72c4 3054
43e80b89 3055 prefetch(bnapi->status_blk.msi);
8e6a72c4
MC		 3056
3057 /* Return here if interrupt is disabled. */
3058 if (unlikely(atomic_read(&bp->intr_sem) != 0))
3059 return IRQ_HANDLED;
3060
35efa7c1 3061 netif_rx_schedule(dev, &bnapi->napi);
8e6a72c4
MC		 3062
3063 return IRQ_HANDLED;
3064}
3065
b6016b76 3066static irqreturn_t
7d12e780 3067bnx2_interrupt(int irq, void *dev_instance)
b6016b76 3068{
f0ea2e63
MC		 3069 struct bnx2_napi *bnapi = dev_instance;
3070 struct bnx2 *bp = bnapi->bp;
3071 struct net_device *dev = bp->dev;
43e80b89 3072 struct status_block *sblk = bnapi->status_blk.msi;
b6016b76
MC		 3073
3074 /* When using INTx, it is possible for the interrupt to arrive
3075 * at the CPU before the status block posted prior to the
3076 * interrupt. Reading a register will flush the status block.
3077 * When using MSI, the MSI message will always complete after
3078 * the status block write.
3079 */
35efa7c1 3080 if ((sblk->status_idx == bnapi->last_status_idx) &&
b6016b76
MC		 3081 (REG_RD(bp, BNX2_PCICFG_MISC_STATUS) &
3082 BNX2_PCICFG_MISC_STATUS_INTA_VALUE))
73eef4cd 3083 return IRQ_NONE;
b6016b76
MC		 3084
3085 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3086 BNX2_PCICFG_INT_ACK_CMD_USE_INT_HC_PARAM |
3087 BNX2_PCICFG_INT_ACK_CMD_MASK_INT);
3088
b8a7ce7b
MC		 3089 /* Read back to deassert IRQ immediately to avoid too many
3090 * spurious interrupts.
3091 */
3092 REG_RD(bp, BNX2_PCICFG_INT_ACK_CMD);
3093
b6016b76 3094 /* Return here if interrupt is shared and is disabled. */
73eef4cd
MC		 3095 if (unlikely(atomic_read(&bp->intr_sem) != 0))
3096 return IRQ_HANDLED;
b6016b76 3097
35efa7c1
MC		 3098 if (netif_rx_schedule_prep(dev, &bnapi->napi)) {
3099 bnapi->last_status_idx = sblk->status_idx;
3100 __netif_rx_schedule(dev, &bnapi->napi);
b8a7ce7b 3101 }
b6016b76 3102
73eef4cd 3103 return IRQ_HANDLED;
b6016b76
MC		 3104}
3105
f4e418f7 3106static inline int
43e80b89 3107bnx2_has_fast_work(struct bnx2_napi *bnapi)
f4e418f7 3108{
35e9010b 3109 struct bnx2_tx_ring_info *txr = &bnapi->tx_ring;
bb4f98ab 3110 struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
f4e418f7 3111
bb4f98ab 3112 if ((bnx2_get_hw_rx_cons(bnapi) != rxr->rx_cons) ||
35e9010b 3113 (bnx2_get_hw_tx_cons(bnapi) != txr->hw_tx_cons))
f4e418f7 3114 return 1;
43e80b89
MC		 3115 return 0;
3116}
3117
3118#define STATUS_ATTN_EVENTS (STATUS_ATTN_BITS_LINK_STATE | \
3119 STATUS_ATTN_BITS_TIMER_ABORT)
3120
3121static inline int
3122bnx2_has_work(struct bnx2_napi *bnapi)
3123{
3124 struct status_block *sblk = bnapi->status_blk.msi;
3125
3126 if (bnx2_has_fast_work(bnapi))
3127 return 1;
f4e418f7 3128
da3e4fbe
MC		 3129 if ((sblk->status_attn_bits & STATUS_ATTN_EVENTS) !=
3130 (sblk->status_attn_bits_ack & STATUS_ATTN_EVENTS))
f4e418f7
MC		 3131 return 1;
3132
3133 return 0;
3134}
3135
43e80b89 3136static void bnx2_poll_link(struct bnx2 *bp, struct bnx2_napi *bnapi)
b6016b76 3137{
43e80b89 3138 struct status_block *sblk = bnapi->status_blk.msi;
da3e4fbe
MC		 3139 u32 status_attn_bits = sblk->status_attn_bits;
3140 u32 status_attn_bits_ack = sblk->status_attn_bits_ack;
b6016b76 3141
da3e4fbe
MC		 3142 if ((status_attn_bits & STATUS_ATTN_EVENTS) !=
3143 (status_attn_bits_ack & STATUS_ATTN_EVENTS)) {
b6016b76 3144
35efa7c1 3145 bnx2_phy_int(bp, bnapi);
bf5295bb
MC		 3146
3147 /* This is needed to take care of transient status
3148 * during link changes.
3149 */
3150 REG_WR(bp, BNX2_HC_COMMAND,
3151 bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
3152 REG_RD(bp, BNX2_HC_COMMAND);
b6016b76 3153 }
43e80b89
MC		 3154}
3155
3156static int bnx2_poll_work(struct bnx2 *bp, struct bnx2_napi *bnapi,
3157 int work_done, int budget)
3158{
3159 struct bnx2_tx_ring_info *txr = &bnapi->tx_ring;
3160 struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
b6016b76 3161
35e9010b 3162 if (bnx2_get_hw_tx_cons(bnapi) != txr->hw_tx_cons)
57851d84 3163 bnx2_tx_int(bp, bnapi, 0);
b6016b76 3164
bb4f98ab 3165 if (bnx2_get_hw_rx_cons(bnapi) != rxr->rx_cons)
35efa7c1 3166 work_done += bnx2_rx_int(bp, bnapi, budget - work_done);
6aa20a22 3167
6f535763
DM		 3168 return work_done;
3169}
3170
f0ea2e63
MC		 3171static int bnx2_poll_msix(struct napi_struct *napi, int budget)
3172{
3173 struct bnx2_napi *bnapi = container_of(napi, struct bnx2_napi, napi);
3174 struct bnx2 *bp = bnapi->bp;
3175 int work_done = 0;
3176 struct status_block_msix *sblk = bnapi->status_blk.msix;
3177
3178 while (1) {
3179 work_done = bnx2_poll_work(bp, bnapi, work_done, budget);
3180 if (unlikely(work_done >= budget))
3181 break;
3182
3183 bnapi->last_status_idx = sblk->status_idx;
3184 /* status idx must be read before checking for more work. */
3185 rmb();
3186 if (likely(!bnx2_has_fast_work(bnapi))) {
3187
3188 netif_rx_complete(bp->dev, napi);
3189 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD, bnapi->int_num |
3190 BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
3191 bnapi->last_status_idx);
3192 break;
3193 }
3194 }
3195 return work_done;
3196}
3197
6f535763
DM		 3198static int bnx2_poll(struct napi_struct *napi, int budget)
3199{
35efa7c1
MC		 3200 struct bnx2_napi *bnapi = container_of(napi, struct bnx2_napi, napi);
3201 struct bnx2 *bp = bnapi->bp;
6f535763 3202 int work_done = 0;
43e80b89 3203 struct status_block *sblk = bnapi->status_blk.msi;
6f535763
DM		 3204
3205 while (1) {
43e80b89
MC		 3206 bnx2_poll_link(bp, bnapi);
3207
35efa7c1 3208 work_done = bnx2_poll_work(bp, bnapi, work_done, budget);
f4e418f7 3209
6f535763
DM		 3210 if (unlikely(work_done >= budget))
3211 break;
3212
35efa7c1 3213 /* bnapi->last_status_idx is used below to tell the hw how
6dee6421
MC		 3214 * much work has been processed, so we must read it before
3215 * checking for more work.
3216 */
35efa7c1 3217 bnapi->last_status_idx = sblk->status_idx;
6dee6421 3218 rmb();
35efa7c1 3219 if (likely(!bnx2_has_work(bnapi))) {
6f535763 3220 netif_rx_complete(bp->dev, napi);
f86e82fb 3221 if (likely(bp->flags & BNX2_FLAG_USING_MSI_OR_MSIX)) {
6f535763
DM		 3222 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3223 BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
35efa7c1 3224 bnapi->last_status_idx);
6dee6421 3225 break;
6f535763 3226 }
1269a8a6
MC		 3227 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3228 BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
6f535763 3229 BNX2_PCICFG_INT_ACK_CMD_MASK_INT |
35efa7c1 3230 bnapi->last_status_idx);
1269a8a6 3231
6f535763
DM		 3232 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3233 BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
35efa7c1 3234 bnapi->last_status_idx);
6f535763
DM		 3235 break;
3236 }
b6016b76
MC		 3237 }
3238
bea3348e 3239 return work_done;
b6016b76
MC		 3240}
3241
932ff279 3242/* Called with rtnl_lock from vlan functions and also netif_tx_lock
b6016b76
MC		 3243 * from set_multicast.
3244 */
3245static void
3246bnx2_set_rx_mode(struct net_device *dev)
3247{
972ec0d4 3248 struct bnx2 *bp = netdev_priv(dev);
b6016b76 3249 u32 rx_mode, sort_mode;
5fcaed01 3250 struct dev_addr_list *uc_ptr;
b6016b76 3251 int i;
b6016b76 3252
c770a65c 3253 spin_lock_bh(&bp->phy_lock);
b6016b76
MC		 3254
3255 rx_mode = bp->rx_mode & ~(BNX2_EMAC_RX_MODE_PROMISCUOUS |
3256 BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG);
3257 sort_mode = 1 | BNX2_RPM_SORT_USER0_BC_EN;
3258#ifdef BCM_VLAN
7c6337a1 3259 if (!bp->vlgrp && (bp->flags & BNX2_FLAG_CAN_KEEP_VLAN))
b6016b76 3260 rx_mode |= BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG;
b6016b76 3261#else
7c6337a1 3262 if (bp->flags & BNX2_FLAG_CAN_KEEP_VLAN)
e29054f9 3263 rx_mode |= BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG;
b6016b76
MC		 3264#endif
3265 if (dev->flags & IFF_PROMISC) {
3266 /* Promiscuous mode. */
3267 rx_mode |= BNX2_EMAC_RX_MODE_PROMISCUOUS;
7510873d
MC		 3268 sort_mode |= BNX2_RPM_SORT_USER0_PROM_EN |
3269 BNX2_RPM_SORT_USER0_PROM_VLAN;
b6016b76
MC		 3270 }
3271 else if (dev->flags & IFF_ALLMULTI) {
3272 for (i = 0; i < NUM_MC_HASH_REGISTERS; i++) {
3273 REG_WR(bp, BNX2_EMAC_MULTICAST_HASH0 + (i * 4),
3274 0xffffffff);
3275 }
3276 sort_mode |= BNX2_RPM_SORT_USER0_MC_EN;
3277 }
3278 else {
3279 /* Accept one or more multicast(s). */
3280 struct dev_mc_list *mclist;
3281 u32 mc_filter[NUM_MC_HASH_REGISTERS];
3282 u32 regidx;
3283 u32 bit;
3284 u32 crc;
3285
3286 memset(mc_filter, 0, 4 * NUM_MC_HASH_REGISTERS);
3287
3288 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
3289 i++, mclist = mclist->next) {
3290
3291 crc = ether_crc_le(ETH_ALEN, mclist->dmi_addr);
3292 bit = crc & 0xff;
3293 regidx = (bit & 0xe0) >> 5;
3294 bit &= 0x1f;
3295 mc_filter[regidx] |= (1 << bit);
3296 }
3297
3298 for (i = 0; i < NUM_MC_HASH_REGISTERS; i++) {
3299 REG_WR(bp, BNX2_EMAC_MULTICAST_HASH0 + (i * 4),
3300 mc_filter[i]);
3301 }
3302
3303 sort_mode |= BNX2_RPM_SORT_USER0_MC_HSH_EN;
3304 }
3305
5fcaed01
BL		 3306 uc_ptr = NULL;
3307 if (dev->uc_count > BNX2_MAX_UNICAST_ADDRESSES) {
3308 rx_mode |= BNX2_EMAC_RX_MODE_PROMISCUOUS;
3309 sort_mode |= BNX2_RPM_SORT_USER0_PROM_EN |
3310 BNX2_RPM_SORT_USER0_PROM_VLAN;
3311 } else if (!(dev->flags & IFF_PROMISC)) {
3312 uc_ptr = dev->uc_list;
3313
3314 /* Add all entries into to the match filter list */
3315 for (i = 0; i < dev->uc_count; i++) {
3316 bnx2_set_mac_addr(bp, uc_ptr->da_addr,
3317 i + BNX2_START_UNICAST_ADDRESS_INDEX);
3318 sort_mode |= (1 <<
3319 (i + BNX2_START_UNICAST_ADDRESS_INDEX));
3320 uc_ptr = uc_ptr->next;
3321 }
3322
3323 }
3324
b6016b76
MC		 3325 if (rx_mode != bp->rx_mode) {
3326 bp->rx_mode = rx_mode;
3327 REG_WR(bp, BNX2_EMAC_RX_MODE, rx_mode);
3328 }
3329
3330 REG_WR(bp, BNX2_RPM_SORT_USER0, 0x0);
3331 REG_WR(bp, BNX2_RPM_SORT_USER0, sort_mode);
3332 REG_WR(bp, BNX2_RPM_SORT_USER0, sort_mode | BNX2_RPM_SORT_USER0_ENA);
3333
c770a65c 3334 spin_unlock_bh(&bp->phy_lock);
b6016b76
MC		 3335}
3336
3337static void
b491edd5 3338load_rv2p_fw(struct bnx2 *bp, __le32 *rv2p_code, u32 rv2p_code_len,
b6016b76
MC		 3339 u32 rv2p_proc)
3340{
3341 int i;
3342 u32 val;
3343
d25be1d3
MC		 3344 if (rv2p_proc == RV2P_PROC2 && CHIP_NUM(bp) == CHIP_NUM_5709) {
3345 val = le32_to_cpu(rv2p_code[XI_RV2P_PROC2_MAX_BD_PAGE_LOC]);
3346 val &= ~XI_RV2P_PROC2_BD_PAGE_SIZE_MSK;
3347 val |= XI_RV2P_PROC2_BD_PAGE_SIZE;
3348 rv2p_code[XI_RV2P_PROC2_MAX_BD_PAGE_LOC] = cpu_to_le32(val);
3349 }
b6016b76
MC		 3350
3351 for (i = 0; i < rv2p_code_len; i += 8) {
b491edd5 3352 REG_WR(bp, BNX2_RV2P_INSTR_HIGH, le32_to_cpu(*rv2p_code));
b6016b76 3353 rv2p_code++;
b491edd5 3354 REG_WR(bp, BNX2_RV2P_INSTR_LOW, le32_to_cpu(*rv2p_code));
b6016b76
MC		 3355 rv2p_code++;
3356
3357 if (rv2p_proc == RV2P_PROC1) {
3358 val = (i / 8) | BNX2_RV2P_PROC1_ADDR_CMD_RDWR;
3359 REG_WR(bp, BNX2_RV2P_PROC1_ADDR_CMD, val);
3360 }
3361 else {
3362 val = (i / 8) | BNX2_RV2P_PROC2_ADDR_CMD_RDWR;
3363 REG_WR(bp, BNX2_RV2P_PROC2_ADDR_CMD, val);
3364 }
3365 }
3366
3367 /* Reset the processor, un-stall is done later. */
3368 if (rv2p_proc == RV2P_PROC1) {
3369 REG_WR(bp, BNX2_RV2P_COMMAND, BNX2_RV2P_COMMAND_PROC1_RESET);
3370 }
3371 else {
3372 REG_WR(bp, BNX2_RV2P_COMMAND, BNX2_RV2P_COMMAND_PROC2_RESET);
3373 }
3374}
3375
af3ee519 3376static int
10343cca 3377load_cpu_fw(struct bnx2 *bp, const struct cpu_reg *cpu_reg, struct fw_info *fw)
b6016b76
MC		 3378{
3379 u32 offset;
3380 u32 val;
af3ee519 3381 int rc;
b6016b76
MC		 3382
3383 /* Halt the CPU. */
2726d6e1 3384 val = bnx2_reg_rd_ind(bp, cpu_reg->mode);
b6016b76 3385 val |= cpu_reg->mode_value_halt;
2726d6e1
MC		 3386 bnx2_reg_wr_ind(bp, cpu_reg->mode, val);
3387 bnx2_reg_wr_ind(bp, cpu_reg->state, cpu_reg->state_value_clear);
b6016b76
MC		 3388
3389 /* Load the Text area. */
3390 offset = cpu_reg->spad_base + (fw->text_addr - cpu_reg->mips_view_base);
af3ee519 3391 if (fw->gz_text) {
b6016b76
MC		 3392 int j;
3393
ea1f8d5c
MC		 3394 rc = zlib_inflate_blob(fw->text, FW_BUF_SIZE, fw->gz_text,
3395 fw->gz_text_len);
3396 if (rc < 0)
b3448b0b 3397 return rc;
ea1f8d5c 3398
b6016b76 3399 for (j = 0; j < (fw->text_len / 4); j++, offset += 4) {
2726d6e1 3400 bnx2_reg_wr_ind(bp, offset, le32_to_cpu(fw->text[j]));
b6016b76
MC		 3401 }
3402 }
3403
3404 /* Load the Data area. */
3405 offset = cpu_reg->spad_base + (fw->data_addr - cpu_reg->mips_view_base);
3406 if (fw->data) {
3407 int j;
3408
3409 for (j = 0; j < (fw->data_len / 4); j++, offset += 4) {
2726d6e1 3410 bnx2_reg_wr_ind(bp, offset, fw->data[j]);
b6016b76
MC		 3411 }
3412 }
3413
3414 /* Load the SBSS area. */
3415 offset = cpu_reg->spad_base + (fw->sbss_addr - cpu_reg->mips_view_base);
ea1f8d5c 3416 if (fw->sbss_len) {
b6016b76
MC		 3417 int j;
3418
3419 for (j = 0; j < (fw->sbss_len / 4); j++, offset += 4) {
2726d6e1 3420 bnx2_reg_wr_ind(bp, offset, 0);
b6016b76
MC		 3421 }
3422 }
3423
3424 /* Load the BSS area. */
3425 offset = cpu_reg->spad_base + (fw->bss_addr - cpu_reg->mips_view_base);
ea1f8d5c 3426 if (fw->bss_len) {
b6016b76
MC		 3427 int j;
3428
3429 for (j = 0; j < (fw->bss_len/4); j++, offset += 4) {
2726d6e1 3430 bnx2_reg_wr_ind(bp, offset, 0);
b6016b76
MC		 3431 }
3432 }
3433
3434 /* Load the Read-Only area. */
3435 offset = cpu_reg->spad_base +
3436 (fw->rodata_addr - cpu_reg->mips_view_base);
3437 if (fw->rodata) {
3438 int j;
3439
3440 for (j = 0; j < (fw->rodata_len / 4); j++, offset += 4) {
2726d6e1 3441 bnx2_reg_wr_ind(bp, offset, fw->rodata[j]);
b6016b76
MC		 3442 }
3443 }
3444
3445 /* Clear the pre-fetch instruction. */
2726d6e1
MC		 3446 bnx2_reg_wr_ind(bp, cpu_reg->inst, 0);
3447 bnx2_reg_wr_ind(bp, cpu_reg->pc, fw->start_addr);
b6016b76
MC		 3448
3449 /* Start the CPU. */
2726d6e1 3450 val = bnx2_reg_rd_ind(bp, cpu_reg->mode);
b6016b76 3451 val &= ~cpu_reg->mode_value_halt;
2726d6e1
MC		 3452 bnx2_reg_wr_ind(bp, cpu_reg->state, cpu_reg->state_value_clear);
3453 bnx2_reg_wr_ind(bp, cpu_reg->mode, val);
af3ee519
MC		 3454
3455 return 0;
b6016b76
MC		 3456}
3457
fba9fe91 3458static int
b6016b76
MC		 3459bnx2_init_cpus(struct bnx2 *bp)
3460{
af3ee519 3461 struct fw_info *fw;
110d0ef9
MC		 3462 int rc, rv2p_len;
3463 void *text, *rv2p;
b6016b76
MC		 3464
3465 /* Initialize the RV2P processor. */
b3448b0b
DV		 3466 text = vmalloc(FW_BUF_SIZE);
3467 if (!text)
3468 return -ENOMEM;
110d0ef9
MC		 3469 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
3470 rv2p = bnx2_xi_rv2p_proc1;
3471 rv2p_len = sizeof(bnx2_xi_rv2p_proc1);
3472 } else {
3473 rv2p = bnx2_rv2p_proc1;
3474 rv2p_len = sizeof(bnx2_rv2p_proc1);
3475 }
3476 rc = zlib_inflate_blob(text, FW_BUF_SIZE, rv2p, rv2p_len);
ea1f8d5c 3477 if (rc < 0)
fba9fe91 3478 goto init_cpu_err;
ea1f8d5c 3479
b3448b0b 3480 load_rv2p_fw(bp, text, rc /* == len */, RV2P_PROC1);
fba9fe91 3481
110d0ef9
MC		 3482 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
3483 rv2p = bnx2_xi_rv2p_proc2;
3484 rv2p_len = sizeof(bnx2_xi_rv2p_proc2);
3485 } else {
3486 rv2p = bnx2_rv2p_proc2;
3487 rv2p_len = sizeof(bnx2_rv2p_proc2);
3488 }
3489 rc = zlib_inflate_blob(text, FW_BUF_SIZE, rv2p, rv2p_len);
ea1f8d5c 3490 if (rc < 0)
fba9fe91 3491 goto init_cpu_err;
ea1f8d5c 3492
b3448b0b 3493 load_rv2p_fw(bp, text, rc /* == len */, RV2P_PROC2);
b6016b76
MC		 3494
3495 /* Initialize the RX Processor. */
d43584c8
MC		 3496 if (CHIP_NUM(bp) == CHIP_NUM_5709)
3497 fw = &bnx2_rxp_fw_09;
3498 else
3499 fw = &bnx2_rxp_fw_06;
fba9fe91 3500
ea1f8d5c 3501 fw->text = text;
10343cca 3502 rc = load_cpu_fw(bp, &cpu_reg_rxp, fw);
fba9fe91
MC		 3503 if (rc)
3504 goto init_cpu_err;
3505
b6016b76 3506 /* Initialize the TX Processor. */
d43584c8
MC		 3507 if (CHIP_NUM(bp) == CHIP_NUM_5709)
3508 fw = &bnx2_txp_fw_09;
3509 else
3510 fw = &bnx2_txp_fw_06;
fba9fe91 3511
ea1f8d5c 3512 fw->text = text;
10343cca 3513 rc = load_cpu_fw(bp, &cpu_reg_txp, fw);
fba9fe91
MC		 3514 if (rc)
3515 goto init_cpu_err;
3516
b6016b76 3517 /* Initialize the TX Patch-up Processor. */
d43584c8
MC		 3518 if (CHIP_NUM(bp) == CHIP_NUM_5709)
3519 fw = &bnx2_tpat_fw_09;
3520 else
3521 fw = &bnx2_tpat_fw_06;
fba9fe91 3522
ea1f8d5c 3523 fw->text = text;
10343cca 3524 rc = load_cpu_fw(bp, &cpu_reg_tpat, fw);
fba9fe91
MC		 3525 if (rc)
3526 goto init_cpu_err;
3527
b6016b76 3528 /* Initialize the Completion Processor. */
d43584c8
MC		 3529 if (CHIP_NUM(bp) == CHIP_NUM_5709)
3530 fw = &bnx2_com_fw_09;
3531 else
3532 fw = &bnx2_com_fw_06;
fba9fe91 3533
ea1f8d5c 3534 fw->text = text;
10343cca 3535 rc = load_cpu_fw(bp, &cpu_reg_com, fw);
fba9fe91
MC		 3536 if (rc)
3537 goto init_cpu_err;
3538
d43584c8 3539 /* Initialize the Command Processor. */
110d0ef9 3540 if (CHIP_NUM(bp) == CHIP_NUM_5709)
d43584c8 3541 fw = &bnx2_cp_fw_09;
110d0ef9
MC		 3542 else
3543 fw = &bnx2_cp_fw_06;
3544
3545 fw->text = text;
10343cca 3546 rc = load_cpu_fw(bp, &cpu_reg_cp, fw);
b6016b76 3547
fba9fe91 3548init_cpu_err:
ea1f8d5c 3549 vfree(text);
fba9fe91 3550 return rc;
b6016b76
MC		 3551}
3552
3553static int
829ca9a3 3554bnx2_set_power_state(struct bnx2 *bp, pci_power_t state)
b6016b76
MC		 3555{
3556 u16 pmcsr;
3557
3558 pci_read_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL, &pmcsr);
3559
3560 switch (state) {
829ca9a3 3561 case PCI_D0: {
b6016b76
MC		 3562 u32 val;
3563
3564 pci_write_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL,
3565 (pmcsr & ~PCI_PM_CTRL_STATE_MASK) |
3566 PCI_PM_CTRL_PME_STATUS);
3567
3568 if (pmcsr & PCI_PM_CTRL_STATE_MASK)
3569 /* delay required during transition out of D3hot */
3570 msleep(20);
3571
3572 val = REG_RD(bp, BNX2_EMAC_MODE);
3573 val |= BNX2_EMAC_MODE_MPKT_RCVD | BNX2_EMAC_MODE_ACPI_RCVD;
3574 val &= ~BNX2_EMAC_MODE_MPKT;
3575 REG_WR(bp, BNX2_EMAC_MODE, val);
3576
3577 val = REG_RD(bp, BNX2_RPM_CONFIG);
3578 val &= ~BNX2_RPM_CONFIG_ACPI_ENA;
3579 REG_WR(bp, BNX2_RPM_CONFIG, val);
3580 break;
3581 }
829ca9a3 3582 case PCI_D3hot: {
b6016b76
MC		 3583 int i;
3584 u32 val, wol_msg;
3585
3586 if (bp->wol) {
3587 u32 advertising;
3588 u8 autoneg;
3589
3590 autoneg = bp->autoneg;
3591 advertising = bp->advertising;
3592
239cd343
MC		 3593 if (bp->phy_port == PORT_TP) {
3594 bp->autoneg = AUTONEG_SPEED;
3595 bp->advertising = ADVERTISED_10baseT_Half |
3596 ADVERTISED_10baseT_Full |
3597 ADVERTISED_100baseT_Half |
3598 ADVERTISED_100baseT_Full |
3599 ADVERTISED_Autoneg;
3600 }
b6016b76 3601
239cd343
MC		 3602 spin_lock_bh(&bp->phy_lock);
3603 bnx2_setup_phy(bp, bp->phy_port);
3604 spin_unlock_bh(&bp->phy_lock);
b6016b76
MC		 3605
3606 bp->autoneg = autoneg;
3607 bp->advertising = advertising;
3608
5fcaed01 3609 bnx2_set_mac_addr(bp, bp->dev->dev_addr, 0);
b6016b76
MC		 3610
3611 val = REG_RD(bp, BNX2_EMAC_MODE);
3612
3613 /* Enable port mode. */
3614 val &= ~BNX2_EMAC_MODE_PORT;
239cd343 3615 val |= BNX2_EMAC_MODE_MPKT_RCVD |
b6016b76 3616 BNX2_EMAC_MODE_ACPI_RCVD |
b6016b76 3617 BNX2_EMAC_MODE_MPKT;
239cd343
MC		 3618 if (bp->phy_port == PORT_TP)
3619 val |= BNX2_EMAC_MODE_PORT_MII;
3620 else {
3621 val |= BNX2_EMAC_MODE_PORT_GMII;
3622 if (bp->line_speed == SPEED_2500)
3623 val |= BNX2_EMAC_MODE_25G_MODE;
3624 }
b6016b76
MC		 3625
3626 REG_WR(bp, BNX2_EMAC_MODE, val);
3627
3628 /* receive all multicast */
3629 for (i = 0; i < NUM_MC_HASH_REGISTERS; i++) {
3630 REG_WR(bp, BNX2_EMAC_MULTICAST_HASH0 + (i * 4),
3631 0xffffffff);
3632 }
3633 REG_WR(bp, BNX2_EMAC_RX_MODE,
3634 BNX2_EMAC_RX_MODE_SORT_MODE);
3635
3636 val = 1 | BNX2_RPM_SORT_USER0_BC_EN |
3637 BNX2_RPM_SORT_USER0_MC_EN;
3638 REG_WR(bp, BNX2_RPM_SORT_USER0, 0x0);
3639 REG_WR(bp, BNX2_RPM_SORT_USER0, val);
3640 REG_WR(bp, BNX2_RPM_SORT_USER0, val |
3641 BNX2_RPM_SORT_USER0_ENA);
3642
3643 /* Need to enable EMAC and RPM for WOL. */
3644 REG_WR(bp, BNX2_MISC_ENABLE_SET_BITS,
3645 BNX2_MISC_ENABLE_SET_BITS_RX_PARSER_MAC_ENABLE |
3646 BNX2_MISC_ENABLE_SET_BITS_TX_HEADER_Q_ENABLE |
3647 BNX2_MISC_ENABLE_SET_BITS_EMAC_ENABLE);
3648
3649 val = REG_RD(bp, BNX2_RPM_CONFIG);
3650 val &= ~BNX2_RPM_CONFIG_ACPI_ENA;
3651 REG_WR(bp, BNX2_RPM_CONFIG, val);
3652
3653 wol_msg = BNX2_DRV_MSG_CODE_SUSPEND_WOL;
3654 }
3655 else {
3656 wol_msg = BNX2_DRV_MSG_CODE_SUSPEND_NO_WOL;
3657 }
3658
f86e82fb 3659 if (!(bp->flags & BNX2_FLAG_NO_WOL))
a2f13890
MC		 3660 bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT3 | wol_msg,
3661 1, 0);
b6016b76
MC		 3662
3663 pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
3664 if ((CHIP_ID(bp) == CHIP_ID_5706_A0) ||
3665 (CHIP_ID(bp) == CHIP_ID_5706_A1)) {
3666
3667 if (bp->wol)
3668 pmcsr |= 3;
3669 }
3670 else {
3671 pmcsr |= 3;
3672 }
3673 if (bp->wol) {
3674 pmcsr |= PCI_PM_CTRL_PME_ENABLE;
3675 }
3676 pci_write_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL,
3677 pmcsr);
3678
3679 /* No more memory access after this point until
3680 * device is brought back to D0.
3681 */
3682 udelay(50);
3683 break;
3684 }
3685 default:
3686 return -EINVAL;
3687 }
3688 return 0;
3689}
3690
3691static int
3692bnx2_acquire_nvram_lock(struct bnx2 *bp)
3693{
3694 u32 val;
3695 int j;
3696
3697 /* Request access to the flash interface. */
3698 REG_WR(bp, BNX2_NVM_SW_ARB, BNX2_NVM_SW_ARB_ARB_REQ_SET2);
3699 for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3700 val = REG_RD(bp, BNX2_NVM_SW_ARB);
3701 if (val & BNX2_NVM_SW_ARB_ARB_ARB2)
3702 break;
3703
3704 udelay(5);
3705 }
3706
3707 if (j >= NVRAM_TIMEOUT_COUNT)
3708 return -EBUSY;
3709
3710 return 0;
3711}
3712
3713static int
3714bnx2_release_nvram_lock(struct bnx2 *bp)
3715{
3716 int j;
3717 u32 val;
3718
3719 /* Relinquish nvram interface. */
3720 REG_WR(bp, BNX2_NVM_SW_ARB, BNX2_NVM_SW_ARB_ARB_REQ_CLR2);
3721
3722 for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3723 val = REG_RD(bp, BNX2_NVM_SW_ARB);
3724 if (!(val & BNX2_NVM_SW_ARB_ARB_ARB2))
3725 break;
3726
3727 udelay(5);
3728 }
3729
3730 if (j >= NVRAM_TIMEOUT_COUNT)
3731 return -EBUSY;
3732
3733 return 0;
3734}
3735
3736
3737static int
3738bnx2_enable_nvram_write(struct bnx2 *bp)
3739{
3740 u32 val;
3741
3742 val = REG_RD(bp, BNX2_MISC_CFG);
3743 REG_WR(bp, BNX2_MISC_CFG, val | BNX2_MISC_CFG_NVM_WR_EN_PCI);
3744
e30372c9 3745 if (bp->flash_info->flags & BNX2_NV_WREN) {
b6016b76
MC		 3746 int j;
3747
3748 REG_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
3749 REG_WR(bp, BNX2_NVM_COMMAND,
3750 BNX2_NVM_COMMAND_WREN | BNX2_NVM_COMMAND_DOIT);
3751
3752 for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3753 udelay(5);
3754
3755 val = REG_RD(bp, BNX2_NVM_COMMAND);
3756 if (val & BNX2_NVM_COMMAND_DONE)
3757 break;
3758 }
3759
3760 if (j >= NVRAM_TIMEOUT_COUNT)
3761 return -EBUSY;
3762 }
3763 return 0;
3764}
3765
3766static void
3767bnx2_disable_nvram_write(struct bnx2 *bp)
3768{
3769 u32 val;
3770
3771 val = REG_RD(bp, BNX2_MISC_CFG);
3772 REG_WR(bp, BNX2_MISC_CFG, val & ~BNX2_MISC_CFG_NVM_WR_EN);
3773}
3774
3775
3776static void
3777bnx2_enable_nvram_access(struct bnx2 *bp)
3778{
3779 u32 val;
3780
3781 val = REG_RD(bp, BNX2_NVM_ACCESS_ENABLE);
3782 /* Enable both bits, even on read. */
6aa20a22 3783 REG_WR(bp, BNX2_NVM_ACCESS_ENABLE,
b6016b76
MC		 3784 val | BNX2_NVM_ACCESS_ENABLE_EN | BNX2_NVM_ACCESS_ENABLE_WR_EN);
3785}
3786
3787static void
3788bnx2_disable_nvram_access(struct bnx2 *bp)
3789{
3790 u32 val;
3791
3792 val = REG_RD(bp, BNX2_NVM_ACCESS_ENABLE);
3793 /* Disable both bits, even after read. */
6aa20a22 3794 REG_WR(bp, BNX2_NVM_ACCESS_ENABLE,
b6016b76
MC		 3795 val & ~(BNX2_NVM_ACCESS_ENABLE_EN |
3796 BNX2_NVM_ACCESS_ENABLE_WR_EN));
3797}
3798
3799static int
3800bnx2_nvram_erase_page(struct bnx2 *bp, u32 offset)
3801{
3802 u32 cmd;
3803 int j;
3804
e30372c9 3805 if (bp->flash_info->flags & BNX2_NV_BUFFERED)
b6016b76
MC		 3806 /* Buffered flash, no erase needed */
3807 return 0;
3808
3809 /* Build an erase command */
3810 cmd = BNX2_NVM_COMMAND_ERASE | BNX2_NVM_COMMAND_WR |
3811 BNX2_NVM_COMMAND_DOIT;
3812
3813 /* Need to clear DONE bit separately. */
3814 REG_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
3815
3816 /* Address of the NVRAM to read from. */
3817 REG_WR(bp, BNX2_NVM_ADDR, offset & BNX2_NVM_ADDR_NVM_ADDR_VALUE);
3818
3819 /* Issue an erase command. */
3820 REG_WR(bp, BNX2_NVM_COMMAND, cmd);
3821
3822 /* Wait for completion. */
3823 for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3824 u32 val;
3825
3826 udelay(5);
3827
3828 val = REG_RD(bp, BNX2_NVM_COMMAND);
3829 if (val & BNX2_NVM_COMMAND_DONE)
3830 break;
3831 }
3832
3833 if (j >= NVRAM_TIMEOUT_COUNT)
3834 return -EBUSY;
3835
3836 return 0;
3837}
3838
3839static int
3840bnx2_nvram_read_dword(struct bnx2 *bp, u32 offset, u8 *ret_val, u32 cmd_flags)
3841{
3842 u32 cmd;
3843 int j;
3844
3845 /* Build the command word. */
3846 cmd = BNX2_NVM_COMMAND_DOIT | cmd_flags;
3847
e30372c9
MC		 3848 /* Calculate an offset of a buffered flash, not needed for 5709. */
3849 if (bp->flash_info->flags & BNX2_NV_TRANSLATE) {
b6016b76
MC		 3850 offset = ((offset / bp->flash_info->page_size) <<
3851 bp->flash_info->page_bits) +
3852 (offset % bp->flash_info->page_size);
3853 }
3854
3855 /* Need to clear DONE bit separately. */
3856 REG_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
3857
3858 /* Address of the NVRAM to read from. */
3859 REG_WR(bp, BNX2_NVM_ADDR, offset & BNX2_NVM_ADDR_NVM_ADDR_VALUE);
3860
3861 /* Issue a read command. */
3862 REG_WR(bp, BNX2_NVM_COMMAND, cmd);
3863
3864 /* Wait for completion. */
3865 for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3866 u32 val;
3867
3868 udelay(5);
3869
3870 val = REG_RD(bp, BNX2_NVM_COMMAND);
3871 if (val & BNX2_NVM_COMMAND_DONE) {
b491edd5
AV		 3872 __be32 v = cpu_to_be32(REG_RD(bp, BNX2_NVM_READ));
3873 memcpy(ret_val, &v, 4);
b6016b76
MC		 3874 break;
3875 }
3876 }
3877 if (j >= NVRAM_TIMEOUT_COUNT)
3878 return -EBUSY;
3879
3880 return 0;
3881}
3882
3883
3884static int
3885bnx2_nvram_write_dword(struct bnx2 *bp, u32 offset, u8 *val, u32 cmd_flags)
3886{
b491edd5
AV		 3887 u32 cmd;
3888 __be32 val32;
b6016b76
MC		 3889 int j;
3890
3891 /* Build the command word. */
3892 cmd = BNX2_NVM_COMMAND_DOIT | BNX2_NVM_COMMAND_WR | cmd_flags;
3893
e30372c9
MC		 3894 /* Calculate an offset of a buffered flash, not needed for 5709. */
3895 if (bp->flash_info->flags & BNX2_NV_TRANSLATE) {
b6016b76
MC		 3896 offset = ((offset / bp->flash_info->page_size) <<
3897 bp->flash_info->page_bits) +
3898 (offset % bp->flash_info->page_size);
3899 }
3900
3901 /* Need to clear DONE bit separately. */
3902 REG_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
3903
3904 memcpy(&val32, val, 4);
b6016b76
MC		 3905
3906 /* Write the data. */
b491edd5 3907 REG_WR(bp, BNX2_NVM_WRITE, be32_to_cpu(val32));
b6016b76
MC		 3908
3909 /* Address of the NVRAM to write to. */
3910 REG_WR(bp, BNX2_NVM_ADDR, offset & BNX2_NVM_ADDR_NVM_ADDR_VALUE);
3911
3912 /* Issue the write command. */
3913 REG_WR(bp, BNX2_NVM_COMMAND, cmd);
3914
3915 /* Wait for completion. */
3916 for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3917 udelay(5);
3918
3919 if (REG_RD(bp, BNX2_NVM_COMMAND) & BNX2_NVM_COMMAND_DONE)
3920 break;
3921 }
3922 if (j >= NVRAM_TIMEOUT_COUNT)
3923 return -EBUSY;
3924
3925 return 0;
3926}
3927
3928static int
3929bnx2_init_nvram(struct bnx2 *bp)
3930{
3931 u32 val;
e30372c9 3932 int j, entry_count, rc = 0;
b6016b76
MC		 3933 struct flash_spec *flash;
3934
e30372c9
MC		 3935 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
3936 bp->flash_info = &flash_5709;
3937 goto get_flash_size;
3938 }
3939
b6016b76
MC		 3940 /* Determine the selected interface. */
3941 val = REG_RD(bp, BNX2_NVM_CFG1);
3942
ff8ac609 3943 entry_count = ARRAY_SIZE(flash_table);
b6016b76 3944
b6016b76
MC		 3945 if (val & 0x40000000) {
3946
3947 /* Flash interface has been reconfigured */
3948 for (j = 0, flash = &flash_table[0]; j < entry_count;
37137709
MC		 3949 j++, flash++) {
3950 if ((val & FLASH_BACKUP_STRAP_MASK) ==
3951 (flash->config1 & FLASH_BACKUP_STRAP_MASK)) {
b6016b76
MC		 3952 bp->flash_info = flash;
3953 break;
3954 }
3955 }
3956 }
3957 else {
37137709 3958 u32 mask;
b6016b76
MC		 3959 /* Not yet been reconfigured */
3960
37137709
MC		 3961 if (val & (1 << 23))
3962 mask = FLASH_BACKUP_STRAP_MASK;
3963 else
3964 mask = FLASH_STRAP_MASK;
3965
b6016b76
MC		 3966 for (j = 0, flash = &flash_table[0]; j < entry_count;
3967 j++, flash++) {
3968
37137709 3969 if ((val & mask) == (flash->strapping & mask)) {
b6016b76
MC		 3970 bp->flash_info = flash;
3971
3972 /* Request access to the flash interface. */
3973 if ((rc = bnx2_acquire_nvram_lock(bp)) != 0)
3974 return rc;
3975
3976 /* Enable access to flash interface */
3977 bnx2_enable_nvram_access(bp);
3978
3979 /* Reconfigure the flash interface */
3980 REG_WR(bp, BNX2_NVM_CFG1, flash->config1);
3981 REG_WR(bp, BNX2_NVM_CFG2, flash->config2);
3982 REG_WR(bp, BNX2_NVM_CFG3, flash->config3);
3983 REG_WR(bp, BNX2_NVM_WRITE1, flash->write1);
3984
3985 /* Disable access to flash interface */
3986 bnx2_disable_nvram_access(bp);
3987 bnx2_release_nvram_lock(bp);
3988
3989 break;
3990 }
3991 }
3992 } /* if (val & 0x40000000) */
3993
3994 if (j == entry_count) {
3995 bp->flash_info = NULL;
2f23c523 3996 printk(KERN_ALERT PFX "Unknown flash/EEPROM type.\n");
1122db71 3997 return -ENODEV;
b6016b76
MC		 3998 }
3999
e30372c9 4000get_flash_size:
2726d6e1 4001 val = bnx2_shmem_rd(bp, BNX2_SHARED_HW_CFG_CONFIG2);
1122db71
MC		 4002 val &= BNX2_SHARED_HW_CFG2_NVM_SIZE_MASK;
4003 if (val)
4004 bp->flash_size = val;
4005 else
4006 bp->flash_size = bp->flash_info->total_size;
4007
b6016b76
MC		 4008 return rc;
4009}
4010
4011static int
4012bnx2_nvram_read(struct bnx2 *bp, u32 offset, u8 *ret_buf,
4013 int buf_size)
4014{
4015 int rc = 0;
4016 u32 cmd_flags, offset32, len32, extra;
4017
4018 if (buf_size == 0)
4019 return 0;
4020
4021 /* Request access to the flash interface. */
4022 if ((rc = bnx2_acquire_nvram_lock(bp)) != 0)
4023 return rc;
4024
4025 /* Enable access to flash interface */
4026 bnx2_enable_nvram_access(bp);
4027
4028 len32 = buf_size;
4029 offset32 = offset;
4030 extra = 0;
4031
4032 cmd_flags = 0;
4033
4034 if (offset32 & 3) {
4035 u8 buf[4];
4036 u32 pre_len;
4037
4038 offset32 &= ~3;
4039 pre_len = 4 - (offset & 3);
4040
4041 if (pre_len >= len32) {
4042 pre_len = len32;
4043 cmd_flags = BNX2_NVM_COMMAND_FIRST |
4044 BNX2_NVM_COMMAND_LAST;
4045 }
4046 else {
4047 cmd_flags = BNX2_NVM_COMMAND_FIRST;
4048 }
4049
4050 rc = bnx2_nvram_read_dword(bp, offset32, buf, cmd_flags);
4051
4052 if (rc)
4053 return rc;
4054
4055 memcpy(ret_buf, buf + (offset & 3), pre_len);
4056
4057 offset32 += 4;
4058 ret_buf += pre_len;
4059 len32 -= pre_len;
4060 }
4061 if (len32 & 3) {
4062 extra = 4 - (len32 & 3);
4063 len32 = (len32 + 4) & ~3;
4064 }
4065
4066 if (len32 == 4) {
4067 u8 buf[4];
4068
4069 if (cmd_flags)
4070 cmd_flags = BNX2_NVM_COMMAND_LAST;
4071 else
4072 cmd_flags = BNX2_NVM_COMMAND_FIRST |
4073 BNX2_NVM_COMMAND_LAST;
4074
4075 rc = bnx2_nvram_read_dword(bp, offset32, buf, cmd_flags);
4076
4077 memcpy(ret_buf, buf, 4 - extra);
4078 }
4079 else if (len32 > 0) {
4080 u8 buf[4];
4081
4082 /* Read the first word. */
4083 if (cmd_flags)
4084 cmd_flags = 0;
4085 else
4086 cmd_flags = BNX2_NVM_COMMAND_FIRST;
4087
4088 rc = bnx2_nvram_read_dword(bp, offset32, ret_buf, cmd_flags);
4089
4090 /* Advance to the next dword. */
4091 offset32 += 4;
4092 ret_buf += 4;
4093 len32 -= 4;
4094
4095 while (len32 > 4 && rc == 0) {
4096 rc = bnx2_nvram_read_dword(bp, offset32, ret_buf, 0);
4097
4098 /* Advance to the next dword. */
4099 offset32 += 4;
4100 ret_buf += 4;
4101 len32 -= 4;
4102 }
4103
4104 if (rc)
4105 return rc;
4106
4107 cmd_flags = BNX2_NVM_COMMAND_LAST;
4108 rc = bnx2_nvram_read_dword(bp, offset32, buf, cmd_flags);
4109
4110 memcpy(ret_buf, buf, 4 - extra);
4111 }
4112
4113 /* Disable access to flash interface */
4114 bnx2_disable_nvram_access(bp);
4115
4116 bnx2_release_nvram_lock(bp);
4117
4118 return rc;
4119}
4120
4121static int
4122bnx2_nvram_write(struct bnx2 *bp, u32 offset, u8 *data_buf,
4123 int buf_size)
4124{
4125 u32 written, offset32, len32;
e6be763f 4126 u8 *buf, start[4], end[4], *align_buf = NULL, *flash_buffer = NULL;
b6016b76
MC		 4127 int rc = 0;
4128 int align_start, align_end;
4129
4130 buf = data_buf;
4131 offset32 = offset;
4132 len32 = buf_size;
4133 align_start = align_end = 0;
4134
4135 if ((align_start = (offset32 & 3))) {
4136 offset32 &= ~3;
c873879c
MC		 4137 len32 += align_start;
4138 if (len32 < 4)
4139 len32 = 4;
b6016b76
MC		 4140 if ((rc = bnx2_nvram_read(bp, offset32, start, 4)))
4141 return rc;
4142 }
4143
4144 if (len32 & 3) {
c873879c
MC		 4145 align_end = 4 - (len32 & 3);
4146 len32 += align_end;
4147 if ((rc = bnx2_nvram_read(bp, offset32 + len32 - 4, end, 4)))
4148 return rc;
b6016b76
MC		 4149 }
4150
4151 if (align_start || align_end) {
e6be763f
MC		 4152 align_buf = kmalloc(len32, GFP_KERNEL);
4153 if (align_buf == NULL)
b6016b76
MC		 4154 return -ENOMEM;
4155 if (align_start) {
e6be763f 4156 memcpy(align_buf, start, 4);
b6016b76
MC		 4157 }
4158 if (align_end) {
e6be763f 4159 memcpy(align_buf + len32 - 4, end, 4);
b6016b76 4160 }
e6be763f
MC		 4161 memcpy(align_buf + align_start, data_buf, buf_size);
4162 buf = align_buf;
b6016b76
MC		 4163 }
4164
e30372c9 4165 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
ae181bc4
MC		 4166 flash_buffer = kmalloc(264, GFP_KERNEL);
4167 if (flash_buffer == NULL) {
4168 rc = -ENOMEM;
4169 goto nvram_write_end;
4170 }
4171 }
4172
b6016b76
MC		 4173 written = 0;
4174 while ((written < len32) && (rc == 0)) {
4175 u32 page_start, page_end, data_start, data_end;
4176 u32 addr, cmd_flags;
4177 int i;
b6016b76
MC		 4178
4179 /* Find the page_start addr */
4180 page_start = offset32 + written;
4181 page_start -= (page_start % bp->flash_info->page_size);
4182 /* Find the page_end addr */
4183 page_end = page_start + bp->flash_info->page_size;
4184 /* Find the data_start addr */
4185 data_start = (written == 0) ? offset32 : page_start;
4186 /* Find the data_end addr */
6aa20a22 4187 data_end = (page_end > offset32 + len32) ?
b6016b76
MC		 4188 (offset32 + len32) : page_end;
4189
4190 /* Request access to the flash interface. */
4191 if ((rc = bnx2_acquire_nvram_lock(bp)) != 0)
4192 goto nvram_write_end;
4193
4194 /* Enable access to flash interface */
4195 bnx2_enable_nvram_access(bp);
4196
4197 cmd_flags = BNX2_NVM_COMMAND_FIRST;
e30372c9 4198 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
b6016b76
MC		 4199 int j;
4200
4201 /* Read the whole page into the buffer
4202 * (non-buffer flash only) */
4203 for (j = 0; j < bp->flash_info->page_size; j += 4) {
4204 if (j == (bp->flash_info->page_size - 4)) {
4205 cmd_flags |= BNX2_NVM_COMMAND_LAST;
4206 }
4207 rc = bnx2_nvram_read_dword(bp,
6aa20a22
JG		 4208 page_start + j,
4209 &flash_buffer[j],
b6016b76
MC		 4210 cmd_flags);
4211
4212 if (rc)
4213 goto nvram_write_end;
4214
4215 cmd_flags = 0;
4216 }
4217 }
4218
4219 /* Enable writes to flash interface (unlock write-protect) */
4220 if ((rc = bnx2_enable_nvram_write(bp)) != 0)
4221 goto nvram_write_end;
4222
b6016b76
MC		 4223 /* Loop to write back the buffer data from page_start to
4224 * data_start */
4225 i = 0;
e30372c9 4226 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
c873879c
MC		 4227 /* Erase the page */
4228 if ((rc = bnx2_nvram_erase_page(bp, page_start)) != 0)
4229 goto nvram_write_end;
4230
4231 /* Re-enable the write again for the actual write */
4232 bnx2_enable_nvram_write(bp);
4233
b6016b76
MC		 4234 for (addr = page_start; addr < data_start;
4235 addr += 4, i += 4) {
6aa20a22 4236
b6016b76
MC		 4237 rc = bnx2_nvram_write_dword(bp, addr,
4238 &flash_buffer[i], cmd_flags);
4239
4240 if (rc != 0)
4241 goto nvram_write_end;
4242
4243 cmd_flags = 0;
4244 }
4245 }
4246
4247 /* Loop to write the new data from data_start to data_end */
bae25761 4248 for (addr = data_start; addr < data_end; addr += 4, i += 4) {
b6016b76 4249 if ((addr == page_end - 4) ||
e30372c9 4250 ((bp->flash_info->flags & BNX2_NV_BUFFERED) &&
b6016b76
MC		 4251 (addr == data_end - 4))) {
4252
4253 cmd_flags |= BNX2_NVM_COMMAND_LAST;
4254 }
4255 rc = bnx2_nvram_write_dword(bp, addr, buf,
4256 cmd_flags);
4257
4258 if (rc != 0)
4259 goto nvram_write_end;
4260
4261 cmd_flags = 0;
4262 buf += 4;
4263 }
4264
4265 /* Loop to write back the buffer data from data_end
4266 * to page_end */
e30372c9 4267 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
b6016b76
MC		 4268 for (addr = data_end; addr < page_end;
4269 addr += 4, i += 4) {
6aa20a22 4270
b6016b76
MC		 4271 if (addr == page_end-4) {
4272 cmd_flags = BNX2_NVM_COMMAND_LAST;
4273 }
4274 rc = bnx2_nvram_write_dword(bp, addr,
4275 &flash_buffer[i], cmd_flags);
4276
4277 if (rc != 0)
4278 goto nvram_write_end;
4279
4280 cmd_flags = 0;
4281 }
4282 }
4283
4284 /* Disable writes to flash interface (lock write-protect) */
4285 bnx2_disable_nvram_write(bp);
4286
4287 /* Disable access to flash interface */
4288 bnx2_disable_nvram_access(bp);
4289 bnx2_release_nvram_lock(bp);
4290
4291 /* Increment written */
4292 written += data_end - data_start;
4293 }
4294
4295nvram_write_end:
e6be763f
MC		 4296 kfree(flash_buffer);
4297 kfree(align_buf);
b6016b76
MC		 4298 return rc;
4299}
4300
0d8a6571 4301static void
7c62e83b 4302bnx2_init_fw_cap(struct bnx2 *bp)
0d8a6571 4303{
7c62e83b 4304 u32 val, sig = 0;
0d8a6571 4305
583c28e5 4306 bp->phy_flags &= ~BNX2_PHY_FLAG_REMOTE_PHY_CAP;
7c62e83b
MC		 4307 bp->flags &= ~BNX2_FLAG_CAN_KEEP_VLAN;
4308
4309 if (!(bp->flags & BNX2_FLAG_ASF_ENABLE))
4310 bp->flags |= BNX2_FLAG_CAN_KEEP_VLAN;
0d8a6571 4311
2726d6e1 4312 val = bnx2_shmem_rd(bp, BNX2_FW_CAP_MB);
0d8a6571
MC		 4313 if ((val & BNX2_FW_CAP_SIGNATURE_MASK) != BNX2_FW_CAP_SIGNATURE)
4314 return;
4315
7c62e83b
MC		 4316 if ((val & BNX2_FW_CAP_CAN_KEEP_VLAN) == BNX2_FW_CAP_CAN_KEEP_VLAN) {
4317 bp->flags |= BNX2_FLAG_CAN_KEEP_VLAN;
4318 sig |= BNX2_DRV_ACK_CAP_SIGNATURE | BNX2_FW_CAP_CAN_KEEP_VLAN;
4319 }
4320
4321 if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
4322 (val & BNX2_FW_CAP_REMOTE_PHY_CAPABLE)) {
4323 u32 link;
4324
583c28e5 4325 bp->phy_flags |= BNX2_PHY_FLAG_REMOTE_PHY_CAP;
0d8a6571 4326
7c62e83b
MC		 4327 link = bnx2_shmem_rd(bp, BNX2_LINK_STATUS);
4328 if (link & BNX2_LINK_STATUS_SERDES_LINK)
0d8a6571
MC		 4329 bp->phy_port = PORT_FIBRE;
4330 else
4331 bp->phy_port = PORT_TP;
489310a4 4332
7c62e83b
MC		 4333 sig |= BNX2_DRV_ACK_CAP_SIGNATURE |
4334 BNX2_FW_CAP_REMOTE_PHY_CAPABLE;
0d8a6571 4335 }
7c62e83b
MC		 4336
4337 if (netif_running(bp->dev) && sig)
4338 bnx2_shmem_wr(bp, BNX2_DRV_ACK_CAP_MB, sig);
0d8a6571
MC		 4339}
4340
b4b36042
MC		 4341static void
4342bnx2_setup_msix_tbl(struct bnx2 *bp)
4343{
4344 REG_WR(bp, BNX2_PCI_GRC_WINDOW_ADDR, BNX2_PCI_GRC_WINDOW_ADDR_SEP_WIN);
4345
4346 REG_WR(bp, BNX2_PCI_GRC_WINDOW2_ADDR, BNX2_MSIX_TABLE_ADDR);
4347 REG_WR(bp, BNX2_PCI_GRC_WINDOW3_ADDR, BNX2_MSIX_PBA_ADDR);
4348}
4349
b6016b76
MC		 4350static int
4351bnx2_reset_chip(struct bnx2 *bp, u32 reset_code)
4352{
4353 u32 val;
4354 int i, rc = 0;
489310a4 4355 u8 old_port;
b6016b76
MC		 4356
4357 /* Wait for the current PCI transaction to complete before
4358 * issuing a reset. */
4359 REG_WR(bp, BNX2_MISC_ENABLE_CLR_BITS,
4360 BNX2_MISC_ENABLE_CLR_BITS_TX_DMA_ENABLE |
4361 BNX2_MISC_ENABLE_CLR_BITS_DMA_ENGINE_ENABLE |
4362 BNX2_MISC_ENABLE_CLR_BITS_RX_DMA_ENABLE |
4363 BNX2_MISC_ENABLE_CLR_BITS_HOST_COALESCE_ENABLE);
4364 val = REG_RD(bp, BNX2_MISC_ENABLE_CLR_BITS);
4365 udelay(5);
4366
b090ae2b 4367 /* Wait for the firmware to tell us it is ok to issue a reset. */
a2f13890 4368 bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT0 | reset_code, 1, 1);
b090ae2b 4369
b6016b76
MC		 4370 /* Deposit a driver reset signature so the firmware knows that
4371 * this is a soft reset. */
2726d6e1
MC		 4372 bnx2_shmem_wr(bp, BNX2_DRV_RESET_SIGNATURE,
4373 BNX2_DRV_RESET_SIGNATURE_MAGIC);
b6016b76 4374
b6016b76
MC		 4375 /* Do a dummy read to force the chip to complete all current transaction
4376 * before we issue a reset. */
4377 val = REG_RD(bp, BNX2_MISC_ID);
4378
234754d5
MC		 4379 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
4380 REG_WR(bp, BNX2_MISC_COMMAND, BNX2_MISC_COMMAND_SW_RESET);
4381 REG_RD(bp, BNX2_MISC_COMMAND);
4382 udelay(5);
b6016b76 4383
234754d5
MC		 4384 val = BNX2_PCICFG_MISC_CONFIG_REG_WINDOW_ENA |
4385 BNX2_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP;
b6016b76 4386
234754d5 4387 pci_write_config_dword(bp->pdev, BNX2_PCICFG_MISC_CONFIG, val);
b6016b76 4388
234754d5
MC		 4389 } else {
4390 val = BNX2_PCICFG_MISC_CONFIG_CORE_RST_REQ |
4391 BNX2_PCICFG_MISC_CONFIG_REG_WINDOW_ENA |
4392 BNX2_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP;
4393
4394 /* Chip reset. */
4395 REG_WR(bp, BNX2_PCICFG_MISC_CONFIG, val);
4396
594a9dfa
MC		 4397 /* Reading back any register after chip reset will hang the
4398 * bus on 5706 A0 and A1. The msleep below provides plenty
4399 * of margin for write posting.
4400 */
234754d5 4401 if ((CHIP_ID(bp) == CHIP_ID_5706_A0) ||
8e545881
AV		 4402 (CHIP_ID(bp) == CHIP_ID_5706_A1))
4403 msleep(20);
b6016b76 4404
234754d5
MC		 4405 /* Reset takes approximate 30 usec */
4406 for (i = 0; i < 10; i++) {
4407 val = REG_RD(bp, BNX2_PCICFG_MISC_CONFIG);
4408 if ((val & (BNX2_PCICFG_MISC_CONFIG_CORE_RST_REQ |
4409 BNX2_PCICFG_MISC_CONFIG_CORE_RST_BSY)) == 0)
4410 break;
4411 udelay(10);
4412 }
4413
4414 if (val & (BNX2_PCICFG_MISC_CONFIG_CORE_RST_REQ |
4415 BNX2_PCICFG_MISC_CONFIG_CORE_RST_BSY)) {
4416 printk(KERN_ERR PFX "Chip reset did not complete\n");
4417 return -EBUSY;
4418 }
b6016b76
MC		 4419 }
4420
4421 /* Make sure byte swapping is properly configured. */
4422 val = REG_RD(bp, BNX2_PCI_SWAP_DIAG0);
4423 if (val != 0x01020304) {
4424 printk(KERN_ERR PFX "Chip not in correct endian mode\n");
4425 return -ENODEV;
4426 }
4427
b6016b76 4428 /* Wait for the firmware to finish its initialization. */
a2f13890 4429 rc = bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT1 | reset_code, 1, 0);
b090ae2b
MC		 4430 if (rc)
4431 return rc;
b6016b76 4432
0d8a6571 4433 spin_lock_bh(&bp->phy_lock);
489310a4 4434 old_port = bp->phy_port;
7c62e83b 4435 bnx2_init_fw_cap(bp);
583c28e5
MC		 4436 if ((bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) &&
4437 old_port != bp->phy_port)
0d8a6571
MC		 4438 bnx2_set_default_remote_link(bp);
4439 spin_unlock_bh(&bp->phy_lock);
4440
b6016b76
MC		 4441 if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
4442 /* Adjust the voltage regular to two steps lower. The default
4443 * of this register is 0x0000000e. */
4444 REG_WR(bp, BNX2_MISC_VREG_CONTROL, 0x000000fa);
4445
4446 /* Remove bad rbuf memory from the free pool. */
4447 rc = bnx2_alloc_bad_rbuf(bp);
4448 }
4449
f86e82fb 4450 if (bp->flags & BNX2_FLAG_USING_MSIX)
b4b36042
MC		 4451 bnx2_setup_msix_tbl(bp);
4452
b6016b76
MC		 4453 return rc;
4454}
4455
4456static int
4457bnx2_init_chip(struct bnx2 *bp)
4458{
4459 u32 val;
b4b36042 4460 int rc, i;
b6016b76
MC		 4461
4462 /* Make sure the interrupt is not active. */
4463 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD, BNX2_PCICFG_INT_ACK_CMD_MASK_INT);
4464
4465 val = BNX2_DMA_CONFIG_DATA_BYTE_SWAP |
4466 BNX2_DMA_CONFIG_DATA_WORD_SWAP |
4467#ifdef __BIG_ENDIAN
6aa20a22 4468 BNX2_DMA_CONFIG_CNTL_BYTE_SWAP |
b6016b76 4469#endif
6aa20a22 4470 BNX2_DMA_CONFIG_CNTL_WORD_SWAP |
b6016b76
MC		 4471 DMA_READ_CHANS << 12 |
4472 DMA_WRITE_CHANS << 16;
4473
4474 val |= (0x2 << 20) | (1 << 11);
4475
f86e82fb 4476 if ((bp->flags & BNX2_FLAG_PCIX) && (bp->bus_speed_mhz == 133))
b6016b76
MC		 4477 val |= (1 << 23);
4478
4479 if ((CHIP_NUM(bp) == CHIP_NUM_5706) &&
f86e82fb 4480 (CHIP_ID(bp) != CHIP_ID_5706_A0) && !(bp->flags & BNX2_FLAG_PCIX))
b6016b76
MC		 4481 val |= BNX2_DMA_CONFIG_CNTL_PING_PONG_DMA;
4482
4483 REG_WR(bp, BNX2_DMA_CONFIG, val);
4484
4485 if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
4486 val = REG_RD(bp, BNX2_TDMA_CONFIG);
4487 val |= BNX2_TDMA_CONFIG_ONE_DMA;
4488 REG_WR(bp, BNX2_TDMA_CONFIG, val);
4489 }
4490
f86e82fb 4491 if (bp->flags & BNX2_FLAG_PCIX) {
b6016b76
MC		 4492 u16 val16;
4493
4494 pci_read_config_word(bp->pdev, bp->pcix_cap + PCI_X_CMD,
4495 &val16);
4496 pci_write_config_word(bp->pdev, bp->pcix_cap + PCI_X_CMD,
4497 val16 & ~PCI_X_CMD_ERO);
4498 }
4499
4500 REG_WR(bp, BNX2_MISC_ENABLE_SET_BITS,
4501 BNX2_MISC_ENABLE_SET_BITS_HOST_COALESCE_ENABLE |
4502 BNX2_MISC_ENABLE_STATUS_BITS_RX_V2P_ENABLE |
4503 BNX2_MISC_ENABLE_STATUS_BITS_CONTEXT_ENABLE);
4504
4505 /* Initialize context mapping and zero out the quick contexts. The
4506 * context block must have already been enabled. */
641bdcd5
MC		 4507 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
4508 rc = bnx2_init_5709_context(bp);
4509 if (rc)
4510 return rc;
4511 } else
59b47d8a 4512 bnx2_init_context(bp);
b6016b76 4513
fba9fe91
MC		 4514 if ((rc = bnx2_init_cpus(bp)) != 0)
4515 return rc;
4516
b6016b76
MC		 4517 bnx2_init_nvram(bp);
4518
5fcaed01 4519 bnx2_set_mac_addr(bp, bp->dev->dev_addr, 0);
b6016b76
MC		 4520
4521 val = REG_RD(bp, BNX2_MQ_CONFIG);
4522 val &= ~BNX2_MQ_CONFIG_KNL_BYP_BLK_SIZE;
4523 val |= BNX2_MQ_CONFIG_KNL_BYP_BLK_SIZE_256;
68c9f75a
MC		 4524 if (CHIP_ID(bp) == CHIP_ID_5709_A0 || CHIP_ID(bp) == CHIP_ID_5709_A1)
4525 val |= BNX2_MQ_CONFIG_HALT_DIS;
4526
b6016b76
MC		 4527 REG_WR(bp, BNX2_MQ_CONFIG, val);
4528
4529 val = 0x10000 + (MAX_CID_CNT * MB_KERNEL_CTX_SIZE);
4530 REG_WR(bp, BNX2_MQ_KNL_BYP_WIND_START, val);
4531 REG_WR(bp, BNX2_MQ_KNL_WIND_END, val);
4532
4533 val = (BCM_PAGE_BITS - 8) << 24;
4534 REG_WR(bp, BNX2_RV2P_CONFIG, val);
4535
4536 /* Configure page size. */
4537 val = REG_RD(bp, BNX2_TBDR_CONFIG);
4538 val &= ~BNX2_TBDR_CONFIG_PAGE_SIZE;
4539 val |= (BCM_PAGE_BITS - 8) << 24 | 0x40;
4540 REG_WR(bp, BNX2_TBDR_CONFIG, val);
4541
4542 val = bp->mac_addr[0] +
4543 (bp->mac_addr[1] << 8) +
4544 (bp->mac_addr[2] << 16) +
4545 bp->mac_addr[3] +
4546 (bp->mac_addr[4] << 8) +
4547 (bp->mac_addr[5] << 16);
4548 REG_WR(bp, BNX2_EMAC_BACKOFF_SEED, val);
4549
4550 /* Program the MTU. Also include 4 bytes for CRC32. */
4551 val = bp->dev->mtu + ETH_HLEN + 4;
4552 if (val > (MAX_ETHERNET_PACKET_SIZE + 4))
4553 val |= BNX2_EMAC_RX_MTU_SIZE_JUMBO_ENA;
4554 REG_WR(bp, BNX2_EMAC_RX_MTU_SIZE, val);
4555
b4b36042
MC		 4556 for (i = 0; i < BNX2_MAX_MSIX_VEC; i++)
4557 bp->bnx2_napi[i].last_status_idx = 0;
4558
b6016b76
MC		 4559 bp->rx_mode = BNX2_EMAC_RX_MODE_SORT_MODE;
4560
4561 /* Set up how to generate a link change interrupt. */
4562 REG_WR(bp, BNX2_EMAC_ATTENTION_ENA, BNX2_EMAC_ATTENTION_ENA_LINK);
4563
4564 REG_WR(bp, BNX2_HC_STATUS_ADDR_L,
4565 (u64) bp->status_blk_mapping & 0xffffffff);
4566 REG_WR(bp, BNX2_HC_STATUS_ADDR_H, (u64) bp->status_blk_mapping >> 32);
4567
4568 REG_WR(bp, BNX2_HC_STATISTICS_ADDR_L,
4569 (u64) bp->stats_blk_mapping & 0xffffffff);
4570 REG_WR(bp, BNX2_HC_STATISTICS_ADDR_H,
4571 (u64) bp->stats_blk_mapping >> 32);
4572
6aa20a22 4573 REG_WR(bp, BNX2_HC_TX_QUICK_CONS_TRIP,
b6016b76
MC		 4574 (bp->tx_quick_cons_trip_int << 16) | bp->tx_quick_cons_trip);
4575
4576 REG_WR(bp, BNX2_HC_RX_QUICK_CONS_TRIP,
4577 (bp->rx_quick_cons_trip_int << 16) | bp->rx_quick_cons_trip);
4578
4579 REG_WR(bp, BNX2_HC_COMP_PROD_TRIP,
4580 (bp->comp_prod_trip_int << 16) | bp->comp_prod_trip);
4581
4582 REG_WR(bp, BNX2_HC_TX_TICKS, (bp->tx_ticks_int << 16) | bp->tx_ticks);
4583
4584 REG_WR(bp, BNX2_HC_RX_TICKS, (bp->rx_ticks_int << 16) | bp->rx_ticks);
4585
4586 REG_WR(bp, BNX2_HC_COM_TICKS,
4587 (bp->com_ticks_int << 16) | bp->com_ticks);
4588
4589 REG_WR(bp, BNX2_HC_CMD_TICKS,
4590 (bp->cmd_ticks_int << 16) | bp->cmd_ticks);
4591
02537b06
MC		 4592 if (CHIP_NUM(bp) == CHIP_NUM_5708)
4593 REG_WR(bp, BNX2_HC_STATS_TICKS, 0);
4594 else
7ea6920e 4595 REG_WR(bp, BNX2_HC_STATS_TICKS, bp->stats_ticks);
b6016b76
MC		 4596 REG_WR(bp, BNX2_HC_STAT_COLLECT_TICKS, 0xbb8); /* 3ms */
4597
4598 if (CHIP_ID(bp) == CHIP_ID_5706_A1)
8e6a72c4 4599 val = BNX2_HC_CONFIG_COLLECT_STATS;
b6016b76 4600 else {
8e6a72c4
MC		 4601 val = BNX2_HC_CONFIG_RX_TMR_MODE | BNX2_HC_CONFIG_TX_TMR_MODE |
4602 BNX2_HC_CONFIG_COLLECT_STATS;
b6016b76
MC		 4603 }
4604
5e9ad9e1 4605 if (bp->irq_nvecs > 1) {
c76c0475
MC		 4606 REG_WR(bp, BNX2_HC_MSIX_BIT_VECTOR,
4607 BNX2_HC_MSIX_BIT_VECTOR_VAL);
4608
5e9ad9e1
MC		 4609 val |= BNX2_HC_CONFIG_SB_ADDR_INC_128B;
4610 }
4611
4612 if (bp->flags & BNX2_FLAG_ONE_SHOT_MSI)
4613 val |= BNX2_HC_CONFIG_ONE_SHOT;
4614
4615 REG_WR(bp, BNX2_HC_CONFIG, val);
4616
4617 for (i = 1; i < bp->irq_nvecs; i++) {
4618 u32 base = ((i - 1) * BNX2_HC_SB_CONFIG_SIZE) +
4619 BNX2_HC_SB_CONFIG_1;
4620
6f743ca0 4621 REG_WR(bp, base,
c76c0475 4622 BNX2_HC_SB_CONFIG_1_TX_TMR_MODE |
5e9ad9e1 4623 BNX2_HC_SB_CONFIG_1_RX_TMR_MODE |
c76c0475
MC		 4624 BNX2_HC_SB_CONFIG_1_ONE_SHOT);
4625
6f743ca0 4626 REG_WR(bp, base + BNX2_HC_TX_QUICK_CONS_TRIP_OFF,
c76c0475
MC		 4627 (bp->tx_quick_cons_trip_int << 16) |
4628 bp->tx_quick_cons_trip);
4629
6f743ca0 4630 REG_WR(bp, base + BNX2_HC_TX_TICKS_OFF,
c76c0475
MC		 4631 (bp->tx_ticks_int << 16) | bp->tx_ticks);
4632
5e9ad9e1
MC		 4633 REG_WR(bp, base + BNX2_HC_RX_QUICK_CONS_TRIP_OFF,
4634 (bp->rx_quick_cons_trip_int << 16) |
4635 bp->rx_quick_cons_trip);
8e6a72c4 4636
5e9ad9e1
MC		 4637 REG_WR(bp, base + BNX2_HC_RX_TICKS_OFF,
4638 (bp->rx_ticks_int << 16) | bp->rx_ticks);
4639 }
8e6a72c4 4640
b6016b76
MC		 4641 /* Clear internal stats counters. */
4642 REG_WR(bp, BNX2_HC_COMMAND, BNX2_HC_COMMAND_CLR_STAT_NOW);
4643
da3e4fbe 4644 REG_WR(bp, BNX2_HC_ATTN_BITS_ENABLE, STATUS_ATTN_EVENTS);
b6016b76
MC		 4645
4646 /* Initialize the receive filter. */
4647 bnx2_set_rx_mode(bp->dev);
4648
0aa38df7
MC		 4649 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
4650 val = REG_RD(bp, BNX2_MISC_NEW_CORE_CTL);
4651 val |= BNX2_MISC_NEW_CORE_CTL_DMA_ENABLE;
4652 REG_WR(bp, BNX2_MISC_NEW_CORE_CTL, val);
4653 }
b090ae2b 4654 rc = bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT2 | BNX2_DRV_MSG_CODE_RESET,
a2f13890 4655 1, 0);
b6016b76 4656
df149d70 4657 REG_WR(bp, BNX2_MISC_ENABLE_SET_BITS, BNX2_MISC_ENABLE_DEFAULT);
b6016b76
MC		 4658 REG_RD(bp, BNX2_MISC_ENABLE_SET_BITS);
4659
4660 udelay(20);
4661
bf5295bb
MC		 4662 bp->hc_cmd = REG_RD(bp, BNX2_HC_COMMAND);
4663
b090ae2b 4664 return rc;
b6016b76
MC		 4665}
4666
c76c0475
MC		 4667static void
4668bnx2_clear_ring_states(struct bnx2 *bp)
4669{
4670 struct bnx2_napi *bnapi;
35e9010b 4671 struct bnx2_tx_ring_info *txr;
bb4f98ab 4672 struct bnx2_rx_ring_info *rxr;
c76c0475
MC		 4673 int i;
4674
4675 for (i = 0; i < BNX2_MAX_MSIX_VEC; i++) {
4676 bnapi = &bp->bnx2_napi[i];
35e9010b 4677 txr = &bnapi->tx_ring;
bb4f98ab 4678 rxr = &bnapi->rx_ring;
c76c0475 4679
35e9010b
MC		 4680 txr->tx_cons = 0;
4681 txr->hw_tx_cons = 0;
bb4f98ab
MC		 4682 rxr->rx_prod_bseq = 0;
4683 rxr->rx_prod = 0;
4684 rxr->rx_cons = 0;
4685 rxr->rx_pg_prod = 0;
4686 rxr->rx_pg_cons = 0;
c76c0475
MC		 4687 }
4688}
4689
59b47d8a 4690static void
35e9010b 4691bnx2_init_tx_context(struct bnx2 *bp, u32 cid, struct bnx2_tx_ring_info *txr)
59b47d8a
MC		 4692{
4693 u32 val, offset0, offset1, offset2, offset3;
62a8313c 4694 u32 cid_addr = GET_CID_ADDR(cid);
59b47d8a
MC		 4695
4696 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
4697 offset0 = BNX2_L2CTX_TYPE_XI;
4698 offset1 = BNX2_L2CTX_CMD_TYPE_XI;
4699 offset2 = BNX2_L2CTX_TBDR_BHADDR_HI_XI;
4700 offset3 = BNX2_L2CTX_TBDR_BHADDR_LO_XI;
4701 } else {
4702 offset0 = BNX2_L2CTX_TYPE;
4703 offset1 = BNX2_L2CTX_CMD_TYPE;
4704 offset2 = BNX2_L2CTX_TBDR_BHADDR_HI;
4705 offset3 = BNX2_L2CTX_TBDR_BHADDR_LO;
4706 }
4707 val = BNX2_L2CTX_TYPE_TYPE_L2 | BNX2_L2CTX_TYPE_SIZE_L2;
62a8313c 4708 bnx2_ctx_wr(bp, cid_addr, offset0, val);
59b47d8a
MC		 4709
4710 val = BNX2_L2CTX_CMD_TYPE_TYPE_L2 | (8 << 16);
62a8313c 4711 bnx2_ctx_wr(bp, cid_addr, offset1, val);
59b47d8a 4712
35e9010b 4713 val = (u64) txr->tx_desc_mapping >> 32;
62a8313c 4714 bnx2_ctx_wr(bp, cid_addr, offset2, val);
59b47d8a 4715
35e9010b 4716 val = (u64) txr->tx_desc_mapping & 0xffffffff;
62a8313c 4717 bnx2_ctx_wr(bp, cid_addr, offset3, val);
59b47d8a 4718}
b6016b76
MC		 4719
4720static void
35e9010b 4721bnx2_init_tx_ring(struct bnx2 *bp, int ring_num)
b6016b76
MC		 4722{
4723 struct tx_bd *txbd;
c76c0475
MC		 4724 u32 cid = TX_CID;
4725 struct bnx2_napi *bnapi;
35e9010b 4726 struct bnx2_tx_ring_info *txr;
c76c0475 4727
35e9010b
MC		 4728 bnapi = &bp->bnx2_napi[ring_num];
4729 txr = &bnapi->tx_ring;
4730
4731 if (ring_num == 0)
4732 cid = TX_CID;
4733 else
4734 cid = TX_TSS_CID + ring_num - 1;
b6016b76 4735
2f8af120
MC		 4736 bp->tx_wake_thresh = bp->tx_ring_size / 2;
4737
35e9010b 4738 txbd = &txr->tx_desc_ring[MAX_TX_DESC_CNT];
6aa20a22 4739
35e9010b
MC		 4740 txbd->tx_bd_haddr_hi = (u64) txr->tx_desc_mapping >> 32;
4741 txbd->tx_bd_haddr_lo = (u64) txr->tx_desc_mapping & 0xffffffff;
b6016b76 4742
35e9010b
MC		 4743 txr->tx_prod = 0;
4744 txr->tx_prod_bseq = 0;
6aa20a22 4745
35e9010b
MC		 4746 txr->tx_bidx_addr = MB_GET_CID_ADDR(cid) + BNX2_L2CTX_TX_HOST_BIDX;
4747 txr->tx_bseq_addr = MB_GET_CID_ADDR(cid) + BNX2_L2CTX_TX_HOST_BSEQ;
b6016b76 4748
35e9010b 4749 bnx2_init_tx_context(bp, cid, txr);
b6016b76
MC		 4750}
4751
4752static void
5d5d0015
MC		 4753bnx2_init_rxbd_rings(struct rx_bd *rx_ring[], dma_addr_t dma[], u32 buf_size,
4754 int num_rings)
b6016b76 4755{
b6016b76 4756 int i;
5d5d0015 4757 struct rx_bd *rxbd;
6aa20a22 4758
5d5d0015 4759 for (i = 0; i < num_rings; i++) {
13daffa2 4760 int j;
b6016b76 4761
5d5d0015 4762 rxbd = &rx_ring[i][0];
13daffa2 4763 for (j = 0; j < MAX_RX_DESC_CNT; j++, rxbd++) {
5d5d0015 4764 rxbd->rx_bd_len = buf_size;
13daffa2
MC		 4765 rxbd->rx_bd_flags = RX_BD_FLAGS_START | RX_BD_FLAGS_END;
4766 }
5d5d0015 4767 if (i == (num_rings - 1))
13daffa2
MC		 4768 j = 0;
4769 else
4770 j = i + 1;
5d5d0015
MC		 4771 rxbd->rx_bd_haddr_hi = (u64) dma[j] >> 32;
4772 rxbd->rx_bd_haddr_lo = (u64) dma[j] & 0xffffffff;
13daffa2 4773 }
5d5d0015
MC		 4774}
4775
4776static void
bb4f98ab 4777bnx2_init_rx_ring(struct bnx2 *bp, int ring_num)
5d5d0015
MC		 4778{
4779 int i;
4780 u16 prod, ring_prod;
bb4f98ab
MC		 4781 u32 cid, rx_cid_addr, val;
4782 struct bnx2_napi *bnapi = &bp->bnx2_napi[ring_num];
4783 struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
4784
4785 if (ring_num == 0)
4786 cid = RX_CID;
4787 else
4788 cid = RX_RSS_CID + ring_num - 1;
4789
4790 rx_cid_addr = GET_CID_ADDR(cid);
5d5d0015 4791
bb4f98ab 4792 bnx2_init_rxbd_rings(rxr->rx_desc_ring, rxr->rx_desc_mapping,
5d5d0015
MC		 4793 bp->rx_buf_use_size, bp->rx_max_ring);
4794
bb4f98ab 4795 bnx2_init_rx_context(bp, cid);
83e3fc89
MC		 4796
4797 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
4798 val = REG_RD(bp, BNX2_MQ_MAP_L2_5);
4799 REG_WR(bp, BNX2_MQ_MAP_L2_5, val | BNX2_MQ_MAP_L2_5_ARM);
4800 }
4801
62a8313c 4802 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_PG_BUF_SIZE, 0);
47bf4246 4803 if (bp->rx_pg_ring_size) {
bb4f98ab
MC		 4804 bnx2_init_rxbd_rings(rxr->rx_pg_desc_ring,
4805 rxr->rx_pg_desc_mapping,
47bf4246
MC		 4806 PAGE_SIZE, bp->rx_max_pg_ring);
4807 val = (bp->rx_buf_use_size << 16) | PAGE_SIZE;
62a8313c
MC		 4808 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_PG_BUF_SIZE, val);
4809 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_RBDC_KEY,
5e9ad9e1 4810 BNX2_L2CTX_RBDC_JUMBO_KEY - ring_num);
47bf4246 4811
bb4f98ab 4812 val = (u64) rxr->rx_pg_desc_mapping[0] >> 32;
62a8313c 4813 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_NX_PG_BDHADDR_HI, val);
47bf4246 4814
bb4f98ab 4815 val = (u64) rxr->rx_pg_desc_mapping[0] & 0xffffffff;
62a8313c 4816 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_NX_PG_BDHADDR_LO, val);
47bf4246
MC		 4817
4818 if (CHIP_NUM(bp) == CHIP_NUM_5709)
4819 REG_WR(bp, BNX2_MQ_MAP_L2_3, BNX2_MQ_MAP_L2_3_DEFAULT);
4820 }
b6016b76 4821
bb4f98ab 4822 val = (u64) rxr->rx_desc_mapping[0] >> 32;
62a8313c 4823 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_NX_BDHADDR_HI, val);
b6016b76 4824
bb4f98ab 4825 val = (u64) rxr->rx_desc_mapping[0] & 0xffffffff;
62a8313c 4826 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_NX_BDHADDR_LO, val);
b6016b76 4827
bb4f98ab 4828 ring_prod = prod = rxr->rx_pg_prod;
47bf4246 4829 for (i = 0; i < bp->rx_pg_ring_size; i++) {
bb4f98ab 4830 if (bnx2_alloc_rx_page(bp, rxr, ring_prod) < 0)
47bf4246
MC		 4831 break;
4832 prod = NEXT_RX_BD(prod);
4833 ring_prod = RX_PG_RING_IDX(prod);
4834 }
bb4f98ab 4835 rxr->rx_pg_prod = prod;
47bf4246 4836
bb4f98ab 4837 ring_prod = prod = rxr->rx_prod;
236b6394 4838 for (i = 0; i < bp->rx_ring_size; i++) {
bb4f98ab 4839 if (bnx2_alloc_rx_skb(bp, rxr, ring_prod) < 0)
b6016b76 4840 break;
b6016b76
MC		 4841 prod = NEXT_RX_BD(prod);
4842 ring_prod = RX_RING_IDX(prod);
4843 }
bb4f98ab 4844 rxr->rx_prod = prod;
b6016b76 4845
bb4f98ab
MC		 4846 rxr->rx_bidx_addr = MB_GET_CID_ADDR(cid) + BNX2_L2CTX_HOST_BDIDX;
4847 rxr->rx_bseq_addr = MB_GET_CID_ADDR(cid) + BNX2_L2CTX_HOST_BSEQ;
4848 rxr->rx_pg_bidx_addr = MB_GET_CID_ADDR(cid) + BNX2_L2CTX_HOST_PG_BDIDX;
b6016b76 4849
bb4f98ab
MC		 4850 REG_WR16(bp, rxr->rx_pg_bidx_addr, rxr->rx_pg_prod);
4851 REG_WR16(bp, rxr->rx_bidx_addr, prod);
4852
4853 REG_WR(bp, rxr->rx_bseq_addr, rxr->rx_prod_bseq);
b6016b76
MC		 4854}
4855
35e9010b
MC		 4856static void
4857bnx2_init_all_rings(struct bnx2 *bp)
4858{
4859 int i;
5e9ad9e1 4860 u32 val;
35e9010b
MC		 4861
4862 bnx2_clear_ring_states(bp);
4863
4864 REG_WR(bp, BNX2_TSCH_TSS_CFG, 0);
4865 for (i = 0; i < bp->num_tx_rings; i++)
4866 bnx2_init_tx_ring(bp, i);
4867
4868 if (bp->num_tx_rings > 1)
4869 REG_WR(bp, BNX2_TSCH_TSS_CFG, ((bp->num_tx_rings - 1) << 24) |
4870 (TX_TSS_CID << 7));
4871
5e9ad9e1
MC		 4872 REG_WR(bp, BNX2_RLUP_RSS_CONFIG, 0);
4873 bnx2_reg_wr_ind(bp, BNX2_RXP_SCRATCH_RSS_TBL_SZ, 0);
4874
bb4f98ab
MC		 4875 for (i = 0; i < bp->num_rx_rings; i++)
4876 bnx2_init_rx_ring(bp, i);
5e9ad9e1
MC		 4877
4878 if (bp->num_rx_rings > 1) {
4879 u32 tbl_32;
4880 u8 *tbl = (u8 *) &tbl_32;
4881
4882 bnx2_reg_wr_ind(bp, BNX2_RXP_SCRATCH_RSS_TBL_SZ,
4883 BNX2_RXP_SCRATCH_RSS_TBL_MAX_ENTRIES);
4884
4885 for (i = 0; i < BNX2_RXP_SCRATCH_RSS_TBL_MAX_ENTRIES; i++) {
4886 tbl[i % 4] = i % (bp->num_rx_rings - 1);
4887 if ((i % 4) == 3)
4888 bnx2_reg_wr_ind(bp,
4889 BNX2_RXP_SCRATCH_RSS_TBL + i,
4890 cpu_to_be32(tbl_32));
4891 }
4892
4893 val = BNX2_RLUP_RSS_CONFIG_IPV4_RSS_TYPE_ALL_XI |
4894 BNX2_RLUP_RSS_CONFIG_IPV6_RSS_TYPE_ALL_XI;
4895
4896 REG_WR(bp, BNX2_RLUP_RSS_CONFIG, val);
4897
4898 }
35e9010b
MC		 4899}
4900
5d5d0015 4901static u32 bnx2_find_max_ring(u32 ring_size, u32 max_size)
13daffa2 4902{
5d5d0015 4903 u32 max, num_rings = 1;
13daffa2 4904
5d5d0015
MC		 4905 while (ring_size > MAX_RX_DESC_CNT) {
4906 ring_size -= MAX_RX_DESC_CNT;
13daffa2
MC		 4907 num_rings++;
4908 }
4909 /* round to next power of 2 */
5d5d0015 4910 max = max_size;
13daffa2
MC		 4911 while ((max & num_rings) == 0)
4912 max >>= 1;
4913
4914 if (num_rings != max)
4915 max <<= 1;
4916
5d5d0015
MC		 4917 return max;
4918}
4919
4920static void
4921bnx2_set_rx_ring_size(struct bnx2 *bp, u32 size)
4922{
84eaa187 4923 u32 rx_size, rx_space, jumbo_size;
5d5d0015
MC		 4924
4925 /* 8 for CRC and VLAN */
d89cb6af 4926 rx_size = bp->dev->mtu + ETH_HLEN + BNX2_RX_OFFSET + 8;
5d5d0015 4927
84eaa187
MC		 4928 rx_space = SKB_DATA_ALIGN(rx_size + BNX2_RX_ALIGN) + NET_SKB_PAD +
4929 sizeof(struct skb_shared_info);
4930
601d3d18 4931 bp->rx_copy_thresh = BNX2_RX_COPY_THRESH;
47bf4246
MC		 4932 bp->rx_pg_ring_size = 0;
4933 bp->rx_max_pg_ring = 0;
4934 bp->rx_max_pg_ring_idx = 0;
f86e82fb 4935 if ((rx_space > PAGE_SIZE) && !(bp->flags & BNX2_FLAG_JUMBO_BROKEN)) {
84eaa187
MC		 4936 int pages = PAGE_ALIGN(bp->dev->mtu - 40) >> PAGE_SHIFT;
4937
4938 jumbo_size = size * pages;
4939 if (jumbo_size > MAX_TOTAL_RX_PG_DESC_CNT)
4940 jumbo_size = MAX_TOTAL_RX_PG_DESC_CNT;
4941
4942 bp->rx_pg_ring_size = jumbo_size;
4943 bp->rx_max_pg_ring = bnx2_find_max_ring(jumbo_size,
4944 MAX_RX_PG_RINGS);
4945 bp->rx_max_pg_ring_idx = (bp->rx_max_pg_ring * RX_DESC_CNT) - 1;
601d3d18 4946 rx_size = BNX2_RX_COPY_THRESH + BNX2_RX_OFFSET;
84eaa187
MC		 4947 bp->rx_copy_thresh = 0;
4948 }
5d5d0015
MC		 4949
4950 bp->rx_buf_use_size = rx_size;
4951 /* hw alignment */
4952 bp->rx_buf_size = bp->rx_buf_use_size + BNX2_RX_ALIGN;
d89cb6af 4953 bp->rx_jumbo_thresh = rx_size - BNX2_RX_OFFSET;
5d5d0015
MC		 4954 bp->rx_ring_size = size;
4955 bp->rx_max_ring = bnx2_find_max_ring(size, MAX_RX_RINGS);
13daffa2
MC		 4956 bp->rx_max_ring_idx = (bp->rx_max_ring * RX_DESC_CNT) - 1;
4957}
4958
b6016b76
MC		 4959static void
4960bnx2_free_tx_skbs(struct bnx2 *bp)
4961{
4962 int i;
4963
35e9010b
MC		 4964 for (i = 0; i < bp->num_tx_rings; i++) {
4965 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
4966 struct bnx2_tx_ring_info *txr = &bnapi->tx_ring;
4967 int j;
b6016b76 4968
35e9010b 4969 if (txr->tx_buf_ring == NULL)
b6016b76 4970 continue;
b6016b76 4971
35e9010b
MC		 4972 for (j = 0; j < TX_DESC_CNT; ) {
4973 struct sw_bd *tx_buf = &txr->tx_buf_ring[j];
4974 struct sk_buff *skb = tx_buf->skb;
4975 int k, last;
4976
4977 if (skb == NULL) {
4978 j++;
4979 continue;
4980 }
4981
4982 pci_unmap_single(bp->pdev,
4983 pci_unmap_addr(tx_buf, mapping),
b6016b76
MC		 4984 skb_headlen(skb), PCI_DMA_TODEVICE);
4985
35e9010b 4986 tx_buf->skb = NULL;
b6016b76 4987
35e9010b
MC		 4988 last = skb_shinfo(skb)->nr_frags;
4989 for (k = 0; k < last; k++) {
4990 tx_buf = &txr->tx_buf_ring[j + k + 1];
4991 pci_unmap_page(bp->pdev,
4992 pci_unmap_addr(tx_buf, mapping),
4993 skb_shinfo(skb)->frags[j].size,
4994 PCI_DMA_TODEVICE);
4995 }
4996 dev_kfree_skb(skb);
4997 j += k + 1;
b6016b76 4998 }
b6016b76 4999 }
b6016b76
MC		 5000}
5001
5002static void
5003bnx2_free_rx_skbs(struct bnx2 *bp)
5004{
5005 int i;
5006
bb4f98ab
MC		 5007 for (i = 0; i < bp->num_rx_rings; i++) {
5008 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
5009 struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
5010 int j;
b6016b76 5011
bb4f98ab
MC		 5012 if (rxr->rx_buf_ring == NULL)
5013 return;
b6016b76 5014
bb4f98ab
MC		 5015 for (j = 0; j < bp->rx_max_ring_idx; j++) {
5016 struct sw_bd *rx_buf = &rxr->rx_buf_ring[j];
5017 struct sk_buff *skb = rx_buf->skb;
b6016b76 5018
bb4f98ab
MC		 5019 if (skb == NULL)
5020 continue;
b6016b76 5021
bb4f98ab
MC		 5022 pci_unmap_single(bp->pdev,
5023 pci_unmap_addr(rx_buf, mapping),
5024 bp->rx_buf_use_size,
5025 PCI_DMA_FROMDEVICE);
b6016b76 5026
bb4f98ab
MC		 5027 rx_buf->skb = NULL;
5028
5029 dev_kfree_skb(skb);
5030 }
5031 for (j = 0; j < bp->rx_max_pg_ring_idx; j++)
5032 bnx2_free_rx_page(bp, rxr, j);
b6016b76
MC		 5033 }
5034}
5035
5036static void
5037bnx2_free_skbs(struct bnx2 *bp)
5038{
5039 bnx2_free_tx_skbs(bp);
5040 bnx2_free_rx_skbs(bp);
5041}
5042
5043static int
5044bnx2_reset_nic(struct bnx2 *bp, u32 reset_code)
5045{
5046 int rc;
5047
5048 rc = bnx2_reset_chip(bp, reset_code);
5049 bnx2_free_skbs(bp);
5050 if (rc)
5051 return rc;
5052
fba9fe91
MC		 5053 if ((rc = bnx2_init_chip(bp)) != 0)
5054 return rc;
5055
35e9010b 5056 bnx2_init_all_rings(bp);
b6016b76
MC		 5057 return 0;
5058}
5059
5060static int
9a120bc5 5061bnx2_init_nic(struct bnx2 *bp, int reset_phy)
b6016b76
MC		 5062{
5063 int rc;
5064
5065 if ((rc = bnx2_reset_nic(bp, BNX2_DRV_MSG_CODE_RESET)) != 0)
5066 return rc;
5067
80be4434 5068 spin_lock_bh(&bp->phy_lock);
9a120bc5 5069 bnx2_init_phy(bp, reset_phy);
b6016b76 5070 bnx2_set_link(bp);
543a827d
MC		 5071 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
5072 bnx2_remote_phy_event(bp);
0d8a6571 5073 spin_unlock_bh(&bp->phy_lock);
b6016b76
MC		 5074 return 0;
5075}
5076
5077static int
5078bnx2_test_registers(struct bnx2 *bp)
5079{
5080 int ret;
5bae30c9 5081 int i, is_5709;
f71e1309 5082 static const struct {
b6016b76
MC		 5083 u16 offset;
5084 u16 flags;
5bae30c9 5085#define BNX2_FL_NOT_5709 1
b6016b76
MC		 5086 u32 rw_mask;
5087 u32 ro_mask;
5088 } reg_tbl[] = {
5089 { 0x006c, 0, 0x00000000, 0x0000003f },
5090 { 0x0090, 0, 0xffffffff, 0x00000000 },
5091 { 0x0094, 0, 0x00000000, 0x00000000 },
5092
5bae30c9
MC		 5093 { 0x0404, BNX2_FL_NOT_5709, 0x00003f00, 0x00000000 },
5094 { 0x0418, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
5095 { 0x041c, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
5096 { 0x0420, BNX2_FL_NOT_5709, 0x00000000, 0x80ffffff },
5097 { 0x0424, BNX2_FL_NOT_5709, 0x00000000, 0x00000000 },
5098 { 0x0428, BNX2_FL_NOT_5709, 0x00000000, 0x00000001 },
5099 { 0x0450, BNX2_FL_NOT_5709, 0x00000000, 0x0000ffff },
5100 { 0x0454, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
5101 { 0x0458, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
5102
5103 { 0x0808, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
5104 { 0x0854, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
5105 { 0x0868, BNX2_FL_NOT_5709, 0x00000000, 0x77777777 },
5106 { 0x086c, BNX2_FL_NOT_5709, 0x00000000, 0x77777777 },
5107 { 0x0870, BNX2_FL_NOT_5709, 0x00000000, 0x77777777 },
5108 { 0x0874, BNX2_FL_NOT_5709, 0x00000000, 0x77777777 },
5109
5110 { 0x0c00, BNX2_FL_NOT_5709, 0x00000000, 0x00000001 },
5111 { 0x0c04, BNX2_FL_NOT_5709, 0x00000000, 0x03ff0001 },
5112 { 0x0c08, BNX2_FL_NOT_5709, 0x0f0ff073, 0x00000000 },
b6016b76
MC		 5113
5114 { 0x1000, 0, 0x00000000, 0x00000001 },
15b169cc 5115 { 0x1004, BNX2_FL_NOT_5709, 0x00000000, 0x000f0001 },
b6016b76
MC		 5116
5117 { 0x1408, 0, 0x01c00800, 0x00000000 },
5118 { 0x149c, 0, 0x8000ffff, 0x00000000 },
5119 { 0x14a8, 0, 0x00000000, 0x000001ff },
5b0c76ad 5120 { 0x14ac, 0, 0x0fffffff, 0x10000000 },
b6016b76
MC		 5121 { 0x14b0, 0, 0x00000002, 0x00000001 },
5122 { 0x14b8, 0, 0x00000000, 0x00000000 },
5123 { 0x14c0, 0, 0x00000000, 0x00000009 },
5124 { 0x14c4, 0, 0x00003fff, 0x00000000 },
5125 { 0x14cc, 0, 0x00000000, 0x00000001 },
5126 { 0x14d0, 0, 0xffffffff, 0x00000000 },
b6016b76
MC		 5127
5128 { 0x1800, 0, 0x00000000, 0x00000001 },
5129 { 0x1804, 0, 0x00000000, 0x00000003 },
b6016b76
MC		 5130
5131 { 0x2800, 0, 0x00000000, 0x00000001 },
5132 { 0x2804, 0, 0x00000000, 0x00003f01 },
5133 { 0x2808, 0, 0x0f3f3f03, 0x00000000 },
5134 { 0x2810, 0, 0xffff0000, 0x00000000 },
5135 { 0x2814, 0, 0xffff0000, 0x00000000 },
5136 { 0x2818, 0, 0xffff0000, 0x00000000 },
5137 { 0x281c, 0, 0xffff0000, 0x00000000 },
5138 { 0x2834, 0, 0xffffffff, 0x00000000 },
5139 { 0x2840, 0, 0x00000000, 0xffffffff },
5140 { 0x2844, 0, 0x00000000, 0xffffffff },
5141 { 0x2848, 0, 0xffffffff, 0x00000000 },
5142 { 0x284c, 0, 0xf800f800, 0x07ff07ff },
5143
5144 { 0x2c00, 0, 0x00000000, 0x00000011 },
5145 { 0x2c04, 0, 0x00000000, 0x00030007 },
5146
b6016b76
MC		 5147 { 0x3c00, 0, 0x00000000, 0x00000001 },
5148 { 0x3c04, 0, 0x00000000, 0x00070000 },
5149 { 0x3c08, 0, 0x00007f71, 0x07f00000 },
5150 { 0x3c0c, 0, 0x1f3ffffc, 0x00000000 },
5151 { 0x3c10, 0, 0xffffffff, 0x00000000 },
5152 { 0x3c14, 0, 0x00000000, 0xffffffff },
5153 { 0x3c18, 0, 0x00000000, 0xffffffff },
5154 { 0x3c1c, 0, 0xfffff000, 0x00000000 },
5155 { 0x3c20, 0, 0xffffff00, 0x00000000 },
b6016b76
MC		 5156
5157 { 0x5004, 0, 0x00000000, 0x0000007f },
5158 { 0x5008, 0, 0x0f0007ff, 0x00000000 },
b6016b76 5159
b6016b76
MC		 5160 { 0x5c00, 0, 0x00000000, 0x00000001 },
5161 { 0x5c04, 0, 0x00000000, 0x0003000f },
5162 { 0x5c08, 0, 0x00000003, 0x00000000 },
5163 { 0x5c0c, 0, 0x0000fff8, 0x00000000 },
5164 { 0x5c10, 0, 0x00000000, 0xffffffff },
5165 { 0x5c80, 0, 0x00000000, 0x0f7113f1 },
5166 { 0x5c84, 0, 0x00000000, 0x0000f333 },
5167 { 0x5c88, 0, 0x00000000, 0x00077373 },
5168 { 0x5c8c, 0, 0x00000000, 0x0007f737 },
5169
5170 { 0x6808, 0, 0x0000ff7f, 0x00000000 },
5171 { 0x680c, 0, 0xffffffff, 0x00000000 },
5172 { 0x6810, 0, 0xffffffff, 0x00000000 },
5173 { 0x6814, 0, 0xffffffff, 0x00000000 },
5174 { 0x6818, 0, 0xffffffff, 0x00000000 },
5175 { 0x681c, 0, 0xffffffff, 0x00000000 },
5176 { 0x6820, 0, 0x00ff00ff, 0x00000000 },
5177 { 0x6824, 0, 0x00ff00ff, 0x00000000 },
5178 { 0x6828, 0, 0x00ff00ff, 0x00000000 },
5179 { 0x682c, 0, 0x03ff03ff, 0x00000000 },
5180 { 0x6830, 0, 0x03ff03ff, 0x00000000 },
5181 { 0x6834, 0, 0x03ff03ff, 0x00000000 },
5182 { 0x6838, 0, 0x03ff03ff, 0x00000000 },
5183 { 0x683c, 0, 0x0000ffff, 0x00000000 },
5184 { 0x6840, 0, 0x00000ff0, 0x00000000 },
5185 { 0x6844, 0, 0x00ffff00, 0x00000000 },
5186 { 0x684c, 0, 0xffffffff, 0x00000000 },
5187 { 0x6850, 0, 0x7f7f7f7f, 0x00000000 },
5188 { 0x6854, 0, 0x7f7f7f7f, 0x00000000 },
5189 { 0x6858, 0, 0x7f7f7f7f, 0x00000000 },
5190 { 0x685c, 0, 0x7f7f7f7f, 0x00000000 },
5191 { 0x6908, 0, 0x00000000, 0x0001ff0f },
5192 { 0x690c, 0, 0x00000000, 0x0ffe00f0 },
5193
5194 { 0xffff, 0, 0x00000000, 0x00000000 },
5195 };
5196
5197 ret = 0;
5bae30c9
MC		 5198 is_5709 = 0;
5199 if (CHIP_NUM(bp) == CHIP_NUM_5709)
5200 is_5709 = 1;
5201
b6016b76
MC		 5202 for (i = 0; reg_tbl[i].offset != 0xffff; i++) {
5203 u32 offset, rw_mask, ro_mask, save_val, val;
5bae30c9
MC		 5204 u16 flags = reg_tbl[i].flags;
5205
5206 if (is_5709 && (flags & BNX2_FL_NOT_5709))
5207 continue;
b6016b76
MC		 5208
5209 offset = (u32) reg_tbl[i].offset;
5210 rw_mask = reg_tbl[i].rw_mask;
5211 ro_mask = reg_tbl[i].ro_mask;
5212
14ab9b86 5213 save_val = readl(bp->regview + offset);
b6016b76 5214
14ab9b86 5215 writel(0, bp->regview + offset);
b6016b76 5216
14ab9b86 5217 val = readl(bp->regview + offset);
b6016b76
MC		 5218 if ((val & rw_mask) != 0) {
5219 goto reg_test_err;
5220 }
5221
5222 if ((val & ro_mask) != (save_val & ro_mask)) {
5223 goto reg_test_err;
5224 }
5225
14ab9b86 5226 writel(0xffffffff, bp->regview + offset);
b6016b76 5227
14ab9b86 5228 val = readl(bp->regview + offset);
b6016b76
MC		 5229 if ((val & rw_mask) != rw_mask) {
5230 goto reg_test_err;
5231 }
5232
5233 if ((val & ro_mask) != (save_val & ro_mask)) {
5234 goto reg_test_err;
5235 }
5236
14ab9b86 5237 writel(save_val, bp->regview + offset);
b6016b76
MC		 5238 continue;
5239
5240reg_test_err:
14ab9b86 5241 writel(save_val, bp->regview + offset);
b6016b76
MC		 5242 ret = -ENODEV;
5243 break;
5244 }
5245 return ret;
5246}
5247
5248static int
5249bnx2_do_mem_test(struct bnx2 *bp, u32 start, u32 size)
5250{
f71e1309 5251 static const u32 test_pattern[] = { 0x00000000, 0xffffffff, 0x55555555,
b6016b76
MC		 5252 0xaaaaaaaa , 0xaa55aa55, 0x55aa55aa };
5253 int i;
5254
5255 for (i = 0; i < sizeof(test_pattern) / 4; i++) {
5256 u32 offset;
5257
5258 for (offset = 0; offset < size; offset += 4) {
5259
2726d6e1 5260 bnx2_reg_wr_ind(bp, start + offset, test_pattern[i]);
b6016b76 5261
2726d6e1 5262 if (bnx2_reg_rd_ind(bp, start + offset) !=
b6016b76
MC		 5263 test_pattern[i]) {
5264 return -ENODEV;
5265 }
5266 }
5267 }
5268 return 0;
5269}
5270
5271static int
5272bnx2_test_memory(struct bnx2 *bp)
5273{
5274 int ret = 0;
5275 int i;
5bae30c9 5276 static struct mem_entry {
b6016b76
MC		 5277 u32 offset;
5278 u32 len;
5bae30c9 5279 } mem_tbl_5706[] = {
b6016b76 5280 { 0x60000, 0x4000 },
5b0c76ad 5281 { 0xa0000, 0x3000 },
b6016b76
MC		 5282 { 0xe0000, 0x4000 },
5283 { 0x120000, 0x4000 },
5284 { 0x1a0000, 0x4000 },
5285 { 0x160000, 0x4000 },
5286 { 0xffffffff, 0 },
5bae30c9
MC		 5287 },
5288 mem_tbl_5709[] = {
5289 { 0x60000, 0x4000 },
5290 { 0xa0000, 0x3000 },
5291 { 0xe0000, 0x4000 },
5292 { 0x120000, 0x4000 },
5293 { 0x1a0000, 0x4000 },
5294 { 0xffffffff, 0 },
b6016b76 5295 };
5bae30c9
MC		 5296 struct mem_entry *mem_tbl;
5297
5298 if (CHIP_NUM(bp) == CHIP_NUM_5709)
5299 mem_tbl = mem_tbl_5709;
5300 else
5301 mem_tbl = mem_tbl_5706;
b6016b76
MC		 5302
5303 for (i = 0; mem_tbl[i].offset != 0xffffffff; i++) {
5304 if ((ret = bnx2_do_mem_test(bp, mem_tbl[i].offset,
5305 mem_tbl[i].len)) != 0) {
5306 return ret;
5307 }
5308 }
6aa20a22 5309
b6016b76
MC		 5310 return ret;
5311}
5312
bc5a0690
MC		 5313#define BNX2_MAC_LOOPBACK 0
5314#define BNX2_PHY_LOOPBACK 1
5315
b6016b76 5316static int
bc5a0690 5317bnx2_run_loopback(struct bnx2 *bp, int loopback_mode)
b6016b76
MC		 5318{
5319 unsigned int pkt_size, num_pkts, i;
5320 struct sk_buff *skb, *rx_skb;
5321 unsigned char *packet;
bc5a0690 5322 u16 rx_start_idx, rx_idx;
b6016b76
MC		 5323 dma_addr_t map;
5324 struct tx_bd *txbd;
5325 struct sw_bd *rx_buf;
5326 struct l2_fhdr *rx_hdr;
5327 int ret = -ENODEV;
c76c0475 5328 struct bnx2_napi *bnapi = &bp->bnx2_napi[0], *tx_napi;
35e9010b 5329 struct bnx2_tx_ring_info *txr = &bnapi->tx_ring;
bb4f98ab 5330 struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
c76c0475
MC		 5331
5332 tx_napi = bnapi;
b6016b76 5333
35e9010b 5334 txr = &tx_napi->tx_ring;
bb4f98ab 5335 rxr = &bnapi->rx_ring;
bc5a0690
MC		 5336 if (loopback_mode == BNX2_MAC_LOOPBACK) {
5337 bp->loopback = MAC_LOOPBACK;
5338 bnx2_set_mac_loopback(bp);
5339 }
5340 else if (loopback_mode == BNX2_PHY_LOOPBACK) {
583c28e5 5341 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
489310a4
MC		 5342 return 0;
5343
80be4434 5344 bp->loopback = PHY_LOOPBACK;
bc5a0690
MC		 5345 bnx2_set_phy_loopback(bp);
5346 }
5347 else
5348 return -EINVAL;
b6016b76 5349
84eaa187 5350 pkt_size = min(bp->dev->mtu + ETH_HLEN, bp->rx_jumbo_thresh - 4);
932f3772 5351 skb = netdev_alloc_skb(bp->dev, pkt_size);
b6cbc3b6
JL		 5352 if (!skb)
5353 return -ENOMEM;
b6016b76 5354 packet = skb_put(skb, pkt_size);
6634292b 5355 memcpy(packet, bp->dev->dev_addr, 6);
b6016b76
MC		 5356 memset(packet + 6, 0x0, 8);
5357 for (i = 14; i < pkt_size; i++)
5358 packet[i] = (unsigned char) (i & 0xff);
5359
5360 map = pci_map_single(bp->pdev, skb->data, pkt_size,
5361 PCI_DMA_TODEVICE);
5362
bf5295bb
MC		 5363 REG_WR(bp, BNX2_HC_COMMAND,
5364 bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
5365
b6016b76
MC		 5366 REG_RD(bp, BNX2_HC_COMMAND);
5367
5368 udelay(5);
35efa7c1 5369 rx_start_idx = bnx2_get_hw_rx_cons(bnapi);
b6016b76 5370
b6016b76
MC		 5371 num_pkts = 0;
5372
35e9010b 5373 txbd = &txr->tx_desc_ring[TX_RING_IDX(txr->tx_prod)];
b6016b76
MC		 5374
5375 txbd->tx_bd_haddr_hi = (u64) map >> 32;
5376 txbd->tx_bd_haddr_lo = (u64) map & 0xffffffff;
5377 txbd->tx_bd_mss_nbytes = pkt_size;
5378 txbd->tx_bd_vlan_tag_flags = TX_BD_FLAGS_START | TX_BD_FLAGS_END;
5379
5380 num_pkts++;
35e9010b
MC		 5381 txr->tx_prod = NEXT_TX_BD(txr->tx_prod);
5382 txr->tx_prod_bseq += pkt_size;
b6016b76 5383
35e9010b
MC		 5384 REG_WR16(bp, txr->tx_bidx_addr, txr->tx_prod);
5385 REG_WR(bp, txr->tx_bseq_addr, txr->tx_prod_bseq);
b6016b76
MC		 5386
5387 udelay(100);
5388
bf5295bb
MC		 5389 REG_WR(bp, BNX2_HC_COMMAND,
5390 bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
5391
b6016b76
MC		 5392 REG_RD(bp, BNX2_HC_COMMAND);
5393
5394 udelay(5);
5395
5396 pci_unmap_single(bp->pdev, map, pkt_size, PCI_DMA_TODEVICE);
745720e5 5397 dev_kfree_skb(skb);
b6016b76 5398
35e9010b 5399 if (bnx2_get_hw_tx_cons(tx_napi) != txr->tx_prod)
b6016b76 5400 goto loopback_test_done;
b6016b76 5401
35efa7c1 5402 rx_idx = bnx2_get_hw_rx_cons(bnapi);
b6016b76
MC		 5403 if (rx_idx != rx_start_idx + num_pkts) {
5404 goto loopback_test_done;
5405 }
5406
bb4f98ab 5407 rx_buf = &rxr->rx_buf_ring[rx_start_idx];
b6016b76
MC		 5408 rx_skb = rx_buf->skb;
5409
5410 rx_hdr = (struct l2_fhdr *) rx_skb->data;
d89cb6af 5411 skb_reserve(rx_skb, BNX2_RX_OFFSET);
b6016b76
MC		 5412
5413 pci_dma_sync_single_for_cpu(bp->pdev,
5414 pci_unmap_addr(rx_buf, mapping),
5415 bp->rx_buf_size, PCI_DMA_FROMDEVICE);
5416
ade2bfe7 5417 if (rx_hdr->l2_fhdr_status &
b6016b76
MC		 5418 (L2_FHDR_ERRORS_BAD_CRC |
5419 L2_FHDR_ERRORS_PHY_DECODE |
5420 L2_FHDR_ERRORS_ALIGNMENT |
5421 L2_FHDR_ERRORS_TOO_SHORT |
5422 L2_FHDR_ERRORS_GIANT_FRAME)) {
5423
5424 goto loopback_test_done;
5425 }
5426
5427 if ((rx_hdr->l2_fhdr_pkt_len - 4) != pkt_size) {
5428 goto loopback_test_done;
5429 }
5430
5431 for (i = 14; i < pkt_size; i++) {
5432 if (*(rx_skb->data + i) != (unsigned char) (i & 0xff)) {
5433 goto loopback_test_done;
5434 }
5435 }
5436
5437 ret = 0;
5438
5439loopback_test_done:
5440 bp->loopback = 0;
5441 return ret;
5442}
5443
bc5a0690
MC		 5444#define BNX2_MAC_LOOPBACK_FAILED 1
5445#define BNX2_PHY_LOOPBACK_FAILED 2
5446#define BNX2_LOOPBACK_FAILED (BNX2_MAC_LOOPBACK_FAILED | \
5447 BNX2_PHY_LOOPBACK_FAILED)
5448
5449static int
5450bnx2_test_loopback(struct bnx2 *bp)
5451{
5452 int rc = 0;
5453
5454 if (!netif_running(bp->dev))
5455 return BNX2_LOOPBACK_FAILED;
5456
5457 bnx2_reset_nic(bp, BNX2_DRV_MSG_CODE_RESET);
5458 spin_lock_bh(&bp->phy_lock);
9a120bc5 5459 bnx2_init_phy(bp, 1);
bc5a0690
MC		 5460 spin_unlock_bh(&bp->phy_lock);
5461 if (bnx2_run_loopback(bp, BNX2_MAC_LOOPBACK))
5462 rc |= BNX2_MAC_LOOPBACK_FAILED;
5463 if (bnx2_run_loopback(bp, BNX2_PHY_LOOPBACK))
5464 rc |= BNX2_PHY_LOOPBACK_FAILED;
5465 return rc;
5466}
5467
b6016b76
MC		 5468#define NVRAM_SIZE 0x200
5469#define CRC32_RESIDUAL 0xdebb20e3
5470
5471static int
5472bnx2_test_nvram(struct bnx2 *bp)
5473{
b491edd5 5474 __be32 buf[NVRAM_SIZE / 4];
b6016b76
MC		 5475 u8 *data = (u8 *) buf;
5476 int rc = 0;
5477 u32 magic, csum;
5478
5479 if ((rc = bnx2_nvram_read(bp, 0, data, 4)) != 0)
5480 goto test_nvram_done;
5481
5482 magic = be32_to_cpu(buf[0]);
5483 if (magic != 0x669955aa) {
5484 rc = -ENODEV;
5485 goto test_nvram_done;
5486 }
5487
5488 if ((rc = bnx2_nvram_read(bp, 0x100, data, NVRAM_SIZE)) != 0)
5489 goto test_nvram_done;
5490
5491 csum = ether_crc_le(0x100, data);
5492 if (csum != CRC32_RESIDUAL) {
5493 rc = -ENODEV;
5494 goto test_nvram_done;
5495 }
5496
5497 csum = ether_crc_le(0x100, data + 0x100);
5498 if (csum != CRC32_RESIDUAL) {
5499 rc = -ENODEV;
5500 }
5501
5502test_nvram_done:
5503 return rc;
5504}
5505
5506static int
5507bnx2_test_link(struct bnx2 *bp)
5508{
5509 u32 bmsr;
5510
583c28e5 5511 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) {
489310a4
MC		 5512 if (bp->link_up)
5513 return 0;
5514 return -ENODEV;
5515 }
c770a65c 5516 spin_lock_bh(&bp->phy_lock);
27a005b8
MC		 5517 bnx2_enable_bmsr1(bp);
5518 bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
5519 bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
5520 bnx2_disable_bmsr1(bp);
c770a65c 5521 spin_unlock_bh(&bp->phy_lock);
6aa20a22 5522
b6016b76
MC		 5523 if (bmsr & BMSR_LSTATUS) {
5524 return 0;
5525 }
5526 return -ENODEV;
5527}
5528
5529static int
5530bnx2_test_intr(struct bnx2 *bp)
5531{
5532 int i;
b6016b76
MC		 5533 u16 status_idx;
5534
5535 if (!netif_running(bp->dev))
5536 return -ENODEV;
5537
5538 status_idx = REG_RD(bp, BNX2_PCICFG_INT_ACK_CMD) & 0xffff;
5539
5540 /* This register is not touched during run-time. */
bf5295bb 5541 REG_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW);
b6016b76
MC		 5542 REG_RD(bp, BNX2_HC_COMMAND);
5543
5544 for (i = 0; i < 10; i++) {
5545 if ((REG_RD(bp, BNX2_PCICFG_INT_ACK_CMD) & 0xffff) !=
5546 status_idx) {
5547
5548 break;
5549 }
5550
5551 msleep_interruptible(10);
5552 }
5553 if (i < 10)
5554 return 0;
5555
5556 return -ENODEV;
5557}
5558
38ea3686 5559/* Determining link for parallel detection. */
b2fadeae
MC		 5560static int
5561bnx2_5706_serdes_has_link(struct bnx2 *bp)
5562{
5563 u32 mode_ctl, an_dbg, exp;
5564
38ea3686
MC		 5565 if (bp->phy_flags & BNX2_PHY_FLAG_NO_PARALLEL)
5566 return 0;
5567
b2fadeae
MC		 5568 bnx2_write_phy(bp, MII_BNX2_MISC_SHADOW, MISC_SHDW_MODE_CTL);
5569 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &mode_ctl);
5570
5571 if (!(mode_ctl & MISC_SHDW_MODE_CTL_SIG_DET))
5572 return 0;
5573
5574 bnx2_write_phy(bp, MII_BNX2_MISC_SHADOW, MISC_SHDW_AN_DBG);
5575 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &an_dbg);
5576 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &an_dbg);
5577
f3014c0c 5578 if (an_dbg & (MISC_SHDW_AN_DBG_NOSYNC | MISC_SHDW_AN_DBG_RUDI_INVALID))
b2fadeae
MC		 5579 return 0;
5580
5581 bnx2_write_phy(bp, MII_BNX2_DSP_ADDRESS, MII_EXPAND_REG1);
5582 bnx2_read_phy(bp, MII_BNX2_DSP_RW_PORT, &exp);
5583 bnx2_read_phy(bp, MII_BNX2_DSP_RW_PORT, &exp);
5584
5585 if (exp & MII_EXPAND_REG1_RUDI_C) /* receiving CONFIG */
5586 return 0;
5587
5588 return 1;
5589}
5590
b6016b76 5591static void
48b01e2d 5592bnx2_5706_serdes_timer(struct bnx2 *bp)
b6016b76 5593{
b2fadeae
MC		 5594 int check_link = 1;
5595
48b01e2d 5596 spin_lock(&bp->phy_lock);
b2fadeae 5597 if (bp->serdes_an_pending) {
48b01e2d 5598 bp->serdes_an_pending--;
b2fadeae
MC		 5599 check_link = 0;
5600 } else if ((bp->link_up == 0) && (bp->autoneg & AUTONEG_SPEED)) {
48b01e2d 5601 u32 bmcr;
b6016b76 5602
48b01e2d 5603 bp->current_interval = bp->timer_interval;
cd339a0e 5604
ca58c3af 5605 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
b6016b76 5606
48b01e2d 5607 if (bmcr & BMCR_ANENABLE) {
b2fadeae 5608 if (bnx2_5706_serdes_has_link(bp)) {
48b01e2d
MC		 5609 bmcr &= ~BMCR_ANENABLE;
5610 bmcr |= BMCR_SPEED1000 | BMCR_FULLDPLX;
ca58c3af 5611 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
583c28e5 5612 bp->phy_flags |= BNX2_PHY_FLAG_PARALLEL_DETECT;
48b01e2d 5613 }
b6016b76 5614 }
48b01e2d
MC		 5615 }
5616 else if ((bp->link_up) && (bp->autoneg & AUTONEG_SPEED) &&
583c28e5 5617 (bp->phy_flags & BNX2_PHY_FLAG_PARALLEL_DETECT)) {
48b01e2d 5618 u32 phy2;
b6016b76 5619
48b01e2d
MC		 5620 bnx2_write_phy(bp, 0x17, 0x0f01);
5621 bnx2_read_phy(bp, 0x15, &phy2);
5622 if (phy2 & 0x20) {
5623 u32 bmcr;
cd339a0e 5624
ca58c3af 5625 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
48b01e2d 5626 bmcr |= BMCR_ANENABLE;
ca58c3af 5627 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
b6016b76 5628
583c28e5 5629 bp->phy_flags &= ~BNX2_PHY_FLAG_PARALLEL_DETECT;
48b01e2d
MC		 5630 }
5631 } else
5632 bp->current_interval = bp->timer_interval;
b6016b76 5633
a2724e25 5634 if (check_link) {
b2fadeae
MC		 5635 u32 val;
5636
5637 bnx2_write_phy(bp, MII_BNX2_MISC_SHADOW, MISC_SHDW_AN_DBG);
5638 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &val);
5639 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &val);
5640
a2724e25
MC		 5641 if (bp->link_up && (val & MISC_SHDW_AN_DBG_NOSYNC)) {
5642 if (!(bp->phy_flags & BNX2_PHY_FLAG_FORCED_DOWN)) {
5643 bnx2_5706s_force_link_dn(bp, 1);
5644 bp->phy_flags |= BNX2_PHY_FLAG_FORCED_DOWN;
5645 } else
5646 bnx2_set_link(bp);
5647 } else if (!bp->link_up && !(val & MISC_SHDW_AN_DBG_NOSYNC))
5648 bnx2_set_link(bp);
b2fadeae 5649 }
48b01e2d
MC		 5650 spin_unlock(&bp->phy_lock);
5651}
b6016b76 5652
f8dd064e
MC		 5653static void
5654bnx2_5708_serdes_timer(struct bnx2 *bp)
5655{
583c28e5 5656 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
0d8a6571
MC		 5657 return;
5658
583c28e5 5659 if ((bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE) == 0) {
f8dd064e
MC		 5660 bp->serdes_an_pending = 0;
5661 return;
5662 }
b6016b76 5663
f8dd064e
MC		 5664 spin_lock(&bp->phy_lock);
5665 if (bp->serdes_an_pending)
5666 bp->serdes_an_pending--;
5667 else if ((bp->link_up == 0) && (bp->autoneg & AUTONEG_SPEED)) {
5668 u32 bmcr;
b6016b76 5669
ca58c3af 5670 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
f8dd064e 5671 if (bmcr & BMCR_ANENABLE) {
605a9e20 5672 bnx2_enable_forced_2g5(bp);
f8dd064e
MC		 5673 bp->current_interval = SERDES_FORCED_TIMEOUT;
5674 } else {
605a9e20 5675 bnx2_disable_forced_2g5(bp);
f8dd064e
MC		 5676 bp->serdes_an_pending = 2;
5677 bp->current_interval = bp->timer_interval;
b6016b76 5678 }
b6016b76 5679
f8dd064e
MC		 5680 } else
5681 bp->current_interval = bp->timer_interval;
b6016b76 5682
f8dd064e
MC		 5683 spin_unlock(&bp->phy_lock);
5684}
5685
48b01e2d
MC		 5686static void
5687bnx2_timer(unsigned long data)
5688{
5689 struct bnx2 *bp = (struct bnx2 *) data;
b6016b76 5690
48b01e2d
MC		 5691 if (!netif_running(bp->dev))
5692 return;
b6016b76 5693
48b01e2d
MC		 5694 if (atomic_read(&bp->intr_sem) != 0)
5695 goto bnx2_restart_timer;
b6016b76 5696
df149d70 5697 bnx2_send_heart_beat(bp);
b6016b76 5698
2726d6e1
MC		 5699 bp->stats_blk->stat_FwRxDrop =
5700 bnx2_reg_rd_ind(bp, BNX2_FW_RX_DROP_COUNT);
b6016b76 5701
02537b06
MC		 5702 /* workaround occasional corrupted counters */
5703 if (CHIP_NUM(bp) == CHIP_NUM_5708 && bp->stats_ticks)
5704 REG_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd |
5705 BNX2_HC_COMMAND_STATS_NOW);
5706
583c28e5 5707 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
f8dd064e
MC		 5708 if (CHIP_NUM(bp) == CHIP_NUM_5706)
5709 bnx2_5706_serdes_timer(bp);
27a005b8 5710 else
f8dd064e 5711 bnx2_5708_serdes_timer(bp);
b6016b76
MC		 5712 }
5713
5714bnx2_restart_timer:
cd339a0e 5715 mod_timer(&bp->timer, jiffies + bp->current_interval);
b6016b76
MC		 5716}
5717
8e6a72c4
MC		 5718static int
5719bnx2_request_irq(struct bnx2 *bp)
5720{
6d866ffc 5721 unsigned long flags;
b4b36042
MC		 5722 struct bnx2_irq *irq;
5723 int rc = 0, i;
8e6a72c4 5724
f86e82fb 5725 if (bp->flags & BNX2_FLAG_USING_MSI_OR_MSIX)
6d866ffc
MC		 5726 flags = 0;
5727 else
5728 flags = IRQF_SHARED;
b4b36042
MC		 5729
5730 for (i = 0; i < bp->irq_nvecs; i++) {
5731 irq = &bp->irq_tbl[i];
c76c0475 5732 rc = request_irq(irq->vector, irq->handler, flags, irq->name,
f0ea2e63 5733 &bp->bnx2_napi[i]);
b4b36042
MC		 5734 if (rc)
5735 break;
5736 irq->requested = 1;
5737 }
8e6a72c4
MC		 5738 return rc;
5739}
5740
5741static void
5742bnx2_free_irq(struct bnx2 *bp)
5743{
b4b36042
MC		 5744 struct bnx2_irq *irq;
5745 int i;
8e6a72c4 5746
b4b36042
MC		 5747 for (i = 0; i < bp->irq_nvecs; i++) {
5748 irq = &bp->irq_tbl[i];
5749 if (irq->requested)
f0ea2e63 5750 free_irq(irq->vector, &bp->bnx2_napi[i]);
b4b36042 5751 irq->requested = 0;
6d866ffc 5752 }
f86e82fb 5753 if (bp->flags & BNX2_FLAG_USING_MSI)
b4b36042 5754 pci_disable_msi(bp->pdev);
f86e82fb 5755 else if (bp->flags & BNX2_FLAG_USING_MSIX)
b4b36042
MC		 5756 pci_disable_msix(bp->pdev);
5757
f86e82fb 5758 bp->flags &= ~(BNX2_FLAG_USING_MSI_OR_MSIX | BNX2_FLAG_ONE_SHOT_MSI);
b4b36042
MC		 5759}
5760
5761static void
5e9ad9e1 5762bnx2_enable_msix(struct bnx2 *bp, int msix_vecs)
b4b36042 5763{
57851d84
MC		 5764 int i, rc;
5765 struct msix_entry msix_ent[BNX2_MAX_MSIX_VEC];
5766
b4b36042
MC		 5767 bnx2_setup_msix_tbl(bp);
5768 REG_WR(bp, BNX2_PCI_MSIX_CONTROL, BNX2_MAX_MSIX_HW_VEC - 1);
5769 REG_WR(bp, BNX2_PCI_MSIX_TBL_OFF_BIR, BNX2_PCI_GRC_WINDOW2_BASE);
5770 REG_WR(bp, BNX2_PCI_MSIX_PBA_OFF_BIT, BNX2_PCI_GRC_WINDOW3_BASE);
57851d84
MC		 5771
5772 for (i = 0; i < BNX2_MAX_MSIX_VEC; i++) {
5773 msix_ent[i].entry = i;
5774 msix_ent[i].vector = 0;
35e9010b
MC		 5775
5776 strcpy(bp->irq_tbl[i].name, bp->dev->name);
f0ea2e63 5777 bp->irq_tbl[i].handler = bnx2_msi_1shot;
57851d84
MC		 5778 }
5779
5780 rc = pci_enable_msix(bp->pdev, msix_ent, BNX2_MAX_MSIX_VEC);
5781 if (rc != 0)
5782 return;
5783
5e9ad9e1 5784 bp->irq_nvecs = msix_vecs;
f86e82fb 5785 bp->flags |= BNX2_FLAG_USING_MSIX | BNX2_FLAG_ONE_SHOT_MSI;
57851d84
MC		 5786 for (i = 0; i < BNX2_MAX_MSIX_VEC; i++)
5787 bp->irq_tbl[i].vector = msix_ent[i].vector;
6d866ffc
MC		 5788}
5789
5790static void
5791bnx2_setup_int_mode(struct bnx2 *bp, int dis_msi)
5792{
5e9ad9e1 5793 int cpus = num_online_cpus();
706bf240 5794 int msix_vecs = min(cpus + 1, RX_MAX_RINGS);
5e9ad9e1 5795
6d866ffc
MC		 5796 bp->irq_tbl[0].handler = bnx2_interrupt;
5797 strcpy(bp->irq_tbl[0].name, bp->dev->name);
b4b36042
MC		 5798 bp->irq_nvecs = 1;
5799 bp->irq_tbl[0].vector = bp->pdev->irq;
5800
5e9ad9e1
MC		 5801 if ((bp->flags & BNX2_FLAG_MSIX_CAP) && !dis_msi && cpus > 1)
5802 bnx2_enable_msix(bp, msix_vecs);
6d866ffc 5803
f86e82fb
DM		 5804 if ((bp->flags & BNX2_FLAG_MSI_CAP) && !dis_msi &&
5805 !(bp->flags & BNX2_FLAG_USING_MSIX)) {
6d866ffc 5806 if (pci_enable_msi(bp->pdev) == 0) {
f86e82fb 5807 bp->flags |= BNX2_FLAG_USING_MSI;
6d866ffc 5808 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
f86e82fb 5809 bp->flags |= BNX2_FLAG_ONE_SHOT_MSI;
6d866ffc
MC		 5810 bp->irq_tbl[0].handler = bnx2_msi_1shot;
5811 } else
5812 bp->irq_tbl[0].handler = bnx2_msi;
b4b36042
MC		 5813
5814 bp->irq_tbl[0].vector = bp->pdev->irq;
6d866ffc
MC		 5815 }
5816 }
706bf240
BL		 5817
5818 bp->num_tx_rings = rounddown_pow_of_two(bp->irq_nvecs);
5819 bp->dev->real_num_tx_queues = bp->num_tx_rings;
5820
5e9ad9e1 5821 bp->num_rx_rings = bp->irq_nvecs;
8e6a72c4
MC		 5822}
5823
b6016b76
MC		 5824/* Called with rtnl_lock */
5825static int
5826bnx2_open(struct net_device *dev)
5827{
972ec0d4 5828 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 5829 int rc;
5830
1b2f922f
MC		 5831 netif_carrier_off(dev);
5832
829ca9a3 5833 bnx2_set_power_state(bp, PCI_D0);
b6016b76
MC		 5834 bnx2_disable_int(bp);
5835
35e9010b
MC		 5836 bnx2_setup_int_mode(bp, disable_msi);
5837 bnx2_napi_enable(bp);
b6016b76 5838 rc = bnx2_alloc_mem(bp);
2739a8bb
MC		 5839 if (rc)
5840 goto open_err;
b6016b76 5841
8e6a72c4 5842 rc = bnx2_request_irq(bp);
2739a8bb
MC		 5843 if (rc)
5844 goto open_err;
b6016b76 5845
9a120bc5 5846 rc = bnx2_init_nic(bp, 1);
2739a8bb
MC		 5847 if (rc)
5848 goto open_err;
6aa20a22 5849
cd339a0e 5850 mod_timer(&bp->timer, jiffies + bp->current_interval);
b6016b76
MC		 5851
5852 atomic_set(&bp->intr_sem, 0);
5853
5854 bnx2_enable_int(bp);
5855
f86e82fb 5856 if (bp->flags & BNX2_FLAG_USING_MSI) {
b6016b76
MC		 5857 /* Test MSI to make sure it is working
5858 * If MSI test fails, go back to INTx mode
5859 */
5860 if (bnx2_test_intr(bp) != 0) {
5861 printk(KERN_WARNING PFX "%s: No interrupt was generated"
5862 " using MSI, switching to INTx mode. Please"
5863 " report this failure to the PCI maintainer"
5864 " and include system chipset information.\n",
5865 bp->dev->name);
5866
5867 bnx2_disable_int(bp);
8e6a72c4 5868 bnx2_free_irq(bp);
b6016b76 5869
6d866ffc
MC		 5870 bnx2_setup_int_mode(bp, 1);
5871
9a120bc5 5872 rc = bnx2_init_nic(bp, 0);
b6016b76 5873
8e6a72c4
MC		 5874 if (!rc)
5875 rc = bnx2_request_irq(bp);
5876
b6016b76 5877 if (rc) {
b6016b76 5878 del_timer_sync(&bp->timer);
2739a8bb 5879 goto open_err;
b6016b76
MC		 5880 }
5881 bnx2_enable_int(bp);
5882 }
5883 }
f86e82fb 5884 if (bp->flags & BNX2_FLAG_USING_MSI)
b6016b76 5885 printk(KERN_INFO PFX "%s: using MSI\n", dev->name);
f86e82fb 5886 else if (bp->flags & BNX2_FLAG_USING_MSIX)
57851d84 5887 printk(KERN_INFO PFX "%s: using MSIX\n", dev->name);
b6016b76 5888
706bf240 5889 netif_tx_start_all_queues(dev);
b6016b76
MC		 5890
5891 return 0;
2739a8bb
MC		 5892
5893open_err:
5894 bnx2_napi_disable(bp);
5895 bnx2_free_skbs(bp);
5896 bnx2_free_irq(bp);
5897 bnx2_free_mem(bp);
5898 return rc;
b6016b76
MC		 5899}
5900
5901static void
c4028958 5902bnx2_reset_task(struct work_struct *work)
b6016b76 5903{
c4028958 5904 struct bnx2 *bp = container_of(work, struct bnx2, reset_task);
b6016b76 5905
afdc08b9
MC		 5906 if (!netif_running(bp->dev))
5907 return;
5908
b6016b76
MC		 5909 bnx2_netif_stop(bp);
5910
9a120bc5 5911 bnx2_init_nic(bp, 1);
b6016b76
MC		 5912
5913 atomic_set(&bp->intr_sem, 1);
5914 bnx2_netif_start(bp);
5915}
5916
5917static void
5918bnx2_tx_timeout(struct net_device *dev)
5919{
972ec0d4 5920 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 5921
5922 /* This allows the netif to be shutdown gracefully before resetting */
5923 schedule_work(&bp->reset_task);
5924}
5925
5926#ifdef BCM_VLAN
5927/* Called with rtnl_lock */
5928static void
5929bnx2_vlan_rx_register(struct net_device *dev, struct vlan_group *vlgrp)
5930{
972ec0d4 5931 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 5932
5933 bnx2_netif_stop(bp);
5934
5935 bp->vlgrp = vlgrp;
5936 bnx2_set_rx_mode(dev);
7c62e83b
MC		 5937 if (bp->flags & BNX2_FLAG_CAN_KEEP_VLAN)
5938 bnx2_fw_sync(bp, BNX2_DRV_MSG_CODE_KEEP_VLAN_UPDATE, 0, 1);
b6016b76
MC		 5939
5940 bnx2_netif_start(bp);
5941}
b6016b76
MC		 5942#endif
5943
932ff279 5944/* Called with netif_tx_lock.
2f8af120
MC		 5945 * bnx2_tx_int() runs without netif_tx_lock unless it needs to call
5946 * netif_wake_queue().
b6016b76
MC		 5947 */
5948static int
5949bnx2_start_xmit(struct sk_buff *skb, struct net_device *dev)
5950{
972ec0d4 5951 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 5952 dma_addr_t mapping;
5953 struct tx_bd *txbd;
5954 struct sw_bd *tx_buf;
5955 u32 len, vlan_tag_flags, last_frag, mss;
5956 u16 prod, ring_prod;
5957 int i;
706bf240
BL		 5958 struct bnx2_napi *bnapi;
5959 struct bnx2_tx_ring_info *txr;
5960 struct netdev_queue *txq;
5961
5962 /* Determine which tx ring we will be placed on */
5963 i = skb_get_queue_mapping(skb);
5964 bnapi = &bp->bnx2_napi[i];
5965 txr = &bnapi->tx_ring;
5966 txq = netdev_get_tx_queue(dev, i);
b6016b76 5967
35e9010b 5968 if (unlikely(bnx2_tx_avail(bp, txr) <
a550c99b 5969 (skb_shinfo(skb)->nr_frags + 1))) {
706bf240 5970 netif_tx_stop_queue(txq);
b6016b76
MC		 5971 printk(KERN_ERR PFX "%s: BUG! Tx ring full when queue awake!\n",
5972 dev->name);
5973
5974 return NETDEV_TX_BUSY;
5975 }
5976 len = skb_headlen(skb);
35e9010b 5977 prod = txr->tx_prod;
b6016b76
MC		 5978 ring_prod = TX_RING_IDX(prod);
5979
5980 vlan_tag_flags = 0;
84fa7933 5981 if (skb->ip_summed == CHECKSUM_PARTIAL) {
b6016b76
MC		 5982 vlan_tag_flags |= TX_BD_FLAGS_TCP_UDP_CKSUM;
5983 }
5984
729b85cd 5985#ifdef BCM_VLAN
79ea13ce 5986 if (bp->vlgrp && vlan_tx_tag_present(skb)) {
b6016b76
MC		 5987 vlan_tag_flags |=
5988 (TX_BD_FLAGS_VLAN_TAG | (vlan_tx_tag_get(skb) << 16));
5989 }
729b85cd 5990#endif
fde82055 5991 if ((mss = skb_shinfo(skb)->gso_size)) {
b6016b76 5992 u32 tcp_opt_len, ip_tcp_len;
eddc9ec5 5993 struct iphdr *iph;
b6016b76 5994
b6016b76
MC		 5995 vlan_tag_flags |= TX_BD_FLAGS_SW_LSO;
5996
4666f87a
MC		 5997 tcp_opt_len = tcp_optlen(skb);
5998
5999 if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6) {
6000 u32 tcp_off = skb_transport_offset(skb) -
6001 sizeof(struct ipv6hdr) - ETH_HLEN;
ab6a5bb6 6002
4666f87a
MC		 6003 vlan_tag_flags |= ((tcp_opt_len >> 2) << 8) |
6004 TX_BD_FLAGS_SW_FLAGS;
6005 if (likely(tcp_off == 0))
6006 vlan_tag_flags &= ~TX_BD_FLAGS_TCP6_OFF0_MSK;
6007 else {
6008 tcp_off >>= 3;
6009 vlan_tag_flags |= ((tcp_off & 0x3) <<
6010 TX_BD_FLAGS_TCP6_OFF0_SHL) |
6011 ((tcp_off & 0x10) <<
6012 TX_BD_FLAGS_TCP6_OFF4_SHL);
6013 mss |= (tcp_off & 0xc) << TX_BD_TCP6_OFF2_SHL;
6014 }
6015 } else {
6016 if (skb_header_cloned(skb) &&
6017 pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) {
6018 dev_kfree_skb(skb);
6019 return NETDEV_TX_OK;
6020 }
b6016b76 6021
4666f87a
MC		 6022 ip_tcp_len = ip_hdrlen(skb) + sizeof(struct tcphdr);
6023
6024 iph = ip_hdr(skb);
6025 iph->check = 0;
6026 iph->tot_len = htons(mss + ip_tcp_len + tcp_opt_len);
6027 tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
6028 iph->daddr, 0,
6029 IPPROTO_TCP,
6030 0);
6031 if (tcp_opt_len || (iph->ihl > 5)) {
6032 vlan_tag_flags |= ((iph->ihl - 5) +
6033 (tcp_opt_len >> 2)) << 8;
6034 }
b6016b76 6035 }
4666f87a 6036 } else
b6016b76 6037 mss = 0;
b6016b76
MC		 6038
6039 mapping = pci_map_single(bp->pdev, skb->data, len, PCI_DMA_TODEVICE);
6aa20a22 6040
35e9010b 6041 tx_buf = &txr->tx_buf_ring[ring_prod];
b6016b76
MC		 6042 tx_buf->skb = skb;
6043 pci_unmap_addr_set(tx_buf, mapping, mapping);
6044
35e9010b 6045 txbd = &txr->tx_desc_ring[ring_prod];
b6016b76
MC		 6046
6047 txbd->tx_bd_haddr_hi = (u64) mapping >> 32;
6048 txbd->tx_bd_haddr_lo = (u64) mapping & 0xffffffff;
6049 txbd->tx_bd_mss_nbytes = len | (mss << 16);
6050 txbd->tx_bd_vlan_tag_flags = vlan_tag_flags | TX_BD_FLAGS_START;
6051
6052 last_frag = skb_shinfo(skb)->nr_frags;
6053
6054 for (i = 0; i < last_frag; i++) {
6055 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
6056
6057 prod = NEXT_TX_BD(prod);
6058 ring_prod = TX_RING_IDX(prod);
35e9010b 6059 txbd = &txr->tx_desc_ring[ring_prod];
b6016b76
MC		 6060
6061 len = frag->size;
6062 mapping = pci_map_page(bp->pdev, frag->page, frag->page_offset,
6063 len, PCI_DMA_TODEVICE);
35e9010b 6064 pci_unmap_addr_set(&txr->tx_buf_ring[ring_prod],
b6016b76
MC		 6065 mapping, mapping);
6066
6067 txbd->tx_bd_haddr_hi = (u64) mapping >> 32;
6068 txbd->tx_bd_haddr_lo = (u64) mapping & 0xffffffff;
6069 txbd->tx_bd_mss_nbytes = len | (mss << 16);
6070 txbd->tx_bd_vlan_tag_flags = vlan_tag_flags;
6071
6072 }
6073 txbd->tx_bd_vlan_tag_flags |= TX_BD_FLAGS_END;
6074
6075 prod = NEXT_TX_BD(prod);
35e9010b 6076 txr->tx_prod_bseq += skb->len;
b6016b76 6077
35e9010b
MC		 6078 REG_WR16(bp, txr->tx_bidx_addr, prod);
6079 REG_WR(bp, txr->tx_bseq_addr, txr->tx_prod_bseq);
b6016b76
MC		 6080
6081 mmiowb();
6082
35e9010b 6083 txr->tx_prod = prod;
b6016b76
MC		 6084 dev->trans_start = jiffies;
6085
35e9010b 6086 if (unlikely(bnx2_tx_avail(bp, txr) <= MAX_SKB_FRAGS)) {
706bf240 6087 netif_tx_stop_queue(txq);
35e9010b 6088 if (bnx2_tx_avail(bp, txr) > bp->tx_wake_thresh)
706bf240 6089 netif_tx_wake_queue(txq);
b6016b76
MC		 6090 }
6091
6092 return NETDEV_TX_OK;
6093}
6094
6095/* Called with rtnl_lock */
6096static int
6097bnx2_close(struct net_device *dev)
6098{
972ec0d4 6099 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6100 u32 reset_code;
6101
4bb073c0 6102 cancel_work_sync(&bp->reset_task);
afdc08b9 6103
bea3348e 6104 bnx2_disable_int_sync(bp);
35efa7c1 6105 bnx2_napi_disable(bp);
b6016b76 6106 del_timer_sync(&bp->timer);
f86e82fb 6107 if (bp->flags & BNX2_FLAG_NO_WOL)
6c4f095e 6108 reset_code = BNX2_DRV_MSG_CODE_UNLOAD_LNK_DN;
dda1e390 6109 else if (bp->wol)
b6016b76
MC		 6110 reset_code = BNX2_DRV_MSG_CODE_SUSPEND_WOL;
6111 else
6112 reset_code = BNX2_DRV_MSG_CODE_SUSPEND_NO_WOL;
6113 bnx2_reset_chip(bp, reset_code);
8e6a72c4 6114 bnx2_free_irq(bp);
b6016b76
MC		 6115 bnx2_free_skbs(bp);
6116 bnx2_free_mem(bp);
6117 bp->link_up = 0;
6118 netif_carrier_off(bp->dev);
829ca9a3 6119 bnx2_set_power_state(bp, PCI_D3hot);
b6016b76
MC		 6120 return 0;
6121}
6122
6123#define GET_NET_STATS64(ctr) \
6124 (unsigned long) ((unsigned long) (ctr##_hi) << 32) + \
6125 (unsigned long) (ctr##_lo)
6126
6127#define GET_NET_STATS32(ctr) \
6128 (ctr##_lo)
6129
6130#if (BITS_PER_LONG == 64)
6131#define GET_NET_STATS GET_NET_STATS64
6132#else
6133#define GET_NET_STATS GET_NET_STATS32
6134#endif
6135
6136static struct net_device_stats *
6137bnx2_get_stats(struct net_device *dev)
6138{
972ec0d4 6139 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6140 struct statistics_block *stats_blk = bp->stats_blk;
6141 struct net_device_stats *net_stats = &bp->net_stats;
6142
6143 if (bp->stats_blk == NULL) {
6144 return net_stats;
6145 }
6146 net_stats->rx_packets =
6147 GET_NET_STATS(stats_blk->stat_IfHCInUcastPkts) +
6148 GET_NET_STATS(stats_blk->stat_IfHCInMulticastPkts) +
6149 GET_NET_STATS(stats_blk->stat_IfHCInBroadcastPkts);
6150
6151 net_stats->tx_packets =
6152 GET_NET_STATS(stats_blk->stat_IfHCOutUcastPkts) +
6153 GET_NET_STATS(stats_blk->stat_IfHCOutMulticastPkts) +
6154 GET_NET_STATS(stats_blk->stat_IfHCOutBroadcastPkts);
6155
6156 net_stats->rx_bytes =
6157 GET_NET_STATS(stats_blk->stat_IfHCInOctets);
6158
6159 net_stats->tx_bytes =
6160 GET_NET_STATS(stats_blk->stat_IfHCOutOctets);
6161
6aa20a22 6162 net_stats->multicast =
b6016b76
MC		 6163 GET_NET_STATS(stats_blk->stat_IfHCOutMulticastPkts);
6164
6aa20a22 6165 net_stats->collisions =
b6016b76
MC		 6166 (unsigned long) stats_blk->stat_EtherStatsCollisions;
6167
6aa20a22 6168 net_stats->rx_length_errors =
b6016b76
MC		 6169 (unsigned long) (stats_blk->stat_EtherStatsUndersizePkts +
6170 stats_blk->stat_EtherStatsOverrsizePkts);
6171
6aa20a22 6172 net_stats->rx_over_errors =
b6016b76
MC		 6173 (unsigned long) stats_blk->stat_IfInMBUFDiscards;
6174
6aa20a22 6175 net_stats->rx_frame_errors =
b6016b76
MC		 6176 (unsigned long) stats_blk->stat_Dot3StatsAlignmentErrors;
6177
6aa20a22 6178 net_stats->rx_crc_errors =
b6016b76
MC		 6179 (unsigned long) stats_blk->stat_Dot3StatsFCSErrors;
6180
6181 net_stats->rx_errors = net_stats->rx_length_errors +
6182 net_stats->rx_over_errors + net_stats->rx_frame_errors +
6183 net_stats->rx_crc_errors;
6184
6185 net_stats->tx_aborted_errors =
6186 (unsigned long) (stats_blk->stat_Dot3StatsExcessiveCollisions +
6187 stats_blk->stat_Dot3StatsLateCollisions);
6188
5b0c76ad
MC		 6189 if ((CHIP_NUM(bp) == CHIP_NUM_5706) ||
6190 (CHIP_ID(bp) == CHIP_ID_5708_A0))
b6016b76
MC		 6191 net_stats->tx_carrier_errors = 0;
6192 else {
6193 net_stats->tx_carrier_errors =
6194 (unsigned long)
6195 stats_blk->stat_Dot3StatsCarrierSenseErrors;
6196 }
6197
6198 net_stats->tx_errors =
6aa20a22 6199 (unsigned long)
b6016b76
MC		 6200 stats_blk->stat_emac_tx_stat_dot3statsinternalmactransmiterrors
6201 +
6202 net_stats->tx_aborted_errors +
6203 net_stats->tx_carrier_errors;
6204
cea94db9
MC		 6205 net_stats->rx_missed_errors =
6206 (unsigned long) (stats_blk->stat_IfInMBUFDiscards +
6207 stats_blk->stat_FwRxDrop);
6208
b6016b76
MC		 6209 return net_stats;
6210}
6211
6212/* All ethtool functions called with rtnl_lock */
6213
6214static int
6215bnx2_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
6216{
972ec0d4 6217 struct bnx2 *bp = netdev_priv(dev);
7b6b8347 6218 int support_serdes = 0, support_copper = 0;
b6016b76
MC		 6219
6220 cmd->supported = SUPPORTED_Autoneg;
583c28e5 6221 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) {
7b6b8347
MC		 6222 support_serdes = 1;
6223 support_copper = 1;
6224 } else if (bp->phy_port == PORT_FIBRE)
6225 support_serdes = 1;
6226 else
6227 support_copper = 1;
6228
6229 if (support_serdes) {
b6016b76
MC		 6230 cmd->supported |= SUPPORTED_1000baseT_Full |
6231 SUPPORTED_FIBRE;
583c28e5 6232 if (bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE)
605a9e20 6233 cmd->supported |= SUPPORTED_2500baseX_Full;
b6016b76 6234
b6016b76 6235 }
7b6b8347 6236 if (support_copper) {
b6016b76
MC		 6237 cmd->supported |= SUPPORTED_10baseT_Half |
6238 SUPPORTED_10baseT_Full |
6239 SUPPORTED_100baseT_Half |
6240 SUPPORTED_100baseT_Full |
6241 SUPPORTED_1000baseT_Full |
6242 SUPPORTED_TP;
6243
b6016b76
MC		 6244 }
6245
7b6b8347
MC		 6246 spin_lock_bh(&bp->phy_lock);
6247 cmd->port = bp->phy_port;
b6016b76
MC		 6248 cmd->advertising = bp->advertising;
6249
6250 if (bp->autoneg & AUTONEG_SPEED) {
6251 cmd->autoneg = AUTONEG_ENABLE;
6252 }
6253 else {
6254 cmd->autoneg = AUTONEG_DISABLE;
6255 }
6256
6257 if (netif_carrier_ok(dev)) {
6258 cmd->speed = bp->line_speed;
6259 cmd->duplex = bp->duplex;
6260 }
6261 else {
6262 cmd->speed = -1;
6263 cmd->duplex = -1;
6264 }
7b6b8347 6265 spin_unlock_bh(&bp->phy_lock);
b6016b76
MC		 6266
6267 cmd->transceiver = XCVR_INTERNAL;
6268 cmd->phy_address = bp->phy_addr;
6269
6270 return 0;
6271}
6aa20a22 6272
b6016b76
MC		 6273static int
6274bnx2_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
6275{
972ec0d4 6276 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6277 u8 autoneg = bp->autoneg;
6278 u8 req_duplex = bp->req_duplex;
6279 u16 req_line_speed = bp->req_line_speed;
6280 u32 advertising = bp->advertising;
7b6b8347
MC		 6281 int err = -EINVAL;
6282
6283 spin_lock_bh(&bp->phy_lock);
6284
6285 if (cmd->port != PORT_TP && cmd->port != PORT_FIBRE)
6286 goto err_out_unlock;
6287
583c28e5
MC		 6288 if (cmd->port != bp->phy_port &&
6289 !(bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP))
7b6b8347 6290 goto err_out_unlock;
b6016b76 6291
d6b14486
MC		 6292 /* If device is down, we can store the settings only if the user
6293 * is setting the currently active port.
6294 */
6295 if (!netif_running(dev) && cmd->port != bp->phy_port)
6296 goto err_out_unlock;
6297
b6016b76
MC		 6298 if (cmd->autoneg == AUTONEG_ENABLE) {
6299 autoneg |= AUTONEG_SPEED;
6300
6aa20a22 6301 cmd->advertising &= ETHTOOL_ALL_COPPER_SPEED;
b6016b76
MC		 6302
6303 /* allow advertising 1 speed */
6304 if ((cmd->advertising == ADVERTISED_10baseT_Half) ||
6305 (cmd->advertising == ADVERTISED_10baseT_Full) ||
6306 (cmd->advertising == ADVERTISED_100baseT_Half) ||
6307 (cmd->advertising == ADVERTISED_100baseT_Full)) {
6308
7b6b8347
MC		 6309 if (cmd->port == PORT_FIBRE)
6310 goto err_out_unlock;
b6016b76
MC		 6311
6312 advertising = cmd->advertising;
6313
27a005b8 6314 } else if (cmd->advertising == ADVERTISED_2500baseX_Full) {
583c28e5 6315 if (!(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE) ||
7b6b8347
MC		 6316 (cmd->port == PORT_TP))
6317 goto err_out_unlock;
6318 } else if (cmd->advertising == ADVERTISED_1000baseT_Full)
b6016b76 6319 advertising = cmd->advertising;
7b6b8347
MC		 6320 else if (cmd->advertising == ADVERTISED_1000baseT_Half)
6321 goto err_out_unlock;
b6016b76 6322 else {
7b6b8347 6323 if (cmd->port == PORT_FIBRE)
b6016b76 6324 advertising = ETHTOOL_ALL_FIBRE_SPEED;
7b6b8347 6325 else
b6016b76 6326 advertising = ETHTOOL_ALL_COPPER_SPEED;
b6016b76
MC		 6327 }
6328 advertising |= ADVERTISED_Autoneg;
6329 }
6330 else {
7b6b8347 6331 if (cmd->port == PORT_FIBRE) {
80be4434
MC		 6332 if ((cmd->speed != SPEED_1000 &&
6333 cmd->speed != SPEED_2500) ||
6334 (cmd->duplex != DUPLEX_FULL))
7b6b8347 6335 goto err_out_unlock;
80be4434
MC		 6336
6337 if (cmd->speed == SPEED_2500 &&
583c28e5 6338 !(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
7b6b8347 6339 goto err_out_unlock;
b6016b76 6340 }
7b6b8347
MC		 6341 else if (cmd->speed == SPEED_1000 || cmd->speed == SPEED_2500)
6342 goto err_out_unlock;
6343
b6016b76
MC		 6344 autoneg &= ~AUTONEG_SPEED;
6345 req_line_speed = cmd->speed;
6346 req_duplex = cmd->duplex;
6347 advertising = 0;
6348 }
6349
6350 bp->autoneg = autoneg;
6351 bp->advertising = advertising;
6352 bp->req_line_speed = req_line_speed;
6353 bp->req_duplex = req_duplex;
6354
d6b14486
MC		 6355 err = 0;
6356 /* If device is down, the new settings will be picked up when it is
6357 * brought up.
6358 */
6359 if (netif_running(dev))
6360 err = bnx2_setup_phy(bp, cmd->port);
b6016b76 6361
7b6b8347 6362err_out_unlock:
c770a65c 6363 spin_unlock_bh(&bp->phy_lock);
b6016b76 6364
7b6b8347 6365 return err;
b6016b76
MC		 6366}
6367
6368static void
6369bnx2_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
6370{
972ec0d4 6371 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6372
6373 strcpy(info->driver, DRV_MODULE_NAME);
6374 strcpy(info->version, DRV_MODULE_VERSION);
6375 strcpy(info->bus_info, pci_name(bp->pdev));
58fc2ea4 6376 strcpy(info->fw_version, bp->fw_version);
b6016b76
MC		 6377}
6378
244ac4f4
MC		 6379#define BNX2_REGDUMP_LEN (32 * 1024)
6380
6381static int
6382bnx2_get_regs_len(struct net_device *dev)
6383{
6384 return BNX2_REGDUMP_LEN;
6385}
6386
6387static void
6388bnx2_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
6389{
6390 u32 *p = _p, i, offset;
6391 u8 *orig_p = _p;
6392 struct bnx2 *bp = netdev_priv(dev);
6393 u32 reg_boundaries[] = { 0x0000, 0x0098, 0x0400, 0x045c,
6394 0x0800, 0x0880, 0x0c00, 0x0c10,
6395 0x0c30, 0x0d08, 0x1000, 0x101c,
6396 0x1040, 0x1048, 0x1080, 0x10a4,
6397 0x1400, 0x1490, 0x1498, 0x14f0,
6398 0x1500, 0x155c, 0x1580, 0x15dc,
6399 0x1600, 0x1658, 0x1680, 0x16d8,
6400 0x1800, 0x1820, 0x1840, 0x1854,
6401 0x1880, 0x1894, 0x1900, 0x1984,
6402 0x1c00, 0x1c0c, 0x1c40, 0x1c54,
6403 0x1c80, 0x1c94, 0x1d00, 0x1d84,
6404 0x2000, 0x2030, 0x23c0, 0x2400,
6405 0x2800, 0x2820, 0x2830, 0x2850,
6406 0x2b40, 0x2c10, 0x2fc0, 0x3058,
6407 0x3c00, 0x3c94, 0x4000, 0x4010,
6408 0x4080, 0x4090, 0x43c0, 0x4458,
6409 0x4c00, 0x4c18, 0x4c40, 0x4c54,
6410 0x4fc0, 0x5010, 0x53c0, 0x5444,
6411 0x5c00, 0x5c18, 0x5c80, 0x5c90,
6412 0x5fc0, 0x6000, 0x6400, 0x6428,
6413 0x6800, 0x6848, 0x684c, 0x6860,
6414 0x6888, 0x6910, 0x8000 };
6415
6416 regs->version = 0;
6417
6418 memset(p, 0, BNX2_REGDUMP_LEN);
6419
6420 if (!netif_running(bp->dev))
6421 return;
6422
6423 i = 0;
6424 offset = reg_boundaries[0];
6425 p += offset;
6426 while (offset < BNX2_REGDUMP_LEN) {
6427 *p++ = REG_RD(bp, offset);
6428 offset += 4;
6429 if (offset == reg_boundaries[i + 1]) {
6430 offset = reg_boundaries[i + 2];
6431 p = (u32 *) (orig_p + offset);
6432 i += 2;
6433 }
6434 }
6435}
6436
b6016b76
MC		 6437static void
6438bnx2_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
6439{
972ec0d4 6440 struct bnx2 *bp = netdev_priv(dev);
b6016b76 6441
f86e82fb 6442 if (bp->flags & BNX2_FLAG_NO_WOL) {
b6016b76
MC		 6443 wol->supported = 0;
6444 wol->wolopts = 0;
6445 }
6446 else {
6447 wol->supported = WAKE_MAGIC;
6448 if (bp->wol)
6449 wol->wolopts = WAKE_MAGIC;
6450 else
6451 wol->wolopts = 0;
6452 }
6453 memset(&wol->sopass, 0, sizeof(wol->sopass));
6454}
6455
6456static int
6457bnx2_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
6458{
972ec0d4 6459 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6460
6461 if (wol->wolopts & ~WAKE_MAGIC)
6462 return -EINVAL;
6463
6464 if (wol->wolopts & WAKE_MAGIC) {
f86e82fb 6465 if (bp->flags & BNX2_FLAG_NO_WOL)
b6016b76
MC		 6466 return -EINVAL;
6467
6468 bp->wol = 1;
6469 }
6470 else {
6471 bp->wol = 0;
6472 }
6473 return 0;
6474}
6475
6476static int
6477bnx2_nway_reset(struct net_device *dev)
6478{
972ec0d4 6479 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6480 u32 bmcr;
6481
6482 if (!(bp->autoneg & AUTONEG_SPEED)) {
6483 return -EINVAL;
6484 }
6485
c770a65c 6486 spin_lock_bh(&bp->phy_lock);
b6016b76 6487
583c28e5 6488 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) {
7b6b8347
MC		 6489 int rc;
6490
6491 rc = bnx2_setup_remote_phy(bp, bp->phy_port);
6492 spin_unlock_bh(&bp->phy_lock);
6493 return rc;
6494 }
6495
b6016b76 6496 /* Force a link down visible on the other side */
583c28e5 6497 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
ca58c3af 6498 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK);
c770a65c 6499 spin_unlock_bh(&bp->phy_lock);
b6016b76
MC		 6500
6501 msleep(20);
6502
c770a65c 6503 spin_lock_bh(&bp->phy_lock);
f8dd064e
MC		 6504
6505 bp->current_interval = SERDES_AN_TIMEOUT;
6506 bp->serdes_an_pending = 1;
6507 mod_timer(&bp->timer, jiffies + bp->current_interval);
b6016b76
MC		 6508 }
6509
ca58c3af 6510 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
b6016b76 6511 bmcr &= ~BMCR_LOOPBACK;
ca58c3af 6512 bnx2_write_phy(bp, bp->mii_bmcr, bmcr | BMCR_ANRESTART | BMCR_ANENABLE);
b6016b76 6513
c770a65c 6514 spin_unlock_bh(&bp->phy_lock);
b6016b76
MC		 6515
6516 return 0;
6517}
6518
6519static int
6520bnx2_get_eeprom_len(struct net_device *dev)
6521{
972ec0d4 6522 struct bnx2 *bp = netdev_priv(dev);
b6016b76 6523
1122db71 6524 if (bp->flash_info == NULL)
b6016b76
MC		 6525 return 0;
6526
1122db71 6527 return (int) bp->flash_size;
b6016b76
MC		 6528}
6529
6530static int
6531bnx2_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
6532 u8 *eebuf)
6533{
972ec0d4 6534 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6535 int rc;
6536
1064e944 6537 /* parameters already validated in ethtool_get_eeprom */
b6016b76
MC		 6538
6539 rc = bnx2_nvram_read(bp, eeprom->offset, eebuf, eeprom->len);
6540
6541 return rc;
6542}
6543
6544static int
6545bnx2_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
6546 u8 *eebuf)
6547{
972ec0d4 6548 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6549 int rc;
6550
1064e944 6551 /* parameters already validated in ethtool_set_eeprom */
b6016b76
MC		 6552
6553 rc = bnx2_nvram_write(bp, eeprom->offset, eebuf, eeprom->len);
6554
6555 return rc;
6556}
6557
6558static int
6559bnx2_get_coalesce(struct net_device *dev, struct ethtool_coalesce *coal)
6560{
972ec0d4 6561 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6562
6563 memset(coal, 0, sizeof(struct ethtool_coalesce));
6564
6565 coal->rx_coalesce_usecs = bp->rx_ticks;
6566 coal->rx_max_coalesced_frames = bp->rx_quick_cons_trip;
6567 coal->rx_coalesce_usecs_irq = bp->rx_ticks_int;
6568 coal->rx_max_coalesced_frames_irq = bp->rx_quick_cons_trip_int;
6569
6570 coal->tx_coalesce_usecs = bp->tx_ticks;
6571 coal->tx_max_coalesced_frames = bp->tx_quick_cons_trip;
6572 coal->tx_coalesce_usecs_irq = bp->tx_ticks_int;
6573 coal->tx_max_coalesced_frames_irq = bp->tx_quick_cons_trip_int;
6574
6575 coal->stats_block_coalesce_usecs = bp->stats_ticks;
6576
6577 return 0;
6578}
6579
6580static int
6581bnx2_set_coalesce(struct net_device *dev, struct ethtool_coalesce *coal)
6582{
972ec0d4 6583 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6584
6585 bp->rx_ticks = (u16) coal->rx_coalesce_usecs;
6586 if (bp->rx_ticks > 0x3ff) bp->rx_ticks = 0x3ff;
6587
6aa20a22 6588 bp->rx_quick_cons_trip = (u16) coal->rx_max_coalesced_frames;
b6016b76
MC		 6589 if (bp->rx_quick_cons_trip > 0xff) bp->rx_quick_cons_trip = 0xff;
6590
6591 bp->rx_ticks_int = (u16) coal->rx_coalesce_usecs_irq;
6592 if (bp->rx_ticks_int > 0x3ff) bp->rx_ticks_int = 0x3ff;
6593
6594 bp->rx_quick_cons_trip_int = (u16) coal->rx_max_coalesced_frames_irq;
6595 if (bp->rx_quick_cons_trip_int > 0xff)
6596 bp->rx_quick_cons_trip_int = 0xff;
6597
6598 bp->tx_ticks = (u16) coal->tx_coalesce_usecs;
6599 if (bp->tx_ticks > 0x3ff) bp->tx_ticks = 0x3ff;
6600
6601 bp->tx_quick_cons_trip = (u16) coal->tx_max_coalesced_frames;
6602 if (bp->tx_quick_cons_trip > 0xff) bp->tx_quick_cons_trip = 0xff;
6603
6604 bp->tx_ticks_int = (u16) coal->tx_coalesce_usecs_irq;
6605 if (bp->tx_ticks_int > 0x3ff) bp->tx_ticks_int = 0x3ff;
6606
6607 bp->tx_quick_cons_trip_int = (u16) coal->tx_max_coalesced_frames_irq;
6608 if (bp->tx_quick_cons_trip_int > 0xff) bp->tx_quick_cons_trip_int =
6609 0xff;
6610
6611 bp->stats_ticks = coal->stats_block_coalesce_usecs;
02537b06
MC		 6612 if (CHIP_NUM(bp) == CHIP_NUM_5708) {
6613 if (bp->stats_ticks != 0 && bp->stats_ticks != USEC_PER_SEC)
6614 bp->stats_ticks = USEC_PER_SEC;
6615 }
7ea6920e
MC		 6616 if (bp->stats_ticks > BNX2_HC_STATS_TICKS_HC_STAT_TICKS)
6617 bp->stats_ticks = BNX2_HC_STATS_TICKS_HC_STAT_TICKS;
6618 bp->stats_ticks &= BNX2_HC_STATS_TICKS_HC_STAT_TICKS;
b6016b76
MC		 6619
6620 if (netif_running(bp->dev)) {
6621 bnx2_netif_stop(bp);
9a120bc5 6622 bnx2_init_nic(bp, 0);
b6016b76
MC		 6623 bnx2_netif_start(bp);
6624 }
6625
6626 return 0;
6627}
6628
6629static void
6630bnx2_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
6631{
972ec0d4 6632 struct bnx2 *bp = netdev_priv(dev);
b6016b76 6633
13daffa2 6634 ering->rx_max_pending = MAX_TOTAL_RX_DESC_CNT;
b6016b76 6635 ering->rx_mini_max_pending = 0;
47bf4246 6636 ering->rx_jumbo_max_pending = MAX_TOTAL_RX_PG_DESC_CNT;
b6016b76
MC		 6637
6638 ering->rx_pending = bp->rx_ring_size;
6639 ering->rx_mini_pending = 0;
47bf4246 6640 ering->rx_jumbo_pending = bp->rx_pg_ring_size;
b6016b76
MC		 6641
6642 ering->tx_max_pending = MAX_TX_DESC_CNT;
6643 ering->tx_pending = bp->tx_ring_size;
6644}
6645
6646static int
5d5d0015 6647bnx2_change_ring_size(struct bnx2 *bp, u32 rx, u32 tx)
b6016b76 6648{
13daffa2
MC		 6649 if (netif_running(bp->dev)) {
6650 bnx2_netif_stop(bp);
6651 bnx2_reset_chip(bp, BNX2_DRV_MSG_CODE_RESET);
6652 bnx2_free_skbs(bp);
6653 bnx2_free_mem(bp);
6654 }
6655
5d5d0015
MC		 6656 bnx2_set_rx_ring_size(bp, rx);
6657 bp->tx_ring_size = tx;
b6016b76
MC		 6658
6659 if (netif_running(bp->dev)) {
13daffa2
MC		 6660 int rc;
6661
6662 rc = bnx2_alloc_mem(bp);
6663 if (rc)
6664 return rc;
9a120bc5 6665 bnx2_init_nic(bp, 0);
b6016b76
MC		 6666 bnx2_netif_start(bp);
6667 }
b6016b76
MC		 6668 return 0;
6669}
6670
5d5d0015
MC		 6671static int
6672bnx2_set_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
6673{
6674 struct bnx2 *bp = netdev_priv(dev);
6675 int rc;
6676
6677 if ((ering->rx_pending > MAX_TOTAL_RX_DESC_CNT) ||
6678 (ering->tx_pending > MAX_TX_DESC_CNT) ||
6679 (ering->tx_pending <= MAX_SKB_FRAGS)) {
6680
6681 return -EINVAL;
6682 }
6683 rc = bnx2_change_ring_size(bp, ering->rx_pending, ering->tx_pending);
6684 return rc;
6685}
6686
b6016b76
MC		 6687static void
6688bnx2_get_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
6689{
972ec0d4 6690 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6691
6692 epause->autoneg = ((bp->autoneg & AUTONEG_FLOW_CTRL) != 0);
6693 epause->rx_pause = ((bp->flow_ctrl & FLOW_CTRL_RX) != 0);
6694 epause->tx_pause = ((bp->flow_ctrl & FLOW_CTRL_TX) != 0);
6695}
6696
6697static int
6698bnx2_set_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
6699{
972ec0d4 6700 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6701
6702 bp->req_flow_ctrl = 0;
6703 if (epause->rx_pause)
6704 bp->req_flow_ctrl |= FLOW_CTRL_RX;
6705 if (epause->tx_pause)
6706 bp->req_flow_ctrl |= FLOW_CTRL_TX;
6707
6708 if (epause->autoneg) {
6709 bp->autoneg |= AUTONEG_FLOW_CTRL;
6710 }
6711 else {
6712 bp->autoneg &= ~AUTONEG_FLOW_CTRL;
6713 }
6714
c770a65c 6715 spin_lock_bh(&bp->phy_lock);
b6016b76 6716
0d8a6571 6717 bnx2_setup_phy(bp, bp->phy_port);
b6016b76 6718
c770a65c 6719 spin_unlock_bh(&bp->phy_lock);
b6016b76
MC		 6720
6721 return 0;
6722}
6723
6724static u32
6725bnx2_get_rx_csum(struct net_device *dev)
6726{
972ec0d4 6727 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6728
6729 return bp->rx_csum;
6730}
6731
6732static int
6733bnx2_set_rx_csum(struct net_device *dev, u32 data)
6734{
972ec0d4 6735 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6736
6737 bp->rx_csum = data;
6738 return 0;
6739}
6740
b11d6213
MC		 6741static int
6742bnx2_set_tso(struct net_device *dev, u32 data)
6743{
4666f87a
MC		 6744 struct bnx2 *bp = netdev_priv(dev);
6745
6746 if (data) {
b11d6213 6747 dev->features |= NETIF_F_TSO | NETIF_F_TSO_ECN;
4666f87a
MC		 6748 if (CHIP_NUM(bp) == CHIP_NUM_5709)
6749 dev->features |= NETIF_F_TSO6;
6750 } else
6751 dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6 |
6752 NETIF_F_TSO_ECN);
b11d6213
MC		 6753 return 0;
6754}
6755
cea94db9 6756#define BNX2_NUM_STATS 46
b6016b76 6757
14ab9b86 6758static struct {
b6016b76
MC		 6759 char string[ETH_GSTRING_LEN];
6760} bnx2_stats_str_arr[BNX2_NUM_STATS] = {
6761 { "rx_bytes" },
6762 { "rx_error_bytes" },
6763 { "tx_bytes" },
6764 { "tx_error_bytes" },
6765 { "rx_ucast_packets" },
6766 { "rx_mcast_packets" },
6767 { "rx_bcast_packets" },
6768 { "tx_ucast_packets" },
6769 { "tx_mcast_packets" },
6770 { "tx_bcast_packets" },
6771 { "tx_mac_errors" },
6772 { "tx_carrier_errors" },
6773 { "rx_crc_errors" },
6774 { "rx_align_errors" },
6775 { "tx_single_collisions" },
6776 { "tx_multi_collisions" },
6777 { "tx_deferred" },
6778 { "tx_excess_collisions" },
6779 { "tx_late_collisions" },
6780 { "tx_total_collisions" },
6781 { "rx_fragments" },
6782 { "rx_jabbers" },
6783 { "rx_undersize_packets" },
6784 { "rx_oversize_packets" },
6785 { "rx_64_byte_packets" },
6786 { "rx_65_to_127_byte_packets" },
6787 { "rx_128_to_255_byte_packets" },
6788 { "rx_256_to_511_byte_packets" },
6789 { "rx_512_to_1023_byte_packets" },
6790 { "rx_1024_to_1522_byte_packets" },
6791 { "rx_1523_to_9022_byte_packets" },
6792 { "tx_64_byte_packets" },
6793 { "tx_65_to_127_byte_packets" },
6794 { "tx_128_to_255_byte_packets" },
6795 { "tx_256_to_511_byte_packets" },
6796 { "tx_512_to_1023_byte_packets" },
6797 { "tx_1024_to_1522_byte_packets" },
6798 { "tx_1523_to_9022_byte_packets" },
6799 { "rx_xon_frames" },
6800 { "rx_xoff_frames" },
6801 { "tx_xon_frames" },
6802 { "tx_xoff_frames" },
6803 { "rx_mac_ctrl_frames" },
6804 { "rx_filtered_packets" },
6805 { "rx_discards" },
cea94db9 6806 { "rx_fw_discards" },
b6016b76
MC		 6807};
6808
6809#define STATS_OFFSET32(offset_name) (offsetof(struct statistics_block, offset_name) / 4)
6810
f71e1309 6811static const unsigned long bnx2_stats_offset_arr[BNX2_NUM_STATS] = {
b6016b76
MC		 6812 STATS_OFFSET32(stat_IfHCInOctets_hi),
6813 STATS_OFFSET32(stat_IfHCInBadOctets_hi),
6814 STATS_OFFSET32(stat_IfHCOutOctets_hi),
6815 STATS_OFFSET32(stat_IfHCOutBadOctets_hi),
6816 STATS_OFFSET32(stat_IfHCInUcastPkts_hi),
6817 STATS_OFFSET32(stat_IfHCInMulticastPkts_hi),
6818 STATS_OFFSET32(stat_IfHCInBroadcastPkts_hi),
6819 STATS_OFFSET32(stat_IfHCOutUcastPkts_hi),
6820 STATS_OFFSET32(stat_IfHCOutMulticastPkts_hi),
6821 STATS_OFFSET32(stat_IfHCOutBroadcastPkts_hi),
6822 STATS_OFFSET32(stat_emac_tx_stat_dot3statsinternalmactransmiterrors),
6aa20a22
JG		 6823 STATS_OFFSET32(stat_Dot3StatsCarrierSenseErrors),
6824 STATS_OFFSET32(stat_Dot3StatsFCSErrors),
6825 STATS_OFFSET32(stat_Dot3StatsAlignmentErrors),
6826 STATS_OFFSET32(stat_Dot3StatsSingleCollisionFrames),
6827 STATS_OFFSET32(stat_Dot3StatsMultipleCollisionFrames),
6828 STATS_OFFSET32(stat_Dot3StatsDeferredTransmissions),
6829 STATS_OFFSET32(stat_Dot3StatsExcessiveCollisions),
6830 STATS_OFFSET32(stat_Dot3StatsLateCollisions),
6831 STATS_OFFSET32(stat_EtherStatsCollisions),
6832 STATS_OFFSET32(stat_EtherStatsFragments),
6833 STATS_OFFSET32(stat_EtherStatsJabbers),
6834 STATS_OFFSET32(stat_EtherStatsUndersizePkts),
6835 STATS_OFFSET32(stat_EtherStatsOverrsizePkts),
6836 STATS_OFFSET32(stat_EtherStatsPktsRx64Octets),
6837 STATS_OFFSET32(stat_EtherStatsPktsRx65Octetsto127Octets),
6838 STATS_OFFSET32(stat_EtherStatsPktsRx128Octetsto255Octets),
6839 STATS_OFFSET32(stat_EtherStatsPktsRx256Octetsto511Octets),
6840 STATS_OFFSET32(stat_EtherStatsPktsRx512Octetsto1023Octets),
6841 STATS_OFFSET32(stat_EtherStatsPktsRx1024Octetsto1522Octets),
6842 STATS_OFFSET32(stat_EtherStatsPktsRx1523Octetsto9022Octets),
6843 STATS_OFFSET32(stat_EtherStatsPktsTx64Octets),
6844 STATS_OFFSET32(stat_EtherStatsPktsTx65Octetsto127Octets),
6845 STATS_OFFSET32(stat_EtherStatsPktsTx128Octetsto255Octets),
6846 STATS_OFFSET32(stat_EtherStatsPktsTx256Octetsto511Octets),
6847 STATS_OFFSET32(stat_EtherStatsPktsTx512Octetsto1023Octets),
6848 STATS_OFFSET32(stat_EtherStatsPktsTx1024Octetsto1522Octets),
6849 STATS_OFFSET32(stat_EtherStatsPktsTx1523Octetsto9022Octets),
6850 STATS_OFFSET32(stat_XonPauseFramesReceived),
6851 STATS_OFFSET32(stat_XoffPauseFramesReceived),
6852 STATS_OFFSET32(stat_OutXonSent),
6853 STATS_OFFSET32(stat_OutXoffSent),
6854 STATS_OFFSET32(stat_MacControlFramesReceived),
6855 STATS_OFFSET32(stat_IfInFramesL2FilterDiscards),
6856 STATS_OFFSET32(stat_IfInMBUFDiscards),
cea94db9 6857 STATS_OFFSET32(stat_FwRxDrop),
b6016b76
MC		 6858};
6859
6860/* stat_IfHCInBadOctets and stat_Dot3StatsCarrierSenseErrors are
6861 * skipped because of errata.
6aa20a22 6862 */
14ab9b86 6863static u8 bnx2_5706_stats_len_arr[BNX2_NUM_STATS] = {
b6016b76
MC		 6864 8,0,8,8,8,8,8,8,8,8,
6865 4,0,4,4,4,4,4,4,4,4,
6866 4,4,4,4,4,4,4,4,4,4,
6867 4,4,4,4,4,4,4,4,4,4,
cea94db9 6868 4,4,4,4,4,4,
b6016b76
MC		 6869};
6870
5b0c76ad
MC		 6871static u8 bnx2_5708_stats_len_arr[BNX2_NUM_STATS] = {
6872 8,0,8,8,8,8,8,8,8,8,
6873 4,4,4,4,4,4,4,4,4,4,
6874 4,4,4,4,4,4,4,4,4,4,
6875 4,4,4,4,4,4,4,4,4,4,
cea94db9 6876 4,4,4,4,4,4,
5b0c76ad
MC		 6877};
6878
b6016b76
MC		 6879#define BNX2_NUM_TESTS 6
6880
14ab9b86 6881static struct {
b6016b76
MC		 6882 char string[ETH_GSTRING_LEN];
6883} bnx2_tests_str_arr[BNX2_NUM_TESTS] = {
6884 { "register_test (offline)" },
6885 { "memory_test (offline)" },
6886 { "loopback_test (offline)" },
6887 { "nvram_test (online)" },
6888 { "interrupt_test (online)" },
6889 { "link_test (online)" },
6890};
6891
6892static int
b9f2c044 6893bnx2_get_sset_count(struct net_device *dev, int sset)
b6016b76 6894{
b9f2c044
JG		 6895 switch (sset) {
6896 case ETH_SS_TEST:
6897 return BNX2_NUM_TESTS;
6898 case ETH_SS_STATS:
6899 return BNX2_NUM_STATS;
6900 default:
6901 return -EOPNOTSUPP;
6902 }
b6016b76
MC		 6903}
6904
6905static void
6906bnx2_self_test(struct net_device *dev, struct ethtool_test *etest, u64 *buf)
6907{
972ec0d4 6908 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6909
6910 memset(buf, 0, sizeof(u64) * BNX2_NUM_TESTS);
6911 if (etest->flags & ETH_TEST_FL_OFFLINE) {
80be4434
MC		 6912 int i;
6913
b6016b76
MC		 6914 bnx2_netif_stop(bp);
6915 bnx2_reset_chip(bp, BNX2_DRV_MSG_CODE_DIAG);
6916 bnx2_free_skbs(bp);
6917
6918 if (bnx2_test_registers(bp) != 0) {
6919 buf[0] = 1;
6920 etest->flags |= ETH_TEST_FL_FAILED;
6921 }
6922 if (bnx2_test_memory(bp) != 0) {
6923 buf[1] = 1;
6924 etest->flags |= ETH_TEST_FL_FAILED;
6925 }
bc5a0690 6926 if ((buf[2] = bnx2_test_loopback(bp)) != 0)
b6016b76 6927 etest->flags |= ETH_TEST_FL_FAILED;
b6016b76
MC		 6928
6929 if (!netif_running(bp->dev)) {
6930 bnx2_reset_chip(bp, BNX2_DRV_MSG_CODE_RESET);
6931 }
6932 else {
9a120bc5 6933 bnx2_init_nic(bp, 1);
b6016b76
MC		 6934 bnx2_netif_start(bp);
6935 }
6936
6937 /* wait for link up */
80be4434
MC		 6938 for (i = 0; i < 7; i++) {
6939 if (bp->link_up)
6940 break;
6941 msleep_interruptible(1000);
6942 }
b6016b76
MC		 6943 }
6944
6945 if (bnx2_test_nvram(bp) != 0) {
6946 buf[3] = 1;
6947 etest->flags |= ETH_TEST_FL_FAILED;
6948 }
6949 if (bnx2_test_intr(bp) != 0) {
6950 buf[4] = 1;
6951 etest->flags |= ETH_TEST_FL_FAILED;
6952 }
6953
6954 if (bnx2_test_link(bp) != 0) {
6955 buf[5] = 1;
6956 etest->flags |= ETH_TEST_FL_FAILED;
6957
6958 }
6959}
6960
6961static void
6962bnx2_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
6963{
6964 switch (stringset) {
6965 case ETH_SS_STATS:
6966 memcpy(buf, bnx2_stats_str_arr,
6967 sizeof(bnx2_stats_str_arr));
6968 break;
6969 case ETH_SS_TEST:
6970 memcpy(buf, bnx2_tests_str_arr,
6971 sizeof(bnx2_tests_str_arr));
6972 break;
6973 }
6974}
6975
b6016b76
MC		 6976static void
6977bnx2_get_ethtool_stats(struct net_device *dev,
6978 struct ethtool_stats *stats, u64 *buf)
6979{
972ec0d4 6980 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 6981 int i;
6982 u32 *hw_stats = (u32 *) bp->stats_blk;
14ab9b86 6983 u8 *stats_len_arr = NULL;
b6016b76
MC		 6984
6985 if (hw_stats == NULL) {
6986 memset(buf, 0, sizeof(u64) * BNX2_NUM_STATS);
6987 return;
6988 }
6989
5b0c76ad
MC		 6990 if ((CHIP_ID(bp) == CHIP_ID_5706_A0) ||
6991 (CHIP_ID(bp) == CHIP_ID_5706_A1) ||
6992 (CHIP_ID(bp) == CHIP_ID_5706_A2) ||
6993 (CHIP_ID(bp) == CHIP_ID_5708_A0))
b6016b76 6994 stats_len_arr = bnx2_5706_stats_len_arr;
5b0c76ad
MC		 6995 else
6996 stats_len_arr = bnx2_5708_stats_len_arr;
b6016b76
MC		 6997
6998 for (i = 0; i < BNX2_NUM_STATS; i++) {
6999 if (stats_len_arr[i] == 0) {
7000 /* skip this counter */
7001 buf[i] = 0;
7002 continue;
7003 }
7004 if (stats_len_arr[i] == 4) {
7005 /* 4-byte counter */
7006 buf[i] = (u64)
7007 *(hw_stats + bnx2_stats_offset_arr[i]);
7008 continue;
7009 }
7010 /* 8-byte counter */
7011 buf[i] = (((u64) *(hw_stats +
7012 bnx2_stats_offset_arr[i])) << 32) +
7013 *(hw_stats + bnx2_stats_offset_arr[i] + 1);
7014 }
7015}
7016
7017static int
7018bnx2_phys_id(struct net_device *dev, u32 data)
7019{
972ec0d4 7020 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 7021 int i;
7022 u32 save;
7023
7024 if (data == 0)
7025 data = 2;
7026
7027 save = REG_RD(bp, BNX2_MISC_CFG);
7028 REG_WR(bp, BNX2_MISC_CFG, BNX2_MISC_CFG_LEDMODE_MAC);
7029
7030 for (i = 0; i < (data * 2); i++) {
7031 if ((i % 2) == 0) {
7032 REG_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE);
7033 }
7034 else {
7035 REG_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE |
7036 BNX2_EMAC_LED_1000MB_OVERRIDE |
7037 BNX2_EMAC_LED_100MB_OVERRIDE |
7038 BNX2_EMAC_LED_10MB_OVERRIDE |
7039 BNX2_EMAC_LED_TRAFFIC_OVERRIDE |
7040 BNX2_EMAC_LED_TRAFFIC);
7041 }
7042 msleep_interruptible(500);
7043 if (signal_pending(current))
7044 break;
7045 }
7046 REG_WR(bp, BNX2_EMAC_LED, 0);
7047 REG_WR(bp, BNX2_MISC_CFG, save);
7048 return 0;
7049}
7050
4666f87a
MC		 7051static int
7052bnx2_set_tx_csum(struct net_device *dev, u32 data)
7053{
7054 struct bnx2 *bp = netdev_priv(dev);
7055
7056 if (CHIP_NUM(bp) == CHIP_NUM_5709)
6460d948 7057 return (ethtool_op_set_tx_ipv6_csum(dev, data));
4666f87a
MC		 7058 else
7059 return (ethtool_op_set_tx_csum(dev, data));
7060}
7061
7282d491 7062static const struct ethtool_ops bnx2_ethtool_ops = {
b6016b76
MC		 7063 .get_settings = bnx2_get_settings,
7064 .set_settings = bnx2_set_settings,
7065 .get_drvinfo = bnx2_get_drvinfo,
244ac4f4
MC		 7066 .get_regs_len = bnx2_get_regs_len,
7067 .get_regs = bnx2_get_regs,
b6016b76
MC		 7068 .get_wol = bnx2_get_wol,
7069 .set_wol = bnx2_set_wol,
7070 .nway_reset = bnx2_nway_reset,
7071 .get_link = ethtool_op_get_link,
7072 .get_eeprom_len = bnx2_get_eeprom_len,
7073 .get_eeprom = bnx2_get_eeprom,
7074 .set_eeprom = bnx2_set_eeprom,
7075 .get_coalesce = bnx2_get_coalesce,
7076 .set_coalesce = bnx2_set_coalesce,
7077 .get_ringparam = bnx2_get_ringparam,
7078 .set_ringparam = bnx2_set_ringparam,
7079 .get_pauseparam = bnx2_get_pauseparam,
7080 .set_pauseparam = bnx2_set_pauseparam,
7081 .get_rx_csum = bnx2_get_rx_csum,
7082 .set_rx_csum = bnx2_set_rx_csum,
4666f87a 7083 .set_tx_csum = bnx2_set_tx_csum,
b6016b76 7084 .set_sg = ethtool_op_set_sg,
b11d6213 7085 .set_tso = bnx2_set_tso,
b6016b76
MC		 7086 .self_test = bnx2_self_test,
7087 .get_strings = bnx2_get_strings,
7088 .phys_id = bnx2_phys_id,
b6016b76 7089 .get_ethtool_stats = bnx2_get_ethtool_stats,
b9f2c044 7090 .get_sset_count = bnx2_get_sset_count,
b6016b76
MC		 7091};
7092
7093/* Called with rtnl_lock */
7094static int
7095bnx2_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
7096{
14ab9b86 7097 struct mii_ioctl_data *data = if_mii(ifr);
972ec0d4 7098 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 7099 int err;
7100
7101 switch(cmd) {
7102 case SIOCGMIIPHY:
7103 data->phy_id = bp->phy_addr;
7104
7105 /* fallthru */
7106 case SIOCGMIIREG: {
7107 u32 mii_regval;
7108
583c28e5 7109 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
7b6b8347
MC		 7110 return -EOPNOTSUPP;
7111
dad3e452
MC		 7112 if (!netif_running(dev))
7113 return -EAGAIN;
7114
c770a65c 7115 spin_lock_bh(&bp->phy_lock);
b6016b76 7116 err = bnx2_read_phy(bp, data->reg_num & 0x1f, &mii_regval);
c770a65c 7117 spin_unlock_bh(&bp->phy_lock);
b6016b76
MC		 7118
7119 data->val_out = mii_regval;
7120
7121 return err;
7122 }
7123
7124 case SIOCSMIIREG:
7125 if (!capable(CAP_NET_ADMIN))
7126 return -EPERM;
7127
583c28e5 7128 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
7b6b8347
MC		 7129 return -EOPNOTSUPP;
7130
dad3e452
MC		 7131 if (!netif_running(dev))
7132 return -EAGAIN;
7133
c770a65c 7134 spin_lock_bh(&bp->phy_lock);
b6016b76 7135 err = bnx2_write_phy(bp, data->reg_num & 0x1f, data->val_in);
c770a65c 7136 spin_unlock_bh(&bp->phy_lock);
b6016b76
MC		 7137
7138 return err;
7139
7140 default:
7141 /* do nothing */
7142 break;
7143 }
7144 return -EOPNOTSUPP;
7145}
7146
7147/* Called with rtnl_lock */
7148static int
7149bnx2_change_mac_addr(struct net_device *dev, void *p)
7150{
7151 struct sockaddr *addr = p;
972ec0d4 7152 struct bnx2 *bp = netdev_priv(dev);
b6016b76 7153
73eef4cd
MC		 7154 if (!is_valid_ether_addr(addr->sa_data))
7155 return -EINVAL;
7156
b6016b76
MC		 7157 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
7158 if (netif_running(dev))
5fcaed01 7159 bnx2_set_mac_addr(bp, bp->dev->dev_addr, 0);
b6016b76
MC		 7160
7161 return 0;
7162}
7163
7164/* Called with rtnl_lock */
7165static int
7166bnx2_change_mtu(struct net_device *dev, int new_mtu)
7167{
972ec0d4 7168 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 7169
7170 if (((new_mtu + ETH_HLEN) > MAX_ETHERNET_JUMBO_PACKET_SIZE) ||
7171 ((new_mtu + ETH_HLEN) < MIN_ETHERNET_PACKET_SIZE))
7172 return -EINVAL;
7173
7174 dev->mtu = new_mtu;
5d5d0015 7175 return (bnx2_change_ring_size(bp, bp->rx_ring_size, bp->tx_ring_size));
b6016b76
MC		 7176}
7177
7178#if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
7179static void
7180poll_bnx2(struct net_device *dev)
7181{
972ec0d4 7182 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 7183
7184 disable_irq(bp->pdev->irq);
7d12e780 7185 bnx2_interrupt(bp->pdev->irq, dev);
b6016b76
MC		 7186 enable_irq(bp->pdev->irq);
7187}
7188#endif
7189
253c8b75
MC		 7190static void __devinit
7191bnx2_get_5709_media(struct bnx2 *bp)
7192{
7193 u32 val = REG_RD(bp, BNX2_MISC_DUAL_MEDIA_CTRL);
7194 u32 bond_id = val & BNX2_MISC_DUAL_MEDIA_CTRL_BOND_ID;
7195 u32 strap;
7196
7197 if (bond_id == BNX2_MISC_DUAL_MEDIA_CTRL_BOND_ID_C)
7198 return;
7199 else if (bond_id == BNX2_MISC_DUAL_MEDIA_CTRL_BOND_ID_S) {
583c28e5 7200 bp->phy_flags |= BNX2_PHY_FLAG_SERDES;
253c8b75
MC		 7201 return;
7202 }
7203
7204 if (val & BNX2_MISC_DUAL_MEDIA_CTRL_STRAP_OVERRIDE)
7205 strap = (val & BNX2_MISC_DUAL_MEDIA_CTRL_PHY_CTRL) >> 21;
7206 else
7207 strap = (val & BNX2_MISC_DUAL_MEDIA_CTRL_PHY_CTRL_STRAP) >> 8;
7208
7209 if (PCI_FUNC(bp->pdev->devfn) == 0) {
7210 switch (strap) {
7211 case 0x4:
7212 case 0x5:
7213 case 0x6:
583c28e5 7214 bp->phy_flags |= BNX2_PHY_FLAG_SERDES;
253c8b75
MC		 7215 return;
7216 }
7217 } else {
7218 switch (strap) {
7219 case 0x1:
7220 case 0x2:
7221 case 0x4:
583c28e5 7222 bp->phy_flags |= BNX2_PHY_FLAG_SERDES;
253c8b75
MC		 7223 return;
7224 }
7225 }
7226}
7227
883e5151
MC		 7228static void __devinit
7229bnx2_get_pci_speed(struct bnx2 *bp)
7230{
7231 u32 reg;
7232
7233 reg = REG_RD(bp, BNX2_PCICFG_MISC_STATUS);
7234 if (reg & BNX2_PCICFG_MISC_STATUS_PCIX_DET) {
7235 u32 clkreg;
7236
f86e82fb 7237 bp->flags |= BNX2_FLAG_PCIX;
883e5151
MC		 7238
7239 clkreg = REG_RD(bp, BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS);
7240
7241 clkreg &= BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET;
7242 switch (clkreg) {
7243 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_133MHZ:
7244 bp->bus_speed_mhz = 133;
7245 break;
7246
7247 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_95MHZ:
7248 bp->bus_speed_mhz = 100;
7249 break;
7250
7251 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_66MHZ:
7252 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_80MHZ:
7253 bp->bus_speed_mhz = 66;
7254 break;
7255
7256 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_48MHZ:
7257 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_55MHZ:
7258 bp->bus_speed_mhz = 50;
7259 break;
7260
7261 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_LOW:
7262 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_32MHZ:
7263 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_38MHZ:
7264 bp->bus_speed_mhz = 33;
7265 break;
7266 }
7267 }
7268 else {
7269 if (reg & BNX2_PCICFG_MISC_STATUS_M66EN)
7270 bp->bus_speed_mhz = 66;
7271 else
7272 bp->bus_speed_mhz = 33;
7273 }
7274
7275 if (reg & BNX2_PCICFG_MISC_STATUS_32BIT_DET)
f86e82fb 7276 bp->flags |= BNX2_FLAG_PCI_32BIT;
883e5151
MC		 7277
7278}
7279
b6016b76
MC		 7280static int __devinit
7281bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
7282{
7283 struct bnx2 *bp;
7284 unsigned long mem_len;
58fc2ea4 7285 int rc, i, j;
b6016b76 7286 u32 reg;
40453c83 7287 u64 dma_mask, persist_dma_mask;
b6016b76 7288
b6016b76 7289 SET_NETDEV_DEV(dev, &pdev->dev);
972ec0d4 7290 bp = netdev_priv(dev);
b6016b76
MC		 7291
7292 bp->flags = 0;
7293 bp->phy_flags = 0;
7294
7295 /* enable device (incl. PCI PM wakeup), and bus-mastering */
7296 rc = pci_enable_device(pdev);
7297 if (rc) {
898eb71c 7298 dev_err(&pdev->dev, "Cannot enable PCI device, aborting.\n");
b6016b76
MC		 7299 goto err_out;
7300 }
7301
7302 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
9b91cf9d 7303 dev_err(&pdev->dev,
2e8a538d 7304 "Cannot find PCI device base address, aborting.\n");
b6016b76
MC		 7305 rc = -ENODEV;
7306 goto err_out_disable;
7307 }
7308
7309 rc = pci_request_regions(pdev, DRV_MODULE_NAME);
7310 if (rc) {
9b91cf9d 7311 dev_err(&pdev->dev, "Cannot obtain PCI resources, aborting.\n");
b6016b76
MC		 7312 goto err_out_disable;
7313 }
7314
7315 pci_set_master(pdev);
6ff2da49 7316 pci_save_state(pdev);
b6016b76
MC		 7317
7318 bp->pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM);
7319 if (bp->pm_cap == 0) {
9b91cf9d 7320 dev_err(&pdev->dev,
2e8a538d 7321 "Cannot find power management capability, aborting.\n");
b6016b76
MC		 7322 rc = -EIO;
7323 goto err_out_release;
7324 }
7325
b6016b76
MC		 7326 bp->dev = dev;
7327 bp->pdev = pdev;
7328
7329 spin_lock_init(&bp->phy_lock);
1b8227c4 7330 spin_lock_init(&bp->indirect_lock);
c4028958 7331 INIT_WORK(&bp->reset_task, bnx2_reset_task);
b6016b76
MC		 7332
7333 dev->base_addr = dev->mem_start = pci_resource_start(pdev, 0);
706bf240 7334 mem_len = MB_GET_CID_ADDR(TX_TSS_CID + TX_MAX_TSS_RINGS);
b6016b76
MC		 7335 dev->mem_end = dev->mem_start + mem_len;
7336 dev->irq = pdev->irq;
7337
7338 bp->regview = ioremap_nocache(dev->base_addr, mem_len);
7339
7340 if (!bp->regview) {
9b91cf9d 7341 dev_err(&pdev->dev, "Cannot map register space, aborting.\n");
b6016b76
MC		 7342 rc = -ENOMEM;
7343 goto err_out_release;
7344 }
7345
7346 /* Configure byte swap and enable write to the reg_window registers.
7347 * Rely on CPU to do target byte swapping on big endian systems
7348 * The chip's target access swapping will not swap all accesses
7349 */
7350 pci_write_config_dword(bp->pdev, BNX2_PCICFG_MISC_CONFIG,
7351 BNX2_PCICFG_MISC_CONFIG_REG_WINDOW_ENA |
7352 BNX2_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP);
7353
829ca9a3 7354 bnx2_set_power_state(bp, PCI_D0);
b6016b76
MC		 7355
7356 bp->chip_id = REG_RD(bp, BNX2_MISC_ID);
7357
883e5151
MC		 7358 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
7359 if (pci_find_capability(pdev, PCI_CAP_ID_EXP) == 0) {
7360 dev_err(&pdev->dev,
7361 "Cannot find PCIE capability, aborting.\n");
7362 rc = -EIO;
7363 goto err_out_unmap;
7364 }
f86e82fb 7365 bp->flags |= BNX2_FLAG_PCIE;
2dd201d7 7366 if (CHIP_REV(bp) == CHIP_REV_Ax)
f86e82fb 7367 bp->flags |= BNX2_FLAG_JUMBO_BROKEN;
883e5151 7368 } else {
59b47d8a
MC		 7369 bp->pcix_cap = pci_find_capability(pdev, PCI_CAP_ID_PCIX);
7370 if (bp->pcix_cap == 0) {
7371 dev_err(&pdev->dev,
7372 "Cannot find PCIX capability, aborting.\n");
7373 rc = -EIO;
7374 goto err_out_unmap;
7375 }
7376 }
7377
b4b36042
MC		 7378 if (CHIP_NUM(bp) == CHIP_NUM_5709 && CHIP_REV(bp) != CHIP_REV_Ax) {
7379 if (pci_find_capability(pdev, PCI_CAP_ID_MSIX))
f86e82fb 7380 bp->flags |= BNX2_FLAG_MSIX_CAP;
b4b36042
MC		 7381 }
7382
8e6a72c4
MC		 7383 if (CHIP_ID(bp) != CHIP_ID_5706_A0 && CHIP_ID(bp) != CHIP_ID_5706_A1) {
7384 if (pci_find_capability(pdev, PCI_CAP_ID_MSI))
f86e82fb 7385 bp->flags |= BNX2_FLAG_MSI_CAP;
8e6a72c4
MC		 7386 }
7387
40453c83
MC		 7388 /* 5708 cannot support DMA addresses > 40-bit. */
7389 if (CHIP_NUM(bp) == CHIP_NUM_5708)
7390 persist_dma_mask = dma_mask = DMA_40BIT_MASK;
7391 else
7392 persist_dma_mask = dma_mask = DMA_64BIT_MASK;
7393
7394 /* Configure DMA attributes. */
7395 if (pci_set_dma_mask(pdev, dma_mask) == 0) {
7396 dev->features |= NETIF_F_HIGHDMA;
7397 rc = pci_set_consistent_dma_mask(pdev, persist_dma_mask);
7398 if (rc) {
7399 dev_err(&pdev->dev,
7400 "pci_set_consistent_dma_mask failed, aborting.\n");
7401 goto err_out_unmap;
7402 }
7403 } else if ((rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK)) != 0) {
7404 dev_err(&pdev->dev, "System does not support DMA, aborting.\n");
7405 goto err_out_unmap;
7406 }
7407
f86e82fb 7408 if (!(bp->flags & BNX2_FLAG_PCIE))
883e5151 7409 bnx2_get_pci_speed(bp);
b6016b76
MC		 7410
7411 /* 5706A0 may falsely detect SERR and PERR. */
7412 if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
7413 reg = REG_RD(bp, PCI_COMMAND);
7414 reg &= ~(PCI_COMMAND_SERR | PCI_COMMAND_PARITY);
7415 REG_WR(bp, PCI_COMMAND, reg);
7416 }
7417 else if ((CHIP_ID(bp) == CHIP_ID_5706_A1) &&
f86e82fb 7418 !(bp->flags & BNX2_FLAG_PCIX)) {
b6016b76 7419
9b91cf9d 7420 dev_err(&pdev->dev,
2e8a538d 7421 "5706 A1 can only be used in a PCIX bus, aborting.\n");
b6016b76
MC		 7422 goto err_out_unmap;
7423 }
7424
7425 bnx2_init_nvram(bp);
7426
2726d6e1 7427 reg = bnx2_reg_rd_ind(bp, BNX2_SHM_HDR_SIGNATURE);
e3648b3d
MC		 7428
7429 if ((reg & BNX2_SHM_HDR_SIGNATURE_SIG_MASK) ==
24cb230b
MC		 7430 BNX2_SHM_HDR_SIGNATURE_SIG) {
7431 u32 off = PCI_FUNC(pdev->devfn) << 2;
7432
2726d6e1 7433 bp->shmem_base = bnx2_reg_rd_ind(bp, BNX2_SHM_HDR_ADDR_0 + off);
24cb230b 7434 } else
e3648b3d
MC		 7435 bp->shmem_base = HOST_VIEW_SHMEM_BASE;
7436
b6016b76
MC		 7437 /* Get the permanent MAC address. First we need to make sure the
7438 * firmware is actually running.
7439 */
2726d6e1 7440 reg = bnx2_shmem_rd(bp, BNX2_DEV_INFO_SIGNATURE);
b6016b76
MC		 7441
7442 if ((reg & BNX2_DEV_INFO_SIGNATURE_MAGIC_MASK) !=
7443 BNX2_DEV_INFO_SIGNATURE_MAGIC) {
9b91cf9d 7444 dev_err(&pdev->dev, "Firmware not running, aborting.\n");
b6016b76
MC		 7445 rc = -ENODEV;
7446 goto err_out_unmap;
7447 }
7448
2726d6e1 7449 reg = bnx2_shmem_rd(bp, BNX2_DEV_INFO_BC_REV);
58fc2ea4
MC		 7450 for (i = 0, j = 0; i < 3; i++) {
7451 u8 num, k, skip0;
7452
7453 num = (u8) (reg >> (24 - (i * 8)));
7454 for (k = 100, skip0 = 1; k >= 1; num %= k, k /= 10) {
7455 if (num >= k || !skip0 || k == 1) {
7456 bp->fw_version[j++] = (num / k) + '0';
7457 skip0 = 0;
7458 }
7459 }
7460 if (i != 2)
7461 bp->fw_version[j++] = '.';
7462 }
2726d6e1 7463 reg = bnx2_shmem_rd(bp, BNX2_PORT_FEATURE);
846f5c62
MC		 7464 if (reg & BNX2_PORT_FEATURE_WOL_ENABLED)
7465 bp->wol = 1;
7466
7467 if (reg & BNX2_PORT_FEATURE_ASF_ENABLED) {
f86e82fb 7468 bp->flags |= BNX2_FLAG_ASF_ENABLE;
c2d3db8c
MC		 7469
7470 for (i = 0; i < 30; i++) {
2726d6e1 7471 reg = bnx2_shmem_rd(bp, BNX2_BC_STATE_CONDITION);
c2d3db8c
MC		 7472 if (reg & BNX2_CONDITION_MFW_RUN_MASK)
7473 break;
7474 msleep(10);
7475 }
7476 }
2726d6e1 7477 reg = bnx2_shmem_rd(bp, BNX2_BC_STATE_CONDITION);
58fc2ea4
MC		 7478 reg &= BNX2_CONDITION_MFW_RUN_MASK;
7479 if (reg != BNX2_CONDITION_MFW_RUN_UNKNOWN &&
7480 reg != BNX2_CONDITION_MFW_RUN_NONE) {
2726d6e1 7481 u32 addr = bnx2_shmem_rd(bp, BNX2_MFW_VER_PTR);
58fc2ea4
MC		 7482
7483 bp->fw_version[j++] = ' ';
7484 for (i = 0; i < 3; i++) {
2726d6e1 7485 reg = bnx2_reg_rd_ind(bp, addr + i * 4);
58fc2ea4
MC		 7486 reg = swab32(reg);
7487 memcpy(&bp->fw_version[j], &reg, 4);
7488 j += 4;
7489 }
7490 }
b6016b76 7491
2726d6e1 7492 reg = bnx2_shmem_rd(bp, BNX2_PORT_HW_CFG_MAC_UPPER);
b6016b76
MC		 7493 bp->mac_addr[0] = (u8) (reg >> 8);
7494 bp->mac_addr[1] = (u8) reg;
7495
2726d6e1 7496 reg = bnx2_shmem_rd(bp, BNX2_PORT_HW_CFG_MAC_LOWER);
b6016b76
MC		 7497 bp->mac_addr[2] = (u8) (reg >> 24);
7498 bp->mac_addr[3] = (u8) (reg >> 16);
7499 bp->mac_addr[4] = (u8) (reg >> 8);
7500 bp->mac_addr[5] = (u8) reg;
7501
7502 bp->tx_ring_size = MAX_TX_DESC_CNT;
932f3772 7503 bnx2_set_rx_ring_size(bp, 255);
b6016b76
MC		 7504
7505 bp->rx_csum = 1;
7506
b6016b76
MC		 7507 bp->tx_quick_cons_trip_int = 20;
7508 bp->tx_quick_cons_trip = 20;
7509 bp->tx_ticks_int = 80;
7510 bp->tx_ticks = 80;
6aa20a22 7511
b6016b76
MC		 7512 bp->rx_quick_cons_trip_int = 6;
7513 bp->rx_quick_cons_trip = 6;
7514 bp->rx_ticks_int = 18;
7515 bp->rx_ticks = 18;
7516
7ea6920e 7517 bp->stats_ticks = USEC_PER_SEC & BNX2_HC_STATS_TICKS_HC_STAT_TICKS;
b6016b76
MC		 7518
7519 bp->timer_interval = HZ;
cd339a0e 7520 bp->current_interval = HZ;
b6016b76 7521
5b0c76ad
MC		 7522 bp->phy_addr = 1;
7523
b6016b76 7524 /* Disable WOL support if we are running on a SERDES chip. */
253c8b75
MC		 7525 if (CHIP_NUM(bp) == CHIP_NUM_5709)
7526 bnx2_get_5709_media(bp);
7527 else if (CHIP_BOND_ID(bp) & CHIP_BOND_ID_SERDES_BIT)
583c28e5 7528 bp->phy_flags |= BNX2_PHY_FLAG_SERDES;
bac0dff6 7529
0d8a6571 7530 bp->phy_port = PORT_TP;
583c28e5 7531 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
0d8a6571 7532 bp->phy_port = PORT_FIBRE;
2726d6e1 7533 reg = bnx2_shmem_rd(bp, BNX2_SHARED_HW_CFG_CONFIG);
846f5c62 7534 if (!(reg & BNX2_SHARED_HW_CFG_GIG_LINK_ON_VAUX)) {
f86e82fb 7535 bp->flags |= BNX2_FLAG_NO_WOL;
846f5c62
MC		 7536 bp->wol = 0;
7537 }
38ea3686
MC		 7538 if (CHIP_NUM(bp) == CHIP_NUM_5706) {
7539 /* Don't do parallel detect on this board because of
7540 * some board problems. The link will not go down
7541 * if we do parallel detect.
7542 */
7543 if (pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
7544 pdev->subsystem_device == 0x310c)
7545 bp->phy_flags |= BNX2_PHY_FLAG_NO_PARALLEL;
7546 } else {
5b0c76ad 7547 bp->phy_addr = 2;
5b0c76ad 7548 if (reg & BNX2_SHARED_HW_CFG_PHY_2_5G)
583c28e5 7549 bp->phy_flags |= BNX2_PHY_FLAG_2_5G_CAPABLE;
5b0c76ad 7550 }
261dd5ca
MC		 7551 } else if (CHIP_NUM(bp) == CHIP_NUM_5706 ||
7552 CHIP_NUM(bp) == CHIP_NUM_5708)
583c28e5 7553 bp->phy_flags |= BNX2_PHY_FLAG_CRC_FIX;
fb0c18bd
MC		 7554 else if (CHIP_NUM(bp) == CHIP_NUM_5709 &&
7555 (CHIP_REV(bp) == CHIP_REV_Ax ||
7556 CHIP_REV(bp) == CHIP_REV_Bx))
583c28e5 7557 bp->phy_flags |= BNX2_PHY_FLAG_DIS_EARLY_DAC;
b6016b76 7558
7c62e83b
MC		 7559 bnx2_init_fw_cap(bp);
7560
16088272
MC		 7561 if ((CHIP_ID(bp) == CHIP_ID_5708_A0) ||
7562 (CHIP_ID(bp) == CHIP_ID_5708_B0) ||
846f5c62 7563 (CHIP_ID(bp) == CHIP_ID_5708_B1)) {
f86e82fb 7564 bp->flags |= BNX2_FLAG_NO_WOL;
846f5c62
MC		 7565 bp->wol = 0;
7566 }
dda1e390 7567
b6016b76
MC		 7568 if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
7569 bp->tx_quick_cons_trip_int =
7570 bp->tx_quick_cons_trip;
7571 bp->tx_ticks_int = bp->tx_ticks;
7572 bp->rx_quick_cons_trip_int =
7573 bp->rx_quick_cons_trip;
7574 bp->rx_ticks_int = bp->rx_ticks;
7575 bp->comp_prod_trip_int = bp->comp_prod_trip;
7576 bp->com_ticks_int = bp->com_ticks;
7577 bp->cmd_ticks_int = bp->cmd_ticks;
7578 }
7579
f9317a40
MC		 7580 /* Disable MSI on 5706 if AMD 8132 bridge is found.
7581 *
7582 * MSI is defined to be 32-bit write. The 5706 does 64-bit MSI writes
7583 * with byte enables disabled on the unused 32-bit word. This is legal
7584 * but causes problems on the AMD 8132 which will eventually stop
7585 * responding after a while.
7586 *
7587 * AMD believes this incompatibility is unique to the 5706, and
88187dfa 7588 * prefers to locally disable MSI rather than globally disabling it.
f9317a40
MC		 7589 */
7590 if (CHIP_NUM(bp) == CHIP_NUM_5706 && disable_msi == 0) {
7591 struct pci_dev *amd_8132 = NULL;
7592
7593 while ((amd_8132 = pci_get_device(PCI_VENDOR_ID_AMD,
7594 PCI_DEVICE_ID_AMD_8132_BRIDGE,
7595 amd_8132))) {
f9317a40 7596
44c10138
AK		 7597 if (amd_8132->revision >= 0x10 &&
7598 amd_8132->revision <= 0x13) {
f9317a40
MC		 7599 disable_msi = 1;
7600 pci_dev_put(amd_8132);
7601 break;
7602 }
7603 }
7604 }
7605
deaf391b 7606 bnx2_set_default_link(bp);
b6016b76
MC		 7607 bp->req_flow_ctrl = FLOW_CTRL_RX | FLOW_CTRL_TX;
7608
cd339a0e
MC		 7609 init_timer(&bp->timer);
7610 bp->timer.expires = RUN_AT(bp->timer_interval);
7611 bp->timer.data = (unsigned long) bp;
7612 bp->timer.function = bnx2_timer;
7613
b6016b76
MC		 7614 return 0;
7615
7616err_out_unmap:
7617 if (bp->regview) {
7618 iounmap(bp->regview);
73eef4cd 7619 bp->regview = NULL;
b6016b76
MC		 7620 }
7621
7622err_out_release:
7623 pci_release_regions(pdev);
7624
7625err_out_disable:
7626 pci_disable_device(pdev);
7627 pci_set_drvdata(pdev, NULL);
7628
7629err_out:
7630 return rc;
7631}
7632
883e5151
MC		 7633static char * __devinit
7634bnx2_bus_string(struct bnx2 *bp, char *str)
7635{
7636 char *s = str;
7637
f86e82fb 7638 if (bp->flags & BNX2_FLAG_PCIE) {
883e5151
MC		 7639 s += sprintf(s, "PCI Express");
7640 } else {
7641 s += sprintf(s, "PCI");
f86e82fb 7642 if (bp->flags & BNX2_FLAG_PCIX)
883e5151 7643 s += sprintf(s, "-X");
f86e82fb 7644 if (bp->flags & BNX2_FLAG_PCI_32BIT)
883e5151
MC		 7645 s += sprintf(s, " 32-bit");
7646 else
7647 s += sprintf(s, " 64-bit");
7648 s += sprintf(s, " %dMHz", bp->bus_speed_mhz);
7649 }
7650 return str;
7651}
7652
2ba582b7 7653static void __devinit
35efa7c1
MC		 7654bnx2_init_napi(struct bnx2 *bp)
7655{
b4b36042 7656 int i;
35efa7c1 7657
b4b36042 7658 for (i = 0; i < BNX2_MAX_MSIX_VEC; i++) {
35e9010b
MC		 7659 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
7660 int (*poll)(struct napi_struct *, int);
7661
7662 if (i == 0)
7663 poll = bnx2_poll;
7664 else
f0ea2e63 7665 poll = bnx2_poll_msix;
35e9010b
MC		 7666
7667 netif_napi_add(bp->dev, &bp->bnx2_napi[i].napi, poll, 64);
b4b36042
MC		 7668 bnapi->bp = bp;
7669 }
35efa7c1
MC		 7670}
7671
b6016b76
MC		 7672static int __devinit
7673bnx2_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
7674{
7675 static int version_printed = 0;
7676 struct net_device *dev = NULL;
7677 struct bnx2 *bp;
0795af57 7678 int rc;
883e5151 7679 char str[40];
0795af57 7680 DECLARE_MAC_BUF(mac);
b6016b76
MC		 7681
7682 if (version_printed++ == 0)
7683 printk(KERN_INFO "%s", version);
7684
7685 /* dev zeroed in init_etherdev */
706bf240 7686 dev = alloc_etherdev_mq(sizeof(*bp), TX_MAX_RINGS);
b6016b76
MC		 7687
7688 if (!dev)
7689 return -ENOMEM;
7690
7691 rc = bnx2_init_board(pdev, dev);
7692 if (rc < 0) {
7693 free_netdev(dev);
7694 return rc;
7695 }
7696
7697 dev->open = bnx2_open;
7698 dev->hard_start_xmit = bnx2_start_xmit;
7699 dev->stop = bnx2_close;
7700 dev->get_stats = bnx2_get_stats;
5fcaed01 7701 dev->set_rx_mode = bnx2_set_rx_mode;
b6016b76
MC		 7702 dev->do_ioctl = bnx2_ioctl;
7703 dev->set_mac_address = bnx2_change_mac_addr;
7704 dev->change_mtu = bnx2_change_mtu;
7705 dev->tx_timeout = bnx2_tx_timeout;
7706 dev->watchdog_timeo = TX_TIMEOUT;
7707#ifdef BCM_VLAN
7708 dev->vlan_rx_register = bnx2_vlan_rx_register;
b6016b76 7709#endif
b6016b76 7710 dev->ethtool_ops = &bnx2_ethtool_ops;
b6016b76 7711
972ec0d4 7712 bp = netdev_priv(dev);
35efa7c1 7713 bnx2_init_napi(bp);
b6016b76
MC		 7714
7715#if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
7716 dev->poll_controller = poll_bnx2;
7717#endif
7718
1b2f922f
MC		 7719 pci_set_drvdata(pdev, dev);
7720
7721 memcpy(dev->dev_addr, bp->mac_addr, 6);
7722 memcpy(dev->perm_addr, bp->mac_addr, 6);
7723 bp->name = board_info[ent->driver_data].name;
7724
d212f87b 7725 dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
4666f87a 7726 if (CHIP_NUM(bp) == CHIP_NUM_5709)
d212f87b
SH		 7727 dev->features |= NETIF_F_IPV6_CSUM;
7728
1b2f922f
MC		 7729#ifdef BCM_VLAN
7730 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
7731#endif
7732 dev->features |= NETIF_F_TSO | NETIF_F_TSO_ECN;
4666f87a
MC		 7733 if (CHIP_NUM(bp) == CHIP_NUM_5709)
7734 dev->features |= NETIF_F_TSO6;
1b2f922f 7735
b6016b76 7736 if ((rc = register_netdev(dev))) {
9b91cf9d 7737 dev_err(&pdev->dev, "Cannot register net device\n");
b6016b76
MC		 7738 if (bp->regview)
7739 iounmap(bp->regview);
7740 pci_release_regions(pdev);
7741 pci_disable_device(pdev);
7742 pci_set_drvdata(pdev, NULL);
7743 free_netdev(dev);
7744 return rc;
7745 }
7746
883e5151 7747 printk(KERN_INFO "%s: %s (%c%d) %s found at mem %lx, "
0795af57 7748 "IRQ %d, node addr %s\n",
b6016b76
MC		 7749 dev->name,
7750 bp->name,
7751 ((CHIP_ID(bp) & 0xf000) >> 12) + 'A',
7752 ((CHIP_ID(bp) & 0x0ff0) >> 4),
883e5151 7753 bnx2_bus_string(bp, str),
b6016b76 7754 dev->base_addr,
0795af57 7755 bp->pdev->irq, print_mac(mac, dev->dev_addr));
b6016b76 7756
b6016b76
MC		 7757 return 0;
7758}
7759
7760static void __devexit
7761bnx2_remove_one(struct pci_dev *pdev)
7762{
7763 struct net_device *dev = pci_get_drvdata(pdev);
972ec0d4 7764 struct bnx2 *bp = netdev_priv(dev);
b6016b76 7765
afdc08b9
MC		 7766 flush_scheduled_work();
7767
b6016b76
MC		 7768 unregister_netdev(dev);
7769
7770 if (bp->regview)
7771 iounmap(bp->regview);
7772
7773 free_netdev(dev);
7774 pci_release_regions(pdev);
7775 pci_disable_device(pdev);
7776 pci_set_drvdata(pdev, NULL);
7777}
7778
7779static int
829ca9a3 7780bnx2_suspend(struct pci_dev *pdev, pm_message_t state)
b6016b76
MC		 7781{
7782 struct net_device *dev = pci_get_drvdata(pdev);
972ec0d4 7783 struct bnx2 *bp = netdev_priv(dev);
b6016b76
MC		 7784 u32 reset_code;
7785
6caebb02
MC		 7786 /* PCI register 4 needs to be saved whether netif_running() or not.
7787 * MSI address and data need to be saved if using MSI and
7788 * netif_running().
7789 */
7790 pci_save_state(pdev);
b6016b76
MC		 7791 if (!netif_running(dev))
7792 return 0;
7793
1d60290f 7794 flush_scheduled_work();
b6016b76
MC		 7795 bnx2_netif_stop(bp);
7796 netif_device_detach(dev);
7797 del_timer_sync(&bp->timer);
f86e82fb 7798 if (bp->flags & BNX2_FLAG_NO_WOL)
6c4f095e 7799 reset_code = BNX2_DRV_MSG_CODE_UNLOAD_LNK_DN;
dda1e390 7800 else if (bp->wol)
b6016b76
MC		 7801 reset_code = BNX2_DRV_MSG_CODE_SUSPEND_WOL;
7802 else
7803 reset_code = BNX2_DRV_MSG_CODE_SUSPEND_NO_WOL;
7804 bnx2_reset_chip(bp, reset_code);
7805 bnx2_free_skbs(bp);
829ca9a3 7806 bnx2_set_power_state(bp, pci_choose_state(pdev, state));
b6016b76
MC		 7807 return 0;
7808}
7809
7810static int
7811bnx2_resume(struct pci_dev *pdev)
7812{
7813 struct net_device *dev = pci_get_drvdata(pdev);
972ec0d4 7814 struct bnx2 *bp = netdev_priv(dev);
b6016b76 7815
6caebb02 7816 pci_restore_state(pdev);
b6016b76
MC		 7817 if (!netif_running(dev))
7818 return 0;
7819
829ca9a3 7820 bnx2_set_power_state(bp, PCI_D0);
b6016b76 7821 netif_device_attach(dev);
9a120bc5 7822 bnx2_init_nic(bp, 1);
b6016b76
MC		 7823 bnx2_netif_start(bp);
7824 return 0;
7825}
7826
6ff2da49
WX		 7827/**
7828 * bnx2_io_error_detected - called when PCI error is detected
7829 * @pdev: Pointer to PCI device
7830 * @state: The current pci connection state
7831 *
7832 * This function is called after a PCI bus error affecting
7833 * this device has been detected.
7834 */
7835static pci_ers_result_t bnx2_io_error_detected(struct pci_dev *pdev,
7836 pci_channel_state_t state)
7837{
7838 struct net_device *dev = pci_get_drvdata(pdev);
7839 struct bnx2 *bp = netdev_priv(dev);
7840
7841 rtnl_lock();
7842 netif_device_detach(dev);
7843
7844 if (netif_running(dev)) {
7845 bnx2_netif_stop(bp);
7846 del_timer_sync(&bp->timer);
7847 bnx2_reset_nic(bp, BNX2_DRV_MSG_CODE_RESET);
7848 }
7849
7850 pci_disable_device(pdev);
7851 rtnl_unlock();
7852
7853 /* Request a slot slot reset. */
7854 return PCI_ERS_RESULT_NEED_RESET;
7855}
7856
7857/**
7858 * bnx2_io_slot_reset - called after the pci bus has been reset.
7859 * @pdev: Pointer to PCI device
7860 *
7861 * Restart the card from scratch, as if from a cold-boot.
7862 */
7863static pci_ers_result_t bnx2_io_slot_reset(struct pci_dev *pdev)
7864{
7865 struct net_device *dev = pci_get_drvdata(pdev);
7866 struct bnx2 *bp = netdev_priv(dev);
7867
7868 rtnl_lock();
7869 if (pci_enable_device(pdev)) {
7870 dev_err(&pdev->dev,
7871 "Cannot re-enable PCI device after reset.\n");
7872 rtnl_unlock();
7873 return PCI_ERS_RESULT_DISCONNECT;
7874 }
7875 pci_set_master(pdev);
7876 pci_restore_state(pdev);
7877
7878 if (netif_running(dev)) {
7879 bnx2_set_power_state(bp, PCI_D0);
7880 bnx2_init_nic(bp, 1);
7881 }
7882
7883 rtnl_unlock();
7884 return PCI_ERS_RESULT_RECOVERED;
7885}
7886
7887/**
7888 * bnx2_io_resume - called when traffic can start flowing again.
7889 * @pdev: Pointer to PCI device
7890 *
7891 * This callback is called when the error recovery driver tells us that
7892 * its OK to resume normal operation.
7893 */
7894static void bnx2_io_resume(struct pci_dev *pdev)
7895{
7896 struct net_device *dev = pci_get_drvdata(pdev);
7897 struct bnx2 *bp = netdev_priv(dev);
7898
7899 rtnl_lock();
7900 if (netif_running(dev))
7901 bnx2_netif_start(bp);
7902
7903 netif_device_attach(dev);
7904 rtnl_unlock();
7905}
7906
7907static struct pci_error_handlers bnx2_err_handler = {
7908 .error_detected = bnx2_io_error_detected,
7909 .slot_reset = bnx2_io_slot_reset,
7910 .resume = bnx2_io_resume,
7911};
7912
b6016b76 7913static struct pci_driver bnx2_pci_driver = {
14ab9b86
PH		 7914 .name = DRV_MODULE_NAME,
7915 .id_table = bnx2_pci_tbl,
7916 .probe = bnx2_init_one,
7917 .remove = __devexit_p(bnx2_remove_one),
7918 .suspend = bnx2_suspend,
7919 .resume = bnx2_resume,
6ff2da49 7920 .err_handler = &bnx2_err_handler,
b6016b76
MC		 7921};
7922
7923static int __init bnx2_init(void)
7924{
29917620 7925 return pci_register_driver(&bnx2_pci_driver);
b6016b76
MC		 7926}
7927
7928static void __exit bnx2_cleanup(void)
7929{
7930 pci_unregister_driver(&bnx2_pci_driver);
7931}
7932
7933module_init(bnx2_init);
7934module_exit(bnx2_cleanup);
7935
7936
7937
Clone of davem's net-next-2.6 tree