?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] w1: fix CRC calculation on bigendian platforms.
[linux-2.6/verdex.git] / drivers / net / s2io.c
blobea638b162d3f09223cd16ca8b97f16073650f354
1 /************************************************************************
2 * s2io.c: A Linux PCI-X Ethernet driver for S2IO 10GbE Server NIC
3 * Copyright(c) 2002-2005 Neterion Inc.
4
5 * This software may be used and distributed according to the terms of
6 * the GNU General Public License (GPL), incorporated herein by reference.
7 * Drivers based on or derived from this code fall under the GPL and must
8 * retain the authorship, copyright and license notice. This file is not
9 * a complete program and may only be used when the entire operating
10 * system is licensed under the GPL.
11 * See the file COPYING in this distribution for more information.
12 *
13 * Credits:
14 * Jeff Garzik : For pointing out the improper error condition
15 * check in the s2io_xmit routine and also some
16 * issues in the Tx watch dog function. Also for
17 * patiently answering all those innumerable
18 * questions regaring the 2.6 porting issues.
19 * Stephen Hemminger : Providing proper 2.6 porting mechanism for some
20 * macros available only in 2.6 Kernel.
21 * Francois Romieu : For pointing out all code part that were
22 * deprecated and also styling related comments.
23 * Grant Grundler : For helping me get rid of some Architecture
24 * dependent code.
25 * Christopher Hellwig : Some more 2.6 specific issues in the driver.
26 *
27 * The module loadable parameters that are supported by the driver and a brief
28 * explaination of all the variables.
29 * rx_ring_num : This can be used to program the number of receive rings used
30 * in the driver.
31 * rx_ring_len: This defines the number of descriptors each ring can have. This
32 * is also an array of size 8.
33 * tx_fifo_num: This defines the number of Tx FIFOs thats used int the driver.
34 * tx_fifo_len: This too is an array of 8. Each element defines the number of
35 * Tx descriptors that can be associated with each corresponding FIFO.
36 * in PCI Configuration space.
37 ************************************************************************/
38
39 #include <linux/config.h>
40 #include <linux/module.h>
41 #include <linux/types.h>
42 #include <linux/errno.h>
43 #include <linux/ioport.h>
44 #include <linux/pci.h>
45 #include <linux/dma-mapping.h>
46 #include <linux/kernel.h>
47 #include <linux/netdevice.h>
48 #include <linux/etherdevice.h>
49 #include <linux/skbuff.h>
50 #include <linux/init.h>
51 #include <linux/delay.h>
52 #include <linux/stddef.h>
53 #include <linux/ioctl.h>
54 #include <linux/timex.h>
55 #include <linux/sched.h>
56 #include <linux/ethtool.h>
57 #include <linux/version.h>
58 #include <linux/workqueue.h>
59
60 #include <asm/io.h>
61 #include <asm/system.h>
62 #include <asm/uaccess.h>
63
64 /* local include */
65 #include "s2io.h"
66 #include "s2io-regs.h"
67
68 /* S2io Driver name & version. */
69 static char s2io_driver_name[] = "s2io";
70 static char s2io_driver_version[] = "Version 1.7.7.1";
71
72 /*
73 * Cards with following subsystem_id have a link state indication
74 * problem, 600B, 600C, 600D, 640B, 640C and 640D.
75 * macro below identifies these cards given the subsystem_id.
76 */
77 #define CARDS_WITH_FAULTY_LINK_INDICATORS(subid) \
78 (((subid >= 0x600B) && (subid <= 0x600D)) || \
79 ((subid >= 0x640B) && (subid <= 0x640D))) ? 1 : 0
80
81 #define LINK_IS_UP(val64) (!(val64 & (ADAPTER_STATUS_RMAC_REMOTE_FAULT | \
82 ADAPTER_STATUS_RMAC_LOCAL_FAULT)))
83 #define TASKLET_IN_USE test_and_set_bit(0, (&sp->tasklet_status))
84 #define PANIC 1
85 #define LOW 2
86 static inline int rx_buffer_level(nic_t * sp, int rxb_size, int ring)
87 {
88 int level = 0;
89 if ((sp->pkt_cnt[ring] - rxb_size) > 16) {
90 level = LOW;
91 if ((sp->pkt_cnt[ring] - rxb_size) < MAX_RXDS_PER_BLOCK) {
92 level = PANIC;
93 }
94 }
95
96 return level;
97 }
98
99 /* Ethtool related variables and Macros. */
100 static char s2io_gstrings[][ETH_GSTRING_LEN] = {
101 "Register test\t(offline)",
102 "Eeprom test\t(offline)",
103 "Link test\t(online)",
104 "RLDRAM test\t(offline)",
105 "BIST Test\t(offline)"
106 };
107
108 static char ethtool_stats_keys[][ETH_GSTRING_LEN] = {
109 {"tmac_frms"},
110 {"tmac_data_octets"},
111 {"tmac_drop_frms"},
112 {"tmac_mcst_frms"},
113 {"tmac_bcst_frms"},
114 {"tmac_pause_ctrl_frms"},
115 {"tmac_any_err_frms"},
116 {"tmac_vld_ip_octets"},
117 {"tmac_vld_ip"},
118 {"tmac_drop_ip"},
119 {"tmac_icmp"},
120 {"tmac_rst_tcp"},
121 {"tmac_tcp"},
122 {"tmac_udp"},
123 {"rmac_vld_frms"},
124 {"rmac_data_octets"},
125 {"rmac_fcs_err_frms"},
126 {"rmac_drop_frms"},
127 {"rmac_vld_mcst_frms"},
128 {"rmac_vld_bcst_frms"},
129 {"rmac_in_rng_len_err_frms"},
130 {"rmac_long_frms"},
131 {"rmac_pause_ctrl_frms"},
132 {"rmac_discarded_frms"},
133 {"rmac_usized_frms"},
134 {"rmac_osized_frms"},
135 {"rmac_frag_frms"},
136 {"rmac_jabber_frms"},
137 {"rmac_ip"},
138 {"rmac_ip_octets"},
139 {"rmac_hdr_err_ip"},
140 {"rmac_drop_ip"},
141 {"rmac_icmp"},
142 {"rmac_tcp"},
143 {"rmac_udp"},
144 {"rmac_err_drp_udp"},
145 {"rmac_pause_cnt"},
146 {"rmac_accepted_ip"},
147 {"rmac_err_tcp"},
148 };
149
150 #define S2IO_STAT_LEN sizeof(ethtool_stats_keys)/ ETH_GSTRING_LEN
151 #define S2IO_STAT_STRINGS_LEN S2IO_STAT_LEN * ETH_GSTRING_LEN
152
153 #define S2IO_TEST_LEN sizeof(s2io_gstrings) / ETH_GSTRING_LEN
154 #define S2IO_STRINGS_LEN S2IO_TEST_LEN * ETH_GSTRING_LEN
155
156
157 /*
158 * Constants to be programmed into the Xena's registers, to configure
159 * the XAUI.
160 */
161
162 #define SWITCH_SIGN 0xA5A5A5A5A5A5A5A5ULL
163 #define END_SIGN 0x0
164
165 static u64 default_mdio_cfg[] = {
166 /* Reset PMA PLL */
167 0xC001010000000000ULL, 0xC0010100000000E0ULL,
168 0xC0010100008000E4ULL,
169 /* Remove Reset from PMA PLL */
170 0xC001010000000000ULL, 0xC0010100000000E0ULL,
171 0xC0010100000000E4ULL,
172 END_SIGN
173 };
174
175 static u64 default_dtx_cfg[] = {
176 0x8000051500000000ULL, 0x80000515000000E0ULL,
177 0x80000515D93500E4ULL, 0x8001051500000000ULL,
178 0x80010515000000E0ULL, 0x80010515001E00E4ULL,
179 0x8002051500000000ULL, 0x80020515000000E0ULL,
180 0x80020515F21000E4ULL,
181 /* Set PADLOOPBACKN */
182 0x8002051500000000ULL, 0x80020515000000E0ULL,
183 0x80020515B20000E4ULL, 0x8003051500000000ULL,
184 0x80030515000000E0ULL, 0x80030515B20000E4ULL,
185 0x8004051500000000ULL, 0x80040515000000E0ULL,
186 0x80040515B20000E4ULL, 0x8005051500000000ULL,
187 0x80050515000000E0ULL, 0x80050515B20000E4ULL,
188 SWITCH_SIGN,
189 /* Remove PADLOOPBACKN */
190 0x8002051500000000ULL, 0x80020515000000E0ULL,
191 0x80020515F20000E4ULL, 0x8003051500000000ULL,
192 0x80030515000000E0ULL, 0x80030515F20000E4ULL,
193 0x8004051500000000ULL, 0x80040515000000E0ULL,
194 0x80040515F20000E4ULL, 0x8005051500000000ULL,
195 0x80050515000000E0ULL, 0x80050515F20000E4ULL,
196 END_SIGN
197 };
198
199
200 /*
201 * Constants for Fixing the MacAddress problem seen mostly on
202 * Alpha machines.
203 */
204 static u64 fix_mac[] = {
205 0x0060000000000000ULL, 0x0060600000000000ULL,
206 0x0040600000000000ULL, 0x0000600000000000ULL,
207 0x0020600000000000ULL, 0x0060600000000000ULL,
208 0x0020600000000000ULL, 0x0060600000000000ULL,
209 0x0020600000000000ULL, 0x0060600000000000ULL,
210 0x0020600000000000ULL, 0x0060600000000000ULL,
211 0x0020600000000000ULL, 0x0060600000000000ULL,
212 0x0020600000000000ULL, 0x0060600000000000ULL,
213 0x0020600000000000ULL, 0x0060600000000000ULL,
214 0x0020600000000000ULL, 0x0060600000000000ULL,
215 0x0020600000000000ULL, 0x0060600000000000ULL,
216 0x0020600000000000ULL, 0x0060600000000000ULL,
217 0x0020600000000000ULL, 0x0000600000000000ULL,
218 0x0040600000000000ULL, 0x0060600000000000ULL,
219 END_SIGN
220 };
221
222 /* Module Loadable parameters. */
223 static unsigned int tx_fifo_num = 1;
224 static unsigned int tx_fifo_len[MAX_TX_FIFOS] =
225 {[0 ...(MAX_TX_FIFOS - 1)] = 0 };
226 static unsigned int rx_ring_num = 1;
227 static unsigned int rx_ring_sz[MAX_RX_RINGS] =
228 {[0 ...(MAX_RX_RINGS - 1)] = 0 };
229 static unsigned int Stats_refresh_time = 4;
230 static unsigned int rmac_pause_time = 65535;
231 static unsigned int mc_pause_threshold_q0q3 = 187;
232 static unsigned int mc_pause_threshold_q4q7 = 187;
233 static unsigned int shared_splits;
234 static unsigned int tmac_util_period = 5;
235 static unsigned int rmac_util_period = 5;
236 #ifndef CONFIG_S2IO_NAPI
237 static unsigned int indicate_max_pkts;
238 #endif
239
240 /*
241 * S2IO device table.
242 * This table lists all the devices that this driver supports.
243 */
244 static struct pci_device_id s2io_tbl[] __devinitdata = {
245 {PCI_VENDOR_ID_S2IO, PCI_DEVICE_ID_S2IO_WIN,
246 PCI_ANY_ID, PCI_ANY_ID},
247 {PCI_VENDOR_ID_S2IO, PCI_DEVICE_ID_S2IO_UNI,
248 PCI_ANY_ID, PCI_ANY_ID},
249 {PCI_VENDOR_ID_S2IO, PCI_DEVICE_ID_HERC_WIN,
250 PCI_ANY_ID, PCI_ANY_ID},
251 {PCI_VENDOR_ID_S2IO, PCI_DEVICE_ID_HERC_UNI,
252 PCI_ANY_ID, PCI_ANY_ID},
253 {0,}
254 };
255
256 MODULE_DEVICE_TABLE(pci, s2io_tbl);
257
258 static struct pci_driver s2io_driver = {
259 .name = "S2IO",
260 .id_table = s2io_tbl,
261 .probe = s2io_init_nic,
262 .remove = __devexit_p(s2io_rem_nic),
263 };
264
265 /* A simplifier macro used both by init and free shared_mem Fns(). */
266 #define TXD_MEM_PAGE_CNT(len, per_each) ((len+per_each - 1) / per_each)
267
268 /**
269 * init_shared_mem - Allocation and Initialization of Memory
270 * @nic: Device private variable.
271 * Description: The function allocates all the memory areas shared
272 * between the NIC and the driver. This includes Tx descriptors,
273 * Rx descriptors and the statistics block.
274 */
275
276 static int init_shared_mem(struct s2io_nic *nic)
277 {
278 u32 size;
279 void *tmp_v_addr, *tmp_v_addr_next;
280 dma_addr_t tmp_p_addr, tmp_p_addr_next;
281 RxD_block_t *pre_rxd_blk = NULL;
282 int i, j, blk_cnt;
283 int lst_size, lst_per_page;
284 struct net_device *dev = nic->dev;
285 #ifdef CONFIG_2BUFF_MODE
286 unsigned long tmp;
287 buffAdd_t *ba;
288 #endif
289
290 mac_info_t *mac_control;
291 struct config_param *config;
292
293 mac_control = &nic->mac_control;
294 config = &nic->config;
295
296
297 /* Allocation and initialization of TXDLs in FIOFs */
298 size = 0;
299 for (i = 0; i < config->tx_fifo_num; i++) {
300 size += config->tx_cfg[i].fifo_len;
301 }
302 if (size > MAX_AVAILABLE_TXDS) {
303 DBG_PRINT(ERR_DBG, "%s: Total number of Tx FIFOs ",
304 dev->name);
305 DBG_PRINT(ERR_DBG, "exceeds the maximum value ");
306 DBG_PRINT(ERR_DBG, "that can be used\n");
307 return FAILURE;
308 }
309
310 lst_size = (sizeof(TxD_t) * config->max_txds);
311 lst_per_page = PAGE_SIZE / lst_size;
312
313 for (i = 0; i < config->tx_fifo_num; i++) {
314 int fifo_len = config->tx_cfg[i].fifo_len;
315 int list_holder_size = fifo_len * sizeof(list_info_hold_t);
316 nic->list_info[i] = kmalloc(list_holder_size, GFP_KERNEL);
317 if (!nic->list_info[i]) {
318 DBG_PRINT(ERR_DBG,
319 "Malloc failed for list_info\n");
320 return -ENOMEM;
321 }
322 memset(nic->list_info[i], 0, list_holder_size);
323 }
324 for (i = 0; i < config->tx_fifo_num; i++) {
325 int page_num = TXD_MEM_PAGE_CNT(config->tx_cfg[i].fifo_len,
326 lst_per_page);
327 mac_control->tx_curr_put_info[i].offset = 0;
328 mac_control->tx_curr_put_info[i].fifo_len =
329 config->tx_cfg[i].fifo_len - 1;
330 mac_control->tx_curr_get_info[i].offset = 0;
331 mac_control->tx_curr_get_info[i].fifo_len =
332 config->tx_cfg[i].fifo_len - 1;
333 for (j = 0; j < page_num; j++) {
334 int k = 0;
335 dma_addr_t tmp_p;
336 void *tmp_v;
337 tmp_v = pci_alloc_consistent(nic->pdev,
338 PAGE_SIZE, &tmp_p);
339 if (!tmp_v) {
340 DBG_PRINT(ERR_DBG,
341 "pci_alloc_consistent ");
342 DBG_PRINT(ERR_DBG, "failed for TxDL\n");
343 return -ENOMEM;
344 }
345 while (k < lst_per_page) {
346 int l = (j * lst_per_page) + k;
347 if (l == config->tx_cfg[i].fifo_len)
348 goto end_txd_alloc;
349 nic->list_info[i][l].list_virt_addr =
350 tmp_v + (k * lst_size);
351 nic->list_info[i][l].list_phy_addr =
352 tmp_p + (k * lst_size);
353 k++;
354 }
355 }
356 }
357 end_txd_alloc:
358
359 /* Allocation and initialization of RXDs in Rings */
360 size = 0;
361 for (i = 0; i < config->rx_ring_num; i++) {
362 if (config->rx_cfg[i].num_rxd % (MAX_RXDS_PER_BLOCK + 1)) {
363 DBG_PRINT(ERR_DBG, "%s: RxD count of ", dev->name);
364 DBG_PRINT(ERR_DBG, "Ring%d is not a multiple of ",
365 i);
366 DBG_PRINT(ERR_DBG, "RxDs per Block");
367 return FAILURE;
368 }
369 size += config->rx_cfg[i].num_rxd;
370 nic->block_count[i] =
371 config->rx_cfg[i].num_rxd / (MAX_RXDS_PER_BLOCK + 1);
372 nic->pkt_cnt[i] =
373 config->rx_cfg[i].num_rxd - nic->block_count[i];
374 }
375
376 for (i = 0; i < config->rx_ring_num; i++) {
377 mac_control->rx_curr_get_info[i].block_index = 0;
378 mac_control->rx_curr_get_info[i].offset = 0;
379 mac_control->rx_curr_get_info[i].ring_len =
380 config->rx_cfg[i].num_rxd - 1;
381 mac_control->rx_curr_put_info[i].block_index = 0;
382 mac_control->rx_curr_put_info[i].offset = 0;
383 mac_control->rx_curr_put_info[i].ring_len =
384 config->rx_cfg[i].num_rxd - 1;
385 blk_cnt =
386 config->rx_cfg[i].num_rxd / (MAX_RXDS_PER_BLOCK + 1);
387 /* Allocating all the Rx blocks */
388 for (j = 0; j < blk_cnt; j++) {
389 #ifndef CONFIG_2BUFF_MODE
390 size = (MAX_RXDS_PER_BLOCK + 1) * (sizeof(RxD_t));
391 #else
392 size = SIZE_OF_BLOCK;
393 #endif
394 tmp_v_addr = pci_alloc_consistent(nic->pdev, size,
395 &tmp_p_addr);
396 if (tmp_v_addr == NULL) {
397 /*
398 * In case of failure, free_shared_mem()
399 * is called, which should free any
400 * memory that was alloced till the
401 * failure happened.
402 */
403 nic->rx_blocks[i][j].block_virt_addr =
404 tmp_v_addr;
405 return -ENOMEM;
406 }
407 memset(tmp_v_addr, 0, size);
408 nic->rx_blocks[i][j].block_virt_addr = tmp_v_addr;
409 nic->rx_blocks[i][j].block_dma_addr = tmp_p_addr;
410 }
411 /* Interlinking all Rx Blocks */
412 for (j = 0; j < blk_cnt; j++) {
413 tmp_v_addr = nic->rx_blocks[i][j].block_virt_addr;
414 tmp_v_addr_next =
415 nic->rx_blocks[i][(j + 1) %
416 blk_cnt].block_virt_addr;
417 tmp_p_addr = nic->rx_blocks[i][j].block_dma_addr;
418 tmp_p_addr_next =
419 nic->rx_blocks[i][(j + 1) %
420 blk_cnt].block_dma_addr;
421
422 pre_rxd_blk = (RxD_block_t *) tmp_v_addr;
423 pre_rxd_blk->reserved_1 = END_OF_BLOCK; /* last RxD
424 * marker.
425 */
426 #ifndef CONFIG_2BUFF_MODE
427 pre_rxd_blk->reserved_2_pNext_RxD_block =
428 (unsigned long) tmp_v_addr_next;
429 #endif
430 pre_rxd_blk->pNext_RxD_Blk_physical =
431 (u64) tmp_p_addr_next;
432 }
433 }
434
435 #ifdef CONFIG_2BUFF_MODE
436 /*
437 * Allocation of Storages for buffer addresses in 2BUFF mode
438 * and the buffers as well.
439 */
440 for (i = 0; i < config->rx_ring_num; i++) {
441 blk_cnt =
442 config->rx_cfg[i].num_rxd / (MAX_RXDS_PER_BLOCK + 1);
443 nic->ba[i] = kmalloc((sizeof(buffAdd_t *) * blk_cnt),
444 GFP_KERNEL);
445 if (!nic->ba[i])
446 return -ENOMEM;
447 for (j = 0; j < blk_cnt; j++) {
448 int k = 0;
449 nic->ba[i][j] = kmalloc((sizeof(buffAdd_t) *
450 (MAX_RXDS_PER_BLOCK + 1)),
451 GFP_KERNEL);
452 if (!nic->ba[i][j])
453 return -ENOMEM;
454 while (k != MAX_RXDS_PER_BLOCK) {
455 ba = &nic->ba[i][j][k];
456
457 ba->ba_0_org = kmalloc
458 (BUF0_LEN + ALIGN_SIZE, GFP_KERNEL);
459 if (!ba->ba_0_org)
460 return -ENOMEM;
461 tmp = (unsigned long) ba->ba_0_org;
462 tmp += ALIGN_SIZE;
463 tmp &= ~((unsigned long) ALIGN_SIZE);
464 ba->ba_0 = (void *) tmp;
465
466 ba->ba_1_org = kmalloc
467 (BUF1_LEN + ALIGN_SIZE, GFP_KERNEL);
468 if (!ba->ba_1_org)
469 return -ENOMEM;
470 tmp = (unsigned long) ba->ba_1_org;
471 tmp += ALIGN_SIZE;
472 tmp &= ~((unsigned long) ALIGN_SIZE);
473 ba->ba_1 = (void *) tmp;
474 k++;
475 }
476 }
477 }
478 #endif
479
480 /* Allocation and initialization of Statistics block */
481 size = sizeof(StatInfo_t);
482 mac_control->stats_mem = pci_alloc_consistent
483 (nic->pdev, size, &mac_control->stats_mem_phy);
484
485 if (!mac_control->stats_mem) {
486 /*
487 * In case of failure, free_shared_mem() is called, which
488 * should free any memory that was alloced till the
489 * failure happened.
490 */
491 return -ENOMEM;
492 }
493 mac_control->stats_mem_sz = size;
494
495 tmp_v_addr = mac_control->stats_mem;
496 mac_control->stats_info = (StatInfo_t *) tmp_v_addr;
497 memset(tmp_v_addr, 0, size);
498
499 DBG_PRINT(INIT_DBG, "%s:Ring Mem PHY: 0x%llx\n", dev->name,
500 (unsigned long long) tmp_p_addr);
501
502 return SUCCESS;
503 }
504
505 /**
506 * free_shared_mem - Free the allocated Memory
507 * @nic: Device private variable.
508 * Description: This function is to free all memory locations allocated by
509 * the init_shared_mem() function and return it to the kernel.
510 */
511
512 static void free_shared_mem(struct s2io_nic *nic)
513 {
514 int i, j, blk_cnt, size;
515 void *tmp_v_addr;
516 dma_addr_t tmp_p_addr;
517 mac_info_t *mac_control;
518 struct config_param *config;
519 int lst_size, lst_per_page;
520
521
522 if (!nic)
523 return;
524
525 mac_control = &nic->mac_control;
526 config = &nic->config;
527
528 lst_size = (sizeof(TxD_t) * config->max_txds);
529 lst_per_page = PAGE_SIZE / lst_size;
530
531 for (i = 0; i < config->tx_fifo_num; i++) {
532 int page_num = TXD_MEM_PAGE_CNT(config->tx_cfg[i].fifo_len,
533 lst_per_page);
534 for (j = 0; j < page_num; j++) {
535 int mem_blks = (j * lst_per_page);
536 if (!nic->list_info[i][mem_blks].list_virt_addr)
537 break;
538 pci_free_consistent(nic->pdev, PAGE_SIZE,
539 nic->list_info[i][mem_blks].
540 list_virt_addr,
541 nic->list_info[i][mem_blks].
542 list_phy_addr);
543 }
544 kfree(nic->list_info[i]);
545 }
546
547 #ifndef CONFIG_2BUFF_MODE
548 size = (MAX_RXDS_PER_BLOCK + 1) * (sizeof(RxD_t));
549 #else
550 size = SIZE_OF_BLOCK;
551 #endif
552 for (i = 0; i < config->rx_ring_num; i++) {
553 blk_cnt = nic->block_count[i];
554 for (j = 0; j < blk_cnt; j++) {
555 tmp_v_addr = nic->rx_blocks[i][j].block_virt_addr;
556 tmp_p_addr = nic->rx_blocks[i][j].block_dma_addr;
557 if (tmp_v_addr == NULL)
558 break;
559 pci_free_consistent(nic->pdev, size,
560 tmp_v_addr, tmp_p_addr);
561 }
562 }
563
564 #ifdef CONFIG_2BUFF_MODE
565 /* Freeing buffer storage addresses in 2BUFF mode. */
566 for (i = 0; i < config->rx_ring_num; i++) {
567 blk_cnt =
568 config->rx_cfg[i].num_rxd / (MAX_RXDS_PER_BLOCK + 1);
569 if (!nic->ba[i])
570 goto end_free;
571 for (j = 0; j < blk_cnt; j++) {
572 int k = 0;
573 if (!nic->ba[i][j]) {
574 kfree(nic->ba[i]);
575 goto end_free;
576 }
577 while (k != MAX_RXDS_PER_BLOCK) {
578 buffAdd_t *ba = &nic->ba[i][j][k];
579 if (!ba || !ba->ba_0_org || !ba->ba_1_org)
580 {
581 kfree(nic->ba[i]);
582 kfree(nic->ba[i][j]);
583 if(ba->ba_0_org)
584 kfree(ba->ba_0_org);
585 if(ba->ba_1_org)
586 kfree(ba->ba_1_org);
587 goto end_free;
588 }
589 kfree(ba->ba_0_org);
590 kfree(ba->ba_1_org);
591 k++;
592 }
593 kfree(nic->ba[i][j]);
594 }
595 kfree(nic->ba[i]);
596 }
597 end_free:
598 #endif
599
600 if (mac_control->stats_mem) {
601 pci_free_consistent(nic->pdev,
602 mac_control->stats_mem_sz,
603 mac_control->stats_mem,
604 mac_control->stats_mem_phy);
605 }
606 }
607
608 /**
609 * init_nic - Initialization of hardware
610 * @nic: device peivate variable
611 * Description: The function sequentially configures every block
612 * of the H/W from their reset values.
613 * Return Value: SUCCESS on success and
614 * '-1' on failure (endian settings incorrect).
615 */
616
617 static int init_nic(struct s2io_nic *nic)
618 {
619 XENA_dev_config_t __iomem *bar0 = nic->bar0;
620 struct net_device *dev = nic->dev;
621 register u64 val64 = 0;
622 void __iomem *add;
623 u32 time;
624 int i, j;
625 mac_info_t *mac_control;
626 struct config_param *config;
627 int mdio_cnt = 0, dtx_cnt = 0;
628 unsigned long long mem_share;
629
630 mac_control = &nic->mac_control;
631 config = &nic->config;
632
633 /* Initialize swapper control register */
634 if (s2io_set_swapper(nic)) {
635 DBG_PRINT(ERR_DBG,"ERROR: Setting Swapper failed\n");
636 return -1;
637 }
638
639 /* Remove XGXS from reset state */
640 val64 = 0;
641 writeq(val64, &bar0->sw_reset);
642 val64 = readq(&bar0->sw_reset);
643 msleep(500);
644
645 /* Enable Receiving broadcasts */
646 add = &bar0->mac_cfg;
647 val64 = readq(&bar0->mac_cfg);
648 val64 |= MAC_RMAC_BCAST_ENABLE;
649 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
650 writel((u32) val64, add);
651 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
652 writel((u32) (val64 >> 32), (add + 4));
653
654 /* Read registers in all blocks */
655 val64 = readq(&bar0->mac_int_mask);
656 val64 = readq(&bar0->mc_int_mask);
657 val64 = readq(&bar0->xgxs_int_mask);
658
659 /* Set MTU */
660 val64 = dev->mtu;
661 writeq(vBIT(val64, 2, 14), &bar0->rmac_max_pyld_len);
662
663 /*
664 * Configuring the XAUI Interface of Xena.
665 * ***************************************
666 * To Configure the Xena's XAUI, one has to write a series
667 * of 64 bit values into two registers in a particular
668 * sequence. Hence a macro 'SWITCH_SIGN' has been defined
669 * which will be defined in the array of configuration values
670 * (default_dtx_cfg & default_mdio_cfg) at appropriate places
671 * to switch writing from one regsiter to another. We continue
672 * writing these values until we encounter the 'END_SIGN' macro.
673 * For example, After making a series of 21 writes into
674 * dtx_control register the 'SWITCH_SIGN' appears and hence we
675 * start writing into mdio_control until we encounter END_SIGN.
676 */
677 while (1) {
678 dtx_cfg:
679 while (default_dtx_cfg[dtx_cnt] != END_SIGN) {
680 if (default_dtx_cfg[dtx_cnt] == SWITCH_SIGN) {
681 dtx_cnt++;
682 goto mdio_cfg;
683 }
684 SPECIAL_REG_WRITE(default_dtx_cfg[dtx_cnt],
685 &bar0->dtx_control, UF);
686 val64 = readq(&bar0->dtx_control);
687 dtx_cnt++;
688 }
689 mdio_cfg:
690 while (default_mdio_cfg[mdio_cnt] != END_SIGN) {
691 if (default_mdio_cfg[mdio_cnt] == SWITCH_SIGN) {
692 mdio_cnt++;
693 goto dtx_cfg;
694 }
695 SPECIAL_REG_WRITE(default_mdio_cfg[mdio_cnt],
696 &bar0->mdio_control, UF);
697 val64 = readq(&bar0->mdio_control);
698 mdio_cnt++;
699 }
700 if ((default_dtx_cfg[dtx_cnt] == END_SIGN) &&
701 (default_mdio_cfg[mdio_cnt] == END_SIGN)) {
702 break;
703 } else {
704 goto dtx_cfg;
705 }
706 }
707
708 /* Tx DMA Initialization */
709 val64 = 0;
710 writeq(val64, &bar0->tx_fifo_partition_0);
711 writeq(val64, &bar0->tx_fifo_partition_1);
712 writeq(val64, &bar0->tx_fifo_partition_2);
713 writeq(val64, &bar0->tx_fifo_partition_3);
714
715
716 for (i = 0, j = 0; i < config->tx_fifo_num; i++) {
717 val64 |=
718 vBIT(config->tx_cfg[i].fifo_len - 1, ((i * 32) + 19),
719 13) | vBIT(config->tx_cfg[i].fifo_priority,
720 ((i * 32) + 5), 3);
721
722 if (i == (config->tx_fifo_num - 1)) {
723 if (i % 2 == 0)
724 i++;
725 }
726
727 switch (i) {
728 case 1:
729 writeq(val64, &bar0->tx_fifo_partition_0);
730 val64 = 0;
731 break;
732 case 3:
733 writeq(val64, &bar0->tx_fifo_partition_1);
734 val64 = 0;
735 break;
736 case 5:
737 writeq(val64, &bar0->tx_fifo_partition_2);
738 val64 = 0;
739 break;
740 case 7:
741 writeq(val64, &bar0->tx_fifo_partition_3);
742 break;
743 }
744 }
745
746 /* Enable Tx FIFO partition 0. */
747 val64 = readq(&bar0->tx_fifo_partition_0);
748 val64 |= BIT(0); /* To enable the FIFO partition. */
749 writeq(val64, &bar0->tx_fifo_partition_0);
750
751 val64 = readq(&bar0->tx_fifo_partition_0);
752 DBG_PRINT(INIT_DBG, "Fifo partition at: 0x%p is: 0x%llx\n",
753 &bar0->tx_fifo_partition_0, (unsigned long long) val64);
754
755 /*
756 * Initialization of Tx_PA_CONFIG register to ignore packet
757 * integrity checking.
758 */
759 val64 = readq(&bar0->tx_pa_cfg);
760 val64 |= TX_PA_CFG_IGNORE_FRM_ERR | TX_PA_CFG_IGNORE_SNAP_OUI |
761 TX_PA_CFG_IGNORE_LLC_CTRL | TX_PA_CFG_IGNORE_L2_ERR;
762 writeq(val64, &bar0->tx_pa_cfg);
763
764 /* Rx DMA intialization. */
765 val64 = 0;
766 for (i = 0; i < config->rx_ring_num; i++) {
767 val64 |=
768 vBIT(config->rx_cfg[i].ring_priority, (5 + (i * 8)),
769 3);
770 }
771 writeq(val64, &bar0->rx_queue_priority);
772
773 /*
774 * Allocating equal share of memory to all the
775 * configured Rings.
776 */
777 val64 = 0;
778 for (i = 0; i < config->rx_ring_num; i++) {
779 switch (i) {
780 case 0:
781 mem_share = (64 / config->rx_ring_num +
782 64 % config->rx_ring_num);
783 val64 |= RX_QUEUE_CFG_Q0_SZ(mem_share);
784 continue;
785 case 1:
786 mem_share = (64 / config->rx_ring_num);
787 val64 |= RX_QUEUE_CFG_Q1_SZ(mem_share);
788 continue;
789 case 2:
790 mem_share = (64 / config->rx_ring_num);
791 val64 |= RX_QUEUE_CFG_Q2_SZ(mem_share);
792 continue;
793 case 3:
794 mem_share = (64 / config->rx_ring_num);
795 val64 |= RX_QUEUE_CFG_Q3_SZ(mem_share);
796 continue;
797 case 4:
798 mem_share = (64 / config->rx_ring_num);
799 val64 |= RX_QUEUE_CFG_Q4_SZ(mem_share);
800 continue;
801 case 5:
802 mem_share = (64 / config->rx_ring_num);
803 val64 |= RX_QUEUE_CFG_Q5_SZ(mem_share);
804 continue;
805 case 6:
806 mem_share = (64 / config->rx_ring_num);
807 val64 |= RX_QUEUE_CFG_Q6_SZ(mem_share);
808 continue;
809 case 7:
810 mem_share = (64 / config->rx_ring_num);
811 val64 |= RX_QUEUE_CFG_Q7_SZ(mem_share);
812 continue;
813 }
814 }
815 writeq(val64, &bar0->rx_queue_cfg);
816
817 /*
818 * Initializing the Tx round robin registers to 0.
819 * Filling Tx and Rx round robin registers as per the
820 * number of FIFOs and Rings is still TODO.
821 */
822 writeq(0, &bar0->tx_w_round_robin_0);
823 writeq(0, &bar0->tx_w_round_robin_1);
824 writeq(0, &bar0->tx_w_round_robin_2);
825 writeq(0, &bar0->tx_w_round_robin_3);
826 writeq(0, &bar0->tx_w_round_robin_4);
827
828 /*
829 * TODO
830 * Disable Rx steering. Hard coding all packets be steered to
831 * Queue 0 for now.
832 */
833 val64 = 0x8080808080808080ULL;
834 writeq(val64, &bar0->rts_qos_steering);
835
836 /* UDP Fix */
837 val64 = 0;
838 for (i = 1; i < 8; i++)
839 writeq(val64, &bar0->rts_frm_len_n[i]);
840
841 /* Set rts_frm_len register for fifo 0 */
842 writeq(MAC_RTS_FRM_LEN_SET(dev->mtu + 22),
843 &bar0->rts_frm_len_n[0]);
844
845 /* Enable statistics */
846 writeq(mac_control->stats_mem_phy, &bar0->stat_addr);
847 val64 = SET_UPDT_PERIOD(Stats_refresh_time) |
848 STAT_CFG_STAT_RO | STAT_CFG_STAT_EN;
849 writeq(val64, &bar0->stat_cfg);
850
851 /*
852 * Initializing the sampling rate for the device to calculate the
853 * bandwidth utilization.
854 */
855 val64 = MAC_TX_LINK_UTIL_VAL(tmac_util_period) |
856 MAC_RX_LINK_UTIL_VAL(rmac_util_period);
857 writeq(val64, &bar0->mac_link_util);
858
859
860 /*
861 * Initializing the Transmit and Receive Traffic Interrupt
862 * Scheme.
863 */
864 /* TTI Initialization. Default Tx timer gets us about
865 * 250 interrupts per sec. Continuous interrupts are enabled
866 * by default.
867 */
868 val64 = TTI_DATA1_MEM_TX_TIMER_VAL(0x2078) |
869 TTI_DATA1_MEM_TX_URNG_A(0xA) |
870 TTI_DATA1_MEM_TX_URNG_B(0x10) |
871 TTI_DATA1_MEM_TX_URNG_C(0x30) | TTI_DATA1_MEM_TX_TIMER_AC_EN |
872 TTI_DATA1_MEM_TX_TIMER_CI_EN;
873 writeq(val64, &bar0->tti_data1_mem);
874
875 val64 = TTI_DATA2_MEM_TX_UFC_A(0x10) |
876 TTI_DATA2_MEM_TX_UFC_B(0x20) |
877 TTI_DATA2_MEM_TX_UFC_C(0x40) | TTI_DATA2_MEM_TX_UFC_D(0x80);
878 writeq(val64, &bar0->tti_data2_mem);
879
880 val64 = TTI_CMD_MEM_WE | TTI_CMD_MEM_STROBE_NEW_CMD;
881 writeq(val64, &bar0->tti_command_mem);
882
883 /*
884 * Once the operation completes, the Strobe bit of the command
885 * register will be reset. We poll for this particular condition
886 * We wait for a maximum of 500ms for the operation to complete,
887 * if it's not complete by then we return error.
888 */
889 time = 0;
890 while (TRUE) {
891 val64 = readq(&bar0->tti_command_mem);
892 if (!(val64 & TTI_CMD_MEM_STROBE_NEW_CMD)) {
893 break;
894 }
895 if (time > 10) {
896 DBG_PRINT(ERR_DBG, "%s: TTI init Failed\n",
897 dev->name);
898 return -1;
899 }
900 msleep(50);
901 time++;
902 }
903
904 /* RTI Initialization */
905 val64 = RTI_DATA1_MEM_RX_TIMER_VAL(0xFFF) |
906 RTI_DATA1_MEM_RX_URNG_A(0xA) |
907 RTI_DATA1_MEM_RX_URNG_B(0x10) |
908 RTI_DATA1_MEM_RX_URNG_C(0x30) | RTI_DATA1_MEM_RX_TIMER_AC_EN;
909
910 writeq(val64, &bar0->rti_data1_mem);
911
912 val64 = RTI_DATA2_MEM_RX_UFC_A(0x1) |
913 RTI_DATA2_MEM_RX_UFC_B(0x2) |
914 RTI_DATA2_MEM_RX_UFC_C(0x40) | RTI_DATA2_MEM_RX_UFC_D(0x80);
915 writeq(val64, &bar0->rti_data2_mem);
916
917 val64 = RTI_CMD_MEM_WE | RTI_CMD_MEM_STROBE_NEW_CMD;
918 writeq(val64, &bar0->rti_command_mem);
919
920 /*
921 * Once the operation completes, the Strobe bit of the command
922 * register will be reset. We poll for this particular condition
923 * We wait for a maximum of 500ms for the operation to complete,
924 * if it's not complete by then we return error.
925 */
926 time = 0;
927 while (TRUE) {
928 val64 = readq(&bar0->rti_command_mem);
929 if (!(val64 & TTI_CMD_MEM_STROBE_NEW_CMD)) {
930 break;
931 }
932 if (time > 10) {
933 DBG_PRINT(ERR_DBG, "%s: RTI init Failed\n",
934 dev->name);
935 return -1;
936 }
937 time++;
938 msleep(50);
939 }
940
941 /*
942 * Initializing proper values as Pause threshold into all
943 * the 8 Queues on Rx side.
944 */
945 writeq(0xffbbffbbffbbffbbULL, &bar0->mc_pause_thresh_q0q3);
946 writeq(0xffbbffbbffbbffbbULL, &bar0->mc_pause_thresh_q4q7);
947
948 /* Disable RMAC PAD STRIPPING */
949 add = &bar0->mac_cfg;
950 val64 = readq(&bar0->mac_cfg);
951 val64 &= ~(MAC_CFG_RMAC_STRIP_PAD);
952 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
953 writel((u32) (val64), add);
954 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
955 writel((u32) (val64 >> 32), (add + 4));
956 val64 = readq(&bar0->mac_cfg);
957
958 /*
959 * Set the time value to be inserted in the pause frame
960 * generated by xena.
961 */
962 val64 = readq(&bar0->rmac_pause_cfg);
963 val64 &= ~(RMAC_PAUSE_HG_PTIME(0xffff));
964 val64 |= RMAC_PAUSE_HG_PTIME(nic->mac_control.rmac_pause_time);
965 writeq(val64, &bar0->rmac_pause_cfg);
966
967 /*
968 * Set the Threshold Limit for Generating the pause frame
969 * If the amount of data in any Queue exceeds ratio of
970 * (mac_control.mc_pause_threshold_q0q3 or q4q7)/256
971 * pause frame is generated
972 */
973 val64 = 0;
974 for (i = 0; i < 4; i++) {
975 val64 |=
976 (((u64) 0xFF00 | nic->mac_control.
977 mc_pause_threshold_q0q3)
978 << (i * 2 * 8));
979 }
980 writeq(val64, &bar0->mc_pause_thresh_q0q3);
981
982 val64 = 0;
983 for (i = 0; i < 4; i++) {
984 val64 |=
985 (((u64) 0xFF00 | nic->mac_control.
986 mc_pause_threshold_q4q7)
987 << (i * 2 * 8));
988 }
989 writeq(val64, &bar0->mc_pause_thresh_q4q7);
990
991 /*
992 * TxDMA will stop Read request if the number of read split has
993 * exceeded the limit pointed by shared_splits
994 */
995 val64 = readq(&bar0->pic_control);
996 val64 |= PIC_CNTL_SHARED_SPLITS(shared_splits);
997 writeq(val64, &bar0->pic_control);
998
999 return SUCCESS;
1000 }
1001
1002 /**
1003 * en_dis_able_nic_intrs - Enable or Disable the interrupts
1004 * @nic: device private variable,
1005 * @mask: A mask indicating which Intr block must be modified and,
1006 * @flag: A flag indicating whether to enable or disable the Intrs.
1007 * Description: This function will either disable or enable the interrupts
1008 * depending on the flag argument. The mask argument can be used to
1009 * enable/disable any Intr block.
1010 * Return Value: NONE.
1011 */
1012
1013 static void en_dis_able_nic_intrs(struct s2io_nic *nic, u16 mask, int flag)
1014 {
1015 XENA_dev_config_t __iomem *bar0 = nic->bar0;
1016 register u64 val64 = 0, temp64 = 0;
1017
1018 /* Top level interrupt classification */
1019 /* PIC Interrupts */
1020 if ((mask & (TX_PIC_INTR | RX_PIC_INTR))) {
1021 /* Enable PIC Intrs in the general intr mask register */
1022 val64 = TXPIC_INT_M | PIC_RX_INT_M;
1023 if (flag == ENABLE_INTRS) {
1024 temp64 = readq(&bar0->general_int_mask);
1025 temp64 &= ~((u64) val64);
1026 writeq(temp64, &bar0->general_int_mask);
1027 /*
1028 * Disabled all PCIX, Flash, MDIO, IIC and GPIO
1029 * interrupts for now.
1030 * TODO
1031 */
1032 writeq(DISABLE_ALL_INTRS, &bar0->pic_int_mask);
1033 /*
1034 * No MSI Support is available presently, so TTI and
1035 * RTI interrupts are also disabled.
1036 */
1037 } else if (flag == DISABLE_INTRS) {
1038 /*
1039 * Disable PIC Intrs in the general
1040 * intr mask register
1041 */
1042 writeq(DISABLE_ALL_INTRS, &bar0->pic_int_mask);
1043 temp64 = readq(&bar0->general_int_mask);
1044 val64 |= temp64;
1045 writeq(val64, &bar0->general_int_mask);
1046 }
1047 }
1048
1049 /* DMA Interrupts */
1050 /* Enabling/Disabling Tx DMA interrupts */
1051 if (mask & TX_DMA_INTR) {
1052 /* Enable TxDMA Intrs in the general intr mask register */
1053 val64 = TXDMA_INT_M;
1054 if (flag == ENABLE_INTRS) {
1055 temp64 = readq(&bar0->general_int_mask);
1056 temp64 &= ~((u64) val64);
1057 writeq(temp64, &bar0->general_int_mask);
1058 /*
1059 * Keep all interrupts other than PFC interrupt
1060 * and PCC interrupt disabled in DMA level.
1061 */
1062 val64 = DISABLE_ALL_INTRS & ~(TXDMA_PFC_INT_M |
1063 TXDMA_PCC_INT_M);
1064 writeq(val64, &bar0->txdma_int_mask);
1065 /*
1066 * Enable only the MISC error 1 interrupt in PFC block
1067 */
1068 val64 = DISABLE_ALL_INTRS & (~PFC_MISC_ERR_1);
1069 writeq(val64, &bar0->pfc_err_mask);
1070 /*
1071 * Enable only the FB_ECC error interrupt in PCC block
1072 */
1073 val64 = DISABLE_ALL_INTRS & (~PCC_FB_ECC_ERR);
1074 writeq(val64, &bar0->pcc_err_mask);
1075 } else if (flag == DISABLE_INTRS) {
1076 /*
1077 * Disable TxDMA Intrs in the general intr mask
1078 * register
1079 */
1080 writeq(DISABLE_ALL_INTRS, &bar0->txdma_int_mask);
1081 writeq(DISABLE_ALL_INTRS, &bar0->pfc_err_mask);
1082 temp64 = readq(&bar0->general_int_mask);
1083 val64 |= temp64;
1084 writeq(val64, &bar0->general_int_mask);
1085 }
1086 }
1087
1088 /* Enabling/Disabling Rx DMA interrupts */
1089 if (mask & RX_DMA_INTR) {
1090 /* Enable RxDMA Intrs in the general intr mask register */
1091 val64 = RXDMA_INT_M;
1092 if (flag == ENABLE_INTRS) {
1093 temp64 = readq(&bar0->general_int_mask);
1094 temp64 &= ~((u64) val64);
1095 writeq(temp64, &bar0->general_int_mask);
1096 /*
1097 * All RxDMA block interrupts are disabled for now
1098 * TODO
1099 */
1100 writeq(DISABLE_ALL_INTRS, &bar0->rxdma_int_mask);
1101 } else if (flag == DISABLE_INTRS) {
1102 /*
1103 * Disable RxDMA Intrs in the general intr mask
1104 * register
1105 */
1106 writeq(DISABLE_ALL_INTRS, &bar0->rxdma_int_mask);
1107 temp64 = readq(&bar0->general_int_mask);
1108 val64 |= temp64;
1109 writeq(val64, &bar0->general_int_mask);
1110 }
1111 }
1112
1113 /* MAC Interrupts */
1114 /* Enabling/Disabling MAC interrupts */
1115 if (mask & (TX_MAC_INTR | RX_MAC_INTR)) {
1116 val64 = TXMAC_INT_M | RXMAC_INT_M;
1117 if (flag == ENABLE_INTRS) {
1118 temp64 = readq(&bar0->general_int_mask);
1119 temp64 &= ~((u64) val64);
1120 writeq(temp64, &bar0->general_int_mask);
1121 /*
1122 * All MAC block error interrupts are disabled for now
1123 * except the link status change interrupt.
1124 * TODO
1125 */
1126 val64 = MAC_INT_STATUS_RMAC_INT;
1127 temp64 = readq(&bar0->mac_int_mask);
1128 temp64 &= ~((u64) val64);
1129 writeq(temp64, &bar0->mac_int_mask);
1130
1131 val64 = readq(&bar0->mac_rmac_err_mask);
1132 val64 &= ~((u64) RMAC_LINK_STATE_CHANGE_INT);
1133 writeq(val64, &bar0->mac_rmac_err_mask);
1134 } else if (flag == DISABLE_INTRS) {
1135 /*
1136 * Disable MAC Intrs in the general intr mask register
1137 */
1138 writeq(DISABLE_ALL_INTRS, &bar0->mac_int_mask);
1139 writeq(DISABLE_ALL_INTRS,
1140 &bar0->mac_rmac_err_mask);
1141
1142 temp64 = readq(&bar0->general_int_mask);
1143 val64 |= temp64;
1144 writeq(val64, &bar0->general_int_mask);
1145 }
1146 }
1147
1148 /* XGXS Interrupts */
1149 if (mask & (TX_XGXS_INTR | RX_XGXS_INTR)) {
1150 val64 = TXXGXS_INT_M | RXXGXS_INT_M;
1151 if (flag == ENABLE_INTRS) {
1152 temp64 = readq(&bar0->general_int_mask);
1153 temp64 &= ~((u64) val64);
1154 writeq(temp64, &bar0->general_int_mask);
1155 /*
1156 * All XGXS block error interrupts are disabled for now
1157 * TODO
1158 */
1159 writeq(DISABLE_ALL_INTRS, &bar0->xgxs_int_mask);
1160 } else if (flag == DISABLE_INTRS) {
1161 /*
1162 * Disable MC Intrs in the general intr mask register
1163 */
1164 writeq(DISABLE_ALL_INTRS, &bar0->xgxs_int_mask);
1165 temp64 = readq(&bar0->general_int_mask);
1166 val64 |= temp64;
1167 writeq(val64, &bar0->general_int_mask);
1168 }
1169 }
1170
1171 /* Memory Controller(MC) interrupts */
1172 if (mask & MC_INTR) {
1173 val64 = MC_INT_M;
1174 if (flag == ENABLE_INTRS) {
1175 temp64 = readq(&bar0->general_int_mask);
1176 temp64 &= ~((u64) val64);
1177 writeq(temp64, &bar0->general_int_mask);
1178 /*
1179 * All MC block error interrupts are disabled for now
1180 * TODO
1181 */
1182 writeq(DISABLE_ALL_INTRS, &bar0->mc_int_mask);
1183 } else if (flag == DISABLE_INTRS) {
1184 /*
1185 * Disable MC Intrs in the general intr mask register
1186 */
1187 writeq(DISABLE_ALL_INTRS, &bar0->mc_int_mask);
1188 temp64 = readq(&bar0->general_int_mask);
1189 val64 |= temp64;
1190 writeq(val64, &bar0->general_int_mask);
1191 }
1192 }
1193
1194
1195 /* Tx traffic interrupts */
1196 if (mask & TX_TRAFFIC_INTR) {
1197 val64 = TXTRAFFIC_INT_M;
1198 if (flag == ENABLE_INTRS) {
1199 temp64 = readq(&bar0->general_int_mask);
1200 temp64 &= ~((u64) val64);
1201 writeq(temp64, &bar0->general_int_mask);
1202 /*
1203 * Enable all the Tx side interrupts
1204 * writing 0 Enables all 64 TX interrupt levels
1205 */
1206 writeq(0x0, &bar0->tx_traffic_mask);
1207 } else if (flag == DISABLE_INTRS) {
1208 /*
1209 * Disable Tx Traffic Intrs in the general intr mask
1210 * register.
1211 */
1212 writeq(DISABLE_ALL_INTRS, &bar0->tx_traffic_mask);
1213 temp64 = readq(&bar0->general_int_mask);
1214 val64 |= temp64;
1215 writeq(val64, &bar0->general_int_mask);
1216 }
1217 }
1218
1219 /* Rx traffic interrupts */
1220 if (mask & RX_TRAFFIC_INTR) {
1221 val64 = RXTRAFFIC_INT_M;
1222 if (flag == ENABLE_INTRS) {
1223 temp64 = readq(&bar0->general_int_mask);
1224 temp64 &= ~((u64) val64);
1225 writeq(temp64, &bar0->general_int_mask);
1226 /* writing 0 Enables all 8 RX interrupt levels */
1227 writeq(0x0, &bar0->rx_traffic_mask);
1228 } else if (flag == DISABLE_INTRS) {
1229 /*
1230 * Disable Rx Traffic Intrs in the general intr mask
1231 * register.
1232 */
1233 writeq(DISABLE_ALL_INTRS, &bar0->rx_traffic_mask);
1234 temp64 = readq(&bar0->general_int_mask);
1235 val64 |= temp64;
1236 writeq(val64, &bar0->general_int_mask);
1237 }
1238 }
1239 }
1240
1241 /**
1242 * verify_xena_quiescence - Checks whether the H/W is ready
1243 * @val64 : Value read from adapter status register.
1244 * @flag : indicates if the adapter enable bit was ever written once
1245 * before.
1246 * Description: Returns whether the H/W is ready to go or not. Depending
1247 * on whether adapter enable bit was written or not the comparison
1248 * differs and the calling function passes the input argument flag to
1249 * indicate this.
1250 * Return: 1 If xena is quiescence
1251 * 0 If Xena is not quiescence
1252 */
1253
1254 static int verify_xena_quiescence(u64 val64, int flag)
1255 {
1256 int ret = 0;
1257 u64 tmp64 = ~((u64) val64);
1258
1259 if (!
1260 (tmp64 &
1261 (ADAPTER_STATUS_TDMA_READY | ADAPTER_STATUS_RDMA_READY |
1262 ADAPTER_STATUS_PFC_READY | ADAPTER_STATUS_TMAC_BUF_EMPTY |
1263 ADAPTER_STATUS_PIC_QUIESCENT | ADAPTER_STATUS_MC_DRAM_READY |
1264 ADAPTER_STATUS_MC_QUEUES_READY | ADAPTER_STATUS_M_PLL_LOCK |
1265 ADAPTER_STATUS_P_PLL_LOCK))) {
1266 if (flag == FALSE) {
1267 if (!(val64 & ADAPTER_STATUS_RMAC_PCC_IDLE) &&
1268 ((val64 & ADAPTER_STATUS_RC_PRC_QUIESCENT) ==
1269 ADAPTER_STATUS_RC_PRC_QUIESCENT)) {
1270
1271 ret = 1;
1272
1273 }
1274 } else {
1275 if (((val64 & ADAPTER_STATUS_RMAC_PCC_IDLE) ==
1276 ADAPTER_STATUS_RMAC_PCC_IDLE) &&
1277 (!(val64 & ADAPTER_STATUS_RC_PRC_QUIESCENT) ||
1278 ((val64 & ADAPTER_STATUS_RC_PRC_QUIESCENT) ==
1279 ADAPTER_STATUS_RC_PRC_QUIESCENT))) {
1280
1281 ret = 1;
1282
1283 }
1284 }
1285 }
1286
1287 return ret;
1288 }
1289
1290 /**
1291 * fix_mac_address - Fix for Mac addr problem on Alpha platforms
1292 * @sp: Pointer to device specifc structure
1293 * Description :
1294 * New procedure to clear mac address reading problems on Alpha platforms
1295 *
1296 */
1297
1298 static void fix_mac_address(nic_t * sp)
1299 {
1300 XENA_dev_config_t __iomem *bar0 = sp->bar0;
1301 u64 val64;
1302 int i = 0;
1303
1304 while (fix_mac[i] != END_SIGN) {
1305 writeq(fix_mac[i++], &bar0->gpio_control);
1306 val64 = readq(&bar0->gpio_control);
1307 }
1308 }
1309
1310 /**
1311 * start_nic - Turns the device on
1312 * @nic : device private variable.
1313 * Description:
1314 * This function actually turns the device on. Before this function is
1315 * called,all Registers are configured from their reset states
1316 * and shared memory is allocated but the NIC is still quiescent. On
1317 * calling this function, the device interrupts are cleared and the NIC is
1318 * literally switched on by writing into the adapter control register.
1319 * Return Value:
1320 * SUCCESS on success and -1 on failure.
1321 */
1322
1323 static int start_nic(struct s2io_nic *nic)
1324 {
1325 XENA_dev_config_t __iomem *bar0 = nic->bar0;
1326 struct net_device *dev = nic->dev;
1327 register u64 val64 = 0;
1328 u16 interruptible, i;
1329 u16 subid;
1330 mac_info_t *mac_control;
1331 struct config_param *config;
1332
1333 mac_control = &nic->mac_control;
1334 config = &nic->config;
1335
1336 /* PRC Initialization and configuration */
1337 for (i = 0; i < config->rx_ring_num; i++) {
1338 writeq((u64) nic->rx_blocks[i][0].block_dma_addr,
1339 &bar0->prc_rxd0_n[i]);
1340
1341 val64 = readq(&bar0->prc_ctrl_n[i]);
1342 #ifndef CONFIG_2BUFF_MODE
1343 val64 |= PRC_CTRL_RC_ENABLED;
1344 #else
1345 val64 |= PRC_CTRL_RC_ENABLED | PRC_CTRL_RING_MODE_3;
1346 #endif
1347 writeq(val64, &bar0->prc_ctrl_n[i]);
1348 }
1349
1350 #ifdef CONFIG_2BUFF_MODE
1351 /* Enabling 2 buffer mode by writing into Rx_pa_cfg reg. */
1352 val64 = readq(&bar0->rx_pa_cfg);
1353 val64 |= RX_PA_CFG_IGNORE_L2_ERR;
1354 writeq(val64, &bar0->rx_pa_cfg);
1355 #endif
1356
1357 /*
1358 * Enabling MC-RLDRAM. After enabling the device, we timeout
1359 * for around 100ms, which is approximately the time required
1360 * for the device to be ready for operation.
1361 */
1362 val64 = readq(&bar0->mc_rldram_mrs);
1363 val64 |= MC_RLDRAM_QUEUE_SIZE_ENABLE | MC_RLDRAM_MRS_ENABLE;
1364 SPECIAL_REG_WRITE(val64, &bar0->mc_rldram_mrs, UF);
1365 val64 = readq(&bar0->mc_rldram_mrs);
1366
1367 msleep(100); /* Delay by around 100 ms. */
1368
1369 /* Enabling ECC Protection. */
1370 val64 = readq(&bar0->adapter_control);
1371 val64 &= ~ADAPTER_ECC_EN;
1372 writeq(val64, &bar0->adapter_control);
1373
1374 /*
1375 * Clearing any possible Link state change interrupts that
1376 * could have popped up just before Enabling the card.
1377 */
1378 val64 = readq(&bar0->mac_rmac_err_reg);
1379 if (val64)
1380 writeq(val64, &bar0->mac_rmac_err_reg);
1381
1382 /*
1383 * Verify if the device is ready to be enabled, if so enable
1384 * it.
1385 */
1386 val64 = readq(&bar0->adapter_status);
1387 if (!verify_xena_quiescence(val64, nic->device_enabled_once)) {
1388 DBG_PRINT(ERR_DBG, "%s: device is not ready, ", dev->name);
1389 DBG_PRINT(ERR_DBG, "Adapter status reads: 0x%llx\n",
1390 (unsigned long long) val64);
1391 return FAILURE;
1392 }
1393
1394 /* Enable select interrupts */
1395 interruptible = TX_TRAFFIC_INTR | RX_TRAFFIC_INTR | TX_MAC_INTR |
1396 RX_MAC_INTR;
1397 en_dis_able_nic_intrs(nic, interruptible, ENABLE_INTRS);
1398
1399 /*
1400 * With some switches, link might be already up at this point.
1401 * Because of this weird behavior, when we enable laser,
1402 * we may not get link. We need to handle this. We cannot
1403 * figure out which switch is misbehaving. So we are forced to
1404 * make a global change.
1405 */
1406
1407 /* Enabling Laser. */
1408 val64 = readq(&bar0->adapter_control);
1409 val64 |= ADAPTER_EOI_TX_ON;
1410 writeq(val64, &bar0->adapter_control);
1411
1412 /* SXE-002: Initialize link and activity LED */
1413 subid = nic->pdev->subsystem_device;
1414 if ((subid & 0xFF) >= 0x07) {
1415 val64 = readq(&bar0->gpio_control);
1416 val64 |= 0x0000800000000000ULL;
1417 writeq(val64, &bar0->gpio_control);
1418 val64 = 0x0411040400000000ULL;
1419 writeq(val64, (void __iomem *) bar0 + 0x2700);
1420 }
1421
1422 /*
1423 * Don't see link state interrupts on certain switches, so
1424 * directly scheduling a link state task from here.
1425 */
1426 schedule_work(&nic->set_link_task);
1427
1428 /*
1429 * Here we are performing soft reset on XGXS to
1430 * force link down. Since link is already up, we will get
1431 * link state change interrupt after this reset
1432 */
1433 SPECIAL_REG_WRITE(0x80010515001E0000ULL, &bar0->dtx_control, UF);
1434 val64 = readq(&bar0->dtx_control);
1435 udelay(50);
1436 SPECIAL_REG_WRITE(0x80010515001E00E0ULL, &bar0->dtx_control, UF);
1437 val64 = readq(&bar0->dtx_control);
1438 udelay(50);
1439 SPECIAL_REG_WRITE(0x80070515001F00E4ULL, &bar0->dtx_control, UF);
1440 val64 = readq(&bar0->dtx_control);
1441 udelay(50);
1442
1443 return SUCCESS;
1444 }
1445
1446 /**
1447 * free_tx_buffers - Free all queued Tx buffers
1448 * @nic : device private variable.
1449 * Description:
1450 * Free all queued Tx buffers.
1451 * Return Value: void
1452 */
1453
1454 static void free_tx_buffers(struct s2io_nic *nic)
1455 {
1456 struct net_device *dev = nic->dev;
1457 struct sk_buff *skb;
1458 TxD_t *txdp;
1459 int i, j;
1460 mac_info_t *mac_control;
1461 struct config_param *config;
1462 int cnt = 0;
1463
1464 mac_control = &nic->mac_control;
1465 config = &nic->config;
1466
1467 for (i = 0; i < config->tx_fifo_num; i++) {
1468 for (j = 0; j < config->tx_cfg[i].fifo_len - 1; j++) {
1469 txdp = (TxD_t *) nic->list_info[i][j].
1470 list_virt_addr;
1471 skb =
1472 (struct sk_buff *) ((unsigned long) txdp->
1473 Host_Control);
1474 if (skb == NULL) {
1475 memset(txdp, 0, sizeof(TxD_t));
1476 continue;
1477 }
1478 dev_kfree_skb(skb);
1479 memset(txdp, 0, sizeof(TxD_t));
1480 cnt++;
1481 }
1482 DBG_PRINT(INTR_DBG,
1483 "%s:forcibly freeing %d skbs on FIFO%d\n",
1484 dev->name, cnt, i);
1485 mac_control->tx_curr_get_info[i].offset = 0;
1486 mac_control->tx_curr_put_info[i].offset = 0;
1487 }
1488 }
1489
1490 /**
1491 * stop_nic - To stop the nic
1492 * @nic ; device private variable.
1493 * Description:
1494 * This function does exactly the opposite of what the start_nic()
1495 * function does. This function is called to stop the device.
1496 * Return Value:
1497 * void.
1498 */
1499
1500 static void stop_nic(struct s2io_nic *nic)
1501 {
1502 XENA_dev_config_t __iomem *bar0 = nic->bar0;
1503 register u64 val64 = 0;
1504 u16 interruptible, i;
1505 mac_info_t *mac_control;
1506 struct config_param *config;
1507
1508 mac_control = &nic->mac_control;
1509 config = &nic->config;
1510
1511 /* Disable all interrupts */
1512 interruptible = TX_TRAFFIC_INTR | RX_TRAFFIC_INTR | TX_MAC_INTR |
1513 RX_MAC_INTR;
1514 en_dis_able_nic_intrs(nic, interruptible, DISABLE_INTRS);
1515
1516 /* Disable PRCs */
1517 for (i = 0; i < config->rx_ring_num; i++) {
1518 val64 = readq(&bar0->prc_ctrl_n[i]);
1519 val64 &= ~((u64) PRC_CTRL_RC_ENABLED);
1520 writeq(val64, &bar0->prc_ctrl_n[i]);
1521 }
1522 }
1523
1524 /**
1525 * fill_rx_buffers - Allocates the Rx side skbs
1526 * @nic: device private variable
1527 * @ring_no: ring number
1528 * Description:
1529 * The function allocates Rx side skbs and puts the physical
1530 * address of these buffers into the RxD buffer pointers, so that the NIC
1531 * can DMA the received frame into these locations.
1532 * The NIC supports 3 receive modes, viz
1533 * 1. single buffer,
1534 * 2. three buffer and
1535 * 3. Five buffer modes.
1536 * Each mode defines how many fragments the received frame will be split
1537 * up into by the NIC. The frame is split into L3 header, L4 Header,
1538 * L4 payload in three buffer mode and in 5 buffer mode, L4 payload itself
1539 * is split into 3 fragments. As of now only single buffer mode is
1540 * supported.
1541 * Return Value:
1542 * SUCCESS on success or an appropriate -ve value on failure.
1543 */
1544
1545 static int fill_rx_buffers(struct s2io_nic *nic, int ring_no)
1546 {
1547 struct net_device *dev = nic->dev;
1548 struct sk_buff *skb;
1549 RxD_t *rxdp;
1550 int off, off1, size, block_no, block_no1;
1551 int offset, offset1;
1552 u32 alloc_tab = 0;
1553 u32 alloc_cnt = nic->pkt_cnt[ring_no] -
1554 atomic_read(&nic->rx_bufs_left[ring_no]);
1555 mac_info_t *mac_control;
1556 struct config_param *config;
1557 #ifdef CONFIG_2BUFF_MODE
1558 RxD_t *rxdpnext;
1559 int nextblk;
1560 unsigned long tmp;
1561 buffAdd_t *ba;
1562 dma_addr_t rxdpphys;
1563 #endif
1564 #ifndef CONFIG_S2IO_NAPI
1565 unsigned long flags;
1566 #endif
1567
1568 mac_control = &nic->mac_control;
1569 config = &nic->config;
1570
1571 size = dev->mtu + HEADER_ETHERNET_II_802_3_SIZE +
1572 HEADER_802_2_SIZE + HEADER_SNAP_SIZE;
1573
1574 while (alloc_tab < alloc_cnt) {
1575 block_no = mac_control->rx_curr_put_info[ring_no].
1576 block_index;
1577 block_no1 = mac_control->rx_curr_get_info[ring_no].
1578 block_index;
1579 off = mac_control->rx_curr_put_info[ring_no].offset;
1580 off1 = mac_control->rx_curr_get_info[ring_no].offset;
1581 #ifndef CONFIG_2BUFF_MODE
1582 offset = block_no * (MAX_RXDS_PER_BLOCK + 1) + off;
1583 offset1 = block_no1 * (MAX_RXDS_PER_BLOCK + 1) + off1;
1584 #else
1585 offset = block_no * (MAX_RXDS_PER_BLOCK) + off;
1586 offset1 = block_no1 * (MAX_RXDS_PER_BLOCK) + off1;
1587 #endif
1588
1589 rxdp = nic->rx_blocks[ring_no][block_no].
1590 block_virt_addr + off;
1591 if ((offset == offset1) && (rxdp->Host_Control)) {
1592 DBG_PRINT(INTR_DBG, "%s: Get and Put", dev->name);
1593 DBG_PRINT(INTR_DBG, " info equated\n");
1594 goto end;
1595 }
1596 #ifndef CONFIG_2BUFF_MODE
1597 if (rxdp->Control_1 == END_OF_BLOCK) {
1598 mac_control->rx_curr_put_info[ring_no].
1599 block_index++;
1600 mac_control->rx_curr_put_info[ring_no].
1601 block_index %= nic->block_count[ring_no];
1602 block_no = mac_control->rx_curr_put_info
1603 [ring_no].block_index;
1604 off++;
1605 off %= (MAX_RXDS_PER_BLOCK + 1);
1606 mac_control->rx_curr_put_info[ring_no].offset =
1607 off;
1608 rxdp = (RxD_t *) ((unsigned long) rxdp->Control_2);
1609 DBG_PRINT(INTR_DBG, "%s: Next block at: %p\n",
1610 dev->name, rxdp);
1611 }
1612 #ifndef CONFIG_S2IO_NAPI
1613 spin_lock_irqsave(&nic->put_lock, flags);
1614 nic->put_pos[ring_no] =
1615 (block_no * (MAX_RXDS_PER_BLOCK + 1)) + off;
1616 spin_unlock_irqrestore(&nic->put_lock, flags);
1617 #endif
1618 #else
1619 if (rxdp->Host_Control == END_OF_BLOCK) {
1620 mac_control->rx_curr_put_info[ring_no].
1621 block_index++;
1622 mac_control->rx_curr_put_info[ring_no].
1623 block_index %= nic->block_count[ring_no];
1624 block_no = mac_control->rx_curr_put_info
1625 [ring_no].block_index;
1626 off = 0;
1627 DBG_PRINT(INTR_DBG, "%s: block%d at: 0x%llx\n",
1628 dev->name, block_no,
1629 (unsigned long long) rxdp->Control_1);
1630 mac_control->rx_curr_put_info[ring_no].offset =
1631 off;
1632 rxdp = nic->rx_blocks[ring_no][block_no].
1633 block_virt_addr;
1634 }
1635 #ifndef CONFIG_S2IO_NAPI
1636 spin_lock_irqsave(&nic->put_lock, flags);
1637 nic->put_pos[ring_no] = (block_no *
1638 (MAX_RXDS_PER_BLOCK + 1)) + off;
1639 spin_unlock_irqrestore(&nic->put_lock, flags);
1640 #endif
1641 #endif
1642
1643 #ifndef CONFIG_2BUFF_MODE
1644 if (rxdp->Control_1 & RXD_OWN_XENA)
1645 #else
1646 if (rxdp->Control_2 & BIT(0))
1647 #endif
1648 {
1649 mac_control->rx_curr_put_info[ring_no].
1650 offset = off;
1651 goto end;
1652 }
1653 #ifdef CONFIG_2BUFF_MODE
1654 /*
1655 * RxDs Spanning cache lines will be replenished only
1656 * if the succeeding RxD is also owned by Host. It
1657 * will always be the ((8*i)+3) and ((8*i)+6)
1658 * descriptors for the 48 byte descriptor. The offending
1659 * decsriptor is of-course the 3rd descriptor.
1660 */
1661 rxdpphys = nic->rx_blocks[ring_no][block_no].
1662 block_dma_addr + (off * sizeof(RxD_t));
1663 if (((u64) (rxdpphys)) % 128 > 80) {
1664 rxdpnext = nic->rx_blocks[ring_no][block_no].
1665 block_virt_addr + (off + 1);
1666 if (rxdpnext->Host_Control == END_OF_BLOCK) {
1667 nextblk = (block_no + 1) %
1668 (nic->block_count[ring_no]);
1669 rxdpnext = nic->rx_blocks[ring_no]
1670 [nextblk].block_virt_addr;
1671 }
1672 if (rxdpnext->Control_2 & BIT(0))
1673 goto end;
1674 }
1675 #endif
1676
1677 #ifndef CONFIG_2BUFF_MODE
1678 skb = dev_alloc_skb(size + NET_IP_ALIGN);
1679 #else
1680 skb = dev_alloc_skb(dev->mtu + ALIGN_SIZE + BUF0_LEN + 4);
1681 #endif
1682 if (!skb) {
1683 DBG_PRINT(ERR_DBG, "%s: Out of ", dev->name);
1684 DBG_PRINT(ERR_DBG, "memory to allocate SKBs\n");
1685 return -ENOMEM;
1686 }
1687 #ifndef CONFIG_2BUFF_MODE
1688 skb_reserve(skb, NET_IP_ALIGN);
1689 memset(rxdp, 0, sizeof(RxD_t));
1690 rxdp->Buffer0_ptr = pci_map_single
1691 (nic->pdev, skb->data, size, PCI_DMA_FROMDEVICE);
1692 rxdp->Control_2 &= (~MASK_BUFFER0_SIZE);
1693 rxdp->Control_2 |= SET_BUFFER0_SIZE(size);
1694 rxdp->Host_Control = (unsigned long) (skb);
1695 rxdp->Control_1 |= RXD_OWN_XENA;
1696 off++;
1697 off %= (MAX_RXDS_PER_BLOCK + 1);
1698 mac_control->rx_curr_put_info[ring_no].offset = off;
1699 #else
1700 ba = &nic->ba[ring_no][block_no][off];
1701 skb_reserve(skb, BUF0_LEN);
1702 tmp = ((unsigned long) skb->data & ALIGN_SIZE);
1703 if (tmp)
1704 skb_reserve(skb, (ALIGN_SIZE + 1) - tmp);
1705
1706 memset(rxdp, 0, sizeof(RxD_t));
1707 rxdp->Buffer2_ptr = pci_map_single
1708 (nic->pdev, skb->data, dev->mtu + BUF0_LEN + 4,
1709 PCI_DMA_FROMDEVICE);
1710 rxdp->Buffer0_ptr =
1711 pci_map_single(nic->pdev, ba->ba_0, BUF0_LEN,
1712 PCI_DMA_FROMDEVICE);
1713 rxdp->Buffer1_ptr =
1714 pci_map_single(nic->pdev, ba->ba_1, BUF1_LEN,
1715 PCI_DMA_FROMDEVICE);
1716
1717 rxdp->Control_2 = SET_BUFFER2_SIZE(dev->mtu + 4);
1718 rxdp->Control_2 |= SET_BUFFER0_SIZE(BUF0_LEN);
1719 rxdp->Control_2 |= SET_BUFFER1_SIZE(1); /* dummy. */
1720 rxdp->Control_2 |= BIT(0); /* Set Buffer_Empty bit. */
1721 rxdp->Host_Control = (u64) ((unsigned long) (skb));
1722 rxdp->Control_1 |= RXD_OWN_XENA;
1723 off++;
1724 mac_control->rx_curr_put_info[ring_no].offset = off;
1725 #endif
1726 atomic_inc(&nic->rx_bufs_left[ring_no]);
1727 alloc_tab++;
1728 }
1729
1730 end:
1731 return SUCCESS;
1732 }
1733
1734 /**
1735 * free_rx_buffers - Frees all Rx buffers
1736 * @sp: device private variable.
1737 * Description:
1738 * This function will free all Rx buffers allocated by host.
1739 * Return Value:
1740 * NONE.
1741 */
1742
1743 static void free_rx_buffers(struct s2io_nic *sp)
1744 {
1745 struct net_device *dev = sp->dev;
1746 int i, j, blk = 0, off, buf_cnt = 0;
1747 RxD_t *rxdp;
1748 struct sk_buff *skb;
1749 mac_info_t *mac_control;
1750 struct config_param *config;
1751 #ifdef CONFIG_2BUFF_MODE
1752 buffAdd_t *ba;
1753 #endif
1754
1755 mac_control = &sp->mac_control;
1756 config = &sp->config;
1757
1758 for (i = 0; i < config->rx_ring_num; i++) {
1759 for (j = 0, blk = 0; j < config->rx_cfg[i].num_rxd; j++) {
1760 off = j % (MAX_RXDS_PER_BLOCK + 1);
1761 rxdp = sp->rx_blocks[i][blk].block_virt_addr + off;
1762
1763 #ifndef CONFIG_2BUFF_MODE
1764 if (rxdp->Control_1 == END_OF_BLOCK) {
1765 rxdp =
1766 (RxD_t *) ((unsigned long) rxdp->
1767 Control_2);
1768 j++;
1769 blk++;
1770 }
1771 #else
1772 if (rxdp->Host_Control == END_OF_BLOCK) {
1773 blk++;
1774 continue;
1775 }
1776 #endif
1777
1778 if (!(rxdp->Control_1 & RXD_OWN_XENA)) {
1779 memset(rxdp, 0, sizeof(RxD_t));
1780 continue;
1781 }
1782
1783 skb =
1784 (struct sk_buff *) ((unsigned long) rxdp->
1785 Host_Control);
1786 if (skb) {
1787 #ifndef CONFIG_2BUFF_MODE
1788 pci_unmap_single(sp->pdev, (dma_addr_t)
1789 rxdp->Buffer0_ptr,
1790 dev->mtu +
1791 HEADER_ETHERNET_II_802_3_SIZE
1792 + HEADER_802_2_SIZE +
1793 HEADER_SNAP_SIZE,
1794 PCI_DMA_FROMDEVICE);
1795 #else
1796 ba = &sp->ba[i][blk][off];
1797 pci_unmap_single(sp->pdev, (dma_addr_t)
1798 rxdp->Buffer0_ptr,
1799 BUF0_LEN,
1800 PCI_DMA_FROMDEVICE);
1801 pci_unmap_single(sp->pdev, (dma_addr_t)
1802 rxdp->Buffer1_ptr,
1803 BUF1_LEN,
1804 PCI_DMA_FROMDEVICE);
1805 pci_unmap_single(sp->pdev, (dma_addr_t)
1806 rxdp->Buffer2_ptr,
1807 dev->mtu + BUF0_LEN + 4,
1808 PCI_DMA_FROMDEVICE);
1809 #endif
1810 dev_kfree_skb(skb);
1811 atomic_dec(&sp->rx_bufs_left[i]);
1812 buf_cnt++;
1813 }
1814 memset(rxdp, 0, sizeof(RxD_t));
1815 }
1816 mac_control->rx_curr_put_info[i].block_index = 0;
1817 mac_control->rx_curr_get_info[i].block_index = 0;
1818 mac_control->rx_curr_put_info[i].offset = 0;
1819 mac_control->rx_curr_get_info[i].offset = 0;
1820 atomic_set(&sp->rx_bufs_left[i], 0);
1821 DBG_PRINT(INIT_DBG, "%s:Freed 0x%x Rx Buffers on ring%d\n",
1822 dev->name, buf_cnt, i);
1823 }
1824 }
1825
1826 /**
1827 * s2io_poll - Rx interrupt handler for NAPI support
1828 * @dev : pointer to the device structure.
1829 * @budget : The number of packets that were budgeted to be processed
1830 * during one pass through the 'Poll" function.
1831 * Description:
1832 * Comes into picture only if NAPI support has been incorporated. It does
1833 * the same thing that rx_intr_handler does, but not in a interrupt context
1834 * also It will process only a given number of packets.
1835 * Return value:
1836 * 0 on success and 1 if there are No Rx packets to be processed.
1837 */
1838
1839 #ifdef CONFIG_S2IO_NAPI
1840 static int s2io_poll(struct net_device *dev, int *budget)
1841 {
1842 nic_t *nic = dev->priv;
1843 XENA_dev_config_t __iomem *bar0 = nic->bar0;
1844 int pkts_to_process = *budget, pkt_cnt = 0;
1845 register u64 val64 = 0;
1846 rx_curr_get_info_t get_info, put_info;
1847 int i, get_block, put_block, get_offset, put_offset, ring_bufs;
1848 #ifndef CONFIG_2BUFF_MODE
1849 u16 val16, cksum;
1850 #endif
1851 struct sk_buff *skb;
1852 RxD_t *rxdp;
1853 mac_info_t *mac_control;
1854 struct config_param *config;
1855 #ifdef CONFIG_2BUFF_MODE
1856 buffAdd_t *ba;
1857 #endif
1858
1859 mac_control = &nic->mac_control;
1860 config = &nic->config;
1861
1862 if (pkts_to_process > dev->quota)
1863 pkts_to_process = dev->quota;
1864
1865 val64 = readq(&bar0->rx_traffic_int);
1866 writeq(val64, &bar0->rx_traffic_int);
1867
1868 for (i = 0; i < config->rx_ring_num; i++) {
1869 get_info = mac_control->rx_curr_get_info[i];
1870 get_block = get_info.block_index;
1871 put_info = mac_control->rx_curr_put_info[i];
1872 put_block = put_info.block_index;
1873 ring_bufs = config->rx_cfg[i].num_rxd;
1874 rxdp = nic->rx_blocks[i][get_block].block_virt_addr +
1875 get_info.offset;
1876 #ifndef CONFIG_2BUFF_MODE
1877 get_offset = (get_block * (MAX_RXDS_PER_BLOCK + 1)) +
1878 get_info.offset;
1879 put_offset = (put_block * (MAX_RXDS_PER_BLOCK + 1)) +
1880 put_info.offset;
1881 while ((!(rxdp->Control_1 & RXD_OWN_XENA)) &&
1882 (((get_offset + 1) % ring_bufs) != put_offset)) {
1883 if (--pkts_to_process < 0) {
1884 goto no_rx;
1885 }
1886 if (rxdp->Control_1 == END_OF_BLOCK) {
1887 rxdp =
1888 (RxD_t *) ((unsigned long) rxdp->
1889 Control_2);
1890 get_info.offset++;
1891 get_info.offset %=
1892 (MAX_RXDS_PER_BLOCK + 1);
1893 get_block++;
1894 get_block %= nic->block_count[i];
1895 mac_control->rx_curr_get_info[i].
1896 offset = get_info.offset;
1897 mac_control->rx_curr_get_info[i].
1898 block_index = get_block;
1899 continue;
1900 }
1901 get_offset =
1902 (get_block * (MAX_RXDS_PER_BLOCK + 1)) +
1903 get_info.offset;
1904 skb =
1905 (struct sk_buff *) ((unsigned long) rxdp->
1906 Host_Control);
1907 if (skb == NULL) {
1908 DBG_PRINT(ERR_DBG, "%s: The skb is ",
1909 dev->name);
1910 DBG_PRINT(ERR_DBG, "Null in Rx Intr\n");
1911 goto no_rx;
1912 }
1913 val64 = RXD_GET_BUFFER0_SIZE(rxdp->Control_2);
1914 val16 = (u16) (val64 >> 48);
1915 cksum = RXD_GET_L4_CKSUM(rxdp->Control_1);
1916 pci_unmap_single(nic->pdev, (dma_addr_t)
1917 rxdp->Buffer0_ptr,
1918 dev->mtu +
1919 HEADER_ETHERNET_II_802_3_SIZE +
1920 HEADER_802_2_SIZE +
1921 HEADER_SNAP_SIZE,
1922 PCI_DMA_FROMDEVICE);
1923 rx_osm_handler(nic, val16, rxdp, i);
1924 pkt_cnt++;
1925 get_info.offset++;
1926 get_info.offset %= (MAX_RXDS_PER_BLOCK + 1);
1927 rxdp =
1928 nic->rx_blocks[i][get_block].block_virt_addr +
1929 get_info.offset;
1930 mac_control->rx_curr_get_info[i].offset =
1931 get_info.offset;
1932 }
1933 #else
1934 get_offset = (get_block * (MAX_RXDS_PER_BLOCK + 1)) +
1935 get_info.offset;
1936 put_offset = (put_block * (MAX_RXDS_PER_BLOCK + 1)) +
1937 put_info.offset;
1938 while (((!(rxdp->Control_1 & RXD_OWN_XENA)) &&
1939 !(rxdp->Control_2 & BIT(0))) &&
1940 (((get_offset + 1) % ring_bufs) != put_offset)) {
1941 if (--pkts_to_process < 0) {
1942 goto no_rx;
1943 }
1944 skb = (struct sk_buff *) ((unsigned long)
1945 rxdp->Host_Control);
1946 if (skb == NULL) {
1947 DBG_PRINT(ERR_DBG, "%s: The skb is ",
1948 dev->name);
1949 DBG_PRINT(ERR_DBG, "Null in Rx Intr\n");
1950 goto no_rx;
1951 }
1952
1953 pci_unmap_single(nic->pdev, (dma_addr_t)
1954 rxdp->Buffer0_ptr,
1955 BUF0_LEN, PCI_DMA_FROMDEVICE);
1956 pci_unmap_single(nic->pdev, (dma_addr_t)
1957 rxdp->Buffer1_ptr,
1958 BUF1_LEN, PCI_DMA_FROMDEVICE);
1959 pci_unmap_single(nic->pdev, (dma_addr_t)
1960 rxdp->Buffer2_ptr,
1961 dev->mtu + BUF0_LEN + 4,
1962 PCI_DMA_FROMDEVICE);
1963 ba = &nic->ba[i][get_block][get_info.offset];
1964
1965 rx_osm_handler(nic, rxdp, i, ba);
1966
1967 get_info.offset++;
1968 mac_control->rx_curr_get_info[i].offset =
1969 get_info.offset;
1970 rxdp =
1971 nic->rx_blocks[i][get_block].block_virt_addr +
1972 get_info.offset;
1973
1974 if (get_info.offset &&
1975 (!(get_info.offset % MAX_RXDS_PER_BLOCK))) {
1976 get_info.offset = 0;
1977 mac_control->rx_curr_get_info[i].
1978 offset = get_info.offset;
1979 get_block++;
1980 get_block %= nic->block_count[i];
1981 mac_control->rx_curr_get_info[i].
1982 block_index = get_block;
1983 rxdp =
1984 nic->rx_blocks[i][get_block].
1985 block_virt_addr;
1986 }
1987 get_offset =
1988 (get_block * (MAX_RXDS_PER_BLOCK + 1)) +
1989 get_info.offset;
1990 pkt_cnt++;
1991 }
1992 #endif
1993 }
1994 if (!pkt_cnt)
1995 pkt_cnt = 1;
1996
1997 dev->quota -= pkt_cnt;
1998 *budget -= pkt_cnt;
1999 netif_rx_complete(dev);
2000
2001 for (i = 0; i < config->rx_ring_num; i++) {
2002 if (fill_rx_buffers(nic, i) == -ENOMEM) {
2003 DBG_PRINT(ERR_DBG, "%s:Out of memory", dev->name);
2004 DBG_PRINT(ERR_DBG, " in Rx Poll!!\n");
2005 break;
2006 }
2007 }
2008 /* Re enable the Rx interrupts. */
2009 en_dis_able_nic_intrs(nic, RX_TRAFFIC_INTR, ENABLE_INTRS);
2010 return 0;
2011
2012 no_rx:
2013 dev->quota -= pkt_cnt;
2014 *budget -= pkt_cnt;
2015
2016 for (i = 0; i < config->rx_ring_num; i++) {
2017 if (fill_rx_buffers(nic, i) == -ENOMEM) {
2018 DBG_PRINT(ERR_DBG, "%s:Out of memory", dev->name);
2019 DBG_PRINT(ERR_DBG, " in Rx Poll!!\n");
2020 break;
2021 }
2022 }
2023 return 1;
2024 }
2025 #else
2026 /**
2027 * rx_intr_handler - Rx interrupt handler
2028 * @nic: device private variable.
2029 * Description:
2030 * If the interrupt is because of a received frame or if the
2031 * receive ring contains fresh as yet un-processed frames,this function is
2032 * called. It picks out the RxD at which place the last Rx processing had
2033 * stopped and sends the skb to the OSM's Rx handler and then increments
2034 * the offset.
2035 * Return Value:
2036 * NONE.
2037 */
2038
2039 static void rx_intr_handler(struct s2io_nic *nic)
2040 {
2041 struct net_device *dev = (struct net_device *) nic->dev;
2042 XENA_dev_config_t *bar0 = (XENA_dev_config_t *) nic->bar0;
2043 rx_curr_get_info_t get_info, put_info;
2044 RxD_t *rxdp;
2045 struct sk_buff *skb;
2046 #ifndef CONFIG_2BUFF_MODE
2047 u16 val16, cksum;
2048 #endif
2049 register u64 val64 = 0;
2050 int get_block, get_offset, put_block, put_offset, ring_bufs;
2051 int i, pkt_cnt = 0;
2052 mac_info_t *mac_control;
2053 struct config_param *config;
2054 #ifdef CONFIG_2BUFF_MODE
2055 buffAdd_t *ba;
2056 #endif
2057
2058 mac_control = &nic->mac_control;
2059 config = &nic->config;
2060
2061 /*
2062 * rx_traffic_int reg is an R1 register, hence we read and write back
2063 * the samevalue in the register to clear it.
2064 */
2065 val64 = readq(&bar0->rx_traffic_int);
2066 writeq(val64, &bar0->rx_traffic_int);
2067
2068 for (i = 0; i < config->rx_ring_num; i++) {
2069 get_info = mac_control->rx_curr_get_info[i];
2070 get_block = get_info.block_index;
2071 put_info = mac_control->rx_curr_put_info[i];
2072 put_block = put_info.block_index;
2073 ring_bufs = config->rx_cfg[i].num_rxd;
2074 rxdp = nic->rx_blocks[i][get_block].block_virt_addr +
2075 get_info.offset;
2076 #ifndef CONFIG_2BUFF_MODE
2077 get_offset = (get_block * (MAX_RXDS_PER_BLOCK + 1)) +
2078 get_info.offset;
2079 spin_lock(&nic->put_lock);
2080 put_offset = nic->put_pos[i];
2081 spin_unlock(&nic->put_lock);
2082 while ((!(rxdp->Control_1 & RXD_OWN_XENA)) &&
2083 (((get_offset + 1) % ring_bufs) != put_offset)) {
2084 if (rxdp->Control_1 == END_OF_BLOCK) {
2085 rxdp = (RxD_t *) ((unsigned long)
2086 rxdp->Control_2);
2087 get_info.offset++;
2088 get_info.offset %=
2089 (MAX_RXDS_PER_BLOCK + 1);
2090 get_block++;
2091 get_block %= nic->block_count[i];
2092 mac_control->rx_curr_get_info[i].
2093 offset = get_info.offset;
2094 mac_control->rx_curr_get_info[i].
2095 block_index = get_block;
2096 continue;
2097 }
2098 get_offset =
2099 (get_block * (MAX_RXDS_PER_BLOCK + 1)) +
2100 get_info.offset;
2101 skb = (struct sk_buff *) ((unsigned long)
2102 rxdp->Host_Control);
2103 if (skb == NULL) {
2104 DBG_PRINT(ERR_DBG, "%s: The skb is ",
2105 dev->name);
2106 DBG_PRINT(ERR_DBG, "Null in Rx Intr\n");
2107 return;
2108 }
2109 val64 = RXD_GET_BUFFER0_SIZE(rxdp->Control_2);
2110 val16 = (u16) (val64 >> 48);
2111 cksum = RXD_GET_L4_CKSUM(rxdp->Control_1);
2112 pci_unmap_single(nic->pdev, (dma_addr_t)
2113 rxdp->Buffer0_ptr,
2114 dev->mtu +
2115 HEADER_ETHERNET_II_802_3_SIZE +
2116 HEADER_802_2_SIZE +
2117 HEADER_SNAP_SIZE,
2118 PCI_DMA_FROMDEVICE);
2119 rx_osm_handler(nic, val16, rxdp, i);
2120 get_info.offset++;
2121 get_info.offset %= (MAX_RXDS_PER_BLOCK + 1);
2122 rxdp =
2123 nic->rx_blocks[i][get_block].block_virt_addr +
2124 get_info.offset;
2125 mac_control->rx_curr_get_info[i].offset =
2126 get_info.offset;
2127 pkt_cnt++;
2128 if ((indicate_max_pkts)
2129 && (pkt_cnt > indicate_max_pkts))
2130 break;
2131 }
2132 #else
2133 get_offset = (get_block * (MAX_RXDS_PER_BLOCK + 1)) +
2134 get_info.offset;
2135 spin_lock(&nic->put_lock);
2136 put_offset = nic->put_pos[i];
2137 spin_unlock(&nic->put_lock);
2138 while (((!(rxdp->Control_1 & RXD_OWN_XENA)) &&
2139 !(rxdp->Control_2 & BIT(0))) &&
2140 (((get_offset + 1) % ring_bufs) != put_offset)) {
2141 skb = (struct sk_buff *) ((unsigned long)
2142 rxdp->Host_Control);
2143 if (skb == NULL) {
2144 DBG_PRINT(ERR_DBG, "%s: The skb is ",
2145 dev->name);
2146 DBG_PRINT(ERR_DBG, "Null in Rx Intr\n");
2147 return;
2148 }
2149
2150 pci_unmap_single(nic->pdev, (dma_addr_t)
2151 rxdp->Buffer0_ptr,
2152 BUF0_LEN, PCI_DMA_FROMDEVICE);
2153 pci_unmap_single(nic->pdev, (dma_addr_t)
2154 rxdp->Buffer1_ptr,
2155 BUF1_LEN, PCI_DMA_FROMDEVICE);
2156 pci_unmap_single(nic->pdev, (dma_addr_t)
2157 rxdp->Buffer2_ptr,
2158 dev->mtu + BUF0_LEN + 4,
2159 PCI_DMA_FROMDEVICE);
2160 ba = &nic->ba[i][get_block][get_info.offset];
2161
2162 rx_osm_handler(nic, rxdp, i, ba);
2163
2164 get_info.offset++;
2165 mac_control->rx_curr_get_info[i].offset =
2166 get_info.offset;
2167 rxdp =
2168 nic->rx_blocks[i][get_block].block_virt_addr +
2169 get_info.offset;
2170
2171 if (get_info.offset &&
2172 (!(get_info.offset % MAX_RXDS_PER_BLOCK))) {
2173 get_info.offset = 0;
2174 mac_control->rx_curr_get_info[i].
2175 offset = get_info.offset;
2176 get_block++;
2177 get_block %= nic->block_count[i];
2178 mac_control->rx_curr_get_info[i].
2179 block_index = get_block;
2180 rxdp =
2181 nic->rx_blocks[i][get_block].
2182 block_virt_addr;
2183 }
2184 get_offset =
2185 (get_block * (MAX_RXDS_PER_BLOCK + 1)) +
2186 get_info.offset;
2187 pkt_cnt++;
2188 if ((indicate_max_pkts)
2189 && (pkt_cnt > indicate_max_pkts))
2190 break;
2191 }
2192 #endif
2193 if ((indicate_max_pkts) && (pkt_cnt > indicate_max_pkts))
2194 break;
2195 }
2196 }
2197 #endif
2198 /**
2199 * tx_intr_handler - Transmit interrupt handler
2200 * @nic : device private variable
2201 * Description:
2202 * If an interrupt was raised to indicate DMA complete of the
2203 * Tx packet, this function is called. It identifies the last TxD
2204 * whose buffer was freed and frees all skbs whose data have already
2205 * DMA'ed into the NICs internal memory.
2206 * Return Value:
2207 * NONE
2208 */
2209
2210 static void tx_intr_handler(struct s2io_nic *nic)
2211 {
2212 XENA_dev_config_t __iomem *bar0 = nic->bar0;
2213 struct net_device *dev = (struct net_device *) nic->dev;
2214 tx_curr_get_info_t get_info, put_info;
2215 struct sk_buff *skb;
2216 TxD_t *txdlp;
2217 register u64 val64 = 0;
2218 int i;
2219 u16 j, frg_cnt;
2220 mac_info_t *mac_control;
2221 struct config_param *config;
2222
2223 mac_control = &nic->mac_control;
2224 config = &nic->config;
2225
2226 /*
2227 * tx_traffic_int reg is an R1 register, hence we read and write
2228 * back the samevalue in the register to clear it.
2229 */
2230 val64 = readq(&bar0->tx_traffic_int);
2231 writeq(val64, &bar0->tx_traffic_int);
2232
2233 for (i = 0; i < config->tx_fifo_num; i++) {
2234 get_info = mac_control->tx_curr_get_info[i];
2235 put_info = mac_control->tx_curr_put_info[i];
2236 txdlp = (TxD_t *) nic->list_info[i][get_info.offset].
2237 list_virt_addr;
2238 while ((!(txdlp->Control_1 & TXD_LIST_OWN_XENA)) &&
2239 (get_info.offset != put_info.offset) &&
2240 (txdlp->Host_Control)) {
2241 /* Check for TxD errors */
2242 if (txdlp->Control_1 & TXD_T_CODE) {
2243 unsigned long long err;
2244 err = txdlp->Control_1 & TXD_T_CODE;
2245 DBG_PRINT(ERR_DBG, "***TxD error %llx\n",
2246 err);
2247 }
2248
2249 skb = (struct sk_buff *) ((unsigned long)
2250 txdlp->Host_Control);
2251 if (skb == NULL) {
2252 DBG_PRINT(ERR_DBG, "%s: Null skb ",
2253 dev->name);
2254 DBG_PRINT(ERR_DBG, "in Tx Free Intr\n");
2255 return;
2256 }
2257 nic->tx_pkt_count++;
2258
2259 frg_cnt = skb_shinfo(skb)->nr_frags;
2260
2261 /* For unfragmented skb */
2262 pci_unmap_single(nic->pdev, (dma_addr_t)
2263 txdlp->Buffer_Pointer,
2264 skb->len - skb->data_len,
2265 PCI_DMA_TODEVICE);
2266 if (frg_cnt) {
2267 TxD_t *temp = txdlp;
2268 txdlp++;
2269 for (j = 0; j < frg_cnt; j++, txdlp++) {
2270 skb_frag_t *frag =
2271 &skb_shinfo(skb)->frags[j];
2272 pci_unmap_page(nic->pdev,
2273 (dma_addr_t)
2274 txdlp->
2275 Buffer_Pointer,
2276 frag->size,
2277 PCI_DMA_TODEVICE);
2278 }
2279 txdlp = temp;
2280 }
2281 memset(txdlp, 0,
2282 (sizeof(TxD_t) * config->max_txds));
2283
2284 /* Updating the statistics block */
2285 nic->stats.tx_packets++;
2286 nic->stats.tx_bytes += skb->len;
2287 dev_kfree_skb_irq(skb);
2288
2289 get_info.offset++;
2290 get_info.offset %= get_info.fifo_len + 1;
2291 txdlp = (TxD_t *) nic->list_info[i]
2292 [get_info.offset].list_virt_addr;
2293 mac_control->tx_curr_get_info[i].offset =
2294 get_info.offset;
2295 }
2296 }
2297
2298 spin_lock(&nic->tx_lock);
2299 if (netif_queue_stopped(dev))
2300 netif_wake_queue(dev);
2301 spin_unlock(&nic->tx_lock);
2302 }
2303
2304 /**
2305 * alarm_intr_handler - Alarm Interrrupt handler
2306 * @nic: device private variable
2307 * Description: If the interrupt was neither because of Rx packet or Tx
2308 * complete, this function is called. If the interrupt was to indicate
2309 * a loss of link, the OSM link status handler is invoked for any other
2310 * alarm interrupt the block that raised the interrupt is displayed
2311 * and a H/W reset is issued.
2312 * Return Value:
2313 * NONE
2314 */
2315
2316 static void alarm_intr_handler(struct s2io_nic *nic)
2317 {
2318 struct net_device *dev = (struct net_device *) nic->dev;
2319 XENA_dev_config_t __iomem *bar0 = nic->bar0;
2320 register u64 val64 = 0, err_reg = 0;
2321
2322 /* Handling link status change error Intr */
2323 err_reg = readq(&bar0->mac_rmac_err_reg);
2324 writeq(err_reg, &bar0->mac_rmac_err_reg);
2325 if (err_reg & RMAC_LINK_STATE_CHANGE_INT) {
2326 schedule_work(&nic->set_link_task);
2327 }
2328
2329 /* In case of a serious error, the device will be Reset. */
2330 val64 = readq(&bar0->serr_source);
2331 if (val64 & SERR_SOURCE_ANY) {
2332 DBG_PRINT(ERR_DBG, "%s: Device indicates ", dev->name);
2333 DBG_PRINT(ERR_DBG, "serious error!!\n");
2334 netif_stop_queue(dev);
2335 schedule_work(&nic->rst_timer_task);
2336 }
2337
2338 /*
2339 * Also as mentioned in the latest Errata sheets if the PCC_FB_ECC
2340 * Error occurs, the adapter will be recycled by disabling the
2341 * adapter enable bit and enabling it again after the device
2342 * becomes Quiescent.
2343 */
2344 val64 = readq(&bar0->pcc_err_reg);
2345 writeq(val64, &bar0->pcc_err_reg);
2346 if (val64 & PCC_FB_ECC_DB_ERR) {
2347 u64 ac = readq(&bar0->adapter_control);
2348 ac &= ~(ADAPTER_CNTL_EN);
2349 writeq(ac, &bar0->adapter_control);
2350 ac = readq(&bar0->adapter_control);
2351 schedule_work(&nic->set_link_task);
2352 }
2353
2354 /* Other type of interrupts are not being handled now, TODO */
2355 }
2356
2357 /**
2358 * wait_for_cmd_complete - waits for a command to complete.
2359 * @sp : private member of the device structure, which is a pointer to the
2360 * s2io_nic structure.
2361 * Description: Function that waits for a command to Write into RMAC
2362 * ADDR DATA registers to be completed and returns either success or
2363 * error depending on whether the command was complete or not.
2364 * Return value:
2365 * SUCCESS on success and FAILURE on failure.
2366 */
2367
2368 static int wait_for_cmd_complete(nic_t * sp)
2369 {
2370 XENA_dev_config_t __iomem *bar0 = sp->bar0;
2371 int ret = FAILURE, cnt = 0;
2372 u64 val64;
2373
2374 while (TRUE) {
2375 val64 = readq(&bar0->rmac_addr_cmd_mem);
2376 if (!(val64 & RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING)) {
2377 ret = SUCCESS;
2378 break;
2379 }
2380 msleep(50);
2381 if (cnt++ > 10)
2382 break;
2383 }
2384
2385 return ret;
2386 }
2387
2388 /**
2389 * s2io_reset - Resets the card.
2390 * @sp : private member of the device structure.
2391 * Description: Function to Reset the card. This function then also
2392 * restores the previously saved PCI configuration space registers as
2393 * the card reset also resets the configuration space.
2394 * Return value:
2395 * void.
2396 */
2397
2398 static void s2io_reset(nic_t * sp)
2399 {
2400 XENA_dev_config_t __iomem *bar0 = sp->bar0;
2401 u64 val64;
2402 u16 subid;
2403
2404 val64 = SW_RESET_ALL;
2405 writeq(val64, &bar0->sw_reset);
2406
2407 /*
2408 * At this stage, if the PCI write is indeed completed, the
2409 * card is reset and so is the PCI Config space of the device.
2410 * So a read cannot be issued at this stage on any of the
2411 * registers to ensure the write into "sw_reset" register
2412 * has gone through.
2413 * Question: Is there any system call that will explicitly force
2414 * all the write commands still pending on the bus to be pushed
2415 * through?
2416 * As of now I'am just giving a 250ms delay and hoping that the
2417 * PCI write to sw_reset register is done by this time.
2418 */
2419 msleep(250);
2420
2421 /* Restore the PCI state saved during initializarion. */
2422 pci_restore_state(sp->pdev);
2423 s2io_init_pci(sp);
2424
2425 msleep(250);
2426
2427 /* SXE-002: Configure link and activity LED to turn it off */
2428 subid = sp->pdev->subsystem_device;
2429 if ((subid & 0xFF) >= 0x07) {
2430 val64 = readq(&bar0->gpio_control);
2431 val64 |= 0x0000800000000000ULL;
2432 writeq(val64, &bar0->gpio_control);
2433 val64 = 0x0411040400000000ULL;
2434 writeq(val64, (void __iomem *) bar0 + 0x2700);
2435 }
2436
2437 sp->device_enabled_once = FALSE;
2438 }
2439
2440 /**
2441 * s2io_set_swapper - to set the swapper controle on the card
2442 * @sp : private member of the device structure,
2443 * pointer to the s2io_nic structure.
2444 * Description: Function to set the swapper control on the card
2445 * correctly depending on the 'endianness' of the system.
2446 * Return value:
2447 * SUCCESS on success and FAILURE on failure.
2448 */
2449
2450 static int s2io_set_swapper(nic_t * sp)
2451 {
2452 struct net_device *dev = sp->dev;
2453 XENA_dev_config_t __iomem *bar0 = sp->bar0;
2454 u64 val64, valt, valr;
2455
2456 /*
2457 * Set proper endian settings and verify the same by reading
2458 * the PIF Feed-back register.
2459 */
2460
2461 val64 = readq(&bar0->pif_rd_swapper_fb);
2462 if (val64 != 0x0123456789ABCDEFULL) {
2463 int i = 0;
2464 u64 value[] = { 0xC30000C3C30000C3ULL, /* FE=1, SE=1 */
2465 0x8100008181000081ULL, /* FE=1, SE=0 */
2466 0x4200004242000042ULL, /* FE=0, SE=1 */
2467 0}; /* FE=0, SE=0 */
2468
2469 while(i<4) {
2470 writeq(value[i], &bar0->swapper_ctrl);
2471 val64 = readq(&bar0->pif_rd_swapper_fb);
2472 if (val64 == 0x0123456789ABCDEFULL)
2473 break;
2474 i++;
2475 }
2476 if (i == 4) {
2477 DBG_PRINT(ERR_DBG, "%s: Endian settings are wrong, ",
2478 dev->name);
2479 DBG_PRINT(ERR_DBG, "feedback read %llx\n",
2480 (unsigned long long) val64);
2481 return FAILURE;
2482 }
2483 valr = value[i];
2484 } else {
2485 valr = readq(&bar0->swapper_ctrl);
2486 }
2487
2488 valt = 0x0123456789ABCDEFULL;
2489 writeq(valt, &bar0->xmsi_address);
2490 val64 = readq(&bar0->xmsi_address);
2491
2492 if(val64 != valt) {
2493 int i = 0;
2494 u64 value[] = { 0x00C3C30000C3C300ULL, /* FE=1, SE=1 */
2495 0x0081810000818100ULL, /* FE=1, SE=0 */
2496 0x0042420000424200ULL, /* FE=0, SE=1 */
2497 0}; /* FE=0, SE=0 */
2498
2499 while(i<4) {
2500 writeq((value[i] | valr), &bar0->swapper_ctrl);
2501 writeq(valt, &bar0->xmsi_address);
2502 val64 = readq(&bar0->xmsi_address);
2503 if(val64 == valt)
2504 break;
2505 i++;
2506 }
2507 if(i == 4) {
2508 DBG_PRINT(ERR_DBG, "Write failed, Xmsi_addr ");
2509 DBG_PRINT(ERR_DBG, "reads:0x%llx\n",val64);
2510 return FAILURE;
2511 }
2512 }
2513 val64 = readq(&bar0->swapper_ctrl);
2514 val64 &= 0xFFFF000000000000ULL;
2515
2516 #ifdef __BIG_ENDIAN
2517 /*
2518 * The device by default set to a big endian format, so a
2519 * big endian driver need not set anything.
2520 */
2521 val64 |= (SWAPPER_CTRL_TXP_FE |
2522 SWAPPER_CTRL_TXP_SE |
2523 SWAPPER_CTRL_TXD_R_FE |
2524 SWAPPER_CTRL_TXD_W_FE |
2525 SWAPPER_CTRL_TXF_R_FE |
2526 SWAPPER_CTRL_RXD_R_FE |
2527 SWAPPER_CTRL_RXD_W_FE |
2528 SWAPPER_CTRL_RXF_W_FE |
2529 SWAPPER_CTRL_XMSI_FE |
2530 SWAPPER_CTRL_XMSI_SE |
2531 SWAPPER_CTRL_STATS_FE | SWAPPER_CTRL_STATS_SE);
2532 writeq(val64, &bar0->swapper_ctrl);
2533 #else
2534 /*
2535 * Initially we enable all bits to make it accessible by the
2536 * driver, then we selectively enable only those bits that
2537 * we want to set.
2538 */
2539 val64 |= (SWAPPER_CTRL_TXP_FE |
2540 SWAPPER_CTRL_TXP_SE |
2541 SWAPPER_CTRL_TXD_R_FE |
2542 SWAPPER_CTRL_TXD_R_SE |
2543 SWAPPER_CTRL_TXD_W_FE |
2544 SWAPPER_CTRL_TXD_W_SE |
2545 SWAPPER_CTRL_TXF_R_FE |
2546 SWAPPER_CTRL_RXD_R_FE |
2547 SWAPPER_CTRL_RXD_R_SE |
2548 SWAPPER_CTRL_RXD_W_FE |
2549 SWAPPER_CTRL_RXD_W_SE |
2550 SWAPPER_CTRL_RXF_W_FE |
2551 SWAPPER_CTRL_XMSI_FE |
2552 SWAPPER_CTRL_XMSI_SE |
2553 SWAPPER_CTRL_STATS_FE | SWAPPER_CTRL_STATS_SE);
2554 writeq(val64, &bar0->swapper_ctrl);
2555 #endif
2556 val64 = readq(&bar0->swapper_ctrl);
2557
2558 /*
2559 * Verifying if endian settings are accurate by reading a
2560 * feedback register.
2561 */
2562 val64 = readq(&bar0->pif_rd_swapper_fb);
2563 if (val64 != 0x0123456789ABCDEFULL) {
2564 /* Endian settings are incorrect, calls for another dekko. */
2565 DBG_PRINT(ERR_DBG, "%s: Endian settings are wrong, ",
2566 dev->name);
2567 DBG_PRINT(ERR_DBG, "feedback read %llx\n",
2568 (unsigned long long) val64);
2569 return FAILURE;
2570 }
2571
2572 return SUCCESS;
2573 }
2574
2575 /* ********************************************************* *
2576 * Functions defined below concern the OS part of the driver *
2577 * ********************************************************* */
2578
2579 /**
2580 * s2io_open - open entry point of the driver
2581 * @dev : pointer to the device structure.
2582 * Description:
2583 * This function is the open entry point of the driver. It mainly calls a
2584 * function to allocate Rx buffers and inserts them into the buffer
2585 * descriptors and then enables the Rx part of the NIC.
2586 * Return value:
2587 * 0 on success and an appropriate (-)ve integer as defined in errno.h
2588 * file on failure.
2589 */
2590
2591 static int s2io_open(struct net_device *dev)
2592 {
2593 nic_t *sp = dev->priv;
2594 int err = 0;
2595
2596 /*
2597 * Make sure you have link off by default every time
2598 * Nic is initialized
2599 */
2600 netif_carrier_off(dev);
2601 sp->last_link_state = LINK_DOWN;
2602
2603 /* Initialize H/W and enable interrupts */
2604 if (s2io_card_up(sp)) {
2605 DBG_PRINT(ERR_DBG, "%s: H/W initialization failed\n",
2606 dev->name);
2607 return -ENODEV;
2608 }
2609
2610 /* After proper initialization of H/W, register ISR */
2611 err = request_irq((int) sp->irq, s2io_isr, SA_SHIRQ,
2612 sp->name, dev);
2613 if (err) {
2614 s2io_reset(sp);
2615 DBG_PRINT(ERR_DBG, "%s: ISR registration failed\n",
2616 dev->name);
2617 return err;
2618 }
2619
2620 if (s2io_set_mac_addr(dev, dev->dev_addr) == FAILURE) {
2621 DBG_PRINT(ERR_DBG, "Set Mac Address Failed\n");
2622 s2io_reset(sp);
2623 return -ENODEV;
2624 }
2625
2626 netif_start_queue(dev);
2627 return 0;
2628 }
2629
2630 /**
2631 * s2io_close -close entry point of the driver
2632 * @dev : device pointer.
2633 * Description:
2634 * This is the stop entry point of the driver. It needs to undo exactly
2635 * whatever was done by the open entry point,thus it's usually referred to
2636 * as the close function.Among other things this function mainly stops the
2637 * Rx side of the NIC and frees all the Rx buffers in the Rx rings.
2638 * Return value:
2639 * 0 on success and an appropriate (-)ve integer as defined in errno.h
2640 * file on failure.
2641 */
2642
2643 static int s2io_close(struct net_device *dev)
2644 {
2645 nic_t *sp = dev->priv;
2646
2647 flush_scheduled_work();
2648 netif_stop_queue(dev);
2649 /* Reset card, kill tasklet and free Tx and Rx buffers. */
2650 s2io_card_down(sp);
2651
2652 free_irq(dev->irq, dev);
2653 sp->device_close_flag = TRUE; /* Device is shut down. */
2654 return 0;
2655 }
2656
2657 /**
2658 * s2io_xmit - Tx entry point of te driver
2659 * @skb : the socket buffer containing the Tx data.
2660 * @dev : device pointer.
2661 * Description :
2662 * This function is the Tx entry point of the driver. S2IO NIC supports
2663 * certain protocol assist features on Tx side, namely CSO, S/G, LSO.
2664 * NOTE: when device cant queue the pkt,just the trans_start variable will
2665 * not be upadted.
2666 * Return value:
2667 * 0 on success & 1 on failure.
2668 */
2669
2670 static int s2io_xmit(struct sk_buff *skb, struct net_device *dev)
2671 {
2672 nic_t *sp = dev->priv;
2673 u16 frg_cnt, frg_len, i, queue, queue_len, put_off, get_off;
2674 register u64 val64;
2675 TxD_t *txdp;
2676 TxFIFO_element_t __iomem *tx_fifo;
2677 unsigned long flags;
2678 #ifdef NETIF_F_TSO
2679 int mss;
2680 #endif
2681 mac_info_t *mac_control;
2682 struct config_param *config;
2683 XENA_dev_config_t __iomem *bar0 = sp->bar0;
2684
2685 mac_control = &sp->mac_control;
2686 config = &sp->config;
2687
2688 DBG_PRINT(TX_DBG, "%s: In S2IO Tx routine\n", dev->name);
2689 spin_lock_irqsave(&sp->tx_lock, flags);
2690
2691 if (atomic_read(&sp->card_state) == CARD_DOWN) {
2692 DBG_PRINT(ERR_DBG, "%s: Card going down for reset\n",
2693 dev->name);
2694 spin_unlock_irqrestore(&sp->tx_lock, flags);
2695 return 1;
2696 }
2697
2698 queue = 0;
2699 put_off = (u16) mac_control->tx_curr_put_info[queue].offset;
2700 get_off = (u16) mac_control->tx_curr_get_info[queue].offset;
2701 txdp = (TxD_t *) sp->list_info[queue][put_off].list_virt_addr;
2702
2703 queue_len = mac_control->tx_curr_put_info[queue].fifo_len + 1;
2704 /* Avoid "put" pointer going beyond "get" pointer */
2705 if (txdp->Host_Control || (((put_off + 1) % queue_len) == get_off)) {
2706 DBG_PRINT(ERR_DBG, "Error in xmit, No free TXDs.\n");
2707 netif_stop_queue(dev);
2708 dev_kfree_skb(skb);
2709 spin_unlock_irqrestore(&sp->tx_lock, flags);
2710 return 0;
2711 }
2712 #ifdef NETIF_F_TSO
2713 mss = skb_shinfo(skb)->tso_size;
2714 if (mss) {
2715 txdp->Control_1 |= TXD_TCP_LSO_EN;
2716 txdp->Control_1 |= TXD_TCP_LSO_MSS(mss);
2717 }
2718 #endif
2719
2720 frg_cnt = skb_shinfo(skb)->nr_frags;
2721 frg_len = skb->len - skb->data_len;
2722
2723 txdp->Host_Control = (unsigned long) skb;
2724 txdp->Buffer_Pointer = pci_map_single
2725 (sp->pdev, skb->data, frg_len, PCI_DMA_TODEVICE);
2726 if (skb->ip_summed == CHECKSUM_HW) {
2727 txdp->Control_2 |=
2728 (TXD_TX_CKO_IPV4_EN | TXD_TX_CKO_TCP_EN |
2729 TXD_TX_CKO_UDP_EN);
2730 }
2731
2732 txdp->Control_2 |= config->tx_intr_type;
2733
2734 txdp->Control_1 |= (TXD_BUFFER0_SIZE(frg_len) |
2735 TXD_GATHER_CODE_FIRST);
2736 txdp->Control_1 |= TXD_LIST_OWN_XENA;
2737
2738 /* For fragmented SKB. */
2739 for (i = 0; i < frg_cnt; i++) {
2740 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2741 txdp++;
2742 txdp->Buffer_Pointer = (u64) pci_map_page
2743 (sp->pdev, frag->page, frag->page_offset,
2744 frag->size, PCI_DMA_TODEVICE);
2745 txdp->Control_1 |= TXD_BUFFER0_SIZE(frag->size);
2746 }
2747 txdp->Control_1 |= TXD_GATHER_CODE_LAST;
2748
2749 tx_fifo = mac_control->tx_FIFO_start[queue];
2750 val64 = sp->list_info[queue][put_off].list_phy_addr;
2751 writeq(val64, &tx_fifo->TxDL_Pointer);
2752
2753 val64 = (TX_FIFO_LAST_TXD_NUM(frg_cnt) | TX_FIFO_FIRST_LIST |
2754 TX_FIFO_LAST_LIST);
2755 #ifdef NETIF_F_TSO
2756 if (mss)
2757 val64 |= TX_FIFO_SPECIAL_FUNC;
2758 #endif
2759 writeq(val64, &tx_fifo->List_Control);
2760
2761 /* Perform a PCI read to flush previous writes */
2762 val64 = readq(&bar0->general_int_status);
2763
2764 put_off++;
2765 put_off %= mac_control->tx_curr_put_info[queue].fifo_len + 1;
2766 mac_control->tx_curr_put_info[queue].offset = put_off;
2767
2768 /* Avoid "put" pointer going beyond "get" pointer */
2769 if (((put_off + 1) % queue_len) == get_off) {
2770 DBG_PRINT(TX_DBG,
2771 "No free TxDs for xmit, Put: 0x%x Get:0x%x\n",
2772 put_off, get_off);
2773 netif_stop_queue(dev);
2774 }
2775
2776 dev->trans_start = jiffies;
2777 spin_unlock_irqrestore(&sp->tx_lock, flags);
2778
2779 return 0;
2780 }
2781
2782 /**
2783 * s2io_isr - ISR handler of the device .
2784 * @irq: the irq of the device.
2785 * @dev_id: a void pointer to the dev structure of the NIC.
2786 * @pt_regs: pointer to the registers pushed on the stack.
2787 * Description: This function is the ISR handler of the device. It
2788 * identifies the reason for the interrupt and calls the relevant
2789 * service routines. As a contongency measure, this ISR allocates the
2790 * recv buffers, if their numbers are below the panic value which is
2791 * presently set to 25% of the original number of rcv buffers allocated.
2792 * Return value:
2793 * IRQ_HANDLED: will be returned if IRQ was handled by this routine
2794 * IRQ_NONE: will be returned if interrupt is not from our device
2795 */
2796 static irqreturn_t s2io_isr(int irq, void *dev_id, struct pt_regs *regs)
2797 {
2798 struct net_device *dev = (struct net_device *) dev_id;
2799 nic_t *sp = dev->priv;
2800 XENA_dev_config_t __iomem *bar0 = sp->bar0;
2801 #ifndef CONFIG_S2IO_NAPI
2802 int i, ret;
2803 #endif
2804 u64 reason = 0;
2805 mac_info_t *mac_control;
2806 struct config_param *config;
2807
2808 mac_control = &sp->mac_control;
2809 config = &sp->config;
2810
2811 /*
2812 * Identify the cause for interrupt and call the appropriate
2813 * interrupt handler. Causes for the interrupt could be;
2814 * 1. Rx of packet.
2815 * 2. Tx complete.
2816 * 3. Link down.
2817 * 4. Error in any functional blocks of the NIC.
2818 */
2819 reason = readq(&bar0->general_int_status);
2820
2821 if (!reason) {
2822 /* The interrupt was not raised by Xena. */
2823 return IRQ_NONE;
2824 }
2825
2826 /* If Intr is because of Tx Traffic */
2827 if (reason & GEN_INTR_TXTRAFFIC) {
2828 tx_intr_handler(sp);
2829 }
2830
2831 /* If Intr is because of an error */
2832 if (reason & (GEN_ERROR_INTR))
2833 alarm_intr_handler(sp);
2834
2835 #ifdef CONFIG_S2IO_NAPI
2836 if (reason & GEN_INTR_RXTRAFFIC) {
2837 if (netif_rx_schedule_prep(dev)) {
2838 en_dis_able_nic_intrs(sp, RX_TRAFFIC_INTR,
2839 DISABLE_INTRS);
2840 __netif_rx_schedule(dev);
2841 }
2842 }
2843 #else
2844 /* If Intr is because of Rx Traffic */
2845 if (reason & GEN_INTR_RXTRAFFIC) {
2846 rx_intr_handler(sp);
2847 }
2848 #endif
2849
2850 /*
2851 * If the Rx buffer count is below the panic threshold then
2852 * reallocate the buffers from the interrupt handler itself,
2853 * else schedule a tasklet to reallocate the buffers.
2854 */
2855 #ifndef CONFIG_S2IO_NAPI
2856 for (i = 0; i < config->rx_ring_num; i++) {
2857 int rxb_size = atomic_read(&sp->rx_bufs_left[i]);
2858 int level = rx_buffer_level(sp, rxb_size, i);
2859
2860 if ((level == PANIC) && (!TASKLET_IN_USE)) {
2861 DBG_PRINT(INTR_DBG, "%s: Rx BD hit ", dev->name);
2862 DBG_PRINT(INTR_DBG, "PANIC levels\n");
2863 if ((ret = fill_rx_buffers(sp, i)) == -ENOMEM) {
2864 DBG_PRINT(ERR_DBG, "%s:Out of memory",
2865 dev->name);
2866 DBG_PRINT(ERR_DBG, " in ISR!!\n");
2867 clear_bit(0, (&sp->tasklet_status));
2868 return IRQ_HANDLED;
2869 }
2870 clear_bit(0, (&sp->tasklet_status));
2871 } else if (level == LOW) {
2872 tasklet_schedule(&sp->task);
2873 }
2874 }
2875 #endif
2876
2877 return IRQ_HANDLED;
2878 }
2879
2880 /**
2881 * s2io_get_stats - Updates the device statistics structure.
2882 * @dev : pointer to the device structure.
2883 * Description:
2884 * This function updates the device statistics structure in the s2io_nic
2885 * structure and returns a pointer to the same.
2886 * Return value:
2887 * pointer to the updated net_device_stats structure.
2888 */
2889
2890 static struct net_device_stats *s2io_get_stats(struct net_device *dev)
2891 {
2892 nic_t *sp = dev->priv;
2893 mac_info_t *mac_control;
2894 struct config_param *config;
2895
2896 mac_control = &sp->mac_control;
2897 config = &sp->config;
2898
2899 sp->stats.tx_errors = mac_control->stats_info->tmac_any_err_frms;
2900 sp->stats.rx_errors = mac_control->stats_info->rmac_drop_frms;
2901 sp->stats.multicast = mac_control->stats_info->rmac_vld_mcst_frms;
2902 sp->stats.rx_length_errors =
2903 mac_control->stats_info->rmac_long_frms;
2904
2905 return (&sp->stats);
2906 }
2907
2908 /**
2909 * s2io_set_multicast - entry point for multicast address enable/disable.
2910 * @dev : pointer to the device structure
2911 * Description:
2912 * This function is a driver entry point which gets called by the kernel
2913 * whenever multicast addresses must be enabled/disabled. This also gets
2914 * called to set/reset promiscuous mode. Depending on the deivce flag, we
2915 * determine, if multicast address must be enabled or if promiscuous mode
2916 * is to be disabled etc.
2917 * Return value:
2918 * void.
2919 */
2920
2921 static void s2io_set_multicast(struct net_device *dev)
2922 {
2923 int i, j, prev_cnt;
2924 struct dev_mc_list *mclist;
2925 nic_t *sp = dev->priv;
2926 XENA_dev_config_t __iomem *bar0 = sp->bar0;
2927 u64 val64 = 0, multi_mac = 0x010203040506ULL, mask =
2928 0xfeffffffffffULL;
2929 u64 dis_addr = 0xffffffffffffULL, mac_addr = 0;
2930 void __iomem *add;
2931
2932 if ((dev->flags & IFF_ALLMULTI) && (!sp->m_cast_flg)) {
2933 /* Enable all Multicast addresses */
2934 writeq(RMAC_ADDR_DATA0_MEM_ADDR(multi_mac),
2935 &bar0->rmac_addr_data0_mem);
2936 writeq(RMAC_ADDR_DATA1_MEM_MASK(mask),
2937 &bar0->rmac_addr_data1_mem);
2938 val64 = RMAC_ADDR_CMD_MEM_WE |
2939 RMAC_ADDR_CMD_MEM_STROBE_NEW_CMD |
2940 RMAC_ADDR_CMD_MEM_OFFSET(MAC_MC_ALL_MC_ADDR_OFFSET);
2941 writeq(val64, &bar0->rmac_addr_cmd_mem);
2942 /* Wait till command completes */
2943 wait_for_cmd_complete(sp);
2944
2945 sp->m_cast_flg = 1;
2946 sp->all_multi_pos = MAC_MC_ALL_MC_ADDR_OFFSET;
2947 } else if ((dev->flags & IFF_ALLMULTI) && (sp->m_cast_flg)) {
2948 /* Disable all Multicast addresses */
2949 writeq(RMAC_ADDR_DATA0_MEM_ADDR(dis_addr),
2950 &bar0->rmac_addr_data0_mem);
2951 val64 = RMAC_ADDR_CMD_MEM_WE |
2952 RMAC_ADDR_CMD_MEM_STROBE_NEW_CMD |
2953 RMAC_ADDR_CMD_MEM_OFFSET(sp->all_multi_pos);
2954 writeq(val64, &bar0->rmac_addr_cmd_mem);
2955 /* Wait till command completes */
2956 wait_for_cmd_complete(sp);
2957
2958 sp->m_cast_flg = 0;
2959 sp->all_multi_pos = 0;
2960 }
2961
2962 if ((dev->flags & IFF_PROMISC) && (!sp->promisc_flg)) {
2963 /* Put the NIC into promiscuous mode */
2964 add = &bar0->mac_cfg;
2965 val64 = readq(&bar0->mac_cfg);
2966 val64 |= MAC_CFG_RMAC_PROM_ENABLE;
2967
2968 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
2969 writel((u32) val64, add);
2970 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
2971 writel((u32) (val64 >> 32), (add + 4));
2972
2973 val64 = readq(&bar0->mac_cfg);
2974 sp->promisc_flg = 1;
2975 DBG_PRINT(ERR_DBG, "%s: entered promiscuous mode\n",
2976 dev->name);
2977 } else if (!(dev->flags & IFF_PROMISC) && (sp->promisc_flg)) {
2978 /* Remove the NIC from promiscuous mode */
2979 add = &bar0->mac_cfg;
2980 val64 = readq(&bar0->mac_cfg);
2981 val64 &= ~MAC_CFG_RMAC_PROM_ENABLE;
2982
2983 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
2984 writel((u32) val64, add);
2985 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
2986 writel((u32) (val64 >> 32), (add + 4));
2987
2988 val64 = readq(&bar0->mac_cfg);
2989 sp->promisc_flg = 0;
2990 DBG_PRINT(ERR_DBG, "%s: left promiscuous mode\n",
2991 dev->name);
2992 }
2993
2994 /* Update individual M_CAST address list */
2995 if ((!sp->m_cast_flg) && dev->mc_count) {
2996 if (dev->mc_count >
2997 (MAX_ADDRS_SUPPORTED - MAC_MC_ADDR_START_OFFSET - 1)) {
2998 DBG_PRINT(ERR_DBG, "%s: No more Rx filters ",
2999 dev->name);
3000 DBG_PRINT(ERR_DBG, "can be added, please enable ");
3001 DBG_PRINT(ERR_DBG, "ALL_MULTI instead\n");
3002 return;
3003 }
3004
3005 prev_cnt = sp->mc_addr_count;
3006 sp->mc_addr_count = dev->mc_count;
3007
3008 /* Clear out the previous list of Mc in the H/W. */
3009 for (i = 0; i < prev_cnt; i++) {
3010 writeq(RMAC_ADDR_DATA0_MEM_ADDR(dis_addr),
3011 &bar0->rmac_addr_data0_mem);
3012 writeq(RMAC_ADDR_DATA1_MEM_MASK(0ULL),
3013 &bar0->rmac_addr_data1_mem);
3014 val64 = RMAC_ADDR_CMD_MEM_WE |
3015 RMAC_ADDR_CMD_MEM_STROBE_NEW_CMD |
3016 RMAC_ADDR_CMD_MEM_OFFSET
3017 (MAC_MC_ADDR_START_OFFSET + i);
3018 writeq(val64, &bar0->rmac_addr_cmd_mem);
3019
3020 /* Wait for command completes */
3021 if (wait_for_cmd_complete(sp)) {
3022 DBG_PRINT(ERR_DBG, "%s: Adding ",
3023 dev->name);
3024 DBG_PRINT(ERR_DBG, "Multicasts failed\n");
3025 return;
3026 }
3027 }
3028
3029 /* Create the new Rx filter list and update the same in H/W. */
3030 for (i = 0, mclist = dev->mc_list; i < dev->mc_count;
3031 i++, mclist = mclist->next) {
3032 memcpy(sp->usr_addrs[i].addr, mclist->dmi_addr,
3033 ETH_ALEN);
3034 for (j = 0; j < ETH_ALEN; j++) {
3035 mac_addr |= mclist->dmi_addr[j];
3036 mac_addr <<= 8;
3037 }
3038 mac_addr >>= 8;
3039 writeq(RMAC_ADDR_DATA0_MEM_ADDR(mac_addr),
3040 &bar0->rmac_addr_data0_mem);
3041 writeq(RMAC_ADDR_DATA1_MEM_MASK(0ULL),
3042 &bar0->rmac_addr_data1_mem);
3043
3044 val64 = RMAC_ADDR_CMD_MEM_WE |
3045 RMAC_ADDR_CMD_MEM_STROBE_NEW_CMD |
3046 RMAC_ADDR_CMD_MEM_OFFSET
3047 (i + MAC_MC_ADDR_START_OFFSET);
3048 writeq(val64, &bar0->rmac_addr_cmd_mem);
3049
3050 /* Wait for command completes */
3051 if (wait_for_cmd_complete(sp)) {
3052 DBG_PRINT(ERR_DBG, "%s: Adding ",
3053 dev->name);
3054 DBG_PRINT(ERR_DBG, "Multicasts failed\n");
3055 return;
3056 }
3057 }
3058 }
3059 }
3060
3061 /**
3062 * s2io_set_mac_addr - Programs the Xframe mac address
3063 * @dev : pointer to the device structure.
3064 * @addr: a uchar pointer to the new mac address which is to be set.
3065 * Description : This procedure will program the Xframe to receive
3066 * frames with new Mac Address
3067 * Return value: SUCCESS on success and an appropriate (-)ve integer
3068 * as defined in errno.h file on failure.
3069 */
3070
3071 int s2io_set_mac_addr(struct net_device *dev, u8 * addr)
3072 {
3073 nic_t *sp = dev->priv;
3074 XENA_dev_config_t __iomem *bar0 = sp->bar0;
3075 register u64 val64, mac_addr = 0;
3076 int i;
3077
3078 /*
3079 * Set the new MAC address as the new unicast filter and reflect this
3080 * change on the device address registered with the OS. It will be
3081 * at offset 0.
3082 */
3083 for (i = 0; i < ETH_ALEN; i++) {
3084 mac_addr <<= 8;
3085 mac_addr |= addr[i];
3086 }
3087
3088 writeq(RMAC_ADDR_DATA0_MEM_ADDR(mac_addr),
3089 &bar0->rmac_addr_data0_mem);
3090
3091 val64 =
3092 RMAC_ADDR_CMD_MEM_WE | RMAC_ADDR_CMD_MEM_STROBE_NEW_CMD |
3093 RMAC_ADDR_CMD_MEM_OFFSET(0);
3094 writeq(val64, &bar0->rmac_addr_cmd_mem);
3095 /* Wait till command completes */
3096 if (wait_for_cmd_complete(sp)) {
3097 DBG_PRINT(ERR_DBG, "%s: set_mac_addr failed\n", dev->name);
3098 return FAILURE;
3099 }
3100
3101 return SUCCESS;
3102 }
3103
3104 /**
3105 * s2io_ethtool_sset - Sets different link parameters.
3106 * @sp : private member of the device structure, which is a pointer to the * s2io_nic structure.
3107 * @info: pointer to the structure with parameters given by ethtool to set
3108 * link information.
3109 * Description:
3110 * The function sets different link parameters provided by the user onto
3111 * the NIC.
3112 * Return value:
3113 * 0 on success.
3114 */
3115
3116 static int s2io_ethtool_sset(struct net_device *dev,
3117 struct ethtool_cmd *info)
3118 {
3119 nic_t *sp = dev->priv;
3120 if ((info->autoneg == AUTONEG_ENABLE) ||
3121 (info->speed != SPEED_10000) || (info->duplex != DUPLEX_FULL))
3122 return -EINVAL;
3123 else {
3124 s2io_close(sp->dev);
3125 s2io_open(sp->dev);
3126 }
3127
3128 return 0;
3129 }
3130
3131 /**
3132 * s2io_ethtol_gset - Return link specific information.
3133 * @sp : private member of the device structure, pointer to the
3134 * s2io_nic structure.
3135 * @info : pointer to the structure with parameters given by ethtool
3136 * to return link information.
3137 * Description:
3138 * Returns link specific information like speed, duplex etc.. to ethtool.
3139 * Return value :
3140 * return 0 on success.
3141 */
3142
3143 static int s2io_ethtool_gset(struct net_device *dev, struct ethtool_cmd *info)
3144 {
3145 nic_t *sp = dev->priv;
3146 info->supported = (SUPPORTED_10000baseT_Full | SUPPORTED_FIBRE);
3147 info->advertising = (SUPPORTED_10000baseT_Full | SUPPORTED_FIBRE);
3148 info->port = PORT_FIBRE;
3149 /* info->transceiver?? TODO */
3150
3151 if (netif_carrier_ok(sp->dev)) {
3152 info->speed = 10000;
3153 info->duplex = DUPLEX_FULL;
3154 } else {
3155 info->speed = -1;
3156 info->duplex = -1;
3157 }
3158
3159 info->autoneg = AUTONEG_DISABLE;
3160 return 0;
3161 }
3162
3163 /**
3164 * s2io_ethtool_gdrvinfo - Returns driver specific information.
3165 * @sp : private member of the device structure, which is a pointer to the
3166 * s2io_nic structure.
3167 * @info : pointer to the structure with parameters given by ethtool to
3168 * return driver information.
3169 * Description:
3170 * Returns driver specefic information like name, version etc.. to ethtool.
3171 * Return value:
3172 * void
3173 */
3174
3175 static void s2io_ethtool_gdrvinfo(struct net_device *dev,
3176 struct ethtool_drvinfo *info)
3177 {
3178 nic_t *sp = dev->priv;
3179
3180 strncpy(info->driver, s2io_driver_name, sizeof(s2io_driver_name));
3181 strncpy(info->version, s2io_driver_version,
3182 sizeof(s2io_driver_version));
3183 strncpy(info->fw_version, "", 32);
3184 strncpy(info->bus_info, pci_name(sp->pdev), 32);
3185 info->regdump_len = XENA_REG_SPACE;
3186 info->eedump_len = XENA_EEPROM_SPACE;
3187 info->testinfo_len = S2IO_TEST_LEN;
3188 info->n_stats = S2IO_STAT_LEN;
3189 }
3190
3191 /**
3192 * s2io_ethtool_gregs - dumps the entire space of Xfame into the buffer.
3193 * @sp: private member of the device structure, which is a pointer to the
3194 * s2io_nic structure.
3195 * @regs : pointer to the structure with parameters given by ethtool for
3196 * dumping the registers.
3197 * @reg_space: The input argumnet into which all the registers are dumped.
3198 * Description:
3199 * Dumps the entire register space of xFrame NIC into the user given
3200 * buffer area.
3201 * Return value :
3202 * void .
3203 */
3204
3205 static void s2io_ethtool_gregs(struct net_device *dev,
3206 struct ethtool_regs *regs, void *space)
3207 {
3208 int i;
3209 u64 reg;
3210 u8 *reg_space = (u8 *) space;
3211 nic_t *sp = dev->priv;
3212
3213 regs->len = XENA_REG_SPACE;
3214 regs->version = sp->pdev->subsystem_device;
3215
3216 for (i = 0; i < regs->len; i += 8) {
3217 reg = readq(sp->bar0 + i);
3218 memcpy((reg_space + i), &reg, 8);
3219 }
3220 }
3221
3222 /**
3223 * s2io_phy_id - timer function that alternates adapter LED.
3224 * @data : address of the private member of the device structure, which
3225 * is a pointer to the s2io_nic structure, provided as an u32.
3226 * Description: This is actually the timer function that alternates the
3227 * adapter LED bit of the adapter control bit to set/reset every time on
3228 * invocation. The timer is set for 1/2 a second, hence tha NIC blinks
3229 * once every second.
3230 */
3231 static void s2io_phy_id(unsigned long data)
3232 {
3233 nic_t *sp = (nic_t *) data;
3234 XENA_dev_config_t __iomem *bar0 = sp->bar0;
3235 u64 val64 = 0;
3236 u16 subid;
3237
3238 subid = sp->pdev->subsystem_device;
3239 if ((subid & 0xFF) >= 0x07) {
3240 val64 = readq(&bar0->gpio_control);
3241 val64 ^= GPIO_CTRL_GPIO_0;
3242 writeq(val64, &bar0->gpio_control);
3243 } else {
3244 val64 = readq(&bar0->adapter_control);
3245 val64 ^= ADAPTER_LED_ON;
3246 writeq(val64, &bar0->adapter_control);
3247 }
3248
3249 mod_timer(&sp->id_timer, jiffies + HZ / 2);
3250 }
3251
3252 /**
3253 * s2io_ethtool_idnic - To physically identify the nic on the system.
3254 * @sp : private member of the device structure, which is a pointer to the
3255 * s2io_nic structure.
3256 * @id : pointer to the structure with identification parameters given by
3257 * ethtool.
3258 * Description: Used to physically identify the NIC on the system.
3259 * The Link LED will blink for a time specified by the user for
3260 * identification.
3261 * NOTE: The Link has to be Up to be able to blink the LED. Hence
3262 * identification is possible only if it's link is up.
3263 * Return value:
3264 * int , returns 0 on success
3265 */
3266
3267 static int s2io_ethtool_idnic(struct net_device *dev, u32 data)
3268 {
3269 u64 val64 = 0, last_gpio_ctrl_val;
3270 nic_t *sp = dev->priv;
3271 XENA_dev_config_t __iomem *bar0 = sp->bar0;
3272 u16 subid;
3273
3274 subid = sp->pdev->subsystem_device;
3275 last_gpio_ctrl_val = readq(&bar0->gpio_control);
3276 if ((subid & 0xFF) < 0x07) {
3277 val64 = readq(&bar0->adapter_control);
3278 if (!(val64 & ADAPTER_CNTL_EN)) {
3279 printk(KERN_ERR
3280 "Adapter Link down, cannot blink LED\n");
3281 return -EFAULT;
3282 }
3283 }
3284 if (sp->id_timer.function == NULL) {
3285 init_timer(&sp->id_timer);
3286 sp->id_timer.function = s2io_phy_id;
3287 sp->id_timer.data = (unsigned long) sp;
3288 }
3289 mod_timer(&sp->id_timer, jiffies);
3290 if (data)
3291 msleep(data * 1000);
3292 else
3293 msleep(0xFFFFFFFF);
3294 del_timer_sync(&sp->id_timer);
3295
3296 if (CARDS_WITH_FAULTY_LINK_INDICATORS(subid)) {
3297 writeq(last_gpio_ctrl_val, &bar0->gpio_control);
3298 last_gpio_ctrl_val = readq(&bar0->gpio_control);
3299 }
3300
3301 return 0;
3302 }
3303
3304 /**
3305 * s2io_ethtool_getpause_data -Pause frame frame generation and reception.
3306 * @sp : private member of the device structure, which is a pointer to the * s2io_nic structure.
3307 * @ep : pointer to the structure with pause parameters given by ethtool.
3308 * Description:
3309 * Returns the Pause frame generation and reception capability of the NIC.
3310 * Return value:
3311 * void
3312 */
3313 static void s2io_ethtool_getpause_data(struct net_device *dev,
3314 struct ethtool_pauseparam *ep)
3315 {
3316 u64 val64;
3317 nic_t *sp = dev->priv;
3318 XENA_dev_config_t __iomem *bar0 = sp->bar0;
3319
3320 val64 = readq(&bar0->rmac_pause_cfg);
3321 if (val64 & RMAC_PAUSE_GEN_ENABLE)
3322 ep->tx_pause = TRUE;
3323 if (val64 & RMAC_PAUSE_RX_ENABLE)
3324 ep->rx_pause = TRUE;
3325 ep->autoneg = FALSE;
3326 }
3327
3328 /**
3329 * s2io_ethtool_setpause_data - set/reset pause frame generation.
3330 * @sp : private member of the device structure, which is a pointer to the
3331 * s2io_nic structure.
3332 * @ep : pointer to the structure with pause parameters given by ethtool.
3333 * Description:
3334 * It can be used to set or reset Pause frame generation or reception
3335 * support of the NIC.
3336 * Return value:
3337 * int, returns 0 on Success
3338 */
3339
3340 static int s2io_ethtool_setpause_data(struct net_device *dev,
3341 struct ethtool_pauseparam *ep)
3342 {
3343 u64 val64;
3344 nic_t *sp = dev->priv;
3345 XENA_dev_config_t __iomem *bar0 = sp->bar0;
3346
3347 val64 = readq(&bar0->rmac_pause_cfg);
3348 if (ep->tx_pause)
3349 val64 |= RMAC_PAUSE_GEN_ENABLE;
3350 else
3351 val64 &= ~RMAC_PAUSE_GEN_ENABLE;
3352 if (ep->rx_pause)
3353 val64 |= RMAC_PAUSE_RX_ENABLE;
3354 else
3355 val64 &= ~RMAC_PAUSE_RX_ENABLE;
3356 writeq(val64, &bar0->rmac_pause_cfg);
3357 return 0;
3358 }
3359
3360 /**
3361 * read_eeprom - reads 4 bytes of data from user given offset.
3362 * @sp : private member of the device structure, which is a pointer to the
3363 * s2io_nic structure.
3364 * @off : offset at which the data must be written
3365 * @data : Its an output parameter where the data read at the given
3366 * offset is stored.
3367 * Description:
3368 * Will read 4 bytes of data from the user given offset and return the
3369 * read data.
3370 * NOTE: Will allow to read only part of the EEPROM visible through the
3371 * I2C bus.
3372 * Return value:
3373 * -1 on failure and 0 on success.
3374 */
3375
3376 #define S2IO_DEV_ID 5
3377 static int read_eeprom(nic_t * sp, int off, u32 * data)
3378 {
3379 int ret = -1;
3380 u32 exit_cnt = 0;
3381 u64 val64;
3382 XENA_dev_config_t __iomem *bar0 = sp->bar0;
3383
3384 val64 = I2C_CONTROL_DEV_ID(S2IO_DEV_ID) | I2C_CONTROL_ADDR(off) |
3385 I2C_CONTROL_BYTE_CNT(0x3) | I2C_CONTROL_READ |
3386 I2C_CONTROL_CNTL_START;
3387 SPECIAL_REG_WRITE(val64, &bar0->i2c_control, LF);
3388
3389 while (exit_cnt < 5) {
3390 val64 = readq(&bar0->i2c_control);
3391 if (I2C_CONTROL_CNTL_END(val64)) {
3392 *data = I2C_CONTROL_GET_DATA(val64);
3393 ret = 0;
3394 break;
3395 }
3396 msleep(50);
3397 exit_cnt++;
3398 }
3399
3400 return ret;
3401 }
3402
3403 /**
3404 * write_eeprom - actually writes the relevant part of the data value.
3405 * @sp : private member of the device structure, which is a pointer to the
3406 * s2io_nic structure.
3407 * @off : offset at which the data must be written
3408 * @data : The data that is to be written
3409 * @cnt : Number of bytes of the data that are actually to be written into
3410 * the Eeprom. (max of 3)
3411 * Description:
3412 * Actually writes the relevant part of the data value into the Eeprom
3413 * through the I2C bus.
3414 * Return value:
3415 * 0 on success, -1 on failure.
3416 */
3417
3418 static int write_eeprom(nic_t * sp, int off, u32 data, int cnt)
3419 {
3420 int exit_cnt = 0, ret = -1;
3421 u64 val64;
3422 XENA_dev_config_t __iomem *bar0 = sp->bar0;
3423
3424 val64 = I2C_CONTROL_DEV_ID(S2IO_DEV_ID) | I2C_CONTROL_ADDR(off) |
3425 I2C_CONTROL_BYTE_CNT(cnt) | I2C_CONTROL_SET_DATA(data) |
3426 I2C_CONTROL_CNTL_START;
3427 SPECIAL_REG_WRITE(val64, &bar0->i2c_control, LF);
3428
3429 while (exit_cnt < 5) {
3430 val64 = readq(&bar0->i2c_control);
3431 if (I2C_CONTROL_CNTL_END(val64)) {
3432 if (!(val64 & I2C_CONTROL_NACK))
3433 ret = 0;
3434 break;
3435 }
3436 msleep(50);
3437 exit_cnt++;
3438 }
3439
3440 return ret;
3441 }
3442
3443 /**
3444 * s2io_ethtool_geeprom - reads the value stored in the Eeprom.
3445 * @sp : private member of the device structure, which is a pointer to the * s2io_nic structure.
3446 * @eeprom : pointer to the user level structure provided by ethtool,
3447 * containing all relevant information.
3448 * @data_buf : user defined value to be written into Eeprom.
3449 * Description: Reads the values stored in the Eeprom at given offset
3450 * for a given length. Stores these values int the input argument data
3451 * buffer 'data_buf' and returns these to the caller (ethtool.)
3452 * Return value:
3453 * int 0 on success
3454 */
3455
3456 static int s2io_ethtool_geeprom(struct net_device *dev,
3457 struct ethtool_eeprom *eeprom, u8 * data_buf)
3458 {
3459 u32 data, i, valid;
3460 nic_t *sp = dev->priv;
3461
3462 eeprom->magic = sp->pdev->vendor | (sp->pdev->device << 16);
3463
3464 if ((eeprom->offset + eeprom->len) > (XENA_EEPROM_SPACE))
3465 eeprom->len = XENA_EEPROM_SPACE - eeprom->offset;
3466
3467 for (i = 0; i < eeprom->len; i += 4) {
3468 if (read_eeprom(sp, (eeprom->offset + i), &data)) {
3469 DBG_PRINT(ERR_DBG, "Read of EEPROM failed\n");
3470 return -EFAULT;
3471 }
3472 valid = INV(data);
3473 memcpy((data_buf + i), &valid, 4);
3474 }
3475 return 0;
3476 }
3477
3478 /**
3479 * s2io_ethtool_seeprom - tries to write the user provided value in Eeprom
3480 * @sp : private member of the device structure, which is a pointer to the
3481 * s2io_nic structure.
3482 * @eeprom : pointer to the user level structure provided by ethtool,
3483 * containing all relevant information.
3484 * @data_buf ; user defined value to be written into Eeprom.
3485 * Description:
3486 * Tries to write the user provided value in the Eeprom, at the offset
3487 * given by the user.
3488 * Return value:
3489 * 0 on success, -EFAULT on failure.
3490 */
3491
3492 static int s2io_ethtool_seeprom(struct net_device *dev,
3493 struct ethtool_eeprom *eeprom,
3494 u8 * data_buf)
3495 {
3496 int len = eeprom->len, cnt = 0;
3497 u32 valid = 0, data;
3498 nic_t *sp = dev->priv;
3499
3500 if (eeprom->magic != (sp->pdev->vendor | (sp->pdev->device << 16))) {
3501 DBG_PRINT(ERR_DBG,
3502 "ETHTOOL_WRITE_EEPROM Err: Magic value ");
3503 DBG_PRINT(ERR_DBG, "is wrong, Its not 0x%x\n",
3504 eeprom->magic);
3505 return -EFAULT;
3506 }
3507
3508 while (len) {
3509 data = (u32) data_buf[cnt] & 0x000000FF;
3510 if (data) {
3511 valid = (u32) (data << 24);
3512 } else
3513 valid = data;
3514
3515 if (write_eeprom(sp, (eeprom->offset + cnt), valid, 0)) {
3516 DBG_PRINT(ERR_DBG,
3517 "ETHTOOL_WRITE_EEPROM Err: Cannot ");
3518 DBG_PRINT(ERR_DBG,
3519 "write into the specified offset\n");
3520 return -EFAULT;
3521 }
3522 cnt++;
3523 len--;
3524 }
3525
3526 return 0;
3527 }
3528
3529 /**
3530 * s2io_register_test - reads and writes into all clock domains.
3531 * @sp : private member of the device structure, which is a pointer to the
3532 * s2io_nic structure.
3533 * @data : variable that returns the result of each of the test conducted b
3534 * by the driver.
3535 * Description:
3536 * Read and write into all clock domains. The NIC has 3 clock domains,
3537 * see that registers in all the three regions are accessible.
3538 * Return value:
3539 * 0 on success.
3540 */
3541
3542 static int s2io_register_test(nic_t * sp, uint64_t * data)
3543 {
3544 XENA_dev_config_t __iomem *bar0 = sp->bar0;
3545 u64 val64 = 0;
3546 int fail = 0;
3547
3548 val64 = readq(&bar0->pcc_enable);
3549 if (val64 != 0xff00000000000000ULL) {
3550 fail = 1;
3551 DBG_PRINT(INFO_DBG, "Read Test level 1 fails\n");
3552 }
3553
3554 val64 = readq(&bar0->rmac_pause_cfg);
3555 if (val64 != 0xc000ffff00000000ULL) {
3556 fail = 1;
3557 DBG_PRINT(INFO_DBG, "Read Test level 2 fails\n");
3558 }
3559
3560 val64 = readq(&bar0->rx_queue_cfg);
3561 if (val64 != 0x0808080808080808ULL) {
3562 fail = 1;
3563 DBG_PRINT(INFO_DBG, "Read Test level 3 fails\n");
3564 }
3565
3566 val64 = readq(&bar0->xgxs_efifo_cfg);
3567 if (val64 != 0x000000001923141EULL) {
3568 fail = 1;
3569 DBG_PRINT(INFO_DBG, "Read Test level 4 fails\n");
3570 }
3571
3572 val64 = 0x5A5A5A5A5A5A5A5AULL;
3573 writeq(val64, &bar0->xmsi_data);
3574 val64 = readq(&bar0->xmsi_data);
3575 if (val64 != 0x5A5A5A5A5A5A5A5AULL) {
3576 fail = 1;
3577 DBG_PRINT(ERR_DBG, "Write Test level 1 fails\n");
3578 }
3579
3580 val64 = 0xA5A5A5A5A5A5A5A5ULL;
3581 writeq(val64, &bar0->xmsi_data);
3582 val64 = readq(&bar0->xmsi_data);
3583 if (val64 != 0xA5A5A5A5A5A5A5A5ULL) {
3584 fail = 1;
3585 DBG_PRINT(ERR_DBG, "Write Test level 2 fails\n");
3586 }
3587
3588 *data = fail;
3589 return 0;
3590 }
3591
3592 /**
3593 * s2io_eeprom_test - to verify that EEprom in the xena can be programmed.
3594 * @sp : private member of the device structure, which is a pointer to the
3595 * s2io_nic structure.
3596 * @data:variable that returns the result of each of the test conducted by
3597 * the driver.
3598 * Description:
3599 * Verify that EEPROM in the xena can be programmed using I2C_CONTROL
3600 * register.
3601 * Return value:
3602 * 0 on success.
3603 */
3604
3605 static int s2io_eeprom_test(nic_t * sp, uint64_t * data)
3606 {
3607 int fail = 0;
3608 u32 ret_data;
3609
3610 /* Test Write Error at offset 0 */
3611 if (!write_eeprom(sp, 0, 0, 3))
3612 fail = 1;
3613
3614 /* Test Write at offset 4f0 */
3615 if (write_eeprom(sp, 0x4F0, 0x01234567, 3))
3616 fail = 1;
3617 if (read_eeprom(sp, 0x4F0, &ret_data))
3618 fail = 1;
3619
3620 if (ret_data != 0x01234567)
3621 fail = 1;
3622
3623 /* Reset the EEPROM data go FFFF */
3624 write_eeprom(sp, 0x4F0, 0xFFFFFFFF, 3);
3625
3626 /* Test Write Request Error at offset 0x7c */
3627 if (!write_eeprom(sp, 0x07C, 0, 3))
3628 fail = 1;
3629
3630 /* Test Write Request at offset 0x7fc */
3631 if (write_eeprom(sp, 0x7FC, 0x01234567, 3))
3632 fail = 1;
3633 if (read_eeprom(sp, 0x7FC, &ret_data))
3634 fail = 1;
3635
3636 if (ret_data != 0x01234567)
3637 fail = 1;
3638
3639 /* Reset the EEPROM data go FFFF */
3640 write_eeprom(sp, 0x7FC, 0xFFFFFFFF, 3);
3641
3642 /* Test Write Error at offset 0x80 */
3643 if (!write_eeprom(sp, 0x080, 0, 3))
3644 fail = 1;
3645
3646 /* Test Write Error at offset 0xfc */
3647 if (!write_eeprom(sp, 0x0FC, 0, 3))
3648 fail = 1;
3649
3650 /* Test Write Error at offset 0x100 */
3651 if (!write_eeprom(sp, 0x100, 0, 3))
3652 fail = 1;
3653
3654 /* Test Write Error at offset 4ec */
3655 if (!write_eeprom(sp, 0x4EC, 0, 3))
3656 fail = 1;
3657
3658 *data = fail;
3659 return 0;
3660 }
3661
3662 /**
3663 * s2io_bist_test - invokes the MemBist test of the card .
3664 * @sp : private member of the device structure, which is a pointer to the
3665 * s2io_nic structure.
3666 * @data:variable that returns the result of each of the test conducted by
3667 * the driver.
3668 * Description:
3669 * This invokes the MemBist test of the card. We give around
3670 * 2 secs time for the Test to complete. If it's still not complete
3671 * within this peiod, we consider that the test failed.
3672 * Return value:
3673 * 0 on success and -1 on failure.
3674 */
3675
3676 static int s2io_bist_test(nic_t * sp, uint64_t * data)
3677 {
3678 u8 bist = 0;
3679 int cnt = 0, ret = -1;
3680
3681 pci_read_config_byte(sp->pdev, PCI_BIST, &bist);
3682 bist |= PCI_BIST_START;
3683 pci_write_config_word(sp->pdev, PCI_BIST, bist);
3684
3685 while (cnt < 20) {
3686 pci_read_config_byte(sp->pdev, PCI_BIST, &bist);
3687 if (!(bist & PCI_BIST_START)) {
3688 *data = (bist & PCI_BIST_CODE_MASK);
3689 ret = 0;
3690 break;
3691 }
3692 msleep(100);
3693 cnt++;
3694 }
3695
3696 return ret;
3697 }
3698
3699 /**
3700 * s2io-link_test - verifies the link state of the nic
3701 * @sp ; private member of the device structure, which is a pointer to the
3702 * s2io_nic structure.
3703 * @data: variable that returns the result of each of the test conducted by
3704 * the driver.
3705 * Description:
3706 * The function verifies the link state of the NIC and updates the input
3707 * argument 'data' appropriately.
3708 * Return value:
3709 * 0 on success.
3710 */
3711
3712 static int s2io_link_test(nic_t * sp, uint64_t * data)
3713 {
3714 XENA_dev_config_t __iomem *bar0 = sp->bar0;
3715 u64 val64;
3716
3717 val64 = readq(&bar0->adapter_status);
3718 if (val64 & ADAPTER_STATUS_RMAC_LOCAL_FAULT)
3719 *data = 1;
3720
3721 return 0;
3722 }
3723
3724 /**
3725 * s2io_rldram_test - offline test for access to the RldRam chip on the NIC
3726 * @sp - private member of the device structure, which is a pointer to the
3727 * s2io_nic structure.
3728 * @data - variable that returns the result of each of the test
3729 * conducted by the driver.
3730 * Description:
3731 * This is one of the offline test that tests the read and write
3732 * access to the RldRam chip on the NIC.
3733 * Return value:
3734 * 0 on success.
3735 */
3736
3737 static int s2io_rldram_test(nic_t * sp, uint64_t * data)
3738 {
3739 XENA_dev_config_t __iomem *bar0 = sp->bar0;
3740 u64 val64;
3741 int cnt, iteration = 0, test_pass = 0;
3742
3743 val64 = readq(&bar0->adapter_control);
3744 val64 &= ~ADAPTER_ECC_EN;
3745 writeq(val64, &bar0->adapter_control);
3746
3747 val64 = readq(&bar0->mc_rldram_test_ctrl);
3748 val64 |= MC_RLDRAM_TEST_MODE;
3749 writeq(val64, &bar0->mc_rldram_test_ctrl);
3750
3751 val64 = readq(&bar0->mc_rldram_mrs);
3752 val64 |= MC_RLDRAM_QUEUE_SIZE_ENABLE;
3753 SPECIAL_REG_WRITE(val64, &bar0->mc_rldram_mrs, UF);
3754
3755 val64 |= MC_RLDRAM_MRS_ENABLE;
3756 SPECIAL_REG_WRITE(val64, &bar0->mc_rldram_mrs, UF);
3757
3758 while (iteration < 2) {
3759 val64 = 0x55555555aaaa0000ULL;
3760 if (iteration == 1) {
3761 val64 ^= 0xFFFFFFFFFFFF0000ULL;
3762 }
3763 writeq(val64, &bar0->mc_rldram_test_d0);
3764
3765 val64 = 0xaaaa5a5555550000ULL;
3766 if (iteration == 1) {
3767 val64 ^= 0xFFFFFFFFFFFF0000ULL;
3768 }
3769 writeq(val64, &bar0->mc_rldram_test_d1);
3770
3771 val64 = 0x55aaaaaaaa5a0000ULL;
3772 if (iteration == 1) {
3773 val64 ^= 0xFFFFFFFFFFFF0000ULL;
3774 }
3775 writeq(val64, &bar0->mc_rldram_test_d2);
3776
3777 val64 = (u64) (0x0000003fffff0000ULL);
3778 writeq(val64, &bar0->mc_rldram_test_add);
3779
3780
3781 val64 = MC_RLDRAM_TEST_MODE;
3782 writeq(val64, &bar0->mc_rldram_test_ctrl);
3783
3784 val64 |=
3785 MC_RLDRAM_TEST_MODE | MC_RLDRAM_TEST_WRITE |
3786 MC_RLDRAM_TEST_GO;
3787 writeq(val64, &bar0->mc_rldram_test_ctrl);
3788
3789 for (cnt = 0; cnt < 5; cnt++) {
3790 val64 = readq(&bar0->mc_rldram_test_ctrl);
3791 if (val64 & MC_RLDRAM_TEST_DONE)
3792 break;
3793 msleep(200);
3794 }
3795
3796 if (cnt == 5)
3797 break;
3798
3799 val64 = MC_RLDRAM_TEST_MODE;
3800 writeq(val64, &bar0->mc_rldram_test_ctrl);
3801
3802 val64 |= MC_RLDRAM_TEST_MODE | MC_RLDRAM_TEST_GO;
3803 writeq(val64, &bar0->mc_rldram_test_ctrl);
3804
3805 for (cnt = 0; cnt < 5; cnt++) {
3806 val64 = readq(&bar0->mc_rldram_test_ctrl);
3807 if (val64 & MC_RLDRAM_TEST_DONE)
3808 break;
3809 msleep(500);
3810 }
3811
3812 if (cnt == 5)
3813 break;
3814
3815 val64 = readq(&bar0->mc_rldram_test_ctrl);
3816 if (val64 & MC_RLDRAM_TEST_PASS)
3817 test_pass = 1;
3818
3819 iteration++;
3820 }
3821
3822 if (!test_pass)
3823 *data = 1;
3824 else
3825 *data = 0;
3826
3827 return 0;
3828 }
3829
3830 /**
3831 * s2io_ethtool_test - conducts 6 tsets to determine the health of card.
3832 * @sp : private member of the device structure, which is a pointer to the
3833 * s2io_nic structure.
3834 * @ethtest : pointer to a ethtool command specific structure that will be
3835 * returned to the user.
3836 * @data : variable that returns the result of each of the test
3837 * conducted by the driver.
3838 * Description:
3839 * This function conducts 6 tests ( 4 offline and 2 online) to determine
3840 * the health of the card.
3841 * Return value:
3842 * void
3843 */
3844
3845 static void s2io_ethtool_test(struct net_device *dev,
3846 struct ethtool_test *ethtest,
3847 uint64_t * data)
3848 {
3849 nic_t *sp = dev->priv;
3850 int orig_state = netif_running(sp->dev);
3851
3852 if (ethtest->flags == ETH_TEST_FL_OFFLINE) {
3853 /* Offline Tests. */
3854 if (orig_state) {
3855 s2io_close(sp->dev);
3856 s2io_set_swapper(sp);
3857 } else
3858 s2io_set_swapper(sp);
3859
3860 if (s2io_register_test(sp, &data[0]))
3861 ethtest->flags |= ETH_TEST_FL_FAILED;
3862
3863 s2io_reset(sp);
3864 s2io_set_swapper(sp);
3865
3866 if (s2io_rldram_test(sp, &data[3]))
3867 ethtest->flags |= ETH_TEST_FL_FAILED;
3868
3869 s2io_reset(sp);
3870 s2io_set_swapper(sp);
3871
3872 if (s2io_eeprom_test(sp, &data[1]))
3873 ethtest->flags |= ETH_TEST_FL_FAILED;
3874
3875 if (s2io_bist_test(sp, &data[4]))
3876 ethtest->flags |= ETH_TEST_FL_FAILED;
3877
3878 if (orig_state)
3879 s2io_open(sp->dev);
3880
3881 data[2] = 0;
3882 } else {
3883 /* Online Tests. */
3884 if (!orig_state) {
3885 DBG_PRINT(ERR_DBG,
3886 "%s: is not up, cannot run test\n",
3887 dev->name);
3888 data[0] = -1;
3889 data[1] = -1;
3890 data[2] = -1;
3891 data[3] = -1;
3892 data[4] = -1;
3893 }
3894
3895 if (s2io_link_test(sp, &data[2]))
3896 ethtest->flags |= ETH_TEST_FL_FAILED;
3897
3898 data[0] = 0;
3899 data[1] = 0;
3900 data[3] = 0;
3901 data[4] = 0;
3902 }
3903 }
3904
3905 static void s2io_get_ethtool_stats(struct net_device *dev,
3906 struct ethtool_stats *estats,
3907 u64 * tmp_stats)
3908 {
3909 int i = 0;
3910 nic_t *sp = dev->priv;
3911 StatInfo_t *stat_info = sp->mac_control.stats_info;
3912
3913 tmp_stats[i++] = le32_to_cpu(stat_info->tmac_frms);
3914 tmp_stats[i++] = le32_to_cpu(stat_info->tmac_data_octets);
3915 tmp_stats[i++] = le64_to_cpu(stat_info->tmac_drop_frms);
3916 tmp_stats[i++] = le32_to_cpu(stat_info->tmac_mcst_frms);
3917 tmp_stats[i++] = le32_to_cpu(stat_info->tmac_bcst_frms);
3918 tmp_stats[i++] = le64_to_cpu(stat_info->tmac_pause_ctrl_frms);
3919 tmp_stats[i++] = le32_to_cpu(stat_info->tmac_any_err_frms);
3920 tmp_stats[i++] = le64_to_cpu(stat_info->tmac_vld_ip_octets);
3921 tmp_stats[i++] = le32_to_cpu(stat_info->tmac_vld_ip);
3922 tmp_stats[i++] = le32_to_cpu(stat_info->tmac_drop_ip);
3923 tmp_stats[i++] = le32_to_cpu(stat_info->tmac_icmp);
3924 tmp_stats[i++] = le32_to_cpu(stat_info->tmac_rst_tcp);
3925 tmp_stats[i++] = le64_to_cpu(stat_info->tmac_tcp);
3926 tmp_stats[i++] = le32_to_cpu(stat_info->tmac_udp);
3927 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_vld_frms);
3928 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_data_octets);
3929 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_fcs_err_frms);
3930 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_drop_frms);
3931 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_vld_mcst_frms);
3932 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_vld_bcst_frms);
3933 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_in_rng_len_err_frms);
3934 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_long_frms);
3935 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_pause_ctrl_frms);
3936 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_discarded_frms);
3937 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_usized_frms);
3938 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_osized_frms);
3939 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_frag_frms);
3940 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_jabber_frms);
3941 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_ip);
3942 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ip_octets);
3943 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_hdr_err_ip);
3944 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_drop_ip);
3945 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_icmp);
3946 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_tcp);
3947 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_udp);
3948 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_err_drp_udp);
3949 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_pause_cnt);
3950 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_accepted_ip);
3951 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_err_tcp);
3952 }
3953
3954 static int s2io_ethtool_get_regs_len(struct net_device *dev)
3955 {
3956 return (XENA_REG_SPACE);
3957 }
3958
3959
3960 static u32 s2io_ethtool_get_rx_csum(struct net_device * dev)
3961 {
3962 nic_t *sp = dev->priv;
3963
3964 return (sp->rx_csum);
3965 }
3966
3967 static int s2io_ethtool_set_rx_csum(struct net_device *dev, u32 data)
3968 {
3969 nic_t *sp = dev->priv;
3970
3971 if (data)
3972 sp->rx_csum = 1;
3973 else
3974 sp->rx_csum = 0;
3975
3976 return 0;
3977 }
3978
3979 static int s2io_get_eeprom_len(struct net_device *dev)
3980 {
3981 return (XENA_EEPROM_SPACE);
3982 }
3983
3984 static int s2io_ethtool_self_test_count(struct net_device *dev)
3985 {
3986 return (S2IO_TEST_LEN);
3987 }
3988
3989 static void s2io_ethtool_get_strings(struct net_device *dev,
3990 u32 stringset, u8 * data)
3991 {
3992 switch (stringset) {
3993 case ETH_SS_TEST:
3994 memcpy(data, s2io_gstrings, S2IO_STRINGS_LEN);
3995 break;
3996 case ETH_SS_STATS:
3997 memcpy(data, &ethtool_stats_keys,
3998 sizeof(ethtool_stats_keys));
3999 }
4000 }
4001
4002 static int s2io_ethtool_get_stats_count(struct net_device *dev)
4003 {
4004 return (S2IO_STAT_LEN);
4005 }
4006
4007 static int s2io_ethtool_op_set_tx_csum(struct net_device *dev, u32 data)
4008 {
4009 if (data)
4010 dev->features |= NETIF_F_IP_CSUM;
4011 else
4012 dev->features &= ~NETIF_F_IP_CSUM;
4013
4014 return 0;
4015 }
4016
4017
4018 static struct ethtool_ops netdev_ethtool_ops = {
4019 .get_settings = s2io_ethtool_gset,
4020 .set_settings = s2io_ethtool_sset,
4021 .get_drvinfo = s2io_ethtool_gdrvinfo,
4022 .get_regs_len = s2io_ethtool_get_regs_len,
4023 .get_regs = s2io_ethtool_gregs,
4024 .get_link = ethtool_op_get_link,
4025 .get_eeprom_len = s2io_get_eeprom_len,
4026 .get_eeprom = s2io_ethtool_geeprom,
4027 .set_eeprom = s2io_ethtool_seeprom,
4028 .get_pauseparam = s2io_ethtool_getpause_data,
4029 .set_pauseparam = s2io_ethtool_setpause_data,
4030 .get_rx_csum = s2io_ethtool_get_rx_csum,
4031 .set_rx_csum = s2io_ethtool_set_rx_csum,
4032 .get_tx_csum = ethtool_op_get_tx_csum,
4033 .set_tx_csum = s2io_ethtool_op_set_tx_csum,
4034 .get_sg = ethtool_op_get_sg,
4035 .set_sg = ethtool_op_set_sg,
4036 #ifdef NETIF_F_TSO
4037 .get_tso = ethtool_op_get_tso,
4038 .set_tso = ethtool_op_set_tso,
4039 #endif
4040 .self_test_count = s2io_ethtool_self_test_count,
4041 .self_test = s2io_ethtool_test,
4042 .get_strings = s2io_ethtool_get_strings,
4043 .phys_id = s2io_ethtool_idnic,
4044 .get_stats_count = s2io_ethtool_get_stats_count,
4045 .get_ethtool_stats = s2io_get_ethtool_stats
4046 };
4047
4048 /**
4049 * s2io_ioctl - Entry point for the Ioctl
4050 * @dev : Device pointer.
4051 * @ifr : An IOCTL specefic structure, that can contain a pointer to
4052 * a proprietary structure used to pass information to the driver.
4053 * @cmd : This is used to distinguish between the different commands that
4054 * can be passed to the IOCTL functions.
4055 * Description:
4056 * This function has support for ethtool, adding multiple MAC addresses on
4057 * the NIC and some DBG commands for the util tool.
4058 * Return value:
4059 * Currently the IOCTL supports no operations, hence by default this
4060 * function returns OP NOT SUPPORTED value.
4061 */
4062
4063 static int s2io_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
4064 {
4065 return -EOPNOTSUPP;
4066 }
4067
4068 /**
4069 * s2io_change_mtu - entry point to change MTU size for the device.
4070 * @dev : device pointer.
4071 * @new_mtu : the new MTU size for the device.
4072 * Description: A driver entry point to change MTU size for the device.
4073 * Before changing the MTU the device must be stopped.
4074 * Return value:
4075 * 0 on success and an appropriate (-)ve integer as defined in errno.h
4076 * file on failure.
4077 */
4078
4079 static int s2io_change_mtu(struct net_device *dev, int new_mtu)
4080 {
4081 nic_t *sp = dev->priv;
4082 XENA_dev_config_t __iomem *bar0 = sp->bar0;
4083 register u64 val64;
4084
4085 if (netif_running(dev)) {
4086 DBG_PRINT(ERR_DBG, "%s: Must be stopped to ", dev->name);
4087 DBG_PRINT(ERR_DBG, "change its MTU \n");
4088 return -EBUSY;
4089 }
4090
4091 if ((new_mtu < MIN_MTU) || (new_mtu > S2IO_JUMBO_SIZE)) {
4092 DBG_PRINT(ERR_DBG, "%s: MTU size is invalid.\n",
4093 dev->name);
4094 return -EPERM;
4095 }
4096
4097 /* Set the new MTU into the PYLD register of the NIC */
4098 val64 = new_mtu;
4099 writeq(vBIT(val64, 2, 14), &bar0->rmac_max_pyld_len);
4100
4101 dev->mtu = new_mtu;
4102
4103 return 0;
4104 }
4105
4106 /**
4107 * s2io_tasklet - Bottom half of the ISR.
4108 * @dev_adr : address of the device structure in dma_addr_t format.
4109 * Description:
4110 * This is the tasklet or the bottom half of the ISR. This is
4111 * an extension of the ISR which is scheduled by the scheduler to be run
4112 * when the load on the CPU is low. All low priority tasks of the ISR can
4113 * be pushed into the tasklet. For now the tasklet is used only to
4114 * replenish the Rx buffers in the Rx buffer descriptors.
4115 * Return value:
4116 * void.
4117 */
4118
4119 static void s2io_tasklet(unsigned long dev_addr)
4120 {
4121 struct net_device *dev = (struct net_device *) dev_addr;
4122 nic_t *sp = dev->priv;
4123 int i, ret;
4124 mac_info_t *mac_control;
4125 struct config_param *config;
4126
4127 mac_control = &sp->mac_control;
4128 config = &sp->config;
4129
4130 if (!TASKLET_IN_USE) {
4131 for (i = 0; i < config->rx_ring_num; i++) {
4132 ret = fill_rx_buffers(sp, i);
4133 if (ret == -ENOMEM) {
4134 DBG_PRINT(ERR_DBG, "%s: Out of ",
4135 dev->name);
4136 DBG_PRINT(ERR_DBG, "memory in tasklet\n");
4137 break;
4138 } else if (ret == -EFILL) {
4139 DBG_PRINT(ERR_DBG,
4140 "%s: Rx Ring %d is full\n",
4141 dev->name, i);
4142 break;
4143 }
4144 }
4145 clear_bit(0, (&sp->tasklet_status));
4146 }
4147 }
4148
4149 /**
4150 * s2io_set_link - Set the LInk status
4151 * @data: long pointer to device private structue
4152 * Description: Sets the link status for the adapter
4153 */
4154
4155 static void s2io_set_link(unsigned long data)
4156 {
4157 nic_t *nic = (nic_t *) data;
4158 struct net_device *dev = nic->dev;
4159 XENA_dev_config_t __iomem *bar0 = nic->bar0;
4160 register u64 val64;
4161 u16 subid;
4162
4163 if (test_and_set_bit(0, &(nic->link_state))) {
4164 /* The card is being reset, no point doing anything */
4165 return;
4166 }
4167
4168 subid = nic->pdev->subsystem_device;
4169 /*
4170 * Allow a small delay for the NICs self initiated
4171 * cleanup to complete.
4172 */
4173 msleep(100);
4174
4175 val64 = readq(&bar0->adapter_status);
4176 if (verify_xena_quiescence(val64, nic->device_enabled_once)) {
4177 if (LINK_IS_UP(val64)) {
4178 val64 = readq(&bar0->adapter_control);
4179 val64 |= ADAPTER_CNTL_EN;
4180 writeq(val64, &bar0->adapter_control);
4181 if (CARDS_WITH_FAULTY_LINK_INDICATORS(subid)) {
4182 val64 = readq(&bar0->gpio_control);
4183 val64 |= GPIO_CTRL_GPIO_0;
4184 writeq(val64, &bar0->gpio_control);
4185 val64 = readq(&bar0->gpio_control);
4186 } else {
4187 val64 |= ADAPTER_LED_ON;
4188 writeq(val64, &bar0->adapter_control);
4189 }
4190 val64 = readq(&bar0->adapter_status);
4191 if (!LINK_IS_UP(val64)) {
4192 DBG_PRINT(ERR_DBG, "%s:", dev->name);
4193 DBG_PRINT(ERR_DBG, " Link down");
4194 DBG_PRINT(ERR_DBG, "after ");
4195 DBG_PRINT(ERR_DBG, "enabling ");
4196 DBG_PRINT(ERR_DBG, "device \n");
4197 }
4198 if (nic->device_enabled_once == FALSE) {
4199 nic->device_enabled_once = TRUE;
4200 }
4201 s2io_link(nic, LINK_UP);
4202 } else {
4203 if (CARDS_WITH_FAULTY_LINK_INDICATORS(subid)) {
4204 val64 = readq(&bar0->gpio_control);
4205 val64 &= ~GPIO_CTRL_GPIO_0;
4206 writeq(val64, &bar0->gpio_control);
4207 val64 = readq(&bar0->gpio_control);
4208 }
4209 s2io_link(nic, LINK_DOWN);
4210 }
4211 } else { /* NIC is not Quiescent. */
4212 DBG_PRINT(ERR_DBG, "%s: Error: ", dev->name);
4213 DBG_PRINT(ERR_DBG, "device is not Quiescent\n");
4214 netif_stop_queue(dev);
4215 }
4216 clear_bit(0, &(nic->link_state));
4217 }
4218
4219 static void s2io_card_down(nic_t * sp)
4220 {
4221 int cnt = 0;
4222 XENA_dev_config_t __iomem *bar0 = sp->bar0;
4223 unsigned long flags;
4224 register u64 val64 = 0;
4225
4226 /* If s2io_set_link task is executing, wait till it completes. */
4227 while (test_and_set_bit(0, &(sp->link_state)))
4228 msleep(50);
4229 atomic_set(&sp->card_state, CARD_DOWN);
4230
4231 /* disable Tx and Rx traffic on the NIC */
4232 stop_nic(sp);
4233
4234 /* Kill tasklet. */
4235 tasklet_kill(&sp->task);
4236
4237 /* Check if the device is Quiescent and then Reset the NIC */
4238 do {
4239 val64 = readq(&bar0->adapter_status);
4240 if (verify_xena_quiescence(val64, sp->device_enabled_once)) {
4241 break;
4242 }
4243
4244 msleep(50);
4245 cnt++;
4246 if (cnt == 10) {
4247 DBG_PRINT(ERR_DBG,
4248 "s2io_close:Device not Quiescent ");
4249 DBG_PRINT(ERR_DBG, "adaper status reads 0x%llx\n",
4250 (unsigned long long) val64);
4251 break;
4252 }
4253 } while (1);
4254 spin_lock_irqsave(&sp->tx_lock, flags);
4255 s2io_reset(sp);
4256
4257 /* Free all unused Tx and Rx buffers */
4258 free_tx_buffers(sp);
4259 free_rx_buffers(sp);
4260
4261 spin_unlock_irqrestore(&sp->tx_lock, flags);
4262 clear_bit(0, &(sp->link_state));
4263 }
4264
4265 static int s2io_card_up(nic_t * sp)
4266 {
4267 int i, ret;
4268 mac_info_t *mac_control;
4269 struct config_param *config;
4270 struct net_device *dev = (struct net_device *) sp->dev;
4271
4272 /* Initialize the H/W I/O registers */
4273 if (init_nic(sp) != 0) {
4274 DBG_PRINT(ERR_DBG, "%s: H/W initialization failed\n",
4275 dev->name);
4276 return -ENODEV;
4277 }
4278
4279 /*
4280 * Initializing the Rx buffers. For now we are considering only 1
4281 * Rx ring and initializing buffers into 30 Rx blocks
4282 */
4283 mac_control = &sp->mac_control;
4284 config = &sp->config;
4285
4286 for (i = 0; i < config->rx_ring_num; i++) {
4287 if ((ret = fill_rx_buffers(sp, i))) {
4288 DBG_PRINT(ERR_DBG, "%s: Out of memory in Open\n",
4289 dev->name);
4290 s2io_reset(sp);
4291 free_rx_buffers(sp);
4292 return -ENOMEM;
4293 }
4294 DBG_PRINT(INFO_DBG, "Buf in ring:%d is %d:\n", i,
4295 atomic_read(&sp->rx_bufs_left[i]));
4296 }
4297
4298 /* Setting its receive mode */
4299 s2io_set_multicast(dev);
4300
4301 /* Enable tasklet for the device */
4302 tasklet_init(&sp->task, s2io_tasklet, (unsigned long) dev);
4303
4304 /* Enable Rx Traffic and interrupts on the NIC */
4305 if (start_nic(sp)) {
4306 DBG_PRINT(ERR_DBG, "%s: Starting NIC failed\n", dev->name);
4307 tasklet_kill(&sp->task);
4308 s2io_reset(sp);
4309 free_irq(dev->irq, dev);
4310 free_rx_buffers(sp);
4311 return -ENODEV;
4312 }
4313
4314 atomic_set(&sp->card_state, CARD_UP);
4315 return 0;
4316 }
4317
4318 /**
4319 * s2io_restart_nic - Resets the NIC.
4320 * @data : long pointer to the device private structure
4321 * Description:
4322 * This function is scheduled to be run by the s2io_tx_watchdog
4323 * function after 0.5 secs to reset the NIC. The idea is to reduce
4324 * the run time of the watch dog routine which is run holding a
4325 * spin lock.
4326 */
4327
4328 static void s2io_restart_nic(unsigned long data)
4329 {
4330 struct net_device *dev = (struct net_device *) data;
4331 nic_t *sp = dev->priv;
4332
4333 s2io_card_down(sp);
4334 if (s2io_card_up(sp)) {
4335 DBG_PRINT(ERR_DBG, "%s: Device bring up failed\n",
4336 dev->name);
4337 }
4338 netif_wake_queue(dev);
4339 DBG_PRINT(ERR_DBG, "%s: was reset by Tx watchdog timer\n",
4340 dev->name);
4341 }
4342
4343 /**
4344 * s2io_tx_watchdog - Watchdog for transmit side.
4345 * @dev : Pointer to net device structure
4346 * Description:
4347 * This function is triggered if the Tx Queue is stopped
4348 * for a pre-defined amount of time when the Interface is still up.
4349 * If the Interface is jammed in such a situation, the hardware is
4350 * reset (by s2io_close) and restarted again (by s2io_open) to
4351 * overcome any problem that might have been caused in the hardware.
4352 * Return value:
4353 * void
4354 */
4355
4356 static void s2io_tx_watchdog(struct net_device *dev)
4357 {
4358 nic_t *sp = dev->priv;
4359
4360 if (netif_carrier_ok(dev)) {
4361 schedule_work(&sp->rst_timer_task);
4362 }
4363 }
4364
4365 /**
4366 * rx_osm_handler - To perform some OS related operations on SKB.
4367 * @sp: private member of the device structure,pointer to s2io_nic structure.
4368 * @skb : the socket buffer pointer.
4369 * @len : length of the packet
4370 * @cksum : FCS checksum of the frame.
4371 * @ring_no : the ring from which this RxD was extracted.
4372 * Description:
4373 * This function is called by the Tx interrupt serivce routine to perform
4374 * some OS related operations on the SKB before passing it to the upper
4375 * layers. It mainly checks if the checksum is OK, if so adds it to the
4376 * SKBs cksum variable, increments the Rx packet count and passes the SKB
4377 * to the upper layer. If the checksum is wrong, it increments the Rx
4378 * packet error count, frees the SKB and returns error.
4379 * Return value:
4380 * SUCCESS on success and -1 on failure.
4381 */
4382 #ifndef CONFIG_2BUFF_MODE
4383 static int rx_osm_handler(nic_t * sp, u16 len, RxD_t * rxdp, int ring_no)
4384 #else
4385 static int rx_osm_handler(nic_t * sp, RxD_t * rxdp, int ring_no,
4386 buffAdd_t * ba)
4387 #endif
4388 {
4389 struct net_device *dev = (struct net_device *) sp->dev;
4390 struct sk_buff *skb =
4391 (struct sk_buff *) ((unsigned long) rxdp->Host_Control);
4392 u16 l3_csum, l4_csum;
4393 #ifdef CONFIG_2BUFF_MODE
4394 int buf0_len, buf2_len;
4395 unsigned char *buff;
4396 #endif
4397
4398 l3_csum = RXD_GET_L3_CKSUM(rxdp->Control_1);
4399 if ((rxdp->Control_1 & TCP_OR_UDP_FRAME) && (sp->rx_csum)) {
4400 l4_csum = RXD_GET_L4_CKSUM(rxdp->Control_1);
4401 if ((l3_csum == L3_CKSUM_OK) && (l4_csum == L4_CKSUM_OK)) {
4402 /*
4403 * NIC verifies if the Checksum of the received
4404 * frame is Ok or not and accordingly returns
4405 * a flag in the RxD.
4406 */
4407 skb->ip_summed = CHECKSUM_UNNECESSARY;
4408 } else {
4409 /*
4410 * Packet with erroneous checksum, let the
4411 * upper layers deal with it.
4412 */
4413 skb->ip_summed = CHECKSUM_NONE;
4414 }
4415 } else {
4416 skb->ip_summed = CHECKSUM_NONE;
4417 }
4418
4419 if (rxdp->Control_1 & RXD_T_CODE) {
4420 unsigned long long err = rxdp->Control_1 & RXD_T_CODE;
4421 DBG_PRINT(ERR_DBG, "%s: Rx error Value: 0x%llx\n",
4422 dev->name, err);
4423 }
4424 #ifdef CONFIG_2BUFF_MODE
4425 buf0_len = RXD_GET_BUFFER0_SIZE(rxdp->Control_2);
4426 buf2_len = RXD_GET_BUFFER2_SIZE(rxdp->Control_2);
4427 #endif
4428
4429 skb->dev = dev;
4430 #ifndef CONFIG_2BUFF_MODE
4431 skb_put(skb, len);
4432 skb->protocol = eth_type_trans(skb, dev);
4433 #else
4434 buff = skb_push(skb, buf0_len);
4435 memcpy(buff, ba->ba_0, buf0_len);
4436 skb_put(skb, buf2_len);
4437 skb->protocol = eth_type_trans(skb, dev);
4438 #endif
4439
4440 #ifdef CONFIG_S2IO_NAPI
4441 netif_receive_skb(skb);
4442 #else
4443 netif_rx(skb);
4444 #endif
4445
4446 dev->last_rx = jiffies;
4447 sp->rx_pkt_count++;
4448 sp->stats.rx_packets++;
4449 #ifndef CONFIG_2BUFF_MODE
4450 sp->stats.rx_bytes += len;
4451 #else
4452 sp->stats.rx_bytes += buf0_len + buf2_len;
4453 #endif
4454
4455 atomic_dec(&sp->rx_bufs_left[ring_no]);
4456 rxdp->Host_Control = 0;
4457 return SUCCESS;
4458 }
4459
4460 /**
4461 * s2io_link - stops/starts the Tx queue.
4462 * @sp : private member of the device structure, which is a pointer to the
4463 * s2io_nic structure.
4464 * @link : inidicates whether link is UP/DOWN.
4465 * Description:
4466 * This function stops/starts the Tx queue depending on whether the link
4467 * status of the NIC is is down or up. This is called by the Alarm
4468 * interrupt handler whenever a link change interrupt comes up.
4469 * Return value:
4470 * void.
4471 */
4472
4473 static void s2io_link(nic_t * sp, int link)
4474 {
4475 struct net_device *dev = (struct net_device *) sp->dev;
4476
4477 if (link != sp->last_link_state) {
4478 if (link == LINK_DOWN) {
4479 DBG_PRINT(ERR_DBG, "%s: Link down\n", dev->name);
4480 netif_carrier_off(dev);
4481 } else {
4482 DBG_PRINT(ERR_DBG, "%s: Link Up\n", dev->name);
4483 netif_carrier_on(dev);
4484 }
4485 }
4486 sp->last_link_state = link;
4487 }
4488
4489 /**
4490 * s2io_init_pci -Initialization of PCI and PCI-X configuration registers .
4491 * @sp : private member of the device structure, which is a pointer to the
4492 * s2io_nic structure.
4493 * Description:
4494 * This function initializes a few of the PCI and PCI-X configuration registers
4495 * with recommended values.
4496 * Return value:
4497 * void
4498 */
4499
4500 static void s2io_init_pci(nic_t * sp)
4501 {
4502 u16 pci_cmd = 0;
4503
4504 /* Enable Data Parity Error Recovery in PCI-X command register. */
4505 pci_read_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
4506 &(sp->pcix_cmd));
4507 pci_write_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
4508 (sp->pcix_cmd | 1));
4509 pci_read_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
4510 &(sp->pcix_cmd));
4511
4512 /* Set the PErr Response bit in PCI command register. */
4513 pci_read_config_word(sp->pdev, PCI_COMMAND, &pci_cmd);
4514 pci_write_config_word(sp->pdev, PCI_COMMAND,
4515 (pci_cmd | PCI_COMMAND_PARITY));
4516 pci_read_config_word(sp->pdev, PCI_COMMAND, &pci_cmd);
4517
4518 /* Set MMRB count to 1024 in PCI-X Command register. */
4519 sp->pcix_cmd &= 0xFFF3;
4520 pci_write_config_word(sp->pdev, PCIX_COMMAND_REGISTER, (sp->pcix_cmd | (0x1 << 2))); /* MMRBC 1K */
4521 pci_read_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
4522 &(sp->pcix_cmd));
4523
4524 /* Setting Maximum outstanding splits based on system type. */
4525 sp->pcix_cmd &= 0xFF8F;
4526
4527 sp->pcix_cmd |= XENA_MAX_OUTSTANDING_SPLITS(0x1); /* 2 splits. */
4528 pci_write_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
4529 sp->pcix_cmd);
4530 pci_read_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
4531 &(sp->pcix_cmd));
4532 /* Forcibly disabling relaxed ordering capability of the card. */
4533 sp->pcix_cmd &= 0xfffd;
4534 pci_write_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
4535 sp->pcix_cmd);
4536 pci_read_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
4537 &(sp->pcix_cmd));
4538 }
4539
4540 MODULE_AUTHOR("Raghavendra Koushik <raghavendra.koushik@neterion.com>");
4541 MODULE_LICENSE("GPL");
4542 module_param(tx_fifo_num, int, 0);
4543 module_param_array(tx_fifo_len, int, NULL, 0);
4544 module_param(rx_ring_num, int, 0);
4545 module_param_array(rx_ring_sz, int, NULL, 0);
4546 module_param(Stats_refresh_time, int, 0);
4547 module_param(rmac_pause_time, int, 0);
4548 module_param(mc_pause_threshold_q0q3, int, 0);
4549 module_param(mc_pause_threshold_q4q7, int, 0);
4550 module_param(shared_splits, int, 0);
4551 module_param(tmac_util_period, int, 0);
4552 module_param(rmac_util_period, int, 0);
4553 #ifndef CONFIG_S2IO_NAPI
4554 module_param(indicate_max_pkts, int, 0);
4555 #endif
4556 /**
4557 * s2io_init_nic - Initialization of the adapter .
4558 * @pdev : structure containing the PCI related information of the device.
4559 * @pre: List of PCI devices supported by the driver listed in s2io_tbl.
4560 * Description:
4561 * The function initializes an adapter identified by the pci_dec structure.
4562 * All OS related initialization including memory and device structure and
4563 * initlaization of the device private variable is done. Also the swapper
4564 * control register is initialized to enable read and write into the I/O
4565 * registers of the device.
4566 * Return value:
4567 * returns 0 on success and negative on failure.
4568 */
4569
4570 static int __devinit
4571 s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
4572 {
4573 nic_t *sp;
4574 struct net_device *dev;
4575 char *dev_name = "S2IO 10GE NIC";
4576 int i, j, ret;
4577 int dma_flag = FALSE;
4578 u32 mac_up, mac_down;
4579 u64 val64 = 0, tmp64 = 0;
4580 XENA_dev_config_t __iomem *bar0 = NULL;
4581 u16 subid;
4582 mac_info_t *mac_control;
4583 struct config_param *config;
4584
4585
4586 DBG_PRINT(ERR_DBG, "Loading S2IO driver with %s\n",
4587 s2io_driver_version);
4588
4589 if ((ret = pci_enable_device(pdev))) {
4590 DBG_PRINT(ERR_DBG,
4591 "s2io_init_nic: pci_enable_device failed\n");
4592 return ret;
4593 }
4594
4595 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
4596 DBG_PRINT(INIT_DBG, "s2io_init_nic: Using 64bit DMA\n");
4597 dma_flag = TRUE;
4598
4599 if (pci_set_consistent_dma_mask
4600 (pdev, DMA_64BIT_MASK)) {
4601 DBG_PRINT(ERR_DBG,
4602 "Unable to obtain 64bit DMA for \
4603 consistent allocations\n");
4604 pci_disable_device(pdev);
4605 return -ENOMEM;
4606 }
4607 } else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
4608 DBG_PRINT(INIT_DBG, "s2io_init_nic: Using 32bit DMA\n");
4609 } else {
4610 pci_disable_device(pdev);
4611 return -ENOMEM;
4612 }
4613
4614 if (pci_request_regions(pdev, s2io_driver_name)) {
4615 DBG_PRINT(ERR_DBG, "Request Regions failed\n"),
4616 pci_disable_device(pdev);
4617 return -ENODEV;
4618 }
4619
4620 dev = alloc_etherdev(sizeof(nic_t));
4621 if (dev == NULL) {
4622 DBG_PRINT(ERR_DBG, "Device allocation failed\n");
4623 pci_disable_device(pdev);
4624 pci_release_regions(pdev);
4625 return -ENODEV;
4626 }
4627
4628 pci_set_master(pdev);
4629 pci_set_drvdata(pdev, dev);
4630 SET_MODULE_OWNER(dev);
4631 SET_NETDEV_DEV(dev, &pdev->dev);
4632
4633 /* Private member variable initialized to s2io NIC structure */
4634 sp = dev->priv;
4635 memset(sp, 0, sizeof(nic_t));
4636 sp->dev = dev;
4637 sp->pdev = pdev;
4638 sp->vendor_id = pdev->vendor;
4639 sp->device_id = pdev->device;
4640 sp->high_dma_flag = dma_flag;
4641 sp->irq = pdev->irq;
4642 sp->device_enabled_once = FALSE;
4643 strcpy(sp->name, dev_name);
4644
4645 /* Initialize some PCI/PCI-X fields of the NIC. */
4646 s2io_init_pci(sp);
4647
4648 /*
4649 * Setting the device configuration parameters.
4650 * Most of these parameters can be specified by the user during
4651 * module insertion as they are module loadable parameters. If
4652 * these parameters are not not specified during load time, they
4653 * are initialized with default values.
4654 */
4655 mac_control = &sp->mac_control;
4656 config = &sp->config;
4657
4658 /* Tx side parameters. */
4659 tx_fifo_len[0] = DEFAULT_FIFO_LEN; /* Default value. */
4660 config->tx_fifo_num = tx_fifo_num;
4661 for (i = 0; i < MAX_TX_FIFOS; i++) {
4662 config->tx_cfg[i].fifo_len = tx_fifo_len[i];
4663 config->tx_cfg[i].fifo_priority = i;
4664 }
4665
4666 config->tx_intr_type = TXD_INT_TYPE_UTILZ;
4667 for (i = 0; i < config->tx_fifo_num; i++) {
4668 config->tx_cfg[i].f_no_snoop =
4669 (NO_SNOOP_TXD | NO_SNOOP_TXD_BUFFER);
4670 if (config->tx_cfg[i].fifo_len < 65) {
4671 config->tx_intr_type = TXD_INT_TYPE_PER_LIST;
4672 break;
4673 }
4674 }
4675 config->max_txds = MAX_SKB_FRAGS;
4676
4677 /* Rx side parameters. */
4678 rx_ring_sz[0] = SMALL_BLK_CNT; /* Default value. */
4679 config->rx_ring_num = rx_ring_num;
4680 for (i = 0; i < MAX_RX_RINGS; i++) {
4681 config->rx_cfg[i].num_rxd = rx_ring_sz[i] *
4682 (MAX_RXDS_PER_BLOCK + 1);
4683 config->rx_cfg[i].ring_priority = i;
4684 }
4685
4686 for (i = 0; i < rx_ring_num; i++) {
4687 config->rx_cfg[i].ring_org = RING_ORG_BUFF1;
4688 config->rx_cfg[i].f_no_snoop =
4689 (NO_SNOOP_RXD | NO_SNOOP_RXD_BUFFER);
4690 }
4691
4692 /* Setting Mac Control parameters */
4693 mac_control->rmac_pause_time = rmac_pause_time;
4694 mac_control->mc_pause_threshold_q0q3 = mc_pause_threshold_q0q3;
4695 mac_control->mc_pause_threshold_q4q7 = mc_pause_threshold_q4q7;
4696
4697
4698 /* Initialize Ring buffer parameters. */
4699 for (i = 0; i < config->rx_ring_num; i++)
4700 atomic_set(&sp->rx_bufs_left[i], 0);
4701
4702 /* initialize the shared memory used by the NIC and the host */
4703 if (init_shared_mem(sp)) {
4704 DBG_PRINT(ERR_DBG, "%s: Memory allocation failed\n",
4705 dev->name);
4706 ret = -ENOMEM;
4707 goto mem_alloc_failed;
4708 }
4709
4710 sp->bar0 = ioremap(pci_resource_start(pdev, 0),
4711 pci_resource_len(pdev, 0));
4712 if (!sp->bar0) {
4713 DBG_PRINT(ERR_DBG, "%s: S2IO: cannot remap io mem1\n",
4714 dev->name);
4715 ret = -ENOMEM;
4716 goto bar0_remap_failed;
4717 }
4718
4719 sp->bar1 = ioremap(pci_resource_start(pdev, 2),
4720 pci_resource_len(pdev, 2));
4721 if (!sp->bar1) {
4722 DBG_PRINT(ERR_DBG, "%s: S2IO: cannot remap io mem2\n",
4723 dev->name);
4724 ret = -ENOMEM;
4725 goto bar1_remap_failed;
4726 }
4727
4728 dev->irq = pdev->irq;
4729 dev->base_addr = (unsigned long) sp->bar0;
4730
4731 /* Initializing the BAR1 address as the start of the FIFO pointer. */
4732 for (j = 0; j < MAX_TX_FIFOS; j++) {
4733 mac_control->tx_FIFO_start[j] = (TxFIFO_element_t __iomem *)
4734 (sp->bar1 + (j * 0x00020000));
4735 }
4736
4737 /* Driver entry points */
4738 dev->open = &s2io_open;
4739 dev->stop = &s2io_close;
4740 dev->hard_start_xmit = &s2io_xmit;
4741 dev->get_stats = &s2io_get_stats;
4742 dev->set_multicast_list = &s2io_set_multicast;
4743 dev->do_ioctl = &s2io_ioctl;
4744 dev->change_mtu = &s2io_change_mtu;
4745 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
4746 /*
4747 * will use eth_mac_addr() for dev->set_mac_address
4748 * mac address will be set every time dev->open() is called
4749 */
4750 #ifdef CONFIG_S2IO_NAPI
4751 dev->poll = s2io_poll;
4752 dev->weight = 90;
4753 #endif
4754
4755 dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
4756 if (sp->high_dma_flag == TRUE)
4757 dev->features |= NETIF_F_HIGHDMA;
4758 #ifdef NETIF_F_TSO
4759 dev->features |= NETIF_F_TSO;
4760 #endif
4761
4762 dev->tx_timeout = &s2io_tx_watchdog;
4763 dev->watchdog_timeo = WATCH_DOG_TIMEOUT;
4764 INIT_WORK(&sp->rst_timer_task,
4765 (void (*)(void *)) s2io_restart_nic, dev);
4766 INIT_WORK(&sp->set_link_task,
4767 (void (*)(void *)) s2io_set_link, sp);
4768
4769 pci_save_state(sp->pdev);
4770
4771 /* Setting swapper control on the NIC, for proper reset operation */
4772 if (s2io_set_swapper(sp)) {
4773 DBG_PRINT(ERR_DBG, "%s:swapper settings are wrong\n",
4774 dev->name);
4775 ret = -EAGAIN;
4776 goto set_swap_failed;
4777 }
4778
4779 /* Fix for all "FFs" MAC address problems observed on Alpha platforms */
4780 fix_mac_address(sp);
4781 s2io_reset(sp);
4782
4783 /*
4784 * Setting swapper control on the NIC, so the MAC address can be read.
4785 */
4786 if (s2io_set_swapper(sp)) {
4787 DBG_PRINT(ERR_DBG,
4788 "%s: S2IO: swapper settings are wrong\n",
4789 dev->name);
4790 ret = -EAGAIN;
4791 goto set_swap_failed;
4792 }
4793
4794 /*
4795 * MAC address initialization.
4796 * For now only one mac address will be read and used.
4797 */
4798 bar0 = sp->bar0;
4799 val64 = RMAC_ADDR_CMD_MEM_RD | RMAC_ADDR_CMD_MEM_STROBE_NEW_CMD |
4800 RMAC_ADDR_CMD_MEM_OFFSET(0 + MAC_MAC_ADDR_START_OFFSET);
4801 writeq(val64, &bar0->rmac_addr_cmd_mem);
4802 wait_for_cmd_complete(sp);
4803
4804 tmp64 = readq(&bar0->rmac_addr_data0_mem);
4805 mac_down = (u32) tmp64;
4806 mac_up = (u32) (tmp64 >> 32);
4807
4808 memset(sp->def_mac_addr[0].mac_addr, 0, sizeof(ETH_ALEN));
4809
4810 sp->def_mac_addr[0].mac_addr[3] = (u8) (mac_up);
4811 sp->def_mac_addr[0].mac_addr[2] = (u8) (mac_up >> 8);
4812 sp->def_mac_addr[0].mac_addr[1] = (u8) (mac_up >> 16);
4813 sp->def_mac_addr[0].mac_addr[0] = (u8) (mac_up >> 24);
4814 sp->def_mac_addr[0].mac_addr[5] = (u8) (mac_down >> 16);
4815 sp->def_mac_addr[0].mac_addr[4] = (u8) (mac_down >> 24);
4816
4817 DBG_PRINT(INIT_DBG,
4818 "DEFAULT MAC ADDR:0x%02x-%02x-%02x-%02x-%02x-%02x\n",
4819 sp->def_mac_addr[0].mac_addr[0],
4820 sp->def_mac_addr[0].mac_addr[1],
4821 sp->def_mac_addr[0].mac_addr[2],
4822 sp->def_mac_addr[0].mac_addr[3],
4823 sp->def_mac_addr[0].mac_addr[4],
4824 sp->def_mac_addr[0].mac_addr[5]);
4825
4826 /* Set the factory defined MAC address initially */
4827 dev->addr_len = ETH_ALEN;
4828 memcpy(dev->dev_addr, sp->def_mac_addr, ETH_ALEN);
4829
4830 /*
4831 * Initialize the tasklet status and link state flags
4832 * and the card statte parameter
4833 */
4834 atomic_set(&(sp->card_state), 0);
4835 sp->tasklet_status = 0;
4836 sp->link_state = 0;
4837
4838
4839 /* Initialize spinlocks */
4840 spin_lock_init(&sp->tx_lock);
4841 #ifndef CONFIG_S2IO_NAPI
4842 spin_lock_init(&sp->put_lock);
4843 #endif
4844
4845 /*
4846 * SXE-002: Configure link and activity LED to init state
4847 * on driver load.
4848 */
4849 subid = sp->pdev->subsystem_device;
4850 if ((subid & 0xFF) >= 0x07) {
4851 val64 = readq(&bar0->gpio_control);
4852 val64 |= 0x0000800000000000ULL;
4853 writeq(val64, &bar0->gpio_control);
4854 val64 = 0x0411040400000000ULL;
4855 writeq(val64, (void __iomem *) bar0 + 0x2700);
4856 val64 = readq(&bar0->gpio_control);
4857 }
4858
4859 sp->rx_csum = 1; /* Rx chksum verify enabled by default */
4860
4861 if (register_netdev(dev)) {
4862 DBG_PRINT(ERR_DBG, "Device registration failed\n");
4863 ret = -ENODEV;
4864 goto register_failed;
4865 }
4866
4867 /*
4868 * Make Link state as off at this point, when the Link change
4869 * interrupt comes the state will be automatically changed to
4870 * the right state.
4871 */
4872 netif_carrier_off(dev);
4873 sp->last_link_state = LINK_DOWN;
4874
4875 return 0;
4876
4877 register_failed:
4878 set_swap_failed:
4879 iounmap(sp->bar1);
4880 bar1_remap_failed:
4881 iounmap(sp->bar0);
4882 bar0_remap_failed:
4883 mem_alloc_failed:
4884 free_shared_mem(sp);
4885 pci_disable_device(pdev);
4886 pci_release_regions(pdev);
4887 pci_set_drvdata(pdev, NULL);
4888 free_netdev(dev);
4889
4890 return ret;
4891 }
4892
4893 /**
4894 * s2io_rem_nic - Free the PCI device
4895 * @pdev: structure containing the PCI related information of the device.
4896 * Description: This function is called by the Pci subsystem to release a
4897 * PCI device and free up all resource held up by the device. This could
4898 * be in response to a Hot plug event or when the driver is to be removed
4899 * from memory.
4900 */
4901
4902 static void __devexit s2io_rem_nic(struct pci_dev *pdev)
4903 {
4904 struct net_device *dev =
4905 (struct net_device *) pci_get_drvdata(pdev);
4906 nic_t *sp;
4907
4908 if (dev == NULL) {
4909 DBG_PRINT(ERR_DBG, "Driver Data is NULL!!\n");
4910 return;
4911 }
4912
4913 sp = dev->priv;
4914 unregister_netdev(dev);
4915
4916 free_shared_mem(sp);
4917 iounmap(sp->bar0);
4918 iounmap(sp->bar1);
4919 pci_disable_device(pdev);
4920 pci_release_regions(pdev);
4921 pci_set_drvdata(pdev, NULL);
4922
4923 free_netdev(dev);
4924 }
4925
4926 /**
4927 * s2io_starter - Entry point for the driver
4928 * Description: This function is the entry point for the driver. It verifies
4929 * the module loadable parameters and initializes PCI configuration space.
4930 */
4931
4932 int __init s2io_starter(void)
4933 {
4934 return pci_module_init(&s2io_driver);
4935 }
4936
4937 /**
4938 * s2io_closer - Cleanup routine for the driver
4939 * Description: This function is the cleanup routine for the driver. It unregist * ers the driver.
4940 */
4941
4942 static void s2io_closer(void)
4943 {
4944 pci_unregister_driver(&s2io_driver);
4945 DBG_PRINT(INIT_DBG, "cleanup done\n");
4946 }
4947
4948 module_init(s2io_starter);
4949 module_exit(s2io_closer);
Verdex Pro support