?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
CRIS: Move common Kconfig variable ETRAX_RTC to arch independet Kconfig.
[wrt350n-kernel.git] / drivers / net / bnx2x.c
blob4a73c884d0c4dab1cdda1bf309a6b516c1bc85bc
1 /* bnx2x.c: Broadcom Everest network driver.
2 *
3 * Copyright (c) 2007 Broadcom Corporation
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation.
8 *
9 * Written by: Eliezer Tamir <eliezert@broadcom.com>
10 * Based on code from Michael Chan's bnx2 driver
11 * UDP CSUM errata workaround by Arik Gendelman
12 * Slowpath rework by Vladislav Zolotarov
13 * Statistics and Link managment by Yitchak Gertner
14 *
15 */
16
17 /* define this to make the driver freeze on error
18 * to allow getting debug info
19 * (you will need to reboot afterwords)
20 */
21 /*#define BNX2X_STOP_ON_ERROR*/
22
23 #include <linux/module.h>
24 #include <linux/moduleparam.h>
25 #include <linux/kernel.h>
26 #include <linux/device.h> /* for dev_info() */
27 #include <linux/timer.h>
28 #include <linux/errno.h>
29 #include <linux/ioport.h>
30 #include <linux/slab.h>
31 #include <linux/vmalloc.h>
32 #include <linux/interrupt.h>
33 #include <linux/pci.h>
34 #include <linux/init.h>
35 #include <linux/netdevice.h>
36 #include <linux/etherdevice.h>
37 #include <linux/skbuff.h>
38 #include <linux/dma-mapping.h>
39 #include <linux/bitops.h>
40 #include <linux/irq.h>
41 #include <linux/delay.h>
42 #include <asm/byteorder.h>
43 #include <linux/time.h>
44 #include <linux/ethtool.h>
45 #include <linux/mii.h>
46 #ifdef NETIF_F_HW_VLAN_TX
47 #include <linux/if_vlan.h>
48 #define BCM_VLAN 1
49 #endif
50 #include <net/ip.h>
51 #include <net/tcp.h>
52 #include <net/checksum.h>
53 #include <linux/workqueue.h>
54 #include <linux/crc32.h>
55 #include <linux/prefetch.h>
56 #include <linux/zlib.h>
57 #include <linux/version.h>
58 #include <linux/io.h>
59
60 #include "bnx2x_reg.h"
61 #include "bnx2x_fw_defs.h"
62 #include "bnx2x_hsi.h"
63 #include "bnx2x.h"
64 #include "bnx2x_init.h"
65
66 #define DRV_MODULE_VERSION "0.40.15"
67 #define DRV_MODULE_RELDATE "$DateTime: 2007/11/15 07:28:37 $"
68 #define BNX2X_BC_VER 0x040009
69
70 /* Time in jiffies before concluding the transmitter is hung. */
71 #define TX_TIMEOUT (5*HZ)
72
73 static const char version[] __devinitdata =
74 "Broadcom NetXtreme II 577xx 10Gigabit Ethernet Driver "
75 DRV_MODULE_NAME " " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
76
77 MODULE_AUTHOR("Eliezer Tamir <eliezert@broadcom.com>");
78 MODULE_DESCRIPTION("Broadcom NetXtreme II BCM57710 Driver");
79 MODULE_LICENSE("GPL");
80 MODULE_VERSION(DRV_MODULE_VERSION);
81 MODULE_INFO(cvs_version, "$Revision: #356 $");
82
83 static int use_inta;
84 static int poll;
85 static int onefunc;
86 static int nomcp;
87 static int debug;
88 static int use_multi;
89
90 module_param(use_inta, int, 0);
91 module_param(poll, int, 0);
92 module_param(onefunc, int, 0);
93 module_param(debug, int, 0);
94 MODULE_PARM_DESC(use_inta, "use INT#A instead of MSI-X");
95 MODULE_PARM_DESC(poll, "use polling (for debug)");
96 MODULE_PARM_DESC(onefunc, "enable only first function");
97 MODULE_PARM_DESC(nomcp, "ignore managment CPU (Implies onefunc)");
98 MODULE_PARM_DESC(debug, "defualt debug msglevel");
99
100 #ifdef BNX2X_MULTI
101 module_param(use_multi, int, 0);
102 MODULE_PARM_DESC(use_multi, "use per-CPU queues");
103 #endif
104
105 enum bnx2x_board_type {
106 BCM57710 = 0,
107 };
108
109 /* indexed by board_t, above */
110 static const struct {
111 char *name;
112 } board_info[] __devinitdata = {
113 { "Broadcom NetXtreme II BCM57710 XGb" }
114 };
115
116 static const struct pci_device_id bnx2x_pci_tbl[] = {
117 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57710,
118 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM57710 },
119 { 0 }
120 };
121
122 MODULE_DEVICE_TABLE(pci, bnx2x_pci_tbl);
123
124 /****************************************************************************
125 * General service functions
126 ****************************************************************************/
127
128 /* used only at init
129 * locking is done by mcp
130 */
131 static void bnx2x_reg_wr_ind(struct bnx2x *bp, u32 addr, u32 val)
132 {
133 pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
134 pci_write_config_dword(bp->pdev, PCICFG_GRC_DATA, val);
135 pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
136 PCICFG_VENDOR_ID_OFFSET);
137 }
138
139 #ifdef BNX2X_IND_RD
140 static u32 bnx2x_reg_rd_ind(struct bnx2x *bp, u32 addr)
141 {
142 u32 val;
143
144 pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
145 pci_read_config_dword(bp->pdev, PCICFG_GRC_DATA, &val);
146 pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
147 PCICFG_VENDOR_ID_OFFSET);
148
149 return val;
150 }
151 #endif
152
153 static const u32 dmae_reg_go_c[] = {
154 DMAE_REG_GO_C0, DMAE_REG_GO_C1, DMAE_REG_GO_C2, DMAE_REG_GO_C3,
155 DMAE_REG_GO_C4, DMAE_REG_GO_C5, DMAE_REG_GO_C6, DMAE_REG_GO_C7,
156 DMAE_REG_GO_C8, DMAE_REG_GO_C9, DMAE_REG_GO_C10, DMAE_REG_GO_C11,
157 DMAE_REG_GO_C12, DMAE_REG_GO_C13, DMAE_REG_GO_C14, DMAE_REG_GO_C15
158 };
159
160 /* copy command into DMAE command memory and set DMAE command go */
161 static void bnx2x_post_dmae(struct bnx2x *bp, struct dmae_command *dmae,
162 int idx)
163 {
164 u32 cmd_offset;
165 int i;
166
167 cmd_offset = (DMAE_REG_CMD_MEM + sizeof(struct dmae_command) * idx);
168 for (i = 0; i < (sizeof(struct dmae_command)/4); i++) {
169 REG_WR(bp, cmd_offset + i*4, *(((u32 *)dmae) + i));
170
171 /* DP(NETIF_MSG_DMAE, "DMAE cmd[%d].%d (0x%08x) : 0x%08x\n",
172 idx, i, cmd_offset + i*4, *(((u32 *)dmae) + i)); */
173 }
174 REG_WR(bp, dmae_reg_go_c[idx], 1);
175 }
176
177 static void bnx2x_write_dmae(struct bnx2x *bp, dma_addr_t dma_addr,
178 u32 dst_addr, u32 len32)
179 {
180 struct dmae_command *dmae = &bp->dmae;
181 int port = bp->port;
182 u32 *wb_comp = bnx2x_sp(bp, wb_comp);
183 int timeout = 200;
184
185 memset(dmae, 0, sizeof(struct dmae_command));
186
187 dmae->opcode = (DMAE_CMD_SRC_PCI | DMAE_CMD_DST_GRC |
188 DMAE_CMD_C_DST_PCI | DMAE_CMD_C_ENABLE |
189 DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
190 #ifdef __BIG_ENDIAN
191 DMAE_CMD_ENDIANITY_B_DW_SWAP |
192 #else
193 DMAE_CMD_ENDIANITY_DW_SWAP |
194 #endif
195 (port ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0));
196 dmae->src_addr_lo = U64_LO(dma_addr);
197 dmae->src_addr_hi = U64_HI(dma_addr);
198 dmae->dst_addr_lo = dst_addr >> 2;
199 dmae->dst_addr_hi = 0;
200 dmae->len = len32;
201 dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_comp));
202 dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_comp));
203 dmae->comp_val = BNX2X_WB_COMP_VAL;
204
205 /*
206 DP(NETIF_MSG_DMAE, "dmae: opcode 0x%08x\n"
207 DP_LEVEL "src_addr [%x:%08x] len [%d *4] "
208 "dst_addr [%x:%08x (%08x)]\n"
209 DP_LEVEL "comp_addr [%x:%08x] comp_val 0x%08x\n",
210 dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
211 dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo, dst_addr,
212 dmae->comp_addr_hi, dmae->comp_addr_lo, dmae->comp_val);
213 */
214 /*
215 DP(NETIF_MSG_DMAE, "data [0x%08x 0x%08x 0x%08x 0x%08x]\n",
216 bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
217 bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
218 */
219
220 *wb_comp = 0;
221
222 bnx2x_post_dmae(bp, dmae, port * 8);
223
224 udelay(5);
225 /* adjust timeout for emulation/FPGA */
226 if (CHIP_REV_IS_SLOW(bp))
227 timeout *= 100;
228 while (*wb_comp != BNX2X_WB_COMP_VAL) {
229 /* DP(NETIF_MSG_DMAE, "wb_comp 0x%08x\n", *wb_comp); */
230 udelay(5);
231 if (!timeout) {
232 BNX2X_ERR("dmae timeout!\n");
233 break;
234 }
235 timeout--;
236 }
237 }
238
239 #ifdef BNX2X_DMAE_RD
240 static void bnx2x_read_dmae(struct bnx2x *bp, u32 src_addr, u32 len32)
241 {
242 struct dmae_command *dmae = &bp->dmae;
243 int port = bp->port;
244 u32 *wb_comp = bnx2x_sp(bp, wb_comp);
245 int timeout = 200;
246
247 memset(bnx2x_sp(bp, wb_data[0]), 0, sizeof(u32) * 4);
248 memset(dmae, 0, sizeof(struct dmae_command));
249
250 dmae->opcode = (DMAE_CMD_SRC_GRC | DMAE_CMD_DST_PCI |
251 DMAE_CMD_C_DST_PCI | DMAE_CMD_C_ENABLE |
252 DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
253 #ifdef __BIG_ENDIAN
254 DMAE_CMD_ENDIANITY_B_DW_SWAP |
255 #else
256 DMAE_CMD_ENDIANITY_DW_SWAP |
257 #endif
258 (port ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0));
259 dmae->src_addr_lo = src_addr >> 2;
260 dmae->src_addr_hi = 0;
261 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_data));
262 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_data));
263 dmae->len = len32;
264 dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_comp));
265 dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_comp));
266 dmae->comp_val = BNX2X_WB_COMP_VAL;
267
268 /*
269 DP(NETIF_MSG_DMAE, "dmae: opcode 0x%08x\n"
270 DP_LEVEL "src_addr [%x:%08x] len [%d *4] "
271 "dst_addr [%x:%08x (%08x)]\n"
272 DP_LEVEL "comp_addr [%x:%08x] comp_val 0x%08x\n",
273 dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
274 dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo, src_addr,
275 dmae->comp_addr_hi, dmae->comp_addr_lo, dmae->comp_val);
276 */
277
278 *wb_comp = 0;
279
280 bnx2x_post_dmae(bp, dmae, port * 8);
281
282 udelay(5);
283 while (*wb_comp != BNX2X_WB_COMP_VAL) {
284 udelay(5);
285 if (!timeout) {
286 BNX2X_ERR("dmae timeout!\n");
287 break;
288 }
289 timeout--;
290 }
291 /*
292 DP(NETIF_MSG_DMAE, "data [0x%08x 0x%08x 0x%08x 0x%08x]\n",
293 bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
294 bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
295 */
296 }
297 #endif
298
299 static int bnx2x_mc_assert(struct bnx2x *bp)
300 {
301 int i, j;
302 int rc = 0;
303 char last_idx;
304 const char storm[] = {"XTCU"};
305 const u32 intmem_base[] = {
306 BAR_XSTRORM_INTMEM,
307 BAR_TSTRORM_INTMEM,
308 BAR_CSTRORM_INTMEM,
309 BAR_USTRORM_INTMEM
310 };
311
312 /* Go through all instances of all SEMIs */
313 for (i = 0; i < 4; i++) {
314 last_idx = REG_RD8(bp, XSTORM_ASSERT_LIST_INDEX_OFFSET +
315 intmem_base[i]);
316 BNX2X_ERR("DATA %cSTORM_ASSERT_LIST_INDEX 0x%x\n",
317 storm[i], last_idx);
318
319 /* print the asserts */
320 for (j = 0; j < STROM_ASSERT_ARRAY_SIZE; j++) {
321 u32 row0, row1, row2, row3;
322
323 row0 = REG_RD(bp, XSTORM_ASSERT_LIST_OFFSET(j) +
324 intmem_base[i]);
325 row1 = REG_RD(bp, XSTORM_ASSERT_LIST_OFFSET(j) + 4 +
326 intmem_base[i]);
327 row2 = REG_RD(bp, XSTORM_ASSERT_LIST_OFFSET(j) + 8 +
328 intmem_base[i]);
329 row3 = REG_RD(bp, XSTORM_ASSERT_LIST_OFFSET(j) + 12 +
330 intmem_base[i]);
331
332 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
333 BNX2X_ERR("DATA %cSTORM_ASSERT_INDEX 0x%x ="
334 " 0x%08x 0x%08x 0x%08x 0x%08x\n",
335 storm[i], j, row3, row2, row1, row0);
336 rc++;
337 } else {
338 break;
339 }
340 }
341 }
342 return rc;
343 }
344 static void bnx2x_fw_dump(struct bnx2x *bp)
345 {
346 u32 mark, offset;
347 u32 data[9];
348 int word;
349
350 mark = REG_RD(bp, MCP_REG_MCPR_SCRATCH + 0xf104);
351 printk(KERN_ERR PFX "begin fw dump (mark 0x%x)\n", mark);
352
353 for (offset = mark - 0x08000000; offset <= 0xF900; offset += 0x8*4) {
354 for (word = 0; word < 8; word++)
355 data[word] = htonl(REG_RD(bp, MCP_REG_MCPR_SCRATCH +
356 offset + 4*word));
357 data[8] = 0x0;
358 printk(KERN_ERR PFX "%s", (char *)data);
359 }
360 for (offset = 0xF108; offset <= mark - 0x08000000; offset += 0x8*4) {
361 for (word = 0; word < 8; word++)
362 data[word] = htonl(REG_RD(bp, MCP_REG_MCPR_SCRATCH +
363 offset + 4*word));
364 data[8] = 0x0;
365 printk(KERN_ERR PFX "%s", (char *)data);
366 }
367 printk("\n" KERN_ERR PFX "end of fw dump\n");
368 }
369
370 static void bnx2x_panic_dump(struct bnx2x *bp)
371 {
372 int i;
373 u16 j, start, end;
374
375 BNX2X_ERR("begin crash dump -----------------\n");
376
377 for_each_queue(bp, i) {
378 struct bnx2x_fastpath *fp = &bp->fp[i];
379 struct eth_tx_db_data *hw_prods = fp->hw_tx_prods;
380
381 BNX2X_ERR("queue[%d]: tx_pkt_prod(%x) tx_pkt_cons(%x)"
382 " tx_bd_prod(%x) tx_bd_cons(%x) *tx_cons_sb(%x)"
383 " *rx_cons_sb(%x) rx_comp_prod(%x)"
384 " rx_comp_cons(%x) fp_c_idx(%x) fp_u_idx(%x)"
385 " bd data(%x,%x)\n",
386 i, fp->tx_pkt_prod, fp->tx_pkt_cons, fp->tx_bd_prod,
387 fp->tx_bd_cons, *fp->tx_cons_sb, *fp->rx_cons_sb,
388 fp->rx_comp_prod, fp->rx_comp_cons, fp->fp_c_idx,
389 fp->fp_u_idx, hw_prods->packets_prod,
390 hw_prods->bds_prod);
391
392 start = TX_BD(le16_to_cpu(*fp->tx_cons_sb) - 10);
393 end = TX_BD(le16_to_cpu(*fp->tx_cons_sb) + 245);
394 for (j = start; j < end; j++) {
395 struct sw_tx_bd *sw_bd = &fp->tx_buf_ring[j];
396
397 BNX2X_ERR("packet[%x]=[%p,%x]\n", j,
398 sw_bd->skb, sw_bd->first_bd);
399 }
400
401 start = TX_BD(fp->tx_bd_cons - 10);
402 end = TX_BD(fp->tx_bd_cons + 254);
403 for (j = start; j < end; j++) {
404 u32 *tx_bd = (u32 *)&fp->tx_desc_ring[j];
405
406 BNX2X_ERR("tx_bd[%x]=[%x:%x:%x:%x]\n",
407 j, tx_bd[0], tx_bd[1], tx_bd[2], tx_bd[3]);
408 }
409
410 start = RX_BD(le16_to_cpu(*fp->rx_cons_sb) - 10);
411 end = RX_BD(le16_to_cpu(*fp->rx_cons_sb) + 503);
412 for (j = start; j < end; j++) {
413 u32 *rx_bd = (u32 *)&fp->rx_desc_ring[j];
414 struct sw_rx_bd *sw_bd = &fp->rx_buf_ring[j];
415
416 BNX2X_ERR("rx_bd[%x]=[%x:%x] sw_bd=[%p]\n",
417 j, rx_bd[0], rx_bd[1], sw_bd->skb);
418 }
419
420 start = RCQ_BD(fp->rx_comp_cons - 10);
421 end = RCQ_BD(fp->rx_comp_cons + 503);
422 for (j = start; j < end; j++) {
423 u32 *cqe = (u32 *)&fp->rx_comp_ring[j];
424
425 BNX2X_ERR("cqe[%x]=[%x:%x:%x:%x]\n",
426 j, cqe[0], cqe[1], cqe[2], cqe[3]);
427 }
428 }
429
430 BNX2X_ERR("def_c_idx(%u) def_u_idx(%u) def_t_idx(%u)"
431 " def_x_idx(%u) def_att_idx(%u) attn_state(%u)"
432 " spq_prod_idx(%u)\n",
433 bp->def_c_idx, bp->def_u_idx, bp->def_t_idx, bp->def_x_idx,
434 bp->def_att_idx, bp->attn_state, bp->spq_prod_idx);
435
436
437 bnx2x_mc_assert(bp);
438 BNX2X_ERR("end crash dump -----------------\n");
439
440 bp->stats_state = STATS_STATE_DISABLE;
441 DP(BNX2X_MSG_STATS, "stats_state - DISABLE\n");
442 }
443
444 static void bnx2x_enable_int(struct bnx2x *bp)
445 {
446 int port = bp->port;
447 u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
448 u32 val = REG_RD(bp, addr);
449 int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
450
451 if (msix) {
452 val &= ~HC_CONFIG_0_REG_SINGLE_ISR_EN_0;
453 val |= (HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
454 HC_CONFIG_0_REG_ATTN_BIT_EN_0);
455 } else {
456 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
457 HC_CONFIG_0_REG_INT_LINE_EN_0 |
458 HC_CONFIG_0_REG_ATTN_BIT_EN_0);
459 val &= ~HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0;
460 }
461
462 DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x) msi %d\n",
463 val, port, addr, msix);
464
465 REG_WR(bp, addr, val);
466 }
467
468 static void bnx2x_disable_int(struct bnx2x *bp)
469 {
470 int port = bp->port;
471 u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
472 u32 val = REG_RD(bp, addr);
473
474 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
475 HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
476 HC_CONFIG_0_REG_INT_LINE_EN_0 |
477 HC_CONFIG_0_REG_ATTN_BIT_EN_0);
478
479 DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)\n",
480 val, port, addr);
481
482 REG_WR(bp, addr, val);
483 if (REG_RD(bp, addr) != val)
484 BNX2X_ERR("BUG! proper val not read from IGU!\n");
485 }
486
487 static void bnx2x_disable_int_sync(struct bnx2x *bp)
488 {
489
490 int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
491 int i;
492
493 atomic_inc(&bp->intr_sem);
494 /* prevent the HW from sending interrupts*/
495 bnx2x_disable_int(bp);
496
497 /* make sure all ISRs are done */
498 if (msix) {
499 for_each_queue(bp, i)
500 synchronize_irq(bp->msix_table[i].vector);
501
502 /* one more for the Slow Path IRQ */
503 synchronize_irq(bp->msix_table[i].vector);
504 } else
505 synchronize_irq(bp->pdev->irq);
506
507 /* make sure sp_task is not running */
508 cancel_work_sync(&bp->sp_task);
509
510 }
511
512 /* fast path code */
513
514 /*
515 * general service functions
516 */
517
518 static inline void bnx2x_ack_sb(struct bnx2x *bp, u8 id,
519 u8 storm, u16 index, u8 op, u8 update)
520 {
521 u32 igu_addr = (IGU_ADDR_INT_ACK + IGU_PORT_BASE * bp->port) * 8;
522 struct igu_ack_register igu_ack;
523
524 igu_ack.status_block_index = index;
525 igu_ack.sb_id_and_flags =
526 ((id << IGU_ACK_REGISTER_STATUS_BLOCK_ID_SHIFT) |
527 (storm << IGU_ACK_REGISTER_STORM_ID_SHIFT) |
528 (update << IGU_ACK_REGISTER_UPDATE_INDEX_SHIFT) |
529 (op << IGU_ACK_REGISTER_INTERRUPT_MODE_SHIFT));
530
531 /* DP(NETIF_MSG_INTR, "write 0x%08x to IGU addr 0x%x\n",
532 (*(u32 *)&igu_ack), BAR_IGU_INTMEM + igu_addr); */
533 REG_WR(bp, BAR_IGU_INTMEM + igu_addr, (*(u32 *)&igu_ack));
534 }
535
536 static inline u16 bnx2x_update_fpsb_idx(struct bnx2x_fastpath *fp)
537 {
538 struct host_status_block *fpsb = fp->status_blk;
539 u16 rc = 0;
540
541 barrier(); /* status block is written to by the chip */
542 if (fp->fp_c_idx != fpsb->c_status_block.status_block_index) {
543 fp->fp_c_idx = fpsb->c_status_block.status_block_index;
544 rc |= 1;
545 }
546 if (fp->fp_u_idx != fpsb->u_status_block.status_block_index) {
547 fp->fp_u_idx = fpsb->u_status_block.status_block_index;
548 rc |= 2;
549 }
550 return rc;
551 }
552
553 static inline int bnx2x_has_work(struct bnx2x_fastpath *fp)
554 {
555 u16 rx_cons_sb = le16_to_cpu(*fp->rx_cons_sb);
556
557 if ((rx_cons_sb & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
558 rx_cons_sb++;
559
560 if ((rx_cons_sb != fp->rx_comp_cons) ||
561 (le16_to_cpu(*fp->tx_cons_sb) != fp->tx_pkt_cons))
562 return 1;
563
564 return 0;
565 }
566
567 static u16 bnx2x_ack_int(struct bnx2x *bp)
568 {
569 u32 igu_addr = (IGU_ADDR_SIMD_MASK + IGU_PORT_BASE * bp->port) * 8;
570 u32 result = REG_RD(bp, BAR_IGU_INTMEM + igu_addr);
571
572 /* DP(NETIF_MSG_INTR, "read 0x%08x from IGU addr 0x%x\n",
573 result, BAR_IGU_INTMEM + igu_addr); */
574
575 #ifdef IGU_DEBUG
576 #warning IGU_DEBUG active
577 if (result == 0) {
578 BNX2X_ERR("read %x from IGU\n", result);
579 REG_WR(bp, TM_REG_TIMER_SOFT_RST, 0);
580 }
581 #endif
582 return result;
583 }
584
585
586 /*
587 * fast path service functions
588 */
589
590 /* free skb in the packet ring at pos idx
591 * return idx of last bd freed
592 */
593 static u16 bnx2x_free_tx_pkt(struct bnx2x *bp, struct bnx2x_fastpath *fp,
594 u16 idx)
595 {
596 struct sw_tx_bd *tx_buf = &fp->tx_buf_ring[idx];
597 struct eth_tx_bd *tx_bd;
598 struct sk_buff *skb = tx_buf->skb;
599 u16 bd_idx = tx_buf->first_bd;
600 int nbd;
601
602 DP(BNX2X_MSG_OFF, "pkt_idx %d buff @(%p)->skb %p\n",
603 idx, tx_buf, skb);
604
605 /* unmap first bd */
606 DP(BNX2X_MSG_OFF, "free bd_idx %d\n", bd_idx);
607 tx_bd = &fp->tx_desc_ring[bd_idx];
608 pci_unmap_single(bp->pdev, BD_UNMAP_ADDR(tx_bd),
609 BD_UNMAP_LEN(tx_bd), PCI_DMA_TODEVICE);
610
611 nbd = le16_to_cpu(tx_bd->nbd) - 1;
612 #ifdef BNX2X_STOP_ON_ERROR
613 if (nbd > (MAX_SKB_FRAGS + 2)) {
614 BNX2X_ERR("bad nbd!\n");
615 bnx2x_panic();
616 }
617 #endif
618
619 /* Skip a parse bd and the TSO split header bd
620 since they have no mapping */
621 if (nbd)
622 bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
623
624 if (tx_bd->bd_flags.as_bitfield & (ETH_TX_BD_FLAGS_IP_CSUM |
625 ETH_TX_BD_FLAGS_TCP_CSUM |
626 ETH_TX_BD_FLAGS_SW_LSO)) {
627 if (--nbd)
628 bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
629 tx_bd = &fp->tx_desc_ring[bd_idx];
630 /* is this a TSO split header bd? */
631 if (tx_bd->bd_flags.as_bitfield & ETH_TX_BD_FLAGS_SW_LSO) {
632 if (--nbd)
633 bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
634 }
635 }
636
637 /* now free frags */
638 while (nbd > 0) {
639
640 DP(BNX2X_MSG_OFF, "free frag bd_idx %d\n", bd_idx);
641 tx_bd = &fp->tx_desc_ring[bd_idx];
642 pci_unmap_page(bp->pdev, BD_UNMAP_ADDR(tx_bd),
643 BD_UNMAP_LEN(tx_bd), PCI_DMA_TODEVICE);
644 if (--nbd)
645 bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
646 }
647
648 /* release skb */
649 BUG_TRAP(skb);
650 dev_kfree_skb(skb);
651 tx_buf->first_bd = 0;
652 tx_buf->skb = NULL;
653
654 return bd_idx;
655 }
656
657 static inline u32 bnx2x_tx_avail(struct bnx2x_fastpath *fp)
658 {
659 u16 used;
660 u32 prod;
661 u32 cons;
662
663 /* Tell compiler that prod and cons can change */
664 barrier();
665 prod = fp->tx_bd_prod;
666 cons = fp->tx_bd_cons;
667
668 used = (NUM_TX_BD - NUM_TX_RINGS + prod - cons +
669 (cons / TX_DESC_CNT) - (prod / TX_DESC_CNT));
670
671 if (prod >= cons) {
672 /* used = prod - cons - prod/size + cons/size */
673 used -= NUM_TX_BD - NUM_TX_RINGS;
674 }
675
676 BUG_TRAP(used <= fp->bp->tx_ring_size);
677 BUG_TRAP((fp->bp->tx_ring_size - used) <= MAX_TX_AVAIL);
678
679 return (fp->bp->tx_ring_size - used);
680 }
681
682 static void bnx2x_tx_int(struct bnx2x_fastpath *fp, int work)
683 {
684 struct bnx2x *bp = fp->bp;
685 u16 hw_cons, sw_cons, bd_cons = fp->tx_bd_cons;
686 int done = 0;
687
688 #ifdef BNX2X_STOP_ON_ERROR
689 if (unlikely(bp->panic))
690 return;
691 #endif
692
693 hw_cons = le16_to_cpu(*fp->tx_cons_sb);
694 sw_cons = fp->tx_pkt_cons;
695
696 while (sw_cons != hw_cons) {
697 u16 pkt_cons;
698
699 pkt_cons = TX_BD(sw_cons);
700
701 /* prefetch(bp->tx_buf_ring[pkt_cons].skb); */
702
703 DP(NETIF_MSG_TX_DONE, "hw_cons %u sw_cons %u pkt_cons %d\n",
704 hw_cons, sw_cons, pkt_cons);
705
706 /* if (NEXT_TX_IDX(sw_cons) != hw_cons) {
707 rmb();
708 prefetch(fp->tx_buf_ring[NEXT_TX_IDX(sw_cons)].skb);
709 }
710 */
711 bd_cons = bnx2x_free_tx_pkt(bp, fp, pkt_cons);
712 sw_cons++;
713 done++;
714
715 if (done == work)
716 break;
717 }
718
719 fp->tx_pkt_cons = sw_cons;
720 fp->tx_bd_cons = bd_cons;
721
722 /* Need to make the tx_cons update visible to start_xmit()
723 * before checking for netif_queue_stopped(). Without the
724 * memory barrier, there is a small possibility that start_xmit()
725 * will miss it and cause the queue to be stopped forever.
726 */
727 smp_mb();
728
729 /* TBD need a thresh? */
730 if (unlikely(netif_queue_stopped(bp->dev))) {
731
732 netif_tx_lock(bp->dev);
733
734 if (netif_queue_stopped(bp->dev) &&
735 (bnx2x_tx_avail(fp) >= MAX_SKB_FRAGS + 3))
736 netif_wake_queue(bp->dev);
737
738 netif_tx_unlock(bp->dev);
739
740 }
741 }
742
743 static void bnx2x_sp_event(struct bnx2x_fastpath *fp,
744 union eth_rx_cqe *rr_cqe)
745 {
746 struct bnx2x *bp = fp->bp;
747 int cid = SW_CID(rr_cqe->ramrod_cqe.conn_and_cmd_data);
748 int command = CQE_CMD(rr_cqe->ramrod_cqe.conn_and_cmd_data);
749
750 DP(NETIF_MSG_RX_STATUS,
751 "fp %d cid %d got ramrod #%d state is %x type is %d\n",
752 fp->index, cid, command, bp->state, rr_cqe->ramrod_cqe.type);
753
754 bp->spq_left++;
755
756 if (fp->index) {
757 switch (command | fp->state) {
758 case (RAMROD_CMD_ID_ETH_CLIENT_SETUP |
759 BNX2X_FP_STATE_OPENING):
760 DP(NETIF_MSG_IFUP, "got MULTI[%d] setup ramrod\n",
761 cid);
762 fp->state = BNX2X_FP_STATE_OPEN;
763 break;
764
765 case (RAMROD_CMD_ID_ETH_HALT | BNX2X_FP_STATE_HALTING):
766 DP(NETIF_MSG_IFDOWN, "got MULTI[%d] halt ramrod\n",
767 cid);
768 fp->state = BNX2X_FP_STATE_HALTED;
769 break;
770
771 default:
772 BNX2X_ERR("unexpected MC reply(%d) state is %x\n",
773 command, fp->state);
774 }
775 mb(); /* force bnx2x_wait_ramrod to see the change */
776 return;
777 }
778 switch (command | bp->state) {
779 case (RAMROD_CMD_ID_ETH_PORT_SETUP | BNX2X_STATE_OPENING_WAIT4_PORT):
780 DP(NETIF_MSG_IFUP, "got setup ramrod\n");
781 bp->state = BNX2X_STATE_OPEN;
782 break;
783
784 case (RAMROD_CMD_ID_ETH_HALT | BNX2X_STATE_CLOSING_WAIT4_HALT):
785 DP(NETIF_MSG_IFDOWN, "got halt ramrod\n");
786 bp->state = BNX2X_STATE_CLOSING_WAIT4_DELETE;
787 fp->state = BNX2X_FP_STATE_HALTED;
788 break;
789
790 case (RAMROD_CMD_ID_ETH_PORT_DEL | BNX2X_STATE_CLOSING_WAIT4_DELETE):
791 DP(NETIF_MSG_IFDOWN, "got delete ramrod\n");
792 bp->state = BNX2X_STATE_CLOSING_WAIT4_UNLOAD;
793 break;
794
795 case (RAMROD_CMD_ID_ETH_CFC_DEL | BNX2X_STATE_CLOSING_WAIT4_HALT):
796 DP(NETIF_MSG_IFDOWN, "got delete ramrod for MULTI[%d]\n", cid);
797 bnx2x_fp(bp, cid, state) = BNX2X_FP_STATE_DELETED;
798 break;
799
800 case (RAMROD_CMD_ID_ETH_SET_MAC | BNX2X_STATE_OPEN):
801 DP(NETIF_MSG_IFUP, "got set mac ramrod\n");
802 break;
803
804 default:
805 BNX2X_ERR("unexpected ramrod (%d) state is %x\n",
806 command, bp->state);
807 }
808
809 mb(); /* force bnx2x_wait_ramrod to see the change */
810 }
811
812 static inline int bnx2x_alloc_rx_skb(struct bnx2x *bp,
813 struct bnx2x_fastpath *fp, u16 index)
814 {
815 struct sk_buff *skb;
816 struct sw_rx_bd *rx_buf = &fp->rx_buf_ring[index];
817 struct eth_rx_bd *rx_bd = &fp->rx_desc_ring[index];
818 dma_addr_t mapping;
819
820 skb = netdev_alloc_skb(bp->dev, bp->rx_buf_size);
821 if (unlikely(skb == NULL))
822 return -ENOMEM;
823
824 mapping = pci_map_single(bp->pdev, skb->data, bp->rx_buf_use_size,
825 PCI_DMA_FROMDEVICE);
826 if (unlikely(dma_mapping_error(mapping))) {
827
828 dev_kfree_skb(skb);
829 return -ENOMEM;
830 }
831
832 rx_buf->skb = skb;
833 pci_unmap_addr_set(rx_buf, mapping, mapping);
834
835 rx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
836 rx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
837
838 return 0;
839 }
840
841 /* note that we are not allocating a new skb,
842 * we are just moving one from cons to prod
843 * we are not creating a new mapping,
844 * so there is no need to check for dma_mapping_error().
845 */
846 static void bnx2x_reuse_rx_skb(struct bnx2x_fastpath *fp,
847 struct sk_buff *skb, u16 cons, u16 prod)
848 {
849 struct bnx2x *bp = fp->bp;
850 struct sw_rx_bd *cons_rx_buf = &fp->rx_buf_ring[cons];
851 struct sw_rx_bd *prod_rx_buf = &fp->rx_buf_ring[prod];
852 struct eth_rx_bd *cons_bd = &fp->rx_desc_ring[cons];
853 struct eth_rx_bd *prod_bd = &fp->rx_desc_ring[prod];
854
855 pci_dma_sync_single_for_device(bp->pdev,
856 pci_unmap_addr(cons_rx_buf, mapping),
857 bp->rx_offset + RX_COPY_THRESH,
858 PCI_DMA_FROMDEVICE);
859
860 prod_rx_buf->skb = cons_rx_buf->skb;
861 pci_unmap_addr_set(prod_rx_buf, mapping,
862 pci_unmap_addr(cons_rx_buf, mapping));
863 *prod_bd = *cons_bd;
864 }
865
866 static int bnx2x_rx_int(struct bnx2x_fastpath *fp, int budget)
867 {
868 struct bnx2x *bp = fp->bp;
869 u16 bd_cons, bd_prod, comp_ring_cons;
870 u16 hw_comp_cons, sw_comp_cons, sw_comp_prod;
871 int rx_pkt = 0;
872
873 #ifdef BNX2X_STOP_ON_ERROR
874 if (unlikely(bp->panic))
875 return 0;
876 #endif
877
878 hw_comp_cons = le16_to_cpu(*fp->rx_cons_sb);
879 if ((hw_comp_cons & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
880 hw_comp_cons++;
881
882 bd_cons = fp->rx_bd_cons;
883 bd_prod = fp->rx_bd_prod;
884 sw_comp_cons = fp->rx_comp_cons;
885 sw_comp_prod = fp->rx_comp_prod;
886
887 /* Memory barrier necessary as speculative reads of the rx
888 * buffer can be ahead of the index in the status block
889 */
890 rmb();
891
892 DP(NETIF_MSG_RX_STATUS,
893 "queue[%d]: hw_comp_cons %u sw_comp_cons %u\n",
894 fp->index, hw_comp_cons, sw_comp_cons);
895
896 while (sw_comp_cons != hw_comp_cons) {
897 unsigned int len, pad;
898 struct sw_rx_bd *rx_buf;
899 struct sk_buff *skb;
900 union eth_rx_cqe *cqe;
901
902 comp_ring_cons = RCQ_BD(sw_comp_cons);
903 bd_prod = RX_BD(bd_prod);
904 bd_cons = RX_BD(bd_cons);
905
906 cqe = &fp->rx_comp_ring[comp_ring_cons];
907
908 DP(NETIF_MSG_RX_STATUS, "hw_comp_cons %u sw_comp_cons %u"
909 " comp_ring (%u) bd_ring (%u,%u)\n",
910 hw_comp_cons, sw_comp_cons,
911 comp_ring_cons, bd_prod, bd_cons);
912 DP(NETIF_MSG_RX_STATUS, "CQE type %x err %x status %x"
913 " queue %x vlan %x len %x\n",
914 cqe->fast_path_cqe.type,
915 cqe->fast_path_cqe.error_type_flags,
916 cqe->fast_path_cqe.status_flags,
917 cqe->fast_path_cqe.rss_hash_result,
918 cqe->fast_path_cqe.vlan_tag, cqe->fast_path_cqe.pkt_len);
919
920 /* is this a slowpath msg? */
921 if (unlikely(cqe->fast_path_cqe.type)) {
922 bnx2x_sp_event(fp, cqe);
923 goto next_cqe;
924
925 /* this is an rx packet */
926 } else {
927 rx_buf = &fp->rx_buf_ring[bd_cons];
928 skb = rx_buf->skb;
929
930 len = le16_to_cpu(cqe->fast_path_cqe.pkt_len);
931 pad = cqe->fast_path_cqe.placement_offset;
932
933 pci_dma_sync_single_for_device(bp->pdev,
934 pci_unmap_addr(rx_buf, mapping),
935 pad + RX_COPY_THRESH,
936 PCI_DMA_FROMDEVICE);
937 prefetch(skb);
938 prefetch(((char *)(skb)) + 128);
939
940 /* is this an error packet? */
941 if (unlikely(cqe->fast_path_cqe.error_type_flags &
942 ETH_RX_ERROR_FALGS)) {
943 /* do we sometimes forward error packets anyway? */
944 DP(NETIF_MSG_RX_ERR,
945 "ERROR flags(%u) Rx packet(%u)\n",
946 cqe->fast_path_cqe.error_type_flags,
947 sw_comp_cons);
948 /* TBD make sure MC counts this as a drop */
949 goto reuse_rx;
950 }
951
952 /* Since we don't have a jumbo ring
953 * copy small packets if mtu > 1500
954 */
955 if ((bp->dev->mtu > ETH_MAX_PACKET_SIZE) &&
956 (len <= RX_COPY_THRESH)) {
957 struct sk_buff *new_skb;
958
959 new_skb = netdev_alloc_skb(bp->dev,
960 len + pad);
961 if (new_skb == NULL) {
962 DP(NETIF_MSG_RX_ERR,
963 "ERROR packet dropped "
964 "because of alloc failure\n");
965 /* TBD count this as a drop? */
966 goto reuse_rx;
967 }
968
969 /* aligned copy */
970 skb_copy_from_linear_data_offset(skb, pad,
971 new_skb->data + pad, len);
972 skb_reserve(new_skb, pad);
973 skb_put(new_skb, len);
974
975 bnx2x_reuse_rx_skb(fp, skb, bd_cons, bd_prod);
976
977 skb = new_skb;
978
979 } else if (bnx2x_alloc_rx_skb(bp, fp, bd_prod) == 0) {
980 pci_unmap_single(bp->pdev,
981 pci_unmap_addr(rx_buf, mapping),
982 bp->rx_buf_use_size,
983 PCI_DMA_FROMDEVICE);
984 skb_reserve(skb, pad);
985 skb_put(skb, len);
986
987 } else {
988 DP(NETIF_MSG_RX_ERR,
989 "ERROR packet dropped because "
990 "of alloc failure\n");
991 reuse_rx:
992 bnx2x_reuse_rx_skb(fp, skb, bd_cons, bd_prod);
993 goto next_rx;
994 }
995
996 skb->protocol = eth_type_trans(skb, bp->dev);
997
998 skb->ip_summed = CHECKSUM_NONE;
999 if (bp->rx_csum && BNX2X_RX_SUM_OK(cqe))
1000 skb->ip_summed = CHECKSUM_UNNECESSARY;
1001
1002 /* TBD do we pass bad csum packets in promisc */
1003 }
1004
1005 #ifdef BCM_VLAN
1006 if ((le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags)
1007 & PARSING_FLAGS_NUMBER_OF_NESTED_VLANS)
1008 && (bp->vlgrp != NULL))
1009 vlan_hwaccel_receive_skb(skb, bp->vlgrp,
1010 le16_to_cpu(cqe->fast_path_cqe.vlan_tag));
1011 else
1012 #endif
1013 netif_receive_skb(skb);
1014
1015 bp->dev->last_rx = jiffies;
1016
1017 next_rx:
1018 rx_buf->skb = NULL;
1019
1020 bd_cons = NEXT_RX_IDX(bd_cons);
1021 bd_prod = NEXT_RX_IDX(bd_prod);
1022 next_cqe:
1023 sw_comp_prod = NEXT_RCQ_IDX(sw_comp_prod);
1024 sw_comp_cons = NEXT_RCQ_IDX(sw_comp_cons);
1025 rx_pkt++;
1026
1027 if ((rx_pkt == budget))
1028 break;
1029 } /* while */
1030
1031 fp->rx_bd_cons = bd_cons;
1032 fp->rx_bd_prod = bd_prod;
1033 fp->rx_comp_cons = sw_comp_cons;
1034 fp->rx_comp_prod = sw_comp_prod;
1035
1036 REG_WR(bp, BAR_TSTRORM_INTMEM +
1037 TSTORM_RCQ_PROD_OFFSET(bp->port, fp->index), sw_comp_prod);
1038
1039 mmiowb(); /* keep prod updates ordered */
1040
1041 fp->rx_pkt += rx_pkt;
1042 fp->rx_calls++;
1043
1044 return rx_pkt;
1045 }
1046
1047 static irqreturn_t bnx2x_msix_fp_int(int irq, void *fp_cookie)
1048 {
1049 struct bnx2x_fastpath *fp = fp_cookie;
1050 struct bnx2x *bp = fp->bp;
1051 struct net_device *dev = bp->dev;
1052 int index = fp->index;
1053
1054 DP(NETIF_MSG_INTR, "got an msix interrupt on [%d]\n", index);
1055 bnx2x_ack_sb(bp, index, USTORM_ID, 0, IGU_INT_DISABLE, 0);
1056
1057 #ifdef BNX2X_STOP_ON_ERROR
1058 if (unlikely(bp->panic))
1059 return IRQ_HANDLED;
1060 #endif
1061
1062 prefetch(fp->rx_cons_sb);
1063 prefetch(fp->tx_cons_sb);
1064 prefetch(&fp->status_blk->c_status_block.status_block_index);
1065 prefetch(&fp->status_blk->u_status_block.status_block_index);
1066
1067 netif_rx_schedule(dev, &bnx2x_fp(bp, index, napi));
1068 return IRQ_HANDLED;
1069 }
1070
1071 static irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
1072 {
1073 struct net_device *dev = dev_instance;
1074 struct bnx2x *bp = netdev_priv(dev);
1075 u16 status = bnx2x_ack_int(bp);
1076
1077 if (unlikely(status == 0)) {
1078 DP(NETIF_MSG_INTR, "not our interrupt!\n");
1079 return IRQ_NONE;
1080 }
1081
1082 DP(NETIF_MSG_INTR, "got an interrupt status is %u\n", status);
1083
1084 #ifdef BNX2X_STOP_ON_ERROR
1085 if (unlikely(bp->panic))
1086 return IRQ_HANDLED;
1087 #endif
1088
1089 /* Return here if interrupt is shared and is disabled */
1090 if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
1091 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
1092 return IRQ_HANDLED;
1093 }
1094
1095 if (status & 0x2) {
1096 struct bnx2x_fastpath *fp = &bp->fp[0];
1097
1098 prefetch(fp->rx_cons_sb);
1099 prefetch(fp->tx_cons_sb);
1100 prefetch(&fp->status_blk->c_status_block.status_block_index);
1101 prefetch(&fp->status_blk->u_status_block.status_block_index);
1102
1103 netif_rx_schedule(dev, &bnx2x_fp(bp, 0, napi));
1104
1105 status &= ~0x2;
1106 if (!status)
1107 return IRQ_HANDLED;
1108 }
1109
1110 if (unlikely(status & 0x1)) {
1111
1112 schedule_work(&bp->sp_task);
1113
1114 status &= ~0x1;
1115 if (!status)
1116 return IRQ_HANDLED;
1117 }
1118
1119 DP(NETIF_MSG_INTR, "got an unknown interrupt! (status is %u)\n",
1120 status);
1121
1122 return IRQ_HANDLED;
1123 }
1124
1125 /* end of fast path */
1126
1127 /* PHY/MAC */
1128
1129 /*
1130 * General service functions
1131 */
1132
1133 static void bnx2x_leds_set(struct bnx2x *bp, unsigned int speed)
1134 {
1135 int port = bp->port;
1136
1137 NIG_WR(NIG_REG_LED_MODE_P0 + port*4,
1138 ((bp->hw_config & SHARED_HW_CFG_LED_MODE_MASK) >>
1139 SHARED_HW_CFG_LED_MODE_SHIFT));
1140 NIG_WR(NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0 + port*4, 0);
1141
1142 /* Set blinking rate to ~15.9Hz */
1143 NIG_WR(NIG_REG_LED_CONTROL_BLINK_RATE_P0 + port*4,
1144 LED_BLINK_RATE_VAL);
1145 NIG_WR(NIG_REG_LED_CONTROL_BLINK_RATE_ENA_P0 + port*4, 1);
1146
1147 /* On Ax chip versions for speeds less than 10G
1148 LED scheme is different */
1149 if ((CHIP_REV(bp) == CHIP_REV_Ax) && (speed < SPEED_10000)) {
1150 NIG_WR(NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0 + port*4, 1);
1151 NIG_WR(NIG_REG_LED_CONTROL_TRAFFIC_P0 + port*4, 0);
1152 NIG_WR(NIG_REG_LED_CONTROL_BLINK_TRAFFIC_P0 + port*4, 1);
1153 }
1154 }
1155
1156 static void bnx2x_leds_unset(struct bnx2x *bp)
1157 {
1158 int port = bp->port;
1159
1160 NIG_WR(NIG_REG_LED_10G_P0 + port*4, 0);
1161 NIG_WR(NIG_REG_LED_MODE_P0 + port*4, SHARED_HW_CFG_LED_MAC1);
1162 }
1163
1164 static u32 bnx2x_bits_en(struct bnx2x *bp, u32 reg, u32 bits)
1165 {
1166 u32 val = REG_RD(bp, reg);
1167
1168 val |= bits;
1169 REG_WR(bp, reg, val);
1170 return val;
1171 }
1172
1173 static u32 bnx2x_bits_dis(struct bnx2x *bp, u32 reg, u32 bits)
1174 {
1175 u32 val = REG_RD(bp, reg);
1176
1177 val &= ~bits;
1178 REG_WR(bp, reg, val);
1179 return val;
1180 }
1181
1182 static int bnx2x_mdio22_write(struct bnx2x *bp, u32 reg, u32 val)
1183 {
1184 int rc;
1185 u32 tmp, i;
1186 int port = bp->port;
1187 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
1188
1189 /* DP(NETIF_MSG_HW, "phy_addr 0x%x reg 0x%x val 0x%08x\n",
1190 bp->phy_addr, reg, val); */
1191
1192 if (bp->phy_flags & PHY_INT_MODE_AUTO_POLLING_FLAG) {
1193
1194 tmp = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1195 tmp &= ~EMAC_MDIO_MODE_AUTO_POLL;
1196 EMAC_WR(EMAC_REG_EMAC_MDIO_MODE, tmp);
1197 REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1198 udelay(40);
1199 }
1200
1201 tmp = ((bp->phy_addr << 21) | (reg << 16) |
1202 (val & EMAC_MDIO_COMM_DATA) |
1203 EMAC_MDIO_COMM_COMMAND_WRITE_22 |
1204 EMAC_MDIO_COMM_START_BUSY);
1205 EMAC_WR(EMAC_REG_EMAC_MDIO_COMM, tmp);
1206
1207 for (i = 0; i < 50; i++) {
1208 udelay(10);
1209
1210 tmp = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_COMM);
1211 if (!(tmp & EMAC_MDIO_COMM_START_BUSY)) {
1212 udelay(5);
1213 break;
1214 }
1215 }
1216
1217 if (tmp & EMAC_MDIO_COMM_START_BUSY) {
1218 BNX2X_ERR("write phy register failed\n");
1219
1220 rc = -EBUSY;
1221 } else {
1222 rc = 0;
1223 }
1224
1225 if (bp->phy_flags & PHY_INT_MODE_AUTO_POLLING_FLAG) {
1226
1227 tmp = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1228 tmp |= EMAC_MDIO_MODE_AUTO_POLL;
1229 EMAC_WR(EMAC_REG_EMAC_MDIO_MODE, tmp);
1230 }
1231
1232 return rc;
1233 }
1234
1235 static int bnx2x_mdio22_read(struct bnx2x *bp, u32 reg, u32 *ret_val)
1236 {
1237 int port = bp->port;
1238 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
1239 u32 val, i;
1240 int rc;
1241
1242 if (bp->phy_flags & PHY_INT_MODE_AUTO_POLLING_FLAG) {
1243
1244 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1245 val &= ~EMAC_MDIO_MODE_AUTO_POLL;
1246 EMAC_WR(EMAC_REG_EMAC_MDIO_MODE, val);
1247 REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1248 udelay(40);
1249 }
1250
1251 val = ((bp->phy_addr << 21) | (reg << 16) |
1252 EMAC_MDIO_COMM_COMMAND_READ_22 |
1253 EMAC_MDIO_COMM_START_BUSY);
1254 EMAC_WR(EMAC_REG_EMAC_MDIO_COMM, val);
1255
1256 for (i = 0; i < 50; i++) {
1257 udelay(10);
1258
1259 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_COMM);
1260 if (!(val & EMAC_MDIO_COMM_START_BUSY)) {
1261 val &= EMAC_MDIO_COMM_DATA;
1262 break;
1263 }
1264 }
1265
1266 if (val & EMAC_MDIO_COMM_START_BUSY) {
1267 BNX2X_ERR("read phy register failed\n");
1268
1269 *ret_val = 0x0;
1270 rc = -EBUSY;
1271 } else {
1272 *ret_val = val;
1273 rc = 0;
1274 }
1275
1276 if (bp->phy_flags & PHY_INT_MODE_AUTO_POLLING_FLAG) {
1277
1278 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1279 val |= EMAC_MDIO_MODE_AUTO_POLL;
1280 EMAC_WR(EMAC_REG_EMAC_MDIO_MODE, val);
1281 }
1282
1283 /* DP(NETIF_MSG_HW, "phy_addr 0x%x reg 0x%x ret_val 0x%08x\n",
1284 bp->phy_addr, reg, *ret_val); */
1285
1286 return rc;
1287 }
1288
1289 static int bnx2x_mdio45_write(struct bnx2x *bp, u32 reg, u32 addr, u32 val)
1290 {
1291 int rc = 0;
1292 u32 tmp, i;
1293 int port = bp->port;
1294 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
1295
1296 if (bp->phy_flags & PHY_INT_MODE_AUTO_POLLING_FLAG) {
1297
1298 tmp = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1299 tmp &= ~EMAC_MDIO_MODE_AUTO_POLL;
1300 EMAC_WR(EMAC_REG_EMAC_MDIO_MODE, tmp);
1301 REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1302 udelay(40);
1303 }
1304
1305 /* set clause 45 mode */
1306 tmp = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1307 tmp |= EMAC_MDIO_MODE_CLAUSE_45;
1308 EMAC_WR(EMAC_REG_EMAC_MDIO_MODE, tmp);
1309
1310 /* address */
1311 tmp = ((bp->phy_addr << 21) | (reg << 16) | addr |
1312 EMAC_MDIO_COMM_COMMAND_ADDRESS |
1313 EMAC_MDIO_COMM_START_BUSY);
1314 EMAC_WR(EMAC_REG_EMAC_MDIO_COMM, tmp);
1315
1316 for (i = 0; i < 50; i++) {
1317 udelay(10);
1318
1319 tmp = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_COMM);
1320 if (!(tmp & EMAC_MDIO_COMM_START_BUSY)) {
1321 udelay(5);
1322 break;
1323 }
1324 }
1325
1326 if (tmp & EMAC_MDIO_COMM_START_BUSY) {
1327 BNX2X_ERR("write phy register failed\n");
1328
1329 rc = -EBUSY;
1330 } else {
1331 /* data */
1332 tmp = ((bp->phy_addr << 21) | (reg << 16) | val |
1333 EMAC_MDIO_COMM_COMMAND_WRITE_45 |
1334 EMAC_MDIO_COMM_START_BUSY);
1335 EMAC_WR(EMAC_REG_EMAC_MDIO_COMM, tmp);
1336
1337 for (i = 0; i < 50; i++) {
1338 udelay(10);
1339
1340 tmp = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_COMM);
1341 if (!(tmp & EMAC_MDIO_COMM_START_BUSY)) {
1342 udelay(5);
1343 break;
1344 }
1345 }
1346
1347 if (tmp & EMAC_MDIO_COMM_START_BUSY) {
1348 BNX2X_ERR("write phy register failed\n");
1349
1350 rc = -EBUSY;
1351 }
1352 }
1353
1354 /* unset clause 45 mode */
1355 tmp = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1356 tmp &= ~EMAC_MDIO_MODE_CLAUSE_45;
1357 EMAC_WR(EMAC_REG_EMAC_MDIO_MODE, tmp);
1358
1359 if (bp->phy_flags & PHY_INT_MODE_AUTO_POLLING_FLAG) {
1360
1361 tmp = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1362 tmp |= EMAC_MDIO_MODE_AUTO_POLL;
1363 EMAC_WR(EMAC_REG_EMAC_MDIO_MODE, tmp);
1364 }
1365
1366 return rc;
1367 }
1368
1369 static int bnx2x_mdio45_read(struct bnx2x *bp, u32 reg, u32 addr,
1370 u32 *ret_val)
1371 {
1372 int port = bp->port;
1373 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
1374 u32 val, i;
1375 int rc = 0;
1376
1377 if (bp->phy_flags & PHY_INT_MODE_AUTO_POLLING_FLAG) {
1378
1379 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1380 val &= ~EMAC_MDIO_MODE_AUTO_POLL;
1381 EMAC_WR(EMAC_REG_EMAC_MDIO_MODE, val);
1382 REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1383 udelay(40);
1384 }
1385
1386 /* set clause 45 mode */
1387 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1388 val |= EMAC_MDIO_MODE_CLAUSE_45;
1389 EMAC_WR(EMAC_REG_EMAC_MDIO_MODE, val);
1390
1391 /* address */
1392 val = ((bp->phy_addr << 21) | (reg << 16) | addr |
1393 EMAC_MDIO_COMM_COMMAND_ADDRESS |
1394 EMAC_MDIO_COMM_START_BUSY);
1395 EMAC_WR(EMAC_REG_EMAC_MDIO_COMM, val);
1396
1397 for (i = 0; i < 50; i++) {
1398 udelay(10);
1399
1400 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_COMM);
1401 if (!(val & EMAC_MDIO_COMM_START_BUSY)) {
1402 udelay(5);
1403 break;
1404 }
1405 }
1406
1407 if (val & EMAC_MDIO_COMM_START_BUSY) {
1408 BNX2X_ERR("read phy register failed\n");
1409
1410 *ret_val = 0;
1411 rc = -EBUSY;
1412 } else {
1413 /* data */
1414 val = ((bp->phy_addr << 21) | (reg << 16) |
1415 EMAC_MDIO_COMM_COMMAND_READ_45 |
1416 EMAC_MDIO_COMM_START_BUSY);
1417 EMAC_WR(EMAC_REG_EMAC_MDIO_COMM, val);
1418
1419 for (i = 0; i < 50; i++) {
1420 udelay(10);
1421
1422 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_COMM);
1423 if (!(val & EMAC_MDIO_COMM_START_BUSY)) {
1424 val &= EMAC_MDIO_COMM_DATA;
1425 break;
1426 }
1427 }
1428
1429 if (val & EMAC_MDIO_COMM_START_BUSY) {
1430 BNX2X_ERR("read phy register failed\n");
1431
1432 val = 0;
1433 rc = -EBUSY;
1434 }
1435
1436 *ret_val = val;
1437 }
1438
1439 /* unset clause 45 mode */
1440 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1441 val &= ~EMAC_MDIO_MODE_CLAUSE_45;
1442 EMAC_WR(EMAC_REG_EMAC_MDIO_MODE, val);
1443
1444 if (bp->phy_flags & PHY_INT_MODE_AUTO_POLLING_FLAG) {
1445
1446 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MDIO_MODE);
1447 val |= EMAC_MDIO_MODE_AUTO_POLL;
1448 EMAC_WR(EMAC_REG_EMAC_MDIO_MODE, val);
1449 }
1450
1451 return rc;
1452 }
1453
1454 static int bnx2x_mdio45_vwrite(struct bnx2x *bp, u32 reg, u32 addr, u32 val)
1455 {
1456 int i;
1457 u32 rd_val;
1458
1459 might_sleep();
1460 for (i = 0; i < 10; i++) {
1461 bnx2x_mdio45_write(bp, reg, addr, val);
1462 msleep(5);
1463 bnx2x_mdio45_read(bp, reg, addr, &rd_val);
1464 /* if the read value is not the same as the value we wrote,
1465 we should write it again */
1466 if (rd_val == val)
1467 return 0;
1468 }
1469 BNX2X_ERR("MDIO write in CL45 failed\n");
1470 return -EBUSY;
1471 }
1472
1473 /*
1474 * link managment
1475 */
1476
1477 static void bnx2x_flow_ctrl_resolve(struct bnx2x *bp, u32 gp_status)
1478 {
1479 u32 ld_pause; /* local driver */
1480 u32 lp_pause; /* link partner */
1481 u32 pause_result;
1482
1483 bp->flow_ctrl = 0;
1484
1485 /* reolve from gp_status in case of AN complete and not sgmii */
1486 if ((bp->req_autoneg & AUTONEG_FLOW_CTRL) &&
1487 (gp_status & MDIO_AN_CL73_OR_37_COMPLETE) &&
1488 (!(bp->phy_flags & PHY_SGMII_FLAG)) &&
1489 (XGXS_EXT_PHY_TYPE(bp) == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT)) {
1490
1491 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_COMBO_IEEE0);
1492 bnx2x_mdio22_read(bp, MDIO_COMBO_IEEE0_AUTO_NEG_ADV,
1493 &ld_pause);
1494 bnx2x_mdio22_read(bp,
1495 MDIO_COMBO_IEEE0_AUTO_NEG_LINK_PARTNER_ABILITY1,
1496 &lp_pause);
1497 pause_result = (ld_pause &
1498 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK)>>5;
1499 pause_result |= (lp_pause &
1500 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK)>>7;
1501 DP(NETIF_MSG_LINK, "pause_result 0x%x\n", pause_result);
1502
1503 switch (pause_result) { /* ASYM P ASYM P */
1504 case 0xb: /* 1 0 1 1 */
1505 bp->flow_ctrl = FLOW_CTRL_TX;
1506 break;
1507
1508 case 0xe: /* 1 1 1 0 */
1509 bp->flow_ctrl = FLOW_CTRL_RX;
1510 break;
1511
1512 case 0x5: /* 0 1 0 1 */
1513 case 0x7: /* 0 1 1 1 */
1514 case 0xd: /* 1 1 0 1 */
1515 case 0xf: /* 1 1 1 1 */
1516 bp->flow_ctrl = FLOW_CTRL_BOTH;
1517 break;
1518
1519 default:
1520 break;
1521 }
1522
1523 } else { /* forced mode */
1524 switch (bp->req_flow_ctrl) {
1525 case FLOW_CTRL_AUTO:
1526 if (bp->dev->mtu <= 4500)
1527 bp->flow_ctrl = FLOW_CTRL_BOTH;
1528 else
1529 bp->flow_ctrl = FLOW_CTRL_TX;
1530 break;
1531
1532 case FLOW_CTRL_TX:
1533 case FLOW_CTRL_RX:
1534 case FLOW_CTRL_BOTH:
1535 bp->flow_ctrl = bp->req_flow_ctrl;
1536 break;
1537
1538 case FLOW_CTRL_NONE:
1539 default:
1540 break;
1541 }
1542 }
1543 DP(NETIF_MSG_LINK, "flow_ctrl 0x%x\n", bp->flow_ctrl);
1544 }
1545
1546 static void bnx2x_link_settings_status(struct bnx2x *bp, u32 gp_status)
1547 {
1548 bp->link_status = 0;
1549
1550 if (gp_status & MDIO_GP_STATUS_TOP_AN_STATUS1_LINK_STATUS) {
1551 DP(NETIF_MSG_LINK, "link up\n");
1552
1553 bp->link_up = 1;
1554 bp->link_status |= LINK_STATUS_LINK_UP;
1555
1556 if (gp_status & MDIO_GP_STATUS_TOP_AN_STATUS1_DUPLEX_STATUS)
1557 bp->duplex = DUPLEX_FULL;
1558 else
1559 bp->duplex = DUPLEX_HALF;
1560
1561 bnx2x_flow_ctrl_resolve(bp, gp_status);
1562
1563 switch (gp_status & GP_STATUS_SPEED_MASK) {
1564 case GP_STATUS_10M:
1565 bp->line_speed = SPEED_10;
1566 if (bp->duplex == DUPLEX_FULL)
1567 bp->link_status |= LINK_10TFD;
1568 else
1569 bp->link_status |= LINK_10THD;
1570 break;
1571
1572 case GP_STATUS_100M:
1573 bp->line_speed = SPEED_100;
1574 if (bp->duplex == DUPLEX_FULL)
1575 bp->link_status |= LINK_100TXFD;
1576 else
1577 bp->link_status |= LINK_100TXHD;
1578 break;
1579
1580 case GP_STATUS_1G:
1581 case GP_STATUS_1G_KX:
1582 bp->line_speed = SPEED_1000;
1583 if (bp->duplex == DUPLEX_FULL)
1584 bp->link_status |= LINK_1000TFD;
1585 else
1586 bp->link_status |= LINK_1000THD;
1587 break;
1588
1589 case GP_STATUS_2_5G:
1590 bp->line_speed = SPEED_2500;
1591 if (bp->duplex == DUPLEX_FULL)
1592 bp->link_status |= LINK_2500TFD;
1593 else
1594 bp->link_status |= LINK_2500THD;
1595 break;
1596
1597 case GP_STATUS_5G:
1598 case GP_STATUS_6G:
1599 BNX2X_ERR("link speed unsupported gp_status 0x%x\n",
1600 gp_status);
1601 break;
1602
1603 case GP_STATUS_10G_KX4:
1604 case GP_STATUS_10G_HIG:
1605 case GP_STATUS_10G_CX4:
1606 bp->line_speed = SPEED_10000;
1607 bp->link_status |= LINK_10GTFD;
1608 break;
1609
1610 case GP_STATUS_12G_HIG:
1611 bp->line_speed = SPEED_12000;
1612 bp->link_status |= LINK_12GTFD;
1613 break;
1614
1615 case GP_STATUS_12_5G:
1616 bp->line_speed = SPEED_12500;
1617 bp->link_status |= LINK_12_5GTFD;
1618 break;
1619
1620 case GP_STATUS_13G:
1621 bp->line_speed = SPEED_13000;
1622 bp->link_status |= LINK_13GTFD;
1623 break;
1624
1625 case GP_STATUS_15G:
1626 bp->line_speed = SPEED_15000;
1627 bp->link_status |= LINK_15GTFD;
1628 break;
1629
1630 case GP_STATUS_16G:
1631 bp->line_speed = SPEED_16000;
1632 bp->link_status |= LINK_16GTFD;
1633 break;
1634
1635 default:
1636 BNX2X_ERR("link speed unsupported gp_status 0x%x\n",
1637 gp_status);
1638 break;
1639 }
1640
1641 bp->link_status |= LINK_STATUS_SERDES_LINK;
1642
1643 if (bp->req_autoneg & AUTONEG_SPEED) {
1644 bp->link_status |= LINK_STATUS_AUTO_NEGOTIATE_ENABLED;
1645
1646 if (gp_status & MDIO_AN_CL73_OR_37_COMPLETE)
1647 bp->link_status |=
1648 LINK_STATUS_AUTO_NEGOTIATE_COMPLETE;
1649
1650 if (bp->autoneg & AUTONEG_PARALLEL)
1651 bp->link_status |=
1652 LINK_STATUS_PARALLEL_DETECTION_USED;
1653 }
1654
1655 if (bp->flow_ctrl & FLOW_CTRL_TX)
1656 bp->link_status |= LINK_STATUS_TX_FLOW_CONTROL_ENABLED;
1657
1658 if (bp->flow_ctrl & FLOW_CTRL_RX)
1659 bp->link_status |= LINK_STATUS_RX_FLOW_CONTROL_ENABLED;
1660
1661 } else { /* link_down */
1662 DP(NETIF_MSG_LINK, "link down\n");
1663
1664 bp->link_up = 0;
1665
1666 bp->line_speed = 0;
1667 bp->duplex = DUPLEX_FULL;
1668 bp->flow_ctrl = 0;
1669 }
1670
1671 DP(NETIF_MSG_LINK, "gp_status 0x%x link_up %d\n"
1672 DP_LEVEL " line_speed %d duplex %d flow_ctrl 0x%x"
1673 " link_status 0x%x\n",
1674 gp_status, bp->link_up, bp->line_speed, bp->duplex, bp->flow_ctrl,
1675 bp->link_status);
1676 }
1677
1678 static void bnx2x_link_int_ack(struct bnx2x *bp, int is_10g)
1679 {
1680 int port = bp->port;
1681
1682 /* first reset all status
1683 * we asume only one line will be change at a time */
1684 bnx2x_bits_dis(bp, NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
1685 (NIG_XGXS0_LINK_STATUS |
1686 NIG_SERDES0_LINK_STATUS |
1687 NIG_STATUS_INTERRUPT_XGXS0_LINK10G));
1688 if (bp->link_up) {
1689 if (is_10g) {
1690 /* Disable the 10G link interrupt
1691 * by writing 1 to the status register
1692 */
1693 DP(NETIF_MSG_LINK, "10G XGXS link up\n");
1694 bnx2x_bits_en(bp,
1695 NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
1696 NIG_STATUS_INTERRUPT_XGXS0_LINK10G);
1697
1698 } else if (bp->phy_flags & PHY_XGXS_FLAG) {
1699 /* Disable the link interrupt
1700 * by writing 1 to the relevant lane
1701 * in the status register
1702 */
1703 DP(NETIF_MSG_LINK, "1G XGXS link up\n");
1704 bnx2x_bits_en(bp,
1705 NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
1706 ((1 << bp->ser_lane) <<
1707 NIG_XGXS0_LINK_STATUS_SIZE));
1708
1709 } else { /* SerDes */
1710 DP(NETIF_MSG_LINK, "SerDes link up\n");
1711 /* Disable the link interrupt
1712 * by writing 1 to the status register
1713 */
1714 bnx2x_bits_en(bp,
1715 NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
1716 NIG_SERDES0_LINK_STATUS);
1717 }
1718
1719 } else { /* link_down */
1720 }
1721 }
1722
1723 static int bnx2x_ext_phy_is_link_up(struct bnx2x *bp)
1724 {
1725 u32 ext_phy_type;
1726 u32 ext_phy_addr;
1727 u32 local_phy;
1728 u32 val = 0;
1729 u32 rx_sd, pcs_status;
1730
1731 if (bp->phy_flags & PHY_XGXS_FLAG) {
1732 local_phy = bp->phy_addr;
1733 ext_phy_addr = ((bp->ext_phy_config &
1734 PORT_HW_CFG_XGXS_EXT_PHY_ADDR_MASK) >>
1735 PORT_HW_CFG_XGXS_EXT_PHY_ADDR_SHIFT);
1736 bp->phy_addr = (u8)ext_phy_addr;
1737
1738 ext_phy_type = XGXS_EXT_PHY_TYPE(bp);
1739 switch (ext_phy_type) {
1740 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
1741 DP(NETIF_MSG_LINK, "XGXS Direct\n");
1742 val = 1;
1743 break;
1744
1745 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
1746 DP(NETIF_MSG_LINK, "XGXS 8705\n");
1747 bnx2x_mdio45_read(bp, EXT_PHY_OPT_WIS_DEVAD,
1748 EXT_PHY_OPT_LASI_STATUS, &val);
1749 DP(NETIF_MSG_LINK, "8705 LASI status is %d\n", val);
1750
1751 bnx2x_mdio45_read(bp, EXT_PHY_OPT_WIS_DEVAD,
1752 EXT_PHY_OPT_LASI_STATUS, &val);
1753 DP(NETIF_MSG_LINK, "8705 LASI status is %d\n", val);
1754
1755 bnx2x_mdio45_read(bp, EXT_PHY_OPT_PMA_PMD_DEVAD,
1756 EXT_PHY_OPT_PMD_RX_SD, &rx_sd);
1757 val = (rx_sd & 0x1);
1758 break;
1759
1760 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
1761 DP(NETIF_MSG_LINK, "XGXS 8706\n");
1762 bnx2x_mdio45_read(bp, EXT_PHY_OPT_PMA_PMD_DEVAD,
1763 EXT_PHY_OPT_LASI_STATUS, &val);
1764 DP(NETIF_MSG_LINK, "8706 LASI status is %d\n", val);
1765
1766 bnx2x_mdio45_read(bp, EXT_PHY_OPT_PMA_PMD_DEVAD,
1767 EXT_PHY_OPT_LASI_STATUS, &val);
1768 DP(NETIF_MSG_LINK, "8706 LASI status is %d\n", val);
1769
1770 bnx2x_mdio45_read(bp, EXT_PHY_OPT_PMA_PMD_DEVAD,
1771 EXT_PHY_OPT_PMD_RX_SD, &rx_sd);
1772 bnx2x_mdio45_read(bp, EXT_PHY_OPT_PCS_DEVAD,
1773 EXT_PHY_OPT_PCS_STATUS, &pcs_status);
1774 DP(NETIF_MSG_LINK, "8706 rx_sd 0x%x"
1775 " pcs_status 0x%x\n", rx_sd, pcs_status);
1776 /* link is up if both bit 0 of pmd_rx and
1777 * bit 0 of pcs_status are set
1778 */
1779 val = (rx_sd & pcs_status);
1780 break;
1781
1782 default:
1783 DP(NETIF_MSG_LINK, "BAD XGXS ext_phy_config 0x%x\n",
1784 bp->ext_phy_config);
1785 val = 0;
1786 break;
1787 }
1788 bp->phy_addr = local_phy;
1789
1790 } else { /* SerDes */
1791 ext_phy_type = SERDES_EXT_PHY_TYPE(bp);
1792 switch (ext_phy_type) {
1793 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT:
1794 DP(NETIF_MSG_LINK, "SerDes Direct\n");
1795 val = 1;
1796 break;
1797
1798 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482:
1799 DP(NETIF_MSG_LINK, "SerDes 5482\n");
1800 val = 1;
1801 break;
1802
1803 default:
1804 DP(NETIF_MSG_LINK, "BAD SerDes ext_phy_config 0x%x\n",
1805 bp->ext_phy_config);
1806 val = 0;
1807 break;
1808 }
1809 }
1810
1811 return val;
1812 }
1813
1814 static void bnx2x_bmac_enable(struct bnx2x *bp, int is_lb)
1815 {
1816 int port = bp->port;
1817 u32 bmac_addr = port ? NIG_REG_INGRESS_BMAC1_MEM :
1818 NIG_REG_INGRESS_BMAC0_MEM;
1819 u32 wb_write[2];
1820 u32 val;
1821
1822 DP(NETIF_MSG_LINK, "enableing BigMAC\n");
1823 /* reset and unreset the BigMac */
1824 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
1825 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
1826 msleep(5);
1827 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
1828 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
1829
1830 /* enable access for bmac registers */
1831 NIG_WR(NIG_REG_BMAC0_REGS_OUT_EN + port*4, 0x1);
1832
1833 /* XGXS control */
1834 wb_write[0] = 0x3c;
1835 wb_write[1] = 0;
1836 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_BMAC_XGXS_CONTROL,
1837 wb_write, 2);
1838
1839 /* tx MAC SA */
1840 wb_write[0] = ((bp->dev->dev_addr[2] << 24) |
1841 (bp->dev->dev_addr[3] << 16) |
1842 (bp->dev->dev_addr[4] << 8) |
1843 bp->dev->dev_addr[5]);
1844 wb_write[1] = ((bp->dev->dev_addr[0] << 8) |
1845 bp->dev->dev_addr[1]);
1846 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_TX_SOURCE_ADDR,
1847 wb_write, 2);
1848
1849 /* tx control */
1850 val = 0xc0;
1851 if (bp->flow_ctrl & FLOW_CTRL_TX)
1852 val |= 0x800000;
1853 wb_write[0] = val;
1854 wb_write[1] = 0;
1855 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_TX_CONTROL, wb_write, 2);
1856
1857 /* set tx mtu */
1858 wb_write[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD; /* -CRC */
1859 wb_write[1] = 0;
1860 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_TX_MAX_SIZE, wb_write, 2);
1861
1862 /* mac control */
1863 val = 0x3;
1864 if (is_lb) {
1865 val |= 0x4;
1866 DP(NETIF_MSG_LINK, "enable bmac loopback\n");
1867 }
1868 wb_write[0] = val;
1869 wb_write[1] = 0;
1870 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_BMAC_CONTROL,
1871 wb_write, 2);
1872
1873 /* rx control set to don't strip crc */
1874 val = 0x14;
1875 if (bp->flow_ctrl & FLOW_CTRL_RX)
1876 val |= 0x20;
1877 wb_write[0] = val;
1878 wb_write[1] = 0;
1879 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_RX_CONTROL, wb_write, 2);
1880
1881 /* set rx mtu */
1882 wb_write[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD;
1883 wb_write[1] = 0;
1884 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_RX_MAX_SIZE, wb_write, 2);
1885
1886 /* set cnt max size */
1887 wb_write[0] = ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD; /* -VLAN */
1888 wb_write[1] = 0;
1889 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_CNT_MAX_SIZE,
1890 wb_write, 2);
1891
1892 /* configure safc */
1893 wb_write[0] = 0x1000200;
1894 wb_write[1] = 0;
1895 REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_RX_LLFC_MSG_FLDS,
1896 wb_write, 2);
1897
1898 /* fix for emulation */
1899 if (CHIP_REV(bp) == CHIP_REV_EMUL) {
1900 wb_write[0] = 0xf000;
1901 wb_write[1] = 0;
1902 REG_WR_DMAE(bp,
1903 bmac_addr + BIGMAC_REGISTER_TX_PAUSE_THRESHOLD,
1904 wb_write, 2);
1905 }
1906
1907 /* reset old bmac stats */
1908 memset(&bp->old_bmac, 0, sizeof(struct bmac_stats));
1909
1910 NIG_WR(NIG_REG_XCM0_OUT_EN + port*4, 0x0);
1911
1912 /* select XGXS */
1913 NIG_WR(NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 0x1);
1914 NIG_WR(NIG_REG_XGXS_LANE_SEL_P0 + port*4, 0x0);
1915
1916 /* disable the NIG in/out to the emac */
1917 NIG_WR(NIG_REG_EMAC0_IN_EN + port*4, 0x0);
1918 NIG_WR(NIG_REG_EMAC0_PAUSE_OUT_EN + port*4, 0x0);
1919 NIG_WR(NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0x0);
1920
1921 /* enable the NIG in/out to the bmac */
1922 NIG_WR(NIG_REG_EGRESS_EMAC0_PORT + port*4, 0x0);
1923
1924 NIG_WR(NIG_REG_BMAC0_IN_EN + port*4, 0x1);
1925 val = 0;
1926 if (bp->flow_ctrl & FLOW_CTRL_TX)
1927 val = 1;
1928 NIG_WR(NIG_REG_BMAC0_PAUSE_OUT_EN + port*4, val);
1929 NIG_WR(NIG_REG_BMAC0_OUT_EN + port*4, 0x1);
1930
1931 bp->phy_flags |= PHY_BMAC_FLAG;
1932
1933 bp->stats_state = STATS_STATE_ENABLE;
1934 }
1935
1936 static void bnx2x_emac_enable(struct bnx2x *bp)
1937 {
1938 int port = bp->port;
1939 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
1940 u32 val;
1941 int timeout;
1942
1943 DP(NETIF_MSG_LINK, "enableing EMAC\n");
1944 /* reset and unreset the emac core */
1945 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
1946 (MISC_REGISTERS_RESET_REG_2_RST_EMAC0_HARD_CORE << port));
1947 msleep(5);
1948 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
1949 (MISC_REGISTERS_RESET_REG_2_RST_EMAC0_HARD_CORE << port));
1950
1951 /* enable emac and not bmac */
1952 NIG_WR(NIG_REG_EGRESS_EMAC0_PORT + port*4, 1);
1953
1954 /* for paladium */
1955 if (CHIP_REV(bp) == CHIP_REV_EMUL) {
1956 /* Use lane 1 (of lanes 0-3) */
1957 NIG_WR(NIG_REG_XGXS_LANE_SEL_P0 + port*4, 1);
1958 NIG_WR(NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 1);
1959 }
1960 /* for fpga */
1961 else if (CHIP_REV(bp) == CHIP_REV_FPGA) {
1962 /* Use lane 1 (of lanes 0-3) */
1963 NIG_WR(NIG_REG_XGXS_LANE_SEL_P0 + port*4, 1);
1964 NIG_WR(NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 0);
1965 }
1966 /* ASIC */
1967 else {
1968 if (bp->phy_flags & PHY_XGXS_FLAG) {
1969 DP(NETIF_MSG_LINK, "XGXS\n");
1970 /* select the master lanes (out of 0-3) */
1971 NIG_WR(NIG_REG_XGXS_LANE_SEL_P0 + port*4,
1972 bp->ser_lane);
1973 /* select XGXS */
1974 NIG_WR(NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 1);
1975
1976 } else { /* SerDes */
1977 DP(NETIF_MSG_LINK, "SerDes\n");
1978 /* select SerDes */
1979 NIG_WR(NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 0);
1980 }
1981 }
1982
1983 /* enable emac */
1984 NIG_WR(NIG_REG_NIG_EMAC0_EN + port*4, 1);
1985
1986 /* init emac - use read-modify-write */
1987 /* self clear reset */
1988 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
1989 EMAC_WR(EMAC_REG_EMAC_MODE, (val | EMAC_MODE_RESET));
1990
1991 timeout = 200;
1992 while (val & EMAC_MODE_RESET) {
1993 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
1994 DP(NETIF_MSG_LINK, "EMAC reset reg is %u\n", val);
1995 if (!timeout) {
1996 BNX2X_ERR("EMAC timeout!\n");
1997 break;
1998 }
1999 timeout--;
2000 }
2001
2002 /* reset tx part */
2003 EMAC_WR(EMAC_REG_EMAC_TX_MODE, EMAC_TX_MODE_RESET);
2004
2005 timeout = 200;
2006 while (val & EMAC_TX_MODE_RESET) {
2007 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_TX_MODE);
2008 DP(NETIF_MSG_LINK, "EMAC reset reg is %u\n", val);
2009 if (!timeout) {
2010 BNX2X_ERR("EMAC timeout!\n");
2011 break;
2012 }
2013 timeout--;
2014 }
2015
2016 if (CHIP_REV_IS_SLOW(bp)) {
2017 /* config GMII mode */
2018 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
2019 EMAC_WR(EMAC_REG_EMAC_MODE, (val | EMAC_MODE_PORT_GMII));
2020
2021 } else { /* ASIC */
2022 /* pause enable/disable */
2023 bnx2x_bits_dis(bp, emac_base + EMAC_REG_EMAC_RX_MODE,
2024 EMAC_RX_MODE_FLOW_EN);
2025 if (bp->flow_ctrl & FLOW_CTRL_RX)
2026 bnx2x_bits_en(bp, emac_base + EMAC_REG_EMAC_RX_MODE,
2027 EMAC_RX_MODE_FLOW_EN);
2028
2029 bnx2x_bits_dis(bp, emac_base + EMAC_REG_EMAC_TX_MODE,
2030 EMAC_TX_MODE_EXT_PAUSE_EN);
2031 if (bp->flow_ctrl & FLOW_CTRL_TX)
2032 bnx2x_bits_en(bp, emac_base + EMAC_REG_EMAC_TX_MODE,
2033 EMAC_TX_MODE_EXT_PAUSE_EN);
2034 }
2035
2036 /* KEEP_VLAN_TAG, promiscous */
2037 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_RX_MODE);
2038 val |= EMAC_RX_MODE_KEEP_VLAN_TAG | EMAC_RX_MODE_PROMISCUOUS;
2039 EMAC_WR(EMAC_REG_EMAC_RX_MODE, val);
2040
2041 /* identify magic packets */
2042 val = REG_RD(bp, emac_base + EMAC_REG_EMAC_MODE);
2043 EMAC_WR(EMAC_REG_EMAC_MODE, (val | EMAC_MODE_MPKT));
2044
2045 /* enable emac for jumbo packets */
2046 EMAC_WR(EMAC_REG_EMAC_RX_MTU_SIZE,
2047 (EMAC_RX_MTU_SIZE_JUMBO_ENA |
2048 (ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD))); /* -VLAN */
2049
2050 /* strip CRC */
2051 NIG_WR(NIG_REG_NIG_INGRESS_EMAC0_NO_CRC + port*4, 0x1);
2052
2053 val = ((bp->dev->dev_addr[0] << 8) |
2054 bp->dev->dev_addr[1]);
2055 EMAC_WR(EMAC_REG_EMAC_MAC_MATCH, val);
2056
2057 val = ((bp->dev->dev_addr[2] << 24) |
2058 (bp->dev->dev_addr[3] << 16) |
2059 (bp->dev->dev_addr[4] << 8) |
2060 bp->dev->dev_addr[5]);
2061 EMAC_WR(EMAC_REG_EMAC_MAC_MATCH + 4, val);
2062
2063 /* disable the NIG in/out to the bmac */
2064 NIG_WR(NIG_REG_BMAC0_IN_EN + port*4, 0x0);
2065 NIG_WR(NIG_REG_BMAC0_PAUSE_OUT_EN + port*4, 0x0);
2066 NIG_WR(NIG_REG_BMAC0_OUT_EN + port*4, 0x0);
2067
2068 /* enable the NIG in/out to the emac */
2069 NIG_WR(NIG_REG_EMAC0_IN_EN + port*4, 0x1);
2070 val = 0;
2071 if (bp->flow_ctrl & FLOW_CTRL_TX)
2072 val = 1;
2073 NIG_WR(NIG_REG_EMAC0_PAUSE_OUT_EN + port*4, val);
2074 NIG_WR(NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0x1);
2075
2076 if (CHIP_REV(bp) == CHIP_REV_FPGA) {
2077 /* take the BigMac out of reset */
2078 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
2079 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
2080
2081 /* enable access for bmac registers */
2082 NIG_WR(NIG_REG_BMAC0_REGS_OUT_EN + port*4, 0x1);
2083 }
2084
2085 bp->phy_flags |= PHY_EMAC_FLAG;
2086
2087 bp->stats_state = STATS_STATE_ENABLE;
2088 }
2089
2090 static void bnx2x_emac_program(struct bnx2x *bp)
2091 {
2092 u16 mode = 0;
2093 int port = bp->port;
2094
2095 DP(NETIF_MSG_LINK, "setting link speed & duplex\n");
2096 bnx2x_bits_dis(bp, GRCBASE_EMAC0 + port*0x400 + EMAC_REG_EMAC_MODE,
2097 (EMAC_MODE_25G_MODE |
2098 EMAC_MODE_PORT_MII_10M |
2099 EMAC_MODE_HALF_DUPLEX));
2100 switch (bp->line_speed) {
2101 case SPEED_10:
2102 mode |= EMAC_MODE_PORT_MII_10M;
2103 break;
2104
2105 case SPEED_100:
2106 mode |= EMAC_MODE_PORT_MII;
2107 break;
2108
2109 case SPEED_1000:
2110 mode |= EMAC_MODE_PORT_GMII;
2111 break;
2112
2113 case SPEED_2500:
2114 mode |= (EMAC_MODE_25G_MODE | EMAC_MODE_PORT_GMII);
2115 break;
2116
2117 default:
2118 /* 10G not valid for EMAC */
2119 BNX2X_ERR("Invalid line_speed 0x%x\n", bp->line_speed);
2120 break;
2121 }
2122
2123 if (bp->duplex == DUPLEX_HALF)
2124 mode |= EMAC_MODE_HALF_DUPLEX;
2125 bnx2x_bits_en(bp, GRCBASE_EMAC0 + port*0x400 + EMAC_REG_EMAC_MODE,
2126 mode);
2127
2128 bnx2x_leds_set(bp, bp->line_speed);
2129 }
2130
2131 static void bnx2x_set_sgmii_tx_driver(struct bnx2x *bp)
2132 {
2133 u32 lp_up2;
2134 u32 tx_driver;
2135
2136 /* read precomp */
2137 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_OVER_1G);
2138 bnx2x_mdio22_read(bp, MDIO_OVER_1G_LP_UP2, &lp_up2);
2139
2140 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_TX0);
2141 bnx2x_mdio22_read(bp, MDIO_TX0_TX_DRIVER, &tx_driver);
2142
2143 /* bits [10:7] at lp_up2, positioned at [15:12] */
2144 lp_up2 = (((lp_up2 & MDIO_OVER_1G_LP_UP2_PREEMPHASIS_MASK) >>
2145 MDIO_OVER_1G_LP_UP2_PREEMPHASIS_SHIFT) <<
2146 MDIO_TX0_TX_DRIVER_PREEMPHASIS_SHIFT);
2147
2148 if ((lp_up2 != 0) &&
2149 (lp_up2 != (tx_driver & MDIO_TX0_TX_DRIVER_PREEMPHASIS_MASK))) {
2150 /* replace tx_driver bits [15:12] */
2151 tx_driver &= ~MDIO_TX0_TX_DRIVER_PREEMPHASIS_MASK;
2152 tx_driver |= lp_up2;
2153 bnx2x_mdio22_write(bp, MDIO_TX0_TX_DRIVER, tx_driver);
2154 }
2155 }
2156
2157 static void bnx2x_pbf_update(struct bnx2x *bp)
2158 {
2159 int port = bp->port;
2160 u32 init_crd, crd;
2161 u32 count = 1000;
2162 u32 pause = 0;
2163
2164
2165 /* disable port */
2166 REG_WR(bp, PBF_REG_DISABLE_NEW_TASK_PROC_P0 + port*4, 0x1);
2167
2168 /* wait for init credit */
2169 init_crd = REG_RD(bp, PBF_REG_P0_INIT_CRD + port*4);
2170 crd = REG_RD(bp, PBF_REG_P0_CREDIT + port*8);
2171 DP(NETIF_MSG_LINK, "init_crd 0x%x crd 0x%x\n", init_crd, crd);
2172
2173 while ((init_crd != crd) && count) {
2174 msleep(5);
2175
2176 crd = REG_RD(bp, PBF_REG_P0_CREDIT + port*8);
2177 count--;
2178 }
2179 crd = REG_RD(bp, PBF_REG_P0_CREDIT + port*8);
2180 if (init_crd != crd)
2181 BNX2X_ERR("BUG! init_crd 0x%x != crd 0x%x\n", init_crd, crd);
2182
2183 if (bp->flow_ctrl & FLOW_CTRL_RX)
2184 pause = 1;
2185 REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + port*4, pause);
2186 if (pause) {
2187 /* update threshold */
2188 REG_WR(bp, PBF_REG_P0_ARB_THRSH + port*4, 0);
2189 /* update init credit */
2190 init_crd = 778; /* (800-18-4) */
2191
2192 } else {
2193 u32 thresh = (ETH_MAX_JUMBO_PACKET_SIZE + ETH_OVREHEAD)/16;
2194
2195 /* update threshold */
2196 REG_WR(bp, PBF_REG_P0_ARB_THRSH + port*4, thresh);
2197 /* update init credit */
2198 switch (bp->line_speed) {
2199 case SPEED_10:
2200 case SPEED_100:
2201 case SPEED_1000:
2202 init_crd = thresh + 55 - 22;
2203 break;
2204
2205 case SPEED_2500:
2206 init_crd = thresh + 138 - 22;
2207 break;
2208
2209 case SPEED_10000:
2210 init_crd = thresh + 553 - 22;
2211 break;
2212
2213 default:
2214 BNX2X_ERR("Invalid line_speed 0x%x\n",
2215 bp->line_speed);
2216 break;
2217 }
2218 }
2219 REG_WR(bp, PBF_REG_P0_INIT_CRD + port*4, init_crd);
2220 DP(NETIF_MSG_LINK, "PBF updated to speed %d credit %d\n",
2221 bp->line_speed, init_crd);
2222
2223 /* probe the credit changes */
2224 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0x1);
2225 msleep(5);
2226 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0x0);
2227
2228 /* enable port */
2229 REG_WR(bp, PBF_REG_DISABLE_NEW_TASK_PROC_P0 + port*4, 0x0);
2230 }
2231
2232 static void bnx2x_update_mng(struct bnx2x *bp)
2233 {
2234 if (!nomcp)
2235 SHMEM_WR(bp, drv_fw_mb[bp->port].link_status,
2236 bp->link_status);
2237 }
2238
2239 static void bnx2x_link_report(struct bnx2x *bp)
2240 {
2241 if (bp->link_up) {
2242 netif_carrier_on(bp->dev);
2243 printk(KERN_INFO PFX "%s NIC Link is Up, ", bp->dev->name);
2244
2245 printk("%d Mbps ", bp->line_speed);
2246
2247 if (bp->duplex == DUPLEX_FULL)
2248 printk("full duplex");
2249 else
2250 printk("half duplex");
2251
2252 if (bp->flow_ctrl) {
2253 if (bp->flow_ctrl & FLOW_CTRL_RX) {
2254 printk(", receive ");
2255 if (bp->flow_ctrl & FLOW_CTRL_TX)
2256 printk("& transmit ");
2257 } else {
2258 printk(", transmit ");
2259 }
2260 printk("flow control ON");
2261 }
2262 printk("\n");
2263
2264 } else { /* link_down */
2265 netif_carrier_off(bp->dev);
2266 printk(KERN_INFO PFX "%s NIC Link is Down\n", bp->dev->name);
2267 }
2268 }
2269
2270 static void bnx2x_link_up(struct bnx2x *bp)
2271 {
2272 int port = bp->port;
2273
2274 /* PBF - link up */
2275 bnx2x_pbf_update(bp);
2276
2277 /* disable drain */
2278 NIG_WR(NIG_REG_EGRESS_DRAIN0_MODE + port*4, 0);
2279
2280 /* update shared memory */
2281 bnx2x_update_mng(bp);
2282
2283 /* indicate link up */
2284 bnx2x_link_report(bp);
2285 }
2286
2287 static void bnx2x_link_down(struct bnx2x *bp)
2288 {
2289 int port = bp->port;
2290
2291 /* notify stats */
2292 if (bp->stats_state != STATS_STATE_DISABLE) {
2293 bp->stats_state = STATS_STATE_STOP;
2294 DP(BNX2X_MSG_STATS, "stats_state - STOP\n");
2295 }
2296
2297 /* indicate link down */
2298 bp->phy_flags &= ~(PHY_BMAC_FLAG | PHY_EMAC_FLAG);
2299
2300 /* reset BigMac */
2301 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
2302 (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
2303
2304 /* ignore drain flag interrupt */
2305 /* activate nig drain */
2306 NIG_WR(NIG_REG_EGRESS_DRAIN0_MODE + port*4, 1);
2307
2308 /* update shared memory */
2309 bnx2x_update_mng(bp);
2310
2311 /* indicate link down */
2312 bnx2x_link_report(bp);
2313 }
2314
2315 static void bnx2x_init_mac_stats(struct bnx2x *bp);
2316
2317 /* This function is called upon link interrupt */
2318 static void bnx2x_link_update(struct bnx2x *bp)
2319 {
2320 u32 gp_status;
2321 int port = bp->port;
2322 int i;
2323 int link_10g;
2324
2325 DP(NETIF_MSG_LINK, "port %x, is xgxs %x, stat_mask 0x%x,"
2326 " int_mask 0x%x, saved_mask 0x%x, MI_INT %x, SERDES_LINK %x,"
2327 " 10G %x, XGXS_LINK %x\n", port, (bp->phy_flags & PHY_XGXS_FLAG),
2328 REG_RD(bp, NIG_REG_STATUS_INTERRUPT_PORT0 + port*4),
2329 REG_RD(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4), bp->nig_mask,
2330 REG_RD(bp, NIG_REG_EMAC0_STATUS_MISC_MI_INT + port*0x18),
2331 REG_RD(bp, NIG_REG_SERDES0_STATUS_LINK_STATUS + port*0x3c),
2332 REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK10G + port*0x68),
2333 REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK_STATUS + port*0x68)
2334 );
2335
2336 might_sleep();
2337 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_GP_STATUS);
2338 /* avoid fast toggling */
2339 for (i = 0 ; i < 10 ; i++) {
2340 msleep(10);
2341 bnx2x_mdio22_read(bp, MDIO_GP_STATUS_TOP_AN_STATUS1,
2342 &gp_status);
2343 }
2344
2345 bnx2x_link_settings_status(bp, gp_status);
2346
2347 /* anything 10 and over uses the bmac */
2348 link_10g = ((bp->line_speed >= SPEED_10000) &&
2349 (bp->line_speed <= SPEED_16000));
2350
2351 bnx2x_link_int_ack(bp, link_10g);
2352
2353 /* link is up only if both local phy and external phy are up */
2354 if (bp->link_up && bnx2x_ext_phy_is_link_up(bp)) {
2355 if (link_10g) {
2356 bnx2x_bmac_enable(bp, 0);
2357 bnx2x_leds_set(bp, SPEED_10000);
2358
2359 } else {
2360 bnx2x_emac_enable(bp);
2361 bnx2x_emac_program(bp);
2362
2363 /* AN complete? */
2364 if (gp_status & MDIO_AN_CL73_OR_37_COMPLETE) {
2365 if (!(bp->phy_flags & PHY_SGMII_FLAG))
2366 bnx2x_set_sgmii_tx_driver(bp);
2367 }
2368 }
2369 bnx2x_link_up(bp);
2370
2371 } else { /* link down */
2372 bnx2x_leds_unset(bp);
2373 bnx2x_link_down(bp);
2374 }
2375
2376 bnx2x_init_mac_stats(bp);
2377 }
2378
2379 /*
2380 * Init service functions
2381 */
2382
2383 static void bnx2x_set_aer_mmd(struct bnx2x *bp)
2384 {
2385 u16 offset = (bp->phy_flags & PHY_XGXS_FLAG) ?
2386 (bp->phy_addr + bp->ser_lane) : 0;
2387
2388 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_AER_BLOCK);
2389 bnx2x_mdio22_write(bp, MDIO_AER_BLOCK_AER_REG, 0x3800 + offset);
2390 }
2391
2392 static void bnx2x_set_master_ln(struct bnx2x *bp)
2393 {
2394 u32 new_master_ln;
2395
2396 /* set the master_ln for AN */
2397 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_XGXS_BLOCK2);
2398 bnx2x_mdio22_read(bp, MDIO_XGXS_BLOCK2_TEST_MODE_LANE,
2399 &new_master_ln);
2400 bnx2x_mdio22_write(bp, MDIO_XGXS_BLOCK2_TEST_MODE_LANE,
2401 (new_master_ln | bp->ser_lane));
2402 }
2403
2404 static void bnx2x_reset_unicore(struct bnx2x *bp)
2405 {
2406 u32 mii_control;
2407 int i;
2408
2409 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_COMBO_IEEE0);
2410 bnx2x_mdio22_read(bp, MDIO_COMBO_IEEE0_MII_CONTROL, &mii_control);
2411 /* reset the unicore */
2412 bnx2x_mdio22_write(bp, MDIO_COMBO_IEEE0_MII_CONTROL,
2413 (mii_control | MDIO_COMBO_IEEO_MII_CONTROL_RESET));
2414
2415 /* wait for the reset to self clear */
2416 for (i = 0; i < MDIO_ACCESS_TIMEOUT; i++) {
2417 udelay(5);
2418
2419 /* the reset erased the previous bank value */
2420 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_COMBO_IEEE0);
2421 bnx2x_mdio22_read(bp, MDIO_COMBO_IEEE0_MII_CONTROL,
2422 &mii_control);
2423
2424 if (!(mii_control & MDIO_COMBO_IEEO_MII_CONTROL_RESET)) {
2425 udelay(5);
2426 return;
2427 }
2428 }
2429
2430 BNX2X_ERR("BUG! unicore is still in reset!\n");
2431 }
2432
2433 static void bnx2x_set_swap_lanes(struct bnx2x *bp)
2434 {
2435 /* Each two bits represents a lane number:
2436 No swap is 0123 => 0x1b no need to enable the swap */
2437
2438 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_XGXS_BLOCK2);
2439 if (bp->rx_lane_swap != 0x1b) {
2440 bnx2x_mdio22_write(bp, MDIO_XGXS_BLOCK2_RX_LN_SWAP,
2441 (bp->rx_lane_swap |
2442 MDIO_XGXS_BLOCK2_RX_LN_SWAP_ENABLE |
2443 MDIO_XGXS_BLOCK2_RX_LN_SWAP_FORCE_ENABLE));
2444 } else {
2445 bnx2x_mdio22_write(bp, MDIO_XGXS_BLOCK2_RX_LN_SWAP, 0);
2446 }
2447
2448 if (bp->tx_lane_swap != 0x1b) {
2449 bnx2x_mdio22_write(bp, MDIO_XGXS_BLOCK2_TX_LN_SWAP,
2450 (bp->tx_lane_swap |
2451 MDIO_XGXS_BLOCK2_TX_LN_SWAP_ENABLE));
2452 } else {
2453 bnx2x_mdio22_write(bp, MDIO_XGXS_BLOCK2_TX_LN_SWAP, 0);
2454 }
2455 }
2456
2457 static void bnx2x_set_parallel_detection(struct bnx2x *bp)
2458 {
2459 u32 control2;
2460
2461 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_SERDES_DIGITAL);
2462 bnx2x_mdio22_read(bp, MDIO_SERDES_DIGITAL_A_1000X_CONTROL2,
2463 &control2);
2464
2465 if (bp->autoneg & AUTONEG_PARALLEL) {
2466 control2 |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL2_PRL_DT_EN;
2467 } else {
2468 control2 &= ~MDIO_SERDES_DIGITAL_A_1000X_CONTROL2_PRL_DT_EN;
2469 }
2470 bnx2x_mdio22_write(bp, MDIO_SERDES_DIGITAL_A_1000X_CONTROL2,
2471 control2);
2472
2473 if (bp->phy_flags & PHY_XGXS_FLAG) {
2474 DP(NETIF_MSG_LINK, "XGXS\n");
2475 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_10G_PARALLEL_DETECT);
2476
2477 bnx2x_mdio22_write(bp,
2478 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_LINK,
2479 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_LINK_CNT);
2480
2481 bnx2x_mdio22_read(bp,
2482 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_CONTROL,
2483 &control2);
2484
2485 if (bp->autoneg & AUTONEG_PARALLEL) {
2486 control2 |=
2487 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_CONTROL_PARDET10G_EN;
2488 } else {
2489 control2 &=
2490 ~MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_CONTROL_PARDET10G_EN;
2491 }
2492 bnx2x_mdio22_write(bp,
2493 MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_CONTROL,
2494 control2);
2495 }
2496 }
2497
2498 static void bnx2x_set_autoneg(struct bnx2x *bp)
2499 {
2500 u32 reg_val;
2501
2502 /* CL37 Autoneg */
2503 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_COMBO_IEEE0);
2504 bnx2x_mdio22_read(bp, MDIO_COMBO_IEEE0_MII_CONTROL, &reg_val);
2505 if ((bp->req_autoneg & AUTONEG_SPEED) &&
2506 (bp->autoneg & AUTONEG_CL37)) {
2507 /* CL37 Autoneg Enabled */
2508 reg_val |= MDIO_COMBO_IEEO_MII_CONTROL_AN_EN;
2509 } else {
2510 /* CL37 Autoneg Disabled */
2511 reg_val &= ~(MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
2512 MDIO_COMBO_IEEO_MII_CONTROL_RESTART_AN);
2513 }
2514 bnx2x_mdio22_write(bp, MDIO_COMBO_IEEE0_MII_CONTROL, reg_val);
2515
2516 /* Enable/Disable Autodetection */
2517 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_SERDES_DIGITAL);
2518 bnx2x_mdio22_read(bp, MDIO_SERDES_DIGITAL_A_1000X_CONTROL1, &reg_val);
2519 reg_val &= ~MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_SIGNAL_DETECT_EN;
2520
2521 if ((bp->req_autoneg & AUTONEG_SPEED) &&
2522 (bp->autoneg & AUTONEG_SGMII_FIBER_AUTODET)) {
2523 reg_val |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_AUTODET;
2524 } else {
2525 reg_val &= ~MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_AUTODET;
2526 }
2527 bnx2x_mdio22_write(bp, MDIO_SERDES_DIGITAL_A_1000X_CONTROL1, reg_val);
2528
2529 /* Enable TetonII and BAM autoneg */
2530 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_BAM_NEXT_PAGE);
2531 bnx2x_mdio22_read(bp, MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL,
2532 &reg_val);
2533 if ((bp->req_autoneg & AUTONEG_SPEED) &&
2534 (bp->autoneg & AUTONEG_CL37) && (bp->autoneg & AUTONEG_BAM)) {
2535 /* Enable BAM aneg Mode and TetonII aneg Mode */
2536 reg_val |= (MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_BAM_MODE |
2537 MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_TETON_AN);
2538 } else {
2539 /* TetonII and BAM Autoneg Disabled */
2540 reg_val &= ~(MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_BAM_MODE |
2541 MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL_TETON_AN);
2542 }
2543 bnx2x_mdio22_write(bp, MDIO_BAM_NEXT_PAGE_MP5_NEXT_PAGE_CTRL,
2544 reg_val);
2545
2546 /* Enable Clause 73 Aneg */
2547 if ((bp->req_autoneg & AUTONEG_SPEED) &&
2548 (bp->autoneg & AUTONEG_CL73)) {
2549 /* Enable BAM Station Manager */
2550 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_CL73_USERB0);
2551 bnx2x_mdio22_write(bp, MDIO_CL73_USERB0_CL73_BAM_CTRL1,
2552 (MDIO_CL73_USERB0_CL73_BAM_CTRL1_BAM_EN |
2553 MDIO_CL73_USERB0_CL73_BAM_CTRL1_BAM_STATION_MNGR_EN |
2554 MDIO_CL73_USERB0_CL73_BAM_CTRL1_BAM_NP_AFTER_BP_EN));
2555
2556 /* Merge CL73 and CL37 aneg resolution */
2557 bnx2x_mdio22_read(bp, MDIO_CL73_USERB0_CL73_BAM_CTRL3,
2558 &reg_val);
2559 bnx2x_mdio22_write(bp, MDIO_CL73_USERB0_CL73_BAM_CTRL3,
2560 (reg_val |
2561 MDIO_CL73_USERB0_CL73_BAM_CTRL3_USE_CL73_HCD_MR));
2562
2563 /* Set the CL73 AN speed */
2564 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_CL73_IEEEB1);
2565 bnx2x_mdio22_read(bp, MDIO_CL73_IEEEB1_AN_ADV2, &reg_val);
2566 /* In the SerDes we support only the 1G.
2567 In the XGXS we support the 10G KX4
2568 but we currently do not support the KR */
2569 if (bp->phy_flags & PHY_XGXS_FLAG) {
2570 DP(NETIF_MSG_LINK, "XGXS\n");
2571 /* 10G KX4 */
2572 reg_val |= MDIO_CL73_IEEEB1_AN_ADV2_ADVR_10G_KX4;
2573 } else {
2574 DP(NETIF_MSG_LINK, "SerDes\n");
2575 /* 1000M KX */
2576 reg_val |= MDIO_CL73_IEEEB1_AN_ADV2_ADVR_1000M_KX;
2577 }
2578 bnx2x_mdio22_write(bp, MDIO_CL73_IEEEB1_AN_ADV2, reg_val);
2579
2580 /* CL73 Autoneg Enabled */
2581 reg_val = MDIO_CL73_IEEEB0_CL73_AN_CONTROL_AN_EN;
2582 } else {
2583 /* CL73 Autoneg Disabled */
2584 reg_val = 0;
2585 }
2586 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_CL73_IEEEB0);
2587 bnx2x_mdio22_write(bp, MDIO_CL73_IEEEB0_CL73_AN_CONTROL, reg_val);
2588 }
2589
2590 /* program SerDes, forced speed */
2591 static void bnx2x_program_serdes(struct bnx2x *bp)
2592 {
2593 u32 reg_val;
2594
2595 /* program duplex, disable autoneg */
2596 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_COMBO_IEEE0);
2597 bnx2x_mdio22_read(bp, MDIO_COMBO_IEEE0_MII_CONTROL, &reg_val);
2598 reg_val &= ~(MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX |
2599 MDIO_COMBO_IEEO_MII_CONTROL_AN_EN);
2600 if (bp->req_duplex == DUPLEX_FULL)
2601 reg_val |= MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX;
2602 bnx2x_mdio22_write(bp, MDIO_COMBO_IEEE0_MII_CONTROL, reg_val);
2603
2604 /* program speed
2605 - needed only if the speed is greater than 1G (2.5G or 10G) */
2606 if (bp->req_line_speed > SPEED_1000) {
2607 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_SERDES_DIGITAL);
2608 bnx2x_mdio22_read(bp, MDIO_SERDES_DIGITAL_MISC1, &reg_val);
2609 /* clearing the speed value before setting the right speed */
2610 reg_val &= ~MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_MASK;
2611 reg_val |= (MDIO_SERDES_DIGITAL_MISC1_REFCLK_SEL_156_25M |
2612 MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_SEL);
2613 if (bp->req_line_speed == SPEED_10000)
2614 reg_val |=
2615 MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_10G_CX4;
2616 bnx2x_mdio22_write(bp, MDIO_SERDES_DIGITAL_MISC1, reg_val);
2617 }
2618 }
2619
2620 static void bnx2x_set_brcm_cl37_advertisment(struct bnx2x *bp)
2621 {
2622 u32 val = 0;
2623
2624 /* configure the 48 bits for BAM AN */
2625 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_OVER_1G);
2626
2627 /* set extended capabilities */
2628 if (bp->advertising & ADVERTISED_2500baseT_Full)
2629 val |= MDIO_OVER_1G_UP1_2_5G;
2630 if (bp->advertising & ADVERTISED_10000baseT_Full)
2631 val |= MDIO_OVER_1G_UP1_10G;
2632 bnx2x_mdio22_write(bp, MDIO_OVER_1G_UP1, val);
2633
2634 bnx2x_mdio22_write(bp, MDIO_OVER_1G_UP3, 0);
2635 }
2636
2637 static void bnx2x_set_ieee_aneg_advertisment(struct bnx2x *bp)
2638 {
2639 u32 an_adv;
2640
2641 /* for AN, we are always publishing full duplex */
2642 an_adv = MDIO_COMBO_IEEE0_AUTO_NEG_ADV_FULL_DUPLEX;
2643
2644 /* set pause */
2645 switch (bp->pause_mode) {
2646 case PAUSE_SYMMETRIC:
2647 an_adv |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_SYMMETRIC;
2648 break;
2649 case PAUSE_ASYMMETRIC:
2650 an_adv |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC;
2651 break;
2652 case PAUSE_BOTH:
2653 an_adv |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
2654 break;
2655 case PAUSE_NONE:
2656 an_adv |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE;
2657 break;
2658 }
2659
2660 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_COMBO_IEEE0);
2661 bnx2x_mdio22_write(bp, MDIO_COMBO_IEEE0_AUTO_NEG_ADV, an_adv);
2662 }
2663
2664 static void bnx2x_restart_autoneg(struct bnx2x *bp)
2665 {
2666 if (bp->autoneg & AUTONEG_CL73) {
2667 /* enable and restart clause 73 aneg */
2668 u32 an_ctrl;
2669
2670 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_CL73_IEEEB0);
2671 bnx2x_mdio22_read(bp, MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
2672 &an_ctrl);
2673 bnx2x_mdio22_write(bp, MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
2674 (an_ctrl |
2675 MDIO_CL73_IEEEB0_CL73_AN_CONTROL_AN_EN |
2676 MDIO_CL73_IEEEB0_CL73_AN_CONTROL_RESTART_AN));
2677
2678 } else {
2679 /* Enable and restart BAM/CL37 aneg */
2680 u32 mii_control;
2681
2682 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_COMBO_IEEE0);
2683 bnx2x_mdio22_read(bp, MDIO_COMBO_IEEE0_MII_CONTROL,
2684 &mii_control);
2685 bnx2x_mdio22_write(bp, MDIO_COMBO_IEEE0_MII_CONTROL,
2686 (mii_control |
2687 MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
2688 MDIO_COMBO_IEEO_MII_CONTROL_RESTART_AN));
2689 }
2690 }
2691
2692 static void bnx2x_initialize_sgmii_process(struct bnx2x *bp)
2693 {
2694 u32 control1;
2695
2696 /* in SGMII mode, the unicore is always slave */
2697 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_SERDES_DIGITAL);
2698 bnx2x_mdio22_read(bp, MDIO_SERDES_DIGITAL_A_1000X_CONTROL1,
2699 &control1);
2700 control1 |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_INVERT_SIGNAL_DETECT;
2701 /* set sgmii mode (and not fiber) */
2702 control1 &= ~(MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_FIBER_MODE |
2703 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_AUTODET |
2704 MDIO_SERDES_DIGITAL_A_1000X_CONTROL1_MSTR_MODE);
2705 bnx2x_mdio22_write(bp, MDIO_SERDES_DIGITAL_A_1000X_CONTROL1,
2706 control1);
2707
2708 /* if forced speed */
2709 if (!(bp->req_autoneg & AUTONEG_SPEED)) {
2710 /* set speed, disable autoneg */
2711 u32 mii_control;
2712
2713 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_COMBO_IEEE0);
2714 bnx2x_mdio22_read(bp, MDIO_COMBO_IEEE0_MII_CONTROL,
2715 &mii_control);
2716 mii_control &= ~(MDIO_COMBO_IEEO_MII_CONTROL_AN_EN |
2717 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_MASK |
2718 MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX);
2719
2720 switch (bp->req_line_speed) {
2721 case SPEED_100:
2722 mii_control |=
2723 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_100;
2724 break;
2725 case SPEED_1000:
2726 mii_control |=
2727 MDIO_COMBO_IEEO_MII_CONTROL_MAN_SGMII_SP_1000;
2728 break;
2729 case SPEED_10:
2730 /* there is nothing to set for 10M */
2731 break;
2732 default:
2733 /* invalid speed for SGMII */
2734 DP(NETIF_MSG_LINK, "Invalid req_line_speed 0x%x\n",
2735 bp->req_line_speed);
2736 break;
2737 }
2738
2739 /* setting the full duplex */
2740 if (bp->req_duplex == DUPLEX_FULL)
2741 mii_control |=
2742 MDIO_COMBO_IEEO_MII_CONTROL_FULL_DUPLEX;
2743 bnx2x_mdio22_write(bp, MDIO_COMBO_IEEE0_MII_CONTROL,
2744 mii_control);
2745
2746 } else { /* AN mode */
2747 /* enable and restart AN */
2748 bnx2x_restart_autoneg(bp);
2749 }
2750 }
2751
2752 static void bnx2x_link_int_enable(struct bnx2x *bp)
2753 {
2754 int port = bp->port;
2755
2756 /* setting the status to report on link up
2757 for either XGXS or SerDes */
2758 bnx2x_bits_dis(bp, NIG_REG_STATUS_INTERRUPT_PORT0 + port*4,
2759 (NIG_XGXS0_LINK_STATUS |
2760 NIG_STATUS_INTERRUPT_XGXS0_LINK10G |
2761 NIG_SERDES0_LINK_STATUS));
2762
2763 if (bp->phy_flags & PHY_XGXS_FLAG) {
2764 /* TBD -
2765 * in force mode (not AN) we can enable just the relevant
2766 * interrupt
2767 * Even in AN we might enable only one according to the AN
2768 * speed mask
2769 */
2770 bnx2x_bits_en(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
2771 (NIG_MASK_XGXS0_LINK_STATUS |
2772 NIG_MASK_XGXS0_LINK10G));
2773 DP(NETIF_MSG_LINK, "enable XGXS interrupt\n");
2774
2775 } else { /* SerDes */
2776 bnx2x_bits_en(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
2777 NIG_MASK_SERDES0_LINK_STATUS);
2778 DP(NETIF_MSG_LINK, "enable SerDes interrupt\n");
2779 }
2780 }
2781
2782 static void bnx2x_ext_phy_init(struct bnx2x *bp)
2783 {
2784 int port = bp->port;
2785 u32 ext_phy_type;
2786 u32 ext_phy_addr;
2787 u32 local_phy;
2788
2789 if (bp->phy_flags & PHY_XGXS_FLAG) {
2790 local_phy = bp->phy_addr;
2791 ext_phy_addr = ((bp->ext_phy_config &
2792 PORT_HW_CFG_XGXS_EXT_PHY_ADDR_MASK) >>
2793 PORT_HW_CFG_XGXS_EXT_PHY_ADDR_SHIFT);
2794
2795 ext_phy_type = XGXS_EXT_PHY_TYPE(bp);
2796 switch (ext_phy_type) {
2797 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
2798 DP(NETIF_MSG_LINK, "XGXS Direct\n");
2799 break;
2800
2801 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
2802 DP(NETIF_MSG_LINK, "XGXS 8705\n");
2803 bnx2x_bits_en(bp,
2804 NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
2805 NIG_MASK_MI_INT);
2806 DP(NETIF_MSG_LINK, "enabled extenal phy int\n");
2807
2808 bp->phy_addr = ext_phy_type;
2809 bnx2x_mdio45_vwrite(bp, EXT_PHY_OPT_PMA_PMD_DEVAD,
2810 EXT_PHY_OPT_PMD_MISC_CNTL,
2811 0x8288);
2812 bnx2x_mdio45_vwrite(bp, EXT_PHY_OPT_PMA_PMD_DEVAD,
2813 EXT_PHY_OPT_PHY_IDENTIFIER,
2814 0x7fbf);
2815 bnx2x_mdio45_vwrite(bp, EXT_PHY_OPT_PMA_PMD_DEVAD,
2816 EXT_PHY_OPT_CMU_PLL_BYPASS,
2817 0x0100);
2818 bnx2x_mdio45_vwrite(bp, EXT_PHY_OPT_WIS_DEVAD,
2819 EXT_PHY_OPT_LASI_CNTL, 0x1);
2820 break;
2821
2822 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
2823 DP(NETIF_MSG_LINK, "XGXS 8706\n");
2824 bnx2x_bits_en(bp,
2825 NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
2826 NIG_MASK_MI_INT);
2827 DP(NETIF_MSG_LINK, "enabled extenal phy int\n");
2828
2829 bp->phy_addr = ext_phy_type;
2830 bnx2x_mdio45_vwrite(bp, EXT_PHY_OPT_PMA_PMD_DEVAD,
2831 EXT_PHY_OPT_PMD_DIGITAL_CNT,
2832 0x400);
2833 bnx2x_mdio45_vwrite(bp, EXT_PHY_OPT_PMA_PMD_DEVAD,
2834 EXT_PHY_OPT_LASI_CNTL, 0x1);
2835 break;
2836
2837 default:
2838 DP(NETIF_MSG_LINK, "BAD XGXS ext_phy_config 0x%x\n",
2839 bp->ext_phy_config);
2840 break;
2841 }
2842 bp->phy_addr = local_phy;
2843
2844 } else { /* SerDes */
2845 /* ext_phy_addr = ((bp->ext_phy_config &
2846 PORT_HW_CFG_SERDES_EXT_PHY_ADDR_MASK) >>
2847 PORT_HW_CFG_SERDES_EXT_PHY_ADDR_SHIFT);
2848 */
2849 ext_phy_type = SERDES_EXT_PHY_TYPE(bp);
2850 switch (ext_phy_type) {
2851 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT:
2852 DP(NETIF_MSG_LINK, "SerDes Direct\n");
2853 break;
2854
2855 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482:
2856 DP(NETIF_MSG_LINK, "SerDes 5482\n");
2857 bnx2x_bits_en(bp,
2858 NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
2859 NIG_MASK_MI_INT);
2860 DP(NETIF_MSG_LINK, "enabled extenal phy int\n");
2861 break;
2862
2863 default:
2864 DP(NETIF_MSG_LINK, "BAD SerDes ext_phy_config 0x%x\n",
2865 bp->ext_phy_config);
2866 break;
2867 }
2868 }
2869 }
2870
2871 static void bnx2x_ext_phy_reset(struct bnx2x *bp)
2872 {
2873 u32 ext_phy_type;
2874 u32 ext_phy_addr;
2875 u32 local_phy;
2876
2877 if (bp->phy_flags & PHY_XGXS_FLAG) {
2878 ext_phy_type = XGXS_EXT_PHY_TYPE(bp);
2879 switch (ext_phy_type) {
2880 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
2881 DP(NETIF_MSG_LINK, "XGXS Direct\n");
2882 break;
2883
2884 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
2885 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
2886 DP(NETIF_MSG_LINK, "XGXS 8705/6\n");
2887 local_phy = bp->phy_addr;
2888 ext_phy_addr = ((bp->ext_phy_config &
2889 PORT_HW_CFG_XGXS_EXT_PHY_ADDR_MASK) >>
2890 PORT_HW_CFG_XGXS_EXT_PHY_ADDR_SHIFT);
2891 bp->phy_addr = (u8)ext_phy_addr;
2892 bnx2x_mdio45_write(bp, EXT_PHY_OPT_PMA_PMD_DEVAD,
2893 EXT_PHY_OPT_CNTL, 0xa040);
2894 bp->phy_addr = local_phy;
2895 break;
2896
2897 default:
2898 DP(NETIF_MSG_LINK, "BAD XGXS ext_phy_config 0x%x\n",
2899 bp->ext_phy_config);
2900 break;
2901 }
2902
2903 } else { /* SerDes */
2904 ext_phy_type = SERDES_EXT_PHY_TYPE(bp);
2905 switch (ext_phy_type) {
2906 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT:
2907 DP(NETIF_MSG_LINK, "SerDes Direct\n");
2908 break;
2909
2910 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482:
2911 DP(NETIF_MSG_LINK, "SerDes 5482\n");
2912 break;
2913
2914 default:
2915 DP(NETIF_MSG_LINK, "BAD SerDes ext_phy_config 0x%x\n",
2916 bp->ext_phy_config);
2917 break;
2918 }
2919 }
2920 }
2921
2922 static void bnx2x_link_initialize(struct bnx2x *bp)
2923 {
2924 int port = bp->port;
2925
2926 /* disable attentions */
2927 bnx2x_bits_dis(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
2928 (NIG_MASK_XGXS0_LINK_STATUS |
2929 NIG_MASK_XGXS0_LINK10G |
2930 NIG_MASK_SERDES0_LINK_STATUS |
2931 NIG_MASK_MI_INT));
2932
2933 bnx2x_ext_phy_reset(bp);
2934
2935 bnx2x_set_aer_mmd(bp);
2936
2937 if (bp->phy_flags & PHY_XGXS_FLAG)
2938 bnx2x_set_master_ln(bp);
2939
2940 /* reset the SerDes and wait for reset bit return low */
2941 bnx2x_reset_unicore(bp);
2942
2943 bnx2x_set_aer_mmd(bp);
2944
2945 /* setting the masterLn_def again after the reset */
2946 if (bp->phy_flags & PHY_XGXS_FLAG) {
2947 bnx2x_set_master_ln(bp);
2948 bnx2x_set_swap_lanes(bp);
2949 }
2950
2951 /* Set Parallel Detect */
2952 if (bp->req_autoneg & AUTONEG_SPEED)
2953 bnx2x_set_parallel_detection(bp);
2954
2955 if (bp->phy_flags & PHY_XGXS_FLAG) {
2956 if (bp->req_line_speed &&
2957 bp->req_line_speed < SPEED_1000) {
2958 bp->phy_flags |= PHY_SGMII_FLAG;
2959 } else {
2960 bp->phy_flags &= ~PHY_SGMII_FLAG;
2961 }
2962 }
2963
2964 if (!(bp->phy_flags & PHY_SGMII_FLAG)) {
2965 u16 bank, rx_eq;
2966
2967 rx_eq = ((bp->serdes_config &
2968 PORT_HW_CFG_SERDES_RX_DRV_EQUALIZER_MASK) >>
2969 PORT_HW_CFG_SERDES_RX_DRV_EQUALIZER_SHIFT);
2970
2971 DP(NETIF_MSG_LINK, "setting rx eq to %d\n", rx_eq);
2972 for (bank = MDIO_REG_BANK_RX0; bank <= MDIO_REG_BANK_RX_ALL;
2973 bank += (MDIO_REG_BANK_RX1 - MDIO_REG_BANK_RX0)) {
2974 MDIO_SET_REG_BANK(bp, bank);
2975 bnx2x_mdio22_write(bp, MDIO_RX0_RX_EQ_BOOST,
2976 ((rx_eq &
2977 MDIO_RX0_RX_EQ_BOOST_EQUALIZER_CTRL_MASK) |
2978 MDIO_RX0_RX_EQ_BOOST_OFFSET_CTRL));
2979 }
2980
2981 /* forced speed requested? */
2982 if (!(bp->req_autoneg & AUTONEG_SPEED)) {
2983 DP(NETIF_MSG_LINK, "not SGMII, no AN\n");
2984
2985 /* disable autoneg */
2986 bnx2x_set_autoneg(bp);
2987
2988 /* program speed and duplex */
2989 bnx2x_program_serdes(bp);
2990
2991 } else { /* AN_mode */
2992 DP(NETIF_MSG_LINK, "not SGMII, AN\n");
2993
2994 /* AN enabled */
2995 bnx2x_set_brcm_cl37_advertisment(bp);
2996
2997 /* program duplex & pause advertisment (for aneg) */
2998 bnx2x_set_ieee_aneg_advertisment(bp);
2999
3000 /* enable autoneg */
3001 bnx2x_set_autoneg(bp);
3002
3003 /* enalbe and restart AN */
3004 bnx2x_restart_autoneg(bp);
3005 }
3006
3007 } else { /* SGMII mode */
3008 DP(NETIF_MSG_LINK, "SGMII\n");
3009
3010 bnx2x_initialize_sgmii_process(bp);
3011 }
3012
3013 /* enable the interrupt */
3014 bnx2x_link_int_enable(bp);
3015
3016 /* init ext phy and enable link state int */
3017 bnx2x_ext_phy_init(bp);
3018 }
3019
3020 static void bnx2x_phy_deassert(struct bnx2x *bp)
3021 {
3022 int port = bp->port;
3023 u32 val;
3024
3025 if (bp->phy_flags & PHY_XGXS_FLAG) {
3026 DP(NETIF_MSG_LINK, "XGXS\n");
3027 val = XGXS_RESET_BITS;
3028
3029 } else { /* SerDes */
3030 DP(NETIF_MSG_LINK, "SerDes\n");
3031 val = SERDES_RESET_BITS;
3032 }
3033
3034 val = val << (port*16);
3035
3036 /* reset and unreset the SerDes/XGXS */
3037 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_CLEAR, val);
3038 msleep(5);
3039 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_SET, val);
3040 }
3041
3042 static int bnx2x_phy_init(struct bnx2x *bp)
3043 {
3044 DP(NETIF_MSG_LINK, "started\n");
3045 if (CHIP_REV(bp) == CHIP_REV_FPGA) {
3046 bp->phy_flags |= PHY_EMAC_FLAG;
3047 bp->link_up = 1;
3048 bp->line_speed = SPEED_10000;
3049 bp->duplex = DUPLEX_FULL;
3050 NIG_WR(NIG_REG_EGRESS_DRAIN0_MODE + bp->port*4, 0);
3051 bnx2x_emac_enable(bp);
3052 bnx2x_link_report(bp);
3053 return 0;
3054
3055 } else if (CHIP_REV(bp) == CHIP_REV_EMUL) {
3056 bp->phy_flags |= PHY_BMAC_FLAG;
3057 bp->link_up = 1;
3058 bp->line_speed = SPEED_10000;
3059 bp->duplex = DUPLEX_FULL;
3060 NIG_WR(NIG_REG_EGRESS_DRAIN0_MODE + bp->port*4, 0);
3061 bnx2x_bmac_enable(bp, 0);
3062 bnx2x_link_report(bp);
3063 return 0;
3064
3065 } else {
3066 bnx2x_phy_deassert(bp);
3067 bnx2x_link_initialize(bp);
3068 }
3069
3070 return 0;
3071 }
3072
3073 static void bnx2x_link_reset(struct bnx2x *bp)
3074 {
3075 int port = bp->port;
3076
3077 /* disable attentions */
3078 bnx2x_bits_dis(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4,
3079 (NIG_MASK_XGXS0_LINK_STATUS |
3080 NIG_MASK_XGXS0_LINK10G |
3081 NIG_MASK_SERDES0_LINK_STATUS |
3082 NIG_MASK_MI_INT));
3083
3084 bnx2x_ext_phy_reset(bp);
3085
3086 /* reset the SerDes/XGXS */
3087 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_3_CLEAR,
3088 (0x1ff << (port*16)));
3089
3090 /* reset EMAC / BMAC and disable NIG interfaces */
3091 NIG_WR(NIG_REG_BMAC0_IN_EN + port*4, 0);
3092 NIG_WR(NIG_REG_BMAC0_OUT_EN + port*4, 0);
3093
3094 NIG_WR(NIG_REG_NIG_EMAC0_EN + port*4, 0);
3095 NIG_WR(NIG_REG_EMAC0_IN_EN + port*4, 0);
3096 NIG_WR(NIG_REG_EGRESS_EMAC0_OUT_EN + port*4, 0);
3097
3098 NIG_WR(NIG_REG_EGRESS_DRAIN0_MODE + port*4, 1);
3099 }
3100
3101 #ifdef BNX2X_XGXS_LB
3102 static void bnx2x_set_xgxs_loopback(struct bnx2x *bp, int is_10g)
3103 {
3104 int port = bp->port;
3105
3106 if (is_10g) {
3107 u32 md_devad;
3108
3109 DP(NETIF_MSG_LINK, "XGXS 10G loopback enable\n");
3110
3111 /* change the uni_phy_addr in the nig */
3112 REG_RD(bp, (NIG_REG_XGXS0_CTRL_MD_DEVAD + port*0x18),
3113 &md_devad);
3114 NIG_WR(NIG_REG_XGXS0_CTRL_MD_DEVAD + port*0x18, 0x5);
3115
3116 /* change the aer mmd */
3117 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_AER_BLOCK);
3118 bnx2x_mdio22_write(bp, MDIO_AER_BLOCK_AER_REG, 0x2800);
3119
3120 /* config combo IEEE0 control reg for loopback */
3121 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_CL73_IEEEB0);
3122 bnx2x_mdio22_write(bp, MDIO_CL73_IEEEB0_CL73_AN_CONTROL,
3123 0x6041);
3124
3125 /* set aer mmd back */
3126 bnx2x_set_aer_mmd(bp);
3127
3128 /* and md_devad */
3129 NIG_WR(NIG_REG_XGXS0_CTRL_MD_DEVAD + port*0x18, md_devad);
3130
3131 } else {
3132 u32 mii_control;
3133
3134 DP(NETIF_MSG_LINK, "XGXS 1G loopback enable\n");
3135
3136 MDIO_SET_REG_BANK(bp, MDIO_REG_BANK_COMBO_IEEE0);
3137 bnx2x_mdio22_read(bp, MDIO_COMBO_IEEE0_MII_CONTROL,
3138 &mii_control);
3139 bnx2x_mdio22_write(bp, MDIO_COMBO_IEEE0_MII_CONTROL,
3140 (mii_control |
3141 MDIO_COMBO_IEEO_MII_CONTROL_LOOPBACK));
3142 }
3143 }
3144 #endif
3145
3146 /* end of PHY/MAC */
3147
3148 /* slow path */
3149
3150 /*
3151 * General service functions
3152 */
3153
3154 /* the slow path queue is odd since completions arrive on the fastpath ring */
3155 static int bnx2x_sp_post(struct bnx2x *bp, int command, int cid,
3156 u32 data_hi, u32 data_lo, int common)
3157 {
3158 int port = bp->port;
3159
3160 DP(NETIF_MSG_TIMER,
3161 "spe (%x:%x) command %x hw_cid %x data (%x:%x) left %x\n",
3162 (u32)U64_HI(bp->spq_mapping), (u32)(U64_LO(bp->spq_mapping) +
3163 (void *)bp->spq_prod_bd - (void *)bp->spq), command,
3164 HW_CID(bp, cid), data_hi, data_lo, bp->spq_left);
3165
3166 #ifdef BNX2X_STOP_ON_ERROR
3167 if (unlikely(bp->panic))
3168 return -EIO;
3169 #endif
3170
3171 spin_lock(&bp->spq_lock);
3172
3173 if (!bp->spq_left) {
3174 BNX2X_ERR("BUG! SPQ ring full!\n");
3175 spin_unlock(&bp->spq_lock);
3176 bnx2x_panic();
3177 return -EBUSY;
3178 }
3179 /* CID needs port number to be encoded int it */
3180 bp->spq_prod_bd->hdr.conn_and_cmd_data =
3181 cpu_to_le32(((command << SPE_HDR_CMD_ID_SHIFT) |
3182 HW_CID(bp, cid)));
3183 bp->spq_prod_bd->hdr.type = cpu_to_le16(ETH_CONNECTION_TYPE);
3184 if (common)
3185 bp->spq_prod_bd->hdr.type |=
3186 cpu_to_le16((1 << SPE_HDR_COMMON_RAMROD_SHIFT));
3187
3188 bp->spq_prod_bd->data.mac_config_addr.hi = cpu_to_le32(data_hi);
3189 bp->spq_prod_bd->data.mac_config_addr.lo = cpu_to_le32(data_lo);
3190
3191 bp->spq_left--;
3192
3193 if (bp->spq_prod_bd == bp->spq_last_bd) {
3194 bp->spq_prod_bd = bp->spq;
3195 bp->spq_prod_idx = 0;
3196 DP(NETIF_MSG_TIMER, "end of spq\n");
3197
3198 } else {
3199 bp->spq_prod_bd++;
3200 bp->spq_prod_idx++;
3201 }
3202
3203 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_SPQ_PROD_OFFSET(port),
3204 bp->spq_prod_idx);
3205
3206 spin_unlock(&bp->spq_lock);
3207 return 0;
3208 }
3209
3210 /* acquire split MCP access lock register */
3211 static int bnx2x_lock_alr(struct bnx2x *bp)
3212 {
3213 int rc = 0;
3214 u32 i, j, val;
3215
3216 might_sleep();
3217 i = 100;
3218 for (j = 0; j < i*10; j++) {
3219 val = (1UL << 31);
3220 REG_WR(bp, GRCBASE_MCP + 0x9c, val);
3221 val = REG_RD(bp, GRCBASE_MCP + 0x9c);
3222 if (val & (1L << 31))
3223 break;
3224
3225 msleep(5);
3226 }
3227
3228 if (!(val & (1L << 31))) {
3229 BNX2X_ERR("Cannot acquire nvram interface\n");
3230
3231 rc = -EBUSY;
3232 }
3233
3234 return rc;
3235 }
3236
3237 /* Release split MCP access lock register */
3238 static void bnx2x_unlock_alr(struct bnx2x *bp)
3239 {
3240 u32 val = 0;
3241
3242 REG_WR(bp, GRCBASE_MCP + 0x9c, val);
3243 }
3244
3245 static inline u16 bnx2x_update_dsb_idx(struct bnx2x *bp)
3246 {
3247 struct host_def_status_block *def_sb = bp->def_status_blk;
3248 u16 rc = 0;
3249
3250 barrier(); /* status block is written to by the chip */
3251
3252 if (bp->def_att_idx != def_sb->atten_status_block.attn_bits_index) {
3253 bp->def_att_idx = def_sb->atten_status_block.attn_bits_index;
3254 rc |= 1;
3255 }
3256 if (bp->def_c_idx != def_sb->c_def_status_block.status_block_index) {
3257 bp->def_c_idx = def_sb->c_def_status_block.status_block_index;
3258 rc |= 2;
3259 }
3260 if (bp->def_u_idx != def_sb->u_def_status_block.status_block_index) {
3261 bp->def_u_idx = def_sb->u_def_status_block.status_block_index;
3262 rc |= 4;
3263 }
3264 if (bp->def_x_idx != def_sb->x_def_status_block.status_block_index) {
3265 bp->def_x_idx = def_sb->x_def_status_block.status_block_index;
3266 rc |= 8;
3267 }
3268 if (bp->def_t_idx != def_sb->t_def_status_block.status_block_index) {
3269 bp->def_t_idx = def_sb->t_def_status_block.status_block_index;
3270 rc |= 16;
3271 }
3272 return rc;
3273 }
3274
3275 /*
3276 * slow path service functions
3277 */
3278
3279 static void bnx2x_attn_int_asserted(struct bnx2x *bp, u32 asserted)
3280 {
3281 int port = bp->port;
3282 u32 igu_addr = (IGU_ADDR_ATTN_BITS_SET + IGU_PORT_BASE * port) * 8;
3283 u32 aeu_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
3284 MISC_REG_AEU_MASK_ATTN_FUNC_0;
3285 u32 nig_mask_addr = port ? NIG_REG_MASK_INTERRUPT_PORT1 :
3286 NIG_REG_MASK_INTERRUPT_PORT0;
3287
3288 if (~bp->aeu_mask & (asserted & 0xff))
3289 BNX2X_ERR("IGU ERROR\n");
3290 if (bp->attn_state & asserted)
3291 BNX2X_ERR("IGU ERROR\n");
3292
3293 DP(NETIF_MSG_HW, "aeu_mask %x newly asserted %x\n",
3294 bp->aeu_mask, asserted);
3295 bp->aeu_mask &= ~(asserted & 0xff);
3296 DP(NETIF_MSG_HW, "after masking: aeu_mask %x\n", bp->aeu_mask);
3297
3298 REG_WR(bp, aeu_addr, bp->aeu_mask);
3299
3300 bp->attn_state |= asserted;
3301
3302 if (asserted & ATTN_HARD_WIRED_MASK) {
3303 if (asserted & ATTN_NIG_FOR_FUNC) {
3304 u32 nig_status_port;
3305 u32 nig_int_addr = port ?
3306 NIG_REG_STATUS_INTERRUPT_PORT1 :
3307 NIG_REG_STATUS_INTERRUPT_PORT0;
3308
3309 bp->nig_mask = REG_RD(bp, nig_mask_addr);
3310 REG_WR(bp, nig_mask_addr, 0);
3311
3312 nig_status_port = REG_RD(bp, nig_int_addr);
3313 bnx2x_link_update(bp);
3314
3315 /* handle unicore attn? */
3316 }
3317 if (asserted & ATTN_SW_TIMER_4_FUNC)
3318 DP(NETIF_MSG_HW, "ATTN_SW_TIMER_4_FUNC!\n");
3319
3320 if (asserted & GPIO_2_FUNC)
3321 DP(NETIF_MSG_HW, "GPIO_2_FUNC!\n");
3322
3323 if (asserted & GPIO_3_FUNC)
3324 DP(NETIF_MSG_HW, "GPIO_3_FUNC!\n");
3325
3326 if (asserted & GPIO_4_FUNC)
3327 DP(NETIF_MSG_HW, "GPIO_4_FUNC!\n");
3328
3329 if (port == 0) {
3330 if (asserted & ATTN_GENERAL_ATTN_1) {
3331 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_1!\n");
3332 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_1, 0x0);
3333 }
3334 if (asserted & ATTN_GENERAL_ATTN_2) {
3335 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_2!\n");
3336 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_2, 0x0);
3337 }
3338 if (asserted & ATTN_GENERAL_ATTN_3) {
3339 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_3!\n");
3340 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_3, 0x0);
3341 }
3342 } else {
3343 if (asserted & ATTN_GENERAL_ATTN_4) {
3344 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_4!\n");
3345 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_4, 0x0);
3346 }
3347 if (asserted & ATTN_GENERAL_ATTN_5) {
3348 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_5!\n");
3349 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_5, 0x0);
3350 }
3351 if (asserted & ATTN_GENERAL_ATTN_6) {
3352 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_6!\n");
3353 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_6, 0x0);
3354 }
3355 }
3356
3357 } /* if hardwired */
3358
3359 DP(NETIF_MSG_HW, "about to mask 0x%08x at IGU addr 0x%x\n",
3360 asserted, BAR_IGU_INTMEM + igu_addr);
3361 REG_WR(bp, BAR_IGU_INTMEM + igu_addr, asserted);
3362
3363 /* now set back the mask */
3364 if (asserted & ATTN_NIG_FOR_FUNC)
3365 REG_WR(bp, nig_mask_addr, bp->nig_mask);
3366 }
3367
3368 static void bnx2x_attn_int_deasserted(struct bnx2x *bp, u32 deasserted)
3369 {
3370 int port = bp->port;
3371 int index;
3372 struct attn_route attn;
3373 struct attn_route group_mask;
3374 u32 reg_addr;
3375 u32 val;
3376
3377 /* need to take HW lock because MCP or other port might also
3378 try to handle this event */
3379 bnx2x_lock_alr(bp);
3380
3381 attn.sig[0] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 + port*4);
3382 attn.sig[1] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_2_FUNC_0 + port*4);
3383 attn.sig[2] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_3_FUNC_0 + port*4);
3384 attn.sig[3] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_4_FUNC_0 + port*4);
3385 DP(NETIF_MSG_HW, "attn %llx\n", (unsigned long long)attn.sig[0]);
3386
3387 for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
3388 if (deasserted & (1 << index)) {
3389 group_mask = bp->attn_group[index];
3390
3391 DP(NETIF_MSG_HW, "group[%d]: %llx\n", index,
3392 (unsigned long long)group_mask.sig[0]);
3393
3394 if (attn.sig[3] & group_mask.sig[3] &
3395 EVEREST_GEN_ATTN_IN_USE_MASK) {
3396
3397 if (attn.sig[3] & BNX2X_MC_ASSERT_BITS) {
3398
3399 BNX2X_ERR("MC assert!\n");
3400 bnx2x_panic();
3401
3402 } else if (attn.sig[3] & BNX2X_MCP_ASSERT) {
3403
3404 BNX2X_ERR("MCP assert!\n");
3405 REG_WR(bp,
3406 MISC_REG_AEU_GENERAL_ATTN_11, 0);
3407 bnx2x_mc_assert(bp);
3408
3409 } else {
3410 BNX2X_ERR("UNKOWEN HW ASSERT!\n");
3411 }
3412 }
3413
3414 if (attn.sig[1] & group_mask.sig[1] &
3415 BNX2X_DOORQ_ASSERT) {
3416
3417 val = REG_RD(bp, DORQ_REG_DORQ_INT_STS_CLR);
3418 BNX2X_ERR("DB hw attention 0x%x\n", val);
3419 /* DORQ discard attention */
3420 if (val & 0x2)
3421 BNX2X_ERR("FATAL error from DORQ\n");
3422 }
3423
3424 if (attn.sig[2] & group_mask.sig[2] &
3425 AEU_INPUTS_ATTN_BITS_CFC_HW_INTERRUPT) {
3426
3427 val = REG_RD(bp, CFC_REG_CFC_INT_STS_CLR);
3428 BNX2X_ERR("CFC hw attention 0x%x\n", val);
3429 /* CFC error attention */
3430 if (val & 0x2)
3431 BNX2X_ERR("FATAL error from CFC\n");
3432 }
3433
3434 if (attn.sig[2] & group_mask.sig[2] &
3435 AEU_INPUTS_ATTN_BITS_PXP_HW_INTERRUPT) {
3436
3437 val = REG_RD(bp, PXP_REG_PXP_INT_STS_CLR_0);
3438 BNX2X_ERR("PXP hw attention 0x%x\n", val);
3439 /* RQ_USDMDP_FIFO_OVERFLOW */
3440 if (val & 0x18000)
3441 BNX2X_ERR("FATAL error from PXP\n");
3442 }
3443
3444 if (attn.sig[3] & group_mask.sig[3] &
3445 EVEREST_LATCHED_ATTN_IN_USE_MASK) {
3446
3447 REG_WR(bp, MISC_REG_AEU_CLR_LATCH_SIGNAL,
3448 0x7ff);
3449 DP(NETIF_MSG_HW, "got latched bits 0x%x\n",
3450 attn.sig[3]);
3451 }
3452
3453 if ((attn.sig[0] & group_mask.sig[0] &
3454 HW_INTERRUT_ASSERT_SET_0) ||
3455 (attn.sig[1] & group_mask.sig[1] &
3456 HW_INTERRUT_ASSERT_SET_1) ||
3457 (attn.sig[2] & group_mask.sig[2] &
3458 HW_INTERRUT_ASSERT_SET_2))
3459 BNX2X_ERR("FATAL HW block attention\n");
3460
3461 if ((attn.sig[0] & group_mask.sig[0] &
3462 HW_PRTY_ASSERT_SET_0) ||
3463 (attn.sig[1] & group_mask.sig[1] &
3464 HW_PRTY_ASSERT_SET_1) ||
3465 (attn.sig[2] & group_mask.sig[2] &
3466 HW_PRTY_ASSERT_SET_2))
3467 BNX2X_ERR("FATAL HW block parity atention\n");
3468 }
3469 }
3470
3471 bnx2x_unlock_alr(bp);
3472
3473 reg_addr = (IGU_ADDR_ATTN_BITS_CLR + IGU_PORT_BASE * port) * 8;
3474
3475 val = ~deasserted;
3476 /* DP(NETIF_MSG_INTR, "write 0x%08x to IGU addr 0x%x\n",
3477 val, BAR_IGU_INTMEM + reg_addr); */
3478 REG_WR(bp, BAR_IGU_INTMEM + reg_addr, val);
3479
3480 if (bp->aeu_mask & (deasserted & 0xff))
3481 BNX2X_ERR("IGU BUG\n");
3482 if (~bp->attn_state & deasserted)
3483 BNX2X_ERR("IGU BUG\n");
3484
3485 reg_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
3486 MISC_REG_AEU_MASK_ATTN_FUNC_0;
3487
3488 DP(NETIF_MSG_HW, "aeu_mask %x\n", bp->aeu_mask);
3489 bp->aeu_mask |= (deasserted & 0xff);
3490
3491 DP(NETIF_MSG_HW, "new mask %x\n", bp->aeu_mask);
3492 REG_WR(bp, reg_addr, bp->aeu_mask);
3493
3494 DP(NETIF_MSG_HW, "attn_state %x\n", bp->attn_state);
3495 bp->attn_state &= ~deasserted;
3496 DP(NETIF_MSG_HW, "new state %x\n", bp->attn_state);
3497 }
3498
3499 static void bnx2x_attn_int(struct bnx2x *bp)
3500 {
3501 /* read local copy of bits */
3502 u32 attn_bits = bp->def_status_blk->atten_status_block.attn_bits;
3503 u32 attn_ack = bp->def_status_blk->atten_status_block.attn_bits_ack;
3504 u32 attn_state = bp->attn_state;
3505
3506 /* look for changed bits */
3507 u32 asserted = attn_bits & ~attn_ack & ~attn_state;
3508 u32 deasserted = ~attn_bits & attn_ack & attn_state;
3509
3510 DP(NETIF_MSG_HW,
3511 "attn_bits %x attn_ack %x asserted %x deasserted %x\n",
3512 attn_bits, attn_ack, asserted, deasserted);
3513
3514 if (~(attn_bits ^ attn_ack) & (attn_bits ^ attn_state))
3515 BNX2X_ERR("bad attention state\n");
3516
3517 /* handle bits that were raised */
3518 if (asserted)
3519 bnx2x_attn_int_asserted(bp, asserted);
3520
3521 if (deasserted)
3522 bnx2x_attn_int_deasserted(bp, deasserted);
3523 }
3524
3525 static void bnx2x_sp_task(struct work_struct *work)
3526 {
3527 struct bnx2x *bp = container_of(work, struct bnx2x, sp_task);
3528 u16 status;
3529
3530 /* Return here if interrupt is disabled */
3531 if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
3532 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
3533 return;
3534 }
3535
3536 status = bnx2x_update_dsb_idx(bp);
3537 if (status == 0)
3538 BNX2X_ERR("spurious slowpath interrupt!\n");
3539
3540 DP(NETIF_MSG_INTR, "got a slowpath interrupt (updated %x)\n", status);
3541
3542 if (status & 0x1) {
3543 /* HW attentions */
3544 bnx2x_attn_int(bp);
3545 }
3546
3547 /* CStorm events: query_stats, cfc delete ramrods */
3548 if (status & 0x2)
3549 bp->stat_pending = 0;
3550
3551 bnx2x_ack_sb(bp, DEF_SB_ID, ATTENTION_ID, bp->def_att_idx,
3552 IGU_INT_NOP, 1);
3553 bnx2x_ack_sb(bp, DEF_SB_ID, USTORM_ID, le16_to_cpu(bp->def_u_idx),
3554 IGU_INT_NOP, 1);
3555 bnx2x_ack_sb(bp, DEF_SB_ID, CSTORM_ID, le16_to_cpu(bp->def_c_idx),
3556 IGU_INT_NOP, 1);
3557 bnx2x_ack_sb(bp, DEF_SB_ID, XSTORM_ID, le16_to_cpu(bp->def_x_idx),
3558 IGU_INT_NOP, 1);
3559 bnx2x_ack_sb(bp, DEF_SB_ID, TSTORM_ID, le16_to_cpu(bp->def_t_idx),
3560 IGU_INT_ENABLE, 1);
3561 }
3562
3563 static irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance)
3564 {
3565 struct net_device *dev = dev_instance;
3566 struct bnx2x *bp = netdev_priv(dev);
3567
3568 /* Return here if interrupt is disabled */
3569 if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
3570 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
3571 return IRQ_HANDLED;
3572 }
3573
3574 bnx2x_ack_sb(bp, 16, XSTORM_ID, 0, IGU_INT_DISABLE, 0);
3575
3576 #ifdef BNX2X_STOP_ON_ERROR
3577 if (unlikely(bp->panic))
3578 return IRQ_HANDLED;
3579 #endif
3580
3581 schedule_work(&bp->sp_task);
3582
3583 return IRQ_HANDLED;
3584 }
3585
3586 /* end of slow path */
3587
3588 /* Statistics */
3589
3590 /****************************************************************************
3591 * Macros
3592 ****************************************************************************/
3593
3594 #define UPDATE_STAT(s, t) \
3595 do { \
3596 estats->t += new->s - old->s; \
3597 old->s = new->s; \
3598 } while (0)
3599
3600 /* sum[hi:lo] += add[hi:lo] */
3601 #define ADD_64(s_hi, a_hi, s_lo, a_lo) \
3602 do { \
3603 s_lo += a_lo; \
3604 s_hi += a_hi + (s_lo < a_lo) ? 1 : 0; \
3605 } while (0)
3606
3607 /* difference = minuend - subtrahend */
3608 #define DIFF_64(d_hi, m_hi, s_hi, d_lo, m_lo, s_lo) \
3609 do { \
3610 if (m_lo < s_lo) { /* underflow */ \
3611 d_hi = m_hi - s_hi; \
3612 if (d_hi > 0) { /* we can 'loan' 1 */ \
3613 d_hi--; \
3614 d_lo = m_lo + (UINT_MAX - s_lo) + 1; \
3615 } else { /* m_hi <= s_hi */ \
3616 d_hi = 0; \
3617 d_lo = 0; \
3618 } \
3619 } else { /* m_lo >= s_lo */ \
3620 if (m_hi < s_hi) { \
3621 d_hi = 0; \
3622 d_lo = 0; \
3623 } else { /* m_hi >= s_hi */ \
3624 d_hi = m_hi - s_hi; \
3625 d_lo = m_lo - s_lo; \
3626 } \
3627 } \
3628 } while (0)
3629
3630 /* minuend -= subtrahend */
3631 #define SUB_64(m_hi, s_hi, m_lo, s_lo) \
3632 do { \
3633 DIFF_64(m_hi, m_hi, s_hi, m_lo, m_lo, s_lo); \
3634 } while (0)
3635
3636 #define UPDATE_STAT64(s_hi, t_hi, s_lo, t_lo) \
3637 do { \
3638 DIFF_64(diff.hi, new->s_hi, old->s_hi, \
3639 diff.lo, new->s_lo, old->s_lo); \
3640 old->s_hi = new->s_hi; \
3641 old->s_lo = new->s_lo; \
3642 ADD_64(estats->t_hi, diff.hi, \
3643 estats->t_lo, diff.lo); \
3644 } while (0)
3645
3646 /* sum[hi:lo] += add */
3647 #define ADD_EXTEND_64(s_hi, s_lo, a) \
3648 do { \
3649 s_lo += a; \
3650 s_hi += (s_lo < a) ? 1 : 0; \
3651 } while (0)
3652
3653 #define UPDATE_EXTEND_STAT(s, t_hi, t_lo) \
3654 do { \
3655 ADD_EXTEND_64(estats->t_hi, estats->t_lo, new->s); \
3656 } while (0)
3657
3658 #define UPDATE_EXTEND_TSTAT(s, t_hi, t_lo) \
3659 do { \
3660 diff = le32_to_cpu(tclient->s) - old_tclient->s; \
3661 old_tclient->s = le32_to_cpu(tclient->s); \
3662 ADD_EXTEND_64(estats->t_hi, estats->t_lo, diff); \
3663 } while (0)
3664
3665 /*
3666 * General service functions
3667 */
3668
3669 static inline long bnx2x_hilo(u32 *hiref)
3670 {
3671 u32 lo = *(hiref + 1);
3672 #if (BITS_PER_LONG == 64)
3673 u32 hi = *hiref;
3674
3675 return HILO_U64(hi, lo);
3676 #else
3677 return lo;
3678 #endif
3679 }
3680
3681 /*
3682 * Init service functions
3683 */
3684
3685 static void bnx2x_init_mac_stats(struct bnx2x *bp)
3686 {
3687 struct dmae_command *dmae;
3688 int port = bp->port;
3689 int loader_idx = port * 8;
3690 u32 opcode;
3691 u32 mac_addr;
3692
3693 bp->executer_idx = 0;
3694 if (bp->fw_mb) {
3695 /* MCP */
3696 opcode = (DMAE_CMD_SRC_PCI | DMAE_CMD_DST_GRC |
3697 DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
3698 #ifdef __BIG_ENDIAN
3699 DMAE_CMD_ENDIANITY_B_DW_SWAP |
3700 #else
3701 DMAE_CMD_ENDIANITY_DW_SWAP |
3702 #endif
3703 (port ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0));
3704
3705 if (bp->link_up)
3706 opcode |= (DMAE_CMD_C_DST_GRC | DMAE_CMD_C_ENABLE);
3707
3708 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3709 dmae->opcode = opcode;
3710 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, eth_stats) +
3711 sizeof(u32));
3712 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, eth_stats) +
3713 sizeof(u32));
3714 dmae->dst_addr_lo = bp->fw_mb >> 2;
3715 dmae->dst_addr_hi = 0;
3716 dmae->len = (offsetof(struct bnx2x_eth_stats, mac_stx_end) -
3717 sizeof(u32)) >> 2;
3718 if (bp->link_up) {
3719 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3720 dmae->comp_addr_hi = 0;
3721 dmae->comp_val = 1;
3722 } else {
3723 dmae->comp_addr_lo = 0;
3724 dmae->comp_addr_hi = 0;
3725 dmae->comp_val = 0;
3726 }
3727 }
3728
3729 if (!bp->link_up) {
3730 /* no need to collect statistics in link down */
3731 return;
3732 }
3733
3734 opcode = (DMAE_CMD_SRC_GRC | DMAE_CMD_DST_PCI |
3735 DMAE_CMD_C_DST_GRC | DMAE_CMD_C_ENABLE |
3736 DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
3737 #ifdef __BIG_ENDIAN
3738 DMAE_CMD_ENDIANITY_B_DW_SWAP |
3739 #else
3740 DMAE_CMD_ENDIANITY_DW_SWAP |
3741 #endif
3742 (port ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0));
3743
3744 if (bp->phy_flags & PHY_BMAC_FLAG) {
3745
3746 mac_addr = (port ? NIG_REG_INGRESS_BMAC1_MEM :
3747 NIG_REG_INGRESS_BMAC0_MEM);
3748
3749 /* BIGMAC_REGISTER_TX_STAT_GTPKT ..
3750 BIGMAC_REGISTER_TX_STAT_GTBYT */
3751 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3752 dmae->opcode = opcode;
3753 dmae->src_addr_lo = (mac_addr +
3754 BIGMAC_REGISTER_TX_STAT_GTPKT) >> 2;
3755 dmae->src_addr_hi = 0;
3756 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats));
3757 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats));
3758 dmae->len = (8 + BIGMAC_REGISTER_TX_STAT_GTBYT -
3759 BIGMAC_REGISTER_TX_STAT_GTPKT) >> 2;
3760 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3761 dmae->comp_addr_hi = 0;
3762 dmae->comp_val = 1;
3763
3764 /* BIGMAC_REGISTER_RX_STAT_GR64 ..
3765 BIGMAC_REGISTER_RX_STAT_GRIPJ */
3766 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3767 dmae->opcode = opcode;
3768 dmae->src_addr_lo = (mac_addr +
3769 BIGMAC_REGISTER_RX_STAT_GR64) >> 2;
3770 dmae->src_addr_hi = 0;
3771 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats) +
3772 offsetof(struct bmac_stats, rx_gr64));
3773 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats) +
3774 offsetof(struct bmac_stats, rx_gr64));
3775 dmae->len = (8 + BIGMAC_REGISTER_RX_STAT_GRIPJ -
3776 BIGMAC_REGISTER_RX_STAT_GR64) >> 2;
3777 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3778 dmae->comp_addr_hi = 0;
3779 dmae->comp_val = 1;
3780
3781 } else if (bp->phy_flags & PHY_EMAC_FLAG) {
3782
3783 mac_addr = (port ? GRCBASE_EMAC1 : GRCBASE_EMAC0);
3784
3785 /* EMAC_REG_EMAC_RX_STAT_AC (EMAC_REG_EMAC_RX_STAT_AC_COUNT)*/
3786 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3787 dmae->opcode = opcode;
3788 dmae->src_addr_lo = (mac_addr +
3789 EMAC_REG_EMAC_RX_STAT_AC) >> 2;
3790 dmae->src_addr_hi = 0;
3791 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats));
3792 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats));
3793 dmae->len = EMAC_REG_EMAC_RX_STAT_AC_COUNT;
3794 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3795 dmae->comp_addr_hi = 0;
3796 dmae->comp_val = 1;
3797
3798 /* EMAC_REG_EMAC_RX_STAT_AC_28 */
3799 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3800 dmae->opcode = opcode;
3801 dmae->src_addr_lo = (mac_addr +
3802 EMAC_REG_EMAC_RX_STAT_AC_28) >> 2;
3803 dmae->src_addr_hi = 0;
3804 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats) +
3805 offsetof(struct emac_stats,
3806 rx_falsecarriererrors));
3807 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats) +
3808 offsetof(struct emac_stats,
3809 rx_falsecarriererrors));
3810 dmae->len = 1;
3811 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3812 dmae->comp_addr_hi = 0;
3813 dmae->comp_val = 1;
3814
3815 /* EMAC_REG_EMAC_TX_STAT_AC (EMAC_REG_EMAC_TX_STAT_AC_COUNT)*/
3816 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3817 dmae->opcode = opcode;
3818 dmae->src_addr_lo = (mac_addr +
3819 EMAC_REG_EMAC_TX_STAT_AC) >> 2;
3820 dmae->src_addr_hi = 0;
3821 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats) +
3822 offsetof(struct emac_stats,
3823 tx_ifhcoutoctets));
3824 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats) +
3825 offsetof(struct emac_stats,
3826 tx_ifhcoutoctets));
3827 dmae->len = EMAC_REG_EMAC_TX_STAT_AC_COUNT;
3828 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3829 dmae->comp_addr_hi = 0;
3830 dmae->comp_val = 1;
3831 }
3832
3833 /* NIG */
3834 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3835 dmae->opcode = (DMAE_CMD_SRC_GRC | DMAE_CMD_DST_PCI |
3836 DMAE_CMD_C_DST_PCI | DMAE_CMD_C_ENABLE |
3837 DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
3838 #ifdef __BIG_ENDIAN
3839 DMAE_CMD_ENDIANITY_B_DW_SWAP |
3840 #else
3841 DMAE_CMD_ENDIANITY_DW_SWAP |
3842 #endif
3843 (port ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0));
3844 dmae->src_addr_lo = (port ? NIG_REG_STAT1_BRB_DISCARD :
3845 NIG_REG_STAT0_BRB_DISCARD) >> 2;
3846 dmae->src_addr_hi = 0;
3847 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig));
3848 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig));
3849 dmae->len = (sizeof(struct nig_stats) - 2*sizeof(u32)) >> 2;
3850 dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig) +
3851 offsetof(struct nig_stats, done));
3852 dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig) +
3853 offsetof(struct nig_stats, done));
3854 dmae->comp_val = 0xffffffff;
3855 }
3856
3857 static void bnx2x_init_stats(struct bnx2x *bp)
3858 {
3859 int port = bp->port;
3860
3861 bp->stats_state = STATS_STATE_DISABLE;
3862 bp->executer_idx = 0;
3863
3864 bp->old_brb_discard = REG_RD(bp,
3865 NIG_REG_STAT0_BRB_DISCARD + port*0x38);
3866
3867 memset(&bp->old_bmac, 0, sizeof(struct bmac_stats));
3868 memset(&bp->old_tclient, 0, sizeof(struct tstorm_per_client_stats));
3869 memset(&bp->dev->stats, 0, sizeof(struct net_device_stats));
3870
3871 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_STATS_FLAGS_OFFSET(port), 1);
3872 REG_WR(bp, BAR_XSTRORM_INTMEM +
3873 XSTORM_STATS_FLAGS_OFFSET(port) + 4, 0);
3874
3875 REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_STATS_FLAGS_OFFSET(port), 1);
3876 REG_WR(bp, BAR_TSTRORM_INTMEM +
3877 TSTORM_STATS_FLAGS_OFFSET(port) + 4, 0);
3878
3879 REG_WR(bp, BAR_CSTRORM_INTMEM + CSTORM_STATS_FLAGS_OFFSET(port), 0);
3880 REG_WR(bp, BAR_CSTRORM_INTMEM +
3881 CSTORM_STATS_FLAGS_OFFSET(port) + 4, 0);
3882
3883 REG_WR(bp, BAR_XSTRORM_INTMEM +
3884 XSTORM_ETH_STATS_QUERY_ADDR_OFFSET(port),
3885 U64_LO(bnx2x_sp_mapping(bp, fw_stats)));
3886 REG_WR(bp, BAR_XSTRORM_INTMEM +
3887 XSTORM_ETH_STATS_QUERY_ADDR_OFFSET(port) + 4,
3888 U64_HI(bnx2x_sp_mapping(bp, fw_stats)));
3889
3890 REG_WR(bp, BAR_TSTRORM_INTMEM +
3891 TSTORM_ETH_STATS_QUERY_ADDR_OFFSET(port),
3892 U64_LO(bnx2x_sp_mapping(bp, fw_stats)));
3893 REG_WR(bp, BAR_TSTRORM_INTMEM +
3894 TSTORM_ETH_STATS_QUERY_ADDR_OFFSET(port) + 4,
3895 U64_HI(bnx2x_sp_mapping(bp, fw_stats)));
3896 }
3897
3898 static void bnx2x_stop_stats(struct bnx2x *bp)
3899 {
3900 might_sleep();
3901 if (bp->stats_state != STATS_STATE_DISABLE) {
3902 int timeout = 10;
3903
3904 bp->stats_state = STATS_STATE_STOP;
3905 DP(BNX2X_MSG_STATS, "stats_state - STOP\n");
3906
3907 while (bp->stats_state != STATS_STATE_DISABLE) {
3908 if (!timeout) {
3909 BNX2X_ERR("timeout wating for stats stop\n");
3910 break;
3911 }
3912 timeout--;
3913 msleep(100);
3914 }
3915 }
3916 DP(BNX2X_MSG_STATS, "stats_state - DISABLE\n");
3917 }
3918
3919 /*
3920 * Statistics service functions
3921 */
3922
3923 static void bnx2x_update_bmac_stats(struct bnx2x *bp)
3924 {
3925 struct regp diff;
3926 struct regp sum;
3927 struct bmac_stats *new = bnx2x_sp(bp, mac_stats.bmac);
3928 struct bmac_stats *old = &bp->old_bmac;
3929 struct bnx2x_eth_stats *estats = bnx2x_sp(bp, eth_stats);
3930
3931 sum.hi = 0;
3932 sum.lo = 0;
3933
3934 UPDATE_STAT64(tx_gtbyt.hi, total_bytes_transmitted_hi,
3935 tx_gtbyt.lo, total_bytes_transmitted_lo);
3936
3937 UPDATE_STAT64(tx_gtmca.hi, total_multicast_packets_transmitted_hi,
3938 tx_gtmca.lo, total_multicast_packets_transmitted_lo);
3939 ADD_64(sum.hi, diff.hi, sum.lo, diff.lo);
3940
3941 UPDATE_STAT64(tx_gtgca.hi, total_broadcast_packets_transmitted_hi,
3942 tx_gtgca.lo, total_broadcast_packets_transmitted_lo);
3943 ADD_64(sum.hi, diff.hi, sum.lo, diff.lo);
3944
3945 UPDATE_STAT64(tx_gtpkt.hi, total_unicast_packets_transmitted_hi,
3946 tx_gtpkt.lo, total_unicast_packets_transmitted_lo);
3947 SUB_64(estats->total_unicast_packets_transmitted_hi, sum.hi,
3948 estats->total_unicast_packets_transmitted_lo, sum.lo);
3949
3950 UPDATE_STAT(tx_gtxpf.lo, pause_xoff_frames_transmitted);
3951 UPDATE_STAT(tx_gt64.lo, frames_transmitted_64_bytes);
3952 UPDATE_STAT(tx_gt127.lo, frames_transmitted_65_127_bytes);
3953 UPDATE_STAT(tx_gt255.lo, frames_transmitted_128_255_bytes);
3954 UPDATE_STAT(tx_gt511.lo, frames_transmitted_256_511_bytes);
3955 UPDATE_STAT(tx_gt1023.lo, frames_transmitted_512_1023_bytes);
3956 UPDATE_STAT(tx_gt1518.lo, frames_transmitted_1024_1522_bytes);
3957 UPDATE_STAT(tx_gt2047.lo, frames_transmitted_1523_9022_bytes);
3958 UPDATE_STAT(tx_gt4095.lo, frames_transmitted_1523_9022_bytes);
3959 UPDATE_STAT(tx_gt9216.lo, frames_transmitted_1523_9022_bytes);
3960 UPDATE_STAT(tx_gt16383.lo, frames_transmitted_1523_9022_bytes);
3961
3962 UPDATE_STAT(rx_grfcs.lo, crc_receive_errors);
3963 UPDATE_STAT(rx_grund.lo, runt_packets_received);
3964 UPDATE_STAT(rx_grovr.lo, stat_Dot3statsFramesTooLong);
3965 UPDATE_STAT(rx_grxpf.lo, pause_xoff_frames_received);
3966 UPDATE_STAT(rx_grxcf.lo, control_frames_received);
3967 /* UPDATE_STAT(rx_grxpf.lo, control_frames_received); */
3968 UPDATE_STAT(rx_grfrg.lo, error_runt_packets_received);
3969 UPDATE_STAT(rx_grjbr.lo, error_jabber_packets_received);
3970
3971 UPDATE_STAT64(rx_grerb.hi, stat_IfHCInBadOctets_hi,
3972 rx_grerb.lo, stat_IfHCInBadOctets_lo);
3973 UPDATE_STAT64(tx_gtufl.hi, stat_IfHCOutBadOctets_hi,
3974 tx_gtufl.lo, stat_IfHCOutBadOctets_lo);
3975 UPDATE_STAT(tx_gterr.lo, stat_Dot3statsInternalMacTransmitErrors);
3976 /* UPDATE_STAT(rx_grxpf.lo, stat_XoffStateEntered); */
3977 estats->stat_XoffStateEntered = estats->pause_xoff_frames_received;
3978 }
3979
3980 static void bnx2x_update_emac_stats(struct bnx2x *bp)
3981 {
3982 struct emac_stats *new = bnx2x_sp(bp, mac_stats.emac);
3983 struct bnx2x_eth_stats *estats = bnx2x_sp(bp, eth_stats);
3984
3985 UPDATE_EXTEND_STAT(tx_ifhcoutoctets, total_bytes_transmitted_hi,
3986 total_bytes_transmitted_lo);
3987 UPDATE_EXTEND_STAT(tx_ifhcoutucastpkts,
3988 total_unicast_packets_transmitted_hi,
3989 total_unicast_packets_transmitted_lo);
3990 UPDATE_EXTEND_STAT(tx_ifhcoutmulticastpkts,
3991 total_multicast_packets_transmitted_hi,
3992 total_multicast_packets_transmitted_lo);
3993 UPDATE_EXTEND_STAT(tx_ifhcoutbroadcastpkts,
3994 total_broadcast_packets_transmitted_hi,
3995 total_broadcast_packets_transmitted_lo);
3996
3997 estats->pause_xon_frames_transmitted += new->tx_outxonsent;
3998 estats->pause_xoff_frames_transmitted += new->tx_outxoffsent;
3999 estats->single_collision_transmit_frames +=
4000 new->tx_dot3statssinglecollisionframes;
4001 estats->multiple_collision_transmit_frames +=
4002 new->tx_dot3statsmultiplecollisionframes;
4003 estats->late_collision_frames += new->tx_dot3statslatecollisions;
4004 estats->excessive_collision_frames +=
4005 new->tx_dot3statsexcessivecollisions;
4006 estats->frames_transmitted_64_bytes += new->tx_etherstatspkts64octets;
4007 estats->frames_transmitted_65_127_bytes +=
4008 new->tx_etherstatspkts65octetsto127octets;
4009 estats->frames_transmitted_128_255_bytes +=
4010 new->tx_etherstatspkts128octetsto255octets;
4011 estats->frames_transmitted_256_511_bytes +=
4012 new->tx_etherstatspkts256octetsto511octets;
4013 estats->frames_transmitted_512_1023_bytes +=
4014 new->tx_etherstatspkts512octetsto1023octets;
4015 estats->frames_transmitted_1024_1522_bytes +=
4016 new->tx_etherstatspkts1024octetsto1522octet;
4017 estats->frames_transmitted_1523_9022_bytes +=
4018 new->tx_etherstatspktsover1522octets;
4019
4020 estats->crc_receive_errors += new->rx_dot3statsfcserrors;
4021 estats->alignment_errors += new->rx_dot3statsalignmenterrors;
4022 estats->false_carrier_detections += new->rx_falsecarriererrors;
4023 estats->runt_packets_received += new->rx_etherstatsundersizepkts;
4024 estats->stat_Dot3statsFramesTooLong += new->rx_dot3statsframestoolong;
4025 estats->pause_xon_frames_received += new->rx_xonpauseframesreceived;
4026 estats->pause_xoff_frames_received += new->rx_xoffpauseframesreceived;
4027 estats->control_frames_received += new->rx_maccontrolframesreceived;
4028 estats->error_runt_packets_received += new->rx_etherstatsfragments;
4029 estats->error_jabber_packets_received += new->rx_etherstatsjabbers;
4030
4031 UPDATE_EXTEND_STAT(rx_ifhcinbadoctets, stat_IfHCInBadOctets_hi,
4032 stat_IfHCInBadOctets_lo);
4033 UPDATE_EXTEND_STAT(tx_ifhcoutbadoctets, stat_IfHCOutBadOctets_hi,
4034 stat_IfHCOutBadOctets_lo);
4035 estats->stat_Dot3statsInternalMacTransmitErrors +=
4036 new->tx_dot3statsinternalmactransmiterrors;
4037 estats->stat_Dot3StatsCarrierSenseErrors +=
4038 new->rx_dot3statscarriersenseerrors;
4039 estats->stat_Dot3StatsDeferredTransmissions +=
4040 new->tx_dot3statsdeferredtransmissions;
4041 estats->stat_FlowControlDone += new->tx_flowcontroldone;
4042 estats->stat_XoffStateEntered += new->rx_xoffstateentered;
4043 }
4044
4045 static int bnx2x_update_storm_stats(struct bnx2x *bp)
4046 {
4047 struct eth_stats_query *stats = bnx2x_sp(bp, fw_stats);
4048 struct tstorm_common_stats *tstats = &stats->tstorm_common;
4049 struct tstorm_per_client_stats *tclient =
4050 &tstats->client_statistics[0];
4051 struct tstorm_per_client_stats *old_tclient = &bp->old_tclient;
4052 struct xstorm_common_stats *xstats = &stats->xstorm_common;
4053 struct nig_stats *nstats = bnx2x_sp(bp, nig);
4054 struct bnx2x_eth_stats *estats = bnx2x_sp(bp, eth_stats);
4055 u32 diff;
4056
4057 /* are DMAE stats valid? */
4058 if (nstats->done != 0xffffffff) {
4059 DP(BNX2X_MSG_STATS, "stats not updated by dmae\n");
4060 return -1;
4061 }
4062
4063 /* are storm stats valid? */
4064 if (tstats->done.hi != 0xffffffff) {
4065 DP(BNX2X_MSG_STATS, "stats not updated by tstorm\n");
4066 return -2;
4067 }
4068 if (xstats->done.hi != 0xffffffff) {
4069 DP(BNX2X_MSG_STATS, "stats not updated by xstorm\n");
4070 return -3;
4071 }
4072
4073 estats->total_bytes_received_hi =
4074 estats->valid_bytes_received_hi =
4075 le32_to_cpu(tclient->total_rcv_bytes.hi);
4076 estats->total_bytes_received_lo =
4077 estats->valid_bytes_received_lo =
4078 le32_to_cpu(tclient->total_rcv_bytes.lo);
4079 ADD_64(estats->total_bytes_received_hi,
4080 le32_to_cpu(tclient->rcv_error_bytes.hi),
4081 estats->total_bytes_received_lo,
4082 le32_to_cpu(tclient->rcv_error_bytes.lo));
4083
4084 UPDATE_EXTEND_TSTAT(rcv_unicast_pkts,
4085 total_unicast_packets_received_hi,
4086 total_unicast_packets_received_lo);
4087 UPDATE_EXTEND_TSTAT(rcv_multicast_pkts,
4088 total_multicast_packets_received_hi,
4089 total_multicast_packets_received_lo);
4090 UPDATE_EXTEND_TSTAT(rcv_broadcast_pkts,
4091 total_broadcast_packets_received_hi,
4092 total_broadcast_packets_received_lo);
4093
4094 estats->frames_received_64_bytes = MAC_STX_NA;
4095 estats->frames_received_65_127_bytes = MAC_STX_NA;
4096 estats->frames_received_128_255_bytes = MAC_STX_NA;
4097 estats->frames_received_256_511_bytes = MAC_STX_NA;
4098 estats->frames_received_512_1023_bytes = MAC_STX_NA;
4099 estats->frames_received_1024_1522_bytes = MAC_STX_NA;
4100 estats->frames_received_1523_9022_bytes = MAC_STX_NA;
4101
4102 estats->x_total_sent_bytes_hi =
4103 le32_to_cpu(xstats->total_sent_bytes.hi);
4104 estats->x_total_sent_bytes_lo =
4105 le32_to_cpu(xstats->total_sent_bytes.lo);
4106 estats->x_total_sent_pkts = le32_to_cpu(xstats->total_sent_pkts);
4107
4108 estats->t_rcv_unicast_bytes_hi =
4109 le32_to_cpu(tclient->rcv_unicast_bytes.hi);
4110 estats->t_rcv_unicast_bytes_lo =
4111 le32_to_cpu(tclient->rcv_unicast_bytes.lo);
4112 estats->t_rcv_broadcast_bytes_hi =
4113 le32_to_cpu(tclient->rcv_broadcast_bytes.hi);
4114 estats->t_rcv_broadcast_bytes_lo =
4115 le32_to_cpu(tclient->rcv_broadcast_bytes.lo);
4116 estats->t_rcv_multicast_bytes_hi =
4117 le32_to_cpu(tclient->rcv_multicast_bytes.hi);
4118 estats->t_rcv_multicast_bytes_lo =
4119 le32_to_cpu(tclient->rcv_multicast_bytes.lo);
4120 estats->t_total_rcv_pkt = le32_to_cpu(tclient->total_rcv_pkts);
4121
4122 estats->checksum_discard = le32_to_cpu(tclient->checksum_discard);
4123 estats->packets_too_big_discard =
4124 le32_to_cpu(tclient->packets_too_big_discard);
4125 estats->jabber_packets_received = estats->packets_too_big_discard +
4126 estats->stat_Dot3statsFramesTooLong;
4127 estats->no_buff_discard = le32_to_cpu(tclient->no_buff_discard);
4128 estats->ttl0_discard = le32_to_cpu(tclient->ttl0_discard);
4129 estats->mac_discard = le32_to_cpu(tclient->mac_discard);
4130 estats->mac_filter_discard = le32_to_cpu(tstats->mac_filter_discard);
4131 estats->xxoverflow_discard = le32_to_cpu(tstats->xxoverflow_discard);
4132 estats->brb_truncate_discard =
4133 le32_to_cpu(tstats->brb_truncate_discard);
4134
4135 estats->brb_discard += nstats->brb_discard - bp->old_brb_discard;
4136 bp->old_brb_discard = nstats->brb_discard;
4137
4138 estats->brb_packet = nstats->brb_packet;
4139 estats->brb_truncate = nstats->brb_truncate;
4140 estats->flow_ctrl_discard = nstats->flow_ctrl_discard;
4141 estats->flow_ctrl_octets = nstats->flow_ctrl_octets;
4142 estats->flow_ctrl_packet = nstats->flow_ctrl_packet;
4143 estats->mng_discard = nstats->mng_discard;
4144 estats->mng_octet_inp = nstats->mng_octet_inp;
4145 estats->mng_octet_out = nstats->mng_octet_out;
4146 estats->mng_packet_inp = nstats->mng_packet_inp;
4147 estats->mng_packet_out = nstats->mng_packet_out;
4148 estats->pbf_octets = nstats->pbf_octets;
4149 estats->pbf_packet = nstats->pbf_packet;
4150 estats->safc_inp = nstats->safc_inp;
4151
4152 xstats->done.hi = 0;
4153 tstats->done.hi = 0;
4154 nstats->done = 0;
4155
4156 return 0;
4157 }
4158
4159 static void bnx2x_update_net_stats(struct bnx2x *bp)
4160 {
4161 struct bnx2x_eth_stats *estats = bnx2x_sp(bp, eth_stats);
4162 struct net_device_stats *nstats = &bp->dev->stats;
4163
4164 nstats->rx_packets =
4165 bnx2x_hilo(&estats->total_unicast_packets_received_hi) +
4166 bnx2x_hilo(&estats->total_multicast_packets_received_hi) +
4167 bnx2x_hilo(&estats->total_broadcast_packets_received_hi);
4168
4169 nstats->tx_packets =
4170 bnx2x_hilo(&estats->total_unicast_packets_transmitted_hi) +
4171 bnx2x_hilo(&estats->total_multicast_packets_transmitted_hi) +
4172 bnx2x_hilo(&estats->total_broadcast_packets_transmitted_hi);
4173
4174 nstats->rx_bytes = bnx2x_hilo(&estats->total_bytes_received_hi);
4175
4176 nstats->tx_bytes =
4177 bnx2x_hilo(&estats->total_bytes_transmitted_hi);
4178
4179 nstats->rx_dropped = estats->checksum_discard +
4180 estats->mac_discard;
4181 nstats->tx_dropped = 0;
4182
4183 nstats->multicast =
4184 bnx2x_hilo(&estats->total_multicast_packets_transmitted_hi);
4185
4186 nstats->collisions =
4187 estats->single_collision_transmit_frames +
4188 estats->multiple_collision_transmit_frames +
4189 estats->late_collision_frames +
4190 estats->excessive_collision_frames;
4191
4192 nstats->rx_length_errors = estats->runt_packets_received +
4193 estats->jabber_packets_received;
4194 nstats->rx_over_errors = estats->no_buff_discard;
4195 nstats->rx_crc_errors = estats->crc_receive_errors;
4196 nstats->rx_frame_errors = estats->alignment_errors;
4197 nstats->rx_fifo_errors = estats->brb_discard +
4198 estats->brb_truncate_discard;
4199 nstats->rx_missed_errors = estats->xxoverflow_discard;
4200
4201 nstats->rx_errors = nstats->rx_length_errors +
4202 nstats->rx_over_errors +
4203 nstats->rx_crc_errors +
4204 nstats->rx_frame_errors +
4205 nstats->rx_fifo_errors;
4206
4207 nstats->tx_aborted_errors = estats->late_collision_frames +
4208 estats->excessive_collision_frames;
4209 nstats->tx_carrier_errors = estats->false_carrier_detections;
4210 nstats->tx_fifo_errors = 0;
4211 nstats->tx_heartbeat_errors = 0;
4212 nstats->tx_window_errors = 0;
4213
4214 nstats->tx_errors = nstats->tx_aborted_errors +
4215 nstats->tx_carrier_errors;
4216
4217 estats->mac_stx_start = ++estats->mac_stx_end;
4218 }
4219
4220 static void bnx2x_update_stats(struct bnx2x *bp)
4221 {
4222 int i;
4223
4224 if (!bnx2x_update_storm_stats(bp)) {
4225
4226 if (bp->phy_flags & PHY_BMAC_FLAG) {
4227 bnx2x_update_bmac_stats(bp);
4228
4229 } else if (bp->phy_flags & PHY_EMAC_FLAG) {
4230 bnx2x_update_emac_stats(bp);
4231
4232 } else { /* unreached */
4233 BNX2X_ERR("no MAC active\n");
4234 return;
4235 }
4236
4237 bnx2x_update_net_stats(bp);
4238 }
4239
4240 if (bp->msglevel & NETIF_MSG_TIMER) {
4241 struct bnx2x_eth_stats *estats = bnx2x_sp(bp, eth_stats);
4242 struct net_device_stats *nstats = &bp->dev->stats;
4243
4244 printk(KERN_DEBUG "%s:\n", bp->dev->name);
4245 printk(KERN_DEBUG " tx avail (%4x) tx hc idx (%x)"
4246 " tx pkt (%lx)\n",
4247 bnx2x_tx_avail(bp->fp),
4248 *bp->fp->tx_cons_sb, nstats->tx_packets);
4249 printk(KERN_DEBUG " rx usage (%4x) rx hc idx (%x)"
4250 " rx pkt (%lx)\n",
4251 (u16)(*bp->fp->rx_cons_sb - bp->fp->rx_comp_cons),
4252 *bp->fp->rx_cons_sb, nstats->rx_packets);
4253 printk(KERN_DEBUG " %s (Xoff events %u) brb drops %u\n",
4254 netif_queue_stopped(bp->dev)? "Xoff" : "Xon",
4255 estats->driver_xoff, estats->brb_discard);
4256 printk(KERN_DEBUG "tstats: checksum_discard %u "
4257 "packets_too_big_discard %u no_buff_discard %u "
4258 "mac_discard %u mac_filter_discard %u "
4259 "xxovrflow_discard %u brb_truncate_discard %u "
4260 "ttl0_discard %u\n",
4261 estats->checksum_discard,
4262 estats->packets_too_big_discard,
4263 estats->no_buff_discard, estats->mac_discard,
4264 estats->mac_filter_discard, estats->xxoverflow_discard,
4265 estats->brb_truncate_discard, estats->ttl0_discard);
4266
4267 for_each_queue(bp, i) {
4268 printk(KERN_DEBUG "[%d]: %lu\t%lu\t%lu\n", i,
4269 bnx2x_fp(bp, i, tx_pkt),
4270 bnx2x_fp(bp, i, rx_pkt),
4271 bnx2x_fp(bp, i, rx_calls));
4272 }
4273 }
4274
4275 if (bp->state != BNX2X_STATE_OPEN) {
4276 DP(BNX2X_MSG_STATS, "state is %x, returning\n", bp->state);
4277 return;
4278 }
4279
4280 #ifdef BNX2X_STOP_ON_ERROR
4281 if (unlikely(bp->panic))
4282 return;
4283 #endif
4284
4285 /* loader */
4286 if (bp->executer_idx) {
4287 struct dmae_command *dmae = &bp->dmae;
4288 int port = bp->port;
4289 int loader_idx = port * 8;
4290
4291 memset(dmae, 0, sizeof(struct dmae_command));
4292
4293 dmae->opcode = (DMAE_CMD_SRC_PCI | DMAE_CMD_DST_GRC |
4294 DMAE_CMD_C_DST_GRC | DMAE_CMD_C_ENABLE |
4295 DMAE_CMD_DST_RESET |
4296 #ifdef __BIG_ENDIAN
4297 DMAE_CMD_ENDIANITY_B_DW_SWAP |
4298 #else
4299 DMAE_CMD_ENDIANITY_DW_SWAP |
4300 #endif
4301 (port ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0));
4302 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, dmae[0]));
4303 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, dmae[0]));
4304 dmae->dst_addr_lo = (DMAE_REG_CMD_MEM +
4305 sizeof(struct dmae_command) *
4306 (loader_idx + 1)) >> 2;
4307 dmae->dst_addr_hi = 0;
4308 dmae->len = sizeof(struct dmae_command) >> 2;
4309 dmae->len--; /* !!! for A0/1 only */
4310 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx + 1] >> 2;
4311 dmae->comp_addr_hi = 0;
4312 dmae->comp_val = 1;
4313
4314 bnx2x_post_dmae(bp, dmae, loader_idx);
4315 }
4316
4317 if (bp->stats_state != STATS_STATE_ENABLE) {
4318 bp->stats_state = STATS_STATE_DISABLE;
4319 return;
4320 }
4321
4322 if (bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_STAT_QUERY, 0, 0, 0, 0) == 0) {
4323 /* stats ramrod has it's own slot on the spe */
4324 bp->spq_left++;
4325 bp->stat_pending = 1;
4326 }
4327 }
4328
4329 static void bnx2x_timer(unsigned long data)
4330 {
4331 struct bnx2x *bp = (struct bnx2x *) data;
4332
4333 if (!netif_running(bp->dev))
4334 return;
4335
4336 if (atomic_read(&bp->intr_sem) != 0)
4337 goto bnx2x_restart_timer;
4338
4339 if (poll) {
4340 struct bnx2x_fastpath *fp = &bp->fp[0];
4341 int rc;
4342
4343 bnx2x_tx_int(fp, 1000);
4344 rc = bnx2x_rx_int(fp, 1000);
4345 }
4346
4347 if (!nomcp && (bp->bc_ver >= 0x040003)) {
4348 int port = bp->port;
4349 u32 drv_pulse;
4350 u32 mcp_pulse;
4351
4352 ++bp->fw_drv_pulse_wr_seq;
4353 bp->fw_drv_pulse_wr_seq &= DRV_PULSE_SEQ_MASK;
4354 /* TBD - add SYSTEM_TIME */
4355 drv_pulse = bp->fw_drv_pulse_wr_seq;
4356 SHMEM_WR(bp, drv_fw_mb[port].drv_pulse_mb, drv_pulse);
4357
4358 mcp_pulse = (SHMEM_RD(bp, drv_fw_mb[port].mcp_pulse_mb) &
4359 MCP_PULSE_SEQ_MASK);
4360 /* The delta between driver pulse and mcp response
4361 * should be 1 (before mcp response) or 0 (after mcp response)
4362 */
4363 if ((drv_pulse != mcp_pulse) &&
4364 (drv_pulse != ((mcp_pulse + 1) & MCP_PULSE_SEQ_MASK))) {
4365 /* someone lost a heartbeat... */
4366 BNX2X_ERR("drv_pulse (0x%x) != mcp_pulse (0x%x)\n",
4367 drv_pulse, mcp_pulse);
4368 }
4369 }
4370
4371 if (bp->stats_state == STATS_STATE_DISABLE)
4372 goto bnx2x_restart_timer;
4373
4374 bnx2x_update_stats(bp);
4375
4376 bnx2x_restart_timer:
4377 mod_timer(&bp->timer, jiffies + bp->current_interval);
4378 }
4379
4380 /* end of Statistics */
4381
4382 /* nic init */
4383
4384 /*
4385 * nic init service functions
4386 */
4387
4388 static void bnx2x_init_sb(struct bnx2x *bp, struct host_status_block *sb,
4389 dma_addr_t mapping, int id)
4390 {
4391 int port = bp->port;
4392 u64 section;
4393 int index;
4394
4395 /* USTORM */
4396 section = ((u64)mapping) + offsetof(struct host_status_block,
4397 u_status_block);
4398 sb->u_status_block.status_block_id = id;
4399
4400 REG_WR(bp, BAR_USTRORM_INTMEM +
4401 USTORM_SB_HOST_SB_ADDR_OFFSET(port, id), U64_LO(section));
4402 REG_WR(bp, BAR_USTRORM_INTMEM +
4403 ((USTORM_SB_HOST_SB_ADDR_OFFSET(port, id)) + 4),
4404 U64_HI(section));
4405
4406 for (index = 0; index < HC_USTORM_SB_NUM_INDICES; index++)
4407 REG_WR16(bp, BAR_USTRORM_INTMEM +
4408 USTORM_SB_HC_DISABLE_OFFSET(port, id, index), 0x1);
4409
4410 /* CSTORM */
4411 section = ((u64)mapping) + offsetof(struct host_status_block,
4412 c_status_block);
4413 sb->c_status_block.status_block_id = id;
4414
4415 REG_WR(bp, BAR_CSTRORM_INTMEM +
4416 CSTORM_SB_HOST_SB_ADDR_OFFSET(port, id), U64_LO(section));
4417 REG_WR(bp, BAR_CSTRORM_INTMEM +
4418 ((CSTORM_SB_HOST_SB_ADDR_OFFSET(port, id)) + 4),
4419 U64_HI(section));
4420
4421 for (index = 0; index < HC_CSTORM_SB_NUM_INDICES; index++)
4422 REG_WR16(bp, BAR_CSTRORM_INTMEM +
4423 CSTORM_SB_HC_DISABLE_OFFSET(port, id, index), 0x1);
4424
4425 bnx2x_ack_sb(bp, id, CSTORM_ID, 0, IGU_INT_ENABLE, 0);
4426 }
4427
4428 static void bnx2x_init_def_sb(struct bnx2x *bp,
4429 struct host_def_status_block *def_sb,
4430 dma_addr_t mapping, int id)
4431 {
4432 int port = bp->port;
4433 int index, val, reg_offset;
4434 u64 section;
4435
4436 /* ATTN */
4437 section = ((u64)mapping) + offsetof(struct host_def_status_block,
4438 atten_status_block);
4439 def_sb->atten_status_block.status_block_id = id;
4440
4441 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
4442 MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
4443
4444 for (index = 0; index < 3; index++) {
4445 bp->attn_group[index].sig[0] = REG_RD(bp,
4446 reg_offset + 0x10*index);
4447 bp->attn_group[index].sig[1] = REG_RD(bp,
4448 reg_offset + 0x4 + 0x10*index);
4449 bp->attn_group[index].sig[2] = REG_RD(bp,
4450 reg_offset + 0x8 + 0x10*index);
4451 bp->attn_group[index].sig[3] = REG_RD(bp,
4452 reg_offset + 0xc + 0x10*index);
4453 }
4454
4455 bp->aeu_mask = REG_RD(bp, (port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
4456 MISC_REG_AEU_MASK_ATTN_FUNC_0));
4457
4458 reg_offset = (port ? HC_REG_ATTN_MSG1_ADDR_L :
4459 HC_REG_ATTN_MSG0_ADDR_L);
4460
4461 REG_WR(bp, reg_offset, U64_LO(section));
4462 REG_WR(bp, reg_offset + 4, U64_HI(section));
4463
4464 reg_offset = (port ? HC_REG_ATTN_NUM_P1 : HC_REG_ATTN_NUM_P0);
4465
4466 val = REG_RD(bp, reg_offset);
4467 val |= id;
4468 REG_WR(bp, reg_offset, val);
4469
4470 /* USTORM */
4471 section = ((u64)mapping) + offsetof(struct host_def_status_block,
4472 u_def_status_block);
4473 def_sb->u_def_status_block.status_block_id = id;
4474
4475 REG_WR(bp, BAR_USTRORM_INTMEM +
4476 USTORM_DEF_SB_HOST_SB_ADDR_OFFSET(port), U64_LO(section));
4477 REG_WR(bp, BAR_USTRORM_INTMEM +
4478 ((USTORM_DEF_SB_HOST_SB_ADDR_OFFSET(port)) + 4),
4479 U64_HI(section));
4480 REG_WR(bp, BAR_USTRORM_INTMEM + USTORM_HC_BTR_OFFSET(port),
4481 BNX2X_BTR);
4482
4483 for (index = 0; index < HC_USTORM_DEF_SB_NUM_INDICES; index++)
4484 REG_WR16(bp, BAR_USTRORM_INTMEM +
4485 USTORM_DEF_SB_HC_DISABLE_OFFSET(port, index), 0x1);
4486
4487 /* CSTORM */
4488 section = ((u64)mapping) + offsetof(struct host_def_status_block,
4489 c_def_status_block);
4490 def_sb->c_def_status_block.status_block_id = id;
4491
4492 REG_WR(bp, BAR_CSTRORM_INTMEM +
4493 CSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(port), U64_LO(section));
4494 REG_WR(bp, BAR_CSTRORM_INTMEM +
4495 ((CSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(port)) + 4),
4496 U64_HI(section));
4497 REG_WR(bp, BAR_CSTRORM_INTMEM + CSTORM_HC_BTR_OFFSET(port),
4498 BNX2X_BTR);
4499
4500 for (index = 0; index < HC_CSTORM_DEF_SB_NUM_INDICES; index++)
4501 REG_WR16(bp, BAR_CSTRORM_INTMEM +
4502 CSTORM_DEF_SB_HC_DISABLE_OFFSET(port, index), 0x1);
4503
4504 /* TSTORM */
4505 section = ((u64)mapping) + offsetof(struct host_def_status_block,
4506 t_def_status_block);
4507 def_sb->t_def_status_block.status_block_id = id;
4508
4509 REG_WR(bp, BAR_TSTRORM_INTMEM +
4510 TSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(port), U64_LO(section));
4511 REG_WR(bp, BAR_TSTRORM_INTMEM +
4512 ((TSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(port)) + 4),
4513 U64_HI(section));
4514 REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_HC_BTR_OFFSET(port),
4515 BNX2X_BTR);
4516
4517 for (index = 0; index < HC_TSTORM_DEF_SB_NUM_INDICES; index++)
4518 REG_WR16(bp, BAR_TSTRORM_INTMEM +
4519 TSTORM_DEF_SB_HC_DISABLE_OFFSET(port, index), 0x1);
4520
4521 /* XSTORM */
4522 section = ((u64)mapping) + offsetof(struct host_def_status_block,
4523 x_def_status_block);
4524 def_sb->x_def_status_block.status_block_id = id;
4525
4526 REG_WR(bp, BAR_XSTRORM_INTMEM +
4527 XSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(port), U64_LO(section));
4528 REG_WR(bp, BAR_XSTRORM_INTMEM +
4529 ((XSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(port)) + 4),
4530 U64_HI(section));
4531 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_HC_BTR_OFFSET(port),
4532 BNX2X_BTR);
4533
4534 for (index = 0; index < HC_XSTORM_DEF_SB_NUM_INDICES; index++)
4535 REG_WR16(bp, BAR_XSTRORM_INTMEM +
4536 XSTORM_DEF_SB_HC_DISABLE_OFFSET(port, index), 0x1);
4537
4538 bnx2x_ack_sb(bp, id, CSTORM_ID, 0, IGU_INT_ENABLE, 0);
4539 }
4540
4541 static void bnx2x_update_coalesce(struct bnx2x *bp)
4542 {
4543 int port = bp->port;
4544 int i;
4545
4546 for_each_queue(bp, i) {
4547
4548 /* HC_INDEX_U_ETH_RX_CQ_CONS */
4549 REG_WR8(bp, BAR_USTRORM_INTMEM +
4550 USTORM_SB_HC_TIMEOUT_OFFSET(port, i,
4551 HC_INDEX_U_ETH_RX_CQ_CONS),
4552 bp->rx_ticks_int/12);
4553 REG_WR16(bp, BAR_USTRORM_INTMEM +
4554 USTORM_SB_HC_DISABLE_OFFSET(port, i,
4555 HC_INDEX_U_ETH_RX_CQ_CONS),
4556 bp->rx_ticks_int ? 0 : 1);
4557
4558 /* HC_INDEX_C_ETH_TX_CQ_CONS */
4559 REG_WR8(bp, BAR_CSTRORM_INTMEM +
4560 CSTORM_SB_HC_TIMEOUT_OFFSET(port, i,
4561 HC_INDEX_C_ETH_TX_CQ_CONS),
4562 bp->tx_ticks_int/12);
4563 REG_WR16(bp, BAR_CSTRORM_INTMEM +
4564 CSTORM_SB_HC_DISABLE_OFFSET(port, i,
4565 HC_INDEX_C_ETH_TX_CQ_CONS),
4566 bp->tx_ticks_int ? 0 : 1);
4567 }
4568 }
4569
4570 static void bnx2x_init_rx_rings(struct bnx2x *bp)
4571 {
4572 u16 ring_prod;
4573 int i, j;
4574 int port = bp->port;
4575
4576 bp->rx_buf_use_size = bp->dev->mtu;
4577
4578 bp->rx_buf_use_size += bp->rx_offset + ETH_OVREHEAD;
4579 bp->rx_buf_size = bp->rx_buf_use_size + 64;
4580
4581 for_each_queue(bp, j) {
4582 struct bnx2x_fastpath *fp = &bp->fp[j];
4583
4584 fp->rx_bd_cons = 0;
4585 fp->rx_cons_sb = BNX2X_RX_SB_INDEX;
4586
4587 for (i = 1; i <= NUM_RX_RINGS; i++) {
4588 struct eth_rx_bd *rx_bd;
4589
4590 rx_bd = &fp->rx_desc_ring[RX_DESC_CNT * i - 2];
4591 rx_bd->addr_hi =
4592 cpu_to_le32(U64_HI(fp->rx_desc_mapping +
4593 BCM_PAGE_SIZE*(i % NUM_RX_RINGS)));
4594 rx_bd->addr_lo =
4595 cpu_to_le32(U64_LO(fp->rx_desc_mapping +
4596 BCM_PAGE_SIZE*(i % NUM_RX_RINGS)));
4597
4598 }
4599
4600 for (i = 1; i <= NUM_RCQ_RINGS; i++) {
4601 struct eth_rx_cqe_next_page *nextpg;
4602
4603 nextpg = (struct eth_rx_cqe_next_page *)
4604 &fp->rx_comp_ring[RCQ_DESC_CNT * i - 1];
4605 nextpg->addr_hi =
4606 cpu_to_le32(U64_HI(fp->rx_comp_mapping +
4607 BCM_PAGE_SIZE*(i % NUM_RCQ_RINGS)));
4608 nextpg->addr_lo =
4609 cpu_to_le32(U64_LO(fp->rx_comp_mapping +
4610 BCM_PAGE_SIZE*(i % NUM_RCQ_RINGS)));
4611 }
4612
4613 /* rx completion queue */
4614 fp->rx_comp_cons = ring_prod = 0;
4615
4616 for (i = 0; i < bp->rx_ring_size; i++) {
4617 if (bnx2x_alloc_rx_skb(bp, fp, ring_prod) < 0) {
4618 BNX2X_ERR("was only able to allocate "
4619 "%d rx skbs\n", i);
4620 break;
4621 }
4622 ring_prod = NEXT_RX_IDX(ring_prod);
4623 BUG_TRAP(ring_prod > i);
4624 }
4625
4626 fp->rx_bd_prod = fp->rx_comp_prod = ring_prod;
4627 fp->rx_pkt = fp->rx_calls = 0;
4628
4629 /* Warning! this will genrate an interrupt (to the TSTORM) */
4630 /* must only be done when chip is initialized */
4631 REG_WR(bp, BAR_TSTRORM_INTMEM +
4632 TSTORM_RCQ_PROD_OFFSET(port, j), ring_prod);
4633 if (j != 0)
4634 continue;
4635
4636 REG_WR(bp, BAR_USTRORM_INTMEM +
4637 USTORM_MEM_WORKAROUND_ADDRESS_OFFSET(port),
4638 U64_LO(fp->rx_comp_mapping));
4639 REG_WR(bp, BAR_USTRORM_INTMEM +
4640 USTORM_MEM_WORKAROUND_ADDRESS_OFFSET(port) + 4,
4641 U64_HI(fp->rx_comp_mapping));
4642 }
4643 }
4644
4645 static void bnx2x_init_tx_ring(struct bnx2x *bp)
4646 {
4647 int i, j;
4648
4649 for_each_queue(bp, j) {
4650 struct bnx2x_fastpath *fp = &bp->fp[j];
4651
4652 for (i = 1; i <= NUM_TX_RINGS; i++) {
4653 struct eth_tx_bd *tx_bd =
4654 &fp->tx_desc_ring[TX_DESC_CNT * i - 1];
4655
4656 tx_bd->addr_hi =
4657 cpu_to_le32(U64_HI(fp->tx_desc_mapping +
4658 BCM_PAGE_SIZE*(i % NUM_TX_RINGS)));
4659 tx_bd->addr_lo =
4660 cpu_to_le32(U64_LO(fp->tx_desc_mapping +
4661 BCM_PAGE_SIZE*(i % NUM_TX_RINGS)));
4662 }
4663
4664 fp->tx_pkt_prod = 0;
4665 fp->tx_pkt_cons = 0;
4666 fp->tx_bd_prod = 0;
4667 fp->tx_bd_cons = 0;
4668 fp->tx_cons_sb = BNX2X_TX_SB_INDEX;
4669 fp->tx_pkt = 0;
4670 }
4671 }
4672
4673 static void bnx2x_init_sp_ring(struct bnx2x *bp)
4674 {
4675 int port = bp->port;
4676
4677 spin_lock_init(&bp->spq_lock);
4678
4679 bp->spq_left = MAX_SPQ_PENDING;
4680 bp->spq_prod_idx = 0;
4681 bp->dsb_sp_prod_idx = 0;
4682 bp->dsb_sp_prod = BNX2X_SP_DSB_INDEX;
4683 bp->spq_prod_bd = bp->spq;
4684 bp->spq_last_bd = bp->spq_prod_bd + MAX_SP_DESC_CNT;
4685
4686 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_SPQ_PAGE_BASE_OFFSET(port),
4687 U64_LO(bp->spq_mapping));
4688 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_SPQ_PAGE_BASE_OFFSET(port) + 4,
4689 U64_HI(bp->spq_mapping));
4690
4691 REG_WR(bp, XSEM_REG_FAST_MEMORY + XSTORM_SPQ_PROD_OFFSET(port),
4692 bp->spq_prod_idx);
4693 }
4694
4695 static void bnx2x_init_context(struct bnx2x *bp)
4696 {
4697 int i;
4698
4699 for_each_queue(bp, i) {
4700 struct eth_context *context = bnx2x_sp(bp, context[i].eth);
4701 struct bnx2x_fastpath *fp = &bp->fp[i];
4702
4703 context->xstorm_st_context.tx_bd_page_base_hi =
4704 U64_HI(fp->tx_desc_mapping);
4705 context->xstorm_st_context.tx_bd_page_base_lo =
4706 U64_LO(fp->tx_desc_mapping);
4707 context->xstorm_st_context.db_data_addr_hi =
4708 U64_HI(fp->tx_prods_mapping);
4709 context->xstorm_st_context.db_data_addr_lo =
4710 U64_LO(fp->tx_prods_mapping);
4711
4712 context->ustorm_st_context.rx_bd_page_base_hi =
4713 U64_HI(fp->rx_desc_mapping);
4714 context->ustorm_st_context.rx_bd_page_base_lo =
4715 U64_LO(fp->rx_desc_mapping);
4716 context->ustorm_st_context.status_block_id = i;
4717 context->ustorm_st_context.sb_index_number =
4718 HC_INDEX_U_ETH_RX_CQ_CONS;
4719 context->ustorm_st_context.rcq_base_address_hi =
4720 U64_HI(fp->rx_comp_mapping);
4721 context->ustorm_st_context.rcq_base_address_lo =
4722 U64_LO(fp->rx_comp_mapping);
4723 context->ustorm_st_context.flags =
4724 USTORM_ETH_ST_CONTEXT_ENABLE_MC_ALIGNMENT;
4725 context->ustorm_st_context.mc_alignment_size = 64;
4726 context->ustorm_st_context.num_rss = bp->num_queues;
4727
4728 context->cstorm_st_context.sb_index_number =
4729 HC_INDEX_C_ETH_TX_CQ_CONS;
4730 context->cstorm_st_context.status_block_id = i;
4731
4732 context->xstorm_ag_context.cdu_reserved =
4733 CDU_RSRVD_VALUE_TYPE_A(HW_CID(bp, i),
4734 CDU_REGION_NUMBER_XCM_AG,
4735 ETH_CONNECTION_TYPE);
4736 context->ustorm_ag_context.cdu_usage =
4737 CDU_RSRVD_VALUE_TYPE_A(HW_CID(bp, i),
4738 CDU_REGION_NUMBER_UCM_AG,
4739 ETH_CONNECTION_TYPE);
4740 }
4741 }
4742
4743 static void bnx2x_init_ind_table(struct bnx2x *bp)
4744 {
4745 int port = bp->port;
4746 int i;
4747
4748 if (!is_multi(bp))
4749 return;
4750
4751 for (i = 0; i < TSTORM_INDIRECTION_TABLE_SIZE; i++)
4752 REG_WR8(bp, TSTORM_INDIRECTION_TABLE_OFFSET(port) + i,
4753 i % bp->num_queues);
4754
4755 REG_WR(bp, PRS_REG_A_PRSU_20, 0xf);
4756 }
4757
4758 static void bnx2x_set_storm_rx_mode(struct bnx2x *bp)
4759 {
4760 int mode = bp->rx_mode;
4761 int port = bp->port;
4762 struct tstorm_eth_mac_filter_config tstorm_mac_filter = {0};
4763 int i;
4764
4765 DP(NETIF_MSG_RX_STATUS, "rx mode is %d\n", mode);
4766
4767 switch (mode) {
4768 case BNX2X_RX_MODE_NONE: /* no Rx */
4769 tstorm_mac_filter.ucast_drop_all = 1;
4770 tstorm_mac_filter.mcast_drop_all = 1;
4771 tstorm_mac_filter.bcast_drop_all = 1;
4772 break;
4773 case BNX2X_RX_MODE_NORMAL:
4774 tstorm_mac_filter.bcast_accept_all = 1;
4775 break;
4776 case BNX2X_RX_MODE_ALLMULTI:
4777 tstorm_mac_filter.mcast_accept_all = 1;
4778 tstorm_mac_filter.bcast_accept_all = 1;
4779 break;
4780 case BNX2X_RX_MODE_PROMISC:
4781 tstorm_mac_filter.ucast_accept_all = 1;
4782 tstorm_mac_filter.mcast_accept_all = 1;
4783 tstorm_mac_filter.bcast_accept_all = 1;
4784 break;
4785 default:
4786 BNX2X_ERR("bad rx mode (%d)\n", mode);
4787 }
4788
4789 for (i = 0; i < sizeof(struct tstorm_eth_mac_filter_config)/4; i++) {
4790 REG_WR(bp, BAR_TSTRORM_INTMEM +
4791 TSTORM_MAC_FILTER_CONFIG_OFFSET(port) + i * 4,
4792 ((u32 *)&tstorm_mac_filter)[i]);
4793
4794 /* DP(NETIF_MSG_IFUP, "tstorm_mac_filter[%d]: 0x%08x\n", i,
4795 ((u32 *)&tstorm_mac_filter)[i]); */
4796 }
4797 }
4798
4799 static void bnx2x_set_client_config(struct bnx2x *bp, int client_id)
4800 {
4801 #ifdef BCM_VLAN
4802 int mode = bp->rx_mode;
4803 #endif
4804 int port = bp->port;
4805 struct tstorm_eth_client_config tstorm_client = {0};
4806
4807 tstorm_client.mtu = bp->dev->mtu;
4808 tstorm_client.statistics_counter_id = 0;
4809 tstorm_client.config_flags =
4810 TSTORM_ETH_CLIENT_CONFIG_STATSITICS_ENABLE;
4811 #ifdef BCM_VLAN
4812 if (mode && bp->vlgrp) {
4813 tstorm_client.config_flags |=
4814 TSTORM_ETH_CLIENT_CONFIG_VLAN_REMOVAL_ENABLE;
4815 DP(NETIF_MSG_IFUP, "vlan removal enabled\n");
4816 }
4817 #endif
4818 tstorm_client.drop_flags = (TSTORM_ETH_CLIENT_CONFIG_DROP_IP_CS_ERR |
4819 TSTORM_ETH_CLIENT_CONFIG_DROP_TCP_CS_ERR |
4820 TSTORM_ETH_CLIENT_CONFIG_DROP_UDP_CS_ERR |
4821 TSTORM_ETH_CLIENT_CONFIG_DROP_MAC_ERR);
4822
4823 REG_WR(bp, BAR_TSTRORM_INTMEM +
4824 TSTORM_CLIENT_CONFIG_OFFSET(port, client_id),
4825 ((u32 *)&tstorm_client)[0]);
4826 REG_WR(bp, BAR_TSTRORM_INTMEM +
4827 TSTORM_CLIENT_CONFIG_OFFSET(port, client_id) + 4,
4828 ((u32 *)&tstorm_client)[1]);
4829
4830 /* DP(NETIF_MSG_IFUP, "tstorm_client: 0x%08x 0x%08x\n",
4831 ((u32 *)&tstorm_client)[0], ((u32 *)&tstorm_client)[1]); */
4832 }
4833
4834 static void bnx2x_init_internal(struct bnx2x *bp)
4835 {
4836 int port = bp->port;
4837 struct tstorm_eth_function_common_config tstorm_config = {0};
4838 struct stats_indication_flags stats_flags = {0};
4839 int i;
4840
4841 if (is_multi(bp)) {
4842 tstorm_config.config_flags = MULTI_FLAGS;
4843 tstorm_config.rss_result_mask = MULTI_MASK;
4844 }
4845
4846 REG_WR(bp, BAR_TSTRORM_INTMEM +
4847 TSTORM_FUNCTION_COMMON_CONFIG_OFFSET(port),
4848 (*(u32 *)&tstorm_config));
4849
4850 /* DP(NETIF_MSG_IFUP, "tstorm_config: 0x%08x\n",
4851 (*(u32 *)&tstorm_config)); */
4852
4853 bp->rx_mode = BNX2X_RX_MODE_NONE; /* no rx untill link is up */
4854 bnx2x_set_storm_rx_mode(bp);
4855
4856 for_each_queue(bp, i)
4857 bnx2x_set_client_config(bp, i);
4858
4859
4860 stats_flags.collect_eth = cpu_to_le32(1);
4861
4862 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_STATS_FLAGS_OFFSET(port),
4863 ((u32 *)&stats_flags)[0]);
4864 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_STATS_FLAGS_OFFSET(port) + 4,
4865 ((u32 *)&stats_flags)[1]);
4866
4867 REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_STATS_FLAGS_OFFSET(port),
4868 ((u32 *)&stats_flags)[0]);
4869 REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_STATS_FLAGS_OFFSET(port) + 4,
4870 ((u32 *)&stats_flags)[1]);
4871
4872 REG_WR(bp, BAR_CSTRORM_INTMEM + CSTORM_STATS_FLAGS_OFFSET(port),
4873 ((u32 *)&stats_flags)[0]);
4874 REG_WR(bp, BAR_CSTRORM_INTMEM + CSTORM_STATS_FLAGS_OFFSET(port) + 4,
4875 ((u32 *)&stats_flags)[1]);
4876
4877 /* DP(NETIF_MSG_IFUP, "stats_flags: 0x%08x 0x%08x\n",
4878 ((u32 *)&stats_flags)[0], ((u32 *)&stats_flags)[1]); */
4879 }
4880
4881 static void bnx2x_nic_init(struct bnx2x *bp)
4882 {
4883 int i;
4884
4885 for_each_queue(bp, i) {
4886 struct bnx2x_fastpath *fp = &bp->fp[i];
4887
4888 fp->state = BNX2X_FP_STATE_CLOSED;
4889 DP(NETIF_MSG_IFUP, "bnx2x_init_sb(%p,%p,%d);\n",
4890 bp, fp->status_blk, i);
4891 fp->index = i;
4892 bnx2x_init_sb(bp, fp->status_blk, fp->status_blk_mapping, i);
4893 }
4894
4895 bnx2x_init_def_sb(bp, bp->def_status_blk,
4896 bp->def_status_blk_mapping, 0x10);
4897 bnx2x_update_coalesce(bp);
4898 bnx2x_init_rx_rings(bp);
4899 bnx2x_init_tx_ring(bp);
4900 bnx2x_init_sp_ring(bp);
4901 bnx2x_init_context(bp);
4902 bnx2x_init_internal(bp);
4903 bnx2x_init_stats(bp);
4904 bnx2x_init_ind_table(bp);
4905 bnx2x_enable_int(bp);
4906
4907 }
4908
4909 /* end of nic init */
4910
4911 /*
4912 * gzip service functions
4913 */
4914
4915 static int bnx2x_gunzip_init(struct bnx2x *bp)
4916 {
4917 bp->gunzip_buf = pci_alloc_consistent(bp->pdev, FW_BUF_SIZE,
4918 &bp->gunzip_mapping);
4919 if (bp->gunzip_buf == NULL)
4920 goto gunzip_nomem1;
4921
4922 bp->strm = kmalloc(sizeof(*bp->strm), GFP_KERNEL);
4923 if (bp->strm == NULL)
4924 goto gunzip_nomem2;
4925
4926 bp->strm->workspace = kmalloc(zlib_inflate_workspacesize(),
4927 GFP_KERNEL);
4928 if (bp->strm->workspace == NULL)
4929 goto gunzip_nomem3;
4930
4931 return 0;
4932
4933 gunzip_nomem3:
4934 kfree(bp->strm);
4935 bp->strm = NULL;
4936
4937 gunzip_nomem2:
4938 pci_free_consistent(bp->pdev, FW_BUF_SIZE, bp->gunzip_buf,
4939 bp->gunzip_mapping);
4940 bp->gunzip_buf = NULL;
4941
4942 gunzip_nomem1:
4943 printk(KERN_ERR PFX "%s: Cannot allocate firmware buffer for"
4944 " uncompression\n", bp->dev->name);
4945 return -ENOMEM;
4946 }
4947
4948 static void bnx2x_gunzip_end(struct bnx2x *bp)
4949 {
4950 kfree(bp->strm->workspace);
4951
4952 kfree(bp->strm);
4953 bp->strm = NULL;
4954
4955 if (bp->gunzip_buf) {
4956 pci_free_consistent(bp->pdev, FW_BUF_SIZE, bp->gunzip_buf,
4957 bp->gunzip_mapping);
4958 bp->gunzip_buf = NULL;
4959 }
4960 }
4961
4962 static int bnx2x_gunzip(struct bnx2x *bp, u8 *zbuf, int len)
4963 {
4964 int n, rc;
4965
4966 /* check gzip header */
4967 if ((zbuf[0] != 0x1f) || (zbuf[1] != 0x8b) || (zbuf[2] != Z_DEFLATED))
4968 return -EINVAL;
4969
4970 n = 10;
4971
4972 #define FNAME 0x8
4973
4974 if (zbuf[3] & FNAME)
4975 while ((zbuf[n++] != 0) && (n < len));
4976
4977 bp->strm->next_in = zbuf + n;
4978 bp->strm->avail_in = len - n;
4979 bp->strm->next_out = bp->gunzip_buf;
4980 bp->strm->avail_out = FW_BUF_SIZE;
4981
4982 rc = zlib_inflateInit2(bp->strm, -MAX_WBITS);
4983 if (rc != Z_OK)
4984 return rc;
4985
4986 rc = zlib_inflate(bp->strm, Z_FINISH);
4987 if ((rc != Z_OK) && (rc != Z_STREAM_END))
4988 printk(KERN_ERR PFX "%s: Firmware decompression error: %s\n",
4989 bp->dev->name, bp->strm->msg);
4990
4991 bp->gunzip_outlen = (FW_BUF_SIZE - bp->strm->avail_out);
4992 if (bp->gunzip_outlen & 0x3)
4993 printk(KERN_ERR PFX "%s: Firmware decompression error:"
4994 " gunzip_outlen (%d) not aligned\n",
4995 bp->dev->name, bp->gunzip_outlen);
4996 bp->gunzip_outlen >>= 2;
4997
4998 zlib_inflateEnd(bp->strm);
4999
5000 if (rc == Z_STREAM_END)
5001 return 0;
5002
5003 return rc;
5004 }
5005
5006 /* nic load/unload */
5007
5008 /*
5009 * general service functions
5010 */
5011
5012 /* send a NIG loopback debug packet */
5013 static void bnx2x_lb_pckt(struct bnx2x *bp)
5014 {
5015 #ifdef USE_DMAE
5016 u32 wb_write[3];
5017 #endif
5018
5019 /* Ethernet source and destination addresses */
5020 #ifdef USE_DMAE
5021 wb_write[0] = 0x55555555;
5022 wb_write[1] = 0x55555555;
5023 wb_write[2] = 0x20; /* SOP */
5024 REG_WR_DMAE(bp, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
5025 #else
5026 REG_WR_IND(bp, NIG_REG_DEBUG_PACKET_LB, 0x55555555);
5027 REG_WR_IND(bp, NIG_REG_DEBUG_PACKET_LB + 4, 0x55555555);
5028 /* SOP */
5029 REG_WR_IND(bp, NIG_REG_DEBUG_PACKET_LB + 8, 0x20);
5030 #endif
5031
5032 /* NON-IP protocol */
5033 #ifdef USE_DMAE
5034 wb_write[0] = 0x09000000;
5035 wb_write[1] = 0x55555555;
5036 wb_write[2] = 0x10; /* EOP, eop_bvalid = 0 */
5037 REG_WR_DMAE(bp, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
5038 #else
5039 REG_WR_IND(bp, NIG_REG_DEBUG_PACKET_LB, 0x09000000);
5040 REG_WR_IND(bp, NIG_REG_DEBUG_PACKET_LB + 4, 0x55555555);
5041 /* EOP, eop_bvalid = 0 */
5042 REG_WR_IND(bp, NIG_REG_DEBUG_PACKET_LB + 8, 0x10);
5043 #endif
5044 }
5045
5046 /* some of the internal memories
5047 * are not directly readable from the driver
5048 * to test them we send debug packets
5049 */
5050 static int bnx2x_int_mem_test(struct bnx2x *bp)
5051 {
5052 int factor;
5053 int count, i;
5054 u32 val = 0;
5055
5056 switch (CHIP_REV(bp)) {
5057 case CHIP_REV_EMUL:
5058 factor = 200;
5059 break;
5060 case CHIP_REV_FPGA:
5061 factor = 120;
5062 break;
5063 default:
5064 factor = 1;
5065 break;
5066 }
5067
5068 DP(NETIF_MSG_HW, "start part1\n");
5069
5070 /* Disable inputs of parser neighbor blocks */
5071 REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x0);
5072 REG_WR(bp, TCM_REG_PRS_IFEN, 0x0);
5073 REG_WR(bp, CFC_REG_DEBUG0, 0x1);
5074 NIG_WR(NIG_REG_PRS_REQ_IN_EN, 0x0);
5075
5076 /* Write 0 to parser credits for CFC search request */
5077 REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
5078
5079 /* send Ethernet packet */
5080 bnx2x_lb_pckt(bp);
5081
5082 /* TODO do i reset NIG statistic? */
5083 /* Wait until NIG register shows 1 packet of size 0x10 */
5084 count = 1000 * factor;
5085 while (count) {
5086 #ifdef BNX2X_DMAE_RD
5087 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
5088 val = *bnx2x_sp(bp, wb_data[0]);
5089 #else
5090 val = REG_RD(bp, NIG_REG_STAT2_BRB_OCTET);
5091 REG_RD(bp, NIG_REG_STAT2_BRB_OCTET + 4);
5092 #endif
5093 if (val == 0x10)
5094 break;
5095
5096 msleep(10);
5097 count--;
5098 }
5099 if (val != 0x10) {
5100 BNX2X_ERR("NIG timeout val = 0x%x\n", val);
5101 return -1;
5102 }
5103
5104 /* Wait until PRS register shows 1 packet */
5105 count = 1000 * factor;
5106 while (count) {
5107 val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
5108
5109 if (val == 1)
5110 break;
5111
5112 msleep(10);
5113 count--;
5114 }
5115 if (val != 0x1) {
5116 BNX2X_ERR("PRS timeout val = 0x%x\n", val);
5117 return -2;
5118 }
5119
5120 /* Reset and init BRB, PRS */
5121 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x3);
5122 msleep(50);
5123 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x3);
5124 msleep(50);
5125 bnx2x_init_block(bp, BRB1_COMMON_START, BRB1_COMMON_END);
5126 bnx2x_init_block(bp, PRS_COMMON_START, PRS_COMMON_END);
5127
5128 DP(NETIF_MSG_HW, "part2\n");
5129
5130 /* Disable inputs of parser neighbor blocks */
5131 REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x0);
5132 REG_WR(bp, TCM_REG_PRS_IFEN, 0x0);
5133 REG_WR(bp, CFC_REG_DEBUG0, 0x1);
5134 NIG_WR(NIG_REG_PRS_REQ_IN_EN, 0x0);
5135
5136 /* Write 0 to parser credits for CFC search request */
5137 REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
5138
5139 /* send 10 Ethernet packets */
5140 for (i = 0; i < 10; i++)
5141 bnx2x_lb_pckt(bp);
5142
5143 /* Wait until NIG register shows 10 + 1
5144 packets of size 11*0x10 = 0xb0 */
5145 count = 1000 * factor;
5146 while (count) {
5147 #ifdef BNX2X_DMAE_RD
5148 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
5149 val = *bnx2x_sp(bp, wb_data[0]);
5150 #else
5151 val = REG_RD(bp, NIG_REG_STAT2_BRB_OCTET);
5152 REG_RD(bp, NIG_REG_STAT2_BRB_OCTET + 4);
5153 #endif
5154 if (val == 0xb0)
5155 break;
5156
5157 msleep(10);
5158 count--;
5159 }
5160 if (val != 0xb0) {
5161 BNX2X_ERR("NIG timeout val = 0x%x\n", val);
5162 return -3;
5163 }
5164
5165 /* Wait until PRS register shows 2 packets */
5166 val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
5167 if (val != 2)
5168 BNX2X_ERR("PRS timeout val = 0x%x\n", val);
5169
5170 /* Write 1 to parser credits for CFC search request */
5171 REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x1);
5172
5173 /* Wait until PRS register shows 3 packets */
5174 msleep(10 * factor);
5175 /* Wait until NIG register shows 1 packet of size 0x10 */
5176 val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
5177 if (val != 3)
5178 BNX2X_ERR("PRS timeout val = 0x%x\n", val);
5179
5180 /* clear NIG EOP FIFO */
5181 for (i = 0; i < 11; i++)
5182 REG_RD(bp, NIG_REG_INGRESS_EOP_LB_FIFO);
5183 val = REG_RD(bp, NIG_REG_INGRESS_EOP_LB_EMPTY);
5184 if (val != 1) {
5185 BNX2X_ERR("clear of NIG failed\n");
5186 return -4;
5187 }
5188
5189 /* Reset and init BRB, PRS, NIG */
5190 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
5191 msleep(50);
5192 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
5193 msleep(50);
5194 bnx2x_init_block(bp, BRB1_COMMON_START, BRB1_COMMON_END);
5195 bnx2x_init_block(bp, PRS_COMMON_START, PRS_COMMON_END);
5196 #ifndef BCM_ISCSI
5197 /* set NIC mode */
5198 REG_WR(bp, PRS_REG_NIC_MODE, 1);
5199 #endif
5200
5201 /* Enable inputs of parser neighbor blocks */
5202 REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x7fffffff);
5203 REG_WR(bp, TCM_REG_PRS_IFEN, 0x1);
5204 REG_WR(bp, CFC_REG_DEBUG0, 0x0);
5205 NIG_WR(NIG_REG_PRS_REQ_IN_EN, 0x1);
5206
5207 DP(NETIF_MSG_HW, "done\n");
5208
5209 return 0; /* OK */
5210 }
5211
5212 static void enable_blocks_attention(struct bnx2x *bp)
5213 {
5214 REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
5215 REG_WR(bp, PXP_REG_PXP_INT_MASK_1, 0);
5216 REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
5217 REG_WR(bp, CFC_REG_CFC_INT_MASK, 0);
5218 REG_WR(bp, QM_REG_QM_INT_MASK, 0);
5219 REG_WR(bp, TM_REG_TM_INT_MASK, 0);
5220 REG_WR(bp, XSDM_REG_XSDM_INT_MASK_0, 0);
5221 REG_WR(bp, XSDM_REG_XSDM_INT_MASK_1, 0);
5222 REG_WR(bp, XCM_REG_XCM_INT_MASK, 0);
5223 /* REG_WR(bp, XSEM_REG_XSEM_INT_MASK_0, 0); */
5224 /* REG_WR(bp, XSEM_REG_XSEM_INT_MASK_1, 0); */
5225 REG_WR(bp, USDM_REG_USDM_INT_MASK_0, 0);
5226 REG_WR(bp, USDM_REG_USDM_INT_MASK_1, 0);
5227 REG_WR(bp, UCM_REG_UCM_INT_MASK, 0);
5228 /* REG_WR(bp, USEM_REG_USEM_INT_MASK_0, 0); */
5229 /* REG_WR(bp, USEM_REG_USEM_INT_MASK_1, 0); */
5230 REG_WR(bp, GRCBASE_UPB + PB_REG_PB_INT_MASK, 0);
5231 REG_WR(bp, CSDM_REG_CSDM_INT_MASK_0, 0);
5232 REG_WR(bp, CSDM_REG_CSDM_INT_MASK_1, 0);
5233 REG_WR(bp, CCM_REG_CCM_INT_MASK, 0);
5234 /* REG_WR(bp, CSEM_REG_CSEM_INT_MASK_0, 0); */
5235 /* REG_WR(bp, CSEM_REG_CSEM_INT_MASK_1, 0); */
5236 REG_WR(bp, PXP2_REG_PXP2_INT_MASK, 0x480000);
5237 REG_WR(bp, TSDM_REG_TSDM_INT_MASK_0, 0);
5238 REG_WR(bp, TSDM_REG_TSDM_INT_MASK_1, 0);
5239 REG_WR(bp, TCM_REG_TCM_INT_MASK, 0);
5240 /* REG_WR(bp, TSEM_REG_TSEM_INT_MASK_0, 0); */
5241 /* REG_WR(bp, TSEM_REG_TSEM_INT_MASK_1, 0); */
5242 REG_WR(bp, CDU_REG_CDU_INT_MASK, 0);
5243 REG_WR(bp, DMAE_REG_DMAE_INT_MASK, 0);
5244 /* REG_WR(bp, MISC_REG_MISC_INT_MASK, 0); */
5245 REG_WR(bp, PBF_REG_PBF_INT_MASK, 0X18); /* bit 3,4 masked */
5246 }
5247
5248 static int bnx2x_function_init(struct bnx2x *bp, int mode)
5249 {
5250 int func = bp->port;
5251 int port = func ? PORT1 : PORT0;
5252 u32 val, i;
5253 #ifdef USE_DMAE
5254 u32 wb_write[2];
5255 #endif
5256
5257 DP(BNX2X_MSG_MCP, "function is %d mode is %x\n", func, mode);
5258 if ((func != 0) && (func != 1)) {
5259 BNX2X_ERR("BAD function number (%d)\n", func);
5260 return -ENODEV;
5261 }
5262
5263 bnx2x_gunzip_init(bp);
5264
5265 if (mode & 0x1) { /* init common */
5266 DP(BNX2X_MSG_MCP, "starting common init func %d mode %x\n",
5267 func, mode);
5268 REG_WR(bp, MISC_REG_RESET_REG_1, 0xffffffff);
5269 REG_WR(bp, MISC_REG_RESET_REG_2, 0xfffc);
5270 bnx2x_init_block(bp, MISC_COMMON_START, MISC_COMMON_END);
5271
5272 REG_WR(bp, MISC_REG_LCPLL_CTRL_REG_2, 0x100);
5273 msleep(30);
5274 REG_WR(bp, MISC_REG_LCPLL_CTRL_REG_2, 0x0);
5275
5276 bnx2x_init_block(bp, PXP_COMMON_START, PXP_COMMON_END);
5277 bnx2x_init_block(bp, PXP2_COMMON_START, PXP2_COMMON_END);
5278
5279 bnx2x_init_pxp(bp);
5280
5281 if (CHIP_REV(bp) == CHIP_REV_Ax) {
5282 /* enable HW interrupt from PXP on USDM
5283 overflow bit 16 on INT_MASK_0 */
5284 REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
5285 }
5286
5287 #ifdef __BIG_ENDIAN
5288 REG_WR(bp, PXP2_REG_RQ_QM_ENDIAN_M, 1);
5289 REG_WR(bp, PXP2_REG_RQ_TM_ENDIAN_M, 1);
5290 REG_WR(bp, PXP2_REG_RQ_SRC_ENDIAN_M, 1);
5291 REG_WR(bp, PXP2_REG_RQ_CDU_ENDIAN_M, 1);
5292 REG_WR(bp, PXP2_REG_RQ_DBG_ENDIAN_M, 1);
5293 REG_WR(bp, PXP2_REG_RQ_HC_ENDIAN_M, 1);
5294
5295 /* REG_WR(bp, PXP2_REG_RD_PBF_SWAP_MODE, 1); */
5296 REG_WR(bp, PXP2_REG_RD_QM_SWAP_MODE, 1);
5297 REG_WR(bp, PXP2_REG_RD_TM_SWAP_MODE, 1);
5298 REG_WR(bp, PXP2_REG_RD_SRC_SWAP_MODE, 1);
5299 REG_WR(bp, PXP2_REG_RD_CDURD_SWAP_MODE, 1);
5300 #endif
5301
5302 #ifndef BCM_ISCSI
5303 /* set NIC mode */
5304 REG_WR(bp, PRS_REG_NIC_MODE, 1);
5305 #endif
5306
5307 REG_WR(bp, PXP2_REG_RQ_CDU_P_SIZE, 5);
5308 #ifdef BCM_ISCSI
5309 REG_WR(bp, PXP2_REG_RQ_TM_P_SIZE, 5);
5310 REG_WR(bp, PXP2_REG_RQ_QM_P_SIZE, 5);
5311 REG_WR(bp, PXP2_REG_RQ_SRC_P_SIZE, 5);
5312 #endif
5313
5314 bnx2x_init_block(bp, DMAE_COMMON_START, DMAE_COMMON_END);
5315
5316 /* let the HW do it's magic ... */
5317 msleep(100);
5318 /* finish PXP init
5319 (can be moved up if we want to use the DMAE) */
5320 val = REG_RD(bp, PXP2_REG_RQ_CFG_DONE);
5321 if (val != 1) {
5322 BNX2X_ERR("PXP2 CFG failed\n");
5323 return -EBUSY;
5324 }
5325
5326 val = REG_RD(bp, PXP2_REG_RD_INIT_DONE);
5327 if (val != 1) {
5328 BNX2X_ERR("PXP2 RD_INIT failed\n");
5329 return -EBUSY;
5330 }
5331
5332 REG_WR(bp, PXP2_REG_RQ_DISABLE_INPUTS, 0);
5333 REG_WR(bp, PXP2_REG_RD_DISABLE_INPUTS, 0);
5334
5335 bnx2x_init_fill(bp, TSEM_REG_PRAM, 0, 8);
5336
5337 bnx2x_init_block(bp, TCM_COMMON_START, TCM_COMMON_END);
5338 bnx2x_init_block(bp, UCM_COMMON_START, UCM_COMMON_END);
5339 bnx2x_init_block(bp, CCM_COMMON_START, CCM_COMMON_END);
5340 bnx2x_init_block(bp, XCM_COMMON_START, XCM_COMMON_END);
5341
5342 #ifdef BNX2X_DMAE_RD
5343 bnx2x_read_dmae(bp, XSEM_REG_PASSIVE_BUFFER, 3);
5344 bnx2x_read_dmae(bp, CSEM_REG_PASSIVE_BUFFER, 3);
5345 bnx2x_read_dmae(bp, TSEM_REG_PASSIVE_BUFFER, 3);
5346 bnx2x_read_dmae(bp, USEM_REG_PASSIVE_BUFFER, 3);
5347 #else
5348 REG_RD(bp, XSEM_REG_PASSIVE_BUFFER);
5349 REG_RD(bp, XSEM_REG_PASSIVE_BUFFER + 4);
5350 REG_RD(bp, XSEM_REG_PASSIVE_BUFFER + 8);
5351 REG_RD(bp, CSEM_REG_PASSIVE_BUFFER);
5352 REG_RD(bp, CSEM_REG_PASSIVE_BUFFER + 4);
5353 REG_RD(bp, CSEM_REG_PASSIVE_BUFFER + 8);
5354 REG_RD(bp, TSEM_REG_PASSIVE_BUFFER);
5355 REG_RD(bp, TSEM_REG_PASSIVE_BUFFER + 4);
5356 REG_RD(bp, TSEM_REG_PASSIVE_BUFFER + 8);
5357 REG_RD(bp, USEM_REG_PASSIVE_BUFFER);
5358 REG_RD(bp, USEM_REG_PASSIVE_BUFFER + 4);
5359 REG_RD(bp, USEM_REG_PASSIVE_BUFFER + 8);
5360 #endif
5361 bnx2x_init_block(bp, QM_COMMON_START, QM_COMMON_END);
5362 /* softrest pulse */
5363 REG_WR(bp, QM_REG_SOFT_RESET, 1);
5364 REG_WR(bp, QM_REG_SOFT_RESET, 0);
5365
5366 #ifdef BCM_ISCSI
5367 bnx2x_init_block(bp, TIMERS_COMMON_START, TIMERS_COMMON_END);
5368 #endif
5369 bnx2x_init_block(bp, DQ_COMMON_START, DQ_COMMON_END);
5370 REG_WR(bp, DORQ_REG_DPM_CID_OFST, BCM_PAGE_BITS);
5371 if (CHIP_REV(bp) == CHIP_REV_Ax) {
5372 /* enable hw interrupt from doorbell Q */
5373 REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
5374 }
5375
5376 bnx2x_init_block(bp, BRB1_COMMON_START, BRB1_COMMON_END);
5377
5378 if (CHIP_REV_IS_SLOW(bp)) {
5379 /* fix for emulation and FPGA for no pause */
5380 REG_WR(bp, BRB1_REG_PAUSE_HIGH_THRESHOLD_0, 513);
5381 REG_WR(bp, BRB1_REG_PAUSE_HIGH_THRESHOLD_1, 513);
5382 REG_WR(bp, BRB1_REG_PAUSE_LOW_THRESHOLD_0, 0);
5383 REG_WR(bp, BRB1_REG_PAUSE_LOW_THRESHOLD_1, 0);
5384 }
5385
5386 bnx2x_init_block(bp, PRS_COMMON_START, PRS_COMMON_END);
5387
5388 bnx2x_init_block(bp, TSDM_COMMON_START, TSDM_COMMON_END);
5389 bnx2x_init_block(bp, CSDM_COMMON_START, CSDM_COMMON_END);
5390 bnx2x_init_block(bp, USDM_COMMON_START, USDM_COMMON_END);
5391 bnx2x_init_block(bp, XSDM_COMMON_START, XSDM_COMMON_END);
5392
5393 bnx2x_init_fill(bp, TSTORM_INTMEM_ADDR, 0, STORM_INTMEM_SIZE);
5394 bnx2x_init_fill(bp, CSTORM_INTMEM_ADDR, 0, STORM_INTMEM_SIZE);
5395 bnx2x_init_fill(bp, XSTORM_INTMEM_ADDR, 0, STORM_INTMEM_SIZE);
5396 bnx2x_init_fill(bp, USTORM_INTMEM_ADDR, 0, STORM_INTMEM_SIZE);
5397
5398 bnx2x_init_block(bp, TSEM_COMMON_START, TSEM_COMMON_END);
5399 bnx2x_init_block(bp, USEM_COMMON_START, USEM_COMMON_END);
5400 bnx2x_init_block(bp, CSEM_COMMON_START, CSEM_COMMON_END);
5401 bnx2x_init_block(bp, XSEM_COMMON_START, XSEM_COMMON_END);
5402
5403 /* sync semi rtc */
5404 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
5405 0x80000000);
5406 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
5407 0x80000000);
5408
5409 bnx2x_init_block(bp, UPB_COMMON_START, UPB_COMMON_END);
5410 bnx2x_init_block(bp, XPB_COMMON_START, XPB_COMMON_END);
5411 bnx2x_init_block(bp, PBF_COMMON_START, PBF_COMMON_END);
5412
5413 REG_WR(bp, SRC_REG_SOFT_RST, 1);
5414 for (i = SRC_REG_KEYRSS0_0; i <= SRC_REG_KEYRSS1_9; i += 4) {
5415 REG_WR(bp, i, 0xc0cac01a);
5416 /* TODO: repleace with something meaningfull */
5417 }
5418 /* SRCH COMMON comes here */
5419 REG_WR(bp, SRC_REG_SOFT_RST, 0);
5420
5421 if (sizeof(union cdu_context) != 1024) {
5422 /* we currently assume that a context is 1024 bytes */
5423 printk(KERN_ALERT PFX "please adjust the size of"
5424 " cdu_context(%ld)\n",
5425 (long)sizeof(union cdu_context));
5426 }
5427 val = (4 << 24) + (0 << 12) + 1024;
5428 REG_WR(bp, CDU_REG_CDU_GLOBAL_PARAMS, val);
5429 bnx2x_init_block(bp, CDU_COMMON_START, CDU_COMMON_END);
5430
5431 bnx2x_init_block(bp, CFC_COMMON_START, CFC_COMMON_END);
5432 REG_WR(bp, CFC_REG_INIT_REG, 0x7FF);
5433
5434 bnx2x_init_block(bp, HC_COMMON_START, HC_COMMON_END);
5435 bnx2x_init_block(bp, MISC_AEU_COMMON_START,
5436 MISC_AEU_COMMON_END);
5437 /* RXPCS COMMON comes here */
5438 /* EMAC0 COMMON comes here */
5439 /* EMAC1 COMMON comes here */
5440 /* DBU COMMON comes here */
5441 /* DBG COMMON comes here */
5442 bnx2x_init_block(bp, NIG_COMMON_START, NIG_COMMON_END);
5443
5444 if (CHIP_REV_IS_SLOW(bp))
5445 msleep(200);
5446
5447 /* finish CFC init */
5448 val = REG_RD(bp, CFC_REG_LL_INIT_DONE);
5449 if (val != 1) {
5450 BNX2X_ERR("CFC LL_INIT failed\n");
5451 return -EBUSY;
5452 }
5453
5454 val = REG_RD(bp, CFC_REG_AC_INIT_DONE);
5455 if (val != 1) {
5456 BNX2X_ERR("CFC AC_INIT failed\n");
5457 return -EBUSY;
5458 }
5459
5460 val = REG_RD(bp, CFC_REG_CAM_INIT_DONE);
5461 if (val != 1) {
5462 BNX2X_ERR("CFC CAM_INIT failed\n");
5463 return -EBUSY;
5464 }
5465
5466 REG_WR(bp, CFC_REG_DEBUG0, 0);
5467
5468 /* read NIG statistic
5469 to see if this is our first up since powerup */
5470 #ifdef BNX2X_DMAE_RD
5471 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
5472 val = *bnx2x_sp(bp, wb_data[0]);
5473 #else
5474 val = REG_RD(bp, NIG_REG_STAT2_BRB_OCTET);
5475 REG_RD(bp, NIG_REG_STAT2_BRB_OCTET + 4);
5476 #endif
5477 /* do internal memory self test */
5478 if ((val == 0) && bnx2x_int_mem_test(bp)) {
5479 BNX2X_ERR("internal mem selftest failed\n");
5480 return -EBUSY;
5481 }
5482
5483 /* clear PXP2 attentions */
5484 REG_RD(bp, PXP2_REG_PXP2_INT_STS_CLR);
5485
5486 enable_blocks_attention(bp);
5487 /* enable_blocks_parity(bp); */
5488
5489 } /* end of common init */
5490
5491 /* per port init */
5492
5493 /* the phys address is shifted right 12 bits and has an added
5494 1=valid bit added to the 53rd bit
5495 then since this is a wide register(TM)
5496 we split it into two 32 bit writes
5497 */
5498 #define RQ_ONCHIP_AT_PORT_SIZE 384
5499 #define ONCHIP_ADDR1(x) ((u32)(((u64)x >> 12) & 0xFFFFFFFF))
5500 #define ONCHIP_ADDR2(x) ((u32)((1 << 20) | ((u64)x >> 44)))
5501 #define PXP_ONE_ILT(x) ((x << 10) | x)
5502
5503 DP(BNX2X_MSG_MCP, "starting per-function init port is %x\n", func);
5504
5505 REG_WR(bp, NIG_REG_MASK_INTERRUPT_PORT0 + func*4, 0);
5506
5507 /* Port PXP comes here */
5508 /* Port PXP2 comes here */
5509
5510 /* Offset is
5511 * Port0 0
5512 * Port1 384 */
5513 i = func * RQ_ONCHIP_AT_PORT_SIZE;
5514 #ifdef USE_DMAE
5515 wb_write[0] = ONCHIP_ADDR1(bnx2x_sp_mapping(bp, context));
5516 wb_write[1] = ONCHIP_ADDR2(bnx2x_sp_mapping(bp, context));
5517 REG_WR_DMAE(bp, PXP2_REG_RQ_ONCHIP_AT + i*8, wb_write, 2);
5518 #else
5519 REG_WR_IND(bp, PXP2_REG_RQ_ONCHIP_AT + i*8,
5520 ONCHIP_ADDR1(bnx2x_sp_mapping(bp, context)));
5521 REG_WR_IND(bp, PXP2_REG_RQ_ONCHIP_AT + i*8 + 4,
5522 ONCHIP_ADDR2(bnx2x_sp_mapping(bp, context)));
5523 #endif
5524 REG_WR(bp, PXP2_REG_PSWRQ_CDU0_L2P + func*4, PXP_ONE_ILT(i));
5525
5526 #ifdef BCM_ISCSI
5527 /* Port0 1
5528 * Port1 385 */
5529 i++;
5530 wb_write[0] = ONCHIP_ADDR1(bp->timers_mapping);
5531 wb_write[1] = ONCHIP_ADDR2(bp->timers_mapping);
5532 REG_WR_DMAE(bp, PXP2_REG_RQ_ONCHIP_AT + i*8, wb_write, 2);
5533 REG_WR(bp, PXP2_REG_PSWRQ_TM0_L2P + func*4, PXP_ONE_ILT(i));
5534
5535 /* Port0 2
5536 * Port1 386 */
5537 i++;
5538 wb_write[0] = ONCHIP_ADDR1(bp->qm_mapping);
5539 wb_write[1] = ONCHIP_ADDR2(bp->qm_mapping);
5540 REG_WR_DMAE(bp, PXP2_REG_RQ_ONCHIP_AT + i*8, wb_write, 2);
5541 REG_WR(bp, PXP2_REG_PSWRQ_QM0_L2P + func*4, PXP_ONE_ILT(i));
5542
5543 /* Port0 3
5544 * Port1 387 */
5545 i++;
5546 wb_write[0] = ONCHIP_ADDR1(bp->t1_mapping);
5547 wb_write[1] = ONCHIP_ADDR2(bp->t1_mapping);
5548 REG_WR_DMAE(bp, PXP2_REG_RQ_ONCHIP_AT + i*8, wb_write, 2);
5549 REG_WR(bp, PXP2_REG_PSWRQ_SRC0_L2P + func*4, PXP_ONE_ILT(i));
5550 #endif
5551
5552 /* Port TCM comes here */
5553 /* Port UCM comes here */
5554 /* Port CCM comes here */
5555 bnx2x_init_block(bp, func ? XCM_PORT1_START : XCM_PORT0_START,
5556 func ? XCM_PORT1_END : XCM_PORT0_END);
5557
5558 #ifdef USE_DMAE
5559 wb_write[0] = 0;
5560 wb_write[1] = 0;
5561 #endif
5562 for (i = 0; i < 32; i++) {
5563 REG_WR(bp, QM_REG_BASEADDR + (func*32 + i)*4, 1024 * 4 * i);
5564 #ifdef USE_DMAE
5565 REG_WR_DMAE(bp, QM_REG_PTRTBL + (func*32 + i)*8, wb_write, 2);
5566 #else
5567 REG_WR_IND(bp, QM_REG_PTRTBL + (func*32 + i)*8, 0);
5568 REG_WR_IND(bp, QM_REG_PTRTBL + (func*32 + i)*8 + 4, 0);
5569 #endif
5570 }
5571 REG_WR(bp, QM_REG_CONNNUM_0 + func*4, 1024/16 - 1);
5572
5573 /* Port QM comes here */
5574
5575 #ifdef BCM_ISCSI
5576 REG_WR(bp, TM_REG_LIN0_SCAN_TIME + func*4, 1024/64*20);
5577 REG_WR(bp, TM_REG_LIN0_MAX_ACTIVE_CID + func*4, 31);
5578
5579 bnx2x_init_block(bp, func ? TIMERS_PORT1_START : TIMERS_PORT0_START,
5580 func ? TIMERS_PORT1_END : TIMERS_PORT0_END);
5581 #endif
5582 /* Port DQ comes here */
5583 /* Port BRB1 comes here */
5584 bnx2x_init_block(bp, func ? PRS_PORT1_START : PRS_PORT0_START,
5585 func ? PRS_PORT1_END : PRS_PORT0_END);
5586 /* Port TSDM comes here */
5587 /* Port CSDM comes here */
5588 /* Port USDM comes here */
5589 /* Port XSDM comes here */
5590 bnx2x_init_block(bp, func ? TSEM_PORT1_START : TSEM_PORT0_START,
5591 func ? TSEM_PORT1_END : TSEM_PORT0_END);
5592 bnx2x_init_block(bp, func ? USEM_PORT1_START : USEM_PORT0_START,
5593 func ? USEM_PORT1_END : USEM_PORT0_END);
5594 bnx2x_init_block(bp, func ? CSEM_PORT1_START : CSEM_PORT0_START,
5595 func ? CSEM_PORT1_END : CSEM_PORT0_END);
5596 bnx2x_init_block(bp, func ? XSEM_PORT1_START : XSEM_PORT0_START,
5597 func ? XSEM_PORT1_END : XSEM_PORT0_END);
5598 /* Port UPB comes here */
5599 /* Port XSDM comes here */
5600 bnx2x_init_block(bp, func ? PBF_PORT1_START : PBF_PORT0_START,
5601 func ? PBF_PORT1_END : PBF_PORT0_END);
5602
5603 /* configure PBF to work without PAUSE mtu 9000 */
5604 REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + func*4, 0);
5605
5606 /* update threshold */
5607 REG_WR(bp, PBF_REG_P0_ARB_THRSH + func*4, (9040/16));
5608 /* update init credit */
5609 REG_WR(bp, PBF_REG_P0_INIT_CRD + func*4, (9040/16) + 553 - 22);
5610
5611 /* probe changes */
5612 REG_WR(bp, PBF_REG_INIT_P0 + func*4, 1);
5613 msleep(5);
5614 REG_WR(bp, PBF_REG_INIT_P0 + func*4, 0);
5615
5616 #ifdef BCM_ISCSI
5617 /* tell the searcher where the T2 table is */
5618 REG_WR(bp, SRC_REG_COUNTFREE0 + func*4, 16*1024/64);
5619
5620 wb_write[0] = U64_LO(bp->t2_mapping);
5621 wb_write[1] = U64_HI(bp->t2_mapping);
5622 REG_WR_DMAE(bp, SRC_REG_FIRSTFREE0 + func*4, wb_write, 2);
5623 wb_write[0] = U64_LO((u64)bp->t2_mapping + 16*1024 - 64);
5624 wb_write[1] = U64_HI((u64)bp->t2_mapping + 16*1024 - 64);
5625 REG_WR_DMAE(bp, SRC_REG_LASTFREE0 + func*4, wb_write, 2);
5626
5627 REG_WR(bp, SRC_REG_NUMBER_HASH_BITS0 + func*4, 10);
5628 /* Port SRCH comes here */
5629 #endif
5630 /* Port CDU comes here */
5631 /* Port CFC comes here */
5632 bnx2x_init_block(bp, func ? HC_PORT1_START : HC_PORT0_START,
5633 func ? HC_PORT1_END : HC_PORT0_END);
5634 bnx2x_init_block(bp, func ? MISC_AEU_PORT1_START :
5635 MISC_AEU_PORT0_START,
5636 func ? MISC_AEU_PORT1_END : MISC_AEU_PORT0_END);
5637 /* Port PXPCS comes here */
5638 /* Port EMAC0 comes here */
5639 /* Port EMAC1 comes here */
5640 /* Port DBU comes here */
5641 /* Port DBG comes here */
5642 bnx2x_init_block(bp, func ? NIG_PORT1_START : NIG_PORT0_START,
5643 func ? NIG_PORT1_END : NIG_PORT0_END);
5644 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + func*4, 1);
5645 /* Port MCP comes here */
5646 /* Port DMAE comes here */
5647
5648 bnx2x_link_reset(bp);
5649
5650 /* Reset pciex errors for debug */
5651 REG_WR(bp, 0x2114, 0xffffffff);
5652 REG_WR(bp, 0x2120, 0xffffffff);
5653 REG_WR(bp, 0x2814, 0xffffffff);
5654
5655 /* !!! move to init_values.h */
5656 REG_WR(bp, XSDM_REG_INIT_CREDIT_PXP_CTRL, 0x1);
5657 REG_WR(bp, USDM_REG_INIT_CREDIT_PXP_CTRL, 0x1);
5658 REG_WR(bp, CSDM_REG_INIT_CREDIT_PXP_CTRL, 0x1);
5659 REG_WR(bp, TSDM_REG_INIT_CREDIT_PXP_CTRL, 0x1);
5660
5661 REG_WR(bp, DBG_REG_PCI_REQ_CREDIT, 0x1);
5662 REG_WR(bp, TM_REG_PCIARB_CRDCNT_VAL, 0x1);
5663 REG_WR(bp, CDU_REG_CDU_DEBUG, 0x264);
5664 REG_WR(bp, CDU_REG_CDU_DEBUG, 0x0);
5665
5666 bnx2x_gunzip_end(bp);
5667
5668 if (!nomcp) {
5669 port = bp->port;
5670
5671 bp->fw_drv_pulse_wr_seq =
5672 (SHMEM_RD(bp, drv_fw_mb[port].drv_pulse_mb) &
5673 DRV_PULSE_SEQ_MASK);
5674 bp->fw_mb = SHMEM_RD(bp, drv_fw_mb[port].fw_mb_param);
5675 DP(BNX2X_MSG_MCP, "drv_pulse 0x%x fw_mb 0x%x\n",
5676 bp->fw_drv_pulse_wr_seq, bp->fw_mb);
5677 } else {
5678 bp->fw_mb = 0;
5679 }
5680
5681 return 0;
5682 }
5683
5684
5685 /* send the MCP a request, block untill there is a reply */
5686 static u32 bnx2x_fw_command(struct bnx2x *bp, u32 command)
5687 {
5688 u32 rc = 0;
5689 u32 seq = ++bp->fw_seq;
5690 int port = bp->port;
5691
5692 SHMEM_WR(bp, drv_fw_mb[port].drv_mb_header, command|seq);
5693 DP(BNX2X_MSG_MCP, "wrote command (%x) to FW MB\n", command|seq);
5694
5695 /* let the FW do it's magic ... */
5696 msleep(100); /* TBD */
5697
5698 if (CHIP_REV_IS_SLOW(bp))
5699 msleep(900);
5700
5701 rc = SHMEM_RD(bp, drv_fw_mb[port].fw_mb_header);
5702
5703 DP(BNX2X_MSG_MCP, "read (%x) seq is (%x) from FW MB\n", rc, seq);
5704
5705 /* is this a reply to our command? */
5706 if (seq == (rc & FW_MSG_SEQ_NUMBER_MASK)) {
5707 rc &= FW_MSG_CODE_MASK;
5708 } else {
5709 /* FW BUG! */
5710 BNX2X_ERR("FW failed to respond!\n");
5711 bnx2x_fw_dump(bp);
5712 rc = 0;
5713 }
5714 return rc;
5715 }
5716
5717 static void bnx2x_free_mem(struct bnx2x *bp)
5718 {
5719
5720 #define BNX2X_PCI_FREE(x, y, size) \
5721 do { \
5722 if (x) { \
5723 pci_free_consistent(bp->pdev, size, x, y); \
5724 x = NULL; \
5725 y = 0; \
5726 } \
5727 } while (0)
5728
5729 #define BNX2X_FREE(x) \
5730 do { \
5731 if (x) { \
5732 vfree(x); \
5733 x = NULL; \
5734 } \
5735 } while (0)
5736
5737 int i;
5738
5739 /* fastpath */
5740 for_each_queue(bp, i) {
5741
5742 /* Status blocks */
5743 BNX2X_PCI_FREE(bnx2x_fp(bp, i, status_blk),
5744 bnx2x_fp(bp, i, status_blk_mapping),
5745 sizeof(struct host_status_block) +
5746 sizeof(struct eth_tx_db_data));
5747
5748 /* fast path rings: tx_buf tx_desc rx_buf rx_desc rx_comp */
5749 BNX2X_FREE(bnx2x_fp(bp, i, tx_buf_ring));
5750 BNX2X_PCI_FREE(bnx2x_fp(bp, i, tx_desc_ring),
5751 bnx2x_fp(bp, i, tx_desc_mapping),
5752 sizeof(struct eth_tx_bd) * NUM_TX_BD);
5753
5754 BNX2X_FREE(bnx2x_fp(bp, i, rx_buf_ring));
5755 BNX2X_PCI_FREE(bnx2x_fp(bp, i, rx_desc_ring),
5756 bnx2x_fp(bp, i, rx_desc_mapping),
5757 sizeof(struct eth_rx_bd) * NUM_RX_BD);
5758
5759 BNX2X_PCI_FREE(bnx2x_fp(bp, i, rx_comp_ring),
5760 bnx2x_fp(bp, i, rx_comp_mapping),
5761 sizeof(struct eth_fast_path_rx_cqe) *
5762 NUM_RCQ_BD);
5763 }
5764
5765 BNX2X_FREE(bp->fp);
5766
5767 /* end of fastpath */
5768
5769 BNX2X_PCI_FREE(bp->def_status_blk, bp->def_status_blk_mapping,
5770 (sizeof(struct host_def_status_block)));
5771
5772 BNX2X_PCI_FREE(bp->slowpath, bp->slowpath_mapping,
5773 (sizeof(struct bnx2x_slowpath)));
5774
5775 #ifdef BCM_ISCSI
5776 BNX2X_PCI_FREE(bp->t1, bp->t1_mapping, 64*1024);
5777 BNX2X_PCI_FREE(bp->t2, bp->t2_mapping, 16*1024);
5778 BNX2X_PCI_FREE(bp->timers, bp->timers_mapping, 8*1024);
5779 BNX2X_PCI_FREE(bp->qm, bp->qm_mapping, 128*1024);
5780 #endif
5781 BNX2X_PCI_FREE(bp->spq, bp->spq_mapping, PAGE_SIZE);
5782
5783 #undef BNX2X_PCI_FREE
5784 #undef BNX2X_KFREE
5785 }
5786
5787 static int bnx2x_alloc_mem(struct bnx2x *bp)
5788 {
5789
5790 #define BNX2X_PCI_ALLOC(x, y, size) \
5791 do { \
5792 x = pci_alloc_consistent(bp->pdev, size, y); \
5793 if (x == NULL) \
5794 goto alloc_mem_err; \
5795 memset(x, 0, size); \
5796 } while (0)
5797
5798 #define BNX2X_ALLOC(x, size) \
5799 do { \
5800 x = vmalloc(size); \
5801 if (x == NULL) \
5802 goto alloc_mem_err; \
5803 memset(x, 0, size); \
5804 } while (0)
5805
5806 int i;
5807
5808 /* fastpath */
5809 BNX2X_ALLOC(bp->fp, sizeof(struct bnx2x_fastpath) * bp->num_queues);
5810
5811 for_each_queue(bp, i) {
5812 bnx2x_fp(bp, i, bp) = bp;
5813
5814 /* Status blocks */
5815 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, status_blk),
5816 &bnx2x_fp(bp, i, status_blk_mapping),
5817 sizeof(struct host_status_block) +
5818 sizeof(struct eth_tx_db_data));
5819
5820 bnx2x_fp(bp, i, hw_tx_prods) =
5821 (void *)(bnx2x_fp(bp, i, status_blk) + 1);
5822
5823 bnx2x_fp(bp, i, tx_prods_mapping) =
5824 bnx2x_fp(bp, i, status_blk_mapping) +
5825 sizeof(struct host_status_block);
5826
5827 /* fast path rings: tx_buf tx_desc rx_buf rx_desc rx_comp */
5828 BNX2X_ALLOC(bnx2x_fp(bp, i, tx_buf_ring),
5829 sizeof(struct sw_tx_bd) * NUM_TX_BD);
5830 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, tx_desc_ring),
5831 &bnx2x_fp(bp, i, tx_desc_mapping),
5832 sizeof(struct eth_tx_bd) * NUM_TX_BD);
5833
5834 BNX2X_ALLOC(bnx2x_fp(bp, i, rx_buf_ring),
5835 sizeof(struct sw_rx_bd) * NUM_RX_BD);
5836 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, rx_desc_ring),
5837 &bnx2x_fp(bp, i, rx_desc_mapping),
5838 sizeof(struct eth_rx_bd) * NUM_RX_BD);
5839
5840 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, rx_comp_ring),
5841 &bnx2x_fp(bp, i, rx_comp_mapping),
5842 sizeof(struct eth_fast_path_rx_cqe) *
5843 NUM_RCQ_BD);
5844
5845 }
5846 /* end of fastpath */
5847
5848 BNX2X_PCI_ALLOC(bp->def_status_blk, &bp->def_status_blk_mapping,
5849 sizeof(struct host_def_status_block));
5850
5851 BNX2X_PCI_ALLOC(bp->slowpath, &bp->slowpath_mapping,
5852 sizeof(struct bnx2x_slowpath));
5853
5854 #ifdef BCM_ISCSI
5855 BNX2X_PCI_ALLOC(bp->t1, &bp->t1_mapping, 64*1024);
5856
5857 /* Initialize T1 */
5858 for (i = 0; i < 64*1024; i += 64) {
5859 *(u64 *)((char *)bp->t1 + i + 56) = 0x0UL;
5860 *(u64 *)((char *)bp->t1 + i + 3) = 0x0UL;
5861 }
5862
5863 /* allocate searcher T2 table
5864 we allocate 1/4 of alloc num for T2
5865 (which is not entered into the ILT) */
5866 BNX2X_PCI_ALLOC(bp->t2, &bp->t2_mapping, 16*1024);
5867
5868 /* Initialize T2 */
5869 for (i = 0; i < 16*1024; i += 64)
5870 * (u64 *)((char *)bp->t2 + i + 56) = bp->t2_mapping + i + 64;
5871
5872 /* now sixup the last line in the block to point to the next block */
5873 *(u64 *)((char *)bp->t2 + 1024*16-8) = bp->t2_mapping;
5874
5875 /* Timer block array (MAX_CONN*8) phys uncached for now 1024 conns */
5876 BNX2X_PCI_ALLOC(bp->timers, &bp->timers_mapping, 8*1024);
5877
5878 /* QM queues (128*MAX_CONN) */
5879 BNX2X_PCI_ALLOC(bp->qm, &bp->qm_mapping, 128*1024);
5880 #endif
5881
5882 /* Slow path ring */
5883 BNX2X_PCI_ALLOC(bp->spq, &bp->spq_mapping, BCM_PAGE_SIZE);
5884
5885 return 0;
5886
5887 alloc_mem_err:
5888 bnx2x_free_mem(bp);
5889 return -ENOMEM;
5890
5891 #undef BNX2X_PCI_ALLOC
5892 #undef BNX2X_ALLOC
5893 }
5894
5895 static void bnx2x_free_tx_skbs(struct bnx2x *bp)
5896 {
5897 int i;
5898
5899 for_each_queue(bp, i) {
5900 struct bnx2x_fastpath *fp = &bp->fp[i];
5901
5902 u16 bd_cons = fp->tx_bd_cons;
5903 u16 sw_prod = fp->tx_pkt_prod;
5904 u16 sw_cons = fp->tx_pkt_cons;
5905
5906 BUG_TRAP(fp->tx_buf_ring != NULL);
5907
5908 while (sw_cons != sw_prod) {
5909 bd_cons = bnx2x_free_tx_pkt(bp, fp, TX_BD(sw_cons));
5910 sw_cons++;
5911 }
5912 }
5913 }
5914
5915 static void bnx2x_free_rx_skbs(struct bnx2x *bp)
5916 {
5917 int i, j;
5918
5919 for_each_queue(bp, j) {
5920 struct bnx2x_fastpath *fp = &bp->fp[j];
5921
5922 BUG_TRAP(fp->rx_buf_ring != NULL);
5923
5924 for (i = 0; i < NUM_RX_BD; i++) {
5925 struct sw_rx_bd *rx_buf = &fp->rx_buf_ring[i];
5926 struct sk_buff *skb = rx_buf->skb;
5927
5928 if (skb == NULL)
5929 continue;
5930
5931 pci_unmap_single(bp->pdev,
5932 pci_unmap_addr(rx_buf, mapping),
5933 bp->rx_buf_use_size,
5934 PCI_DMA_FROMDEVICE);
5935
5936 rx_buf->skb = NULL;
5937 dev_kfree_skb(skb);
5938 }
5939 }
5940 }
5941
5942 static void bnx2x_free_skbs(struct bnx2x *bp)
5943 {
5944 bnx2x_free_tx_skbs(bp);
5945 bnx2x_free_rx_skbs(bp);
5946 }
5947
5948 static void bnx2x_free_msix_irqs(struct bnx2x *bp)
5949 {
5950 int i;
5951
5952 free_irq(bp->msix_table[0].vector, bp->dev);
5953 DP(NETIF_MSG_IFDOWN, "rleased sp irq (%d)\n",
5954 bp->msix_table[0].vector);
5955
5956 for_each_queue(bp, i) {
5957 DP(NETIF_MSG_IFDOWN, "about to rlease fp #%d->%d irq "
5958 "state(%x)\n", i, bp->msix_table[i + 1].vector,
5959 bnx2x_fp(bp, i, state));
5960
5961 if (bnx2x_fp(bp, i, state) != BNX2X_FP_STATE_CLOSED) {
5962
5963 free_irq(bp->msix_table[i + 1].vector, &bp->fp[i]);
5964 bnx2x_fp(bp, i, state) = BNX2X_FP_STATE_CLOSED;
5965
5966 } else
5967 DP(NETIF_MSG_IFDOWN, "irq not freed\n");
5968
5969 }
5970
5971 }
5972
5973 static void bnx2x_free_irq(struct bnx2x *bp)
5974 {
5975
5976 if (bp->flags & USING_MSIX_FLAG) {
5977
5978 bnx2x_free_msix_irqs(bp);
5979 pci_disable_msix(bp->pdev);
5980
5981 bp->flags &= ~USING_MSIX_FLAG;
5982
5983 } else
5984 free_irq(bp->pdev->irq, bp->dev);
5985 }
5986
5987 static int bnx2x_enable_msix(struct bnx2x *bp)
5988 {
5989
5990 int i;
5991
5992 bp->msix_table[0].entry = 0;
5993 for_each_queue(bp, i)
5994 bp->msix_table[i + 1].entry = i + 1;
5995
5996 if (pci_enable_msix(bp->pdev, &bp->msix_table[0],
5997 bp->num_queues + 1)){
5998 BNX2X_ERR("failed to enable msix\n");
5999 return -1;
6000
6001 }
6002
6003 bp->flags |= USING_MSIX_FLAG;
6004
6005 return 0;
6006
6007 }
6008
6009
6010 static int bnx2x_req_msix_irqs(struct bnx2x *bp)
6011 {
6012
6013
6014 int i, rc;
6015
6016 DP(NETIF_MSG_IFUP, "about to request sp irq\n");
6017
6018 rc = request_irq(bp->msix_table[0].vector, bnx2x_msix_sp_int, 0,
6019 bp->dev->name, bp->dev);
6020
6021 if (rc) {
6022 BNX2X_ERR("request sp irq failed\n");
6023 return -EBUSY;
6024 }
6025
6026 for_each_queue(bp, i) {
6027 rc = request_irq(bp->msix_table[i + 1].vector,
6028 bnx2x_msix_fp_int, 0,
6029 bp->dev->name, &bp->fp[i]);
6030
6031 if (rc) {
6032 BNX2X_ERR("request fp #%d irq failed\n", i);
6033 bnx2x_free_msix_irqs(bp);
6034 return -EBUSY;
6035 }
6036
6037 bnx2x_fp(bp, i, state) = BNX2X_FP_STATE_IRQ;
6038
6039 }
6040
6041 return 0;
6042
6043 }
6044
6045 static int bnx2x_req_irq(struct bnx2x *bp)
6046 {
6047
6048 int rc = request_irq(bp->pdev->irq, bnx2x_interrupt,
6049 IRQF_SHARED, bp->dev->name, bp->dev);
6050 if (!rc)
6051 bnx2x_fp(bp, 0, state) = BNX2X_FP_STATE_IRQ;
6052
6053 return rc;
6054
6055 }
6056
6057 /*
6058 * Init service functions
6059 */
6060
6061 static void bnx2x_set_mac_addr(struct bnx2x *bp)
6062 {
6063 struct mac_configuration_cmd *config = bnx2x_sp(bp, mac_config);
6064
6065 /* CAM allocation
6066 * unicasts 0-31:port0 32-63:port1
6067 * multicast 64-127:port0 128-191:port1
6068 */
6069 config->hdr.length_6b = 2;
6070 config->hdr.offset = bp->port ? 31 : 0;
6071 config->hdr.reserved0 = 0;
6072 config->hdr.reserved1 = 0;
6073
6074 /* primary MAC */
6075 config->config_table[0].cam_entry.msb_mac_addr =
6076 swab16(*(u16 *)&bp->dev->dev_addr[0]);
6077 config->config_table[0].cam_entry.middle_mac_addr =
6078 swab16(*(u16 *)&bp->dev->dev_addr[2]);
6079 config->config_table[0].cam_entry.lsb_mac_addr =
6080 swab16(*(u16 *)&bp->dev->dev_addr[4]);
6081 config->config_table[0].cam_entry.flags = cpu_to_le16(bp->port);
6082 config->config_table[0].target_table_entry.flags = 0;
6083 config->config_table[0].target_table_entry.client_id = 0;
6084 config->config_table[0].target_table_entry.vlan_id = 0;
6085
6086 DP(NETIF_MSG_IFUP, "setting MAC (%04x:%04x:%04x)\n",
6087 config->config_table[0].cam_entry.msb_mac_addr,
6088 config->config_table[0].cam_entry.middle_mac_addr,
6089 config->config_table[0].cam_entry.lsb_mac_addr);
6090
6091 /* broadcast */
6092 config->config_table[1].cam_entry.msb_mac_addr = 0xffff;
6093 config->config_table[1].cam_entry.middle_mac_addr = 0xffff;
6094 config->config_table[1].cam_entry.lsb_mac_addr = 0xffff;
6095 config->config_table[1].cam_entry.flags = cpu_to_le16(bp->port);
6096 config->config_table[1].target_table_entry.flags =
6097 TSTORM_CAM_TARGET_TABLE_ENTRY_BROADCAST;
6098 config->config_table[1].target_table_entry.client_id = 0;
6099 config->config_table[1].target_table_entry.vlan_id = 0;
6100
6101 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_SET_MAC, 0,
6102 U64_HI(bnx2x_sp_mapping(bp, mac_config)),
6103 U64_LO(bnx2x_sp_mapping(bp, mac_config)), 0);
6104 }
6105
6106 static int bnx2x_wait_ramrod(struct bnx2x *bp, int state, int idx,
6107 int *state_p, int poll)
6108 {
6109 /* can take a while if any port is running */
6110 int timeout = 500;
6111
6112 /* DP("waiting for state to become %d on IDX [%d]\n",
6113 state, sb_idx); */
6114
6115 might_sleep();
6116
6117 while (timeout) {
6118
6119 if (poll) {
6120 bnx2x_rx_int(bp->fp, 10);
6121 /* If index is different from 0
6122 * The reply for some commands will
6123 * be on the none default queue
6124 */
6125 if (idx)
6126 bnx2x_rx_int(&bp->fp[idx], 10);
6127 }
6128
6129 mb(); /* state is changed by bnx2x_sp_event()*/
6130
6131 if (*state_p != state)
6132 return 0;
6133
6134 timeout--;
6135 msleep(1);
6136
6137 }
6138
6139
6140 /* timeout! */
6141 BNX2X_ERR("timeout waiting for ramrod %d on %d\n", state, idx);
6142 return -EBUSY;
6143
6144 }
6145
6146 static int bnx2x_setup_leading(struct bnx2x *bp)
6147 {
6148
6149 /* reset IGU staae */
6150 bnx2x_ack_sb(bp, DEF_SB_ID, CSTORM_ID, 0, IGU_INT_ENABLE, 0);
6151
6152 /* SETUP ramrod */
6153 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_PORT_SETUP, 0, 0, 0, 0);
6154
6155 return bnx2x_wait_ramrod(bp, BNX2X_STATE_OPEN, 0, &(bp->state), 0);
6156
6157 }
6158
6159 static int bnx2x_setup_multi(struct bnx2x *bp, int index)
6160 {
6161
6162 /* reset IGU state */
6163 bnx2x_ack_sb(bp, index, CSTORM_ID, 0, IGU_INT_ENABLE, 0);
6164
6165 bp->fp[index].state = BNX2X_FP_STATE_OPENING;
6166 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_CLIENT_SETUP, index, 0, index, 0);
6167
6168 /* Wait for completion */
6169 return bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_OPEN, index,
6170 &(bp->fp[index].state), 1);
6171
6172 }
6173
6174
6175 static int bnx2x_poll(struct napi_struct *napi, int budget);
6176 static void bnx2x_set_rx_mode(struct net_device *dev);
6177
6178 static int bnx2x_nic_load(struct bnx2x *bp, int req_irq)
6179 {
6180 int rc;
6181 int i = 0;
6182
6183 bp->state = BNX2X_STATE_OPENING_WAIT4_LOAD;
6184
6185 /* Send LOAD_REQUEST command to MCP.
6186 Returns the type of LOAD command: if it is the
6187 first port to be initialized common blocks should be
6188 initialized, otherwise - not.
6189 */
6190 if (!nomcp) {
6191 rc = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_REQ);
6192 if (rc == FW_MSG_CODE_DRV_LOAD_REFUSED) {
6193 return -EBUSY; /* other port in diagnostic mode */
6194 }
6195 } else {
6196 rc = FW_MSG_CODE_DRV_LOAD_COMMON;
6197 }
6198
6199 DP(NETIF_MSG_IFUP, "set number of queues to %d\n", bp->num_queues);
6200
6201 /* if we can't use msix we only need one fp,
6202 * so try to enable msix with the requested number of fp's
6203 * and fallback to inta with one fp
6204 */
6205 if (req_irq) {
6206
6207 if (use_inta) {
6208 bp->num_queues = 1;
6209 } else {
6210 if (use_multi > 1 && use_multi <= 16)
6211 /* user requested number */
6212 bp->num_queues = use_multi;
6213 else if (use_multi == 1)
6214 bp->num_queues = num_online_cpus();
6215 else
6216 bp->num_queues = 1;
6217
6218 if (bnx2x_enable_msix(bp)) {
6219 /* faild to enable msix */
6220 bp->num_queues = 1;
6221 if (use_multi)
6222 BNX2X_ERR("Muti requested but failed"
6223 " to enable MSI-X\n");
6224 }
6225 }
6226 }
6227
6228 if (bnx2x_alloc_mem(bp))
6229 return -ENOMEM;
6230
6231 if (req_irq) {
6232 if (bp->flags & USING_MSIX_FLAG) {
6233 if (bnx2x_req_msix_irqs(bp)) {
6234 pci_disable_msix(bp->pdev);
6235 goto out_error;
6236 }
6237
6238 } else {
6239 if (bnx2x_req_irq(bp)) {
6240 BNX2X_ERR("IRQ request failed, aborting\n");
6241 goto out_error;
6242 }
6243 }
6244 }
6245
6246 for_each_queue(bp, i)
6247 netif_napi_add(bp->dev, &bnx2x_fp(bp, i, napi),
6248 bnx2x_poll, 128);
6249
6250
6251 /* Initialize HW */
6252 if (bnx2x_function_init(bp, (rc == FW_MSG_CODE_DRV_LOAD_COMMON))) {
6253 BNX2X_ERR("HW init failed, aborting\n");
6254 goto out_error;
6255 }
6256
6257
6258 atomic_set(&bp->intr_sem, 0);
6259
6260 /* Reenable SP tasklet */
6261 /*if (bp->sp_task_en) { */
6262 /* tasklet_enable(&bp->sp_task);*/
6263 /*} else { */
6264 /* bp->sp_task_en = 1; */
6265 /*} */
6266
6267 /* Setup NIC internals and enable interrupts */
6268 bnx2x_nic_init(bp);
6269
6270 /* Send LOAD_DONE command to MCP */
6271 if (!nomcp) {
6272 rc = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_DONE);
6273 DP(NETIF_MSG_IFUP, "rc = 0x%x\n", rc);
6274 if (!rc) {
6275 BNX2X_ERR("MCP response failure, unloading\n");
6276 goto int_disable;
6277 }
6278 }
6279
6280 bp->state = BNX2X_STATE_OPENING_WAIT4_PORT;
6281
6282 /* Enable Rx interrupt handling before sending the ramrod
6283 as it's completed on Rx FP queue */
6284 for_each_queue(bp, i)
6285 napi_enable(&bnx2x_fp(bp, i, napi));
6286
6287 if (bnx2x_setup_leading(bp))
6288 goto stop_netif;
6289
6290 for_each_nondefault_queue(bp, i)
6291 if (bnx2x_setup_multi(bp, i))
6292 goto stop_netif;
6293
6294 bnx2x_set_mac_addr(bp);
6295
6296 bnx2x_phy_init(bp);
6297
6298 /* Start fast path */
6299 if (req_irq) { /* IRQ is only requested from bnx2x_open */
6300 netif_start_queue(bp->dev);
6301 if (bp->flags & USING_MSIX_FLAG)
6302 printk(KERN_INFO PFX "%s: using MSI-X\n",
6303 bp->dev->name);
6304
6305 /* Otherwise Tx queue should be only reenabled */
6306 } else if (netif_running(bp->dev)) {
6307 netif_wake_queue(bp->dev);
6308 bnx2x_set_rx_mode(bp->dev);
6309 }
6310
6311 /* start the timer */
6312 mod_timer(&bp->timer, jiffies + bp->current_interval);
6313
6314 return 0;
6315
6316 stop_netif:
6317 for_each_queue(bp, i)
6318 napi_disable(&bnx2x_fp(bp, i, napi));
6319
6320 int_disable:
6321 bnx2x_disable_int_sync(bp);
6322
6323 bnx2x_free_skbs(bp);
6324 bnx2x_free_irq(bp);
6325
6326 out_error:
6327 bnx2x_free_mem(bp);
6328
6329 /* TBD we really need to reset the chip
6330 if we want to recover from this */
6331 return rc;
6332 }
6333
6334 static void bnx2x_netif_stop(struct bnx2x *bp)
6335 {
6336 int i;
6337
6338 bp->rx_mode = BNX2X_RX_MODE_NONE;
6339 bnx2x_set_storm_rx_mode(bp);
6340
6341 bnx2x_disable_int_sync(bp);
6342 bnx2x_link_reset(bp);
6343
6344 for_each_queue(bp, i)
6345 napi_disable(&bnx2x_fp(bp, i, napi));
6346
6347 if (netif_running(bp->dev)) {
6348 netif_tx_disable(bp->dev);
6349 bp->dev->trans_start = jiffies; /* prevent tx timeout */
6350 }
6351 }
6352
6353 static void bnx2x_reset_chip(struct bnx2x *bp, u32 reset_code)
6354 {
6355 int port = bp->port;
6356 #ifdef USE_DMAE
6357 u32 wb_write[2];
6358 #endif
6359 int base, i;
6360
6361 DP(NETIF_MSG_IFDOWN, "reset called with code %x\n", reset_code);
6362
6363 /* Do not rcv packets to BRB */
6364 REG_WR(bp, NIG_REG_LLH0_BRB1_DRV_MASK + port*4, 0x0);
6365 /* Do not direct rcv packets that are not for MCP to the BRB */
6366 REG_WR(bp, (port ? NIG_REG_LLH1_BRB1_NOT_MCP :
6367 NIG_REG_LLH0_BRB1_NOT_MCP), 0x0);
6368
6369 /* Configure IGU and AEU */
6370 REG_WR(bp, HC_REG_CONFIG_0 + port*4, 0x1000);
6371 REG_WR(bp, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4, 0);
6372
6373 /* TODO: Close Doorbell port? */
6374
6375 /* Clear ILT */
6376 #ifdef USE_DMAE
6377 wb_write[0] = 0;
6378 wb_write[1] = 0;
6379 #endif
6380 base = port * RQ_ONCHIP_AT_PORT_SIZE;
6381 for (i = base; i < base + RQ_ONCHIP_AT_PORT_SIZE; i++) {
6382 #ifdef USE_DMAE
6383 REG_WR_DMAE(bp, PXP2_REG_RQ_ONCHIP_AT + i*8, wb_write, 2);
6384 #else
6385 REG_WR_IND(bp, PXP2_REG_RQ_ONCHIP_AT, 0);
6386 REG_WR_IND(bp, PXP2_REG_RQ_ONCHIP_AT + 4, 0);
6387 #endif
6388 }
6389
6390 if (reset_code == FW_MSG_CODE_DRV_UNLOAD_COMMON) {
6391 /* reset_common */
6392 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
6393 0xd3ffff7f);
6394 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
6395 0x1403);
6396 }
6397 }
6398
6399 static int bnx2x_stop_multi(struct bnx2x *bp, int index)
6400 {
6401
6402 int rc;
6403
6404 /* halt the connnection */
6405 bp->fp[index].state = BNX2X_FP_STATE_HALTING;
6406 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_HALT, index, 0, 0, 0);
6407
6408
6409 rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_HALTED, index,
6410 &(bp->fp[index].state), 1);
6411 if (rc) /* timout */
6412 return rc;
6413
6414 /* delete cfc entry */
6415 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_CFC_DEL, index, 0, 0, 1);
6416
6417 return bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_DELETED, index,
6418 &(bp->fp[index].state), 1);
6419
6420 }
6421
6422
6423 static void bnx2x_stop_leading(struct bnx2x *bp)
6424 {
6425
6426 /* if the other port is hadling traffic,
6427 this can take a lot of time */
6428 int timeout = 500;
6429
6430 might_sleep();
6431
6432 /* Send HALT ramrod */
6433 bp->fp[0].state = BNX2X_FP_STATE_HALTING;
6434 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_HALT, 0, 0, 0, 0);
6435
6436 if (bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_HALTED, 0,
6437 &(bp->fp[0].state), 1))
6438 return;
6439
6440 bp->dsb_sp_prod_idx = *bp->dsb_sp_prod;
6441
6442 /* Send CFC_DELETE ramrod */
6443 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_PORT_DEL, 0, 0, 0, 1);
6444
6445 /*
6446 Wait for completion.
6447 we are going to reset the chip anyway
6448 so there is not much to do if this times out
6449 */
6450 while (bp->dsb_sp_prod_idx == *bp->dsb_sp_prod && timeout) {
6451 timeout--;
6452 msleep(1);
6453 }
6454
6455 }
6456
6457 static int bnx2x_nic_unload(struct bnx2x *bp, int fre_irq)
6458 {
6459 u32 reset_code = 0;
6460 int rc;
6461 int i;
6462
6463 bp->state = BNX2X_STATE_CLOSING_WAIT4_HALT;
6464
6465 /* Calling flush_scheduled_work() may deadlock because
6466 * linkwatch_event() may be on the workqueue and it will try to get
6467 * the rtnl_lock which we are holding.
6468 */
6469
6470 while (bp->in_reset_task)
6471 msleep(1);
6472
6473 /* Delete the timer: do it before disabling interrupts, as it
6474 may be stil STAT_QUERY ramrod pending after stopping the timer */
6475 del_timer_sync(&bp->timer);
6476
6477 /* Wait until stat ramrod returns and all SP tasks complete */
6478 while (bp->stat_pending && (bp->spq_left != MAX_SPQ_PENDING))
6479 msleep(1);
6480
6481 /* Stop fast path, disable MAC, disable interrupts, disable napi */
6482 bnx2x_netif_stop(bp);
6483
6484 if (bp->flags & NO_WOL_FLAG)
6485 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP;
6486 else if (bp->wol) {
6487 u32 emac_base = bp->port ? GRCBASE_EMAC0 : GRCBASE_EMAC1;
6488 u8 *mac_addr = bp->dev->dev_addr;
6489 u32 val = (EMAC_MODE_MPKT | EMAC_MODE_MPKT_RCVD |
6490 EMAC_MODE_ACPI_RCVD);
6491
6492 EMAC_WR(EMAC_REG_EMAC_MODE, val);
6493
6494 val = (mac_addr[0] << 8) | mac_addr[1];
6495 EMAC_WR(EMAC_REG_EMAC_MAC_MATCH, val);
6496
6497 val = (mac_addr[2] << 24) | (mac_addr[3] << 16) |
6498 (mac_addr[4] << 8) | mac_addr[5];
6499 EMAC_WR(EMAC_REG_EMAC_MAC_MATCH + 4, val);
6500
6501 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_EN;
6502 } else
6503 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
6504
6505 for_each_nondefault_queue(bp, i)
6506 if (bnx2x_stop_multi(bp, i))
6507 goto error;
6508
6509
6510 bnx2x_stop_leading(bp);
6511
6512 error:
6513 if (!nomcp)
6514 rc = bnx2x_fw_command(bp, reset_code);
6515 else
6516 rc = FW_MSG_CODE_DRV_UNLOAD_COMMON;
6517
6518 /* Release IRQs */
6519 if (fre_irq)
6520 bnx2x_free_irq(bp);
6521
6522 /* Reset the chip */
6523 bnx2x_reset_chip(bp, rc);
6524
6525 /* Report UNLOAD_DONE to MCP */
6526 if (!nomcp)
6527 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE);
6528
6529 /* Free SKBs and driver internals */
6530 bnx2x_free_skbs(bp);
6531 bnx2x_free_mem(bp);
6532
6533 bp->state = BNX2X_STATE_CLOSED;
6534 /* Set link down */
6535 bp->link_up = 0;
6536 netif_carrier_off(bp->dev);
6537
6538 return 0;
6539 }
6540
6541 /* end of nic load/unload */
6542
6543 /* ethtool_ops */
6544
6545 /*
6546 * Init service functions
6547 */
6548
6549 static void bnx2x_link_settings_supported(struct bnx2x *bp, u32 switch_cfg)
6550 {
6551 int port = bp->port;
6552 u32 ext_phy_type;
6553
6554 bp->phy_flags = 0;
6555
6556 switch (switch_cfg) {
6557 case SWITCH_CFG_1G:
6558 BNX2X_DEV_INFO("switch_cfg 0x%x (1G)\n", switch_cfg);
6559
6560 ext_phy_type = SERDES_EXT_PHY_TYPE(bp);
6561 switch (ext_phy_type) {
6562 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT:
6563 BNX2X_DEV_INFO("ext_phy_type 0x%x (Direct)\n",
6564 ext_phy_type);
6565
6566 bp->supported |= (SUPPORTED_10baseT_Half |
6567 SUPPORTED_10baseT_Full |
6568 SUPPORTED_100baseT_Half |
6569 SUPPORTED_100baseT_Full |
6570 SUPPORTED_1000baseT_Full |
6571 SUPPORTED_2500baseT_Full |
6572 SUPPORTED_TP | SUPPORTED_FIBRE |
6573 SUPPORTED_Autoneg |
6574 SUPPORTED_Pause |
6575 SUPPORTED_Asym_Pause);
6576 break;
6577
6578 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482:
6579 BNX2X_DEV_INFO("ext_phy_type 0x%x (5482)\n",
6580 ext_phy_type);
6581
6582 bp->phy_flags |= PHY_SGMII_FLAG;
6583
6584 bp->supported |= (/* SUPPORTED_10baseT_Half |
6585 SUPPORTED_10baseT_Full |
6586 SUPPORTED_100baseT_Half |
6587 SUPPORTED_100baseT_Full |*/
6588 SUPPORTED_1000baseT_Full |
6589 SUPPORTED_TP | SUPPORTED_FIBRE |
6590 SUPPORTED_Autoneg |
6591 SUPPORTED_Pause |
6592 SUPPORTED_Asym_Pause);
6593 break;
6594
6595 default:
6596 BNX2X_ERR("NVRAM config error. "
6597 "BAD SerDes ext_phy_config 0x%x\n",
6598 bp->ext_phy_config);
6599 return;
6600 }
6601
6602 bp->phy_addr = REG_RD(bp, NIG_REG_SERDES0_CTRL_PHY_ADDR +
6603 port*0x10);
6604 BNX2X_DEV_INFO("phy_addr 0x%x\n", bp->phy_addr);
6605 break;
6606
6607 case SWITCH_CFG_10G:
6608 BNX2X_DEV_INFO("switch_cfg 0x%x (10G)\n", switch_cfg);
6609
6610 bp->phy_flags |= PHY_XGXS_FLAG;
6611
6612 ext_phy_type = XGXS_EXT_PHY_TYPE(bp);
6613 switch (ext_phy_type) {
6614 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
6615 BNX2X_DEV_INFO("ext_phy_type 0x%x (Direct)\n",
6616 ext_phy_type);
6617
6618 bp->supported |= (SUPPORTED_10baseT_Half |
6619 SUPPORTED_10baseT_Full |
6620 SUPPORTED_100baseT_Half |
6621 SUPPORTED_100baseT_Full |
6622 SUPPORTED_1000baseT_Full |
6623 SUPPORTED_2500baseT_Full |
6624 SUPPORTED_10000baseT_Full |
6625 SUPPORTED_TP | SUPPORTED_FIBRE |
6626 SUPPORTED_Autoneg |
6627 SUPPORTED_Pause |
6628 SUPPORTED_Asym_Pause);
6629 break;
6630
6631 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
6632 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
6633 BNX2X_DEV_INFO("ext_phy_type 0x%x (8705/6)\n",
6634 ext_phy_type);
6635
6636 bp->supported |= (SUPPORTED_10000baseT_Full |
6637 SUPPORTED_FIBRE |
6638 SUPPORTED_Pause |
6639 SUPPORTED_Asym_Pause);
6640 break;
6641
6642 default:
6643 BNX2X_ERR("NVRAM config error. "
6644 "BAD XGXS ext_phy_config 0x%x\n",
6645 bp->ext_phy_config);
6646 return;
6647 }
6648
6649 bp->phy_addr = REG_RD(bp, NIG_REG_XGXS0_CTRL_PHY_ADDR +
6650 port*0x18);
6651 BNX2X_DEV_INFO("phy_addr 0x%x\n", bp->phy_addr);
6652
6653 bp->ser_lane = ((bp->lane_config &
6654 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
6655 PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
6656 bp->rx_lane_swap = ((bp->lane_config &
6657 PORT_HW_CFG_LANE_SWAP_CFG_RX_MASK) >>
6658 PORT_HW_CFG_LANE_SWAP_CFG_RX_SHIFT);
6659 bp->tx_lane_swap = ((bp->lane_config &
6660 PORT_HW_CFG_LANE_SWAP_CFG_TX_MASK) >>
6661 PORT_HW_CFG_LANE_SWAP_CFG_TX_SHIFT);
6662 BNX2X_DEV_INFO("rx_lane_swap 0x%x tx_lane_swap 0x%x\n",
6663 bp->rx_lane_swap, bp->tx_lane_swap);
6664 break;
6665
6666 default:
6667 BNX2X_ERR("BAD switch_cfg link_config 0x%x\n",
6668 bp->link_config);
6669 return;
6670 }
6671
6672 /* mask what we support according to speed_cap_mask */
6673 if (!(bp->speed_cap_mask &
6674 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF))
6675 bp->supported &= ~SUPPORTED_10baseT_Half;
6676
6677 if (!(bp->speed_cap_mask &
6678 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL))
6679 bp->supported &= ~SUPPORTED_10baseT_Full;
6680
6681 if (!(bp->speed_cap_mask &
6682 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF))
6683 bp->supported &= ~SUPPORTED_100baseT_Half;
6684
6685 if (!(bp->speed_cap_mask &
6686 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL))
6687 bp->supported &= ~SUPPORTED_100baseT_Full;
6688
6689 if (!(bp->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_1G))
6690 bp->supported &= ~(SUPPORTED_1000baseT_Half |
6691 SUPPORTED_1000baseT_Full);
6692
6693 if (!(bp->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G))
6694 bp->supported &= ~SUPPORTED_2500baseT_Full;
6695
6696 if (!(bp->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_10G))
6697 bp->supported &= ~SUPPORTED_10000baseT_Full;
6698
6699 BNX2X_DEV_INFO("supported 0x%x\n", bp->supported);
6700 }
6701
6702 static void bnx2x_link_settings_requested(struct bnx2x *bp)
6703 {
6704 bp->req_autoneg = 0;
6705 bp->req_duplex = DUPLEX_FULL;
6706
6707 switch (bp->link_config & PORT_FEATURE_LINK_SPEED_MASK) {
6708 case PORT_FEATURE_LINK_SPEED_AUTO:
6709 if (bp->supported & SUPPORTED_Autoneg) {
6710 bp->req_autoneg |= AUTONEG_SPEED;
6711 bp->req_line_speed = 0;
6712 bp->advertising = bp->supported;
6713 } else {
6714 u32 ext_phy_type;
6715
6716 ext_phy_type = XGXS_EXT_PHY_TYPE(bp);
6717 if ((ext_phy_type ==
6718 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705) ||
6719 (ext_phy_type ==
6720 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706)) {
6721 /* force 10G, no AN */
6722 bp->req_line_speed = SPEED_10000;
6723 bp->advertising =
6724 (ADVERTISED_10000baseT_Full |
6725 ADVERTISED_FIBRE);
6726 break;
6727 }
6728 BNX2X_ERR("NVRAM config error. "
6729 "Invalid link_config 0x%x"
6730 " Autoneg not supported\n",
6731 bp->link_config);
6732 return;
6733 }
6734 break;
6735
6736 case PORT_FEATURE_LINK_SPEED_10M_FULL:
6737 if (bp->speed_cap_mask &
6738 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL) {
6739 bp->req_line_speed = SPEED_10;
6740 bp->advertising = (ADVERTISED_10baseT_Full |
6741 ADVERTISED_TP);
6742 } else {
6743 BNX2X_ERR("NVRAM config error. "
6744 "Invalid link_config 0x%x"
6745 " speed_cap_mask 0x%x\n",
6746 bp->link_config, bp->speed_cap_mask);
6747 return;
6748 }
6749 break;
6750
6751 case PORT_FEATURE_LINK_SPEED_10M_HALF:
6752 if (bp->speed_cap_mask &
6753 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF) {
6754 bp->req_line_speed = SPEED_10;
6755 bp->req_duplex = DUPLEX_HALF;
6756 bp->advertising = (ADVERTISED_10baseT_Half |
6757 ADVERTISED_TP);
6758 } else {
6759 BNX2X_ERR("NVRAM config error. "
6760 "Invalid link_config 0x%x"
6761 " speed_cap_mask 0x%x\n",
6762 bp->link_config, bp->speed_cap_mask);
6763 return;
6764 }
6765 break;
6766
6767 case PORT_FEATURE_LINK_SPEED_100M_FULL:
6768 if (bp->speed_cap_mask &
6769 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL) {
6770 bp->req_line_speed = SPEED_100;
6771 bp->advertising = (ADVERTISED_100baseT_Full |
6772 ADVERTISED_TP);
6773 } else {
6774 BNX2X_ERR("NVRAM config error. "
6775 "Invalid link_config 0x%x"
6776 " speed_cap_mask 0x%x\n",
6777 bp->link_config, bp->speed_cap_mask);
6778 return;
6779 }
6780 break;
6781
6782 case PORT_FEATURE_LINK_SPEED_100M_HALF:
6783 if (bp->speed_cap_mask &
6784 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF) {
6785 bp->req_line_speed = SPEED_100;
6786 bp->req_duplex = DUPLEX_HALF;
6787 bp->advertising = (ADVERTISED_100baseT_Half |
6788 ADVERTISED_TP);
6789 } else {
6790 BNX2X_ERR("NVRAM config error. "
6791 "Invalid link_config 0x%x"
6792 " speed_cap_mask 0x%x\n",
6793 bp->link_config, bp->speed_cap_mask);
6794 return;
6795 }
6796 break;
6797
6798 case PORT_FEATURE_LINK_SPEED_1G:
6799 if (bp->speed_cap_mask &
6800 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G) {
6801 bp->req_line_speed = SPEED_1000;
6802 bp->advertising = (ADVERTISED_1000baseT_Full |
6803 ADVERTISED_TP);
6804 } else {
6805 BNX2X_ERR("NVRAM config error. "
6806 "Invalid link_config 0x%x"
6807 " speed_cap_mask 0x%x\n",
6808 bp->link_config, bp->speed_cap_mask);
6809 return;
6810 }
6811 break;
6812
6813 case PORT_FEATURE_LINK_SPEED_2_5G:
6814 if (bp->speed_cap_mask &
6815 PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G) {
6816 bp->req_line_speed = SPEED_2500;
6817 bp->advertising = (ADVERTISED_2500baseT_Full |
6818 ADVERTISED_TP);
6819 } else {
6820 BNX2X_ERR("NVRAM config error. "
6821 "Invalid link_config 0x%x"
6822 " speed_cap_mask 0x%x\n",
6823 bp->link_config, bp->speed_cap_mask);
6824 return;
6825 }
6826 break;
6827
6828 case PORT_FEATURE_LINK_SPEED_10G_CX4:
6829 case PORT_FEATURE_LINK_SPEED_10G_KX4:
6830 case PORT_FEATURE_LINK_SPEED_10G_KR:
6831 if (!(bp->phy_flags & PHY_XGXS_FLAG)) {
6832 BNX2X_ERR("NVRAM config error. "
6833 "Invalid link_config 0x%x"
6834 " phy_flags 0x%x\n",
6835 bp->link_config, bp->phy_flags);
6836 return;
6837 }
6838 if (bp->speed_cap_mask &
6839 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G) {
6840 bp->req_line_speed = SPEED_10000;
6841 bp->advertising = (ADVERTISED_10000baseT_Full |
6842 ADVERTISED_FIBRE);
6843 } else {
6844 BNX2X_ERR("NVRAM config error. "
6845 "Invalid link_config 0x%x"
6846 " speed_cap_mask 0x%x\n",
6847 bp->link_config, bp->speed_cap_mask);
6848 return;
6849 }
6850 break;
6851
6852 default:
6853 BNX2X_ERR("NVRAM config error. "
6854 "BAD link speed link_config 0x%x\n",
6855 bp->link_config);
6856 bp->req_autoneg |= AUTONEG_SPEED;
6857 bp->req_line_speed = 0;
6858 bp->advertising = bp->supported;
6859 break;
6860 }
6861 BNX2X_DEV_INFO("req_line_speed %d req_duplex %d\n",
6862 bp->req_line_speed, bp->req_duplex);
6863
6864 bp->req_flow_ctrl = (bp->link_config &
6865 PORT_FEATURE_FLOW_CONTROL_MASK);
6866 /* Please refer to Table 28B-3 of the 802.3ab-1999 spec */
6867 switch (bp->req_flow_ctrl) {
6868 case FLOW_CTRL_AUTO:
6869 bp->req_autoneg |= AUTONEG_FLOW_CTRL;
6870 if (bp->dev->mtu <= 4500) {
6871 bp->pause_mode = PAUSE_BOTH;
6872 bp->advertising |= (ADVERTISED_Pause |
6873 ADVERTISED_Asym_Pause);
6874 } else {
6875 bp->pause_mode = PAUSE_ASYMMETRIC;
6876 bp->advertising |= ADVERTISED_Asym_Pause;
6877 }
6878 break;
6879
6880 case FLOW_CTRL_TX:
6881 bp->pause_mode = PAUSE_ASYMMETRIC;
6882 bp->advertising |= ADVERTISED_Asym_Pause;
6883 break;
6884
6885 case FLOW_CTRL_RX:
6886 case FLOW_CTRL_BOTH:
6887 bp->pause_mode = PAUSE_BOTH;
6888 bp->advertising |= (ADVERTISED_Pause |
6889 ADVERTISED_Asym_Pause);
6890 break;
6891
6892 case FLOW_CTRL_NONE:
6893 default:
6894 bp->pause_mode = PAUSE_NONE;
6895 bp->advertising &= ~(ADVERTISED_Pause |
6896 ADVERTISED_Asym_Pause);
6897 break;
6898 }
6899 BNX2X_DEV_INFO("req_autoneg 0x%x req_flow_ctrl 0x%x\n"
6900 KERN_INFO " pause_mode %d advertising 0x%x\n",
6901 bp->req_autoneg, bp->req_flow_ctrl,
6902 bp->pause_mode, bp->advertising);
6903 }
6904
6905 static void bnx2x_get_hwinfo(struct bnx2x *bp)
6906 {
6907 u32 val, val2, val3, val4, id;
6908 int port = bp->port;
6909 u32 switch_cfg;
6910
6911 bp->shmem_base = REG_RD(bp, MISC_REG_SHARED_MEM_ADDR);
6912 BNX2X_DEV_INFO("shmem offset is %x\n", bp->shmem_base);
6913
6914 /* Get the chip revision id and number. */
6915 /* chip num:16-31, rev:12-15, metal:4-11, bond_id:0-3 */
6916 val = REG_RD(bp, MISC_REG_CHIP_NUM);
6917 id = ((val & 0xffff) << 16);
6918 val = REG_RD(bp, MISC_REG_CHIP_REV);
6919 id |= ((val & 0xf) << 12);
6920 val = REG_RD(bp, MISC_REG_CHIP_METAL);
6921 id |= ((val & 0xff) << 4);
6922 REG_RD(bp, MISC_REG_BOND_ID);
6923 id |= (val & 0xf);
6924 bp->chip_id = id;
6925 BNX2X_DEV_INFO("chip ID is %x\n", id);
6926
6927 if (!bp->shmem_base || (bp->shmem_base != 0xAF900)) {
6928 BNX2X_DEV_INFO("MCP not active\n");
6929 nomcp = 1;
6930 goto set_mac;
6931 }
6932
6933 val = SHMEM_RD(bp, validity_map[port]);
6934 if ((val & (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
6935 != (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
6936 BNX2X_ERR("MCP validity signature bad\n");
6937
6938 bp->fw_seq = (SHMEM_RD(bp, drv_fw_mb[port].drv_mb_header) &
6939 DRV_MSG_SEQ_NUMBER_MASK);
6940
6941 bp->hw_config = SHMEM_RD(bp, dev_info.shared_hw_config.config);
6942
6943 bp->serdes_config =
6944 SHMEM_RD(bp, dev_info.port_hw_config[bp->port].serdes_config);
6945 bp->lane_config =
6946 SHMEM_RD(bp, dev_info.port_hw_config[port].lane_config);
6947 bp->ext_phy_config =
6948 SHMEM_RD(bp,
6949 dev_info.port_hw_config[port].external_phy_config);
6950 bp->speed_cap_mask =
6951 SHMEM_RD(bp,
6952 dev_info.port_hw_config[port].speed_capability_mask);
6953
6954 bp->link_config =
6955 SHMEM_RD(bp, dev_info.port_feature_config[port].link_config);
6956
6957 BNX2X_DEV_INFO("hw_config (%08x) serdes_config (%08x)\n"
6958 KERN_INFO " lane_config (%08x) ext_phy_config (%08x)\n"
6959 KERN_INFO " speed_cap_mask (%08x) link_config (%08x)"
6960 " fw_seq (%08x)\n",
6961 bp->hw_config, bp->serdes_config, bp->lane_config,
6962 bp->ext_phy_config, bp->speed_cap_mask,
6963 bp->link_config, bp->fw_seq);
6964
6965 switch_cfg = (bp->link_config & PORT_FEATURE_CONNECTED_SWITCH_MASK);
6966 bnx2x_link_settings_supported(bp, switch_cfg);
6967
6968 bp->autoneg = (bp->hw_config & SHARED_HW_CFG_AN_ENABLE_MASK);
6969 /* for now disable cl73 */
6970 bp->autoneg &= ~SHARED_HW_CFG_AN_ENABLE_CL73;
6971 BNX2X_DEV_INFO("autoneg 0x%x\n", bp->autoneg);
6972
6973 bnx2x_link_settings_requested(bp);
6974
6975 val2 = SHMEM_RD(bp, dev_info.port_hw_config[port].mac_upper);
6976 val = SHMEM_RD(bp, dev_info.port_hw_config[port].mac_lower);
6977 bp->dev->dev_addr[0] = (u8)(val2 >> 8 & 0xff);
6978 bp->dev->dev_addr[1] = (u8)(val2 & 0xff);
6979 bp->dev->dev_addr[2] = (u8)(val >> 24 & 0xff);
6980 bp->dev->dev_addr[3] = (u8)(val >> 16 & 0xff);
6981 bp->dev->dev_addr[4] = (u8)(val >> 8 & 0xff);
6982 bp->dev->dev_addr[5] = (u8)(val & 0xff);
6983
6984 memcpy(bp->dev->perm_addr, bp->dev->dev_addr, 6);
6985
6986
6987 val = SHMEM_RD(bp, dev_info.shared_hw_config.part_num);
6988 val2 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[4]);
6989 val3 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[8]);
6990 val4 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[12]);
6991
6992 printk(KERN_INFO PFX "part number %X-%X-%X-%X\n",
6993 val, val2, val3, val4);
6994
6995 /* bc ver */
6996 if (!nomcp) {
6997 bp->bc_ver = val = ((SHMEM_RD(bp, dev_info.bc_rev)) >> 8);
6998 BNX2X_DEV_INFO("bc_ver %X\n", val);
6999 if (val < BNX2X_BC_VER) {
7000 /* for now only warn
7001 * later we might need to enforce this */
7002 BNX2X_ERR("This driver needs bc_ver %X but found %X,"
7003 " please upgrade BC\n", BNX2X_BC_VER, val);
7004 }
7005 } else {
7006 bp->bc_ver = 0;
7007 }
7008
7009 val = REG_RD(bp, MCP_REG_MCPR_NVM_CFG4);
7010 bp->flash_size = (NVRAM_1MB_SIZE << (val & MCPR_NVM_CFG4_FLASH_SIZE));
7011 BNX2X_DEV_INFO("flash_size 0x%x (%d)\n",
7012 bp->flash_size, bp->flash_size);
7013
7014 return;
7015
7016 set_mac: /* only supposed to happen on emulation/FPGA */
7017 BNX2X_ERR("warning constant MAC workaround active\n");
7018 bp->dev->dev_addr[0] = 0;
7019 bp->dev->dev_addr[1] = 0x50;
7020 bp->dev->dev_addr[2] = 0xc2;
7021 bp->dev->dev_addr[3] = 0x2c;
7022 bp->dev->dev_addr[4] = 0x71;
7023 bp->dev->dev_addr[5] = port ? 0x0d : 0x0e;
7024
7025 memcpy(bp->dev->perm_addr, bp->dev->dev_addr, 6);
7026
7027 }
7028
7029 /*
7030 * ethtool service functions
7031 */
7032
7033 /* All ethtool functions called with rtnl_lock */
7034
7035 static int bnx2x_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
7036 {
7037 struct bnx2x *bp = netdev_priv(dev);
7038
7039 cmd->supported = bp->supported;
7040 cmd->advertising = bp->advertising;
7041
7042 if (netif_carrier_ok(dev)) {
7043 cmd->speed = bp->line_speed;
7044 cmd->duplex = bp->duplex;
7045 } else {
7046 cmd->speed = bp->req_line_speed;
7047 cmd->duplex = bp->req_duplex;
7048 }
7049
7050 if (bp->phy_flags & PHY_XGXS_FLAG) {
7051 cmd->port = PORT_FIBRE;
7052 } else {
7053 cmd->port = PORT_TP;
7054 }
7055
7056 cmd->phy_address = bp->phy_addr;
7057 cmd->transceiver = XCVR_INTERNAL;
7058
7059 if (bp->req_autoneg & AUTONEG_SPEED) {
7060 cmd->autoneg = AUTONEG_ENABLE;
7061 } else {
7062 cmd->autoneg = AUTONEG_DISABLE;
7063 }
7064
7065 cmd->maxtxpkt = 0;
7066 cmd->maxrxpkt = 0;
7067
7068 DP(NETIF_MSG_LINK, "ethtool_cmd: cmd %d\n"
7069 DP_LEVEL " supported 0x%x advertising 0x%x speed %d\n"
7070 DP_LEVEL " duplex %d port %d phy_address %d transceiver %d\n"
7071 DP_LEVEL " autoneg %d maxtxpkt %d maxrxpkt %d\n",
7072 cmd->cmd, cmd->supported, cmd->advertising, cmd->speed,
7073 cmd->duplex, cmd->port, cmd->phy_address, cmd->transceiver,
7074 cmd->autoneg, cmd->maxtxpkt, cmd->maxrxpkt);
7075
7076 return 0;
7077 }
7078
7079 static int bnx2x_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
7080 {
7081 struct bnx2x *bp = netdev_priv(dev);
7082 u32 advertising;
7083
7084 DP(NETIF_MSG_LINK, "ethtool_cmd: cmd %d\n"
7085 DP_LEVEL " supported 0x%x advertising 0x%x speed %d\n"
7086 DP_LEVEL " duplex %d port %d phy_address %d transceiver %d\n"
7087 DP_LEVEL " autoneg %d maxtxpkt %d maxrxpkt %d\n",
7088 cmd->cmd, cmd->supported, cmd->advertising, cmd->speed,
7089 cmd->duplex, cmd->port, cmd->phy_address, cmd->transceiver,
7090 cmd->autoneg, cmd->maxtxpkt, cmd->maxrxpkt);
7091
7092 switch (cmd->port) {
7093 case PORT_TP:
7094 if (!(bp->supported & SUPPORTED_TP))
7095 return -EINVAL;
7096
7097 if (bp->phy_flags & PHY_XGXS_FLAG) {
7098 bnx2x_link_reset(bp);
7099 bnx2x_link_settings_supported(bp, SWITCH_CFG_1G);
7100 bnx2x_phy_deassert(bp);
7101 }
7102 break;
7103
7104 case PORT_FIBRE:
7105 if (!(bp->supported & SUPPORTED_FIBRE))
7106 return -EINVAL;
7107
7108 if (!(bp->phy_flags & PHY_XGXS_FLAG)) {
7109 bnx2x_link_reset(bp);
7110 bnx2x_link_settings_supported(bp, SWITCH_CFG_10G);
7111 bnx2x_phy_deassert(bp);
7112 }
7113 break;
7114
7115 default:
7116 return -EINVAL;
7117 }
7118
7119 if (cmd->autoneg == AUTONEG_ENABLE) {
7120 if (!(bp->supported & SUPPORTED_Autoneg))
7121 return -EINVAL;
7122
7123 /* advertise the requested speed and duplex if supported */
7124 cmd->advertising &= bp->supported;
7125
7126 bp->req_autoneg |= AUTONEG_SPEED;
7127 bp->req_line_speed = 0;
7128 bp->req_duplex = DUPLEX_FULL;
7129 bp->advertising |= (ADVERTISED_Autoneg | cmd->advertising);
7130
7131 } else { /* forced speed */
7132 /* advertise the requested speed and duplex if supported */
7133 switch (cmd->speed) {
7134 case SPEED_10:
7135 if (cmd->duplex == DUPLEX_FULL) {
7136 if (!(bp->supported & SUPPORTED_10baseT_Full))
7137 return -EINVAL;
7138
7139 advertising = (ADVERTISED_10baseT_Full |
7140 ADVERTISED_TP);
7141 } else {
7142 if (!(bp->supported & SUPPORTED_10baseT_Half))
7143 return -EINVAL;
7144
7145 advertising = (ADVERTISED_10baseT_Half |
7146 ADVERTISED_TP);
7147 }
7148 break;
7149
7150 case SPEED_100:
7151 if (cmd->duplex == DUPLEX_FULL) {
7152 if (!(bp->supported &
7153 SUPPORTED_100baseT_Full))
7154 return -EINVAL;
7155
7156 advertising = (ADVERTISED_100baseT_Full |
7157 ADVERTISED_TP);
7158 } else {
7159 if (!(bp->supported &
7160 SUPPORTED_100baseT_Half))
7161 return -EINVAL;
7162
7163 advertising = (ADVERTISED_100baseT_Half |
7164 ADVERTISED_TP);
7165 }
7166 break;
7167
7168 case SPEED_1000:
7169 if (cmd->duplex != DUPLEX_FULL)
7170 return -EINVAL;
7171
7172 if (!(bp->supported & SUPPORTED_1000baseT_Full))
7173 return -EINVAL;
7174
7175 advertising = (ADVERTISED_1000baseT_Full |
7176 ADVERTISED_TP);
7177 break;
7178
7179 case SPEED_2500:
7180 if (cmd->duplex != DUPLEX_FULL)
7181 return -EINVAL;
7182
7183 if (!(bp->supported & SUPPORTED_2500baseT_Full))
7184 return -EINVAL;
7185
7186 advertising = (ADVERTISED_2500baseT_Full |
7187 ADVERTISED_TP);
7188 break;
7189
7190 case SPEED_10000:
7191 if (cmd->duplex != DUPLEX_FULL)
7192 return -EINVAL;
7193
7194 if (!(bp->supported & SUPPORTED_10000baseT_Full))
7195 return -EINVAL;
7196
7197 advertising = (ADVERTISED_10000baseT_Full |
7198 ADVERTISED_FIBRE);
7199 break;
7200
7201 default:
7202 return -EINVAL;
7203 }
7204
7205 bp->req_autoneg &= ~AUTONEG_SPEED;
7206 bp->req_line_speed = cmd->speed;
7207 bp->req_duplex = cmd->duplex;
7208 bp->advertising = advertising;
7209 }
7210
7211 DP(NETIF_MSG_LINK, "req_autoneg 0x%x req_line_speed %d\n"
7212 DP_LEVEL " req_duplex %d advertising 0x%x\n",
7213 bp->req_autoneg, bp->req_line_speed, bp->req_duplex,
7214 bp->advertising);
7215
7216 bnx2x_stop_stats(bp);
7217 bnx2x_link_initialize(bp);
7218
7219 return 0;
7220 }
7221
7222 static void bnx2x_get_drvinfo(struct net_device *dev,
7223 struct ethtool_drvinfo *info)
7224 {
7225 struct bnx2x *bp = netdev_priv(dev);
7226
7227 strcpy(info->driver, DRV_MODULE_NAME);
7228 strcpy(info->version, DRV_MODULE_VERSION);
7229 snprintf(info->fw_version, 32, "%d.%d.%d:%d (BC VER %x)",
7230 BCM_5710_FW_MAJOR_VERSION, BCM_5710_FW_MINOR_VERSION,
7231 BCM_5710_FW_REVISION_VERSION, BCM_5710_FW_COMPILE_FLAGS,
7232 bp->bc_ver);
7233 strcpy(info->bus_info, pci_name(bp->pdev));
7234 info->n_stats = BNX2X_NUM_STATS;
7235 info->testinfo_len = BNX2X_NUM_TESTS;
7236 info->eedump_len = bp->flash_size;
7237 info->regdump_len = 0;
7238 }
7239
7240 static void bnx2x_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
7241 {
7242 struct bnx2x *bp = netdev_priv(dev);
7243
7244 if (bp->flags & NO_WOL_FLAG) {
7245 wol->supported = 0;
7246 wol->wolopts = 0;
7247 } else {
7248 wol->supported = WAKE_MAGIC;
7249 if (bp->wol)
7250 wol->wolopts = WAKE_MAGIC;
7251 else
7252 wol->wolopts = 0;
7253 }
7254 memset(&wol->sopass, 0, sizeof(wol->sopass));
7255 }
7256
7257 static int bnx2x_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
7258 {
7259 struct bnx2x *bp = netdev_priv(dev);
7260
7261 if (wol->wolopts & ~WAKE_MAGIC)
7262 return -EINVAL;
7263
7264 if (wol->wolopts & WAKE_MAGIC) {
7265 if (bp->flags & NO_WOL_FLAG)
7266 return -EINVAL;
7267
7268 bp->wol = 1;
7269 } else {
7270 bp->wol = 0;
7271 }
7272 return 0;
7273 }
7274
7275 static u32 bnx2x_get_msglevel(struct net_device *dev)
7276 {
7277 struct bnx2x *bp = netdev_priv(dev);
7278
7279 return bp->msglevel;
7280 }
7281
7282 static void bnx2x_set_msglevel(struct net_device *dev, u32 level)
7283 {
7284 struct bnx2x *bp = netdev_priv(dev);
7285
7286 if (capable(CAP_NET_ADMIN))
7287 bp->msglevel = level;
7288 }
7289
7290 static int bnx2x_nway_reset(struct net_device *dev)
7291 {
7292 struct bnx2x *bp = netdev_priv(dev);
7293
7294 if (bp->state != BNX2X_STATE_OPEN) {
7295 DP(NETIF_MSG_PROBE, "state is %x, returning\n", bp->state);
7296 return -EAGAIN;
7297 }
7298
7299 bnx2x_stop_stats(bp);
7300 bnx2x_link_initialize(bp);
7301
7302 return 0;
7303 }
7304
7305 static int bnx2x_get_eeprom_len(struct net_device *dev)
7306 {
7307 struct bnx2x *bp = netdev_priv(dev);
7308
7309 return bp->flash_size;
7310 }
7311
7312 static int bnx2x_acquire_nvram_lock(struct bnx2x *bp)
7313 {
7314 int port = bp->port;
7315 int count, i;
7316 u32 val = 0;
7317
7318 /* adjust timeout for emulation/FPGA */
7319 count = NVRAM_TIMEOUT_COUNT;
7320 if (CHIP_REV_IS_SLOW(bp))
7321 count *= 100;
7322
7323 /* request access to nvram interface */
7324 REG_WR(bp, MCP_REG_MCPR_NVM_SW_ARB,
7325 (MCPR_NVM_SW_ARB_ARB_REQ_SET1 << port));
7326
7327 for (i = 0; i < count*10; i++) {
7328 val = REG_RD(bp, MCP_REG_MCPR_NVM_SW_ARB);
7329 if (val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port))
7330 break;
7331
7332 udelay(5);
7333 }
7334
7335 if (!(val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port))) {
7336 DP(NETIF_MSG_NVM, "cannot get access to nvram interface\n");
7337 return -EBUSY;
7338 }
7339
7340 return 0;
7341 }
7342
7343 static int bnx2x_release_nvram_lock(struct bnx2x *bp)
7344 {
7345 int port = bp->port;
7346 int count, i;
7347 u32 val = 0;
7348
7349 /* adjust timeout for emulation/FPGA */
7350 count = NVRAM_TIMEOUT_COUNT;
7351 if (CHIP_REV_IS_SLOW(bp))
7352 count *= 100;
7353
7354 /* relinquish nvram interface */
7355 REG_WR(bp, MCP_REG_MCPR_NVM_SW_ARB,
7356 (MCPR_NVM_SW_ARB_ARB_REQ_CLR1 << port));
7357
7358 for (i = 0; i < count*10; i++) {
7359 val = REG_RD(bp, MCP_REG_MCPR_NVM_SW_ARB);
7360 if (!(val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port)))
7361 break;
7362
7363 udelay(5);
7364 }
7365
7366 if (val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port)) {
7367 DP(NETIF_MSG_NVM, "cannot free access to nvram interface\n");
7368 return -EBUSY;
7369 }
7370
7371 return 0;
7372 }
7373
7374 static void bnx2x_enable_nvram_access(struct bnx2x *bp)
7375 {
7376 u32 val;
7377
7378 val = REG_RD(bp, MCP_REG_MCPR_NVM_ACCESS_ENABLE);
7379
7380 /* enable both bits, even on read */
7381 REG_WR(bp, MCP_REG_MCPR_NVM_ACCESS_ENABLE,
7382 (val | MCPR_NVM_ACCESS_ENABLE_EN |
7383 MCPR_NVM_ACCESS_ENABLE_WR_EN));
7384 }
7385
7386 static void bnx2x_disable_nvram_access(struct bnx2x *bp)
7387 {
7388 u32 val;
7389
7390 val = REG_RD(bp, MCP_REG_MCPR_NVM_ACCESS_ENABLE);
7391
7392 /* disable both bits, even after read */
7393 REG_WR(bp, MCP_REG_MCPR_NVM_ACCESS_ENABLE,
7394 (val & ~(MCPR_NVM_ACCESS_ENABLE_EN |
7395 MCPR_NVM_ACCESS_ENABLE_WR_EN)));
7396 }
7397
7398 static int bnx2x_nvram_read_dword(struct bnx2x *bp, u32 offset, u32 *ret_val,
7399 u32 cmd_flags)
7400 {
7401 int rc;
7402 int count, i;
7403 u32 val;
7404
7405 /* build the command word */
7406 cmd_flags |= MCPR_NVM_COMMAND_DOIT;
7407
7408 /* need to clear DONE bit separately */
7409 REG_WR(bp, MCP_REG_MCPR_NVM_COMMAND, MCPR_NVM_COMMAND_DONE);
7410
7411 /* address of the NVRAM to read from */
7412 REG_WR(bp, MCP_REG_MCPR_NVM_ADDR,
7413 (offset & MCPR_NVM_ADDR_NVM_ADDR_VALUE));
7414
7415 /* issue a read command */
7416 REG_WR(bp, MCP_REG_MCPR_NVM_COMMAND, cmd_flags);
7417
7418 /* adjust timeout for emulation/FPGA */
7419 count = NVRAM_TIMEOUT_COUNT;
7420 if (CHIP_REV_IS_SLOW(bp))
7421 count *= 100;
7422
7423 /* wait for completion */
7424 *ret_val = 0;
7425 rc = -EBUSY;
7426 for (i = 0; i < count; i++) {
7427 udelay(5);
7428 val = REG_RD(bp, MCP_REG_MCPR_NVM_COMMAND);
7429
7430 if (val & MCPR_NVM_COMMAND_DONE) {
7431 val = REG_RD(bp, MCP_REG_MCPR_NVM_READ);
7432 DP(NETIF_MSG_NVM, "val 0x%08x\n", val);
7433 /* we read nvram data in cpu order
7434 * but ethtool sees it as an array of bytes
7435 * converting to big-endian will do the work */
7436 val = cpu_to_be32(val);
7437 *ret_val = val;
7438 rc = 0;
7439 break;
7440 }
7441 }
7442
7443 return rc;
7444 }
7445
7446 static int bnx2x_nvram_read(struct bnx2x *bp, u32 offset, u8 *ret_buf,
7447 int buf_size)
7448 {
7449 int rc;
7450 u32 cmd_flags;
7451 u32 val;
7452
7453 if ((offset & 0x03) || (buf_size & 0x03) || (buf_size == 0)) {
7454 DP(NETIF_MSG_NVM,
7455 "Invalid paramter: offset 0x%x buf_size 0x%x\n",
7456 offset, buf_size);
7457 return -EINVAL;
7458 }
7459
7460 if (offset + buf_size > bp->flash_size) {
7461 DP(NETIF_MSG_NVM, "Invalid paramter: offset (0x%x) +"
7462 " buf_size (0x%x) > flash_size (0x%x)\n",
7463 offset, buf_size, bp->flash_size);
7464 return -EINVAL;
7465 }
7466
7467 /* request access to nvram interface */
7468 rc = bnx2x_acquire_nvram_lock(bp);
7469 if (rc)
7470 return rc;
7471
7472 /* enable access to nvram interface */
7473 bnx2x_enable_nvram_access(bp);
7474
7475 /* read the first word(s) */
7476 cmd_flags = MCPR_NVM_COMMAND_FIRST;
7477 while ((buf_size > sizeof(u32)) && (rc == 0)) {
7478 rc = bnx2x_nvram_read_dword(bp, offset, &val, cmd_flags);
7479 memcpy(ret_buf, &val, 4);
7480
7481 /* advance to the next dword */
7482 offset += sizeof(u32);
7483 ret_buf += sizeof(u32);
7484 buf_size -= sizeof(u32);
7485 cmd_flags = 0;
7486 }
7487
7488 if (rc == 0) {
7489 cmd_flags |= MCPR_NVM_COMMAND_LAST;
7490 rc = bnx2x_nvram_read_dword(bp, offset, &val, cmd_flags);
7491 memcpy(ret_buf, &val, 4);
7492 }
7493
7494 /* disable access to nvram interface */
7495 bnx2x_disable_nvram_access(bp);
7496 bnx2x_release_nvram_lock(bp);
7497
7498 return rc;
7499 }
7500
7501 static int bnx2x_get_eeprom(struct net_device *dev,
7502 struct ethtool_eeprom *eeprom, u8 *eebuf)
7503 {
7504 struct bnx2x *bp = netdev_priv(dev);
7505 int rc;
7506
7507 DP(NETIF_MSG_NVM, "ethtool_eeprom: cmd %d\n"
7508 DP_LEVEL " magic 0x%x offset 0x%x (%d) len 0x%x (%d)\n",
7509 eeprom->cmd, eeprom->magic, eeprom->offset, eeprom->offset,
7510 eeprom->len, eeprom->len);
7511
7512 /* parameters already validated in ethtool_get_eeprom */
7513
7514 rc = bnx2x_nvram_read(bp, eeprom->offset, eebuf, eeprom->len);
7515
7516 return rc;
7517 }
7518
7519 static int bnx2x_nvram_write_dword(struct bnx2x *bp, u32 offset, u32 val,
7520 u32 cmd_flags)
7521 {
7522 int rc;
7523 int count, i;
7524
7525 /* build the command word */
7526 cmd_flags |= MCPR_NVM_COMMAND_DOIT | MCPR_NVM_COMMAND_WR;
7527
7528 /* need to clear DONE bit separately */
7529 REG_WR(bp, MCP_REG_MCPR_NVM_COMMAND, MCPR_NVM_COMMAND_DONE);
7530
7531 /* write the data */
7532 REG_WR(bp, MCP_REG_MCPR_NVM_WRITE, val);
7533
7534 /* address of the NVRAM to write to */
7535 REG_WR(bp, MCP_REG_MCPR_NVM_ADDR,
7536 (offset & MCPR_NVM_ADDR_NVM_ADDR_VALUE));
7537
7538 /* issue the write command */
7539 REG_WR(bp, MCP_REG_MCPR_NVM_COMMAND, cmd_flags);
7540
7541 /* adjust timeout for emulation/FPGA */
7542 count = NVRAM_TIMEOUT_COUNT;
7543 if (CHIP_REV_IS_SLOW(bp))
7544 count *= 100;
7545
7546 /* wait for completion */
7547 rc = -EBUSY;
7548 for (i = 0; i < count; i++) {
7549 udelay(5);
7550 val = REG_RD(bp, MCP_REG_MCPR_NVM_COMMAND);
7551 if (val & MCPR_NVM_COMMAND_DONE) {
7552 rc = 0;
7553 break;
7554 }
7555 }
7556
7557 return rc;
7558 }
7559
7560 #define BYTE_OFFSET(offset) (8 * (offset & 0x03))
7561
7562 static int bnx2x_nvram_write1(struct bnx2x *bp, u32 offset, u8 *data_buf,
7563 int buf_size)
7564 {
7565 int rc;
7566 u32 cmd_flags;
7567 u32 align_offset;
7568 u32 val;
7569
7570 if (offset + buf_size > bp->flash_size) {
7571 DP(NETIF_MSG_NVM, "Invalid paramter: offset (0x%x) +"
7572 " buf_size (0x%x) > flash_size (0x%x)\n",
7573 offset, buf_size, bp->flash_size);
7574 return -EINVAL;
7575 }
7576
7577 /* request access to nvram interface */
7578 rc = bnx2x_acquire_nvram_lock(bp);
7579 if (rc)
7580 return rc;
7581
7582 /* enable access to nvram interface */
7583 bnx2x_enable_nvram_access(bp);
7584
7585 cmd_flags = (MCPR_NVM_COMMAND_FIRST | MCPR_NVM_COMMAND_LAST);
7586 align_offset = (offset & ~0x03);
7587 rc = bnx2x_nvram_read_dword(bp, align_offset, &val, cmd_flags);
7588
7589 if (rc == 0) {
7590 val &= ~(0xff << BYTE_OFFSET(offset));
7591 val |= (*data_buf << BYTE_OFFSET(offset));
7592
7593 /* nvram data is returned as an array of bytes
7594 * convert it back to cpu order */
7595 val = be32_to_cpu(val);
7596
7597 DP(NETIF_MSG_NVM, "val 0x%08x\n", val);
7598
7599 rc = bnx2x_nvram_write_dword(bp, align_offset, val,
7600 cmd_flags);
7601 }
7602
7603 /* disable access to nvram interface */
7604 bnx2x_disable_nvram_access(bp);
7605 bnx2x_release_nvram_lock(bp);
7606
7607 return rc;
7608 }
7609
7610 static int bnx2x_nvram_write(struct bnx2x *bp, u32 offset, u8 *data_buf,
7611 int buf_size)
7612 {
7613 int rc;
7614 u32 cmd_flags;
7615 u32 val;
7616 u32 written_so_far;
7617
7618 if (buf_size == 1) { /* ethtool */
7619 return bnx2x_nvram_write1(bp, offset, data_buf, buf_size);
7620 }
7621
7622 if ((offset & 0x03) || (buf_size & 0x03) || (buf_size == 0)) {
7623 DP(NETIF_MSG_NVM,
7624 "Invalid paramter: offset 0x%x buf_size 0x%x\n",
7625 offset, buf_size);
7626 return -EINVAL;
7627 }
7628
7629 if (offset + buf_size > bp->flash_size) {
7630 DP(NETIF_MSG_NVM, "Invalid paramter: offset (0x%x) +"
7631 " buf_size (0x%x) > flash_size (0x%x)\n",
7632 offset, buf_size, bp->flash_size);
7633 return -EINVAL;
7634 }
7635
7636 /* request access to nvram interface */
7637 rc = bnx2x_acquire_nvram_lock(bp);
7638 if (rc)
7639 return rc;
7640
7641 /* enable access to nvram interface */
7642 bnx2x_enable_nvram_access(bp);
7643
7644 written_so_far = 0;
7645 cmd_flags = MCPR_NVM_COMMAND_FIRST;
7646 while ((written_so_far < buf_size) && (rc == 0)) {
7647 if (written_so_far == (buf_size - sizeof(u32)))
7648 cmd_flags |= MCPR_NVM_COMMAND_LAST;
7649 else if (((offset + 4) % NVRAM_PAGE_SIZE) == 0)
7650 cmd_flags |= MCPR_NVM_COMMAND_LAST;
7651 else if ((offset % NVRAM_PAGE_SIZE) == 0)
7652 cmd_flags |= MCPR_NVM_COMMAND_FIRST;
7653
7654 memcpy(&val, data_buf, 4);
7655 DP(NETIF_MSG_NVM, "val 0x%08x\n", val);
7656
7657 rc = bnx2x_nvram_write_dword(bp, offset, val, cmd_flags);
7658
7659 /* advance to the next dword */
7660 offset += sizeof(u32);
7661 data_buf += sizeof(u32);
7662 written_so_far += sizeof(u32);
7663 cmd_flags = 0;
7664 }
7665
7666 /* disable access to nvram interface */
7667 bnx2x_disable_nvram_access(bp);
7668 bnx2x_release_nvram_lock(bp);
7669
7670 return rc;
7671 }
7672
7673 static int bnx2x_set_eeprom(struct net_device *dev,
7674 struct ethtool_eeprom *eeprom, u8 *eebuf)
7675 {
7676 struct bnx2x *bp = netdev_priv(dev);
7677 int rc;
7678
7679 DP(NETIF_MSG_NVM, "ethtool_eeprom: cmd %d\n"
7680 DP_LEVEL " magic 0x%x offset 0x%x (%d) len 0x%x (%d)\n",
7681 eeprom->cmd, eeprom->magic, eeprom->offset, eeprom->offset,
7682 eeprom->len, eeprom->len);
7683
7684 /* parameters already validated in ethtool_set_eeprom */
7685
7686 rc = bnx2x_nvram_write(bp, eeprom->offset, eebuf, eeprom->len);
7687
7688 return rc;
7689 }
7690
7691 static int bnx2x_get_coalesce(struct net_device *dev,
7692 struct ethtool_coalesce *coal)
7693 {
7694 struct bnx2x *bp = netdev_priv(dev);
7695
7696 memset(coal, 0, sizeof(struct ethtool_coalesce));
7697
7698 coal->rx_coalesce_usecs = bp->rx_ticks;
7699 coal->tx_coalesce_usecs = bp->tx_ticks;
7700 coal->stats_block_coalesce_usecs = bp->stats_ticks;
7701
7702 return 0;
7703 }
7704
7705 static int bnx2x_set_coalesce(struct net_device *dev,
7706 struct ethtool_coalesce *coal)
7707 {
7708 struct bnx2x *bp = netdev_priv(dev);
7709
7710 bp->rx_ticks = (u16) coal->rx_coalesce_usecs;
7711 if (bp->rx_ticks > 3000)
7712 bp->rx_ticks = 3000;
7713
7714 bp->tx_ticks = (u16) coal->tx_coalesce_usecs;
7715 if (bp->tx_ticks > 0x3000)
7716 bp->tx_ticks = 0x3000;
7717
7718 bp->stats_ticks = coal->stats_block_coalesce_usecs;
7719 if (bp->stats_ticks > 0xffff00)
7720 bp->stats_ticks = 0xffff00;
7721 bp->stats_ticks &= 0xffff00;
7722
7723 if (netif_running(bp->dev))
7724 bnx2x_update_coalesce(bp);
7725
7726 return 0;
7727 }
7728
7729 static void bnx2x_get_ringparam(struct net_device *dev,
7730 struct ethtool_ringparam *ering)
7731 {
7732 struct bnx2x *bp = netdev_priv(dev);
7733
7734 ering->rx_max_pending = MAX_RX_AVAIL;
7735 ering->rx_mini_max_pending = 0;
7736 ering->rx_jumbo_max_pending = 0;
7737
7738 ering->rx_pending = bp->rx_ring_size;
7739 ering->rx_mini_pending = 0;
7740 ering->rx_jumbo_pending = 0;
7741
7742 ering->tx_max_pending = MAX_TX_AVAIL;
7743 ering->tx_pending = bp->tx_ring_size;
7744 }
7745
7746 static int bnx2x_set_ringparam(struct net_device *dev,
7747 struct ethtool_ringparam *ering)
7748 {
7749 struct bnx2x *bp = netdev_priv(dev);
7750
7751 if ((ering->rx_pending > MAX_RX_AVAIL) ||
7752 (ering->tx_pending > MAX_TX_AVAIL) ||
7753 (ering->tx_pending <= MAX_SKB_FRAGS + 4))
7754 return -EINVAL;
7755
7756 bp->rx_ring_size = ering->rx_pending;
7757 bp->tx_ring_size = ering->tx_pending;
7758
7759 if (netif_running(bp->dev)) {
7760 bnx2x_nic_unload(bp, 0);
7761 bnx2x_nic_load(bp, 0);
7762 }
7763
7764 return 0;
7765 }
7766
7767 static void bnx2x_get_pauseparam(struct net_device *dev,
7768 struct ethtool_pauseparam *epause)
7769 {
7770 struct bnx2x *bp = netdev_priv(dev);
7771
7772 epause->autoneg =
7773 ((bp->req_autoneg & AUTONEG_FLOW_CTRL) == AUTONEG_FLOW_CTRL);
7774 epause->rx_pause = ((bp->flow_ctrl & FLOW_CTRL_RX) == FLOW_CTRL_RX);
7775 epause->tx_pause = ((bp->flow_ctrl & FLOW_CTRL_TX) == FLOW_CTRL_TX);
7776
7777 DP(NETIF_MSG_LINK, "ethtool_pauseparam: cmd %d\n"
7778 DP_LEVEL " autoneg %d rx_pause %d tx_pause %d\n",
7779 epause->cmd, epause->autoneg, epause->rx_pause, epause->tx_pause);
7780 }
7781
7782 static int bnx2x_set_pauseparam(struct net_device *dev,
7783 struct ethtool_pauseparam *epause)
7784 {
7785 struct bnx2x *bp = netdev_priv(dev);
7786
7787 DP(NETIF_MSG_LINK, "ethtool_pauseparam: cmd %d\n"
7788 DP_LEVEL " autoneg %d rx_pause %d tx_pause %d\n",
7789 epause->cmd, epause->autoneg, epause->rx_pause, epause->tx_pause);
7790
7791 bp->req_flow_ctrl = FLOW_CTRL_AUTO;
7792 if (epause->autoneg) {
7793 bp->req_autoneg |= AUTONEG_FLOW_CTRL;
7794 if (bp->dev->mtu <= 4500) {
7795 bp->pause_mode = PAUSE_BOTH;
7796 bp->advertising |= (ADVERTISED_Pause |
7797 ADVERTISED_Asym_Pause);
7798 } else {
7799 bp->pause_mode = PAUSE_ASYMMETRIC;
7800 bp->advertising |= ADVERTISED_Asym_Pause;
7801 }
7802
7803 } else {
7804 bp->req_autoneg &= ~AUTONEG_FLOW_CTRL;
7805
7806 if (epause->rx_pause)
7807 bp->req_flow_ctrl |= FLOW_CTRL_RX;
7808 if (epause->tx_pause)
7809 bp->req_flow_ctrl |= FLOW_CTRL_TX;
7810
7811 switch (bp->req_flow_ctrl) {
7812 case FLOW_CTRL_AUTO:
7813 bp->req_flow_ctrl = FLOW_CTRL_NONE;
7814 bp->pause_mode = PAUSE_NONE;
7815 bp->advertising &= ~(ADVERTISED_Pause |
7816 ADVERTISED_Asym_Pause);
7817 break;
7818
7819 case FLOW_CTRL_TX:
7820 bp->pause_mode = PAUSE_ASYMMETRIC;
7821 bp->advertising |= ADVERTISED_Asym_Pause;
7822 break;
7823
7824 case FLOW_CTRL_RX:
7825 case FLOW_CTRL_BOTH:
7826 bp->pause_mode = PAUSE_BOTH;
7827 bp->advertising |= (ADVERTISED_Pause |
7828 ADVERTISED_Asym_Pause);
7829 break;
7830 }
7831 }
7832
7833 DP(NETIF_MSG_LINK, "req_autoneg 0x%x req_flow_ctrl 0x%x\n"
7834 DP_LEVEL " pause_mode %d advertising 0x%x\n",
7835 bp->req_autoneg, bp->req_flow_ctrl, bp->pause_mode,
7836 bp->advertising);
7837
7838 bnx2x_stop_stats(bp);
7839 bnx2x_link_initialize(bp);
7840
7841 return 0;
7842 }
7843
7844 static u32 bnx2x_get_rx_csum(struct net_device *dev)
7845 {
7846 struct bnx2x *bp = netdev_priv(dev);
7847
7848 return bp->rx_csum;
7849 }
7850
7851 static int bnx2x_set_rx_csum(struct net_device *dev, u32 data)
7852 {
7853 struct bnx2x *bp = netdev_priv(dev);
7854
7855 bp->rx_csum = data;
7856 return 0;
7857 }
7858
7859 static int bnx2x_set_tso(struct net_device *dev, u32 data)
7860 {
7861 if (data)
7862 dev->features |= (NETIF_F_TSO | NETIF_F_TSO_ECN);
7863 else
7864 dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO_ECN);
7865 return 0;
7866 }
7867
7868 static struct {
7869 char string[ETH_GSTRING_LEN];
7870 } bnx2x_tests_str_arr[BNX2X_NUM_TESTS] = {
7871 { "MC Errors (online)" }
7872 };
7873
7874 static int bnx2x_self_test_count(struct net_device *dev)
7875 {
7876 return BNX2X_NUM_TESTS;
7877 }
7878
7879 static void bnx2x_self_test(struct net_device *dev,
7880 struct ethtool_test *etest, u64 *buf)
7881 {
7882 struct bnx2x *bp = netdev_priv(dev);
7883 int stats_state;
7884
7885 memset(buf, 0, sizeof(u64) * BNX2X_NUM_TESTS);
7886
7887 if (bp->state != BNX2X_STATE_OPEN) {
7888 DP(NETIF_MSG_PROBE, "state is %x, returning\n", bp->state);
7889 return;
7890 }
7891
7892 stats_state = bp->stats_state;
7893 bnx2x_stop_stats(bp);
7894
7895 if (bnx2x_mc_assert(bp) != 0) {
7896 buf[0] = 1;
7897 etest->flags |= ETH_TEST_FL_FAILED;
7898 }
7899
7900 #ifdef BNX2X_EXTRA_DEBUG
7901 bnx2x_panic_dump(bp);
7902 #endif
7903 bp->stats_state = stats_state;
7904 }
7905
7906 static struct {
7907 char string[ETH_GSTRING_LEN];
7908 } bnx2x_stats_str_arr[BNX2X_NUM_STATS] = {
7909 { "rx_bytes"}, /* 0 */
7910 { "rx_error_bytes"}, /* 1 */
7911 { "tx_bytes"}, /* 2 */
7912 { "tx_error_bytes"}, /* 3 */
7913 { "rx_ucast_packets"}, /* 4 */
7914 { "rx_mcast_packets"}, /* 5 */
7915 { "rx_bcast_packets"}, /* 6 */
7916 { "tx_ucast_packets"}, /* 7 */
7917 { "tx_mcast_packets"}, /* 8 */
7918 { "tx_bcast_packets"}, /* 9 */
7919 { "tx_mac_errors"}, /* 10 */
7920 { "tx_carrier_errors"}, /* 11 */
7921 { "rx_crc_errors"}, /* 12 */
7922 { "rx_align_errors"}, /* 13 */
7923 { "tx_single_collisions"}, /* 14 */
7924 { "tx_multi_collisions"}, /* 15 */
7925 { "tx_deferred"}, /* 16 */
7926 { "tx_excess_collisions"}, /* 17 */
7927 { "tx_late_collisions"}, /* 18 */
7928 { "tx_total_collisions"}, /* 19 */
7929 { "rx_fragments"}, /* 20 */
7930 { "rx_jabbers"}, /* 21 */
7931 { "rx_undersize_packets"}, /* 22 */
7932 { "rx_oversize_packets"}, /* 23 */
7933 { "rx_xon_frames"}, /* 24 */
7934 { "rx_xoff_frames"}, /* 25 */
7935 { "tx_xon_frames"}, /* 26 */
7936 { "tx_xoff_frames"}, /* 27 */
7937 { "rx_mac_ctrl_frames"}, /* 28 */
7938 { "rx_filtered_packets"}, /* 29 */
7939 { "rx_discards"}, /* 30 */
7940 };
7941
7942 #define STATS_OFFSET32(offset_name) \
7943 (offsetof(struct bnx2x_eth_stats, offset_name) / 4)
7944
7945 static unsigned long bnx2x_stats_offset_arr[BNX2X_NUM_STATS] = {
7946 STATS_OFFSET32(total_bytes_received_hi), /* 0 */
7947 STATS_OFFSET32(stat_IfHCInBadOctets_hi), /* 1 */
7948 STATS_OFFSET32(total_bytes_transmitted_hi), /* 2 */
7949 STATS_OFFSET32(stat_IfHCOutBadOctets_hi), /* 3 */
7950 STATS_OFFSET32(total_unicast_packets_received_hi), /* 4 */
7951 STATS_OFFSET32(total_multicast_packets_received_hi), /* 5 */
7952 STATS_OFFSET32(total_broadcast_packets_received_hi), /* 6 */
7953 STATS_OFFSET32(total_unicast_packets_transmitted_hi), /* 7 */
7954 STATS_OFFSET32(total_multicast_packets_transmitted_hi), /* 8 */
7955 STATS_OFFSET32(total_broadcast_packets_transmitted_hi), /* 9 */
7956 STATS_OFFSET32(stat_Dot3statsInternalMacTransmitErrors), /* 10 */
7957 STATS_OFFSET32(stat_Dot3StatsCarrierSenseErrors), /* 11 */
7958 STATS_OFFSET32(crc_receive_errors), /* 12 */
7959 STATS_OFFSET32(alignment_errors), /* 13 */
7960 STATS_OFFSET32(single_collision_transmit_frames), /* 14 */
7961 STATS_OFFSET32(multiple_collision_transmit_frames), /* 15 */
7962 STATS_OFFSET32(stat_Dot3StatsDeferredTransmissions), /* 16 */
7963 STATS_OFFSET32(excessive_collision_frames), /* 17 */
7964 STATS_OFFSET32(late_collision_frames), /* 18 */
7965 STATS_OFFSET32(number_of_bugs_found_in_stats_spec), /* 19 */
7966 STATS_OFFSET32(runt_packets_received), /* 20 */
7967 STATS_OFFSET32(jabber_packets_received), /* 21 */
7968 STATS_OFFSET32(error_runt_packets_received), /* 22 */
7969 STATS_OFFSET32(error_jabber_packets_received), /* 23 */
7970 STATS_OFFSET32(pause_xon_frames_received), /* 24 */
7971 STATS_OFFSET32(pause_xoff_frames_received), /* 25 */
7972 STATS_OFFSET32(pause_xon_frames_transmitted), /* 26 */
7973 STATS_OFFSET32(pause_xoff_frames_transmitted), /* 27 */
7974 STATS_OFFSET32(control_frames_received), /* 28 */
7975 STATS_OFFSET32(mac_filter_discard), /* 29 */
7976 STATS_OFFSET32(no_buff_discard), /* 30 */
7977 };
7978
7979 static u8 bnx2x_stats_len_arr[BNX2X_NUM_STATS] = {
7980 8, 0, 8, 0, 8, 8, 8, 8, 8, 8,
7981 4, 0, 4, 4, 4, 4, 4, 4, 4, 4,
7982 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
7983 4,
7984 };
7985
7986 static void bnx2x_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
7987 {
7988 switch (stringset) {
7989 case ETH_SS_STATS:
7990 memcpy(buf, bnx2x_stats_str_arr, sizeof(bnx2x_stats_str_arr));
7991 break;
7992
7993 case ETH_SS_TEST:
7994 memcpy(buf, bnx2x_tests_str_arr, sizeof(bnx2x_tests_str_arr));
7995 break;
7996 }
7997 }
7998
7999 static int bnx2x_get_stats_count(struct net_device *dev)
8000 {
8001 return BNX2X_NUM_STATS;
8002 }
8003
8004 static void bnx2x_get_ethtool_stats(struct net_device *dev,
8005 struct ethtool_stats *stats, u64 *buf)
8006 {
8007 struct bnx2x *bp = netdev_priv(dev);
8008 u32 *hw_stats = (u32 *)bnx2x_sp_check(bp, eth_stats);
8009 int i;
8010
8011 for (i = 0; i < BNX2X_NUM_STATS; i++) {
8012 if (bnx2x_stats_len_arr[i] == 0) {
8013 /* skip this counter */
8014 buf[i] = 0;
8015 continue;
8016 }
8017 if (!hw_stats) {
8018 buf[i] = 0;
8019 continue;
8020 }
8021 if (bnx2x_stats_len_arr[i] == 4) {
8022 /* 4-byte counter */
8023 buf[i] = (u64) *(hw_stats + bnx2x_stats_offset_arr[i]);
8024 continue;
8025 }
8026 /* 8-byte counter */
8027 buf[i] = HILO_U64(*(hw_stats + bnx2x_stats_offset_arr[i]),
8028 *(hw_stats + bnx2x_stats_offset_arr[i] + 1));
8029 }
8030 }
8031
8032 static int bnx2x_phys_id(struct net_device *dev, u32 data)
8033 {
8034 struct bnx2x *bp = netdev_priv(dev);
8035 int i;
8036
8037 if (data == 0)
8038 data = 2;
8039
8040 for (i = 0; i < (data * 2); i++) {
8041 if ((i % 2) == 0) {
8042 bnx2x_leds_set(bp, SPEED_1000);
8043 } else {
8044 bnx2x_leds_unset(bp);
8045 }
8046 msleep_interruptible(500);
8047 if (signal_pending(current))
8048 break;
8049 }
8050
8051 if (bp->link_up)
8052 bnx2x_leds_set(bp, bp->line_speed);
8053
8054 return 0;
8055 }
8056
8057 static struct ethtool_ops bnx2x_ethtool_ops = {
8058 .get_settings = bnx2x_get_settings,
8059 .set_settings = bnx2x_set_settings,
8060 .get_drvinfo = bnx2x_get_drvinfo,
8061 .get_wol = bnx2x_get_wol,
8062 .set_wol = bnx2x_set_wol,
8063 .get_msglevel = bnx2x_get_msglevel,
8064 .set_msglevel = bnx2x_set_msglevel,
8065 .nway_reset = bnx2x_nway_reset,
8066 .get_link = ethtool_op_get_link,
8067 .get_eeprom_len = bnx2x_get_eeprom_len,
8068 .get_eeprom = bnx2x_get_eeprom,
8069 .set_eeprom = bnx2x_set_eeprom,
8070 .get_coalesce = bnx2x_get_coalesce,
8071 .set_coalesce = bnx2x_set_coalesce,
8072 .get_ringparam = bnx2x_get_ringparam,
8073 .set_ringparam = bnx2x_set_ringparam,
8074 .get_pauseparam = bnx2x_get_pauseparam,
8075 .set_pauseparam = bnx2x_set_pauseparam,
8076 .get_rx_csum = bnx2x_get_rx_csum,
8077 .set_rx_csum = bnx2x_set_rx_csum,
8078 .get_tx_csum = ethtool_op_get_tx_csum,
8079 .set_tx_csum = ethtool_op_set_tx_csum,
8080 .get_sg = ethtool_op_get_sg,
8081 .set_sg = ethtool_op_set_sg,
8082 .get_tso = ethtool_op_get_tso,
8083 .set_tso = bnx2x_set_tso,
8084 .self_test_count = bnx2x_self_test_count,
8085 .self_test = bnx2x_self_test,
8086 .get_strings = bnx2x_get_strings,
8087 .phys_id = bnx2x_phys_id,
8088 .get_stats_count = bnx2x_get_stats_count,
8089 .get_ethtool_stats = bnx2x_get_ethtool_stats
8090 };
8091
8092 /* end of ethtool_ops */
8093
8094 /****************************************************************************
8095 * General service functions
8096 ****************************************************************************/
8097
8098 static int bnx2x_set_power_state(struct bnx2x *bp, pci_power_t state)
8099 {
8100 u16 pmcsr;
8101
8102 pci_read_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL, &pmcsr);
8103
8104 switch (state) {
8105 case PCI_D0:
8106 pci_write_config_word(bp->pdev,
8107 bp->pm_cap + PCI_PM_CTRL,
8108 ((pmcsr & ~PCI_PM_CTRL_STATE_MASK) |
8109 PCI_PM_CTRL_PME_STATUS));
8110
8111 if (pmcsr & PCI_PM_CTRL_STATE_MASK)
8112 /* delay required during transition out of D3hot */
8113 msleep(20);
8114 break;
8115
8116 case PCI_D3hot:
8117 pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
8118 pmcsr |= 3;
8119
8120 if (bp->wol)
8121 pmcsr |= PCI_PM_CTRL_PME_ENABLE;
8122
8123 pci_write_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL,
8124 pmcsr);
8125
8126 /* No more memory access after this point until
8127 * device is brought back to D0.
8128 */
8129 break;
8130
8131 default:
8132 return -EINVAL;
8133 }
8134 return 0;
8135 }
8136
8137 /*
8138 * net_device service functions
8139 */
8140
8141 /* Called with rtnl_lock from vlan functions and also netif_tx_lock
8142 * from set_multicast.
8143 */
8144 static void bnx2x_set_rx_mode(struct net_device *dev)
8145 {
8146 struct bnx2x *bp = netdev_priv(dev);
8147 u32 rx_mode = BNX2X_RX_MODE_NORMAL;
8148
8149 DP(NETIF_MSG_IFUP, "called dev->flags = %x\n", dev->flags);
8150
8151 if (dev->flags & IFF_PROMISC)
8152 rx_mode = BNX2X_RX_MODE_PROMISC;
8153
8154 else if ((dev->flags & IFF_ALLMULTI) ||
8155 (dev->mc_count > BNX2X_MAX_MULTICAST))
8156 rx_mode = BNX2X_RX_MODE_ALLMULTI;
8157
8158 else { /* some multicasts */
8159 int i, old, offset;
8160 struct dev_mc_list *mclist;
8161 struct mac_configuration_cmd *config =
8162 bnx2x_sp(bp, mcast_config);
8163
8164 for (i = 0, mclist = dev->mc_list;
8165 mclist && (i < dev->mc_count);
8166 i++, mclist = mclist->next) {
8167
8168 config->config_table[i].cam_entry.msb_mac_addr =
8169 swab16(*(u16 *)&mclist->dmi_addr[0]);
8170 config->config_table[i].cam_entry.middle_mac_addr =
8171 swab16(*(u16 *)&mclist->dmi_addr[2]);
8172 config->config_table[i].cam_entry.lsb_mac_addr =
8173 swab16(*(u16 *)&mclist->dmi_addr[4]);
8174 config->config_table[i].cam_entry.flags =
8175 cpu_to_le16(bp->port);
8176 config->config_table[i].target_table_entry.flags = 0;
8177 config->config_table[i].target_table_entry.
8178 client_id = 0;
8179 config->config_table[i].target_table_entry.
8180 vlan_id = 0;
8181
8182 DP(NETIF_MSG_IFUP,
8183 "setting MCAST[%d] (%04x:%04x:%04x)\n",
8184 i, config->config_table[i].cam_entry.msb_mac_addr,
8185 config->config_table[i].cam_entry.middle_mac_addr,
8186 config->config_table[i].cam_entry.lsb_mac_addr);
8187 }
8188 old = config->hdr.length_6b;
8189 if (old > i) {
8190 for (; i < old; i++) {
8191 if (CAM_IS_INVALID(config->config_table[i])) {
8192 i--; /* already invalidated */
8193 break;
8194 }
8195 /* invalidate */
8196 CAM_INVALIDATE(config->config_table[i]);
8197 }
8198 }
8199
8200 if (CHIP_REV_IS_SLOW(bp))
8201 offset = BNX2X_MAX_EMUL_MULTI*(1 + bp->port);
8202 else
8203 offset = BNX2X_MAX_MULTICAST*(1 + bp->port);
8204
8205 config->hdr.length_6b = i;
8206 config->hdr.offset = offset;
8207 config->hdr.reserved0 = 0;
8208 config->hdr.reserved1 = 0;
8209
8210 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_SET_MAC, 0,
8211 U64_HI(bnx2x_sp_mapping(bp, mcast_config)),
8212 U64_LO(bnx2x_sp_mapping(bp, mcast_config)), 0);
8213 }
8214
8215 bp->rx_mode = rx_mode;
8216 bnx2x_set_storm_rx_mode(bp);
8217 }
8218
8219 static int bnx2x_poll(struct napi_struct *napi, int budget)
8220 {
8221 struct bnx2x_fastpath *fp = container_of(napi, struct bnx2x_fastpath,
8222 napi);
8223 struct bnx2x *bp = fp->bp;
8224 int work_done = 0;
8225
8226 #ifdef BNX2X_STOP_ON_ERROR
8227 if (unlikely(bp->panic))
8228 goto out_panic;
8229 #endif
8230
8231 prefetch(fp->tx_buf_ring[TX_BD(fp->tx_pkt_cons)].skb);
8232 prefetch(fp->rx_buf_ring[RX_BD(fp->rx_bd_cons)].skb);
8233 prefetch((char *)(fp->rx_buf_ring[RX_BD(fp->rx_bd_cons)].skb) + 256);
8234
8235 bnx2x_update_fpsb_idx(fp);
8236
8237 if (le16_to_cpu(*fp->tx_cons_sb) != fp->tx_pkt_cons)
8238 bnx2x_tx_int(fp, budget);
8239
8240
8241 if (le16_to_cpu(*fp->rx_cons_sb) != fp->rx_comp_cons)
8242 work_done = bnx2x_rx_int(fp, budget);
8243
8244
8245 rmb(); /* bnx2x_has_work() reads the status block */
8246
8247 /* must not complete if we consumed full budget */
8248 if ((work_done < budget) && !bnx2x_has_work(fp)) {
8249
8250 #ifdef BNX2X_STOP_ON_ERROR
8251 out_panic:
8252 #endif
8253 netif_rx_complete(bp->dev, napi);
8254
8255 bnx2x_ack_sb(bp, fp->index, USTORM_ID,
8256 le16_to_cpu(fp->fp_u_idx), IGU_INT_NOP, 1);
8257 bnx2x_ack_sb(bp, fp->index, CSTORM_ID,
8258 le16_to_cpu(fp->fp_c_idx), IGU_INT_ENABLE, 1);
8259 }
8260
8261 return work_done;
8262 }
8263
8264 /* Called with netif_tx_lock.
8265 * bnx2x_tx_int() runs without netif_tx_lock unless it needs to call
8266 * netif_wake_queue().
8267 */
8268 static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
8269 {
8270 struct bnx2x *bp = netdev_priv(dev);
8271 struct bnx2x_fastpath *fp;
8272 struct sw_tx_bd *tx_buf;
8273 struct eth_tx_bd *tx_bd;
8274 struct eth_tx_parse_bd *pbd = NULL;
8275 u16 pkt_prod, bd_prod;
8276 int nbd, fp_index = 0;
8277 dma_addr_t mapping;
8278
8279 #ifdef BNX2X_STOP_ON_ERROR
8280 if (unlikely(bp->panic))
8281 return NETDEV_TX_BUSY;
8282 #endif
8283
8284 fp_index = smp_processor_id() % (bp->num_queues);
8285
8286 fp = &bp->fp[fp_index];
8287 if (unlikely(bnx2x_tx_avail(bp->fp) <
8288 (skb_shinfo(skb)->nr_frags + 3))) {
8289 bp->slowpath->eth_stats.driver_xoff++,
8290 netif_stop_queue(dev);
8291 BNX2X_ERR("BUG! Tx ring full when queue awake!\n");
8292 return NETDEV_TX_BUSY;
8293 }
8294
8295 /*
8296 This is a bit ugly. First we use one BD which we mark as start,
8297 then for TSO or xsum we have a parsing info BD,
8298 and only then we have the rest of the TSO bds.
8299 (don't forget to mark the last one as last,
8300 and to unmap only AFTER you write to the BD ...)
8301 I would like to thank DovH for this mess.
8302 */
8303
8304 pkt_prod = fp->tx_pkt_prod++;
8305 bd_prod = fp->tx_bd_prod;
8306 bd_prod = TX_BD(bd_prod);
8307
8308 /* get a tx_buff and first bd */
8309 tx_buf = &fp->tx_buf_ring[TX_BD(pkt_prod)];
8310 tx_bd = &fp->tx_desc_ring[bd_prod];
8311
8312 tx_bd->bd_flags.as_bitfield = ETH_TX_BD_FLAGS_START_BD;
8313 tx_bd->general_data = (UNICAST_ADDRESS <<
8314 ETH_TX_BD_ETH_ADDR_TYPE_SHIFT);
8315 tx_bd->general_data |= 1; /* header nbd */
8316
8317 /* remeber the first bd of the packet */
8318 tx_buf->first_bd = bd_prod;
8319
8320 DP(NETIF_MSG_TX_QUEUED,
8321 "sending pkt %u @%p next_idx %u bd %u @%p\n",
8322 pkt_prod, tx_buf, fp->tx_pkt_prod, bd_prod, tx_bd);
8323
8324 if (skb->ip_summed == CHECKSUM_PARTIAL) {
8325 struct iphdr *iph = ip_hdr(skb);
8326 u8 len;
8327
8328 tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_IP_CSUM;
8329
8330 /* turn on parsing and get a bd */
8331 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
8332 pbd = (void *)&fp->tx_desc_ring[bd_prod];
8333 len = ((u8 *)iph - (u8 *)skb->data) / 2;
8334
8335 /* for now NS flag is not used in Linux */
8336 pbd->global_data = (len |
8337 ((skb->protocol == ETH_P_8021Q) <<
8338 ETH_TX_PARSE_BD_LLC_SNAP_EN_SHIFT));
8339 pbd->ip_hlen = ip_hdrlen(skb) / 2;
8340 pbd->total_hlen = cpu_to_le16(len + pbd->ip_hlen);
8341 if (iph->protocol == IPPROTO_TCP) {
8342 struct tcphdr *th = tcp_hdr(skb);
8343
8344 tx_bd->bd_flags.as_bitfield |=
8345 ETH_TX_BD_FLAGS_TCP_CSUM;
8346 pbd->tcp_flags = htonl(tcp_flag_word(skb)) & 0xFFFF;
8347 pbd->total_hlen += cpu_to_le16(tcp_hdrlen(skb) / 2);
8348 pbd->tcp_pseudo_csum = swab16(th->check);
8349
8350 } else if (iph->protocol == IPPROTO_UDP) {
8351 struct udphdr *uh = udp_hdr(skb);
8352
8353 tx_bd->bd_flags.as_bitfield |=
8354 ETH_TX_BD_FLAGS_TCP_CSUM;
8355 pbd->total_hlen += cpu_to_le16(4);
8356 pbd->global_data |= ETH_TX_PARSE_BD_CS_ANY_FLG;
8357 pbd->cs_offset = 5; /* 10 >> 1 */
8358 pbd->tcp_pseudo_csum = 0;
8359 /* HW bug: we need to subtract 10 bytes before the
8360 * UDP header from the csum
8361 */
8362 uh->check = (u16) ~csum_fold(csum_sub(uh->check,
8363 csum_partial(((u8 *)(uh)-10), 10, 0)));
8364 }
8365 }
8366
8367 if ((bp->vlgrp != NULL) && vlan_tx_tag_present(skb)) {
8368 tx_bd->vlan = cpu_to_le16(vlan_tx_tag_get(skb));
8369 tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_VLAN_TAG;
8370 } else {
8371 tx_bd->vlan = cpu_to_le16(pkt_prod);
8372 }
8373
8374 mapping = pci_map_single(bp->pdev, skb->data,
8375 skb->len, PCI_DMA_TODEVICE);
8376
8377 tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
8378 tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
8379 nbd = skb_shinfo(skb)->nr_frags + ((pbd == NULL)? 1 : 2);
8380 tx_bd->nbd = cpu_to_le16(nbd);
8381 tx_bd->nbytes = cpu_to_le16(skb_headlen(skb));
8382
8383 DP(NETIF_MSG_TX_QUEUED, "first bd @%p addr (%x:%x) nbd %d"
8384 " nbytes %d flags %x vlan %u\n",
8385 tx_bd, tx_bd->addr_hi, tx_bd->addr_lo, tx_bd->nbd,
8386 tx_bd->nbytes, tx_bd->bd_flags.as_bitfield, tx_bd->vlan);
8387
8388 if (skb_shinfo(skb)->gso_size &&
8389 (skb->len > (bp->dev->mtu + ETH_HLEN))) {
8390 int hlen = 2 * le32_to_cpu(pbd->total_hlen);
8391
8392 DP(NETIF_MSG_TX_QUEUED,
8393 "TSO packet len %d hlen %d total len %d tso size %d\n",
8394 skb->len, hlen, skb_headlen(skb),
8395 skb_shinfo(skb)->gso_size);
8396
8397 tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_SW_LSO;
8398
8399 if (tx_bd->nbytes > cpu_to_le16(hlen)) {
8400 /* we split the first bd into headers and data bds
8401 * to ease the pain of our fellow micocode engineers
8402 * we use one mapping for both bds
8403 * So far this has only been observed to happen
8404 * in Other Operating Systems(TM)
8405 */
8406
8407 /* first fix first bd */
8408 nbd++;
8409 tx_bd->nbd = cpu_to_le16(nbd);
8410 tx_bd->nbytes = cpu_to_le16(hlen);
8411
8412 /* we only print this as an error
8413 * because we don't think this will ever happen.
8414 */
8415 BNX2X_ERR("TSO split header size is %d (%x:%x)"
8416 " nbd %d\n", tx_bd->nbytes, tx_bd->addr_hi,
8417 tx_bd->addr_lo, tx_bd->nbd);
8418
8419 /* now get a new data bd
8420 * (after the pbd) and fill it */
8421 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
8422 tx_bd = &fp->tx_desc_ring[bd_prod];
8423
8424 tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
8425 tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping) + hlen);
8426 tx_bd->nbytes = cpu_to_le16(skb_headlen(skb) - hlen);
8427 tx_bd->vlan = cpu_to_le16(pkt_prod);
8428 /* this marks the bd
8429 * as one that has no individual mapping
8430 * the FW ignors this flag in a bd not maked start
8431 */
8432 tx_bd->bd_flags.as_bitfield = ETH_TX_BD_FLAGS_SW_LSO;
8433 DP(NETIF_MSG_TX_QUEUED,
8434 "TSO split data size is %d (%x:%x)\n",
8435 tx_bd->nbytes, tx_bd->addr_hi, tx_bd->addr_lo);
8436 }
8437
8438 if (!pbd) {
8439 /* supposed to be unreached
8440 * (and therefore not handled properly...)
8441 */
8442 BNX2X_ERR("LSO with no PBD\n");
8443 BUG();
8444 }
8445
8446 pbd->lso_mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
8447 pbd->tcp_send_seq = swab32(tcp_hdr(skb)->seq);
8448 pbd->ip_id = swab16(ip_hdr(skb)->id);
8449 pbd->tcp_pseudo_csum =
8450 swab16(~csum_tcpudp_magic(ip_hdr(skb)->saddr,
8451 ip_hdr(skb)->daddr,
8452 0, IPPROTO_TCP, 0));
8453 pbd->global_data |= ETH_TX_PARSE_BD_PSEUDO_CS_WITHOUT_LEN;
8454 }
8455
8456 {
8457 int i;
8458
8459 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
8460 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
8461
8462 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
8463 tx_bd = &fp->tx_desc_ring[bd_prod];
8464
8465 mapping = pci_map_page(bp->pdev, frag->page,
8466 frag->page_offset,
8467 frag->size, PCI_DMA_TODEVICE);
8468
8469 tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
8470 tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
8471 tx_bd->nbytes = cpu_to_le16(frag->size);
8472 tx_bd->vlan = cpu_to_le16(pkt_prod);
8473 tx_bd->bd_flags.as_bitfield = 0;
8474 DP(NETIF_MSG_TX_QUEUED, "frag %d bd @%p"
8475 " addr (%x:%x) nbytes %d flags %x\n",
8476 i, tx_bd, tx_bd->addr_hi, tx_bd->addr_lo,
8477 tx_bd->nbytes, tx_bd->bd_flags.as_bitfield);
8478 } /* for */
8479 }
8480
8481 /* now at last mark the bd as the last bd */
8482 tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_END_BD;
8483
8484 DP(NETIF_MSG_TX_QUEUED, "last bd @%p flags %x\n",
8485 tx_bd, tx_bd->bd_flags.as_bitfield);
8486
8487 tx_buf->skb = skb;
8488
8489 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
8490
8491 /* now send a tx doorbell, counting the next bd
8492 * if the packet contains or ends with it
8493 */
8494 if (TX_BD_POFF(bd_prod) < nbd)
8495 nbd++;
8496
8497 if (pbd)
8498 DP(NETIF_MSG_TX_QUEUED,
8499 "PBD @%p ip_data %x ip_hlen %u ip_id %u lso_mss %u"
8500 " tcp_flags %x xsum %x seq %u hlen %u\n",
8501 pbd, pbd->global_data, pbd->ip_hlen, pbd->ip_id,
8502 pbd->lso_mss, pbd->tcp_flags, pbd->tcp_pseudo_csum,
8503 pbd->tcp_send_seq, pbd->total_hlen);
8504
8505 DP(NETIF_MSG_TX_QUEUED, "doorbell: nbd %u bd %d\n", nbd, bd_prod);
8506
8507 fp->hw_tx_prods->bds_prod += cpu_to_le16(nbd);
8508 mb(); /* FW restriction: must not reorder writing nbd and packets */
8509 fp->hw_tx_prods->packets_prod += cpu_to_le32(1);
8510 DOORBELL(bp, fp_index, 0);
8511
8512 mmiowb();
8513
8514 fp->tx_bd_prod = bd_prod;
8515 dev->trans_start = jiffies;
8516
8517 if (unlikely(bnx2x_tx_avail(fp) < MAX_SKB_FRAGS + 3)) {
8518 netif_stop_queue(dev);
8519 bp->slowpath->eth_stats.driver_xoff++;
8520 if (bnx2x_tx_avail(fp) >= MAX_SKB_FRAGS + 3)
8521 netif_wake_queue(dev);
8522 }
8523 fp->tx_pkt++;
8524
8525 return NETDEV_TX_OK;
8526 }
8527
8528 static struct net_device_stats *bnx2x_get_stats(struct net_device *dev)
8529 {
8530 return &dev->stats;
8531 }
8532
8533 /* Called with rtnl_lock */
8534 static int bnx2x_open(struct net_device *dev)
8535 {
8536 struct bnx2x *bp = netdev_priv(dev);
8537
8538 bnx2x_set_power_state(bp, PCI_D0);
8539
8540 return bnx2x_nic_load(bp, 1);
8541 }
8542
8543 /* Called with rtnl_lock */
8544 static int bnx2x_close(struct net_device *dev)
8545 {
8546 int rc;
8547 struct bnx2x *bp = netdev_priv(dev);
8548
8549 /* Unload the driver, release IRQs */
8550 rc = bnx2x_nic_unload(bp, 1);
8551 if (rc) {
8552 BNX2X_ERR("bnx2x_nic_unload failed: %d\n", rc);
8553 return rc;
8554 }
8555 bnx2x_set_power_state(bp, PCI_D3hot);
8556
8557 return 0;
8558 }
8559
8560 /* Called with rtnl_lock */
8561 static int bnx2x_change_mac_addr(struct net_device *dev, void *p)
8562 {
8563 struct sockaddr *addr = p;
8564 struct bnx2x *bp = netdev_priv(dev);
8565
8566 if (!is_valid_ether_addr(addr->sa_data))
8567 return -EINVAL;
8568
8569 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
8570 if (netif_running(dev))
8571 bnx2x_set_mac_addr(bp);
8572
8573 return 0;
8574 }
8575
8576 /* Called with rtnl_lock */
8577 static int bnx2x_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
8578 {
8579 struct mii_ioctl_data *data = if_mii(ifr);
8580 struct bnx2x *bp = netdev_priv(dev);
8581 int err;
8582
8583 switch (cmd) {
8584 case SIOCGMIIPHY:
8585 data->phy_id = bp->phy_addr;
8586
8587 /* fallthru */
8588 case SIOCGMIIREG: {
8589 u32 mii_regval;
8590
8591 spin_lock_bh(&bp->phy_lock);
8592 if (bp->state == BNX2X_STATE_OPEN) {
8593 err = bnx2x_mdio22_read(bp, data->reg_num & 0x1f,
8594 &mii_regval);
8595
8596 data->val_out = mii_regval;
8597 } else {
8598 err = -EAGAIN;
8599 }
8600 spin_unlock_bh(&bp->phy_lock);
8601 return err;
8602 }
8603
8604 case SIOCSMIIREG:
8605 if (!capable(CAP_NET_ADMIN))
8606 return -EPERM;
8607
8608 spin_lock_bh(&bp->phy_lock);
8609 if (bp->state == BNX2X_STATE_OPEN) {
8610 err = bnx2x_mdio22_write(bp, data->reg_num & 0x1f,
8611 data->val_in);
8612 } else {
8613 err = -EAGAIN;
8614 }
8615 spin_unlock_bh(&bp->phy_lock);
8616 return err;
8617
8618 default:
8619 /* do nothing */
8620 break;
8621 }
8622
8623 return -EOPNOTSUPP;
8624 }
8625
8626 /* Called with rtnl_lock */
8627 static int bnx2x_change_mtu(struct net_device *dev, int new_mtu)
8628 {
8629 struct bnx2x *bp = netdev_priv(dev);
8630
8631 if ((new_mtu > ETH_MAX_JUMBO_PACKET_SIZE) ||
8632 ((new_mtu + ETH_HLEN) < ETH_MIN_PACKET_SIZE))
8633 return -EINVAL;
8634
8635 /* This does not race with packet allocation
8636 * because the actuall alloc size is
8637 * only updated as part of load
8638 */
8639 dev->mtu = new_mtu;
8640
8641 if (netif_running(dev)) {
8642 bnx2x_nic_unload(bp, 0);
8643 bnx2x_nic_load(bp, 0);
8644 }
8645 return 0;
8646 }
8647
8648 static void bnx2x_tx_timeout(struct net_device *dev)
8649 {
8650 struct bnx2x *bp = netdev_priv(dev);
8651
8652 #ifdef BNX2X_STOP_ON_ERROR
8653 if (!bp->panic)
8654 bnx2x_panic();
8655 #endif
8656 /* This allows the netif to be shutdown gracefully before resetting */
8657 schedule_work(&bp->reset_task);
8658 }
8659
8660 #ifdef BCM_VLAN
8661 /* Called with rtnl_lock */
8662 static void bnx2x_vlan_rx_register(struct net_device *dev,
8663 struct vlan_group *vlgrp)
8664 {
8665 struct bnx2x *bp = netdev_priv(dev);
8666
8667 bp->vlgrp = vlgrp;
8668 if (netif_running(dev))
8669 bnx2x_set_rx_mode(dev);
8670 }
8671 #endif
8672
8673 #if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
8674 static void poll_bnx2x(struct net_device *dev)
8675 {
8676 struct bnx2x *bp = netdev_priv(dev);
8677
8678 disable_irq(bp->pdev->irq);
8679 bnx2x_interrupt(bp->pdev->irq, dev);
8680 enable_irq(bp->pdev->irq);
8681 }
8682 #endif
8683
8684 static void bnx2x_reset_task(struct work_struct *work)
8685 {
8686 struct bnx2x *bp = container_of(work, struct bnx2x, reset_task);
8687
8688 #ifdef BNX2X_STOP_ON_ERROR
8689 BNX2X_ERR("reset task called but STOP_ON_ERROR defined"
8690 " so reset not done to allow debug dump,\n"
8691 KERN_ERR " you will need to reboot when done\n");
8692 return;
8693 #endif
8694
8695 if (!netif_running(bp->dev))
8696 return;
8697
8698 bp->in_reset_task = 1;
8699
8700 bnx2x_netif_stop(bp);
8701
8702 bnx2x_nic_unload(bp, 0);
8703 bnx2x_nic_load(bp, 0);
8704
8705 bp->in_reset_task = 0;
8706 }
8707
8708 static int __devinit bnx2x_init_board(struct pci_dev *pdev,
8709 struct net_device *dev)
8710 {
8711 struct bnx2x *bp;
8712 int rc;
8713
8714 SET_NETDEV_DEV(dev, &pdev->dev);
8715 bp = netdev_priv(dev);
8716
8717 bp->flags = 0;
8718 bp->port = PCI_FUNC(pdev->devfn);
8719
8720 rc = pci_enable_device(pdev);
8721 if (rc) {
8722 printk(KERN_ERR PFX "Cannot enable PCI device, aborting\n");
8723 goto err_out;
8724 }
8725
8726 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
8727 printk(KERN_ERR PFX "Cannot find PCI device base address,"
8728 " aborting\n");
8729 rc = -ENODEV;
8730 goto err_out_disable;
8731 }
8732
8733 if (!(pci_resource_flags(pdev, 2) & IORESOURCE_MEM)) {
8734 printk(KERN_ERR PFX "Cannot find second PCI device"
8735 " base address, aborting\n");
8736 rc = -ENODEV;
8737 goto err_out_disable;
8738 }
8739
8740 rc = pci_request_regions(pdev, DRV_MODULE_NAME);
8741 if (rc) {
8742 printk(KERN_ERR PFX "Cannot obtain PCI resources,"
8743 " aborting\n");
8744 goto err_out_disable;
8745 }
8746
8747 pci_set_master(pdev);
8748
8749 bp->pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM);
8750 if (bp->pm_cap == 0) {
8751 printk(KERN_ERR PFX "Cannot find power management"
8752 " capability, aborting\n");
8753 rc = -EIO;
8754 goto err_out_release;
8755 }
8756
8757 bp->pcie_cap = pci_find_capability(pdev, PCI_CAP_ID_EXP);
8758 if (bp->pcie_cap == 0) {
8759 printk(KERN_ERR PFX "Cannot find PCI Express capability,"
8760 " aborting\n");
8761 rc = -EIO;
8762 goto err_out_release;
8763 }
8764
8765 if (pci_set_dma_mask(pdev, DMA_64BIT_MASK) == 0) {
8766 bp->flags |= USING_DAC_FLAG;
8767 if (pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK) != 0) {
8768 printk(KERN_ERR PFX "pci_set_consistent_dma_mask"
8769 " failed, aborting\n");
8770 rc = -EIO;
8771 goto err_out_release;
8772 }
8773
8774 } else if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0) {
8775 printk(KERN_ERR PFX "System does not support DMA,"
8776 " aborting\n");
8777 rc = -EIO;
8778 goto err_out_release;
8779 }
8780
8781 bp->dev = dev;
8782 bp->pdev = pdev;
8783
8784 spin_lock_init(&bp->phy_lock);
8785
8786 bp->in_reset_task = 0;
8787
8788 INIT_WORK(&bp->reset_task, bnx2x_reset_task);
8789 INIT_WORK(&bp->sp_task, bnx2x_sp_task);
8790
8791 dev->base_addr = pci_resource_start(pdev, 0);
8792
8793 dev->irq = pdev->irq;
8794
8795 bp->regview = ioremap_nocache(dev->base_addr,
8796 pci_resource_len(pdev, 0));
8797 if (!bp->regview) {
8798 printk(KERN_ERR PFX "Cannot map register space, aborting\n");
8799 rc = -ENOMEM;
8800 goto err_out_release;
8801 }
8802
8803 bp->doorbells = ioremap_nocache(pci_resource_start(pdev , 2),
8804 pci_resource_len(pdev, 2));
8805 if (!bp->doorbells) {
8806 printk(KERN_ERR PFX "Cannot map doorbell space, aborting\n");
8807 rc = -ENOMEM;
8808 goto err_out_unmap;
8809 }
8810
8811 bnx2x_set_power_state(bp, PCI_D0);
8812
8813 bnx2x_get_hwinfo(bp);
8814
8815 if (CHIP_REV(bp) == CHIP_REV_FPGA) {
8816 printk(KERN_ERR PFX "FPGA detacted. MCP disabled,"
8817 " will only init first device\n");
8818 onefunc = 1;
8819 nomcp = 1;
8820 }
8821
8822 if (nomcp) {
8823 printk(KERN_ERR PFX "MCP disabled, will only"
8824 " init first device\n");
8825 onefunc = 1;
8826 }
8827
8828 if (onefunc && bp->port) {
8829 printk(KERN_ERR PFX "Second device disabled, exiting\n");
8830 rc = -ENODEV;
8831 goto err_out_unmap;
8832 }
8833
8834 bp->tx_ring_size = MAX_TX_AVAIL;
8835 bp->rx_ring_size = MAX_RX_AVAIL;
8836
8837 bp->rx_csum = 1;
8838
8839 bp->rx_offset = 0;
8840
8841 bp->tx_quick_cons_trip_int = 0xff;
8842 bp->tx_quick_cons_trip = 0xff;
8843 bp->tx_ticks_int = 50;
8844 bp->tx_ticks = 50;
8845
8846 bp->rx_quick_cons_trip_int = 0xff;
8847 bp->rx_quick_cons_trip = 0xff;
8848 bp->rx_ticks_int = 25;
8849 bp->rx_ticks = 25;
8850
8851 bp->stats_ticks = 1000000 & 0xffff00;
8852
8853 bp->timer_interval = HZ;
8854 bp->current_interval = (poll ? poll : HZ);
8855
8856 init_timer(&bp->timer);
8857 bp->timer.expires = jiffies + bp->current_interval;
8858 bp->timer.data = (unsigned long) bp;
8859 bp->timer.function = bnx2x_timer;
8860
8861 return 0;
8862
8863 err_out_unmap:
8864 if (bp->regview) {
8865 iounmap(bp->regview);
8866 bp->regview = NULL;
8867 }
8868
8869 if (bp->doorbells) {
8870 iounmap(bp->doorbells);
8871 bp->doorbells = NULL;
8872 }
8873
8874 err_out_release:
8875 pci_release_regions(pdev);
8876
8877 err_out_disable:
8878 pci_disable_device(pdev);
8879 pci_set_drvdata(pdev, NULL);
8880
8881 err_out:
8882 return rc;
8883 }
8884
8885 static int __devinit bnx2x_init_one(struct pci_dev *pdev,
8886 const struct pci_device_id *ent)
8887 {
8888 static int version_printed;
8889 struct net_device *dev = NULL;
8890 struct bnx2x *bp;
8891 int rc, i;
8892 int port = PCI_FUNC(pdev->devfn);
8893
8894 if (version_printed++ == 0)
8895 printk(KERN_INFO "%s", version);
8896
8897 /* dev zeroed in init_etherdev */
8898 dev = alloc_etherdev(sizeof(*bp));
8899 if (!dev)
8900 return -ENOMEM;
8901
8902 netif_carrier_off(dev);
8903
8904 bp = netdev_priv(dev);
8905 bp->msglevel = debug;
8906
8907 if (port && onefunc) {
8908 printk(KERN_ERR PFX "second function disabled. exiting\n");
8909 return 0;
8910 }
8911
8912 rc = bnx2x_init_board(pdev, dev);
8913 if (rc < 0) {
8914 free_netdev(dev);
8915 return rc;
8916 }
8917
8918 dev->hard_start_xmit = bnx2x_start_xmit;
8919 dev->watchdog_timeo = TX_TIMEOUT;
8920
8921 dev->get_stats = bnx2x_get_stats;
8922 dev->ethtool_ops = &bnx2x_ethtool_ops;
8923 dev->open = bnx2x_open;
8924 dev->stop = bnx2x_close;
8925 dev->set_multicast_list = bnx2x_set_rx_mode;
8926 dev->set_mac_address = bnx2x_change_mac_addr;
8927 dev->do_ioctl = bnx2x_ioctl;
8928 dev->change_mtu = bnx2x_change_mtu;
8929 dev->tx_timeout = bnx2x_tx_timeout;
8930 #ifdef BCM_VLAN
8931 dev->vlan_rx_register = bnx2x_vlan_rx_register;
8932 #endif
8933 #if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
8934 dev->poll_controller = poll_bnx2x;
8935 #endif
8936 dev->features |= NETIF_F_SG;
8937 if (bp->flags & USING_DAC_FLAG)
8938 dev->features |= NETIF_F_HIGHDMA;
8939 dev->features |= NETIF_F_IP_CSUM;
8940 #ifdef BCM_VLAN
8941 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
8942 #endif
8943 dev->features |= NETIF_F_TSO | NETIF_F_TSO_ECN;
8944
8945 rc = register_netdev(dev);
8946 if (rc) {
8947 printk(KERN_ERR PFX "Cannot register net device\n");
8948 if (bp->regview)
8949 iounmap(bp->regview);
8950 if (bp->doorbells)
8951 iounmap(bp->doorbells);
8952 pci_release_regions(pdev);
8953 pci_disable_device(pdev);
8954 pci_set_drvdata(pdev, NULL);
8955 free_netdev(dev);
8956 return rc;
8957 }
8958
8959 pci_set_drvdata(pdev, dev);
8960
8961 bp->name = board_info[ent->driver_data].name;
8962 printk(KERN_INFO "%s: %s (%c%d) PCI%s %s %dMHz "
8963 "found at mem %lx, IRQ %d, ",
8964 dev->name, bp->name,
8965 ((CHIP_ID(bp) & 0xf000) >> 12) + 'A',
8966 ((CHIP_ID(bp) & 0x0ff0) >> 4),
8967 ((bp->flags & PCIX_FLAG) ? "-X" : ""),
8968 ((bp->flags & PCI_32BIT_FLAG) ? "32-bit" : "64-bit"),
8969 bp->bus_speed_mhz,
8970 dev->base_addr,
8971 bp->pdev->irq);
8972
8973 printk("node addr ");
8974 for (i = 0; i < 6; i++)
8975 printk("%2.2x", dev->dev_addr[i]);
8976 printk("\n");
8977
8978 return 0;
8979 }
8980
8981 static void __devexit bnx2x_remove_one(struct pci_dev *pdev)
8982 {
8983 struct net_device *dev = pci_get_drvdata(pdev);
8984 struct bnx2x *bp = netdev_priv(dev);
8985
8986 flush_scheduled_work();
8987 /*tasklet_kill(&bp->sp_task);*/
8988 unregister_netdev(dev);
8989
8990 if (bp->regview)
8991 iounmap(bp->regview);
8992
8993 if (bp->doorbells)
8994 iounmap(bp->doorbells);
8995
8996 free_netdev(dev);
8997 pci_release_regions(pdev);
8998 pci_disable_device(pdev);
8999 pci_set_drvdata(pdev, NULL);
9000 }
9001
9002 static int bnx2x_suspend(struct pci_dev *pdev, pm_message_t state)
9003 {
9004 struct net_device *dev = pci_get_drvdata(pdev);
9005 struct bnx2x *bp = netdev_priv(dev);
9006 int rc;
9007
9008 if (!netif_running(dev))
9009 return 0;
9010
9011 rc = bnx2x_nic_unload(bp, 0);
9012 if (!rc)
9013 return rc;
9014
9015 netif_device_detach(dev);
9016 pci_save_state(pdev);
9017
9018 bnx2x_set_power_state(bp, pci_choose_state(pdev, state));
9019 return 0;
9020 }
9021
9022 static int bnx2x_resume(struct pci_dev *pdev)
9023 {
9024 struct net_device *dev = pci_get_drvdata(pdev);
9025 struct bnx2x *bp = netdev_priv(dev);
9026 int rc;
9027
9028 if (!netif_running(dev))
9029 return 0;
9030
9031 pci_restore_state(pdev);
9032
9033 bnx2x_set_power_state(bp, PCI_D0);
9034 netif_device_attach(dev);
9035
9036 rc = bnx2x_nic_load(bp, 0);
9037 if (rc)
9038 return rc;
9039
9040 return 0;
9041 }
9042
9043 static struct pci_driver bnx2x_pci_driver = {
9044 .name = DRV_MODULE_NAME,
9045 .id_table = bnx2x_pci_tbl,
9046 .probe = bnx2x_init_one,
9047 .remove = __devexit_p(bnx2x_remove_one),
9048 .suspend = bnx2x_suspend,
9049 .resume = bnx2x_resume,
9050 };
9051
9052 static int __init bnx2x_init(void)
9053 {
9054 return pci_register_driver(&bnx2x_pci_driver);
9055 }
9056
9057 static void __exit bnx2x_cleanup(void)
9058 {
9059 pci_unregister_driver(&bnx2x_pci_driver);
9060 }
9061
9062 module_init(bnx2x_init);
9063 module_exit(bnx2x_cleanup);
9064
WRT350N Kernel Patches