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