blob: 2dd002b338cb018b1d2998439c9f7623fcc85ef8 [file] [log] [blame]
Michael Chanb6016b72005-05-26 13:03:09 -07001/* bnx2.c: Broadcom NX2 network driver.
2 *
Michael Chan72fbaeb2007-05-03 13:25:32 -07003 * Copyright (c) 2004-2007 Broadcom Corporation
Michael Chanb6016b72005-05-26 13:03:09 -07004 *
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
Michael Chanf2a4f052006-03-23 01:13:12 -080012
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>
29#include <asm/bitops.h>
30#include <asm/io.h>
31#include <asm/irq.h>
32#include <linux/delay.h>
33#include <asm/byteorder.h>
Michael Chanc86a31f2006-06-13 15:03:47 -070034#include <asm/page.h>
Michael Chanf2a4f052006-03-23 01:13:12 -080035#include <linux/time.h>
36#include <linux/ethtool.h>
37#include <linux/mii.h>
38#ifdef NETIF_F_HW_VLAN_TX
39#include <linux/if_vlan.h>
40#define BCM_VLAN 1
41#endif
Michael Chanf2a4f052006-03-23 01:13:12 -080042#include <net/ip.h>
Linus Torvaldsde081fa2007-07-12 16:40:08 -070043#include <net/tcp.h>
Michael Chanf2a4f052006-03-23 01:13:12 -080044#include <net/checksum.h>
Michael Chanf2a4f052006-03-23 01:13:12 -080045#include <linux/workqueue.h>
46#include <linux/crc32.h>
47#include <linux/prefetch.h>
Michael Chan29b12172006-03-23 01:13:43 -080048#include <linux/cache.h>
Michael Chanfba9fe92006-06-12 22:21:25 -070049#include <linux/zlib.h>
Michael Chanf2a4f052006-03-23 01:13:12 -080050
Michael Chanb6016b72005-05-26 13:03:09 -070051#include "bnx2.h"
52#include "bnx2_fw.h"
Michael Chand43584c2006-11-19 14:14:35 -080053#include "bnx2_fw2.h"
Michael Chanb6016b72005-05-26 13:03:09 -070054
55#define DRV_MODULE_NAME "bnx2"
56#define PFX DRV_MODULE_NAME ": "
Michael Chan3a334b32007-07-07 22:52:37 -070057#define DRV_MODULE_VERSION "1.6.2"
58#define DRV_MODULE_RELDATE "July 6, 2007"
Michael Chanb6016b72005-05-26 13:03:09 -070059
60#define RUN_AT(x) (jiffies + (x))
61
62/* Time in jiffies before concluding the transmitter is hung. */
63#define TX_TIMEOUT (5*HZ)
64
Randy Dunlape19360f2006-04-10 23:22:06 -070065static const char version[] __devinitdata =
Michael Chanb6016b72005-05-26 13:03:09 -070066 "Broadcom NetXtreme II Gigabit Ethernet Driver " DRV_MODULE_NAME " v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
67
68MODULE_AUTHOR("Michael Chan <mchan@broadcom.com>");
Michael Chan05d0f1c2005-11-04 08:53:48 -080069MODULE_DESCRIPTION("Broadcom NetXtreme II BCM5706/5708 Driver");
Michael Chanb6016b72005-05-26 13:03:09 -070070MODULE_LICENSE("GPL");
71MODULE_VERSION(DRV_MODULE_VERSION);
72
73static int disable_msi = 0;
74
75module_param(disable_msi, int, 0);
76MODULE_PARM_DESC(disable_msi, "Disable Message Signaled Interrupt (MSI)");
77
78typedef enum {
79 BCM5706 = 0,
80 NC370T,
81 NC370I,
82 BCM5706S,
83 NC370F,
Michael Chan5b0c76a2005-11-04 08:45:49 -080084 BCM5708,
85 BCM5708S,
Michael Chanbac0dff2006-11-19 14:15:05 -080086 BCM5709,
Michael Chan27a005b2007-05-03 13:23:41 -070087 BCM5709S,
Michael Chanb6016b72005-05-26 13:03:09 -070088} board_t;
89
90/* indexed by board_t, above */
Arjan van de Venf71e1302006-03-03 21:33:57 -050091static const struct {
Michael Chanb6016b72005-05-26 13:03:09 -070092 char *name;
93} board_info[] __devinitdata = {
94 { "Broadcom NetXtreme II BCM5706 1000Base-T" },
95 { "HP NC370T Multifunction Gigabit Server Adapter" },
96 { "HP NC370i Multifunction Gigabit Server Adapter" },
97 { "Broadcom NetXtreme II BCM5706 1000Base-SX" },
98 { "HP NC370F Multifunction Gigabit Server Adapter" },
Michael Chan5b0c76a2005-11-04 08:45:49 -080099 { "Broadcom NetXtreme II BCM5708 1000Base-T" },
100 { "Broadcom NetXtreme II BCM5708 1000Base-SX" },
Michael Chanbac0dff2006-11-19 14:15:05 -0800101 { "Broadcom NetXtreme II BCM5709 1000Base-T" },
Michael Chan27a005b2007-05-03 13:23:41 -0700102 { "Broadcom NetXtreme II BCM5709 1000Base-SX" },
Michael Chanb6016b72005-05-26 13:03:09 -0700103 };
104
105static struct pci_device_id bnx2_pci_tbl[] = {
106 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706,
107 PCI_VENDOR_ID_HP, 0x3101, 0, 0, NC370T },
108 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706,
109 PCI_VENDOR_ID_HP, 0x3106, 0, 0, NC370I },
110 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706,
111 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5706 },
Michael Chan5b0c76a2005-11-04 08:45:49 -0800112 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5708,
113 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5708 },
Michael Chanb6016b72005-05-26 13:03:09 -0700114 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706S,
115 PCI_VENDOR_ID_HP, 0x3102, 0, 0, NC370F },
116 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706S,
117 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5706S },
Michael Chan5b0c76a2005-11-04 08:45:49 -0800118 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5708S,
119 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5708S },
Michael Chanbac0dff2006-11-19 14:15:05 -0800120 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5709,
121 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5709 },
Michael Chan27a005b2007-05-03 13:23:41 -0700122 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5709S,
123 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5709S },
Michael Chanb6016b72005-05-26 13:03:09 -0700124 { 0, }
125};
126
127static struct flash_spec flash_table[] =
128{
Michael Chane30372c2007-07-16 18:26:23 -0700129#define BUFFERED_FLAGS (BNX2_NV_BUFFERED | BNX2_NV_TRANSLATE)
130#define NONBUFFERED_FLAGS (BNX2_NV_WREN)
Michael Chanb6016b72005-05-26 13:03:09 -0700131 /* Slow EEPROM */
Michael Chan37137702005-11-04 08:49:17 -0800132 {0x00000000, 0x40830380, 0x009f0081, 0xa184a053, 0xaf000400,
Michael Chane30372c2007-07-16 18:26:23 -0700133 BUFFERED_FLAGS, SEEPROM_PAGE_BITS, SEEPROM_PAGE_SIZE,
Michael Chanb6016b72005-05-26 13:03:09 -0700134 SEEPROM_BYTE_ADDR_MASK, SEEPROM_TOTAL_SIZE,
135 "EEPROM - slow"},
Michael Chan37137702005-11-04 08:49:17 -0800136 /* Expansion entry 0001 */
137 {0x08000002, 0x4b808201, 0x00050081, 0x03840253, 0xaf020406,
Michael Chane30372c2007-07-16 18:26:23 -0700138 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
Michael Chan37137702005-11-04 08:49:17 -0800139 SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
140 "Entry 0001"},
Michael Chanb6016b72005-05-26 13:03:09 -0700141 /* Saifun SA25F010 (non-buffered flash) */
142 /* strap, cfg1, & write1 need updates */
Michael Chan37137702005-11-04 08:49:17 -0800143 {0x04000001, 0x47808201, 0x00050081, 0x03840253, 0xaf020406,
Michael Chane30372c2007-07-16 18:26:23 -0700144 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
Michael Chanb6016b72005-05-26 13:03:09 -0700145 SAIFUN_FLASH_BYTE_ADDR_MASK, SAIFUN_FLASH_BASE_TOTAL_SIZE*2,
146 "Non-buffered flash (128kB)"},
147 /* Saifun SA25F020 (non-buffered flash) */
148 /* strap, cfg1, & write1 need updates */
Michael Chan37137702005-11-04 08:49:17 -0800149 {0x0c000003, 0x4f808201, 0x00050081, 0x03840253, 0xaf020406,
Michael Chane30372c2007-07-16 18:26:23 -0700150 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
Michael Chanb6016b72005-05-26 13:03:09 -0700151 SAIFUN_FLASH_BYTE_ADDR_MASK, SAIFUN_FLASH_BASE_TOTAL_SIZE*4,
152 "Non-buffered flash (256kB)"},
Michael Chan37137702005-11-04 08:49:17 -0800153 /* Expansion entry 0100 */
154 {0x11000000, 0x53808201, 0x00050081, 0x03840253, 0xaf020406,
Michael Chane30372c2007-07-16 18:26:23 -0700155 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
Michael Chan37137702005-11-04 08:49:17 -0800156 SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
157 "Entry 0100"},
158 /* Entry 0101: ST M45PE10 (non-buffered flash, TetonII B0) */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400159 {0x19000002, 0x5b808201, 0x000500db, 0x03840253, 0xaf020406,
Michael Chane30372c2007-07-16 18:26:23 -0700160 NONBUFFERED_FLAGS, ST_MICRO_FLASH_PAGE_BITS, ST_MICRO_FLASH_PAGE_SIZE,
Michael Chan37137702005-11-04 08:49:17 -0800161 ST_MICRO_FLASH_BYTE_ADDR_MASK, ST_MICRO_FLASH_BASE_TOTAL_SIZE*2,
162 "Entry 0101: ST M45PE10 (128kB non-bufferred)"},
163 /* Entry 0110: ST M45PE20 (non-buffered flash)*/
164 {0x15000001, 0x57808201, 0x000500db, 0x03840253, 0xaf020406,
Michael Chane30372c2007-07-16 18:26:23 -0700165 NONBUFFERED_FLAGS, ST_MICRO_FLASH_PAGE_BITS, ST_MICRO_FLASH_PAGE_SIZE,
Michael Chan37137702005-11-04 08:49:17 -0800166 ST_MICRO_FLASH_BYTE_ADDR_MASK, ST_MICRO_FLASH_BASE_TOTAL_SIZE*4,
167 "Entry 0110: ST M45PE20 (256kB non-bufferred)"},
168 /* Saifun SA25F005 (non-buffered flash) */
169 /* strap, cfg1, & write1 need updates */
170 {0x1d000003, 0x5f808201, 0x00050081, 0x03840253, 0xaf020406,
Michael Chane30372c2007-07-16 18:26:23 -0700171 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
Michael Chan37137702005-11-04 08:49:17 -0800172 SAIFUN_FLASH_BYTE_ADDR_MASK, SAIFUN_FLASH_BASE_TOTAL_SIZE,
173 "Non-buffered flash (64kB)"},
174 /* Fast EEPROM */
175 {0x22000000, 0x62808380, 0x009f0081, 0xa184a053, 0xaf000400,
Michael Chane30372c2007-07-16 18:26:23 -0700176 BUFFERED_FLAGS, SEEPROM_PAGE_BITS, SEEPROM_PAGE_SIZE,
Michael Chan37137702005-11-04 08:49:17 -0800177 SEEPROM_BYTE_ADDR_MASK, SEEPROM_TOTAL_SIZE,
178 "EEPROM - fast"},
179 /* Expansion entry 1001 */
180 {0x2a000002, 0x6b808201, 0x00050081, 0x03840253, 0xaf020406,
Michael Chane30372c2007-07-16 18:26:23 -0700181 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
Michael Chan37137702005-11-04 08:49:17 -0800182 SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
183 "Entry 1001"},
184 /* Expansion entry 1010 */
185 {0x26000001, 0x67808201, 0x00050081, 0x03840253, 0xaf020406,
Michael Chane30372c2007-07-16 18:26:23 -0700186 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
Michael Chan37137702005-11-04 08:49:17 -0800187 SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
188 "Entry 1010"},
189 /* ATMEL AT45DB011B (buffered flash) */
190 {0x2e000003, 0x6e808273, 0x00570081, 0x68848353, 0xaf000400,
Michael Chane30372c2007-07-16 18:26:23 -0700191 BUFFERED_FLAGS, BUFFERED_FLASH_PAGE_BITS, BUFFERED_FLASH_PAGE_SIZE,
Michael Chan37137702005-11-04 08:49:17 -0800192 BUFFERED_FLASH_BYTE_ADDR_MASK, BUFFERED_FLASH_TOTAL_SIZE,
193 "Buffered flash (128kB)"},
194 /* Expansion entry 1100 */
195 {0x33000000, 0x73808201, 0x00050081, 0x03840253, 0xaf020406,
Michael Chane30372c2007-07-16 18:26:23 -0700196 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
Michael Chan37137702005-11-04 08:49:17 -0800197 SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
198 "Entry 1100"},
199 /* Expansion entry 1101 */
200 {0x3b000002, 0x7b808201, 0x00050081, 0x03840253, 0xaf020406,
Michael Chane30372c2007-07-16 18:26:23 -0700201 NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
Michael Chan37137702005-11-04 08:49:17 -0800202 SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
203 "Entry 1101"},
204 /* Ateml Expansion entry 1110 */
205 {0x37000001, 0x76808273, 0x00570081, 0x68848353, 0xaf000400,
Michael Chane30372c2007-07-16 18:26:23 -0700206 BUFFERED_FLAGS, BUFFERED_FLASH_PAGE_BITS, BUFFERED_FLASH_PAGE_SIZE,
Michael Chan37137702005-11-04 08:49:17 -0800207 BUFFERED_FLASH_BYTE_ADDR_MASK, 0,
208 "Entry 1110 (Atmel)"},
209 /* ATMEL AT45DB021B (buffered flash) */
210 {0x3f000003, 0x7e808273, 0x00570081, 0x68848353, 0xaf000400,
Michael Chane30372c2007-07-16 18:26:23 -0700211 BUFFERED_FLAGS, BUFFERED_FLASH_PAGE_BITS, BUFFERED_FLASH_PAGE_SIZE,
Michael Chan37137702005-11-04 08:49:17 -0800212 BUFFERED_FLASH_BYTE_ADDR_MASK, BUFFERED_FLASH_TOTAL_SIZE*2,
213 "Buffered flash (256kB)"},
Michael Chanb6016b72005-05-26 13:03:09 -0700214};
215
Michael Chane30372c2007-07-16 18:26:23 -0700216static struct flash_spec flash_5709 = {
217 .flags = BNX2_NV_BUFFERED,
218 .page_bits = BCM5709_FLASH_PAGE_BITS,
219 .page_size = BCM5709_FLASH_PAGE_SIZE,
220 .addr_mask = BCM5709_FLASH_BYTE_ADDR_MASK,
221 .total_size = BUFFERED_FLASH_TOTAL_SIZE*2,
222 .name = "5709 Buffered flash (256kB)",
223};
224
Michael Chanb6016b72005-05-26 13:03:09 -0700225MODULE_DEVICE_TABLE(pci, bnx2_pci_tbl);
226
Michael Chane89bbf12005-08-25 15:36:58 -0700227static inline u32 bnx2_tx_avail(struct bnx2 *bp)
228{
Michael Chan2f8af122006-08-15 01:39:10 -0700229 u32 diff;
Michael Chane89bbf12005-08-25 15:36:58 -0700230
Michael Chan2f8af122006-08-15 01:39:10 -0700231 smp_mb();
Michael Chanfaac9c42006-12-14 15:56:32 -0800232
233 /* The ring uses 256 indices for 255 entries, one of them
234 * needs to be skipped.
235 */
236 diff = bp->tx_prod - bp->tx_cons;
237 if (unlikely(diff >= TX_DESC_CNT)) {
238 diff &= 0xffff;
239 if (diff == TX_DESC_CNT)
240 diff = MAX_TX_DESC_CNT;
241 }
Michael Chane89bbf12005-08-25 15:36:58 -0700242 return (bp->tx_ring_size - diff);
243}
244
Michael Chanb6016b72005-05-26 13:03:09 -0700245static u32
246bnx2_reg_rd_ind(struct bnx2 *bp, u32 offset)
247{
Michael Chan1b8227c2007-05-03 13:24:05 -0700248 u32 val;
249
250 spin_lock_bh(&bp->indirect_lock);
Michael Chanb6016b72005-05-26 13:03:09 -0700251 REG_WR(bp, BNX2_PCICFG_REG_WINDOW_ADDRESS, offset);
Michael Chan1b8227c2007-05-03 13:24:05 -0700252 val = REG_RD(bp, BNX2_PCICFG_REG_WINDOW);
253 spin_unlock_bh(&bp->indirect_lock);
254 return val;
Michael Chanb6016b72005-05-26 13:03:09 -0700255}
256
257static void
258bnx2_reg_wr_ind(struct bnx2 *bp, u32 offset, u32 val)
259{
Michael Chan1b8227c2007-05-03 13:24:05 -0700260 spin_lock_bh(&bp->indirect_lock);
Michael Chanb6016b72005-05-26 13:03:09 -0700261 REG_WR(bp, BNX2_PCICFG_REG_WINDOW_ADDRESS, offset);
262 REG_WR(bp, BNX2_PCICFG_REG_WINDOW, val);
Michael Chan1b8227c2007-05-03 13:24:05 -0700263 spin_unlock_bh(&bp->indirect_lock);
Michael Chanb6016b72005-05-26 13:03:09 -0700264}
265
266static void
267bnx2_ctx_wr(struct bnx2 *bp, u32 cid_addr, u32 offset, u32 val)
268{
269 offset += cid_addr;
Michael Chan1b8227c2007-05-03 13:24:05 -0700270 spin_lock_bh(&bp->indirect_lock);
Michael Chan59b47d82006-11-19 14:10:45 -0800271 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
272 int i;
273
274 REG_WR(bp, BNX2_CTX_CTX_DATA, val);
275 REG_WR(bp, BNX2_CTX_CTX_CTRL,
276 offset | BNX2_CTX_CTX_CTRL_WRITE_REQ);
277 for (i = 0; i < 5; i++) {
278 u32 val;
279 val = REG_RD(bp, BNX2_CTX_CTX_CTRL);
280 if ((val & BNX2_CTX_CTX_CTRL_WRITE_REQ) == 0)
281 break;
282 udelay(5);
283 }
284 } else {
285 REG_WR(bp, BNX2_CTX_DATA_ADR, offset);
286 REG_WR(bp, BNX2_CTX_DATA, val);
287 }
Michael Chan1b8227c2007-05-03 13:24:05 -0700288 spin_unlock_bh(&bp->indirect_lock);
Michael Chanb6016b72005-05-26 13:03:09 -0700289}
290
291static int
292bnx2_read_phy(struct bnx2 *bp, u32 reg, u32 *val)
293{
294 u32 val1;
295 int i, ret;
296
297 if (bp->phy_flags & PHY_INT_MODE_AUTO_POLLING_FLAG) {
298 val1 = REG_RD(bp, BNX2_EMAC_MDIO_MODE);
299 val1 &= ~BNX2_EMAC_MDIO_MODE_AUTO_POLL;
300
301 REG_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
302 REG_RD(bp, BNX2_EMAC_MDIO_MODE);
303
304 udelay(40);
305 }
306
307 val1 = (bp->phy_addr << 21) | (reg << 16) |
308 BNX2_EMAC_MDIO_COMM_COMMAND_READ | BNX2_EMAC_MDIO_COMM_DISEXT |
309 BNX2_EMAC_MDIO_COMM_START_BUSY;
310 REG_WR(bp, BNX2_EMAC_MDIO_COMM, val1);
311
312 for (i = 0; i < 50; i++) {
313 udelay(10);
314
315 val1 = REG_RD(bp, BNX2_EMAC_MDIO_COMM);
316 if (!(val1 & BNX2_EMAC_MDIO_COMM_START_BUSY)) {
317 udelay(5);
318
319 val1 = REG_RD(bp, BNX2_EMAC_MDIO_COMM);
320 val1 &= BNX2_EMAC_MDIO_COMM_DATA;
321
322 break;
323 }
324 }
325
326 if (val1 & BNX2_EMAC_MDIO_COMM_START_BUSY) {
327 *val = 0x0;
328 ret = -EBUSY;
329 }
330 else {
331 *val = val1;
332 ret = 0;
333 }
334
335 if (bp->phy_flags & PHY_INT_MODE_AUTO_POLLING_FLAG) {
336 val1 = REG_RD(bp, BNX2_EMAC_MDIO_MODE);
337 val1 |= BNX2_EMAC_MDIO_MODE_AUTO_POLL;
338
339 REG_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
340 REG_RD(bp, BNX2_EMAC_MDIO_MODE);
341
342 udelay(40);
343 }
344
345 return ret;
346}
347
348static int
349bnx2_write_phy(struct bnx2 *bp, u32 reg, u32 val)
350{
351 u32 val1;
352 int i, ret;
353
354 if (bp->phy_flags & PHY_INT_MODE_AUTO_POLLING_FLAG) {
355 val1 = REG_RD(bp, BNX2_EMAC_MDIO_MODE);
356 val1 &= ~BNX2_EMAC_MDIO_MODE_AUTO_POLL;
357
358 REG_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
359 REG_RD(bp, BNX2_EMAC_MDIO_MODE);
360
361 udelay(40);
362 }
363
364 val1 = (bp->phy_addr << 21) | (reg << 16) | val |
365 BNX2_EMAC_MDIO_COMM_COMMAND_WRITE |
366 BNX2_EMAC_MDIO_COMM_START_BUSY | BNX2_EMAC_MDIO_COMM_DISEXT;
367 REG_WR(bp, BNX2_EMAC_MDIO_COMM, val1);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400368
Michael Chanb6016b72005-05-26 13:03:09 -0700369 for (i = 0; i < 50; i++) {
370 udelay(10);
371
372 val1 = REG_RD(bp, BNX2_EMAC_MDIO_COMM);
373 if (!(val1 & BNX2_EMAC_MDIO_COMM_START_BUSY)) {
374 udelay(5);
375 break;
376 }
377 }
378
379 if (val1 & BNX2_EMAC_MDIO_COMM_START_BUSY)
380 ret = -EBUSY;
381 else
382 ret = 0;
383
384 if (bp->phy_flags & PHY_INT_MODE_AUTO_POLLING_FLAG) {
385 val1 = REG_RD(bp, BNX2_EMAC_MDIO_MODE);
386 val1 |= BNX2_EMAC_MDIO_MODE_AUTO_POLL;
387
388 REG_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
389 REG_RD(bp, BNX2_EMAC_MDIO_MODE);
390
391 udelay(40);
392 }
393
394 return ret;
395}
396
397static void
398bnx2_disable_int(struct bnx2 *bp)
399{
400 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
401 BNX2_PCICFG_INT_ACK_CMD_MASK_INT);
402 REG_RD(bp, BNX2_PCICFG_INT_ACK_CMD);
403}
404
405static void
406bnx2_enable_int(struct bnx2 *bp)
407{
Michael Chanb6016b72005-05-26 13:03:09 -0700408 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
Michael Chan1269a8a2006-01-23 16:11:03 -0800409 BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
410 BNX2_PCICFG_INT_ACK_CMD_MASK_INT | bp->last_status_idx);
411
412 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
Michael Chanb6016b72005-05-26 13:03:09 -0700413 BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID | bp->last_status_idx);
414
Michael Chanbf5295b2006-03-23 01:11:56 -0800415 REG_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW);
Michael Chanb6016b72005-05-26 13:03:09 -0700416}
417
418static void
419bnx2_disable_int_sync(struct bnx2 *bp)
420{
421 atomic_inc(&bp->intr_sem);
422 bnx2_disable_int(bp);
423 synchronize_irq(bp->pdev->irq);
424}
425
426static void
427bnx2_netif_stop(struct bnx2 *bp)
428{
429 bnx2_disable_int_sync(bp);
430 if (netif_running(bp->dev)) {
431 netif_poll_disable(bp->dev);
432 netif_tx_disable(bp->dev);
433 bp->dev->trans_start = jiffies; /* prevent tx timeout */
434 }
435}
436
437static void
438bnx2_netif_start(struct bnx2 *bp)
439{
440 if (atomic_dec_and_test(&bp->intr_sem)) {
441 if (netif_running(bp->dev)) {
442 netif_wake_queue(bp->dev);
443 netif_poll_enable(bp->dev);
444 bnx2_enable_int(bp);
445 }
446 }
447}
448
449static void
450bnx2_free_mem(struct bnx2 *bp)
451{
Michael Chan13daffa2006-03-20 17:49:20 -0800452 int i;
453
Michael Chan59b47d82006-11-19 14:10:45 -0800454 for (i = 0; i < bp->ctx_pages; i++) {
455 if (bp->ctx_blk[i]) {
456 pci_free_consistent(bp->pdev, BCM_PAGE_SIZE,
457 bp->ctx_blk[i],
458 bp->ctx_blk_mapping[i]);
459 bp->ctx_blk[i] = NULL;
460 }
461 }
Michael Chanb6016b72005-05-26 13:03:09 -0700462 if (bp->status_blk) {
Michael Chan0f31f992006-03-23 01:12:38 -0800463 pci_free_consistent(bp->pdev, bp->status_stats_size,
Michael Chanb6016b72005-05-26 13:03:09 -0700464 bp->status_blk, bp->status_blk_mapping);
465 bp->status_blk = NULL;
Michael Chan0f31f992006-03-23 01:12:38 -0800466 bp->stats_blk = NULL;
Michael Chanb6016b72005-05-26 13:03:09 -0700467 }
468 if (bp->tx_desc_ring) {
469 pci_free_consistent(bp->pdev,
470 sizeof(struct tx_bd) * TX_DESC_CNT,
471 bp->tx_desc_ring, bp->tx_desc_mapping);
472 bp->tx_desc_ring = NULL;
473 }
Jesper Juhlb4558ea2005-10-28 16:53:13 -0400474 kfree(bp->tx_buf_ring);
475 bp->tx_buf_ring = NULL;
Michael Chan13daffa2006-03-20 17:49:20 -0800476 for (i = 0; i < bp->rx_max_ring; i++) {
477 if (bp->rx_desc_ring[i])
478 pci_free_consistent(bp->pdev,
479 sizeof(struct rx_bd) * RX_DESC_CNT,
480 bp->rx_desc_ring[i],
481 bp->rx_desc_mapping[i]);
482 bp->rx_desc_ring[i] = NULL;
Michael Chanb6016b72005-05-26 13:03:09 -0700483 }
Michael Chan13daffa2006-03-20 17:49:20 -0800484 vfree(bp->rx_buf_ring);
Jesper Juhlb4558ea2005-10-28 16:53:13 -0400485 bp->rx_buf_ring = NULL;
Michael Chanb6016b72005-05-26 13:03:09 -0700486}
487
488static int
489bnx2_alloc_mem(struct bnx2 *bp)
490{
Michael Chan0f31f992006-03-23 01:12:38 -0800491 int i, status_blk_size;
Michael Chan13daffa2006-03-20 17:49:20 -0800492
Michael Chan0f31f992006-03-23 01:12:38 -0800493 bp->tx_buf_ring = kzalloc(sizeof(struct sw_bd) * TX_DESC_CNT,
494 GFP_KERNEL);
Michael Chanb6016b72005-05-26 13:03:09 -0700495 if (bp->tx_buf_ring == NULL)
496 return -ENOMEM;
497
Michael Chanb6016b72005-05-26 13:03:09 -0700498 bp->tx_desc_ring = pci_alloc_consistent(bp->pdev,
499 sizeof(struct tx_bd) *
500 TX_DESC_CNT,
501 &bp->tx_desc_mapping);
502 if (bp->tx_desc_ring == NULL)
503 goto alloc_mem_err;
504
Michael Chan13daffa2006-03-20 17:49:20 -0800505 bp->rx_buf_ring = vmalloc(sizeof(struct sw_bd) * RX_DESC_CNT *
506 bp->rx_max_ring);
Michael Chanb6016b72005-05-26 13:03:09 -0700507 if (bp->rx_buf_ring == NULL)
508 goto alloc_mem_err;
509
Michael Chan13daffa2006-03-20 17:49:20 -0800510 memset(bp->rx_buf_ring, 0, sizeof(struct sw_bd) * RX_DESC_CNT *
511 bp->rx_max_ring);
512
513 for (i = 0; i < bp->rx_max_ring; i++) {
514 bp->rx_desc_ring[i] =
515 pci_alloc_consistent(bp->pdev,
516 sizeof(struct rx_bd) * RX_DESC_CNT,
517 &bp->rx_desc_mapping[i]);
518 if (bp->rx_desc_ring[i] == NULL)
519 goto alloc_mem_err;
520
521 }
Michael Chanb6016b72005-05-26 13:03:09 -0700522
Michael Chan0f31f992006-03-23 01:12:38 -0800523 /* Combine status and statistics blocks into one allocation. */
524 status_blk_size = L1_CACHE_ALIGN(sizeof(struct status_block));
525 bp->status_stats_size = status_blk_size +
526 sizeof(struct statistics_block);
527
528 bp->status_blk = pci_alloc_consistent(bp->pdev, bp->status_stats_size,
Michael Chanb6016b72005-05-26 13:03:09 -0700529 &bp->status_blk_mapping);
530 if (bp->status_blk == NULL)
531 goto alloc_mem_err;
532
Michael Chan0f31f992006-03-23 01:12:38 -0800533 memset(bp->status_blk, 0, bp->status_stats_size);
Michael Chanb6016b72005-05-26 13:03:09 -0700534
Michael Chan0f31f992006-03-23 01:12:38 -0800535 bp->stats_blk = (void *) ((unsigned long) bp->status_blk +
536 status_blk_size);
Michael Chanb6016b72005-05-26 13:03:09 -0700537
Michael Chan0f31f992006-03-23 01:12:38 -0800538 bp->stats_blk_mapping = bp->status_blk_mapping + status_blk_size;
Michael Chanb6016b72005-05-26 13:03:09 -0700539
Michael Chan59b47d82006-11-19 14:10:45 -0800540 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
541 bp->ctx_pages = 0x2000 / BCM_PAGE_SIZE;
542 if (bp->ctx_pages == 0)
543 bp->ctx_pages = 1;
544 for (i = 0; i < bp->ctx_pages; i++) {
545 bp->ctx_blk[i] = pci_alloc_consistent(bp->pdev,
546 BCM_PAGE_SIZE,
547 &bp->ctx_blk_mapping[i]);
548 if (bp->ctx_blk[i] == NULL)
549 goto alloc_mem_err;
550 }
551 }
Michael Chanb6016b72005-05-26 13:03:09 -0700552 return 0;
553
554alloc_mem_err:
555 bnx2_free_mem(bp);
556 return -ENOMEM;
557}
558
559static void
Michael Chane3648b32005-11-04 08:51:21 -0800560bnx2_report_fw_link(struct bnx2 *bp)
561{
562 u32 fw_link_status = 0;
563
Michael Chan0d8a6572007-07-07 22:49:43 -0700564 if (bp->phy_flags & REMOTE_PHY_CAP_FLAG)
565 return;
566
Michael Chane3648b32005-11-04 08:51:21 -0800567 if (bp->link_up) {
568 u32 bmsr;
569
570 switch (bp->line_speed) {
571 case SPEED_10:
572 if (bp->duplex == DUPLEX_HALF)
573 fw_link_status = BNX2_LINK_STATUS_10HALF;
574 else
575 fw_link_status = BNX2_LINK_STATUS_10FULL;
576 break;
577 case SPEED_100:
578 if (bp->duplex == DUPLEX_HALF)
579 fw_link_status = BNX2_LINK_STATUS_100HALF;
580 else
581 fw_link_status = BNX2_LINK_STATUS_100FULL;
582 break;
583 case SPEED_1000:
584 if (bp->duplex == DUPLEX_HALF)
585 fw_link_status = BNX2_LINK_STATUS_1000HALF;
586 else
587 fw_link_status = BNX2_LINK_STATUS_1000FULL;
588 break;
589 case SPEED_2500:
590 if (bp->duplex == DUPLEX_HALF)
591 fw_link_status = BNX2_LINK_STATUS_2500HALF;
592 else
593 fw_link_status = BNX2_LINK_STATUS_2500FULL;
594 break;
595 }
596
597 fw_link_status |= BNX2_LINK_STATUS_LINK_UP;
598
599 if (bp->autoneg) {
600 fw_link_status |= BNX2_LINK_STATUS_AN_ENABLED;
601
Michael Chanca58c3a2007-05-03 13:22:52 -0700602 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
603 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
Michael Chane3648b32005-11-04 08:51:21 -0800604
605 if (!(bmsr & BMSR_ANEGCOMPLETE) ||
606 bp->phy_flags & PHY_PARALLEL_DETECT_FLAG)
607 fw_link_status |= BNX2_LINK_STATUS_PARALLEL_DET;
608 else
609 fw_link_status |= BNX2_LINK_STATUS_AN_COMPLETE;
610 }
611 }
612 else
613 fw_link_status = BNX2_LINK_STATUS_LINK_DOWN;
614
615 REG_WR_IND(bp, bp->shmem_base + BNX2_LINK_STATUS, fw_link_status);
616}
617
Michael Chan9b1084b2007-07-07 22:50:37 -0700618static char *
619bnx2_xceiver_str(struct bnx2 *bp)
620{
621 return ((bp->phy_port == PORT_FIBRE) ? "SerDes" :
622 ((bp->phy_flags & PHY_SERDES_FLAG) ? "Remote Copper" :
623 "Copper"));
624}
625
Michael Chane3648b32005-11-04 08:51:21 -0800626static void
Michael Chanb6016b72005-05-26 13:03:09 -0700627bnx2_report_link(struct bnx2 *bp)
628{
629 if (bp->link_up) {
630 netif_carrier_on(bp->dev);
Michael Chan9b1084b2007-07-07 22:50:37 -0700631 printk(KERN_INFO PFX "%s NIC %s Link is Up, ", bp->dev->name,
632 bnx2_xceiver_str(bp));
Michael Chanb6016b72005-05-26 13:03:09 -0700633
634 printk("%d Mbps ", bp->line_speed);
635
636 if (bp->duplex == DUPLEX_FULL)
637 printk("full duplex");
638 else
639 printk("half duplex");
640
641 if (bp->flow_ctrl) {
642 if (bp->flow_ctrl & FLOW_CTRL_RX) {
643 printk(", receive ");
644 if (bp->flow_ctrl & FLOW_CTRL_TX)
645 printk("& transmit ");
646 }
647 else {
648 printk(", transmit ");
649 }
650 printk("flow control ON");
651 }
652 printk("\n");
653 }
654 else {
655 netif_carrier_off(bp->dev);
Michael Chan9b1084b2007-07-07 22:50:37 -0700656 printk(KERN_ERR PFX "%s NIC %s Link is Down\n", bp->dev->name,
657 bnx2_xceiver_str(bp));
Michael Chanb6016b72005-05-26 13:03:09 -0700658 }
Michael Chane3648b32005-11-04 08:51:21 -0800659
660 bnx2_report_fw_link(bp);
Michael Chanb6016b72005-05-26 13:03:09 -0700661}
662
663static void
664bnx2_resolve_flow_ctrl(struct bnx2 *bp)
665{
666 u32 local_adv, remote_adv;
667
668 bp->flow_ctrl = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400669 if ((bp->autoneg & (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) !=
Michael Chanb6016b72005-05-26 13:03:09 -0700670 (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) {
671
672 if (bp->duplex == DUPLEX_FULL) {
673 bp->flow_ctrl = bp->req_flow_ctrl;
674 }
675 return;
676 }
677
678 if (bp->duplex != DUPLEX_FULL) {
679 return;
680 }
681
Michael Chan5b0c76a2005-11-04 08:45:49 -0800682 if ((bp->phy_flags & PHY_SERDES_FLAG) &&
683 (CHIP_NUM(bp) == CHIP_NUM_5708)) {
684 u32 val;
685
686 bnx2_read_phy(bp, BCM5708S_1000X_STAT1, &val);
687 if (val & BCM5708S_1000X_STAT1_TX_PAUSE)
688 bp->flow_ctrl |= FLOW_CTRL_TX;
689 if (val & BCM5708S_1000X_STAT1_RX_PAUSE)
690 bp->flow_ctrl |= FLOW_CTRL_RX;
691 return;
692 }
693
Michael Chanca58c3a2007-05-03 13:22:52 -0700694 bnx2_read_phy(bp, bp->mii_adv, &local_adv);
695 bnx2_read_phy(bp, bp->mii_lpa, &remote_adv);
Michael Chanb6016b72005-05-26 13:03:09 -0700696
697 if (bp->phy_flags & PHY_SERDES_FLAG) {
698 u32 new_local_adv = 0;
699 u32 new_remote_adv = 0;
700
701 if (local_adv & ADVERTISE_1000XPAUSE)
702 new_local_adv |= ADVERTISE_PAUSE_CAP;
703 if (local_adv & ADVERTISE_1000XPSE_ASYM)
704 new_local_adv |= ADVERTISE_PAUSE_ASYM;
705 if (remote_adv & ADVERTISE_1000XPAUSE)
706 new_remote_adv |= ADVERTISE_PAUSE_CAP;
707 if (remote_adv & ADVERTISE_1000XPSE_ASYM)
708 new_remote_adv |= ADVERTISE_PAUSE_ASYM;
709
710 local_adv = new_local_adv;
711 remote_adv = new_remote_adv;
712 }
713
714 /* See Table 28B-3 of 802.3ab-1999 spec. */
715 if (local_adv & ADVERTISE_PAUSE_CAP) {
716 if(local_adv & ADVERTISE_PAUSE_ASYM) {
717 if (remote_adv & ADVERTISE_PAUSE_CAP) {
718 bp->flow_ctrl = FLOW_CTRL_TX | FLOW_CTRL_RX;
719 }
720 else if (remote_adv & ADVERTISE_PAUSE_ASYM) {
721 bp->flow_ctrl = FLOW_CTRL_RX;
722 }
723 }
724 else {
725 if (remote_adv & ADVERTISE_PAUSE_CAP) {
726 bp->flow_ctrl = FLOW_CTRL_TX | FLOW_CTRL_RX;
727 }
728 }
729 }
730 else if (local_adv & ADVERTISE_PAUSE_ASYM) {
731 if ((remote_adv & ADVERTISE_PAUSE_CAP) &&
732 (remote_adv & ADVERTISE_PAUSE_ASYM)) {
733
734 bp->flow_ctrl = FLOW_CTRL_TX;
735 }
736 }
737}
738
739static int
Michael Chan27a005b2007-05-03 13:23:41 -0700740bnx2_5709s_linkup(struct bnx2 *bp)
741{
742 u32 val, speed;
743
744 bp->link_up = 1;
745
746 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_GP_STATUS);
747 bnx2_read_phy(bp, MII_BNX2_GP_TOP_AN_STATUS1, &val);
748 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
749
750 if ((bp->autoneg & AUTONEG_SPEED) == 0) {
751 bp->line_speed = bp->req_line_speed;
752 bp->duplex = bp->req_duplex;
753 return 0;
754 }
755 speed = val & MII_BNX2_GP_TOP_AN_SPEED_MSK;
756 switch (speed) {
757 case MII_BNX2_GP_TOP_AN_SPEED_10:
758 bp->line_speed = SPEED_10;
759 break;
760 case MII_BNX2_GP_TOP_AN_SPEED_100:
761 bp->line_speed = SPEED_100;
762 break;
763 case MII_BNX2_GP_TOP_AN_SPEED_1G:
764 case MII_BNX2_GP_TOP_AN_SPEED_1GKV:
765 bp->line_speed = SPEED_1000;
766 break;
767 case MII_BNX2_GP_TOP_AN_SPEED_2_5G:
768 bp->line_speed = SPEED_2500;
769 break;
770 }
771 if (val & MII_BNX2_GP_TOP_AN_FD)
772 bp->duplex = DUPLEX_FULL;
773 else
774 bp->duplex = DUPLEX_HALF;
775 return 0;
776}
777
778static int
Michael Chan5b0c76a2005-11-04 08:45:49 -0800779bnx2_5708s_linkup(struct bnx2 *bp)
780{
781 u32 val;
782
783 bp->link_up = 1;
784 bnx2_read_phy(bp, BCM5708S_1000X_STAT1, &val);
785 switch (val & BCM5708S_1000X_STAT1_SPEED_MASK) {
786 case BCM5708S_1000X_STAT1_SPEED_10:
787 bp->line_speed = SPEED_10;
788 break;
789 case BCM5708S_1000X_STAT1_SPEED_100:
790 bp->line_speed = SPEED_100;
791 break;
792 case BCM5708S_1000X_STAT1_SPEED_1G:
793 bp->line_speed = SPEED_1000;
794 break;
795 case BCM5708S_1000X_STAT1_SPEED_2G5:
796 bp->line_speed = SPEED_2500;
797 break;
798 }
799 if (val & BCM5708S_1000X_STAT1_FD)
800 bp->duplex = DUPLEX_FULL;
801 else
802 bp->duplex = DUPLEX_HALF;
803
804 return 0;
805}
806
807static int
808bnx2_5706s_linkup(struct bnx2 *bp)
Michael Chanb6016b72005-05-26 13:03:09 -0700809{
810 u32 bmcr, local_adv, remote_adv, common;
811
812 bp->link_up = 1;
813 bp->line_speed = SPEED_1000;
814
Michael Chanca58c3a2007-05-03 13:22:52 -0700815 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
Michael Chanb6016b72005-05-26 13:03:09 -0700816 if (bmcr & BMCR_FULLDPLX) {
817 bp->duplex = DUPLEX_FULL;
818 }
819 else {
820 bp->duplex = DUPLEX_HALF;
821 }
822
823 if (!(bmcr & BMCR_ANENABLE)) {
824 return 0;
825 }
826
Michael Chanca58c3a2007-05-03 13:22:52 -0700827 bnx2_read_phy(bp, bp->mii_adv, &local_adv);
828 bnx2_read_phy(bp, bp->mii_lpa, &remote_adv);
Michael Chanb6016b72005-05-26 13:03:09 -0700829
830 common = local_adv & remote_adv;
831 if (common & (ADVERTISE_1000XHALF | ADVERTISE_1000XFULL)) {
832
833 if (common & ADVERTISE_1000XFULL) {
834 bp->duplex = DUPLEX_FULL;
835 }
836 else {
837 bp->duplex = DUPLEX_HALF;
838 }
839 }
840
841 return 0;
842}
843
844static int
845bnx2_copper_linkup(struct bnx2 *bp)
846{
847 u32 bmcr;
848
Michael Chanca58c3a2007-05-03 13:22:52 -0700849 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
Michael Chanb6016b72005-05-26 13:03:09 -0700850 if (bmcr & BMCR_ANENABLE) {
851 u32 local_adv, remote_adv, common;
852
853 bnx2_read_phy(bp, MII_CTRL1000, &local_adv);
854 bnx2_read_phy(bp, MII_STAT1000, &remote_adv);
855
856 common = local_adv & (remote_adv >> 2);
857 if (common & ADVERTISE_1000FULL) {
858 bp->line_speed = SPEED_1000;
859 bp->duplex = DUPLEX_FULL;
860 }
861 else if (common & ADVERTISE_1000HALF) {
862 bp->line_speed = SPEED_1000;
863 bp->duplex = DUPLEX_HALF;
864 }
865 else {
Michael Chanca58c3a2007-05-03 13:22:52 -0700866 bnx2_read_phy(bp, bp->mii_adv, &local_adv);
867 bnx2_read_phy(bp, bp->mii_lpa, &remote_adv);
Michael Chanb6016b72005-05-26 13:03:09 -0700868
869 common = local_adv & remote_adv;
870 if (common & ADVERTISE_100FULL) {
871 bp->line_speed = SPEED_100;
872 bp->duplex = DUPLEX_FULL;
873 }
874 else if (common & ADVERTISE_100HALF) {
875 bp->line_speed = SPEED_100;
876 bp->duplex = DUPLEX_HALF;
877 }
878 else if (common & ADVERTISE_10FULL) {
879 bp->line_speed = SPEED_10;
880 bp->duplex = DUPLEX_FULL;
881 }
882 else if (common & ADVERTISE_10HALF) {
883 bp->line_speed = SPEED_10;
884 bp->duplex = DUPLEX_HALF;
885 }
886 else {
887 bp->line_speed = 0;
888 bp->link_up = 0;
889 }
890 }
891 }
892 else {
893 if (bmcr & BMCR_SPEED100) {
894 bp->line_speed = SPEED_100;
895 }
896 else {
897 bp->line_speed = SPEED_10;
898 }
899 if (bmcr & BMCR_FULLDPLX) {
900 bp->duplex = DUPLEX_FULL;
901 }
902 else {
903 bp->duplex = DUPLEX_HALF;
904 }
905 }
906
907 return 0;
908}
909
910static int
911bnx2_set_mac_link(struct bnx2 *bp)
912{
913 u32 val;
914
915 REG_WR(bp, BNX2_EMAC_TX_LENGTHS, 0x2620);
916 if (bp->link_up && (bp->line_speed == SPEED_1000) &&
917 (bp->duplex == DUPLEX_HALF)) {
918 REG_WR(bp, BNX2_EMAC_TX_LENGTHS, 0x26ff);
919 }
920
921 /* Configure the EMAC mode register. */
922 val = REG_RD(bp, BNX2_EMAC_MODE);
923
924 val &= ~(BNX2_EMAC_MODE_PORT | BNX2_EMAC_MODE_HALF_DUPLEX |
Michael Chan5b0c76a2005-11-04 08:45:49 -0800925 BNX2_EMAC_MODE_MAC_LOOP | BNX2_EMAC_MODE_FORCE_LINK |
Michael Chan59b47d82006-11-19 14:10:45 -0800926 BNX2_EMAC_MODE_25G_MODE);
Michael Chanb6016b72005-05-26 13:03:09 -0700927
928 if (bp->link_up) {
Michael Chan5b0c76a2005-11-04 08:45:49 -0800929 switch (bp->line_speed) {
930 case SPEED_10:
Michael Chan59b47d82006-11-19 14:10:45 -0800931 if (CHIP_NUM(bp) != CHIP_NUM_5706) {
932 val |= BNX2_EMAC_MODE_PORT_MII_10M;
Michael Chan5b0c76a2005-11-04 08:45:49 -0800933 break;
934 }
935 /* fall through */
936 case SPEED_100:
937 val |= BNX2_EMAC_MODE_PORT_MII;
938 break;
939 case SPEED_2500:
Michael Chan59b47d82006-11-19 14:10:45 -0800940 val |= BNX2_EMAC_MODE_25G_MODE;
Michael Chan5b0c76a2005-11-04 08:45:49 -0800941 /* fall through */
942 case SPEED_1000:
943 val |= BNX2_EMAC_MODE_PORT_GMII;
944 break;
945 }
Michael Chanb6016b72005-05-26 13:03:09 -0700946 }
947 else {
948 val |= BNX2_EMAC_MODE_PORT_GMII;
949 }
950
951 /* Set the MAC to operate in the appropriate duplex mode. */
952 if (bp->duplex == DUPLEX_HALF)
953 val |= BNX2_EMAC_MODE_HALF_DUPLEX;
954 REG_WR(bp, BNX2_EMAC_MODE, val);
955
956 /* Enable/disable rx PAUSE. */
957 bp->rx_mode &= ~BNX2_EMAC_RX_MODE_FLOW_EN;
958
959 if (bp->flow_ctrl & FLOW_CTRL_RX)
960 bp->rx_mode |= BNX2_EMAC_RX_MODE_FLOW_EN;
961 REG_WR(bp, BNX2_EMAC_RX_MODE, bp->rx_mode);
962
963 /* Enable/disable tx PAUSE. */
964 val = REG_RD(bp, BNX2_EMAC_TX_MODE);
965 val &= ~BNX2_EMAC_TX_MODE_FLOW_EN;
966
967 if (bp->flow_ctrl & FLOW_CTRL_TX)
968 val |= BNX2_EMAC_TX_MODE_FLOW_EN;
969 REG_WR(bp, BNX2_EMAC_TX_MODE, val);
970
971 /* Acknowledge the interrupt. */
972 REG_WR(bp, BNX2_EMAC_STATUS, BNX2_EMAC_STATUS_LINK_CHANGE);
973
974 return 0;
975}
976
Michael Chan27a005b2007-05-03 13:23:41 -0700977static void
978bnx2_enable_bmsr1(struct bnx2 *bp)
979{
980 if ((bp->phy_flags & PHY_SERDES_FLAG) &&
981 (CHIP_NUM(bp) == CHIP_NUM_5709))
982 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
983 MII_BNX2_BLK_ADDR_GP_STATUS);
984}
985
986static void
987bnx2_disable_bmsr1(struct bnx2 *bp)
988{
989 if ((bp->phy_flags & PHY_SERDES_FLAG) &&
990 (CHIP_NUM(bp) == CHIP_NUM_5709))
991 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
992 MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
993}
994
Michael Chanb6016b72005-05-26 13:03:09 -0700995static int
Michael Chan605a9e22007-05-03 13:23:13 -0700996bnx2_test_and_enable_2g5(struct bnx2 *bp)
997{
998 u32 up1;
999 int ret = 1;
1000
1001 if (!(bp->phy_flags & PHY_2_5G_CAPABLE_FLAG))
1002 return 0;
1003
1004 if (bp->autoneg & AUTONEG_SPEED)
1005 bp->advertising |= ADVERTISED_2500baseX_Full;
1006
Michael Chan27a005b2007-05-03 13:23:41 -07001007 if (CHIP_NUM(bp) == CHIP_NUM_5709)
1008 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_OVER1G);
1009
Michael Chan605a9e22007-05-03 13:23:13 -07001010 bnx2_read_phy(bp, bp->mii_up1, &up1);
1011 if (!(up1 & BCM5708S_UP1_2G5)) {
1012 up1 |= BCM5708S_UP1_2G5;
1013 bnx2_write_phy(bp, bp->mii_up1, up1);
1014 ret = 0;
1015 }
1016
Michael Chan27a005b2007-05-03 13:23:41 -07001017 if (CHIP_NUM(bp) == CHIP_NUM_5709)
1018 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1019 MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1020
Michael Chan605a9e22007-05-03 13:23:13 -07001021 return ret;
1022}
1023
1024static int
1025bnx2_test_and_disable_2g5(struct bnx2 *bp)
1026{
1027 u32 up1;
1028 int ret = 0;
1029
1030 if (!(bp->phy_flags & PHY_2_5G_CAPABLE_FLAG))
1031 return 0;
1032
Michael Chan27a005b2007-05-03 13:23:41 -07001033 if (CHIP_NUM(bp) == CHIP_NUM_5709)
1034 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_OVER1G);
1035
Michael Chan605a9e22007-05-03 13:23:13 -07001036 bnx2_read_phy(bp, bp->mii_up1, &up1);
1037 if (up1 & BCM5708S_UP1_2G5) {
1038 up1 &= ~BCM5708S_UP1_2G5;
1039 bnx2_write_phy(bp, bp->mii_up1, up1);
1040 ret = 1;
1041 }
1042
Michael Chan27a005b2007-05-03 13:23:41 -07001043 if (CHIP_NUM(bp) == CHIP_NUM_5709)
1044 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1045 MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1046
Michael Chan605a9e22007-05-03 13:23:13 -07001047 return ret;
1048}
1049
1050static void
1051bnx2_enable_forced_2g5(struct bnx2 *bp)
1052{
1053 u32 bmcr;
1054
1055 if (!(bp->phy_flags & PHY_2_5G_CAPABLE_FLAG))
1056 return;
1057
Michael Chan27a005b2007-05-03 13:23:41 -07001058 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
1059 u32 val;
1060
1061 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1062 MII_BNX2_BLK_ADDR_SERDES_DIG);
1063 bnx2_read_phy(bp, MII_BNX2_SERDES_DIG_MISC1, &val);
1064 val &= ~MII_BNX2_SD_MISC1_FORCE_MSK;
1065 val |= MII_BNX2_SD_MISC1_FORCE | MII_BNX2_SD_MISC1_FORCE_2_5G;
1066 bnx2_write_phy(bp, MII_BNX2_SERDES_DIG_MISC1, val);
1067
1068 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1069 MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1070 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1071
1072 } else if (CHIP_NUM(bp) == CHIP_NUM_5708) {
Michael Chan605a9e22007-05-03 13:23:13 -07001073 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1074 bmcr |= BCM5708S_BMCR_FORCE_2500;
1075 }
1076
1077 if (bp->autoneg & AUTONEG_SPEED) {
1078 bmcr &= ~BMCR_ANENABLE;
1079 if (bp->req_duplex == DUPLEX_FULL)
1080 bmcr |= BMCR_FULLDPLX;
1081 }
1082 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
1083}
1084
1085static void
1086bnx2_disable_forced_2g5(struct bnx2 *bp)
1087{
1088 u32 bmcr;
1089
1090 if (!(bp->phy_flags & PHY_2_5G_CAPABLE_FLAG))
1091 return;
1092
Michael Chan27a005b2007-05-03 13:23:41 -07001093 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
1094 u32 val;
1095
1096 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1097 MII_BNX2_BLK_ADDR_SERDES_DIG);
1098 bnx2_read_phy(bp, MII_BNX2_SERDES_DIG_MISC1, &val);
1099 val &= ~MII_BNX2_SD_MISC1_FORCE;
1100 bnx2_write_phy(bp, MII_BNX2_SERDES_DIG_MISC1, val);
1101
1102 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1103 MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1104 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1105
1106 } else if (CHIP_NUM(bp) == CHIP_NUM_5708) {
Michael Chan605a9e22007-05-03 13:23:13 -07001107 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1108 bmcr &= ~BCM5708S_BMCR_FORCE_2500;
1109 }
1110
1111 if (bp->autoneg & AUTONEG_SPEED)
1112 bmcr |= BMCR_SPEED1000 | BMCR_ANENABLE | BMCR_ANRESTART;
1113 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
1114}
1115
1116static int
Michael Chanb6016b72005-05-26 13:03:09 -07001117bnx2_set_link(struct bnx2 *bp)
1118{
1119 u32 bmsr;
1120 u8 link_up;
1121
Michael Chan80be4432006-11-19 14:07:28 -08001122 if (bp->loopback == MAC_LOOPBACK || bp->loopback == PHY_LOOPBACK) {
Michael Chanb6016b72005-05-26 13:03:09 -07001123 bp->link_up = 1;
1124 return 0;
1125 }
1126
Michael Chan0d8a6572007-07-07 22:49:43 -07001127 if (bp->phy_flags & REMOTE_PHY_CAP_FLAG)
1128 return 0;
1129
Michael Chanb6016b72005-05-26 13:03:09 -07001130 link_up = bp->link_up;
1131
Michael Chan27a005b2007-05-03 13:23:41 -07001132 bnx2_enable_bmsr1(bp);
1133 bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
1134 bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
1135 bnx2_disable_bmsr1(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07001136
1137 if ((bp->phy_flags & PHY_SERDES_FLAG) &&
1138 (CHIP_NUM(bp) == CHIP_NUM_5706)) {
1139 u32 val;
1140
1141 val = REG_RD(bp, BNX2_EMAC_STATUS);
1142 if (val & BNX2_EMAC_STATUS_LINK)
1143 bmsr |= BMSR_LSTATUS;
1144 else
1145 bmsr &= ~BMSR_LSTATUS;
1146 }
1147
1148 if (bmsr & BMSR_LSTATUS) {
1149 bp->link_up = 1;
1150
1151 if (bp->phy_flags & PHY_SERDES_FLAG) {
Michael Chan5b0c76a2005-11-04 08:45:49 -08001152 if (CHIP_NUM(bp) == CHIP_NUM_5706)
1153 bnx2_5706s_linkup(bp);
1154 else if (CHIP_NUM(bp) == CHIP_NUM_5708)
1155 bnx2_5708s_linkup(bp);
Michael Chan27a005b2007-05-03 13:23:41 -07001156 else if (CHIP_NUM(bp) == CHIP_NUM_5709)
1157 bnx2_5709s_linkup(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07001158 }
1159 else {
1160 bnx2_copper_linkup(bp);
1161 }
1162 bnx2_resolve_flow_ctrl(bp);
1163 }
1164 else {
1165 if ((bp->phy_flags & PHY_SERDES_FLAG) &&
Michael Chan605a9e22007-05-03 13:23:13 -07001166 (bp->autoneg & AUTONEG_SPEED))
1167 bnx2_disable_forced_2g5(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07001168
Michael Chanb6016b72005-05-26 13:03:09 -07001169 bp->phy_flags &= ~PHY_PARALLEL_DETECT_FLAG;
1170 bp->link_up = 0;
1171 }
1172
1173 if (bp->link_up != link_up) {
1174 bnx2_report_link(bp);
1175 }
1176
1177 bnx2_set_mac_link(bp);
1178
1179 return 0;
1180}
1181
1182static int
1183bnx2_reset_phy(struct bnx2 *bp)
1184{
1185 int i;
1186 u32 reg;
1187
Michael Chanca58c3a2007-05-03 13:22:52 -07001188 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_RESET);
Michael Chanb6016b72005-05-26 13:03:09 -07001189
1190#define PHY_RESET_MAX_WAIT 100
1191 for (i = 0; i < PHY_RESET_MAX_WAIT; i++) {
1192 udelay(10);
1193
Michael Chanca58c3a2007-05-03 13:22:52 -07001194 bnx2_read_phy(bp, bp->mii_bmcr, &reg);
Michael Chanb6016b72005-05-26 13:03:09 -07001195 if (!(reg & BMCR_RESET)) {
1196 udelay(20);
1197 break;
1198 }
1199 }
1200 if (i == PHY_RESET_MAX_WAIT) {
1201 return -EBUSY;
1202 }
1203 return 0;
1204}
1205
1206static u32
1207bnx2_phy_get_pause_adv(struct bnx2 *bp)
1208{
1209 u32 adv = 0;
1210
1211 if ((bp->req_flow_ctrl & (FLOW_CTRL_RX | FLOW_CTRL_TX)) ==
1212 (FLOW_CTRL_RX | FLOW_CTRL_TX)) {
1213
1214 if (bp->phy_flags & PHY_SERDES_FLAG) {
1215 adv = ADVERTISE_1000XPAUSE;
1216 }
1217 else {
1218 adv = ADVERTISE_PAUSE_CAP;
1219 }
1220 }
1221 else if (bp->req_flow_ctrl & FLOW_CTRL_TX) {
1222 if (bp->phy_flags & PHY_SERDES_FLAG) {
1223 adv = ADVERTISE_1000XPSE_ASYM;
1224 }
1225 else {
1226 adv = ADVERTISE_PAUSE_ASYM;
1227 }
1228 }
1229 else if (bp->req_flow_ctrl & FLOW_CTRL_RX) {
1230 if (bp->phy_flags & PHY_SERDES_FLAG) {
1231 adv = ADVERTISE_1000XPAUSE | ADVERTISE_1000XPSE_ASYM;
1232 }
1233 else {
1234 adv = ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
1235 }
1236 }
1237 return adv;
1238}
1239
Michael Chan0d8a6572007-07-07 22:49:43 -07001240static int bnx2_fw_sync(struct bnx2 *, u32, int);
1241
Michael Chanb6016b72005-05-26 13:03:09 -07001242static int
Michael Chan0d8a6572007-07-07 22:49:43 -07001243bnx2_setup_remote_phy(struct bnx2 *bp, u8 port)
1244{
1245 u32 speed_arg = 0, pause_adv;
1246
1247 pause_adv = bnx2_phy_get_pause_adv(bp);
1248
1249 if (bp->autoneg & AUTONEG_SPEED) {
1250 speed_arg |= BNX2_NETLINK_SET_LINK_ENABLE_AUTONEG;
1251 if (bp->advertising & ADVERTISED_10baseT_Half)
1252 speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_10HALF;
1253 if (bp->advertising & ADVERTISED_10baseT_Full)
1254 speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_10FULL;
1255 if (bp->advertising & ADVERTISED_100baseT_Half)
1256 speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_100HALF;
1257 if (bp->advertising & ADVERTISED_100baseT_Full)
1258 speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_100FULL;
1259 if (bp->advertising & ADVERTISED_1000baseT_Full)
1260 speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_1GFULL;
1261 if (bp->advertising & ADVERTISED_2500baseX_Full)
1262 speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_2G5FULL;
1263 } else {
1264 if (bp->req_line_speed == SPEED_2500)
1265 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_2G5FULL;
1266 else if (bp->req_line_speed == SPEED_1000)
1267 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_1GFULL;
1268 else if (bp->req_line_speed == SPEED_100) {
1269 if (bp->req_duplex == DUPLEX_FULL)
1270 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_100FULL;
1271 else
1272 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_100HALF;
1273 } else if (bp->req_line_speed == SPEED_10) {
1274 if (bp->req_duplex == DUPLEX_FULL)
1275 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_10FULL;
1276 else
1277 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_10HALF;
1278 }
1279 }
1280
1281 if (pause_adv & (ADVERTISE_1000XPAUSE | ADVERTISE_PAUSE_CAP))
1282 speed_arg |= BNX2_NETLINK_SET_LINK_FC_SYM_PAUSE;
1283 if (pause_adv & (ADVERTISE_1000XPSE_ASYM | ADVERTISE_1000XPSE_ASYM))
1284 speed_arg |= BNX2_NETLINK_SET_LINK_FC_ASYM_PAUSE;
1285
1286 if (port == PORT_TP)
1287 speed_arg |= BNX2_NETLINK_SET_LINK_PHY_APP_REMOTE |
1288 BNX2_NETLINK_SET_LINK_ETH_AT_WIRESPEED;
1289
1290 REG_WR_IND(bp, bp->shmem_base + BNX2_DRV_MB_ARG0, speed_arg);
1291
1292 spin_unlock_bh(&bp->phy_lock);
1293 bnx2_fw_sync(bp, BNX2_DRV_MSG_CODE_CMD_SET_LINK, 0);
1294 spin_lock_bh(&bp->phy_lock);
1295
1296 return 0;
1297}
1298
1299static int
1300bnx2_setup_serdes_phy(struct bnx2 *bp, u8 port)
Michael Chanb6016b72005-05-26 13:03:09 -07001301{
Michael Chan605a9e22007-05-03 13:23:13 -07001302 u32 adv, bmcr;
Michael Chanb6016b72005-05-26 13:03:09 -07001303 u32 new_adv = 0;
1304
Michael Chan0d8a6572007-07-07 22:49:43 -07001305 if (bp->phy_flags & REMOTE_PHY_CAP_FLAG)
1306 return (bnx2_setup_remote_phy(bp, port));
1307
Michael Chanb6016b72005-05-26 13:03:09 -07001308 if (!(bp->autoneg & AUTONEG_SPEED)) {
1309 u32 new_bmcr;
Michael Chan5b0c76a2005-11-04 08:45:49 -08001310 int force_link_down = 0;
1311
Michael Chan605a9e22007-05-03 13:23:13 -07001312 if (bp->req_line_speed == SPEED_2500) {
1313 if (!bnx2_test_and_enable_2g5(bp))
1314 force_link_down = 1;
1315 } else if (bp->req_line_speed == SPEED_1000) {
1316 if (bnx2_test_and_disable_2g5(bp))
1317 force_link_down = 1;
1318 }
Michael Chanca58c3a2007-05-03 13:22:52 -07001319 bnx2_read_phy(bp, bp->mii_adv, &adv);
Michael Chan80be4432006-11-19 14:07:28 -08001320 adv &= ~(ADVERTISE_1000XFULL | ADVERTISE_1000XHALF);
1321
Michael Chanca58c3a2007-05-03 13:22:52 -07001322 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
Michael Chan605a9e22007-05-03 13:23:13 -07001323 new_bmcr = bmcr & ~BMCR_ANENABLE;
Michael Chan80be4432006-11-19 14:07:28 -08001324 new_bmcr |= BMCR_SPEED1000;
Michael Chan605a9e22007-05-03 13:23:13 -07001325
Michael Chan27a005b2007-05-03 13:23:41 -07001326 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
1327 if (bp->req_line_speed == SPEED_2500)
1328 bnx2_enable_forced_2g5(bp);
1329 else if (bp->req_line_speed == SPEED_1000) {
1330 bnx2_disable_forced_2g5(bp);
1331 new_bmcr &= ~0x2000;
1332 }
1333
1334 } else if (CHIP_NUM(bp) == CHIP_NUM_5708) {
Michael Chan605a9e22007-05-03 13:23:13 -07001335 if (bp->req_line_speed == SPEED_2500)
1336 new_bmcr |= BCM5708S_BMCR_FORCE_2500;
1337 else
1338 new_bmcr = bmcr & ~BCM5708S_BMCR_FORCE_2500;
Michael Chan5b0c76a2005-11-04 08:45:49 -08001339 }
1340
Michael Chanb6016b72005-05-26 13:03:09 -07001341 if (bp->req_duplex == DUPLEX_FULL) {
Michael Chan5b0c76a2005-11-04 08:45:49 -08001342 adv |= ADVERTISE_1000XFULL;
Michael Chanb6016b72005-05-26 13:03:09 -07001343 new_bmcr |= BMCR_FULLDPLX;
1344 }
1345 else {
Michael Chan5b0c76a2005-11-04 08:45:49 -08001346 adv |= ADVERTISE_1000XHALF;
Michael Chanb6016b72005-05-26 13:03:09 -07001347 new_bmcr &= ~BMCR_FULLDPLX;
1348 }
Michael Chan5b0c76a2005-11-04 08:45:49 -08001349 if ((new_bmcr != bmcr) || (force_link_down)) {
Michael Chanb6016b72005-05-26 13:03:09 -07001350 /* Force a link down visible on the other side */
1351 if (bp->link_up) {
Michael Chanca58c3a2007-05-03 13:22:52 -07001352 bnx2_write_phy(bp, bp->mii_adv, adv &
Michael Chan5b0c76a2005-11-04 08:45:49 -08001353 ~(ADVERTISE_1000XFULL |
1354 ADVERTISE_1000XHALF));
Michael Chanca58c3a2007-05-03 13:22:52 -07001355 bnx2_write_phy(bp, bp->mii_bmcr, bmcr |
Michael Chanb6016b72005-05-26 13:03:09 -07001356 BMCR_ANRESTART | BMCR_ANENABLE);
1357
1358 bp->link_up = 0;
1359 netif_carrier_off(bp->dev);
Michael Chanca58c3a2007-05-03 13:22:52 -07001360 bnx2_write_phy(bp, bp->mii_bmcr, new_bmcr);
Michael Chan80be4432006-11-19 14:07:28 -08001361 bnx2_report_link(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07001362 }
Michael Chanca58c3a2007-05-03 13:22:52 -07001363 bnx2_write_phy(bp, bp->mii_adv, adv);
1364 bnx2_write_phy(bp, bp->mii_bmcr, new_bmcr);
Michael Chan605a9e22007-05-03 13:23:13 -07001365 } else {
1366 bnx2_resolve_flow_ctrl(bp);
1367 bnx2_set_mac_link(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07001368 }
1369 return 0;
1370 }
1371
Michael Chan605a9e22007-05-03 13:23:13 -07001372 bnx2_test_and_enable_2g5(bp);
Michael Chan5b0c76a2005-11-04 08:45:49 -08001373
Michael Chanb6016b72005-05-26 13:03:09 -07001374 if (bp->advertising & ADVERTISED_1000baseT_Full)
1375 new_adv |= ADVERTISE_1000XFULL;
1376
1377 new_adv |= bnx2_phy_get_pause_adv(bp);
1378
Michael Chanca58c3a2007-05-03 13:22:52 -07001379 bnx2_read_phy(bp, bp->mii_adv, &adv);
1380 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
Michael Chanb6016b72005-05-26 13:03:09 -07001381
1382 bp->serdes_an_pending = 0;
1383 if ((adv != new_adv) || ((bmcr & BMCR_ANENABLE) == 0)) {
1384 /* Force a link down visible on the other side */
1385 if (bp->link_up) {
Michael Chanca58c3a2007-05-03 13:22:52 -07001386 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK);
Michael Chan80be4432006-11-19 14:07:28 -08001387 spin_unlock_bh(&bp->phy_lock);
1388 msleep(20);
1389 spin_lock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07001390 }
1391
Michael Chanca58c3a2007-05-03 13:22:52 -07001392 bnx2_write_phy(bp, bp->mii_adv, new_adv);
1393 bnx2_write_phy(bp, bp->mii_bmcr, bmcr | BMCR_ANRESTART |
Michael Chanb6016b72005-05-26 13:03:09 -07001394 BMCR_ANENABLE);
Michael Chanf8dd0642006-11-19 14:08:29 -08001395 /* Speed up link-up time when the link partner
1396 * does not autonegotiate which is very common
1397 * in blade servers. Some blade servers use
1398 * IPMI for kerboard input and it's important
1399 * to minimize link disruptions. Autoneg. involves
1400 * exchanging base pages plus 3 next pages and
1401 * normally completes in about 120 msec.
1402 */
1403 bp->current_interval = SERDES_AN_TIMEOUT;
1404 bp->serdes_an_pending = 1;
1405 mod_timer(&bp->timer, jiffies + bp->current_interval);
Michael Chan605a9e22007-05-03 13:23:13 -07001406 } else {
1407 bnx2_resolve_flow_ctrl(bp);
1408 bnx2_set_mac_link(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07001409 }
1410
1411 return 0;
1412}
1413
1414#define ETHTOOL_ALL_FIBRE_SPEED \
Michael Chandeaf3912007-07-07 22:48:00 -07001415 (bp->phy_flags & PHY_2_5G_CAPABLE_FLAG) ? \
1416 (ADVERTISED_2500baseX_Full | ADVERTISED_1000baseT_Full) :\
1417 (ADVERTISED_1000baseT_Full)
Michael Chanb6016b72005-05-26 13:03:09 -07001418
1419#define ETHTOOL_ALL_COPPER_SPEED \
1420 (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full | \
1421 ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full | \
1422 ADVERTISED_1000baseT_Full)
1423
1424#define PHY_ALL_10_100_SPEED (ADVERTISE_10HALF | ADVERTISE_10FULL | \
1425 ADVERTISE_100HALF | ADVERTISE_100FULL | ADVERTISE_CSMA)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001426
Michael Chanb6016b72005-05-26 13:03:09 -07001427#define PHY_ALL_1000_SPEED (ADVERTISE_1000HALF | ADVERTISE_1000FULL)
1428
Michael Chandeaf3912007-07-07 22:48:00 -07001429static void
Michael Chan0d8a6572007-07-07 22:49:43 -07001430bnx2_set_default_remote_link(struct bnx2 *bp)
1431{
1432 u32 link;
1433
1434 if (bp->phy_port == PORT_TP)
1435 link = REG_RD_IND(bp, bp->shmem_base + BNX2_RPHY_COPPER_LINK);
1436 else
1437 link = REG_RD_IND(bp, bp->shmem_base + BNX2_RPHY_SERDES_LINK);
1438
1439 if (link & BNX2_NETLINK_SET_LINK_ENABLE_AUTONEG) {
1440 bp->req_line_speed = 0;
1441 bp->autoneg |= AUTONEG_SPEED;
1442 bp->advertising = ADVERTISED_Autoneg;
1443 if (link & BNX2_NETLINK_SET_LINK_SPEED_10HALF)
1444 bp->advertising |= ADVERTISED_10baseT_Half;
1445 if (link & BNX2_NETLINK_SET_LINK_SPEED_10FULL)
1446 bp->advertising |= ADVERTISED_10baseT_Full;
1447 if (link & BNX2_NETLINK_SET_LINK_SPEED_100HALF)
1448 bp->advertising |= ADVERTISED_100baseT_Half;
1449 if (link & BNX2_NETLINK_SET_LINK_SPEED_100FULL)
1450 bp->advertising |= ADVERTISED_100baseT_Full;
1451 if (link & BNX2_NETLINK_SET_LINK_SPEED_1GFULL)
1452 bp->advertising |= ADVERTISED_1000baseT_Full;
1453 if (link & BNX2_NETLINK_SET_LINK_SPEED_2G5FULL)
1454 bp->advertising |= ADVERTISED_2500baseX_Full;
1455 } else {
1456 bp->autoneg = 0;
1457 bp->advertising = 0;
1458 bp->req_duplex = DUPLEX_FULL;
1459 if (link & BNX2_NETLINK_SET_LINK_SPEED_10) {
1460 bp->req_line_speed = SPEED_10;
1461 if (link & BNX2_NETLINK_SET_LINK_SPEED_10HALF)
1462 bp->req_duplex = DUPLEX_HALF;
1463 }
1464 if (link & BNX2_NETLINK_SET_LINK_SPEED_100) {
1465 bp->req_line_speed = SPEED_100;
1466 if (link & BNX2_NETLINK_SET_LINK_SPEED_100HALF)
1467 bp->req_duplex = DUPLEX_HALF;
1468 }
1469 if (link & BNX2_NETLINK_SET_LINK_SPEED_1GFULL)
1470 bp->req_line_speed = SPEED_1000;
1471 if (link & BNX2_NETLINK_SET_LINK_SPEED_2G5FULL)
1472 bp->req_line_speed = SPEED_2500;
1473 }
1474}
1475
1476static void
Michael Chandeaf3912007-07-07 22:48:00 -07001477bnx2_set_default_link(struct bnx2 *bp)
1478{
Michael Chan0d8a6572007-07-07 22:49:43 -07001479 if (bp->phy_flags & REMOTE_PHY_CAP_FLAG)
1480 return bnx2_set_default_remote_link(bp);
1481
Michael Chandeaf3912007-07-07 22:48:00 -07001482 bp->autoneg = AUTONEG_SPEED | AUTONEG_FLOW_CTRL;
1483 bp->req_line_speed = 0;
1484 if (bp->phy_flags & PHY_SERDES_FLAG) {
1485 u32 reg;
1486
1487 bp->advertising = ETHTOOL_ALL_FIBRE_SPEED | ADVERTISED_Autoneg;
1488
1489 reg = REG_RD_IND(bp, bp->shmem_base + BNX2_PORT_HW_CFG_CONFIG);
1490 reg &= BNX2_PORT_HW_CFG_CFG_DFLT_LINK_MASK;
1491 if (reg == BNX2_PORT_HW_CFG_CFG_DFLT_LINK_1G) {
1492 bp->autoneg = 0;
1493 bp->req_line_speed = bp->line_speed = SPEED_1000;
1494 bp->req_duplex = DUPLEX_FULL;
1495 }
1496 } else
1497 bp->advertising = ETHTOOL_ALL_COPPER_SPEED | ADVERTISED_Autoneg;
1498}
1499
Michael Chan0d8a6572007-07-07 22:49:43 -07001500static void
Michael Chandf149d72007-07-07 22:51:36 -07001501bnx2_send_heart_beat(struct bnx2 *bp)
1502{
1503 u32 msg;
1504 u32 addr;
1505
1506 spin_lock(&bp->indirect_lock);
1507 msg = (u32) (++bp->fw_drv_pulse_wr_seq & BNX2_DRV_PULSE_SEQ_MASK);
1508 addr = bp->shmem_base + BNX2_DRV_PULSE_MB;
1509 REG_WR(bp, BNX2_PCICFG_REG_WINDOW_ADDRESS, addr);
1510 REG_WR(bp, BNX2_PCICFG_REG_WINDOW, msg);
1511 spin_unlock(&bp->indirect_lock);
1512}
1513
1514static void
Michael Chan0d8a6572007-07-07 22:49:43 -07001515bnx2_remote_phy_event(struct bnx2 *bp)
1516{
1517 u32 msg;
1518 u8 link_up = bp->link_up;
1519 u8 old_port;
1520
1521 msg = REG_RD_IND(bp, bp->shmem_base + BNX2_LINK_STATUS);
1522
Michael Chandf149d72007-07-07 22:51:36 -07001523 if (msg & BNX2_LINK_STATUS_HEART_BEAT_EXPIRED)
1524 bnx2_send_heart_beat(bp);
1525
1526 msg &= ~BNX2_LINK_STATUS_HEART_BEAT_EXPIRED;
1527
Michael Chan0d8a6572007-07-07 22:49:43 -07001528 if ((msg & BNX2_LINK_STATUS_LINK_UP) == BNX2_LINK_STATUS_LINK_DOWN)
1529 bp->link_up = 0;
1530 else {
1531 u32 speed;
1532
1533 bp->link_up = 1;
1534 speed = msg & BNX2_LINK_STATUS_SPEED_MASK;
1535 bp->duplex = DUPLEX_FULL;
1536 switch (speed) {
1537 case BNX2_LINK_STATUS_10HALF:
1538 bp->duplex = DUPLEX_HALF;
1539 case BNX2_LINK_STATUS_10FULL:
1540 bp->line_speed = SPEED_10;
1541 break;
1542 case BNX2_LINK_STATUS_100HALF:
1543 bp->duplex = DUPLEX_HALF;
1544 case BNX2_LINK_STATUS_100BASE_T4:
1545 case BNX2_LINK_STATUS_100FULL:
1546 bp->line_speed = SPEED_100;
1547 break;
1548 case BNX2_LINK_STATUS_1000HALF:
1549 bp->duplex = DUPLEX_HALF;
1550 case BNX2_LINK_STATUS_1000FULL:
1551 bp->line_speed = SPEED_1000;
1552 break;
1553 case BNX2_LINK_STATUS_2500HALF:
1554 bp->duplex = DUPLEX_HALF;
1555 case BNX2_LINK_STATUS_2500FULL:
1556 bp->line_speed = SPEED_2500;
1557 break;
1558 default:
1559 bp->line_speed = 0;
1560 break;
1561 }
1562
1563 spin_lock(&bp->phy_lock);
1564 bp->flow_ctrl = 0;
1565 if ((bp->autoneg & (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) !=
1566 (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) {
1567 if (bp->duplex == DUPLEX_FULL)
1568 bp->flow_ctrl = bp->req_flow_ctrl;
1569 } else {
1570 if (msg & BNX2_LINK_STATUS_TX_FC_ENABLED)
1571 bp->flow_ctrl |= FLOW_CTRL_TX;
1572 if (msg & BNX2_LINK_STATUS_RX_FC_ENABLED)
1573 bp->flow_ctrl |= FLOW_CTRL_RX;
1574 }
1575
1576 old_port = bp->phy_port;
1577 if (msg & BNX2_LINK_STATUS_SERDES_LINK)
1578 bp->phy_port = PORT_FIBRE;
1579 else
1580 bp->phy_port = PORT_TP;
1581
1582 if (old_port != bp->phy_port)
1583 bnx2_set_default_link(bp);
1584
1585 spin_unlock(&bp->phy_lock);
1586 }
1587 if (bp->link_up != link_up)
1588 bnx2_report_link(bp);
1589
1590 bnx2_set_mac_link(bp);
1591}
1592
1593static int
1594bnx2_set_remote_link(struct bnx2 *bp)
1595{
1596 u32 evt_code;
1597
1598 evt_code = REG_RD_IND(bp, bp->shmem_base + BNX2_FW_EVT_CODE_MB);
1599 switch (evt_code) {
1600 case BNX2_FW_EVT_CODE_LINK_EVENT:
1601 bnx2_remote_phy_event(bp);
1602 break;
1603 case BNX2_FW_EVT_CODE_SW_TIMER_EXPIRATION_EVENT:
1604 default:
Michael Chandf149d72007-07-07 22:51:36 -07001605 bnx2_send_heart_beat(bp);
Michael Chan0d8a6572007-07-07 22:49:43 -07001606 break;
1607 }
1608 return 0;
1609}
1610
Michael Chanb6016b72005-05-26 13:03:09 -07001611static int
1612bnx2_setup_copper_phy(struct bnx2 *bp)
1613{
1614 u32 bmcr;
1615 u32 new_bmcr;
1616
Michael Chanca58c3a2007-05-03 13:22:52 -07001617 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
Michael Chanb6016b72005-05-26 13:03:09 -07001618
1619 if (bp->autoneg & AUTONEG_SPEED) {
1620 u32 adv_reg, adv1000_reg;
1621 u32 new_adv_reg = 0;
1622 u32 new_adv1000_reg = 0;
1623
Michael Chanca58c3a2007-05-03 13:22:52 -07001624 bnx2_read_phy(bp, bp->mii_adv, &adv_reg);
Michael Chanb6016b72005-05-26 13:03:09 -07001625 adv_reg &= (PHY_ALL_10_100_SPEED | ADVERTISE_PAUSE_CAP |
1626 ADVERTISE_PAUSE_ASYM);
1627
1628 bnx2_read_phy(bp, MII_CTRL1000, &adv1000_reg);
1629 adv1000_reg &= PHY_ALL_1000_SPEED;
1630
1631 if (bp->advertising & ADVERTISED_10baseT_Half)
1632 new_adv_reg |= ADVERTISE_10HALF;
1633 if (bp->advertising & ADVERTISED_10baseT_Full)
1634 new_adv_reg |= ADVERTISE_10FULL;
1635 if (bp->advertising & ADVERTISED_100baseT_Half)
1636 new_adv_reg |= ADVERTISE_100HALF;
1637 if (bp->advertising & ADVERTISED_100baseT_Full)
1638 new_adv_reg |= ADVERTISE_100FULL;
1639 if (bp->advertising & ADVERTISED_1000baseT_Full)
1640 new_adv1000_reg |= ADVERTISE_1000FULL;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001641
Michael Chanb6016b72005-05-26 13:03:09 -07001642 new_adv_reg |= ADVERTISE_CSMA;
1643
1644 new_adv_reg |= bnx2_phy_get_pause_adv(bp);
1645
1646 if ((adv1000_reg != new_adv1000_reg) ||
1647 (adv_reg != new_adv_reg) ||
1648 ((bmcr & BMCR_ANENABLE) == 0)) {
1649
Michael Chanca58c3a2007-05-03 13:22:52 -07001650 bnx2_write_phy(bp, bp->mii_adv, new_adv_reg);
Michael Chanb6016b72005-05-26 13:03:09 -07001651 bnx2_write_phy(bp, MII_CTRL1000, new_adv1000_reg);
Michael Chanca58c3a2007-05-03 13:22:52 -07001652 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_ANRESTART |
Michael Chanb6016b72005-05-26 13:03:09 -07001653 BMCR_ANENABLE);
1654 }
1655 else if (bp->link_up) {
1656 /* Flow ctrl may have changed from auto to forced */
1657 /* or vice-versa. */
1658
1659 bnx2_resolve_flow_ctrl(bp);
1660 bnx2_set_mac_link(bp);
1661 }
1662 return 0;
1663 }
1664
1665 new_bmcr = 0;
1666 if (bp->req_line_speed == SPEED_100) {
1667 new_bmcr |= BMCR_SPEED100;
1668 }
1669 if (bp->req_duplex == DUPLEX_FULL) {
1670 new_bmcr |= BMCR_FULLDPLX;
1671 }
1672 if (new_bmcr != bmcr) {
1673 u32 bmsr;
Michael Chanb6016b72005-05-26 13:03:09 -07001674
Michael Chanca58c3a2007-05-03 13:22:52 -07001675 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
1676 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001677
Michael Chanb6016b72005-05-26 13:03:09 -07001678 if (bmsr & BMSR_LSTATUS) {
1679 /* Force link down */
Michael Chanca58c3a2007-05-03 13:22:52 -07001680 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK);
Michael Chana16dda02006-11-19 14:08:56 -08001681 spin_unlock_bh(&bp->phy_lock);
1682 msleep(50);
1683 spin_lock_bh(&bp->phy_lock);
1684
Michael Chanca58c3a2007-05-03 13:22:52 -07001685 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
1686 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
Michael Chanb6016b72005-05-26 13:03:09 -07001687 }
1688
Michael Chanca58c3a2007-05-03 13:22:52 -07001689 bnx2_write_phy(bp, bp->mii_bmcr, new_bmcr);
Michael Chanb6016b72005-05-26 13:03:09 -07001690
1691 /* Normally, the new speed is setup after the link has
1692 * gone down and up again. In some cases, link will not go
1693 * down so we need to set up the new speed here.
1694 */
1695 if (bmsr & BMSR_LSTATUS) {
1696 bp->line_speed = bp->req_line_speed;
1697 bp->duplex = bp->req_duplex;
1698 bnx2_resolve_flow_ctrl(bp);
1699 bnx2_set_mac_link(bp);
1700 }
Michael Chan27a005b2007-05-03 13:23:41 -07001701 } else {
1702 bnx2_resolve_flow_ctrl(bp);
1703 bnx2_set_mac_link(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07001704 }
1705 return 0;
1706}
1707
1708static int
Michael Chan0d8a6572007-07-07 22:49:43 -07001709bnx2_setup_phy(struct bnx2 *bp, u8 port)
Michael Chanb6016b72005-05-26 13:03:09 -07001710{
1711 if (bp->loopback == MAC_LOOPBACK)
1712 return 0;
1713
1714 if (bp->phy_flags & PHY_SERDES_FLAG) {
Michael Chan0d8a6572007-07-07 22:49:43 -07001715 return (bnx2_setup_serdes_phy(bp, port));
Michael Chanb6016b72005-05-26 13:03:09 -07001716 }
1717 else {
1718 return (bnx2_setup_copper_phy(bp));
1719 }
1720}
1721
1722static int
Michael Chan27a005b2007-05-03 13:23:41 -07001723bnx2_init_5709s_phy(struct bnx2 *bp)
1724{
1725 u32 val;
1726
1727 bp->mii_bmcr = MII_BMCR + 0x10;
1728 bp->mii_bmsr = MII_BMSR + 0x10;
1729 bp->mii_bmsr1 = MII_BNX2_GP_TOP_AN_STATUS1;
1730 bp->mii_adv = MII_ADVERTISE + 0x10;
1731 bp->mii_lpa = MII_LPA + 0x10;
1732 bp->mii_up1 = MII_BNX2_OVER1G_UP1;
1733
1734 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_AER);
1735 bnx2_write_phy(bp, MII_BNX2_AER_AER, MII_BNX2_AER_AER_AN_MMD);
1736
1737 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1738 bnx2_reset_phy(bp);
1739
1740 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_SERDES_DIG);
1741
1742 bnx2_read_phy(bp, MII_BNX2_SERDES_DIG_1000XCTL1, &val);
1743 val &= ~MII_BNX2_SD_1000XCTL1_AUTODET;
1744 val |= MII_BNX2_SD_1000XCTL1_FIBER;
1745 bnx2_write_phy(bp, MII_BNX2_SERDES_DIG_1000XCTL1, val);
1746
1747 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_OVER1G);
1748 bnx2_read_phy(bp, MII_BNX2_OVER1G_UP1, &val);
1749 if (bp->phy_flags & PHY_2_5G_CAPABLE_FLAG)
1750 val |= BCM5708S_UP1_2G5;
1751 else
1752 val &= ~BCM5708S_UP1_2G5;
1753 bnx2_write_phy(bp, MII_BNX2_OVER1G_UP1, val);
1754
1755 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_BAM_NXTPG);
1756 bnx2_read_phy(bp, MII_BNX2_BAM_NXTPG_CTL, &val);
1757 val |= MII_BNX2_NXTPG_CTL_T2 | MII_BNX2_NXTPG_CTL_BAM;
1758 bnx2_write_phy(bp, MII_BNX2_BAM_NXTPG_CTL, val);
1759
1760 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_CL73_USERB0);
1761
1762 val = MII_BNX2_CL73_BAM_EN | MII_BNX2_CL73_BAM_STA_MGR_EN |
1763 MII_BNX2_CL73_BAM_NP_AFT_BP_EN;
1764 bnx2_write_phy(bp, MII_BNX2_CL73_BAM_CTL1, val);
1765
1766 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1767
1768 return 0;
1769}
1770
1771static int
Michael Chan5b0c76a2005-11-04 08:45:49 -08001772bnx2_init_5708s_phy(struct bnx2 *bp)
1773{
1774 u32 val;
1775
Michael Chan27a005b2007-05-03 13:23:41 -07001776 bnx2_reset_phy(bp);
1777
1778 bp->mii_up1 = BCM5708S_UP1;
1779
Michael Chan5b0c76a2005-11-04 08:45:49 -08001780 bnx2_write_phy(bp, BCM5708S_BLK_ADDR, BCM5708S_BLK_ADDR_DIG3);
1781 bnx2_write_phy(bp, BCM5708S_DIG_3_0, BCM5708S_DIG_3_0_USE_IEEE);
1782 bnx2_write_phy(bp, BCM5708S_BLK_ADDR, BCM5708S_BLK_ADDR_DIG);
1783
1784 bnx2_read_phy(bp, BCM5708S_1000X_CTL1, &val);
1785 val |= BCM5708S_1000X_CTL1_FIBER_MODE | BCM5708S_1000X_CTL1_AUTODET_EN;
1786 bnx2_write_phy(bp, BCM5708S_1000X_CTL1, val);
1787
1788 bnx2_read_phy(bp, BCM5708S_1000X_CTL2, &val);
1789 val |= BCM5708S_1000X_CTL2_PLLEL_DET_EN;
1790 bnx2_write_phy(bp, BCM5708S_1000X_CTL2, val);
1791
1792 if (bp->phy_flags & PHY_2_5G_CAPABLE_FLAG) {
1793 bnx2_read_phy(bp, BCM5708S_UP1, &val);
1794 val |= BCM5708S_UP1_2G5;
1795 bnx2_write_phy(bp, BCM5708S_UP1, val);
1796 }
1797
1798 if ((CHIP_ID(bp) == CHIP_ID_5708_A0) ||
Michael Chandda1e392006-01-23 16:08:14 -08001799 (CHIP_ID(bp) == CHIP_ID_5708_B0) ||
1800 (CHIP_ID(bp) == CHIP_ID_5708_B1)) {
Michael Chan5b0c76a2005-11-04 08:45:49 -08001801 /* increase tx signal amplitude */
1802 bnx2_write_phy(bp, BCM5708S_BLK_ADDR,
1803 BCM5708S_BLK_ADDR_TX_MISC);
1804 bnx2_read_phy(bp, BCM5708S_TX_ACTL1, &val);
1805 val &= ~BCM5708S_TX_ACTL1_DRIVER_VCM;
1806 bnx2_write_phy(bp, BCM5708S_TX_ACTL1, val);
1807 bnx2_write_phy(bp, BCM5708S_BLK_ADDR, BCM5708S_BLK_ADDR_DIG);
1808 }
1809
Michael Chane3648b32005-11-04 08:51:21 -08001810 val = REG_RD_IND(bp, bp->shmem_base + BNX2_PORT_HW_CFG_CONFIG) &
Michael Chan5b0c76a2005-11-04 08:45:49 -08001811 BNX2_PORT_HW_CFG_CFG_TXCTL3_MASK;
1812
1813 if (val) {
1814 u32 is_backplane;
1815
Michael Chane3648b32005-11-04 08:51:21 -08001816 is_backplane = REG_RD_IND(bp, bp->shmem_base +
Michael Chan5b0c76a2005-11-04 08:45:49 -08001817 BNX2_SHARED_HW_CFG_CONFIG);
1818 if (is_backplane & BNX2_SHARED_HW_CFG_PHY_BACKPLANE) {
1819 bnx2_write_phy(bp, BCM5708S_BLK_ADDR,
1820 BCM5708S_BLK_ADDR_TX_MISC);
1821 bnx2_write_phy(bp, BCM5708S_TX_ACTL3, val);
1822 bnx2_write_phy(bp, BCM5708S_BLK_ADDR,
1823 BCM5708S_BLK_ADDR_DIG);
1824 }
1825 }
1826 return 0;
1827}
1828
1829static int
1830bnx2_init_5706s_phy(struct bnx2 *bp)
Michael Chanb6016b72005-05-26 13:03:09 -07001831{
Michael Chan27a005b2007-05-03 13:23:41 -07001832 bnx2_reset_phy(bp);
1833
Michael Chanb6016b72005-05-26 13:03:09 -07001834 bp->phy_flags &= ~PHY_PARALLEL_DETECT_FLAG;
1835
Michael Chan59b47d82006-11-19 14:10:45 -08001836 if (CHIP_NUM(bp) == CHIP_NUM_5706)
1837 REG_WR(bp, BNX2_MISC_GP_HW_CTL0, 0x300);
Michael Chanb6016b72005-05-26 13:03:09 -07001838
1839 if (bp->dev->mtu > 1500) {
1840 u32 val;
1841
1842 /* Set extended packet length bit */
1843 bnx2_write_phy(bp, 0x18, 0x7);
1844 bnx2_read_phy(bp, 0x18, &val);
1845 bnx2_write_phy(bp, 0x18, (val & 0xfff8) | 0x4000);
1846
1847 bnx2_write_phy(bp, 0x1c, 0x6c00);
1848 bnx2_read_phy(bp, 0x1c, &val);
1849 bnx2_write_phy(bp, 0x1c, (val & 0x3ff) | 0xec02);
1850 }
1851 else {
1852 u32 val;
1853
1854 bnx2_write_phy(bp, 0x18, 0x7);
1855 bnx2_read_phy(bp, 0x18, &val);
1856 bnx2_write_phy(bp, 0x18, val & ~0x4007);
1857
1858 bnx2_write_phy(bp, 0x1c, 0x6c00);
1859 bnx2_read_phy(bp, 0x1c, &val);
1860 bnx2_write_phy(bp, 0x1c, (val & 0x3fd) | 0xec00);
1861 }
1862
1863 return 0;
1864}
1865
1866static int
1867bnx2_init_copper_phy(struct bnx2 *bp)
1868{
Michael Chan5b0c76a2005-11-04 08:45:49 -08001869 u32 val;
1870
Michael Chan27a005b2007-05-03 13:23:41 -07001871 bnx2_reset_phy(bp);
1872
Michael Chanb6016b72005-05-26 13:03:09 -07001873 if (bp->phy_flags & PHY_CRC_FIX_FLAG) {
1874 bnx2_write_phy(bp, 0x18, 0x0c00);
1875 bnx2_write_phy(bp, 0x17, 0x000a);
1876 bnx2_write_phy(bp, 0x15, 0x310b);
1877 bnx2_write_phy(bp, 0x17, 0x201f);
1878 bnx2_write_phy(bp, 0x15, 0x9506);
1879 bnx2_write_phy(bp, 0x17, 0x401f);
1880 bnx2_write_phy(bp, 0x15, 0x14e2);
1881 bnx2_write_phy(bp, 0x18, 0x0400);
1882 }
1883
Michael Chanb659f442007-02-02 00:46:35 -08001884 if (bp->phy_flags & PHY_DIS_EARLY_DAC_FLAG) {
1885 bnx2_write_phy(bp, MII_BNX2_DSP_ADDRESS,
1886 MII_BNX2_DSP_EXPAND_REG | 0x8);
1887 bnx2_read_phy(bp, MII_BNX2_DSP_RW_PORT, &val);
1888 val &= ~(1 << 8);
1889 bnx2_write_phy(bp, MII_BNX2_DSP_RW_PORT, val);
1890 }
1891
Michael Chanb6016b72005-05-26 13:03:09 -07001892 if (bp->dev->mtu > 1500) {
Michael Chanb6016b72005-05-26 13:03:09 -07001893 /* Set extended packet length bit */
1894 bnx2_write_phy(bp, 0x18, 0x7);
1895 bnx2_read_phy(bp, 0x18, &val);
1896 bnx2_write_phy(bp, 0x18, val | 0x4000);
1897
1898 bnx2_read_phy(bp, 0x10, &val);
1899 bnx2_write_phy(bp, 0x10, val | 0x1);
1900 }
1901 else {
Michael Chanb6016b72005-05-26 13:03:09 -07001902 bnx2_write_phy(bp, 0x18, 0x7);
1903 bnx2_read_phy(bp, 0x18, &val);
1904 bnx2_write_phy(bp, 0x18, val & ~0x4007);
1905
1906 bnx2_read_phy(bp, 0x10, &val);
1907 bnx2_write_phy(bp, 0x10, val & ~0x1);
1908 }
1909
Michael Chan5b0c76a2005-11-04 08:45:49 -08001910 /* ethernet@wirespeed */
1911 bnx2_write_phy(bp, 0x18, 0x7007);
1912 bnx2_read_phy(bp, 0x18, &val);
1913 bnx2_write_phy(bp, 0x18, val | (1 << 15) | (1 << 4));
Michael Chanb6016b72005-05-26 13:03:09 -07001914 return 0;
1915}
1916
1917
1918static int
1919bnx2_init_phy(struct bnx2 *bp)
1920{
1921 u32 val;
1922 int rc = 0;
1923
1924 bp->phy_flags &= ~PHY_INT_MODE_MASK_FLAG;
1925 bp->phy_flags |= PHY_INT_MODE_LINK_READY_FLAG;
1926
Michael Chanca58c3a2007-05-03 13:22:52 -07001927 bp->mii_bmcr = MII_BMCR;
1928 bp->mii_bmsr = MII_BMSR;
Michael Chan27a005b2007-05-03 13:23:41 -07001929 bp->mii_bmsr1 = MII_BMSR;
Michael Chanca58c3a2007-05-03 13:22:52 -07001930 bp->mii_adv = MII_ADVERTISE;
1931 bp->mii_lpa = MII_LPA;
1932
Michael Chanb6016b72005-05-26 13:03:09 -07001933 REG_WR(bp, BNX2_EMAC_ATTENTION_ENA, BNX2_EMAC_ATTENTION_ENA_LINK);
1934
Michael Chan0d8a6572007-07-07 22:49:43 -07001935 if (bp->phy_flags & REMOTE_PHY_CAP_FLAG)
1936 goto setup_phy;
1937
Michael Chanb6016b72005-05-26 13:03:09 -07001938 bnx2_read_phy(bp, MII_PHYSID1, &val);
1939 bp->phy_id = val << 16;
1940 bnx2_read_phy(bp, MII_PHYSID2, &val);
1941 bp->phy_id |= val & 0xffff;
1942
1943 if (bp->phy_flags & PHY_SERDES_FLAG) {
Michael Chan5b0c76a2005-11-04 08:45:49 -08001944 if (CHIP_NUM(bp) == CHIP_NUM_5706)
1945 rc = bnx2_init_5706s_phy(bp);
1946 else if (CHIP_NUM(bp) == CHIP_NUM_5708)
1947 rc = bnx2_init_5708s_phy(bp);
Michael Chan27a005b2007-05-03 13:23:41 -07001948 else if (CHIP_NUM(bp) == CHIP_NUM_5709)
1949 rc = bnx2_init_5709s_phy(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07001950 }
1951 else {
1952 rc = bnx2_init_copper_phy(bp);
1953 }
1954
Michael Chan0d8a6572007-07-07 22:49:43 -07001955setup_phy:
1956 if (!rc)
1957 rc = bnx2_setup_phy(bp, bp->phy_port);
Michael Chanb6016b72005-05-26 13:03:09 -07001958
1959 return rc;
1960}
1961
1962static int
1963bnx2_set_mac_loopback(struct bnx2 *bp)
1964{
1965 u32 mac_mode;
1966
1967 mac_mode = REG_RD(bp, BNX2_EMAC_MODE);
1968 mac_mode &= ~BNX2_EMAC_MODE_PORT;
1969 mac_mode |= BNX2_EMAC_MODE_MAC_LOOP | BNX2_EMAC_MODE_FORCE_LINK;
1970 REG_WR(bp, BNX2_EMAC_MODE, mac_mode);
1971 bp->link_up = 1;
1972 return 0;
1973}
1974
Michael Chanbc5a0692006-01-23 16:13:22 -08001975static int bnx2_test_link(struct bnx2 *);
1976
1977static int
1978bnx2_set_phy_loopback(struct bnx2 *bp)
1979{
1980 u32 mac_mode;
1981 int rc, i;
1982
1983 spin_lock_bh(&bp->phy_lock);
Michael Chanca58c3a2007-05-03 13:22:52 -07001984 rc = bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK | BMCR_FULLDPLX |
Michael Chanbc5a0692006-01-23 16:13:22 -08001985 BMCR_SPEED1000);
1986 spin_unlock_bh(&bp->phy_lock);
1987 if (rc)
1988 return rc;
1989
1990 for (i = 0; i < 10; i++) {
1991 if (bnx2_test_link(bp) == 0)
1992 break;
Michael Chan80be4432006-11-19 14:07:28 -08001993 msleep(100);
Michael Chanbc5a0692006-01-23 16:13:22 -08001994 }
1995
1996 mac_mode = REG_RD(bp, BNX2_EMAC_MODE);
1997 mac_mode &= ~(BNX2_EMAC_MODE_PORT | BNX2_EMAC_MODE_HALF_DUPLEX |
1998 BNX2_EMAC_MODE_MAC_LOOP | BNX2_EMAC_MODE_FORCE_LINK |
Michael Chan59b47d82006-11-19 14:10:45 -08001999 BNX2_EMAC_MODE_25G_MODE);
Michael Chanbc5a0692006-01-23 16:13:22 -08002000
2001 mac_mode |= BNX2_EMAC_MODE_PORT_GMII;
2002 REG_WR(bp, BNX2_EMAC_MODE, mac_mode);
2003 bp->link_up = 1;
2004 return 0;
2005}
2006
Michael Chanb6016b72005-05-26 13:03:09 -07002007static int
Michael Chanb090ae22006-01-23 16:07:10 -08002008bnx2_fw_sync(struct bnx2 *bp, u32 msg_data, int silent)
Michael Chanb6016b72005-05-26 13:03:09 -07002009{
2010 int i;
2011 u32 val;
2012
Michael Chanb6016b72005-05-26 13:03:09 -07002013 bp->fw_wr_seq++;
2014 msg_data |= bp->fw_wr_seq;
2015
Michael Chane3648b32005-11-04 08:51:21 -08002016 REG_WR_IND(bp, bp->shmem_base + BNX2_DRV_MB, msg_data);
Michael Chanb6016b72005-05-26 13:03:09 -07002017
2018 /* wait for an acknowledgement. */
Michael Chanb090ae22006-01-23 16:07:10 -08002019 for (i = 0; i < (FW_ACK_TIME_OUT_MS / 10); i++) {
2020 msleep(10);
Michael Chanb6016b72005-05-26 13:03:09 -07002021
Michael Chane3648b32005-11-04 08:51:21 -08002022 val = REG_RD_IND(bp, bp->shmem_base + BNX2_FW_MB);
Michael Chanb6016b72005-05-26 13:03:09 -07002023
2024 if ((val & BNX2_FW_MSG_ACK) == (msg_data & BNX2_DRV_MSG_SEQ))
2025 break;
2026 }
Michael Chanb090ae22006-01-23 16:07:10 -08002027 if ((msg_data & BNX2_DRV_MSG_DATA) == BNX2_DRV_MSG_DATA_WAIT0)
2028 return 0;
Michael Chanb6016b72005-05-26 13:03:09 -07002029
2030 /* If we timed out, inform the firmware that this is the case. */
Michael Chanb090ae22006-01-23 16:07:10 -08002031 if ((val & BNX2_FW_MSG_ACK) != (msg_data & BNX2_DRV_MSG_SEQ)) {
2032 if (!silent)
2033 printk(KERN_ERR PFX "fw sync timeout, reset code = "
2034 "%x\n", msg_data);
Michael Chanb6016b72005-05-26 13:03:09 -07002035
2036 msg_data &= ~BNX2_DRV_MSG_CODE;
2037 msg_data |= BNX2_DRV_MSG_CODE_FW_TIMEOUT;
2038
Michael Chane3648b32005-11-04 08:51:21 -08002039 REG_WR_IND(bp, bp->shmem_base + BNX2_DRV_MB, msg_data);
Michael Chanb6016b72005-05-26 13:03:09 -07002040
Michael Chanb6016b72005-05-26 13:03:09 -07002041 return -EBUSY;
2042 }
2043
Michael Chanb090ae22006-01-23 16:07:10 -08002044 if ((val & BNX2_FW_MSG_STATUS_MASK) != BNX2_FW_MSG_STATUS_OK)
2045 return -EIO;
2046
Michael Chanb6016b72005-05-26 13:03:09 -07002047 return 0;
2048}
2049
Michael Chan59b47d82006-11-19 14:10:45 -08002050static int
2051bnx2_init_5709_context(struct bnx2 *bp)
2052{
2053 int i, ret = 0;
2054 u32 val;
2055
2056 val = BNX2_CTX_COMMAND_ENABLED | BNX2_CTX_COMMAND_MEM_INIT | (1 << 12);
2057 val |= (BCM_PAGE_BITS - 8) << 16;
2058 REG_WR(bp, BNX2_CTX_COMMAND, val);
Michael Chan641bdcd2007-06-04 21:22:24 -07002059 for (i = 0; i < 10; i++) {
2060 val = REG_RD(bp, BNX2_CTX_COMMAND);
2061 if (!(val & BNX2_CTX_COMMAND_MEM_INIT))
2062 break;
2063 udelay(2);
2064 }
2065 if (val & BNX2_CTX_COMMAND_MEM_INIT)
2066 return -EBUSY;
2067
Michael Chan59b47d82006-11-19 14:10:45 -08002068 for (i = 0; i < bp->ctx_pages; i++) {
2069 int j;
2070
2071 REG_WR(bp, BNX2_CTX_HOST_PAGE_TBL_DATA0,
2072 (bp->ctx_blk_mapping[i] & 0xffffffff) |
2073 BNX2_CTX_HOST_PAGE_TBL_DATA0_VALID);
2074 REG_WR(bp, BNX2_CTX_HOST_PAGE_TBL_DATA1,
2075 (u64) bp->ctx_blk_mapping[i] >> 32);
2076 REG_WR(bp, BNX2_CTX_HOST_PAGE_TBL_CTRL, i |
2077 BNX2_CTX_HOST_PAGE_TBL_CTRL_WRITE_REQ);
2078 for (j = 0; j < 10; j++) {
2079
2080 val = REG_RD(bp, BNX2_CTX_HOST_PAGE_TBL_CTRL);
2081 if (!(val & BNX2_CTX_HOST_PAGE_TBL_CTRL_WRITE_REQ))
2082 break;
2083 udelay(5);
2084 }
2085 if (val & BNX2_CTX_HOST_PAGE_TBL_CTRL_WRITE_REQ) {
2086 ret = -EBUSY;
2087 break;
2088 }
2089 }
2090 return ret;
2091}
2092
Michael Chanb6016b72005-05-26 13:03:09 -07002093static void
2094bnx2_init_context(struct bnx2 *bp)
2095{
2096 u32 vcid;
2097
2098 vcid = 96;
2099 while (vcid) {
2100 u32 vcid_addr, pcid_addr, offset;
Michael Chan7947b202007-06-04 21:17:10 -07002101 int i;
Michael Chanb6016b72005-05-26 13:03:09 -07002102
2103 vcid--;
2104
2105 if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
2106 u32 new_vcid;
2107
2108 vcid_addr = GET_PCID_ADDR(vcid);
2109 if (vcid & 0x8) {
2110 new_vcid = 0x60 + (vcid & 0xf0) + (vcid & 0x7);
2111 }
2112 else {
2113 new_vcid = vcid;
2114 }
2115 pcid_addr = GET_PCID_ADDR(new_vcid);
2116 }
2117 else {
2118 vcid_addr = GET_CID_ADDR(vcid);
2119 pcid_addr = vcid_addr;
2120 }
2121
Michael Chan7947b202007-06-04 21:17:10 -07002122 for (i = 0; i < (CTX_SIZE / PHY_CTX_SIZE); i++) {
2123 vcid_addr += (i << PHY_CTX_SHIFT);
2124 pcid_addr += (i << PHY_CTX_SHIFT);
Michael Chanb6016b72005-05-26 13:03:09 -07002125
Michael Chan7947b202007-06-04 21:17:10 -07002126 REG_WR(bp, BNX2_CTX_VIRT_ADDR, 0x00);
2127 REG_WR(bp, BNX2_CTX_PAGE_TBL, pcid_addr);
2128
2129 /* Zero out the context. */
2130 for (offset = 0; offset < PHY_CTX_SIZE; offset += 4)
2131 CTX_WR(bp, 0x00, offset, 0);
2132
2133 REG_WR(bp, BNX2_CTX_VIRT_ADDR, vcid_addr);
2134 REG_WR(bp, BNX2_CTX_PAGE_TBL, pcid_addr);
Michael Chanb6016b72005-05-26 13:03:09 -07002135 }
Michael Chanb6016b72005-05-26 13:03:09 -07002136 }
2137}
2138
2139static int
2140bnx2_alloc_bad_rbuf(struct bnx2 *bp)
2141{
2142 u16 *good_mbuf;
2143 u32 good_mbuf_cnt;
2144 u32 val;
2145
2146 good_mbuf = kmalloc(512 * sizeof(u16), GFP_KERNEL);
2147 if (good_mbuf == NULL) {
2148 printk(KERN_ERR PFX "Failed to allocate memory in "
2149 "bnx2_alloc_bad_rbuf\n");
2150 return -ENOMEM;
2151 }
2152
2153 REG_WR(bp, BNX2_MISC_ENABLE_SET_BITS,
2154 BNX2_MISC_ENABLE_SET_BITS_RX_MBUF_ENABLE);
2155
2156 good_mbuf_cnt = 0;
2157
2158 /* Allocate a bunch of mbufs and save the good ones in an array. */
2159 val = REG_RD_IND(bp, BNX2_RBUF_STATUS1);
2160 while (val & BNX2_RBUF_STATUS1_FREE_COUNT) {
2161 REG_WR_IND(bp, BNX2_RBUF_COMMAND, BNX2_RBUF_COMMAND_ALLOC_REQ);
2162
2163 val = REG_RD_IND(bp, BNX2_RBUF_FW_BUF_ALLOC);
2164
2165 val &= BNX2_RBUF_FW_BUF_ALLOC_VALUE;
2166
2167 /* The addresses with Bit 9 set are bad memory blocks. */
2168 if (!(val & (1 << 9))) {
2169 good_mbuf[good_mbuf_cnt] = (u16) val;
2170 good_mbuf_cnt++;
2171 }
2172
2173 val = REG_RD_IND(bp, BNX2_RBUF_STATUS1);
2174 }
2175
2176 /* Free the good ones back to the mbuf pool thus discarding
2177 * all the bad ones. */
2178 while (good_mbuf_cnt) {
2179 good_mbuf_cnt--;
2180
2181 val = good_mbuf[good_mbuf_cnt];
2182 val = (val << 9) | val | 1;
2183
2184 REG_WR_IND(bp, BNX2_RBUF_FW_BUF_FREE, val);
2185 }
2186 kfree(good_mbuf);
2187 return 0;
2188}
2189
2190static void
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002191bnx2_set_mac_addr(struct bnx2 *bp)
Michael Chanb6016b72005-05-26 13:03:09 -07002192{
2193 u32 val;
2194 u8 *mac_addr = bp->dev->dev_addr;
2195
2196 val = (mac_addr[0] << 8) | mac_addr[1];
2197
2198 REG_WR(bp, BNX2_EMAC_MAC_MATCH0, val);
2199
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002200 val = (mac_addr[2] << 24) | (mac_addr[3] << 16) |
Michael Chanb6016b72005-05-26 13:03:09 -07002201 (mac_addr[4] << 8) | mac_addr[5];
2202
2203 REG_WR(bp, BNX2_EMAC_MAC_MATCH1, val);
2204}
2205
2206static inline int
2207bnx2_alloc_rx_skb(struct bnx2 *bp, u16 index)
2208{
2209 struct sk_buff *skb;
2210 struct sw_bd *rx_buf = &bp->rx_buf_ring[index];
2211 dma_addr_t mapping;
Michael Chan13daffa2006-03-20 17:49:20 -08002212 struct rx_bd *rxbd = &bp->rx_desc_ring[RX_RING(index)][RX_IDX(index)];
Michael Chanb6016b72005-05-26 13:03:09 -07002213 unsigned long align;
2214
Michael Chan932f3772006-08-15 01:39:36 -07002215 skb = netdev_alloc_skb(bp->dev, bp->rx_buf_size);
Michael Chanb6016b72005-05-26 13:03:09 -07002216 if (skb == NULL) {
2217 return -ENOMEM;
2218 }
2219
Michael Chan59b47d82006-11-19 14:10:45 -08002220 if (unlikely((align = (unsigned long) skb->data & (BNX2_RX_ALIGN - 1))))
2221 skb_reserve(skb, BNX2_RX_ALIGN - align);
Michael Chanb6016b72005-05-26 13:03:09 -07002222
Michael Chanb6016b72005-05-26 13:03:09 -07002223 mapping = pci_map_single(bp->pdev, skb->data, bp->rx_buf_use_size,
2224 PCI_DMA_FROMDEVICE);
2225
2226 rx_buf->skb = skb;
2227 pci_unmap_addr_set(rx_buf, mapping, mapping);
2228
2229 rxbd->rx_bd_haddr_hi = (u64) mapping >> 32;
2230 rxbd->rx_bd_haddr_lo = (u64) mapping & 0xffffffff;
2231
2232 bp->rx_prod_bseq += bp->rx_buf_use_size;
2233
2234 return 0;
2235}
2236
Michael Chanda3e4fb2007-05-03 13:24:23 -07002237static int
2238bnx2_phy_event_is_set(struct bnx2 *bp, u32 event)
2239{
2240 struct status_block *sblk = bp->status_blk;
2241 u32 new_link_state, old_link_state;
2242 int is_set = 1;
2243
2244 new_link_state = sblk->status_attn_bits & event;
2245 old_link_state = sblk->status_attn_bits_ack & event;
2246 if (new_link_state != old_link_state) {
2247 if (new_link_state)
2248 REG_WR(bp, BNX2_PCICFG_STATUS_BIT_SET_CMD, event);
2249 else
2250 REG_WR(bp, BNX2_PCICFG_STATUS_BIT_CLEAR_CMD, event);
2251 } else
2252 is_set = 0;
2253
2254 return is_set;
2255}
2256
Michael Chanb6016b72005-05-26 13:03:09 -07002257static void
2258bnx2_phy_int(struct bnx2 *bp)
2259{
Michael Chanda3e4fb2007-05-03 13:24:23 -07002260 if (bnx2_phy_event_is_set(bp, STATUS_ATTN_BITS_LINK_STATE)) {
2261 spin_lock(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07002262 bnx2_set_link(bp);
Michael Chanda3e4fb2007-05-03 13:24:23 -07002263 spin_unlock(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07002264 }
Michael Chan0d8a6572007-07-07 22:49:43 -07002265 if (bnx2_phy_event_is_set(bp, STATUS_ATTN_BITS_TIMER_ABORT))
2266 bnx2_set_remote_link(bp);
2267
Michael Chanb6016b72005-05-26 13:03:09 -07002268}
2269
2270static void
2271bnx2_tx_int(struct bnx2 *bp)
2272{
Michael Chanf4e418f2005-11-04 08:53:48 -08002273 struct status_block *sblk = bp->status_blk;
Michael Chanb6016b72005-05-26 13:03:09 -07002274 u16 hw_cons, sw_cons, sw_ring_cons;
2275 int tx_free_bd = 0;
2276
Michael Chanf4e418f2005-11-04 08:53:48 -08002277 hw_cons = bp->hw_tx_cons = sblk->status_tx_quick_consumer_index0;
Michael Chanb6016b72005-05-26 13:03:09 -07002278 if ((hw_cons & MAX_TX_DESC_CNT) == MAX_TX_DESC_CNT) {
2279 hw_cons++;
2280 }
2281 sw_cons = bp->tx_cons;
2282
2283 while (sw_cons != hw_cons) {
2284 struct sw_bd *tx_buf;
2285 struct sk_buff *skb;
2286 int i, last;
2287
2288 sw_ring_cons = TX_RING_IDX(sw_cons);
2289
2290 tx_buf = &bp->tx_buf_ring[sw_ring_cons];
2291 skb = tx_buf->skb;
Arjan van de Ven1d39ed52006-12-12 14:06:23 +01002292
Michael Chanb6016b72005-05-26 13:03:09 -07002293 /* partial BD completions possible with TSO packets */
Herbert Xu89114af2006-07-08 13:34:32 -07002294 if (skb_is_gso(skb)) {
Michael Chanb6016b72005-05-26 13:03:09 -07002295 u16 last_idx, last_ring_idx;
2296
2297 last_idx = sw_cons +
2298 skb_shinfo(skb)->nr_frags + 1;
2299 last_ring_idx = sw_ring_cons +
2300 skb_shinfo(skb)->nr_frags + 1;
2301 if (unlikely(last_ring_idx >= MAX_TX_DESC_CNT)) {
2302 last_idx++;
2303 }
2304 if (((s16) ((s16) last_idx - (s16) hw_cons)) > 0) {
2305 break;
2306 }
2307 }
Arjan van de Ven1d39ed52006-12-12 14:06:23 +01002308
Michael Chanb6016b72005-05-26 13:03:09 -07002309 pci_unmap_single(bp->pdev, pci_unmap_addr(tx_buf, mapping),
2310 skb_headlen(skb), PCI_DMA_TODEVICE);
2311
2312 tx_buf->skb = NULL;
2313 last = skb_shinfo(skb)->nr_frags;
2314
2315 for (i = 0; i < last; i++) {
2316 sw_cons = NEXT_TX_BD(sw_cons);
2317
2318 pci_unmap_page(bp->pdev,
2319 pci_unmap_addr(
2320 &bp->tx_buf_ring[TX_RING_IDX(sw_cons)],
2321 mapping),
2322 skb_shinfo(skb)->frags[i].size,
2323 PCI_DMA_TODEVICE);
2324 }
2325
2326 sw_cons = NEXT_TX_BD(sw_cons);
2327
2328 tx_free_bd += last + 1;
2329
Michael Chan745720e2006-06-29 12:37:41 -07002330 dev_kfree_skb(skb);
Michael Chanb6016b72005-05-26 13:03:09 -07002331
Michael Chanf4e418f2005-11-04 08:53:48 -08002332 hw_cons = bp->hw_tx_cons =
2333 sblk->status_tx_quick_consumer_index0;
2334
Michael Chanb6016b72005-05-26 13:03:09 -07002335 if ((hw_cons & MAX_TX_DESC_CNT) == MAX_TX_DESC_CNT) {
2336 hw_cons++;
2337 }
2338 }
2339
Michael Chane89bbf12005-08-25 15:36:58 -07002340 bp->tx_cons = sw_cons;
Michael Chan2f8af122006-08-15 01:39:10 -07002341 /* Need to make the tx_cons update visible to bnx2_start_xmit()
2342 * before checking for netif_queue_stopped(). Without the
2343 * memory barrier, there is a small possibility that bnx2_start_xmit()
2344 * will miss it and cause the queue to be stopped forever.
2345 */
2346 smp_mb();
Michael Chanb6016b72005-05-26 13:03:09 -07002347
Michael Chan2f8af122006-08-15 01:39:10 -07002348 if (unlikely(netif_queue_stopped(bp->dev)) &&
2349 (bnx2_tx_avail(bp) > bp->tx_wake_thresh)) {
2350 netif_tx_lock(bp->dev);
Michael Chanb6016b72005-05-26 13:03:09 -07002351 if ((netif_queue_stopped(bp->dev)) &&
Michael Chan2f8af122006-08-15 01:39:10 -07002352 (bnx2_tx_avail(bp) > bp->tx_wake_thresh))
Michael Chanb6016b72005-05-26 13:03:09 -07002353 netif_wake_queue(bp->dev);
Michael Chan2f8af122006-08-15 01:39:10 -07002354 netif_tx_unlock(bp->dev);
Michael Chanb6016b72005-05-26 13:03:09 -07002355 }
Michael Chanb6016b72005-05-26 13:03:09 -07002356}
2357
2358static inline void
2359bnx2_reuse_rx_skb(struct bnx2 *bp, struct sk_buff *skb,
2360 u16 cons, u16 prod)
2361{
Michael Chan236b6392006-03-20 17:49:02 -08002362 struct sw_bd *cons_rx_buf, *prod_rx_buf;
2363 struct rx_bd *cons_bd, *prod_bd;
2364
2365 cons_rx_buf = &bp->rx_buf_ring[cons];
2366 prod_rx_buf = &bp->rx_buf_ring[prod];
Michael Chanb6016b72005-05-26 13:03:09 -07002367
2368 pci_dma_sync_single_for_device(bp->pdev,
2369 pci_unmap_addr(cons_rx_buf, mapping),
2370 bp->rx_offset + RX_COPY_THRESH, PCI_DMA_FROMDEVICE);
2371
Michael Chan236b6392006-03-20 17:49:02 -08002372 bp->rx_prod_bseq += bp->rx_buf_use_size;
2373
2374 prod_rx_buf->skb = skb;
2375
2376 if (cons == prod)
2377 return;
2378
Michael Chanb6016b72005-05-26 13:03:09 -07002379 pci_unmap_addr_set(prod_rx_buf, mapping,
2380 pci_unmap_addr(cons_rx_buf, mapping));
2381
Michael Chan3fdfcc22006-03-20 17:49:49 -08002382 cons_bd = &bp->rx_desc_ring[RX_RING(cons)][RX_IDX(cons)];
2383 prod_bd = &bp->rx_desc_ring[RX_RING(prod)][RX_IDX(prod)];
Michael Chan236b6392006-03-20 17:49:02 -08002384 prod_bd->rx_bd_haddr_hi = cons_bd->rx_bd_haddr_hi;
2385 prod_bd->rx_bd_haddr_lo = cons_bd->rx_bd_haddr_lo;
Michael Chanb6016b72005-05-26 13:03:09 -07002386}
2387
2388static int
2389bnx2_rx_int(struct bnx2 *bp, int budget)
2390{
Michael Chanf4e418f2005-11-04 08:53:48 -08002391 struct status_block *sblk = bp->status_blk;
Michael Chanb6016b72005-05-26 13:03:09 -07002392 u16 hw_cons, sw_cons, sw_ring_cons, sw_prod, sw_ring_prod;
2393 struct l2_fhdr *rx_hdr;
2394 int rx_pkt = 0;
2395
Michael Chanf4e418f2005-11-04 08:53:48 -08002396 hw_cons = bp->hw_rx_cons = sblk->status_rx_quick_consumer_index0;
Michael Chanb6016b72005-05-26 13:03:09 -07002397 if ((hw_cons & MAX_RX_DESC_CNT) == MAX_RX_DESC_CNT) {
2398 hw_cons++;
2399 }
2400 sw_cons = bp->rx_cons;
2401 sw_prod = bp->rx_prod;
2402
2403 /* Memory barrier necessary as speculative reads of the rx
2404 * buffer can be ahead of the index in the status block
2405 */
2406 rmb();
2407 while (sw_cons != hw_cons) {
2408 unsigned int len;
Michael Chanade2bfe2006-01-23 16:09:51 -08002409 u32 status;
Michael Chanb6016b72005-05-26 13:03:09 -07002410 struct sw_bd *rx_buf;
2411 struct sk_buff *skb;
Michael Chan236b6392006-03-20 17:49:02 -08002412 dma_addr_t dma_addr;
Michael Chanb6016b72005-05-26 13:03:09 -07002413
2414 sw_ring_cons = RX_RING_IDX(sw_cons);
2415 sw_ring_prod = RX_RING_IDX(sw_prod);
2416
2417 rx_buf = &bp->rx_buf_ring[sw_ring_cons];
2418 skb = rx_buf->skb;
Michael Chan236b6392006-03-20 17:49:02 -08002419
2420 rx_buf->skb = NULL;
2421
2422 dma_addr = pci_unmap_addr(rx_buf, mapping);
2423
2424 pci_dma_sync_single_for_cpu(bp->pdev, dma_addr,
Michael Chanb6016b72005-05-26 13:03:09 -07002425 bp->rx_offset + RX_COPY_THRESH, PCI_DMA_FROMDEVICE);
2426
2427 rx_hdr = (struct l2_fhdr *) skb->data;
2428 len = rx_hdr->l2_fhdr_pkt_len - 4;
2429
Michael Chanade2bfe2006-01-23 16:09:51 -08002430 if ((status = rx_hdr->l2_fhdr_status) &
Michael Chanb6016b72005-05-26 13:03:09 -07002431 (L2_FHDR_ERRORS_BAD_CRC |
2432 L2_FHDR_ERRORS_PHY_DECODE |
2433 L2_FHDR_ERRORS_ALIGNMENT |
2434 L2_FHDR_ERRORS_TOO_SHORT |
2435 L2_FHDR_ERRORS_GIANT_FRAME)) {
2436
2437 goto reuse_rx;
2438 }
2439
2440 /* Since we don't have a jumbo ring, copy small packets
2441 * if mtu > 1500
2442 */
2443 if ((bp->dev->mtu > 1500) && (len <= RX_COPY_THRESH)) {
2444 struct sk_buff *new_skb;
2445
Michael Chan932f3772006-08-15 01:39:36 -07002446 new_skb = netdev_alloc_skb(bp->dev, len + 2);
Michael Chanb6016b72005-05-26 13:03:09 -07002447 if (new_skb == NULL)
2448 goto reuse_rx;
2449
2450 /* aligned copy */
Arnaldo Carvalho de Melod626f622007-03-27 18:55:52 -03002451 skb_copy_from_linear_data_offset(skb, bp->rx_offset - 2,
2452 new_skb->data, len + 2);
Michael Chanb6016b72005-05-26 13:03:09 -07002453 skb_reserve(new_skb, 2);
2454 skb_put(new_skb, len);
Michael Chanb6016b72005-05-26 13:03:09 -07002455
2456 bnx2_reuse_rx_skb(bp, skb,
2457 sw_ring_cons, sw_ring_prod);
2458
2459 skb = new_skb;
2460 }
2461 else if (bnx2_alloc_rx_skb(bp, sw_ring_prod) == 0) {
Michael Chan236b6392006-03-20 17:49:02 -08002462 pci_unmap_single(bp->pdev, dma_addr,
Michael Chanb6016b72005-05-26 13:03:09 -07002463 bp->rx_buf_use_size, PCI_DMA_FROMDEVICE);
2464
2465 skb_reserve(skb, bp->rx_offset);
2466 skb_put(skb, len);
2467 }
2468 else {
2469reuse_rx:
2470 bnx2_reuse_rx_skb(bp, skb,
2471 sw_ring_cons, sw_ring_prod);
2472 goto next_rx;
2473 }
2474
2475 skb->protocol = eth_type_trans(skb, bp->dev);
2476
2477 if ((len > (bp->dev->mtu + ETH_HLEN)) &&
Alexey Dobriyand1e100b2006-06-11 20:57:17 -07002478 (ntohs(skb->protocol) != 0x8100)) {
Michael Chanb6016b72005-05-26 13:03:09 -07002479
Michael Chan745720e2006-06-29 12:37:41 -07002480 dev_kfree_skb(skb);
Michael Chanb6016b72005-05-26 13:03:09 -07002481 goto next_rx;
2482
2483 }
2484
Michael Chanb6016b72005-05-26 13:03:09 -07002485 skb->ip_summed = CHECKSUM_NONE;
2486 if (bp->rx_csum &&
2487 (status & (L2_FHDR_STATUS_TCP_SEGMENT |
2488 L2_FHDR_STATUS_UDP_DATAGRAM))) {
2489
Michael Chanade2bfe2006-01-23 16:09:51 -08002490 if (likely((status & (L2_FHDR_ERRORS_TCP_XSUM |
2491 L2_FHDR_ERRORS_UDP_XSUM)) == 0))
Michael Chanb6016b72005-05-26 13:03:09 -07002492 skb->ip_summed = CHECKSUM_UNNECESSARY;
2493 }
2494
2495#ifdef BCM_VLAN
2496 if ((status & L2_FHDR_STATUS_L2_VLAN_TAG) && (bp->vlgrp != 0)) {
2497 vlan_hwaccel_receive_skb(skb, bp->vlgrp,
2498 rx_hdr->l2_fhdr_vlan_tag);
2499 }
2500 else
2501#endif
2502 netif_receive_skb(skb);
2503
2504 bp->dev->last_rx = jiffies;
2505 rx_pkt++;
2506
2507next_rx:
Michael Chanb6016b72005-05-26 13:03:09 -07002508 sw_cons = NEXT_RX_BD(sw_cons);
2509 sw_prod = NEXT_RX_BD(sw_prod);
2510
2511 if ((rx_pkt == budget))
2512 break;
Michael Chanf4e418f2005-11-04 08:53:48 -08002513
2514 /* Refresh hw_cons to see if there is new work */
2515 if (sw_cons == hw_cons) {
2516 hw_cons = bp->hw_rx_cons =
2517 sblk->status_rx_quick_consumer_index0;
2518 if ((hw_cons & MAX_RX_DESC_CNT) == MAX_RX_DESC_CNT)
2519 hw_cons++;
2520 rmb();
2521 }
Michael Chanb6016b72005-05-26 13:03:09 -07002522 }
2523 bp->rx_cons = sw_cons;
2524 bp->rx_prod = sw_prod;
2525
2526 REG_WR16(bp, MB_RX_CID_ADDR + BNX2_L2CTX_HOST_BDIDX, sw_prod);
2527
2528 REG_WR(bp, MB_RX_CID_ADDR + BNX2_L2CTX_HOST_BSEQ, bp->rx_prod_bseq);
2529
2530 mmiowb();
2531
2532 return rx_pkt;
2533
2534}
2535
2536/* MSI ISR - The only difference between this and the INTx ISR
2537 * is that the MSI interrupt is always serviced.
2538 */
2539static irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +01002540bnx2_msi(int irq, void *dev_instance)
Michael Chanb6016b72005-05-26 13:03:09 -07002541{
2542 struct net_device *dev = dev_instance;
Michael Chan972ec0d2006-01-23 16:12:43 -08002543 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07002544
Michael Chanc921e4c2005-09-08 13:15:32 -07002545 prefetch(bp->status_blk);
Michael Chanb6016b72005-05-26 13:03:09 -07002546 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
2547 BNX2_PCICFG_INT_ACK_CMD_USE_INT_HC_PARAM |
2548 BNX2_PCICFG_INT_ACK_CMD_MASK_INT);
2549
2550 /* Return here if interrupt is disabled. */
Michael Chan73eef4c2005-08-25 15:39:15 -07002551 if (unlikely(atomic_read(&bp->intr_sem) != 0))
2552 return IRQ_HANDLED;
Michael Chanb6016b72005-05-26 13:03:09 -07002553
Michael Chan73eef4c2005-08-25 15:39:15 -07002554 netif_rx_schedule(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07002555
Michael Chan73eef4c2005-08-25 15:39:15 -07002556 return IRQ_HANDLED;
Michael Chanb6016b72005-05-26 13:03:09 -07002557}
2558
2559static irqreturn_t
Michael Chan8e6a72c2007-05-03 13:24:48 -07002560bnx2_msi_1shot(int irq, void *dev_instance)
2561{
2562 struct net_device *dev = dev_instance;
2563 struct bnx2 *bp = netdev_priv(dev);
2564
2565 prefetch(bp->status_blk);
2566
2567 /* Return here if interrupt is disabled. */
2568 if (unlikely(atomic_read(&bp->intr_sem) != 0))
2569 return IRQ_HANDLED;
2570
2571 netif_rx_schedule(dev);
2572
2573 return IRQ_HANDLED;
2574}
2575
2576static irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +01002577bnx2_interrupt(int irq, void *dev_instance)
Michael Chanb6016b72005-05-26 13:03:09 -07002578{
2579 struct net_device *dev = dev_instance;
Michael Chan972ec0d2006-01-23 16:12:43 -08002580 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb8a7ce72007-07-07 22:51:03 -07002581 struct status_block *sblk = bp->status_blk;
Michael Chanb6016b72005-05-26 13:03:09 -07002582
2583 /* When using INTx, it is possible for the interrupt to arrive
2584 * at the CPU before the status block posted prior to the
2585 * interrupt. Reading a register will flush the status block.
2586 * When using MSI, the MSI message will always complete after
2587 * the status block write.
2588 */
Michael Chanb8a7ce72007-07-07 22:51:03 -07002589 if ((sblk->status_idx == bp->last_status_idx) &&
Michael Chanb6016b72005-05-26 13:03:09 -07002590 (REG_RD(bp, BNX2_PCICFG_MISC_STATUS) &
2591 BNX2_PCICFG_MISC_STATUS_INTA_VALUE))
Michael Chan73eef4c2005-08-25 15:39:15 -07002592 return IRQ_NONE;
Michael Chanb6016b72005-05-26 13:03:09 -07002593
2594 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
2595 BNX2_PCICFG_INT_ACK_CMD_USE_INT_HC_PARAM |
2596 BNX2_PCICFG_INT_ACK_CMD_MASK_INT);
2597
Michael Chanb8a7ce72007-07-07 22:51:03 -07002598 /* Read back to deassert IRQ immediately to avoid too many
2599 * spurious interrupts.
2600 */
2601 REG_RD(bp, BNX2_PCICFG_INT_ACK_CMD);
2602
Michael Chanb6016b72005-05-26 13:03:09 -07002603 /* Return here if interrupt is shared and is disabled. */
Michael Chan73eef4c2005-08-25 15:39:15 -07002604 if (unlikely(atomic_read(&bp->intr_sem) != 0))
2605 return IRQ_HANDLED;
Michael Chanb6016b72005-05-26 13:03:09 -07002606
Michael Chanb8a7ce72007-07-07 22:51:03 -07002607 if (netif_rx_schedule_prep(dev)) {
2608 bp->last_status_idx = sblk->status_idx;
2609 __netif_rx_schedule(dev);
2610 }
Michael Chanb6016b72005-05-26 13:03:09 -07002611
Michael Chan73eef4c2005-08-25 15:39:15 -07002612 return IRQ_HANDLED;
Michael Chanb6016b72005-05-26 13:03:09 -07002613}
2614
Michael Chan0d8a6572007-07-07 22:49:43 -07002615#define STATUS_ATTN_EVENTS (STATUS_ATTN_BITS_LINK_STATE | \
2616 STATUS_ATTN_BITS_TIMER_ABORT)
Michael Chanda3e4fb2007-05-03 13:24:23 -07002617
Michael Chanf4e418f2005-11-04 08:53:48 -08002618static inline int
2619bnx2_has_work(struct bnx2 *bp)
2620{
2621 struct status_block *sblk = bp->status_blk;
2622
2623 if ((sblk->status_rx_quick_consumer_index0 != bp->hw_rx_cons) ||
2624 (sblk->status_tx_quick_consumer_index0 != bp->hw_tx_cons))
2625 return 1;
2626
Michael Chanda3e4fb2007-05-03 13:24:23 -07002627 if ((sblk->status_attn_bits & STATUS_ATTN_EVENTS) !=
2628 (sblk->status_attn_bits_ack & STATUS_ATTN_EVENTS))
Michael Chanf4e418f2005-11-04 08:53:48 -08002629 return 1;
2630
2631 return 0;
2632}
2633
Michael Chanb6016b72005-05-26 13:03:09 -07002634static int
2635bnx2_poll(struct net_device *dev, int *budget)
2636{
Michael Chan972ec0d2006-01-23 16:12:43 -08002637 struct bnx2 *bp = netdev_priv(dev);
Michael Chanda3e4fb2007-05-03 13:24:23 -07002638 struct status_block *sblk = bp->status_blk;
2639 u32 status_attn_bits = sblk->status_attn_bits;
2640 u32 status_attn_bits_ack = sblk->status_attn_bits_ack;
Michael Chanb6016b72005-05-26 13:03:09 -07002641
Michael Chanda3e4fb2007-05-03 13:24:23 -07002642 if ((status_attn_bits & STATUS_ATTN_EVENTS) !=
2643 (status_attn_bits_ack & STATUS_ATTN_EVENTS)) {
Michael Chanb6016b72005-05-26 13:03:09 -07002644
Michael Chanb6016b72005-05-26 13:03:09 -07002645 bnx2_phy_int(bp);
Michael Chanbf5295b2006-03-23 01:11:56 -08002646
2647 /* This is needed to take care of transient status
2648 * during link changes.
2649 */
2650 REG_WR(bp, BNX2_HC_COMMAND,
2651 bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
2652 REG_RD(bp, BNX2_HC_COMMAND);
Michael Chanb6016b72005-05-26 13:03:09 -07002653 }
2654
Michael Chanf4e418f2005-11-04 08:53:48 -08002655 if (bp->status_blk->status_tx_quick_consumer_index0 != bp->hw_tx_cons)
Michael Chanb6016b72005-05-26 13:03:09 -07002656 bnx2_tx_int(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07002657
Michael Chanf4e418f2005-11-04 08:53:48 -08002658 if (bp->status_blk->status_rx_quick_consumer_index0 != bp->hw_rx_cons) {
Michael Chanb6016b72005-05-26 13:03:09 -07002659 int orig_budget = *budget;
2660 int work_done;
2661
2662 if (orig_budget > dev->quota)
2663 orig_budget = dev->quota;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002664
Michael Chanb6016b72005-05-26 13:03:09 -07002665 work_done = bnx2_rx_int(bp, orig_budget);
2666 *budget -= work_done;
2667 dev->quota -= work_done;
Michael Chanb6016b72005-05-26 13:03:09 -07002668 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002669
Michael Chanf4e418f2005-11-04 08:53:48 -08002670 bp->last_status_idx = bp->status_blk->status_idx;
2671 rmb();
2672
2673 if (!bnx2_has_work(bp)) {
Michael Chanb6016b72005-05-26 13:03:09 -07002674 netif_rx_complete(dev);
Michael Chan1269a8a2006-01-23 16:11:03 -08002675 if (likely(bp->flags & USING_MSI_FLAG)) {
2676 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
2677 BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
2678 bp->last_status_idx);
2679 return 0;
2680 }
Michael Chanb6016b72005-05-26 13:03:09 -07002681 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
Michael Chan1269a8a2006-01-23 16:11:03 -08002682 BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
2683 BNX2_PCICFG_INT_ACK_CMD_MASK_INT |
2684 bp->last_status_idx);
2685
2686 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
2687 BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
2688 bp->last_status_idx);
Michael Chanb6016b72005-05-26 13:03:09 -07002689 return 0;
2690 }
2691
2692 return 1;
2693}
2694
Herbert Xu932ff272006-06-09 12:20:56 -07002695/* Called with rtnl_lock from vlan functions and also netif_tx_lock
Michael Chanb6016b72005-05-26 13:03:09 -07002696 * from set_multicast.
2697 */
2698static void
2699bnx2_set_rx_mode(struct net_device *dev)
2700{
Michael Chan972ec0d2006-01-23 16:12:43 -08002701 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07002702 u32 rx_mode, sort_mode;
2703 int i;
Michael Chanb6016b72005-05-26 13:03:09 -07002704
Michael Chanc770a652005-08-25 15:38:39 -07002705 spin_lock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07002706
2707 rx_mode = bp->rx_mode & ~(BNX2_EMAC_RX_MODE_PROMISCUOUS |
2708 BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG);
2709 sort_mode = 1 | BNX2_RPM_SORT_USER0_BC_EN;
2710#ifdef BCM_VLAN
Michael Chane29054f2006-01-23 16:06:06 -08002711 if (!bp->vlgrp && !(bp->flags & ASF_ENABLE_FLAG))
Michael Chanb6016b72005-05-26 13:03:09 -07002712 rx_mode |= BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG;
Michael Chanb6016b72005-05-26 13:03:09 -07002713#else
Michael Chane29054f2006-01-23 16:06:06 -08002714 if (!(bp->flags & ASF_ENABLE_FLAG))
2715 rx_mode |= BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG;
Michael Chanb6016b72005-05-26 13:03:09 -07002716#endif
2717 if (dev->flags & IFF_PROMISC) {
2718 /* Promiscuous mode. */
2719 rx_mode |= BNX2_EMAC_RX_MODE_PROMISCUOUS;
Michael Chan75108732006-11-19 14:06:40 -08002720 sort_mode |= BNX2_RPM_SORT_USER0_PROM_EN |
2721 BNX2_RPM_SORT_USER0_PROM_VLAN;
Michael Chanb6016b72005-05-26 13:03:09 -07002722 }
2723 else if (dev->flags & IFF_ALLMULTI) {
2724 for (i = 0; i < NUM_MC_HASH_REGISTERS; i++) {
2725 REG_WR(bp, BNX2_EMAC_MULTICAST_HASH0 + (i * 4),
2726 0xffffffff);
2727 }
2728 sort_mode |= BNX2_RPM_SORT_USER0_MC_EN;
2729 }
2730 else {
2731 /* Accept one or more multicast(s). */
2732 struct dev_mc_list *mclist;
2733 u32 mc_filter[NUM_MC_HASH_REGISTERS];
2734 u32 regidx;
2735 u32 bit;
2736 u32 crc;
2737
2738 memset(mc_filter, 0, 4 * NUM_MC_HASH_REGISTERS);
2739
2740 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
2741 i++, mclist = mclist->next) {
2742
2743 crc = ether_crc_le(ETH_ALEN, mclist->dmi_addr);
2744 bit = crc & 0xff;
2745 regidx = (bit & 0xe0) >> 5;
2746 bit &= 0x1f;
2747 mc_filter[regidx] |= (1 << bit);
2748 }
2749
2750 for (i = 0; i < NUM_MC_HASH_REGISTERS; i++) {
2751 REG_WR(bp, BNX2_EMAC_MULTICAST_HASH0 + (i * 4),
2752 mc_filter[i]);
2753 }
2754
2755 sort_mode |= BNX2_RPM_SORT_USER0_MC_HSH_EN;
2756 }
2757
2758 if (rx_mode != bp->rx_mode) {
2759 bp->rx_mode = rx_mode;
2760 REG_WR(bp, BNX2_EMAC_RX_MODE, rx_mode);
2761 }
2762
2763 REG_WR(bp, BNX2_RPM_SORT_USER0, 0x0);
2764 REG_WR(bp, BNX2_RPM_SORT_USER0, sort_mode);
2765 REG_WR(bp, BNX2_RPM_SORT_USER0, sort_mode | BNX2_RPM_SORT_USER0_ENA);
2766
Michael Chanc770a652005-08-25 15:38:39 -07002767 spin_unlock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07002768}
2769
Michael Chanfba9fe92006-06-12 22:21:25 -07002770#define FW_BUF_SIZE 0x8000
2771
2772static int
2773bnx2_gunzip_init(struct bnx2 *bp)
2774{
2775 if ((bp->gunzip_buf = vmalloc(FW_BUF_SIZE)) == NULL)
2776 goto gunzip_nomem1;
2777
2778 if ((bp->strm = kmalloc(sizeof(*bp->strm), GFP_KERNEL)) == NULL)
2779 goto gunzip_nomem2;
2780
2781 bp->strm->workspace = kmalloc(zlib_inflate_workspacesize(), GFP_KERNEL);
2782 if (bp->strm->workspace == NULL)
2783 goto gunzip_nomem3;
2784
2785 return 0;
2786
2787gunzip_nomem3:
2788 kfree(bp->strm);
2789 bp->strm = NULL;
2790
2791gunzip_nomem2:
2792 vfree(bp->gunzip_buf);
2793 bp->gunzip_buf = NULL;
2794
2795gunzip_nomem1:
2796 printk(KERN_ERR PFX "%s: Cannot allocate firmware buffer for "
2797 "uncompression.\n", bp->dev->name);
2798 return -ENOMEM;
2799}
2800
2801static void
2802bnx2_gunzip_end(struct bnx2 *bp)
2803{
2804 kfree(bp->strm->workspace);
2805
2806 kfree(bp->strm);
2807 bp->strm = NULL;
2808
2809 if (bp->gunzip_buf) {
2810 vfree(bp->gunzip_buf);
2811 bp->gunzip_buf = NULL;
2812 }
2813}
2814
2815static int
2816bnx2_gunzip(struct bnx2 *bp, u8 *zbuf, int len, void **outbuf, int *outlen)
2817{
2818 int n, rc;
2819
2820 /* check gzip header */
2821 if ((zbuf[0] != 0x1f) || (zbuf[1] != 0x8b) || (zbuf[2] != Z_DEFLATED))
2822 return -EINVAL;
2823
2824 n = 10;
2825
2826#define FNAME 0x8
2827 if (zbuf[3] & FNAME)
2828 while ((zbuf[n++] != 0) && (n < len));
2829
2830 bp->strm->next_in = zbuf + n;
2831 bp->strm->avail_in = len - n;
2832 bp->strm->next_out = bp->gunzip_buf;
2833 bp->strm->avail_out = FW_BUF_SIZE;
2834
2835 rc = zlib_inflateInit2(bp->strm, -MAX_WBITS);
2836 if (rc != Z_OK)
2837 return rc;
2838
2839 rc = zlib_inflate(bp->strm, Z_FINISH);
2840
2841 *outlen = FW_BUF_SIZE - bp->strm->avail_out;
2842 *outbuf = bp->gunzip_buf;
2843
2844 if ((rc != Z_OK) && (rc != Z_STREAM_END))
2845 printk(KERN_ERR PFX "%s: Firmware decompression error: %s\n",
2846 bp->dev->name, bp->strm->msg);
2847
2848 zlib_inflateEnd(bp->strm);
2849
2850 if (rc == Z_STREAM_END)
2851 return 0;
2852
2853 return rc;
2854}
2855
Michael Chanb6016b72005-05-26 13:03:09 -07002856static void
2857load_rv2p_fw(struct bnx2 *bp, u32 *rv2p_code, u32 rv2p_code_len,
2858 u32 rv2p_proc)
2859{
2860 int i;
2861 u32 val;
2862
2863
2864 for (i = 0; i < rv2p_code_len; i += 8) {
Michael Chanfba9fe92006-06-12 22:21:25 -07002865 REG_WR(bp, BNX2_RV2P_INSTR_HIGH, cpu_to_le32(*rv2p_code));
Michael Chanb6016b72005-05-26 13:03:09 -07002866 rv2p_code++;
Michael Chanfba9fe92006-06-12 22:21:25 -07002867 REG_WR(bp, BNX2_RV2P_INSTR_LOW, cpu_to_le32(*rv2p_code));
Michael Chanb6016b72005-05-26 13:03:09 -07002868 rv2p_code++;
2869
2870 if (rv2p_proc == RV2P_PROC1) {
2871 val = (i / 8) | BNX2_RV2P_PROC1_ADDR_CMD_RDWR;
2872 REG_WR(bp, BNX2_RV2P_PROC1_ADDR_CMD, val);
2873 }
2874 else {
2875 val = (i / 8) | BNX2_RV2P_PROC2_ADDR_CMD_RDWR;
2876 REG_WR(bp, BNX2_RV2P_PROC2_ADDR_CMD, val);
2877 }
2878 }
2879
2880 /* Reset the processor, un-stall is done later. */
2881 if (rv2p_proc == RV2P_PROC1) {
2882 REG_WR(bp, BNX2_RV2P_COMMAND, BNX2_RV2P_COMMAND_PROC1_RESET);
2883 }
2884 else {
2885 REG_WR(bp, BNX2_RV2P_COMMAND, BNX2_RV2P_COMMAND_PROC2_RESET);
2886 }
2887}
2888
Michael Chanaf3ee512006-11-19 14:09:25 -08002889static int
Michael Chanb6016b72005-05-26 13:03:09 -07002890load_cpu_fw(struct bnx2 *bp, struct cpu_reg *cpu_reg, struct fw_info *fw)
2891{
2892 u32 offset;
2893 u32 val;
Michael Chanaf3ee512006-11-19 14:09:25 -08002894 int rc;
Michael Chanb6016b72005-05-26 13:03:09 -07002895
2896 /* Halt the CPU. */
2897 val = REG_RD_IND(bp, cpu_reg->mode);
2898 val |= cpu_reg->mode_value_halt;
2899 REG_WR_IND(bp, cpu_reg->mode, val);
2900 REG_WR_IND(bp, cpu_reg->state, cpu_reg->state_value_clear);
2901
2902 /* Load the Text area. */
2903 offset = cpu_reg->spad_base + (fw->text_addr - cpu_reg->mips_view_base);
Michael Chanaf3ee512006-11-19 14:09:25 -08002904 if (fw->gz_text) {
2905 u32 text_len;
2906 void *text;
2907
2908 rc = bnx2_gunzip(bp, fw->gz_text, fw->gz_text_len, &text,
2909 &text_len);
2910 if (rc)
2911 return rc;
2912
2913 fw->text = text;
2914 }
2915 if (fw->gz_text) {
Michael Chanb6016b72005-05-26 13:03:09 -07002916 int j;
2917
2918 for (j = 0; j < (fw->text_len / 4); j++, offset += 4) {
Michael Chanfba9fe92006-06-12 22:21:25 -07002919 REG_WR_IND(bp, offset, cpu_to_le32(fw->text[j]));
Michael Chanb6016b72005-05-26 13:03:09 -07002920 }
2921 }
2922
2923 /* Load the Data area. */
2924 offset = cpu_reg->spad_base + (fw->data_addr - cpu_reg->mips_view_base);
2925 if (fw->data) {
2926 int j;
2927
2928 for (j = 0; j < (fw->data_len / 4); j++, offset += 4) {
2929 REG_WR_IND(bp, offset, fw->data[j]);
2930 }
2931 }
2932
2933 /* Load the SBSS area. */
2934 offset = cpu_reg->spad_base + (fw->sbss_addr - cpu_reg->mips_view_base);
2935 if (fw->sbss) {
2936 int j;
2937
2938 for (j = 0; j < (fw->sbss_len / 4); j++, offset += 4) {
2939 REG_WR_IND(bp, offset, fw->sbss[j]);
2940 }
2941 }
2942
2943 /* Load the BSS area. */
2944 offset = cpu_reg->spad_base + (fw->bss_addr - cpu_reg->mips_view_base);
2945 if (fw->bss) {
2946 int j;
2947
2948 for (j = 0; j < (fw->bss_len/4); j++, offset += 4) {
2949 REG_WR_IND(bp, offset, fw->bss[j]);
2950 }
2951 }
2952
2953 /* Load the Read-Only area. */
2954 offset = cpu_reg->spad_base +
2955 (fw->rodata_addr - cpu_reg->mips_view_base);
2956 if (fw->rodata) {
2957 int j;
2958
2959 for (j = 0; j < (fw->rodata_len / 4); j++, offset += 4) {
2960 REG_WR_IND(bp, offset, fw->rodata[j]);
2961 }
2962 }
2963
2964 /* Clear the pre-fetch instruction. */
2965 REG_WR_IND(bp, cpu_reg->inst, 0);
2966 REG_WR_IND(bp, cpu_reg->pc, fw->start_addr);
2967
2968 /* Start the CPU. */
2969 val = REG_RD_IND(bp, cpu_reg->mode);
2970 val &= ~cpu_reg->mode_value_halt;
2971 REG_WR_IND(bp, cpu_reg->state, cpu_reg->state_value_clear);
2972 REG_WR_IND(bp, cpu_reg->mode, val);
Michael Chanaf3ee512006-11-19 14:09:25 -08002973
2974 return 0;
Michael Chanb6016b72005-05-26 13:03:09 -07002975}
2976
Michael Chanfba9fe92006-06-12 22:21:25 -07002977static int
Michael Chanb6016b72005-05-26 13:03:09 -07002978bnx2_init_cpus(struct bnx2 *bp)
2979{
2980 struct cpu_reg cpu_reg;
Michael Chanaf3ee512006-11-19 14:09:25 -08002981 struct fw_info *fw;
Michael Chanfba9fe92006-06-12 22:21:25 -07002982 int rc = 0;
2983 void *text;
2984 u32 text_len;
2985
2986 if ((rc = bnx2_gunzip_init(bp)) != 0)
2987 return rc;
Michael Chanb6016b72005-05-26 13:03:09 -07002988
2989 /* Initialize the RV2P processor. */
Michael Chanfba9fe92006-06-12 22:21:25 -07002990 rc = bnx2_gunzip(bp, bnx2_rv2p_proc1, sizeof(bnx2_rv2p_proc1), &text,
2991 &text_len);
2992 if (rc)
2993 goto init_cpu_err;
2994
2995 load_rv2p_fw(bp, text, text_len, RV2P_PROC1);
2996
2997 rc = bnx2_gunzip(bp, bnx2_rv2p_proc2, sizeof(bnx2_rv2p_proc2), &text,
2998 &text_len);
2999 if (rc)
3000 goto init_cpu_err;
3001
3002 load_rv2p_fw(bp, text, text_len, RV2P_PROC2);
Michael Chanb6016b72005-05-26 13:03:09 -07003003
3004 /* Initialize the RX Processor. */
3005 cpu_reg.mode = BNX2_RXP_CPU_MODE;
3006 cpu_reg.mode_value_halt = BNX2_RXP_CPU_MODE_SOFT_HALT;
3007 cpu_reg.mode_value_sstep = BNX2_RXP_CPU_MODE_STEP_ENA;
3008 cpu_reg.state = BNX2_RXP_CPU_STATE;
3009 cpu_reg.state_value_clear = 0xffffff;
3010 cpu_reg.gpr0 = BNX2_RXP_CPU_REG_FILE;
3011 cpu_reg.evmask = BNX2_RXP_CPU_EVENT_MASK;
3012 cpu_reg.pc = BNX2_RXP_CPU_PROGRAM_COUNTER;
3013 cpu_reg.inst = BNX2_RXP_CPU_INSTRUCTION;
3014 cpu_reg.bp = BNX2_RXP_CPU_HW_BREAKPOINT;
3015 cpu_reg.spad_base = BNX2_RXP_SCRATCH;
3016 cpu_reg.mips_view_base = 0x8000000;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003017
Michael Chand43584c2006-11-19 14:14:35 -08003018 if (CHIP_NUM(bp) == CHIP_NUM_5709)
3019 fw = &bnx2_rxp_fw_09;
3020 else
3021 fw = &bnx2_rxp_fw_06;
Michael Chanb6016b72005-05-26 13:03:09 -07003022
Michael Chanaf3ee512006-11-19 14:09:25 -08003023 rc = load_cpu_fw(bp, &cpu_reg, fw);
Michael Chanfba9fe92006-06-12 22:21:25 -07003024 if (rc)
3025 goto init_cpu_err;
3026
Michael Chanb6016b72005-05-26 13:03:09 -07003027 /* Initialize the TX Processor. */
3028 cpu_reg.mode = BNX2_TXP_CPU_MODE;
3029 cpu_reg.mode_value_halt = BNX2_TXP_CPU_MODE_SOFT_HALT;
3030 cpu_reg.mode_value_sstep = BNX2_TXP_CPU_MODE_STEP_ENA;
3031 cpu_reg.state = BNX2_TXP_CPU_STATE;
3032 cpu_reg.state_value_clear = 0xffffff;
3033 cpu_reg.gpr0 = BNX2_TXP_CPU_REG_FILE;
3034 cpu_reg.evmask = BNX2_TXP_CPU_EVENT_MASK;
3035 cpu_reg.pc = BNX2_TXP_CPU_PROGRAM_COUNTER;
3036 cpu_reg.inst = BNX2_TXP_CPU_INSTRUCTION;
3037 cpu_reg.bp = BNX2_TXP_CPU_HW_BREAKPOINT;
3038 cpu_reg.spad_base = BNX2_TXP_SCRATCH;
3039 cpu_reg.mips_view_base = 0x8000000;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003040
Michael Chand43584c2006-11-19 14:14:35 -08003041 if (CHIP_NUM(bp) == CHIP_NUM_5709)
3042 fw = &bnx2_txp_fw_09;
3043 else
3044 fw = &bnx2_txp_fw_06;
Michael Chanb6016b72005-05-26 13:03:09 -07003045
Michael Chanaf3ee512006-11-19 14:09:25 -08003046 rc = load_cpu_fw(bp, &cpu_reg, fw);
Michael Chanfba9fe92006-06-12 22:21:25 -07003047 if (rc)
3048 goto init_cpu_err;
3049
Michael Chanb6016b72005-05-26 13:03:09 -07003050 /* Initialize the TX Patch-up Processor. */
3051 cpu_reg.mode = BNX2_TPAT_CPU_MODE;
3052 cpu_reg.mode_value_halt = BNX2_TPAT_CPU_MODE_SOFT_HALT;
3053 cpu_reg.mode_value_sstep = BNX2_TPAT_CPU_MODE_STEP_ENA;
3054 cpu_reg.state = BNX2_TPAT_CPU_STATE;
3055 cpu_reg.state_value_clear = 0xffffff;
3056 cpu_reg.gpr0 = BNX2_TPAT_CPU_REG_FILE;
3057 cpu_reg.evmask = BNX2_TPAT_CPU_EVENT_MASK;
3058 cpu_reg.pc = BNX2_TPAT_CPU_PROGRAM_COUNTER;
3059 cpu_reg.inst = BNX2_TPAT_CPU_INSTRUCTION;
3060 cpu_reg.bp = BNX2_TPAT_CPU_HW_BREAKPOINT;
3061 cpu_reg.spad_base = BNX2_TPAT_SCRATCH;
3062 cpu_reg.mips_view_base = 0x8000000;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003063
Michael Chand43584c2006-11-19 14:14:35 -08003064 if (CHIP_NUM(bp) == CHIP_NUM_5709)
3065 fw = &bnx2_tpat_fw_09;
3066 else
3067 fw = &bnx2_tpat_fw_06;
Michael Chanb6016b72005-05-26 13:03:09 -07003068
Michael Chanaf3ee512006-11-19 14:09:25 -08003069 rc = load_cpu_fw(bp, &cpu_reg, fw);
Michael Chanfba9fe92006-06-12 22:21:25 -07003070 if (rc)
3071 goto init_cpu_err;
3072
Michael Chanb6016b72005-05-26 13:03:09 -07003073 /* Initialize the Completion Processor. */
3074 cpu_reg.mode = BNX2_COM_CPU_MODE;
3075 cpu_reg.mode_value_halt = BNX2_COM_CPU_MODE_SOFT_HALT;
3076 cpu_reg.mode_value_sstep = BNX2_COM_CPU_MODE_STEP_ENA;
3077 cpu_reg.state = BNX2_COM_CPU_STATE;
3078 cpu_reg.state_value_clear = 0xffffff;
3079 cpu_reg.gpr0 = BNX2_COM_CPU_REG_FILE;
3080 cpu_reg.evmask = BNX2_COM_CPU_EVENT_MASK;
3081 cpu_reg.pc = BNX2_COM_CPU_PROGRAM_COUNTER;
3082 cpu_reg.inst = BNX2_COM_CPU_INSTRUCTION;
3083 cpu_reg.bp = BNX2_COM_CPU_HW_BREAKPOINT;
3084 cpu_reg.spad_base = BNX2_COM_SCRATCH;
3085 cpu_reg.mips_view_base = 0x8000000;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003086
Michael Chand43584c2006-11-19 14:14:35 -08003087 if (CHIP_NUM(bp) == CHIP_NUM_5709)
3088 fw = &bnx2_com_fw_09;
3089 else
3090 fw = &bnx2_com_fw_06;
Michael Chanb6016b72005-05-26 13:03:09 -07003091
Michael Chanaf3ee512006-11-19 14:09:25 -08003092 rc = load_cpu_fw(bp, &cpu_reg, fw);
Michael Chanfba9fe92006-06-12 22:21:25 -07003093 if (rc)
3094 goto init_cpu_err;
3095
Michael Chand43584c2006-11-19 14:14:35 -08003096 /* Initialize the Command Processor. */
3097 cpu_reg.mode = BNX2_CP_CPU_MODE;
3098 cpu_reg.mode_value_halt = BNX2_CP_CPU_MODE_SOFT_HALT;
3099 cpu_reg.mode_value_sstep = BNX2_CP_CPU_MODE_STEP_ENA;
3100 cpu_reg.state = BNX2_CP_CPU_STATE;
3101 cpu_reg.state_value_clear = 0xffffff;
3102 cpu_reg.gpr0 = BNX2_CP_CPU_REG_FILE;
3103 cpu_reg.evmask = BNX2_CP_CPU_EVENT_MASK;
3104 cpu_reg.pc = BNX2_CP_CPU_PROGRAM_COUNTER;
3105 cpu_reg.inst = BNX2_CP_CPU_INSTRUCTION;
3106 cpu_reg.bp = BNX2_CP_CPU_HW_BREAKPOINT;
3107 cpu_reg.spad_base = BNX2_CP_SCRATCH;
3108 cpu_reg.mips_view_base = 0x8000000;
Michael Chanb6016b72005-05-26 13:03:09 -07003109
Michael Chand43584c2006-11-19 14:14:35 -08003110 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
3111 fw = &bnx2_cp_fw_09;
Michael Chanb6016b72005-05-26 13:03:09 -07003112
Adrian Bunk6c1bbcc2006-12-07 15:10:06 -08003113 rc = load_cpu_fw(bp, &cpu_reg, fw);
Michael Chand43584c2006-11-19 14:14:35 -08003114 if (rc)
3115 goto init_cpu_err;
3116 }
Michael Chanfba9fe92006-06-12 22:21:25 -07003117init_cpu_err:
3118 bnx2_gunzip_end(bp);
3119 return rc;
Michael Chanb6016b72005-05-26 13:03:09 -07003120}
3121
3122static int
Pavel Machek829ca9a2005-09-03 15:56:56 -07003123bnx2_set_power_state(struct bnx2 *bp, pci_power_t state)
Michael Chanb6016b72005-05-26 13:03:09 -07003124{
3125 u16 pmcsr;
3126
3127 pci_read_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL, &pmcsr);
3128
3129 switch (state) {
Pavel Machek829ca9a2005-09-03 15:56:56 -07003130 case PCI_D0: {
Michael Chanb6016b72005-05-26 13:03:09 -07003131 u32 val;
3132
3133 pci_write_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL,
3134 (pmcsr & ~PCI_PM_CTRL_STATE_MASK) |
3135 PCI_PM_CTRL_PME_STATUS);
3136
3137 if (pmcsr & PCI_PM_CTRL_STATE_MASK)
3138 /* delay required during transition out of D3hot */
3139 msleep(20);
3140
3141 val = REG_RD(bp, BNX2_EMAC_MODE);
3142 val |= BNX2_EMAC_MODE_MPKT_RCVD | BNX2_EMAC_MODE_ACPI_RCVD;
3143 val &= ~BNX2_EMAC_MODE_MPKT;
3144 REG_WR(bp, BNX2_EMAC_MODE, val);
3145
3146 val = REG_RD(bp, BNX2_RPM_CONFIG);
3147 val &= ~BNX2_RPM_CONFIG_ACPI_ENA;
3148 REG_WR(bp, BNX2_RPM_CONFIG, val);
3149 break;
3150 }
Pavel Machek829ca9a2005-09-03 15:56:56 -07003151 case PCI_D3hot: {
Michael Chanb6016b72005-05-26 13:03:09 -07003152 int i;
3153 u32 val, wol_msg;
3154
3155 if (bp->wol) {
3156 u32 advertising;
3157 u8 autoneg;
3158
3159 autoneg = bp->autoneg;
3160 advertising = bp->advertising;
3161
3162 bp->autoneg = AUTONEG_SPEED;
3163 bp->advertising = ADVERTISED_10baseT_Half |
3164 ADVERTISED_10baseT_Full |
3165 ADVERTISED_100baseT_Half |
3166 ADVERTISED_100baseT_Full |
3167 ADVERTISED_Autoneg;
3168
3169 bnx2_setup_copper_phy(bp);
3170
3171 bp->autoneg = autoneg;
3172 bp->advertising = advertising;
3173
3174 bnx2_set_mac_addr(bp);
3175
3176 val = REG_RD(bp, BNX2_EMAC_MODE);
3177
3178 /* Enable port mode. */
3179 val &= ~BNX2_EMAC_MODE_PORT;
3180 val |= BNX2_EMAC_MODE_PORT_MII |
3181 BNX2_EMAC_MODE_MPKT_RCVD |
3182 BNX2_EMAC_MODE_ACPI_RCVD |
Michael Chanb6016b72005-05-26 13:03:09 -07003183 BNX2_EMAC_MODE_MPKT;
3184
3185 REG_WR(bp, BNX2_EMAC_MODE, val);
3186
3187 /* receive all multicast */
3188 for (i = 0; i < NUM_MC_HASH_REGISTERS; i++) {
3189 REG_WR(bp, BNX2_EMAC_MULTICAST_HASH0 + (i * 4),
3190 0xffffffff);
3191 }
3192 REG_WR(bp, BNX2_EMAC_RX_MODE,
3193 BNX2_EMAC_RX_MODE_SORT_MODE);
3194
3195 val = 1 | BNX2_RPM_SORT_USER0_BC_EN |
3196 BNX2_RPM_SORT_USER0_MC_EN;
3197 REG_WR(bp, BNX2_RPM_SORT_USER0, 0x0);
3198 REG_WR(bp, BNX2_RPM_SORT_USER0, val);
3199 REG_WR(bp, BNX2_RPM_SORT_USER0, val |
3200 BNX2_RPM_SORT_USER0_ENA);
3201
3202 /* Need to enable EMAC and RPM for WOL. */
3203 REG_WR(bp, BNX2_MISC_ENABLE_SET_BITS,
3204 BNX2_MISC_ENABLE_SET_BITS_RX_PARSER_MAC_ENABLE |
3205 BNX2_MISC_ENABLE_SET_BITS_TX_HEADER_Q_ENABLE |
3206 BNX2_MISC_ENABLE_SET_BITS_EMAC_ENABLE);
3207
3208 val = REG_RD(bp, BNX2_RPM_CONFIG);
3209 val &= ~BNX2_RPM_CONFIG_ACPI_ENA;
3210 REG_WR(bp, BNX2_RPM_CONFIG, val);
3211
3212 wol_msg = BNX2_DRV_MSG_CODE_SUSPEND_WOL;
3213 }
3214 else {
3215 wol_msg = BNX2_DRV_MSG_CODE_SUSPEND_NO_WOL;
3216 }
3217
Michael Chandda1e392006-01-23 16:08:14 -08003218 if (!(bp->flags & NO_WOL_FLAG))
3219 bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT3 | wol_msg, 0);
Michael Chanb6016b72005-05-26 13:03:09 -07003220
3221 pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
3222 if ((CHIP_ID(bp) == CHIP_ID_5706_A0) ||
3223 (CHIP_ID(bp) == CHIP_ID_5706_A1)) {
3224
3225 if (bp->wol)
3226 pmcsr |= 3;
3227 }
3228 else {
3229 pmcsr |= 3;
3230 }
3231 if (bp->wol) {
3232 pmcsr |= PCI_PM_CTRL_PME_ENABLE;
3233 }
3234 pci_write_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL,
3235 pmcsr);
3236
3237 /* No more memory access after this point until
3238 * device is brought back to D0.
3239 */
3240 udelay(50);
3241 break;
3242 }
3243 default:
3244 return -EINVAL;
3245 }
3246 return 0;
3247}
3248
3249static int
3250bnx2_acquire_nvram_lock(struct bnx2 *bp)
3251{
3252 u32 val;
3253 int j;
3254
3255 /* Request access to the flash interface. */
3256 REG_WR(bp, BNX2_NVM_SW_ARB, BNX2_NVM_SW_ARB_ARB_REQ_SET2);
3257 for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3258 val = REG_RD(bp, BNX2_NVM_SW_ARB);
3259 if (val & BNX2_NVM_SW_ARB_ARB_ARB2)
3260 break;
3261
3262 udelay(5);
3263 }
3264
3265 if (j >= NVRAM_TIMEOUT_COUNT)
3266 return -EBUSY;
3267
3268 return 0;
3269}
3270
3271static int
3272bnx2_release_nvram_lock(struct bnx2 *bp)
3273{
3274 int j;
3275 u32 val;
3276
3277 /* Relinquish nvram interface. */
3278 REG_WR(bp, BNX2_NVM_SW_ARB, BNX2_NVM_SW_ARB_ARB_REQ_CLR2);
3279
3280 for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3281 val = REG_RD(bp, BNX2_NVM_SW_ARB);
3282 if (!(val & BNX2_NVM_SW_ARB_ARB_ARB2))
3283 break;
3284
3285 udelay(5);
3286 }
3287
3288 if (j >= NVRAM_TIMEOUT_COUNT)
3289 return -EBUSY;
3290
3291 return 0;
3292}
3293
3294
3295static int
3296bnx2_enable_nvram_write(struct bnx2 *bp)
3297{
3298 u32 val;
3299
3300 val = REG_RD(bp, BNX2_MISC_CFG);
3301 REG_WR(bp, BNX2_MISC_CFG, val | BNX2_MISC_CFG_NVM_WR_EN_PCI);
3302
Michael Chane30372c2007-07-16 18:26:23 -07003303 if (bp->flash_info->flags & BNX2_NV_WREN) {
Michael Chanb6016b72005-05-26 13:03:09 -07003304 int j;
3305
3306 REG_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
3307 REG_WR(bp, BNX2_NVM_COMMAND,
3308 BNX2_NVM_COMMAND_WREN | BNX2_NVM_COMMAND_DOIT);
3309
3310 for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3311 udelay(5);
3312
3313 val = REG_RD(bp, BNX2_NVM_COMMAND);
3314 if (val & BNX2_NVM_COMMAND_DONE)
3315 break;
3316 }
3317
3318 if (j >= NVRAM_TIMEOUT_COUNT)
3319 return -EBUSY;
3320 }
3321 return 0;
3322}
3323
3324static void
3325bnx2_disable_nvram_write(struct bnx2 *bp)
3326{
3327 u32 val;
3328
3329 val = REG_RD(bp, BNX2_MISC_CFG);
3330 REG_WR(bp, BNX2_MISC_CFG, val & ~BNX2_MISC_CFG_NVM_WR_EN);
3331}
3332
3333
3334static void
3335bnx2_enable_nvram_access(struct bnx2 *bp)
3336{
3337 u32 val;
3338
3339 val = REG_RD(bp, BNX2_NVM_ACCESS_ENABLE);
3340 /* Enable both bits, even on read. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003341 REG_WR(bp, BNX2_NVM_ACCESS_ENABLE,
Michael Chanb6016b72005-05-26 13:03:09 -07003342 val | BNX2_NVM_ACCESS_ENABLE_EN | BNX2_NVM_ACCESS_ENABLE_WR_EN);
3343}
3344
3345static void
3346bnx2_disable_nvram_access(struct bnx2 *bp)
3347{
3348 u32 val;
3349
3350 val = REG_RD(bp, BNX2_NVM_ACCESS_ENABLE);
3351 /* Disable both bits, even after read. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003352 REG_WR(bp, BNX2_NVM_ACCESS_ENABLE,
Michael Chanb6016b72005-05-26 13:03:09 -07003353 val & ~(BNX2_NVM_ACCESS_ENABLE_EN |
3354 BNX2_NVM_ACCESS_ENABLE_WR_EN));
3355}
3356
3357static int
3358bnx2_nvram_erase_page(struct bnx2 *bp, u32 offset)
3359{
3360 u32 cmd;
3361 int j;
3362
Michael Chane30372c2007-07-16 18:26:23 -07003363 if (bp->flash_info->flags & BNX2_NV_BUFFERED)
Michael Chanb6016b72005-05-26 13:03:09 -07003364 /* Buffered flash, no erase needed */
3365 return 0;
3366
3367 /* Build an erase command */
3368 cmd = BNX2_NVM_COMMAND_ERASE | BNX2_NVM_COMMAND_WR |
3369 BNX2_NVM_COMMAND_DOIT;
3370
3371 /* Need to clear DONE bit separately. */
3372 REG_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
3373
3374 /* Address of the NVRAM to read from. */
3375 REG_WR(bp, BNX2_NVM_ADDR, offset & BNX2_NVM_ADDR_NVM_ADDR_VALUE);
3376
3377 /* Issue an erase command. */
3378 REG_WR(bp, BNX2_NVM_COMMAND, cmd);
3379
3380 /* Wait for completion. */
3381 for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3382 u32 val;
3383
3384 udelay(5);
3385
3386 val = REG_RD(bp, BNX2_NVM_COMMAND);
3387 if (val & BNX2_NVM_COMMAND_DONE)
3388 break;
3389 }
3390
3391 if (j >= NVRAM_TIMEOUT_COUNT)
3392 return -EBUSY;
3393
3394 return 0;
3395}
3396
3397static int
3398bnx2_nvram_read_dword(struct bnx2 *bp, u32 offset, u8 *ret_val, u32 cmd_flags)
3399{
3400 u32 cmd;
3401 int j;
3402
3403 /* Build the command word. */
3404 cmd = BNX2_NVM_COMMAND_DOIT | cmd_flags;
3405
Michael Chane30372c2007-07-16 18:26:23 -07003406 /* Calculate an offset of a buffered flash, not needed for 5709. */
3407 if (bp->flash_info->flags & BNX2_NV_TRANSLATE) {
Michael Chanb6016b72005-05-26 13:03:09 -07003408 offset = ((offset / bp->flash_info->page_size) <<
3409 bp->flash_info->page_bits) +
3410 (offset % bp->flash_info->page_size);
3411 }
3412
3413 /* Need to clear DONE bit separately. */
3414 REG_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
3415
3416 /* Address of the NVRAM to read from. */
3417 REG_WR(bp, BNX2_NVM_ADDR, offset & BNX2_NVM_ADDR_NVM_ADDR_VALUE);
3418
3419 /* Issue a read command. */
3420 REG_WR(bp, BNX2_NVM_COMMAND, cmd);
3421
3422 /* Wait for completion. */
3423 for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3424 u32 val;
3425
3426 udelay(5);
3427
3428 val = REG_RD(bp, BNX2_NVM_COMMAND);
3429 if (val & BNX2_NVM_COMMAND_DONE) {
3430 val = REG_RD(bp, BNX2_NVM_READ);
3431
3432 val = be32_to_cpu(val);
3433 memcpy(ret_val, &val, 4);
3434 break;
3435 }
3436 }
3437 if (j >= NVRAM_TIMEOUT_COUNT)
3438 return -EBUSY;
3439
3440 return 0;
3441}
3442
3443
3444static int
3445bnx2_nvram_write_dword(struct bnx2 *bp, u32 offset, u8 *val, u32 cmd_flags)
3446{
3447 u32 cmd, val32;
3448 int j;
3449
3450 /* Build the command word. */
3451 cmd = BNX2_NVM_COMMAND_DOIT | BNX2_NVM_COMMAND_WR | cmd_flags;
3452
Michael Chane30372c2007-07-16 18:26:23 -07003453 /* Calculate an offset of a buffered flash, not needed for 5709. */
3454 if (bp->flash_info->flags & BNX2_NV_TRANSLATE) {
Michael Chanb6016b72005-05-26 13:03:09 -07003455 offset = ((offset / bp->flash_info->page_size) <<
3456 bp->flash_info->page_bits) +
3457 (offset % bp->flash_info->page_size);
3458 }
3459
3460 /* Need to clear DONE bit separately. */
3461 REG_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
3462
3463 memcpy(&val32, val, 4);
3464 val32 = cpu_to_be32(val32);
3465
3466 /* Write the data. */
3467 REG_WR(bp, BNX2_NVM_WRITE, val32);
3468
3469 /* Address of the NVRAM to write to. */
3470 REG_WR(bp, BNX2_NVM_ADDR, offset & BNX2_NVM_ADDR_NVM_ADDR_VALUE);
3471
3472 /* Issue the write command. */
3473 REG_WR(bp, BNX2_NVM_COMMAND, cmd);
3474
3475 /* Wait for completion. */
3476 for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3477 udelay(5);
3478
3479 if (REG_RD(bp, BNX2_NVM_COMMAND) & BNX2_NVM_COMMAND_DONE)
3480 break;
3481 }
3482 if (j >= NVRAM_TIMEOUT_COUNT)
3483 return -EBUSY;
3484
3485 return 0;
3486}
3487
3488static int
3489bnx2_init_nvram(struct bnx2 *bp)
3490{
3491 u32 val;
Michael Chane30372c2007-07-16 18:26:23 -07003492 int j, entry_count, rc = 0;
Michael Chanb6016b72005-05-26 13:03:09 -07003493 struct flash_spec *flash;
3494
Michael Chane30372c2007-07-16 18:26:23 -07003495 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
3496 bp->flash_info = &flash_5709;
3497 goto get_flash_size;
3498 }
3499
Michael Chanb6016b72005-05-26 13:03:09 -07003500 /* Determine the selected interface. */
3501 val = REG_RD(bp, BNX2_NVM_CFG1);
3502
3503 entry_count = sizeof(flash_table) / sizeof(struct flash_spec);
3504
Michael Chanb6016b72005-05-26 13:03:09 -07003505 if (val & 0x40000000) {
3506
3507 /* Flash interface has been reconfigured */
3508 for (j = 0, flash = &flash_table[0]; j < entry_count;
Michael Chan37137702005-11-04 08:49:17 -08003509 j++, flash++) {
3510 if ((val & FLASH_BACKUP_STRAP_MASK) ==
3511 (flash->config1 & FLASH_BACKUP_STRAP_MASK)) {
Michael Chanb6016b72005-05-26 13:03:09 -07003512 bp->flash_info = flash;
3513 break;
3514 }
3515 }
3516 }
3517 else {
Michael Chan37137702005-11-04 08:49:17 -08003518 u32 mask;
Michael Chanb6016b72005-05-26 13:03:09 -07003519 /* Not yet been reconfigured */
3520
Michael Chan37137702005-11-04 08:49:17 -08003521 if (val & (1 << 23))
3522 mask = FLASH_BACKUP_STRAP_MASK;
3523 else
3524 mask = FLASH_STRAP_MASK;
3525
Michael Chanb6016b72005-05-26 13:03:09 -07003526 for (j = 0, flash = &flash_table[0]; j < entry_count;
3527 j++, flash++) {
3528
Michael Chan37137702005-11-04 08:49:17 -08003529 if ((val & mask) == (flash->strapping & mask)) {
Michael Chanb6016b72005-05-26 13:03:09 -07003530 bp->flash_info = flash;
3531
3532 /* Request access to the flash interface. */
3533 if ((rc = bnx2_acquire_nvram_lock(bp)) != 0)
3534 return rc;
3535
3536 /* Enable access to flash interface */
3537 bnx2_enable_nvram_access(bp);
3538
3539 /* Reconfigure the flash interface */
3540 REG_WR(bp, BNX2_NVM_CFG1, flash->config1);
3541 REG_WR(bp, BNX2_NVM_CFG2, flash->config2);
3542 REG_WR(bp, BNX2_NVM_CFG3, flash->config3);
3543 REG_WR(bp, BNX2_NVM_WRITE1, flash->write1);
3544
3545 /* Disable access to flash interface */
3546 bnx2_disable_nvram_access(bp);
3547 bnx2_release_nvram_lock(bp);
3548
3549 break;
3550 }
3551 }
3552 } /* if (val & 0x40000000) */
3553
3554 if (j == entry_count) {
3555 bp->flash_info = NULL;
John W. Linville2f23c522005-11-10 12:57:33 -08003556 printk(KERN_ALERT PFX "Unknown flash/EEPROM type.\n");
Michael Chan1122db72006-01-23 16:11:42 -08003557 return -ENODEV;
Michael Chanb6016b72005-05-26 13:03:09 -07003558 }
3559
Michael Chane30372c2007-07-16 18:26:23 -07003560get_flash_size:
Michael Chan1122db72006-01-23 16:11:42 -08003561 val = REG_RD_IND(bp, bp->shmem_base + BNX2_SHARED_HW_CFG_CONFIG2);
3562 val &= BNX2_SHARED_HW_CFG2_NVM_SIZE_MASK;
3563 if (val)
3564 bp->flash_size = val;
3565 else
3566 bp->flash_size = bp->flash_info->total_size;
3567
Michael Chanb6016b72005-05-26 13:03:09 -07003568 return rc;
3569}
3570
3571static int
3572bnx2_nvram_read(struct bnx2 *bp, u32 offset, u8 *ret_buf,
3573 int buf_size)
3574{
3575 int rc = 0;
3576 u32 cmd_flags, offset32, len32, extra;
3577
3578 if (buf_size == 0)
3579 return 0;
3580
3581 /* Request access to the flash interface. */
3582 if ((rc = bnx2_acquire_nvram_lock(bp)) != 0)
3583 return rc;
3584
3585 /* Enable access to flash interface */
3586 bnx2_enable_nvram_access(bp);
3587
3588 len32 = buf_size;
3589 offset32 = offset;
3590 extra = 0;
3591
3592 cmd_flags = 0;
3593
3594 if (offset32 & 3) {
3595 u8 buf[4];
3596 u32 pre_len;
3597
3598 offset32 &= ~3;
3599 pre_len = 4 - (offset & 3);
3600
3601 if (pre_len >= len32) {
3602 pre_len = len32;
3603 cmd_flags = BNX2_NVM_COMMAND_FIRST |
3604 BNX2_NVM_COMMAND_LAST;
3605 }
3606 else {
3607 cmd_flags = BNX2_NVM_COMMAND_FIRST;
3608 }
3609
3610 rc = bnx2_nvram_read_dword(bp, offset32, buf, cmd_flags);
3611
3612 if (rc)
3613 return rc;
3614
3615 memcpy(ret_buf, buf + (offset & 3), pre_len);
3616
3617 offset32 += 4;
3618 ret_buf += pre_len;
3619 len32 -= pre_len;
3620 }
3621 if (len32 & 3) {
3622 extra = 4 - (len32 & 3);
3623 len32 = (len32 + 4) & ~3;
3624 }
3625
3626 if (len32 == 4) {
3627 u8 buf[4];
3628
3629 if (cmd_flags)
3630 cmd_flags = BNX2_NVM_COMMAND_LAST;
3631 else
3632 cmd_flags = BNX2_NVM_COMMAND_FIRST |
3633 BNX2_NVM_COMMAND_LAST;
3634
3635 rc = bnx2_nvram_read_dword(bp, offset32, buf, cmd_flags);
3636
3637 memcpy(ret_buf, buf, 4 - extra);
3638 }
3639 else if (len32 > 0) {
3640 u8 buf[4];
3641
3642 /* Read the first word. */
3643 if (cmd_flags)
3644 cmd_flags = 0;
3645 else
3646 cmd_flags = BNX2_NVM_COMMAND_FIRST;
3647
3648 rc = bnx2_nvram_read_dword(bp, offset32, ret_buf, cmd_flags);
3649
3650 /* Advance to the next dword. */
3651 offset32 += 4;
3652 ret_buf += 4;
3653 len32 -= 4;
3654
3655 while (len32 > 4 && rc == 0) {
3656 rc = bnx2_nvram_read_dword(bp, offset32, ret_buf, 0);
3657
3658 /* Advance to the next dword. */
3659 offset32 += 4;
3660 ret_buf += 4;
3661 len32 -= 4;
3662 }
3663
3664 if (rc)
3665 return rc;
3666
3667 cmd_flags = BNX2_NVM_COMMAND_LAST;
3668 rc = bnx2_nvram_read_dword(bp, offset32, buf, cmd_flags);
3669
3670 memcpy(ret_buf, buf, 4 - extra);
3671 }
3672
3673 /* Disable access to flash interface */
3674 bnx2_disable_nvram_access(bp);
3675
3676 bnx2_release_nvram_lock(bp);
3677
3678 return rc;
3679}
3680
3681static int
3682bnx2_nvram_write(struct bnx2 *bp, u32 offset, u8 *data_buf,
3683 int buf_size)
3684{
3685 u32 written, offset32, len32;
Michael Chane6be7632007-01-08 19:56:13 -08003686 u8 *buf, start[4], end[4], *align_buf = NULL, *flash_buffer = NULL;
Michael Chanb6016b72005-05-26 13:03:09 -07003687 int rc = 0;
3688 int align_start, align_end;
3689
3690 buf = data_buf;
3691 offset32 = offset;
3692 len32 = buf_size;
3693 align_start = align_end = 0;
3694
3695 if ((align_start = (offset32 & 3))) {
3696 offset32 &= ~3;
Michael Chanc8738792007-03-30 14:53:06 -07003697 len32 += align_start;
3698 if (len32 < 4)
3699 len32 = 4;
Michael Chanb6016b72005-05-26 13:03:09 -07003700 if ((rc = bnx2_nvram_read(bp, offset32, start, 4)))
3701 return rc;
3702 }
3703
3704 if (len32 & 3) {
Michael Chanc8738792007-03-30 14:53:06 -07003705 align_end = 4 - (len32 & 3);
3706 len32 += align_end;
3707 if ((rc = bnx2_nvram_read(bp, offset32 + len32 - 4, end, 4)))
3708 return rc;
Michael Chanb6016b72005-05-26 13:03:09 -07003709 }
3710
3711 if (align_start || align_end) {
Michael Chane6be7632007-01-08 19:56:13 -08003712 align_buf = kmalloc(len32, GFP_KERNEL);
3713 if (align_buf == NULL)
Michael Chanb6016b72005-05-26 13:03:09 -07003714 return -ENOMEM;
3715 if (align_start) {
Michael Chane6be7632007-01-08 19:56:13 -08003716 memcpy(align_buf, start, 4);
Michael Chanb6016b72005-05-26 13:03:09 -07003717 }
3718 if (align_end) {
Michael Chane6be7632007-01-08 19:56:13 -08003719 memcpy(align_buf + len32 - 4, end, 4);
Michael Chanb6016b72005-05-26 13:03:09 -07003720 }
Michael Chane6be7632007-01-08 19:56:13 -08003721 memcpy(align_buf + align_start, data_buf, buf_size);
3722 buf = align_buf;
Michael Chanb6016b72005-05-26 13:03:09 -07003723 }
3724
Michael Chane30372c2007-07-16 18:26:23 -07003725 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
Michael Chanae181bc2006-05-22 16:39:20 -07003726 flash_buffer = kmalloc(264, GFP_KERNEL);
3727 if (flash_buffer == NULL) {
3728 rc = -ENOMEM;
3729 goto nvram_write_end;
3730 }
3731 }
3732
Michael Chanb6016b72005-05-26 13:03:09 -07003733 written = 0;
3734 while ((written < len32) && (rc == 0)) {
3735 u32 page_start, page_end, data_start, data_end;
3736 u32 addr, cmd_flags;
3737 int i;
Michael Chanb6016b72005-05-26 13:03:09 -07003738
3739 /* Find the page_start addr */
3740 page_start = offset32 + written;
3741 page_start -= (page_start % bp->flash_info->page_size);
3742 /* Find the page_end addr */
3743 page_end = page_start + bp->flash_info->page_size;
3744 /* Find the data_start addr */
3745 data_start = (written == 0) ? offset32 : page_start;
3746 /* Find the data_end addr */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003747 data_end = (page_end > offset32 + len32) ?
Michael Chanb6016b72005-05-26 13:03:09 -07003748 (offset32 + len32) : page_end;
3749
3750 /* Request access to the flash interface. */
3751 if ((rc = bnx2_acquire_nvram_lock(bp)) != 0)
3752 goto nvram_write_end;
3753
3754 /* Enable access to flash interface */
3755 bnx2_enable_nvram_access(bp);
3756
3757 cmd_flags = BNX2_NVM_COMMAND_FIRST;
Michael Chane30372c2007-07-16 18:26:23 -07003758 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
Michael Chanb6016b72005-05-26 13:03:09 -07003759 int j;
3760
3761 /* Read the whole page into the buffer
3762 * (non-buffer flash only) */
3763 for (j = 0; j < bp->flash_info->page_size; j += 4) {
3764 if (j == (bp->flash_info->page_size - 4)) {
3765 cmd_flags |= BNX2_NVM_COMMAND_LAST;
3766 }
3767 rc = bnx2_nvram_read_dword(bp,
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003768 page_start + j,
3769 &flash_buffer[j],
Michael Chanb6016b72005-05-26 13:03:09 -07003770 cmd_flags);
3771
3772 if (rc)
3773 goto nvram_write_end;
3774
3775 cmd_flags = 0;
3776 }
3777 }
3778
3779 /* Enable writes to flash interface (unlock write-protect) */
3780 if ((rc = bnx2_enable_nvram_write(bp)) != 0)
3781 goto nvram_write_end;
3782
Michael Chanb6016b72005-05-26 13:03:09 -07003783 /* Loop to write back the buffer data from page_start to
3784 * data_start */
3785 i = 0;
Michael Chane30372c2007-07-16 18:26:23 -07003786 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
Michael Chanc8738792007-03-30 14:53:06 -07003787 /* Erase the page */
3788 if ((rc = bnx2_nvram_erase_page(bp, page_start)) != 0)
3789 goto nvram_write_end;
3790
3791 /* Re-enable the write again for the actual write */
3792 bnx2_enable_nvram_write(bp);
3793
Michael Chanb6016b72005-05-26 13:03:09 -07003794 for (addr = page_start; addr < data_start;
3795 addr += 4, i += 4) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003796
Michael Chanb6016b72005-05-26 13:03:09 -07003797 rc = bnx2_nvram_write_dword(bp, addr,
3798 &flash_buffer[i], cmd_flags);
3799
3800 if (rc != 0)
3801 goto nvram_write_end;
3802
3803 cmd_flags = 0;
3804 }
3805 }
3806
3807 /* Loop to write the new data from data_start to data_end */
Michael Chanbae25762006-05-22 16:38:38 -07003808 for (addr = data_start; addr < data_end; addr += 4, i += 4) {
Michael Chanb6016b72005-05-26 13:03:09 -07003809 if ((addr == page_end - 4) ||
Michael Chane30372c2007-07-16 18:26:23 -07003810 ((bp->flash_info->flags & BNX2_NV_BUFFERED) &&
Michael Chanb6016b72005-05-26 13:03:09 -07003811 (addr == data_end - 4))) {
3812
3813 cmd_flags |= BNX2_NVM_COMMAND_LAST;
3814 }
3815 rc = bnx2_nvram_write_dword(bp, addr, buf,
3816 cmd_flags);
3817
3818 if (rc != 0)
3819 goto nvram_write_end;
3820
3821 cmd_flags = 0;
3822 buf += 4;
3823 }
3824
3825 /* Loop to write back the buffer data from data_end
3826 * to page_end */
Michael Chane30372c2007-07-16 18:26:23 -07003827 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
Michael Chanb6016b72005-05-26 13:03:09 -07003828 for (addr = data_end; addr < page_end;
3829 addr += 4, i += 4) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003830
Michael Chanb6016b72005-05-26 13:03:09 -07003831 if (addr == page_end-4) {
3832 cmd_flags = BNX2_NVM_COMMAND_LAST;
3833 }
3834 rc = bnx2_nvram_write_dword(bp, addr,
3835 &flash_buffer[i], cmd_flags);
3836
3837 if (rc != 0)
3838 goto nvram_write_end;
3839
3840 cmd_flags = 0;
3841 }
3842 }
3843
3844 /* Disable writes to flash interface (lock write-protect) */
3845 bnx2_disable_nvram_write(bp);
3846
3847 /* Disable access to flash interface */
3848 bnx2_disable_nvram_access(bp);
3849 bnx2_release_nvram_lock(bp);
3850
3851 /* Increment written */
3852 written += data_end - data_start;
3853 }
3854
3855nvram_write_end:
Michael Chane6be7632007-01-08 19:56:13 -08003856 kfree(flash_buffer);
3857 kfree(align_buf);
Michael Chanb6016b72005-05-26 13:03:09 -07003858 return rc;
3859}
3860
Michael Chan0d8a6572007-07-07 22:49:43 -07003861static void
3862bnx2_init_remote_phy(struct bnx2 *bp)
3863{
3864 u32 val;
3865
3866 bp->phy_flags &= ~REMOTE_PHY_CAP_FLAG;
3867 if (!(bp->phy_flags & PHY_SERDES_FLAG))
3868 return;
3869
3870 val = REG_RD_IND(bp, bp->shmem_base + BNX2_FW_CAP_MB);
3871 if ((val & BNX2_FW_CAP_SIGNATURE_MASK) != BNX2_FW_CAP_SIGNATURE)
3872 return;
3873
3874 if (val & BNX2_FW_CAP_REMOTE_PHY_CAPABLE) {
3875 if (netif_running(bp->dev)) {
3876 val = BNX2_DRV_ACK_CAP_SIGNATURE |
3877 BNX2_FW_CAP_REMOTE_PHY_CAPABLE;
3878 REG_WR_IND(bp, bp->shmem_base + BNX2_DRV_ACK_CAP_MB,
3879 val);
3880 }
3881 bp->phy_flags |= REMOTE_PHY_CAP_FLAG;
3882
3883 val = REG_RD_IND(bp, bp->shmem_base + BNX2_LINK_STATUS);
3884 if (val & BNX2_LINK_STATUS_SERDES_LINK)
3885 bp->phy_port = PORT_FIBRE;
3886 else
3887 bp->phy_port = PORT_TP;
3888 }
3889}
3890
Michael Chanb6016b72005-05-26 13:03:09 -07003891static int
3892bnx2_reset_chip(struct bnx2 *bp, u32 reset_code)
3893{
3894 u32 val;
3895 int i, rc = 0;
3896
3897 /* Wait for the current PCI transaction to complete before
3898 * issuing a reset. */
3899 REG_WR(bp, BNX2_MISC_ENABLE_CLR_BITS,
3900 BNX2_MISC_ENABLE_CLR_BITS_TX_DMA_ENABLE |
3901 BNX2_MISC_ENABLE_CLR_BITS_DMA_ENGINE_ENABLE |
3902 BNX2_MISC_ENABLE_CLR_BITS_RX_DMA_ENABLE |
3903 BNX2_MISC_ENABLE_CLR_BITS_HOST_COALESCE_ENABLE);
3904 val = REG_RD(bp, BNX2_MISC_ENABLE_CLR_BITS);
3905 udelay(5);
3906
Michael Chanb090ae22006-01-23 16:07:10 -08003907 /* Wait for the firmware to tell us it is ok to issue a reset. */
3908 bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT0 | reset_code, 1);
3909
Michael Chanb6016b72005-05-26 13:03:09 -07003910 /* Deposit a driver reset signature so the firmware knows that
3911 * this is a soft reset. */
Michael Chane3648b32005-11-04 08:51:21 -08003912 REG_WR_IND(bp, bp->shmem_base + BNX2_DRV_RESET_SIGNATURE,
Michael Chanb6016b72005-05-26 13:03:09 -07003913 BNX2_DRV_RESET_SIGNATURE_MAGIC);
3914
Michael Chanb6016b72005-05-26 13:03:09 -07003915 /* Do a dummy read to force the chip to complete all current transaction
3916 * before we issue a reset. */
3917 val = REG_RD(bp, BNX2_MISC_ID);
3918
Michael Chan234754d2006-11-19 14:11:41 -08003919 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
3920 REG_WR(bp, BNX2_MISC_COMMAND, BNX2_MISC_COMMAND_SW_RESET);
3921 REG_RD(bp, BNX2_MISC_COMMAND);
3922 udelay(5);
Michael Chanb6016b72005-05-26 13:03:09 -07003923
Michael Chan234754d2006-11-19 14:11:41 -08003924 val = BNX2_PCICFG_MISC_CONFIG_REG_WINDOW_ENA |
3925 BNX2_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP;
Michael Chanb6016b72005-05-26 13:03:09 -07003926
Michael Chan234754d2006-11-19 14:11:41 -08003927 pci_write_config_dword(bp->pdev, BNX2_PCICFG_MISC_CONFIG, val);
Michael Chanb6016b72005-05-26 13:03:09 -07003928
Michael Chan234754d2006-11-19 14:11:41 -08003929 } else {
3930 val = BNX2_PCICFG_MISC_CONFIG_CORE_RST_REQ |
3931 BNX2_PCICFG_MISC_CONFIG_REG_WINDOW_ENA |
3932 BNX2_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP;
3933
3934 /* Chip reset. */
3935 REG_WR(bp, BNX2_PCICFG_MISC_CONFIG, val);
3936
3937 if ((CHIP_ID(bp) == CHIP_ID_5706_A0) ||
3938 (CHIP_ID(bp) == CHIP_ID_5706_A1)) {
3939 current->state = TASK_UNINTERRUPTIBLE;
3940 schedule_timeout(HZ / 50);
Michael Chanb6016b72005-05-26 13:03:09 -07003941 }
Michael Chanb6016b72005-05-26 13:03:09 -07003942
Michael Chan234754d2006-11-19 14:11:41 -08003943 /* Reset takes approximate 30 usec */
3944 for (i = 0; i < 10; i++) {
3945 val = REG_RD(bp, BNX2_PCICFG_MISC_CONFIG);
3946 if ((val & (BNX2_PCICFG_MISC_CONFIG_CORE_RST_REQ |
3947 BNX2_PCICFG_MISC_CONFIG_CORE_RST_BSY)) == 0)
3948 break;
3949 udelay(10);
3950 }
3951
3952 if (val & (BNX2_PCICFG_MISC_CONFIG_CORE_RST_REQ |
3953 BNX2_PCICFG_MISC_CONFIG_CORE_RST_BSY)) {
3954 printk(KERN_ERR PFX "Chip reset did not complete\n");
3955 return -EBUSY;
3956 }
Michael Chanb6016b72005-05-26 13:03:09 -07003957 }
3958
3959 /* Make sure byte swapping is properly configured. */
3960 val = REG_RD(bp, BNX2_PCI_SWAP_DIAG0);
3961 if (val != 0x01020304) {
3962 printk(KERN_ERR PFX "Chip not in correct endian mode\n");
3963 return -ENODEV;
3964 }
3965
Michael Chanb6016b72005-05-26 13:03:09 -07003966 /* Wait for the firmware to finish its initialization. */
Michael Chanb090ae22006-01-23 16:07:10 -08003967 rc = bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT1 | reset_code, 0);
3968 if (rc)
3969 return rc;
Michael Chanb6016b72005-05-26 13:03:09 -07003970
Michael Chan0d8a6572007-07-07 22:49:43 -07003971 spin_lock_bh(&bp->phy_lock);
3972 bnx2_init_remote_phy(bp);
3973 if (bp->phy_flags & REMOTE_PHY_CAP_FLAG)
3974 bnx2_set_default_remote_link(bp);
3975 spin_unlock_bh(&bp->phy_lock);
3976
Michael Chanb6016b72005-05-26 13:03:09 -07003977 if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
3978 /* Adjust the voltage regular to two steps lower. The default
3979 * of this register is 0x0000000e. */
3980 REG_WR(bp, BNX2_MISC_VREG_CONTROL, 0x000000fa);
3981
3982 /* Remove bad rbuf memory from the free pool. */
3983 rc = bnx2_alloc_bad_rbuf(bp);
3984 }
3985
3986 return rc;
3987}
3988
3989static int
3990bnx2_init_chip(struct bnx2 *bp)
3991{
3992 u32 val;
Michael Chanb090ae22006-01-23 16:07:10 -08003993 int rc;
Michael Chanb6016b72005-05-26 13:03:09 -07003994
3995 /* Make sure the interrupt is not active. */
3996 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD, BNX2_PCICFG_INT_ACK_CMD_MASK_INT);
3997
3998 val = BNX2_DMA_CONFIG_DATA_BYTE_SWAP |
3999 BNX2_DMA_CONFIG_DATA_WORD_SWAP |
4000#ifdef __BIG_ENDIAN
Jeff Garzik6aa20a22006-09-13 13:24:59 -04004001 BNX2_DMA_CONFIG_CNTL_BYTE_SWAP |
Michael Chanb6016b72005-05-26 13:03:09 -07004002#endif
Jeff Garzik6aa20a22006-09-13 13:24:59 -04004003 BNX2_DMA_CONFIG_CNTL_WORD_SWAP |
Michael Chanb6016b72005-05-26 13:03:09 -07004004 DMA_READ_CHANS << 12 |
4005 DMA_WRITE_CHANS << 16;
4006
4007 val |= (0x2 << 20) | (1 << 11);
4008
Michael Chandda1e392006-01-23 16:08:14 -08004009 if ((bp->flags & PCIX_FLAG) && (bp->bus_speed_mhz == 133))
Michael Chanb6016b72005-05-26 13:03:09 -07004010 val |= (1 << 23);
4011
4012 if ((CHIP_NUM(bp) == CHIP_NUM_5706) &&
4013 (CHIP_ID(bp) != CHIP_ID_5706_A0) && !(bp->flags & PCIX_FLAG))
4014 val |= BNX2_DMA_CONFIG_CNTL_PING_PONG_DMA;
4015
4016 REG_WR(bp, BNX2_DMA_CONFIG, val);
4017
4018 if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
4019 val = REG_RD(bp, BNX2_TDMA_CONFIG);
4020 val |= BNX2_TDMA_CONFIG_ONE_DMA;
4021 REG_WR(bp, BNX2_TDMA_CONFIG, val);
4022 }
4023
4024 if (bp->flags & PCIX_FLAG) {
4025 u16 val16;
4026
4027 pci_read_config_word(bp->pdev, bp->pcix_cap + PCI_X_CMD,
4028 &val16);
4029 pci_write_config_word(bp->pdev, bp->pcix_cap + PCI_X_CMD,
4030 val16 & ~PCI_X_CMD_ERO);
4031 }
4032
4033 REG_WR(bp, BNX2_MISC_ENABLE_SET_BITS,
4034 BNX2_MISC_ENABLE_SET_BITS_HOST_COALESCE_ENABLE |
4035 BNX2_MISC_ENABLE_STATUS_BITS_RX_V2P_ENABLE |
4036 BNX2_MISC_ENABLE_STATUS_BITS_CONTEXT_ENABLE);
4037
4038 /* Initialize context mapping and zero out the quick contexts. The
4039 * context block must have already been enabled. */
Michael Chan641bdcd2007-06-04 21:22:24 -07004040 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
4041 rc = bnx2_init_5709_context(bp);
4042 if (rc)
4043 return rc;
4044 } else
Michael Chan59b47d82006-11-19 14:10:45 -08004045 bnx2_init_context(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07004046
Michael Chanfba9fe92006-06-12 22:21:25 -07004047 if ((rc = bnx2_init_cpus(bp)) != 0)
4048 return rc;
4049
Michael Chanb6016b72005-05-26 13:03:09 -07004050 bnx2_init_nvram(bp);
4051
4052 bnx2_set_mac_addr(bp);
4053
4054 val = REG_RD(bp, BNX2_MQ_CONFIG);
4055 val &= ~BNX2_MQ_CONFIG_KNL_BYP_BLK_SIZE;
4056 val |= BNX2_MQ_CONFIG_KNL_BYP_BLK_SIZE_256;
Michael Chan68c9f752007-04-24 15:35:53 -07004057 if (CHIP_ID(bp) == CHIP_ID_5709_A0 || CHIP_ID(bp) == CHIP_ID_5709_A1)
4058 val |= BNX2_MQ_CONFIG_HALT_DIS;
4059
Michael Chanb6016b72005-05-26 13:03:09 -07004060 REG_WR(bp, BNX2_MQ_CONFIG, val);
4061
4062 val = 0x10000 + (MAX_CID_CNT * MB_KERNEL_CTX_SIZE);
4063 REG_WR(bp, BNX2_MQ_KNL_BYP_WIND_START, val);
4064 REG_WR(bp, BNX2_MQ_KNL_WIND_END, val);
4065
4066 val = (BCM_PAGE_BITS - 8) << 24;
4067 REG_WR(bp, BNX2_RV2P_CONFIG, val);
4068
4069 /* Configure page size. */
4070 val = REG_RD(bp, BNX2_TBDR_CONFIG);
4071 val &= ~BNX2_TBDR_CONFIG_PAGE_SIZE;
4072 val |= (BCM_PAGE_BITS - 8) << 24 | 0x40;
4073 REG_WR(bp, BNX2_TBDR_CONFIG, val);
4074
4075 val = bp->mac_addr[0] +
4076 (bp->mac_addr[1] << 8) +
4077 (bp->mac_addr[2] << 16) +
4078 bp->mac_addr[3] +
4079 (bp->mac_addr[4] << 8) +
4080 (bp->mac_addr[5] << 16);
4081 REG_WR(bp, BNX2_EMAC_BACKOFF_SEED, val);
4082
4083 /* Program the MTU. Also include 4 bytes for CRC32. */
4084 val = bp->dev->mtu + ETH_HLEN + 4;
4085 if (val > (MAX_ETHERNET_PACKET_SIZE + 4))
4086 val |= BNX2_EMAC_RX_MTU_SIZE_JUMBO_ENA;
4087 REG_WR(bp, BNX2_EMAC_RX_MTU_SIZE, val);
4088
4089 bp->last_status_idx = 0;
4090 bp->rx_mode = BNX2_EMAC_RX_MODE_SORT_MODE;
4091
4092 /* Set up how to generate a link change interrupt. */
4093 REG_WR(bp, BNX2_EMAC_ATTENTION_ENA, BNX2_EMAC_ATTENTION_ENA_LINK);
4094
4095 REG_WR(bp, BNX2_HC_STATUS_ADDR_L,
4096 (u64) bp->status_blk_mapping & 0xffffffff);
4097 REG_WR(bp, BNX2_HC_STATUS_ADDR_H, (u64) bp->status_blk_mapping >> 32);
4098
4099 REG_WR(bp, BNX2_HC_STATISTICS_ADDR_L,
4100 (u64) bp->stats_blk_mapping & 0xffffffff);
4101 REG_WR(bp, BNX2_HC_STATISTICS_ADDR_H,
4102 (u64) bp->stats_blk_mapping >> 32);
4103
Jeff Garzik6aa20a22006-09-13 13:24:59 -04004104 REG_WR(bp, BNX2_HC_TX_QUICK_CONS_TRIP,
Michael Chanb6016b72005-05-26 13:03:09 -07004105 (bp->tx_quick_cons_trip_int << 16) | bp->tx_quick_cons_trip);
4106
4107 REG_WR(bp, BNX2_HC_RX_QUICK_CONS_TRIP,
4108 (bp->rx_quick_cons_trip_int << 16) | bp->rx_quick_cons_trip);
4109
4110 REG_WR(bp, BNX2_HC_COMP_PROD_TRIP,
4111 (bp->comp_prod_trip_int << 16) | bp->comp_prod_trip);
4112
4113 REG_WR(bp, BNX2_HC_TX_TICKS, (bp->tx_ticks_int << 16) | bp->tx_ticks);
4114
4115 REG_WR(bp, BNX2_HC_RX_TICKS, (bp->rx_ticks_int << 16) | bp->rx_ticks);
4116
4117 REG_WR(bp, BNX2_HC_COM_TICKS,
4118 (bp->com_ticks_int << 16) | bp->com_ticks);
4119
4120 REG_WR(bp, BNX2_HC_CMD_TICKS,
4121 (bp->cmd_ticks_int << 16) | bp->cmd_ticks);
4122
Michael Chan02537b062007-06-04 21:24:07 -07004123 if (CHIP_NUM(bp) == CHIP_NUM_5708)
4124 REG_WR(bp, BNX2_HC_STATS_TICKS, 0);
4125 else
Michael Chan7ea69202007-07-16 18:27:10 -07004126 REG_WR(bp, BNX2_HC_STATS_TICKS, bp->stats_ticks);
Michael Chanb6016b72005-05-26 13:03:09 -07004127 REG_WR(bp, BNX2_HC_STAT_COLLECT_TICKS, 0xbb8); /* 3ms */
4128
4129 if (CHIP_ID(bp) == CHIP_ID_5706_A1)
Michael Chan8e6a72c2007-05-03 13:24:48 -07004130 val = BNX2_HC_CONFIG_COLLECT_STATS;
Michael Chanb6016b72005-05-26 13:03:09 -07004131 else {
Michael Chan8e6a72c2007-05-03 13:24:48 -07004132 val = BNX2_HC_CONFIG_RX_TMR_MODE | BNX2_HC_CONFIG_TX_TMR_MODE |
4133 BNX2_HC_CONFIG_COLLECT_STATS;
Michael Chanb6016b72005-05-26 13:03:09 -07004134 }
4135
Michael Chan8e6a72c2007-05-03 13:24:48 -07004136 if (bp->flags & ONE_SHOT_MSI_FLAG)
4137 val |= BNX2_HC_CONFIG_ONE_SHOT;
4138
4139 REG_WR(bp, BNX2_HC_CONFIG, val);
4140
Michael Chanb6016b72005-05-26 13:03:09 -07004141 /* Clear internal stats counters. */
4142 REG_WR(bp, BNX2_HC_COMMAND, BNX2_HC_COMMAND_CLR_STAT_NOW);
4143
Michael Chanda3e4fb2007-05-03 13:24:23 -07004144 REG_WR(bp, BNX2_HC_ATTN_BITS_ENABLE, STATUS_ATTN_EVENTS);
Michael Chanb6016b72005-05-26 13:03:09 -07004145
4146 /* Initialize the receive filter. */
4147 bnx2_set_rx_mode(bp->dev);
4148
Michael Chan0aa38df2007-06-04 21:23:06 -07004149 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
4150 val = REG_RD(bp, BNX2_MISC_NEW_CORE_CTL);
4151 val |= BNX2_MISC_NEW_CORE_CTL_DMA_ENABLE;
4152 REG_WR(bp, BNX2_MISC_NEW_CORE_CTL, val);
4153 }
Michael Chanb090ae22006-01-23 16:07:10 -08004154 rc = bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT2 | BNX2_DRV_MSG_CODE_RESET,
4155 0);
Michael Chanb6016b72005-05-26 13:03:09 -07004156
Michael Chandf149d72007-07-07 22:51:36 -07004157 REG_WR(bp, BNX2_MISC_ENABLE_SET_BITS, BNX2_MISC_ENABLE_DEFAULT);
Michael Chanb6016b72005-05-26 13:03:09 -07004158 REG_RD(bp, BNX2_MISC_ENABLE_SET_BITS);
4159
4160 udelay(20);
4161
Michael Chanbf5295b2006-03-23 01:11:56 -08004162 bp->hc_cmd = REG_RD(bp, BNX2_HC_COMMAND);
4163
Michael Chanb090ae22006-01-23 16:07:10 -08004164 return rc;
Michael Chanb6016b72005-05-26 13:03:09 -07004165}
4166
Michael Chan59b47d82006-11-19 14:10:45 -08004167static void
4168bnx2_init_tx_context(struct bnx2 *bp, u32 cid)
4169{
4170 u32 val, offset0, offset1, offset2, offset3;
4171
4172 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
4173 offset0 = BNX2_L2CTX_TYPE_XI;
4174 offset1 = BNX2_L2CTX_CMD_TYPE_XI;
4175 offset2 = BNX2_L2CTX_TBDR_BHADDR_HI_XI;
4176 offset3 = BNX2_L2CTX_TBDR_BHADDR_LO_XI;
4177 } else {
4178 offset0 = BNX2_L2CTX_TYPE;
4179 offset1 = BNX2_L2CTX_CMD_TYPE;
4180 offset2 = BNX2_L2CTX_TBDR_BHADDR_HI;
4181 offset3 = BNX2_L2CTX_TBDR_BHADDR_LO;
4182 }
4183 val = BNX2_L2CTX_TYPE_TYPE_L2 | BNX2_L2CTX_TYPE_SIZE_L2;
4184 CTX_WR(bp, GET_CID_ADDR(cid), offset0, val);
4185
4186 val = BNX2_L2CTX_CMD_TYPE_TYPE_L2 | (8 << 16);
4187 CTX_WR(bp, GET_CID_ADDR(cid), offset1, val);
4188
4189 val = (u64) bp->tx_desc_mapping >> 32;
4190 CTX_WR(bp, GET_CID_ADDR(cid), offset2, val);
4191
4192 val = (u64) bp->tx_desc_mapping & 0xffffffff;
4193 CTX_WR(bp, GET_CID_ADDR(cid), offset3, val);
4194}
Michael Chanb6016b72005-05-26 13:03:09 -07004195
4196static void
4197bnx2_init_tx_ring(struct bnx2 *bp)
4198{
4199 struct tx_bd *txbd;
Michael Chan59b47d82006-11-19 14:10:45 -08004200 u32 cid;
Michael Chanb6016b72005-05-26 13:03:09 -07004201
Michael Chan2f8af122006-08-15 01:39:10 -07004202 bp->tx_wake_thresh = bp->tx_ring_size / 2;
4203
Michael Chanb6016b72005-05-26 13:03:09 -07004204 txbd = &bp->tx_desc_ring[MAX_TX_DESC_CNT];
Jeff Garzik6aa20a22006-09-13 13:24:59 -04004205
Michael Chanb6016b72005-05-26 13:03:09 -07004206 txbd->tx_bd_haddr_hi = (u64) bp->tx_desc_mapping >> 32;
4207 txbd->tx_bd_haddr_lo = (u64) bp->tx_desc_mapping & 0xffffffff;
4208
4209 bp->tx_prod = 0;
4210 bp->tx_cons = 0;
Michael Chanf4e418f2005-11-04 08:53:48 -08004211 bp->hw_tx_cons = 0;
Michael Chanb6016b72005-05-26 13:03:09 -07004212 bp->tx_prod_bseq = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04004213
Michael Chan59b47d82006-11-19 14:10:45 -08004214 cid = TX_CID;
4215 bp->tx_bidx_addr = MB_GET_CID_ADDR(cid) + BNX2_L2CTX_TX_HOST_BIDX;
4216 bp->tx_bseq_addr = MB_GET_CID_ADDR(cid) + BNX2_L2CTX_TX_HOST_BSEQ;
Michael Chanb6016b72005-05-26 13:03:09 -07004217
Michael Chan59b47d82006-11-19 14:10:45 -08004218 bnx2_init_tx_context(bp, cid);
Michael Chanb6016b72005-05-26 13:03:09 -07004219}
4220
4221static void
4222bnx2_init_rx_ring(struct bnx2 *bp)
4223{
4224 struct rx_bd *rxbd;
4225 int i;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04004226 u16 prod, ring_prod;
Michael Chanb6016b72005-05-26 13:03:09 -07004227 u32 val;
4228
4229 /* 8 for CRC and VLAN */
4230 bp->rx_buf_use_size = bp->dev->mtu + ETH_HLEN + bp->rx_offset + 8;
Michael Chan59b47d82006-11-19 14:10:45 -08004231 /* hw alignment */
4232 bp->rx_buf_size = bp->rx_buf_use_size + BNX2_RX_ALIGN;
Michael Chanb6016b72005-05-26 13:03:09 -07004233
4234 ring_prod = prod = bp->rx_prod = 0;
4235 bp->rx_cons = 0;
Michael Chanf4e418f2005-11-04 08:53:48 -08004236 bp->hw_rx_cons = 0;
Michael Chanb6016b72005-05-26 13:03:09 -07004237 bp->rx_prod_bseq = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04004238
Michael Chan13daffa2006-03-20 17:49:20 -08004239 for (i = 0; i < bp->rx_max_ring; i++) {
4240 int j;
Michael Chanb6016b72005-05-26 13:03:09 -07004241
Michael Chan13daffa2006-03-20 17:49:20 -08004242 rxbd = &bp->rx_desc_ring[i][0];
4243 for (j = 0; j < MAX_RX_DESC_CNT; j++, rxbd++) {
4244 rxbd->rx_bd_len = bp->rx_buf_use_size;
4245 rxbd->rx_bd_flags = RX_BD_FLAGS_START | RX_BD_FLAGS_END;
4246 }
4247 if (i == (bp->rx_max_ring - 1))
4248 j = 0;
4249 else
4250 j = i + 1;
4251 rxbd->rx_bd_haddr_hi = (u64) bp->rx_desc_mapping[j] >> 32;
4252 rxbd->rx_bd_haddr_lo = (u64) bp->rx_desc_mapping[j] &
4253 0xffffffff;
4254 }
Michael Chanb6016b72005-05-26 13:03:09 -07004255
4256 val = BNX2_L2CTX_CTX_TYPE_CTX_BD_CHN_TYPE_VALUE;
4257 val |= BNX2_L2CTX_CTX_TYPE_SIZE_L2;
4258 val |= 0x02 << 8;
4259 CTX_WR(bp, GET_CID_ADDR(RX_CID), BNX2_L2CTX_CTX_TYPE, val);
4260
Michael Chan13daffa2006-03-20 17:49:20 -08004261 val = (u64) bp->rx_desc_mapping[0] >> 32;
Michael Chanb6016b72005-05-26 13:03:09 -07004262 CTX_WR(bp, GET_CID_ADDR(RX_CID), BNX2_L2CTX_NX_BDHADDR_HI, val);
4263
Michael Chan13daffa2006-03-20 17:49:20 -08004264 val = (u64) bp->rx_desc_mapping[0] & 0xffffffff;
Michael Chanb6016b72005-05-26 13:03:09 -07004265 CTX_WR(bp, GET_CID_ADDR(RX_CID), BNX2_L2CTX_NX_BDHADDR_LO, val);
4266
Michael Chan236b6392006-03-20 17:49:02 -08004267 for (i = 0; i < bp->rx_ring_size; i++) {
Michael Chanb6016b72005-05-26 13:03:09 -07004268 if (bnx2_alloc_rx_skb(bp, ring_prod) < 0) {
4269 break;
4270 }
4271 prod = NEXT_RX_BD(prod);
4272 ring_prod = RX_RING_IDX(prod);
4273 }
4274 bp->rx_prod = prod;
4275
4276 REG_WR16(bp, MB_RX_CID_ADDR + BNX2_L2CTX_HOST_BDIDX, prod);
4277
4278 REG_WR(bp, MB_RX_CID_ADDR + BNX2_L2CTX_HOST_BSEQ, bp->rx_prod_bseq);
4279}
4280
4281static void
Michael Chan13daffa2006-03-20 17:49:20 -08004282bnx2_set_rx_ring_size(struct bnx2 *bp, u32 size)
4283{
4284 u32 num_rings, max;
4285
4286 bp->rx_ring_size = size;
4287 num_rings = 1;
4288 while (size > MAX_RX_DESC_CNT) {
4289 size -= MAX_RX_DESC_CNT;
4290 num_rings++;
4291 }
4292 /* round to next power of 2 */
4293 max = MAX_RX_RINGS;
4294 while ((max & num_rings) == 0)
4295 max >>= 1;
4296
4297 if (num_rings != max)
4298 max <<= 1;
4299
4300 bp->rx_max_ring = max;
4301 bp->rx_max_ring_idx = (bp->rx_max_ring * RX_DESC_CNT) - 1;
4302}
4303
4304static void
Michael Chanb6016b72005-05-26 13:03:09 -07004305bnx2_free_tx_skbs(struct bnx2 *bp)
4306{
4307 int i;
4308
4309 if (bp->tx_buf_ring == NULL)
4310 return;
4311
4312 for (i = 0; i < TX_DESC_CNT; ) {
4313 struct sw_bd *tx_buf = &bp->tx_buf_ring[i];
4314 struct sk_buff *skb = tx_buf->skb;
4315 int j, last;
4316
4317 if (skb == NULL) {
4318 i++;
4319 continue;
4320 }
4321
4322 pci_unmap_single(bp->pdev, pci_unmap_addr(tx_buf, mapping),
4323 skb_headlen(skb), PCI_DMA_TODEVICE);
4324
4325 tx_buf->skb = NULL;
4326
4327 last = skb_shinfo(skb)->nr_frags;
4328 for (j = 0; j < last; j++) {
4329 tx_buf = &bp->tx_buf_ring[i + j + 1];
4330 pci_unmap_page(bp->pdev,
4331 pci_unmap_addr(tx_buf, mapping),
4332 skb_shinfo(skb)->frags[j].size,
4333 PCI_DMA_TODEVICE);
4334 }
Michael Chan745720e2006-06-29 12:37:41 -07004335 dev_kfree_skb(skb);
Michael Chanb6016b72005-05-26 13:03:09 -07004336 i += j + 1;
4337 }
4338
4339}
4340
4341static void
4342bnx2_free_rx_skbs(struct bnx2 *bp)
4343{
4344 int i;
4345
4346 if (bp->rx_buf_ring == NULL)
4347 return;
4348
Michael Chan13daffa2006-03-20 17:49:20 -08004349 for (i = 0; i < bp->rx_max_ring_idx; i++) {
Michael Chanb6016b72005-05-26 13:03:09 -07004350 struct sw_bd *rx_buf = &bp->rx_buf_ring[i];
4351 struct sk_buff *skb = rx_buf->skb;
4352
Michael Chan05d0f1c2005-11-04 08:53:48 -08004353 if (skb == NULL)
Michael Chanb6016b72005-05-26 13:03:09 -07004354 continue;
4355
4356 pci_unmap_single(bp->pdev, pci_unmap_addr(rx_buf, mapping),
4357 bp->rx_buf_use_size, PCI_DMA_FROMDEVICE);
4358
4359 rx_buf->skb = NULL;
4360
Michael Chan745720e2006-06-29 12:37:41 -07004361 dev_kfree_skb(skb);
Michael Chanb6016b72005-05-26 13:03:09 -07004362 }
4363}
4364
4365static void
4366bnx2_free_skbs(struct bnx2 *bp)
4367{
4368 bnx2_free_tx_skbs(bp);
4369 bnx2_free_rx_skbs(bp);
4370}
4371
4372static int
4373bnx2_reset_nic(struct bnx2 *bp, u32 reset_code)
4374{
4375 int rc;
4376
4377 rc = bnx2_reset_chip(bp, reset_code);
4378 bnx2_free_skbs(bp);
4379 if (rc)
4380 return rc;
4381
Michael Chanfba9fe92006-06-12 22:21:25 -07004382 if ((rc = bnx2_init_chip(bp)) != 0)
4383 return rc;
4384
Michael Chanb6016b72005-05-26 13:03:09 -07004385 bnx2_init_tx_ring(bp);
4386 bnx2_init_rx_ring(bp);
4387 return 0;
4388}
4389
4390static int
4391bnx2_init_nic(struct bnx2 *bp)
4392{
4393 int rc;
4394
4395 if ((rc = bnx2_reset_nic(bp, BNX2_DRV_MSG_CODE_RESET)) != 0)
4396 return rc;
4397
Michael Chan80be4432006-11-19 14:07:28 -08004398 spin_lock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07004399 bnx2_init_phy(bp);
4400 bnx2_set_link(bp);
Michael Chan0d8a6572007-07-07 22:49:43 -07004401 spin_unlock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07004402 return 0;
4403}
4404
4405static int
4406bnx2_test_registers(struct bnx2 *bp)
4407{
4408 int ret;
Michael Chan5bae30c2007-05-03 13:18:46 -07004409 int i, is_5709;
Arjan van de Venf71e1302006-03-03 21:33:57 -05004410 static const struct {
Michael Chanb6016b72005-05-26 13:03:09 -07004411 u16 offset;
4412 u16 flags;
Michael Chan5bae30c2007-05-03 13:18:46 -07004413#define BNX2_FL_NOT_5709 1
Michael Chanb6016b72005-05-26 13:03:09 -07004414 u32 rw_mask;
4415 u32 ro_mask;
4416 } reg_tbl[] = {
4417 { 0x006c, 0, 0x00000000, 0x0000003f },
4418 { 0x0090, 0, 0xffffffff, 0x00000000 },
4419 { 0x0094, 0, 0x00000000, 0x00000000 },
4420
Michael Chan5bae30c2007-05-03 13:18:46 -07004421 { 0x0404, BNX2_FL_NOT_5709, 0x00003f00, 0x00000000 },
4422 { 0x0418, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
4423 { 0x041c, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
4424 { 0x0420, BNX2_FL_NOT_5709, 0x00000000, 0x80ffffff },
4425 { 0x0424, BNX2_FL_NOT_5709, 0x00000000, 0x00000000 },
4426 { 0x0428, BNX2_FL_NOT_5709, 0x00000000, 0x00000001 },
4427 { 0x0450, BNX2_FL_NOT_5709, 0x00000000, 0x0000ffff },
4428 { 0x0454, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
4429 { 0x0458, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
Michael Chanb6016b72005-05-26 13:03:09 -07004430
Michael Chan5bae30c2007-05-03 13:18:46 -07004431 { 0x0808, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
4432 { 0x0854, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
4433 { 0x0868, BNX2_FL_NOT_5709, 0x00000000, 0x77777777 },
4434 { 0x086c, BNX2_FL_NOT_5709, 0x00000000, 0x77777777 },
4435 { 0x0870, BNX2_FL_NOT_5709, 0x00000000, 0x77777777 },
4436 { 0x0874, BNX2_FL_NOT_5709, 0x00000000, 0x77777777 },
Michael Chanb6016b72005-05-26 13:03:09 -07004437
Michael Chan5bae30c2007-05-03 13:18:46 -07004438 { 0x0c00, BNX2_FL_NOT_5709, 0x00000000, 0x00000001 },
4439 { 0x0c04, BNX2_FL_NOT_5709, 0x00000000, 0x03ff0001 },
4440 { 0x0c08, BNX2_FL_NOT_5709, 0x0f0ff073, 0x00000000 },
Michael Chanb6016b72005-05-26 13:03:09 -07004441
4442 { 0x1000, 0, 0x00000000, 0x00000001 },
4443 { 0x1004, 0, 0x00000000, 0x000f0001 },
Michael Chanb6016b72005-05-26 13:03:09 -07004444
4445 { 0x1408, 0, 0x01c00800, 0x00000000 },
4446 { 0x149c, 0, 0x8000ffff, 0x00000000 },
4447 { 0x14a8, 0, 0x00000000, 0x000001ff },
Michael Chan5b0c76a2005-11-04 08:45:49 -08004448 { 0x14ac, 0, 0x0fffffff, 0x10000000 },
Michael Chanb6016b72005-05-26 13:03:09 -07004449 { 0x14b0, 0, 0x00000002, 0x00000001 },
4450 { 0x14b8, 0, 0x00000000, 0x00000000 },
4451 { 0x14c0, 0, 0x00000000, 0x00000009 },
4452 { 0x14c4, 0, 0x00003fff, 0x00000000 },
4453 { 0x14cc, 0, 0x00000000, 0x00000001 },
4454 { 0x14d0, 0, 0xffffffff, 0x00000000 },
Michael Chanb6016b72005-05-26 13:03:09 -07004455
4456 { 0x1800, 0, 0x00000000, 0x00000001 },
4457 { 0x1804, 0, 0x00000000, 0x00000003 },
Michael Chanb6016b72005-05-26 13:03:09 -07004458
4459 { 0x2800, 0, 0x00000000, 0x00000001 },
4460 { 0x2804, 0, 0x00000000, 0x00003f01 },
4461 { 0x2808, 0, 0x0f3f3f03, 0x00000000 },
4462 { 0x2810, 0, 0xffff0000, 0x00000000 },
4463 { 0x2814, 0, 0xffff0000, 0x00000000 },
4464 { 0x2818, 0, 0xffff0000, 0x00000000 },
4465 { 0x281c, 0, 0xffff0000, 0x00000000 },
4466 { 0x2834, 0, 0xffffffff, 0x00000000 },
4467 { 0x2840, 0, 0x00000000, 0xffffffff },
4468 { 0x2844, 0, 0x00000000, 0xffffffff },
4469 { 0x2848, 0, 0xffffffff, 0x00000000 },
4470 { 0x284c, 0, 0xf800f800, 0x07ff07ff },
4471
4472 { 0x2c00, 0, 0x00000000, 0x00000011 },
4473 { 0x2c04, 0, 0x00000000, 0x00030007 },
4474
Michael Chanb6016b72005-05-26 13:03:09 -07004475 { 0x3c00, 0, 0x00000000, 0x00000001 },
4476 { 0x3c04, 0, 0x00000000, 0x00070000 },
4477 { 0x3c08, 0, 0x00007f71, 0x07f00000 },
4478 { 0x3c0c, 0, 0x1f3ffffc, 0x00000000 },
4479 { 0x3c10, 0, 0xffffffff, 0x00000000 },
4480 { 0x3c14, 0, 0x00000000, 0xffffffff },
4481 { 0x3c18, 0, 0x00000000, 0xffffffff },
4482 { 0x3c1c, 0, 0xfffff000, 0x00000000 },
4483 { 0x3c20, 0, 0xffffff00, 0x00000000 },
Michael Chanb6016b72005-05-26 13:03:09 -07004484
4485 { 0x5004, 0, 0x00000000, 0x0000007f },
4486 { 0x5008, 0, 0x0f0007ff, 0x00000000 },
Michael Chanb6016b72005-05-26 13:03:09 -07004487
Michael Chanb6016b72005-05-26 13:03:09 -07004488 { 0x5c00, 0, 0x00000000, 0x00000001 },
4489 { 0x5c04, 0, 0x00000000, 0x0003000f },
4490 { 0x5c08, 0, 0x00000003, 0x00000000 },
4491 { 0x5c0c, 0, 0x0000fff8, 0x00000000 },
4492 { 0x5c10, 0, 0x00000000, 0xffffffff },
4493 { 0x5c80, 0, 0x00000000, 0x0f7113f1 },
4494 { 0x5c84, 0, 0x00000000, 0x0000f333 },
4495 { 0x5c88, 0, 0x00000000, 0x00077373 },
4496 { 0x5c8c, 0, 0x00000000, 0x0007f737 },
4497
4498 { 0x6808, 0, 0x0000ff7f, 0x00000000 },
4499 { 0x680c, 0, 0xffffffff, 0x00000000 },
4500 { 0x6810, 0, 0xffffffff, 0x00000000 },
4501 { 0x6814, 0, 0xffffffff, 0x00000000 },
4502 { 0x6818, 0, 0xffffffff, 0x00000000 },
4503 { 0x681c, 0, 0xffffffff, 0x00000000 },
4504 { 0x6820, 0, 0x00ff00ff, 0x00000000 },
4505 { 0x6824, 0, 0x00ff00ff, 0x00000000 },
4506 { 0x6828, 0, 0x00ff00ff, 0x00000000 },
4507 { 0x682c, 0, 0x03ff03ff, 0x00000000 },
4508 { 0x6830, 0, 0x03ff03ff, 0x00000000 },
4509 { 0x6834, 0, 0x03ff03ff, 0x00000000 },
4510 { 0x6838, 0, 0x03ff03ff, 0x00000000 },
4511 { 0x683c, 0, 0x0000ffff, 0x00000000 },
4512 { 0x6840, 0, 0x00000ff0, 0x00000000 },
4513 { 0x6844, 0, 0x00ffff00, 0x00000000 },
4514 { 0x684c, 0, 0xffffffff, 0x00000000 },
4515 { 0x6850, 0, 0x7f7f7f7f, 0x00000000 },
4516 { 0x6854, 0, 0x7f7f7f7f, 0x00000000 },
4517 { 0x6858, 0, 0x7f7f7f7f, 0x00000000 },
4518 { 0x685c, 0, 0x7f7f7f7f, 0x00000000 },
4519 { 0x6908, 0, 0x00000000, 0x0001ff0f },
4520 { 0x690c, 0, 0x00000000, 0x0ffe00f0 },
4521
4522 { 0xffff, 0, 0x00000000, 0x00000000 },
4523 };
4524
4525 ret = 0;
Michael Chan5bae30c2007-05-03 13:18:46 -07004526 is_5709 = 0;
4527 if (CHIP_NUM(bp) == CHIP_NUM_5709)
4528 is_5709 = 1;
4529
Michael Chanb6016b72005-05-26 13:03:09 -07004530 for (i = 0; reg_tbl[i].offset != 0xffff; i++) {
4531 u32 offset, rw_mask, ro_mask, save_val, val;
Michael Chan5bae30c2007-05-03 13:18:46 -07004532 u16 flags = reg_tbl[i].flags;
4533
4534 if (is_5709 && (flags & BNX2_FL_NOT_5709))
4535 continue;
Michael Chanb6016b72005-05-26 13:03:09 -07004536
4537 offset = (u32) reg_tbl[i].offset;
4538 rw_mask = reg_tbl[i].rw_mask;
4539 ro_mask = reg_tbl[i].ro_mask;
4540
Peter Hagervall14ab9b82005-08-10 14:18:16 -07004541 save_val = readl(bp->regview + offset);
Michael Chanb6016b72005-05-26 13:03:09 -07004542
Peter Hagervall14ab9b82005-08-10 14:18:16 -07004543 writel(0, bp->regview + offset);
Michael Chanb6016b72005-05-26 13:03:09 -07004544
Peter Hagervall14ab9b82005-08-10 14:18:16 -07004545 val = readl(bp->regview + offset);
Michael Chanb6016b72005-05-26 13:03:09 -07004546 if ((val & rw_mask) != 0) {
4547 goto reg_test_err;
4548 }
4549
4550 if ((val & ro_mask) != (save_val & ro_mask)) {
4551 goto reg_test_err;
4552 }
4553
Peter Hagervall14ab9b82005-08-10 14:18:16 -07004554 writel(0xffffffff, bp->regview + offset);
Michael Chanb6016b72005-05-26 13:03:09 -07004555
Peter Hagervall14ab9b82005-08-10 14:18:16 -07004556 val = readl(bp->regview + offset);
Michael Chanb6016b72005-05-26 13:03:09 -07004557 if ((val & rw_mask) != rw_mask) {
4558 goto reg_test_err;
4559 }
4560
4561 if ((val & ro_mask) != (save_val & ro_mask)) {
4562 goto reg_test_err;
4563 }
4564
Peter Hagervall14ab9b82005-08-10 14:18:16 -07004565 writel(save_val, bp->regview + offset);
Michael Chanb6016b72005-05-26 13:03:09 -07004566 continue;
4567
4568reg_test_err:
Peter Hagervall14ab9b82005-08-10 14:18:16 -07004569 writel(save_val, bp->regview + offset);
Michael Chanb6016b72005-05-26 13:03:09 -07004570 ret = -ENODEV;
4571 break;
4572 }
4573 return ret;
4574}
4575
4576static int
4577bnx2_do_mem_test(struct bnx2 *bp, u32 start, u32 size)
4578{
Arjan van de Venf71e1302006-03-03 21:33:57 -05004579 static const u32 test_pattern[] = { 0x00000000, 0xffffffff, 0x55555555,
Michael Chanb6016b72005-05-26 13:03:09 -07004580 0xaaaaaaaa , 0xaa55aa55, 0x55aa55aa };
4581 int i;
4582
4583 for (i = 0; i < sizeof(test_pattern) / 4; i++) {
4584 u32 offset;
4585
4586 for (offset = 0; offset < size; offset += 4) {
4587
4588 REG_WR_IND(bp, start + offset, test_pattern[i]);
4589
4590 if (REG_RD_IND(bp, start + offset) !=
4591 test_pattern[i]) {
4592 return -ENODEV;
4593 }
4594 }
4595 }
4596 return 0;
4597}
4598
4599static int
4600bnx2_test_memory(struct bnx2 *bp)
4601{
4602 int ret = 0;
4603 int i;
Michael Chan5bae30c2007-05-03 13:18:46 -07004604 static struct mem_entry {
Michael Chanb6016b72005-05-26 13:03:09 -07004605 u32 offset;
4606 u32 len;
Michael Chan5bae30c2007-05-03 13:18:46 -07004607 } mem_tbl_5706[] = {
Michael Chanb6016b72005-05-26 13:03:09 -07004608 { 0x60000, 0x4000 },
Michael Chan5b0c76a2005-11-04 08:45:49 -08004609 { 0xa0000, 0x3000 },
Michael Chanb6016b72005-05-26 13:03:09 -07004610 { 0xe0000, 0x4000 },
4611 { 0x120000, 0x4000 },
4612 { 0x1a0000, 0x4000 },
4613 { 0x160000, 0x4000 },
4614 { 0xffffffff, 0 },
Michael Chan5bae30c2007-05-03 13:18:46 -07004615 },
4616 mem_tbl_5709[] = {
4617 { 0x60000, 0x4000 },
4618 { 0xa0000, 0x3000 },
4619 { 0xe0000, 0x4000 },
4620 { 0x120000, 0x4000 },
4621 { 0x1a0000, 0x4000 },
4622 { 0xffffffff, 0 },
Michael Chanb6016b72005-05-26 13:03:09 -07004623 };
Michael Chan5bae30c2007-05-03 13:18:46 -07004624 struct mem_entry *mem_tbl;
4625
4626 if (CHIP_NUM(bp) == CHIP_NUM_5709)
4627 mem_tbl = mem_tbl_5709;
4628 else
4629 mem_tbl = mem_tbl_5706;
Michael Chanb6016b72005-05-26 13:03:09 -07004630
4631 for (i = 0; mem_tbl[i].offset != 0xffffffff; i++) {
4632 if ((ret = bnx2_do_mem_test(bp, mem_tbl[i].offset,
4633 mem_tbl[i].len)) != 0) {
4634 return ret;
4635 }
4636 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04004637
Michael Chanb6016b72005-05-26 13:03:09 -07004638 return ret;
4639}
4640
Michael Chanbc5a0692006-01-23 16:13:22 -08004641#define BNX2_MAC_LOOPBACK 0
4642#define BNX2_PHY_LOOPBACK 1
4643
Michael Chanb6016b72005-05-26 13:03:09 -07004644static int
Michael Chanbc5a0692006-01-23 16:13:22 -08004645bnx2_run_loopback(struct bnx2 *bp, int loopback_mode)
Michael Chanb6016b72005-05-26 13:03:09 -07004646{
4647 unsigned int pkt_size, num_pkts, i;
4648 struct sk_buff *skb, *rx_skb;
4649 unsigned char *packet;
Michael Chanbc5a0692006-01-23 16:13:22 -08004650 u16 rx_start_idx, rx_idx;
Michael Chanb6016b72005-05-26 13:03:09 -07004651 dma_addr_t map;
4652 struct tx_bd *txbd;
4653 struct sw_bd *rx_buf;
4654 struct l2_fhdr *rx_hdr;
4655 int ret = -ENODEV;
4656
Michael Chanbc5a0692006-01-23 16:13:22 -08004657 if (loopback_mode == BNX2_MAC_LOOPBACK) {
4658 bp->loopback = MAC_LOOPBACK;
4659 bnx2_set_mac_loopback(bp);
4660 }
4661 else if (loopback_mode == BNX2_PHY_LOOPBACK) {
Michael Chan80be4432006-11-19 14:07:28 -08004662 bp->loopback = PHY_LOOPBACK;
Michael Chanbc5a0692006-01-23 16:13:22 -08004663 bnx2_set_phy_loopback(bp);
4664 }
4665 else
4666 return -EINVAL;
Michael Chanb6016b72005-05-26 13:03:09 -07004667
4668 pkt_size = 1514;
Michael Chan932f3772006-08-15 01:39:36 -07004669 skb = netdev_alloc_skb(bp->dev, pkt_size);
John W. Linvilleb6cbc3b62005-11-10 12:58:00 -08004670 if (!skb)
4671 return -ENOMEM;
Michael Chanb6016b72005-05-26 13:03:09 -07004672 packet = skb_put(skb, pkt_size);
Michael Chan66342922006-12-14 15:57:04 -08004673 memcpy(packet, bp->dev->dev_addr, 6);
Michael Chanb6016b72005-05-26 13:03:09 -07004674 memset(packet + 6, 0x0, 8);
4675 for (i = 14; i < pkt_size; i++)
4676 packet[i] = (unsigned char) (i & 0xff);
4677
4678 map = pci_map_single(bp->pdev, skb->data, pkt_size,
4679 PCI_DMA_TODEVICE);
4680
Michael Chanbf5295b2006-03-23 01:11:56 -08004681 REG_WR(bp, BNX2_HC_COMMAND,
4682 bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
4683
Michael Chanb6016b72005-05-26 13:03:09 -07004684 REG_RD(bp, BNX2_HC_COMMAND);
4685
4686 udelay(5);
4687 rx_start_idx = bp->status_blk->status_rx_quick_consumer_index0;
4688
Michael Chanb6016b72005-05-26 13:03:09 -07004689 num_pkts = 0;
4690
Michael Chanbc5a0692006-01-23 16:13:22 -08004691 txbd = &bp->tx_desc_ring[TX_RING_IDX(bp->tx_prod)];
Michael Chanb6016b72005-05-26 13:03:09 -07004692
4693 txbd->tx_bd_haddr_hi = (u64) map >> 32;
4694 txbd->tx_bd_haddr_lo = (u64) map & 0xffffffff;
4695 txbd->tx_bd_mss_nbytes = pkt_size;
4696 txbd->tx_bd_vlan_tag_flags = TX_BD_FLAGS_START | TX_BD_FLAGS_END;
4697
4698 num_pkts++;
Michael Chanbc5a0692006-01-23 16:13:22 -08004699 bp->tx_prod = NEXT_TX_BD(bp->tx_prod);
4700 bp->tx_prod_bseq += pkt_size;
Michael Chanb6016b72005-05-26 13:03:09 -07004701
Michael Chan234754d2006-11-19 14:11:41 -08004702 REG_WR16(bp, bp->tx_bidx_addr, bp->tx_prod);
4703 REG_WR(bp, bp->tx_bseq_addr, bp->tx_prod_bseq);
Michael Chanb6016b72005-05-26 13:03:09 -07004704
4705 udelay(100);
4706
Michael Chanbf5295b2006-03-23 01:11:56 -08004707 REG_WR(bp, BNX2_HC_COMMAND,
4708 bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
4709
Michael Chanb6016b72005-05-26 13:03:09 -07004710 REG_RD(bp, BNX2_HC_COMMAND);
4711
4712 udelay(5);
4713
4714 pci_unmap_single(bp->pdev, map, pkt_size, PCI_DMA_TODEVICE);
Michael Chan745720e2006-06-29 12:37:41 -07004715 dev_kfree_skb(skb);
Michael Chanb6016b72005-05-26 13:03:09 -07004716
Michael Chanbc5a0692006-01-23 16:13:22 -08004717 if (bp->status_blk->status_tx_quick_consumer_index0 != bp->tx_prod) {
Michael Chanb6016b72005-05-26 13:03:09 -07004718 goto loopback_test_done;
4719 }
4720
4721 rx_idx = bp->status_blk->status_rx_quick_consumer_index0;
4722 if (rx_idx != rx_start_idx + num_pkts) {
4723 goto loopback_test_done;
4724 }
4725
4726 rx_buf = &bp->rx_buf_ring[rx_start_idx];
4727 rx_skb = rx_buf->skb;
4728
4729 rx_hdr = (struct l2_fhdr *) rx_skb->data;
4730 skb_reserve(rx_skb, bp->rx_offset);
4731
4732 pci_dma_sync_single_for_cpu(bp->pdev,
4733 pci_unmap_addr(rx_buf, mapping),
4734 bp->rx_buf_size, PCI_DMA_FROMDEVICE);
4735
Michael Chanade2bfe2006-01-23 16:09:51 -08004736 if (rx_hdr->l2_fhdr_status &
Michael Chanb6016b72005-05-26 13:03:09 -07004737 (L2_FHDR_ERRORS_BAD_CRC |
4738 L2_FHDR_ERRORS_PHY_DECODE |
4739 L2_FHDR_ERRORS_ALIGNMENT |
4740 L2_FHDR_ERRORS_TOO_SHORT |
4741 L2_FHDR_ERRORS_GIANT_FRAME)) {
4742
4743 goto loopback_test_done;
4744 }
4745
4746 if ((rx_hdr->l2_fhdr_pkt_len - 4) != pkt_size) {
4747 goto loopback_test_done;
4748 }
4749
4750 for (i = 14; i < pkt_size; i++) {
4751 if (*(rx_skb->data + i) != (unsigned char) (i & 0xff)) {
4752 goto loopback_test_done;
4753 }
4754 }
4755
4756 ret = 0;
4757
4758loopback_test_done:
4759 bp->loopback = 0;
4760 return ret;
4761}
4762
Michael Chanbc5a0692006-01-23 16:13:22 -08004763#define BNX2_MAC_LOOPBACK_FAILED 1
4764#define BNX2_PHY_LOOPBACK_FAILED 2
4765#define BNX2_LOOPBACK_FAILED (BNX2_MAC_LOOPBACK_FAILED | \
4766 BNX2_PHY_LOOPBACK_FAILED)
4767
4768static int
4769bnx2_test_loopback(struct bnx2 *bp)
4770{
4771 int rc = 0;
4772
4773 if (!netif_running(bp->dev))
4774 return BNX2_LOOPBACK_FAILED;
4775
4776 bnx2_reset_nic(bp, BNX2_DRV_MSG_CODE_RESET);
4777 spin_lock_bh(&bp->phy_lock);
4778 bnx2_init_phy(bp);
4779 spin_unlock_bh(&bp->phy_lock);
4780 if (bnx2_run_loopback(bp, BNX2_MAC_LOOPBACK))
4781 rc |= BNX2_MAC_LOOPBACK_FAILED;
4782 if (bnx2_run_loopback(bp, BNX2_PHY_LOOPBACK))
4783 rc |= BNX2_PHY_LOOPBACK_FAILED;
4784 return rc;
4785}
4786
Michael Chanb6016b72005-05-26 13:03:09 -07004787#define NVRAM_SIZE 0x200
4788#define CRC32_RESIDUAL 0xdebb20e3
4789
4790static int
4791bnx2_test_nvram(struct bnx2 *bp)
4792{
4793 u32 buf[NVRAM_SIZE / 4];
4794 u8 *data = (u8 *) buf;
4795 int rc = 0;
4796 u32 magic, csum;
4797
4798 if ((rc = bnx2_nvram_read(bp, 0, data, 4)) != 0)
4799 goto test_nvram_done;
4800
4801 magic = be32_to_cpu(buf[0]);
4802 if (magic != 0x669955aa) {
4803 rc = -ENODEV;
4804 goto test_nvram_done;
4805 }
4806
4807 if ((rc = bnx2_nvram_read(bp, 0x100, data, NVRAM_SIZE)) != 0)
4808 goto test_nvram_done;
4809
4810 csum = ether_crc_le(0x100, data);
4811 if (csum != CRC32_RESIDUAL) {
4812 rc = -ENODEV;
4813 goto test_nvram_done;
4814 }
4815
4816 csum = ether_crc_le(0x100, data + 0x100);
4817 if (csum != CRC32_RESIDUAL) {
4818 rc = -ENODEV;
4819 }
4820
4821test_nvram_done:
4822 return rc;
4823}
4824
4825static int
4826bnx2_test_link(struct bnx2 *bp)
4827{
4828 u32 bmsr;
4829
Michael Chanc770a652005-08-25 15:38:39 -07004830 spin_lock_bh(&bp->phy_lock);
Michael Chan27a005b2007-05-03 13:23:41 -07004831 bnx2_enable_bmsr1(bp);
4832 bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
4833 bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
4834 bnx2_disable_bmsr1(bp);
Michael Chanc770a652005-08-25 15:38:39 -07004835 spin_unlock_bh(&bp->phy_lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04004836
Michael Chanb6016b72005-05-26 13:03:09 -07004837 if (bmsr & BMSR_LSTATUS) {
4838 return 0;
4839 }
4840 return -ENODEV;
4841}
4842
4843static int
4844bnx2_test_intr(struct bnx2 *bp)
4845{
4846 int i;
Michael Chanb6016b72005-05-26 13:03:09 -07004847 u16 status_idx;
4848
4849 if (!netif_running(bp->dev))
4850 return -ENODEV;
4851
4852 status_idx = REG_RD(bp, BNX2_PCICFG_INT_ACK_CMD) & 0xffff;
4853
4854 /* This register is not touched during run-time. */
Michael Chanbf5295b2006-03-23 01:11:56 -08004855 REG_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW);
Michael Chanb6016b72005-05-26 13:03:09 -07004856 REG_RD(bp, BNX2_HC_COMMAND);
4857
4858 for (i = 0; i < 10; i++) {
4859 if ((REG_RD(bp, BNX2_PCICFG_INT_ACK_CMD) & 0xffff) !=
4860 status_idx) {
4861
4862 break;
4863 }
4864
4865 msleep_interruptible(10);
4866 }
4867 if (i < 10)
4868 return 0;
4869
4870 return -ENODEV;
4871}
4872
4873static void
Michael Chan48b01e22006-11-19 14:08:00 -08004874bnx2_5706_serdes_timer(struct bnx2 *bp)
4875{
4876 spin_lock(&bp->phy_lock);
4877 if (bp->serdes_an_pending)
4878 bp->serdes_an_pending--;
4879 else if ((bp->link_up == 0) && (bp->autoneg & AUTONEG_SPEED)) {
4880 u32 bmcr;
4881
4882 bp->current_interval = bp->timer_interval;
4883
Michael Chanca58c3a2007-05-03 13:22:52 -07004884 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
Michael Chan48b01e22006-11-19 14:08:00 -08004885
4886 if (bmcr & BMCR_ANENABLE) {
4887 u32 phy1, phy2;
4888
4889 bnx2_write_phy(bp, 0x1c, 0x7c00);
4890 bnx2_read_phy(bp, 0x1c, &phy1);
4891
4892 bnx2_write_phy(bp, 0x17, 0x0f01);
4893 bnx2_read_phy(bp, 0x15, &phy2);
4894 bnx2_write_phy(bp, 0x17, 0x0f01);
4895 bnx2_read_phy(bp, 0x15, &phy2);
4896
4897 if ((phy1 & 0x10) && /* SIGNAL DETECT */
4898 !(phy2 & 0x20)) { /* no CONFIG */
4899
4900 bmcr &= ~BMCR_ANENABLE;
4901 bmcr |= BMCR_SPEED1000 | BMCR_FULLDPLX;
Michael Chanca58c3a2007-05-03 13:22:52 -07004902 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
Michael Chan48b01e22006-11-19 14:08:00 -08004903 bp->phy_flags |= PHY_PARALLEL_DETECT_FLAG;
4904 }
4905 }
4906 }
4907 else if ((bp->link_up) && (bp->autoneg & AUTONEG_SPEED) &&
4908 (bp->phy_flags & PHY_PARALLEL_DETECT_FLAG)) {
4909 u32 phy2;
4910
4911 bnx2_write_phy(bp, 0x17, 0x0f01);
4912 bnx2_read_phy(bp, 0x15, &phy2);
4913 if (phy2 & 0x20) {
4914 u32 bmcr;
4915
Michael Chanca58c3a2007-05-03 13:22:52 -07004916 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
Michael Chan48b01e22006-11-19 14:08:00 -08004917 bmcr |= BMCR_ANENABLE;
Michael Chanca58c3a2007-05-03 13:22:52 -07004918 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
Michael Chan48b01e22006-11-19 14:08:00 -08004919
4920 bp->phy_flags &= ~PHY_PARALLEL_DETECT_FLAG;
4921 }
4922 } else
4923 bp->current_interval = bp->timer_interval;
4924
4925 spin_unlock(&bp->phy_lock);
4926}
4927
4928static void
Michael Chanf8dd0642006-11-19 14:08:29 -08004929bnx2_5708_serdes_timer(struct bnx2 *bp)
4930{
Michael Chan0d8a6572007-07-07 22:49:43 -07004931 if (bp->phy_flags & REMOTE_PHY_CAP_FLAG)
4932 return;
4933
Michael Chanf8dd0642006-11-19 14:08:29 -08004934 if ((bp->phy_flags & PHY_2_5G_CAPABLE_FLAG) == 0) {
4935 bp->serdes_an_pending = 0;
4936 return;
4937 }
4938
4939 spin_lock(&bp->phy_lock);
4940 if (bp->serdes_an_pending)
4941 bp->serdes_an_pending--;
4942 else if ((bp->link_up == 0) && (bp->autoneg & AUTONEG_SPEED)) {
4943 u32 bmcr;
4944
Michael Chanca58c3a2007-05-03 13:22:52 -07004945 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
Michael Chanf8dd0642006-11-19 14:08:29 -08004946 if (bmcr & BMCR_ANENABLE) {
Michael Chan605a9e22007-05-03 13:23:13 -07004947 bnx2_enable_forced_2g5(bp);
Michael Chanf8dd0642006-11-19 14:08:29 -08004948 bp->current_interval = SERDES_FORCED_TIMEOUT;
4949 } else {
Michael Chan605a9e22007-05-03 13:23:13 -07004950 bnx2_disable_forced_2g5(bp);
Michael Chanf8dd0642006-11-19 14:08:29 -08004951 bp->serdes_an_pending = 2;
4952 bp->current_interval = bp->timer_interval;
4953 }
4954
4955 } else
4956 bp->current_interval = bp->timer_interval;
4957
4958 spin_unlock(&bp->phy_lock);
4959}
4960
4961static void
Michael Chanb6016b72005-05-26 13:03:09 -07004962bnx2_timer(unsigned long data)
4963{
4964 struct bnx2 *bp = (struct bnx2 *) data;
Michael Chanb6016b72005-05-26 13:03:09 -07004965
Michael Chancd339a02005-08-25 15:35:24 -07004966 if (!netif_running(bp->dev))
4967 return;
4968
Michael Chanb6016b72005-05-26 13:03:09 -07004969 if (atomic_read(&bp->intr_sem) != 0)
4970 goto bnx2_restart_timer;
4971
Michael Chandf149d72007-07-07 22:51:36 -07004972 bnx2_send_heart_beat(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07004973
Michael Chancea94db2006-06-12 22:16:13 -07004974 bp->stats_blk->stat_FwRxDrop = REG_RD_IND(bp, BNX2_FW_RX_DROP_COUNT);
4975
Michael Chan02537b062007-06-04 21:24:07 -07004976 /* workaround occasional corrupted counters */
4977 if (CHIP_NUM(bp) == CHIP_NUM_5708 && bp->stats_ticks)
4978 REG_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd |
4979 BNX2_HC_COMMAND_STATS_NOW);
4980
Michael Chanf8dd0642006-11-19 14:08:29 -08004981 if (bp->phy_flags & PHY_SERDES_FLAG) {
4982 if (CHIP_NUM(bp) == CHIP_NUM_5706)
4983 bnx2_5706_serdes_timer(bp);
Michael Chan27a005b2007-05-03 13:23:41 -07004984 else
Michael Chanf8dd0642006-11-19 14:08:29 -08004985 bnx2_5708_serdes_timer(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07004986 }
4987
4988bnx2_restart_timer:
Michael Chancd339a02005-08-25 15:35:24 -07004989 mod_timer(&bp->timer, jiffies + bp->current_interval);
Michael Chanb6016b72005-05-26 13:03:09 -07004990}
4991
Michael Chan8e6a72c2007-05-03 13:24:48 -07004992static int
4993bnx2_request_irq(struct bnx2 *bp)
4994{
4995 struct net_device *dev = bp->dev;
4996 int rc = 0;
4997
4998 if (bp->flags & USING_MSI_FLAG) {
4999 irq_handler_t fn = bnx2_msi;
5000
5001 if (bp->flags & ONE_SHOT_MSI_FLAG)
5002 fn = bnx2_msi_1shot;
5003
5004 rc = request_irq(bp->pdev->irq, fn, 0, dev->name, dev);
5005 } else
5006 rc = request_irq(bp->pdev->irq, bnx2_interrupt,
5007 IRQF_SHARED, dev->name, dev);
5008 return rc;
5009}
5010
5011static void
5012bnx2_free_irq(struct bnx2 *bp)
5013{
5014 struct net_device *dev = bp->dev;
5015
5016 if (bp->flags & USING_MSI_FLAG) {
5017 free_irq(bp->pdev->irq, dev);
5018 pci_disable_msi(bp->pdev);
5019 bp->flags &= ~(USING_MSI_FLAG | ONE_SHOT_MSI_FLAG);
5020 } else
5021 free_irq(bp->pdev->irq, dev);
5022}
5023
Michael Chanb6016b72005-05-26 13:03:09 -07005024/* Called with rtnl_lock */
5025static int
5026bnx2_open(struct net_device *dev)
5027{
Michael Chan972ec0d2006-01-23 16:12:43 -08005028 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005029 int rc;
5030
Michael Chan1b2f9222007-05-03 13:20:19 -07005031 netif_carrier_off(dev);
5032
Pavel Machek829ca9a2005-09-03 15:56:56 -07005033 bnx2_set_power_state(bp, PCI_D0);
Michael Chanb6016b72005-05-26 13:03:09 -07005034 bnx2_disable_int(bp);
5035
5036 rc = bnx2_alloc_mem(bp);
5037 if (rc)
5038 return rc;
5039
Michael Chan8e6a72c2007-05-03 13:24:48 -07005040 if ((bp->flags & MSI_CAP_FLAG) && !disable_msi) {
Michael Chanb6016b72005-05-26 13:03:09 -07005041 if (pci_enable_msi(bp->pdev) == 0) {
5042 bp->flags |= USING_MSI_FLAG;
Michael Chan8e6a72c2007-05-03 13:24:48 -07005043 if (CHIP_NUM(bp) == CHIP_NUM_5709)
5044 bp->flags |= ONE_SHOT_MSI_FLAG;
Michael Chanb6016b72005-05-26 13:03:09 -07005045 }
5046 }
Michael Chan8e6a72c2007-05-03 13:24:48 -07005047 rc = bnx2_request_irq(bp);
5048
Michael Chanb6016b72005-05-26 13:03:09 -07005049 if (rc) {
5050 bnx2_free_mem(bp);
5051 return rc;
5052 }
5053
5054 rc = bnx2_init_nic(bp);
5055
5056 if (rc) {
Michael Chan8e6a72c2007-05-03 13:24:48 -07005057 bnx2_free_irq(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07005058 bnx2_free_skbs(bp);
5059 bnx2_free_mem(bp);
5060 return rc;
5061 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04005062
Michael Chancd339a02005-08-25 15:35:24 -07005063 mod_timer(&bp->timer, jiffies + bp->current_interval);
Michael Chanb6016b72005-05-26 13:03:09 -07005064
5065 atomic_set(&bp->intr_sem, 0);
5066
5067 bnx2_enable_int(bp);
5068
5069 if (bp->flags & USING_MSI_FLAG) {
5070 /* Test MSI to make sure it is working
5071 * If MSI test fails, go back to INTx mode
5072 */
5073 if (bnx2_test_intr(bp) != 0) {
5074 printk(KERN_WARNING PFX "%s: No interrupt was generated"
5075 " using MSI, switching to INTx mode. Please"
5076 " report this failure to the PCI maintainer"
5077 " and include system chipset information.\n",
5078 bp->dev->name);
5079
5080 bnx2_disable_int(bp);
Michael Chan8e6a72c2007-05-03 13:24:48 -07005081 bnx2_free_irq(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07005082
5083 rc = bnx2_init_nic(bp);
5084
Michael Chan8e6a72c2007-05-03 13:24:48 -07005085 if (!rc)
5086 rc = bnx2_request_irq(bp);
5087
Michael Chanb6016b72005-05-26 13:03:09 -07005088 if (rc) {
5089 bnx2_free_skbs(bp);
5090 bnx2_free_mem(bp);
5091 del_timer_sync(&bp->timer);
5092 return rc;
5093 }
5094 bnx2_enable_int(bp);
5095 }
5096 }
5097 if (bp->flags & USING_MSI_FLAG) {
5098 printk(KERN_INFO PFX "%s: using MSI\n", dev->name);
5099 }
5100
5101 netif_start_queue(dev);
5102
5103 return 0;
5104}
5105
5106static void
David Howellsc4028952006-11-22 14:57:56 +00005107bnx2_reset_task(struct work_struct *work)
Michael Chanb6016b72005-05-26 13:03:09 -07005108{
David Howellsc4028952006-11-22 14:57:56 +00005109 struct bnx2 *bp = container_of(work, struct bnx2, reset_task);
Michael Chanb6016b72005-05-26 13:03:09 -07005110
Michael Chanafdc08b2005-08-25 15:34:29 -07005111 if (!netif_running(bp->dev))
5112 return;
5113
5114 bp->in_reset_task = 1;
Michael Chanb6016b72005-05-26 13:03:09 -07005115 bnx2_netif_stop(bp);
5116
5117 bnx2_init_nic(bp);
5118
5119 atomic_set(&bp->intr_sem, 1);
5120 bnx2_netif_start(bp);
Michael Chanafdc08b2005-08-25 15:34:29 -07005121 bp->in_reset_task = 0;
Michael Chanb6016b72005-05-26 13:03:09 -07005122}
5123
5124static void
5125bnx2_tx_timeout(struct net_device *dev)
5126{
Michael Chan972ec0d2006-01-23 16:12:43 -08005127 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005128
5129 /* This allows the netif to be shutdown gracefully before resetting */
5130 schedule_work(&bp->reset_task);
5131}
5132
5133#ifdef BCM_VLAN
5134/* Called with rtnl_lock */
5135static void
5136bnx2_vlan_rx_register(struct net_device *dev, struct vlan_group *vlgrp)
5137{
Michael Chan972ec0d2006-01-23 16:12:43 -08005138 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005139
5140 bnx2_netif_stop(bp);
5141
5142 bp->vlgrp = vlgrp;
5143 bnx2_set_rx_mode(dev);
5144
5145 bnx2_netif_start(bp);
5146}
Michael Chanb6016b72005-05-26 13:03:09 -07005147#endif
5148
Herbert Xu932ff272006-06-09 12:20:56 -07005149/* Called with netif_tx_lock.
Michael Chan2f8af122006-08-15 01:39:10 -07005150 * bnx2_tx_int() runs without netif_tx_lock unless it needs to call
5151 * netif_wake_queue().
Michael Chanb6016b72005-05-26 13:03:09 -07005152 */
5153static int
5154bnx2_start_xmit(struct sk_buff *skb, struct net_device *dev)
5155{
Michael Chan972ec0d2006-01-23 16:12:43 -08005156 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005157 dma_addr_t mapping;
5158 struct tx_bd *txbd;
5159 struct sw_bd *tx_buf;
5160 u32 len, vlan_tag_flags, last_frag, mss;
5161 u16 prod, ring_prod;
5162 int i;
5163
Michael Chane89bbf12005-08-25 15:36:58 -07005164 if (unlikely(bnx2_tx_avail(bp) < (skb_shinfo(skb)->nr_frags + 1))) {
Michael Chanb6016b72005-05-26 13:03:09 -07005165 netif_stop_queue(dev);
5166 printk(KERN_ERR PFX "%s: BUG! Tx ring full when queue awake!\n",
5167 dev->name);
5168
5169 return NETDEV_TX_BUSY;
5170 }
5171 len = skb_headlen(skb);
5172 prod = bp->tx_prod;
5173 ring_prod = TX_RING_IDX(prod);
5174
5175 vlan_tag_flags = 0;
Patrick McHardy84fa7932006-08-29 16:44:56 -07005176 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Michael Chanb6016b72005-05-26 13:03:09 -07005177 vlan_tag_flags |= TX_BD_FLAGS_TCP_UDP_CKSUM;
5178 }
5179
5180 if (bp->vlgrp != 0 && vlan_tx_tag_present(skb)) {
5181 vlan_tag_flags |=
5182 (TX_BD_FLAGS_VLAN_TAG | (vlan_tx_tag_get(skb) << 16));
5183 }
Michael Chanfde82052007-05-03 17:23:35 -07005184 if ((mss = skb_shinfo(skb)->gso_size)) {
Michael Chanb6016b72005-05-26 13:03:09 -07005185 u32 tcp_opt_len, ip_tcp_len;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07005186 struct iphdr *iph;
Michael Chanb6016b72005-05-26 13:03:09 -07005187
Michael Chanb6016b72005-05-26 13:03:09 -07005188 vlan_tag_flags |= TX_BD_FLAGS_SW_LSO;
5189
Michael Chan4666f872007-05-03 13:22:28 -07005190 tcp_opt_len = tcp_optlen(skb);
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07005191
Michael Chan4666f872007-05-03 13:22:28 -07005192 if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6) {
5193 u32 tcp_off = skb_transport_offset(skb) -
5194 sizeof(struct ipv6hdr) - ETH_HLEN;
Michael Chanb6016b72005-05-26 13:03:09 -07005195
Michael Chan4666f872007-05-03 13:22:28 -07005196 vlan_tag_flags |= ((tcp_opt_len >> 2) << 8) |
5197 TX_BD_FLAGS_SW_FLAGS;
5198 if (likely(tcp_off == 0))
5199 vlan_tag_flags &= ~TX_BD_FLAGS_TCP6_OFF0_MSK;
5200 else {
5201 tcp_off >>= 3;
5202 vlan_tag_flags |= ((tcp_off & 0x3) <<
5203 TX_BD_FLAGS_TCP6_OFF0_SHL) |
5204 ((tcp_off & 0x10) <<
5205 TX_BD_FLAGS_TCP6_OFF4_SHL);
5206 mss |= (tcp_off & 0xc) << TX_BD_TCP6_OFF2_SHL;
5207 }
5208 } else {
5209 if (skb_header_cloned(skb) &&
5210 pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) {
5211 dev_kfree_skb(skb);
5212 return NETDEV_TX_OK;
5213 }
5214
5215 ip_tcp_len = ip_hdrlen(skb) + sizeof(struct tcphdr);
5216
5217 iph = ip_hdr(skb);
5218 iph->check = 0;
5219 iph->tot_len = htons(mss + ip_tcp_len + tcp_opt_len);
5220 tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
5221 iph->daddr, 0,
5222 IPPROTO_TCP,
5223 0);
5224 if (tcp_opt_len || (iph->ihl > 5)) {
5225 vlan_tag_flags |= ((iph->ihl - 5) +
5226 (tcp_opt_len >> 2)) << 8;
5227 }
Michael Chanb6016b72005-05-26 13:03:09 -07005228 }
Michael Chan4666f872007-05-03 13:22:28 -07005229 } else
Michael Chanb6016b72005-05-26 13:03:09 -07005230 mss = 0;
Michael Chanb6016b72005-05-26 13:03:09 -07005231
5232 mapping = pci_map_single(bp->pdev, skb->data, len, PCI_DMA_TODEVICE);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04005233
Michael Chanb6016b72005-05-26 13:03:09 -07005234 tx_buf = &bp->tx_buf_ring[ring_prod];
5235 tx_buf->skb = skb;
5236 pci_unmap_addr_set(tx_buf, mapping, mapping);
5237
5238 txbd = &bp->tx_desc_ring[ring_prod];
5239
5240 txbd->tx_bd_haddr_hi = (u64) mapping >> 32;
5241 txbd->tx_bd_haddr_lo = (u64) mapping & 0xffffffff;
5242 txbd->tx_bd_mss_nbytes = len | (mss << 16);
5243 txbd->tx_bd_vlan_tag_flags = vlan_tag_flags | TX_BD_FLAGS_START;
5244
5245 last_frag = skb_shinfo(skb)->nr_frags;
5246
5247 for (i = 0; i < last_frag; i++) {
5248 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
5249
5250 prod = NEXT_TX_BD(prod);
5251 ring_prod = TX_RING_IDX(prod);
5252 txbd = &bp->tx_desc_ring[ring_prod];
5253
5254 len = frag->size;
5255 mapping = pci_map_page(bp->pdev, frag->page, frag->page_offset,
5256 len, PCI_DMA_TODEVICE);
5257 pci_unmap_addr_set(&bp->tx_buf_ring[ring_prod],
5258 mapping, mapping);
5259
5260 txbd->tx_bd_haddr_hi = (u64) mapping >> 32;
5261 txbd->tx_bd_haddr_lo = (u64) mapping & 0xffffffff;
5262 txbd->tx_bd_mss_nbytes = len | (mss << 16);
5263 txbd->tx_bd_vlan_tag_flags = vlan_tag_flags;
5264
5265 }
5266 txbd->tx_bd_vlan_tag_flags |= TX_BD_FLAGS_END;
5267
5268 prod = NEXT_TX_BD(prod);
5269 bp->tx_prod_bseq += skb->len;
5270
Michael Chan234754d2006-11-19 14:11:41 -08005271 REG_WR16(bp, bp->tx_bidx_addr, prod);
5272 REG_WR(bp, bp->tx_bseq_addr, bp->tx_prod_bseq);
Michael Chanb6016b72005-05-26 13:03:09 -07005273
5274 mmiowb();
5275
5276 bp->tx_prod = prod;
5277 dev->trans_start = jiffies;
5278
Michael Chane89bbf12005-08-25 15:36:58 -07005279 if (unlikely(bnx2_tx_avail(bp) <= MAX_SKB_FRAGS)) {
Michael Chane89bbf12005-08-25 15:36:58 -07005280 netif_stop_queue(dev);
Michael Chan2f8af122006-08-15 01:39:10 -07005281 if (bnx2_tx_avail(bp) > bp->tx_wake_thresh)
Michael Chane89bbf12005-08-25 15:36:58 -07005282 netif_wake_queue(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005283 }
5284
5285 return NETDEV_TX_OK;
5286}
5287
5288/* Called with rtnl_lock */
5289static int
5290bnx2_close(struct net_device *dev)
5291{
Michael Chan972ec0d2006-01-23 16:12:43 -08005292 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005293 u32 reset_code;
5294
Michael Chanafdc08b2005-08-25 15:34:29 -07005295 /* Calling flush_scheduled_work() may deadlock because
5296 * linkwatch_event() may be on the workqueue and it will try to get
5297 * the rtnl_lock which we are holding.
5298 */
5299 while (bp->in_reset_task)
5300 msleep(1);
5301
Michael Chanb6016b72005-05-26 13:03:09 -07005302 bnx2_netif_stop(bp);
5303 del_timer_sync(&bp->timer);
Michael Chandda1e392006-01-23 16:08:14 -08005304 if (bp->flags & NO_WOL_FLAG)
Michael Chan6c4f0952006-06-29 12:38:15 -07005305 reset_code = BNX2_DRV_MSG_CODE_UNLOAD_LNK_DN;
Michael Chandda1e392006-01-23 16:08:14 -08005306 else if (bp->wol)
Michael Chanb6016b72005-05-26 13:03:09 -07005307 reset_code = BNX2_DRV_MSG_CODE_SUSPEND_WOL;
5308 else
5309 reset_code = BNX2_DRV_MSG_CODE_SUSPEND_NO_WOL;
5310 bnx2_reset_chip(bp, reset_code);
Michael Chan8e6a72c2007-05-03 13:24:48 -07005311 bnx2_free_irq(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07005312 bnx2_free_skbs(bp);
5313 bnx2_free_mem(bp);
5314 bp->link_up = 0;
5315 netif_carrier_off(bp->dev);
Pavel Machek829ca9a2005-09-03 15:56:56 -07005316 bnx2_set_power_state(bp, PCI_D3hot);
Michael Chanb6016b72005-05-26 13:03:09 -07005317 return 0;
5318}
5319
5320#define GET_NET_STATS64(ctr) \
5321 (unsigned long) ((unsigned long) (ctr##_hi) << 32) + \
5322 (unsigned long) (ctr##_lo)
5323
5324#define GET_NET_STATS32(ctr) \
5325 (ctr##_lo)
5326
5327#if (BITS_PER_LONG == 64)
5328#define GET_NET_STATS GET_NET_STATS64
5329#else
5330#define GET_NET_STATS GET_NET_STATS32
5331#endif
5332
5333static struct net_device_stats *
5334bnx2_get_stats(struct net_device *dev)
5335{
Michael Chan972ec0d2006-01-23 16:12:43 -08005336 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005337 struct statistics_block *stats_blk = bp->stats_blk;
5338 struct net_device_stats *net_stats = &bp->net_stats;
5339
5340 if (bp->stats_blk == NULL) {
5341 return net_stats;
5342 }
5343 net_stats->rx_packets =
5344 GET_NET_STATS(stats_blk->stat_IfHCInUcastPkts) +
5345 GET_NET_STATS(stats_blk->stat_IfHCInMulticastPkts) +
5346 GET_NET_STATS(stats_blk->stat_IfHCInBroadcastPkts);
5347
5348 net_stats->tx_packets =
5349 GET_NET_STATS(stats_blk->stat_IfHCOutUcastPkts) +
5350 GET_NET_STATS(stats_blk->stat_IfHCOutMulticastPkts) +
5351 GET_NET_STATS(stats_blk->stat_IfHCOutBroadcastPkts);
5352
5353 net_stats->rx_bytes =
5354 GET_NET_STATS(stats_blk->stat_IfHCInOctets);
5355
5356 net_stats->tx_bytes =
5357 GET_NET_STATS(stats_blk->stat_IfHCOutOctets);
5358
Jeff Garzik6aa20a22006-09-13 13:24:59 -04005359 net_stats->multicast =
Michael Chanb6016b72005-05-26 13:03:09 -07005360 GET_NET_STATS(stats_blk->stat_IfHCOutMulticastPkts);
5361
Jeff Garzik6aa20a22006-09-13 13:24:59 -04005362 net_stats->collisions =
Michael Chanb6016b72005-05-26 13:03:09 -07005363 (unsigned long) stats_blk->stat_EtherStatsCollisions;
5364
Jeff Garzik6aa20a22006-09-13 13:24:59 -04005365 net_stats->rx_length_errors =
Michael Chanb6016b72005-05-26 13:03:09 -07005366 (unsigned long) (stats_blk->stat_EtherStatsUndersizePkts +
5367 stats_blk->stat_EtherStatsOverrsizePkts);
5368
Jeff Garzik6aa20a22006-09-13 13:24:59 -04005369 net_stats->rx_over_errors =
Michael Chanb6016b72005-05-26 13:03:09 -07005370 (unsigned long) stats_blk->stat_IfInMBUFDiscards;
5371
Jeff Garzik6aa20a22006-09-13 13:24:59 -04005372 net_stats->rx_frame_errors =
Michael Chanb6016b72005-05-26 13:03:09 -07005373 (unsigned long) stats_blk->stat_Dot3StatsAlignmentErrors;
5374
Jeff Garzik6aa20a22006-09-13 13:24:59 -04005375 net_stats->rx_crc_errors =
Michael Chanb6016b72005-05-26 13:03:09 -07005376 (unsigned long) stats_blk->stat_Dot3StatsFCSErrors;
5377
5378 net_stats->rx_errors = net_stats->rx_length_errors +
5379 net_stats->rx_over_errors + net_stats->rx_frame_errors +
5380 net_stats->rx_crc_errors;
5381
5382 net_stats->tx_aborted_errors =
5383 (unsigned long) (stats_blk->stat_Dot3StatsExcessiveCollisions +
5384 stats_blk->stat_Dot3StatsLateCollisions);
5385
Michael Chan5b0c76a2005-11-04 08:45:49 -08005386 if ((CHIP_NUM(bp) == CHIP_NUM_5706) ||
5387 (CHIP_ID(bp) == CHIP_ID_5708_A0))
Michael Chanb6016b72005-05-26 13:03:09 -07005388 net_stats->tx_carrier_errors = 0;
5389 else {
5390 net_stats->tx_carrier_errors =
5391 (unsigned long)
5392 stats_blk->stat_Dot3StatsCarrierSenseErrors;
5393 }
5394
5395 net_stats->tx_errors =
Jeff Garzik6aa20a22006-09-13 13:24:59 -04005396 (unsigned long)
Michael Chanb6016b72005-05-26 13:03:09 -07005397 stats_blk->stat_emac_tx_stat_dot3statsinternalmactransmiterrors
5398 +
5399 net_stats->tx_aborted_errors +
5400 net_stats->tx_carrier_errors;
5401
Michael Chancea94db2006-06-12 22:16:13 -07005402 net_stats->rx_missed_errors =
5403 (unsigned long) (stats_blk->stat_IfInMBUFDiscards +
5404 stats_blk->stat_FwRxDrop);
5405
Michael Chanb6016b72005-05-26 13:03:09 -07005406 return net_stats;
5407}
5408
5409/* All ethtool functions called with rtnl_lock */
5410
5411static int
5412bnx2_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
5413{
Michael Chan972ec0d2006-01-23 16:12:43 -08005414 struct bnx2 *bp = netdev_priv(dev);
Michael Chan7b6b8342007-07-07 22:50:15 -07005415 int support_serdes = 0, support_copper = 0;
Michael Chanb6016b72005-05-26 13:03:09 -07005416
5417 cmd->supported = SUPPORTED_Autoneg;
Michael Chan7b6b8342007-07-07 22:50:15 -07005418 if (bp->phy_flags & REMOTE_PHY_CAP_FLAG) {
5419 support_serdes = 1;
5420 support_copper = 1;
5421 } else if (bp->phy_port == PORT_FIBRE)
5422 support_serdes = 1;
5423 else
5424 support_copper = 1;
5425
5426 if (support_serdes) {
Michael Chanb6016b72005-05-26 13:03:09 -07005427 cmd->supported |= SUPPORTED_1000baseT_Full |
5428 SUPPORTED_FIBRE;
Michael Chan605a9e22007-05-03 13:23:13 -07005429 if (bp->phy_flags & PHY_2_5G_CAPABLE_FLAG)
5430 cmd->supported |= SUPPORTED_2500baseX_Full;
Michael Chanb6016b72005-05-26 13:03:09 -07005431
Michael Chanb6016b72005-05-26 13:03:09 -07005432 }
Michael Chan7b6b8342007-07-07 22:50:15 -07005433 if (support_copper) {
Michael Chanb6016b72005-05-26 13:03:09 -07005434 cmd->supported |= SUPPORTED_10baseT_Half |
5435 SUPPORTED_10baseT_Full |
5436 SUPPORTED_100baseT_Half |
5437 SUPPORTED_100baseT_Full |
5438 SUPPORTED_1000baseT_Full |
5439 SUPPORTED_TP;
5440
Michael Chanb6016b72005-05-26 13:03:09 -07005441 }
5442
Michael Chan7b6b8342007-07-07 22:50:15 -07005443 spin_lock_bh(&bp->phy_lock);
5444 cmd->port = bp->phy_port;
Michael Chanb6016b72005-05-26 13:03:09 -07005445 cmd->advertising = bp->advertising;
5446
5447 if (bp->autoneg & AUTONEG_SPEED) {
5448 cmd->autoneg = AUTONEG_ENABLE;
5449 }
5450 else {
5451 cmd->autoneg = AUTONEG_DISABLE;
5452 }
5453
5454 if (netif_carrier_ok(dev)) {
5455 cmd->speed = bp->line_speed;
5456 cmd->duplex = bp->duplex;
5457 }
5458 else {
5459 cmd->speed = -1;
5460 cmd->duplex = -1;
5461 }
Michael Chan7b6b8342007-07-07 22:50:15 -07005462 spin_unlock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07005463
5464 cmd->transceiver = XCVR_INTERNAL;
5465 cmd->phy_address = bp->phy_addr;
5466
5467 return 0;
5468}
Jeff Garzik6aa20a22006-09-13 13:24:59 -04005469
Michael Chanb6016b72005-05-26 13:03:09 -07005470static int
5471bnx2_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
5472{
Michael Chan972ec0d2006-01-23 16:12:43 -08005473 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005474 u8 autoneg = bp->autoneg;
5475 u8 req_duplex = bp->req_duplex;
5476 u16 req_line_speed = bp->req_line_speed;
5477 u32 advertising = bp->advertising;
Michael Chan7b6b8342007-07-07 22:50:15 -07005478 int err = -EINVAL;
5479
5480 spin_lock_bh(&bp->phy_lock);
5481
5482 if (cmd->port != PORT_TP && cmd->port != PORT_FIBRE)
5483 goto err_out_unlock;
5484
5485 if (cmd->port != bp->phy_port && !(bp->phy_flags & REMOTE_PHY_CAP_FLAG))
5486 goto err_out_unlock;
Michael Chanb6016b72005-05-26 13:03:09 -07005487
5488 if (cmd->autoneg == AUTONEG_ENABLE) {
5489 autoneg |= AUTONEG_SPEED;
5490
Jeff Garzik6aa20a22006-09-13 13:24:59 -04005491 cmd->advertising &= ETHTOOL_ALL_COPPER_SPEED;
Michael Chanb6016b72005-05-26 13:03:09 -07005492
5493 /* allow advertising 1 speed */
5494 if ((cmd->advertising == ADVERTISED_10baseT_Half) ||
5495 (cmd->advertising == ADVERTISED_10baseT_Full) ||
5496 (cmd->advertising == ADVERTISED_100baseT_Half) ||
5497 (cmd->advertising == ADVERTISED_100baseT_Full)) {
5498
Michael Chan7b6b8342007-07-07 22:50:15 -07005499 if (cmd->port == PORT_FIBRE)
5500 goto err_out_unlock;
Michael Chanb6016b72005-05-26 13:03:09 -07005501
5502 advertising = cmd->advertising;
5503
Michael Chan27a005b2007-05-03 13:23:41 -07005504 } else if (cmd->advertising == ADVERTISED_2500baseX_Full) {
Michael Chan7b6b8342007-07-07 22:50:15 -07005505 if (!(bp->phy_flags & PHY_2_5G_CAPABLE_FLAG) ||
5506 (cmd->port == PORT_TP))
5507 goto err_out_unlock;
5508 } else if (cmd->advertising == ADVERTISED_1000baseT_Full)
Michael Chanb6016b72005-05-26 13:03:09 -07005509 advertising = cmd->advertising;
Michael Chan7b6b8342007-07-07 22:50:15 -07005510 else if (cmd->advertising == ADVERTISED_1000baseT_Half)
5511 goto err_out_unlock;
Michael Chanb6016b72005-05-26 13:03:09 -07005512 else {
Michael Chan7b6b8342007-07-07 22:50:15 -07005513 if (cmd->port == PORT_FIBRE)
Michael Chanb6016b72005-05-26 13:03:09 -07005514 advertising = ETHTOOL_ALL_FIBRE_SPEED;
Michael Chan7b6b8342007-07-07 22:50:15 -07005515 else
Michael Chanb6016b72005-05-26 13:03:09 -07005516 advertising = ETHTOOL_ALL_COPPER_SPEED;
Michael Chanb6016b72005-05-26 13:03:09 -07005517 }
5518 advertising |= ADVERTISED_Autoneg;
5519 }
5520 else {
Michael Chan7b6b8342007-07-07 22:50:15 -07005521 if (cmd->port == PORT_FIBRE) {
Michael Chan80be4432006-11-19 14:07:28 -08005522 if ((cmd->speed != SPEED_1000 &&
5523 cmd->speed != SPEED_2500) ||
5524 (cmd->duplex != DUPLEX_FULL))
Michael Chan7b6b8342007-07-07 22:50:15 -07005525 goto err_out_unlock;
Michael Chan80be4432006-11-19 14:07:28 -08005526
5527 if (cmd->speed == SPEED_2500 &&
5528 !(bp->phy_flags & PHY_2_5G_CAPABLE_FLAG))
Michael Chan7b6b8342007-07-07 22:50:15 -07005529 goto err_out_unlock;
Michael Chanb6016b72005-05-26 13:03:09 -07005530 }
Michael Chan7b6b8342007-07-07 22:50:15 -07005531 else if (cmd->speed == SPEED_1000 || cmd->speed == SPEED_2500)
5532 goto err_out_unlock;
5533
Michael Chanb6016b72005-05-26 13:03:09 -07005534 autoneg &= ~AUTONEG_SPEED;
5535 req_line_speed = cmd->speed;
5536 req_duplex = cmd->duplex;
5537 advertising = 0;
5538 }
5539
5540 bp->autoneg = autoneg;
5541 bp->advertising = advertising;
5542 bp->req_line_speed = req_line_speed;
5543 bp->req_duplex = req_duplex;
5544
Michael Chan7b6b8342007-07-07 22:50:15 -07005545 err = bnx2_setup_phy(bp, cmd->port);
Michael Chanb6016b72005-05-26 13:03:09 -07005546
Michael Chan7b6b8342007-07-07 22:50:15 -07005547err_out_unlock:
Michael Chanc770a652005-08-25 15:38:39 -07005548 spin_unlock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07005549
Michael Chan7b6b8342007-07-07 22:50:15 -07005550 return err;
Michael Chanb6016b72005-05-26 13:03:09 -07005551}
5552
5553static void
5554bnx2_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
5555{
Michael Chan972ec0d2006-01-23 16:12:43 -08005556 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005557
5558 strcpy(info->driver, DRV_MODULE_NAME);
5559 strcpy(info->version, DRV_MODULE_VERSION);
5560 strcpy(info->bus_info, pci_name(bp->pdev));
Michael Chan58fc2ea2007-07-07 22:52:02 -07005561 strcpy(info->fw_version, bp->fw_version);
Michael Chanb6016b72005-05-26 13:03:09 -07005562}
5563
Michael Chan244ac4f2006-03-20 17:48:46 -08005564#define BNX2_REGDUMP_LEN (32 * 1024)
5565
5566static int
5567bnx2_get_regs_len(struct net_device *dev)
5568{
5569 return BNX2_REGDUMP_LEN;
5570}
5571
5572static void
5573bnx2_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
5574{
5575 u32 *p = _p, i, offset;
5576 u8 *orig_p = _p;
5577 struct bnx2 *bp = netdev_priv(dev);
5578 u32 reg_boundaries[] = { 0x0000, 0x0098, 0x0400, 0x045c,
5579 0x0800, 0x0880, 0x0c00, 0x0c10,
5580 0x0c30, 0x0d08, 0x1000, 0x101c,
5581 0x1040, 0x1048, 0x1080, 0x10a4,
5582 0x1400, 0x1490, 0x1498, 0x14f0,
5583 0x1500, 0x155c, 0x1580, 0x15dc,
5584 0x1600, 0x1658, 0x1680, 0x16d8,
5585 0x1800, 0x1820, 0x1840, 0x1854,
5586 0x1880, 0x1894, 0x1900, 0x1984,
5587 0x1c00, 0x1c0c, 0x1c40, 0x1c54,
5588 0x1c80, 0x1c94, 0x1d00, 0x1d84,
5589 0x2000, 0x2030, 0x23c0, 0x2400,
5590 0x2800, 0x2820, 0x2830, 0x2850,
5591 0x2b40, 0x2c10, 0x2fc0, 0x3058,
5592 0x3c00, 0x3c94, 0x4000, 0x4010,
5593 0x4080, 0x4090, 0x43c0, 0x4458,
5594 0x4c00, 0x4c18, 0x4c40, 0x4c54,
5595 0x4fc0, 0x5010, 0x53c0, 0x5444,
5596 0x5c00, 0x5c18, 0x5c80, 0x5c90,
5597 0x5fc0, 0x6000, 0x6400, 0x6428,
5598 0x6800, 0x6848, 0x684c, 0x6860,
5599 0x6888, 0x6910, 0x8000 };
5600
5601 regs->version = 0;
5602
5603 memset(p, 0, BNX2_REGDUMP_LEN);
5604
5605 if (!netif_running(bp->dev))
5606 return;
5607
5608 i = 0;
5609 offset = reg_boundaries[0];
5610 p += offset;
5611 while (offset < BNX2_REGDUMP_LEN) {
5612 *p++ = REG_RD(bp, offset);
5613 offset += 4;
5614 if (offset == reg_boundaries[i + 1]) {
5615 offset = reg_boundaries[i + 2];
5616 p = (u32 *) (orig_p + offset);
5617 i += 2;
5618 }
5619 }
5620}
5621
Michael Chanb6016b72005-05-26 13:03:09 -07005622static void
5623bnx2_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
5624{
Michael Chan972ec0d2006-01-23 16:12:43 -08005625 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005626
5627 if (bp->flags & NO_WOL_FLAG) {
5628 wol->supported = 0;
5629 wol->wolopts = 0;
5630 }
5631 else {
5632 wol->supported = WAKE_MAGIC;
5633 if (bp->wol)
5634 wol->wolopts = WAKE_MAGIC;
5635 else
5636 wol->wolopts = 0;
5637 }
5638 memset(&wol->sopass, 0, sizeof(wol->sopass));
5639}
5640
5641static int
5642bnx2_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
5643{
Michael Chan972ec0d2006-01-23 16:12:43 -08005644 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005645
5646 if (wol->wolopts & ~WAKE_MAGIC)
5647 return -EINVAL;
5648
5649 if (wol->wolopts & WAKE_MAGIC) {
5650 if (bp->flags & NO_WOL_FLAG)
5651 return -EINVAL;
5652
5653 bp->wol = 1;
5654 }
5655 else {
5656 bp->wol = 0;
5657 }
5658 return 0;
5659}
5660
5661static int
5662bnx2_nway_reset(struct net_device *dev)
5663{
Michael Chan972ec0d2006-01-23 16:12:43 -08005664 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005665 u32 bmcr;
5666
5667 if (!(bp->autoneg & AUTONEG_SPEED)) {
5668 return -EINVAL;
5669 }
5670
Michael Chanc770a652005-08-25 15:38:39 -07005671 spin_lock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07005672
Michael Chan7b6b8342007-07-07 22:50:15 -07005673 if (bp->phy_flags & REMOTE_PHY_CAP_FLAG) {
5674 int rc;
5675
5676 rc = bnx2_setup_remote_phy(bp, bp->phy_port);
5677 spin_unlock_bh(&bp->phy_lock);
5678 return rc;
5679 }
5680
Michael Chanb6016b72005-05-26 13:03:09 -07005681 /* Force a link down visible on the other side */
5682 if (bp->phy_flags & PHY_SERDES_FLAG) {
Michael Chanca58c3a2007-05-03 13:22:52 -07005683 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK);
Michael Chanc770a652005-08-25 15:38:39 -07005684 spin_unlock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07005685
5686 msleep(20);
5687
Michael Chanc770a652005-08-25 15:38:39 -07005688 spin_lock_bh(&bp->phy_lock);
Michael Chanf8dd0642006-11-19 14:08:29 -08005689
5690 bp->current_interval = SERDES_AN_TIMEOUT;
5691 bp->serdes_an_pending = 1;
5692 mod_timer(&bp->timer, jiffies + bp->current_interval);
Michael Chanb6016b72005-05-26 13:03:09 -07005693 }
5694
Michael Chanca58c3a2007-05-03 13:22:52 -07005695 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
Michael Chanb6016b72005-05-26 13:03:09 -07005696 bmcr &= ~BMCR_LOOPBACK;
Michael Chanca58c3a2007-05-03 13:22:52 -07005697 bnx2_write_phy(bp, bp->mii_bmcr, bmcr | BMCR_ANRESTART | BMCR_ANENABLE);
Michael Chanb6016b72005-05-26 13:03:09 -07005698
Michael Chanc770a652005-08-25 15:38:39 -07005699 spin_unlock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07005700
5701 return 0;
5702}
5703
5704static int
5705bnx2_get_eeprom_len(struct net_device *dev)
5706{
Michael Chan972ec0d2006-01-23 16:12:43 -08005707 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005708
Michael Chan1122db72006-01-23 16:11:42 -08005709 if (bp->flash_info == NULL)
Michael Chanb6016b72005-05-26 13:03:09 -07005710 return 0;
5711
Michael Chan1122db72006-01-23 16:11:42 -08005712 return (int) bp->flash_size;
Michael Chanb6016b72005-05-26 13:03:09 -07005713}
5714
5715static int
5716bnx2_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
5717 u8 *eebuf)
5718{
Michael Chan972ec0d2006-01-23 16:12:43 -08005719 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005720 int rc;
5721
John W. Linville1064e942005-11-10 12:58:24 -08005722 /* parameters already validated in ethtool_get_eeprom */
Michael Chanb6016b72005-05-26 13:03:09 -07005723
5724 rc = bnx2_nvram_read(bp, eeprom->offset, eebuf, eeprom->len);
5725
5726 return rc;
5727}
5728
5729static int
5730bnx2_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
5731 u8 *eebuf)
5732{
Michael Chan972ec0d2006-01-23 16:12:43 -08005733 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005734 int rc;
5735
John W. Linville1064e942005-11-10 12:58:24 -08005736 /* parameters already validated in ethtool_set_eeprom */
Michael Chanb6016b72005-05-26 13:03:09 -07005737
5738 rc = bnx2_nvram_write(bp, eeprom->offset, eebuf, eeprom->len);
5739
5740 return rc;
5741}
5742
5743static int
5744bnx2_get_coalesce(struct net_device *dev, struct ethtool_coalesce *coal)
5745{
Michael Chan972ec0d2006-01-23 16:12:43 -08005746 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005747
5748 memset(coal, 0, sizeof(struct ethtool_coalesce));
5749
5750 coal->rx_coalesce_usecs = bp->rx_ticks;
5751 coal->rx_max_coalesced_frames = bp->rx_quick_cons_trip;
5752 coal->rx_coalesce_usecs_irq = bp->rx_ticks_int;
5753 coal->rx_max_coalesced_frames_irq = bp->rx_quick_cons_trip_int;
5754
5755 coal->tx_coalesce_usecs = bp->tx_ticks;
5756 coal->tx_max_coalesced_frames = bp->tx_quick_cons_trip;
5757 coal->tx_coalesce_usecs_irq = bp->tx_ticks_int;
5758 coal->tx_max_coalesced_frames_irq = bp->tx_quick_cons_trip_int;
5759
5760 coal->stats_block_coalesce_usecs = bp->stats_ticks;
5761
5762 return 0;
5763}
5764
5765static int
5766bnx2_set_coalesce(struct net_device *dev, struct ethtool_coalesce *coal)
5767{
Michael Chan972ec0d2006-01-23 16:12:43 -08005768 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005769
5770 bp->rx_ticks = (u16) coal->rx_coalesce_usecs;
5771 if (bp->rx_ticks > 0x3ff) bp->rx_ticks = 0x3ff;
5772
Jeff Garzik6aa20a22006-09-13 13:24:59 -04005773 bp->rx_quick_cons_trip = (u16) coal->rx_max_coalesced_frames;
Michael Chanb6016b72005-05-26 13:03:09 -07005774 if (bp->rx_quick_cons_trip > 0xff) bp->rx_quick_cons_trip = 0xff;
5775
5776 bp->rx_ticks_int = (u16) coal->rx_coalesce_usecs_irq;
5777 if (bp->rx_ticks_int > 0x3ff) bp->rx_ticks_int = 0x3ff;
5778
5779 bp->rx_quick_cons_trip_int = (u16) coal->rx_max_coalesced_frames_irq;
5780 if (bp->rx_quick_cons_trip_int > 0xff)
5781 bp->rx_quick_cons_trip_int = 0xff;
5782
5783 bp->tx_ticks = (u16) coal->tx_coalesce_usecs;
5784 if (bp->tx_ticks > 0x3ff) bp->tx_ticks = 0x3ff;
5785
5786 bp->tx_quick_cons_trip = (u16) coal->tx_max_coalesced_frames;
5787 if (bp->tx_quick_cons_trip > 0xff) bp->tx_quick_cons_trip = 0xff;
5788
5789 bp->tx_ticks_int = (u16) coal->tx_coalesce_usecs_irq;
5790 if (bp->tx_ticks_int > 0x3ff) bp->tx_ticks_int = 0x3ff;
5791
5792 bp->tx_quick_cons_trip_int = (u16) coal->tx_max_coalesced_frames_irq;
5793 if (bp->tx_quick_cons_trip_int > 0xff) bp->tx_quick_cons_trip_int =
5794 0xff;
5795
5796 bp->stats_ticks = coal->stats_block_coalesce_usecs;
Michael Chan02537b062007-06-04 21:24:07 -07005797 if (CHIP_NUM(bp) == CHIP_NUM_5708) {
5798 if (bp->stats_ticks != 0 && bp->stats_ticks != USEC_PER_SEC)
5799 bp->stats_ticks = USEC_PER_SEC;
5800 }
Michael Chan7ea69202007-07-16 18:27:10 -07005801 if (bp->stats_ticks > BNX2_HC_STATS_TICKS_HC_STAT_TICKS)
5802 bp->stats_ticks = BNX2_HC_STATS_TICKS_HC_STAT_TICKS;
5803 bp->stats_ticks &= BNX2_HC_STATS_TICKS_HC_STAT_TICKS;
Michael Chanb6016b72005-05-26 13:03:09 -07005804
5805 if (netif_running(bp->dev)) {
5806 bnx2_netif_stop(bp);
5807 bnx2_init_nic(bp);
5808 bnx2_netif_start(bp);
5809 }
5810
5811 return 0;
5812}
5813
5814static void
5815bnx2_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
5816{
Michael Chan972ec0d2006-01-23 16:12:43 -08005817 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005818
Michael Chan13daffa2006-03-20 17:49:20 -08005819 ering->rx_max_pending = MAX_TOTAL_RX_DESC_CNT;
Michael Chanb6016b72005-05-26 13:03:09 -07005820 ering->rx_mini_max_pending = 0;
5821 ering->rx_jumbo_max_pending = 0;
5822
5823 ering->rx_pending = bp->rx_ring_size;
5824 ering->rx_mini_pending = 0;
5825 ering->rx_jumbo_pending = 0;
5826
5827 ering->tx_max_pending = MAX_TX_DESC_CNT;
5828 ering->tx_pending = bp->tx_ring_size;
5829}
5830
5831static int
5832bnx2_set_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
5833{
Michael Chan972ec0d2006-01-23 16:12:43 -08005834 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005835
Michael Chan13daffa2006-03-20 17:49:20 -08005836 if ((ering->rx_pending > MAX_TOTAL_RX_DESC_CNT) ||
Michael Chanb6016b72005-05-26 13:03:09 -07005837 (ering->tx_pending > MAX_TX_DESC_CNT) ||
5838 (ering->tx_pending <= MAX_SKB_FRAGS)) {
5839
5840 return -EINVAL;
5841 }
Michael Chan13daffa2006-03-20 17:49:20 -08005842 if (netif_running(bp->dev)) {
5843 bnx2_netif_stop(bp);
5844 bnx2_reset_chip(bp, BNX2_DRV_MSG_CODE_RESET);
5845 bnx2_free_skbs(bp);
5846 bnx2_free_mem(bp);
5847 }
5848
5849 bnx2_set_rx_ring_size(bp, ering->rx_pending);
Michael Chanb6016b72005-05-26 13:03:09 -07005850 bp->tx_ring_size = ering->tx_pending;
5851
5852 if (netif_running(bp->dev)) {
Michael Chan13daffa2006-03-20 17:49:20 -08005853 int rc;
5854
5855 rc = bnx2_alloc_mem(bp);
5856 if (rc)
5857 return rc;
Michael Chanb6016b72005-05-26 13:03:09 -07005858 bnx2_init_nic(bp);
5859 bnx2_netif_start(bp);
5860 }
5861
5862 return 0;
5863}
5864
5865static void
5866bnx2_get_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
5867{
Michael Chan972ec0d2006-01-23 16:12:43 -08005868 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005869
5870 epause->autoneg = ((bp->autoneg & AUTONEG_FLOW_CTRL) != 0);
5871 epause->rx_pause = ((bp->flow_ctrl & FLOW_CTRL_RX) != 0);
5872 epause->tx_pause = ((bp->flow_ctrl & FLOW_CTRL_TX) != 0);
5873}
5874
5875static int
5876bnx2_set_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
5877{
Michael Chan972ec0d2006-01-23 16:12:43 -08005878 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005879
5880 bp->req_flow_ctrl = 0;
5881 if (epause->rx_pause)
5882 bp->req_flow_ctrl |= FLOW_CTRL_RX;
5883 if (epause->tx_pause)
5884 bp->req_flow_ctrl |= FLOW_CTRL_TX;
5885
5886 if (epause->autoneg) {
5887 bp->autoneg |= AUTONEG_FLOW_CTRL;
5888 }
5889 else {
5890 bp->autoneg &= ~AUTONEG_FLOW_CTRL;
5891 }
5892
Michael Chanc770a652005-08-25 15:38:39 -07005893 spin_lock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07005894
Michael Chan0d8a6572007-07-07 22:49:43 -07005895 bnx2_setup_phy(bp, bp->phy_port);
Michael Chanb6016b72005-05-26 13:03:09 -07005896
Michael Chanc770a652005-08-25 15:38:39 -07005897 spin_unlock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07005898
5899 return 0;
5900}
5901
5902static u32
5903bnx2_get_rx_csum(struct net_device *dev)
5904{
Michael Chan972ec0d2006-01-23 16:12:43 -08005905 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005906
5907 return bp->rx_csum;
5908}
5909
5910static int
5911bnx2_set_rx_csum(struct net_device *dev, u32 data)
5912{
Michael Chan972ec0d2006-01-23 16:12:43 -08005913 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07005914
5915 bp->rx_csum = data;
5916 return 0;
5917}
5918
Michael Chanb11d6212006-06-29 12:31:21 -07005919static int
5920bnx2_set_tso(struct net_device *dev, u32 data)
5921{
Michael Chan4666f872007-05-03 13:22:28 -07005922 struct bnx2 *bp = netdev_priv(dev);
5923
5924 if (data) {
Michael Chanb11d6212006-06-29 12:31:21 -07005925 dev->features |= NETIF_F_TSO | NETIF_F_TSO_ECN;
Michael Chan4666f872007-05-03 13:22:28 -07005926 if (CHIP_NUM(bp) == CHIP_NUM_5709)
5927 dev->features |= NETIF_F_TSO6;
5928 } else
5929 dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6 |
5930 NETIF_F_TSO_ECN);
Michael Chanb11d6212006-06-29 12:31:21 -07005931 return 0;
5932}
5933
Michael Chancea94db2006-06-12 22:16:13 -07005934#define BNX2_NUM_STATS 46
Michael Chanb6016b72005-05-26 13:03:09 -07005935
Peter Hagervall14ab9b82005-08-10 14:18:16 -07005936static struct {
Michael Chanb6016b72005-05-26 13:03:09 -07005937 char string[ETH_GSTRING_LEN];
5938} bnx2_stats_str_arr[BNX2_NUM_STATS] = {
5939 { "rx_bytes" },
5940 { "rx_error_bytes" },
5941 { "tx_bytes" },
5942 { "tx_error_bytes" },
5943 { "rx_ucast_packets" },
5944 { "rx_mcast_packets" },
5945 { "rx_bcast_packets" },
5946 { "tx_ucast_packets" },
5947 { "tx_mcast_packets" },
5948 { "tx_bcast_packets" },
5949 { "tx_mac_errors" },
5950 { "tx_carrier_errors" },
5951 { "rx_crc_errors" },
5952 { "rx_align_errors" },
5953 { "tx_single_collisions" },
5954 { "tx_multi_collisions" },
5955 { "tx_deferred" },
5956 { "tx_excess_collisions" },
5957 { "tx_late_collisions" },
5958 { "tx_total_collisions" },
5959 { "rx_fragments" },
5960 { "rx_jabbers" },
5961 { "rx_undersize_packets" },
5962 { "rx_oversize_packets" },
5963 { "rx_64_byte_packets" },
5964 { "rx_65_to_127_byte_packets" },
5965 { "rx_128_to_255_byte_packets" },
5966 { "rx_256_to_511_byte_packets" },
5967 { "rx_512_to_1023_byte_packets" },
5968 { "rx_1024_to_1522_byte_packets" },
5969 { "rx_1523_to_9022_byte_packets" },
5970 { "tx_64_byte_packets" },
5971 { "tx_65_to_127_byte_packets" },
5972 { "tx_128_to_255_byte_packets" },
5973 { "tx_256_to_511_byte_packets" },
5974 { "tx_512_to_1023_byte_packets" },
5975 { "tx_1024_to_1522_byte_packets" },
5976 { "tx_1523_to_9022_byte_packets" },
5977 { "rx_xon_frames" },
5978 { "rx_xoff_frames" },
5979 { "tx_xon_frames" },
5980 { "tx_xoff_frames" },
5981 { "rx_mac_ctrl_frames" },
5982 { "rx_filtered_packets" },
5983 { "rx_discards" },
Michael Chancea94db2006-06-12 22:16:13 -07005984 { "rx_fw_discards" },
Michael Chanb6016b72005-05-26 13:03:09 -07005985};
5986
5987#define STATS_OFFSET32(offset_name) (offsetof(struct statistics_block, offset_name) / 4)
5988
Arjan van de Venf71e1302006-03-03 21:33:57 -05005989static const unsigned long bnx2_stats_offset_arr[BNX2_NUM_STATS] = {
Michael Chanb6016b72005-05-26 13:03:09 -07005990 STATS_OFFSET32(stat_IfHCInOctets_hi),
5991 STATS_OFFSET32(stat_IfHCInBadOctets_hi),
5992 STATS_OFFSET32(stat_IfHCOutOctets_hi),
5993 STATS_OFFSET32(stat_IfHCOutBadOctets_hi),
5994 STATS_OFFSET32(stat_IfHCInUcastPkts_hi),
5995 STATS_OFFSET32(stat_IfHCInMulticastPkts_hi),
5996 STATS_OFFSET32(stat_IfHCInBroadcastPkts_hi),
5997 STATS_OFFSET32(stat_IfHCOutUcastPkts_hi),
5998 STATS_OFFSET32(stat_IfHCOutMulticastPkts_hi),
5999 STATS_OFFSET32(stat_IfHCOutBroadcastPkts_hi),
6000 STATS_OFFSET32(stat_emac_tx_stat_dot3statsinternalmactransmiterrors),
Jeff Garzik6aa20a22006-09-13 13:24:59 -04006001 STATS_OFFSET32(stat_Dot3StatsCarrierSenseErrors),
6002 STATS_OFFSET32(stat_Dot3StatsFCSErrors),
6003 STATS_OFFSET32(stat_Dot3StatsAlignmentErrors),
6004 STATS_OFFSET32(stat_Dot3StatsSingleCollisionFrames),
6005 STATS_OFFSET32(stat_Dot3StatsMultipleCollisionFrames),
6006 STATS_OFFSET32(stat_Dot3StatsDeferredTransmissions),
6007 STATS_OFFSET32(stat_Dot3StatsExcessiveCollisions),
6008 STATS_OFFSET32(stat_Dot3StatsLateCollisions),
6009 STATS_OFFSET32(stat_EtherStatsCollisions),
6010 STATS_OFFSET32(stat_EtherStatsFragments),
6011 STATS_OFFSET32(stat_EtherStatsJabbers),
6012 STATS_OFFSET32(stat_EtherStatsUndersizePkts),
6013 STATS_OFFSET32(stat_EtherStatsOverrsizePkts),
6014 STATS_OFFSET32(stat_EtherStatsPktsRx64Octets),
6015 STATS_OFFSET32(stat_EtherStatsPktsRx65Octetsto127Octets),
6016 STATS_OFFSET32(stat_EtherStatsPktsRx128Octetsto255Octets),
6017 STATS_OFFSET32(stat_EtherStatsPktsRx256Octetsto511Octets),
6018 STATS_OFFSET32(stat_EtherStatsPktsRx512Octetsto1023Octets),
6019 STATS_OFFSET32(stat_EtherStatsPktsRx1024Octetsto1522Octets),
6020 STATS_OFFSET32(stat_EtherStatsPktsRx1523Octetsto9022Octets),
6021 STATS_OFFSET32(stat_EtherStatsPktsTx64Octets),
6022 STATS_OFFSET32(stat_EtherStatsPktsTx65Octetsto127Octets),
6023 STATS_OFFSET32(stat_EtherStatsPktsTx128Octetsto255Octets),
6024 STATS_OFFSET32(stat_EtherStatsPktsTx256Octetsto511Octets),
6025 STATS_OFFSET32(stat_EtherStatsPktsTx512Octetsto1023Octets),
6026 STATS_OFFSET32(stat_EtherStatsPktsTx1024Octetsto1522Octets),
6027 STATS_OFFSET32(stat_EtherStatsPktsTx1523Octetsto9022Octets),
6028 STATS_OFFSET32(stat_XonPauseFramesReceived),
6029 STATS_OFFSET32(stat_XoffPauseFramesReceived),
6030 STATS_OFFSET32(stat_OutXonSent),
6031 STATS_OFFSET32(stat_OutXoffSent),
6032 STATS_OFFSET32(stat_MacControlFramesReceived),
6033 STATS_OFFSET32(stat_IfInFramesL2FilterDiscards),
6034 STATS_OFFSET32(stat_IfInMBUFDiscards),
Michael Chancea94db2006-06-12 22:16:13 -07006035 STATS_OFFSET32(stat_FwRxDrop),
Michael Chanb6016b72005-05-26 13:03:09 -07006036};
6037
6038/* stat_IfHCInBadOctets and stat_Dot3StatsCarrierSenseErrors are
6039 * skipped because of errata.
Jeff Garzik6aa20a22006-09-13 13:24:59 -04006040 */
Peter Hagervall14ab9b82005-08-10 14:18:16 -07006041static u8 bnx2_5706_stats_len_arr[BNX2_NUM_STATS] = {
Michael Chanb6016b72005-05-26 13:03:09 -07006042 8,0,8,8,8,8,8,8,8,8,
6043 4,0,4,4,4,4,4,4,4,4,
6044 4,4,4,4,4,4,4,4,4,4,
6045 4,4,4,4,4,4,4,4,4,4,
Michael Chancea94db2006-06-12 22:16:13 -07006046 4,4,4,4,4,4,
Michael Chanb6016b72005-05-26 13:03:09 -07006047};
6048
Michael Chan5b0c76a2005-11-04 08:45:49 -08006049static u8 bnx2_5708_stats_len_arr[BNX2_NUM_STATS] = {
6050 8,0,8,8,8,8,8,8,8,8,
6051 4,4,4,4,4,4,4,4,4,4,
6052 4,4,4,4,4,4,4,4,4,4,
6053 4,4,4,4,4,4,4,4,4,4,
Michael Chancea94db2006-06-12 22:16:13 -07006054 4,4,4,4,4,4,
Michael Chan5b0c76a2005-11-04 08:45:49 -08006055};
6056
Michael Chanb6016b72005-05-26 13:03:09 -07006057#define BNX2_NUM_TESTS 6
6058
Peter Hagervall14ab9b82005-08-10 14:18:16 -07006059static struct {
Michael Chanb6016b72005-05-26 13:03:09 -07006060 char string[ETH_GSTRING_LEN];
6061} bnx2_tests_str_arr[BNX2_NUM_TESTS] = {
6062 { "register_test (offline)" },
6063 { "memory_test (offline)" },
6064 { "loopback_test (offline)" },
6065 { "nvram_test (online)" },
6066 { "interrupt_test (online)" },
6067 { "link_test (online)" },
6068};
6069
6070static int
6071bnx2_self_test_count(struct net_device *dev)
6072{
6073 return BNX2_NUM_TESTS;
6074}
6075
6076static void
6077bnx2_self_test(struct net_device *dev, struct ethtool_test *etest, u64 *buf)
6078{
Michael Chan972ec0d2006-01-23 16:12:43 -08006079 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07006080
6081 memset(buf, 0, sizeof(u64) * BNX2_NUM_TESTS);
6082 if (etest->flags & ETH_TEST_FL_OFFLINE) {
Michael Chan80be4432006-11-19 14:07:28 -08006083 int i;
6084
Michael Chanb6016b72005-05-26 13:03:09 -07006085 bnx2_netif_stop(bp);
6086 bnx2_reset_chip(bp, BNX2_DRV_MSG_CODE_DIAG);
6087 bnx2_free_skbs(bp);
6088
6089 if (bnx2_test_registers(bp) != 0) {
6090 buf[0] = 1;
6091 etest->flags |= ETH_TEST_FL_FAILED;
6092 }
6093 if (bnx2_test_memory(bp) != 0) {
6094 buf[1] = 1;
6095 etest->flags |= ETH_TEST_FL_FAILED;
6096 }
Michael Chanbc5a0692006-01-23 16:13:22 -08006097 if ((buf[2] = bnx2_test_loopback(bp)) != 0)
Michael Chanb6016b72005-05-26 13:03:09 -07006098 etest->flags |= ETH_TEST_FL_FAILED;
Michael Chanb6016b72005-05-26 13:03:09 -07006099
6100 if (!netif_running(bp->dev)) {
6101 bnx2_reset_chip(bp, BNX2_DRV_MSG_CODE_RESET);
6102 }
6103 else {
6104 bnx2_init_nic(bp);
6105 bnx2_netif_start(bp);
6106 }
6107
6108 /* wait for link up */
Michael Chan80be4432006-11-19 14:07:28 -08006109 for (i = 0; i < 7; i++) {
6110 if (bp->link_up)
6111 break;
6112 msleep_interruptible(1000);
6113 }
Michael Chanb6016b72005-05-26 13:03:09 -07006114 }
6115
6116 if (bnx2_test_nvram(bp) != 0) {
6117 buf[3] = 1;
6118 etest->flags |= ETH_TEST_FL_FAILED;
6119 }
6120 if (bnx2_test_intr(bp) != 0) {
6121 buf[4] = 1;
6122 etest->flags |= ETH_TEST_FL_FAILED;
6123 }
6124
6125 if (bnx2_test_link(bp) != 0) {
6126 buf[5] = 1;
6127 etest->flags |= ETH_TEST_FL_FAILED;
6128
6129 }
6130}
6131
6132static void
6133bnx2_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
6134{
6135 switch (stringset) {
6136 case ETH_SS_STATS:
6137 memcpy(buf, bnx2_stats_str_arr,
6138 sizeof(bnx2_stats_str_arr));
6139 break;
6140 case ETH_SS_TEST:
6141 memcpy(buf, bnx2_tests_str_arr,
6142 sizeof(bnx2_tests_str_arr));
6143 break;
6144 }
6145}
6146
6147static int
6148bnx2_get_stats_count(struct net_device *dev)
6149{
6150 return BNX2_NUM_STATS;
6151}
6152
6153static void
6154bnx2_get_ethtool_stats(struct net_device *dev,
6155 struct ethtool_stats *stats, u64 *buf)
6156{
Michael Chan972ec0d2006-01-23 16:12:43 -08006157 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07006158 int i;
6159 u32 *hw_stats = (u32 *) bp->stats_blk;
Peter Hagervall14ab9b82005-08-10 14:18:16 -07006160 u8 *stats_len_arr = NULL;
Michael Chanb6016b72005-05-26 13:03:09 -07006161
6162 if (hw_stats == NULL) {
6163 memset(buf, 0, sizeof(u64) * BNX2_NUM_STATS);
6164 return;
6165 }
6166
Michael Chan5b0c76a2005-11-04 08:45:49 -08006167 if ((CHIP_ID(bp) == CHIP_ID_5706_A0) ||
6168 (CHIP_ID(bp) == CHIP_ID_5706_A1) ||
6169 (CHIP_ID(bp) == CHIP_ID_5706_A2) ||
6170 (CHIP_ID(bp) == CHIP_ID_5708_A0))
Michael Chanb6016b72005-05-26 13:03:09 -07006171 stats_len_arr = bnx2_5706_stats_len_arr;
Michael Chan5b0c76a2005-11-04 08:45:49 -08006172 else
6173 stats_len_arr = bnx2_5708_stats_len_arr;
Michael Chanb6016b72005-05-26 13:03:09 -07006174
6175 for (i = 0; i < BNX2_NUM_STATS; i++) {
6176 if (stats_len_arr[i] == 0) {
6177 /* skip this counter */
6178 buf[i] = 0;
6179 continue;
6180 }
6181 if (stats_len_arr[i] == 4) {
6182 /* 4-byte counter */
6183 buf[i] = (u64)
6184 *(hw_stats + bnx2_stats_offset_arr[i]);
6185 continue;
6186 }
6187 /* 8-byte counter */
6188 buf[i] = (((u64) *(hw_stats +
6189 bnx2_stats_offset_arr[i])) << 32) +
6190 *(hw_stats + bnx2_stats_offset_arr[i] + 1);
6191 }
6192}
6193
6194static int
6195bnx2_phys_id(struct net_device *dev, u32 data)
6196{
Michael Chan972ec0d2006-01-23 16:12:43 -08006197 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07006198 int i;
6199 u32 save;
6200
6201 if (data == 0)
6202 data = 2;
6203
6204 save = REG_RD(bp, BNX2_MISC_CFG);
6205 REG_WR(bp, BNX2_MISC_CFG, BNX2_MISC_CFG_LEDMODE_MAC);
6206
6207 for (i = 0; i < (data * 2); i++) {
6208 if ((i % 2) == 0) {
6209 REG_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE);
6210 }
6211 else {
6212 REG_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE |
6213 BNX2_EMAC_LED_1000MB_OVERRIDE |
6214 BNX2_EMAC_LED_100MB_OVERRIDE |
6215 BNX2_EMAC_LED_10MB_OVERRIDE |
6216 BNX2_EMAC_LED_TRAFFIC_OVERRIDE |
6217 BNX2_EMAC_LED_TRAFFIC);
6218 }
6219 msleep_interruptible(500);
6220 if (signal_pending(current))
6221 break;
6222 }
6223 REG_WR(bp, BNX2_EMAC_LED, 0);
6224 REG_WR(bp, BNX2_MISC_CFG, save);
6225 return 0;
6226}
6227
Michael Chan4666f872007-05-03 13:22:28 -07006228static int
6229bnx2_set_tx_csum(struct net_device *dev, u32 data)
6230{
6231 struct bnx2 *bp = netdev_priv(dev);
6232
6233 if (CHIP_NUM(bp) == CHIP_NUM_5709)
Michael Chan6460d942007-07-14 19:07:52 -07006234 return (ethtool_op_set_tx_ipv6_csum(dev, data));
Michael Chan4666f872007-05-03 13:22:28 -07006235 else
6236 return (ethtool_op_set_tx_csum(dev, data));
6237}
6238
Jeff Garzik7282d492006-09-13 14:30:00 -04006239static const struct ethtool_ops bnx2_ethtool_ops = {
Michael Chanb6016b72005-05-26 13:03:09 -07006240 .get_settings = bnx2_get_settings,
6241 .set_settings = bnx2_set_settings,
6242 .get_drvinfo = bnx2_get_drvinfo,
Michael Chan244ac4f2006-03-20 17:48:46 -08006243 .get_regs_len = bnx2_get_regs_len,
6244 .get_regs = bnx2_get_regs,
Michael Chanb6016b72005-05-26 13:03:09 -07006245 .get_wol = bnx2_get_wol,
6246 .set_wol = bnx2_set_wol,
6247 .nway_reset = bnx2_nway_reset,
6248 .get_link = ethtool_op_get_link,
6249 .get_eeprom_len = bnx2_get_eeprom_len,
6250 .get_eeprom = bnx2_get_eeprom,
6251 .set_eeprom = bnx2_set_eeprom,
6252 .get_coalesce = bnx2_get_coalesce,
6253 .set_coalesce = bnx2_set_coalesce,
6254 .get_ringparam = bnx2_get_ringparam,
6255 .set_ringparam = bnx2_set_ringparam,
6256 .get_pauseparam = bnx2_get_pauseparam,
6257 .set_pauseparam = bnx2_set_pauseparam,
6258 .get_rx_csum = bnx2_get_rx_csum,
6259 .set_rx_csum = bnx2_set_rx_csum,
6260 .get_tx_csum = ethtool_op_get_tx_csum,
Michael Chan4666f872007-05-03 13:22:28 -07006261 .set_tx_csum = bnx2_set_tx_csum,
Michael Chanb6016b72005-05-26 13:03:09 -07006262 .get_sg = ethtool_op_get_sg,
6263 .set_sg = ethtool_op_set_sg,
Michael Chanb6016b72005-05-26 13:03:09 -07006264 .get_tso = ethtool_op_get_tso,
Michael Chanb11d6212006-06-29 12:31:21 -07006265 .set_tso = bnx2_set_tso,
Michael Chanb6016b72005-05-26 13:03:09 -07006266 .self_test_count = bnx2_self_test_count,
6267 .self_test = bnx2_self_test,
6268 .get_strings = bnx2_get_strings,
6269 .phys_id = bnx2_phys_id,
6270 .get_stats_count = bnx2_get_stats_count,
6271 .get_ethtool_stats = bnx2_get_ethtool_stats,
John W. Linville24b8e052005-09-12 14:45:08 -07006272 .get_perm_addr = ethtool_op_get_perm_addr,
Michael Chanb6016b72005-05-26 13:03:09 -07006273};
6274
6275/* Called with rtnl_lock */
6276static int
6277bnx2_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
6278{
Peter Hagervall14ab9b82005-08-10 14:18:16 -07006279 struct mii_ioctl_data *data = if_mii(ifr);
Michael Chan972ec0d2006-01-23 16:12:43 -08006280 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07006281 int err;
6282
6283 switch(cmd) {
6284 case SIOCGMIIPHY:
6285 data->phy_id = bp->phy_addr;
6286
6287 /* fallthru */
6288 case SIOCGMIIREG: {
6289 u32 mii_regval;
6290
Michael Chan7b6b8342007-07-07 22:50:15 -07006291 if (bp->phy_flags & REMOTE_PHY_CAP_FLAG)
6292 return -EOPNOTSUPP;
6293
Michael Chandad3e452007-05-03 13:18:03 -07006294 if (!netif_running(dev))
6295 return -EAGAIN;
6296
Michael Chanc770a652005-08-25 15:38:39 -07006297 spin_lock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07006298 err = bnx2_read_phy(bp, data->reg_num & 0x1f, &mii_regval);
Michael Chanc770a652005-08-25 15:38:39 -07006299 spin_unlock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07006300
6301 data->val_out = mii_regval;
6302
6303 return err;
6304 }
6305
6306 case SIOCSMIIREG:
6307 if (!capable(CAP_NET_ADMIN))
6308 return -EPERM;
6309
Michael Chan7b6b8342007-07-07 22:50:15 -07006310 if (bp->phy_flags & REMOTE_PHY_CAP_FLAG)
6311 return -EOPNOTSUPP;
6312
Michael Chandad3e452007-05-03 13:18:03 -07006313 if (!netif_running(dev))
6314 return -EAGAIN;
6315
Michael Chanc770a652005-08-25 15:38:39 -07006316 spin_lock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07006317 err = bnx2_write_phy(bp, data->reg_num & 0x1f, data->val_in);
Michael Chanc770a652005-08-25 15:38:39 -07006318 spin_unlock_bh(&bp->phy_lock);
Michael Chanb6016b72005-05-26 13:03:09 -07006319
6320 return err;
6321
6322 default:
6323 /* do nothing */
6324 break;
6325 }
6326 return -EOPNOTSUPP;
6327}
6328
6329/* Called with rtnl_lock */
6330static int
6331bnx2_change_mac_addr(struct net_device *dev, void *p)
6332{
6333 struct sockaddr *addr = p;
Michael Chan972ec0d2006-01-23 16:12:43 -08006334 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07006335
Michael Chan73eef4c2005-08-25 15:39:15 -07006336 if (!is_valid_ether_addr(addr->sa_data))
6337 return -EINVAL;
6338
Michael Chanb6016b72005-05-26 13:03:09 -07006339 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
6340 if (netif_running(dev))
6341 bnx2_set_mac_addr(bp);
6342
6343 return 0;
6344}
6345
6346/* Called with rtnl_lock */
6347static int
6348bnx2_change_mtu(struct net_device *dev, int new_mtu)
6349{
Michael Chan972ec0d2006-01-23 16:12:43 -08006350 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07006351
6352 if (((new_mtu + ETH_HLEN) > MAX_ETHERNET_JUMBO_PACKET_SIZE) ||
6353 ((new_mtu + ETH_HLEN) < MIN_ETHERNET_PACKET_SIZE))
6354 return -EINVAL;
6355
6356 dev->mtu = new_mtu;
6357 if (netif_running(dev)) {
6358 bnx2_netif_stop(bp);
6359
6360 bnx2_init_nic(bp);
6361
6362 bnx2_netif_start(bp);
6363 }
6364 return 0;
6365}
6366
6367#if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
6368static void
6369poll_bnx2(struct net_device *dev)
6370{
Michael Chan972ec0d2006-01-23 16:12:43 -08006371 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07006372
6373 disable_irq(bp->pdev->irq);
David Howells7d12e782006-10-05 14:55:46 +01006374 bnx2_interrupt(bp->pdev->irq, dev);
Michael Chanb6016b72005-05-26 13:03:09 -07006375 enable_irq(bp->pdev->irq);
6376}
6377#endif
6378
Michael Chan253c8b72007-01-08 19:56:01 -08006379static void __devinit
6380bnx2_get_5709_media(struct bnx2 *bp)
6381{
6382 u32 val = REG_RD(bp, BNX2_MISC_DUAL_MEDIA_CTRL);
6383 u32 bond_id = val & BNX2_MISC_DUAL_MEDIA_CTRL_BOND_ID;
6384 u32 strap;
6385
6386 if (bond_id == BNX2_MISC_DUAL_MEDIA_CTRL_BOND_ID_C)
6387 return;
6388 else if (bond_id == BNX2_MISC_DUAL_MEDIA_CTRL_BOND_ID_S) {
6389 bp->phy_flags |= PHY_SERDES_FLAG;
6390 return;
6391 }
6392
6393 if (val & BNX2_MISC_DUAL_MEDIA_CTRL_STRAP_OVERRIDE)
6394 strap = (val & BNX2_MISC_DUAL_MEDIA_CTRL_PHY_CTRL) >> 21;
6395 else
6396 strap = (val & BNX2_MISC_DUAL_MEDIA_CTRL_PHY_CTRL_STRAP) >> 8;
6397
6398 if (PCI_FUNC(bp->pdev->devfn) == 0) {
6399 switch (strap) {
6400 case 0x4:
6401 case 0x5:
6402 case 0x6:
6403 bp->phy_flags |= PHY_SERDES_FLAG;
6404 return;
6405 }
6406 } else {
6407 switch (strap) {
6408 case 0x1:
6409 case 0x2:
6410 case 0x4:
6411 bp->phy_flags |= PHY_SERDES_FLAG;
6412 return;
6413 }
6414 }
6415}
6416
Michael Chan883e5152007-05-03 13:25:11 -07006417static void __devinit
6418bnx2_get_pci_speed(struct bnx2 *bp)
6419{
6420 u32 reg;
6421
6422 reg = REG_RD(bp, BNX2_PCICFG_MISC_STATUS);
6423 if (reg & BNX2_PCICFG_MISC_STATUS_PCIX_DET) {
6424 u32 clkreg;
6425
6426 bp->flags |= PCIX_FLAG;
6427
6428 clkreg = REG_RD(bp, BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS);
6429
6430 clkreg &= BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET;
6431 switch (clkreg) {
6432 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_133MHZ:
6433 bp->bus_speed_mhz = 133;
6434 break;
6435
6436 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_95MHZ:
6437 bp->bus_speed_mhz = 100;
6438 break;
6439
6440 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_66MHZ:
6441 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_80MHZ:
6442 bp->bus_speed_mhz = 66;
6443 break;
6444
6445 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_48MHZ:
6446 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_55MHZ:
6447 bp->bus_speed_mhz = 50;
6448 break;
6449
6450 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_LOW:
6451 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_32MHZ:
6452 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_38MHZ:
6453 bp->bus_speed_mhz = 33;
6454 break;
6455 }
6456 }
6457 else {
6458 if (reg & BNX2_PCICFG_MISC_STATUS_M66EN)
6459 bp->bus_speed_mhz = 66;
6460 else
6461 bp->bus_speed_mhz = 33;
6462 }
6463
6464 if (reg & BNX2_PCICFG_MISC_STATUS_32BIT_DET)
6465 bp->flags |= PCI_32BIT_FLAG;
6466
6467}
6468
Michael Chanb6016b72005-05-26 13:03:09 -07006469static int __devinit
6470bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
6471{
6472 struct bnx2 *bp;
6473 unsigned long mem_len;
Michael Chan58fc2ea2007-07-07 22:52:02 -07006474 int rc, i, j;
Michael Chanb6016b72005-05-26 13:03:09 -07006475 u32 reg;
Michael Chan40453c82007-05-03 13:19:18 -07006476 u64 dma_mask, persist_dma_mask;
Michael Chanb6016b72005-05-26 13:03:09 -07006477
6478 SET_MODULE_OWNER(dev);
6479 SET_NETDEV_DEV(dev, &pdev->dev);
Michael Chan972ec0d2006-01-23 16:12:43 -08006480 bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07006481
6482 bp->flags = 0;
6483 bp->phy_flags = 0;
6484
6485 /* enable device (incl. PCI PM wakeup), and bus-mastering */
6486 rc = pci_enable_device(pdev);
6487 if (rc) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -04006488 dev_err(&pdev->dev, "Cannot enable PCI device, aborting.");
Michael Chanb6016b72005-05-26 13:03:09 -07006489 goto err_out;
6490 }
6491
6492 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -04006493 dev_err(&pdev->dev,
Jeff Garzik2e8a5382006-06-27 10:47:51 -04006494 "Cannot find PCI device base address, aborting.\n");
Michael Chanb6016b72005-05-26 13:03:09 -07006495 rc = -ENODEV;
6496 goto err_out_disable;
6497 }
6498
6499 rc = pci_request_regions(pdev, DRV_MODULE_NAME);
6500 if (rc) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -04006501 dev_err(&pdev->dev, "Cannot obtain PCI resources, aborting.\n");
Michael Chanb6016b72005-05-26 13:03:09 -07006502 goto err_out_disable;
6503 }
6504
6505 pci_set_master(pdev);
6506
6507 bp->pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM);
6508 if (bp->pm_cap == 0) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -04006509 dev_err(&pdev->dev,
Jeff Garzik2e8a5382006-06-27 10:47:51 -04006510 "Cannot find power management capability, aborting.\n");
Michael Chanb6016b72005-05-26 13:03:09 -07006511 rc = -EIO;
6512 goto err_out_release;
6513 }
6514
Michael Chanb6016b72005-05-26 13:03:09 -07006515 bp->dev = dev;
6516 bp->pdev = pdev;
6517
6518 spin_lock_init(&bp->phy_lock);
Michael Chan1b8227c2007-05-03 13:24:05 -07006519 spin_lock_init(&bp->indirect_lock);
David Howellsc4028952006-11-22 14:57:56 +00006520 INIT_WORK(&bp->reset_task, bnx2_reset_task);
Michael Chanb6016b72005-05-26 13:03:09 -07006521
6522 dev->base_addr = dev->mem_start = pci_resource_start(pdev, 0);
Michael Chan59b47d82006-11-19 14:10:45 -08006523 mem_len = MB_GET_CID_ADDR(TX_TSS_CID + 1);
Michael Chanb6016b72005-05-26 13:03:09 -07006524 dev->mem_end = dev->mem_start + mem_len;
6525 dev->irq = pdev->irq;
6526
6527 bp->regview = ioremap_nocache(dev->base_addr, mem_len);
6528
6529 if (!bp->regview) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -04006530 dev_err(&pdev->dev, "Cannot map register space, aborting.\n");
Michael Chanb6016b72005-05-26 13:03:09 -07006531 rc = -ENOMEM;
6532 goto err_out_release;
6533 }
6534
6535 /* Configure byte swap and enable write to the reg_window registers.
6536 * Rely on CPU to do target byte swapping on big endian systems
6537 * The chip's target access swapping will not swap all accesses
6538 */
6539 pci_write_config_dword(bp->pdev, BNX2_PCICFG_MISC_CONFIG,
6540 BNX2_PCICFG_MISC_CONFIG_REG_WINDOW_ENA |
6541 BNX2_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP);
6542
Pavel Machek829ca9a2005-09-03 15:56:56 -07006543 bnx2_set_power_state(bp, PCI_D0);
Michael Chanb6016b72005-05-26 13:03:09 -07006544
6545 bp->chip_id = REG_RD(bp, BNX2_MISC_ID);
6546
Michael Chan883e5152007-05-03 13:25:11 -07006547 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
6548 if (pci_find_capability(pdev, PCI_CAP_ID_EXP) == 0) {
6549 dev_err(&pdev->dev,
6550 "Cannot find PCIE capability, aborting.\n");
6551 rc = -EIO;
6552 goto err_out_unmap;
6553 }
6554 bp->flags |= PCIE_FLAG;
6555 } else {
Michael Chan59b47d82006-11-19 14:10:45 -08006556 bp->pcix_cap = pci_find_capability(pdev, PCI_CAP_ID_PCIX);
6557 if (bp->pcix_cap == 0) {
6558 dev_err(&pdev->dev,
6559 "Cannot find PCIX capability, aborting.\n");
6560 rc = -EIO;
6561 goto err_out_unmap;
6562 }
6563 }
6564
Michael Chan8e6a72c2007-05-03 13:24:48 -07006565 if (CHIP_ID(bp) != CHIP_ID_5706_A0 && CHIP_ID(bp) != CHIP_ID_5706_A1) {
6566 if (pci_find_capability(pdev, PCI_CAP_ID_MSI))
6567 bp->flags |= MSI_CAP_FLAG;
6568 }
6569
Michael Chan40453c82007-05-03 13:19:18 -07006570 /* 5708 cannot support DMA addresses > 40-bit. */
6571 if (CHIP_NUM(bp) == CHIP_NUM_5708)
6572 persist_dma_mask = dma_mask = DMA_40BIT_MASK;
6573 else
6574 persist_dma_mask = dma_mask = DMA_64BIT_MASK;
6575
6576 /* Configure DMA attributes. */
6577 if (pci_set_dma_mask(pdev, dma_mask) == 0) {
6578 dev->features |= NETIF_F_HIGHDMA;
6579 rc = pci_set_consistent_dma_mask(pdev, persist_dma_mask);
6580 if (rc) {
6581 dev_err(&pdev->dev,
6582 "pci_set_consistent_dma_mask failed, aborting.\n");
6583 goto err_out_unmap;
6584 }
6585 } else if ((rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK)) != 0) {
6586 dev_err(&pdev->dev, "System does not support DMA, aborting.\n");
6587 goto err_out_unmap;
6588 }
6589
Michael Chan883e5152007-05-03 13:25:11 -07006590 if (!(bp->flags & PCIE_FLAG))
6591 bnx2_get_pci_speed(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07006592
6593 /* 5706A0 may falsely detect SERR and PERR. */
6594 if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
6595 reg = REG_RD(bp, PCI_COMMAND);
6596 reg &= ~(PCI_COMMAND_SERR | PCI_COMMAND_PARITY);
6597 REG_WR(bp, PCI_COMMAND, reg);
6598 }
6599 else if ((CHIP_ID(bp) == CHIP_ID_5706_A1) &&
6600 !(bp->flags & PCIX_FLAG)) {
6601
Jeff Garzik9b91cf92006-06-27 11:39:50 -04006602 dev_err(&pdev->dev,
Jeff Garzik2e8a5382006-06-27 10:47:51 -04006603 "5706 A1 can only be used in a PCIX bus, aborting.\n");
Michael Chanb6016b72005-05-26 13:03:09 -07006604 goto err_out_unmap;
6605 }
6606
6607 bnx2_init_nvram(bp);
6608
Michael Chane3648b32005-11-04 08:51:21 -08006609 reg = REG_RD_IND(bp, BNX2_SHM_HDR_SIGNATURE);
6610
6611 if ((reg & BNX2_SHM_HDR_SIGNATURE_SIG_MASK) ==
Michael Chan24cb2302007-01-25 15:49:56 -08006612 BNX2_SHM_HDR_SIGNATURE_SIG) {
6613 u32 off = PCI_FUNC(pdev->devfn) << 2;
6614
6615 bp->shmem_base = REG_RD_IND(bp, BNX2_SHM_HDR_ADDR_0 + off);
6616 } else
Michael Chane3648b32005-11-04 08:51:21 -08006617 bp->shmem_base = HOST_VIEW_SHMEM_BASE;
6618
Michael Chanb6016b72005-05-26 13:03:09 -07006619 /* Get the permanent MAC address. First we need to make sure the
6620 * firmware is actually running.
6621 */
Michael Chane3648b32005-11-04 08:51:21 -08006622 reg = REG_RD_IND(bp, bp->shmem_base + BNX2_DEV_INFO_SIGNATURE);
Michael Chanb6016b72005-05-26 13:03:09 -07006623
6624 if ((reg & BNX2_DEV_INFO_SIGNATURE_MAGIC_MASK) !=
6625 BNX2_DEV_INFO_SIGNATURE_MAGIC) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -04006626 dev_err(&pdev->dev, "Firmware not running, aborting.\n");
Michael Chanb6016b72005-05-26 13:03:09 -07006627 rc = -ENODEV;
6628 goto err_out_unmap;
6629 }
6630
Michael Chan58fc2ea2007-07-07 22:52:02 -07006631 reg = REG_RD_IND(bp, bp->shmem_base + BNX2_DEV_INFO_BC_REV);
6632 for (i = 0, j = 0; i < 3; i++) {
6633 u8 num, k, skip0;
6634
6635 num = (u8) (reg >> (24 - (i * 8)));
6636 for (k = 100, skip0 = 1; k >= 1; num %= k, k /= 10) {
6637 if (num >= k || !skip0 || k == 1) {
6638 bp->fw_version[j++] = (num / k) + '0';
6639 skip0 = 0;
6640 }
6641 }
6642 if (i != 2)
6643 bp->fw_version[j++] = '.';
6644 }
Michael Chanc2d3db82007-07-16 18:26:43 -07006645 if (REG_RD_IND(bp, bp->shmem_base + BNX2_PORT_FEATURE) &
6646 BNX2_PORT_FEATURE_ASF_ENABLED) {
6647 bp->flags |= ASF_ENABLE_FLAG;
6648
6649 for (i = 0; i < 30; i++) {
6650 reg = REG_RD_IND(bp, bp->shmem_base +
6651 BNX2_BC_STATE_CONDITION);
6652 if (reg & BNX2_CONDITION_MFW_RUN_MASK)
6653 break;
6654 msleep(10);
6655 }
6656 }
Michael Chan58fc2ea2007-07-07 22:52:02 -07006657 reg = REG_RD_IND(bp, bp->shmem_base + BNX2_BC_STATE_CONDITION);
6658 reg &= BNX2_CONDITION_MFW_RUN_MASK;
6659 if (reg != BNX2_CONDITION_MFW_RUN_UNKNOWN &&
6660 reg != BNX2_CONDITION_MFW_RUN_NONE) {
6661 int i;
6662 u32 addr = REG_RD_IND(bp, bp->shmem_base + BNX2_MFW_VER_PTR);
6663
6664 bp->fw_version[j++] = ' ';
6665 for (i = 0; i < 3; i++) {
6666 reg = REG_RD_IND(bp, addr + i * 4);
6667 reg = swab32(reg);
6668 memcpy(&bp->fw_version[j], &reg, 4);
6669 j += 4;
6670 }
6671 }
Michael Chanb6016b72005-05-26 13:03:09 -07006672
Michael Chane3648b32005-11-04 08:51:21 -08006673 reg = REG_RD_IND(bp, bp->shmem_base + BNX2_PORT_HW_CFG_MAC_UPPER);
Michael Chanb6016b72005-05-26 13:03:09 -07006674 bp->mac_addr[0] = (u8) (reg >> 8);
6675 bp->mac_addr[1] = (u8) reg;
6676
Michael Chane3648b32005-11-04 08:51:21 -08006677 reg = REG_RD_IND(bp, bp->shmem_base + BNX2_PORT_HW_CFG_MAC_LOWER);
Michael Chanb6016b72005-05-26 13:03:09 -07006678 bp->mac_addr[2] = (u8) (reg >> 24);
6679 bp->mac_addr[3] = (u8) (reg >> 16);
6680 bp->mac_addr[4] = (u8) (reg >> 8);
6681 bp->mac_addr[5] = (u8) reg;
6682
6683 bp->tx_ring_size = MAX_TX_DESC_CNT;
Michael Chan932f3772006-08-15 01:39:36 -07006684 bnx2_set_rx_ring_size(bp, 255);
Michael Chanb6016b72005-05-26 13:03:09 -07006685
6686 bp->rx_csum = 1;
6687
6688 bp->rx_offset = sizeof(struct l2_fhdr) + 2;
6689
6690 bp->tx_quick_cons_trip_int = 20;
6691 bp->tx_quick_cons_trip = 20;
6692 bp->tx_ticks_int = 80;
6693 bp->tx_ticks = 80;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04006694
Michael Chanb6016b72005-05-26 13:03:09 -07006695 bp->rx_quick_cons_trip_int = 6;
6696 bp->rx_quick_cons_trip = 6;
6697 bp->rx_ticks_int = 18;
6698 bp->rx_ticks = 18;
6699
Michael Chan7ea69202007-07-16 18:27:10 -07006700 bp->stats_ticks = USEC_PER_SEC & BNX2_HC_STATS_TICKS_HC_STAT_TICKS;
Michael Chanb6016b72005-05-26 13:03:09 -07006701
6702 bp->timer_interval = HZ;
Michael Chancd339a02005-08-25 15:35:24 -07006703 bp->current_interval = HZ;
Michael Chanb6016b72005-05-26 13:03:09 -07006704
Michael Chan5b0c76a2005-11-04 08:45:49 -08006705 bp->phy_addr = 1;
6706
Michael Chanb6016b72005-05-26 13:03:09 -07006707 /* Disable WOL support if we are running on a SERDES chip. */
Michael Chan253c8b72007-01-08 19:56:01 -08006708 if (CHIP_NUM(bp) == CHIP_NUM_5709)
6709 bnx2_get_5709_media(bp);
6710 else if (CHIP_BOND_ID(bp) & CHIP_BOND_ID_SERDES_BIT)
Michael Chanb6016b72005-05-26 13:03:09 -07006711 bp->phy_flags |= PHY_SERDES_FLAG;
Michael Chanbac0dff2006-11-19 14:15:05 -08006712
Michael Chan0d8a6572007-07-07 22:49:43 -07006713 bp->phy_port = PORT_TP;
Michael Chanbac0dff2006-11-19 14:15:05 -08006714 if (bp->phy_flags & PHY_SERDES_FLAG) {
Michael Chan0d8a6572007-07-07 22:49:43 -07006715 bp->phy_port = PORT_FIBRE;
Michael Chanb6016b72005-05-26 13:03:09 -07006716 bp->flags |= NO_WOL_FLAG;
Michael Chanbac0dff2006-11-19 14:15:05 -08006717 if (CHIP_NUM(bp) != CHIP_NUM_5706) {
Michael Chan5b0c76a2005-11-04 08:45:49 -08006718 bp->phy_addr = 2;
Michael Chane3648b32005-11-04 08:51:21 -08006719 reg = REG_RD_IND(bp, bp->shmem_base +
Michael Chan5b0c76a2005-11-04 08:45:49 -08006720 BNX2_SHARED_HW_CFG_CONFIG);
6721 if (reg & BNX2_SHARED_HW_CFG_PHY_2_5G)
6722 bp->phy_flags |= PHY_2_5G_CAPABLE_FLAG;
6723 }
Michael Chan0d8a6572007-07-07 22:49:43 -07006724 bnx2_init_remote_phy(bp);
6725
Michael Chan261dd5c2007-01-08 19:55:46 -08006726 } else if (CHIP_NUM(bp) == CHIP_NUM_5706 ||
6727 CHIP_NUM(bp) == CHIP_NUM_5708)
6728 bp->phy_flags |= PHY_CRC_FIX_FLAG;
Michael Chanb659f442007-02-02 00:46:35 -08006729 else if (CHIP_ID(bp) == CHIP_ID_5709_A0)
6730 bp->phy_flags |= PHY_DIS_EARLY_DAC_FLAG;
Michael Chanb6016b72005-05-26 13:03:09 -07006731
Michael Chan16088272006-06-12 22:16:43 -07006732 if ((CHIP_ID(bp) == CHIP_ID_5708_A0) ||
6733 (CHIP_ID(bp) == CHIP_ID_5708_B0) ||
6734 (CHIP_ID(bp) == CHIP_ID_5708_B1))
Michael Chandda1e392006-01-23 16:08:14 -08006735 bp->flags |= NO_WOL_FLAG;
6736
Michael Chanb6016b72005-05-26 13:03:09 -07006737 if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
6738 bp->tx_quick_cons_trip_int =
6739 bp->tx_quick_cons_trip;
6740 bp->tx_ticks_int = bp->tx_ticks;
6741 bp->rx_quick_cons_trip_int =
6742 bp->rx_quick_cons_trip;
6743 bp->rx_ticks_int = bp->rx_ticks;
6744 bp->comp_prod_trip_int = bp->comp_prod_trip;
6745 bp->com_ticks_int = bp->com_ticks;
6746 bp->cmd_ticks_int = bp->cmd_ticks;
6747 }
6748
Michael Chanf9317a42006-09-29 17:06:23 -07006749 /* Disable MSI on 5706 if AMD 8132 bridge is found.
6750 *
6751 * MSI is defined to be 32-bit write. The 5706 does 64-bit MSI writes
6752 * with byte enables disabled on the unused 32-bit word. This is legal
6753 * but causes problems on the AMD 8132 which will eventually stop
6754 * responding after a while.
6755 *
6756 * AMD believes this incompatibility is unique to the 5706, and
Michael Ellerman88187df2007-01-25 19:34:07 +11006757 * prefers to locally disable MSI rather than globally disabling it.
Michael Chanf9317a42006-09-29 17:06:23 -07006758 */
6759 if (CHIP_NUM(bp) == CHIP_NUM_5706 && disable_msi == 0) {
6760 struct pci_dev *amd_8132 = NULL;
6761
6762 while ((amd_8132 = pci_get_device(PCI_VENDOR_ID_AMD,
6763 PCI_DEVICE_ID_AMD_8132_BRIDGE,
6764 amd_8132))) {
Michael Chanf9317a42006-09-29 17:06:23 -07006765
Auke Kok44c10132007-06-08 15:46:36 -07006766 if (amd_8132->revision >= 0x10 &&
6767 amd_8132->revision <= 0x13) {
Michael Chanf9317a42006-09-29 17:06:23 -07006768 disable_msi = 1;
6769 pci_dev_put(amd_8132);
6770 break;
6771 }
6772 }
6773 }
6774
Michael Chandeaf3912007-07-07 22:48:00 -07006775 bnx2_set_default_link(bp);
Michael Chanb6016b72005-05-26 13:03:09 -07006776 bp->req_flow_ctrl = FLOW_CTRL_RX | FLOW_CTRL_TX;
6777
Michael Chancd339a02005-08-25 15:35:24 -07006778 init_timer(&bp->timer);
6779 bp->timer.expires = RUN_AT(bp->timer_interval);
6780 bp->timer.data = (unsigned long) bp;
6781 bp->timer.function = bnx2_timer;
6782
Michael Chanb6016b72005-05-26 13:03:09 -07006783 return 0;
6784
6785err_out_unmap:
6786 if (bp->regview) {
6787 iounmap(bp->regview);
Michael Chan73eef4c2005-08-25 15:39:15 -07006788 bp->regview = NULL;
Michael Chanb6016b72005-05-26 13:03:09 -07006789 }
6790
6791err_out_release:
6792 pci_release_regions(pdev);
6793
6794err_out_disable:
6795 pci_disable_device(pdev);
6796 pci_set_drvdata(pdev, NULL);
6797
6798err_out:
6799 return rc;
6800}
6801
Michael Chan883e5152007-05-03 13:25:11 -07006802static char * __devinit
6803bnx2_bus_string(struct bnx2 *bp, char *str)
6804{
6805 char *s = str;
6806
6807 if (bp->flags & PCIE_FLAG) {
6808 s += sprintf(s, "PCI Express");
6809 } else {
6810 s += sprintf(s, "PCI");
6811 if (bp->flags & PCIX_FLAG)
6812 s += sprintf(s, "-X");
6813 if (bp->flags & PCI_32BIT_FLAG)
6814 s += sprintf(s, " 32-bit");
6815 else
6816 s += sprintf(s, " 64-bit");
6817 s += sprintf(s, " %dMHz", bp->bus_speed_mhz);
6818 }
6819 return str;
6820}
6821
Michael Chanb6016b72005-05-26 13:03:09 -07006822static int __devinit
6823bnx2_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
6824{
6825 static int version_printed = 0;
6826 struct net_device *dev = NULL;
6827 struct bnx2 *bp;
6828 int rc, i;
Michael Chan883e5152007-05-03 13:25:11 -07006829 char str[40];
Michael Chanb6016b72005-05-26 13:03:09 -07006830
6831 if (version_printed++ == 0)
6832 printk(KERN_INFO "%s", version);
6833
6834 /* dev zeroed in init_etherdev */
6835 dev = alloc_etherdev(sizeof(*bp));
6836
6837 if (!dev)
6838 return -ENOMEM;
6839
6840 rc = bnx2_init_board(pdev, dev);
6841 if (rc < 0) {
6842 free_netdev(dev);
6843 return rc;
6844 }
6845
6846 dev->open = bnx2_open;
6847 dev->hard_start_xmit = bnx2_start_xmit;
6848 dev->stop = bnx2_close;
6849 dev->get_stats = bnx2_get_stats;
6850 dev->set_multicast_list = bnx2_set_rx_mode;
6851 dev->do_ioctl = bnx2_ioctl;
6852 dev->set_mac_address = bnx2_change_mac_addr;
6853 dev->change_mtu = bnx2_change_mtu;
6854 dev->tx_timeout = bnx2_tx_timeout;
6855 dev->watchdog_timeo = TX_TIMEOUT;
6856#ifdef BCM_VLAN
6857 dev->vlan_rx_register = bnx2_vlan_rx_register;
Michael Chanb6016b72005-05-26 13:03:09 -07006858#endif
6859 dev->poll = bnx2_poll;
6860 dev->ethtool_ops = &bnx2_ethtool_ops;
6861 dev->weight = 64;
6862
Michael Chan972ec0d2006-01-23 16:12:43 -08006863 bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07006864
6865#if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
6866 dev->poll_controller = poll_bnx2;
6867#endif
6868
Michael Chan1b2f9222007-05-03 13:20:19 -07006869 pci_set_drvdata(pdev, dev);
6870
6871 memcpy(dev->dev_addr, bp->mac_addr, 6);
6872 memcpy(dev->perm_addr, bp->mac_addr, 6);
6873 bp->name = board_info[ent->driver_data].name;
6874
Stephen Hemmingerd212f872007-06-27 00:47:37 -07006875 dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
Michael Chan4666f872007-05-03 13:22:28 -07006876 if (CHIP_NUM(bp) == CHIP_NUM_5709)
Stephen Hemmingerd212f872007-06-27 00:47:37 -07006877 dev->features |= NETIF_F_IPV6_CSUM;
6878
Michael Chan1b2f9222007-05-03 13:20:19 -07006879#ifdef BCM_VLAN
6880 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
6881#endif
6882 dev->features |= NETIF_F_TSO | NETIF_F_TSO_ECN;
Michael Chan4666f872007-05-03 13:22:28 -07006883 if (CHIP_NUM(bp) == CHIP_NUM_5709)
6884 dev->features |= NETIF_F_TSO6;
Michael Chan1b2f9222007-05-03 13:20:19 -07006885
Michael Chanb6016b72005-05-26 13:03:09 -07006886 if ((rc = register_netdev(dev))) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -04006887 dev_err(&pdev->dev, "Cannot register net device\n");
Michael Chanb6016b72005-05-26 13:03:09 -07006888 if (bp->regview)
6889 iounmap(bp->regview);
6890 pci_release_regions(pdev);
6891 pci_disable_device(pdev);
6892 pci_set_drvdata(pdev, NULL);
6893 free_netdev(dev);
6894 return rc;
6895 }
6896
Michael Chan883e5152007-05-03 13:25:11 -07006897 printk(KERN_INFO "%s: %s (%c%d) %s found at mem %lx, "
Michael Chanb6016b72005-05-26 13:03:09 -07006898 "IRQ %d, ",
6899 dev->name,
6900 bp->name,
6901 ((CHIP_ID(bp) & 0xf000) >> 12) + 'A',
6902 ((CHIP_ID(bp) & 0x0ff0) >> 4),
Michael Chan883e5152007-05-03 13:25:11 -07006903 bnx2_bus_string(bp, str),
Michael Chanb6016b72005-05-26 13:03:09 -07006904 dev->base_addr,
6905 bp->pdev->irq);
6906
6907 printk("node addr ");
6908 for (i = 0; i < 6; i++)
6909 printk("%2.2x", dev->dev_addr[i]);
6910 printk("\n");
6911
Michael Chanb6016b72005-05-26 13:03:09 -07006912 return 0;
6913}
6914
6915static void __devexit
6916bnx2_remove_one(struct pci_dev *pdev)
6917{
6918 struct net_device *dev = pci_get_drvdata(pdev);
Michael Chan972ec0d2006-01-23 16:12:43 -08006919 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07006920
Michael Chanafdc08b2005-08-25 15:34:29 -07006921 flush_scheduled_work();
6922
Michael Chanb6016b72005-05-26 13:03:09 -07006923 unregister_netdev(dev);
6924
6925 if (bp->regview)
6926 iounmap(bp->regview);
6927
6928 free_netdev(dev);
6929 pci_release_regions(pdev);
6930 pci_disable_device(pdev);
6931 pci_set_drvdata(pdev, NULL);
6932}
6933
6934static int
Pavel Machek829ca9a2005-09-03 15:56:56 -07006935bnx2_suspend(struct pci_dev *pdev, pm_message_t state)
Michael Chanb6016b72005-05-26 13:03:09 -07006936{
6937 struct net_device *dev = pci_get_drvdata(pdev);
Michael Chan972ec0d2006-01-23 16:12:43 -08006938 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07006939 u32 reset_code;
6940
6941 if (!netif_running(dev))
6942 return 0;
6943
Michael Chan1d60290f2006-03-20 17:50:08 -08006944 flush_scheduled_work();
Michael Chanb6016b72005-05-26 13:03:09 -07006945 bnx2_netif_stop(bp);
6946 netif_device_detach(dev);
6947 del_timer_sync(&bp->timer);
Michael Chandda1e392006-01-23 16:08:14 -08006948 if (bp->flags & NO_WOL_FLAG)
Michael Chan6c4f0952006-06-29 12:38:15 -07006949 reset_code = BNX2_DRV_MSG_CODE_UNLOAD_LNK_DN;
Michael Chandda1e392006-01-23 16:08:14 -08006950 else if (bp->wol)
Michael Chanb6016b72005-05-26 13:03:09 -07006951 reset_code = BNX2_DRV_MSG_CODE_SUSPEND_WOL;
6952 else
6953 reset_code = BNX2_DRV_MSG_CODE_SUSPEND_NO_WOL;
6954 bnx2_reset_chip(bp, reset_code);
6955 bnx2_free_skbs(bp);
Michael Chan30c517b2007-05-03 13:20:40 -07006956 pci_save_state(pdev);
Pavel Machek829ca9a2005-09-03 15:56:56 -07006957 bnx2_set_power_state(bp, pci_choose_state(pdev, state));
Michael Chanb6016b72005-05-26 13:03:09 -07006958 return 0;
6959}
6960
6961static int
6962bnx2_resume(struct pci_dev *pdev)
6963{
6964 struct net_device *dev = pci_get_drvdata(pdev);
Michael Chan972ec0d2006-01-23 16:12:43 -08006965 struct bnx2 *bp = netdev_priv(dev);
Michael Chanb6016b72005-05-26 13:03:09 -07006966
6967 if (!netif_running(dev))
6968 return 0;
6969
Michael Chan30c517b2007-05-03 13:20:40 -07006970 pci_restore_state(pdev);
Pavel Machek829ca9a2005-09-03 15:56:56 -07006971 bnx2_set_power_state(bp, PCI_D0);
Michael Chanb6016b72005-05-26 13:03:09 -07006972 netif_device_attach(dev);
6973 bnx2_init_nic(bp);
6974 bnx2_netif_start(bp);
6975 return 0;
6976}
6977
6978static struct pci_driver bnx2_pci_driver = {
Peter Hagervall14ab9b82005-08-10 14:18:16 -07006979 .name = DRV_MODULE_NAME,
6980 .id_table = bnx2_pci_tbl,
6981 .probe = bnx2_init_one,
6982 .remove = __devexit_p(bnx2_remove_one),
6983 .suspend = bnx2_suspend,
6984 .resume = bnx2_resume,
Michael Chanb6016b72005-05-26 13:03:09 -07006985};
6986
6987static int __init bnx2_init(void)
6988{
Jeff Garzik29917622006-08-19 17:48:59 -04006989 return pci_register_driver(&bnx2_pci_driver);
Michael Chanb6016b72005-05-26 13:03:09 -07006990}
6991
6992static void __exit bnx2_cleanup(void)
6993{
6994 pci_unregister_driver(&bnx2_pci_driver);
6995}
6996
6997module_init(bnx2_init);
6998module_exit(bnx2_cleanup);
6999
7000
7001