projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
net: Add skb_record_rx_queue() calls to multiqueue capable drivers.
[deliverable/linux.git] / drivers / net / bnx2x_main.c
1 /* bnx2x_main.c: Broadcom Everest network driver.
2 *
3 * Copyright (c) 2007-2009 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 * Maintained by: Eilon Greenstein <eilong@broadcom.com>
10 * Written by: Eliezer Tamir
11 * Based on code from Michael Chan's bnx2 driver
12 * UDP CSUM errata workaround by Arik Gendelman
13 * Slowpath rework by Vladislav Zolotarov
14 * Statistics and Link management by Yitchak Gertner
15 *
16 */
17
18 #include <linux/module.h>
19 #include <linux/moduleparam.h>
20 #include <linux/kernel.h>
21 #include <linux/device.h> /* for dev_info() */
22 #include <linux/timer.h>
23 #include <linux/errno.h>
24 #include <linux/ioport.h>
25 #include <linux/slab.h>
26 #include <linux/vmalloc.h>
27 #include <linux/interrupt.h>
28 #include <linux/pci.h>
29 #include <linux/init.h>
30 #include <linux/netdevice.h>
31 #include <linux/etherdevice.h>
32 #include <linux/skbuff.h>
33 #include <linux/dma-mapping.h>
34 #include <linux/bitops.h>
35 #include <linux/irq.h>
36 #include <linux/delay.h>
37 #include <asm/byteorder.h>
38 #include <linux/time.h>
39 #include <linux/ethtool.h>
40 #include <linux/mii.h>
41 #include <linux/if_vlan.h>
42 #include <net/ip.h>
43 #include <net/tcp.h>
44 #include <net/checksum.h>
45 #include <net/ip6_checksum.h>
46 #include <linux/workqueue.h>
47 #include <linux/crc32.h>
48 #include <linux/crc32c.h>
49 #include <linux/prefetch.h>
50 #include <linux/zlib.h>
51 #include <linux/io.h>
52
53 #include "bnx2x_reg.h"
54 #include "bnx2x_fw_defs.h"
55 #include "bnx2x_hsi.h"
56 #include "bnx2x_link.h"
57 #include "bnx2x.h"
58 #include "bnx2x_init.h"
59
60 #define DRV_MODULE_VERSION "1.45.26"
61 #define DRV_MODULE_RELDATE "2009/01/26"
62 #define BNX2X_BC_VER 0x040200
63
64 /* Time in jiffies before concluding the transmitter is hung */
65 #define TX_TIMEOUT (5*HZ)
66
67 static char version[] __devinitdata =
68 "Broadcom NetXtreme II 5771x 10Gigabit Ethernet Driver "
69 DRV_MODULE_NAME " " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
70
71 MODULE_AUTHOR("Eliezer Tamir");
72 MODULE_DESCRIPTION("Broadcom NetXtreme II BCM57710/57711/57711E Driver");
73 MODULE_LICENSE("GPL");
74 MODULE_VERSION(DRV_MODULE_VERSION);
75
76 static int disable_tpa;
77 static int use_inta;
78 static int poll;
79 static int debug;
80 static int load_count[3]; /* 0-common, 1-port0, 2-port1 */
81 static int use_multi;
82
83 module_param(disable_tpa, int, 0);
84 module_param(use_inta, int, 0);
85 module_param(poll, int, 0);
86 module_param(debug, int, 0);
87 MODULE_PARM_DESC(disable_tpa, "disable the TPA (LRO) feature");
88 MODULE_PARM_DESC(use_inta, "use INT#A instead of MSI-X");
89 MODULE_PARM_DESC(poll, "use polling (for debug)");
90 MODULE_PARM_DESC(debug, "default debug msglevel");
91
92 #ifdef BNX2X_MULTI
93 module_param(use_multi, int, 0);
94 MODULE_PARM_DESC(use_multi, "use per-CPU queues");
95 #endif
96 static struct workqueue_struct *bnx2x_wq;
97
98 enum bnx2x_board_type {
99 BCM57710 = 0,
100 BCM57711 = 1,
101 BCM57711E = 2,
102 };
103
104 /* indexed by board_type, above */
105 static struct {
106 char *name;
107 } board_info[] __devinitdata = {
108 { "Broadcom NetXtreme II BCM57710 XGb" },
109 { "Broadcom NetXtreme II BCM57711 XGb" },
110 { "Broadcom NetXtreme II BCM57711E XGb" }
111 };
112
113
114 static const struct pci_device_id bnx2x_pci_tbl[] = {
115 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57710,
116 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM57710 },
117 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57711,
118 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM57711 },
119 { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57711E,
120 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM57711E },
121 { 0 }
122 };
123
124 MODULE_DEVICE_TABLE(pci, bnx2x_pci_tbl);
125
126 /****************************************************************************
127 * General service functions
128 ****************************************************************************/
129
130 /* used only at init
131 * locking is done by mcp
132 */
133 static void bnx2x_reg_wr_ind(struct bnx2x *bp, u32 addr, u32 val)
134 {
135 pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
136 pci_write_config_dword(bp->pdev, PCICFG_GRC_DATA, val);
137 pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
138 PCICFG_VENDOR_ID_OFFSET);
139 }
140
141 static u32 bnx2x_reg_rd_ind(struct bnx2x *bp, u32 addr)
142 {
143 u32 val;
144
145 pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
146 pci_read_config_dword(bp->pdev, PCICFG_GRC_DATA, &val);
147 pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
148 PCICFG_VENDOR_ID_OFFSET);
149
150 return val;
151 }
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(BNX2X_MSG_OFF, "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 void bnx2x_write_dmae(struct bnx2x *bp, dma_addr_t dma_addr, u32 dst_addr,
178 u32 len32)
179 {
180 struct dmae_command *dmae = &bp->init_dmae;
181 u32 *wb_comp = bnx2x_sp(bp, wb_comp);
182 int cnt = 200;
183
184 if (!bp->dmae_ready) {
185 u32 *data = bnx2x_sp(bp, wb_data[0]);
186
187 DP(BNX2X_MSG_OFF, "DMAE is not ready (dst_addr %08x len32 %d)"
188 " using indirect\n", dst_addr, len32);
189 bnx2x_init_ind_wr(bp, dst_addr, data, len32);
190 return;
191 }
192
193 mutex_lock(&bp->dmae_mutex);
194
195 memset(dmae, 0, sizeof(struct dmae_command));
196
197 dmae->opcode = (DMAE_CMD_SRC_PCI | DMAE_CMD_DST_GRC |
198 DMAE_CMD_C_DST_PCI | DMAE_CMD_C_ENABLE |
199 DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
200 #ifdef __BIG_ENDIAN
201 DMAE_CMD_ENDIANITY_B_DW_SWAP |
202 #else
203 DMAE_CMD_ENDIANITY_DW_SWAP |
204 #endif
205 (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
206 (BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT));
207 dmae->src_addr_lo = U64_LO(dma_addr);
208 dmae->src_addr_hi = U64_HI(dma_addr);
209 dmae->dst_addr_lo = dst_addr >> 2;
210 dmae->dst_addr_hi = 0;
211 dmae->len = len32;
212 dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_comp));
213 dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_comp));
214 dmae->comp_val = DMAE_COMP_VAL;
215
216 DP(BNX2X_MSG_OFF, "dmae: opcode 0x%08x\n"
217 DP_LEVEL "src_addr [%x:%08x] len [%d *4] "
218 "dst_addr [%x:%08x (%08x)]\n"
219 DP_LEVEL "comp_addr [%x:%08x] comp_val 0x%08x\n",
220 dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
221 dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo, dst_addr,
222 dmae->comp_addr_hi, dmae->comp_addr_lo, dmae->comp_val);
223 DP(BNX2X_MSG_OFF, "data [0x%08x 0x%08x 0x%08x 0x%08x]\n",
224 bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
225 bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
226
227 *wb_comp = 0;
228
229 bnx2x_post_dmae(bp, dmae, INIT_DMAE_C(bp));
230
231 udelay(5);
232
233 while (*wb_comp != DMAE_COMP_VAL) {
234 DP(BNX2X_MSG_OFF, "wb_comp 0x%08x\n", *wb_comp);
235
236 if (!cnt) {
237 BNX2X_ERR("dmae timeout!\n");
238 break;
239 }
240 cnt--;
241 /* adjust delay for emulation/FPGA */
242 if (CHIP_REV_IS_SLOW(bp))
243 msleep(100);
244 else
245 udelay(5);
246 }
247
248 mutex_unlock(&bp->dmae_mutex);
249 }
250
251 void bnx2x_read_dmae(struct bnx2x *bp, u32 src_addr, u32 len32)
252 {
253 struct dmae_command *dmae = &bp->init_dmae;
254 u32 *wb_comp = bnx2x_sp(bp, wb_comp);
255 int cnt = 200;
256
257 if (!bp->dmae_ready) {
258 u32 *data = bnx2x_sp(bp, wb_data[0]);
259 int i;
260
261 DP(BNX2X_MSG_OFF, "DMAE is not ready (src_addr %08x len32 %d)"
262 " using indirect\n", src_addr, len32);
263 for (i = 0; i < len32; i++)
264 data[i] = bnx2x_reg_rd_ind(bp, src_addr + i*4);
265 return;
266 }
267
268 mutex_lock(&bp->dmae_mutex);
269
270 memset(bnx2x_sp(bp, wb_data[0]), 0, sizeof(u32) * 4);
271 memset(dmae, 0, sizeof(struct dmae_command));
272
273 dmae->opcode = (DMAE_CMD_SRC_GRC | DMAE_CMD_DST_PCI |
274 DMAE_CMD_C_DST_PCI | DMAE_CMD_C_ENABLE |
275 DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
276 #ifdef __BIG_ENDIAN
277 DMAE_CMD_ENDIANITY_B_DW_SWAP |
278 #else
279 DMAE_CMD_ENDIANITY_DW_SWAP |
280 #endif
281 (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
282 (BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT));
283 dmae->src_addr_lo = src_addr >> 2;
284 dmae->src_addr_hi = 0;
285 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_data));
286 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_data));
287 dmae->len = len32;
288 dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_comp));
289 dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_comp));
290 dmae->comp_val = DMAE_COMP_VAL;
291
292 DP(BNX2X_MSG_OFF, "dmae: opcode 0x%08x\n"
293 DP_LEVEL "src_addr [%x:%08x] len [%d *4] "
294 "dst_addr [%x:%08x (%08x)]\n"
295 DP_LEVEL "comp_addr [%x:%08x] comp_val 0x%08x\n",
296 dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
297 dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo, src_addr,
298 dmae->comp_addr_hi, dmae->comp_addr_lo, dmae->comp_val);
299
300 *wb_comp = 0;
301
302 bnx2x_post_dmae(bp, dmae, INIT_DMAE_C(bp));
303
304 udelay(5);
305
306 while (*wb_comp != DMAE_COMP_VAL) {
307
308 if (!cnt) {
309 BNX2X_ERR("dmae timeout!\n");
310 break;
311 }
312 cnt--;
313 /* adjust delay for emulation/FPGA */
314 if (CHIP_REV_IS_SLOW(bp))
315 msleep(100);
316 else
317 udelay(5);
318 }
319 DP(BNX2X_MSG_OFF, "data [0x%08x 0x%08x 0x%08x 0x%08x]\n",
320 bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
321 bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
322
323 mutex_unlock(&bp->dmae_mutex);
324 }
325
326 /* used only for slowpath so not inlined */
327 static void bnx2x_wb_wr(struct bnx2x *bp, int reg, u32 val_hi, u32 val_lo)
328 {
329 u32 wb_write[2];
330
331 wb_write[0] = val_hi;
332 wb_write[1] = val_lo;
333 REG_WR_DMAE(bp, reg, wb_write, 2);
334 }
335
336 #ifdef USE_WB_RD
337 static u64 bnx2x_wb_rd(struct bnx2x *bp, int reg)
338 {
339 u32 wb_data[2];
340
341 REG_RD_DMAE(bp, reg, wb_data, 2);
342
343 return HILO_U64(wb_data[0], wb_data[1]);
344 }
345 #endif
346
347 static int bnx2x_mc_assert(struct bnx2x *bp)
348 {
349 char last_idx;
350 int i, rc = 0;
351 u32 row0, row1, row2, row3;
352
353 /* XSTORM */
354 last_idx = REG_RD8(bp, BAR_XSTRORM_INTMEM +
355 XSTORM_ASSERT_LIST_INDEX_OFFSET);
356 if (last_idx)
357 BNX2X_ERR("XSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
358
359 /* print the asserts */
360 for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
361
362 row0 = REG_RD(bp, BAR_XSTRORM_INTMEM +
363 XSTORM_ASSERT_LIST_OFFSET(i));
364 row1 = REG_RD(bp, BAR_XSTRORM_INTMEM +
365 XSTORM_ASSERT_LIST_OFFSET(i) + 4);
366 row2 = REG_RD(bp, BAR_XSTRORM_INTMEM +
367 XSTORM_ASSERT_LIST_OFFSET(i) + 8);
368 row3 = REG_RD(bp, BAR_XSTRORM_INTMEM +
369 XSTORM_ASSERT_LIST_OFFSET(i) + 12);
370
371 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
372 BNX2X_ERR("XSTORM_ASSERT_INDEX 0x%x = 0x%08x"
373 " 0x%08x 0x%08x 0x%08x\n",
374 i, row3, row2, row1, row0);
375 rc++;
376 } else {
377 break;
378 }
379 }
380
381 /* TSTORM */
382 last_idx = REG_RD8(bp, BAR_TSTRORM_INTMEM +
383 TSTORM_ASSERT_LIST_INDEX_OFFSET);
384 if (last_idx)
385 BNX2X_ERR("TSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
386
387 /* print the asserts */
388 for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
389
390 row0 = REG_RD(bp, BAR_TSTRORM_INTMEM +
391 TSTORM_ASSERT_LIST_OFFSET(i));
392 row1 = REG_RD(bp, BAR_TSTRORM_INTMEM +
393 TSTORM_ASSERT_LIST_OFFSET(i) + 4);
394 row2 = REG_RD(bp, BAR_TSTRORM_INTMEM +
395 TSTORM_ASSERT_LIST_OFFSET(i) + 8);
396 row3 = REG_RD(bp, BAR_TSTRORM_INTMEM +
397 TSTORM_ASSERT_LIST_OFFSET(i) + 12);
398
399 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
400 BNX2X_ERR("TSTORM_ASSERT_INDEX 0x%x = 0x%08x"
401 " 0x%08x 0x%08x 0x%08x\n",
402 i, row3, row2, row1, row0);
403 rc++;
404 } else {
405 break;
406 }
407 }
408
409 /* CSTORM */
410 last_idx = REG_RD8(bp, BAR_CSTRORM_INTMEM +
411 CSTORM_ASSERT_LIST_INDEX_OFFSET);
412 if (last_idx)
413 BNX2X_ERR("CSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
414
415 /* print the asserts */
416 for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
417
418 row0 = REG_RD(bp, BAR_CSTRORM_INTMEM +
419 CSTORM_ASSERT_LIST_OFFSET(i));
420 row1 = REG_RD(bp, BAR_CSTRORM_INTMEM +
421 CSTORM_ASSERT_LIST_OFFSET(i) + 4);
422 row2 = REG_RD(bp, BAR_CSTRORM_INTMEM +
423 CSTORM_ASSERT_LIST_OFFSET(i) + 8);
424 row3 = REG_RD(bp, BAR_CSTRORM_INTMEM +
425 CSTORM_ASSERT_LIST_OFFSET(i) + 12);
426
427 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
428 BNX2X_ERR("CSTORM_ASSERT_INDEX 0x%x = 0x%08x"
429 " 0x%08x 0x%08x 0x%08x\n",
430 i, row3, row2, row1, row0);
431 rc++;
432 } else {
433 break;
434 }
435 }
436
437 /* USTORM */
438 last_idx = REG_RD8(bp, BAR_USTRORM_INTMEM +
439 USTORM_ASSERT_LIST_INDEX_OFFSET);
440 if (last_idx)
441 BNX2X_ERR("USTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
442
443 /* print the asserts */
444 for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
445
446 row0 = REG_RD(bp, BAR_USTRORM_INTMEM +
447 USTORM_ASSERT_LIST_OFFSET(i));
448 row1 = REG_RD(bp, BAR_USTRORM_INTMEM +
449 USTORM_ASSERT_LIST_OFFSET(i) + 4);
450 row2 = REG_RD(bp, BAR_USTRORM_INTMEM +
451 USTORM_ASSERT_LIST_OFFSET(i) + 8);
452 row3 = REG_RD(bp, BAR_USTRORM_INTMEM +
453 USTORM_ASSERT_LIST_OFFSET(i) + 12);
454
455 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
456 BNX2X_ERR("USTORM_ASSERT_INDEX 0x%x = 0x%08x"
457 " 0x%08x 0x%08x 0x%08x\n",
458 i, row3, row2, row1, row0);
459 rc++;
460 } else {
461 break;
462 }
463 }
464
465 return rc;
466 }
467
468 static void bnx2x_fw_dump(struct bnx2x *bp)
469 {
470 u32 mark, offset;
471 u32 data[9];
472 int word;
473
474 mark = REG_RD(bp, MCP_REG_MCPR_SCRATCH + 0xf104);
475 mark = ((mark + 0x3) & ~0x3);
476 printk(KERN_ERR PFX "begin fw dump (mark 0x%x)\n" KERN_ERR, mark);
477
478 for (offset = mark - 0x08000000; offset <= 0xF900; offset += 0x8*4) {
479 for (word = 0; word < 8; word++)
480 data[word] = htonl(REG_RD(bp, MCP_REG_MCPR_SCRATCH +
481 offset + 4*word));
482 data[8] = 0x0;
483 printk(KERN_CONT "%s", (char *)data);
484 }
485 for (offset = 0xF108; offset <= mark - 0x08000000; offset += 0x8*4) {
486 for (word = 0; word < 8; word++)
487 data[word] = htonl(REG_RD(bp, MCP_REG_MCPR_SCRATCH +
488 offset + 4*word));
489 data[8] = 0x0;
490 printk(KERN_CONT "%s", (char *)data);
491 }
492 printk("\n" KERN_ERR PFX "end of fw dump\n");
493 }
494
495 static void bnx2x_panic_dump(struct bnx2x *bp)
496 {
497 int i;
498 u16 j, start, end;
499
500 bp->stats_state = STATS_STATE_DISABLED;
501 DP(BNX2X_MSG_STATS, "stats_state - DISABLED\n");
502
503 BNX2X_ERR("begin crash dump -----------------\n");
504
505 for_each_queue(bp, i) {
506 struct bnx2x_fastpath *fp = &bp->fp[i];
507 struct eth_tx_db_data *hw_prods = fp->hw_tx_prods;
508
509 BNX2X_ERR("queue[%d]: tx_pkt_prod(%x) tx_pkt_cons(%x)"
510 " tx_bd_prod(%x) tx_bd_cons(%x) *tx_cons_sb(%x)\n",
511 i, fp->tx_pkt_prod, fp->tx_pkt_cons, fp->tx_bd_prod,
512 fp->tx_bd_cons, le16_to_cpu(*fp->tx_cons_sb));
513 BNX2X_ERR(" rx_bd_prod(%x) rx_bd_cons(%x)"
514 " *rx_bd_cons_sb(%x) rx_comp_prod(%x)"
515 " rx_comp_cons(%x) *rx_cons_sb(%x)\n",
516 fp->rx_bd_prod, fp->rx_bd_cons,
517 le16_to_cpu(*fp->rx_bd_cons_sb), fp->rx_comp_prod,
518 fp->rx_comp_cons, le16_to_cpu(*fp->rx_cons_sb));
519 BNX2X_ERR(" rx_sge_prod(%x) last_max_sge(%x)"
520 " fp_c_idx(%x) *sb_c_idx(%x) fp_u_idx(%x)"
521 " *sb_u_idx(%x) bd data(%x,%x)\n",
522 fp->rx_sge_prod, fp->last_max_sge, fp->fp_c_idx,
523 fp->status_blk->c_status_block.status_block_index,
524 fp->fp_u_idx,
525 fp->status_blk->u_status_block.status_block_index,
526 hw_prods->packets_prod, hw_prods->bds_prod);
527
528 start = TX_BD(le16_to_cpu(*fp->tx_cons_sb) - 10);
529 end = TX_BD(le16_to_cpu(*fp->tx_cons_sb) + 245);
530 for (j = start; j < end; j++) {
531 struct sw_tx_bd *sw_bd = &fp->tx_buf_ring[j];
532
533 BNX2X_ERR("packet[%x]=[%p,%x]\n", j,
534 sw_bd->skb, sw_bd->first_bd);
535 }
536
537 start = TX_BD(fp->tx_bd_cons - 10);
538 end = TX_BD(fp->tx_bd_cons + 254);
539 for (j = start; j < end; j++) {
540 u32 *tx_bd = (u32 *)&fp->tx_desc_ring[j];
541
542 BNX2X_ERR("tx_bd[%x]=[%x:%x:%x:%x]\n",
543 j, tx_bd[0], tx_bd[1], tx_bd[2], tx_bd[3]);
544 }
545
546 start = RX_BD(le16_to_cpu(*fp->rx_cons_sb) - 10);
547 end = RX_BD(le16_to_cpu(*fp->rx_cons_sb) + 503);
548 for (j = start; j < end; j++) {
549 u32 *rx_bd = (u32 *)&fp->rx_desc_ring[j];
550 struct sw_rx_bd *sw_bd = &fp->rx_buf_ring[j];
551
552 BNX2X_ERR("rx_bd[%x]=[%x:%x] sw_bd=[%p]\n",
553 j, rx_bd[1], rx_bd[0], sw_bd->skb);
554 }
555
556 start = RX_SGE(fp->rx_sge_prod);
557 end = RX_SGE(fp->last_max_sge);
558 for (j = start; j < end; j++) {
559 u32 *rx_sge = (u32 *)&fp->rx_sge_ring[j];
560 struct sw_rx_page *sw_page = &fp->rx_page_ring[j];
561
562 BNX2X_ERR("rx_sge[%x]=[%x:%x] sw_page=[%p]\n",
563 j, rx_sge[1], rx_sge[0], sw_page->page);
564 }
565
566 start = RCQ_BD(fp->rx_comp_cons - 10);
567 end = RCQ_BD(fp->rx_comp_cons + 503);
568 for (j = start; j < end; j++) {
569 u32 *cqe = (u32 *)&fp->rx_comp_ring[j];
570
571 BNX2X_ERR("cqe[%x]=[%x:%x:%x:%x]\n",
572 j, cqe[0], cqe[1], cqe[2], cqe[3]);
573 }
574 }
575
576 BNX2X_ERR("def_c_idx(%u) def_u_idx(%u) def_x_idx(%u)"
577 " def_t_idx(%u) def_att_idx(%u) attn_state(%u)"
578 " spq_prod_idx(%u)\n",
579 bp->def_c_idx, bp->def_u_idx, bp->def_x_idx, bp->def_t_idx,
580 bp->def_att_idx, bp->attn_state, bp->spq_prod_idx);
581
582 bnx2x_fw_dump(bp);
583 bnx2x_mc_assert(bp);
584 BNX2X_ERR("end crash dump -----------------\n");
585 }
586
587 static void bnx2x_int_enable(struct bnx2x *bp)
588 {
589 int port = BP_PORT(bp);
590 u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
591 u32 val = REG_RD(bp, addr);
592 int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
593
594 if (msix) {
595 val &= ~HC_CONFIG_0_REG_SINGLE_ISR_EN_0;
596 val |= (HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
597 HC_CONFIG_0_REG_ATTN_BIT_EN_0);
598 } else {
599 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
600 HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
601 HC_CONFIG_0_REG_INT_LINE_EN_0 |
602 HC_CONFIG_0_REG_ATTN_BIT_EN_0);
603
604 DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x) MSI-X %d\n",
605 val, port, addr, msix);
606
607 REG_WR(bp, addr, val);
608
609 val &= ~HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0;
610 }
611
612 DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x) MSI-X %d\n",
613 val, port, addr, msix);
614
615 REG_WR(bp, addr, val);
616
617 if (CHIP_IS_E1H(bp)) {
618 /* init leading/trailing edge */
619 if (IS_E1HMF(bp)) {
620 val = (0xfe0f | (1 << (BP_E1HVN(bp) + 4)));
621 if (bp->port.pmf)
622 /* enable nig attention */
623 val |= 0x0100;
624 } else
625 val = 0xffff;
626
627 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
628 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
629 }
630 }
631
632 static void bnx2x_int_disable(struct bnx2x *bp)
633 {
634 int port = BP_PORT(bp);
635 u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
636 u32 val = REG_RD(bp, addr);
637
638 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
639 HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
640 HC_CONFIG_0_REG_INT_LINE_EN_0 |
641 HC_CONFIG_0_REG_ATTN_BIT_EN_0);
642
643 DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)\n",
644 val, port, addr);
645
646 REG_WR(bp, addr, val);
647 if (REG_RD(bp, addr) != val)
648 BNX2X_ERR("BUG! proper val not read from IGU!\n");
649 }
650
651 static void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw)
652 {
653 int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
654 int i;
655
656 /* disable interrupt handling */
657 atomic_inc(&bp->intr_sem);
658 if (disable_hw)
659 /* prevent the HW from sending interrupts */
660 bnx2x_int_disable(bp);
661
662 /* make sure all ISRs are done */
663 if (msix) {
664 for_each_queue(bp, i)
665 synchronize_irq(bp->msix_table[i].vector);
666
667 /* one more for the Slow Path IRQ */
668 synchronize_irq(bp->msix_table[i].vector);
669 } else
670 synchronize_irq(bp->pdev->irq);
671
672 /* make sure sp_task is not running */
673 cancel_delayed_work(&bp->sp_task);
674 flush_workqueue(bnx2x_wq);
675 }
676
677 /* fast path */
678
679 /*
680 * General service functions
681 */
682
683 static inline void bnx2x_ack_sb(struct bnx2x *bp, u8 sb_id,
684 u8 storm, u16 index, u8 op, u8 update)
685 {
686 u32 hc_addr = (HC_REG_COMMAND_REG + BP_PORT(bp)*32 +
687 COMMAND_REG_INT_ACK);
688 struct igu_ack_register igu_ack;
689
690 igu_ack.status_block_index = index;
691 igu_ack.sb_id_and_flags =
692 ((sb_id << IGU_ACK_REGISTER_STATUS_BLOCK_ID_SHIFT) |
693 (storm << IGU_ACK_REGISTER_STORM_ID_SHIFT) |
694 (update << IGU_ACK_REGISTER_UPDATE_INDEX_SHIFT) |
695 (op << IGU_ACK_REGISTER_INTERRUPT_MODE_SHIFT));
696
697 DP(BNX2X_MSG_OFF, "write 0x%08x to HC addr 0x%x\n",
698 (*(u32 *)&igu_ack), hc_addr);
699 REG_WR(bp, hc_addr, (*(u32 *)&igu_ack));
700 }
701
702 static inline u16 bnx2x_update_fpsb_idx(struct bnx2x_fastpath *fp)
703 {
704 struct host_status_block *fpsb = fp->status_blk;
705 u16 rc = 0;
706
707 barrier(); /* status block is written to by the chip */
708 if (fp->fp_c_idx != fpsb->c_status_block.status_block_index) {
709 fp->fp_c_idx = fpsb->c_status_block.status_block_index;
710 rc |= 1;
711 }
712 if (fp->fp_u_idx != fpsb->u_status_block.status_block_index) {
713 fp->fp_u_idx = fpsb->u_status_block.status_block_index;
714 rc |= 2;
715 }
716 return rc;
717 }
718
719 static u16 bnx2x_ack_int(struct bnx2x *bp)
720 {
721 u32 hc_addr = (HC_REG_COMMAND_REG + BP_PORT(bp)*32 +
722 COMMAND_REG_SIMD_MASK);
723 u32 result = REG_RD(bp, hc_addr);
724
725 DP(BNX2X_MSG_OFF, "read 0x%08x from HC addr 0x%x\n",
726 result, hc_addr);
727
728 return result;
729 }
730
731
732 /*
733 * fast path service functions
734 */
735
736 static inline int bnx2x_has_tx_work(struct bnx2x_fastpath *fp)
737 {
738 u16 tx_cons_sb;
739
740 /* Tell compiler that status block fields can change */
741 barrier();
742 tx_cons_sb = le16_to_cpu(*fp->tx_cons_sb);
743 return (fp->tx_pkt_cons != tx_cons_sb);
744 }
745
746 static inline int bnx2x_has_tx_work_unload(struct bnx2x_fastpath *fp)
747 {
748 /* Tell compiler that consumer and producer can change */
749 barrier();
750 return (fp->tx_pkt_prod != fp->tx_pkt_cons);
751
752 }
753
754 /* free skb in the packet ring at pos idx
755 * return idx of last bd freed
756 */
757 static u16 bnx2x_free_tx_pkt(struct bnx2x *bp, struct bnx2x_fastpath *fp,
758 u16 idx)
759 {
760 struct sw_tx_bd *tx_buf = &fp->tx_buf_ring[idx];
761 struct eth_tx_bd *tx_bd;
762 struct sk_buff *skb = tx_buf->skb;
763 u16 bd_idx = TX_BD(tx_buf->first_bd), new_cons;
764 int nbd;
765
766 DP(BNX2X_MSG_OFF, "pkt_idx %d buff @(%p)->skb %p\n",
767 idx, tx_buf, skb);
768
769 /* unmap first bd */
770 DP(BNX2X_MSG_OFF, "free bd_idx %d\n", bd_idx);
771 tx_bd = &fp->tx_desc_ring[bd_idx];
772 pci_unmap_single(bp->pdev, BD_UNMAP_ADDR(tx_bd),
773 BD_UNMAP_LEN(tx_bd), PCI_DMA_TODEVICE);
774
775 nbd = le16_to_cpu(tx_bd->nbd) - 1;
776 new_cons = nbd + tx_buf->first_bd;
777 #ifdef BNX2X_STOP_ON_ERROR
778 if (nbd > (MAX_SKB_FRAGS + 2)) {
779 BNX2X_ERR("BAD nbd!\n");
780 bnx2x_panic();
781 }
782 #endif
783
784 /* Skip a parse bd and the TSO split header bd
785 since they have no mapping */
786 if (nbd)
787 bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
788
789 if (tx_bd->bd_flags.as_bitfield & (ETH_TX_BD_FLAGS_IP_CSUM |
790 ETH_TX_BD_FLAGS_TCP_CSUM |
791 ETH_TX_BD_FLAGS_SW_LSO)) {
792 if (--nbd)
793 bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
794 tx_bd = &fp->tx_desc_ring[bd_idx];
795 /* is this a TSO split header bd? */
796 if (tx_bd->bd_flags.as_bitfield & ETH_TX_BD_FLAGS_SW_LSO) {
797 if (--nbd)
798 bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
799 }
800 }
801
802 /* now free frags */
803 while (nbd > 0) {
804
805 DP(BNX2X_MSG_OFF, "free frag bd_idx %d\n", bd_idx);
806 tx_bd = &fp->tx_desc_ring[bd_idx];
807 pci_unmap_page(bp->pdev, BD_UNMAP_ADDR(tx_bd),
808 BD_UNMAP_LEN(tx_bd), PCI_DMA_TODEVICE);
809 if (--nbd)
810 bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
811 }
812
813 /* release skb */
814 WARN_ON(!skb);
815 dev_kfree_skb(skb);
816 tx_buf->first_bd = 0;
817 tx_buf->skb = NULL;
818
819 return new_cons;
820 }
821
822 static inline u16 bnx2x_tx_avail(struct bnx2x_fastpath *fp)
823 {
824 s16 used;
825 u16 prod;
826 u16 cons;
827
828 barrier(); /* Tell compiler that prod and cons can change */
829 prod = fp->tx_bd_prod;
830 cons = fp->tx_bd_cons;
831
832 /* NUM_TX_RINGS = number of "next-page" entries
833 It will be used as a threshold */
834 used = SUB_S16(prod, cons) + (s16)NUM_TX_RINGS;
835
836 #ifdef BNX2X_STOP_ON_ERROR
837 WARN_ON(used < 0);
838 WARN_ON(used > fp->bp->tx_ring_size);
839 WARN_ON((fp->bp->tx_ring_size - used) > MAX_TX_AVAIL);
840 #endif
841
842 return (s16)(fp->bp->tx_ring_size) - used;
843 }
844
845 static void bnx2x_tx_int(struct bnx2x_fastpath *fp, int work)
846 {
847 struct bnx2x *bp = fp->bp;
848 u16 hw_cons, sw_cons, bd_cons = fp->tx_bd_cons;
849 int done = 0;
850
851 #ifdef BNX2X_STOP_ON_ERROR
852 if (unlikely(bp->panic))
853 return;
854 #endif
855
856 hw_cons = le16_to_cpu(*fp->tx_cons_sb);
857 sw_cons = fp->tx_pkt_cons;
858
859 while (sw_cons != hw_cons) {
860 u16 pkt_cons;
861
862 pkt_cons = TX_BD(sw_cons);
863
864 /* prefetch(bp->tx_buf_ring[pkt_cons].skb); */
865
866 DP(NETIF_MSG_TX_DONE, "hw_cons %u sw_cons %u pkt_cons %u\n",
867 hw_cons, sw_cons, pkt_cons);
868
869 /* if (NEXT_TX_IDX(sw_cons) != hw_cons) {
870 rmb();
871 prefetch(fp->tx_buf_ring[NEXT_TX_IDX(sw_cons)].skb);
872 }
873 */
874 bd_cons = bnx2x_free_tx_pkt(bp, fp, pkt_cons);
875 sw_cons++;
876 done++;
877
878 if (done == work)
879 break;
880 }
881
882 fp->tx_pkt_cons = sw_cons;
883 fp->tx_bd_cons = bd_cons;
884
885 /* Need to make the tx_cons update visible to start_xmit()
886 * before checking for netif_queue_stopped(). Without the
887 * memory barrier, there is a small possibility that start_xmit()
888 * will miss it and cause the queue to be stopped forever.
889 */
890 smp_mb();
891
892 /* TBD need a thresh? */
893 if (unlikely(netif_queue_stopped(bp->dev))) {
894
895 netif_tx_lock(bp->dev);
896
897 if (netif_queue_stopped(bp->dev) &&
898 (bp->state == BNX2X_STATE_OPEN) &&
899 (bnx2x_tx_avail(fp) >= MAX_SKB_FRAGS + 3))
900 netif_wake_queue(bp->dev);
901
902 netif_tx_unlock(bp->dev);
903 }
904 }
905
906
907 static void bnx2x_sp_event(struct bnx2x_fastpath *fp,
908 union eth_rx_cqe *rr_cqe)
909 {
910 struct bnx2x *bp = fp->bp;
911 int cid = SW_CID(rr_cqe->ramrod_cqe.conn_and_cmd_data);
912 int command = CQE_CMD(rr_cqe->ramrod_cqe.conn_and_cmd_data);
913
914 DP(BNX2X_MSG_SP,
915 "fp %d cid %d got ramrod #%d state is %x type is %d\n",
916 FP_IDX(fp), cid, command, bp->state,
917 rr_cqe->ramrod_cqe.ramrod_type);
918
919 bp->spq_left++;
920
921 if (FP_IDX(fp)) {
922 switch (command | fp->state) {
923 case (RAMROD_CMD_ID_ETH_CLIENT_SETUP |
924 BNX2X_FP_STATE_OPENING):
925 DP(NETIF_MSG_IFUP, "got MULTI[%d] setup ramrod\n",
926 cid);
927 fp->state = BNX2X_FP_STATE_OPEN;
928 break;
929
930 case (RAMROD_CMD_ID_ETH_HALT | BNX2X_FP_STATE_HALTING):
931 DP(NETIF_MSG_IFDOWN, "got MULTI[%d] halt ramrod\n",
932 cid);
933 fp->state = BNX2X_FP_STATE_HALTED;
934 break;
935
936 default:
937 BNX2X_ERR("unexpected MC reply (%d) "
938 "fp->state is %x\n", command, fp->state);
939 break;
940 }
941 mb(); /* force bnx2x_wait_ramrod() to see the change */
942 return;
943 }
944
945 switch (command | bp->state) {
946 case (RAMROD_CMD_ID_ETH_PORT_SETUP | BNX2X_STATE_OPENING_WAIT4_PORT):
947 DP(NETIF_MSG_IFUP, "got setup ramrod\n");
948 bp->state = BNX2X_STATE_OPEN;
949 break;
950
951 case (RAMROD_CMD_ID_ETH_HALT | BNX2X_STATE_CLOSING_WAIT4_HALT):
952 DP(NETIF_MSG_IFDOWN, "got halt ramrod\n");
953 bp->state = BNX2X_STATE_CLOSING_WAIT4_DELETE;
954 fp->state = BNX2X_FP_STATE_HALTED;
955 break;
956
957 case (RAMROD_CMD_ID_ETH_CFC_DEL | BNX2X_STATE_CLOSING_WAIT4_HALT):
958 DP(NETIF_MSG_IFDOWN, "got delete ramrod for MULTI[%d]\n", cid);
959 bnx2x_fp(bp, cid, state) = BNX2X_FP_STATE_CLOSED;
960 break;
961
962
963 case (RAMROD_CMD_ID_ETH_SET_MAC | BNX2X_STATE_OPEN):
964 case (RAMROD_CMD_ID_ETH_SET_MAC | BNX2X_STATE_DIAG):
965 DP(NETIF_MSG_IFUP, "got set mac ramrod\n");
966 bp->set_mac_pending = 0;
967 break;
968
969 case (RAMROD_CMD_ID_ETH_SET_MAC | BNX2X_STATE_CLOSING_WAIT4_HALT):
970 DP(NETIF_MSG_IFDOWN, "got (un)set mac ramrod\n");
971 break;
972
973 default:
974 BNX2X_ERR("unexpected MC reply (%d) bp->state is %x\n",
975 command, bp->state);
976 break;
977 }
978 mb(); /* force bnx2x_wait_ramrod() to see the change */
979 }
980
981 static inline void bnx2x_free_rx_sge(struct bnx2x *bp,
982 struct bnx2x_fastpath *fp, u16 index)
983 {
984 struct sw_rx_page *sw_buf = &fp->rx_page_ring[index];
985 struct page *page = sw_buf->page;
986 struct eth_rx_sge *sge = &fp->rx_sge_ring[index];
987
988 /* Skip "next page" elements */
989 if (!page)
990 return;
991
992 pci_unmap_page(bp->pdev, pci_unmap_addr(sw_buf, mapping),
993 SGE_PAGE_SIZE*PAGES_PER_SGE, PCI_DMA_FROMDEVICE);
994 __free_pages(page, PAGES_PER_SGE_SHIFT);
995
996 sw_buf->page = NULL;
997 sge->addr_hi = 0;
998 sge->addr_lo = 0;
999 }
1000
1001 static inline void bnx2x_free_rx_sge_range(struct bnx2x *bp,
1002 struct bnx2x_fastpath *fp, int last)
1003 {
1004 int i;
1005
1006 for (i = 0; i < last; i++)
1007 bnx2x_free_rx_sge(bp, fp, i);
1008 }
1009
1010 static inline int bnx2x_alloc_rx_sge(struct bnx2x *bp,
1011 struct bnx2x_fastpath *fp, u16 index)
1012 {
1013 struct page *page = alloc_pages(GFP_ATOMIC, PAGES_PER_SGE_SHIFT);
1014 struct sw_rx_page *sw_buf = &fp->rx_page_ring[index];
1015 struct eth_rx_sge *sge = &fp->rx_sge_ring[index];
1016 dma_addr_t mapping;
1017
1018 if (unlikely(page == NULL))
1019 return -ENOMEM;
1020
1021 mapping = pci_map_page(bp->pdev, page, 0, SGE_PAGE_SIZE*PAGES_PER_SGE,
1022 PCI_DMA_FROMDEVICE);
1023 if (unlikely(dma_mapping_error(&bp->pdev->dev, mapping))) {
1024 __free_pages(page, PAGES_PER_SGE_SHIFT);
1025 return -ENOMEM;
1026 }
1027
1028 sw_buf->page = page;
1029 pci_unmap_addr_set(sw_buf, mapping, mapping);
1030
1031 sge->addr_hi = cpu_to_le32(U64_HI(mapping));
1032 sge->addr_lo = cpu_to_le32(U64_LO(mapping));
1033
1034 return 0;
1035 }
1036
1037 static inline int bnx2x_alloc_rx_skb(struct bnx2x *bp,
1038 struct bnx2x_fastpath *fp, u16 index)
1039 {
1040 struct sk_buff *skb;
1041 struct sw_rx_bd *rx_buf = &fp->rx_buf_ring[index];
1042 struct eth_rx_bd *rx_bd = &fp->rx_desc_ring[index];
1043 dma_addr_t mapping;
1044
1045 skb = netdev_alloc_skb(bp->dev, bp->rx_buf_size);
1046 if (unlikely(skb == NULL))
1047 return -ENOMEM;
1048
1049 mapping = pci_map_single(bp->pdev, skb->data, bp->rx_buf_size,
1050 PCI_DMA_FROMDEVICE);
1051 if (unlikely(dma_mapping_error(&bp->pdev->dev, mapping))) {
1052 dev_kfree_skb(skb);
1053 return -ENOMEM;
1054 }
1055
1056 rx_buf->skb = skb;
1057 pci_unmap_addr_set(rx_buf, mapping, mapping);
1058
1059 rx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
1060 rx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
1061
1062 return 0;
1063 }
1064
1065 /* note that we are not allocating a new skb,
1066 * we are just moving one from cons to prod
1067 * we are not creating a new mapping,
1068 * so there is no need to check for dma_mapping_error().
1069 */
1070 static void bnx2x_reuse_rx_skb(struct bnx2x_fastpath *fp,
1071 struct sk_buff *skb, u16 cons, u16 prod)
1072 {
1073 struct bnx2x *bp = fp->bp;
1074 struct sw_rx_bd *cons_rx_buf = &fp->rx_buf_ring[cons];
1075 struct sw_rx_bd *prod_rx_buf = &fp->rx_buf_ring[prod];
1076 struct eth_rx_bd *cons_bd = &fp->rx_desc_ring[cons];
1077 struct eth_rx_bd *prod_bd = &fp->rx_desc_ring[prod];
1078
1079 pci_dma_sync_single_for_device(bp->pdev,
1080 pci_unmap_addr(cons_rx_buf, mapping),
1081 bp->rx_offset + RX_COPY_THRESH,
1082 PCI_DMA_FROMDEVICE);
1083
1084 prod_rx_buf->skb = cons_rx_buf->skb;
1085 pci_unmap_addr_set(prod_rx_buf, mapping,
1086 pci_unmap_addr(cons_rx_buf, mapping));
1087 *prod_bd = *cons_bd;
1088 }
1089
1090 static inline void bnx2x_update_last_max_sge(struct bnx2x_fastpath *fp,
1091 u16 idx)
1092 {
1093 u16 last_max = fp->last_max_sge;
1094
1095 if (SUB_S16(idx, last_max) > 0)
1096 fp->last_max_sge = idx;
1097 }
1098
1099 static void bnx2x_clear_sge_mask_next_elems(struct bnx2x_fastpath *fp)
1100 {
1101 int i, j;
1102
1103 for (i = 1; i <= NUM_RX_SGE_PAGES; i++) {
1104 int idx = RX_SGE_CNT * i - 1;
1105
1106 for (j = 0; j < 2; j++) {
1107 SGE_MASK_CLEAR_BIT(fp, idx);
1108 idx--;
1109 }
1110 }
1111 }
1112
1113 static void bnx2x_update_sge_prod(struct bnx2x_fastpath *fp,
1114 struct eth_fast_path_rx_cqe *fp_cqe)
1115 {
1116 struct bnx2x *bp = fp->bp;
1117 u16 sge_len = SGE_PAGE_ALIGN(le16_to_cpu(fp_cqe->pkt_len) -
1118 le16_to_cpu(fp_cqe->len_on_bd)) >>
1119 SGE_PAGE_SHIFT;
1120 u16 last_max, last_elem, first_elem;
1121 u16 delta = 0;
1122 u16 i;
1123
1124 if (!sge_len)
1125 return;
1126
1127 /* First mark all used pages */
1128 for (i = 0; i < sge_len; i++)
1129 SGE_MASK_CLEAR_BIT(fp, RX_SGE(le16_to_cpu(fp_cqe->sgl[i])));
1130
1131 DP(NETIF_MSG_RX_STATUS, "fp_cqe->sgl[%d] = %d\n",
1132 sge_len - 1, le16_to_cpu(fp_cqe->sgl[sge_len - 1]));
1133
1134 /* Here we assume that the last SGE index is the biggest */
1135 prefetch((void *)(fp->sge_mask));
1136 bnx2x_update_last_max_sge(fp, le16_to_cpu(fp_cqe->sgl[sge_len - 1]));
1137
1138 last_max = RX_SGE(fp->last_max_sge);
1139 last_elem = last_max >> RX_SGE_MASK_ELEM_SHIFT;
1140 first_elem = RX_SGE(fp->rx_sge_prod) >> RX_SGE_MASK_ELEM_SHIFT;
1141
1142 /* If ring is not full */
1143 if (last_elem + 1 != first_elem)
1144 last_elem++;
1145
1146 /* Now update the prod */
1147 for (i = first_elem; i != last_elem; i = NEXT_SGE_MASK_ELEM(i)) {
1148 if (likely(fp->sge_mask[i]))
1149 break;
1150
1151 fp->sge_mask[i] = RX_SGE_MASK_ELEM_ONE_MASK;
1152 delta += RX_SGE_MASK_ELEM_SZ;
1153 }
1154
1155 if (delta > 0) {
1156 fp->rx_sge_prod += delta;
1157 /* clear page-end entries */
1158 bnx2x_clear_sge_mask_next_elems(fp);
1159 }
1160
1161 DP(NETIF_MSG_RX_STATUS,
1162 "fp->last_max_sge = %d fp->rx_sge_prod = %d\n",
1163 fp->last_max_sge, fp->rx_sge_prod);
1164 }
1165
1166 static inline void bnx2x_init_sge_ring_bit_mask(struct bnx2x_fastpath *fp)
1167 {
1168 /* Set the mask to all 1-s: it's faster to compare to 0 than to 0xf-s */
1169 memset(fp->sge_mask, 0xff,
1170 (NUM_RX_SGE >> RX_SGE_MASK_ELEM_SHIFT)*sizeof(u64));
1171
1172 /* Clear the two last indices in the page to 1:
1173 these are the indices that correspond to the "next" element,
1174 hence will never be indicated and should be removed from
1175 the calculations. */
1176 bnx2x_clear_sge_mask_next_elems(fp);
1177 }
1178
1179 static void bnx2x_tpa_start(struct bnx2x_fastpath *fp, u16 queue,
1180 struct sk_buff *skb, u16 cons, u16 prod)
1181 {
1182 struct bnx2x *bp = fp->bp;
1183 struct sw_rx_bd *cons_rx_buf = &fp->rx_buf_ring[cons];
1184 struct sw_rx_bd *prod_rx_buf = &fp->rx_buf_ring[prod];
1185 struct eth_rx_bd *prod_bd = &fp->rx_desc_ring[prod];
1186 dma_addr_t mapping;
1187
1188 /* move empty skb from pool to prod and map it */
1189 prod_rx_buf->skb = fp->tpa_pool[queue].skb;
1190 mapping = pci_map_single(bp->pdev, fp->tpa_pool[queue].skb->data,
1191 bp->rx_buf_size, PCI_DMA_FROMDEVICE);
1192 pci_unmap_addr_set(prod_rx_buf, mapping, mapping);
1193
1194 /* move partial skb from cons to pool (don't unmap yet) */
1195 fp->tpa_pool[queue] = *cons_rx_buf;
1196
1197 /* mark bin state as start - print error if current state != stop */
1198 if (fp->tpa_state[queue] != BNX2X_TPA_STOP)
1199 BNX2X_ERR("start of bin not in stop [%d]\n", queue);
1200
1201 fp->tpa_state[queue] = BNX2X_TPA_START;
1202
1203 /* point prod_bd to new skb */
1204 prod_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
1205 prod_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
1206
1207 #ifdef BNX2X_STOP_ON_ERROR
1208 fp->tpa_queue_used |= (1 << queue);
1209 #ifdef __powerpc64__
1210 DP(NETIF_MSG_RX_STATUS, "fp->tpa_queue_used = 0x%lx\n",
1211 #else
1212 DP(NETIF_MSG_RX_STATUS, "fp->tpa_queue_used = 0x%llx\n",
1213 #endif
1214 fp->tpa_queue_used);
1215 #endif
1216 }
1217
1218 static int bnx2x_fill_frag_skb(struct bnx2x *bp, struct bnx2x_fastpath *fp,
1219 struct sk_buff *skb,
1220 struct eth_fast_path_rx_cqe *fp_cqe,
1221 u16 cqe_idx)
1222 {
1223 struct sw_rx_page *rx_pg, old_rx_pg;
1224 u16 len_on_bd = le16_to_cpu(fp_cqe->len_on_bd);
1225 u32 i, frag_len, frag_size, pages;
1226 int err;
1227 int j;
1228
1229 frag_size = le16_to_cpu(fp_cqe->pkt_len) - len_on_bd;
1230 pages = SGE_PAGE_ALIGN(frag_size) >> SGE_PAGE_SHIFT;
1231
1232 /* This is needed in order to enable forwarding support */
1233 if (frag_size)
1234 skb_shinfo(skb)->gso_size = min((u32)SGE_PAGE_SIZE,
1235 max(frag_size, (u32)len_on_bd));
1236
1237 #ifdef BNX2X_STOP_ON_ERROR
1238 if (pages >
1239 min((u32)8, (u32)MAX_SKB_FRAGS) * SGE_PAGE_SIZE * PAGES_PER_SGE) {
1240 BNX2X_ERR("SGL length is too long: %d. CQE index is %d\n",
1241 pages, cqe_idx);
1242 BNX2X_ERR("fp_cqe->pkt_len = %d fp_cqe->len_on_bd = %d\n",
1243 fp_cqe->pkt_len, len_on_bd);
1244 bnx2x_panic();
1245 return -EINVAL;
1246 }
1247 #endif
1248
1249 /* Run through the SGL and compose the fragmented skb */
1250 for (i = 0, j = 0; i < pages; i += PAGES_PER_SGE, j++) {
1251 u16 sge_idx = RX_SGE(le16_to_cpu(fp_cqe->sgl[j]));
1252
1253 /* FW gives the indices of the SGE as if the ring is an array
1254 (meaning that "next" element will consume 2 indices) */
1255 frag_len = min(frag_size, (u32)(SGE_PAGE_SIZE*PAGES_PER_SGE));
1256 rx_pg = &fp->rx_page_ring[sge_idx];
1257 old_rx_pg = *rx_pg;
1258
1259 /* If we fail to allocate a substitute page, we simply stop
1260 where we are and drop the whole packet */
1261 err = bnx2x_alloc_rx_sge(bp, fp, sge_idx);
1262 if (unlikely(err)) {
1263 bp->eth_stats.rx_skb_alloc_failed++;
1264 return err;
1265 }
1266
1267 /* Unmap the page as we r going to pass it to the stack */
1268 pci_unmap_page(bp->pdev, pci_unmap_addr(&old_rx_pg, mapping),
1269 SGE_PAGE_SIZE*PAGES_PER_SGE, PCI_DMA_FROMDEVICE);
1270
1271 /* Add one frag and update the appropriate fields in the skb */
1272 skb_fill_page_desc(skb, j, old_rx_pg.page, 0, frag_len);
1273
1274 skb->data_len += frag_len;
1275 skb->truesize += frag_len;
1276 skb->len += frag_len;
1277
1278 frag_size -= frag_len;
1279 }
1280
1281 return 0;
1282 }
1283
1284 static void bnx2x_tpa_stop(struct bnx2x *bp, struct bnx2x_fastpath *fp,
1285 u16 queue, int pad, int len, union eth_rx_cqe *cqe,
1286 u16 cqe_idx)
1287 {
1288 struct sw_rx_bd *rx_buf = &fp->tpa_pool[queue];
1289 struct sk_buff *skb = rx_buf->skb;
1290 /* alloc new skb */
1291 struct sk_buff *new_skb = netdev_alloc_skb(bp->dev, bp->rx_buf_size);
1292
1293 /* Unmap skb in the pool anyway, as we are going to change
1294 pool entry status to BNX2X_TPA_STOP even if new skb allocation
1295 fails. */
1296 pci_unmap_single(bp->pdev, pci_unmap_addr(rx_buf, mapping),
1297 bp->rx_buf_size, PCI_DMA_FROMDEVICE);
1298
1299 if (likely(new_skb)) {
1300 /* fix ip xsum and give it to the stack */
1301 /* (no need to map the new skb) */
1302 #ifdef BCM_VLAN
1303 int is_vlan_cqe =
1304 (le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags) &
1305 PARSING_FLAGS_VLAN);
1306 int is_not_hwaccel_vlan_cqe =
1307 (is_vlan_cqe && (!(bp->flags & HW_VLAN_RX_FLAG)));
1308 #endif
1309
1310 prefetch(skb);
1311 prefetch(((char *)(skb)) + 128);
1312
1313 #ifdef BNX2X_STOP_ON_ERROR
1314 if (pad + len > bp->rx_buf_size) {
1315 BNX2X_ERR("skb_put is about to fail... "
1316 "pad %d len %d rx_buf_size %d\n",
1317 pad, len, bp->rx_buf_size);
1318 bnx2x_panic();
1319 return;
1320 }
1321 #endif
1322
1323 skb_reserve(skb, pad);
1324 skb_put(skb, len);
1325
1326 skb->protocol = eth_type_trans(skb, bp->dev);
1327 skb->ip_summed = CHECKSUM_UNNECESSARY;
1328 skb_record_rx_queue(skb, queue);
1329
1330 {
1331 struct iphdr *iph;
1332
1333 iph = (struct iphdr *)skb->data;
1334 #ifdef BCM_VLAN
1335 /* If there is no Rx VLAN offloading -
1336 take VLAN tag into an account */
1337 if (unlikely(is_not_hwaccel_vlan_cqe))
1338 iph = (struct iphdr *)((u8 *)iph + VLAN_HLEN);
1339 #endif
1340 iph->check = 0;
1341 iph->check = ip_fast_csum((u8 *)iph, iph->ihl);
1342 }
1343
1344 if (!bnx2x_fill_frag_skb(bp, fp, skb,
1345 &cqe->fast_path_cqe, cqe_idx)) {
1346 #ifdef BCM_VLAN
1347 if ((bp->vlgrp != NULL) && is_vlan_cqe &&
1348 (!is_not_hwaccel_vlan_cqe))
1349 vlan_hwaccel_receive_skb(skb, bp->vlgrp,
1350 le16_to_cpu(cqe->fast_path_cqe.
1351 vlan_tag));
1352 else
1353 #endif
1354 netif_receive_skb(skb);
1355 } else {
1356 DP(NETIF_MSG_RX_STATUS, "Failed to allocate new pages"
1357 " - dropping packet!\n");
1358 dev_kfree_skb(skb);
1359 }
1360
1361
1362 /* put new skb in bin */
1363 fp->tpa_pool[queue].skb = new_skb;
1364
1365 } else {
1366 /* else drop the packet and keep the buffer in the bin */
1367 DP(NETIF_MSG_RX_STATUS,
1368 "Failed to allocate new skb - dropping packet!\n");
1369 bp->eth_stats.rx_skb_alloc_failed++;
1370 }
1371
1372 fp->tpa_state[queue] = BNX2X_TPA_STOP;
1373 }
1374
1375 static inline void bnx2x_update_rx_prod(struct bnx2x *bp,
1376 struct bnx2x_fastpath *fp,
1377 u16 bd_prod, u16 rx_comp_prod,
1378 u16 rx_sge_prod)
1379 {
1380 struct tstorm_eth_rx_producers rx_prods = {0};
1381 int i;
1382
1383 /* Update producers */
1384 rx_prods.bd_prod = bd_prod;
1385 rx_prods.cqe_prod = rx_comp_prod;
1386 rx_prods.sge_prod = rx_sge_prod;
1387
1388 /*
1389 * Make sure that the BD and SGE data is updated before updating the
1390 * producers since FW might read the BD/SGE right after the producer
1391 * is updated.
1392 * This is only applicable for weak-ordered memory model archs such
1393 * as IA-64. The following barrier is also mandatory since FW will
1394 * assumes BDs must have buffers.
1395 */
1396 wmb();
1397
1398 for (i = 0; i < sizeof(struct tstorm_eth_rx_producers)/4; i++)
1399 REG_WR(bp, BAR_TSTRORM_INTMEM +
1400 TSTORM_RX_PRODS_OFFSET(BP_PORT(bp), FP_CL_ID(fp)) + i*4,
1401 ((u32 *)&rx_prods)[i]);
1402
1403 mmiowb(); /* keep prod updates ordered */
1404
1405 DP(NETIF_MSG_RX_STATUS,
1406 "Wrote: bd_prod %u cqe_prod %u sge_prod %u\n",
1407 bd_prod, rx_comp_prod, rx_sge_prod);
1408 }
1409
1410 static int bnx2x_rx_int(struct bnx2x_fastpath *fp, int budget)
1411 {
1412 struct bnx2x *bp = fp->bp;
1413 u16 bd_cons, bd_prod, bd_prod_fw, comp_ring_cons;
1414 u16 hw_comp_cons, sw_comp_cons, sw_comp_prod;
1415 int rx_pkt = 0;
1416
1417 #ifdef BNX2X_STOP_ON_ERROR
1418 if (unlikely(bp->panic))
1419 return 0;
1420 #endif
1421
1422 /* CQ "next element" is of the size of the regular element,
1423 that's why it's ok here */
1424 hw_comp_cons = le16_to_cpu(*fp->rx_cons_sb);
1425 if ((hw_comp_cons & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
1426 hw_comp_cons++;
1427
1428 bd_cons = fp->rx_bd_cons;
1429 bd_prod = fp->rx_bd_prod;
1430 bd_prod_fw = bd_prod;
1431 sw_comp_cons = fp->rx_comp_cons;
1432 sw_comp_prod = fp->rx_comp_prod;
1433
1434 /* Memory barrier necessary as speculative reads of the rx
1435 * buffer can be ahead of the index in the status block
1436 */
1437 rmb();
1438
1439 DP(NETIF_MSG_RX_STATUS,
1440 "queue[%d]: hw_comp_cons %u sw_comp_cons %u\n",
1441 FP_IDX(fp), hw_comp_cons, sw_comp_cons);
1442
1443 while (sw_comp_cons != hw_comp_cons) {
1444 struct sw_rx_bd *rx_buf = NULL;
1445 struct sk_buff *skb;
1446 union eth_rx_cqe *cqe;
1447 u8 cqe_fp_flags;
1448 u16 len, pad;
1449
1450 comp_ring_cons = RCQ_BD(sw_comp_cons);
1451 bd_prod = RX_BD(bd_prod);
1452 bd_cons = RX_BD(bd_cons);
1453
1454 cqe = &fp->rx_comp_ring[comp_ring_cons];
1455 cqe_fp_flags = cqe->fast_path_cqe.type_error_flags;
1456
1457 DP(NETIF_MSG_RX_STATUS, "CQE type %x err %x status %x"
1458 " queue %x vlan %x len %u\n", CQE_TYPE(cqe_fp_flags),
1459 cqe_fp_flags, cqe->fast_path_cqe.status_flags,
1460 le32_to_cpu(cqe->fast_path_cqe.rss_hash_result),
1461 le16_to_cpu(cqe->fast_path_cqe.vlan_tag),
1462 le16_to_cpu(cqe->fast_path_cqe.pkt_len));
1463
1464 /* is this a slowpath msg? */
1465 if (unlikely(CQE_TYPE(cqe_fp_flags))) {
1466 bnx2x_sp_event(fp, cqe);
1467 goto next_cqe;
1468
1469 /* this is an rx packet */
1470 } else {
1471 rx_buf = &fp->rx_buf_ring[bd_cons];
1472 skb = rx_buf->skb;
1473 len = le16_to_cpu(cqe->fast_path_cqe.pkt_len);
1474 pad = cqe->fast_path_cqe.placement_offset;
1475
1476 /* If CQE is marked both TPA_START and TPA_END
1477 it is a non-TPA CQE */
1478 if ((!fp->disable_tpa) &&
1479 (TPA_TYPE(cqe_fp_flags) !=
1480 (TPA_TYPE_START | TPA_TYPE_END))) {
1481 u16 queue = cqe->fast_path_cqe.queue_index;
1482
1483 if (TPA_TYPE(cqe_fp_flags) == TPA_TYPE_START) {
1484 DP(NETIF_MSG_RX_STATUS,
1485 "calling tpa_start on queue %d\n",
1486 queue);
1487
1488 bnx2x_tpa_start(fp, queue, skb,
1489 bd_cons, bd_prod);
1490 goto next_rx;
1491 }
1492
1493 if (TPA_TYPE(cqe_fp_flags) == TPA_TYPE_END) {
1494 DP(NETIF_MSG_RX_STATUS,
1495 "calling tpa_stop on queue %d\n",
1496 queue);
1497
1498 if (!BNX2X_RX_SUM_FIX(cqe))
1499 BNX2X_ERR("STOP on none TCP "
1500 "data\n");
1501
1502 /* This is a size of the linear data
1503 on this skb */
1504 len = le16_to_cpu(cqe->fast_path_cqe.
1505 len_on_bd);
1506 bnx2x_tpa_stop(bp, fp, queue, pad,
1507 len, cqe, comp_ring_cons);
1508 #ifdef BNX2X_STOP_ON_ERROR
1509 if (bp->panic)
1510 return -EINVAL;
1511 #endif
1512
1513 bnx2x_update_sge_prod(fp,
1514 &cqe->fast_path_cqe);
1515 goto next_cqe;
1516 }
1517 }
1518
1519 pci_dma_sync_single_for_device(bp->pdev,
1520 pci_unmap_addr(rx_buf, mapping),
1521 pad + RX_COPY_THRESH,
1522 PCI_DMA_FROMDEVICE);
1523 prefetch(skb);
1524 prefetch(((char *)(skb)) + 128);
1525
1526 /* is this an error packet? */
1527 if (unlikely(cqe_fp_flags & ETH_RX_ERROR_FALGS)) {
1528 DP(NETIF_MSG_RX_ERR,
1529 "ERROR flags %x rx packet %u\n",
1530 cqe_fp_flags, sw_comp_cons);
1531 bp->eth_stats.rx_err_discard_pkt++;
1532 goto reuse_rx;
1533 }
1534
1535 /* Since we don't have a jumbo ring
1536 * copy small packets if mtu > 1500
1537 */
1538 if ((bp->dev->mtu > ETH_MAX_PACKET_SIZE) &&
1539 (len <= RX_COPY_THRESH)) {
1540 struct sk_buff *new_skb;
1541
1542 new_skb = netdev_alloc_skb(bp->dev,
1543 len + pad);
1544 if (new_skb == NULL) {
1545 DP(NETIF_MSG_RX_ERR,
1546 "ERROR packet dropped "
1547 "because of alloc failure\n");
1548 bp->eth_stats.rx_skb_alloc_failed++;
1549 goto reuse_rx;
1550 }
1551
1552 /* aligned copy */
1553 skb_copy_from_linear_data_offset(skb, pad,
1554 new_skb->data + pad, len);
1555 skb_reserve(new_skb, pad);
1556 skb_put(new_skb, len);
1557
1558 bnx2x_reuse_rx_skb(fp, skb, bd_cons, bd_prod);
1559
1560 skb = new_skb;
1561
1562 } else if (bnx2x_alloc_rx_skb(bp, fp, bd_prod) == 0) {
1563 pci_unmap_single(bp->pdev,
1564 pci_unmap_addr(rx_buf, mapping),
1565 bp->rx_buf_size,
1566 PCI_DMA_FROMDEVICE);
1567 skb_reserve(skb, pad);
1568 skb_put(skb, len);
1569
1570 } else {
1571 DP(NETIF_MSG_RX_ERR,
1572 "ERROR packet dropped because "
1573 "of alloc failure\n");
1574 bp->eth_stats.rx_skb_alloc_failed++;
1575 reuse_rx:
1576 bnx2x_reuse_rx_skb(fp, skb, bd_cons, bd_prod);
1577 goto next_rx;
1578 }
1579
1580 skb->protocol = eth_type_trans(skb, bp->dev);
1581
1582 skb->ip_summed = CHECKSUM_NONE;
1583 if (bp->rx_csum) {
1584 if (likely(BNX2X_RX_CSUM_OK(cqe)))
1585 skb->ip_summed = CHECKSUM_UNNECESSARY;
1586 else
1587 bp->eth_stats.hw_csum_err++;
1588 }
1589 }
1590
1591 #ifdef BCM_VLAN
1592 if ((bp->vlgrp != NULL) && (bp->flags & HW_VLAN_RX_FLAG) &&
1593 (le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags) &
1594 PARSING_FLAGS_VLAN))
1595 vlan_hwaccel_receive_skb(skb, bp->vlgrp,
1596 le16_to_cpu(cqe->fast_path_cqe.vlan_tag));
1597 else
1598 #endif
1599 netif_receive_skb(skb);
1600
1601
1602 next_rx:
1603 rx_buf->skb = NULL;
1604
1605 bd_cons = NEXT_RX_IDX(bd_cons);
1606 bd_prod = NEXT_RX_IDX(bd_prod);
1607 bd_prod_fw = NEXT_RX_IDX(bd_prod_fw);
1608 rx_pkt++;
1609 next_cqe:
1610 sw_comp_prod = NEXT_RCQ_IDX(sw_comp_prod);
1611 sw_comp_cons = NEXT_RCQ_IDX(sw_comp_cons);
1612
1613 if (rx_pkt == budget)
1614 break;
1615 } /* while */
1616
1617 fp->rx_bd_cons = bd_cons;
1618 fp->rx_bd_prod = bd_prod_fw;
1619 fp->rx_comp_cons = sw_comp_cons;
1620 fp->rx_comp_prod = sw_comp_prod;
1621
1622 /* Update producers */
1623 bnx2x_update_rx_prod(bp, fp, bd_prod_fw, sw_comp_prod,
1624 fp->rx_sge_prod);
1625
1626 fp->rx_pkt += rx_pkt;
1627 fp->rx_calls++;
1628
1629 return rx_pkt;
1630 }
1631
1632 static irqreturn_t bnx2x_msix_fp_int(int irq, void *fp_cookie)
1633 {
1634 struct bnx2x_fastpath *fp = fp_cookie;
1635 struct bnx2x *bp = fp->bp;
1636 int index = FP_IDX(fp);
1637
1638 /* Return here if interrupt is disabled */
1639 if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
1640 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
1641 return IRQ_HANDLED;
1642 }
1643
1644 DP(BNX2X_MSG_FP, "got an MSI-X interrupt on IDX:SB [%d:%d]\n",
1645 index, FP_SB_ID(fp));
1646 bnx2x_ack_sb(bp, FP_SB_ID(fp), USTORM_ID, 0, IGU_INT_DISABLE, 0);
1647
1648 #ifdef BNX2X_STOP_ON_ERROR
1649 if (unlikely(bp->panic))
1650 return IRQ_HANDLED;
1651 #endif
1652
1653 prefetch(fp->rx_cons_sb);
1654 prefetch(fp->tx_cons_sb);
1655 prefetch(&fp->status_blk->c_status_block.status_block_index);
1656 prefetch(&fp->status_blk->u_status_block.status_block_index);
1657
1658 napi_schedule(&bnx2x_fp(bp, index, napi));
1659
1660 return IRQ_HANDLED;
1661 }
1662
1663 static irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
1664 {
1665 struct net_device *dev = dev_instance;
1666 struct bnx2x *bp = netdev_priv(dev);
1667 u16 status = bnx2x_ack_int(bp);
1668 u16 mask;
1669
1670 /* Return here if interrupt is shared and it's not for us */
1671 if (unlikely(status == 0)) {
1672 DP(NETIF_MSG_INTR, "not our interrupt!\n");
1673 return IRQ_NONE;
1674 }
1675 DP(NETIF_MSG_INTR, "got an interrupt status %u\n", status);
1676
1677 /* Return here if interrupt is disabled */
1678 if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
1679 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
1680 return IRQ_HANDLED;
1681 }
1682
1683 #ifdef BNX2X_STOP_ON_ERROR
1684 if (unlikely(bp->panic))
1685 return IRQ_HANDLED;
1686 #endif
1687
1688 mask = 0x2 << bp->fp[0].sb_id;
1689 if (status & mask) {
1690 struct bnx2x_fastpath *fp = &bp->fp[0];
1691
1692 prefetch(fp->rx_cons_sb);
1693 prefetch(fp->tx_cons_sb);
1694 prefetch(&fp->status_blk->c_status_block.status_block_index);
1695 prefetch(&fp->status_blk->u_status_block.status_block_index);
1696
1697 napi_schedule(&bnx2x_fp(bp, 0, napi));
1698
1699 status &= ~mask;
1700 }
1701
1702
1703 if (unlikely(status & 0x1)) {
1704 queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
1705
1706 status &= ~0x1;
1707 if (!status)
1708 return IRQ_HANDLED;
1709 }
1710
1711 if (status)
1712 DP(NETIF_MSG_INTR, "got an unknown interrupt! (status %u)\n",
1713 status);
1714
1715 return IRQ_HANDLED;
1716 }
1717
1718 /* end of fast path */
1719
1720 static void bnx2x_stats_handle(struct bnx2x *bp, enum bnx2x_stats_event event);
1721
1722 /* Link */
1723
1724 /*
1725 * General service functions
1726 */
1727
1728 static int bnx2x_acquire_hw_lock(struct bnx2x *bp, u32 resource)
1729 {
1730 u32 lock_status;
1731 u32 resource_bit = (1 << resource);
1732 int func = BP_FUNC(bp);
1733 u32 hw_lock_control_reg;
1734 int cnt;
1735
1736 /* Validating that the resource is within range */
1737 if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1738 DP(NETIF_MSG_HW,
1739 "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1740 resource, HW_LOCK_MAX_RESOURCE_VALUE);
1741 return -EINVAL;
1742 }
1743
1744 if (func <= 5) {
1745 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1746 } else {
1747 hw_lock_control_reg =
1748 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1749 }
1750
1751 /* Validating that the resource is not already taken */
1752 lock_status = REG_RD(bp, hw_lock_control_reg);
1753 if (lock_status & resource_bit) {
1754 DP(NETIF_MSG_HW, "lock_status 0x%x resource_bit 0x%x\n",
1755 lock_status, resource_bit);
1756 return -EEXIST;
1757 }
1758
1759 /* Try for 5 second every 5ms */
1760 for (cnt = 0; cnt < 1000; cnt++) {
1761 /* Try to acquire the lock */
1762 REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
1763 lock_status = REG_RD(bp, hw_lock_control_reg);
1764 if (lock_status & resource_bit)
1765 return 0;
1766
1767 msleep(5);
1768 }
1769 DP(NETIF_MSG_HW, "Timeout\n");
1770 return -EAGAIN;
1771 }
1772
1773 static int bnx2x_release_hw_lock(struct bnx2x *bp, u32 resource)
1774 {
1775 u32 lock_status;
1776 u32 resource_bit = (1 << resource);
1777 int func = BP_FUNC(bp);
1778 u32 hw_lock_control_reg;
1779
1780 /* Validating that the resource is within range */
1781 if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1782 DP(NETIF_MSG_HW,
1783 "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1784 resource, HW_LOCK_MAX_RESOURCE_VALUE);
1785 return -EINVAL;
1786 }
1787
1788 if (func <= 5) {
1789 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1790 } else {
1791 hw_lock_control_reg =
1792 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1793 }
1794
1795 /* Validating that the resource is currently taken */
1796 lock_status = REG_RD(bp, hw_lock_control_reg);
1797 if (!(lock_status & resource_bit)) {
1798 DP(NETIF_MSG_HW, "lock_status 0x%x resource_bit 0x%x\n",
1799 lock_status, resource_bit);
1800 return -EFAULT;
1801 }
1802
1803 REG_WR(bp, hw_lock_control_reg, resource_bit);
1804 return 0;
1805 }
1806
1807 /* HW Lock for shared dual port PHYs */
1808 static void bnx2x_acquire_phy_lock(struct bnx2x *bp)
1809 {
1810 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(bp->link_params.ext_phy_config);
1811
1812 mutex_lock(&bp->port.phy_mutex);
1813
1814 if ((ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072) ||
1815 (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073))
1816 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_8072_MDIO);
1817 }
1818
1819 static void bnx2x_release_phy_lock(struct bnx2x *bp)
1820 {
1821 u32 ext_phy_type = XGXS_EXT_PHY_TYPE(bp->link_params.ext_phy_config);
1822
1823 if ((ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072) ||
1824 (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073))
1825 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_8072_MDIO);
1826
1827 mutex_unlock(&bp->port.phy_mutex);
1828 }
1829
1830 int bnx2x_set_gpio(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
1831 {
1832 /* The GPIO should be swapped if swap register is set and active */
1833 int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1834 REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1835 int gpio_shift = gpio_num +
1836 (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1837 u32 gpio_mask = (1 << gpio_shift);
1838 u32 gpio_reg;
1839
1840 if (gpio_num > MISC_REGISTERS_GPIO_3) {
1841 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1842 return -EINVAL;
1843 }
1844
1845 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1846 /* read GPIO and mask except the float bits */
1847 gpio_reg = (REG_RD(bp, MISC_REG_GPIO) & MISC_REGISTERS_GPIO_FLOAT);
1848
1849 switch (mode) {
1850 case MISC_REGISTERS_GPIO_OUTPUT_LOW:
1851 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> output low\n",
1852 gpio_num, gpio_shift);
1853 /* clear FLOAT and set CLR */
1854 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1855 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_CLR_POS);
1856 break;
1857
1858 case MISC_REGISTERS_GPIO_OUTPUT_HIGH:
1859 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> output high\n",
1860 gpio_num, gpio_shift);
1861 /* clear FLOAT and set SET */
1862 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1863 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_SET_POS);
1864 break;
1865
1866 case MISC_REGISTERS_GPIO_INPUT_HI_Z:
1867 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> input\n",
1868 gpio_num, gpio_shift);
1869 /* set FLOAT */
1870 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1871 break;
1872
1873 default:
1874 break;
1875 }
1876
1877 REG_WR(bp, MISC_REG_GPIO, gpio_reg);
1878 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1879
1880 return 0;
1881 }
1882
1883 static int bnx2x_set_spio(struct bnx2x *bp, int spio_num, u32 mode)
1884 {
1885 u32 spio_mask = (1 << spio_num);
1886 u32 spio_reg;
1887
1888 if ((spio_num < MISC_REGISTERS_SPIO_4) ||
1889 (spio_num > MISC_REGISTERS_SPIO_7)) {
1890 BNX2X_ERR("Invalid SPIO %d\n", spio_num);
1891 return -EINVAL;
1892 }
1893
1894 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
1895 /* read SPIO and mask except the float bits */
1896 spio_reg = (REG_RD(bp, MISC_REG_SPIO) & MISC_REGISTERS_SPIO_FLOAT);
1897
1898 switch (mode) {
1899 case MISC_REGISTERS_SPIO_OUTPUT_LOW:
1900 DP(NETIF_MSG_LINK, "Set SPIO %d -> output low\n", spio_num);
1901 /* clear FLOAT and set CLR */
1902 spio_reg &= ~(spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1903 spio_reg |= (spio_mask << MISC_REGISTERS_SPIO_CLR_POS);
1904 break;
1905
1906 case MISC_REGISTERS_SPIO_OUTPUT_HIGH:
1907 DP(NETIF_MSG_LINK, "Set SPIO %d -> output high\n", spio_num);
1908 /* clear FLOAT and set SET */
1909 spio_reg &= ~(spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1910 spio_reg |= (spio_mask << MISC_REGISTERS_SPIO_SET_POS);
1911 break;
1912
1913 case MISC_REGISTERS_SPIO_INPUT_HI_Z:
1914 DP(NETIF_MSG_LINK, "Set SPIO %d -> input\n", spio_num);
1915 /* set FLOAT */
1916 spio_reg |= (spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1917 break;
1918
1919 default:
1920 break;
1921 }
1922
1923 REG_WR(bp, MISC_REG_SPIO, spio_reg);
1924 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
1925
1926 return 0;
1927 }
1928
1929 static void bnx2x_calc_fc_adv(struct bnx2x *bp)
1930 {
1931 switch (bp->link_vars.ieee_fc &
1932 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
1933 case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE:
1934 bp->port.advertising &= ~(ADVERTISED_Asym_Pause |
1935 ADVERTISED_Pause);
1936 break;
1937 case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH:
1938 bp->port.advertising |= (ADVERTISED_Asym_Pause |
1939 ADVERTISED_Pause);
1940 break;
1941 case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC:
1942 bp->port.advertising |= ADVERTISED_Asym_Pause;
1943 break;
1944 default:
1945 bp->port.advertising &= ~(ADVERTISED_Asym_Pause |
1946 ADVERTISED_Pause);
1947 break;
1948 }
1949 }
1950
1951 static void bnx2x_link_report(struct bnx2x *bp)
1952 {
1953 if (bp->link_vars.link_up) {
1954 if (bp->state == BNX2X_STATE_OPEN)
1955 netif_carrier_on(bp->dev);
1956 printk(KERN_INFO PFX "%s NIC Link is Up, ", bp->dev->name);
1957
1958 printk("%d Mbps ", bp->link_vars.line_speed);
1959
1960 if (bp->link_vars.duplex == DUPLEX_FULL)
1961 printk("full duplex");
1962 else
1963 printk("half duplex");
1964
1965 if (bp->link_vars.flow_ctrl != BNX2X_FLOW_CTRL_NONE) {
1966 if (bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_RX) {
1967 printk(", receive ");
1968 if (bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_TX)
1969 printk("& transmit ");
1970 } else {
1971 printk(", transmit ");
1972 }
1973 printk("flow control ON");
1974 }
1975 printk("\n");
1976
1977 } else { /* link_down */
1978 netif_carrier_off(bp->dev);
1979 printk(KERN_ERR PFX "%s NIC Link is Down\n", bp->dev->name);
1980 }
1981 }
1982
1983 static u8 bnx2x_initial_phy_init(struct bnx2x *bp)
1984 {
1985 if (!BP_NOMCP(bp)) {
1986 u8 rc;
1987
1988 /* Initialize link parameters structure variables */
1989 /* It is recommended to turn off RX FC for jumbo frames
1990 for better performance */
1991 if (IS_E1HMF(bp))
1992 bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_BOTH;
1993 else if (bp->dev->mtu > 5000)
1994 bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_TX;
1995 else
1996 bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_BOTH;
1997
1998 bnx2x_acquire_phy_lock(bp);
1999 rc = bnx2x_phy_init(&bp->link_params, &bp->link_vars);
2000 bnx2x_release_phy_lock(bp);
2001
2002 bnx2x_calc_fc_adv(bp);
2003
2004 if (bp->link_vars.link_up)
2005 bnx2x_link_report(bp);
2006
2007
2008 return rc;
2009 }
2010 BNX2X_ERR("Bootcode is missing -not initializing link\n");
2011 return -EINVAL;
2012 }
2013
2014 static void bnx2x_link_set(struct bnx2x *bp)
2015 {
2016 if (!BP_NOMCP(bp)) {
2017 bnx2x_acquire_phy_lock(bp);
2018 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
2019 bnx2x_release_phy_lock(bp);
2020
2021 bnx2x_calc_fc_adv(bp);
2022 } else
2023 BNX2X_ERR("Bootcode is missing -not setting link\n");
2024 }
2025
2026 static void bnx2x__link_reset(struct bnx2x *bp)
2027 {
2028 if (!BP_NOMCP(bp)) {
2029 bnx2x_acquire_phy_lock(bp);
2030 bnx2x_link_reset(&bp->link_params, &bp->link_vars);
2031 bnx2x_release_phy_lock(bp);
2032 } else
2033 BNX2X_ERR("Bootcode is missing -not resetting link\n");
2034 }
2035
2036 static u8 bnx2x_link_test(struct bnx2x *bp)
2037 {
2038 u8 rc;
2039
2040 bnx2x_acquire_phy_lock(bp);
2041 rc = bnx2x_test_link(&bp->link_params, &bp->link_vars);
2042 bnx2x_release_phy_lock(bp);
2043
2044 return rc;
2045 }
2046
2047 /* Calculates the sum of vn_min_rates.
2048 It's needed for further normalizing of the min_rates.
2049
2050 Returns:
2051 sum of vn_min_rates
2052 or
2053 0 - if all the min_rates are 0.
2054 In the later case fairness algorithm should be deactivated.
2055 If not all min_rates are zero then those that are zeroes will
2056 be set to 1.
2057 */
2058 static u32 bnx2x_calc_vn_wsum(struct bnx2x *bp)
2059 {
2060 int i, port = BP_PORT(bp);
2061 u32 wsum = 0;
2062 int all_zero = 1;
2063
2064 for (i = 0; i < E1HVN_MAX; i++) {
2065 u32 vn_cfg =
2066 SHMEM_RD(bp, mf_cfg.func_mf_config[2*i + port].config);
2067 u32 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
2068 FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
2069 if (!(vn_cfg & FUNC_MF_CFG_FUNC_HIDE)) {
2070 /* If min rate is zero - set it to 1 */
2071 if (!vn_min_rate)
2072 vn_min_rate = DEF_MIN_RATE;
2073 else
2074 all_zero = 0;
2075
2076 wsum += vn_min_rate;
2077 }
2078 }
2079
2080 /* ... only if all min rates are zeros - disable FAIRNESS */
2081 if (all_zero)
2082 return 0;
2083
2084 return wsum;
2085 }
2086
2087 static void bnx2x_init_port_minmax(struct bnx2x *bp,
2088 int en_fness,
2089 u16 port_rate,
2090 struct cmng_struct_per_port *m_cmng_port)
2091 {
2092 u32 r_param = port_rate / 8;
2093 int port = BP_PORT(bp);
2094 int i;
2095
2096 memset(m_cmng_port, 0, sizeof(struct cmng_struct_per_port));
2097
2098 /* Enable minmax only if we are in e1hmf mode */
2099 if (IS_E1HMF(bp)) {
2100 u32 fair_periodic_timeout_usec;
2101 u32 t_fair;
2102
2103 /* Enable rate shaping and fairness */
2104 m_cmng_port->flags.cmng_vn_enable = 1;
2105 m_cmng_port->flags.fairness_enable = en_fness ? 1 : 0;
2106 m_cmng_port->flags.rate_shaping_enable = 1;
2107
2108 if (!en_fness)
2109 DP(NETIF_MSG_IFUP, "All MIN values are zeroes"
2110 " fairness will be disabled\n");
2111
2112 /* 100 usec in SDM ticks = 25 since each tick is 4 usec */
2113 m_cmng_port->rs_vars.rs_periodic_timeout =
2114 RS_PERIODIC_TIMEOUT_USEC / 4;
2115
2116 /* this is the threshold below which no timer arming will occur
2117 1.25 coefficient is for the threshold to be a little bigger
2118 than the real time, to compensate for timer in-accuracy */
2119 m_cmng_port->rs_vars.rs_threshold =
2120 (RS_PERIODIC_TIMEOUT_USEC * r_param * 5) / 4;
2121
2122 /* resolution of fairness timer */
2123 fair_periodic_timeout_usec = QM_ARB_BYTES / r_param;
2124 /* for 10G it is 1000usec. for 1G it is 10000usec. */
2125 t_fair = T_FAIR_COEF / port_rate;
2126
2127 /* this is the threshold below which we won't arm
2128 the timer anymore */
2129 m_cmng_port->fair_vars.fair_threshold = QM_ARB_BYTES;
2130
2131 /* we multiply by 1e3/8 to get bytes/msec.
2132 We don't want the credits to pass a credit
2133 of the T_FAIR*FAIR_MEM (algorithm resolution) */
2134 m_cmng_port->fair_vars.upper_bound =
2135 r_param * t_fair * FAIR_MEM;
2136 /* since each tick is 4 usec */
2137 m_cmng_port->fair_vars.fairness_timeout =
2138 fair_periodic_timeout_usec / 4;
2139
2140 } else {
2141 /* Disable rate shaping and fairness */
2142 m_cmng_port->flags.cmng_vn_enable = 0;
2143 m_cmng_port->flags.fairness_enable = 0;
2144 m_cmng_port->flags.rate_shaping_enable = 0;
2145
2146 DP(NETIF_MSG_IFUP,
2147 "Single function mode minmax will be disabled\n");
2148 }
2149
2150 /* Store it to internal memory */
2151 for (i = 0; i < sizeof(struct cmng_struct_per_port) / 4; i++)
2152 REG_WR(bp, BAR_XSTRORM_INTMEM +
2153 XSTORM_CMNG_PER_PORT_VARS_OFFSET(port) + i * 4,
2154 ((u32 *)(m_cmng_port))[i]);
2155 }
2156
2157 static void bnx2x_init_vn_minmax(struct bnx2x *bp, int func,
2158 u32 wsum, u16 port_rate,
2159 struct cmng_struct_per_port *m_cmng_port)
2160 {
2161 struct rate_shaping_vars_per_vn m_rs_vn;
2162 struct fairness_vars_per_vn m_fair_vn;
2163 u32 vn_cfg = SHMEM_RD(bp, mf_cfg.func_mf_config[func].config);
2164 u16 vn_min_rate, vn_max_rate;
2165 int i;
2166
2167 /* If function is hidden - set min and max to zeroes */
2168 if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE) {
2169 vn_min_rate = 0;
2170 vn_max_rate = 0;
2171
2172 } else {
2173 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
2174 FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
2175 /* If FAIRNESS is enabled (not all min rates are zeroes) and
2176 if current min rate is zero - set it to 1.
2177 This is a requirement of the algorithm. */
2178 if ((vn_min_rate == 0) && wsum)
2179 vn_min_rate = DEF_MIN_RATE;
2180 vn_max_rate = ((vn_cfg & FUNC_MF_CFG_MAX_BW_MASK) >>
2181 FUNC_MF_CFG_MAX_BW_SHIFT) * 100;
2182 }
2183
2184 DP(NETIF_MSG_IFUP, "func %d: vn_min_rate=%d vn_max_rate=%d "
2185 "wsum=%d\n", func, vn_min_rate, vn_max_rate, wsum);
2186
2187 memset(&m_rs_vn, 0, sizeof(struct rate_shaping_vars_per_vn));
2188 memset(&m_fair_vn, 0, sizeof(struct fairness_vars_per_vn));
2189
2190 /* global vn counter - maximal Mbps for this vn */
2191 m_rs_vn.vn_counter.rate = vn_max_rate;
2192
2193 /* quota - number of bytes transmitted in this period */
2194 m_rs_vn.vn_counter.quota =
2195 (vn_max_rate * RS_PERIODIC_TIMEOUT_USEC) / 8;
2196
2197 #ifdef BNX2X_PER_PROT_QOS
2198 /* per protocol counter */
2199 for (protocol = 0; protocol < NUM_OF_PROTOCOLS; protocol++) {
2200 /* maximal Mbps for this protocol */
2201 m_rs_vn.protocol_counters[protocol].rate =
2202 protocol_max_rate[protocol];
2203 /* the quota in each timer period -
2204 number of bytes transmitted in this period */
2205 m_rs_vn.protocol_counters[protocol].quota =
2206 (u32)(rs_periodic_timeout_usec *
2207 ((double)m_rs_vn.
2208 protocol_counters[protocol].rate/8));
2209 }
2210 #endif
2211
2212 if (wsum) {
2213 /* credit for each period of the fairness algorithm:
2214 number of bytes in T_FAIR (the vn share the port rate).
2215 wsum should not be larger than 10000, thus
2216 T_FAIR_COEF / (8 * wsum) will always be grater than zero */
2217 m_fair_vn.vn_credit_delta =
2218 max((u64)(vn_min_rate * (T_FAIR_COEF / (8 * wsum))),
2219 (u64)(m_cmng_port->fair_vars.fair_threshold * 2));
2220 DP(NETIF_MSG_IFUP, "m_fair_vn.vn_credit_delta=%d\n",
2221 m_fair_vn.vn_credit_delta);
2222 }
2223
2224 #ifdef BNX2X_PER_PROT_QOS
2225 do {
2226 u32 protocolWeightSum = 0;
2227
2228 for (protocol = 0; protocol < NUM_OF_PROTOCOLS; protocol++)
2229 protocolWeightSum +=
2230 drvInit.protocol_min_rate[protocol];
2231 /* per protocol counter -
2232 NOT NEEDED IF NO PER-PROTOCOL CONGESTION MANAGEMENT */
2233 if (protocolWeightSum > 0) {
2234 for (protocol = 0;
2235 protocol < NUM_OF_PROTOCOLS; protocol++)
2236 /* credit for each period of the
2237 fairness algorithm - number of bytes in
2238 T_FAIR (the protocol share the vn rate) */
2239 m_fair_vn.protocol_credit_delta[protocol] =
2240 (u32)((vn_min_rate / 8) * t_fair *
2241 protocol_min_rate / protocolWeightSum);
2242 }
2243 } while (0);
2244 #endif
2245
2246 /* Store it to internal memory */
2247 for (i = 0; i < sizeof(struct rate_shaping_vars_per_vn)/4; i++)
2248 REG_WR(bp, BAR_XSTRORM_INTMEM +
2249 XSTORM_RATE_SHAPING_PER_VN_VARS_OFFSET(func) + i * 4,
2250 ((u32 *)(&m_rs_vn))[i]);
2251
2252 for (i = 0; i < sizeof(struct fairness_vars_per_vn)/4; i++)
2253 REG_WR(bp, BAR_XSTRORM_INTMEM +
2254 XSTORM_FAIRNESS_PER_VN_VARS_OFFSET(func) + i * 4,
2255 ((u32 *)(&m_fair_vn))[i]);
2256 }
2257
2258 /* This function is called upon link interrupt */
2259 static void bnx2x_link_attn(struct bnx2x *bp)
2260 {
2261 int vn;
2262
2263 /* Make sure that we are synced with the current statistics */
2264 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2265
2266 bnx2x_link_update(&bp->link_params, &bp->link_vars);
2267
2268 if (bp->link_vars.link_up) {
2269
2270 if (bp->link_vars.mac_type == MAC_TYPE_BMAC) {
2271 struct host_port_stats *pstats;
2272
2273 pstats = bnx2x_sp(bp, port_stats);
2274 /* reset old bmac stats */
2275 memset(&(pstats->mac_stx[0]), 0,
2276 sizeof(struct mac_stx));
2277 }
2278 if ((bp->state == BNX2X_STATE_OPEN) ||
2279 (bp->state == BNX2X_STATE_DISABLED))
2280 bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2281 }
2282
2283 /* indicate link status */
2284 bnx2x_link_report(bp);
2285
2286 if (IS_E1HMF(bp)) {
2287 int func;
2288
2289 for (vn = VN_0; vn < E1HVN_MAX; vn++) {
2290 if (vn == BP_E1HVN(bp))
2291 continue;
2292
2293 func = ((vn << 1) | BP_PORT(bp));
2294
2295 /* Set the attention towards other drivers
2296 on the same port */
2297 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_0 +
2298 (LINK_SYNC_ATTENTION_BIT_FUNC_0 + func)*4, 1);
2299 }
2300 }
2301
2302 if (CHIP_IS_E1H(bp) && (bp->link_vars.line_speed > 0)) {
2303 struct cmng_struct_per_port m_cmng_port;
2304 u32 wsum;
2305 int port = BP_PORT(bp);
2306
2307 /* Init RATE SHAPING and FAIRNESS contexts */
2308 wsum = bnx2x_calc_vn_wsum(bp);
2309 bnx2x_init_port_minmax(bp, (int)wsum,
2310 bp->link_vars.line_speed,
2311 &m_cmng_port);
2312 if (IS_E1HMF(bp))
2313 for (vn = VN_0; vn < E1HVN_MAX; vn++)
2314 bnx2x_init_vn_minmax(bp, 2*vn + port,
2315 wsum, bp->link_vars.line_speed,
2316 &m_cmng_port);
2317 }
2318 }
2319
2320 static void bnx2x__link_status_update(struct bnx2x *bp)
2321 {
2322 if (bp->state != BNX2X_STATE_OPEN)
2323 return;
2324
2325 bnx2x_link_status_update(&bp->link_params, &bp->link_vars);
2326
2327 if (bp->link_vars.link_up)
2328 bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2329 else
2330 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2331
2332 /* indicate link status */
2333 bnx2x_link_report(bp);
2334 }
2335
2336 static void bnx2x_pmf_update(struct bnx2x *bp)
2337 {
2338 int port = BP_PORT(bp);
2339 u32 val;
2340
2341 bp->port.pmf = 1;
2342 DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
2343
2344 /* enable nig attention */
2345 val = (0xff0f | (1 << (BP_E1HVN(bp) + 4)));
2346 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
2347 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
2348
2349 bnx2x_stats_handle(bp, STATS_EVENT_PMF);
2350 }
2351
2352 /* end of Link */
2353
2354 /* slow path */
2355
2356 /*
2357 * General service functions
2358 */
2359
2360 /* the slow path queue is odd since completions arrive on the fastpath ring */
2361 static int bnx2x_sp_post(struct bnx2x *bp, int command, int cid,
2362 u32 data_hi, u32 data_lo, int common)
2363 {
2364 int func = BP_FUNC(bp);
2365
2366 DP(BNX2X_MSG_SP/*NETIF_MSG_TIMER*/,
2367 "SPQE (%x:%x) command %d hw_cid %x data (%x:%x) left %x\n",
2368 (u32)U64_HI(bp->spq_mapping), (u32)(U64_LO(bp->spq_mapping) +
2369 (void *)bp->spq_prod_bd - (void *)bp->spq), command,
2370 HW_CID(bp, cid), data_hi, data_lo, bp->spq_left);
2371
2372 #ifdef BNX2X_STOP_ON_ERROR
2373 if (unlikely(bp->panic))
2374 return -EIO;
2375 #endif
2376
2377 spin_lock_bh(&bp->spq_lock);
2378
2379 if (!bp->spq_left) {
2380 BNX2X_ERR("BUG! SPQ ring full!\n");
2381 spin_unlock_bh(&bp->spq_lock);
2382 bnx2x_panic();
2383 return -EBUSY;
2384 }
2385
2386 /* CID needs port number to be encoded int it */
2387 bp->spq_prod_bd->hdr.conn_and_cmd_data =
2388 cpu_to_le32(((command << SPE_HDR_CMD_ID_SHIFT) |
2389 HW_CID(bp, cid)));
2390 bp->spq_prod_bd->hdr.type = cpu_to_le16(ETH_CONNECTION_TYPE);
2391 if (common)
2392 bp->spq_prod_bd->hdr.type |=
2393 cpu_to_le16((1 << SPE_HDR_COMMON_RAMROD_SHIFT));
2394
2395 bp->spq_prod_bd->data.mac_config_addr.hi = cpu_to_le32(data_hi);
2396 bp->spq_prod_bd->data.mac_config_addr.lo = cpu_to_le32(data_lo);
2397
2398 bp->spq_left--;
2399
2400 if (bp->spq_prod_bd == bp->spq_last_bd) {
2401 bp->spq_prod_bd = bp->spq;
2402 bp->spq_prod_idx = 0;
2403 DP(NETIF_MSG_TIMER, "end of spq\n");
2404
2405 } else {
2406 bp->spq_prod_bd++;
2407 bp->spq_prod_idx++;
2408 }
2409
2410 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_SPQ_PROD_OFFSET(func),
2411 bp->spq_prod_idx);
2412
2413 spin_unlock_bh(&bp->spq_lock);
2414 return 0;
2415 }
2416
2417 /* acquire split MCP access lock register */
2418 static int bnx2x_acquire_alr(struct bnx2x *bp)
2419 {
2420 u32 i, j, val;
2421 int rc = 0;
2422
2423 might_sleep();
2424 i = 100;
2425 for (j = 0; j < i*10; j++) {
2426 val = (1UL << 31);
2427 REG_WR(bp, GRCBASE_MCP + 0x9c, val);
2428 val = REG_RD(bp, GRCBASE_MCP + 0x9c);
2429 if (val & (1L << 31))
2430 break;
2431
2432 msleep(5);
2433 }
2434 if (!(val & (1L << 31))) {
2435 BNX2X_ERR("Cannot acquire MCP access lock register\n");
2436 rc = -EBUSY;
2437 }
2438
2439 return rc;
2440 }
2441
2442 /* release split MCP access lock register */
2443 static void bnx2x_release_alr(struct bnx2x *bp)
2444 {
2445 u32 val = 0;
2446
2447 REG_WR(bp, GRCBASE_MCP + 0x9c, val);
2448 }
2449
2450 static inline u16 bnx2x_update_dsb_idx(struct bnx2x *bp)
2451 {
2452 struct host_def_status_block *def_sb = bp->def_status_blk;
2453 u16 rc = 0;
2454
2455 barrier(); /* status block is written to by the chip */
2456 if (bp->def_att_idx != def_sb->atten_status_block.attn_bits_index) {
2457 bp->def_att_idx = def_sb->atten_status_block.attn_bits_index;
2458 rc |= 1;
2459 }
2460 if (bp->def_c_idx != def_sb->c_def_status_block.status_block_index) {
2461 bp->def_c_idx = def_sb->c_def_status_block.status_block_index;
2462 rc |= 2;
2463 }
2464 if (bp->def_u_idx != def_sb->u_def_status_block.status_block_index) {
2465 bp->def_u_idx = def_sb->u_def_status_block.status_block_index;
2466 rc |= 4;
2467 }
2468 if (bp->def_x_idx != def_sb->x_def_status_block.status_block_index) {
2469 bp->def_x_idx = def_sb->x_def_status_block.status_block_index;
2470 rc |= 8;
2471 }
2472 if (bp->def_t_idx != def_sb->t_def_status_block.status_block_index) {
2473 bp->def_t_idx = def_sb->t_def_status_block.status_block_index;
2474 rc |= 16;
2475 }
2476 return rc;
2477 }
2478
2479 /*
2480 * slow path service functions
2481 */
2482
2483 static void bnx2x_attn_int_asserted(struct bnx2x *bp, u32 asserted)
2484 {
2485 int port = BP_PORT(bp);
2486 u32 hc_addr = (HC_REG_COMMAND_REG + port*32 +
2487 COMMAND_REG_ATTN_BITS_SET);
2488 u32 aeu_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
2489 MISC_REG_AEU_MASK_ATTN_FUNC_0;
2490 u32 nig_int_mask_addr = port ? NIG_REG_MASK_INTERRUPT_PORT1 :
2491 NIG_REG_MASK_INTERRUPT_PORT0;
2492 u32 aeu_mask;
2493
2494 if (bp->attn_state & asserted)
2495 BNX2X_ERR("IGU ERROR\n");
2496
2497 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2498 aeu_mask = REG_RD(bp, aeu_addr);
2499
2500 DP(NETIF_MSG_HW, "aeu_mask %x newly asserted %x\n",
2501 aeu_mask, asserted);
2502 aeu_mask &= ~(asserted & 0xff);
2503 DP(NETIF_MSG_HW, "new mask %x\n", aeu_mask);
2504
2505 REG_WR(bp, aeu_addr, aeu_mask);
2506 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2507
2508 DP(NETIF_MSG_HW, "attn_state %x\n", bp->attn_state);
2509 bp->attn_state |= asserted;
2510 DP(NETIF_MSG_HW, "new state %x\n", bp->attn_state);
2511
2512 if (asserted & ATTN_HARD_WIRED_MASK) {
2513 if (asserted & ATTN_NIG_FOR_FUNC) {
2514
2515 bnx2x_acquire_phy_lock(bp);
2516
2517 /* save nig interrupt mask */
2518 bp->nig_mask = REG_RD(bp, nig_int_mask_addr);
2519 REG_WR(bp, nig_int_mask_addr, 0);
2520
2521 bnx2x_link_attn(bp);
2522
2523 /* handle unicore attn? */
2524 }
2525 if (asserted & ATTN_SW_TIMER_4_FUNC)
2526 DP(NETIF_MSG_HW, "ATTN_SW_TIMER_4_FUNC!\n");
2527
2528 if (asserted & GPIO_2_FUNC)
2529 DP(NETIF_MSG_HW, "GPIO_2_FUNC!\n");
2530
2531 if (asserted & GPIO_3_FUNC)
2532 DP(NETIF_MSG_HW, "GPIO_3_FUNC!\n");
2533
2534 if (asserted & GPIO_4_FUNC)
2535 DP(NETIF_MSG_HW, "GPIO_4_FUNC!\n");
2536
2537 if (port == 0) {
2538 if (asserted & ATTN_GENERAL_ATTN_1) {
2539 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_1!\n");
2540 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_1, 0x0);
2541 }
2542 if (asserted & ATTN_GENERAL_ATTN_2) {
2543 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_2!\n");
2544 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_2, 0x0);
2545 }
2546 if (asserted & ATTN_GENERAL_ATTN_3) {
2547 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_3!\n");
2548 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_3, 0x0);
2549 }
2550 } else {
2551 if (asserted & ATTN_GENERAL_ATTN_4) {
2552 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_4!\n");
2553 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_4, 0x0);
2554 }
2555 if (asserted & ATTN_GENERAL_ATTN_5) {
2556 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_5!\n");
2557 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_5, 0x0);
2558 }
2559 if (asserted & ATTN_GENERAL_ATTN_6) {
2560 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_6!\n");
2561 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_6, 0x0);
2562 }
2563 }
2564
2565 } /* if hardwired */
2566
2567 DP(NETIF_MSG_HW, "about to mask 0x%08x at HC addr 0x%x\n",
2568 asserted, hc_addr);
2569 REG_WR(bp, hc_addr, asserted);
2570
2571 /* now set back the mask */
2572 if (asserted & ATTN_NIG_FOR_FUNC) {
2573 REG_WR(bp, nig_int_mask_addr, bp->nig_mask);
2574 bnx2x_release_phy_lock(bp);
2575 }
2576 }
2577
2578 static inline void bnx2x_attn_int_deasserted0(struct bnx2x *bp, u32 attn)
2579 {
2580 int port = BP_PORT(bp);
2581 int reg_offset;
2582 u32 val;
2583
2584 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
2585 MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
2586
2587 if (attn & AEU_INPUTS_ATTN_BITS_SPIO5) {
2588
2589 val = REG_RD(bp, reg_offset);
2590 val &= ~AEU_INPUTS_ATTN_BITS_SPIO5;
2591 REG_WR(bp, reg_offset, val);
2592
2593 BNX2X_ERR("SPIO5 hw attention\n");
2594
2595 switch (bp->common.board & SHARED_HW_CFG_BOARD_TYPE_MASK) {
2596 case SHARED_HW_CFG_BOARD_TYPE_BCM957710A1021G:
2597 case SHARED_HW_CFG_BOARD_TYPE_BCM957710A1022G:
2598 /* Fan failure attention */
2599
2600 /* The PHY reset is controlled by GPIO 1 */
2601 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
2602 MISC_REGISTERS_GPIO_OUTPUT_LOW, port);
2603 /* Low power mode is controlled by GPIO 2 */
2604 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
2605 MISC_REGISTERS_GPIO_OUTPUT_LOW, port);
2606 /* mark the failure */
2607 bp->link_params.ext_phy_config &=
2608 ~PORT_HW_CFG_XGXS_EXT_PHY_TYPE_MASK;
2609 bp->link_params.ext_phy_config |=
2610 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE;
2611 SHMEM_WR(bp,
2612 dev_info.port_hw_config[port].
2613 external_phy_config,
2614 bp->link_params.ext_phy_config);
2615 /* log the failure */
2616 printk(KERN_ERR PFX "Fan Failure on Network"
2617 " Controller %s has caused the driver to"
2618 " shutdown the card to prevent permanent"
2619 " damage. Please contact Dell Support for"
2620 " assistance\n", bp->dev->name);
2621 break;
2622
2623 default:
2624 break;
2625 }
2626 }
2627
2628 if (attn & HW_INTERRUT_ASSERT_SET_0) {
2629
2630 val = REG_RD(bp, reg_offset);
2631 val &= ~(attn & HW_INTERRUT_ASSERT_SET_0);
2632 REG_WR(bp, reg_offset, val);
2633
2634 BNX2X_ERR("FATAL HW block attention set0 0x%x\n",
2635 (attn & HW_INTERRUT_ASSERT_SET_0));
2636 bnx2x_panic();
2637 }
2638 }
2639
2640 static inline void bnx2x_attn_int_deasserted1(struct bnx2x *bp, u32 attn)
2641 {
2642 u32 val;
2643
2644 if (attn & BNX2X_DOORQ_ASSERT) {
2645
2646 val = REG_RD(bp, DORQ_REG_DORQ_INT_STS_CLR);
2647 BNX2X_ERR("DB hw attention 0x%x\n", val);
2648 /* DORQ discard attention */
2649 if (val & 0x2)
2650 BNX2X_ERR("FATAL error from DORQ\n");
2651 }
2652
2653 if (attn & HW_INTERRUT_ASSERT_SET_1) {
2654
2655 int port = BP_PORT(bp);
2656 int reg_offset;
2657
2658 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_1 :
2659 MISC_REG_AEU_ENABLE1_FUNC_0_OUT_1);
2660
2661 val = REG_RD(bp, reg_offset);
2662 val &= ~(attn & HW_INTERRUT_ASSERT_SET_1);
2663 REG_WR(bp, reg_offset, val);
2664
2665 BNX2X_ERR("FATAL HW block attention set1 0x%x\n",
2666 (attn & HW_INTERRUT_ASSERT_SET_1));
2667 bnx2x_panic();
2668 }
2669 }
2670
2671 static inline void bnx2x_attn_int_deasserted2(struct bnx2x *bp, u32 attn)
2672 {
2673 u32 val;
2674
2675 if (attn & AEU_INPUTS_ATTN_BITS_CFC_HW_INTERRUPT) {
2676
2677 val = REG_RD(bp, CFC_REG_CFC_INT_STS_CLR);
2678 BNX2X_ERR("CFC hw attention 0x%x\n", val);
2679 /* CFC error attention */
2680 if (val & 0x2)
2681 BNX2X_ERR("FATAL error from CFC\n");
2682 }
2683
2684 if (attn & AEU_INPUTS_ATTN_BITS_PXP_HW_INTERRUPT) {
2685
2686 val = REG_RD(bp, PXP_REG_PXP_INT_STS_CLR_0);
2687 BNX2X_ERR("PXP hw attention 0x%x\n", val);
2688 /* RQ_USDMDP_FIFO_OVERFLOW */
2689 if (val & 0x18000)
2690 BNX2X_ERR("FATAL error from PXP\n");
2691 }
2692
2693 if (attn & HW_INTERRUT_ASSERT_SET_2) {
2694
2695 int port = BP_PORT(bp);
2696 int reg_offset;
2697
2698 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_2 :
2699 MISC_REG_AEU_ENABLE1_FUNC_0_OUT_2);
2700
2701 val = REG_RD(bp, reg_offset);
2702 val &= ~(attn & HW_INTERRUT_ASSERT_SET_2);
2703 REG_WR(bp, reg_offset, val);
2704
2705 BNX2X_ERR("FATAL HW block attention set2 0x%x\n",
2706 (attn & HW_INTERRUT_ASSERT_SET_2));
2707 bnx2x_panic();
2708 }
2709 }
2710
2711 static inline void bnx2x_attn_int_deasserted3(struct bnx2x *bp, u32 attn)
2712 {
2713 u32 val;
2714
2715 if (attn & EVEREST_GEN_ATTN_IN_USE_MASK) {
2716
2717 if (attn & BNX2X_PMF_LINK_ASSERT) {
2718 int func = BP_FUNC(bp);
2719
2720 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
2721 bnx2x__link_status_update(bp);
2722 if (SHMEM_RD(bp, func_mb[func].drv_status) &
2723 DRV_STATUS_PMF)
2724 bnx2x_pmf_update(bp);
2725
2726 } else if (attn & BNX2X_MC_ASSERT_BITS) {
2727
2728 BNX2X_ERR("MC assert!\n");
2729 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_10, 0);
2730 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_9, 0);
2731 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_8, 0);
2732 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_7, 0);
2733 bnx2x_panic();
2734
2735 } else if (attn & BNX2X_MCP_ASSERT) {
2736
2737 BNX2X_ERR("MCP assert!\n");
2738 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_11, 0);
2739 bnx2x_fw_dump(bp);
2740
2741 } else
2742 BNX2X_ERR("Unknown HW assert! (attn 0x%x)\n", attn);
2743 }
2744
2745 if (attn & EVEREST_LATCHED_ATTN_IN_USE_MASK) {
2746 BNX2X_ERR("LATCHED attention 0x%08x (masked)\n", attn);
2747 if (attn & BNX2X_GRC_TIMEOUT) {
2748 val = CHIP_IS_E1H(bp) ?
2749 REG_RD(bp, MISC_REG_GRC_TIMEOUT_ATTN) : 0;
2750 BNX2X_ERR("GRC time-out 0x%08x\n", val);
2751 }
2752 if (attn & BNX2X_GRC_RSV) {
2753 val = CHIP_IS_E1H(bp) ?
2754 REG_RD(bp, MISC_REG_GRC_RSV_ATTN) : 0;
2755 BNX2X_ERR("GRC reserved 0x%08x\n", val);
2756 }
2757 REG_WR(bp, MISC_REG_AEU_CLR_LATCH_SIGNAL, 0x7ff);
2758 }
2759 }
2760
2761 static void bnx2x_attn_int_deasserted(struct bnx2x *bp, u32 deasserted)
2762 {
2763 struct attn_route attn;
2764 struct attn_route group_mask;
2765 int port = BP_PORT(bp);
2766 int index;
2767 u32 reg_addr;
2768 u32 val;
2769 u32 aeu_mask;
2770
2771 /* need to take HW lock because MCP or other port might also
2772 try to handle this event */
2773 bnx2x_acquire_alr(bp);
2774
2775 attn.sig[0] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 + port*4);
2776 attn.sig[1] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_2_FUNC_0 + port*4);
2777 attn.sig[2] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_3_FUNC_0 + port*4);
2778 attn.sig[3] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_4_FUNC_0 + port*4);
2779 DP(NETIF_MSG_HW, "attn: %08x %08x %08x %08x\n",
2780 attn.sig[0], attn.sig[1], attn.sig[2], attn.sig[3]);
2781
2782 for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
2783 if (deasserted & (1 << index)) {
2784 group_mask = bp->attn_group[index];
2785
2786 DP(NETIF_MSG_HW, "group[%d]: %08x %08x %08x %08x\n",
2787 index, group_mask.sig[0], group_mask.sig[1],
2788 group_mask.sig[2], group_mask.sig[3]);
2789
2790 bnx2x_attn_int_deasserted3(bp,
2791 attn.sig[3] & group_mask.sig[3]);
2792 bnx2x_attn_int_deasserted1(bp,
2793 attn.sig[1] & group_mask.sig[1]);
2794 bnx2x_attn_int_deasserted2(bp,
2795 attn.sig[2] & group_mask.sig[2]);
2796 bnx2x_attn_int_deasserted0(bp,
2797 attn.sig[0] & group_mask.sig[0]);
2798
2799 if ((attn.sig[0] & group_mask.sig[0] &
2800 HW_PRTY_ASSERT_SET_0) ||
2801 (attn.sig[1] & group_mask.sig[1] &
2802 HW_PRTY_ASSERT_SET_1) ||
2803 (attn.sig[2] & group_mask.sig[2] &
2804 HW_PRTY_ASSERT_SET_2))
2805 BNX2X_ERR("FATAL HW block parity attention\n");
2806 }
2807 }
2808
2809 bnx2x_release_alr(bp);
2810
2811 reg_addr = (HC_REG_COMMAND_REG + port*32 + COMMAND_REG_ATTN_BITS_CLR);
2812
2813 val = ~deasserted;
2814 DP(NETIF_MSG_HW, "about to mask 0x%08x at HC addr 0x%x\n",
2815 val, reg_addr);
2816 REG_WR(bp, reg_addr, val);
2817
2818 if (~bp->attn_state & deasserted)
2819 BNX2X_ERR("IGU ERROR\n");
2820
2821 reg_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
2822 MISC_REG_AEU_MASK_ATTN_FUNC_0;
2823
2824 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2825 aeu_mask = REG_RD(bp, reg_addr);
2826
2827 DP(NETIF_MSG_HW, "aeu_mask %x newly deasserted %x\n",
2828 aeu_mask, deasserted);
2829 aeu_mask |= (deasserted & 0xff);
2830 DP(NETIF_MSG_HW, "new mask %x\n", aeu_mask);
2831
2832 REG_WR(bp, reg_addr, aeu_mask);
2833 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2834
2835 DP(NETIF_MSG_HW, "attn_state %x\n", bp->attn_state);
2836 bp->attn_state &= ~deasserted;
2837 DP(NETIF_MSG_HW, "new state %x\n", bp->attn_state);
2838 }
2839
2840 static void bnx2x_attn_int(struct bnx2x *bp)
2841 {
2842 /* read local copy of bits */
2843 u32 attn_bits = le32_to_cpu(bp->def_status_blk->atten_status_block.
2844 attn_bits);
2845 u32 attn_ack = le32_to_cpu(bp->def_status_blk->atten_status_block.
2846 attn_bits_ack);
2847 u32 attn_state = bp->attn_state;
2848
2849 /* look for changed bits */
2850 u32 asserted = attn_bits & ~attn_ack & ~attn_state;
2851 u32 deasserted = ~attn_bits & attn_ack & attn_state;
2852
2853 DP(NETIF_MSG_HW,
2854 "attn_bits %x attn_ack %x asserted %x deasserted %x\n",
2855 attn_bits, attn_ack, asserted, deasserted);
2856
2857 if (~(attn_bits ^ attn_ack) & (attn_bits ^ attn_state))
2858 BNX2X_ERR("BAD attention state\n");
2859
2860 /* handle bits that were raised */
2861 if (asserted)
2862 bnx2x_attn_int_asserted(bp, asserted);
2863
2864 if (deasserted)
2865 bnx2x_attn_int_deasserted(bp, deasserted);
2866 }
2867
2868 static void bnx2x_sp_task(struct work_struct *work)
2869 {
2870 struct bnx2x *bp = container_of(work, struct bnx2x, sp_task.work);
2871 u16 status;
2872
2873
2874 /* Return here if interrupt is disabled */
2875 if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
2876 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
2877 return;
2878 }
2879
2880 status = bnx2x_update_dsb_idx(bp);
2881 /* if (status == 0) */
2882 /* BNX2X_ERR("spurious slowpath interrupt!\n"); */
2883
2884 DP(NETIF_MSG_INTR, "got a slowpath interrupt (updated %x)\n", status);
2885
2886 /* HW attentions */
2887 if (status & 0x1)
2888 bnx2x_attn_int(bp);
2889
2890 /* CStorm events: query_stats, port delete ramrod */
2891 if (status & 0x2)
2892 bp->stats_pending = 0;
2893
2894 bnx2x_ack_sb(bp, DEF_SB_ID, ATTENTION_ID, le16_to_cpu(bp->def_att_idx),
2895 IGU_INT_NOP, 1);
2896 bnx2x_ack_sb(bp, DEF_SB_ID, USTORM_ID, le16_to_cpu(bp->def_u_idx),
2897 IGU_INT_NOP, 1);
2898 bnx2x_ack_sb(bp, DEF_SB_ID, CSTORM_ID, le16_to_cpu(bp->def_c_idx),
2899 IGU_INT_NOP, 1);
2900 bnx2x_ack_sb(bp, DEF_SB_ID, XSTORM_ID, le16_to_cpu(bp->def_x_idx),
2901 IGU_INT_NOP, 1);
2902 bnx2x_ack_sb(bp, DEF_SB_ID, TSTORM_ID, le16_to_cpu(bp->def_t_idx),
2903 IGU_INT_ENABLE, 1);
2904
2905 }
2906
2907 static irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance)
2908 {
2909 struct net_device *dev = dev_instance;
2910 struct bnx2x *bp = netdev_priv(dev);
2911
2912 /* Return here if interrupt is disabled */
2913 if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
2914 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
2915 return IRQ_HANDLED;
2916 }
2917
2918 bnx2x_ack_sb(bp, DEF_SB_ID, XSTORM_ID, 0, IGU_INT_DISABLE, 0);
2919
2920 #ifdef BNX2X_STOP_ON_ERROR
2921 if (unlikely(bp->panic))
2922 return IRQ_HANDLED;
2923 #endif
2924
2925 queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
2926
2927 return IRQ_HANDLED;
2928 }
2929
2930 /* end of slow path */
2931
2932 /* Statistics */
2933
2934 /****************************************************************************
2935 * Macros
2936 ****************************************************************************/
2937
2938 /* sum[hi:lo] += add[hi:lo] */
2939 #define ADD_64(s_hi, a_hi, s_lo, a_lo) \
2940 do { \
2941 s_lo += a_lo; \
2942 s_hi += a_hi + ((s_lo < a_lo) ? 1 : 0); \
2943 } while (0)
2944
2945 /* difference = minuend - subtrahend */
2946 #define DIFF_64(d_hi, m_hi, s_hi, d_lo, m_lo, s_lo) \
2947 do { \
2948 if (m_lo < s_lo) { \
2949 /* underflow */ \
2950 d_hi = m_hi - s_hi; \
2951 if (d_hi > 0) { \
2952 /* we can 'loan' 1 */ \
2953 d_hi--; \
2954 d_lo = m_lo + (UINT_MAX - s_lo) + 1; \
2955 } else { \
2956 /* m_hi <= s_hi */ \
2957 d_hi = 0; \
2958 d_lo = 0; \
2959 } \
2960 } else { \
2961 /* m_lo >= s_lo */ \
2962 if (m_hi < s_hi) { \
2963 d_hi = 0; \
2964 d_lo = 0; \
2965 } else { \
2966 /* m_hi >= s_hi */ \
2967 d_hi = m_hi - s_hi; \
2968 d_lo = m_lo - s_lo; \
2969 } \
2970 } \
2971 } while (0)
2972
2973 #define UPDATE_STAT64(s, t) \
2974 do { \
2975 DIFF_64(diff.hi, new->s##_hi, pstats->mac_stx[0].t##_hi, \
2976 diff.lo, new->s##_lo, pstats->mac_stx[0].t##_lo); \
2977 pstats->mac_stx[0].t##_hi = new->s##_hi; \
2978 pstats->mac_stx[0].t##_lo = new->s##_lo; \
2979 ADD_64(pstats->mac_stx[1].t##_hi, diff.hi, \
2980 pstats->mac_stx[1].t##_lo, diff.lo); \
2981 } while (0)
2982
2983 #define UPDATE_STAT64_NIG(s, t) \
2984 do { \
2985 DIFF_64(diff.hi, new->s##_hi, old->s##_hi, \
2986 diff.lo, new->s##_lo, old->s##_lo); \
2987 ADD_64(estats->t##_hi, diff.hi, \
2988 estats->t##_lo, diff.lo); \
2989 } while (0)
2990
2991 /* sum[hi:lo] += add */
2992 #define ADD_EXTEND_64(s_hi, s_lo, a) \
2993 do { \
2994 s_lo += a; \
2995 s_hi += (s_lo < a) ? 1 : 0; \
2996 } while (0)
2997
2998 #define UPDATE_EXTEND_STAT(s) \
2999 do { \
3000 ADD_EXTEND_64(pstats->mac_stx[1].s##_hi, \
3001 pstats->mac_stx[1].s##_lo, \
3002 new->s); \
3003 } while (0)
3004
3005 #define UPDATE_EXTEND_TSTAT(s, t) \
3006 do { \
3007 diff = le32_to_cpu(tclient->s) - old_tclient->s; \
3008 old_tclient->s = le32_to_cpu(tclient->s); \
3009 ADD_EXTEND_64(fstats->t##_hi, fstats->t##_lo, diff); \
3010 } while (0)
3011
3012 #define UPDATE_EXTEND_XSTAT(s, t) \
3013 do { \
3014 diff = le32_to_cpu(xclient->s) - old_xclient->s; \
3015 old_xclient->s = le32_to_cpu(xclient->s); \
3016 ADD_EXTEND_64(fstats->t##_hi, fstats->t##_lo, diff); \
3017 } while (0)
3018
3019 /*
3020 * General service functions
3021 */
3022
3023 static inline long bnx2x_hilo(u32 *hiref)
3024 {
3025 u32 lo = *(hiref + 1);
3026 #if (BITS_PER_LONG == 64)
3027 u32 hi = *hiref;
3028
3029 return HILO_U64(hi, lo);
3030 #else
3031 return lo;
3032 #endif
3033 }
3034
3035 /*
3036 * Init service functions
3037 */
3038
3039 static void bnx2x_storm_stats_post(struct bnx2x *bp)
3040 {
3041 if (!bp->stats_pending) {
3042 struct eth_query_ramrod_data ramrod_data = {0};
3043 int rc;
3044
3045 ramrod_data.drv_counter = bp->stats_counter++;
3046 ramrod_data.collect_port_1b = bp->port.pmf ? 1 : 0;
3047 ramrod_data.ctr_id_vector = (1 << BP_CL_ID(bp));
3048
3049 rc = bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_STAT_QUERY, 0,
3050 ((u32 *)&ramrod_data)[1],
3051 ((u32 *)&ramrod_data)[0], 0);
3052 if (rc == 0) {
3053 /* stats ramrod has it's own slot on the spq */
3054 bp->spq_left++;
3055 bp->stats_pending = 1;
3056 }
3057 }
3058 }
3059
3060 static void bnx2x_stats_init(struct bnx2x *bp)
3061 {
3062 int port = BP_PORT(bp);
3063
3064 bp->executer_idx = 0;
3065 bp->stats_counter = 0;
3066
3067 /* port stats */
3068 if (!BP_NOMCP(bp))
3069 bp->port.port_stx = SHMEM_RD(bp, port_mb[port].port_stx);
3070 else
3071 bp->port.port_stx = 0;
3072 DP(BNX2X_MSG_STATS, "port_stx 0x%x\n", bp->port.port_stx);
3073
3074 memset(&(bp->port.old_nig_stats), 0, sizeof(struct nig_stats));
3075 bp->port.old_nig_stats.brb_discard =
3076 REG_RD(bp, NIG_REG_STAT0_BRB_DISCARD + port*0x38);
3077 bp->port.old_nig_stats.brb_truncate =
3078 REG_RD(bp, NIG_REG_STAT0_BRB_TRUNCATE + port*0x38);
3079 REG_RD_DMAE(bp, NIG_REG_STAT0_EGRESS_MAC_PKT0 + port*0x50,
3080 &(bp->port.old_nig_stats.egress_mac_pkt0_lo), 2);
3081 REG_RD_DMAE(bp, NIG_REG_STAT0_EGRESS_MAC_PKT1 + port*0x50,
3082 &(bp->port.old_nig_stats.egress_mac_pkt1_lo), 2);
3083
3084 /* function stats */
3085 memset(&bp->dev->stats, 0, sizeof(struct net_device_stats));
3086 memset(&bp->old_tclient, 0, sizeof(struct tstorm_per_client_stats));
3087 memset(&bp->old_xclient, 0, sizeof(struct xstorm_per_client_stats));
3088 memset(&bp->eth_stats, 0, sizeof(struct bnx2x_eth_stats));
3089
3090 bp->stats_state = STATS_STATE_DISABLED;
3091 if (IS_E1HMF(bp) && bp->port.pmf && bp->port.port_stx)
3092 bnx2x_stats_handle(bp, STATS_EVENT_PMF);
3093 }
3094
3095 static void bnx2x_hw_stats_post(struct bnx2x *bp)
3096 {
3097 struct dmae_command *dmae = &bp->stats_dmae;
3098 u32 *stats_comp = bnx2x_sp(bp, stats_comp);
3099
3100 *stats_comp = DMAE_COMP_VAL;
3101
3102 /* loader */
3103 if (bp->executer_idx) {
3104 int loader_idx = PMF_DMAE_C(bp);
3105
3106 memset(dmae, 0, sizeof(struct dmae_command));
3107
3108 dmae->opcode = (DMAE_CMD_SRC_PCI | DMAE_CMD_DST_GRC |
3109 DMAE_CMD_C_DST_GRC | DMAE_CMD_C_ENABLE |
3110 DMAE_CMD_DST_RESET |
3111 #ifdef __BIG_ENDIAN
3112 DMAE_CMD_ENDIANITY_B_DW_SWAP |
3113 #else
3114 DMAE_CMD_ENDIANITY_DW_SWAP |
3115 #endif
3116 (BP_PORT(bp) ? DMAE_CMD_PORT_1 :
3117 DMAE_CMD_PORT_0) |
3118 (BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT));
3119 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, dmae[0]));
3120 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, dmae[0]));
3121 dmae->dst_addr_lo = (DMAE_REG_CMD_MEM +
3122 sizeof(struct dmae_command) *
3123 (loader_idx + 1)) >> 2;
3124 dmae->dst_addr_hi = 0;
3125 dmae->len = sizeof(struct dmae_command) >> 2;
3126 if (CHIP_IS_E1(bp))
3127 dmae->len--;
3128 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx + 1] >> 2;
3129 dmae->comp_addr_hi = 0;
3130 dmae->comp_val = 1;
3131
3132 *stats_comp = 0;
3133 bnx2x_post_dmae(bp, dmae, loader_idx);
3134
3135 } else if (bp->func_stx) {
3136 *stats_comp = 0;
3137 bnx2x_post_dmae(bp, dmae, INIT_DMAE_C(bp));
3138 }
3139 }
3140
3141 static int bnx2x_stats_comp(struct bnx2x *bp)
3142 {
3143 u32 *stats_comp = bnx2x_sp(bp, stats_comp);
3144 int cnt = 10;
3145
3146 might_sleep();
3147 while (*stats_comp != DMAE_COMP_VAL) {
3148 if (!cnt) {
3149 BNX2X_ERR("timeout waiting for stats finished\n");
3150 break;
3151 }
3152 cnt--;
3153 msleep(1);
3154 }
3155 return 1;
3156 }
3157
3158 /*
3159 * Statistics service functions
3160 */
3161
3162 static void bnx2x_stats_pmf_update(struct bnx2x *bp)
3163 {
3164 struct dmae_command *dmae;
3165 u32 opcode;
3166 int loader_idx = PMF_DMAE_C(bp);
3167 u32 *stats_comp = bnx2x_sp(bp, stats_comp);
3168
3169 /* sanity */
3170 if (!IS_E1HMF(bp) || !bp->port.pmf || !bp->port.port_stx) {
3171 BNX2X_ERR("BUG!\n");
3172 return;
3173 }
3174
3175 bp->executer_idx = 0;
3176
3177 opcode = (DMAE_CMD_SRC_GRC | DMAE_CMD_DST_PCI |
3178 DMAE_CMD_C_ENABLE |
3179 DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
3180 #ifdef __BIG_ENDIAN
3181 DMAE_CMD_ENDIANITY_B_DW_SWAP |
3182 #else
3183 DMAE_CMD_ENDIANITY_DW_SWAP |
3184 #endif
3185 (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
3186 (BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT));
3187
3188 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3189 dmae->opcode = (opcode | DMAE_CMD_C_DST_GRC);
3190 dmae->src_addr_lo = bp->port.port_stx >> 2;
3191 dmae->src_addr_hi = 0;
3192 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, port_stats));
3193 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, port_stats));
3194 dmae->len = DMAE_LEN32_RD_MAX;
3195 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3196 dmae->comp_addr_hi = 0;
3197 dmae->comp_val = 1;
3198
3199 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3200 dmae->opcode = (opcode | DMAE_CMD_C_DST_PCI);
3201 dmae->src_addr_lo = (bp->port.port_stx >> 2) + DMAE_LEN32_RD_MAX;
3202 dmae->src_addr_hi = 0;
3203 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, port_stats) +
3204 DMAE_LEN32_RD_MAX * 4);
3205 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, port_stats) +
3206 DMAE_LEN32_RD_MAX * 4);
3207 dmae->len = (sizeof(struct host_port_stats) >> 2) - DMAE_LEN32_RD_MAX;
3208 dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, stats_comp));
3209 dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, stats_comp));
3210 dmae->comp_val = DMAE_COMP_VAL;
3211
3212 *stats_comp = 0;
3213 bnx2x_hw_stats_post(bp);
3214 bnx2x_stats_comp(bp);
3215 }
3216
3217 static void bnx2x_port_stats_init(struct bnx2x *bp)
3218 {
3219 struct dmae_command *dmae;
3220 int port = BP_PORT(bp);
3221 int vn = BP_E1HVN(bp);
3222 u32 opcode;
3223 int loader_idx = PMF_DMAE_C(bp);
3224 u32 mac_addr;
3225 u32 *stats_comp = bnx2x_sp(bp, stats_comp);
3226
3227 /* sanity */
3228 if (!bp->link_vars.link_up || !bp->port.pmf) {
3229 BNX2X_ERR("BUG!\n");
3230 return;
3231 }
3232
3233 bp->executer_idx = 0;
3234
3235 /* MCP */
3236 opcode = (DMAE_CMD_SRC_PCI | DMAE_CMD_DST_GRC |
3237 DMAE_CMD_C_DST_GRC | DMAE_CMD_C_ENABLE |
3238 DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
3239 #ifdef __BIG_ENDIAN
3240 DMAE_CMD_ENDIANITY_B_DW_SWAP |
3241 #else
3242 DMAE_CMD_ENDIANITY_DW_SWAP |
3243 #endif
3244 (port ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
3245 (vn << DMAE_CMD_E1HVN_SHIFT));
3246
3247 if (bp->port.port_stx) {
3248
3249 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3250 dmae->opcode = opcode;
3251 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, port_stats));
3252 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, port_stats));
3253 dmae->dst_addr_lo = bp->port.port_stx >> 2;
3254 dmae->dst_addr_hi = 0;
3255 dmae->len = sizeof(struct host_port_stats) >> 2;
3256 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3257 dmae->comp_addr_hi = 0;
3258 dmae->comp_val = 1;
3259 }
3260
3261 if (bp->func_stx) {
3262
3263 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3264 dmae->opcode = opcode;
3265 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, func_stats));
3266 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, func_stats));
3267 dmae->dst_addr_lo = bp->func_stx >> 2;
3268 dmae->dst_addr_hi = 0;
3269 dmae->len = sizeof(struct host_func_stats) >> 2;
3270 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3271 dmae->comp_addr_hi = 0;
3272 dmae->comp_val = 1;
3273 }
3274
3275 /* MAC */
3276 opcode = (DMAE_CMD_SRC_GRC | DMAE_CMD_DST_PCI |
3277 DMAE_CMD_C_DST_GRC | DMAE_CMD_C_ENABLE |
3278 DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
3279 #ifdef __BIG_ENDIAN
3280 DMAE_CMD_ENDIANITY_B_DW_SWAP |
3281 #else
3282 DMAE_CMD_ENDIANITY_DW_SWAP |
3283 #endif
3284 (port ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
3285 (vn << DMAE_CMD_E1HVN_SHIFT));
3286
3287 if (bp->link_vars.mac_type == MAC_TYPE_BMAC) {
3288
3289 mac_addr = (port ? NIG_REG_INGRESS_BMAC1_MEM :
3290 NIG_REG_INGRESS_BMAC0_MEM);
3291
3292 /* BIGMAC_REGISTER_TX_STAT_GTPKT ..
3293 BIGMAC_REGISTER_TX_STAT_GTBYT */
3294 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3295 dmae->opcode = opcode;
3296 dmae->src_addr_lo = (mac_addr +
3297 BIGMAC_REGISTER_TX_STAT_GTPKT) >> 2;
3298 dmae->src_addr_hi = 0;
3299 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats));
3300 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats));
3301 dmae->len = (8 + BIGMAC_REGISTER_TX_STAT_GTBYT -
3302 BIGMAC_REGISTER_TX_STAT_GTPKT) >> 2;
3303 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3304 dmae->comp_addr_hi = 0;
3305 dmae->comp_val = 1;
3306
3307 /* BIGMAC_REGISTER_RX_STAT_GR64 ..
3308 BIGMAC_REGISTER_RX_STAT_GRIPJ */
3309 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3310 dmae->opcode = opcode;
3311 dmae->src_addr_lo = (mac_addr +
3312 BIGMAC_REGISTER_RX_STAT_GR64) >> 2;
3313 dmae->src_addr_hi = 0;
3314 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats) +
3315 offsetof(struct bmac_stats, rx_stat_gr64_lo));
3316 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats) +
3317 offsetof(struct bmac_stats, rx_stat_gr64_lo));
3318 dmae->len = (8 + BIGMAC_REGISTER_RX_STAT_GRIPJ -
3319 BIGMAC_REGISTER_RX_STAT_GR64) >> 2;
3320 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3321 dmae->comp_addr_hi = 0;
3322 dmae->comp_val = 1;
3323
3324 } else if (bp->link_vars.mac_type == MAC_TYPE_EMAC) {
3325
3326 mac_addr = (port ? GRCBASE_EMAC1 : GRCBASE_EMAC0);
3327
3328 /* EMAC_REG_EMAC_RX_STAT_AC (EMAC_REG_EMAC_RX_STAT_AC_COUNT)*/
3329 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3330 dmae->opcode = opcode;
3331 dmae->src_addr_lo = (mac_addr +
3332 EMAC_REG_EMAC_RX_STAT_AC) >> 2;
3333 dmae->src_addr_hi = 0;
3334 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats));
3335 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats));
3336 dmae->len = EMAC_REG_EMAC_RX_STAT_AC_COUNT;
3337 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3338 dmae->comp_addr_hi = 0;
3339 dmae->comp_val = 1;
3340
3341 /* EMAC_REG_EMAC_RX_STAT_AC_28 */
3342 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3343 dmae->opcode = opcode;
3344 dmae->src_addr_lo = (mac_addr +
3345 EMAC_REG_EMAC_RX_STAT_AC_28) >> 2;
3346 dmae->src_addr_hi = 0;
3347 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats) +
3348 offsetof(struct emac_stats, rx_stat_falsecarriererrors));
3349 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats) +
3350 offsetof(struct emac_stats, rx_stat_falsecarriererrors));
3351 dmae->len = 1;
3352 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3353 dmae->comp_addr_hi = 0;
3354 dmae->comp_val = 1;
3355
3356 /* EMAC_REG_EMAC_TX_STAT_AC (EMAC_REG_EMAC_TX_STAT_AC_COUNT)*/
3357 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3358 dmae->opcode = opcode;
3359 dmae->src_addr_lo = (mac_addr +
3360 EMAC_REG_EMAC_TX_STAT_AC) >> 2;
3361 dmae->src_addr_hi = 0;
3362 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats) +
3363 offsetof(struct emac_stats, tx_stat_ifhcoutoctets));
3364 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats) +
3365 offsetof(struct emac_stats, tx_stat_ifhcoutoctets));
3366 dmae->len = EMAC_REG_EMAC_TX_STAT_AC_COUNT;
3367 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3368 dmae->comp_addr_hi = 0;
3369 dmae->comp_val = 1;
3370 }
3371
3372 /* NIG */
3373 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3374 dmae->opcode = opcode;
3375 dmae->src_addr_lo = (port ? NIG_REG_STAT1_BRB_DISCARD :
3376 NIG_REG_STAT0_BRB_DISCARD) >> 2;
3377 dmae->src_addr_hi = 0;
3378 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig_stats));
3379 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig_stats));
3380 dmae->len = (sizeof(struct nig_stats) - 4*sizeof(u32)) >> 2;
3381 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3382 dmae->comp_addr_hi = 0;
3383 dmae->comp_val = 1;
3384
3385 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3386 dmae->opcode = opcode;
3387 dmae->src_addr_lo = (port ? NIG_REG_STAT1_EGRESS_MAC_PKT0 :
3388 NIG_REG_STAT0_EGRESS_MAC_PKT0) >> 2;
3389 dmae->src_addr_hi = 0;
3390 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig_stats) +
3391 offsetof(struct nig_stats, egress_mac_pkt0_lo));
3392 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig_stats) +
3393 offsetof(struct nig_stats, egress_mac_pkt0_lo));
3394 dmae->len = (2*sizeof(u32)) >> 2;
3395 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3396 dmae->comp_addr_hi = 0;
3397 dmae->comp_val = 1;
3398
3399 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3400 dmae->opcode = (DMAE_CMD_SRC_GRC | DMAE_CMD_DST_PCI |
3401 DMAE_CMD_C_DST_PCI | DMAE_CMD_C_ENABLE |
3402 DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
3403 #ifdef __BIG_ENDIAN
3404 DMAE_CMD_ENDIANITY_B_DW_SWAP |
3405 #else
3406 DMAE_CMD_ENDIANITY_DW_SWAP |
3407 #endif
3408 (port ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
3409 (vn << DMAE_CMD_E1HVN_SHIFT));
3410 dmae->src_addr_lo = (port ? NIG_REG_STAT1_EGRESS_MAC_PKT1 :
3411 NIG_REG_STAT0_EGRESS_MAC_PKT1) >> 2;
3412 dmae->src_addr_hi = 0;
3413 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig_stats) +
3414 offsetof(struct nig_stats, egress_mac_pkt1_lo));
3415 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig_stats) +
3416 offsetof(struct nig_stats, egress_mac_pkt1_lo));
3417 dmae->len = (2*sizeof(u32)) >> 2;
3418 dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, stats_comp));
3419 dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, stats_comp));
3420 dmae->comp_val = DMAE_COMP_VAL;
3421
3422 *stats_comp = 0;
3423 }
3424
3425 static void bnx2x_func_stats_init(struct bnx2x *bp)
3426 {
3427 struct dmae_command *dmae = &bp->stats_dmae;
3428 u32 *stats_comp = bnx2x_sp(bp, stats_comp);
3429
3430 /* sanity */
3431 if (!bp->func_stx) {
3432 BNX2X_ERR("BUG!\n");
3433 return;
3434 }
3435
3436 bp->executer_idx = 0;
3437 memset(dmae, 0, sizeof(struct dmae_command));
3438
3439 dmae->opcode = (DMAE_CMD_SRC_PCI | DMAE_CMD_DST_GRC |
3440 DMAE_CMD_C_DST_PCI | DMAE_CMD_C_ENABLE |
3441 DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
3442 #ifdef __BIG_ENDIAN
3443 DMAE_CMD_ENDIANITY_B_DW_SWAP |
3444 #else
3445 DMAE_CMD_ENDIANITY_DW_SWAP |
3446 #endif
3447 (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
3448 (BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT));
3449 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, func_stats));
3450 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, func_stats));
3451 dmae->dst_addr_lo = bp->func_stx >> 2;
3452 dmae->dst_addr_hi = 0;
3453 dmae->len = sizeof(struct host_func_stats) >> 2;
3454 dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, stats_comp));
3455 dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, stats_comp));
3456 dmae->comp_val = DMAE_COMP_VAL;
3457
3458 *stats_comp = 0;
3459 }
3460
3461 static void bnx2x_stats_start(struct bnx2x *bp)
3462 {
3463 if (bp->port.pmf)
3464 bnx2x_port_stats_init(bp);
3465
3466 else if (bp->func_stx)
3467 bnx2x_func_stats_init(bp);
3468
3469 bnx2x_hw_stats_post(bp);
3470 bnx2x_storm_stats_post(bp);
3471 }
3472
3473 static void bnx2x_stats_pmf_start(struct bnx2x *bp)
3474 {
3475 bnx2x_stats_comp(bp);
3476 bnx2x_stats_pmf_update(bp);
3477 bnx2x_stats_start(bp);
3478 }
3479
3480 static void bnx2x_stats_restart(struct bnx2x *bp)
3481 {
3482 bnx2x_stats_comp(bp);
3483 bnx2x_stats_start(bp);
3484 }
3485
3486 static void bnx2x_bmac_stats_update(struct bnx2x *bp)
3487 {
3488 struct bmac_stats *new = bnx2x_sp(bp, mac_stats.bmac_stats);
3489 struct host_port_stats *pstats = bnx2x_sp(bp, port_stats);
3490 struct regpair diff;
3491
3492 UPDATE_STAT64(rx_stat_grerb, rx_stat_ifhcinbadoctets);
3493 UPDATE_STAT64(rx_stat_grfcs, rx_stat_dot3statsfcserrors);
3494 UPDATE_STAT64(rx_stat_grund, rx_stat_etherstatsundersizepkts);
3495 UPDATE_STAT64(rx_stat_grovr, rx_stat_dot3statsframestoolong);
3496 UPDATE_STAT64(rx_stat_grfrg, rx_stat_etherstatsfragments);
3497 UPDATE_STAT64(rx_stat_grjbr, rx_stat_etherstatsjabbers);
3498 UPDATE_STAT64(rx_stat_grxcf, rx_stat_maccontrolframesreceived);
3499 UPDATE_STAT64(rx_stat_grxpf, rx_stat_xoffstateentered);
3500 UPDATE_STAT64(rx_stat_grxpf, rx_stat_xoffpauseframesreceived);
3501 UPDATE_STAT64(tx_stat_gtxpf, tx_stat_outxoffsent);
3502 UPDATE_STAT64(tx_stat_gtxpf, tx_stat_flowcontroldone);
3503 UPDATE_STAT64(tx_stat_gt64, tx_stat_etherstatspkts64octets);
3504 UPDATE_STAT64(tx_stat_gt127,
3505 tx_stat_etherstatspkts65octetsto127octets);
3506 UPDATE_STAT64(tx_stat_gt255,
3507 tx_stat_etherstatspkts128octetsto255octets);
3508 UPDATE_STAT64(tx_stat_gt511,
3509 tx_stat_etherstatspkts256octetsto511octets);
3510 UPDATE_STAT64(tx_stat_gt1023,
3511 tx_stat_etherstatspkts512octetsto1023octets);
3512 UPDATE_STAT64(tx_stat_gt1518,
3513 tx_stat_etherstatspkts1024octetsto1522octets);
3514 UPDATE_STAT64(tx_stat_gt2047, tx_stat_bmac_2047);
3515 UPDATE_STAT64(tx_stat_gt4095, tx_stat_bmac_4095);
3516 UPDATE_STAT64(tx_stat_gt9216, tx_stat_bmac_9216);
3517 UPDATE_STAT64(tx_stat_gt16383, tx_stat_bmac_16383);
3518 UPDATE_STAT64(tx_stat_gterr,
3519 tx_stat_dot3statsinternalmactransmiterrors);
3520 UPDATE_STAT64(tx_stat_gtufl, tx_stat_bmac_ufl);
3521 }
3522
3523 static void bnx2x_emac_stats_update(struct bnx2x *bp)
3524 {
3525 struct emac_stats *new = bnx2x_sp(bp, mac_stats.emac_stats);
3526 struct host_port_stats *pstats = bnx2x_sp(bp, port_stats);
3527
3528 UPDATE_EXTEND_STAT(rx_stat_ifhcinbadoctets);
3529 UPDATE_EXTEND_STAT(tx_stat_ifhcoutbadoctets);
3530 UPDATE_EXTEND_STAT(rx_stat_dot3statsfcserrors);
3531 UPDATE_EXTEND_STAT(rx_stat_dot3statsalignmenterrors);
3532 UPDATE_EXTEND_STAT(rx_stat_dot3statscarriersenseerrors);
3533 UPDATE_EXTEND_STAT(rx_stat_falsecarriererrors);
3534 UPDATE_EXTEND_STAT(rx_stat_etherstatsundersizepkts);
3535 UPDATE_EXTEND_STAT(rx_stat_dot3statsframestoolong);
3536 UPDATE_EXTEND_STAT(rx_stat_etherstatsfragments);
3537 UPDATE_EXTEND_STAT(rx_stat_etherstatsjabbers);
3538 UPDATE_EXTEND_STAT(rx_stat_maccontrolframesreceived);
3539 UPDATE_EXTEND_STAT(rx_stat_xoffstateentered);
3540 UPDATE_EXTEND_STAT(rx_stat_xonpauseframesreceived);
3541 UPDATE_EXTEND_STAT(rx_stat_xoffpauseframesreceived);
3542 UPDATE_EXTEND_STAT(tx_stat_outxonsent);
3543 UPDATE_EXTEND_STAT(tx_stat_outxoffsent);
3544 UPDATE_EXTEND_STAT(tx_stat_flowcontroldone);
3545 UPDATE_EXTEND_STAT(tx_stat_etherstatscollisions);
3546 UPDATE_EXTEND_STAT(tx_stat_dot3statssinglecollisionframes);
3547 UPDATE_EXTEND_STAT(tx_stat_dot3statsmultiplecollisionframes);
3548 UPDATE_EXTEND_STAT(tx_stat_dot3statsdeferredtransmissions);
3549 UPDATE_EXTEND_STAT(tx_stat_dot3statsexcessivecollisions);
3550 UPDATE_EXTEND_STAT(tx_stat_dot3statslatecollisions);
3551 UPDATE_EXTEND_STAT(tx_stat_etherstatspkts64octets);
3552 UPDATE_EXTEND_STAT(tx_stat_etherstatspkts65octetsto127octets);
3553 UPDATE_EXTEND_STAT(tx_stat_etherstatspkts128octetsto255octets);
3554 UPDATE_EXTEND_STAT(tx_stat_etherstatspkts256octetsto511octets);
3555 UPDATE_EXTEND_STAT(tx_stat_etherstatspkts512octetsto1023octets);
3556 UPDATE_EXTEND_STAT(tx_stat_etherstatspkts1024octetsto1522octets);
3557 UPDATE_EXTEND_STAT(tx_stat_etherstatspktsover1522octets);
3558 UPDATE_EXTEND_STAT(tx_stat_dot3statsinternalmactransmiterrors);
3559 }
3560
3561 static int bnx2x_hw_stats_update(struct bnx2x *bp)
3562 {
3563 struct nig_stats *new = bnx2x_sp(bp, nig_stats);
3564 struct nig_stats *old = &(bp->port.old_nig_stats);
3565 struct host_port_stats *pstats = bnx2x_sp(bp, port_stats);
3566 struct bnx2x_eth_stats *estats = &bp->eth_stats;
3567 struct regpair diff;
3568
3569 if (bp->link_vars.mac_type == MAC_TYPE_BMAC)
3570 bnx2x_bmac_stats_update(bp);
3571
3572 else if (bp->link_vars.mac_type == MAC_TYPE_EMAC)
3573 bnx2x_emac_stats_update(bp);
3574
3575 else { /* unreached */
3576 BNX2X_ERR("stats updated by dmae but no MAC active\n");
3577 return -1;
3578 }
3579
3580 ADD_EXTEND_64(pstats->brb_drop_hi, pstats->brb_drop_lo,
3581 new->brb_discard - old->brb_discard);
3582 ADD_EXTEND_64(estats->brb_truncate_hi, estats->brb_truncate_lo,
3583 new->brb_truncate - old->brb_truncate);
3584
3585 UPDATE_STAT64_NIG(egress_mac_pkt0,
3586 etherstatspkts1024octetsto1522octets);
3587 UPDATE_STAT64_NIG(egress_mac_pkt1, etherstatspktsover1522octets);
3588
3589 memcpy(old, new, sizeof(struct nig_stats));
3590
3591 memcpy(&(estats->rx_stat_ifhcinbadoctets_hi), &(pstats->mac_stx[1]),
3592 sizeof(struct mac_stx));
3593 estats->brb_drop_hi = pstats->brb_drop_hi;
3594 estats->brb_drop_lo = pstats->brb_drop_lo;
3595
3596 pstats->host_port_stats_start = ++pstats->host_port_stats_end;
3597
3598 return 0;
3599 }
3600
3601 static int bnx2x_storm_stats_update(struct bnx2x *bp)
3602 {
3603 struct eth_stats_query *stats = bnx2x_sp(bp, fw_stats);
3604 int cl_id = BP_CL_ID(bp);
3605 struct tstorm_per_port_stats *tport =
3606 &stats->tstorm_common.port_statistics;
3607 struct tstorm_per_client_stats *tclient =
3608 &stats->tstorm_common.client_statistics[cl_id];
3609 struct tstorm_per_client_stats *old_tclient = &bp->old_tclient;
3610 struct xstorm_per_client_stats *xclient =
3611 &stats->xstorm_common.client_statistics[cl_id];
3612 struct xstorm_per_client_stats *old_xclient = &bp->old_xclient;
3613 struct host_func_stats *fstats = bnx2x_sp(bp, func_stats);
3614 struct bnx2x_eth_stats *estats = &bp->eth_stats;
3615 u32 diff;
3616
3617 /* are storm stats valid? */
3618 if ((u16)(le16_to_cpu(tclient->stats_counter) + 1) !=
3619 bp->stats_counter) {
3620 DP(BNX2X_MSG_STATS, "stats not updated by tstorm"
3621 " tstorm counter (%d) != stats_counter (%d)\n",
3622 tclient->stats_counter, bp->stats_counter);
3623 return -1;
3624 }
3625 if ((u16)(le16_to_cpu(xclient->stats_counter) + 1) !=
3626 bp->stats_counter) {
3627 DP(BNX2X_MSG_STATS, "stats not updated by xstorm"
3628 " xstorm counter (%d) != stats_counter (%d)\n",
3629 xclient->stats_counter, bp->stats_counter);
3630 return -2;
3631 }
3632
3633 fstats->total_bytes_received_hi =
3634 fstats->valid_bytes_received_hi =
3635 le32_to_cpu(tclient->total_rcv_bytes.hi);
3636 fstats->total_bytes_received_lo =
3637 fstats->valid_bytes_received_lo =
3638 le32_to_cpu(tclient->total_rcv_bytes.lo);
3639
3640 estats->error_bytes_received_hi =
3641 le32_to_cpu(tclient->rcv_error_bytes.hi);
3642 estats->error_bytes_received_lo =
3643 le32_to_cpu(tclient->rcv_error_bytes.lo);
3644 ADD_64(estats->error_bytes_received_hi,
3645 estats->rx_stat_ifhcinbadoctets_hi,
3646 estats->error_bytes_received_lo,
3647 estats->rx_stat_ifhcinbadoctets_lo);
3648
3649 ADD_64(fstats->total_bytes_received_hi,
3650 estats->error_bytes_received_hi,
3651 fstats->total_bytes_received_lo,
3652 estats->error_bytes_received_lo);
3653
3654 UPDATE_EXTEND_TSTAT(rcv_unicast_pkts, total_unicast_packets_received);
3655 UPDATE_EXTEND_TSTAT(rcv_multicast_pkts,
3656 total_multicast_packets_received);
3657 UPDATE_EXTEND_TSTAT(rcv_broadcast_pkts,
3658 total_broadcast_packets_received);
3659
3660 fstats->total_bytes_transmitted_hi =
3661 le32_to_cpu(xclient->total_sent_bytes.hi);
3662 fstats->total_bytes_transmitted_lo =
3663 le32_to_cpu(xclient->total_sent_bytes.lo);
3664
3665 UPDATE_EXTEND_XSTAT(unicast_pkts_sent,
3666 total_unicast_packets_transmitted);
3667 UPDATE_EXTEND_XSTAT(multicast_pkts_sent,
3668 total_multicast_packets_transmitted);
3669 UPDATE_EXTEND_XSTAT(broadcast_pkts_sent,
3670 total_broadcast_packets_transmitted);
3671
3672 memcpy(estats, &(fstats->total_bytes_received_hi),
3673 sizeof(struct host_func_stats) - 2*sizeof(u32));
3674
3675 estats->mac_filter_discard = le32_to_cpu(tport->mac_filter_discard);
3676 estats->xxoverflow_discard = le32_to_cpu(tport->xxoverflow_discard);
3677 estats->brb_truncate_discard =
3678 le32_to_cpu(tport->brb_truncate_discard);
3679 estats->mac_discard = le32_to_cpu(tport->mac_discard);
3680
3681 old_tclient->rcv_unicast_bytes.hi =
3682 le32_to_cpu(tclient->rcv_unicast_bytes.hi);
3683 old_tclient->rcv_unicast_bytes.lo =
3684 le32_to_cpu(tclient->rcv_unicast_bytes.lo);
3685 old_tclient->rcv_broadcast_bytes.hi =
3686 le32_to_cpu(tclient->rcv_broadcast_bytes.hi);
3687 old_tclient->rcv_broadcast_bytes.lo =
3688 le32_to_cpu(tclient->rcv_broadcast_bytes.lo);
3689 old_tclient->rcv_multicast_bytes.hi =
3690 le32_to_cpu(tclient->rcv_multicast_bytes.hi);
3691 old_tclient->rcv_multicast_bytes.lo =
3692 le32_to_cpu(tclient->rcv_multicast_bytes.lo);
3693 old_tclient->total_rcv_pkts = le32_to_cpu(tclient->total_rcv_pkts);
3694
3695 old_tclient->checksum_discard = le32_to_cpu(tclient->checksum_discard);
3696 old_tclient->packets_too_big_discard =
3697 le32_to_cpu(tclient->packets_too_big_discard);
3698 estats->no_buff_discard =
3699 old_tclient->no_buff_discard = le32_to_cpu(tclient->no_buff_discard);
3700 old_tclient->ttl0_discard = le32_to_cpu(tclient->ttl0_discard);
3701
3702 old_xclient->total_sent_pkts = le32_to_cpu(xclient->total_sent_pkts);
3703 old_xclient->unicast_bytes_sent.hi =
3704 le32_to_cpu(xclient->unicast_bytes_sent.hi);
3705 old_xclient->unicast_bytes_sent.lo =
3706 le32_to_cpu(xclient->unicast_bytes_sent.lo);
3707 old_xclient->multicast_bytes_sent.hi =
3708 le32_to_cpu(xclient->multicast_bytes_sent.hi);
3709 old_xclient->multicast_bytes_sent.lo =
3710 le32_to_cpu(xclient->multicast_bytes_sent.lo);
3711 old_xclient->broadcast_bytes_sent.hi =
3712 le32_to_cpu(xclient->broadcast_bytes_sent.hi);
3713 old_xclient->broadcast_bytes_sent.lo =
3714 le32_to_cpu(xclient->broadcast_bytes_sent.lo);
3715
3716 fstats->host_func_stats_start = ++fstats->host_func_stats_end;
3717
3718 return 0;
3719 }
3720
3721 static void bnx2x_net_stats_update(struct bnx2x *bp)
3722 {
3723 struct tstorm_per_client_stats *old_tclient = &bp->old_tclient;
3724 struct bnx2x_eth_stats *estats = &bp->eth_stats;
3725 struct net_device_stats *nstats = &bp->dev->stats;
3726
3727 nstats->rx_packets =
3728 bnx2x_hilo(&estats->total_unicast_packets_received_hi) +
3729 bnx2x_hilo(&estats->total_multicast_packets_received_hi) +
3730 bnx2x_hilo(&estats->total_broadcast_packets_received_hi);
3731
3732 nstats->tx_packets =
3733 bnx2x_hilo(&estats->total_unicast_packets_transmitted_hi) +
3734 bnx2x_hilo(&estats->total_multicast_packets_transmitted_hi) +
3735 bnx2x_hilo(&estats->total_broadcast_packets_transmitted_hi);
3736
3737 nstats->rx_bytes = bnx2x_hilo(&estats->valid_bytes_received_hi);
3738
3739 nstats->tx_bytes = bnx2x_hilo(&estats->total_bytes_transmitted_hi);
3740
3741 nstats->rx_dropped = old_tclient->checksum_discard +
3742 estats->mac_discard;
3743 nstats->tx_dropped = 0;
3744
3745 nstats->multicast =
3746 bnx2x_hilo(&estats->total_multicast_packets_transmitted_hi);
3747
3748 nstats->collisions =
3749 estats->tx_stat_dot3statssinglecollisionframes_lo +
3750 estats->tx_stat_dot3statsmultiplecollisionframes_lo +
3751 estats->tx_stat_dot3statslatecollisions_lo +
3752 estats->tx_stat_dot3statsexcessivecollisions_lo;
3753
3754 estats->jabber_packets_received =
3755 old_tclient->packets_too_big_discard +
3756 estats->rx_stat_dot3statsframestoolong_lo;
3757
3758 nstats->rx_length_errors =
3759 estats->rx_stat_etherstatsundersizepkts_lo +
3760 estats->jabber_packets_received;
3761 nstats->rx_over_errors = estats->brb_drop_lo + estats->brb_truncate_lo;
3762 nstats->rx_crc_errors = estats->rx_stat_dot3statsfcserrors_lo;
3763 nstats->rx_frame_errors = estats->rx_stat_dot3statsalignmenterrors_lo;
3764 nstats->rx_fifo_errors = old_tclient->no_buff_discard;
3765 nstats->rx_missed_errors = estats->xxoverflow_discard;
3766
3767 nstats->rx_errors = nstats->rx_length_errors +
3768 nstats->rx_over_errors +
3769 nstats->rx_crc_errors +
3770 nstats->rx_frame_errors +
3771 nstats->rx_fifo_errors +
3772 nstats->rx_missed_errors;
3773
3774 nstats->tx_aborted_errors =
3775 estats->tx_stat_dot3statslatecollisions_lo +
3776 estats->tx_stat_dot3statsexcessivecollisions_lo;
3777 nstats->tx_carrier_errors = estats->rx_stat_falsecarriererrors_lo;
3778 nstats->tx_fifo_errors = 0;
3779 nstats->tx_heartbeat_errors = 0;
3780 nstats->tx_window_errors = 0;
3781
3782 nstats->tx_errors = nstats->tx_aborted_errors +
3783 nstats->tx_carrier_errors;
3784 }
3785
3786 static void bnx2x_stats_update(struct bnx2x *bp)
3787 {
3788 u32 *stats_comp = bnx2x_sp(bp, stats_comp);
3789 int update = 0;
3790
3791 if (*stats_comp != DMAE_COMP_VAL)
3792 return;
3793
3794 if (bp->port.pmf)
3795 update = (bnx2x_hw_stats_update(bp) == 0);
3796
3797 update |= (bnx2x_storm_stats_update(bp) == 0);
3798
3799 if (update)
3800 bnx2x_net_stats_update(bp);
3801
3802 else {
3803 if (bp->stats_pending) {
3804 bp->stats_pending++;
3805 if (bp->stats_pending == 3) {
3806 BNX2X_ERR("stats not updated for 3 times\n");
3807 bnx2x_panic();
3808 return;
3809 }
3810 }
3811 }
3812
3813 if (bp->msglevel & NETIF_MSG_TIMER) {
3814 struct tstorm_per_client_stats *old_tclient = &bp->old_tclient;
3815 struct bnx2x_eth_stats *estats = &bp->eth_stats;
3816 struct net_device_stats *nstats = &bp->dev->stats;
3817 int i;
3818
3819 printk(KERN_DEBUG "%s:\n", bp->dev->name);
3820 printk(KERN_DEBUG " tx avail (%4x) tx hc idx (%x)"
3821 " tx pkt (%lx)\n",
3822 bnx2x_tx_avail(bp->fp),
3823 le16_to_cpu(*bp->fp->tx_cons_sb), nstats->tx_packets);
3824 printk(KERN_DEBUG " rx usage (%4x) rx hc idx (%x)"
3825 " rx pkt (%lx)\n",
3826 (u16)(le16_to_cpu(*bp->fp->rx_cons_sb) -
3827 bp->fp->rx_comp_cons),
3828 le16_to_cpu(*bp->fp->rx_cons_sb), nstats->rx_packets);
3829 printk(KERN_DEBUG " %s (Xoff events %u) brb drops %u\n",
3830 netif_queue_stopped(bp->dev) ? "Xoff" : "Xon",
3831 estats->driver_xoff, estats->brb_drop_lo);
3832 printk(KERN_DEBUG "tstats: checksum_discard %u "
3833 "packets_too_big_discard %u no_buff_discard %u "
3834 "mac_discard %u mac_filter_discard %u "
3835 "xxovrflow_discard %u brb_truncate_discard %u "
3836 "ttl0_discard %u\n",
3837 old_tclient->checksum_discard,
3838 old_tclient->packets_too_big_discard,
3839 old_tclient->no_buff_discard, estats->mac_discard,
3840 estats->mac_filter_discard, estats->xxoverflow_discard,
3841 estats->brb_truncate_discard,
3842 old_tclient->ttl0_discard);
3843
3844 for_each_queue(bp, i) {
3845 printk(KERN_DEBUG "[%d]: %lu\t%lu\t%lu\n", i,
3846 bnx2x_fp(bp, i, tx_pkt),
3847 bnx2x_fp(bp, i, rx_pkt),
3848 bnx2x_fp(bp, i, rx_calls));
3849 }
3850 }
3851
3852 bnx2x_hw_stats_post(bp);
3853 bnx2x_storm_stats_post(bp);
3854 }
3855
3856 static void bnx2x_port_stats_stop(struct bnx2x *bp)
3857 {
3858 struct dmae_command *dmae;
3859 u32 opcode;
3860 int loader_idx = PMF_DMAE_C(bp);
3861 u32 *stats_comp = bnx2x_sp(bp, stats_comp);
3862
3863 bp->executer_idx = 0;
3864
3865 opcode = (DMAE_CMD_SRC_PCI | DMAE_CMD_DST_GRC |
3866 DMAE_CMD_C_ENABLE |
3867 DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
3868 #ifdef __BIG_ENDIAN
3869 DMAE_CMD_ENDIANITY_B_DW_SWAP |
3870 #else
3871 DMAE_CMD_ENDIANITY_DW_SWAP |
3872 #endif
3873 (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
3874 (BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT));
3875
3876 if (bp->port.port_stx) {
3877
3878 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3879 if (bp->func_stx)
3880 dmae->opcode = (opcode | DMAE_CMD_C_DST_GRC);
3881 else
3882 dmae->opcode = (opcode | DMAE_CMD_C_DST_PCI);
3883 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, port_stats));
3884 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, port_stats));
3885 dmae->dst_addr_lo = bp->port.port_stx >> 2;
3886 dmae->dst_addr_hi = 0;
3887 dmae->len = sizeof(struct host_port_stats) >> 2;
3888 if (bp->func_stx) {
3889 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3890 dmae->comp_addr_hi = 0;
3891 dmae->comp_val = 1;
3892 } else {
3893 dmae->comp_addr_lo =
3894 U64_LO(bnx2x_sp_mapping(bp, stats_comp));
3895 dmae->comp_addr_hi =
3896 U64_HI(bnx2x_sp_mapping(bp, stats_comp));
3897 dmae->comp_val = DMAE_COMP_VAL;
3898
3899 *stats_comp = 0;
3900 }
3901 }
3902
3903 if (bp->func_stx) {
3904
3905 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3906 dmae->opcode = (opcode | DMAE_CMD_C_DST_PCI);
3907 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, func_stats));
3908 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, func_stats));
3909 dmae->dst_addr_lo = bp->func_stx >> 2;
3910 dmae->dst_addr_hi = 0;
3911 dmae->len = sizeof(struct host_func_stats) >> 2;
3912 dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, stats_comp));
3913 dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, stats_comp));
3914 dmae->comp_val = DMAE_COMP_VAL;
3915
3916 *stats_comp = 0;
3917 }
3918 }
3919
3920 static void bnx2x_stats_stop(struct bnx2x *bp)
3921 {
3922 int update = 0;
3923
3924 bnx2x_stats_comp(bp);
3925
3926 if (bp->port.pmf)
3927 update = (bnx2x_hw_stats_update(bp) == 0);
3928
3929 update |= (bnx2x_storm_stats_update(bp) == 0);
3930
3931 if (update) {
3932 bnx2x_net_stats_update(bp);
3933
3934 if (bp->port.pmf)
3935 bnx2x_port_stats_stop(bp);
3936
3937 bnx2x_hw_stats_post(bp);
3938 bnx2x_stats_comp(bp);
3939 }
3940 }
3941
3942 static void bnx2x_stats_do_nothing(struct bnx2x *bp)
3943 {
3944 }
3945
3946 static const struct {
3947 void (*action)(struct bnx2x *bp);
3948 enum bnx2x_stats_state next_state;
3949 } bnx2x_stats_stm[STATS_STATE_MAX][STATS_EVENT_MAX] = {
3950 /* state event */
3951 {
3952 /* DISABLED PMF */ {bnx2x_stats_pmf_update, STATS_STATE_DISABLED},
3953 /* LINK_UP */ {bnx2x_stats_start, STATS_STATE_ENABLED},
3954 /* UPDATE */ {bnx2x_stats_do_nothing, STATS_STATE_DISABLED},
3955 /* STOP */ {bnx2x_stats_do_nothing, STATS_STATE_DISABLED}
3956 },
3957 {
3958 /* ENABLED PMF */ {bnx2x_stats_pmf_start, STATS_STATE_ENABLED},
3959 /* LINK_UP */ {bnx2x_stats_restart, STATS_STATE_ENABLED},
3960 /* UPDATE */ {bnx2x_stats_update, STATS_STATE_ENABLED},
3961 /* STOP */ {bnx2x_stats_stop, STATS_STATE_DISABLED}
3962 }
3963 };
3964
3965 static void bnx2x_stats_handle(struct bnx2x *bp, enum bnx2x_stats_event event)
3966 {
3967 enum bnx2x_stats_state state = bp->stats_state;
3968
3969 bnx2x_stats_stm[state][event].action(bp);
3970 bp->stats_state = bnx2x_stats_stm[state][event].next_state;
3971
3972 if ((event != STATS_EVENT_UPDATE) || (bp->msglevel & NETIF_MSG_TIMER))
3973 DP(BNX2X_MSG_STATS, "state %d -> event %d -> state %d\n",
3974 state, event, bp->stats_state);
3975 }
3976
3977 static void bnx2x_timer(unsigned long data)
3978 {
3979 struct bnx2x *bp = (struct bnx2x *) data;
3980
3981 if (!netif_running(bp->dev))
3982 return;
3983
3984 if (atomic_read(&bp->intr_sem) != 0)
3985 goto timer_restart;
3986
3987 if (poll) {
3988 struct bnx2x_fastpath *fp = &bp->fp[0];
3989 int rc;
3990
3991 bnx2x_tx_int(fp, 1000);
3992 rc = bnx2x_rx_int(fp, 1000);
3993 }
3994
3995 if (!BP_NOMCP(bp)) {
3996 int func = BP_FUNC(bp);
3997 u32 drv_pulse;
3998 u32 mcp_pulse;
3999
4000 ++bp->fw_drv_pulse_wr_seq;
4001 bp->fw_drv_pulse_wr_seq &= DRV_PULSE_SEQ_MASK;
4002 /* TBD - add SYSTEM_TIME */
4003 drv_pulse = bp->fw_drv_pulse_wr_seq;
4004 SHMEM_WR(bp, func_mb[func].drv_pulse_mb, drv_pulse);
4005
4006 mcp_pulse = (SHMEM_RD(bp, func_mb[func].mcp_pulse_mb) &
4007 MCP_PULSE_SEQ_MASK);
4008 /* The delta between driver pulse and mcp response
4009 * should be 1 (before mcp response) or 0 (after mcp response)
4010 */
4011 if ((drv_pulse != mcp_pulse) &&
4012 (drv_pulse != ((mcp_pulse + 1) & MCP_PULSE_SEQ_MASK))) {
4013 /* someone lost a heartbeat... */
4014 BNX2X_ERR("drv_pulse (0x%x) != mcp_pulse (0x%x)\n",
4015 drv_pulse, mcp_pulse);
4016 }
4017 }
4018
4019 if ((bp->state == BNX2X_STATE_OPEN) ||
4020 (bp->state == BNX2X_STATE_DISABLED))
4021 bnx2x_stats_handle(bp, STATS_EVENT_UPDATE);
4022
4023 timer_restart:
4024 mod_timer(&bp->timer, jiffies + bp->current_interval);
4025 }
4026
4027 /* end of Statistics */
4028
4029 /* nic init */
4030
4031 /*
4032 * nic init service functions
4033 */
4034
4035 static void bnx2x_zero_sb(struct bnx2x *bp, int sb_id)
4036 {
4037 int port = BP_PORT(bp);
4038
4039 bnx2x_init_fill(bp, BAR_USTRORM_INTMEM +
4040 USTORM_SB_HOST_STATUS_BLOCK_OFFSET(port, sb_id), 0,
4041 sizeof(struct ustorm_status_block)/4);
4042 bnx2x_init_fill(bp, BAR_CSTRORM_INTMEM +
4043 CSTORM_SB_HOST_STATUS_BLOCK_OFFSET(port, sb_id), 0,
4044 sizeof(struct cstorm_status_block)/4);
4045 }
4046
4047 static void bnx2x_init_sb(struct bnx2x *bp, struct host_status_block *sb,
4048 dma_addr_t mapping, int sb_id)
4049 {
4050 int port = BP_PORT(bp);
4051 int func = BP_FUNC(bp);
4052 int index;
4053 u64 section;
4054
4055 /* USTORM */
4056 section = ((u64)mapping) + offsetof(struct host_status_block,
4057 u_status_block);
4058 sb->u_status_block.status_block_id = sb_id;
4059
4060 REG_WR(bp, BAR_USTRORM_INTMEM +
4061 USTORM_SB_HOST_SB_ADDR_OFFSET(port, sb_id), U64_LO(section));
4062 REG_WR(bp, BAR_USTRORM_INTMEM +
4063 ((USTORM_SB_HOST_SB_ADDR_OFFSET(port, sb_id)) + 4),
4064 U64_HI(section));
4065 REG_WR8(bp, BAR_USTRORM_INTMEM + FP_USB_FUNC_OFF +
4066 USTORM_SB_HOST_STATUS_BLOCK_OFFSET(port, sb_id), func);
4067
4068 for (index = 0; index < HC_USTORM_SB_NUM_INDICES; index++)
4069 REG_WR16(bp, BAR_USTRORM_INTMEM +
4070 USTORM_SB_HC_DISABLE_OFFSET(port, sb_id, index), 1);
4071
4072 /* CSTORM */
4073 section = ((u64)mapping) + offsetof(struct host_status_block,
4074 c_status_block);
4075 sb->c_status_block.status_block_id = sb_id;
4076
4077 REG_WR(bp, BAR_CSTRORM_INTMEM +
4078 CSTORM_SB_HOST_SB_ADDR_OFFSET(port, sb_id), U64_LO(section));
4079 REG_WR(bp, BAR_CSTRORM_INTMEM +
4080 ((CSTORM_SB_HOST_SB_ADDR_OFFSET(port, sb_id)) + 4),
4081 U64_HI(section));
4082 REG_WR8(bp, BAR_CSTRORM_INTMEM + FP_CSB_FUNC_OFF +
4083 CSTORM_SB_HOST_STATUS_BLOCK_OFFSET(port, sb_id), func);
4084
4085 for (index = 0; index < HC_CSTORM_SB_NUM_INDICES; index++)
4086 REG_WR16(bp, BAR_CSTRORM_INTMEM +
4087 CSTORM_SB_HC_DISABLE_OFFSET(port, sb_id, index), 1);
4088
4089 bnx2x_ack_sb(bp, sb_id, CSTORM_ID, 0, IGU_INT_ENABLE, 0);
4090 }
4091
4092 static void bnx2x_zero_def_sb(struct bnx2x *bp)
4093 {
4094 int func = BP_FUNC(bp);
4095
4096 bnx2x_init_fill(bp, BAR_USTRORM_INTMEM +
4097 USTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), 0,
4098 sizeof(struct ustorm_def_status_block)/4);
4099 bnx2x_init_fill(bp, BAR_CSTRORM_INTMEM +
4100 CSTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), 0,
4101 sizeof(struct cstorm_def_status_block)/4);
4102 bnx2x_init_fill(bp, BAR_XSTRORM_INTMEM +
4103 XSTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), 0,
4104 sizeof(struct xstorm_def_status_block)/4);
4105 bnx2x_init_fill(bp, BAR_TSTRORM_INTMEM +
4106 TSTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), 0,
4107 sizeof(struct tstorm_def_status_block)/4);
4108 }
4109
4110 static void bnx2x_init_def_sb(struct bnx2x *bp,
4111 struct host_def_status_block *def_sb,
4112 dma_addr_t mapping, int sb_id)
4113 {
4114 int port = BP_PORT(bp);
4115 int func = BP_FUNC(bp);
4116 int index, val, reg_offset;
4117 u64 section;
4118
4119 /* ATTN */
4120 section = ((u64)mapping) + offsetof(struct host_def_status_block,
4121 atten_status_block);
4122 def_sb->atten_status_block.status_block_id = sb_id;
4123
4124 bp->attn_state = 0;
4125
4126 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
4127 MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
4128
4129 for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
4130 bp->attn_group[index].sig[0] = REG_RD(bp,
4131 reg_offset + 0x10*index);
4132 bp->attn_group[index].sig[1] = REG_RD(bp,
4133 reg_offset + 0x4 + 0x10*index);
4134 bp->attn_group[index].sig[2] = REG_RD(bp,
4135 reg_offset + 0x8 + 0x10*index);
4136 bp->attn_group[index].sig[3] = REG_RD(bp,
4137 reg_offset + 0xc + 0x10*index);
4138 }
4139
4140 reg_offset = (port ? HC_REG_ATTN_MSG1_ADDR_L :
4141 HC_REG_ATTN_MSG0_ADDR_L);
4142
4143 REG_WR(bp, reg_offset, U64_LO(section));
4144 REG_WR(bp, reg_offset + 4, U64_HI(section));
4145
4146 reg_offset = (port ? HC_REG_ATTN_NUM_P1 : HC_REG_ATTN_NUM_P0);
4147
4148 val = REG_RD(bp, reg_offset);
4149 val |= sb_id;
4150 REG_WR(bp, reg_offset, val);
4151
4152 /* USTORM */
4153 section = ((u64)mapping) + offsetof(struct host_def_status_block,
4154 u_def_status_block);
4155 def_sb->u_def_status_block.status_block_id = sb_id;
4156
4157 REG_WR(bp, BAR_USTRORM_INTMEM +
4158 USTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func), U64_LO(section));
4159 REG_WR(bp, BAR_USTRORM_INTMEM +
4160 ((USTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func)) + 4),
4161 U64_HI(section));
4162 REG_WR8(bp, BAR_USTRORM_INTMEM + DEF_USB_FUNC_OFF +
4163 USTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), func);
4164
4165 for (index = 0; index < HC_USTORM_DEF_SB_NUM_INDICES; index++)
4166 REG_WR16(bp, BAR_USTRORM_INTMEM +
4167 USTORM_DEF_SB_HC_DISABLE_OFFSET(func, index), 1);
4168
4169 /* CSTORM */
4170 section = ((u64)mapping) + offsetof(struct host_def_status_block,
4171 c_def_status_block);
4172 def_sb->c_def_status_block.status_block_id = sb_id;
4173
4174 REG_WR(bp, BAR_CSTRORM_INTMEM +
4175 CSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func), U64_LO(section));
4176 REG_WR(bp, BAR_CSTRORM_INTMEM +
4177 ((CSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func)) + 4),
4178 U64_HI(section));
4179 REG_WR8(bp, BAR_CSTRORM_INTMEM + DEF_CSB_FUNC_OFF +
4180 CSTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), func);
4181
4182 for (index = 0; index < HC_CSTORM_DEF_SB_NUM_INDICES; index++)
4183 REG_WR16(bp, BAR_CSTRORM_INTMEM +
4184 CSTORM_DEF_SB_HC_DISABLE_OFFSET(func, index), 1);
4185
4186 /* TSTORM */
4187 section = ((u64)mapping) + offsetof(struct host_def_status_block,
4188 t_def_status_block);
4189 def_sb->t_def_status_block.status_block_id = sb_id;
4190
4191 REG_WR(bp, BAR_TSTRORM_INTMEM +
4192 TSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func), U64_LO(section));
4193 REG_WR(bp, BAR_TSTRORM_INTMEM +
4194 ((TSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func)) + 4),
4195 U64_HI(section));
4196 REG_WR8(bp, BAR_TSTRORM_INTMEM + DEF_TSB_FUNC_OFF +
4197 TSTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), func);
4198
4199 for (index = 0; index < HC_TSTORM_DEF_SB_NUM_INDICES; index++)
4200 REG_WR16(bp, BAR_TSTRORM_INTMEM +
4201 TSTORM_DEF_SB_HC_DISABLE_OFFSET(func, index), 1);
4202
4203 /* XSTORM */
4204 section = ((u64)mapping) + offsetof(struct host_def_status_block,
4205 x_def_status_block);
4206 def_sb->x_def_status_block.status_block_id = sb_id;
4207
4208 REG_WR(bp, BAR_XSTRORM_INTMEM +
4209 XSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func), U64_LO(section));
4210 REG_WR(bp, BAR_XSTRORM_INTMEM +
4211 ((XSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func)) + 4),
4212 U64_HI(section));
4213 REG_WR8(bp, BAR_XSTRORM_INTMEM + DEF_XSB_FUNC_OFF +
4214 XSTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), func);
4215
4216 for (index = 0; index < HC_XSTORM_DEF_SB_NUM_INDICES; index++)
4217 REG_WR16(bp, BAR_XSTRORM_INTMEM +
4218 XSTORM_DEF_SB_HC_DISABLE_OFFSET(func, index), 1);
4219
4220 bp->stats_pending = 0;
4221 bp->set_mac_pending = 0;
4222
4223 bnx2x_ack_sb(bp, sb_id, CSTORM_ID, 0, IGU_INT_ENABLE, 0);
4224 }
4225
4226 static void bnx2x_update_coalesce(struct bnx2x *bp)
4227 {
4228 int port = BP_PORT(bp);
4229 int i;
4230
4231 for_each_queue(bp, i) {
4232 int sb_id = bp->fp[i].sb_id;
4233
4234 /* HC_INDEX_U_ETH_RX_CQ_CONS */
4235 REG_WR8(bp, BAR_USTRORM_INTMEM +
4236 USTORM_SB_HC_TIMEOUT_OFFSET(port, sb_id,
4237 U_SB_ETH_RX_CQ_INDEX),
4238 bp->rx_ticks/12);
4239 REG_WR16(bp, BAR_USTRORM_INTMEM +
4240 USTORM_SB_HC_DISABLE_OFFSET(port, sb_id,
4241 U_SB_ETH_RX_CQ_INDEX),
4242 bp->rx_ticks ? 0 : 1);
4243 REG_WR16(bp, BAR_USTRORM_INTMEM +
4244 USTORM_SB_HC_DISABLE_OFFSET(port, sb_id,
4245 U_SB_ETH_RX_BD_INDEX),
4246 bp->rx_ticks ? 0 : 1);
4247
4248 /* HC_INDEX_C_ETH_TX_CQ_CONS */
4249 REG_WR8(bp, BAR_CSTRORM_INTMEM +
4250 CSTORM_SB_HC_TIMEOUT_OFFSET(port, sb_id,
4251 C_SB_ETH_TX_CQ_INDEX),
4252 bp->tx_ticks/12);
4253 REG_WR16(bp, BAR_CSTRORM_INTMEM +
4254 CSTORM_SB_HC_DISABLE_OFFSET(port, sb_id,
4255 C_SB_ETH_TX_CQ_INDEX),
4256 bp->tx_ticks ? 0 : 1);
4257 }
4258 }
4259
4260 static inline void bnx2x_free_tpa_pool(struct bnx2x *bp,
4261 struct bnx2x_fastpath *fp, int last)
4262 {
4263 int i;
4264
4265 for (i = 0; i < last; i++) {
4266 struct sw_rx_bd *rx_buf = &(fp->tpa_pool[i]);
4267 struct sk_buff *skb = rx_buf->skb;
4268
4269 if (skb == NULL) {
4270 DP(NETIF_MSG_IFDOWN, "tpa bin %d empty on free\n", i);
4271 continue;
4272 }
4273
4274 if (fp->tpa_state[i] == BNX2X_TPA_START)
4275 pci_unmap_single(bp->pdev,
4276 pci_unmap_addr(rx_buf, mapping),
4277 bp->rx_buf_size,
4278 PCI_DMA_FROMDEVICE);
4279
4280 dev_kfree_skb(skb);
4281 rx_buf->skb = NULL;
4282 }
4283 }
4284
4285 static void bnx2x_init_rx_rings(struct bnx2x *bp)
4286 {
4287 int func = BP_FUNC(bp);
4288 int max_agg_queues = CHIP_IS_E1(bp) ? ETH_MAX_AGGREGATION_QUEUES_E1 :
4289 ETH_MAX_AGGREGATION_QUEUES_E1H;
4290 u16 ring_prod, cqe_ring_prod;
4291 int i, j;
4292
4293 bp->rx_buf_size = bp->dev->mtu;
4294 bp->rx_buf_size += bp->rx_offset + ETH_OVREHEAD +
4295 BCM_RX_ETH_PAYLOAD_ALIGN;
4296
4297 if (bp->flags & TPA_ENABLE_FLAG) {
4298 DP(NETIF_MSG_IFUP,
4299 "rx_buf_size %d effective_mtu %d\n",
4300 bp->rx_buf_size, bp->dev->mtu + ETH_OVREHEAD);
4301
4302 for_each_queue(bp, j) {
4303 struct bnx2x_fastpath *fp = &bp->fp[j];
4304
4305 for (i = 0; i < max_agg_queues; i++) {
4306 fp->tpa_pool[i].skb =
4307 netdev_alloc_skb(bp->dev, bp->rx_buf_size);
4308 if (!fp->tpa_pool[i].skb) {
4309 BNX2X_ERR("Failed to allocate TPA "
4310 "skb pool for queue[%d] - "
4311 "disabling TPA on this "
4312 "queue!\n", j);
4313 bnx2x_free_tpa_pool(bp, fp, i);
4314 fp->disable_tpa = 1;
4315 break;
4316 }
4317 pci_unmap_addr_set((struct sw_rx_bd *)
4318 &bp->fp->tpa_pool[i],
4319 mapping, 0);
4320 fp->tpa_state[i] = BNX2X_TPA_STOP;
4321 }
4322 }
4323 }
4324
4325 for_each_queue(bp, j) {
4326 struct bnx2x_fastpath *fp = &bp->fp[j];
4327
4328 fp->rx_bd_cons = 0;
4329 fp->rx_cons_sb = BNX2X_RX_SB_INDEX;
4330 fp->rx_bd_cons_sb = BNX2X_RX_SB_BD_INDEX;
4331
4332 /* "next page" elements initialization */
4333 /* SGE ring */
4334 for (i = 1; i <= NUM_RX_SGE_PAGES; i++) {
4335 struct eth_rx_sge *sge;
4336
4337 sge = &fp->rx_sge_ring[RX_SGE_CNT * i - 2];
4338 sge->addr_hi =
4339 cpu_to_le32(U64_HI(fp->rx_sge_mapping +
4340 BCM_PAGE_SIZE*(i % NUM_RX_SGE_PAGES)));
4341 sge->addr_lo =
4342 cpu_to_le32(U64_LO(fp->rx_sge_mapping +
4343 BCM_PAGE_SIZE*(i % NUM_RX_SGE_PAGES)));
4344 }
4345
4346 bnx2x_init_sge_ring_bit_mask(fp);
4347
4348 /* RX BD ring */
4349 for (i = 1; i <= NUM_RX_RINGS; i++) {
4350 struct eth_rx_bd *rx_bd;
4351
4352 rx_bd = &fp->rx_desc_ring[RX_DESC_CNT * i - 2];
4353 rx_bd->addr_hi =
4354 cpu_to_le32(U64_HI(fp->rx_desc_mapping +
4355 BCM_PAGE_SIZE*(i % NUM_RX_RINGS)));
4356 rx_bd->addr_lo =
4357 cpu_to_le32(U64_LO(fp->rx_desc_mapping +
4358 BCM_PAGE_SIZE*(i % NUM_RX_RINGS)));
4359 }
4360
4361 /* CQ ring */
4362 for (i = 1; i <= NUM_RCQ_RINGS; i++) {
4363 struct eth_rx_cqe_next_page *nextpg;
4364
4365 nextpg = (struct eth_rx_cqe_next_page *)
4366 &fp->rx_comp_ring[RCQ_DESC_CNT * i - 1];
4367 nextpg->addr_hi =
4368 cpu_to_le32(U64_HI(fp->rx_comp_mapping +
4369 BCM_PAGE_SIZE*(i % NUM_RCQ_RINGS)));
4370 nextpg->addr_lo =
4371 cpu_to_le32(U64_LO(fp->rx_comp_mapping +
4372 BCM_PAGE_SIZE*(i % NUM_RCQ_RINGS)));
4373 }
4374
4375 /* Allocate SGEs and initialize the ring elements */
4376 for (i = 0, ring_prod = 0;
4377 i < MAX_RX_SGE_CNT*NUM_RX_SGE_PAGES; i++) {
4378
4379 if (bnx2x_alloc_rx_sge(bp, fp, ring_prod) < 0) {
4380 BNX2X_ERR("was only able to allocate "
4381 "%d rx sges\n", i);
4382 BNX2X_ERR("disabling TPA for queue[%d]\n", j);
4383 /* Cleanup already allocated elements */
4384 bnx2x_free_rx_sge_range(bp, fp, ring_prod);
4385 bnx2x_free_tpa_pool(bp, fp, max_agg_queues);
4386 fp->disable_tpa = 1;
4387 ring_prod = 0;
4388 break;
4389 }
4390 ring_prod = NEXT_SGE_IDX(ring_prod);
4391 }
4392 fp->rx_sge_prod = ring_prod;
4393
4394 /* Allocate BDs and initialize BD ring */
4395 fp->rx_comp_cons = 0;
4396 cqe_ring_prod = ring_prod = 0;
4397 for (i = 0; i < bp->rx_ring_size; i++) {
4398 if (bnx2x_alloc_rx_skb(bp, fp, ring_prod) < 0) {
4399 BNX2X_ERR("was only able to allocate "
4400 "%d rx skbs\n", i);
4401 bp->eth_stats.rx_skb_alloc_failed++;
4402 break;
4403 }
4404 ring_prod = NEXT_RX_IDX(ring_prod);
4405 cqe_ring_prod = NEXT_RCQ_IDX(cqe_ring_prod);
4406 WARN_ON(ring_prod <= i);
4407 }
4408
4409 fp->rx_bd_prod = ring_prod;
4410 /* must not have more available CQEs than BDs */
4411 fp->rx_comp_prod = min((u16)(NUM_RCQ_RINGS*RCQ_DESC_CNT),
4412 cqe_ring_prod);
4413 fp->rx_pkt = fp->rx_calls = 0;
4414
4415 /* Warning!
4416 * this will generate an interrupt (to the TSTORM)
4417 * must only be done after chip is initialized
4418 */
4419 bnx2x_update_rx_prod(bp, fp, ring_prod, fp->rx_comp_prod,
4420 fp->rx_sge_prod);
4421 if (j != 0)
4422 continue;
4423
4424 REG_WR(bp, BAR_USTRORM_INTMEM +
4425 USTORM_MEM_WORKAROUND_ADDRESS_OFFSET(func),
4426 U64_LO(fp->rx_comp_mapping));
4427 REG_WR(bp, BAR_USTRORM_INTMEM +
4428 USTORM_MEM_WORKAROUND_ADDRESS_OFFSET(func) + 4,
4429 U64_HI(fp->rx_comp_mapping));
4430 }
4431 }
4432
4433 static void bnx2x_init_tx_ring(struct bnx2x *bp)
4434 {
4435 int i, j;
4436
4437 for_each_queue(bp, j) {
4438 struct bnx2x_fastpath *fp = &bp->fp[j];
4439
4440 for (i = 1; i <= NUM_TX_RINGS; i++) {
4441 struct eth_tx_bd *tx_bd =
4442 &fp->tx_desc_ring[TX_DESC_CNT * i - 1];
4443
4444 tx_bd->addr_hi =
4445 cpu_to_le32(U64_HI(fp->tx_desc_mapping +
4446 BCM_PAGE_SIZE*(i % NUM_TX_RINGS)));
4447 tx_bd->addr_lo =
4448 cpu_to_le32(U64_LO(fp->tx_desc_mapping +
4449 BCM_PAGE_SIZE*(i % NUM_TX_RINGS)));
4450 }
4451
4452 fp->tx_pkt_prod = 0;
4453 fp->tx_pkt_cons = 0;
4454 fp->tx_bd_prod = 0;
4455 fp->tx_bd_cons = 0;
4456 fp->tx_cons_sb = BNX2X_TX_SB_INDEX;
4457 fp->tx_pkt = 0;
4458 }
4459 }
4460
4461 static void bnx2x_init_sp_ring(struct bnx2x *bp)
4462 {
4463 int func = BP_FUNC(bp);
4464
4465 spin_lock_init(&bp->spq_lock);
4466
4467 bp->spq_left = MAX_SPQ_PENDING;
4468 bp->spq_prod_idx = 0;
4469 bp->dsb_sp_prod = BNX2X_SP_DSB_INDEX;
4470 bp->spq_prod_bd = bp->spq;
4471 bp->spq_last_bd = bp->spq_prod_bd + MAX_SP_DESC_CNT;
4472
4473 REG_WR(bp, XSEM_REG_FAST_MEMORY + XSTORM_SPQ_PAGE_BASE_OFFSET(func),
4474 U64_LO(bp->spq_mapping));
4475 REG_WR(bp,
4476 XSEM_REG_FAST_MEMORY + XSTORM_SPQ_PAGE_BASE_OFFSET(func) + 4,
4477 U64_HI(bp->spq_mapping));
4478
4479 REG_WR(bp, XSEM_REG_FAST_MEMORY + XSTORM_SPQ_PROD_OFFSET(func),
4480 bp->spq_prod_idx);
4481 }
4482
4483 static void bnx2x_init_context(struct bnx2x *bp)
4484 {
4485 int i;
4486
4487 for_each_queue(bp, i) {
4488 struct eth_context *context = bnx2x_sp(bp, context[i].eth);
4489 struct bnx2x_fastpath *fp = &bp->fp[i];
4490 u8 sb_id = FP_SB_ID(fp);
4491
4492 context->xstorm_st_context.tx_bd_page_base_hi =
4493 U64_HI(fp->tx_desc_mapping);
4494 context->xstorm_st_context.tx_bd_page_base_lo =
4495 U64_LO(fp->tx_desc_mapping);
4496 context->xstorm_st_context.db_data_addr_hi =
4497 U64_HI(fp->tx_prods_mapping);
4498 context->xstorm_st_context.db_data_addr_lo =
4499 U64_LO(fp->tx_prods_mapping);
4500 context->xstorm_st_context.statistics_data = (BP_CL_ID(bp) |
4501 XSTORM_ETH_ST_CONTEXT_STATISTICS_ENABLE);
4502
4503 context->ustorm_st_context.common.sb_index_numbers =
4504 BNX2X_RX_SB_INDEX_NUM;
4505 context->ustorm_st_context.common.clientId = FP_CL_ID(fp);
4506 context->ustorm_st_context.common.status_block_id = sb_id;
4507 context->ustorm_st_context.common.flags =
4508 USTORM_ETH_ST_CONTEXT_CONFIG_ENABLE_MC_ALIGNMENT;
4509 context->ustorm_st_context.common.mc_alignment_size =
4510 BCM_RX_ETH_PAYLOAD_ALIGN;
4511 context->ustorm_st_context.common.bd_buff_size =
4512 bp->rx_buf_size;
4513 context->ustorm_st_context.common.bd_page_base_hi =
4514 U64_HI(fp->rx_desc_mapping);
4515 context->ustorm_st_context.common.bd_page_base_lo =
4516 U64_LO(fp->rx_desc_mapping);
4517 if (!fp->disable_tpa) {
4518 context->ustorm_st_context.common.flags |=
4519 (USTORM_ETH_ST_CONTEXT_CONFIG_ENABLE_TPA |
4520 USTORM_ETH_ST_CONTEXT_CONFIG_ENABLE_SGE_RING);
4521 context->ustorm_st_context.common.sge_buff_size =
4522 (u16)(BCM_PAGE_SIZE*PAGES_PER_SGE);
4523 context->ustorm_st_context.common.sge_page_base_hi =
4524 U64_HI(fp->rx_sge_mapping);
4525 context->ustorm_st_context.common.sge_page_base_lo =
4526 U64_LO(fp->rx_sge_mapping);
4527 }
4528
4529 context->cstorm_st_context.sb_index_number =
4530 C_SB_ETH_TX_CQ_INDEX;
4531 context->cstorm_st_context.status_block_id = sb_id;
4532
4533 context->xstorm_ag_context.cdu_reserved =
4534 CDU_RSRVD_VALUE_TYPE_A(HW_CID(bp, i),
4535 CDU_REGION_NUMBER_XCM_AG,
4536 ETH_CONNECTION_TYPE);
4537 context->ustorm_ag_context.cdu_usage =
4538 CDU_RSRVD_VALUE_TYPE_A(HW_CID(bp, i),
4539 CDU_REGION_NUMBER_UCM_AG,
4540 ETH_CONNECTION_TYPE);
4541 }
4542 }
4543
4544 static void bnx2x_init_ind_table(struct bnx2x *bp)
4545 {
4546 int func = BP_FUNC(bp);
4547 int i;
4548
4549 if (!is_multi(bp))
4550 return;
4551
4552 DP(NETIF_MSG_IFUP, "Initializing indirection table\n");
4553 for (i = 0; i < TSTORM_INDIRECTION_TABLE_SIZE; i++)
4554 REG_WR8(bp, BAR_TSTRORM_INTMEM +
4555 TSTORM_INDIRECTION_TABLE_OFFSET(func) + i,
4556 BP_CL_ID(bp) + (i % bp->num_queues));
4557 }
4558
4559 static void bnx2x_set_client_config(struct bnx2x *bp)
4560 {
4561 struct tstorm_eth_client_config tstorm_client = {0};
4562 int port = BP_PORT(bp);
4563 int i;
4564
4565 tstorm_client.mtu = bp->dev->mtu;
4566 tstorm_client.statistics_counter_id = BP_CL_ID(bp);
4567 tstorm_client.config_flags =
4568 TSTORM_ETH_CLIENT_CONFIG_STATSITICS_ENABLE;
4569 #ifdef BCM_VLAN
4570 if (bp->rx_mode && bp->vlgrp && (bp->flags & HW_VLAN_RX_FLAG)) {
4571 tstorm_client.config_flags |=
4572 TSTORM_ETH_CLIENT_CONFIG_VLAN_REMOVAL_ENABLE;
4573 DP(NETIF_MSG_IFUP, "vlan removal enabled\n");
4574 }
4575 #endif
4576
4577 if (bp->flags & TPA_ENABLE_FLAG) {
4578 tstorm_client.max_sges_for_packet =
4579 SGE_PAGE_ALIGN(tstorm_client.mtu) >> SGE_PAGE_SHIFT;
4580 tstorm_client.max_sges_for_packet =
4581 ((tstorm_client.max_sges_for_packet +
4582 PAGES_PER_SGE - 1) & (~(PAGES_PER_SGE - 1))) >>
4583 PAGES_PER_SGE_SHIFT;
4584
4585 tstorm_client.config_flags |=
4586 TSTORM_ETH_CLIENT_CONFIG_ENABLE_SGE_RING;
4587 }
4588
4589 for_each_queue(bp, i) {
4590 REG_WR(bp, BAR_TSTRORM_INTMEM +
4591 TSTORM_CLIENT_CONFIG_OFFSET(port, bp->fp[i].cl_id),
4592 ((u32 *)&tstorm_client)[0]);
4593 REG_WR(bp, BAR_TSTRORM_INTMEM +
4594 TSTORM_CLIENT_CONFIG_OFFSET(port, bp->fp[i].cl_id) + 4,
4595 ((u32 *)&tstorm_client)[1]);
4596 }
4597
4598 DP(BNX2X_MSG_OFF, "tstorm_client: 0x%08x 0x%08x\n",
4599 ((u32 *)&tstorm_client)[0], ((u32 *)&tstorm_client)[1]);
4600 }
4601
4602 static void bnx2x_set_storm_rx_mode(struct bnx2x *bp)
4603 {
4604 struct tstorm_eth_mac_filter_config tstorm_mac_filter = {0};
4605 int mode = bp->rx_mode;
4606 int mask = (1 << BP_L_ID(bp));
4607 int func = BP_FUNC(bp);
4608 int i;
4609
4610 DP(NETIF_MSG_IFUP, "rx mode %d mask 0x%x\n", mode, mask);
4611
4612 switch (mode) {
4613 case BNX2X_RX_MODE_NONE: /* no Rx */
4614 tstorm_mac_filter.ucast_drop_all = mask;
4615 tstorm_mac_filter.mcast_drop_all = mask;
4616 tstorm_mac_filter.bcast_drop_all = mask;
4617 break;
4618 case BNX2X_RX_MODE_NORMAL:
4619 tstorm_mac_filter.bcast_accept_all = mask;
4620 break;
4621 case BNX2X_RX_MODE_ALLMULTI:
4622 tstorm_mac_filter.mcast_accept_all = mask;
4623 tstorm_mac_filter.bcast_accept_all = mask;
4624 break;
4625 case BNX2X_RX_MODE_PROMISC:
4626 tstorm_mac_filter.ucast_accept_all = mask;
4627 tstorm_mac_filter.mcast_accept_all = mask;
4628 tstorm_mac_filter.bcast_accept_all = mask;
4629 break;
4630 default:
4631 BNX2X_ERR("BAD rx mode (%d)\n", mode);
4632 break;
4633 }
4634
4635 for (i = 0; i < sizeof(struct tstorm_eth_mac_filter_config)/4; i++) {
4636 REG_WR(bp, BAR_TSTRORM_INTMEM +
4637 TSTORM_MAC_FILTER_CONFIG_OFFSET(func) + i * 4,
4638 ((u32 *)&tstorm_mac_filter)[i]);
4639
4640 /* DP(NETIF_MSG_IFUP, "tstorm_mac_filter[%d]: 0x%08x\n", i,
4641 ((u32 *)&tstorm_mac_filter)[i]); */
4642 }
4643
4644 if (mode != BNX2X_RX_MODE_NONE)
4645 bnx2x_set_client_config(bp);
4646 }
4647
4648 static void bnx2x_init_internal_common(struct bnx2x *bp)
4649 {
4650 int i;
4651
4652 if (bp->flags & TPA_ENABLE_FLAG) {
4653 struct tstorm_eth_tpa_exist tpa = {0};
4654
4655 tpa.tpa_exist = 1;
4656
4657 REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_TPA_EXIST_OFFSET,
4658 ((u32 *)&tpa)[0]);
4659 REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_TPA_EXIST_OFFSET + 4,
4660 ((u32 *)&tpa)[1]);
4661 }
4662
4663 /* Zero this manually as its initialization is
4664 currently missing in the initTool */
4665 for (i = 0; i < (USTORM_AGG_DATA_SIZE >> 2); i++)
4666 REG_WR(bp, BAR_USTRORM_INTMEM +
4667 USTORM_AGG_DATA_OFFSET + i * 4, 0);
4668 }
4669
4670 static void bnx2x_init_internal_port(struct bnx2x *bp)
4671 {
4672 int port = BP_PORT(bp);
4673
4674 REG_WR(bp, BAR_USTRORM_INTMEM + USTORM_HC_BTR_OFFSET(port), BNX2X_BTR);
4675 REG_WR(bp, BAR_CSTRORM_INTMEM + CSTORM_HC_BTR_OFFSET(port), BNX2X_BTR);
4676 REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_HC_BTR_OFFSET(port), BNX2X_BTR);
4677 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_HC_BTR_OFFSET(port), BNX2X_BTR);
4678 }
4679
4680 static void bnx2x_init_internal_func(struct bnx2x *bp)
4681 {
4682 struct tstorm_eth_function_common_config tstorm_config = {0};
4683 struct stats_indication_flags stats_flags = {0};
4684 int port = BP_PORT(bp);
4685 int func = BP_FUNC(bp);
4686 int i;
4687 u16 max_agg_size;
4688
4689 if (is_multi(bp)) {
4690 tstorm_config.config_flags = MULTI_FLAGS;
4691 tstorm_config.rss_result_mask = MULTI_MASK;
4692 }
4693
4694 tstorm_config.leading_client_id = BP_L_ID(bp);
4695
4696 REG_WR(bp, BAR_TSTRORM_INTMEM +
4697 TSTORM_FUNCTION_COMMON_CONFIG_OFFSET(func),
4698 (*(u32 *)&tstorm_config));
4699
4700 bp->rx_mode = BNX2X_RX_MODE_NONE; /* no rx until link is up */
4701 bnx2x_set_storm_rx_mode(bp);
4702
4703 /* reset xstorm per client statistics */
4704 for (i = 0; i < sizeof(struct xstorm_per_client_stats) / 4; i++) {
4705 REG_WR(bp, BAR_XSTRORM_INTMEM +
4706 XSTORM_PER_COUNTER_ID_STATS_OFFSET(port, BP_CL_ID(bp)) +
4707 i*4, 0);
4708 }
4709 /* reset tstorm per client statistics */
4710 for (i = 0; i < sizeof(struct tstorm_per_client_stats) / 4; i++) {
4711 REG_WR(bp, BAR_TSTRORM_INTMEM +
4712 TSTORM_PER_COUNTER_ID_STATS_OFFSET(port, BP_CL_ID(bp)) +
4713 i*4, 0);
4714 }
4715
4716 /* Init statistics related context */
4717 stats_flags.collect_eth = 1;
4718
4719 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_STATS_FLAGS_OFFSET(func),
4720 ((u32 *)&stats_flags)[0]);
4721 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_STATS_FLAGS_OFFSET(func) + 4,
4722 ((u32 *)&stats_flags)[1]);
4723
4724 REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_STATS_FLAGS_OFFSET(func),
4725 ((u32 *)&stats_flags)[0]);
4726 REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_STATS_FLAGS_OFFSET(func) + 4,
4727 ((u32 *)&stats_flags)[1]);
4728
4729 REG_WR(bp, BAR_CSTRORM_INTMEM + CSTORM_STATS_FLAGS_OFFSET(func),
4730 ((u32 *)&stats_flags)[0]);
4731 REG_WR(bp, BAR_CSTRORM_INTMEM + CSTORM_STATS_FLAGS_OFFSET(func) + 4,
4732 ((u32 *)&stats_flags)[1]);
4733
4734 REG_WR(bp, BAR_XSTRORM_INTMEM +
4735 XSTORM_ETH_STATS_QUERY_ADDR_OFFSET(func),
4736 U64_LO(bnx2x_sp_mapping(bp, fw_stats)));
4737 REG_WR(bp, BAR_XSTRORM_INTMEM +
4738 XSTORM_ETH_STATS_QUERY_ADDR_OFFSET(func) + 4,
4739 U64_HI(bnx2x_sp_mapping(bp, fw_stats)));
4740
4741 REG_WR(bp, BAR_TSTRORM_INTMEM +
4742 TSTORM_ETH_STATS_QUERY_ADDR_OFFSET(func),
4743 U64_LO(bnx2x_sp_mapping(bp, fw_stats)));
4744 REG_WR(bp, BAR_TSTRORM_INTMEM +
4745 TSTORM_ETH_STATS_QUERY_ADDR_OFFSET(func) + 4,
4746 U64_HI(bnx2x_sp_mapping(bp, fw_stats)));
4747
4748 if (CHIP_IS_E1H(bp)) {
4749 REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNCTION_MODE_OFFSET,
4750 IS_E1HMF(bp));
4751 REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNCTION_MODE_OFFSET,
4752 IS_E1HMF(bp));
4753 REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNCTION_MODE_OFFSET,
4754 IS_E1HMF(bp));
4755 REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNCTION_MODE_OFFSET,
4756 IS_E1HMF(bp));
4757
4758 REG_WR16(bp, BAR_XSTRORM_INTMEM + XSTORM_E1HOV_OFFSET(func),
4759 bp->e1hov);
4760 }
4761
4762 /* Init CQ ring mapping and aggregation size, the FW limit is 8 frags */
4763 max_agg_size =
4764 min((u32)(min((u32)8, (u32)MAX_SKB_FRAGS) *
4765 SGE_PAGE_SIZE * PAGES_PER_SGE),
4766 (u32)0xffff);
4767 for_each_queue(bp, i) {
4768 struct bnx2x_fastpath *fp = &bp->fp[i];
4769
4770 REG_WR(bp, BAR_USTRORM_INTMEM +
4771 USTORM_CQE_PAGE_BASE_OFFSET(port, FP_CL_ID(fp)),
4772 U64_LO(fp->rx_comp_mapping));
4773 REG_WR(bp, BAR_USTRORM_INTMEM +
4774 USTORM_CQE_PAGE_BASE_OFFSET(port, FP_CL_ID(fp)) + 4,
4775 U64_HI(fp->rx_comp_mapping));
4776
4777 REG_WR16(bp, BAR_USTRORM_INTMEM +
4778 USTORM_MAX_AGG_SIZE_OFFSET(port, FP_CL_ID(fp)),
4779 max_agg_size);
4780 }
4781 }
4782
4783 static void bnx2x_init_internal(struct bnx2x *bp, u32 load_code)
4784 {
4785 switch (load_code) {
4786 case FW_MSG_CODE_DRV_LOAD_COMMON:
4787 bnx2x_init_internal_common(bp);
4788 /* no break */
4789
4790 case FW_MSG_CODE_DRV_LOAD_PORT:
4791 bnx2x_init_internal_port(bp);
4792 /* no break */
4793
4794 case FW_MSG_CODE_DRV_LOAD_FUNCTION:
4795 bnx2x_init_internal_func(bp);
4796 break;
4797
4798 default:
4799 BNX2X_ERR("Unknown load_code (0x%x) from MCP\n", load_code);
4800 break;
4801 }
4802 }
4803
4804 static void bnx2x_nic_init(struct bnx2x *bp, u32 load_code)
4805 {
4806 int i;
4807
4808 for_each_queue(bp, i) {
4809 struct bnx2x_fastpath *fp = &bp->fp[i];
4810
4811 fp->bp = bp;
4812 fp->state = BNX2X_FP_STATE_CLOSED;
4813 fp->index = i;
4814 fp->cl_id = BP_L_ID(bp) + i;
4815 fp->sb_id = fp->cl_id;
4816 DP(NETIF_MSG_IFUP,
4817 "bnx2x_init_sb(%p,%p) index %d cl_id %d sb %d\n",
4818 bp, fp->status_blk, i, FP_CL_ID(fp), FP_SB_ID(fp));
4819 bnx2x_init_sb(bp, fp->status_blk, fp->status_blk_mapping,
4820 FP_SB_ID(fp));
4821 bnx2x_update_fpsb_idx(fp);
4822 }
4823
4824 bnx2x_init_def_sb(bp, bp->def_status_blk, bp->def_status_blk_mapping,
4825 DEF_SB_ID);
4826 bnx2x_update_dsb_idx(bp);
4827 bnx2x_update_coalesce(bp);
4828 bnx2x_init_rx_rings(bp);
4829 bnx2x_init_tx_ring(bp);
4830 bnx2x_init_sp_ring(bp);
4831 bnx2x_init_context(bp);
4832 bnx2x_init_internal(bp, load_code);
4833 bnx2x_init_ind_table(bp);
4834 bnx2x_stats_init(bp);
4835
4836 /* At this point, we are ready for interrupts */
4837 atomic_set(&bp->intr_sem, 0);
4838
4839 /* flush all before enabling interrupts */
4840 mb();
4841 mmiowb();
4842
4843 bnx2x_int_enable(bp);
4844 }
4845
4846 /* end of nic init */
4847
4848 /*
4849 * gzip service functions
4850 */
4851
4852 static int bnx2x_gunzip_init(struct bnx2x *bp)
4853 {
4854 bp->gunzip_buf = pci_alloc_consistent(bp->pdev, FW_BUF_SIZE,
4855 &bp->gunzip_mapping);
4856 if (bp->gunzip_buf == NULL)
4857 goto gunzip_nomem1;
4858
4859 bp->strm = kmalloc(sizeof(*bp->strm), GFP_KERNEL);
4860 if (bp->strm == NULL)
4861 goto gunzip_nomem2;
4862
4863 bp->strm->workspace = kmalloc(zlib_inflate_workspacesize(),
4864 GFP_KERNEL);
4865 if (bp->strm->workspace == NULL)
4866 goto gunzip_nomem3;
4867
4868 return 0;
4869
4870 gunzip_nomem3:
4871 kfree(bp->strm);
4872 bp->strm = NULL;
4873
4874 gunzip_nomem2:
4875 pci_free_consistent(bp->pdev, FW_BUF_SIZE, bp->gunzip_buf,
4876 bp->gunzip_mapping);
4877 bp->gunzip_buf = NULL;
4878
4879 gunzip_nomem1:
4880 printk(KERN_ERR PFX "%s: Cannot allocate firmware buffer for"
4881 " un-compression\n", bp->dev->name);
4882 return -ENOMEM;
4883 }
4884
4885 static void bnx2x_gunzip_end(struct bnx2x *bp)
4886 {
4887 kfree(bp->strm->workspace);
4888
4889 kfree(bp->strm);
4890 bp->strm = NULL;
4891
4892 if (bp->gunzip_buf) {
4893 pci_free_consistent(bp->pdev, FW_BUF_SIZE, bp->gunzip_buf,
4894 bp->gunzip_mapping);
4895 bp->gunzip_buf = NULL;
4896 }
4897 }
4898
4899 static int bnx2x_gunzip(struct bnx2x *bp, u8 *zbuf, int len)
4900 {
4901 int n, rc;
4902
4903 /* check gzip header */
4904 if ((zbuf[0] != 0x1f) || (zbuf[1] != 0x8b) || (zbuf[2] != Z_DEFLATED))
4905 return -EINVAL;
4906
4907 n = 10;
4908
4909 #define FNAME 0x8
4910
4911 if (zbuf[3] & FNAME)
4912 while ((zbuf[n++] != 0) && (n < len));
4913
4914 bp->strm->next_in = zbuf + n;
4915 bp->strm->avail_in = len - n;
4916 bp->strm->next_out = bp->gunzip_buf;
4917 bp->strm->avail_out = FW_BUF_SIZE;
4918
4919 rc = zlib_inflateInit2(bp->strm, -MAX_WBITS);
4920 if (rc != Z_OK)
4921 return rc;
4922
4923 rc = zlib_inflate(bp->strm, Z_FINISH);
4924 if ((rc != Z_OK) && (rc != Z_STREAM_END))
4925 printk(KERN_ERR PFX "%s: Firmware decompression error: %s\n",
4926 bp->dev->name, bp->strm->msg);
4927
4928 bp->gunzip_outlen = (FW_BUF_SIZE - bp->strm->avail_out);
4929 if (bp->gunzip_outlen & 0x3)
4930 printk(KERN_ERR PFX "%s: Firmware decompression error:"
4931 " gunzip_outlen (%d) not aligned\n",
4932 bp->dev->name, bp->gunzip_outlen);
4933 bp->gunzip_outlen >>= 2;
4934
4935 zlib_inflateEnd(bp->strm);
4936
4937 if (rc == Z_STREAM_END)
4938 return 0;
4939
4940 return rc;
4941 }
4942
4943 /* nic load/unload */
4944
4945 /*
4946 * General service functions
4947 */
4948
4949 /* send a NIG loopback debug packet */
4950 static void bnx2x_lb_pckt(struct bnx2x *bp)
4951 {
4952 u32 wb_write[3];
4953
4954 /* Ethernet source and destination addresses */
4955 wb_write[0] = 0x55555555;
4956 wb_write[1] = 0x55555555;
4957 wb_write[2] = 0x20; /* SOP */
4958 REG_WR_DMAE(bp, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
4959
4960 /* NON-IP protocol */
4961 wb_write[0] = 0x09000000;
4962 wb_write[1] = 0x55555555;
4963 wb_write[2] = 0x10; /* EOP, eop_bvalid = 0 */
4964 REG_WR_DMAE(bp, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
4965 }
4966
4967 /* some of the internal memories
4968 * are not directly readable from the driver
4969 * to test them we send debug packets
4970 */
4971 static int bnx2x_int_mem_test(struct bnx2x *bp)
4972 {
4973 int factor;
4974 int count, i;
4975 u32 val = 0;
4976
4977 if (CHIP_REV_IS_FPGA(bp))
4978 factor = 120;
4979 else if (CHIP_REV_IS_EMUL(bp))
4980 factor = 200;
4981 else
4982 factor = 1;
4983
4984 DP(NETIF_MSG_HW, "start part1\n");
4985
4986 /* Disable inputs of parser neighbor blocks */
4987 REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x0);
4988 REG_WR(bp, TCM_REG_PRS_IFEN, 0x0);
4989 REG_WR(bp, CFC_REG_DEBUG0, 0x1);
4990 REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x0);
4991
4992 /* Write 0 to parser credits for CFC search request */
4993 REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
4994
4995 /* send Ethernet packet */
4996 bnx2x_lb_pckt(bp);
4997
4998 /* TODO do i reset NIG statistic? */
4999 /* Wait until NIG register shows 1 packet of size 0x10 */
5000 count = 1000 * factor;
5001 while (count) {
5002
5003 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
5004 val = *bnx2x_sp(bp, wb_data[0]);
5005 if (val == 0x10)
5006 break;
5007
5008 msleep(10);
5009 count--;
5010 }
5011 if (val != 0x10) {
5012 BNX2X_ERR("NIG timeout val = 0x%x\n", val);
5013 return -1;
5014 }
5015
5016 /* Wait until PRS register shows 1 packet */
5017 count = 1000 * factor;
5018 while (count) {
5019 val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
5020 if (val == 1)
5021 break;
5022
5023 msleep(10);
5024 count--;
5025 }
5026 if (val != 0x1) {
5027 BNX2X_ERR("PRS timeout val = 0x%x\n", val);
5028 return -2;
5029 }
5030
5031 /* Reset and init BRB, PRS */
5032 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
5033 msleep(50);
5034 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
5035 msleep(50);
5036 bnx2x_init_block(bp, BRB1_COMMON_START, BRB1_COMMON_END);
5037 bnx2x_init_block(bp, PRS_COMMON_START, PRS_COMMON_END);
5038
5039 DP(NETIF_MSG_HW, "part2\n");
5040
5041 /* Disable inputs of parser neighbor blocks */
5042 REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x0);
5043 REG_WR(bp, TCM_REG_PRS_IFEN, 0x0);
5044 REG_WR(bp, CFC_REG_DEBUG0, 0x1);
5045 REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x0);
5046
5047 /* Write 0 to parser credits for CFC search request */
5048 REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
5049
5050 /* send 10 Ethernet packets */
5051 for (i = 0; i < 10; i++)
5052 bnx2x_lb_pckt(bp);
5053
5054 /* Wait until NIG register shows 10 + 1
5055 packets of size 11*0x10 = 0xb0 */
5056 count = 1000 * factor;
5057 while (count) {
5058
5059 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
5060 val = *bnx2x_sp(bp, wb_data[0]);
5061 if (val == 0xb0)
5062 break;
5063
5064 msleep(10);
5065 count--;
5066 }
5067 if (val != 0xb0) {
5068 BNX2X_ERR("NIG timeout val = 0x%x\n", val);
5069 return -3;
5070 }
5071
5072 /* Wait until PRS register shows 2 packets */
5073 val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
5074 if (val != 2)
5075 BNX2X_ERR("PRS timeout val = 0x%x\n", val);
5076
5077 /* Write 1 to parser credits for CFC search request */
5078 REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x1);
5079
5080 /* Wait until PRS register shows 3 packets */
5081 msleep(10 * factor);
5082 /* Wait until NIG register shows 1 packet of size 0x10 */
5083 val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
5084 if (val != 3)
5085 BNX2X_ERR("PRS timeout val = 0x%x\n", val);
5086
5087 /* clear NIG EOP FIFO */
5088 for (i = 0; i < 11; i++)
5089 REG_RD(bp, NIG_REG_INGRESS_EOP_LB_FIFO);
5090 val = REG_RD(bp, NIG_REG_INGRESS_EOP_LB_EMPTY);
5091 if (val != 1) {
5092 BNX2X_ERR("clear of NIG failed\n");
5093 return -4;
5094 }
5095
5096 /* Reset and init BRB, PRS, NIG */
5097 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
5098 msleep(50);
5099 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
5100 msleep(50);
5101 bnx2x_init_block(bp, BRB1_COMMON_START, BRB1_COMMON_END);
5102 bnx2x_init_block(bp, PRS_COMMON_START, PRS_COMMON_END);
5103 #ifndef BCM_ISCSI
5104 /* set NIC mode */
5105 REG_WR(bp, PRS_REG_NIC_MODE, 1);
5106 #endif
5107
5108 /* Enable inputs of parser neighbor blocks */
5109 REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x7fffffff);
5110 REG_WR(bp, TCM_REG_PRS_IFEN, 0x1);
5111 REG_WR(bp, CFC_REG_DEBUG0, 0x0);
5112 REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x1);
5113
5114 DP(NETIF_MSG_HW, "done\n");
5115
5116 return 0; /* OK */
5117 }
5118
5119 static void enable_blocks_attention(struct bnx2x *bp)
5120 {
5121 REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
5122 REG_WR(bp, PXP_REG_PXP_INT_MASK_1, 0);
5123 REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
5124 REG_WR(bp, CFC_REG_CFC_INT_MASK, 0);
5125 REG_WR(bp, QM_REG_QM_INT_MASK, 0);
5126 REG_WR(bp, TM_REG_TM_INT_MASK, 0);
5127 REG_WR(bp, XSDM_REG_XSDM_INT_MASK_0, 0);
5128 REG_WR(bp, XSDM_REG_XSDM_INT_MASK_1, 0);
5129 REG_WR(bp, XCM_REG_XCM_INT_MASK, 0);
5130 /* REG_WR(bp, XSEM_REG_XSEM_INT_MASK_0, 0); */
5131 /* REG_WR(bp, XSEM_REG_XSEM_INT_MASK_1, 0); */
5132 REG_WR(bp, USDM_REG_USDM_INT_MASK_0, 0);
5133 REG_WR(bp, USDM_REG_USDM_INT_MASK_1, 0);
5134 REG_WR(bp, UCM_REG_UCM_INT_MASK, 0);
5135 /* REG_WR(bp, USEM_REG_USEM_INT_MASK_0, 0); */
5136 /* REG_WR(bp, USEM_REG_USEM_INT_MASK_1, 0); */
5137 REG_WR(bp, GRCBASE_UPB + PB_REG_PB_INT_MASK, 0);
5138 REG_WR(bp, CSDM_REG_CSDM_INT_MASK_0, 0);
5139 REG_WR(bp, CSDM_REG_CSDM_INT_MASK_1, 0);
5140 REG_WR(bp, CCM_REG_CCM_INT_MASK, 0);
5141 /* REG_WR(bp, CSEM_REG_CSEM_INT_MASK_0, 0); */
5142 /* REG_WR(bp, CSEM_REG_CSEM_INT_MASK_1, 0); */
5143 if (CHIP_REV_IS_FPGA(bp))
5144 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0, 0x580000);
5145 else
5146 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0, 0x480000);
5147 REG_WR(bp, TSDM_REG_TSDM_INT_MASK_0, 0);
5148 REG_WR(bp, TSDM_REG_TSDM_INT_MASK_1, 0);
5149 REG_WR(bp, TCM_REG_TCM_INT_MASK, 0);
5150 /* REG_WR(bp, TSEM_REG_TSEM_INT_MASK_0, 0); */
5151 /* REG_WR(bp, TSEM_REG_TSEM_INT_MASK_1, 0); */
5152 REG_WR(bp, CDU_REG_CDU_INT_MASK, 0);
5153 REG_WR(bp, DMAE_REG_DMAE_INT_MASK, 0);
5154 /* REG_WR(bp, MISC_REG_MISC_INT_MASK, 0); */
5155 REG_WR(bp, PBF_REG_PBF_INT_MASK, 0X18); /* bit 3,4 masked */
5156 }
5157
5158
5159 static void bnx2x_reset_common(struct bnx2x *bp)
5160 {
5161 /* reset_common */
5162 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
5163 0xd3ffff7f);
5164 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR, 0x1403);
5165 }
5166
5167 static int bnx2x_init_common(struct bnx2x *bp)
5168 {
5169 u32 val, i;
5170
5171 DP(BNX2X_MSG_MCP, "starting common init func %d\n", BP_FUNC(bp));
5172
5173 bnx2x_reset_common(bp);
5174 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0xffffffff);
5175 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET, 0xfffc);
5176
5177 bnx2x_init_block(bp, MISC_COMMON_START, MISC_COMMON_END);
5178 if (CHIP_IS_E1H(bp))
5179 REG_WR(bp, MISC_REG_E1HMF_MODE, IS_E1HMF(bp));
5180
5181 REG_WR(bp, MISC_REG_LCPLL_CTRL_REG_2, 0x100);
5182 msleep(30);
5183 REG_WR(bp, MISC_REG_LCPLL_CTRL_REG_2, 0x0);
5184
5185 bnx2x_init_block(bp, PXP_COMMON_START, PXP_COMMON_END);
5186 if (CHIP_IS_E1(bp)) {
5187 /* enable HW interrupt from PXP on USDM overflow
5188 bit 16 on INT_MASK_0 */
5189 REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
5190 }
5191
5192 bnx2x_init_block(bp, PXP2_COMMON_START, PXP2_COMMON_END);
5193 bnx2x_init_pxp(bp);
5194
5195 #ifdef __BIG_ENDIAN
5196 REG_WR(bp, PXP2_REG_RQ_QM_ENDIAN_M, 1);
5197 REG_WR(bp, PXP2_REG_RQ_TM_ENDIAN_M, 1);
5198 REG_WR(bp, PXP2_REG_RQ_SRC_ENDIAN_M, 1);
5199 REG_WR(bp, PXP2_REG_RQ_CDU_ENDIAN_M, 1);
5200 REG_WR(bp, PXP2_REG_RQ_DBG_ENDIAN_M, 1);
5201
5202 /* REG_WR(bp, PXP2_REG_RD_PBF_SWAP_MODE, 1); */
5203 REG_WR(bp, PXP2_REG_RD_QM_SWAP_MODE, 1);
5204 REG_WR(bp, PXP2_REG_RD_TM_SWAP_MODE, 1);
5205 REG_WR(bp, PXP2_REG_RD_SRC_SWAP_MODE, 1);
5206 REG_WR(bp, PXP2_REG_RD_CDURD_SWAP_MODE, 1);
5207 #endif
5208
5209 REG_WR(bp, PXP2_REG_RQ_CDU_P_SIZE, 2);
5210 #ifdef BCM_ISCSI
5211 REG_WR(bp, PXP2_REG_RQ_TM_P_SIZE, 5);
5212 REG_WR(bp, PXP2_REG_RQ_QM_P_SIZE, 5);
5213 REG_WR(bp, PXP2_REG_RQ_SRC_P_SIZE, 5);
5214 #endif
5215
5216 if (CHIP_REV_IS_FPGA(bp) && CHIP_IS_E1H(bp))
5217 REG_WR(bp, PXP2_REG_PGL_TAGS_LIMIT, 0x1);
5218
5219 /* let the HW do it's magic ... */
5220 msleep(100);
5221 /* finish PXP init */
5222 val = REG_RD(bp, PXP2_REG_RQ_CFG_DONE);
5223 if (val != 1) {
5224 BNX2X_ERR("PXP2 CFG failed\n");
5225 return -EBUSY;
5226 }
5227 val = REG_RD(bp, PXP2_REG_RD_INIT_DONE);
5228 if (val != 1) {
5229 BNX2X_ERR("PXP2 RD_INIT failed\n");
5230 return -EBUSY;
5231 }
5232
5233 REG_WR(bp, PXP2_REG_RQ_DISABLE_INPUTS, 0);
5234 REG_WR(bp, PXP2_REG_RD_DISABLE_INPUTS, 0);
5235
5236 bnx2x_init_block(bp, DMAE_COMMON_START, DMAE_COMMON_END);
5237
5238 /* clean the DMAE memory */
5239 bp->dmae_ready = 1;
5240 bnx2x_init_fill(bp, TSEM_REG_PRAM, 0, 8);
5241
5242 bnx2x_init_block(bp, TCM_COMMON_START, TCM_COMMON_END);
5243 bnx2x_init_block(bp, UCM_COMMON_START, UCM_COMMON_END);
5244 bnx2x_init_block(bp, CCM_COMMON_START, CCM_COMMON_END);
5245 bnx2x_init_block(bp, XCM_COMMON_START, XCM_COMMON_END);
5246
5247 bnx2x_read_dmae(bp, XSEM_REG_PASSIVE_BUFFER, 3);
5248 bnx2x_read_dmae(bp, CSEM_REG_PASSIVE_BUFFER, 3);
5249 bnx2x_read_dmae(bp, TSEM_REG_PASSIVE_BUFFER, 3);
5250 bnx2x_read_dmae(bp, USEM_REG_PASSIVE_BUFFER, 3);
5251
5252 bnx2x_init_block(bp, QM_COMMON_START, QM_COMMON_END);
5253 /* soft reset pulse */
5254 REG_WR(bp, QM_REG_SOFT_RESET, 1);
5255 REG_WR(bp, QM_REG_SOFT_RESET, 0);
5256
5257 #ifdef BCM_ISCSI
5258 bnx2x_init_block(bp, TIMERS_COMMON_START, TIMERS_COMMON_END);
5259 #endif
5260
5261 bnx2x_init_block(bp, DQ_COMMON_START, DQ_COMMON_END);
5262 REG_WR(bp, DORQ_REG_DPM_CID_OFST, BCM_PAGE_SHIFT);
5263 if (!CHIP_REV_IS_SLOW(bp)) {
5264 /* enable hw interrupt from doorbell Q */
5265 REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
5266 }
5267
5268 bnx2x_init_block(bp, BRB1_COMMON_START, BRB1_COMMON_END);
5269 if (CHIP_REV_IS_SLOW(bp)) {
5270 /* fix for emulation and FPGA for no pause */
5271 REG_WR(bp, BRB1_REG_PAUSE_HIGH_THRESHOLD_0, 513);
5272 REG_WR(bp, BRB1_REG_PAUSE_HIGH_THRESHOLD_1, 513);
5273 REG_WR(bp, BRB1_REG_PAUSE_LOW_THRESHOLD_0, 0);
5274 REG_WR(bp, BRB1_REG_PAUSE_LOW_THRESHOLD_1, 0);
5275 }
5276
5277 bnx2x_init_block(bp, PRS_COMMON_START, PRS_COMMON_END);
5278 REG_WR(bp, PRS_REG_A_PRSU_20, 0xf);
5279 /* set NIC mode */
5280 REG_WR(bp, PRS_REG_NIC_MODE, 1);
5281 if (CHIP_IS_E1H(bp))
5282 REG_WR(bp, PRS_REG_E1HOV_MODE, IS_E1HMF(bp));
5283
5284 bnx2x_init_block(bp, TSDM_COMMON_START, TSDM_COMMON_END);
5285 bnx2x_init_block(bp, CSDM_COMMON_START, CSDM_COMMON_END);
5286 bnx2x_init_block(bp, USDM_COMMON_START, USDM_COMMON_END);
5287 bnx2x_init_block(bp, XSDM_COMMON_START, XSDM_COMMON_END);
5288
5289 if (CHIP_IS_E1H(bp)) {
5290 bnx2x_init_fill(bp, TSTORM_INTMEM_ADDR, 0,
5291 STORM_INTMEM_SIZE_E1H/2);
5292 bnx2x_init_fill(bp,
5293 TSTORM_INTMEM_ADDR + STORM_INTMEM_SIZE_E1H/2,
5294 0, STORM_INTMEM_SIZE_E1H/2);
5295 bnx2x_init_fill(bp, CSTORM_INTMEM_ADDR, 0,
5296 STORM_INTMEM_SIZE_E1H/2);
5297 bnx2x_init_fill(bp,
5298 CSTORM_INTMEM_ADDR + STORM_INTMEM_SIZE_E1H/2,
5299 0, STORM_INTMEM_SIZE_E1H/2);
5300 bnx2x_init_fill(bp, XSTORM_INTMEM_ADDR, 0,
5301 STORM_INTMEM_SIZE_E1H/2);
5302 bnx2x_init_fill(bp,
5303 XSTORM_INTMEM_ADDR + STORM_INTMEM_SIZE_E1H/2,
5304 0, STORM_INTMEM_SIZE_E1H/2);
5305 bnx2x_init_fill(bp, USTORM_INTMEM_ADDR, 0,
5306 STORM_INTMEM_SIZE_E1H/2);
5307 bnx2x_init_fill(bp,
5308 USTORM_INTMEM_ADDR + STORM_INTMEM_SIZE_E1H/2,
5309 0, STORM_INTMEM_SIZE_E1H/2);
5310 } else { /* E1 */
5311 bnx2x_init_fill(bp, TSTORM_INTMEM_ADDR, 0,
5312 STORM_INTMEM_SIZE_E1);
5313 bnx2x_init_fill(bp, CSTORM_INTMEM_ADDR, 0,
5314 STORM_INTMEM_SIZE_E1);
5315 bnx2x_init_fill(bp, XSTORM_INTMEM_ADDR, 0,
5316 STORM_INTMEM_SIZE_E1);
5317 bnx2x_init_fill(bp, USTORM_INTMEM_ADDR, 0,
5318 STORM_INTMEM_SIZE_E1);
5319 }
5320
5321 bnx2x_init_block(bp, TSEM_COMMON_START, TSEM_COMMON_END);
5322 bnx2x_init_block(bp, USEM_COMMON_START, USEM_COMMON_END);
5323 bnx2x_init_block(bp, CSEM_COMMON_START, CSEM_COMMON_END);
5324 bnx2x_init_block(bp, XSEM_COMMON_START, XSEM_COMMON_END);
5325
5326 /* sync semi rtc */
5327 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
5328 0x80000000);
5329 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
5330 0x80000000);
5331
5332 bnx2x_init_block(bp, UPB_COMMON_START, UPB_COMMON_END);
5333 bnx2x_init_block(bp, XPB_COMMON_START, XPB_COMMON_END);
5334 bnx2x_init_block(bp, PBF_COMMON_START, PBF_COMMON_END);
5335
5336 REG_WR(bp, SRC_REG_SOFT_RST, 1);
5337 for (i = SRC_REG_KEYRSS0_0; i <= SRC_REG_KEYRSS1_9; i += 4) {
5338 REG_WR(bp, i, 0xc0cac01a);
5339 /* TODO: replace with something meaningful */
5340 }
5341 if (CHIP_IS_E1H(bp))
5342 bnx2x_init_block(bp, SRCH_COMMON_START, SRCH_COMMON_END);
5343 REG_WR(bp, SRC_REG_SOFT_RST, 0);
5344
5345 if (sizeof(union cdu_context) != 1024)
5346 /* we currently assume that a context is 1024 bytes */
5347 printk(KERN_ALERT PFX "please adjust the size of"
5348 " cdu_context(%ld)\n", (long)sizeof(union cdu_context));
5349
5350 bnx2x_init_block(bp, CDU_COMMON_START, CDU_COMMON_END);
5351 val = (4 << 24) + (0 << 12) + 1024;
5352 REG_WR(bp, CDU_REG_CDU_GLOBAL_PARAMS, val);
5353 if (CHIP_IS_E1(bp)) {
5354 /* !!! fix pxp client crdit until excel update */
5355 REG_WR(bp, CDU_REG_CDU_DEBUG, 0x264);
5356 REG_WR(bp, CDU_REG_CDU_DEBUG, 0);
5357 }
5358
5359 bnx2x_init_block(bp, CFC_COMMON_START, CFC_COMMON_END);
5360 REG_WR(bp, CFC_REG_INIT_REG, 0x7FF);
5361
5362 bnx2x_init_block(bp, HC_COMMON_START, HC_COMMON_END);
5363 bnx2x_init_block(bp, MISC_AEU_COMMON_START, MISC_AEU_COMMON_END);
5364
5365 /* PXPCS COMMON comes here */
5366 /* Reset PCIE errors for debug */
5367 REG_WR(bp, 0x2814, 0xffffffff);
5368 REG_WR(bp, 0x3820, 0xffffffff);
5369
5370 /* EMAC0 COMMON comes here */
5371 /* EMAC1 COMMON comes here */
5372 /* DBU COMMON comes here */
5373 /* DBG COMMON comes here */
5374
5375 bnx2x_init_block(bp, NIG_COMMON_START, NIG_COMMON_END);
5376 if (CHIP_IS_E1H(bp)) {
5377 REG_WR(bp, NIG_REG_LLH_MF_MODE, IS_E1HMF(bp));
5378 REG_WR(bp, NIG_REG_LLH_E1HOV_MODE, IS_E1HMF(bp));
5379 }
5380
5381 if (CHIP_REV_IS_SLOW(bp))
5382 msleep(200);
5383
5384 /* finish CFC init */
5385 val = reg_poll(bp, CFC_REG_LL_INIT_DONE, 1, 100, 10);
5386 if (val != 1) {
5387 BNX2X_ERR("CFC LL_INIT failed\n");
5388 return -EBUSY;
5389 }
5390 val = reg_poll(bp, CFC_REG_AC_INIT_DONE, 1, 100, 10);
5391 if (val != 1) {
5392 BNX2X_ERR("CFC AC_INIT failed\n");
5393 return -EBUSY;
5394 }
5395 val = reg_poll(bp, CFC_REG_CAM_INIT_DONE, 1, 100, 10);
5396 if (val != 1) {
5397 BNX2X_ERR("CFC CAM_INIT failed\n");
5398 return -EBUSY;
5399 }
5400 REG_WR(bp, CFC_REG_DEBUG0, 0);
5401
5402 /* read NIG statistic
5403 to see if this is our first up since powerup */
5404 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
5405 val = *bnx2x_sp(bp, wb_data[0]);
5406
5407 /* do internal memory self test */
5408 if ((CHIP_IS_E1(bp)) && (val == 0) && bnx2x_int_mem_test(bp)) {
5409 BNX2X_ERR("internal mem self test failed\n");
5410 return -EBUSY;
5411 }
5412
5413 switch (bp->common.board & SHARED_HW_CFG_BOARD_TYPE_MASK) {
5414 case SHARED_HW_CFG_BOARD_TYPE_BCM957710A1021G:
5415 case SHARED_HW_CFG_BOARD_TYPE_BCM957710A1022G:
5416 /* Fan failure is indicated by SPIO 5 */
5417 bnx2x_set_spio(bp, MISC_REGISTERS_SPIO_5,
5418 MISC_REGISTERS_SPIO_INPUT_HI_Z);
5419
5420 /* set to active low mode */
5421 val = REG_RD(bp, MISC_REG_SPIO_INT);
5422 val |= ((1 << MISC_REGISTERS_SPIO_5) <<
5423 MISC_REGISTERS_SPIO_INT_OLD_SET_POS);
5424 REG_WR(bp, MISC_REG_SPIO_INT, val);
5425
5426 /* enable interrupt to signal the IGU */
5427 val = REG_RD(bp, MISC_REG_SPIO_EVENT_EN);
5428 val |= (1 << MISC_REGISTERS_SPIO_5);
5429 REG_WR(bp, MISC_REG_SPIO_EVENT_EN, val);
5430 break;
5431
5432 default:
5433 break;
5434 }
5435
5436 /* clear PXP2 attentions */
5437 REG_RD(bp, PXP2_REG_PXP2_INT_STS_CLR_0);
5438
5439 enable_blocks_attention(bp);
5440
5441 if (!BP_NOMCP(bp)) {
5442 bnx2x_acquire_phy_lock(bp);
5443 bnx2x_common_init_phy(bp, bp->common.shmem_base);
5444 bnx2x_release_phy_lock(bp);
5445 } else
5446 BNX2X_ERR("Bootcode is missing - can not initialize link\n");
5447
5448 return 0;
5449 }
5450
5451 static int bnx2x_init_port(struct bnx2x *bp)
5452 {
5453 int port = BP_PORT(bp);
5454 u32 val;
5455
5456 DP(BNX2X_MSG_MCP, "starting port init port %x\n", port);
5457
5458 REG_WR(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
5459
5460 /* Port PXP comes here */
5461 /* Port PXP2 comes here */
5462 #ifdef BCM_ISCSI
5463 /* Port0 1
5464 * Port1 385 */
5465 i++;
5466 wb_write[0] = ONCHIP_ADDR1(bp->timers_mapping);
5467 wb_write[1] = ONCHIP_ADDR2(bp->timers_mapping);
5468 REG_WR_DMAE(bp, PXP2_REG_RQ_ONCHIP_AT + i*8, wb_write, 2);
5469 REG_WR(bp, PXP2_REG_PSWRQ_TM0_L2P + func*4, PXP_ONE_ILT(i));
5470
5471 /* Port0 2
5472 * Port1 386 */
5473 i++;
5474 wb_write[0] = ONCHIP_ADDR1(bp->qm_mapping);
5475 wb_write[1] = ONCHIP_ADDR2(bp->qm_mapping);
5476 REG_WR_DMAE(bp, PXP2_REG_RQ_ONCHIP_AT + i*8, wb_write, 2);
5477 REG_WR(bp, PXP2_REG_PSWRQ_QM0_L2P + func*4, PXP_ONE_ILT(i));
5478
5479 /* Port0 3
5480 * Port1 387 */
5481 i++;
5482 wb_write[0] = ONCHIP_ADDR1(bp->t1_mapping);
5483 wb_write[1] = ONCHIP_ADDR2(bp->t1_mapping);
5484 REG_WR_DMAE(bp, PXP2_REG_RQ_ONCHIP_AT + i*8, wb_write, 2);
5485 REG_WR(bp, PXP2_REG_PSWRQ_SRC0_L2P + func*4, PXP_ONE_ILT(i));
5486 #endif
5487 /* Port CMs come here */
5488
5489 /* Port QM comes here */
5490 #ifdef BCM_ISCSI
5491 REG_WR(bp, TM_REG_LIN0_SCAN_TIME + func*4, 1024/64*20);
5492 REG_WR(bp, TM_REG_LIN0_MAX_ACTIVE_CID + func*4, 31);
5493
5494 bnx2x_init_block(bp, func ? TIMERS_PORT1_START : TIMERS_PORT0_START,
5495 func ? TIMERS_PORT1_END : TIMERS_PORT0_END);
5496 #endif
5497 /* Port DQ comes here */
5498 /* Port BRB1 comes here */
5499 /* Port PRS comes here */
5500 /* Port TSDM comes here */
5501 /* Port CSDM comes here */
5502 /* Port USDM comes here */
5503 /* Port XSDM comes here */
5504 bnx2x_init_block(bp, port ? TSEM_PORT1_START : TSEM_PORT0_START,
5505 port ? TSEM_PORT1_END : TSEM_PORT0_END);
5506 bnx2x_init_block(bp, port ? USEM_PORT1_START : USEM_PORT0_START,
5507 port ? USEM_PORT1_END : USEM_PORT0_END);
5508 bnx2x_init_block(bp, port ? CSEM_PORT1_START : CSEM_PORT0_START,
5509 port ? CSEM_PORT1_END : CSEM_PORT0_END);
5510 bnx2x_init_block(bp, port ? XSEM_PORT1_START : XSEM_PORT0_START,
5511 port ? XSEM_PORT1_END : XSEM_PORT0_END);
5512 /* Port UPB comes here */
5513 /* Port XPB comes here */
5514
5515 bnx2x_init_block(bp, port ? PBF_PORT1_START : PBF_PORT0_START,
5516 port ? PBF_PORT1_END : PBF_PORT0_END);
5517
5518 /* configure PBF to work without PAUSE mtu 9000 */
5519 REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + port*4, 0);
5520
5521 /* update threshold */
5522 REG_WR(bp, PBF_REG_P0_ARB_THRSH + port*4, (9040/16));
5523 /* update init credit */
5524 REG_WR(bp, PBF_REG_P0_INIT_CRD + port*4, (9040/16) + 553 - 22);
5525
5526 /* probe changes */
5527 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 1);
5528 msleep(5);
5529 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0);
5530
5531 #ifdef BCM_ISCSI
5532 /* tell the searcher where the T2 table is */
5533 REG_WR(bp, SRC_REG_COUNTFREE0 + func*4, 16*1024/64);
5534
5535 wb_write[0] = U64_LO(bp->t2_mapping);
5536 wb_write[1] = U64_HI(bp->t2_mapping);
5537 REG_WR_DMAE(bp, SRC_REG_FIRSTFREE0 + func*4, wb_write, 2);
5538 wb_write[0] = U64_LO((u64)bp->t2_mapping + 16*1024 - 64);
5539 wb_write[1] = U64_HI((u64)bp->t2_mapping + 16*1024 - 64);
5540 REG_WR_DMAE(bp, SRC_REG_LASTFREE0 + func*4, wb_write, 2);
5541
5542 REG_WR(bp, SRC_REG_NUMBER_HASH_BITS0 + func*4, 10);
5543 /* Port SRCH comes here */
5544 #endif
5545 /* Port CDU comes here */
5546 /* Port CFC comes here */
5547
5548 if (CHIP_IS_E1(bp)) {
5549 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
5550 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
5551 }
5552 bnx2x_init_block(bp, port ? HC_PORT1_START : HC_PORT0_START,
5553 port ? HC_PORT1_END : HC_PORT0_END);
5554
5555 bnx2x_init_block(bp, port ? MISC_AEU_PORT1_START :
5556 MISC_AEU_PORT0_START,
5557 port ? MISC_AEU_PORT1_END : MISC_AEU_PORT0_END);
5558 /* init aeu_mask_attn_func_0/1:
5559 * - SF mode: bits 3-7 are masked. only bits 0-2 are in use
5560 * - MF mode: bit 3 is masked. bits 0-2 are in use as in SF
5561 * bits 4-7 are used for "per vn group attention" */
5562 REG_WR(bp, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4,
5563 (IS_E1HMF(bp) ? 0xF7 : 0x7));
5564
5565 /* Port PXPCS comes here */
5566 /* Port EMAC0 comes here */
5567 /* Port EMAC1 comes here */
5568 /* Port DBU comes here */
5569 /* Port DBG comes here */
5570 bnx2x_init_block(bp, port ? NIG_PORT1_START : NIG_PORT0_START,
5571 port ? NIG_PORT1_END : NIG_PORT0_END);
5572
5573 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 1);
5574
5575 if (CHIP_IS_E1H(bp)) {
5576 u32 wsum;
5577 struct cmng_struct_per_port m_cmng_port;
5578 int vn;
5579
5580 /* 0x2 disable e1hov, 0x1 enable */
5581 REG_WR(bp, NIG_REG_LLH0_BRB1_DRV_MASK_MF + port*4,
5582 (IS_E1HMF(bp) ? 0x1 : 0x2));
5583
5584 /* Init RATE SHAPING and FAIRNESS contexts.
5585 Initialize as if there is 10G link. */
5586 wsum = bnx2x_calc_vn_wsum(bp);
5587 bnx2x_init_port_minmax(bp, (int)wsum, 10000, &m_cmng_port);
5588 if (IS_E1HMF(bp))
5589 for (vn = VN_0; vn < E1HVN_MAX; vn++)
5590 bnx2x_init_vn_minmax(bp, 2*vn + port,
5591 wsum, 10000, &m_cmng_port);
5592 }
5593
5594 /* Port MCP comes here */
5595 /* Port DMAE comes here */
5596
5597 switch (bp->common.board & SHARED_HW_CFG_BOARD_TYPE_MASK) {
5598 case SHARED_HW_CFG_BOARD_TYPE_BCM957710A1021G:
5599 case SHARED_HW_CFG_BOARD_TYPE_BCM957710A1022G:
5600 /* add SPIO 5 to group 0 */
5601 val = REG_RD(bp, MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
5602 val |= AEU_INPUTS_ATTN_BITS_SPIO5;
5603 REG_WR(bp, MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0, val);
5604 break;
5605
5606 default:
5607 break;
5608 }
5609
5610 bnx2x__link_reset(bp);
5611
5612 return 0;
5613 }
5614
5615 #define ILT_PER_FUNC (768/2)
5616 #define FUNC_ILT_BASE(func) (func * ILT_PER_FUNC)
5617 /* the phys address is shifted right 12 bits and has an added
5618 1=valid bit added to the 53rd bit
5619 then since this is a wide register(TM)
5620 we split it into two 32 bit writes
5621 */
5622 #define ONCHIP_ADDR1(x) ((u32)(((u64)x >> 12) & 0xFFFFFFFF))
5623 #define ONCHIP_ADDR2(x) ((u32)((1 << 20) | ((u64)x >> 44)))
5624 #define PXP_ONE_ILT(x) (((x) << 10) | x)
5625 #define PXP_ILT_RANGE(f, l) (((l) << 10) | f)
5626
5627 #define CNIC_ILT_LINES 0
5628
5629 static void bnx2x_ilt_wr(struct bnx2x *bp, u32 index, dma_addr_t addr)
5630 {
5631 int reg;
5632
5633 if (CHIP_IS_E1H(bp))
5634 reg = PXP2_REG_RQ_ONCHIP_AT_B0 + index*8;
5635 else /* E1 */
5636 reg = PXP2_REG_RQ_ONCHIP_AT + index*8;
5637
5638 bnx2x_wb_wr(bp, reg, ONCHIP_ADDR1(addr), ONCHIP_ADDR2(addr));
5639 }
5640
5641 static int bnx2x_init_func(struct bnx2x *bp)
5642 {
5643 int port = BP_PORT(bp);
5644 int func = BP_FUNC(bp);
5645 int i;
5646
5647 DP(BNX2X_MSG_MCP, "starting func init func %x\n", func);
5648
5649 i = FUNC_ILT_BASE(func);
5650
5651 bnx2x_ilt_wr(bp, i, bnx2x_sp_mapping(bp, context));
5652 if (CHIP_IS_E1H(bp)) {
5653 REG_WR(bp, PXP2_REG_RQ_CDU_FIRST_ILT, i);
5654 REG_WR(bp, PXP2_REG_RQ_CDU_LAST_ILT, i + CNIC_ILT_LINES);
5655 } else /* E1 */
5656 REG_WR(bp, PXP2_REG_PSWRQ_CDU0_L2P + func*4,
5657 PXP_ILT_RANGE(i, i + CNIC_ILT_LINES));
5658
5659
5660 if (CHIP_IS_E1H(bp)) {
5661 for (i = 0; i < 9; i++)
5662 bnx2x_init_block(bp,
5663 cm_start[func][i], cm_end[func][i]);
5664
5665 REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 1);
5666 REG_WR(bp, NIG_REG_LLH0_FUNC_VLAN_ID + port*8, bp->e1hov);
5667 }
5668
5669 /* HC init per function */
5670 if (CHIP_IS_E1H(bp)) {
5671 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
5672
5673 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
5674 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
5675 }
5676 bnx2x_init_block(bp, hc_limits[func][0], hc_limits[func][1]);
5677
5678 if (CHIP_IS_E1H(bp))
5679 REG_WR(bp, HC_REG_FUNC_NUM_P0 + port*4, func);
5680
5681 /* Reset PCIE errors for debug */
5682 REG_WR(bp, 0x2114, 0xffffffff);
5683 REG_WR(bp, 0x2120, 0xffffffff);
5684
5685 return 0;
5686 }
5687
5688 static int bnx2x_init_hw(struct bnx2x *bp, u32 load_code)
5689 {
5690 int i, rc = 0;
5691
5692 DP(BNX2X_MSG_MCP, "function %d load_code %x\n",
5693 BP_FUNC(bp), load_code);
5694
5695 bp->dmae_ready = 0;
5696 mutex_init(&bp->dmae_mutex);
5697 bnx2x_gunzip_init(bp);
5698
5699 switch (load_code) {
5700 case FW_MSG_CODE_DRV_LOAD_COMMON:
5701 rc = bnx2x_init_common(bp);
5702 if (rc)
5703 goto init_hw_err;
5704 /* no break */
5705
5706 case FW_MSG_CODE_DRV_LOAD_PORT:
5707 bp->dmae_ready = 1;
5708 rc = bnx2x_init_port(bp);
5709 if (rc)
5710 goto init_hw_err;
5711 /* no break */
5712
5713 case FW_MSG_CODE_DRV_LOAD_FUNCTION:
5714 bp->dmae_ready = 1;
5715 rc = bnx2x_init_func(bp);
5716 if (rc)
5717 goto init_hw_err;
5718 break;
5719
5720 default:
5721 BNX2X_ERR("Unknown load_code (0x%x) from MCP\n", load_code);
5722 break;
5723 }
5724
5725 if (!BP_NOMCP(bp)) {
5726 int func = BP_FUNC(bp);
5727
5728 bp->fw_drv_pulse_wr_seq =
5729 (SHMEM_RD(bp, func_mb[func].drv_pulse_mb) &
5730 DRV_PULSE_SEQ_MASK);
5731 bp->func_stx = SHMEM_RD(bp, func_mb[func].fw_mb_param);
5732 DP(BNX2X_MSG_MCP, "drv_pulse 0x%x func_stx 0x%x\n",
5733 bp->fw_drv_pulse_wr_seq, bp->func_stx);
5734 } else
5735 bp->func_stx = 0;
5736
5737 /* this needs to be done before gunzip end */
5738 bnx2x_zero_def_sb(bp);
5739 for_each_queue(bp, i)
5740 bnx2x_zero_sb(bp, BP_L_ID(bp) + i);
5741
5742 init_hw_err:
5743 bnx2x_gunzip_end(bp);
5744
5745 return rc;
5746 }
5747
5748 /* send the MCP a request, block until there is a reply */
5749 static u32 bnx2x_fw_command(struct bnx2x *bp, u32 command)
5750 {
5751 int func = BP_FUNC(bp);
5752 u32 seq = ++bp->fw_seq;
5753 u32 rc = 0;
5754 u32 cnt = 1;
5755 u8 delay = CHIP_REV_IS_SLOW(bp) ? 100 : 10;
5756
5757 SHMEM_WR(bp, func_mb[func].drv_mb_header, (command | seq));
5758 DP(BNX2X_MSG_MCP, "wrote command (%x) to FW MB\n", (command | seq));
5759
5760 do {
5761 /* let the FW do it's magic ... */
5762 msleep(delay);
5763
5764 rc = SHMEM_RD(bp, func_mb[func].fw_mb_header);
5765
5766 /* Give the FW up to 2 second (200*10ms) */
5767 } while ((seq != (rc & FW_MSG_SEQ_NUMBER_MASK)) && (cnt++ < 200));
5768
5769 DP(BNX2X_MSG_MCP, "[after %d ms] read (%x) seq is (%x) from FW MB\n",
5770 cnt*delay, rc, seq);
5771
5772 /* is this a reply to our command? */
5773 if (seq == (rc & FW_MSG_SEQ_NUMBER_MASK)) {
5774 rc &= FW_MSG_CODE_MASK;
5775
5776 } else {
5777 /* FW BUG! */
5778 BNX2X_ERR("FW failed to respond!\n");
5779 bnx2x_fw_dump(bp);
5780 rc = 0;
5781 }
5782
5783 return rc;
5784 }
5785
5786 static void bnx2x_free_mem(struct bnx2x *bp)
5787 {
5788
5789 #define BNX2X_PCI_FREE(x, y, size) \
5790 do { \
5791 if (x) { \
5792 pci_free_consistent(bp->pdev, size, x, y); \
5793 x = NULL; \
5794 y = 0; \
5795 } \
5796 } while (0)
5797
5798 #define BNX2X_FREE(x) \
5799 do { \
5800 if (x) { \
5801 vfree(x); \
5802 x = NULL; \
5803 } \
5804 } while (0)
5805
5806 int i;
5807
5808 /* fastpath */
5809 for_each_queue(bp, i) {
5810
5811 /* Status blocks */
5812 BNX2X_PCI_FREE(bnx2x_fp(bp, i, status_blk),
5813 bnx2x_fp(bp, i, status_blk_mapping),
5814 sizeof(struct host_status_block) +
5815 sizeof(struct eth_tx_db_data));
5816
5817 /* fast path rings: tx_buf tx_desc rx_buf rx_desc rx_comp */
5818 BNX2X_FREE(bnx2x_fp(bp, i, tx_buf_ring));
5819 BNX2X_PCI_FREE(bnx2x_fp(bp, i, tx_desc_ring),
5820 bnx2x_fp(bp, i, tx_desc_mapping),
5821 sizeof(struct eth_tx_bd) * NUM_TX_BD);
5822
5823 BNX2X_FREE(bnx2x_fp(bp, i, rx_buf_ring));
5824 BNX2X_PCI_FREE(bnx2x_fp(bp, i, rx_desc_ring),
5825 bnx2x_fp(bp, i, rx_desc_mapping),
5826 sizeof(struct eth_rx_bd) * NUM_RX_BD);
5827
5828 BNX2X_PCI_FREE(bnx2x_fp(bp, i, rx_comp_ring),
5829 bnx2x_fp(bp, i, rx_comp_mapping),
5830 sizeof(struct eth_fast_path_rx_cqe) *
5831 NUM_RCQ_BD);
5832
5833 /* SGE ring */
5834 BNX2X_FREE(bnx2x_fp(bp, i, rx_page_ring));
5835 BNX2X_PCI_FREE(bnx2x_fp(bp, i, rx_sge_ring),
5836 bnx2x_fp(bp, i, rx_sge_mapping),
5837 BCM_PAGE_SIZE * NUM_RX_SGE_PAGES);
5838 }
5839 /* end of fastpath */
5840
5841 BNX2X_PCI_FREE(bp->def_status_blk, bp->def_status_blk_mapping,
5842 sizeof(struct host_def_status_block));
5843
5844 BNX2X_PCI_FREE(bp->slowpath, bp->slowpath_mapping,
5845 sizeof(struct bnx2x_slowpath));
5846
5847 #ifdef BCM_ISCSI
5848 BNX2X_PCI_FREE(bp->t1, bp->t1_mapping, 64*1024);
5849 BNX2X_PCI_FREE(bp->t2, bp->t2_mapping, 16*1024);
5850 BNX2X_PCI_FREE(bp->timers, bp->timers_mapping, 8*1024);
5851 BNX2X_PCI_FREE(bp->qm, bp->qm_mapping, 128*1024);
5852 #endif
5853 BNX2X_PCI_FREE(bp->spq, bp->spq_mapping, BCM_PAGE_SIZE);
5854
5855 #undef BNX2X_PCI_FREE
5856 #undef BNX2X_KFREE
5857 }
5858
5859 static int bnx2x_alloc_mem(struct bnx2x *bp)
5860 {
5861
5862 #define BNX2X_PCI_ALLOC(x, y, size) \
5863 do { \
5864 x = pci_alloc_consistent(bp->pdev, size, y); \
5865 if (x == NULL) \
5866 goto alloc_mem_err; \
5867 memset(x, 0, size); \
5868 } while (0)
5869
5870 #define BNX2X_ALLOC(x, size) \
5871 do { \
5872 x = vmalloc(size); \
5873 if (x == NULL) \
5874 goto alloc_mem_err; \
5875 memset(x, 0, size); \
5876 } while (0)
5877
5878 int i;
5879
5880 /* fastpath */
5881 for_each_queue(bp, i) {
5882 bnx2x_fp(bp, i, bp) = bp;
5883
5884 /* Status blocks */
5885 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, status_blk),
5886 &bnx2x_fp(bp, i, status_blk_mapping),
5887 sizeof(struct host_status_block) +
5888 sizeof(struct eth_tx_db_data));
5889
5890 bnx2x_fp(bp, i, hw_tx_prods) =
5891 (void *)(bnx2x_fp(bp, i, status_blk) + 1);
5892
5893 bnx2x_fp(bp, i, tx_prods_mapping) =
5894 bnx2x_fp(bp, i, status_blk_mapping) +
5895 sizeof(struct host_status_block);
5896
5897 /* fast path rings: tx_buf tx_desc rx_buf rx_desc rx_comp */
5898 BNX2X_ALLOC(bnx2x_fp(bp, i, tx_buf_ring),
5899 sizeof(struct sw_tx_bd) * NUM_TX_BD);
5900 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, tx_desc_ring),
5901 &bnx2x_fp(bp, i, tx_desc_mapping),
5902 sizeof(struct eth_tx_bd) * NUM_TX_BD);
5903
5904 BNX2X_ALLOC(bnx2x_fp(bp, i, rx_buf_ring),
5905 sizeof(struct sw_rx_bd) * NUM_RX_BD);
5906 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, rx_desc_ring),
5907 &bnx2x_fp(bp, i, rx_desc_mapping),
5908 sizeof(struct eth_rx_bd) * NUM_RX_BD);
5909
5910 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, rx_comp_ring),
5911 &bnx2x_fp(bp, i, rx_comp_mapping),
5912 sizeof(struct eth_fast_path_rx_cqe) *
5913 NUM_RCQ_BD);
5914
5915 /* SGE ring */
5916 BNX2X_ALLOC(bnx2x_fp(bp, i, rx_page_ring),
5917 sizeof(struct sw_rx_page) * NUM_RX_SGE);
5918 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, rx_sge_ring),
5919 &bnx2x_fp(bp, i, rx_sge_mapping),
5920 BCM_PAGE_SIZE * NUM_RX_SGE_PAGES);
5921 }
5922 /* end of fastpath */
5923
5924 BNX2X_PCI_ALLOC(bp->def_status_blk, &bp->def_status_blk_mapping,
5925 sizeof(struct host_def_status_block));
5926
5927 BNX2X_PCI_ALLOC(bp->slowpath, &bp->slowpath_mapping,
5928 sizeof(struct bnx2x_slowpath));
5929
5930 #ifdef BCM_ISCSI
5931 BNX2X_PCI_ALLOC(bp->t1, &bp->t1_mapping, 64*1024);
5932
5933 /* Initialize T1 */
5934 for (i = 0; i < 64*1024; i += 64) {
5935 *(u64 *)((char *)bp->t1 + i + 56) = 0x0UL;
5936 *(u64 *)((char *)bp->t1 + i + 3) = 0x0UL;
5937 }
5938
5939 /* allocate searcher T2 table
5940 we allocate 1/4 of alloc num for T2
5941 (which is not entered into the ILT) */
5942 BNX2X_PCI_ALLOC(bp->t2, &bp->t2_mapping, 16*1024);
5943
5944 /* Initialize T2 */
5945 for (i = 0; i < 16*1024; i += 64)
5946 * (u64 *)((char *)bp->t2 + i + 56) = bp->t2_mapping + i + 64;
5947
5948 /* now fixup the last line in the block to point to the next block */
5949 *(u64 *)((char *)bp->t2 + 1024*16-8) = bp->t2_mapping;
5950
5951 /* Timer block array (MAX_CONN*8) phys uncached for now 1024 conns */
5952 BNX2X_PCI_ALLOC(bp->timers, &bp->timers_mapping, 8*1024);
5953
5954 /* QM queues (128*MAX_CONN) */
5955 BNX2X_PCI_ALLOC(bp->qm, &bp->qm_mapping, 128*1024);
5956 #endif
5957
5958 /* Slow path ring */
5959 BNX2X_PCI_ALLOC(bp->spq, &bp->spq_mapping, BCM_PAGE_SIZE);
5960
5961 return 0;
5962
5963 alloc_mem_err:
5964 bnx2x_free_mem(bp);
5965 return -ENOMEM;
5966
5967 #undef BNX2X_PCI_ALLOC
5968 #undef BNX2X_ALLOC
5969 }
5970
5971 static void bnx2x_free_tx_skbs(struct bnx2x *bp)
5972 {
5973 int i;
5974
5975 for_each_queue(bp, i) {
5976 struct bnx2x_fastpath *fp = &bp->fp[i];
5977
5978 u16 bd_cons = fp->tx_bd_cons;
5979 u16 sw_prod = fp->tx_pkt_prod;
5980 u16 sw_cons = fp->tx_pkt_cons;
5981
5982 while (sw_cons != sw_prod) {
5983 bd_cons = bnx2x_free_tx_pkt(bp, fp, TX_BD(sw_cons));
5984 sw_cons++;
5985 }
5986 }
5987 }
5988
5989 static void bnx2x_free_rx_skbs(struct bnx2x *bp)
5990 {
5991 int i, j;
5992
5993 for_each_queue(bp, j) {
5994 struct bnx2x_fastpath *fp = &bp->fp[j];
5995
5996 for (i = 0; i < NUM_RX_BD; i++) {
5997 struct sw_rx_bd *rx_buf = &fp->rx_buf_ring[i];
5998 struct sk_buff *skb = rx_buf->skb;
5999
6000 if (skb == NULL)
6001 continue;
6002
6003 pci_unmap_single(bp->pdev,
6004 pci_unmap_addr(rx_buf, mapping),
6005 bp->rx_buf_size,
6006 PCI_DMA_FROMDEVICE);
6007
6008 rx_buf->skb = NULL;
6009 dev_kfree_skb(skb);
6010 }
6011 if (!fp->disable_tpa)
6012 bnx2x_free_tpa_pool(bp, fp, CHIP_IS_E1(bp) ?
6013 ETH_MAX_AGGREGATION_QUEUES_E1 :
6014 ETH_MAX_AGGREGATION_QUEUES_E1H);
6015 }
6016 }
6017
6018 static void bnx2x_free_skbs(struct bnx2x *bp)
6019 {
6020 bnx2x_free_tx_skbs(bp);
6021 bnx2x_free_rx_skbs(bp);
6022 }
6023
6024 static void bnx2x_free_msix_irqs(struct bnx2x *bp)
6025 {
6026 int i, offset = 1;
6027
6028 free_irq(bp->msix_table[0].vector, bp->dev);
6029 DP(NETIF_MSG_IFDOWN, "released sp irq (%d)\n",
6030 bp->msix_table[0].vector);
6031
6032 for_each_queue(bp, i) {
6033 DP(NETIF_MSG_IFDOWN, "about to release fp #%d->%d irq "
6034 "state %x\n", i, bp->msix_table[i + offset].vector,
6035 bnx2x_fp(bp, i, state));
6036
6037 if (bnx2x_fp(bp, i, state) != BNX2X_FP_STATE_CLOSED)
6038 BNX2X_ERR("IRQ of fp #%d being freed while "
6039 "state != closed\n", i);
6040
6041 free_irq(bp->msix_table[i + offset].vector, &bp->fp[i]);
6042 }
6043 }
6044
6045 static void bnx2x_free_irq(struct bnx2x *bp)
6046 {
6047 if (bp->flags & USING_MSIX_FLAG) {
6048 bnx2x_free_msix_irqs(bp);
6049 pci_disable_msix(bp->pdev);
6050 bp->flags &= ~USING_MSIX_FLAG;
6051
6052 } else
6053 free_irq(bp->pdev->irq, bp->dev);
6054 }
6055
6056 static int bnx2x_enable_msix(struct bnx2x *bp)
6057 {
6058 int i, rc, offset;
6059
6060 bp->msix_table[0].entry = 0;
6061 offset = 1;
6062 DP(NETIF_MSG_IFUP, "msix_table[0].entry = 0 (slowpath)\n");
6063
6064 for_each_queue(bp, i) {
6065 int igu_vec = offset + i + BP_L_ID(bp);
6066
6067 bp->msix_table[i + offset].entry = igu_vec;
6068 DP(NETIF_MSG_IFUP, "msix_table[%d].entry = %d "
6069 "(fastpath #%u)\n", i + offset, igu_vec, i);
6070 }
6071
6072 rc = pci_enable_msix(bp->pdev, &bp->msix_table[0],
6073 bp->num_queues + offset);
6074 if (rc) {
6075 DP(NETIF_MSG_IFUP, "MSI-X is not attainable\n");
6076 return -1;
6077 }
6078 bp->flags |= USING_MSIX_FLAG;
6079
6080 return 0;
6081 }
6082
6083 static int bnx2x_req_msix_irqs(struct bnx2x *bp)
6084 {
6085 int i, rc, offset = 1;
6086
6087 rc = request_irq(bp->msix_table[0].vector, bnx2x_msix_sp_int, 0,
6088 bp->dev->name, bp->dev);
6089 if (rc) {
6090 BNX2X_ERR("request sp irq failed\n");
6091 return -EBUSY;
6092 }
6093
6094 for_each_queue(bp, i) {
6095 rc = request_irq(bp->msix_table[i + offset].vector,
6096 bnx2x_msix_fp_int, 0,
6097 bp->dev->name, &bp->fp[i]);
6098 if (rc) {
6099 BNX2X_ERR("request fp #%d irq failed rc -%d\n",
6100 i + offset, -rc);
6101 bnx2x_free_msix_irqs(bp);
6102 return -EBUSY;
6103 }
6104
6105 bnx2x_fp(bp, i, state) = BNX2X_FP_STATE_IRQ;
6106 }
6107
6108 return 0;
6109 }
6110
6111 static int bnx2x_req_irq(struct bnx2x *bp)
6112 {
6113 int rc;
6114
6115 rc = request_irq(bp->pdev->irq, bnx2x_interrupt, IRQF_SHARED,
6116 bp->dev->name, bp->dev);
6117 if (!rc)
6118 bnx2x_fp(bp, 0, state) = BNX2X_FP_STATE_IRQ;
6119
6120 return rc;
6121 }
6122
6123 static void bnx2x_napi_enable(struct bnx2x *bp)
6124 {
6125 int i;
6126
6127 for_each_queue(bp, i)
6128 napi_enable(&bnx2x_fp(bp, i, napi));
6129 }
6130
6131 static void bnx2x_napi_disable(struct bnx2x *bp)
6132 {
6133 int i;
6134
6135 for_each_queue(bp, i)
6136 napi_disable(&bnx2x_fp(bp, i, napi));
6137 }
6138
6139 static void bnx2x_netif_start(struct bnx2x *bp)
6140 {
6141 if (atomic_dec_and_test(&bp->intr_sem)) {
6142 if (netif_running(bp->dev)) {
6143 if (bp->state == BNX2X_STATE_OPEN)
6144 netif_wake_queue(bp->dev);
6145 bnx2x_napi_enable(bp);
6146 bnx2x_int_enable(bp);
6147 }
6148 }
6149 }
6150
6151 static void bnx2x_netif_stop(struct bnx2x *bp, int disable_hw)
6152 {
6153 bnx2x_int_disable_sync(bp, disable_hw);
6154 bnx2x_napi_disable(bp);
6155 if (netif_running(bp->dev)) {
6156 netif_tx_disable(bp->dev);
6157 bp->dev->trans_start = jiffies; /* prevent tx timeout */
6158 }
6159 }
6160
6161 /*
6162 * Init service functions
6163 */
6164
6165 static void bnx2x_set_mac_addr_e1(struct bnx2x *bp, int set)
6166 {
6167 struct mac_configuration_cmd *config = bnx2x_sp(bp, mac_config);
6168 int port = BP_PORT(bp);
6169
6170 /* CAM allocation
6171 * unicasts 0-31:port0 32-63:port1
6172 * multicast 64-127:port0 128-191:port1
6173 */
6174 config->hdr.length_6b = 2;
6175 config->hdr.offset = port ? 32 : 0;
6176 config->hdr.client_id = BP_CL_ID(bp);
6177 config->hdr.reserved1 = 0;
6178
6179 /* primary MAC */
6180 config->config_table[0].cam_entry.msb_mac_addr =
6181 swab16(*(u16 *)&bp->dev->dev_addr[0]);
6182 config->config_table[0].cam_entry.middle_mac_addr =
6183 swab16(*(u16 *)&bp->dev->dev_addr[2]);
6184 config->config_table[0].cam_entry.lsb_mac_addr =
6185 swab16(*(u16 *)&bp->dev->dev_addr[4]);
6186 config->config_table[0].cam_entry.flags = cpu_to_le16(port);
6187 if (set)
6188 config->config_table[0].target_table_entry.flags = 0;
6189 else
6190 CAM_INVALIDATE(config->config_table[0]);
6191 config->config_table[0].target_table_entry.client_id = 0;
6192 config->config_table[0].target_table_entry.vlan_id = 0;
6193
6194 DP(NETIF_MSG_IFUP, "%s MAC (%04x:%04x:%04x)\n",
6195 (set ? "setting" : "clearing"),
6196 config->config_table[0].cam_entry.msb_mac_addr,
6197 config->config_table[0].cam_entry.middle_mac_addr,
6198 config->config_table[0].cam_entry.lsb_mac_addr);
6199
6200 /* broadcast */
6201 config->config_table[1].cam_entry.msb_mac_addr = 0xffff;
6202 config->config_table[1].cam_entry.middle_mac_addr = 0xffff;
6203 config->config_table[1].cam_entry.lsb_mac_addr = 0xffff;
6204 config->config_table[1].cam_entry.flags = cpu_to_le16(port);
6205 if (set)
6206 config->config_table[1].target_table_entry.flags =
6207 TSTORM_CAM_TARGET_TABLE_ENTRY_BROADCAST;
6208 else
6209 CAM_INVALIDATE(config->config_table[1]);
6210 config->config_table[1].target_table_entry.client_id = 0;
6211 config->config_table[1].target_table_entry.vlan_id = 0;
6212
6213 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_SET_MAC, 0,
6214 U64_HI(bnx2x_sp_mapping(bp, mac_config)),
6215 U64_LO(bnx2x_sp_mapping(bp, mac_config)), 0);
6216 }
6217
6218 static void bnx2x_set_mac_addr_e1h(struct bnx2x *bp, int set)
6219 {
6220 struct mac_configuration_cmd_e1h *config =
6221 (struct mac_configuration_cmd_e1h *)bnx2x_sp(bp, mac_config);
6222
6223 if (set && (bp->state != BNX2X_STATE_OPEN)) {
6224 DP(NETIF_MSG_IFUP, "state is %x, returning\n", bp->state);
6225 return;
6226 }
6227
6228 /* CAM allocation for E1H
6229 * unicasts: by func number
6230 * multicast: 20+FUNC*20, 20 each
6231 */
6232 config->hdr.length_6b = 1;
6233 config->hdr.offset = BP_FUNC(bp);
6234 config->hdr.client_id = BP_CL_ID(bp);
6235 config->hdr.reserved1 = 0;
6236
6237 /* primary MAC */
6238 config->config_table[0].msb_mac_addr =
6239 swab16(*(u16 *)&bp->dev->dev_addr[0]);
6240 config->config_table[0].middle_mac_addr =
6241 swab16(*(u16 *)&bp->dev->dev_addr[2]);
6242 config->config_table[0].lsb_mac_addr =
6243 swab16(*(u16 *)&bp->dev->dev_addr[4]);
6244 config->config_table[0].client_id = BP_L_ID(bp);
6245 config->config_table[0].vlan_id = 0;
6246 config->config_table[0].e1hov_id = cpu_to_le16(bp->e1hov);
6247 if (set)
6248 config->config_table[0].flags = BP_PORT(bp);
6249 else
6250 config->config_table[0].flags =
6251 MAC_CONFIGURATION_ENTRY_E1H_ACTION_TYPE;
6252
6253 DP(NETIF_MSG_IFUP, "%s MAC (%04x:%04x:%04x) E1HOV %d CLID %d\n",
6254 (set ? "setting" : "clearing"),
6255 config->config_table[0].msb_mac_addr,
6256 config->config_table[0].middle_mac_addr,
6257 config->config_table[0].lsb_mac_addr, bp->e1hov, BP_L_ID(bp));
6258
6259 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_SET_MAC, 0,
6260 U64_HI(bnx2x_sp_mapping(bp, mac_config)),
6261 U64_LO(bnx2x_sp_mapping(bp, mac_config)), 0);
6262 }
6263
6264 static int bnx2x_wait_ramrod(struct bnx2x *bp, int state, int idx,
6265 int *state_p, int poll)
6266 {
6267 /* can take a while if any port is running */
6268 int cnt = 500;
6269
6270 DP(NETIF_MSG_IFUP, "%s for state to become %x on IDX [%d]\n",
6271 poll ? "polling" : "waiting", state, idx);
6272
6273 might_sleep();
6274 while (cnt--) {
6275 if (poll) {
6276 bnx2x_rx_int(bp->fp, 10);
6277 /* if index is different from 0
6278 * the reply for some commands will
6279 * be on the non default queue
6280 */
6281 if (idx)
6282 bnx2x_rx_int(&bp->fp[idx], 10);
6283 }
6284
6285 mb(); /* state is changed by bnx2x_sp_event() */
6286 if (*state_p == state)
6287 return 0;
6288
6289 msleep(1);
6290 }
6291
6292 /* timeout! */
6293 BNX2X_ERR("timeout %s for state %x on IDX [%d]\n",
6294 poll ? "polling" : "waiting", state, idx);
6295 #ifdef BNX2X_STOP_ON_ERROR
6296 bnx2x_panic();
6297 #endif
6298
6299 return -EBUSY;
6300 }
6301
6302 static int bnx2x_setup_leading(struct bnx2x *bp)
6303 {
6304 int rc;
6305
6306 /* reset IGU state */
6307 bnx2x_ack_sb(bp, bp->fp[0].sb_id, CSTORM_ID, 0, IGU_INT_ENABLE, 0);
6308
6309 /* SETUP ramrod */
6310 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_PORT_SETUP, 0, 0, 0, 0);
6311
6312 /* Wait for completion */
6313 rc = bnx2x_wait_ramrod(bp, BNX2X_STATE_OPEN, 0, &(bp->state), 0);
6314
6315 return rc;
6316 }
6317
6318 static int bnx2x_setup_multi(struct bnx2x *bp, int index)
6319 {
6320 /* reset IGU state */
6321 bnx2x_ack_sb(bp, bp->fp[index].sb_id, CSTORM_ID, 0, IGU_INT_ENABLE, 0);
6322
6323 /* SETUP ramrod */
6324 bp->fp[index].state = BNX2X_FP_STATE_OPENING;
6325 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_CLIENT_SETUP, index, 0, index, 0);
6326
6327 /* Wait for completion */
6328 return bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_OPEN, index,
6329 &(bp->fp[index].state), 0);
6330 }
6331
6332 static int bnx2x_poll(struct napi_struct *napi, int budget);
6333 static void bnx2x_set_rx_mode(struct net_device *dev);
6334
6335 /* must be called with rtnl_lock */
6336 static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
6337 {
6338 u32 load_code;
6339 int i, rc = 0;
6340 #ifdef BNX2X_STOP_ON_ERROR
6341 if (unlikely(bp->panic))
6342 return -EPERM;
6343 #endif
6344
6345 bp->state = BNX2X_STATE_OPENING_WAIT4_LOAD;
6346
6347 if (use_inta) {
6348 bp->num_queues = 1;
6349
6350 } else {
6351 if ((use_multi > 1) && (use_multi <= BP_MAX_QUEUES(bp)))
6352 /* user requested number */
6353 bp->num_queues = use_multi;
6354
6355 else if (use_multi)
6356 bp->num_queues = min_t(u32, num_online_cpus(),
6357 BP_MAX_QUEUES(bp));
6358 else
6359 bp->num_queues = 1;
6360
6361 DP(NETIF_MSG_IFUP,
6362 "set number of queues to %d\n", bp->num_queues);
6363
6364 /* if we can't use MSI-X we only need one fp,
6365 * so try to enable MSI-X with the requested number of fp's
6366 * and fallback to MSI or legacy INTx with one fp
6367 */
6368 rc = bnx2x_enable_msix(bp);
6369 if (rc) {
6370 /* failed to enable MSI-X */
6371 bp->num_queues = 1;
6372 if (use_multi)
6373 BNX2X_ERR("Multi requested but failed"
6374 " to enable MSI-X\n");
6375 }
6376 }
6377
6378 if (bnx2x_alloc_mem(bp))
6379 return -ENOMEM;
6380
6381 for_each_queue(bp, i)
6382 bnx2x_fp(bp, i, disable_tpa) =
6383 ((bp->flags & TPA_ENABLE_FLAG) == 0);
6384
6385 for_each_queue(bp, i)
6386 netif_napi_add(bp->dev, &bnx2x_fp(bp, i, napi),
6387 bnx2x_poll, 128);
6388
6389 #ifdef BNX2X_STOP_ON_ERROR
6390 for_each_queue(bp, i) {
6391 struct bnx2x_fastpath *fp = &bp->fp[i];
6392
6393 fp->poll_no_work = 0;
6394 fp->poll_calls = 0;
6395 fp->poll_max_calls = 0;
6396 fp->poll_complete = 0;
6397 fp->poll_exit = 0;
6398 }
6399 #endif
6400 bnx2x_napi_enable(bp);
6401
6402 if (bp->flags & USING_MSIX_FLAG) {
6403 rc = bnx2x_req_msix_irqs(bp);
6404 if (rc) {
6405 pci_disable_msix(bp->pdev);
6406 goto load_error1;
6407 }
6408 printk(KERN_INFO PFX "%s: using MSI-X\n", bp->dev->name);
6409 } else {
6410 bnx2x_ack_int(bp);
6411 rc = bnx2x_req_irq(bp);
6412 if (rc) {
6413 BNX2X_ERR("IRQ request failed rc %d, aborting\n", rc);
6414 goto load_error1;
6415 }
6416 }
6417
6418 /* Send LOAD_REQUEST command to MCP
6419 Returns the type of LOAD command:
6420 if it is the first port to be initialized
6421 common blocks should be initialized, otherwise - not
6422 */
6423 if (!BP_NOMCP(bp)) {
6424 load_code = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_REQ);
6425 if (!load_code) {
6426 BNX2X_ERR("MCP response failure, aborting\n");
6427 rc = -EBUSY;
6428 goto load_error2;
6429 }
6430 if (load_code == FW_MSG_CODE_DRV_LOAD_REFUSED) {
6431 rc = -EBUSY; /* other port in diagnostic mode */
6432 goto load_error2;
6433 }
6434
6435 } else {
6436 int port = BP_PORT(bp);
6437
6438 DP(NETIF_MSG_IFUP, "NO MCP load counts before us %d, %d, %d\n",
6439 load_count[0], load_count[1], load_count[2]);
6440 load_count[0]++;
6441 load_count[1 + port]++;
6442 DP(NETIF_MSG_IFUP, "NO MCP new load counts %d, %d, %d\n",
6443 load_count[0], load_count[1], load_count[2]);
6444 if (load_count[0] == 1)
6445 load_code = FW_MSG_CODE_DRV_LOAD_COMMON;
6446 else if (load_count[1 + port] == 1)
6447 load_code = FW_MSG_CODE_DRV_LOAD_PORT;
6448 else
6449 load_code = FW_MSG_CODE_DRV_LOAD_FUNCTION;
6450 }
6451
6452 if ((load_code == FW_MSG_CODE_DRV_LOAD_COMMON) ||
6453 (load_code == FW_MSG_CODE_DRV_LOAD_PORT))
6454 bp->port.pmf = 1;
6455 else
6456 bp->port.pmf = 0;
6457 DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
6458
6459 /* Initialize HW */
6460 rc = bnx2x_init_hw(bp, load_code);
6461 if (rc) {
6462 BNX2X_ERR("HW init failed, aborting\n");
6463 goto load_error2;
6464 }
6465
6466 /* Setup NIC internals and enable interrupts */
6467 bnx2x_nic_init(bp, load_code);
6468
6469 /* Send LOAD_DONE command to MCP */
6470 if (!BP_NOMCP(bp)) {
6471 load_code = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_DONE);
6472 if (!load_code) {
6473 BNX2X_ERR("MCP response failure, aborting\n");
6474 rc = -EBUSY;
6475 goto load_error3;
6476 }
6477 }
6478
6479 bp->state = BNX2X_STATE_OPENING_WAIT4_PORT;
6480
6481 rc = bnx2x_setup_leading(bp);
6482 if (rc) {
6483 BNX2X_ERR("Setup leading failed!\n");
6484 goto load_error3;
6485 }
6486
6487 if (CHIP_IS_E1H(bp))
6488 if (bp->mf_config & FUNC_MF_CFG_FUNC_DISABLED) {
6489 BNX2X_ERR("!!! mf_cfg function disabled\n");
6490 bp->state = BNX2X_STATE_DISABLED;
6491 }
6492
6493 if (bp->state == BNX2X_STATE_OPEN)
6494 for_each_nondefault_queue(bp, i) {
6495 rc = bnx2x_setup_multi(bp, i);
6496 if (rc)
6497 goto load_error3;
6498 }
6499
6500 if (CHIP_IS_E1(bp))
6501 bnx2x_set_mac_addr_e1(bp, 1);
6502 else
6503 bnx2x_set_mac_addr_e1h(bp, 1);
6504
6505 if (bp->port.pmf)
6506 bnx2x_initial_phy_init(bp);
6507
6508 /* Start fast path */
6509 switch (load_mode) {
6510 case LOAD_NORMAL:
6511 /* Tx queue should be only reenabled */
6512 netif_wake_queue(bp->dev);
6513 /* Initialize the receive filter. */
6514 bnx2x_set_rx_mode(bp->dev);
6515 break;
6516
6517 case LOAD_OPEN:
6518 netif_start_queue(bp->dev);
6519 /* Initialize the receive filter. */
6520 bnx2x_set_rx_mode(bp->dev);
6521 break;
6522
6523 case LOAD_DIAG:
6524 /* Initialize the receive filter. */
6525 bnx2x_set_rx_mode(bp->dev);
6526 bp->state = BNX2X_STATE_DIAG;
6527 break;
6528
6529 default:
6530 break;
6531 }
6532
6533 if (!bp->port.pmf)
6534 bnx2x__link_status_update(bp);
6535
6536 /* start the timer */
6537 mod_timer(&bp->timer, jiffies + bp->current_interval);
6538
6539
6540 return 0;
6541
6542 load_error3:
6543 bnx2x_int_disable_sync(bp, 1);
6544 if (!BP_NOMCP(bp)) {
6545 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP);
6546 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE);
6547 }
6548 bp->port.pmf = 0;
6549 /* Free SKBs, SGEs, TPA pool and driver internals */
6550 bnx2x_free_skbs(bp);
6551 for_each_queue(bp, i)
6552 bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
6553 load_error2:
6554 /* Release IRQs */
6555 bnx2x_free_irq(bp);
6556 load_error1:
6557 bnx2x_napi_disable(bp);
6558 for_each_queue(bp, i)
6559 netif_napi_del(&bnx2x_fp(bp, i, napi));
6560 bnx2x_free_mem(bp);
6561
6562 /* TBD we really need to reset the chip
6563 if we want to recover from this */
6564 return rc;
6565 }
6566
6567 static int bnx2x_stop_multi(struct bnx2x *bp, int index)
6568 {
6569 int rc;
6570
6571 /* halt the connection */
6572 bp->fp[index].state = BNX2X_FP_STATE_HALTING;
6573 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_HALT, index, 0, index, 0);
6574
6575 /* Wait for completion */
6576 rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_HALTED, index,
6577 &(bp->fp[index].state), 1);
6578 if (rc) /* timeout */
6579 return rc;
6580
6581 /* delete cfc entry */
6582 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_CFC_DEL, index, 0, 0, 1);
6583
6584 /* Wait for completion */
6585 rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_CLOSED, index,
6586 &(bp->fp[index].state), 1);
6587 return rc;
6588 }
6589
6590 static int bnx2x_stop_leading(struct bnx2x *bp)
6591 {
6592 u16 dsb_sp_prod_idx;
6593 /* if the other port is handling traffic,
6594 this can take a lot of time */
6595 int cnt = 500;
6596 int rc;
6597
6598 might_sleep();
6599
6600 /* Send HALT ramrod */
6601 bp->fp[0].state = BNX2X_FP_STATE_HALTING;
6602 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_HALT, 0, 0, BP_CL_ID(bp), 0);
6603
6604 /* Wait for completion */
6605 rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_HALTED, 0,
6606 &(bp->fp[0].state), 1);
6607 if (rc) /* timeout */
6608 return rc;
6609
6610 dsb_sp_prod_idx = *bp->dsb_sp_prod;
6611
6612 /* Send PORT_DELETE ramrod */
6613 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_PORT_DEL, 0, 0, 0, 1);
6614
6615 /* Wait for completion to arrive on default status block
6616 we are going to reset the chip anyway
6617 so there is not much to do if this times out
6618 */
6619 while (dsb_sp_prod_idx == *bp->dsb_sp_prod) {
6620 if (!cnt) {
6621 DP(NETIF_MSG_IFDOWN, "timeout waiting for port del "
6622 "dsb_sp_prod 0x%x != dsb_sp_prod_idx 0x%x\n",
6623 *bp->dsb_sp_prod, dsb_sp_prod_idx);
6624 #ifdef BNX2X_STOP_ON_ERROR
6625 bnx2x_panic();
6626 #else
6627 rc = -EBUSY;
6628 #endif
6629 break;
6630 }
6631 cnt--;
6632 msleep(1);
6633 rmb(); /* Refresh the dsb_sp_prod */
6634 }
6635 bp->state = BNX2X_STATE_CLOSING_WAIT4_UNLOAD;
6636 bp->fp[0].state = BNX2X_FP_STATE_CLOSED;
6637
6638 return rc;
6639 }
6640
6641 static void bnx2x_reset_func(struct bnx2x *bp)
6642 {
6643 int port = BP_PORT(bp);
6644 int func = BP_FUNC(bp);
6645 int base, i;
6646
6647 /* Configure IGU */
6648 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
6649 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
6650
6651 REG_WR(bp, HC_REG_CONFIG_0 + port*4, 0x1000);
6652
6653 /* Clear ILT */
6654 base = FUNC_ILT_BASE(func);
6655 for (i = base; i < base + ILT_PER_FUNC; i++)
6656 bnx2x_ilt_wr(bp, i, 0);
6657 }
6658
6659 static void bnx2x_reset_port(struct bnx2x *bp)
6660 {
6661 int port = BP_PORT(bp);
6662 u32 val;
6663
6664 REG_WR(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
6665
6666 /* Do not rcv packets to BRB */
6667 REG_WR(bp, NIG_REG_LLH0_BRB1_DRV_MASK + port*4, 0x0);
6668 /* Do not direct rcv packets that are not for MCP to the BRB */
6669 REG_WR(bp, (port ? NIG_REG_LLH1_BRB1_NOT_MCP :
6670 NIG_REG_LLH0_BRB1_NOT_MCP), 0x0);
6671
6672 /* Configure AEU */
6673 REG_WR(bp, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4, 0);
6674
6675 msleep(100);
6676 /* Check for BRB port occupancy */
6677 val = REG_RD(bp, BRB1_REG_PORT_NUM_OCC_BLOCKS_0 + port*4);
6678 if (val)
6679 DP(NETIF_MSG_IFDOWN,
6680 "BRB1 is not empty %d blocks are occupied\n", val);
6681
6682 /* TODO: Close Doorbell port? */
6683 }
6684
6685 static void bnx2x_reset_chip(struct bnx2x *bp, u32 reset_code)
6686 {
6687 DP(BNX2X_MSG_MCP, "function %d reset_code %x\n",
6688 BP_FUNC(bp), reset_code);
6689
6690 switch (reset_code) {
6691 case FW_MSG_CODE_DRV_UNLOAD_COMMON:
6692 bnx2x_reset_port(bp);
6693 bnx2x_reset_func(bp);
6694 bnx2x_reset_common(bp);
6695 break;
6696
6697 case FW_MSG_CODE_DRV_UNLOAD_PORT:
6698 bnx2x_reset_port(bp);
6699 bnx2x_reset_func(bp);
6700 break;
6701
6702 case FW_MSG_CODE_DRV_UNLOAD_FUNCTION:
6703 bnx2x_reset_func(bp);
6704 break;
6705
6706 default:
6707 BNX2X_ERR("Unknown reset_code (0x%x) from MCP\n", reset_code);
6708 break;
6709 }
6710 }
6711
6712 /* must be called with rtnl_lock */
6713 static int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
6714 {
6715 int port = BP_PORT(bp);
6716 u32 reset_code = 0;
6717 int i, cnt, rc;
6718
6719 bp->state = BNX2X_STATE_CLOSING_WAIT4_HALT;
6720
6721 bp->rx_mode = BNX2X_RX_MODE_NONE;
6722 bnx2x_set_storm_rx_mode(bp);
6723
6724 bnx2x_netif_stop(bp, 1);
6725
6726 del_timer_sync(&bp->timer);
6727 SHMEM_WR(bp, func_mb[BP_FUNC(bp)].drv_pulse_mb,
6728 (DRV_PULSE_ALWAYS_ALIVE | bp->fw_drv_pulse_wr_seq));
6729 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
6730
6731 /* Release IRQs */
6732 bnx2x_free_irq(bp);
6733
6734 /* Wait until tx fast path tasks complete */
6735 for_each_queue(bp, i) {
6736 struct bnx2x_fastpath *fp = &bp->fp[i];
6737
6738 cnt = 1000;
6739 smp_rmb();
6740 while (bnx2x_has_tx_work_unload(fp)) {
6741
6742 bnx2x_tx_int(fp, 1000);
6743 if (!cnt) {
6744 BNX2X_ERR("timeout waiting for queue[%d]\n",
6745 i);
6746 #ifdef BNX2X_STOP_ON_ERROR
6747 bnx2x_panic();
6748 return -EBUSY;
6749 #else
6750 break;
6751 #endif
6752 }
6753 cnt--;
6754 msleep(1);
6755 smp_rmb();
6756 }
6757 }
6758 /* Give HW time to discard old tx messages */
6759 msleep(1);
6760
6761 if (CHIP_IS_E1(bp)) {
6762 struct mac_configuration_cmd *config =
6763 bnx2x_sp(bp, mcast_config);
6764
6765 bnx2x_set_mac_addr_e1(bp, 0);
6766
6767 for (i = 0; i < config->hdr.length_6b; i++)
6768 CAM_INVALIDATE(config->config_table[i]);
6769
6770 config->hdr.length_6b = i;
6771 if (CHIP_REV_IS_SLOW(bp))
6772 config->hdr.offset = BNX2X_MAX_EMUL_MULTI*(1 + port);
6773 else
6774 config->hdr.offset = BNX2X_MAX_MULTICAST*(1 + port);
6775 config->hdr.client_id = BP_CL_ID(bp);
6776 config->hdr.reserved1 = 0;
6777
6778 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_SET_MAC, 0,
6779 U64_HI(bnx2x_sp_mapping(bp, mcast_config)),
6780 U64_LO(bnx2x_sp_mapping(bp, mcast_config)), 0);
6781
6782 } else { /* E1H */
6783 REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
6784
6785 bnx2x_set_mac_addr_e1h(bp, 0);
6786
6787 for (i = 0; i < MC_HASH_SIZE; i++)
6788 REG_WR(bp, MC_HASH_OFFSET(bp, i), 0);
6789 }
6790
6791 if (unload_mode == UNLOAD_NORMAL)
6792 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
6793
6794 else if (bp->flags & NO_WOL_FLAG) {
6795 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP;
6796 if (CHIP_IS_E1H(bp))
6797 REG_WR(bp, MISC_REG_E1HMF_MODE, 0);
6798
6799 } else if (bp->wol) {
6800 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
6801 u8 *mac_addr = bp->dev->dev_addr;
6802 u32 val;
6803 /* The mac address is written to entries 1-4 to
6804 preserve entry 0 which is used by the PMF */
6805 u8 entry = (BP_E1HVN(bp) + 1)*8;
6806
6807 val = (mac_addr[0] << 8) | mac_addr[1];
6808 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry, val);
6809
6810 val = (mac_addr[2] << 24) | (mac_addr[3] << 16) |
6811 (mac_addr[4] << 8) | mac_addr[5];
6812 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry + 4, val);
6813
6814 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_EN;
6815
6816 } else
6817 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
6818
6819 /* Close multi and leading connections
6820 Completions for ramrods are collected in a synchronous way */
6821 for_each_nondefault_queue(bp, i)
6822 if (bnx2x_stop_multi(bp, i))
6823 goto unload_error;
6824
6825 rc = bnx2x_stop_leading(bp);
6826 if (rc) {
6827 BNX2X_ERR("Stop leading failed!\n");
6828 #ifdef BNX2X_STOP_ON_ERROR
6829 return -EBUSY;
6830 #else
6831 goto unload_error;
6832 #endif
6833 }
6834
6835 unload_error:
6836 if (!BP_NOMCP(bp))
6837 reset_code = bnx2x_fw_command(bp, reset_code);
6838 else {
6839 DP(NETIF_MSG_IFDOWN, "NO MCP load counts %d, %d, %d\n",
6840 load_count[0], load_count[1], load_count[2]);
6841 load_count[0]--;
6842 load_count[1 + port]--;
6843 DP(NETIF_MSG_IFDOWN, "NO MCP new load counts %d, %d, %d\n",
6844 load_count[0], load_count[1], load_count[2]);
6845 if (load_count[0] == 0)
6846 reset_code = FW_MSG_CODE_DRV_UNLOAD_COMMON;
6847 else if (load_count[1 + port] == 0)
6848 reset_code = FW_MSG_CODE_DRV_UNLOAD_PORT;
6849 else
6850 reset_code = FW_MSG_CODE_DRV_UNLOAD_FUNCTION;
6851 }
6852
6853 if ((reset_code == FW_MSG_CODE_DRV_UNLOAD_COMMON) ||
6854 (reset_code == FW_MSG_CODE_DRV_UNLOAD_PORT))
6855 bnx2x__link_reset(bp);
6856
6857 /* Reset the chip */
6858 bnx2x_reset_chip(bp, reset_code);
6859
6860 /* Report UNLOAD_DONE to MCP */
6861 if (!BP_NOMCP(bp))
6862 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE);
6863 bp->port.pmf = 0;
6864
6865 /* Free SKBs, SGEs, TPA pool and driver internals */
6866 bnx2x_free_skbs(bp);
6867 for_each_queue(bp, i)
6868 bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
6869 for_each_queue(bp, i)
6870 netif_napi_del(&bnx2x_fp(bp, i, napi));
6871 bnx2x_free_mem(bp);
6872
6873 bp->state = BNX2X_STATE_CLOSED;
6874
6875 netif_carrier_off(bp->dev);
6876
6877 return 0;
6878 }
6879
6880 static void bnx2x_reset_task(struct work_struct *work)
6881 {
6882 struct bnx2x *bp = container_of(work, struct bnx2x, reset_task);
6883
6884 #ifdef BNX2X_STOP_ON_ERROR
6885 BNX2X_ERR("reset task called but STOP_ON_ERROR defined"
6886 " so reset not done to allow debug dump,\n"
6887 KERN_ERR " you will need to reboot when done\n");
6888 return;
6889 #endif
6890
6891 rtnl_lock();
6892
6893 if (!netif_running(bp->dev))
6894 goto reset_task_exit;
6895
6896 bnx2x_nic_unload(bp, UNLOAD_NORMAL);
6897 bnx2x_nic_load(bp, LOAD_NORMAL);
6898
6899 reset_task_exit:
6900 rtnl_unlock();
6901 }
6902
6903 /* end of nic load/unload */
6904
6905 /* ethtool_ops */
6906
6907 /*
6908 * Init service functions
6909 */
6910
6911 static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
6912 {
6913 u32 val;
6914
6915 /* Check if there is any driver already loaded */
6916 val = REG_RD(bp, MISC_REG_UNPREPARED);
6917 if (val == 0x1) {
6918 /* Check if it is the UNDI driver
6919 * UNDI driver initializes CID offset for normal bell to 0x7
6920 */
6921 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
6922 val = REG_RD(bp, DORQ_REG_NORM_CID_OFST);
6923 if (val == 0x7) {
6924 u32 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
6925 /* save our func */
6926 int func = BP_FUNC(bp);
6927 u32 swap_en;
6928 u32 swap_val;
6929
6930 /* clear the UNDI indication */
6931 REG_WR(bp, DORQ_REG_NORM_CID_OFST, 0);
6932
6933 BNX2X_DEV_INFO("UNDI is active! reset device\n");
6934
6935 /* try unload UNDI on port 0 */
6936 bp->func = 0;
6937 bp->fw_seq =
6938 (SHMEM_RD(bp, func_mb[bp->func].drv_mb_header) &
6939 DRV_MSG_SEQ_NUMBER_MASK);
6940 reset_code = bnx2x_fw_command(bp, reset_code);
6941
6942 /* if UNDI is loaded on the other port */
6943 if (reset_code != FW_MSG_CODE_DRV_UNLOAD_COMMON) {
6944
6945 /* send "DONE" for previous unload */
6946 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE);
6947
6948 /* unload UNDI on port 1 */
6949 bp->func = 1;
6950 bp->fw_seq =
6951 (SHMEM_RD(bp, func_mb[bp->func].drv_mb_header) &
6952 DRV_MSG_SEQ_NUMBER_MASK);
6953 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
6954
6955 bnx2x_fw_command(bp, reset_code);
6956 }
6957
6958 /* now it's safe to release the lock */
6959 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
6960
6961 REG_WR(bp, (BP_PORT(bp) ? HC_REG_CONFIG_1 :
6962 HC_REG_CONFIG_0), 0x1000);
6963
6964 /* close input traffic and wait for it */
6965 /* Do not rcv packets to BRB */
6966 REG_WR(bp,
6967 (BP_PORT(bp) ? NIG_REG_LLH1_BRB1_DRV_MASK :
6968 NIG_REG_LLH0_BRB1_DRV_MASK), 0x0);
6969 /* Do not direct rcv packets that are not for MCP to
6970 * the BRB */
6971 REG_WR(bp,
6972 (BP_PORT(bp) ? NIG_REG_LLH1_BRB1_NOT_MCP :
6973 NIG_REG_LLH0_BRB1_NOT_MCP), 0x0);
6974 /* clear AEU */
6975 REG_WR(bp,
6976 (BP_PORT(bp) ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
6977 MISC_REG_AEU_MASK_ATTN_FUNC_0), 0);
6978 msleep(10);
6979
6980 /* save NIG port swap info */
6981 swap_val = REG_RD(bp, NIG_REG_PORT_SWAP);
6982 swap_en = REG_RD(bp, NIG_REG_STRAP_OVERRIDE);
6983 /* reset device */
6984 REG_WR(bp,
6985 GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
6986 0xd3ffffff);
6987 REG_WR(bp,
6988 GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
6989 0x1403);
6990 /* take the NIG out of reset and restore swap values */
6991 REG_WR(bp,
6992 GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
6993 MISC_REGISTERS_RESET_REG_1_RST_NIG);
6994 REG_WR(bp, NIG_REG_PORT_SWAP, swap_val);
6995 REG_WR(bp, NIG_REG_STRAP_OVERRIDE, swap_en);
6996
6997 /* send unload done to the MCP */
6998 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE);
6999
7000 /* restore our func and fw_seq */
7001 bp->func = func;
7002 bp->fw_seq =
7003 (SHMEM_RD(bp, func_mb[bp->func].drv_mb_header) &
7004 DRV_MSG_SEQ_NUMBER_MASK);
7005
7006 } else
7007 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
7008 }
7009 }
7010
7011 static void __devinit bnx2x_get_common_hwinfo(struct bnx2x *bp)
7012 {
7013 u32 val, val2, val3, val4, id;
7014 u16 pmc;
7015
7016 /* Get the chip revision id and number. */
7017 /* chip num:16-31, rev:12-15, metal:4-11, bond_id:0-3 */
7018 val = REG_RD(bp, MISC_REG_CHIP_NUM);
7019 id = ((val & 0xffff) << 16);
7020 val = REG_RD(bp, MISC_REG_CHIP_REV);
7021 id |= ((val & 0xf) << 12);
7022 val = REG_RD(bp, MISC_REG_CHIP_METAL);
7023 id |= ((val & 0xff) << 4);
7024 val = REG_RD(bp, MISC_REG_BOND_ID);
7025 id |= (val & 0xf);
7026 bp->common.chip_id = id;
7027 bp->link_params.chip_id = bp->common.chip_id;
7028 BNX2X_DEV_INFO("chip ID is 0x%x\n", id);
7029
7030 val = REG_RD(bp, MCP_REG_MCPR_NVM_CFG4);
7031 bp->common.flash_size = (NVRAM_1MB_SIZE <<
7032 (val & MCPR_NVM_CFG4_FLASH_SIZE));
7033 BNX2X_DEV_INFO("flash_size 0x%x (%d)\n",
7034 bp->common.flash_size, bp->common.flash_size);
7035
7036 bp->common.shmem_base = REG_RD(bp, MISC_REG_SHARED_MEM_ADDR);
7037 bp->link_params.shmem_base = bp->common.shmem_base;
7038 BNX2X_DEV_INFO("shmem offset is 0x%x\n", bp->common.shmem_base);
7039
7040 if (!bp->common.shmem_base ||
7041 (bp->common.shmem_base < 0xA0000) ||
7042 (bp->common.shmem_base >= 0xC0000)) {
7043 BNX2X_DEV_INFO("MCP not active\n");
7044 bp->flags |= NO_MCP_FLAG;
7045 return;
7046 }
7047
7048 val = SHMEM_RD(bp, validity_map[BP_PORT(bp)]);
7049 if ((val & (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
7050 != (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
7051 BNX2X_ERR("BAD MCP validity signature\n");
7052
7053 bp->common.hw_config = SHMEM_RD(bp, dev_info.shared_hw_config.config);
7054 bp->common.board = SHMEM_RD(bp, dev_info.shared_hw_config.board);
7055
7056 BNX2X_DEV_INFO("hw_config 0x%08x board 0x%08x\n",
7057 bp->common.hw_config, bp->common.board);
7058
7059 bp->link_params.hw_led_mode = ((bp->common.hw_config &
7060 SHARED_HW_CFG_LED_MODE_MASK) >>
7061 SHARED_HW_CFG_LED_MODE_SHIFT);
7062
7063 val = SHMEM_RD(bp, dev_info.bc_rev) >> 8;
7064 bp->common.bc_ver = val;
7065 BNX2X_DEV_INFO("bc_ver %X\n", val);
7066 if (val < BNX2X_BC_VER) {
7067 /* for now only warn
7068 * later we might need to enforce this */
7069 BNX2X_ERR("This driver needs bc_ver %X but found %X,"
7070 " please upgrade BC\n", BNX2X_BC_VER, val);
7071 }
7072
7073 if (BP_E1HVN(bp) == 0) {
7074 pci_read_config_word(bp->pdev, bp->pm_cap + PCI_PM_PMC, &pmc);
7075 bp->flags |= (pmc & PCI_PM_CAP_PME_D3cold) ? 0 : NO_WOL_FLAG;
7076 } else {
7077 /* no WOL capability for E1HVN != 0 */
7078 bp->flags |= NO_WOL_FLAG;
7079 }
7080 BNX2X_DEV_INFO("%sWoL capable\n",
7081 (bp->flags & NO_WOL_FLAG) ? "Not " : "");
7082
7083 val = SHMEM_RD(bp, dev_info.shared_hw_config.part_num);
7084 val2 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[4]);
7085 val3 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[8]);
7086 val4 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[12]);
7087
7088 printk(KERN_INFO PFX "part number %X-%X-%X-%X\n",
7089 val, val2, val3, val4);
7090 }
7091
7092 static void __devinit bnx2x_link_settings_supported(struct bnx2x *bp,
7093 u32 switch_cfg)
7094 {
7095 int port = BP_PORT(bp);
7096 u32 ext_phy_type;
7097
7098 switch (switch_cfg) {
7099 case SWITCH_CFG_1G:
7100 BNX2X_DEV_INFO("switch_cfg 0x%x (1G)\n", switch_cfg);
7101
7102 ext_phy_type =
7103 SERDES_EXT_PHY_TYPE(bp->link_params.ext_phy_config);
7104 switch (ext_phy_type) {
7105 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT:
7106 BNX2X_DEV_INFO("ext_phy_type 0x%x (Direct)\n",
7107 ext_phy_type);
7108
7109 bp->port.supported |= (SUPPORTED_10baseT_Half |
7110 SUPPORTED_10baseT_Full |
7111 SUPPORTED_100baseT_Half |
7112 SUPPORTED_100baseT_Full |
7113 SUPPORTED_1000baseT_Full |
7114 SUPPORTED_2500baseX_Full |
7115 SUPPORTED_TP |
7116 SUPPORTED_FIBRE |
7117 SUPPORTED_Autoneg |
7118 SUPPORTED_Pause |
7119 SUPPORTED_Asym_Pause);
7120 break;
7121
7122 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482:
7123 BNX2X_DEV_INFO("ext_phy_type 0x%x (5482)\n",
7124 ext_phy_type);
7125
7126 bp->port.supported |= (SUPPORTED_10baseT_Half |
7127 SUPPORTED_10baseT_Full |
7128 SUPPORTED_100baseT_Half |
7129 SUPPORTED_100baseT_Full |
7130 SUPPORTED_1000baseT_Full |
7131 SUPPORTED_TP |
7132 SUPPORTED_FIBRE |
7133 SUPPORTED_Autoneg |
7134 SUPPORTED_Pause |
7135 SUPPORTED_Asym_Pause);
7136 break;
7137
7138 default:
7139 BNX2X_ERR("NVRAM config error. "
7140 "BAD SerDes ext_phy_config 0x%x\n",
7141 bp->link_params.ext_phy_config);
7142 return;
7143 }
7144
7145 bp->port.phy_addr = REG_RD(bp, NIG_REG_SERDES0_CTRL_PHY_ADDR +
7146 port*0x10);
7147 BNX2X_DEV_INFO("phy_addr 0x%x\n", bp->port.phy_addr);
7148 break;
7149
7150 case SWITCH_CFG_10G:
7151 BNX2X_DEV_INFO("switch_cfg 0x%x (10G)\n", switch_cfg);
7152
7153 ext_phy_type =
7154 XGXS_EXT_PHY_TYPE(bp->link_params.ext_phy_config);
7155 switch (ext_phy_type) {
7156 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
7157 BNX2X_DEV_INFO("ext_phy_type 0x%x (Direct)\n",
7158 ext_phy_type);
7159
7160 bp->port.supported |= (SUPPORTED_10baseT_Half |
7161 SUPPORTED_10baseT_Full |
7162 SUPPORTED_100baseT_Half |
7163 SUPPORTED_100baseT_Full |
7164 SUPPORTED_1000baseT_Full |
7165 SUPPORTED_2500baseX_Full |
7166 SUPPORTED_10000baseT_Full |
7167 SUPPORTED_TP |
7168 SUPPORTED_FIBRE |
7169 SUPPORTED_Autoneg |
7170 SUPPORTED_Pause |
7171 SUPPORTED_Asym_Pause);
7172 break;
7173
7174 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
7175 BNX2X_DEV_INFO("ext_phy_type 0x%x (8705)\n",
7176 ext_phy_type);
7177
7178 bp->port.supported |= (SUPPORTED_10000baseT_Full |
7179 SUPPORTED_FIBRE |
7180 SUPPORTED_Pause |
7181 SUPPORTED_Asym_Pause);
7182 break;
7183
7184 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
7185 BNX2X_DEV_INFO("ext_phy_type 0x%x (8706)\n",
7186 ext_phy_type);
7187
7188 bp->port.supported |= (SUPPORTED_10000baseT_Full |
7189 SUPPORTED_1000baseT_Full |
7190 SUPPORTED_FIBRE |
7191 SUPPORTED_Pause |
7192 SUPPORTED_Asym_Pause);
7193 break;
7194
7195 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
7196 BNX2X_DEV_INFO("ext_phy_type 0x%x (8072)\n",
7197 ext_phy_type);
7198
7199 bp->port.supported |= (SUPPORTED_10000baseT_Full |
7200 SUPPORTED_1000baseT_Full |
7201 SUPPORTED_FIBRE |
7202 SUPPORTED_Autoneg |
7203 SUPPORTED_Pause |
7204 SUPPORTED_Asym_Pause);
7205 break;
7206
7207 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
7208 BNX2X_DEV_INFO("ext_phy_type 0x%x (8073)\n",
7209 ext_phy_type);
7210
7211 bp->port.supported |= (SUPPORTED_10000baseT_Full |
7212 SUPPORTED_2500baseX_Full |
7213 SUPPORTED_1000baseT_Full |
7214 SUPPORTED_FIBRE |
7215 SUPPORTED_Autoneg |
7216 SUPPORTED_Pause |
7217 SUPPORTED_Asym_Pause);
7218 break;
7219
7220 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
7221 BNX2X_DEV_INFO("ext_phy_type 0x%x (SFX7101)\n",
7222 ext_phy_type);
7223
7224 bp->port.supported |= (SUPPORTED_10000baseT_Full |
7225 SUPPORTED_TP |
7226 SUPPORTED_Autoneg |
7227 SUPPORTED_Pause |
7228 SUPPORTED_Asym_Pause);
7229 break;
7230
7231 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE:
7232 BNX2X_ERR("XGXS PHY Failure detected 0x%x\n",
7233 bp->link_params.ext_phy_config);
7234 break;
7235
7236 default:
7237 BNX2X_ERR("NVRAM config error. "
7238 "BAD XGXS ext_phy_config 0x%x\n",
7239 bp->link_params.ext_phy_config);
7240 return;
7241 }
7242
7243 bp->port.phy_addr = REG_RD(bp, NIG_REG_XGXS0_CTRL_PHY_ADDR +
7244 port*0x18);
7245 BNX2X_DEV_INFO("phy_addr 0x%x\n", bp->port.phy_addr);
7246
7247 break;
7248
7249 default:
7250 BNX2X_ERR("BAD switch_cfg link_config 0x%x\n",
7251 bp->port.link_config);
7252 return;
7253 }
7254 bp->link_params.phy_addr = bp->port.phy_addr;
7255
7256 /* mask what we support according to speed_cap_mask */
7257 if (!(bp->link_params.speed_cap_mask &
7258 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF))
7259 bp->port.supported &= ~SUPPORTED_10baseT_Half;
7260
7261 if (!(bp->link_params.speed_cap_mask &
7262 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL))
7263 bp->port.supported &= ~SUPPORTED_10baseT_Full;
7264
7265 if (!(bp->link_params.speed_cap_mask &
7266 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF))
7267 bp->port.supported &= ~SUPPORTED_100baseT_Half;
7268
7269 if (!(bp->link_params.speed_cap_mask &
7270 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL))
7271 bp->port.supported &= ~SUPPORTED_100baseT_Full;
7272
7273 if (!(bp->link_params.speed_cap_mask &
7274 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G))
7275 bp->port.supported &= ~(SUPPORTED_1000baseT_Half |
7276 SUPPORTED_1000baseT_Full);
7277
7278 if (!(bp->link_params.speed_cap_mask &
7279 PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G))
7280 bp->port.supported &= ~SUPPORTED_2500baseX_Full;
7281
7282 if (!(bp->link_params.speed_cap_mask &
7283 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G))
7284 bp->port.supported &= ~SUPPORTED_10000baseT_Full;
7285
7286 BNX2X_DEV_INFO("supported 0x%x\n", bp->port.supported);
7287 }
7288
7289 static void __devinit bnx2x_link_settings_requested(struct bnx2x *bp)
7290 {
7291 bp->link_params.req_duplex = DUPLEX_FULL;
7292
7293 switch (bp->port.link_config & PORT_FEATURE_LINK_SPEED_MASK) {
7294 case PORT_FEATURE_LINK_SPEED_AUTO:
7295 if (bp->port.supported & SUPPORTED_Autoneg) {
7296 bp->link_params.req_line_speed = SPEED_AUTO_NEG;
7297 bp->port.advertising = bp->port.supported;
7298 } else {
7299 u32 ext_phy_type =
7300 XGXS_EXT_PHY_TYPE(bp->link_params.ext_phy_config);
7301
7302 if ((ext_phy_type ==
7303 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705) ||
7304 (ext_phy_type ==
7305 PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706)) {
7306 /* force 10G, no AN */
7307 bp->link_params.req_line_speed = SPEED_10000;
7308 bp->port.advertising =
7309 (ADVERTISED_10000baseT_Full |
7310 ADVERTISED_FIBRE);
7311 break;
7312 }
7313 BNX2X_ERR("NVRAM config error. "
7314 "Invalid link_config 0x%x"
7315 " Autoneg not supported\n",
7316 bp->port.link_config);
7317 return;
7318 }
7319 break;
7320
7321 case PORT_FEATURE_LINK_SPEED_10M_FULL:
7322 if (bp->port.supported & SUPPORTED_10baseT_Full) {
7323 bp->link_params.req_line_speed = SPEED_10;
7324 bp->port.advertising = (ADVERTISED_10baseT_Full |
7325 ADVERTISED_TP);
7326 } else {
7327 BNX2X_ERR("NVRAM config error. "
7328 "Invalid link_config 0x%x"
7329 " speed_cap_mask 0x%x\n",
7330 bp->port.link_config,
7331 bp->link_params.speed_cap_mask);
7332 return;
7333 }
7334 break;
7335
7336 case PORT_FEATURE_LINK_SPEED_10M_HALF:
7337 if (bp->port.supported & SUPPORTED_10baseT_Half) {
7338 bp->link_params.req_line_speed = SPEED_10;
7339 bp->link_params.req_duplex = DUPLEX_HALF;
7340 bp->port.advertising = (ADVERTISED_10baseT_Half |
7341 ADVERTISED_TP);
7342 } else {
7343 BNX2X_ERR("NVRAM config error. "
7344 "Invalid link_config 0x%x"
7345 " speed_cap_mask 0x%x\n",
7346 bp->port.link_config,
7347 bp->link_params.speed_cap_mask);
7348 return;
7349 }
7350 break;
7351
7352 case PORT_FEATURE_LINK_SPEED_100M_FULL:
7353 if (bp->port.supported & SUPPORTED_100baseT_Full) {
7354 bp->link_params.req_line_speed = SPEED_100;
7355 bp->port.advertising = (ADVERTISED_100baseT_Full |
7356 ADVERTISED_TP);
7357 } else {
7358 BNX2X_ERR("NVRAM config error. "
7359 "Invalid link_config 0x%x"
7360 " speed_cap_mask 0x%x\n",
7361 bp->port.link_config,
7362 bp->link_params.speed_cap_mask);
7363 return;
7364 }
7365 break;
7366
7367 case PORT_FEATURE_LINK_SPEED_100M_HALF:
7368 if (bp->port.supported & SUPPORTED_100baseT_Half) {
7369 bp->link_params.req_line_speed = SPEED_100;
7370 bp->link_params.req_duplex = DUPLEX_HALF;
7371 bp->port.advertising = (ADVERTISED_100baseT_Half |
7372 ADVERTISED_TP);
7373 } else {
7374 BNX2X_ERR("NVRAM config error. "
7375 "Invalid link_config 0x%x"
7376 " speed_cap_mask 0x%x\n",
7377 bp->port.link_config,
7378 bp->link_params.speed_cap_mask);
7379 return;
7380 }
7381 break;
7382
7383 case PORT_FEATURE_LINK_SPEED_1G:
7384 if (bp->port.supported & SUPPORTED_1000baseT_Full) {
7385 bp->link_params.req_line_speed = SPEED_1000;
7386 bp->port.advertising = (ADVERTISED_1000baseT_Full |
7387 ADVERTISED_TP);
7388 } else {
7389 BNX2X_ERR("NVRAM config error. "
7390 "Invalid link_config 0x%x"
7391 " speed_cap_mask 0x%x\n",
7392 bp->port.link_config,
7393 bp->link_params.speed_cap_mask);
7394 return;
7395 }
7396 break;
7397
7398 case PORT_FEATURE_LINK_SPEED_2_5G:
7399 if (bp->port.supported & SUPPORTED_2500baseX_Full) {
7400 bp->link_params.req_line_speed = SPEED_2500;
7401 bp->port.advertising = (ADVERTISED_2500baseX_Full |
7402 ADVERTISED_TP);
7403 } else {
7404 BNX2X_ERR("NVRAM config error. "
7405 "Invalid link_config 0x%x"
7406 " speed_cap_mask 0x%x\n",
7407 bp->port.link_config,
7408 bp->link_params.speed_cap_mask);
7409 return;
7410 }
7411 break;
7412
7413 case PORT_FEATURE_LINK_SPEED_10G_CX4:
7414 case PORT_FEATURE_LINK_SPEED_10G_KX4:
7415 case PORT_FEATURE_LINK_SPEED_10G_KR:
7416 if (bp->port.supported & SUPPORTED_10000baseT_Full) {
7417 bp->link_params.req_line_speed = SPEED_10000;
7418 bp->port.advertising = (ADVERTISED_10000baseT_Full |
7419 ADVERTISED_FIBRE);
7420 } else {
7421 BNX2X_ERR("NVRAM config error. "
7422 "Invalid link_config 0x%x"
7423 " speed_cap_mask 0x%x\n",
7424 bp->port.link_config,
7425 bp->link_params.speed_cap_mask);
7426 return;
7427 }
7428 break;
7429
7430 default:
7431 BNX2X_ERR("NVRAM config error. "
7432 "BAD link speed link_config 0x%x\n",
7433 bp->port.link_config);
7434 bp->link_params.req_line_speed = SPEED_AUTO_NEG;
7435 bp->port.advertising = bp->port.supported;
7436 break;
7437 }
7438
7439 bp->link_params.req_flow_ctrl = (bp->port.link_config &
7440 PORT_FEATURE_FLOW_CONTROL_MASK);
7441 if ((bp->link_params.req_flow_ctrl == BNX2X_FLOW_CTRL_AUTO) &&
7442 !(bp->port.supported & SUPPORTED_Autoneg))
7443 bp->link_params.req_flow_ctrl = BNX2X_FLOW_CTRL_NONE;
7444
7445 BNX2X_DEV_INFO("req_line_speed %d req_duplex %d req_flow_ctrl 0x%x"
7446 " advertising 0x%x\n",
7447 bp->link_params.req_line_speed,
7448 bp->link_params.req_duplex,
7449 bp->link_params.req_flow_ctrl, bp->port.advertising);
7450 }
7451
7452 static void __devinit bnx2x_get_port_hwinfo(struct bnx2x *bp)
7453 {
7454 int port = BP_PORT(bp);
7455 u32 val, val2;
7456
7457 bp->link_params.bp = bp;
7458 bp->link_params.port = port;
7459
7460 bp->link_params.serdes_config =
7461 SHMEM_RD(bp, dev_info.port_hw_config[port].serdes_config);
7462 bp->link_params.lane_config =
7463 SHMEM_RD(bp, dev_info.port_hw_config[port].lane_config);
7464 bp->link_params.ext_phy_config =
7465 SHMEM_RD(bp,
7466 dev_info.port_hw_config[port].external_phy_config);
7467 bp->link_params.speed_cap_mask =
7468 SHMEM_RD(bp,
7469 dev_info.port_hw_config[port].speed_capability_mask);
7470
7471 bp->port.link_config =
7472 SHMEM_RD(bp, dev_info.port_feature_config[port].link_config);
7473
7474 BNX2X_DEV_INFO("serdes_config 0x%08x lane_config 0x%08x\n"
7475 KERN_INFO " ext_phy_config 0x%08x speed_cap_mask 0x%08x"
7476 " link_config 0x%08x\n",
7477 bp->link_params.serdes_config,
7478 bp->link_params.lane_config,
7479 bp->link_params.ext_phy_config,
7480 bp->link_params.speed_cap_mask, bp->port.link_config);
7481
7482 bp->link_params.switch_cfg = (bp->port.link_config &
7483 PORT_FEATURE_CONNECTED_SWITCH_MASK);
7484 bnx2x_link_settings_supported(bp, bp->link_params.switch_cfg);
7485
7486 bnx2x_link_settings_requested(bp);
7487
7488 val2 = SHMEM_RD(bp, dev_info.port_hw_config[port].mac_upper);
7489 val = SHMEM_RD(bp, dev_info.port_hw_config[port].mac_lower);
7490 bp->dev->dev_addr[0] = (u8)(val2 >> 8 & 0xff);
7491 bp->dev->dev_addr[1] = (u8)(val2 & 0xff);
7492 bp->dev->dev_addr[2] = (u8)(val >> 24 & 0xff);
7493 bp->dev->dev_addr[3] = (u8)(val >> 16 & 0xff);
7494 bp->dev->dev_addr[4] = (u8)(val >> 8 & 0xff);
7495 bp->dev->dev_addr[5] = (u8)(val & 0xff);
7496 memcpy(bp->link_params.mac_addr, bp->dev->dev_addr, ETH_ALEN);
7497 memcpy(bp->dev->perm_addr, bp->dev->dev_addr, ETH_ALEN);
7498 }
7499
7500 static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
7501 {
7502 int func = BP_FUNC(bp);
7503 u32 val, val2;
7504 int rc = 0;
7505
7506 bnx2x_get_common_hwinfo(bp);
7507
7508 bp->e1hov = 0;
7509 bp->e1hmf = 0;
7510 if (CHIP_IS_E1H(bp)) {
7511 bp->mf_config =
7512 SHMEM_RD(bp, mf_cfg.func_mf_config[func].config);
7513
7514 val = (SHMEM_RD(bp, mf_cfg.func_mf_config[func].e1hov_tag) &
7515 FUNC_MF_CFG_E1HOV_TAG_MASK);
7516 if (val != FUNC_MF_CFG_E1HOV_TAG_DEFAULT) {
7517
7518 bp->e1hov = val;
7519 bp->e1hmf = 1;
7520 BNX2X_DEV_INFO("MF mode E1HOV for func %d is %d "
7521 "(0x%04x)\n",
7522 func, bp->e1hov, bp->e1hov);
7523 } else {
7524 BNX2X_DEV_INFO("Single function mode\n");
7525 if (BP_E1HVN(bp)) {
7526 BNX2X_ERR("!!! No valid E1HOV for func %d,"
7527 " aborting\n", func);
7528 rc = -EPERM;
7529 }
7530 }
7531 }
7532
7533 if (!BP_NOMCP(bp)) {
7534 bnx2x_get_port_hwinfo(bp);
7535
7536 bp->fw_seq = (SHMEM_RD(bp, func_mb[func].drv_mb_header) &
7537 DRV_MSG_SEQ_NUMBER_MASK);
7538 BNX2X_DEV_INFO("fw_seq 0x%08x\n", bp->fw_seq);
7539 }
7540
7541 if (IS_E1HMF(bp)) {
7542 val2 = SHMEM_RD(bp, mf_cfg.func_mf_config[func].mac_upper);
7543 val = SHMEM_RD(bp, mf_cfg.func_mf_config[func].mac_lower);
7544 if ((val2 != FUNC_MF_CFG_UPPERMAC_DEFAULT) &&
7545 (val != FUNC_MF_CFG_LOWERMAC_DEFAULT)) {
7546 bp->dev->dev_addr[0] = (u8)(val2 >> 8 & 0xff);
7547 bp->dev->dev_addr[1] = (u8)(val2 & 0xff);
7548 bp->dev->dev_addr[2] = (u8)(val >> 24 & 0xff);
7549 bp->dev->dev_addr[3] = (u8)(val >> 16 & 0xff);
7550 bp->dev->dev_addr[4] = (u8)(val >> 8 & 0xff);
7551 bp->dev->dev_addr[5] = (u8)(val & 0xff);
7552 memcpy(bp->link_params.mac_addr, bp->dev->dev_addr,
7553 ETH_ALEN);
7554 memcpy(bp->dev->perm_addr, bp->dev->dev_addr,
7555 ETH_ALEN);
7556 }
7557
7558 return rc;
7559 }
7560
7561 if (BP_NOMCP(bp)) {
7562 /* only supposed to happen on emulation/FPGA */
7563 BNX2X_ERR("warning random MAC workaround active\n");
7564 random_ether_addr(bp->dev->dev_addr);
7565 memcpy(bp->dev->perm_addr, bp->dev->dev_addr, ETH_ALEN);
7566 }
7567
7568 return rc;
7569 }
7570
7571 static int __devinit bnx2x_init_bp(struct bnx2x *bp)
7572 {
7573 int func = BP_FUNC(bp);
7574 int rc;
7575
7576 /* Disable interrupt handling until HW is initialized */
7577 atomic_set(&bp->intr_sem, 1);
7578
7579 mutex_init(&bp->port.phy_mutex);
7580
7581 INIT_DELAYED_WORK(&bp->sp_task, bnx2x_sp_task);
7582 INIT_WORK(&bp->reset_task, bnx2x_reset_task);
7583
7584 rc = bnx2x_get_hwinfo(bp);
7585
7586 /* need to reset chip if undi was active */
7587 if (!BP_NOMCP(bp))
7588 bnx2x_undi_unload(bp);
7589
7590 if (CHIP_REV_IS_FPGA(bp))
7591 printk(KERN_ERR PFX "FPGA detected\n");
7592
7593 if (BP_NOMCP(bp) && (func == 0))
7594 printk(KERN_ERR PFX
7595 "MCP disabled, must load devices in order!\n");
7596
7597 /* Set TPA flags */
7598 if (disable_tpa) {
7599 bp->flags &= ~TPA_ENABLE_FLAG;
7600 bp->dev->features &= ~NETIF_F_LRO;
7601 } else {
7602 bp->flags |= TPA_ENABLE_FLAG;
7603 bp->dev->features |= NETIF_F_LRO;
7604 }
7605
7606
7607 bp->tx_ring_size = MAX_TX_AVAIL;
7608 bp->rx_ring_size = MAX_RX_AVAIL;
7609
7610 bp->rx_csum = 1;
7611 bp->rx_offset = 0;
7612
7613 bp->tx_ticks = 50;
7614 bp->rx_ticks = 25;
7615
7616 bp->timer_interval = (CHIP_REV_IS_SLOW(bp) ? 5*HZ : HZ);
7617 bp->current_interval = (poll ? poll : bp->timer_interval);
7618
7619 init_timer(&bp->timer);
7620 bp->timer.expires = jiffies + bp->current_interval;
7621 bp->timer.data = (unsigned long) bp;
7622 bp->timer.function = bnx2x_timer;
7623
7624 return rc;
7625 }
7626
7627 /*
7628 * ethtool service functions
7629 */
7630
7631 /* All ethtool functions called with rtnl_lock */
7632
7633 static int bnx2x_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
7634 {
7635 struct bnx2x *bp = netdev_priv(dev);
7636
7637 cmd->supported = bp->port.supported;
7638 cmd->advertising = bp->port.advertising;
7639
7640 if (netif_carrier_ok(dev)) {
7641 cmd->speed = bp->link_vars.line_speed;
7642 cmd->duplex = bp->link_vars.duplex;
7643 } else {
7644 cmd->speed = bp->link_params.req_line_speed;
7645 cmd->duplex = bp->link_params.req_duplex;
7646 }
7647 if (IS_E1HMF(bp)) {
7648 u16 vn_max_rate;
7649
7650 vn_max_rate = ((bp->mf_config & FUNC_MF_CFG_MAX_BW_MASK) >>
7651 FUNC_MF_CFG_MAX_BW_SHIFT) * 100;
7652 if (vn_max_rate < cmd->speed)
7653 cmd->speed = vn_max_rate;
7654 }
7655
7656 if (bp->link_params.switch_cfg == SWITCH_CFG_10G) {
7657 u32 ext_phy_type =
7658 XGXS_EXT_PHY_TYPE(bp->link_params.ext_phy_config);
7659
7660 switch (ext_phy_type) {
7661 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
7662 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
7663 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
7664 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
7665 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
7666 cmd->port = PORT_FIBRE;
7667 break;
7668
7669 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
7670 cmd->port = PORT_TP;
7671 break;
7672
7673 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE:
7674 BNX2X_ERR("XGXS PHY Failure detected 0x%x\n",
7675 bp->link_params.ext_phy_config);
7676 break;
7677
7678 default:
7679 DP(NETIF_MSG_LINK, "BAD XGXS ext_phy_config 0x%x\n",
7680 bp->link_params.ext_phy_config);
7681 break;
7682 }
7683 } else
7684 cmd->port = PORT_TP;
7685
7686 cmd->phy_address = bp->port.phy_addr;
7687 cmd->transceiver = XCVR_INTERNAL;
7688
7689 if (bp->link_params.req_line_speed == SPEED_AUTO_NEG)
7690 cmd->autoneg = AUTONEG_ENABLE;
7691 else
7692 cmd->autoneg = AUTONEG_DISABLE;
7693
7694 cmd->maxtxpkt = 0;
7695 cmd->maxrxpkt = 0;
7696
7697 DP(NETIF_MSG_LINK, "ethtool_cmd: cmd %d\n"
7698 DP_LEVEL " supported 0x%x advertising 0x%x speed %d\n"
7699 DP_LEVEL " duplex %d port %d phy_address %d transceiver %d\n"
7700 DP_LEVEL " autoneg %d maxtxpkt %d maxrxpkt %d\n",
7701 cmd->cmd, cmd->supported, cmd->advertising, cmd->speed,
7702 cmd->duplex, cmd->port, cmd->phy_address, cmd->transceiver,
7703 cmd->autoneg, cmd->maxtxpkt, cmd->maxrxpkt);
7704
7705 return 0;
7706 }
7707
7708 static int bnx2x_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
7709 {
7710 struct bnx2x *bp = netdev_priv(dev);
7711 u32 advertising;
7712
7713 if (IS_E1HMF(bp))
7714 return 0;
7715
7716 DP(NETIF_MSG_LINK, "ethtool_cmd: cmd %d\n"
7717 DP_LEVEL " supported 0x%x advertising 0x%x speed %d\n"
7718 DP_LEVEL " duplex %d port %d phy_address %d transceiver %d\n"
7719 DP_LEVEL " autoneg %d maxtxpkt %d maxrxpkt %d\n",
7720 cmd->cmd, cmd->supported, cmd->advertising, cmd->speed,
7721 cmd->duplex, cmd->port, cmd->phy_address, cmd->transceiver,
7722 cmd->autoneg, cmd->maxtxpkt, cmd->maxrxpkt);
7723
7724 if (cmd->autoneg == AUTONEG_ENABLE) {
7725 if (!(bp->port.supported & SUPPORTED_Autoneg)) {
7726 DP(NETIF_MSG_LINK, "Autoneg not supported\n");
7727 return -EINVAL;
7728 }
7729
7730 /* advertise the requested speed and duplex if supported */
7731 cmd->advertising &= bp->port.supported;
7732
7733 bp->link_params.req_line_speed = SPEED_AUTO_NEG;
7734 bp->link_params.req_duplex = DUPLEX_FULL;
7735 bp->port.advertising |= (ADVERTISED_Autoneg |
7736 cmd->advertising);
7737
7738 } else { /* forced speed */
7739 /* advertise the requested speed and duplex if supported */
7740 switch (cmd->speed) {
7741 case SPEED_10:
7742 if (cmd->duplex == DUPLEX_FULL) {
7743 if (!(bp->port.supported &
7744 SUPPORTED_10baseT_Full)) {
7745 DP(NETIF_MSG_LINK,
7746 "10M full not supported\n");
7747 return -EINVAL;
7748 }
7749
7750 advertising = (ADVERTISED_10baseT_Full |
7751 ADVERTISED_TP);
7752 } else {
7753 if (!(bp->port.supported &
7754 SUPPORTED_10baseT_Half)) {
7755 DP(NETIF_MSG_LINK,
7756 "10M half not supported\n");
7757 return -EINVAL;
7758 }
7759
7760 advertising = (ADVERTISED_10baseT_Half |
7761 ADVERTISED_TP);
7762 }
7763 break;
7764
7765 case SPEED_100:
7766 if (cmd->duplex == DUPLEX_FULL) {
7767 if (!(bp->port.supported &
7768 SUPPORTED_100baseT_Full)) {
7769 DP(NETIF_MSG_LINK,
7770 "100M full not supported\n");
7771 return -EINVAL;
7772 }
7773
7774 advertising = (ADVERTISED_100baseT_Full |
7775 ADVERTISED_TP);
7776 } else {
7777 if (!(bp->port.supported &
7778 SUPPORTED_100baseT_Half)) {
7779 DP(NETIF_MSG_LINK,
7780 "100M half not supported\n");
7781 return -EINVAL;
7782 }
7783
7784 advertising = (ADVERTISED_100baseT_Half |
7785 ADVERTISED_TP);
7786 }
7787 break;
7788
7789 case SPEED_1000:
7790 if (cmd->duplex != DUPLEX_FULL) {
7791 DP(NETIF_MSG_LINK, "1G half not supported\n");
7792 return -EINVAL;
7793 }
7794
7795 if (!(bp->port.supported & SUPPORTED_1000baseT_Full)) {
7796 DP(NETIF_MSG_LINK, "1G full not supported\n");
7797 return -EINVAL;
7798 }
7799
7800 advertising = (ADVERTISED_1000baseT_Full |
7801 ADVERTISED_TP);
7802 break;
7803
7804 case SPEED_2500:
7805 if (cmd->duplex != DUPLEX_FULL) {
7806 DP(NETIF_MSG_LINK,
7807 "2.5G half not supported\n");
7808 return -EINVAL;
7809 }
7810
7811 if (!(bp->port.supported & SUPPORTED_2500baseX_Full)) {
7812 DP(NETIF_MSG_LINK,
7813 "2.5G full not supported\n");
7814 return -EINVAL;
7815 }
7816
7817 advertising = (ADVERTISED_2500baseX_Full |
7818 ADVERTISED_TP);
7819 break;
7820
7821 case SPEED_10000:
7822 if (cmd->duplex != DUPLEX_FULL) {
7823 DP(NETIF_MSG_LINK, "10G half not supported\n");
7824 return -EINVAL;
7825 }
7826
7827 if (!(bp->port.supported & SUPPORTED_10000baseT_Full)) {
7828 DP(NETIF_MSG_LINK, "10G full not supported\n");
7829 return -EINVAL;
7830 }
7831
7832 advertising = (ADVERTISED_10000baseT_Full |
7833 ADVERTISED_FIBRE);
7834 break;
7835
7836 default:
7837 DP(NETIF_MSG_LINK, "Unsupported speed\n");
7838 return -EINVAL;
7839 }
7840
7841 bp->link_params.req_line_speed = cmd->speed;
7842 bp->link_params.req_duplex = cmd->duplex;
7843 bp->port.advertising = advertising;
7844 }
7845
7846 DP(NETIF_MSG_LINK, "req_line_speed %d\n"
7847 DP_LEVEL " req_duplex %d advertising 0x%x\n",
7848 bp->link_params.req_line_speed, bp->link_params.req_duplex,
7849 bp->port.advertising);
7850
7851 if (netif_running(dev)) {
7852 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
7853 bnx2x_link_set(bp);
7854 }
7855
7856 return 0;
7857 }
7858
7859 #define PHY_FW_VER_LEN 10
7860
7861 static void bnx2x_get_drvinfo(struct net_device *dev,
7862 struct ethtool_drvinfo *info)
7863 {
7864 struct bnx2x *bp = netdev_priv(dev);
7865 u8 phy_fw_ver[PHY_FW_VER_LEN];
7866
7867 strcpy(info->driver, DRV_MODULE_NAME);
7868 strcpy(info->version, DRV_MODULE_VERSION);
7869
7870 phy_fw_ver[0] = '\0';
7871 if (bp->port.pmf) {
7872 bnx2x_acquire_phy_lock(bp);
7873 bnx2x_get_ext_phy_fw_version(&bp->link_params,
7874 (bp->state != BNX2X_STATE_CLOSED),
7875 phy_fw_ver, PHY_FW_VER_LEN);
7876 bnx2x_release_phy_lock(bp);
7877 }
7878
7879 snprintf(info->fw_version, 32, "BC:%d.%d.%d%s%s",
7880 (bp->common.bc_ver & 0xff0000) >> 16,
7881 (bp->common.bc_ver & 0xff00) >> 8,
7882 (bp->common.bc_ver & 0xff),
7883 ((phy_fw_ver[0] != '\0') ? " PHY:" : ""), phy_fw_ver);
7884 strcpy(info->bus_info, pci_name(bp->pdev));
7885 info->n_stats = BNX2X_NUM_STATS;
7886 info->testinfo_len = BNX2X_NUM_TESTS;
7887 info->eedump_len = bp->common.flash_size;
7888 info->regdump_len = 0;
7889 }
7890
7891 static void bnx2x_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
7892 {
7893 struct bnx2x *bp = netdev_priv(dev);
7894
7895 if (bp->flags & NO_WOL_FLAG) {
7896 wol->supported = 0;
7897 wol->wolopts = 0;
7898 } else {
7899 wol->supported = WAKE_MAGIC;
7900 if (bp->wol)
7901 wol->wolopts = WAKE_MAGIC;
7902 else
7903 wol->wolopts = 0;
7904 }
7905 memset(&wol->sopass, 0, sizeof(wol->sopass));
7906 }
7907
7908 static int bnx2x_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
7909 {
7910 struct bnx2x *bp = netdev_priv(dev);
7911
7912 if (wol->wolopts & ~WAKE_MAGIC)
7913 return -EINVAL;
7914
7915 if (wol->wolopts & WAKE_MAGIC) {
7916 if (bp->flags & NO_WOL_FLAG)
7917 return -EINVAL;
7918
7919 bp->wol = 1;
7920 } else
7921 bp->wol = 0;
7922
7923 return 0;
7924 }
7925
7926 static u32 bnx2x_get_msglevel(struct net_device *dev)
7927 {
7928 struct bnx2x *bp = netdev_priv(dev);
7929
7930 return bp->msglevel;
7931 }
7932
7933 static void bnx2x_set_msglevel(struct net_device *dev, u32 level)
7934 {
7935 struct bnx2x *bp = netdev_priv(dev);
7936
7937 if (capable(CAP_NET_ADMIN))
7938 bp->msglevel = level;
7939 }
7940
7941 static int bnx2x_nway_reset(struct net_device *dev)
7942 {
7943 struct bnx2x *bp = netdev_priv(dev);
7944
7945 if (!bp->port.pmf)
7946 return 0;
7947
7948 if (netif_running(dev)) {
7949 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
7950 bnx2x_link_set(bp);
7951 }
7952
7953 return 0;
7954 }
7955
7956 static int bnx2x_get_eeprom_len(struct net_device *dev)
7957 {
7958 struct bnx2x *bp = netdev_priv(dev);
7959
7960 return bp->common.flash_size;
7961 }
7962
7963 static int bnx2x_acquire_nvram_lock(struct bnx2x *bp)
7964 {
7965 int port = BP_PORT(bp);
7966 int count, i;
7967 u32 val = 0;
7968
7969 /* adjust timeout for emulation/FPGA */
7970 count = NVRAM_TIMEOUT_COUNT;
7971 if (CHIP_REV_IS_SLOW(bp))
7972 count *= 100;
7973
7974 /* request access to nvram interface */
7975 REG_WR(bp, MCP_REG_MCPR_NVM_SW_ARB,
7976 (MCPR_NVM_SW_ARB_ARB_REQ_SET1 << port));
7977
7978 for (i = 0; i < count*10; i++) {
7979 val = REG_RD(bp, MCP_REG_MCPR_NVM_SW_ARB);
7980 if (val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port))
7981 break;
7982
7983 udelay(5);
7984 }
7985
7986 if (!(val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port))) {
7987 DP(BNX2X_MSG_NVM, "cannot get access to nvram interface\n");
7988 return -EBUSY;
7989 }
7990
7991 return 0;
7992 }
7993
7994 static int bnx2x_release_nvram_lock(struct bnx2x *bp)
7995 {
7996 int port = BP_PORT(bp);
7997 int count, i;
7998 u32 val = 0;
7999
8000 /* adjust timeout for emulation/FPGA */
8001 count = NVRAM_TIMEOUT_COUNT;
8002 if (CHIP_REV_IS_SLOW(bp))
8003 count *= 100;
8004
8005 /* relinquish nvram interface */
8006 REG_WR(bp, MCP_REG_MCPR_NVM_SW_ARB,
8007 (MCPR_NVM_SW_ARB_ARB_REQ_CLR1 << port));
8008
8009 for (i = 0; i < count*10; i++) {
8010 val = REG_RD(bp, MCP_REG_MCPR_NVM_SW_ARB);
8011 if (!(val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port)))
8012 break;
8013
8014 udelay(5);
8015 }
8016
8017 if (val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port)) {
8018 DP(BNX2X_MSG_NVM, "cannot free access to nvram interface\n");
8019 return -EBUSY;
8020 }
8021
8022 return 0;
8023 }
8024
8025 static void bnx2x_enable_nvram_access(struct bnx2x *bp)
8026 {
8027 u32 val;
8028
8029 val = REG_RD(bp, MCP_REG_MCPR_NVM_ACCESS_ENABLE);
8030
8031 /* enable both bits, even on read */
8032 REG_WR(bp, MCP_REG_MCPR_NVM_ACCESS_ENABLE,
8033 (val | MCPR_NVM_ACCESS_ENABLE_EN |
8034 MCPR_NVM_ACCESS_ENABLE_WR_EN));
8035 }
8036
8037 static void bnx2x_disable_nvram_access(struct bnx2x *bp)
8038 {
8039 u32 val;
8040
8041 val = REG_RD(bp, MCP_REG_MCPR_NVM_ACCESS_ENABLE);
8042
8043 /* disable both bits, even after read */
8044 REG_WR(bp, MCP_REG_MCPR_NVM_ACCESS_ENABLE,
8045 (val & ~(MCPR_NVM_ACCESS_ENABLE_EN |
8046 MCPR_NVM_ACCESS_ENABLE_WR_EN)));
8047 }
8048
8049 static int bnx2x_nvram_read_dword(struct bnx2x *bp, u32 offset, u32 *ret_val,
8050 u32 cmd_flags)
8051 {
8052 int count, i, rc;
8053 u32 val;
8054
8055 /* build the command word */
8056 cmd_flags |= MCPR_NVM_COMMAND_DOIT;
8057
8058 /* need to clear DONE bit separately */
8059 REG_WR(bp, MCP_REG_MCPR_NVM_COMMAND, MCPR_NVM_COMMAND_DONE);
8060
8061 /* address of the NVRAM to read from */
8062 REG_WR(bp, MCP_REG_MCPR_NVM_ADDR,
8063 (offset & MCPR_NVM_ADDR_NVM_ADDR_VALUE));
8064
8065 /* issue a read command */
8066 REG_WR(bp, MCP_REG_MCPR_NVM_COMMAND, cmd_flags);
8067
8068 /* adjust timeout for emulation/FPGA */
8069 count = NVRAM_TIMEOUT_COUNT;
8070 if (CHIP_REV_IS_SLOW(bp))
8071 count *= 100;
8072
8073 /* wait for completion */
8074 *ret_val = 0;
8075 rc = -EBUSY;
8076 for (i = 0; i < count; i++) {
8077 udelay(5);
8078 val = REG_RD(bp, MCP_REG_MCPR_NVM_COMMAND);
8079
8080 if (val & MCPR_NVM_COMMAND_DONE) {
8081 val = REG_RD(bp, MCP_REG_MCPR_NVM_READ);
8082 /* we read nvram data in cpu order
8083 * but ethtool sees it as an array of bytes
8084 * converting to big-endian will do the work */
8085 val = cpu_to_be32(val);
8086 *ret_val = val;
8087 rc = 0;
8088 break;
8089 }
8090 }
8091
8092 return rc;
8093 }
8094
8095 static int bnx2x_nvram_read(struct bnx2x *bp, u32 offset, u8 *ret_buf,
8096 int buf_size)
8097 {
8098 int rc;
8099 u32 cmd_flags;
8100 u32 val;
8101
8102 if ((offset & 0x03) || (buf_size & 0x03) || (buf_size == 0)) {
8103 DP(BNX2X_MSG_NVM,
8104 "Invalid parameter: offset 0x%x buf_size 0x%x\n",
8105 offset, buf_size);
8106 return -EINVAL;
8107 }
8108
8109 if (offset + buf_size > bp->common.flash_size) {
8110 DP(BNX2X_MSG_NVM, "Invalid parameter: offset (0x%x) +"
8111 " buf_size (0x%x) > flash_size (0x%x)\n",
8112 offset, buf_size, bp->common.flash_size);
8113 return -EINVAL;
8114 }
8115
8116 /* request access to nvram interface */
8117 rc = bnx2x_acquire_nvram_lock(bp);
8118 if (rc)
8119 return rc;
8120
8121 /* enable access to nvram interface */
8122 bnx2x_enable_nvram_access(bp);
8123
8124 /* read the first word(s) */
8125 cmd_flags = MCPR_NVM_COMMAND_FIRST;
8126 while ((buf_size > sizeof(u32)) && (rc == 0)) {
8127 rc = bnx2x_nvram_read_dword(bp, offset, &val, cmd_flags);
8128 memcpy(ret_buf, &val, 4);
8129
8130 /* advance to the next dword */
8131 offset += sizeof(u32);
8132 ret_buf += sizeof(u32);
8133 buf_size -= sizeof(u32);
8134 cmd_flags = 0;
8135 }
8136
8137 if (rc == 0) {
8138 cmd_flags |= MCPR_NVM_COMMAND_LAST;
8139 rc = bnx2x_nvram_read_dword(bp, offset, &val, cmd_flags);
8140 memcpy(ret_buf, &val, 4);
8141 }
8142
8143 /* disable access to nvram interface */
8144 bnx2x_disable_nvram_access(bp);
8145 bnx2x_release_nvram_lock(bp);
8146
8147 return rc;
8148 }
8149
8150 static int bnx2x_get_eeprom(struct net_device *dev,
8151 struct ethtool_eeprom *eeprom, u8 *eebuf)
8152 {
8153 struct bnx2x *bp = netdev_priv(dev);
8154 int rc;
8155
8156 if (!netif_running(dev))
8157 return -EAGAIN;
8158
8159 DP(BNX2X_MSG_NVM, "ethtool_eeprom: cmd %d\n"
8160 DP_LEVEL " magic 0x%x offset 0x%x (%d) len 0x%x (%d)\n",
8161 eeprom->cmd, eeprom->magic, eeprom->offset, eeprom->offset,
8162 eeprom->len, eeprom->len);
8163
8164 /* parameters already validated in ethtool_get_eeprom */
8165
8166 rc = bnx2x_nvram_read(bp, eeprom->offset, eebuf, eeprom->len);
8167
8168 return rc;
8169 }
8170
8171 static int bnx2x_nvram_write_dword(struct bnx2x *bp, u32 offset, u32 val,
8172 u32 cmd_flags)
8173 {
8174 int count, i, rc;
8175
8176 /* build the command word */
8177 cmd_flags |= MCPR_NVM_COMMAND_DOIT | MCPR_NVM_COMMAND_WR;
8178
8179 /* need to clear DONE bit separately */
8180 REG_WR(bp, MCP_REG_MCPR_NVM_COMMAND, MCPR_NVM_COMMAND_DONE);
8181
8182 /* write the data */
8183 REG_WR(bp, MCP_REG_MCPR_NVM_WRITE, val);
8184
8185 /* address of the NVRAM to write to */
8186 REG_WR(bp, MCP_REG_MCPR_NVM_ADDR,
8187 (offset & MCPR_NVM_ADDR_NVM_ADDR_VALUE));
8188
8189 /* issue the write command */
8190 REG_WR(bp, MCP_REG_MCPR_NVM_COMMAND, cmd_flags);
8191
8192 /* adjust timeout for emulation/FPGA */
8193 count = NVRAM_TIMEOUT_COUNT;
8194 if (CHIP_REV_IS_SLOW(bp))
8195 count *= 100;
8196
8197 /* wait for completion */
8198 rc = -EBUSY;
8199 for (i = 0; i < count; i++) {
8200 udelay(5);
8201 val = REG_RD(bp, MCP_REG_MCPR_NVM_COMMAND);
8202 if (val & MCPR_NVM_COMMAND_DONE) {
8203 rc = 0;
8204 break;
8205 }
8206 }
8207
8208 return rc;
8209 }
8210
8211 #define BYTE_OFFSET(offset) (8 * (offset & 0x03))
8212
8213 static int bnx2x_nvram_write1(struct bnx2x *bp, u32 offset, u8 *data_buf,
8214 int buf_size)
8215 {
8216 int rc;
8217 u32 cmd_flags;
8218 u32 align_offset;
8219 u32 val;
8220
8221 if (offset + buf_size > bp->common.flash_size) {
8222 DP(BNX2X_MSG_NVM, "Invalid parameter: offset (0x%x) +"
8223 " buf_size (0x%x) > flash_size (0x%x)\n",
8224 offset, buf_size, bp->common.flash_size);
8225 return -EINVAL;
8226 }
8227
8228 /* request access to nvram interface */
8229 rc = bnx2x_acquire_nvram_lock(bp);
8230 if (rc)
8231 return rc;
8232
8233 /* enable access to nvram interface */
8234 bnx2x_enable_nvram_access(bp);
8235
8236 cmd_flags = (MCPR_NVM_COMMAND_FIRST | MCPR_NVM_COMMAND_LAST);
8237 align_offset = (offset & ~0x03);
8238 rc = bnx2x_nvram_read_dword(bp, align_offset, &val, cmd_flags);
8239
8240 if (rc == 0) {
8241 val &= ~(0xff << BYTE_OFFSET(offset));
8242 val |= (*data_buf << BYTE_OFFSET(offset));
8243
8244 /* nvram data is returned as an array of bytes
8245 * convert it back to cpu order */
8246 val = be32_to_cpu(val);
8247
8248 rc = bnx2x_nvram_write_dword(bp, align_offset, val,
8249 cmd_flags);
8250 }
8251
8252 /* disable access to nvram interface */
8253 bnx2x_disable_nvram_access(bp);
8254 bnx2x_release_nvram_lock(bp);
8255
8256 return rc;
8257 }
8258
8259 static int bnx2x_nvram_write(struct bnx2x *bp, u32 offset, u8 *data_buf,
8260 int buf_size)
8261 {
8262 int rc;
8263 u32 cmd_flags;
8264 u32 val;
8265 u32 written_so_far;
8266
8267 if (buf_size == 1) /* ethtool */
8268 return bnx2x_nvram_write1(bp, offset, data_buf, buf_size);
8269
8270 if ((offset & 0x03) || (buf_size & 0x03) || (buf_size == 0)) {
8271 DP(BNX2X_MSG_NVM,
8272 "Invalid parameter: offset 0x%x buf_size 0x%x\n",
8273 offset, buf_size);
8274 return -EINVAL;
8275 }
8276
8277 if (offset + buf_size > bp->common.flash_size) {
8278 DP(BNX2X_MSG_NVM, "Invalid parameter: offset (0x%x) +"
8279 " buf_size (0x%x) > flash_size (0x%x)\n",
8280 offset, buf_size, bp->common.flash_size);
8281 return -EINVAL;
8282 }
8283
8284 /* request access to nvram interface */
8285 rc = bnx2x_acquire_nvram_lock(bp);
8286 if (rc)
8287 return rc;
8288
8289 /* enable access to nvram interface */
8290 bnx2x_enable_nvram_access(bp);
8291
8292 written_so_far = 0;
8293 cmd_flags = MCPR_NVM_COMMAND_FIRST;
8294 while ((written_so_far < buf_size) && (rc == 0)) {
8295 if (written_so_far == (buf_size - sizeof(u32)))
8296 cmd_flags |= MCPR_NVM_COMMAND_LAST;
8297 else if (((offset + 4) % NVRAM_PAGE_SIZE) == 0)
8298 cmd_flags |= MCPR_NVM_COMMAND_LAST;
8299 else if ((offset % NVRAM_PAGE_SIZE) == 0)
8300 cmd_flags |= MCPR_NVM_COMMAND_FIRST;
8301
8302 memcpy(&val, data_buf, 4);
8303
8304 rc = bnx2x_nvram_write_dword(bp, offset, val, cmd_flags);
8305
8306 /* advance to the next dword */
8307 offset += sizeof(u32);
8308 data_buf += sizeof(u32);
8309 written_so_far += sizeof(u32);
8310 cmd_flags = 0;
8311 }
8312
8313 /* disable access to nvram interface */
8314 bnx2x_disable_nvram_access(bp);
8315 bnx2x_release_nvram_lock(bp);
8316
8317 return rc;
8318 }
8319
8320 static int bnx2x_set_eeprom(struct net_device *dev,
8321 struct ethtool_eeprom *eeprom, u8 *eebuf)
8322 {
8323 struct bnx2x *bp = netdev_priv(dev);
8324 int rc;
8325
8326 if (!netif_running(dev))
8327 return -EAGAIN;
8328
8329 DP(BNX2X_MSG_NVM, "ethtool_eeprom: cmd %d\n"
8330 DP_LEVEL " magic 0x%x offset 0x%x (%d) len 0x%x (%d)\n",
8331 eeprom->cmd, eeprom->magic, eeprom->offset, eeprom->offset,
8332 eeprom->len, eeprom->len);
8333
8334 /* parameters already validated in ethtool_set_eeprom */
8335
8336 /* If the magic number is PHY (0x00504859) upgrade the PHY FW */
8337 if (eeprom->magic == 0x00504859)
8338 if (bp->port.pmf) {
8339
8340 bnx2x_acquire_phy_lock(bp);
8341 rc = bnx2x_flash_download(bp, BP_PORT(bp),
8342 bp->link_params.ext_phy_config,
8343 (bp->state != BNX2X_STATE_CLOSED),
8344 eebuf, eeprom->len);
8345 if ((bp->state == BNX2X_STATE_OPEN) ||
8346 (bp->state == BNX2X_STATE_DISABLED)) {
8347 rc |= bnx2x_link_reset(&bp->link_params,
8348 &bp->link_vars);
8349 rc |= bnx2x_phy_init(&bp->link_params,
8350 &bp->link_vars);
8351 }
8352 bnx2x_release_phy_lock(bp);
8353
8354 } else /* Only the PMF can access the PHY */
8355 return -EINVAL;
8356 else
8357 rc = bnx2x_nvram_write(bp, eeprom->offset, eebuf, eeprom->len);
8358
8359 return rc;
8360 }
8361
8362 static int bnx2x_get_coalesce(struct net_device *dev,
8363 struct ethtool_coalesce *coal)
8364 {
8365 struct bnx2x *bp = netdev_priv(dev);
8366
8367 memset(coal, 0, sizeof(struct ethtool_coalesce));
8368
8369 coal->rx_coalesce_usecs = bp->rx_ticks;
8370 coal->tx_coalesce_usecs = bp->tx_ticks;
8371
8372 return 0;
8373 }
8374
8375 static int bnx2x_set_coalesce(struct net_device *dev,
8376 struct ethtool_coalesce *coal)
8377 {
8378 struct bnx2x *bp = netdev_priv(dev);
8379
8380 bp->rx_ticks = (u16) coal->rx_coalesce_usecs;
8381 if (bp->rx_ticks > 3000)
8382 bp->rx_ticks = 3000;
8383
8384 bp->tx_ticks = (u16) coal->tx_coalesce_usecs;
8385 if (bp->tx_ticks > 0x3000)
8386 bp->tx_ticks = 0x3000;
8387
8388 if (netif_running(dev))
8389 bnx2x_update_coalesce(bp);
8390
8391 return 0;
8392 }
8393
8394 static void bnx2x_get_ringparam(struct net_device *dev,
8395 struct ethtool_ringparam *ering)
8396 {
8397 struct bnx2x *bp = netdev_priv(dev);
8398
8399 ering->rx_max_pending = MAX_RX_AVAIL;
8400 ering->rx_mini_max_pending = 0;
8401 ering->rx_jumbo_max_pending = 0;
8402
8403 ering->rx_pending = bp->rx_ring_size;
8404 ering->rx_mini_pending = 0;
8405 ering->rx_jumbo_pending = 0;
8406
8407 ering->tx_max_pending = MAX_TX_AVAIL;
8408 ering->tx_pending = bp->tx_ring_size;
8409 }
8410
8411 static int bnx2x_set_ringparam(struct net_device *dev,
8412 struct ethtool_ringparam *ering)
8413 {
8414 struct bnx2x *bp = netdev_priv(dev);
8415 int rc = 0;
8416
8417 if ((ering->rx_pending > MAX_RX_AVAIL) ||
8418 (ering->tx_pending > MAX_TX_AVAIL) ||
8419 (ering->tx_pending <= MAX_SKB_FRAGS + 4))
8420 return -EINVAL;
8421
8422 bp->rx_ring_size = ering->rx_pending;
8423 bp->tx_ring_size = ering->tx_pending;
8424
8425 if (netif_running(dev)) {
8426 bnx2x_nic_unload(bp, UNLOAD_NORMAL);
8427 rc = bnx2x_nic_load(bp, LOAD_NORMAL);
8428 }
8429
8430 return rc;
8431 }
8432
8433 static void bnx2x_get_pauseparam(struct net_device *dev,
8434 struct ethtool_pauseparam *epause)
8435 {
8436 struct bnx2x *bp = netdev_priv(dev);
8437
8438 epause->autoneg = (bp->link_params.req_flow_ctrl == BNX2X_FLOW_CTRL_AUTO) &&
8439 (bp->link_params.req_line_speed == SPEED_AUTO_NEG);
8440
8441 epause->rx_pause = ((bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_RX) ==
8442 BNX2X_FLOW_CTRL_RX);
8443 epause->tx_pause = ((bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_TX) ==
8444 BNX2X_FLOW_CTRL_TX);
8445
8446 DP(NETIF_MSG_LINK, "ethtool_pauseparam: cmd %d\n"
8447 DP_LEVEL " autoneg %d rx_pause %d tx_pause %d\n",
8448 epause->cmd, epause->autoneg, epause->rx_pause, epause->tx_pause);
8449 }
8450
8451 static int bnx2x_set_pauseparam(struct net_device *dev,
8452 struct ethtool_pauseparam *epause)
8453 {
8454 struct bnx2x *bp = netdev_priv(dev);
8455
8456 if (IS_E1HMF(bp))
8457 return 0;
8458
8459 DP(NETIF_MSG_LINK, "ethtool_pauseparam: cmd %d\n"
8460 DP_LEVEL " autoneg %d rx_pause %d tx_pause %d\n",
8461 epause->cmd, epause->autoneg, epause->rx_pause, epause->tx_pause);
8462
8463 bp->link_params.req_flow_ctrl = BNX2X_FLOW_CTRL_AUTO;
8464
8465 if (epause->rx_pause)
8466 bp->link_params.req_flow_ctrl |= BNX2X_FLOW_CTRL_RX;
8467
8468 if (epause->tx_pause)
8469 bp->link_params.req_flow_ctrl |= BNX2X_FLOW_CTRL_TX;
8470
8471 if (bp->link_params.req_flow_ctrl == BNX2X_FLOW_CTRL_AUTO)
8472 bp->link_params.req_flow_ctrl = BNX2X_FLOW_CTRL_NONE;
8473
8474 if (epause->autoneg) {
8475 if (!(bp->port.supported & SUPPORTED_Autoneg)) {
8476 DP(NETIF_MSG_LINK, "autoneg not supported\n");
8477 return -EINVAL;
8478 }
8479
8480 if (bp->link_params.req_line_speed == SPEED_AUTO_NEG)
8481 bp->link_params.req_flow_ctrl = BNX2X_FLOW_CTRL_AUTO;
8482 }
8483
8484 DP(NETIF_MSG_LINK,
8485 "req_flow_ctrl 0x%x\n", bp->link_params.req_flow_ctrl);
8486
8487 if (netif_running(dev)) {
8488 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
8489 bnx2x_link_set(bp);
8490 }
8491
8492 return 0;
8493 }
8494
8495 static int bnx2x_set_flags(struct net_device *dev, u32 data)
8496 {
8497 struct bnx2x *bp = netdev_priv(dev);
8498 int changed = 0;
8499 int rc = 0;
8500
8501 /* TPA requires Rx CSUM offloading */
8502 if ((data & ETH_FLAG_LRO) && bp->rx_csum) {
8503 if (!(dev->features & NETIF_F_LRO)) {
8504 dev->features |= NETIF_F_LRO;
8505 bp->flags |= TPA_ENABLE_FLAG;
8506 changed = 1;
8507 }
8508
8509 } else if (dev->features & NETIF_F_LRO) {
8510 dev->features &= ~NETIF_F_LRO;
8511 bp->flags &= ~TPA_ENABLE_FLAG;
8512 changed = 1;
8513 }
8514
8515 if (changed && netif_running(dev)) {
8516 bnx2x_nic_unload(bp, UNLOAD_NORMAL);
8517 rc = bnx2x_nic_load(bp, LOAD_NORMAL);
8518 }
8519
8520 return rc;
8521 }
8522
8523 static u32 bnx2x_get_rx_csum(struct net_device *dev)
8524 {
8525 struct bnx2x *bp = netdev_priv(dev);
8526
8527 return bp->rx_csum;
8528 }
8529
8530 static int bnx2x_set_rx_csum(struct net_device *dev, u32 data)
8531 {
8532 struct bnx2x *bp = netdev_priv(dev);
8533 int rc = 0;
8534
8535 bp->rx_csum = data;
8536
8537 /* Disable TPA, when Rx CSUM is disabled. Otherwise all
8538 TPA'ed packets will be discarded due to wrong TCP CSUM */
8539 if (!data) {
8540 u32 flags = ethtool_op_get_flags(dev);
8541
8542 rc = bnx2x_set_flags(dev, (flags & ~ETH_FLAG_LRO));
8543 }
8544
8545 return rc;
8546 }
8547
8548 static int bnx2x_set_tso(struct net_device *dev, u32 data)
8549 {
8550 if (data) {
8551 dev->features |= (NETIF_F_TSO | NETIF_F_TSO_ECN);
8552 dev->features |= NETIF_F_TSO6;
8553 } else {
8554 dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO_ECN);
8555 dev->features &= ~NETIF_F_TSO6;
8556 }
8557
8558 return 0;
8559 }
8560
8561 static const struct {
8562 char string[ETH_GSTRING_LEN];
8563 } bnx2x_tests_str_arr[BNX2X_NUM_TESTS] = {
8564 { "register_test (offline)" },
8565 { "memory_test (offline)" },
8566 { "loopback_test (offline)" },
8567 { "nvram_test (online)" },
8568 { "interrupt_test (online)" },
8569 { "link_test (online)" },
8570 { "idle check (online)" },
8571 { "MC errors (online)" }
8572 };
8573
8574 static int bnx2x_self_test_count(struct net_device *dev)
8575 {
8576 return BNX2X_NUM_TESTS;
8577 }
8578
8579 static int bnx2x_test_registers(struct bnx2x *bp)
8580 {
8581 int idx, i, rc = -ENODEV;
8582 u32 wr_val = 0;
8583 int port = BP_PORT(bp);
8584 static const struct {
8585 u32 offset0;
8586 u32 offset1;
8587 u32 mask;
8588 } reg_tbl[] = {
8589 /* 0 */ { BRB1_REG_PAUSE_LOW_THRESHOLD_0, 4, 0x000003ff },
8590 { DORQ_REG_DB_ADDR0, 4, 0xffffffff },
8591 { HC_REG_AGG_INT_0, 4, 0x000003ff },
8592 { PBF_REG_MAC_IF0_ENABLE, 4, 0x00000001 },
8593 { PBF_REG_P0_INIT_CRD, 4, 0x000007ff },
8594 { PRS_REG_CID_PORT_0, 4, 0x00ffffff },
8595 { PXP2_REG_PSWRQ_CDU0_L2P, 4, 0x000fffff },
8596 { PXP2_REG_RQ_CDU0_EFIRST_MEM_ADDR, 8, 0x0003ffff },
8597 { PXP2_REG_PSWRQ_TM0_L2P, 4, 0x000fffff },
8598 { PXP2_REG_RQ_USDM0_EFIRST_MEM_ADDR, 8, 0x0003ffff },
8599 /* 10 */ { PXP2_REG_PSWRQ_TSDM0_L2P, 4, 0x000fffff },
8600 { QM_REG_CONNNUM_0, 4, 0x000fffff },
8601 { TM_REG_LIN0_MAX_ACTIVE_CID, 4, 0x0003ffff },
8602 { SRC_REG_KEYRSS0_0, 40, 0xffffffff },
8603 { SRC_REG_KEYRSS0_7, 40, 0xffffffff },
8604 { XCM_REG_WU_DA_SET_TMR_CNT_FLG_CMD00, 4, 0x00000001 },
8605 { XCM_REG_WU_DA_CNT_CMD00, 4, 0x00000003 },
8606 { XCM_REG_GLB_DEL_ACK_MAX_CNT_0, 4, 0x000000ff },
8607 { NIG_REG_EGRESS_MNG0_FIFO, 20, 0xffffffff },
8608 { NIG_REG_LLH0_T_BIT, 4, 0x00000001 },
8609 /* 20 */ { NIG_REG_EMAC0_IN_EN, 4, 0x00000001 },
8610 { NIG_REG_BMAC0_IN_EN, 4, 0x00000001 },
8611 { NIG_REG_XCM0_OUT_EN, 4, 0x00000001 },
8612 { NIG_REG_BRB0_OUT_EN, 4, 0x00000001 },
8613 { NIG_REG_LLH0_XCM_MASK, 4, 0x00000007 },
8614 { NIG_REG_LLH0_ACPI_PAT_6_LEN, 68, 0x000000ff },
8615 { NIG_REG_LLH0_ACPI_PAT_0_CRC, 68, 0xffffffff },
8616 { NIG_REG_LLH0_DEST_MAC_0_0, 160, 0xffffffff },
8617 { NIG_REG_LLH0_DEST_IP_0_1, 160, 0xffffffff },
8618 { NIG_REG_LLH0_IPV4_IPV6_0, 160, 0x00000001 },
8619 /* 30 */ { NIG_REG_LLH0_DEST_UDP_0, 160, 0x0000ffff },
8620 { NIG_REG_LLH0_DEST_TCP_0, 160, 0x0000ffff },
8621 { NIG_REG_LLH0_VLAN_ID_0, 160, 0x00000fff },
8622 { NIG_REG_XGXS_SERDES0_MODE_SEL, 4, 0x00000001 },
8623 { NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0, 4, 0x00000001 },
8624 { NIG_REG_STATUS_INTERRUPT_PORT0, 4, 0x07ffffff },
8625 { NIG_REG_XGXS0_CTRL_EXTREMOTEMDIOST, 24, 0x00000001 },
8626 { NIG_REG_SERDES0_CTRL_PHY_ADDR, 16, 0x0000001f },
8627
8628 { 0xffffffff, 0, 0x00000000 }
8629 };
8630
8631 if (!netif_running(bp->dev))
8632 return rc;
8633
8634 /* Repeat the test twice:
8635 First by writing 0x00000000, second by writing 0xffffffff */
8636 for (idx = 0; idx < 2; idx++) {
8637
8638 switch (idx) {
8639 case 0:
8640 wr_val = 0;
8641 break;
8642 case 1:
8643 wr_val = 0xffffffff;
8644 break;
8645 }
8646
8647 for (i = 0; reg_tbl[i].offset0 != 0xffffffff; i++) {
8648 u32 offset, mask, save_val, val;
8649
8650 offset = reg_tbl[i].offset0 + port*reg_tbl[i].offset1;
8651 mask = reg_tbl[i].mask;
8652
8653 save_val = REG_RD(bp, offset);
8654
8655 REG_WR(bp, offset, wr_val);
8656 val = REG_RD(bp, offset);
8657
8658 /* Restore the original register's value */
8659 REG_WR(bp, offset, save_val);
8660
8661 /* verify that value is as expected value */
8662 if ((val & mask) != (wr_val & mask))
8663 goto test_reg_exit;
8664 }
8665 }
8666
8667 rc = 0;
8668
8669 test_reg_exit:
8670 return rc;
8671 }
8672
8673 static int bnx2x_test_memory(struct bnx2x *bp)
8674 {
8675 int i, j, rc = -ENODEV;
8676 u32 val;
8677 static const struct {
8678 u32 offset;
8679 int size;
8680 } mem_tbl[] = {
8681 { CCM_REG_XX_DESCR_TABLE, CCM_REG_XX_DESCR_TABLE_SIZE },
8682 { CFC_REG_ACTIVITY_COUNTER, CFC_REG_ACTIVITY_COUNTER_SIZE },
8683 { CFC_REG_LINK_LIST, CFC_REG_LINK_LIST_SIZE },
8684 { DMAE_REG_CMD_MEM, DMAE_REG_CMD_MEM_SIZE },
8685 { TCM_REG_XX_DESCR_TABLE, TCM_REG_XX_DESCR_TABLE_SIZE },
8686 { UCM_REG_XX_DESCR_TABLE, UCM_REG_XX_DESCR_TABLE_SIZE },
8687 { XCM_REG_XX_DESCR_TABLE, XCM_REG_XX_DESCR_TABLE_SIZE },
8688
8689 { 0xffffffff, 0 }
8690 };
8691 static const struct {
8692 char *name;
8693 u32 offset;
8694 u32 e1_mask;
8695 u32 e1h_mask;
8696 } prty_tbl[] = {
8697 { "CCM_PRTY_STS", CCM_REG_CCM_PRTY_STS, 0x3ffc0, 0 },
8698 { "CFC_PRTY_STS", CFC_REG_CFC_PRTY_STS, 0x2, 0x2 },
8699 { "DMAE_PRTY_STS", DMAE_REG_DMAE_PRTY_STS, 0, 0 },
8700 { "TCM_PRTY_STS", TCM_REG_TCM_PRTY_STS, 0x3ffc0, 0 },
8701 { "UCM_PRTY_STS", UCM_REG_UCM_PRTY_STS, 0x3ffc0, 0 },
8702 { "XCM_PRTY_STS", XCM_REG_XCM_PRTY_STS, 0x3ffc1, 0 },
8703
8704 { NULL, 0xffffffff, 0, 0 }
8705 };
8706
8707 if (!netif_running(bp->dev))
8708 return rc;
8709
8710 /* Go through all the memories */
8711 for (i = 0; mem_tbl[i].offset != 0xffffffff; i++)
8712 for (j = 0; j < mem_tbl[i].size; j++)
8713 REG_RD(bp, mem_tbl[i].offset + j*4);
8714
8715 /* Check the parity status */
8716 for (i = 0; prty_tbl[i].offset != 0xffffffff; i++) {
8717 val = REG_RD(bp, prty_tbl[i].offset);
8718 if ((CHIP_IS_E1(bp) && (val & ~(prty_tbl[i].e1_mask))) ||
8719 (CHIP_IS_E1H(bp) && (val & ~(prty_tbl[i].e1h_mask)))) {
8720 DP(NETIF_MSG_HW,
8721 "%s is 0x%x\n", prty_tbl[i].name, val);
8722 goto test_mem_exit;
8723 }
8724 }
8725
8726 rc = 0;
8727
8728 test_mem_exit:
8729 return rc;
8730 }
8731
8732 static void bnx2x_wait_for_link(struct bnx2x *bp, u8 link_up)
8733 {
8734 int cnt = 1000;
8735
8736 if (link_up)
8737 while (bnx2x_link_test(bp) && cnt--)
8738 msleep(10);
8739 }
8740
8741 static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
8742 {
8743 unsigned int pkt_size, num_pkts, i;
8744 struct sk_buff *skb;
8745 unsigned char *packet;
8746 struct bnx2x_fastpath *fp = &bp->fp[0];
8747 u16 tx_start_idx, tx_idx;
8748 u16 rx_start_idx, rx_idx;
8749 u16 pkt_prod;
8750 struct sw_tx_bd *tx_buf;
8751 struct eth_tx_bd *tx_bd;
8752 dma_addr_t mapping;
8753 union eth_rx_cqe *cqe;
8754 u8 cqe_fp_flags;
8755 struct sw_rx_bd *rx_buf;
8756 u16 len;
8757 int rc = -ENODEV;
8758
8759 if (loopback_mode == BNX2X_MAC_LOOPBACK) {
8760 bp->link_params.loopback_mode = LOOPBACK_BMAC;
8761 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
8762
8763 } else if (loopback_mode == BNX2X_PHY_LOOPBACK) {
8764 u16 cnt = 1000;
8765 bp->link_params.loopback_mode = LOOPBACK_XGXS_10;
8766 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
8767 /* wait until link state is restored */
8768 if (link_up)
8769 while (cnt-- && bnx2x_test_link(&bp->link_params,
8770 &bp->link_vars))
8771 msleep(10);
8772 } else
8773 return -EINVAL;
8774
8775 pkt_size = 1514;
8776 skb = netdev_alloc_skb(bp->dev, bp->rx_buf_size);
8777 if (!skb) {
8778 rc = -ENOMEM;
8779 goto test_loopback_exit;
8780 }
8781 packet = skb_put(skb, pkt_size);
8782 memcpy(packet, bp->dev->dev_addr, ETH_ALEN);
8783 memset(packet + ETH_ALEN, 0, (ETH_HLEN - ETH_ALEN));
8784 for (i = ETH_HLEN; i < pkt_size; i++)
8785 packet[i] = (unsigned char) (i & 0xff);
8786
8787 num_pkts = 0;
8788 tx_start_idx = le16_to_cpu(*fp->tx_cons_sb);
8789 rx_start_idx = le16_to_cpu(*fp->rx_cons_sb);
8790
8791 pkt_prod = fp->tx_pkt_prod++;
8792 tx_buf = &fp->tx_buf_ring[TX_BD(pkt_prod)];
8793 tx_buf->first_bd = fp->tx_bd_prod;
8794 tx_buf->skb = skb;
8795
8796 tx_bd = &fp->tx_desc_ring[TX_BD(fp->tx_bd_prod)];
8797 mapping = pci_map_single(bp->pdev, skb->data,
8798 skb_headlen(skb), PCI_DMA_TODEVICE);
8799 tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
8800 tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
8801 tx_bd->nbd = cpu_to_le16(1);
8802 tx_bd->nbytes = cpu_to_le16(skb_headlen(skb));
8803 tx_bd->vlan = cpu_to_le16(pkt_prod);
8804 tx_bd->bd_flags.as_bitfield = (ETH_TX_BD_FLAGS_START_BD |
8805 ETH_TX_BD_FLAGS_END_BD);
8806 tx_bd->general_data = ((UNICAST_ADDRESS <<
8807 ETH_TX_BD_ETH_ADDR_TYPE_SHIFT) | 1);
8808
8809 wmb();
8810
8811 fp->hw_tx_prods->bds_prod =
8812 cpu_to_le16(le16_to_cpu(fp->hw_tx_prods->bds_prod) + 1);
8813 mb(); /* FW restriction: must not reorder writing nbd and packets */
8814 fp->hw_tx_prods->packets_prod =
8815 cpu_to_le32(le32_to_cpu(fp->hw_tx_prods->packets_prod) + 1);
8816 DOORBELL(bp, FP_IDX(fp), 0);
8817
8818 mmiowb();
8819
8820 num_pkts++;
8821 fp->tx_bd_prod++;
8822 bp->dev->trans_start = jiffies;
8823
8824 udelay(100);
8825
8826 tx_idx = le16_to_cpu(*fp->tx_cons_sb);
8827 if (tx_idx != tx_start_idx + num_pkts)
8828 goto test_loopback_exit;
8829
8830 rx_idx = le16_to_cpu(*fp->rx_cons_sb);
8831 if (rx_idx != rx_start_idx + num_pkts)
8832 goto test_loopback_exit;
8833
8834 cqe = &fp->rx_comp_ring[RCQ_BD(fp->rx_comp_cons)];
8835 cqe_fp_flags = cqe->fast_path_cqe.type_error_flags;
8836 if (CQE_TYPE(cqe_fp_flags) || (cqe_fp_flags & ETH_RX_ERROR_FALGS))
8837 goto test_loopback_rx_exit;
8838
8839 len = le16_to_cpu(cqe->fast_path_cqe.pkt_len);
8840 if (len != pkt_size)
8841 goto test_loopback_rx_exit;
8842
8843 rx_buf = &fp->rx_buf_ring[RX_BD(fp->rx_bd_cons)];
8844 skb = rx_buf->skb;
8845 skb_reserve(skb, cqe->fast_path_cqe.placement_offset);
8846 for (i = ETH_HLEN; i < pkt_size; i++)
8847 if (*(skb->data + i) != (unsigned char) (i & 0xff))
8848 goto test_loopback_rx_exit;
8849
8850 rc = 0;
8851
8852 test_loopback_rx_exit:
8853
8854 fp->rx_bd_cons = NEXT_RX_IDX(fp->rx_bd_cons);
8855 fp->rx_bd_prod = NEXT_RX_IDX(fp->rx_bd_prod);
8856 fp->rx_comp_cons = NEXT_RCQ_IDX(fp->rx_comp_cons);
8857 fp->rx_comp_prod = NEXT_RCQ_IDX(fp->rx_comp_prod);
8858
8859 /* Update producers */
8860 bnx2x_update_rx_prod(bp, fp, fp->rx_bd_prod, fp->rx_comp_prod,
8861 fp->rx_sge_prod);
8862
8863 test_loopback_exit:
8864 bp->link_params.loopback_mode = LOOPBACK_NONE;
8865
8866 return rc;
8867 }
8868
8869 static int bnx2x_test_loopback(struct bnx2x *bp, u8 link_up)
8870 {
8871 int rc = 0;
8872
8873 if (!netif_running(bp->dev))
8874 return BNX2X_LOOPBACK_FAILED;
8875
8876 bnx2x_netif_stop(bp, 1);
8877 bnx2x_acquire_phy_lock(bp);
8878
8879 if (bnx2x_run_loopback(bp, BNX2X_MAC_LOOPBACK, link_up)) {
8880 DP(NETIF_MSG_PROBE, "MAC loopback failed\n");
8881 rc |= BNX2X_MAC_LOOPBACK_FAILED;
8882 }
8883
8884 if (bnx2x_run_loopback(bp, BNX2X_PHY_LOOPBACK, link_up)) {
8885 DP(NETIF_MSG_PROBE, "PHY loopback failed\n");
8886 rc |= BNX2X_PHY_LOOPBACK_FAILED;
8887 }
8888
8889 bnx2x_release_phy_lock(bp);
8890 bnx2x_netif_start(bp);
8891
8892 return rc;
8893 }
8894
8895 #define CRC32_RESIDUAL 0xdebb20e3
8896
8897 static int bnx2x_test_nvram(struct bnx2x *bp)
8898 {
8899 static const struct {
8900 int offset;
8901 int size;
8902 } nvram_tbl[] = {
8903 { 0, 0x14 }, /* bootstrap */
8904 { 0x14, 0xec }, /* dir */
8905 { 0x100, 0x350 }, /* manuf_info */
8906 { 0x450, 0xf0 }, /* feature_info */
8907 { 0x640, 0x64 }, /* upgrade_key_info */
8908 { 0x6a4, 0x64 },
8909 { 0x708, 0x70 }, /* manuf_key_info */
8910 { 0x778, 0x70 },
8911 { 0, 0 }
8912 };
8913 u32 buf[0x350 / 4];
8914 u8 *data = (u8 *)buf;
8915 int i, rc;
8916 u32 magic, csum;
8917
8918 rc = bnx2x_nvram_read(bp, 0, data, 4);
8919 if (rc) {
8920 DP(NETIF_MSG_PROBE, "magic value read (rc -%d)\n", -rc);
8921 goto test_nvram_exit;
8922 }
8923
8924 magic = be32_to_cpu(buf[0]);
8925 if (magic != 0x669955aa) {
8926 DP(NETIF_MSG_PROBE, "magic value (0x%08x)\n", magic);
8927 rc = -ENODEV;
8928 goto test_nvram_exit;
8929 }
8930
8931 for (i = 0; nvram_tbl[i].size; i++) {
8932
8933 rc = bnx2x_nvram_read(bp, nvram_tbl[i].offset, data,
8934 nvram_tbl[i].size);
8935 if (rc) {
8936 DP(NETIF_MSG_PROBE,
8937 "nvram_tbl[%d] read data (rc -%d)\n", i, -rc);
8938 goto test_nvram_exit;
8939 }
8940
8941 csum = ether_crc_le(nvram_tbl[i].size, data);
8942 if (csum != CRC32_RESIDUAL) {
8943 DP(NETIF_MSG_PROBE,
8944 "nvram_tbl[%d] csum value (0x%08x)\n", i, csum);
8945 rc = -ENODEV;
8946 goto test_nvram_exit;
8947 }
8948 }
8949
8950 test_nvram_exit:
8951 return rc;
8952 }
8953
8954 static int bnx2x_test_intr(struct bnx2x *bp)
8955 {
8956 struct mac_configuration_cmd *config = bnx2x_sp(bp, mac_config);
8957 int i, rc;
8958
8959 if (!netif_running(bp->dev))
8960 return -ENODEV;
8961
8962 config->hdr.length_6b = 0;
8963 if (CHIP_IS_E1(bp))
8964 config->hdr.offset = (BP_PORT(bp) ? 32 : 0);
8965 else
8966 config->hdr.offset = BP_FUNC(bp);
8967 config->hdr.client_id = BP_CL_ID(bp);
8968 config->hdr.reserved1 = 0;
8969
8970 rc = bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_SET_MAC, 0,
8971 U64_HI(bnx2x_sp_mapping(bp, mac_config)),
8972 U64_LO(bnx2x_sp_mapping(bp, mac_config)), 0);
8973 if (rc == 0) {
8974 bp->set_mac_pending++;
8975 for (i = 0; i < 10; i++) {
8976 if (!bp->set_mac_pending)
8977 break;
8978 msleep_interruptible(10);
8979 }
8980 if (i == 10)
8981 rc = -ENODEV;
8982 }
8983
8984 return rc;
8985 }
8986
8987 static void bnx2x_self_test(struct net_device *dev,
8988 struct ethtool_test *etest, u64 *buf)
8989 {
8990 struct bnx2x *bp = netdev_priv(dev);
8991
8992 memset(buf, 0, sizeof(u64) * BNX2X_NUM_TESTS);
8993
8994 if (!netif_running(dev))
8995 return;
8996
8997 /* offline tests are not supported in MF mode */
8998 if (IS_E1HMF(bp))
8999 etest->flags &= ~ETH_TEST_FL_OFFLINE;
9000
9001 if (etest->flags & ETH_TEST_FL_OFFLINE) {
9002 u8 link_up;
9003
9004 link_up = bp->link_vars.link_up;
9005 bnx2x_nic_unload(bp, UNLOAD_NORMAL);
9006 bnx2x_nic_load(bp, LOAD_DIAG);
9007 /* wait until link state is restored */
9008 bnx2x_wait_for_link(bp, link_up);
9009
9010 if (bnx2x_test_registers(bp) != 0) {
9011 buf[0] = 1;
9012 etest->flags |= ETH_TEST_FL_FAILED;
9013 }
9014 if (bnx2x_test_memory(bp) != 0) {
9015 buf[1] = 1;
9016 etest->flags |= ETH_TEST_FL_FAILED;
9017 }
9018 buf[2] = bnx2x_test_loopback(bp, link_up);
9019 if (buf[2] != 0)
9020 etest->flags |= ETH_TEST_FL_FAILED;
9021
9022 bnx2x_nic_unload(bp, UNLOAD_NORMAL);
9023 bnx2x_nic_load(bp, LOAD_NORMAL);
9024 /* wait until link state is restored */
9025 bnx2x_wait_for_link(bp, link_up);
9026 }
9027 if (bnx2x_test_nvram(bp) != 0) {
9028 buf[3] = 1;
9029 etest->flags |= ETH_TEST_FL_FAILED;
9030 }
9031 if (bnx2x_test_intr(bp) != 0) {
9032 buf[4] = 1;
9033 etest->flags |= ETH_TEST_FL_FAILED;
9034 }
9035 if (bp->port.pmf)
9036 if (bnx2x_link_test(bp) != 0) {
9037 buf[5] = 1;
9038 etest->flags |= ETH_TEST_FL_FAILED;
9039 }
9040 buf[7] = bnx2x_mc_assert(bp);
9041 if (buf[7] != 0)
9042 etest->flags |= ETH_TEST_FL_FAILED;
9043
9044 #ifdef BNX2X_EXTRA_DEBUG
9045 bnx2x_panic_dump(bp);
9046 #endif
9047 }
9048
9049 static const struct {
9050 long offset;
9051 int size;
9052 u32 flags;
9053 #define STATS_FLAGS_PORT 1
9054 #define STATS_FLAGS_FUNC 2
9055 u8 string[ETH_GSTRING_LEN];
9056 } bnx2x_stats_arr[BNX2X_NUM_STATS] = {
9057 /* 1 */ { STATS_OFFSET32(valid_bytes_received_hi),
9058 8, STATS_FLAGS_FUNC, "rx_bytes" },
9059 { STATS_OFFSET32(error_bytes_received_hi),
9060 8, STATS_FLAGS_FUNC, "rx_error_bytes" },
9061 { STATS_OFFSET32(total_bytes_transmitted_hi),
9062 8, STATS_FLAGS_FUNC, "tx_bytes" },
9063 { STATS_OFFSET32(tx_stat_ifhcoutbadoctets_hi),
9064 8, STATS_FLAGS_PORT, "tx_error_bytes" },
9065 { STATS_OFFSET32(total_unicast_packets_received_hi),
9066 8, STATS_FLAGS_FUNC, "rx_ucast_packets" },
9067 { STATS_OFFSET32(total_multicast_packets_received_hi),
9068 8, STATS_FLAGS_FUNC, "rx_mcast_packets" },
9069 { STATS_OFFSET32(total_broadcast_packets_received_hi),
9070 8, STATS_FLAGS_FUNC, "rx_bcast_packets" },
9071 { STATS_OFFSET32(total_unicast_packets_transmitted_hi),
9072 8, STATS_FLAGS_FUNC, "tx_packets" },
9073 { STATS_OFFSET32(tx_stat_dot3statsinternalmactransmiterrors_hi),
9074 8, STATS_FLAGS_PORT, "tx_mac_errors" },
9075 /* 10 */{ STATS_OFFSET32(rx_stat_dot3statscarriersenseerrors_hi),
9076 8, STATS_FLAGS_PORT, "tx_carrier_errors" },
9077 { STATS_OFFSET32(rx_stat_dot3statsfcserrors_hi),
9078 8, STATS_FLAGS_PORT, "rx_crc_errors" },
9079 { STATS_OFFSET32(rx_stat_dot3statsalignmenterrors_hi),
9080 8, STATS_FLAGS_PORT, "rx_align_errors" },
9081 { STATS_OFFSET32(tx_stat_dot3statssinglecollisionframes_hi),
9082 8, STATS_FLAGS_PORT, "tx_single_collisions" },
9083 { STATS_OFFSET32(tx_stat_dot3statsmultiplecollisionframes_hi),
9084 8, STATS_FLAGS_PORT, "tx_multi_collisions" },
9085 { STATS_OFFSET32(tx_stat_dot3statsdeferredtransmissions_hi),
9086 8, STATS_FLAGS_PORT, "tx_deferred" },
9087 { STATS_OFFSET32(tx_stat_dot3statsexcessivecollisions_hi),
9088 8, STATS_FLAGS_PORT, "tx_excess_collisions" },
9089 { STATS_OFFSET32(tx_stat_dot3statslatecollisions_hi),
9090 8, STATS_FLAGS_PORT, "tx_late_collisions" },
9091 { STATS_OFFSET32(tx_stat_etherstatscollisions_hi),
9092 8, STATS_FLAGS_PORT, "tx_total_collisions" },
9093 { STATS_OFFSET32(rx_stat_etherstatsfragments_hi),
9094 8, STATS_FLAGS_PORT, "rx_fragments" },
9095 /* 20 */{ STATS_OFFSET32(rx_stat_etherstatsjabbers_hi),
9096 8, STATS_FLAGS_PORT, "rx_jabbers" },
9097 { STATS_OFFSET32(rx_stat_etherstatsundersizepkts_hi),
9098 8, STATS_FLAGS_PORT, "rx_undersize_packets" },
9099 { STATS_OFFSET32(jabber_packets_received),
9100 4, STATS_FLAGS_FUNC, "rx_oversize_packets" },
9101 { STATS_OFFSET32(tx_stat_etherstatspkts64octets_hi),
9102 8, STATS_FLAGS_PORT, "tx_64_byte_packets" },
9103 { STATS_OFFSET32(tx_stat_etherstatspkts65octetsto127octets_hi),
9104 8, STATS_FLAGS_PORT, "tx_65_to_127_byte_packets" },
9105 { STATS_OFFSET32(tx_stat_etherstatspkts128octetsto255octets_hi),
9106 8, STATS_FLAGS_PORT, "tx_128_to_255_byte_packets" },
9107 { STATS_OFFSET32(tx_stat_etherstatspkts256octetsto511octets_hi),
9108 8, STATS_FLAGS_PORT, "tx_256_to_511_byte_packets" },
9109 { STATS_OFFSET32(tx_stat_etherstatspkts512octetsto1023octets_hi),
9110 8, STATS_FLAGS_PORT, "tx_512_to_1023_byte_packets" },
9111 { STATS_OFFSET32(etherstatspkts1024octetsto1522octets_hi),
9112 8, STATS_FLAGS_PORT, "tx_1024_to_1522_byte_packets" },
9113 { STATS_OFFSET32(etherstatspktsover1522octets_hi),
9114 8, STATS_FLAGS_PORT, "tx_1523_to_9022_byte_packets" },
9115 /* 30 */{ STATS_OFFSET32(rx_stat_xonpauseframesreceived_hi),
9116 8, STATS_FLAGS_PORT, "rx_xon_frames" },
9117 { STATS_OFFSET32(rx_stat_xoffpauseframesreceived_hi),
9118 8, STATS_FLAGS_PORT, "rx_xoff_frames" },
9119 { STATS_OFFSET32(tx_stat_outxonsent_hi),
9120 8, STATS_FLAGS_PORT, "tx_xon_frames" },
9121 { STATS_OFFSET32(tx_stat_outxoffsent_hi),
9122 8, STATS_FLAGS_PORT, "tx_xoff_frames" },
9123 { STATS_OFFSET32(rx_stat_maccontrolframesreceived_hi),
9124 8, STATS_FLAGS_PORT, "rx_mac_ctrl_frames" },
9125 { STATS_OFFSET32(mac_filter_discard),
9126 4, STATS_FLAGS_PORT, "rx_filtered_packets" },
9127 { STATS_OFFSET32(no_buff_discard),
9128 4, STATS_FLAGS_FUNC, "rx_discards" },
9129 { STATS_OFFSET32(xxoverflow_discard),
9130 4, STATS_FLAGS_PORT, "rx_fw_discards" },
9131 { STATS_OFFSET32(brb_drop_hi),
9132 8, STATS_FLAGS_PORT, "brb_discard" },
9133 { STATS_OFFSET32(brb_truncate_hi),
9134 8, STATS_FLAGS_PORT, "brb_truncate" },
9135 /* 40 */{ STATS_OFFSET32(rx_err_discard_pkt),
9136 4, STATS_FLAGS_FUNC, "rx_phy_ip_err_discards"},
9137 { STATS_OFFSET32(rx_skb_alloc_failed),
9138 4, STATS_FLAGS_FUNC, "rx_skb_alloc_discard" },
9139 /* 42 */{ STATS_OFFSET32(hw_csum_err),
9140 4, STATS_FLAGS_FUNC, "rx_csum_offload_errors" }
9141 };
9142
9143 #define IS_NOT_E1HMF_STAT(bp, i) \
9144 (IS_E1HMF(bp) && (bnx2x_stats_arr[i].flags & STATS_FLAGS_PORT))
9145
9146 static void bnx2x_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
9147 {
9148 struct bnx2x *bp = netdev_priv(dev);
9149 int i, j;
9150
9151 switch (stringset) {
9152 case ETH_SS_STATS:
9153 for (i = 0, j = 0; i < BNX2X_NUM_STATS; i++) {
9154 if (IS_NOT_E1HMF_STAT(bp, i))
9155 continue;
9156 strcpy(buf + j*ETH_GSTRING_LEN,
9157 bnx2x_stats_arr[i].string);
9158 j++;
9159 }
9160 break;
9161
9162 case ETH_SS_TEST:
9163 memcpy(buf, bnx2x_tests_str_arr, sizeof(bnx2x_tests_str_arr));
9164 break;
9165 }
9166 }
9167
9168 static int bnx2x_get_stats_count(struct net_device *dev)
9169 {
9170 struct bnx2x *bp = netdev_priv(dev);
9171 int i, num_stats = 0;
9172
9173 for (i = 0; i < BNX2X_NUM_STATS; i++) {
9174 if (IS_NOT_E1HMF_STAT(bp, i))
9175 continue;
9176 num_stats++;
9177 }
9178 return num_stats;
9179 }
9180
9181 static void bnx2x_get_ethtool_stats(struct net_device *dev,
9182 struct ethtool_stats *stats, u64 *buf)
9183 {
9184 struct bnx2x *bp = netdev_priv(dev);
9185 u32 *hw_stats = (u32 *)&bp->eth_stats;
9186 int i, j;
9187
9188 for (i = 0, j = 0; i < BNX2X_NUM_STATS; i++) {
9189 if (IS_NOT_E1HMF_STAT(bp, i))
9190 continue;
9191
9192 if (bnx2x_stats_arr[i].size == 0) {
9193 /* skip this counter */
9194 buf[j] = 0;
9195 j++;
9196 continue;
9197 }
9198 if (bnx2x_stats_arr[i].size == 4) {
9199 /* 4-byte counter */
9200 buf[j] = (u64) *(hw_stats + bnx2x_stats_arr[i].offset);
9201 j++;
9202 continue;
9203 }
9204 /* 8-byte counter */
9205 buf[j] = HILO_U64(*(hw_stats + bnx2x_stats_arr[i].offset),
9206 *(hw_stats + bnx2x_stats_arr[i].offset + 1));
9207 j++;
9208 }
9209 }
9210
9211 static int bnx2x_phys_id(struct net_device *dev, u32 data)
9212 {
9213 struct bnx2x *bp = netdev_priv(dev);
9214 int port = BP_PORT(bp);
9215 int i;
9216
9217 if (!netif_running(dev))
9218 return 0;
9219
9220 if (!bp->port.pmf)
9221 return 0;
9222
9223 if (data == 0)
9224 data = 2;
9225
9226 for (i = 0; i < (data * 2); i++) {
9227 if ((i % 2) == 0)
9228 bnx2x_set_led(bp, port, LED_MODE_OPER, SPEED_1000,
9229 bp->link_params.hw_led_mode,
9230 bp->link_params.chip_id);
9231 else
9232 bnx2x_set_led(bp, port, LED_MODE_OFF, 0,
9233 bp->link_params.hw_led_mode,
9234 bp->link_params.chip_id);
9235
9236 msleep_interruptible(500);
9237 if (signal_pending(current))
9238 break;
9239 }
9240
9241 if (bp->link_vars.link_up)
9242 bnx2x_set_led(bp, port, LED_MODE_OPER,
9243 bp->link_vars.line_speed,
9244 bp->link_params.hw_led_mode,
9245 bp->link_params.chip_id);
9246
9247 return 0;
9248 }
9249
9250 static struct ethtool_ops bnx2x_ethtool_ops = {
9251 .get_settings = bnx2x_get_settings,
9252 .set_settings = bnx2x_set_settings,
9253 .get_drvinfo = bnx2x_get_drvinfo,
9254 .get_wol = bnx2x_get_wol,
9255 .set_wol = bnx2x_set_wol,
9256 .get_msglevel = bnx2x_get_msglevel,
9257 .set_msglevel = bnx2x_set_msglevel,
9258 .nway_reset = bnx2x_nway_reset,
9259 .get_link = ethtool_op_get_link,
9260 .get_eeprom_len = bnx2x_get_eeprom_len,
9261 .get_eeprom = bnx2x_get_eeprom,
9262 .set_eeprom = bnx2x_set_eeprom,
9263 .get_coalesce = bnx2x_get_coalesce,
9264 .set_coalesce = bnx2x_set_coalesce,
9265 .get_ringparam = bnx2x_get_ringparam,
9266 .set_ringparam = bnx2x_set_ringparam,
9267 .get_pauseparam = bnx2x_get_pauseparam,
9268 .set_pauseparam = bnx2x_set_pauseparam,
9269 .get_rx_csum = bnx2x_get_rx_csum,
9270 .set_rx_csum = bnx2x_set_rx_csum,
9271 .get_tx_csum = ethtool_op_get_tx_csum,
9272 .set_tx_csum = ethtool_op_set_tx_hw_csum,
9273 .set_flags = bnx2x_set_flags,
9274 .get_flags = ethtool_op_get_flags,
9275 .get_sg = ethtool_op_get_sg,
9276 .set_sg = ethtool_op_set_sg,
9277 .get_tso = ethtool_op_get_tso,
9278 .set_tso = bnx2x_set_tso,
9279 .self_test_count = bnx2x_self_test_count,
9280 .self_test = bnx2x_self_test,
9281 .get_strings = bnx2x_get_strings,
9282 .phys_id = bnx2x_phys_id,
9283 .get_stats_count = bnx2x_get_stats_count,
9284 .get_ethtool_stats = bnx2x_get_ethtool_stats,
9285 };
9286
9287 /* end of ethtool_ops */
9288
9289 /****************************************************************************
9290 * General service functions
9291 ****************************************************************************/
9292
9293 static int bnx2x_set_power_state(struct bnx2x *bp, pci_power_t state)
9294 {
9295 u16 pmcsr;
9296
9297 pci_read_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL, &pmcsr);
9298
9299 switch (state) {
9300 case PCI_D0:
9301 pci_write_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL,
9302 ((pmcsr & ~PCI_PM_CTRL_STATE_MASK) |
9303 PCI_PM_CTRL_PME_STATUS));
9304
9305 if (pmcsr & PCI_PM_CTRL_STATE_MASK)
9306 /* delay required during transition out of D3hot */
9307 msleep(20);
9308 break;
9309
9310 case PCI_D3hot:
9311 pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
9312 pmcsr |= 3;
9313
9314 if (bp->wol)
9315 pmcsr |= PCI_PM_CTRL_PME_ENABLE;
9316
9317 pci_write_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL,
9318 pmcsr);
9319
9320 /* No more memory access after this point until
9321 * device is brought back to D0.
9322 */
9323 break;
9324
9325 default:
9326 return -EINVAL;
9327 }
9328 return 0;
9329 }
9330
9331 static inline int bnx2x_has_rx_work(struct bnx2x_fastpath *fp)
9332 {
9333 u16 rx_cons_sb;
9334
9335 /* Tell compiler that status block fields can change */
9336 barrier();
9337 rx_cons_sb = le16_to_cpu(*fp->rx_cons_sb);
9338 if ((rx_cons_sb & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
9339 rx_cons_sb++;
9340 return (fp->rx_comp_cons != rx_cons_sb);
9341 }
9342
9343 /*
9344 * net_device service functions
9345 */
9346
9347 static int bnx2x_poll(struct napi_struct *napi, int budget)
9348 {
9349 struct bnx2x_fastpath *fp = container_of(napi, struct bnx2x_fastpath,
9350 napi);
9351 struct bnx2x *bp = fp->bp;
9352 int work_done = 0;
9353
9354 #ifdef BNX2X_STOP_ON_ERROR
9355 if (unlikely(bp->panic))
9356 goto poll_panic;
9357 #endif
9358
9359 prefetch(fp->tx_buf_ring[TX_BD(fp->tx_pkt_cons)].skb);
9360 prefetch(fp->rx_buf_ring[RX_BD(fp->rx_bd_cons)].skb);
9361 prefetch((char *)(fp->rx_buf_ring[RX_BD(fp->rx_bd_cons)].skb) + 256);
9362
9363 bnx2x_update_fpsb_idx(fp);
9364
9365 if (bnx2x_has_tx_work(fp))
9366 bnx2x_tx_int(fp, budget);
9367
9368 if (bnx2x_has_rx_work(fp))
9369 work_done = bnx2x_rx_int(fp, budget);
9370 rmb(); /* BNX2X_HAS_WORK() reads the status block */
9371
9372 /* must not complete if we consumed full budget */
9373 if ((work_done < budget) && !BNX2X_HAS_WORK(fp)) {
9374
9375 #ifdef BNX2X_STOP_ON_ERROR
9376 poll_panic:
9377 #endif
9378 napi_complete(napi);
9379
9380 bnx2x_ack_sb(bp, FP_SB_ID(fp), USTORM_ID,
9381 le16_to_cpu(fp->fp_u_idx), IGU_INT_NOP, 1);
9382 bnx2x_ack_sb(bp, FP_SB_ID(fp), CSTORM_ID,
9383 le16_to_cpu(fp->fp_c_idx), IGU_INT_ENABLE, 1);
9384 }
9385 return work_done;
9386 }
9387
9388
9389 /* we split the first BD into headers and data BDs
9390 * to ease the pain of our fellow microcode engineers
9391 * we use one mapping for both BDs
9392 * So far this has only been observed to happen
9393 * in Other Operating Systems(TM)
9394 */
9395 static noinline u16 bnx2x_tx_split(struct bnx2x *bp,
9396 struct bnx2x_fastpath *fp,
9397 struct eth_tx_bd **tx_bd, u16 hlen,
9398 u16 bd_prod, int nbd)
9399 {
9400 struct eth_tx_bd *h_tx_bd = *tx_bd;
9401 struct eth_tx_bd *d_tx_bd;
9402 dma_addr_t mapping;
9403 int old_len = le16_to_cpu(h_tx_bd->nbytes);
9404
9405 /* first fix first BD */
9406 h_tx_bd->nbd = cpu_to_le16(nbd);
9407 h_tx_bd->nbytes = cpu_to_le16(hlen);
9408
9409 DP(NETIF_MSG_TX_QUEUED, "TSO split header size is %d "
9410 "(%x:%x) nbd %d\n", h_tx_bd->nbytes, h_tx_bd->addr_hi,
9411 h_tx_bd->addr_lo, h_tx_bd->nbd);
9412
9413 /* now get a new data BD
9414 * (after the pbd) and fill it */
9415 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
9416 d_tx_bd = &fp->tx_desc_ring[bd_prod];
9417
9418 mapping = HILO_U64(le32_to_cpu(h_tx_bd->addr_hi),
9419 le32_to_cpu(h_tx_bd->addr_lo)) + hlen;
9420
9421 d_tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
9422 d_tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
9423 d_tx_bd->nbytes = cpu_to_le16(old_len - hlen);
9424 d_tx_bd->vlan = 0;
9425 /* this marks the BD as one that has no individual mapping
9426 * the FW ignores this flag in a BD not marked start
9427 */
9428 d_tx_bd->bd_flags.as_bitfield = ETH_TX_BD_FLAGS_SW_LSO;
9429 DP(NETIF_MSG_TX_QUEUED,
9430 "TSO split data size is %d (%x:%x)\n",
9431 d_tx_bd->nbytes, d_tx_bd->addr_hi, d_tx_bd->addr_lo);
9432
9433 /* update tx_bd for marking the last BD flag */
9434 *tx_bd = d_tx_bd;
9435
9436 return bd_prod;
9437 }
9438
9439 static inline u16 bnx2x_csum_fix(unsigned char *t_header, u16 csum, s8 fix)
9440 {
9441 if (fix > 0)
9442 csum = (u16) ~csum_fold(csum_sub(csum,
9443 csum_partial(t_header - fix, fix, 0)));
9444
9445 else if (fix < 0)
9446 csum = (u16) ~csum_fold(csum_add(csum,
9447 csum_partial(t_header, -fix, 0)));
9448
9449 return swab16(csum);
9450 }
9451
9452 static inline u32 bnx2x_xmit_type(struct bnx2x *bp, struct sk_buff *skb)
9453 {
9454 u32 rc;
9455
9456 if (skb->ip_summed != CHECKSUM_PARTIAL)
9457 rc = XMIT_PLAIN;
9458
9459 else {
9460 if (skb->protocol == ntohs(ETH_P_IPV6)) {
9461 rc = XMIT_CSUM_V6;
9462 if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
9463 rc |= XMIT_CSUM_TCP;
9464
9465 } else {
9466 rc = XMIT_CSUM_V4;
9467 if (ip_hdr(skb)->protocol == IPPROTO_TCP)
9468 rc |= XMIT_CSUM_TCP;
9469 }
9470 }
9471
9472 if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4)
9473 rc |= XMIT_GSO_V4;
9474
9475 else if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6)
9476 rc |= XMIT_GSO_V6;
9477
9478 return rc;
9479 }
9480
9481 #if (MAX_SKB_FRAGS >= MAX_FETCH_BD - 3)
9482 /* check if packet requires linearization (packet is too fragmented) */
9483 static int bnx2x_pkt_req_lin(struct bnx2x *bp, struct sk_buff *skb,
9484 u32 xmit_type)
9485 {
9486 int to_copy = 0;
9487 int hlen = 0;
9488 int first_bd_sz = 0;
9489
9490 /* 3 = 1 (for linear data BD) + 2 (for PBD and last BD) */
9491 if (skb_shinfo(skb)->nr_frags >= (MAX_FETCH_BD - 3)) {
9492
9493 if (xmit_type & XMIT_GSO) {
9494 unsigned short lso_mss = skb_shinfo(skb)->gso_size;
9495 /* Check if LSO packet needs to be copied:
9496 3 = 1 (for headers BD) + 2 (for PBD and last BD) */
9497 int wnd_size = MAX_FETCH_BD - 3;
9498 /* Number of windows to check */
9499 int num_wnds = skb_shinfo(skb)->nr_frags - wnd_size;
9500 int wnd_idx = 0;
9501 int frag_idx = 0;
9502 u32 wnd_sum = 0;
9503
9504 /* Headers length */
9505 hlen = (int)(skb_transport_header(skb) - skb->data) +
9506 tcp_hdrlen(skb);
9507
9508 /* Amount of data (w/o headers) on linear part of SKB*/
9509 first_bd_sz = skb_headlen(skb) - hlen;
9510
9511 wnd_sum = first_bd_sz;
9512
9513 /* Calculate the first sum - it's special */
9514 for (frag_idx = 0; frag_idx < wnd_size - 1; frag_idx++)
9515 wnd_sum +=
9516 skb_shinfo(skb)->frags[frag_idx].size;
9517
9518 /* If there was data on linear skb data - check it */
9519 if (first_bd_sz > 0) {
9520 if (unlikely(wnd_sum < lso_mss)) {
9521 to_copy = 1;
9522 goto exit_lbl;
9523 }
9524
9525 wnd_sum -= first_bd_sz;
9526 }
9527
9528 /* Others are easier: run through the frag list and
9529 check all windows */
9530 for (wnd_idx = 0; wnd_idx <= num_wnds; wnd_idx++) {
9531 wnd_sum +=
9532 skb_shinfo(skb)->frags[wnd_idx + wnd_size - 1].size;
9533
9534 if (unlikely(wnd_sum < lso_mss)) {
9535 to_copy = 1;
9536 break;
9537 }
9538 wnd_sum -=
9539 skb_shinfo(skb)->frags[wnd_idx].size;
9540 }
9541
9542 } else {
9543 /* in non-LSO too fragmented packet should always
9544 be linearized */
9545 to_copy = 1;
9546 }
9547 }
9548
9549 exit_lbl:
9550 if (unlikely(to_copy))
9551 DP(NETIF_MSG_TX_QUEUED,
9552 "Linearization IS REQUIRED for %s packet. "
9553 "num_frags %d hlen %d first_bd_sz %d\n",
9554 (xmit_type & XMIT_GSO) ? "LSO" : "non-LSO",
9555 skb_shinfo(skb)->nr_frags, hlen, first_bd_sz);
9556
9557 return to_copy;
9558 }
9559 #endif
9560
9561 /* called with netif_tx_lock
9562 * bnx2x_tx_int() runs without netif_tx_lock unless it needs to call
9563 * netif_wake_queue()
9564 */
9565 static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
9566 {
9567 struct bnx2x *bp = netdev_priv(dev);
9568 struct bnx2x_fastpath *fp;
9569 struct sw_tx_bd *tx_buf;
9570 struct eth_tx_bd *tx_bd;
9571 struct eth_tx_parse_bd *pbd = NULL;
9572 u16 pkt_prod, bd_prod;
9573 int nbd, fp_index;
9574 dma_addr_t mapping;
9575 u32 xmit_type = bnx2x_xmit_type(bp, skb);
9576 int vlan_off = (bp->e1hov ? 4 : 0);
9577 int i;
9578 u8 hlen = 0;
9579
9580 #ifdef BNX2X_STOP_ON_ERROR
9581 if (unlikely(bp->panic))
9582 return NETDEV_TX_BUSY;
9583 #endif
9584
9585 fp_index = (smp_processor_id() % bp->num_queues);
9586 fp = &bp->fp[fp_index];
9587
9588 if (unlikely(bnx2x_tx_avail(fp) < (skb_shinfo(skb)->nr_frags + 3))) {
9589 bp->eth_stats.driver_xoff++,
9590 netif_stop_queue(dev);
9591 BNX2X_ERR("BUG! Tx ring full when queue awake!\n");
9592 return NETDEV_TX_BUSY;
9593 }
9594
9595 DP(NETIF_MSG_TX_QUEUED, "SKB: summed %x protocol %x protocol(%x,%x)"
9596 " gso type %x xmit_type %x\n",
9597 skb->ip_summed, skb->protocol, ipv6_hdr(skb)->nexthdr,
9598 ip_hdr(skb)->protocol, skb_shinfo(skb)->gso_type, xmit_type);
9599
9600 #if (MAX_SKB_FRAGS >= MAX_FETCH_BD - 3)
9601 /* First, check if we need to linearize the skb
9602 (due to FW restrictions) */
9603 if (bnx2x_pkt_req_lin(bp, skb, xmit_type)) {
9604 /* Statistics of linearization */
9605 bp->lin_cnt++;
9606 if (skb_linearize(skb) != 0) {
9607 DP(NETIF_MSG_TX_QUEUED, "SKB linearization failed - "
9608 "silently dropping this SKB\n");
9609 dev_kfree_skb_any(skb);
9610 return NETDEV_TX_OK;
9611 }
9612 }
9613 #endif
9614
9615 /*
9616 Please read carefully. First we use one BD which we mark as start,
9617 then for TSO or xsum we have a parsing info BD,
9618 and only then we have the rest of the TSO BDs.
9619 (don't forget to mark the last one as last,
9620 and to unmap only AFTER you write to the BD ...)
9621 And above all, all pdb sizes are in words - NOT DWORDS!
9622 */
9623
9624 pkt_prod = fp->tx_pkt_prod++;
9625 bd_prod = TX_BD(fp->tx_bd_prod);
9626
9627 /* get a tx_buf and first BD */
9628 tx_buf = &fp->tx_buf_ring[TX_BD(pkt_prod)];
9629 tx_bd = &fp->tx_desc_ring[bd_prod];
9630
9631 tx_bd->bd_flags.as_bitfield = ETH_TX_BD_FLAGS_START_BD;
9632 tx_bd->general_data = (UNICAST_ADDRESS <<
9633 ETH_TX_BD_ETH_ADDR_TYPE_SHIFT);
9634 /* header nbd */
9635 tx_bd->general_data |= (1 << ETH_TX_BD_HDR_NBDS_SHIFT);
9636
9637 /* remember the first BD of the packet */
9638 tx_buf->first_bd = fp->tx_bd_prod;
9639 tx_buf->skb = skb;
9640
9641 DP(NETIF_MSG_TX_QUEUED,
9642 "sending pkt %u @%p next_idx %u bd %u @%p\n",
9643 pkt_prod, tx_buf, fp->tx_pkt_prod, bd_prod, tx_bd);
9644
9645 #ifdef BCM_VLAN
9646 if ((bp->vlgrp != NULL) && vlan_tx_tag_present(skb) &&
9647 (bp->flags & HW_VLAN_TX_FLAG)) {
9648 tx_bd->vlan = cpu_to_le16(vlan_tx_tag_get(skb));
9649 tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_VLAN_TAG;
9650 vlan_off += 4;
9651 } else
9652 #endif
9653 tx_bd->vlan = cpu_to_le16(pkt_prod);
9654
9655 if (xmit_type) {
9656 /* turn on parsing and get a BD */
9657 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
9658 pbd = (void *)&fp->tx_desc_ring[bd_prod];
9659
9660 memset(pbd, 0, sizeof(struct eth_tx_parse_bd));
9661 }
9662
9663 if (xmit_type & XMIT_CSUM) {
9664 hlen = (skb_network_header(skb) - skb->data + vlan_off) / 2;
9665
9666 /* for now NS flag is not used in Linux */
9667 pbd->global_data = (hlen |
9668 ((skb->protocol == ntohs(ETH_P_8021Q)) <<
9669 ETH_TX_PARSE_BD_LLC_SNAP_EN_SHIFT));
9670
9671 pbd->ip_hlen = (skb_transport_header(skb) -
9672 skb_network_header(skb)) / 2;
9673
9674 hlen += pbd->ip_hlen + tcp_hdrlen(skb) / 2;
9675
9676 pbd->total_hlen = cpu_to_le16(hlen);
9677 hlen = hlen*2 - vlan_off;
9678
9679 tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_TCP_CSUM;
9680
9681 if (xmit_type & XMIT_CSUM_V4)
9682 tx_bd->bd_flags.as_bitfield |=
9683 ETH_TX_BD_FLAGS_IP_CSUM;
9684 else
9685 tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_IPV6;
9686
9687 if (xmit_type & XMIT_CSUM_TCP) {
9688 pbd->tcp_pseudo_csum = swab16(tcp_hdr(skb)->check);
9689
9690 } else {
9691 s8 fix = SKB_CS_OFF(skb); /* signed! */
9692
9693 pbd->global_data |= ETH_TX_PARSE_BD_CS_ANY_FLG;
9694 pbd->cs_offset = fix / 2;
9695
9696 DP(NETIF_MSG_TX_QUEUED,
9697 "hlen %d offset %d fix %d csum before fix %x\n",
9698 le16_to_cpu(pbd->total_hlen), pbd->cs_offset, fix,
9699 SKB_CS(skb));
9700
9701 /* HW bug: fixup the CSUM */
9702 pbd->tcp_pseudo_csum =
9703 bnx2x_csum_fix(skb_transport_header(skb),
9704 SKB_CS(skb), fix);
9705
9706 DP(NETIF_MSG_TX_QUEUED, "csum after fix %x\n",
9707 pbd->tcp_pseudo_csum);
9708 }
9709 }
9710
9711 mapping = pci_map_single(bp->pdev, skb->data,
9712 skb_headlen(skb), PCI_DMA_TODEVICE);
9713
9714 tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
9715 tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
9716 nbd = skb_shinfo(skb)->nr_frags + ((pbd == NULL) ? 1 : 2);
9717 tx_bd->nbd = cpu_to_le16(nbd);
9718 tx_bd->nbytes = cpu_to_le16(skb_headlen(skb));
9719
9720 DP(NETIF_MSG_TX_QUEUED, "first bd @%p addr (%x:%x) nbd %d"
9721 " nbytes %d flags %x vlan %x\n",
9722 tx_bd, tx_bd->addr_hi, tx_bd->addr_lo, le16_to_cpu(tx_bd->nbd),
9723 le16_to_cpu(tx_bd->nbytes), tx_bd->bd_flags.as_bitfield,
9724 le16_to_cpu(tx_bd->vlan));
9725
9726 if (xmit_type & XMIT_GSO) {
9727
9728 DP(NETIF_MSG_TX_QUEUED,
9729 "TSO packet len %d hlen %d total len %d tso size %d\n",
9730 skb->len, hlen, skb_headlen(skb),
9731 skb_shinfo(skb)->gso_size);
9732
9733 tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_SW_LSO;
9734
9735 if (unlikely(skb_headlen(skb) > hlen))
9736 bd_prod = bnx2x_tx_split(bp, fp, &tx_bd, hlen,
9737 bd_prod, ++nbd);
9738
9739 pbd->lso_mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
9740 pbd->tcp_send_seq = swab32(tcp_hdr(skb)->seq);
9741 pbd->tcp_flags = pbd_tcp_flags(skb);
9742
9743 if (xmit_type & XMIT_GSO_V4) {
9744 pbd->ip_id = swab16(ip_hdr(skb)->id);
9745 pbd->tcp_pseudo_csum =
9746 swab16(~csum_tcpudp_magic(ip_hdr(skb)->saddr,
9747 ip_hdr(skb)->daddr,
9748 0, IPPROTO_TCP, 0));
9749
9750 } else
9751 pbd->tcp_pseudo_csum =
9752 swab16(~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
9753 &ipv6_hdr(skb)->daddr,
9754 0, IPPROTO_TCP, 0));
9755
9756 pbd->global_data |= ETH_TX_PARSE_BD_PSEUDO_CS_WITHOUT_LEN;
9757 }
9758
9759 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
9760 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
9761
9762 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
9763 tx_bd = &fp->tx_desc_ring[bd_prod];
9764
9765 mapping = pci_map_page(bp->pdev, frag->page, frag->page_offset,
9766 frag->size, PCI_DMA_TODEVICE);
9767
9768 tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
9769 tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
9770 tx_bd->nbytes = cpu_to_le16(frag->size);
9771 tx_bd->vlan = cpu_to_le16(pkt_prod);
9772 tx_bd->bd_flags.as_bitfield = 0;
9773
9774 DP(NETIF_MSG_TX_QUEUED,
9775 "frag %d bd @%p addr (%x:%x) nbytes %d flags %x\n",
9776 i, tx_bd, tx_bd->addr_hi, tx_bd->addr_lo,
9777 le16_to_cpu(tx_bd->nbytes), tx_bd->bd_flags.as_bitfield);
9778 }
9779
9780 /* now at last mark the BD as the last BD */
9781 tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_END_BD;
9782
9783 DP(NETIF_MSG_TX_QUEUED, "last bd @%p flags %x\n",
9784 tx_bd, tx_bd->bd_flags.as_bitfield);
9785
9786 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
9787
9788 /* now send a tx doorbell, counting the next BD
9789 * if the packet contains or ends with it
9790 */
9791 if (TX_BD_POFF(bd_prod) < nbd)
9792 nbd++;
9793
9794 if (pbd)
9795 DP(NETIF_MSG_TX_QUEUED,
9796 "PBD @%p ip_data %x ip_hlen %u ip_id %u lso_mss %u"
9797 " tcp_flags %x xsum %x seq %u hlen %u\n",
9798 pbd, pbd->global_data, pbd->ip_hlen, pbd->ip_id,
9799 pbd->lso_mss, pbd->tcp_flags, pbd->tcp_pseudo_csum,
9800 pbd->tcp_send_seq, le16_to_cpu(pbd->total_hlen));
9801
9802 DP(NETIF_MSG_TX_QUEUED, "doorbell: nbd %d bd %u\n", nbd, bd_prod);
9803
9804 /*
9805 * Make sure that the BD data is updated before updating the producer
9806 * since FW might read the BD right after the producer is updated.
9807 * This is only applicable for weak-ordered memory model archs such
9808 * as IA-64. The following barrier is also mandatory since FW will
9809 * assumes packets must have BDs.
9810 */
9811 wmb();
9812
9813 fp->hw_tx_prods->bds_prod =
9814 cpu_to_le16(le16_to_cpu(fp->hw_tx_prods->bds_prod) + nbd);
9815 mb(); /* FW restriction: must not reorder writing nbd and packets */
9816 fp->hw_tx_prods->packets_prod =
9817 cpu_to_le32(le32_to_cpu(fp->hw_tx_prods->packets_prod) + 1);
9818 DOORBELL(bp, FP_IDX(fp), 0);
9819
9820 mmiowb();
9821
9822 fp->tx_bd_prod += nbd;
9823 dev->trans_start = jiffies;
9824
9825 if (unlikely(bnx2x_tx_avail(fp) < MAX_SKB_FRAGS + 3)) {
9826 /* We want bnx2x_tx_int to "see" the updated tx_bd_prod
9827 if we put Tx into XOFF state. */
9828 smp_mb();
9829 netif_stop_queue(dev);
9830 bp->eth_stats.driver_xoff++;
9831 if (bnx2x_tx_avail(fp) >= MAX_SKB_FRAGS + 3)
9832 netif_wake_queue(dev);
9833 }
9834 fp->tx_pkt++;
9835
9836 return NETDEV_TX_OK;
9837 }
9838
9839 /* called with rtnl_lock */
9840 static int bnx2x_open(struct net_device *dev)
9841 {
9842 struct bnx2x *bp = netdev_priv(dev);
9843
9844 netif_carrier_off(dev);
9845
9846 bnx2x_set_power_state(bp, PCI_D0);
9847
9848 return bnx2x_nic_load(bp, LOAD_OPEN);
9849 }
9850
9851 /* called with rtnl_lock */
9852 static int bnx2x_close(struct net_device *dev)
9853 {
9854 struct bnx2x *bp = netdev_priv(dev);
9855
9856 /* Unload the driver, release IRQs */
9857 bnx2x_nic_unload(bp, UNLOAD_CLOSE);
9858 if (atomic_read(&bp->pdev->enable_cnt) == 1)
9859 if (!CHIP_REV_IS_SLOW(bp))
9860 bnx2x_set_power_state(bp, PCI_D3hot);
9861
9862 return 0;
9863 }
9864
9865 /* called with netif_tx_lock from set_multicast */
9866 static void bnx2x_set_rx_mode(struct net_device *dev)
9867 {
9868 struct bnx2x *bp = netdev_priv(dev);
9869 u32 rx_mode = BNX2X_RX_MODE_NORMAL;
9870 int port = BP_PORT(bp);
9871
9872 if (bp->state != BNX2X_STATE_OPEN) {
9873 DP(NETIF_MSG_IFUP, "state is %x, returning\n", bp->state);
9874 return;
9875 }
9876
9877 DP(NETIF_MSG_IFUP, "dev->flags = %x\n", dev->flags);
9878
9879 if (dev->flags & IFF_PROMISC)
9880 rx_mode = BNX2X_RX_MODE_PROMISC;
9881
9882 else if ((dev->flags & IFF_ALLMULTI) ||
9883 ((dev->mc_count > BNX2X_MAX_MULTICAST) && CHIP_IS_E1(bp)))
9884 rx_mode = BNX2X_RX_MODE_ALLMULTI;
9885
9886 else { /* some multicasts */
9887 if (CHIP_IS_E1(bp)) {
9888 int i, old, offset;
9889 struct dev_mc_list *mclist;
9890 struct mac_configuration_cmd *config =
9891 bnx2x_sp(bp, mcast_config);
9892
9893 for (i = 0, mclist = dev->mc_list;
9894 mclist && (i < dev->mc_count);
9895 i++, mclist = mclist->next) {
9896
9897 config->config_table[i].
9898 cam_entry.msb_mac_addr =
9899 swab16(*(u16 *)&mclist->dmi_addr[0]);
9900 config->config_table[i].
9901 cam_entry.middle_mac_addr =
9902 swab16(*(u16 *)&mclist->dmi_addr[2]);
9903 config->config_table[i].
9904 cam_entry.lsb_mac_addr =
9905 swab16(*(u16 *)&mclist->dmi_addr[4]);
9906 config->config_table[i].cam_entry.flags =
9907 cpu_to_le16(port);
9908 config->config_table[i].
9909 target_table_entry.flags = 0;
9910 config->config_table[i].
9911 target_table_entry.client_id = 0;
9912 config->config_table[i].
9913 target_table_entry.vlan_id = 0;
9914
9915 DP(NETIF_MSG_IFUP,
9916 "setting MCAST[%d] (%04x:%04x:%04x)\n", i,
9917 config->config_table[i].
9918 cam_entry.msb_mac_addr,
9919 config->config_table[i].
9920 cam_entry.middle_mac_addr,
9921 config->config_table[i].
9922 cam_entry.lsb_mac_addr);
9923 }
9924 old = config->hdr.length_6b;
9925 if (old > i) {
9926 for (; i < old; i++) {
9927 if (CAM_IS_INVALID(config->
9928 config_table[i])) {
9929 /* already invalidated */
9930 break;
9931 }
9932 /* invalidate */
9933 CAM_INVALIDATE(config->
9934 config_table[i]);
9935 }
9936 }
9937
9938 if (CHIP_REV_IS_SLOW(bp))
9939 offset = BNX2X_MAX_EMUL_MULTI*(1 + port);
9940 else
9941 offset = BNX2X_MAX_MULTICAST*(1 + port);
9942
9943 config->hdr.length_6b = i;
9944 config->hdr.offset = offset;
9945 config->hdr.client_id = BP_CL_ID(bp);
9946 config->hdr.reserved1 = 0;
9947
9948 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_SET_MAC, 0,
9949 U64_HI(bnx2x_sp_mapping(bp, mcast_config)),
9950 U64_LO(bnx2x_sp_mapping(bp, mcast_config)),
9951 0);
9952 } else { /* E1H */
9953 /* Accept one or more multicasts */
9954 struct dev_mc_list *mclist;
9955 u32 mc_filter[MC_HASH_SIZE];
9956 u32 crc, bit, regidx;
9957 int i;
9958
9959 memset(mc_filter, 0, 4 * MC_HASH_SIZE);
9960
9961 for (i = 0, mclist = dev->mc_list;
9962 mclist && (i < dev->mc_count);
9963 i++, mclist = mclist->next) {
9964
9965 DP(NETIF_MSG_IFUP, "Adding mcast MAC: %pM\n",
9966 mclist->dmi_addr);
9967
9968 crc = crc32c_le(0, mclist->dmi_addr, ETH_ALEN);
9969 bit = (crc >> 24) & 0xff;
9970 regidx = bit >> 5;
9971 bit &= 0x1f;
9972 mc_filter[regidx] |= (1 << bit);
9973 }
9974
9975 for (i = 0; i < MC_HASH_SIZE; i++)
9976 REG_WR(bp, MC_HASH_OFFSET(bp, i),
9977 mc_filter[i]);
9978 }
9979 }
9980
9981 bp->rx_mode = rx_mode;
9982 bnx2x_set_storm_rx_mode(bp);
9983 }
9984
9985 /* called with rtnl_lock */
9986 static int bnx2x_change_mac_addr(struct net_device *dev, void *p)
9987 {
9988 struct sockaddr *addr = p;
9989 struct bnx2x *bp = netdev_priv(dev);
9990
9991 if (!is_valid_ether_addr((u8 *)(addr->sa_data)))
9992 return -EINVAL;
9993
9994 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
9995 if (netif_running(dev)) {
9996 if (CHIP_IS_E1(bp))
9997 bnx2x_set_mac_addr_e1(bp, 1);
9998 else
9999 bnx2x_set_mac_addr_e1h(bp, 1);
10000 }
10001
10002 return 0;
10003 }
10004
10005 /* called with rtnl_lock */
10006 static int bnx2x_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
10007 {
10008 struct mii_ioctl_data *data = if_mii(ifr);
10009 struct bnx2x *bp = netdev_priv(dev);
10010 int port = BP_PORT(bp);
10011 int err;
10012
10013 switch (cmd) {
10014 case SIOCGMIIPHY:
10015 data->phy_id = bp->port.phy_addr;
10016
10017 /* fallthrough */
10018
10019 case SIOCGMIIREG: {
10020 u16 mii_regval;
10021
10022 if (!netif_running(dev))
10023 return -EAGAIN;
10024
10025 mutex_lock(&bp->port.phy_mutex);
10026 err = bnx2x_cl45_read(bp, port, 0, bp->port.phy_addr,
10027 DEFAULT_PHY_DEV_ADDR,
10028 (data->reg_num & 0x1f), &mii_regval);
10029 data->val_out = mii_regval;
10030 mutex_unlock(&bp->port.phy_mutex);
10031 return err;
10032 }
10033
10034 case SIOCSMIIREG:
10035 if (!capable(CAP_NET_ADMIN))
10036 return -EPERM;
10037
10038 if (!netif_running(dev))
10039 return -EAGAIN;
10040
10041 mutex_lock(&bp->port.phy_mutex);
10042 err = bnx2x_cl45_write(bp, port, 0, bp->port.phy_addr,
10043 DEFAULT_PHY_DEV_ADDR,
10044 (data->reg_num & 0x1f), data->val_in);
10045 mutex_unlock(&bp->port.phy_mutex);
10046 return err;
10047
10048 default:
10049 /* do nothing */
10050 break;
10051 }
10052
10053 return -EOPNOTSUPP;
10054 }
10055
10056 /* called with rtnl_lock */
10057 static int bnx2x_change_mtu(struct net_device *dev, int new_mtu)
10058 {
10059 struct bnx2x *bp = netdev_priv(dev);
10060 int rc = 0;
10061
10062 if ((new_mtu > ETH_MAX_JUMBO_PACKET_SIZE) ||
10063 ((new_mtu + ETH_HLEN) < ETH_MIN_PACKET_SIZE))
10064 return -EINVAL;
10065
10066 /* This does not race with packet allocation
10067 * because the actual alloc size is
10068 * only updated as part of load
10069 */
10070 dev->mtu = new_mtu;
10071
10072 if (netif_running(dev)) {
10073 bnx2x_nic_unload(bp, UNLOAD_NORMAL);
10074 rc = bnx2x_nic_load(bp, LOAD_NORMAL);
10075 }
10076
10077 return rc;
10078 }
10079
10080 static void bnx2x_tx_timeout(struct net_device *dev)
10081 {
10082 struct bnx2x *bp = netdev_priv(dev);
10083
10084 #ifdef BNX2X_STOP_ON_ERROR
10085 if (!bp->panic)
10086 bnx2x_panic();
10087 #endif
10088 /* This allows the netif to be shutdown gracefully before resetting */
10089 schedule_work(&bp->reset_task);
10090 }
10091
10092 #ifdef BCM_VLAN
10093 /* called with rtnl_lock */
10094 static void bnx2x_vlan_rx_register(struct net_device *dev,
10095 struct vlan_group *vlgrp)
10096 {
10097 struct bnx2x *bp = netdev_priv(dev);
10098
10099 bp->vlgrp = vlgrp;
10100
10101 /* Set flags according to the required capabilities */
10102 bp->flags &= ~(HW_VLAN_RX_FLAG | HW_VLAN_TX_FLAG);
10103
10104 if (dev->features & NETIF_F_HW_VLAN_TX)
10105 bp->flags |= HW_VLAN_TX_FLAG;
10106
10107 if (dev->features & NETIF_F_HW_VLAN_RX)
10108 bp->flags |= HW_VLAN_RX_FLAG;
10109
10110 if (netif_running(dev))
10111 bnx2x_set_client_config(bp);
10112 }
10113
10114 #endif
10115
10116 #if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
10117 static void poll_bnx2x(struct net_device *dev)
10118 {
10119 struct bnx2x *bp = netdev_priv(dev);
10120
10121 disable_irq(bp->pdev->irq);
10122 bnx2x_interrupt(bp->pdev->irq, dev);
10123 enable_irq(bp->pdev->irq);
10124 }
10125 #endif
10126
10127 static const struct net_device_ops bnx2x_netdev_ops = {
10128 .ndo_open = bnx2x_open,
10129 .ndo_stop = bnx2x_close,
10130 .ndo_start_xmit = bnx2x_start_xmit,
10131 .ndo_set_multicast_list = bnx2x_set_rx_mode,
10132 .ndo_set_mac_address = bnx2x_change_mac_addr,
10133 .ndo_validate_addr = eth_validate_addr,
10134 .ndo_do_ioctl = bnx2x_ioctl,
10135 .ndo_change_mtu = bnx2x_change_mtu,
10136 .ndo_tx_timeout = bnx2x_tx_timeout,
10137 #ifdef BCM_VLAN
10138 .ndo_vlan_rx_register = bnx2x_vlan_rx_register,
10139 #endif
10140 #if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
10141 .ndo_poll_controller = poll_bnx2x,
10142 #endif
10143 };
10144
10145
10146 static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
10147 struct net_device *dev)
10148 {
10149 struct bnx2x *bp;
10150 int rc;
10151
10152 SET_NETDEV_DEV(dev, &pdev->dev);
10153 bp = netdev_priv(dev);
10154
10155 bp->dev = dev;
10156 bp->pdev = pdev;
10157 bp->flags = 0;
10158 bp->func = PCI_FUNC(pdev->devfn);
10159
10160 rc = pci_enable_device(pdev);
10161 if (rc) {
10162 printk(KERN_ERR PFX "Cannot enable PCI device, aborting\n");
10163 goto err_out;
10164 }
10165
10166 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
10167 printk(KERN_ERR PFX "Cannot find PCI device base address,"
10168 " aborting\n");
10169 rc = -ENODEV;
10170 goto err_out_disable;
10171 }
10172
10173 if (!(pci_resource_flags(pdev, 2) & IORESOURCE_MEM)) {
10174 printk(KERN_ERR PFX "Cannot find second PCI device"
10175 " base address, aborting\n");
10176 rc = -ENODEV;
10177 goto err_out_disable;
10178 }
10179
10180 if (atomic_read(&pdev->enable_cnt) == 1) {
10181 rc = pci_request_regions(pdev, DRV_MODULE_NAME);
10182 if (rc) {
10183 printk(KERN_ERR PFX "Cannot obtain PCI resources,"
10184 " aborting\n");
10185 goto err_out_disable;
10186 }
10187
10188 pci_set_master(pdev);
10189 pci_save_state(pdev);
10190 }
10191
10192 bp->pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM);
10193 if (bp->pm_cap == 0) {
10194 printk(KERN_ERR PFX "Cannot find power management"
10195 " capability, aborting\n");
10196 rc = -EIO;
10197 goto err_out_release;
10198 }
10199
10200 bp->pcie_cap = pci_find_capability(pdev, PCI_CAP_ID_EXP);
10201 if (bp->pcie_cap == 0) {
10202 printk(KERN_ERR PFX "Cannot find PCI Express capability,"
10203 " aborting\n");
10204 rc = -EIO;
10205 goto err_out_release;
10206 }
10207
10208 if (pci_set_dma_mask(pdev, DMA_64BIT_MASK) == 0) {
10209 bp->flags |= USING_DAC_FLAG;
10210 if (pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK) != 0) {
10211 printk(KERN_ERR PFX "pci_set_consistent_dma_mask"
10212 " failed, aborting\n");
10213 rc = -EIO;
10214 goto err_out_release;
10215 }
10216
10217 } else if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0) {
10218 printk(KERN_ERR PFX "System does not support DMA,"
10219 " aborting\n");
10220 rc = -EIO;
10221 goto err_out_release;
10222 }
10223
10224 dev->mem_start = pci_resource_start(pdev, 0);
10225 dev->base_addr = dev->mem_start;
10226 dev->mem_end = pci_resource_end(pdev, 0);
10227
10228 dev->irq = pdev->irq;
10229
10230 bp->regview = pci_ioremap_bar(pdev, 0);
10231 if (!bp->regview) {
10232 printk(KERN_ERR PFX "Cannot map register space, aborting\n");
10233 rc = -ENOMEM;
10234 goto err_out_release;
10235 }
10236
10237 bp->doorbells = ioremap_nocache(pci_resource_start(pdev, 2),
10238 min_t(u64, BNX2X_DB_SIZE,
10239 pci_resource_len(pdev, 2)));
10240 if (!bp->doorbells) {
10241 printk(KERN_ERR PFX "Cannot map doorbell space, aborting\n");
10242 rc = -ENOMEM;
10243 goto err_out_unmap;
10244 }
10245
10246 bnx2x_set_power_state(bp, PCI_D0);
10247
10248 /* clean indirect addresses */
10249 pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
10250 PCICFG_VENDOR_ID_OFFSET);
10251 REG_WR(bp, PXP2_REG_PGL_ADDR_88_F0 + BP_PORT(bp)*16, 0);
10252 REG_WR(bp, PXP2_REG_PGL_ADDR_8C_F0 + BP_PORT(bp)*16, 0);
10253 REG_WR(bp, PXP2_REG_PGL_ADDR_90_F0 + BP_PORT(bp)*16, 0);
10254 REG_WR(bp, PXP2_REG_PGL_ADDR_94_F0 + BP_PORT(bp)*16, 0);
10255
10256 dev->watchdog_timeo = TX_TIMEOUT;
10257
10258 dev->netdev_ops = &bnx2x_netdev_ops;
10259 dev->ethtool_ops = &bnx2x_ethtool_ops;
10260 dev->features |= NETIF_F_SG;
10261 dev->features |= NETIF_F_HW_CSUM;
10262 if (bp->flags & USING_DAC_FLAG)
10263 dev->features |= NETIF_F_HIGHDMA;
10264 #ifdef BCM_VLAN
10265 dev->features |= (NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX);
10266 bp->flags |= (HW_VLAN_RX_FLAG | HW_VLAN_TX_FLAG);
10267 #endif
10268 dev->features |= (NETIF_F_TSO | NETIF_F_TSO_ECN);
10269 dev->features |= NETIF_F_TSO6;
10270
10271 return 0;
10272
10273 err_out_unmap:
10274 if (bp->regview) {
10275 iounmap(bp->regview);
10276 bp->regview = NULL;
10277 }
10278 if (bp->doorbells) {
10279 iounmap(bp->doorbells);
10280 bp->doorbells = NULL;
10281 }
10282
10283 err_out_release:
10284 if (atomic_read(&pdev->enable_cnt) == 1)
10285 pci_release_regions(pdev);
10286
10287 err_out_disable:
10288 pci_disable_device(pdev);
10289 pci_set_drvdata(pdev, NULL);
10290
10291 err_out:
10292 return rc;
10293 }
10294
10295 static int __devinit bnx2x_get_pcie_width(struct bnx2x *bp)
10296 {
10297 u32 val = REG_RD(bp, PCICFG_OFFSET + PCICFG_LINK_CONTROL);
10298
10299 val = (val & PCICFG_LINK_WIDTH) >> PCICFG_LINK_WIDTH_SHIFT;
10300 return val;
10301 }
10302
10303 /* return value of 1=2.5GHz 2=5GHz */
10304 static int __devinit bnx2x_get_pcie_speed(struct bnx2x *bp)
10305 {
10306 u32 val = REG_RD(bp, PCICFG_OFFSET + PCICFG_LINK_CONTROL);
10307
10308 val = (val & PCICFG_LINK_SPEED) >> PCICFG_LINK_SPEED_SHIFT;
10309 return val;
10310 }
10311
10312 static int __devinit bnx2x_init_one(struct pci_dev *pdev,
10313 const struct pci_device_id *ent)
10314 {
10315 static int version_printed;
10316 struct net_device *dev = NULL;
10317 struct bnx2x *bp;
10318 int rc;
10319
10320 if (version_printed++ == 0)
10321 printk(KERN_INFO "%s", version);
10322
10323 /* dev zeroed in init_etherdev */
10324 dev = alloc_etherdev(sizeof(*bp));
10325 if (!dev) {
10326 printk(KERN_ERR PFX "Cannot allocate net device\n");
10327 return -ENOMEM;
10328 }
10329
10330 bp = netdev_priv(dev);
10331 bp->msglevel = debug;
10332
10333 rc = bnx2x_init_dev(pdev, dev);
10334 if (rc < 0) {
10335 free_netdev(dev);
10336 return rc;
10337 }
10338
10339 pci_set_drvdata(pdev, dev);
10340
10341 rc = bnx2x_init_bp(bp);
10342 if (rc)
10343 goto init_one_exit;
10344
10345 rc = register_netdev(dev);
10346 if (rc) {
10347 dev_err(&pdev->dev, "Cannot register net device\n");
10348 goto init_one_exit;
10349 }
10350
10351 bp->common.name = board_info[ent->driver_data].name;
10352 printk(KERN_INFO "%s: %s (%c%d) PCI-E x%d %s found at mem %lx,"
10353 " IRQ %d, ", dev->name, bp->common.name,
10354 (CHIP_REV(bp) >> 12) + 'A', (CHIP_METAL(bp) >> 4),
10355 bnx2x_get_pcie_width(bp),
10356 (bnx2x_get_pcie_speed(bp) == 2) ? "5GHz (Gen2)" : "2.5GHz",
10357 dev->base_addr, bp->pdev->irq);
10358 printk(KERN_CONT "node addr %pM\n", dev->dev_addr);
10359 return 0;
10360
10361 init_one_exit:
10362 if (bp->regview)
10363 iounmap(bp->regview);
10364
10365 if (bp->doorbells)
10366 iounmap(bp->doorbells);
10367
10368 free_netdev(dev);
10369
10370 if (atomic_read(&pdev->enable_cnt) == 1)
10371 pci_release_regions(pdev);
10372
10373 pci_disable_device(pdev);
10374 pci_set_drvdata(pdev, NULL);
10375
10376 return rc;
10377 }
10378
10379 static void __devexit bnx2x_remove_one(struct pci_dev *pdev)
10380 {
10381 struct net_device *dev = pci_get_drvdata(pdev);
10382 struct bnx2x *bp;
10383
10384 if (!dev) {
10385 printk(KERN_ERR PFX "BAD net device from bnx2x_init_one\n");
10386 return;
10387 }
10388 bp = netdev_priv(dev);
10389
10390 unregister_netdev(dev);
10391
10392 if (bp->regview)
10393 iounmap(bp->regview);
10394
10395 if (bp->doorbells)
10396 iounmap(bp->doorbells);
10397
10398 free_netdev(dev);
10399
10400 if (atomic_read(&pdev->enable_cnt) == 1)
10401 pci_release_regions(pdev);
10402
10403 pci_disable_device(pdev);
10404 pci_set_drvdata(pdev, NULL);
10405 }
10406
10407 static int bnx2x_suspend(struct pci_dev *pdev, pm_message_t state)
10408 {
10409 struct net_device *dev = pci_get_drvdata(pdev);
10410 struct bnx2x *bp;
10411
10412 if (!dev) {
10413 printk(KERN_ERR PFX "BAD net device from bnx2x_init_one\n");
10414 return -ENODEV;
10415 }
10416 bp = netdev_priv(dev);
10417
10418 rtnl_lock();
10419
10420 pci_save_state(pdev);
10421
10422 if (!netif_running(dev)) {
10423 rtnl_unlock();
10424 return 0;
10425 }
10426
10427 netif_device_detach(dev);
10428
10429 bnx2x_nic_unload(bp, UNLOAD_CLOSE);
10430
10431 bnx2x_set_power_state(bp, pci_choose_state(pdev, state));
10432
10433 rtnl_unlock();
10434
10435 return 0;
10436 }
10437
10438 static int bnx2x_resume(struct pci_dev *pdev)
10439 {
10440 struct net_device *dev = pci_get_drvdata(pdev);
10441 struct bnx2x *bp;
10442 int rc;
10443
10444 if (!dev) {
10445 printk(KERN_ERR PFX "BAD net device from bnx2x_init_one\n");
10446 return -ENODEV;
10447 }
10448 bp = netdev_priv(dev);
10449
10450 rtnl_lock();
10451
10452 pci_restore_state(pdev);
10453
10454 if (!netif_running(dev)) {
10455 rtnl_unlock();
10456 return 0;
10457 }
10458
10459 bnx2x_set_power_state(bp, PCI_D0);
10460 netif_device_attach(dev);
10461
10462 rc = bnx2x_nic_load(bp, LOAD_OPEN);
10463
10464 rtnl_unlock();
10465
10466 return rc;
10467 }
10468
10469 static int bnx2x_eeh_nic_unload(struct bnx2x *bp)
10470 {
10471 int i;
10472
10473 bp->state = BNX2X_STATE_ERROR;
10474
10475 bp->rx_mode = BNX2X_RX_MODE_NONE;
10476
10477 bnx2x_netif_stop(bp, 0);
10478
10479 del_timer_sync(&bp->timer);
10480 bp->stats_state = STATS_STATE_DISABLED;
10481 DP(BNX2X_MSG_STATS, "stats_state - DISABLED\n");
10482
10483 /* Release IRQs */
10484 bnx2x_free_irq(bp);
10485
10486 if (CHIP_IS_E1(bp)) {
10487 struct mac_configuration_cmd *config =
10488 bnx2x_sp(bp, mcast_config);
10489
10490 for (i = 0; i < config->hdr.length_6b; i++)
10491 CAM_INVALIDATE(config->config_table[i]);
10492 }
10493
10494 /* Free SKBs, SGEs, TPA pool and driver internals */
10495 bnx2x_free_skbs(bp);
10496 for_each_queue(bp, i)
10497 bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
10498 for_each_queue(bp, i)
10499 netif_napi_del(&bnx2x_fp(bp, i, napi));
10500 bnx2x_free_mem(bp);
10501
10502 bp->state = BNX2X_STATE_CLOSED;
10503
10504 netif_carrier_off(bp->dev);
10505
10506 return 0;
10507 }
10508
10509 static void bnx2x_eeh_recover(struct bnx2x *bp)
10510 {
10511 u32 val;
10512
10513 mutex_init(&bp->port.phy_mutex);
10514
10515 bp->common.shmem_base = REG_RD(bp, MISC_REG_SHARED_MEM_ADDR);
10516 bp->link_params.shmem_base = bp->common.shmem_base;
10517 BNX2X_DEV_INFO("shmem offset is 0x%x\n", bp->common.shmem_base);
10518
10519 if (!bp->common.shmem_base ||
10520 (bp->common.shmem_base < 0xA0000) ||
10521 (bp->common.shmem_base >= 0xC0000)) {
10522 BNX2X_DEV_INFO("MCP not active\n");
10523 bp->flags |= NO_MCP_FLAG;
10524 return;
10525 }
10526
10527 val = SHMEM_RD(bp, validity_map[BP_PORT(bp)]);
10528 if ((val & (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
10529 != (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
10530 BNX2X_ERR("BAD MCP validity signature\n");
10531
10532 if (!BP_NOMCP(bp)) {
10533 bp->fw_seq = (SHMEM_RD(bp, func_mb[BP_FUNC(bp)].drv_mb_header)
10534 & DRV_MSG_SEQ_NUMBER_MASK);
10535 BNX2X_DEV_INFO("fw_seq 0x%08x\n", bp->fw_seq);
10536 }
10537 }
10538
10539 /**
10540 * bnx2x_io_error_detected - called when PCI error is detected
10541 * @pdev: Pointer to PCI device
10542 * @state: The current pci connection state
10543 *
10544 * This function is called after a PCI bus error affecting
10545 * this device has been detected.
10546 */
10547 static pci_ers_result_t bnx2x_io_error_detected(struct pci_dev *pdev,
10548 pci_channel_state_t state)
10549 {
10550 struct net_device *dev = pci_get_drvdata(pdev);
10551 struct bnx2x *bp = netdev_priv(dev);
10552
10553 rtnl_lock();
10554
10555 netif_device_detach(dev);
10556
10557 if (netif_running(dev))
10558 bnx2x_eeh_nic_unload(bp);
10559
10560 pci_disable_device(pdev);
10561
10562 rtnl_unlock();
10563
10564 /* Request a slot reset */
10565 return PCI_ERS_RESULT_NEED_RESET;
10566 }
10567
10568 /**
10569 * bnx2x_io_slot_reset - called after the PCI bus has been reset
10570 * @pdev: Pointer to PCI device
10571 *
10572 * Restart the card from scratch, as if from a cold-boot.
10573 */
10574 static pci_ers_result_t bnx2x_io_slot_reset(struct pci_dev *pdev)
10575 {
10576 struct net_device *dev = pci_get_drvdata(pdev);
10577 struct bnx2x *bp = netdev_priv(dev);
10578
10579 rtnl_lock();
10580
10581 if (pci_enable_device(pdev)) {
10582 dev_err(&pdev->dev,
10583 "Cannot re-enable PCI device after reset\n");
10584 rtnl_unlock();
10585 return PCI_ERS_RESULT_DISCONNECT;
10586 }
10587
10588 pci_set_master(pdev);
10589 pci_restore_state(pdev);
10590
10591 if (netif_running(dev))
10592 bnx2x_set_power_state(bp, PCI_D0);
10593
10594 rtnl_unlock();
10595
10596 return PCI_ERS_RESULT_RECOVERED;
10597 }
10598
10599 /**
10600 * bnx2x_io_resume - called when traffic can start flowing again
10601 * @pdev: Pointer to PCI device
10602 *
10603 * This callback is called when the error recovery driver tells us that
10604 * its OK to resume normal operation.
10605 */
10606 static void bnx2x_io_resume(struct pci_dev *pdev)
10607 {
10608 struct net_device *dev = pci_get_drvdata(pdev);
10609 struct bnx2x *bp = netdev_priv(dev);
10610
10611 rtnl_lock();
10612
10613 bnx2x_eeh_recover(bp);
10614
10615 if (netif_running(dev))
10616 bnx2x_nic_load(bp, LOAD_NORMAL);
10617
10618 netif_device_attach(dev);
10619
10620 rtnl_unlock();
10621 }
10622
10623 static struct pci_error_handlers bnx2x_err_handler = {
10624 .error_detected = bnx2x_io_error_detected,
10625 .slot_reset = bnx2x_io_slot_reset,
10626 .resume = bnx2x_io_resume,
10627 };
10628
10629 static struct pci_driver bnx2x_pci_driver = {
10630 .name = DRV_MODULE_NAME,
10631 .id_table = bnx2x_pci_tbl,
10632 .probe = bnx2x_init_one,
10633 .remove = __devexit_p(bnx2x_remove_one),
10634 .suspend = bnx2x_suspend,
10635 .resume = bnx2x_resume,
10636 .err_handler = &bnx2x_err_handler,
10637 };
10638
10639 static int __init bnx2x_init(void)
10640 {
10641 bnx2x_wq = create_singlethread_workqueue("bnx2x");
10642 if (bnx2x_wq == NULL) {
10643 printk(KERN_ERR PFX "Cannot create workqueue\n");
10644 return -ENOMEM;
10645 }
10646
10647 return pci_register_driver(&bnx2x_pci_driver);
10648 }
10649
10650 static void __exit bnx2x_cleanup(void)
10651 {
10652 pci_unregister_driver(&bnx2x_pci_driver);
10653
10654 destroy_workqueue(bnx2x_wq);
10655 }
10656
10657 module_init(bnx2x_init);
10658 module_exit(bnx2x_cleanup);
10659
Linux kernel - Deliverables
This page took 0.25442 seconds and 6 git commands to generate.