?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
device create: convert device_create_drvdata to device_create
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / net / s2io.c
blob9dae40ccf0482cdce2a9df3bb25ee0e7730a35ae
1 /************************************************************************
2 * s2io.c: A Linux PCI-X Ethernet driver for Neterion 10GbE Server NIC
3 * Copyright(c) 2002-2007 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 *
30 * rx_ring_num : This can be used to program the number of receive rings used
31 * in the driver.
32 * rx_ring_sz: This defines the number of receive blocks each ring can have.
33 * This is also an array of size 8.
34 * rx_ring_mode: This defines the operation mode of all 8 rings. The valid
35 * values are 1, 2.
36 * tx_fifo_num: This defines the number of Tx FIFOs thats used int the driver.
37 * tx_fifo_len: This too is an array of 8. Each element defines the number of
38 * Tx descriptors that can be associated with each corresponding FIFO.
39 * intr_type: This defines the type of interrupt. The values can be 0(INTA),
40 * 2(MSI_X). Default value is '2(MSI_X)'
41 * lro_enable: Specifies whether to enable Large Receive Offload (LRO) or not.
42 * Possible values '1' for enable '0' for disable. Default is '0'
43 * lro_max_pkts: This parameter defines maximum number of packets can be
44 * aggregated as a single large packet
45 * napi: This parameter used to enable/disable NAPI (polling Rx)
46 * Possible values '1' for enable and '0' for disable. Default is '1'
47 * ufo: This parameter used to enable/disable UDP Fragmentation Offload(UFO)
48 * Possible values '1' for enable and '0' for disable. Default is '0'
49 * vlan_tag_strip: This can be used to enable or disable vlan stripping.
50 * Possible values '1' for enable , '0' for disable.
51 * Default is '2' - which means disable in promisc mode
52 * and enable in non-promiscuous mode.
53 * multiq: This parameter used to enable/disable MULTIQUEUE support.
54 * Possible values '1' for enable and '0' for disable. Default is '0'
55 ************************************************************************/
56
57 #include <linux/module.h>
58 #include <linux/types.h>
59 #include <linux/errno.h>
60 #include <linux/ioport.h>
61 #include <linux/pci.h>
62 #include <linux/dma-mapping.h>
63 #include <linux/kernel.h>
64 #include <linux/netdevice.h>
65 #include <linux/etherdevice.h>
66 #include <linux/skbuff.h>
67 #include <linux/init.h>
68 #include <linux/delay.h>
69 #include <linux/stddef.h>
70 #include <linux/ioctl.h>
71 #include <linux/timex.h>
72 #include <linux/ethtool.h>
73 #include <linux/workqueue.h>
74 #include <linux/if_vlan.h>
75 #include <linux/ip.h>
76 #include <linux/tcp.h>
77 #include <net/tcp.h>
78
79 #include <asm/system.h>
80 #include <asm/uaccess.h>
81 #include <asm/io.h>
82 #include <asm/div64.h>
83 #include <asm/irq.h>
84
85 /* local include */
86 #include "s2io.h"
87 #include "s2io-regs.h"
88
89 #define DRV_VERSION "2.0.26.25"
90
91 /* S2io Driver name & version. */
92 static char s2io_driver_name[] = "Neterion";
93 static char s2io_driver_version[] = DRV_VERSION;
94
95 static int rxd_size[2] = {32,48};
96 static int rxd_count[2] = {127,85};
97
98 static inline int RXD_IS_UP2DT(struct RxD_t *rxdp)
99 {
100 int ret;
101
102 ret = ((!(rxdp->Control_1 & RXD_OWN_XENA)) &&
103 (GET_RXD_MARKER(rxdp->Control_2) != THE_RXD_MARK));
104
105 return ret;
106 }
107
108 /*
109 * Cards with following subsystem_id have a link state indication
110 * problem, 600B, 600C, 600D, 640B, 640C and 640D.
111 * macro below identifies these cards given the subsystem_id.
112 */
113 #define CARDS_WITH_FAULTY_LINK_INDICATORS(dev_type, subid) \
114 (dev_type == XFRAME_I_DEVICE) ? \
115 ((((subid >= 0x600B) && (subid <= 0x600D)) || \
116 ((subid >= 0x640B) && (subid <= 0x640D))) ? 1 : 0) : 0
117
118 #define LINK_IS_UP(val64) (!(val64 & (ADAPTER_STATUS_RMAC_REMOTE_FAULT | \
119 ADAPTER_STATUS_RMAC_LOCAL_FAULT)))
120
121 static inline int is_s2io_card_up(const struct s2io_nic * sp)
122 {
123 return test_bit(__S2IO_STATE_CARD_UP, &sp->state);
124 }
125
126 /* Ethtool related variables and Macros. */
127 static char s2io_gstrings[][ETH_GSTRING_LEN] = {
128 "Register test\t(offline)",
129 "Eeprom test\t(offline)",
130 "Link test\t(online)",
131 "RLDRAM test\t(offline)",
132 "BIST Test\t(offline)"
133 };
134
135 static char ethtool_xena_stats_keys[][ETH_GSTRING_LEN] = {
136 {"tmac_frms"},
137 {"tmac_data_octets"},
138 {"tmac_drop_frms"},
139 {"tmac_mcst_frms"},
140 {"tmac_bcst_frms"},
141 {"tmac_pause_ctrl_frms"},
142 {"tmac_ttl_octets"},
143 {"tmac_ucst_frms"},
144 {"tmac_nucst_frms"},
145 {"tmac_any_err_frms"},
146 {"tmac_ttl_less_fb_octets"},
147 {"tmac_vld_ip_octets"},
148 {"tmac_vld_ip"},
149 {"tmac_drop_ip"},
150 {"tmac_icmp"},
151 {"tmac_rst_tcp"},
152 {"tmac_tcp"},
153 {"tmac_udp"},
154 {"rmac_vld_frms"},
155 {"rmac_data_octets"},
156 {"rmac_fcs_err_frms"},
157 {"rmac_drop_frms"},
158 {"rmac_vld_mcst_frms"},
159 {"rmac_vld_bcst_frms"},
160 {"rmac_in_rng_len_err_frms"},
161 {"rmac_out_rng_len_err_frms"},
162 {"rmac_long_frms"},
163 {"rmac_pause_ctrl_frms"},
164 {"rmac_unsup_ctrl_frms"},
165 {"rmac_ttl_octets"},
166 {"rmac_accepted_ucst_frms"},
167 {"rmac_accepted_nucst_frms"},
168 {"rmac_discarded_frms"},
169 {"rmac_drop_events"},
170 {"rmac_ttl_less_fb_octets"},
171 {"rmac_ttl_frms"},
172 {"rmac_usized_frms"},
173 {"rmac_osized_frms"},
174 {"rmac_frag_frms"},
175 {"rmac_jabber_frms"},
176 {"rmac_ttl_64_frms"},
177 {"rmac_ttl_65_127_frms"},
178 {"rmac_ttl_128_255_frms"},
179 {"rmac_ttl_256_511_frms"},
180 {"rmac_ttl_512_1023_frms"},
181 {"rmac_ttl_1024_1518_frms"},
182 {"rmac_ip"},
183 {"rmac_ip_octets"},
184 {"rmac_hdr_err_ip"},
185 {"rmac_drop_ip"},
186 {"rmac_icmp"},
187 {"rmac_tcp"},
188 {"rmac_udp"},
189 {"rmac_err_drp_udp"},
190 {"rmac_xgmii_err_sym"},
191 {"rmac_frms_q0"},
192 {"rmac_frms_q1"},
193 {"rmac_frms_q2"},
194 {"rmac_frms_q3"},
195 {"rmac_frms_q4"},
196 {"rmac_frms_q5"},
197 {"rmac_frms_q6"},
198 {"rmac_frms_q7"},
199 {"rmac_full_q0"},
200 {"rmac_full_q1"},
201 {"rmac_full_q2"},
202 {"rmac_full_q3"},
203 {"rmac_full_q4"},
204 {"rmac_full_q5"},
205 {"rmac_full_q6"},
206 {"rmac_full_q7"},
207 {"rmac_pause_cnt"},
208 {"rmac_xgmii_data_err_cnt"},
209 {"rmac_xgmii_ctrl_err_cnt"},
210 {"rmac_accepted_ip"},
211 {"rmac_err_tcp"},
212 {"rd_req_cnt"},
213 {"new_rd_req_cnt"},
214 {"new_rd_req_rtry_cnt"},
215 {"rd_rtry_cnt"},
216 {"wr_rtry_rd_ack_cnt"},
217 {"wr_req_cnt"},
218 {"new_wr_req_cnt"},
219 {"new_wr_req_rtry_cnt"},
220 {"wr_rtry_cnt"},
221 {"wr_disc_cnt"},
222 {"rd_rtry_wr_ack_cnt"},
223 {"txp_wr_cnt"},
224 {"txd_rd_cnt"},
225 {"txd_wr_cnt"},
226 {"rxd_rd_cnt"},
227 {"rxd_wr_cnt"},
228 {"txf_rd_cnt"},
229 {"rxf_wr_cnt"}
230 };
231
232 static char ethtool_enhanced_stats_keys[][ETH_GSTRING_LEN] = {
233 {"rmac_ttl_1519_4095_frms"},
234 {"rmac_ttl_4096_8191_frms"},
235 {"rmac_ttl_8192_max_frms"},
236 {"rmac_ttl_gt_max_frms"},
237 {"rmac_osized_alt_frms"},
238 {"rmac_jabber_alt_frms"},
239 {"rmac_gt_max_alt_frms"},
240 {"rmac_vlan_frms"},
241 {"rmac_len_discard"},
242 {"rmac_fcs_discard"},
243 {"rmac_pf_discard"},
244 {"rmac_da_discard"},
245 {"rmac_red_discard"},
246 {"rmac_rts_discard"},
247 {"rmac_ingm_full_discard"},
248 {"link_fault_cnt"}
249 };
250
251 static char ethtool_driver_stats_keys[][ETH_GSTRING_LEN] = {
252 {"\n DRIVER STATISTICS"},
253 {"single_bit_ecc_errs"},
254 {"double_bit_ecc_errs"},
255 {"parity_err_cnt"},
256 {"serious_err_cnt"},
257 {"soft_reset_cnt"},
258 {"fifo_full_cnt"},
259 {"ring_0_full_cnt"},
260 {"ring_1_full_cnt"},
261 {"ring_2_full_cnt"},
262 {"ring_3_full_cnt"},
263 {"ring_4_full_cnt"},
264 {"ring_5_full_cnt"},
265 {"ring_6_full_cnt"},
266 {"ring_7_full_cnt"},
267 {"alarm_transceiver_temp_high"},
268 {"alarm_transceiver_temp_low"},
269 {"alarm_laser_bias_current_high"},
270 {"alarm_laser_bias_current_low"},
271 {"alarm_laser_output_power_high"},
272 {"alarm_laser_output_power_low"},
273 {"warn_transceiver_temp_high"},
274 {"warn_transceiver_temp_low"},
275 {"warn_laser_bias_current_high"},
276 {"warn_laser_bias_current_low"},
277 {"warn_laser_output_power_high"},
278 {"warn_laser_output_power_low"},
279 {"lro_aggregated_pkts"},
280 {"lro_flush_both_count"},
281 {"lro_out_of_sequence_pkts"},
282 {"lro_flush_due_to_max_pkts"},
283 {"lro_avg_aggr_pkts"},
284 {"mem_alloc_fail_cnt"},
285 {"pci_map_fail_cnt"},
286 {"watchdog_timer_cnt"},
287 {"mem_allocated"},
288 {"mem_freed"},
289 {"link_up_cnt"},
290 {"link_down_cnt"},
291 {"link_up_time"},
292 {"link_down_time"},
293 {"tx_tcode_buf_abort_cnt"},
294 {"tx_tcode_desc_abort_cnt"},
295 {"tx_tcode_parity_err_cnt"},
296 {"tx_tcode_link_loss_cnt"},
297 {"tx_tcode_list_proc_err_cnt"},
298 {"rx_tcode_parity_err_cnt"},
299 {"rx_tcode_abort_cnt"},
300 {"rx_tcode_parity_abort_cnt"},
301 {"rx_tcode_rda_fail_cnt"},
302 {"rx_tcode_unkn_prot_cnt"},
303 {"rx_tcode_fcs_err_cnt"},
304 {"rx_tcode_buf_size_err_cnt"},
305 {"rx_tcode_rxd_corrupt_cnt"},
306 {"rx_tcode_unkn_err_cnt"},
307 {"tda_err_cnt"},
308 {"pfc_err_cnt"},
309 {"pcc_err_cnt"},
310 {"tti_err_cnt"},
311 {"tpa_err_cnt"},
312 {"sm_err_cnt"},
313 {"lso_err_cnt"},
314 {"mac_tmac_err_cnt"},
315 {"mac_rmac_err_cnt"},
316 {"xgxs_txgxs_err_cnt"},
317 {"xgxs_rxgxs_err_cnt"},
318 {"rc_err_cnt"},
319 {"prc_pcix_err_cnt"},
320 {"rpa_err_cnt"},
321 {"rda_err_cnt"},
322 {"rti_err_cnt"},
323 {"mc_err_cnt"}
324 };
325
326 #define S2IO_XENA_STAT_LEN ARRAY_SIZE(ethtool_xena_stats_keys)
327 #define S2IO_ENHANCED_STAT_LEN ARRAY_SIZE(ethtool_enhanced_stats_keys)
328 #define S2IO_DRIVER_STAT_LEN ARRAY_SIZE(ethtool_driver_stats_keys)
329
330 #define XFRAME_I_STAT_LEN (S2IO_XENA_STAT_LEN + S2IO_DRIVER_STAT_LEN )
331 #define XFRAME_II_STAT_LEN (XFRAME_I_STAT_LEN + S2IO_ENHANCED_STAT_LEN )
332
333 #define XFRAME_I_STAT_STRINGS_LEN ( XFRAME_I_STAT_LEN * ETH_GSTRING_LEN )
334 #define XFRAME_II_STAT_STRINGS_LEN ( XFRAME_II_STAT_LEN * ETH_GSTRING_LEN )
335
336 #define S2IO_TEST_LEN ARRAY_SIZE(s2io_gstrings)
337 #define S2IO_STRINGS_LEN S2IO_TEST_LEN * ETH_GSTRING_LEN
338
339 #define S2IO_TIMER_CONF(timer, handle, arg, exp) \
340 init_timer(&timer); \
341 timer.function = handle; \
342 timer.data = (unsigned long) arg; \
343 mod_timer(&timer, (jiffies + exp)) \
344
345 /* copy mac addr to def_mac_addr array */
346 static void do_s2io_copy_mac_addr(struct s2io_nic *sp, int offset, u64 mac_addr)
347 {
348 sp->def_mac_addr[offset].mac_addr[5] = (u8) (mac_addr);
349 sp->def_mac_addr[offset].mac_addr[4] = (u8) (mac_addr >> 8);
350 sp->def_mac_addr[offset].mac_addr[3] = (u8) (mac_addr >> 16);
351 sp->def_mac_addr[offset].mac_addr[2] = (u8) (mac_addr >> 24);
352 sp->def_mac_addr[offset].mac_addr[1] = (u8) (mac_addr >> 32);
353 sp->def_mac_addr[offset].mac_addr[0] = (u8) (mac_addr >> 40);
354 }
355 /* Add the vlan */
356 static void s2io_vlan_rx_register(struct net_device *dev,
357 struct vlan_group *grp)
358 {
359 int i;
360 struct s2io_nic *nic = dev->priv;
361 unsigned long flags[MAX_TX_FIFOS];
362 struct mac_info *mac_control = &nic->mac_control;
363 struct config_param *config = &nic->config;
364
365 for (i = 0; i < config->tx_fifo_num; i++)
366 spin_lock_irqsave(&mac_control->fifos[i].tx_lock, flags[i]);
367
368 nic->vlgrp = grp;
369 for (i = config->tx_fifo_num - 1; i >= 0; i--)
370 spin_unlock_irqrestore(&mac_control->fifos[i].tx_lock,
371 flags[i]);
372 }
373
374 /* A flag indicating whether 'RX_PA_CFG_STRIP_VLAN_TAG' bit is set or not */
375 static int vlan_strip_flag;
376
377 /* Unregister the vlan */
378 static void s2io_vlan_rx_kill_vid(struct net_device *dev, unsigned long vid)
379 {
380 int i;
381 struct s2io_nic *nic = dev->priv;
382 unsigned long flags[MAX_TX_FIFOS];
383 struct mac_info *mac_control = &nic->mac_control;
384 struct config_param *config = &nic->config;
385
386 for (i = 0; i < config->tx_fifo_num; i++)
387 spin_lock_irqsave(&mac_control->fifos[i].tx_lock, flags[i]);
388
389 if (nic->vlgrp)
390 vlan_group_set_device(nic->vlgrp, vid, NULL);
391
392 for (i = config->tx_fifo_num - 1; i >= 0; i--)
393 spin_unlock_irqrestore(&mac_control->fifos[i].tx_lock,
394 flags[i]);
395 }
396
397 /*
398 * Constants to be programmed into the Xena's registers, to configure
399 * the XAUI.
400 */
401
402 #define END_SIGN 0x0
403 static const u64 herc_act_dtx_cfg[] = {
404 /* Set address */
405 0x8000051536750000ULL, 0x80000515367500E0ULL,
406 /* Write data */
407 0x8000051536750004ULL, 0x80000515367500E4ULL,
408 /* Set address */
409 0x80010515003F0000ULL, 0x80010515003F00E0ULL,
410 /* Write data */
411 0x80010515003F0004ULL, 0x80010515003F00E4ULL,
412 /* Set address */
413 0x801205150D440000ULL, 0x801205150D4400E0ULL,
414 /* Write data */
415 0x801205150D440004ULL, 0x801205150D4400E4ULL,
416 /* Set address */
417 0x80020515F2100000ULL, 0x80020515F21000E0ULL,
418 /* Write data */
419 0x80020515F2100004ULL, 0x80020515F21000E4ULL,
420 /* Done */
421 END_SIGN
422 };
423
424 static const u64 xena_dtx_cfg[] = {
425 /* Set address */
426 0x8000051500000000ULL, 0x80000515000000E0ULL,
427 /* Write data */
428 0x80000515D9350004ULL, 0x80000515D93500E4ULL,
429 /* Set address */
430 0x8001051500000000ULL, 0x80010515000000E0ULL,
431 /* Write data */
432 0x80010515001E0004ULL, 0x80010515001E00E4ULL,
433 /* Set address */
434 0x8002051500000000ULL, 0x80020515000000E0ULL,
435 /* Write data */
436 0x80020515F2100004ULL, 0x80020515F21000E4ULL,
437 END_SIGN
438 };
439
440 /*
441 * Constants for Fixing the MacAddress problem seen mostly on
442 * Alpha machines.
443 */
444 static const u64 fix_mac[] = {
445 0x0060000000000000ULL, 0x0060600000000000ULL,
446 0x0040600000000000ULL, 0x0000600000000000ULL,
447 0x0020600000000000ULL, 0x0060600000000000ULL,
448 0x0020600000000000ULL, 0x0060600000000000ULL,
449 0x0020600000000000ULL, 0x0060600000000000ULL,
450 0x0020600000000000ULL, 0x0060600000000000ULL,
451 0x0020600000000000ULL, 0x0060600000000000ULL,
452 0x0020600000000000ULL, 0x0060600000000000ULL,
453 0x0020600000000000ULL, 0x0060600000000000ULL,
454 0x0020600000000000ULL, 0x0060600000000000ULL,
455 0x0020600000000000ULL, 0x0060600000000000ULL,
456 0x0020600000000000ULL, 0x0060600000000000ULL,
457 0x0020600000000000ULL, 0x0000600000000000ULL,
458 0x0040600000000000ULL, 0x0060600000000000ULL,
459 END_SIGN
460 };
461
462 MODULE_LICENSE("GPL");
463 MODULE_VERSION(DRV_VERSION);
464
465
466 /* Module Loadable parameters. */
467 S2IO_PARM_INT(tx_fifo_num, FIFO_DEFAULT_NUM);
468 S2IO_PARM_INT(rx_ring_num, 1);
469 S2IO_PARM_INT(multiq, 0);
470 S2IO_PARM_INT(rx_ring_mode, 1);
471 S2IO_PARM_INT(use_continuous_tx_intrs, 1);
472 S2IO_PARM_INT(rmac_pause_time, 0x100);
473 S2IO_PARM_INT(mc_pause_threshold_q0q3, 187);
474 S2IO_PARM_INT(mc_pause_threshold_q4q7, 187);
475 S2IO_PARM_INT(shared_splits, 0);
476 S2IO_PARM_INT(tmac_util_period, 5);
477 S2IO_PARM_INT(rmac_util_period, 5);
478 S2IO_PARM_INT(l3l4hdr_size, 128);
479 /* 0 is no steering, 1 is Priority steering, 2 is Default steering */
480 S2IO_PARM_INT(tx_steering_type, TX_DEFAULT_STEERING);
481 /* Frequency of Rx desc syncs expressed as power of 2 */
482 S2IO_PARM_INT(rxsync_frequency, 3);
483 /* Interrupt type. Values can be 0(INTA), 2(MSI_X) */
484 S2IO_PARM_INT(intr_type, 2);
485 /* Large receive offload feature */
486 static unsigned int lro_enable;
487 module_param_named(lro, lro_enable, uint, 0);
488
489 /* Max pkts to be aggregated by LRO at one time. If not specified,
490 * aggregation happens until we hit max IP pkt size(64K)
491 */
492 S2IO_PARM_INT(lro_max_pkts, 0xFFFF);
493 S2IO_PARM_INT(indicate_max_pkts, 0);
494
495 S2IO_PARM_INT(napi, 1);
496 S2IO_PARM_INT(ufo, 0);
497 S2IO_PARM_INT(vlan_tag_strip, NO_STRIP_IN_PROMISC);
498
499 static unsigned int tx_fifo_len[MAX_TX_FIFOS] =
500 {DEFAULT_FIFO_0_LEN, [1 ...(MAX_TX_FIFOS - 1)] = DEFAULT_FIFO_1_7_LEN};
501 static unsigned int rx_ring_sz[MAX_RX_RINGS] =
502 {[0 ...(MAX_RX_RINGS - 1)] = SMALL_BLK_CNT};
503 static unsigned int rts_frm_len[MAX_RX_RINGS] =
504 {[0 ...(MAX_RX_RINGS - 1)] = 0 };
505
506 module_param_array(tx_fifo_len, uint, NULL, 0);
507 module_param_array(rx_ring_sz, uint, NULL, 0);
508 module_param_array(rts_frm_len, uint, NULL, 0);
509
510 /*
511 * S2IO device table.
512 * This table lists all the devices that this driver supports.
513 */
514 static struct pci_device_id s2io_tbl[] __devinitdata = {
515 {PCI_VENDOR_ID_S2IO, PCI_DEVICE_ID_S2IO_WIN,
516 PCI_ANY_ID, PCI_ANY_ID},
517 {PCI_VENDOR_ID_S2IO, PCI_DEVICE_ID_S2IO_UNI,
518 PCI_ANY_ID, PCI_ANY_ID},
519 {PCI_VENDOR_ID_S2IO, PCI_DEVICE_ID_HERC_WIN,
520 PCI_ANY_ID, PCI_ANY_ID},
521 {PCI_VENDOR_ID_S2IO, PCI_DEVICE_ID_HERC_UNI,
522 PCI_ANY_ID, PCI_ANY_ID},
523 {0,}
524 };
525
526 MODULE_DEVICE_TABLE(pci, s2io_tbl);
527
528 static struct pci_error_handlers s2io_err_handler = {
529 .error_detected = s2io_io_error_detected,
530 .slot_reset = s2io_io_slot_reset,
531 .resume = s2io_io_resume,
532 };
533
534 static struct pci_driver s2io_driver = {
535 .name = "S2IO",
536 .id_table = s2io_tbl,
537 .probe = s2io_init_nic,
538 .remove = __devexit_p(s2io_rem_nic),
539 .err_handler = &s2io_err_handler,
540 };
541
542 /* A simplifier macro used both by init and free shared_mem Fns(). */
543 #define TXD_MEM_PAGE_CNT(len, per_each) ((len+per_each - 1) / per_each)
544
545 /* netqueue manipulation helper functions */
546 static inline void s2io_stop_all_tx_queue(struct s2io_nic *sp)
547 {
548 if (!sp->config.multiq) {
549 int i;
550
551 for (i = 0; i < sp->config.tx_fifo_num; i++)
552 sp->mac_control.fifos[i].queue_state = FIFO_QUEUE_STOP;
553 }
554 netif_tx_stop_all_queues(sp->dev);
555 }
556
557 static inline void s2io_stop_tx_queue(struct s2io_nic *sp, int fifo_no)
558 {
559 if (!sp->config.multiq)
560 sp->mac_control.fifos[fifo_no].queue_state =
561 FIFO_QUEUE_STOP;
562
563 netif_tx_stop_all_queues(sp->dev);
564 }
565
566 static inline void s2io_start_all_tx_queue(struct s2io_nic *sp)
567 {
568 if (!sp->config.multiq) {
569 int i;
570
571 for (i = 0; i < sp->config.tx_fifo_num; i++)
572 sp->mac_control.fifos[i].queue_state = FIFO_QUEUE_START;
573 }
574 netif_tx_start_all_queues(sp->dev);
575 }
576
577 static inline void s2io_start_tx_queue(struct s2io_nic *sp, int fifo_no)
578 {
579 if (!sp->config.multiq)
580 sp->mac_control.fifos[fifo_no].queue_state =
581 FIFO_QUEUE_START;
582
583 netif_tx_start_all_queues(sp->dev);
584 }
585
586 static inline void s2io_wake_all_tx_queue(struct s2io_nic *sp)
587 {
588 if (!sp->config.multiq) {
589 int i;
590
591 for (i = 0; i < sp->config.tx_fifo_num; i++)
592 sp->mac_control.fifos[i].queue_state = FIFO_QUEUE_START;
593 }
594 netif_tx_wake_all_queues(sp->dev);
595 }
596
597 static inline void s2io_wake_tx_queue(
598 struct fifo_info *fifo, int cnt, u8 multiq)
599 {
600
601 if (multiq) {
602 if (cnt && __netif_subqueue_stopped(fifo->dev, fifo->fifo_no))
603 netif_wake_subqueue(fifo->dev, fifo->fifo_no);
604 } else if (cnt && (fifo->queue_state == FIFO_QUEUE_STOP)) {
605 if (netif_queue_stopped(fifo->dev)) {
606 fifo->queue_state = FIFO_QUEUE_START;
607 netif_wake_queue(fifo->dev);
608 }
609 }
610 }
611
612 /**
613 * init_shared_mem - Allocation and Initialization of Memory
614 * @nic: Device private variable.
615 * Description: The function allocates all the memory areas shared
616 * between the NIC and the driver. This includes Tx descriptors,
617 * Rx descriptors and the statistics block.
618 */
619
620 static int init_shared_mem(struct s2io_nic *nic)
621 {
622 u32 size;
623 void *tmp_v_addr, *tmp_v_addr_next;
624 dma_addr_t tmp_p_addr, tmp_p_addr_next;
625 struct RxD_block *pre_rxd_blk = NULL;
626 int i, j, blk_cnt;
627 int lst_size, lst_per_page;
628 struct net_device *dev = nic->dev;
629 unsigned long tmp;
630 struct buffAdd *ba;
631
632 struct mac_info *mac_control;
633 struct config_param *config;
634 unsigned long long mem_allocated = 0;
635
636 mac_control = &nic->mac_control;
637 config = &nic->config;
638
639
640 /* Allocation and initialization of TXDLs in FIOFs */
641 size = 0;
642 for (i = 0; i < config->tx_fifo_num; i++) {
643 size += config->tx_cfg[i].fifo_len;
644 }
645 if (size > MAX_AVAILABLE_TXDS) {
646 DBG_PRINT(ERR_DBG, "s2io: Requested TxDs too high, ");
647 DBG_PRINT(ERR_DBG, "Requested: %d, max supported: 8192\n", size);
648 return -EINVAL;
649 }
650
651 size = 0;
652 for (i = 0; i < config->tx_fifo_num; i++) {
653 size = config->tx_cfg[i].fifo_len;
654 /*
655 * Legal values are from 2 to 8192
656 */
657 if (size < 2) {
658 DBG_PRINT(ERR_DBG, "s2io: Invalid fifo len (%d)", size);
659 DBG_PRINT(ERR_DBG, "for fifo %d\n", i);
660 DBG_PRINT(ERR_DBG, "s2io: Legal values for fifo len"
661 "are 2 to 8192\n");
662 return -EINVAL;
663 }
664 }
665
666 lst_size = (sizeof(struct TxD) * config->max_txds);
667 lst_per_page = PAGE_SIZE / lst_size;
668
669 for (i = 0; i < config->tx_fifo_num; i++) {
670 int fifo_len = config->tx_cfg[i].fifo_len;
671 int list_holder_size = fifo_len * sizeof(struct list_info_hold);
672 mac_control->fifos[i].list_info = kzalloc(list_holder_size,
673 GFP_KERNEL);
674 if (!mac_control->fifos[i].list_info) {
675 DBG_PRINT(INFO_DBG,
676 "Malloc failed for list_info\n");
677 return -ENOMEM;
678 }
679 mem_allocated += list_holder_size;
680 }
681 for (i = 0; i < config->tx_fifo_num; i++) {
682 int page_num = TXD_MEM_PAGE_CNT(config->tx_cfg[i].fifo_len,
683 lst_per_page);
684 mac_control->fifos[i].tx_curr_put_info.offset = 0;
685 mac_control->fifos[i].tx_curr_put_info.fifo_len =
686 config->tx_cfg[i].fifo_len - 1;
687 mac_control->fifos[i].tx_curr_get_info.offset = 0;
688 mac_control->fifos[i].tx_curr_get_info.fifo_len =
689 config->tx_cfg[i].fifo_len - 1;
690 mac_control->fifos[i].fifo_no = i;
691 mac_control->fifos[i].nic = nic;
692 mac_control->fifos[i].max_txds = MAX_SKB_FRAGS + 2;
693 mac_control->fifos[i].dev = dev;
694
695 for (j = 0; j < page_num; j++) {
696 int k = 0;
697 dma_addr_t tmp_p;
698 void *tmp_v;
699 tmp_v = pci_alloc_consistent(nic->pdev,
700 PAGE_SIZE, &tmp_p);
701 if (!tmp_v) {
702 DBG_PRINT(INFO_DBG,
703 "pci_alloc_consistent ");
704 DBG_PRINT(INFO_DBG, "failed for TxDL\n");
705 return -ENOMEM;
706 }
707 /* If we got a zero DMA address(can happen on
708 * certain platforms like PPC), reallocate.
709 * Store virtual address of page we don't want,
710 * to be freed later.
711 */
712 if (!tmp_p) {
713 mac_control->zerodma_virt_addr = tmp_v;
714 DBG_PRINT(INIT_DBG,
715 "%s: Zero DMA address for TxDL. ", dev->name);
716 DBG_PRINT(INIT_DBG,
717 "Virtual address %p\n", tmp_v);
718 tmp_v = pci_alloc_consistent(nic->pdev,
719 PAGE_SIZE, &tmp_p);
720 if (!tmp_v) {
721 DBG_PRINT(INFO_DBG,
722 "pci_alloc_consistent ");
723 DBG_PRINT(INFO_DBG, "failed for TxDL\n");
724 return -ENOMEM;
725 }
726 mem_allocated += PAGE_SIZE;
727 }
728 while (k < lst_per_page) {
729 int l = (j * lst_per_page) + k;
730 if (l == config->tx_cfg[i].fifo_len)
731 break;
732 mac_control->fifos[i].list_info[l].list_virt_addr =
733 tmp_v + (k * lst_size);
734 mac_control->fifos[i].list_info[l].list_phy_addr =
735 tmp_p + (k * lst_size);
736 k++;
737 }
738 }
739 }
740
741 for (i = 0; i < config->tx_fifo_num; i++) {
742 size = config->tx_cfg[i].fifo_len;
743 mac_control->fifos[i].ufo_in_band_v
744 = kcalloc(size, sizeof(u64), GFP_KERNEL);
745 if (!mac_control->fifos[i].ufo_in_band_v)
746 return -ENOMEM;
747 mem_allocated += (size * sizeof(u64));
748 }
749
750 /* Allocation and initialization of RXDs in Rings */
751 size = 0;
752 for (i = 0; i < config->rx_ring_num; i++) {
753 if (config->rx_cfg[i].num_rxd %
754 (rxd_count[nic->rxd_mode] + 1)) {
755 DBG_PRINT(ERR_DBG, "%s: RxD count of ", dev->name);
756 DBG_PRINT(ERR_DBG, "Ring%d is not a multiple of ",
757 i);
758 DBG_PRINT(ERR_DBG, "RxDs per Block");
759 return FAILURE;
760 }
761 size += config->rx_cfg[i].num_rxd;
762 mac_control->rings[i].block_count =
763 config->rx_cfg[i].num_rxd /
764 (rxd_count[nic->rxd_mode] + 1 );
765 mac_control->rings[i].pkt_cnt = config->rx_cfg[i].num_rxd -
766 mac_control->rings[i].block_count;
767 }
768 if (nic->rxd_mode == RXD_MODE_1)
769 size = (size * (sizeof(struct RxD1)));
770 else
771 size = (size * (sizeof(struct RxD3)));
772
773 for (i = 0; i < config->rx_ring_num; i++) {
774 mac_control->rings[i].rx_curr_get_info.block_index = 0;
775 mac_control->rings[i].rx_curr_get_info.offset = 0;
776 mac_control->rings[i].rx_curr_get_info.ring_len =
777 config->rx_cfg[i].num_rxd - 1;
778 mac_control->rings[i].rx_curr_put_info.block_index = 0;
779 mac_control->rings[i].rx_curr_put_info.offset = 0;
780 mac_control->rings[i].rx_curr_put_info.ring_len =
781 config->rx_cfg[i].num_rxd - 1;
782 mac_control->rings[i].nic = nic;
783 mac_control->rings[i].ring_no = i;
784 mac_control->rings[i].lro = lro_enable;
785
786 blk_cnt = config->rx_cfg[i].num_rxd /
787 (rxd_count[nic->rxd_mode] + 1);
788 /* Allocating all the Rx blocks */
789 for (j = 0; j < blk_cnt; j++) {
790 struct rx_block_info *rx_blocks;
791 int l;
792
793 rx_blocks = &mac_control->rings[i].rx_blocks[j];
794 size = SIZE_OF_BLOCK; //size is always page size
795 tmp_v_addr = pci_alloc_consistent(nic->pdev, size,
796 &tmp_p_addr);
797 if (tmp_v_addr == NULL) {
798 /*
799 * In case of failure, free_shared_mem()
800 * is called, which should free any
801 * memory that was alloced till the
802 * failure happened.
803 */
804 rx_blocks->block_virt_addr = tmp_v_addr;
805 return -ENOMEM;
806 }
807 mem_allocated += size;
808 memset(tmp_v_addr, 0, size);
809 rx_blocks->block_virt_addr = tmp_v_addr;
810 rx_blocks->block_dma_addr = tmp_p_addr;
811 rx_blocks->rxds = kmalloc(sizeof(struct rxd_info)*
812 rxd_count[nic->rxd_mode],
813 GFP_KERNEL);
814 if (!rx_blocks->rxds)
815 return -ENOMEM;
816 mem_allocated +=
817 (sizeof(struct rxd_info)* rxd_count[nic->rxd_mode]);
818 for (l=0; l<rxd_count[nic->rxd_mode];l++) {
819 rx_blocks->rxds[l].virt_addr =
820 rx_blocks->block_virt_addr +
821 (rxd_size[nic->rxd_mode] * l);
822 rx_blocks->rxds[l].dma_addr =
823 rx_blocks->block_dma_addr +
824 (rxd_size[nic->rxd_mode] * l);
825 }
826 }
827 /* Interlinking all Rx Blocks */
828 for (j = 0; j < blk_cnt; j++) {
829 tmp_v_addr =
830 mac_control->rings[i].rx_blocks[j].block_virt_addr;
831 tmp_v_addr_next =
832 mac_control->rings[i].rx_blocks[(j + 1) %
833 blk_cnt].block_virt_addr;
834 tmp_p_addr =
835 mac_control->rings[i].rx_blocks[j].block_dma_addr;
836 tmp_p_addr_next =
837 mac_control->rings[i].rx_blocks[(j + 1) %
838 blk_cnt].block_dma_addr;
839
840 pre_rxd_blk = (struct RxD_block *) tmp_v_addr;
841 pre_rxd_blk->reserved_2_pNext_RxD_block =
842 (unsigned long) tmp_v_addr_next;
843 pre_rxd_blk->pNext_RxD_Blk_physical =
844 (u64) tmp_p_addr_next;
845 }
846 }
847 if (nic->rxd_mode == RXD_MODE_3B) {
848 /*
849 * Allocation of Storages for buffer addresses in 2BUFF mode
850 * and the buffers as well.
851 */
852 for (i = 0; i < config->rx_ring_num; i++) {
853 blk_cnt = config->rx_cfg[i].num_rxd /
854 (rxd_count[nic->rxd_mode]+ 1);
855 mac_control->rings[i].ba =
856 kmalloc((sizeof(struct buffAdd *) * blk_cnt),
857 GFP_KERNEL);
858 if (!mac_control->rings[i].ba)
859 return -ENOMEM;
860 mem_allocated +=(sizeof(struct buffAdd *) * blk_cnt);
861 for (j = 0; j < blk_cnt; j++) {
862 int k = 0;
863 mac_control->rings[i].ba[j] =
864 kmalloc((sizeof(struct buffAdd) *
865 (rxd_count[nic->rxd_mode] + 1)),
866 GFP_KERNEL);
867 if (!mac_control->rings[i].ba[j])
868 return -ENOMEM;
869 mem_allocated += (sizeof(struct buffAdd) * \
870 (rxd_count[nic->rxd_mode] + 1));
871 while (k != rxd_count[nic->rxd_mode]) {
872 ba = &mac_control->rings[i].ba[j][k];
873
874 ba->ba_0_org = (void *) kmalloc
875 (BUF0_LEN + ALIGN_SIZE, GFP_KERNEL);
876 if (!ba->ba_0_org)
877 return -ENOMEM;
878 mem_allocated +=
879 (BUF0_LEN + ALIGN_SIZE);
880 tmp = (unsigned long)ba->ba_0_org;
881 tmp += ALIGN_SIZE;
882 tmp &= ~((unsigned long) ALIGN_SIZE);
883 ba->ba_0 = (void *) tmp;
884
885 ba->ba_1_org = (void *) kmalloc
886 (BUF1_LEN + ALIGN_SIZE, GFP_KERNEL);
887 if (!ba->ba_1_org)
888 return -ENOMEM;
889 mem_allocated
890 += (BUF1_LEN + ALIGN_SIZE);
891 tmp = (unsigned long) ba->ba_1_org;
892 tmp += ALIGN_SIZE;
893 tmp &= ~((unsigned long) ALIGN_SIZE);
894 ba->ba_1 = (void *) tmp;
895 k++;
896 }
897 }
898 }
899 }
900
901 /* Allocation and initialization of Statistics block */
902 size = sizeof(struct stat_block);
903 mac_control->stats_mem = pci_alloc_consistent
904 (nic->pdev, size, &mac_control->stats_mem_phy);
905
906 if (!mac_control->stats_mem) {
907 /*
908 * In case of failure, free_shared_mem() is called, which
909 * should free any memory that was alloced till the
910 * failure happened.
911 */
912 return -ENOMEM;
913 }
914 mem_allocated += size;
915 mac_control->stats_mem_sz = size;
916
917 tmp_v_addr = mac_control->stats_mem;
918 mac_control->stats_info = (struct stat_block *) tmp_v_addr;
919 memset(tmp_v_addr, 0, size);
920 DBG_PRINT(INIT_DBG, "%s:Ring Mem PHY: 0x%llx\n", dev->name,
921 (unsigned long long) tmp_p_addr);
922 mac_control->stats_info->sw_stat.mem_allocated += mem_allocated;
923 return SUCCESS;
924 }
925
926 /**
927 * free_shared_mem - Free the allocated Memory
928 * @nic: Device private variable.
929 * Description: This function is to free all memory locations allocated by
930 * the init_shared_mem() function and return it to the kernel.
931 */
932
933 static void free_shared_mem(struct s2io_nic *nic)
934 {
935 int i, j, blk_cnt, size;
936 void *tmp_v_addr;
937 dma_addr_t tmp_p_addr;
938 struct mac_info *mac_control;
939 struct config_param *config;
940 int lst_size, lst_per_page;
941 struct net_device *dev;
942 int page_num = 0;
943
944 if (!nic)
945 return;
946
947 dev = nic->dev;
948
949 mac_control = &nic->mac_control;
950 config = &nic->config;
951
952 lst_size = (sizeof(struct TxD) * config->max_txds);
953 lst_per_page = PAGE_SIZE / lst_size;
954
955 for (i = 0; i < config->tx_fifo_num; i++) {
956 page_num = TXD_MEM_PAGE_CNT(config->tx_cfg[i].fifo_len,
957 lst_per_page);
958 for (j = 0; j < page_num; j++) {
959 int mem_blks = (j * lst_per_page);
960 if (!mac_control->fifos[i].list_info)
961 return;
962 if (!mac_control->fifos[i].list_info[mem_blks].
963 list_virt_addr)
964 break;
965 pci_free_consistent(nic->pdev, PAGE_SIZE,
966 mac_control->fifos[i].
967 list_info[mem_blks].
968 list_virt_addr,
969 mac_control->fifos[i].
970 list_info[mem_blks].
971 list_phy_addr);
972 nic->mac_control.stats_info->sw_stat.mem_freed
973 += PAGE_SIZE;
974 }
975 /* If we got a zero DMA address during allocation,
976 * free the page now
977 */
978 if (mac_control->zerodma_virt_addr) {
979 pci_free_consistent(nic->pdev, PAGE_SIZE,
980 mac_control->zerodma_virt_addr,
981 (dma_addr_t)0);
982 DBG_PRINT(INIT_DBG,
983 "%s: Freeing TxDL with zero DMA addr. ",
984 dev->name);
985 DBG_PRINT(INIT_DBG, "Virtual address %p\n",
986 mac_control->zerodma_virt_addr);
987 nic->mac_control.stats_info->sw_stat.mem_freed
988 += PAGE_SIZE;
989 }
990 kfree(mac_control->fifos[i].list_info);
991 nic->mac_control.stats_info->sw_stat.mem_freed +=
992 (nic->config.tx_cfg[i].fifo_len *sizeof(struct list_info_hold));
993 }
994
995 size = SIZE_OF_BLOCK;
996 for (i = 0; i < config->rx_ring_num; i++) {
997 blk_cnt = mac_control->rings[i].block_count;
998 for (j = 0; j < blk_cnt; j++) {
999 tmp_v_addr = mac_control->rings[i].rx_blocks[j].
1000 block_virt_addr;
1001 tmp_p_addr = mac_control->rings[i].rx_blocks[j].
1002 block_dma_addr;
1003 if (tmp_v_addr == NULL)
1004 break;
1005 pci_free_consistent(nic->pdev, size,
1006 tmp_v_addr, tmp_p_addr);
1007 nic->mac_control.stats_info->sw_stat.mem_freed += size;
1008 kfree(mac_control->rings[i].rx_blocks[j].rxds);
1009 nic->mac_control.stats_info->sw_stat.mem_freed +=
1010 ( sizeof(struct rxd_info)* rxd_count[nic->rxd_mode]);
1011 }
1012 }
1013
1014 if (nic->rxd_mode == RXD_MODE_3B) {
1015 /* Freeing buffer storage addresses in 2BUFF mode. */
1016 for (i = 0; i < config->rx_ring_num; i++) {
1017 blk_cnt = config->rx_cfg[i].num_rxd /
1018 (rxd_count[nic->rxd_mode] + 1);
1019 for (j = 0; j < blk_cnt; j++) {
1020 int k = 0;
1021 if (!mac_control->rings[i].ba[j])
1022 continue;
1023 while (k != rxd_count[nic->rxd_mode]) {
1024 struct buffAdd *ba =
1025 &mac_control->rings[i].ba[j][k];
1026 kfree(ba->ba_0_org);
1027 nic->mac_control.stats_info->sw_stat.\
1028 mem_freed += (BUF0_LEN + ALIGN_SIZE);
1029 kfree(ba->ba_1_org);
1030 nic->mac_control.stats_info->sw_stat.\
1031 mem_freed += (BUF1_LEN + ALIGN_SIZE);
1032 k++;
1033 }
1034 kfree(mac_control->rings[i].ba[j]);
1035 nic->mac_control.stats_info->sw_stat.mem_freed +=
1036 (sizeof(struct buffAdd) *
1037 (rxd_count[nic->rxd_mode] + 1));
1038 }
1039 kfree(mac_control->rings[i].ba);
1040 nic->mac_control.stats_info->sw_stat.mem_freed +=
1041 (sizeof(struct buffAdd *) * blk_cnt);
1042 }
1043 }
1044
1045 for (i = 0; i < nic->config.tx_fifo_num; i++) {
1046 if (mac_control->fifos[i].ufo_in_band_v) {
1047 nic->mac_control.stats_info->sw_stat.mem_freed
1048 += (config->tx_cfg[i].fifo_len * sizeof(u64));
1049 kfree(mac_control->fifos[i].ufo_in_band_v);
1050 }
1051 }
1052
1053 if (mac_control->stats_mem) {
1054 nic->mac_control.stats_info->sw_stat.mem_freed +=
1055 mac_control->stats_mem_sz;
1056 pci_free_consistent(nic->pdev,
1057 mac_control->stats_mem_sz,
1058 mac_control->stats_mem,
1059 mac_control->stats_mem_phy);
1060 }
1061 }
1062
1063 /**
1064 * s2io_verify_pci_mode -
1065 */
1066
1067 static int s2io_verify_pci_mode(struct s2io_nic *nic)
1068 {
1069 struct XENA_dev_config __iomem *bar0 = nic->bar0;
1070 register u64 val64 = 0;
1071 int mode;
1072
1073 val64 = readq(&bar0->pci_mode);
1074 mode = (u8)GET_PCI_MODE(val64);
1075
1076 if ( val64 & PCI_MODE_UNKNOWN_MODE)
1077 return -1; /* Unknown PCI mode */
1078 return mode;
1079 }
1080
1081 #define NEC_VENID 0x1033
1082 #define NEC_DEVID 0x0125
1083 static int s2io_on_nec_bridge(struct pci_dev *s2io_pdev)
1084 {
1085 struct pci_dev *tdev = NULL;
1086 while ((tdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, tdev)) != NULL) {
1087 if (tdev->vendor == NEC_VENID && tdev->device == NEC_DEVID) {
1088 if (tdev->bus == s2io_pdev->bus->parent) {
1089 pci_dev_put(tdev);
1090 return 1;
1091 }
1092 }
1093 }
1094 return 0;
1095 }
1096
1097 static int bus_speed[8] = {33, 133, 133, 200, 266, 133, 200, 266};
1098 /**
1099 * s2io_print_pci_mode -
1100 */
1101 static int s2io_print_pci_mode(struct s2io_nic *nic)
1102 {
1103 struct XENA_dev_config __iomem *bar0 = nic->bar0;
1104 register u64 val64 = 0;
1105 int mode;
1106 struct config_param *config = &nic->config;
1107
1108 val64 = readq(&bar0->pci_mode);
1109 mode = (u8)GET_PCI_MODE(val64);
1110
1111 if ( val64 & PCI_MODE_UNKNOWN_MODE)
1112 return -1; /* Unknown PCI mode */
1113
1114 config->bus_speed = bus_speed[mode];
1115
1116 if (s2io_on_nec_bridge(nic->pdev)) {
1117 DBG_PRINT(ERR_DBG, "%s: Device is on PCI-E bus\n",
1118 nic->dev->name);
1119 return mode;
1120 }
1121
1122 if (val64 & PCI_MODE_32_BITS) {
1123 DBG_PRINT(ERR_DBG, "%s: Device is on 32 bit ", nic->dev->name);
1124 } else {
1125 DBG_PRINT(ERR_DBG, "%s: Device is on 64 bit ", nic->dev->name);
1126 }
1127
1128 switch(mode) {
1129 case PCI_MODE_PCI_33:
1130 DBG_PRINT(ERR_DBG, "33MHz PCI bus\n");
1131 break;
1132 case PCI_MODE_PCI_66:
1133 DBG_PRINT(ERR_DBG, "66MHz PCI bus\n");
1134 break;
1135 case PCI_MODE_PCIX_M1_66:
1136 DBG_PRINT(ERR_DBG, "66MHz PCIX(M1) bus\n");
1137 break;
1138 case PCI_MODE_PCIX_M1_100:
1139 DBG_PRINT(ERR_DBG, "100MHz PCIX(M1) bus\n");
1140 break;
1141 case PCI_MODE_PCIX_M1_133:
1142 DBG_PRINT(ERR_DBG, "133MHz PCIX(M1) bus\n");
1143 break;
1144 case PCI_MODE_PCIX_M2_66:
1145 DBG_PRINT(ERR_DBG, "133MHz PCIX(M2) bus\n");
1146 break;
1147 case PCI_MODE_PCIX_M2_100:
1148 DBG_PRINT(ERR_DBG, "200MHz PCIX(M2) bus\n");
1149 break;
1150 case PCI_MODE_PCIX_M2_133:
1151 DBG_PRINT(ERR_DBG, "266MHz PCIX(M2) bus\n");
1152 break;
1153 default:
1154 return -1; /* Unsupported bus speed */
1155 }
1156
1157 return mode;
1158 }
1159
1160 /**
1161 * init_tti - Initialization transmit traffic interrupt scheme
1162 * @nic: device private variable
1163 * @link: link status (UP/DOWN) used to enable/disable continuous
1164 * transmit interrupts
1165 * Description: The function configures transmit traffic interrupts
1166 * Return Value: SUCCESS on success and
1167 * '-1' on failure
1168 */
1169
1170 static int init_tti(struct s2io_nic *nic, int link)
1171 {
1172 struct XENA_dev_config __iomem *bar0 = nic->bar0;
1173 register u64 val64 = 0;
1174 int i;
1175 struct config_param *config;
1176
1177 config = &nic->config;
1178
1179 for (i = 0; i < config->tx_fifo_num; i++) {
1180 /*
1181 * TTI Initialization. Default Tx timer gets us about
1182 * 250 interrupts per sec. Continuous interrupts are enabled
1183 * by default.
1184 */
1185 if (nic->device_type == XFRAME_II_DEVICE) {
1186 int count = (nic->config.bus_speed * 125)/2;
1187 val64 = TTI_DATA1_MEM_TX_TIMER_VAL(count);
1188 } else
1189 val64 = TTI_DATA1_MEM_TX_TIMER_VAL(0x2078);
1190
1191 val64 |= TTI_DATA1_MEM_TX_URNG_A(0xA) |
1192 TTI_DATA1_MEM_TX_URNG_B(0x10) |
1193 TTI_DATA1_MEM_TX_URNG_C(0x30) |
1194 TTI_DATA1_MEM_TX_TIMER_AC_EN;
1195 if (i == 0)
1196 if (use_continuous_tx_intrs && (link == LINK_UP))
1197 val64 |= TTI_DATA1_MEM_TX_TIMER_CI_EN;
1198 writeq(val64, &bar0->tti_data1_mem);
1199
1200 if (nic->config.intr_type == MSI_X) {
1201 val64 = TTI_DATA2_MEM_TX_UFC_A(0x10) |
1202 TTI_DATA2_MEM_TX_UFC_B(0x100) |
1203 TTI_DATA2_MEM_TX_UFC_C(0x200) |
1204 TTI_DATA2_MEM_TX_UFC_D(0x300);
1205 } else {
1206 if ((nic->config.tx_steering_type ==
1207 TX_DEFAULT_STEERING) &&
1208 (config->tx_fifo_num > 1) &&
1209 (i >= nic->udp_fifo_idx) &&
1210 (i < (nic->udp_fifo_idx +
1211 nic->total_udp_fifos)))
1212 val64 = TTI_DATA2_MEM_TX_UFC_A(0x50) |
1213 TTI_DATA2_MEM_TX_UFC_B(0x80) |
1214 TTI_DATA2_MEM_TX_UFC_C(0x100) |
1215 TTI_DATA2_MEM_TX_UFC_D(0x120);
1216 else
1217 val64 = TTI_DATA2_MEM_TX_UFC_A(0x10) |
1218 TTI_DATA2_MEM_TX_UFC_B(0x20) |
1219 TTI_DATA2_MEM_TX_UFC_C(0x40) |
1220 TTI_DATA2_MEM_TX_UFC_D(0x80);
1221 }
1222
1223 writeq(val64, &bar0->tti_data2_mem);
1224
1225 val64 = TTI_CMD_MEM_WE | TTI_CMD_MEM_STROBE_NEW_CMD |
1226 TTI_CMD_MEM_OFFSET(i);
1227 writeq(val64, &bar0->tti_command_mem);
1228
1229 if (wait_for_cmd_complete(&bar0->tti_command_mem,
1230 TTI_CMD_MEM_STROBE_NEW_CMD, S2IO_BIT_RESET) != SUCCESS)
1231 return FAILURE;
1232 }
1233
1234 return SUCCESS;
1235 }
1236
1237 /**
1238 * init_nic - Initialization of hardware
1239 * @nic: device private variable
1240 * Description: The function sequentially configures every block
1241 * of the H/W from their reset values.
1242 * Return Value: SUCCESS on success and
1243 * '-1' on failure (endian settings incorrect).
1244 */
1245
1246 static int init_nic(struct s2io_nic *nic)
1247 {
1248 struct XENA_dev_config __iomem *bar0 = nic->bar0;
1249 struct net_device *dev = nic->dev;
1250 register u64 val64 = 0;
1251 void __iomem *add;
1252 u32 time;
1253 int i, j;
1254 struct mac_info *mac_control;
1255 struct config_param *config;
1256 int dtx_cnt = 0;
1257 unsigned long long mem_share;
1258 int mem_size;
1259
1260 mac_control = &nic->mac_control;
1261 config = &nic->config;
1262
1263 /* to set the swapper controle on the card */
1264 if(s2io_set_swapper(nic)) {
1265 DBG_PRINT(ERR_DBG,"ERROR: Setting Swapper failed\n");
1266 return -EIO;
1267 }
1268
1269 /*
1270 * Herc requires EOI to be removed from reset before XGXS, so..
1271 */
1272 if (nic->device_type & XFRAME_II_DEVICE) {
1273 val64 = 0xA500000000ULL;
1274 writeq(val64, &bar0->sw_reset);
1275 msleep(500);
1276 val64 = readq(&bar0->sw_reset);
1277 }
1278
1279 /* Remove XGXS from reset state */
1280 val64 = 0;
1281 writeq(val64, &bar0->sw_reset);
1282 msleep(500);
1283 val64 = readq(&bar0->sw_reset);
1284
1285 /* Ensure that it's safe to access registers by checking
1286 * RIC_RUNNING bit is reset. Check is valid only for XframeII.
1287 */
1288 if (nic->device_type == XFRAME_II_DEVICE) {
1289 for (i = 0; i < 50; i++) {
1290 val64 = readq(&bar0->adapter_status);
1291 if (!(val64 & ADAPTER_STATUS_RIC_RUNNING))
1292 break;
1293 msleep(10);
1294 }
1295 if (i == 50)
1296 return -ENODEV;
1297 }
1298
1299 /* Enable Receiving broadcasts */
1300 add = &bar0->mac_cfg;
1301 val64 = readq(&bar0->mac_cfg);
1302 val64 |= MAC_RMAC_BCAST_ENABLE;
1303 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
1304 writel((u32) val64, add);
1305 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
1306 writel((u32) (val64 >> 32), (add + 4));
1307
1308 /* Read registers in all blocks */
1309 val64 = readq(&bar0->mac_int_mask);
1310 val64 = readq(&bar0->mc_int_mask);
1311 val64 = readq(&bar0->xgxs_int_mask);
1312
1313 /* Set MTU */
1314 val64 = dev->mtu;
1315 writeq(vBIT(val64, 2, 14), &bar0->rmac_max_pyld_len);
1316
1317 if (nic->device_type & XFRAME_II_DEVICE) {
1318 while (herc_act_dtx_cfg[dtx_cnt] != END_SIGN) {
1319 SPECIAL_REG_WRITE(herc_act_dtx_cfg[dtx_cnt],
1320 &bar0->dtx_control, UF);
1321 if (dtx_cnt & 0x1)
1322 msleep(1); /* Necessary!! */
1323 dtx_cnt++;
1324 }
1325 } else {
1326 while (xena_dtx_cfg[dtx_cnt] != END_SIGN) {
1327 SPECIAL_REG_WRITE(xena_dtx_cfg[dtx_cnt],
1328 &bar0->dtx_control, UF);
1329 val64 = readq(&bar0->dtx_control);
1330 dtx_cnt++;
1331 }
1332 }
1333
1334 /* Tx DMA Initialization */
1335 val64 = 0;
1336 writeq(val64, &bar0->tx_fifo_partition_0);
1337 writeq(val64, &bar0->tx_fifo_partition_1);
1338 writeq(val64, &bar0->tx_fifo_partition_2);
1339 writeq(val64, &bar0->tx_fifo_partition_3);
1340
1341
1342 for (i = 0, j = 0; i < config->tx_fifo_num; i++) {
1343 val64 |=
1344 vBIT(config->tx_cfg[i].fifo_len - 1, ((j * 32) + 19),
1345 13) | vBIT(config->tx_cfg[i].fifo_priority,
1346 ((j * 32) + 5), 3);
1347
1348 if (i == (config->tx_fifo_num - 1)) {
1349 if (i % 2 == 0)
1350 i++;
1351 }
1352
1353 switch (i) {
1354 case 1:
1355 writeq(val64, &bar0->tx_fifo_partition_0);
1356 val64 = 0;
1357 j = 0;
1358 break;
1359 case 3:
1360 writeq(val64, &bar0->tx_fifo_partition_1);
1361 val64 = 0;
1362 j = 0;
1363 break;
1364 case 5:
1365 writeq(val64, &bar0->tx_fifo_partition_2);
1366 val64 = 0;
1367 j = 0;
1368 break;
1369 case 7:
1370 writeq(val64, &bar0->tx_fifo_partition_3);
1371 val64 = 0;
1372 j = 0;
1373 break;
1374 default:
1375 j++;
1376 break;
1377 }
1378 }
1379
1380 /*
1381 * Disable 4 PCCs for Xena1, 2 and 3 as per H/W bug
1382 * SXE-008 TRANSMIT DMA ARBITRATION ISSUE.
1383 */
1384 if ((nic->device_type == XFRAME_I_DEVICE) &&
1385 (nic->pdev->revision < 4))
1386 writeq(PCC_ENABLE_FOUR, &bar0->pcc_enable);
1387
1388 val64 = readq(&bar0->tx_fifo_partition_0);
1389 DBG_PRINT(INIT_DBG, "Fifo partition at: 0x%p is: 0x%llx\n",
1390 &bar0->tx_fifo_partition_0, (unsigned long long) val64);
1391
1392 /*
1393 * Initialization of Tx_PA_CONFIG register to ignore packet
1394 * integrity checking.
1395 */
1396 val64 = readq(&bar0->tx_pa_cfg);
1397 val64 |= TX_PA_CFG_IGNORE_FRM_ERR | TX_PA_CFG_IGNORE_SNAP_OUI |
1398 TX_PA_CFG_IGNORE_LLC_CTRL | TX_PA_CFG_IGNORE_L2_ERR;
1399 writeq(val64, &bar0->tx_pa_cfg);
1400
1401 /* Rx DMA intialization. */
1402 val64 = 0;
1403 for (i = 0; i < config->rx_ring_num; i++) {
1404 val64 |=
1405 vBIT(config->rx_cfg[i].ring_priority, (5 + (i * 8)),
1406 3);
1407 }
1408 writeq(val64, &bar0->rx_queue_priority);
1409
1410 /*
1411 * Allocating equal share of memory to all the
1412 * configured Rings.
1413 */
1414 val64 = 0;
1415 if (nic->device_type & XFRAME_II_DEVICE)
1416 mem_size = 32;
1417 else
1418 mem_size = 64;
1419
1420 for (i = 0; i < config->rx_ring_num; i++) {
1421 switch (i) {
1422 case 0:
1423 mem_share = (mem_size / config->rx_ring_num +
1424 mem_size % config->rx_ring_num);
1425 val64 |= RX_QUEUE_CFG_Q0_SZ(mem_share);
1426 continue;
1427 case 1:
1428 mem_share = (mem_size / config->rx_ring_num);
1429 val64 |= RX_QUEUE_CFG_Q1_SZ(mem_share);
1430 continue;
1431 case 2:
1432 mem_share = (mem_size / config->rx_ring_num);
1433 val64 |= RX_QUEUE_CFG_Q2_SZ(mem_share);
1434 continue;
1435 case 3:
1436 mem_share = (mem_size / config->rx_ring_num);
1437 val64 |= RX_QUEUE_CFG_Q3_SZ(mem_share);
1438 continue;
1439 case 4:
1440 mem_share = (mem_size / config->rx_ring_num);
1441 val64 |= RX_QUEUE_CFG_Q4_SZ(mem_share);
1442 continue;
1443 case 5:
1444 mem_share = (mem_size / config->rx_ring_num);
1445 val64 |= RX_QUEUE_CFG_Q5_SZ(mem_share);
1446 continue;
1447 case 6:
1448 mem_share = (mem_size / config->rx_ring_num);
1449 val64 |= RX_QUEUE_CFG_Q6_SZ(mem_share);
1450 continue;
1451 case 7:
1452 mem_share = (mem_size / config->rx_ring_num);
1453 val64 |= RX_QUEUE_CFG_Q7_SZ(mem_share);
1454 continue;
1455 }
1456 }
1457 writeq(val64, &bar0->rx_queue_cfg);
1458
1459 /*
1460 * Filling Tx round robin registers
1461 * as per the number of FIFOs for equal scheduling priority
1462 */
1463 switch (config->tx_fifo_num) {
1464 case 1:
1465 val64 = 0x0;
1466 writeq(val64, &bar0->tx_w_round_robin_0);
1467 writeq(val64, &bar0->tx_w_round_robin_1);
1468 writeq(val64, &bar0->tx_w_round_robin_2);
1469 writeq(val64, &bar0->tx_w_round_robin_3);
1470 writeq(val64, &bar0->tx_w_round_robin_4);
1471 break;
1472 case 2:
1473 val64 = 0x0001000100010001ULL;
1474 writeq(val64, &bar0->tx_w_round_robin_0);
1475 writeq(val64, &bar0->tx_w_round_robin_1);
1476 writeq(val64, &bar0->tx_w_round_robin_2);
1477 writeq(val64, &bar0->tx_w_round_robin_3);
1478 val64 = 0x0001000100000000ULL;
1479 writeq(val64, &bar0->tx_w_round_robin_4);
1480 break;
1481 case 3:
1482 val64 = 0x0001020001020001ULL;
1483 writeq(val64, &bar0->tx_w_round_robin_0);
1484 val64 = 0x0200010200010200ULL;
1485 writeq(val64, &bar0->tx_w_round_robin_1);
1486 val64 = 0x0102000102000102ULL;
1487 writeq(val64, &bar0->tx_w_round_robin_2);
1488 val64 = 0x0001020001020001ULL;
1489 writeq(val64, &bar0->tx_w_round_robin_3);
1490 val64 = 0x0200010200000000ULL;
1491 writeq(val64, &bar0->tx_w_round_robin_4);
1492 break;
1493 case 4:
1494 val64 = 0x0001020300010203ULL;
1495 writeq(val64, &bar0->tx_w_round_robin_0);
1496 writeq(val64, &bar0->tx_w_round_robin_1);
1497 writeq(val64, &bar0->tx_w_round_robin_2);
1498 writeq(val64, &bar0->tx_w_round_robin_3);
1499 val64 = 0x0001020300000000ULL;
1500 writeq(val64, &bar0->tx_w_round_robin_4);
1501 break;
1502 case 5:
1503 val64 = 0x0001020304000102ULL;
1504 writeq(val64, &bar0->tx_w_round_robin_0);
1505 val64 = 0x0304000102030400ULL;
1506 writeq(val64, &bar0->tx_w_round_robin_1);
1507 val64 = 0x0102030400010203ULL;
1508 writeq(val64, &bar0->tx_w_round_robin_2);
1509 val64 = 0x0400010203040001ULL;
1510 writeq(val64, &bar0->tx_w_round_robin_3);
1511 val64 = 0x0203040000000000ULL;
1512 writeq(val64, &bar0->tx_w_round_robin_4);
1513 break;
1514 case 6:
1515 val64 = 0x0001020304050001ULL;
1516 writeq(val64, &bar0->tx_w_round_robin_0);
1517 val64 = 0x0203040500010203ULL;
1518 writeq(val64, &bar0->tx_w_round_robin_1);
1519 val64 = 0x0405000102030405ULL;
1520 writeq(val64, &bar0->tx_w_round_robin_2);
1521 val64 = 0x0001020304050001ULL;
1522 writeq(val64, &bar0->tx_w_round_robin_3);
1523 val64 = 0x0203040500000000ULL;
1524 writeq(val64, &bar0->tx_w_round_robin_4);
1525 break;
1526 case 7:
1527 val64 = 0x0001020304050600ULL;
1528 writeq(val64, &bar0->tx_w_round_robin_0);
1529 val64 = 0x0102030405060001ULL;
1530 writeq(val64, &bar0->tx_w_round_robin_1);
1531 val64 = 0x0203040506000102ULL;
1532 writeq(val64, &bar0->tx_w_round_robin_2);
1533 val64 = 0x0304050600010203ULL;
1534 writeq(val64, &bar0->tx_w_round_robin_3);
1535 val64 = 0x0405060000000000ULL;
1536 writeq(val64, &bar0->tx_w_round_robin_4);
1537 break;
1538 case 8:
1539 val64 = 0x0001020304050607ULL;
1540 writeq(val64, &bar0->tx_w_round_robin_0);
1541 writeq(val64, &bar0->tx_w_round_robin_1);
1542 writeq(val64, &bar0->tx_w_round_robin_2);
1543 writeq(val64, &bar0->tx_w_round_robin_3);
1544 val64 = 0x0001020300000000ULL;
1545 writeq(val64, &bar0->tx_w_round_robin_4);
1546 break;
1547 }
1548
1549 /* Enable all configured Tx FIFO partitions */
1550 val64 = readq(&bar0->tx_fifo_partition_0);
1551 val64 |= (TX_FIFO_PARTITION_EN);
1552 writeq(val64, &bar0->tx_fifo_partition_0);
1553
1554 /* Filling the Rx round robin registers as per the
1555 * number of Rings and steering based on QoS with
1556 * equal priority.
1557 */
1558 switch (config->rx_ring_num) {
1559 case 1:
1560 val64 = 0x0;
1561 writeq(val64, &bar0->rx_w_round_robin_0);
1562 writeq(val64, &bar0->rx_w_round_robin_1);
1563 writeq(val64, &bar0->rx_w_round_robin_2);
1564 writeq(val64, &bar0->rx_w_round_robin_3);
1565 writeq(val64, &bar0->rx_w_round_robin_4);
1566
1567 val64 = 0x8080808080808080ULL;
1568 writeq(val64, &bar0->rts_qos_steering);
1569 break;
1570 case 2:
1571 val64 = 0x0001000100010001ULL;
1572 writeq(val64, &bar0->rx_w_round_robin_0);
1573 writeq(val64, &bar0->rx_w_round_robin_1);
1574 writeq(val64, &bar0->rx_w_round_robin_2);
1575 writeq(val64, &bar0->rx_w_round_robin_3);
1576 val64 = 0x0001000100000000ULL;
1577 writeq(val64, &bar0->rx_w_round_robin_4);
1578
1579 val64 = 0x8080808040404040ULL;
1580 writeq(val64, &bar0->rts_qos_steering);
1581 break;
1582 case 3:
1583 val64 = 0x0001020001020001ULL;
1584 writeq(val64, &bar0->rx_w_round_robin_0);
1585 val64 = 0x0200010200010200ULL;
1586 writeq(val64, &bar0->rx_w_round_robin_1);
1587 val64 = 0x0102000102000102ULL;
1588 writeq(val64, &bar0->rx_w_round_robin_2);
1589 val64 = 0x0001020001020001ULL;
1590 writeq(val64, &bar0->rx_w_round_robin_3);
1591 val64 = 0x0200010200000000ULL;
1592 writeq(val64, &bar0->rx_w_round_robin_4);
1593
1594 val64 = 0x8080804040402020ULL;
1595 writeq(val64, &bar0->rts_qos_steering);
1596 break;
1597 case 4:
1598 val64 = 0x0001020300010203ULL;
1599 writeq(val64, &bar0->rx_w_round_robin_0);
1600 writeq(val64, &bar0->rx_w_round_robin_1);
1601 writeq(val64, &bar0->rx_w_round_robin_2);
1602 writeq(val64, &bar0->rx_w_round_robin_3);
1603 val64 = 0x0001020300000000ULL;
1604 writeq(val64, &bar0->rx_w_round_robin_4);
1605
1606 val64 = 0x8080404020201010ULL;
1607 writeq(val64, &bar0->rts_qos_steering);
1608 break;
1609 case 5:
1610 val64 = 0x0001020304000102ULL;
1611 writeq(val64, &bar0->rx_w_round_robin_0);
1612 val64 = 0x0304000102030400ULL;
1613 writeq(val64, &bar0->rx_w_round_robin_1);
1614 val64 = 0x0102030400010203ULL;
1615 writeq(val64, &bar0->rx_w_round_robin_2);
1616 val64 = 0x0400010203040001ULL;
1617 writeq(val64, &bar0->rx_w_round_robin_3);
1618 val64 = 0x0203040000000000ULL;
1619 writeq(val64, &bar0->rx_w_round_robin_4);
1620
1621 val64 = 0x8080404020201008ULL;
1622 writeq(val64, &bar0->rts_qos_steering);
1623 break;
1624 case 6:
1625 val64 = 0x0001020304050001ULL;
1626 writeq(val64, &bar0->rx_w_round_robin_0);
1627 val64 = 0x0203040500010203ULL;
1628 writeq(val64, &bar0->rx_w_round_robin_1);
1629 val64 = 0x0405000102030405ULL;
1630 writeq(val64, &bar0->rx_w_round_robin_2);
1631 val64 = 0x0001020304050001ULL;
1632 writeq(val64, &bar0->rx_w_round_robin_3);
1633 val64 = 0x0203040500000000ULL;
1634 writeq(val64, &bar0->rx_w_round_robin_4);
1635
1636 val64 = 0x8080404020100804ULL;
1637 writeq(val64, &bar0->rts_qos_steering);
1638 break;
1639 case 7:
1640 val64 = 0x0001020304050600ULL;
1641 writeq(val64, &bar0->rx_w_round_robin_0);
1642 val64 = 0x0102030405060001ULL;
1643 writeq(val64, &bar0->rx_w_round_robin_1);
1644 val64 = 0x0203040506000102ULL;
1645 writeq(val64, &bar0->rx_w_round_robin_2);
1646 val64 = 0x0304050600010203ULL;
1647 writeq(val64, &bar0->rx_w_round_robin_3);
1648 val64 = 0x0405060000000000ULL;
1649 writeq(val64, &bar0->rx_w_round_robin_4);
1650
1651 val64 = 0x8080402010080402ULL;
1652 writeq(val64, &bar0->rts_qos_steering);
1653 break;
1654 case 8:
1655 val64 = 0x0001020304050607ULL;
1656 writeq(val64, &bar0->rx_w_round_robin_0);
1657 writeq(val64, &bar0->rx_w_round_robin_1);
1658 writeq(val64, &bar0->rx_w_round_robin_2);
1659 writeq(val64, &bar0->rx_w_round_robin_3);
1660 val64 = 0x0001020300000000ULL;
1661 writeq(val64, &bar0->rx_w_round_robin_4);
1662
1663 val64 = 0x8040201008040201ULL;
1664 writeq(val64, &bar0->rts_qos_steering);
1665 break;
1666 }
1667
1668 /* UDP Fix */
1669 val64 = 0;
1670 for (i = 0; i < 8; i++)
1671 writeq(val64, &bar0->rts_frm_len_n[i]);
1672
1673 /* Set the default rts frame length for the rings configured */
1674 val64 = MAC_RTS_FRM_LEN_SET(dev->mtu+22);
1675 for (i = 0 ; i < config->rx_ring_num ; i++)
1676 writeq(val64, &bar0->rts_frm_len_n[i]);
1677
1678 /* Set the frame length for the configured rings
1679 * desired by the user
1680 */
1681 for (i = 0; i < config->rx_ring_num; i++) {
1682 /* If rts_frm_len[i] == 0 then it is assumed that user not
1683 * specified frame length steering.
1684 * If the user provides the frame length then program
1685 * the rts_frm_len register for those values or else
1686 * leave it as it is.
1687 */
1688 if (rts_frm_len[i] != 0) {
1689 writeq(MAC_RTS_FRM_LEN_SET(rts_frm_len[i]),
1690 &bar0->rts_frm_len_n[i]);
1691 }
1692 }
1693
1694 /* Disable differentiated services steering logic */
1695 for (i = 0; i < 64; i++) {
1696 if (rts_ds_steer(nic, i, 0) == FAILURE) {
1697 DBG_PRINT(ERR_DBG, "%s: failed rts ds steering",
1698 dev->name);
1699 DBG_PRINT(ERR_DBG, "set on codepoint %d\n", i);
1700 return -ENODEV;
1701 }
1702 }
1703
1704 /* Program statistics memory */
1705 writeq(mac_control->stats_mem_phy, &bar0->stat_addr);
1706
1707 if (nic->device_type == XFRAME_II_DEVICE) {
1708 val64 = STAT_BC(0x320);
1709 writeq(val64, &bar0->stat_byte_cnt);
1710 }
1711
1712 /*
1713 * Initializing the sampling rate for the device to calculate the
1714 * bandwidth utilization.
1715 */
1716 val64 = MAC_TX_LINK_UTIL_VAL(tmac_util_period) |
1717 MAC_RX_LINK_UTIL_VAL(rmac_util_period);
1718 writeq(val64, &bar0->mac_link_util);
1719
1720 /*
1721 * Initializing the Transmit and Receive Traffic Interrupt
1722 * Scheme.
1723 */
1724
1725 /* Initialize TTI */
1726 if (SUCCESS != init_tti(nic, nic->last_link_state))
1727 return -ENODEV;
1728
1729 /* RTI Initialization */
1730 if (nic->device_type == XFRAME_II_DEVICE) {
1731 /*
1732 * Programmed to generate Apprx 500 Intrs per
1733 * second
1734 */
1735 int count = (nic->config.bus_speed * 125)/4;
1736 val64 = RTI_DATA1_MEM_RX_TIMER_VAL(count);
1737 } else
1738 val64 = RTI_DATA1_MEM_RX_TIMER_VAL(0xFFF);
1739 val64 |= RTI_DATA1_MEM_RX_URNG_A(0xA) |
1740 RTI_DATA1_MEM_RX_URNG_B(0x10) |
1741 RTI_DATA1_MEM_RX_URNG_C(0x30) | RTI_DATA1_MEM_RX_TIMER_AC_EN;
1742
1743 writeq(val64, &bar0->rti_data1_mem);
1744
1745 val64 = RTI_DATA2_MEM_RX_UFC_A(0x1) |
1746 RTI_DATA2_MEM_RX_UFC_B(0x2) ;
1747 if (nic->config.intr_type == MSI_X)
1748 val64 |= (RTI_DATA2_MEM_RX_UFC_C(0x20) | \
1749 RTI_DATA2_MEM_RX_UFC_D(0x40));
1750 else
1751 val64 |= (RTI_DATA2_MEM_RX_UFC_C(0x40) | \
1752 RTI_DATA2_MEM_RX_UFC_D(0x80));
1753 writeq(val64, &bar0->rti_data2_mem);
1754
1755 for (i = 0; i < config->rx_ring_num; i++) {
1756 val64 = RTI_CMD_MEM_WE | RTI_CMD_MEM_STROBE_NEW_CMD
1757 | RTI_CMD_MEM_OFFSET(i);
1758 writeq(val64, &bar0->rti_command_mem);
1759
1760 /*
1761 * Once the operation completes, the Strobe bit of the
1762 * command register will be reset. We poll for this
1763 * particular condition. We wait for a maximum of 500ms
1764 * for the operation to complete, if it's not complete
1765 * by then we return error.
1766 */
1767 time = 0;
1768 while (TRUE) {
1769 val64 = readq(&bar0->rti_command_mem);
1770 if (!(val64 & RTI_CMD_MEM_STROBE_NEW_CMD))
1771 break;
1772
1773 if (time > 10) {
1774 DBG_PRINT(ERR_DBG, "%s: RTI init Failed\n",
1775 dev->name);
1776 return -ENODEV;
1777 }
1778 time++;
1779 msleep(50);
1780 }
1781 }
1782
1783 /*
1784 * Initializing proper values as Pause threshold into all
1785 * the 8 Queues on Rx side.
1786 */
1787 writeq(0xffbbffbbffbbffbbULL, &bar0->mc_pause_thresh_q0q3);
1788 writeq(0xffbbffbbffbbffbbULL, &bar0->mc_pause_thresh_q4q7);
1789
1790 /* Disable RMAC PAD STRIPPING */
1791 add = &bar0->mac_cfg;
1792 val64 = readq(&bar0->mac_cfg);
1793 val64 &= ~(MAC_CFG_RMAC_STRIP_PAD);
1794 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
1795 writel((u32) (val64), add);
1796 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
1797 writel((u32) (val64 >> 32), (add + 4));
1798 val64 = readq(&bar0->mac_cfg);
1799
1800 /* Enable FCS stripping by adapter */
1801 add = &bar0->mac_cfg;
1802 val64 = readq(&bar0->mac_cfg);
1803 val64 |= MAC_CFG_RMAC_STRIP_FCS;
1804 if (nic->device_type == XFRAME_II_DEVICE)
1805 writeq(val64, &bar0->mac_cfg);
1806 else {
1807 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
1808 writel((u32) (val64), add);
1809 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
1810 writel((u32) (val64 >> 32), (add + 4));
1811 }
1812
1813 /*
1814 * Set the time value to be inserted in the pause frame
1815 * generated by xena.
1816 */
1817 val64 = readq(&bar0->rmac_pause_cfg);
1818 val64 &= ~(RMAC_PAUSE_HG_PTIME(0xffff));
1819 val64 |= RMAC_PAUSE_HG_PTIME(nic->mac_control.rmac_pause_time);
1820 writeq(val64, &bar0->rmac_pause_cfg);
1821
1822 /*
1823 * Set the Threshold Limit for Generating the pause frame
1824 * If the amount of data in any Queue exceeds ratio of
1825 * (mac_control.mc_pause_threshold_q0q3 or q4q7)/256
1826 * pause frame is generated
1827 */
1828 val64 = 0;
1829 for (i = 0; i < 4; i++) {
1830 val64 |=
1831 (((u64) 0xFF00 | nic->mac_control.
1832 mc_pause_threshold_q0q3)
1833 << (i * 2 * 8));
1834 }
1835 writeq(val64, &bar0->mc_pause_thresh_q0q3);
1836
1837 val64 = 0;
1838 for (i = 0; i < 4; i++) {
1839 val64 |=
1840 (((u64) 0xFF00 | nic->mac_control.
1841 mc_pause_threshold_q4q7)
1842 << (i * 2 * 8));
1843 }
1844 writeq(val64, &bar0->mc_pause_thresh_q4q7);
1845
1846 /*
1847 * TxDMA will stop Read request if the number of read split has
1848 * exceeded the limit pointed by shared_splits
1849 */
1850 val64 = readq(&bar0->pic_control);
1851 val64 |= PIC_CNTL_SHARED_SPLITS(shared_splits);
1852 writeq(val64, &bar0->pic_control);
1853
1854 if (nic->config.bus_speed == 266) {
1855 writeq(TXREQTO_VAL(0x7f) | TXREQTO_EN, &bar0->txreqtimeout);
1856 writeq(0x0, &bar0->read_retry_delay);
1857 writeq(0x0, &bar0->write_retry_delay);
1858 }
1859
1860 /*
1861 * Programming the Herc to split every write transaction
1862 * that does not start on an ADB to reduce disconnects.
1863 */
1864 if (nic->device_type == XFRAME_II_DEVICE) {
1865 val64 = FAULT_BEHAVIOUR | EXT_REQ_EN |
1866 MISC_LINK_STABILITY_PRD(3);
1867 writeq(val64, &bar0->misc_control);
1868 val64 = readq(&bar0->pic_control2);
1869 val64 &= ~(s2BIT(13)|s2BIT(14)|s2BIT(15));
1870 writeq(val64, &bar0->pic_control2);
1871 }
1872 if (strstr(nic->product_name, "CX4")) {
1873 val64 = TMAC_AVG_IPG(0x17);
1874 writeq(val64, &bar0->tmac_avg_ipg);
1875 }
1876
1877 return SUCCESS;
1878 }
1879 #define LINK_UP_DOWN_INTERRUPT 1
1880 #define MAC_RMAC_ERR_TIMER 2
1881
1882 static int s2io_link_fault_indication(struct s2io_nic *nic)
1883 {
1884 if (nic->device_type == XFRAME_II_DEVICE)
1885 return LINK_UP_DOWN_INTERRUPT;
1886 else
1887 return MAC_RMAC_ERR_TIMER;
1888 }
1889
1890 /**
1891 * do_s2io_write_bits - update alarm bits in alarm register
1892 * @value: alarm bits
1893 * @flag: interrupt status
1894 * @addr: address value
1895 * Description: update alarm bits in alarm register
1896 * Return Value:
1897 * NONE.
1898 */
1899 static void do_s2io_write_bits(u64 value, int flag, void __iomem *addr)
1900 {
1901 u64 temp64;
1902
1903 temp64 = readq(addr);
1904
1905 if(flag == ENABLE_INTRS)
1906 temp64 &= ~((u64) value);
1907 else
1908 temp64 |= ((u64) value);
1909 writeq(temp64, addr);
1910 }
1911
1912 static void en_dis_err_alarms(struct s2io_nic *nic, u16 mask, int flag)
1913 {
1914 struct XENA_dev_config __iomem *bar0 = nic->bar0;
1915 register u64 gen_int_mask = 0;
1916 u64 interruptible;
1917
1918 writeq(DISABLE_ALL_INTRS, &bar0->general_int_mask);
1919 if (mask & TX_DMA_INTR) {
1920
1921 gen_int_mask |= TXDMA_INT_M;
1922
1923 do_s2io_write_bits(TXDMA_TDA_INT | TXDMA_PFC_INT |
1924 TXDMA_PCC_INT | TXDMA_TTI_INT |
1925 TXDMA_LSO_INT | TXDMA_TPA_INT |
1926 TXDMA_SM_INT, flag, &bar0->txdma_int_mask);
1927
1928 do_s2io_write_bits(PFC_ECC_DB_ERR | PFC_SM_ERR_ALARM |
1929 PFC_MISC_0_ERR | PFC_MISC_1_ERR |
1930 PFC_PCIX_ERR | PFC_ECC_SG_ERR, flag,
1931 &bar0->pfc_err_mask);
1932
1933 do_s2io_write_bits(TDA_Fn_ECC_DB_ERR | TDA_SM0_ERR_ALARM |
1934 TDA_SM1_ERR_ALARM | TDA_Fn_ECC_SG_ERR |
1935 TDA_PCIX_ERR, flag, &bar0->tda_err_mask);
1936
1937 do_s2io_write_bits(PCC_FB_ECC_DB_ERR | PCC_TXB_ECC_DB_ERR |
1938 PCC_SM_ERR_ALARM | PCC_WR_ERR_ALARM |
1939 PCC_N_SERR | PCC_6_COF_OV_ERR |
1940 PCC_7_COF_OV_ERR | PCC_6_LSO_OV_ERR |
1941 PCC_7_LSO_OV_ERR | PCC_FB_ECC_SG_ERR |
1942 PCC_TXB_ECC_SG_ERR, flag, &bar0->pcc_err_mask);
1943
1944 do_s2io_write_bits(TTI_SM_ERR_ALARM | TTI_ECC_SG_ERR |
1945 TTI_ECC_DB_ERR, flag, &bar0->tti_err_mask);
1946
1947 do_s2io_write_bits(LSO6_ABORT | LSO7_ABORT |
1948 LSO6_SM_ERR_ALARM | LSO7_SM_ERR_ALARM |
1949 LSO6_SEND_OFLOW | LSO7_SEND_OFLOW,
1950 flag, &bar0->lso_err_mask);
1951
1952 do_s2io_write_bits(TPA_SM_ERR_ALARM | TPA_TX_FRM_DROP,
1953 flag, &bar0->tpa_err_mask);
1954
1955 do_s2io_write_bits(SM_SM_ERR_ALARM, flag, &bar0->sm_err_mask);
1956
1957 }
1958
1959 if (mask & TX_MAC_INTR) {
1960 gen_int_mask |= TXMAC_INT_M;
1961 do_s2io_write_bits(MAC_INT_STATUS_TMAC_INT, flag,
1962 &bar0->mac_int_mask);
1963 do_s2io_write_bits(TMAC_TX_BUF_OVRN | TMAC_TX_SM_ERR |
1964 TMAC_ECC_SG_ERR | TMAC_ECC_DB_ERR |
1965 TMAC_DESC_ECC_SG_ERR | TMAC_DESC_ECC_DB_ERR,
1966 flag, &bar0->mac_tmac_err_mask);
1967 }
1968
1969 if (mask & TX_XGXS_INTR) {
1970 gen_int_mask |= TXXGXS_INT_M;
1971 do_s2io_write_bits(XGXS_INT_STATUS_TXGXS, flag,
1972 &bar0->xgxs_int_mask);
1973 do_s2io_write_bits(TXGXS_ESTORE_UFLOW | TXGXS_TX_SM_ERR |
1974 TXGXS_ECC_SG_ERR | TXGXS_ECC_DB_ERR,
1975 flag, &bar0->xgxs_txgxs_err_mask);
1976 }
1977
1978 if (mask & RX_DMA_INTR) {
1979 gen_int_mask |= RXDMA_INT_M;
1980 do_s2io_write_bits(RXDMA_INT_RC_INT_M | RXDMA_INT_RPA_INT_M |
1981 RXDMA_INT_RDA_INT_M | RXDMA_INT_RTI_INT_M,
1982 flag, &bar0->rxdma_int_mask);
1983 do_s2io_write_bits(RC_PRCn_ECC_DB_ERR | RC_FTC_ECC_DB_ERR |
1984 RC_PRCn_SM_ERR_ALARM | RC_FTC_SM_ERR_ALARM |
1985 RC_PRCn_ECC_SG_ERR | RC_FTC_ECC_SG_ERR |
1986 RC_RDA_FAIL_WR_Rn, flag, &bar0->rc_err_mask);
1987 do_s2io_write_bits(PRC_PCI_AB_RD_Rn | PRC_PCI_AB_WR_Rn |
1988 PRC_PCI_AB_F_WR_Rn | PRC_PCI_DP_RD_Rn |
1989 PRC_PCI_DP_WR_Rn | PRC_PCI_DP_F_WR_Rn, flag,
1990 &bar0->prc_pcix_err_mask);
1991 do_s2io_write_bits(RPA_SM_ERR_ALARM | RPA_CREDIT_ERR |
1992 RPA_ECC_SG_ERR | RPA_ECC_DB_ERR, flag,
1993 &bar0->rpa_err_mask);
1994 do_s2io_write_bits(RDA_RXDn_ECC_DB_ERR | RDA_FRM_ECC_DB_N_AERR |
1995 RDA_SM1_ERR_ALARM | RDA_SM0_ERR_ALARM |
1996 RDA_RXD_ECC_DB_SERR | RDA_RXDn_ECC_SG_ERR |
1997 RDA_FRM_ECC_SG_ERR | RDA_MISC_ERR|RDA_PCIX_ERR,
1998 flag, &bar0->rda_err_mask);
1999 do_s2io_write_bits(RTI_SM_ERR_ALARM |
2000 RTI_ECC_SG_ERR | RTI_ECC_DB_ERR,
2001 flag, &bar0->rti_err_mask);
2002 }
2003
2004 if (mask & RX_MAC_INTR) {
2005 gen_int_mask |= RXMAC_INT_M;
2006 do_s2io_write_bits(MAC_INT_STATUS_RMAC_INT, flag,
2007 &bar0->mac_int_mask);
2008 interruptible = RMAC_RX_BUFF_OVRN | RMAC_RX_SM_ERR |
2009 RMAC_UNUSED_INT | RMAC_SINGLE_ECC_ERR |
2010 RMAC_DOUBLE_ECC_ERR;
2011 if (s2io_link_fault_indication(nic) == MAC_RMAC_ERR_TIMER)
2012 interruptible |= RMAC_LINK_STATE_CHANGE_INT;
2013 do_s2io_write_bits(interruptible,
2014 flag, &bar0->mac_rmac_err_mask);
2015 }
2016
2017 if (mask & RX_XGXS_INTR)
2018 {
2019 gen_int_mask |= RXXGXS_INT_M;
2020 do_s2io_write_bits(XGXS_INT_STATUS_RXGXS, flag,
2021 &bar0->xgxs_int_mask);
2022 do_s2io_write_bits(RXGXS_ESTORE_OFLOW | RXGXS_RX_SM_ERR, flag,
2023 &bar0->xgxs_rxgxs_err_mask);
2024 }
2025
2026 if (mask & MC_INTR) {
2027 gen_int_mask |= MC_INT_M;
2028 do_s2io_write_bits(MC_INT_MASK_MC_INT, flag, &bar0->mc_int_mask);
2029 do_s2io_write_bits(MC_ERR_REG_SM_ERR | MC_ERR_REG_ECC_ALL_SNG |
2030 MC_ERR_REG_ECC_ALL_DBL | PLL_LOCK_N, flag,
2031 &bar0->mc_err_mask);
2032 }
2033 nic->general_int_mask = gen_int_mask;
2034
2035 /* Remove this line when alarm interrupts are enabled */
2036 nic->general_int_mask = 0;
2037 }
2038 /**
2039 * en_dis_able_nic_intrs - Enable or Disable the interrupts
2040 * @nic: device private variable,
2041 * @mask: A mask indicating which Intr block must be modified and,
2042 * @flag: A flag indicating whether to enable or disable the Intrs.
2043 * Description: This function will either disable or enable the interrupts
2044 * depending on the flag argument. The mask argument can be used to
2045 * enable/disable any Intr block.
2046 * Return Value: NONE.
2047 */
2048
2049 static void en_dis_able_nic_intrs(struct s2io_nic *nic, u16 mask, int flag)
2050 {
2051 struct XENA_dev_config __iomem *bar0 = nic->bar0;
2052 register u64 temp64 = 0, intr_mask = 0;
2053
2054 intr_mask = nic->general_int_mask;
2055
2056 /* Top level interrupt classification */
2057 /* PIC Interrupts */
2058 if (mask & TX_PIC_INTR) {
2059 /* Enable PIC Intrs in the general intr mask register */
2060 intr_mask |= TXPIC_INT_M;
2061 if (flag == ENABLE_INTRS) {
2062 /*
2063 * If Hercules adapter enable GPIO otherwise
2064 * disable all PCIX, Flash, MDIO, IIC and GPIO
2065 * interrupts for now.
2066 * TODO
2067 */
2068 if (s2io_link_fault_indication(nic) ==
2069 LINK_UP_DOWN_INTERRUPT ) {
2070 do_s2io_write_bits(PIC_INT_GPIO, flag,
2071 &bar0->pic_int_mask);
2072 do_s2io_write_bits(GPIO_INT_MASK_LINK_UP, flag,
2073 &bar0->gpio_int_mask);
2074 } else
2075 writeq(DISABLE_ALL_INTRS, &bar0->pic_int_mask);
2076 } else if (flag == DISABLE_INTRS) {
2077 /*
2078 * Disable PIC Intrs in the general
2079 * intr mask register
2080 */
2081 writeq(DISABLE_ALL_INTRS, &bar0->pic_int_mask);
2082 }
2083 }
2084
2085 /* Tx traffic interrupts */
2086 if (mask & TX_TRAFFIC_INTR) {
2087 intr_mask |= TXTRAFFIC_INT_M;
2088 if (flag == ENABLE_INTRS) {
2089 /*
2090 * Enable all the Tx side interrupts
2091 * writing 0 Enables all 64 TX interrupt levels
2092 */
2093 writeq(0x0, &bar0->tx_traffic_mask);
2094 } else if (flag == DISABLE_INTRS) {
2095 /*
2096 * Disable Tx Traffic Intrs in the general intr mask
2097 * register.
2098 */
2099 writeq(DISABLE_ALL_INTRS, &bar0->tx_traffic_mask);
2100 }
2101 }
2102
2103 /* Rx traffic interrupts */
2104 if (mask & RX_TRAFFIC_INTR) {
2105 intr_mask |= RXTRAFFIC_INT_M;
2106 if (flag == ENABLE_INTRS) {
2107 /* writing 0 Enables all 8 RX interrupt levels */
2108 writeq(0x0, &bar0->rx_traffic_mask);
2109 } else if (flag == DISABLE_INTRS) {
2110 /*
2111 * Disable Rx Traffic Intrs in the general intr mask
2112 * register.
2113 */
2114 writeq(DISABLE_ALL_INTRS, &bar0->rx_traffic_mask);
2115 }
2116 }
2117
2118 temp64 = readq(&bar0->general_int_mask);
2119 if (flag == ENABLE_INTRS)
2120 temp64 &= ~((u64) intr_mask);
2121 else
2122 temp64 = DISABLE_ALL_INTRS;
2123 writeq(temp64, &bar0->general_int_mask);
2124
2125 nic->general_int_mask = readq(&bar0->general_int_mask);
2126 }
2127
2128 /**
2129 * verify_pcc_quiescent- Checks for PCC quiescent state
2130 * Return: 1 If PCC is quiescence
2131 * 0 If PCC is not quiescence
2132 */
2133 static int verify_pcc_quiescent(struct s2io_nic *sp, int flag)
2134 {
2135 int ret = 0, herc;
2136 struct XENA_dev_config __iomem *bar0 = sp->bar0;
2137 u64 val64 = readq(&bar0->adapter_status);
2138
2139 herc = (sp->device_type == XFRAME_II_DEVICE);
2140
2141 if (flag == FALSE) {
2142 if ((!herc && (sp->pdev->revision >= 4)) || herc) {
2143 if (!(val64 & ADAPTER_STATUS_RMAC_PCC_IDLE))
2144 ret = 1;
2145 } else {
2146 if (!(val64 & ADAPTER_STATUS_RMAC_PCC_FOUR_IDLE))
2147 ret = 1;
2148 }
2149 } else {
2150 if ((!herc && (sp->pdev->revision >= 4)) || herc) {
2151 if (((val64 & ADAPTER_STATUS_RMAC_PCC_IDLE) ==
2152 ADAPTER_STATUS_RMAC_PCC_IDLE))
2153 ret = 1;
2154 } else {
2155 if (((val64 & ADAPTER_STATUS_RMAC_PCC_FOUR_IDLE) ==
2156 ADAPTER_STATUS_RMAC_PCC_FOUR_IDLE))
2157 ret = 1;
2158 }
2159 }
2160
2161 return ret;
2162 }
2163 /**
2164 * verify_xena_quiescence - Checks whether the H/W is ready
2165 * Description: Returns whether the H/W is ready to go or not. Depending
2166 * on whether adapter enable bit was written or not the comparison
2167 * differs and the calling function passes the input argument flag to
2168 * indicate this.
2169 * Return: 1 If xena is quiescence
2170 * 0 If Xena is not quiescence
2171 */
2172
2173 static int verify_xena_quiescence(struct s2io_nic *sp)
2174 {
2175 int mode;
2176 struct XENA_dev_config __iomem *bar0 = sp->bar0;
2177 u64 val64 = readq(&bar0->adapter_status);
2178 mode = s2io_verify_pci_mode(sp);
2179
2180 if (!(val64 & ADAPTER_STATUS_TDMA_READY)) {
2181 DBG_PRINT(ERR_DBG, "%s", "TDMA is not ready!");
2182 return 0;
2183 }
2184 if (!(val64 & ADAPTER_STATUS_RDMA_READY)) {
2185 DBG_PRINT(ERR_DBG, "%s", "RDMA is not ready!");
2186 return 0;
2187 }
2188 if (!(val64 & ADAPTER_STATUS_PFC_READY)) {
2189 DBG_PRINT(ERR_DBG, "%s", "PFC is not ready!");
2190 return 0;
2191 }
2192 if (!(val64 & ADAPTER_STATUS_TMAC_BUF_EMPTY)) {
2193 DBG_PRINT(ERR_DBG, "%s", "TMAC BUF is not empty!");
2194 return 0;
2195 }
2196 if (!(val64 & ADAPTER_STATUS_PIC_QUIESCENT)) {
2197 DBG_PRINT(ERR_DBG, "%s", "PIC is not QUIESCENT!");
2198 return 0;
2199 }
2200 if (!(val64 & ADAPTER_STATUS_MC_DRAM_READY)) {
2201 DBG_PRINT(ERR_DBG, "%s", "MC_DRAM is not ready!");
2202 return 0;
2203 }
2204 if (!(val64 & ADAPTER_STATUS_MC_QUEUES_READY)) {
2205 DBG_PRINT(ERR_DBG, "%s", "MC_QUEUES is not ready!");
2206 return 0;
2207 }
2208 if (!(val64 & ADAPTER_STATUS_M_PLL_LOCK)) {
2209 DBG_PRINT(ERR_DBG, "%s", "M_PLL is not locked!");
2210 return 0;
2211 }
2212
2213 /*
2214 * In PCI 33 mode, the P_PLL is not used, and therefore,
2215 * the the P_PLL_LOCK bit in the adapter_status register will
2216 * not be asserted.
2217 */
2218 if (!(val64 & ADAPTER_STATUS_P_PLL_LOCK) &&
2219 sp->device_type == XFRAME_II_DEVICE && mode !=
2220 PCI_MODE_PCI_33) {
2221 DBG_PRINT(ERR_DBG, "%s", "P_PLL is not locked!");
2222 return 0;
2223 }
2224 if (!((val64 & ADAPTER_STATUS_RC_PRC_QUIESCENT) ==
2225 ADAPTER_STATUS_RC_PRC_QUIESCENT)) {
2226 DBG_PRINT(ERR_DBG, "%s", "RC_PRC is not QUIESCENT!");
2227 return 0;
2228 }
2229 return 1;
2230 }
2231
2232 /**
2233 * fix_mac_address - Fix for Mac addr problem on Alpha platforms
2234 * @sp: Pointer to device specifc structure
2235 * Description :
2236 * New procedure to clear mac address reading problems on Alpha platforms
2237 *
2238 */
2239
2240 static void fix_mac_address(struct s2io_nic * sp)
2241 {
2242 struct XENA_dev_config __iomem *bar0 = sp->bar0;
2243 u64 val64;
2244 int i = 0;
2245
2246 while (fix_mac[i] != END_SIGN) {
2247 writeq(fix_mac[i++], &bar0->gpio_control);
2248 udelay(10);
2249 val64 = readq(&bar0->gpio_control);
2250 }
2251 }
2252
2253 /**
2254 * start_nic - Turns the device on
2255 * @nic : device private variable.
2256 * Description:
2257 * This function actually turns the device on. Before this function is
2258 * called,all Registers are configured from their reset states
2259 * and shared memory is allocated but the NIC is still quiescent. On
2260 * calling this function, the device interrupts are cleared and the NIC is
2261 * literally switched on by writing into the adapter control register.
2262 * Return Value:
2263 * SUCCESS on success and -1 on failure.
2264 */
2265
2266 static int start_nic(struct s2io_nic *nic)
2267 {
2268 struct XENA_dev_config __iomem *bar0 = nic->bar0;
2269 struct net_device *dev = nic->dev;
2270 register u64 val64 = 0;
2271 u16 subid, i;
2272 struct mac_info *mac_control;
2273 struct config_param *config;
2274
2275 mac_control = &nic->mac_control;
2276 config = &nic->config;
2277
2278 /* PRC Initialization and configuration */
2279 for (i = 0; i < config->rx_ring_num; i++) {
2280 writeq((u64) mac_control->rings[i].rx_blocks[0].block_dma_addr,
2281 &bar0->prc_rxd0_n[i]);
2282
2283 val64 = readq(&bar0->prc_ctrl_n[i]);
2284 if (nic->rxd_mode == RXD_MODE_1)
2285 val64 |= PRC_CTRL_RC_ENABLED;
2286 else
2287 val64 |= PRC_CTRL_RC_ENABLED | PRC_CTRL_RING_MODE_3;
2288 if (nic->device_type == XFRAME_II_DEVICE)
2289 val64 |= PRC_CTRL_GROUP_READS;
2290 val64 &= ~PRC_CTRL_RXD_BACKOFF_INTERVAL(0xFFFFFF);
2291 val64 |= PRC_CTRL_RXD_BACKOFF_INTERVAL(0x1000);
2292 writeq(val64, &bar0->prc_ctrl_n[i]);
2293 }
2294
2295 if (nic->rxd_mode == RXD_MODE_3B) {
2296 /* Enabling 2 buffer mode by writing into Rx_pa_cfg reg. */
2297 val64 = readq(&bar0->rx_pa_cfg);
2298 val64 |= RX_PA_CFG_IGNORE_L2_ERR;
2299 writeq(val64, &bar0->rx_pa_cfg);
2300 }
2301
2302 if (vlan_tag_strip == 0) {
2303 val64 = readq(&bar0->rx_pa_cfg);
2304 val64 &= ~RX_PA_CFG_STRIP_VLAN_TAG;
2305 writeq(val64, &bar0->rx_pa_cfg);
2306 vlan_strip_flag = 0;
2307 }
2308
2309 /*
2310 * Enabling MC-RLDRAM. After enabling the device, we timeout
2311 * for around 100ms, which is approximately the time required
2312 * for the device to be ready for operation.
2313 */
2314 val64 = readq(&bar0->mc_rldram_mrs);
2315 val64 |= MC_RLDRAM_QUEUE_SIZE_ENABLE | MC_RLDRAM_MRS_ENABLE;
2316 SPECIAL_REG_WRITE(val64, &bar0->mc_rldram_mrs, UF);
2317 val64 = readq(&bar0->mc_rldram_mrs);
2318
2319 msleep(100); /* Delay by around 100 ms. */
2320
2321 /* Enabling ECC Protection. */
2322 val64 = readq(&bar0->adapter_control);
2323 val64 &= ~ADAPTER_ECC_EN;
2324 writeq(val64, &bar0->adapter_control);
2325
2326 /*
2327 * Verify if the device is ready to be enabled, if so enable
2328 * it.
2329 */
2330 val64 = readq(&bar0->adapter_status);
2331 if (!verify_xena_quiescence(nic)) {
2332 DBG_PRINT(ERR_DBG, "%s: device is not ready, ", dev->name);
2333 DBG_PRINT(ERR_DBG, "Adapter status reads: 0x%llx\n",
2334 (unsigned long long) val64);
2335 return FAILURE;
2336 }
2337
2338 /*
2339 * With some switches, link might be already up at this point.
2340 * Because of this weird behavior, when we enable laser,
2341 * we may not get link. We need to handle this. We cannot
2342 * figure out which switch is misbehaving. So we are forced to
2343 * make a global change.
2344 */
2345
2346 /* Enabling Laser. */
2347 val64 = readq(&bar0->adapter_control);
2348 val64 |= ADAPTER_EOI_TX_ON;
2349 writeq(val64, &bar0->adapter_control);
2350
2351 if (s2io_link_fault_indication(nic) == MAC_RMAC_ERR_TIMER) {
2352 /*
2353 * Dont see link state interrupts initally on some switches,
2354 * so directly scheduling the link state task here.
2355 */
2356 schedule_work(&nic->set_link_task);
2357 }
2358 /* SXE-002: Initialize link and activity LED */
2359 subid = nic->pdev->subsystem_device;
2360 if (((subid & 0xFF) >= 0x07) &&
2361 (nic->device_type == XFRAME_I_DEVICE)) {
2362 val64 = readq(&bar0->gpio_control);
2363 val64 |= 0x0000800000000000ULL;
2364 writeq(val64, &bar0->gpio_control);
2365 val64 = 0x0411040400000000ULL;
2366 writeq(val64, (void __iomem *)bar0 + 0x2700);
2367 }
2368
2369 return SUCCESS;
2370 }
2371 /**
2372 * s2io_txdl_getskb - Get the skb from txdl, unmap and return skb
2373 */
2374 static struct sk_buff *s2io_txdl_getskb(struct fifo_info *fifo_data, struct \
2375 TxD *txdlp, int get_off)
2376 {
2377 struct s2io_nic *nic = fifo_data->nic;
2378 struct sk_buff *skb;
2379 struct TxD *txds;
2380 u16 j, frg_cnt;
2381
2382 txds = txdlp;
2383 if (txds->Host_Control == (u64)(long)fifo_data->ufo_in_band_v) {
2384 pci_unmap_single(nic->pdev, (dma_addr_t)
2385 txds->Buffer_Pointer, sizeof(u64),
2386 PCI_DMA_TODEVICE);
2387 txds++;
2388 }
2389
2390 skb = (struct sk_buff *) ((unsigned long)
2391 txds->Host_Control);
2392 if (!skb) {
2393 memset(txdlp, 0, (sizeof(struct TxD) * fifo_data->max_txds));
2394 return NULL;
2395 }
2396 pci_unmap_single(nic->pdev, (dma_addr_t)
2397 txds->Buffer_Pointer,
2398 skb->len - skb->data_len,
2399 PCI_DMA_TODEVICE);
2400 frg_cnt = skb_shinfo(skb)->nr_frags;
2401 if (frg_cnt) {
2402 txds++;
2403 for (j = 0; j < frg_cnt; j++, txds++) {
2404 skb_frag_t *frag = &skb_shinfo(skb)->frags[j];
2405 if (!txds->Buffer_Pointer)
2406 break;
2407 pci_unmap_page(nic->pdev, (dma_addr_t)
2408 txds->Buffer_Pointer,
2409 frag->size, PCI_DMA_TODEVICE);
2410 }
2411 }
2412 memset(txdlp,0, (sizeof(struct TxD) * fifo_data->max_txds));
2413 return(skb);
2414 }
2415
2416 /**
2417 * free_tx_buffers - Free all queued Tx buffers
2418 * @nic : device private variable.
2419 * Description:
2420 * Free all queued Tx buffers.
2421 * Return Value: void
2422 */
2423
2424 static void free_tx_buffers(struct s2io_nic *nic)
2425 {
2426 struct net_device *dev = nic->dev;
2427 struct sk_buff *skb;
2428 struct TxD *txdp;
2429 int i, j;
2430 struct mac_info *mac_control;
2431 struct config_param *config;
2432 int cnt = 0;
2433
2434 mac_control = &nic->mac_control;
2435 config = &nic->config;
2436
2437 for (i = 0; i < config->tx_fifo_num; i++) {
2438 unsigned long flags;
2439 spin_lock_irqsave(&mac_control->fifos[i].tx_lock, flags);
2440 for (j = 0; j < config->tx_cfg[i].fifo_len; j++) {
2441 txdp = (struct TxD *) \
2442 mac_control->fifos[i].list_info[j].list_virt_addr;
2443 skb = s2io_txdl_getskb(&mac_control->fifos[i], txdp, j);
2444 if (skb) {
2445 nic->mac_control.stats_info->sw_stat.mem_freed
2446 += skb->truesize;
2447 dev_kfree_skb(skb);
2448 cnt++;
2449 }
2450 }
2451 DBG_PRINT(INTR_DBG,
2452 "%s:forcibly freeing %d skbs on FIFO%d\n",
2453 dev->name, cnt, i);
2454 mac_control->fifos[i].tx_curr_get_info.offset = 0;
2455 mac_control->fifos[i].tx_curr_put_info.offset = 0;
2456 spin_unlock_irqrestore(&mac_control->fifos[i].tx_lock, flags);
2457 }
2458 }
2459
2460 /**
2461 * stop_nic - To stop the nic
2462 * @nic ; device private variable.
2463 * Description:
2464 * This function does exactly the opposite of what the start_nic()
2465 * function does. This function is called to stop the device.
2466 * Return Value:
2467 * void.
2468 */
2469
2470 static void stop_nic(struct s2io_nic *nic)
2471 {
2472 struct XENA_dev_config __iomem *bar0 = nic->bar0;
2473 register u64 val64 = 0;
2474 u16 interruptible;
2475 struct mac_info *mac_control;
2476 struct config_param *config;
2477
2478 mac_control = &nic->mac_control;
2479 config = &nic->config;
2480
2481 /* Disable all interrupts */
2482 en_dis_err_alarms(nic, ENA_ALL_INTRS, DISABLE_INTRS);
2483 interruptible = TX_TRAFFIC_INTR | RX_TRAFFIC_INTR;
2484 interruptible |= TX_PIC_INTR;
2485 en_dis_able_nic_intrs(nic, interruptible, DISABLE_INTRS);
2486
2487 /* Clearing Adapter_En bit of ADAPTER_CONTROL Register */
2488 val64 = readq(&bar0->adapter_control);
2489 val64 &= ~(ADAPTER_CNTL_EN);
2490 writeq(val64, &bar0->adapter_control);
2491 }
2492
2493 /**
2494 * fill_rx_buffers - Allocates the Rx side skbs
2495 * @ring_info: per ring structure
2496 * @from_card_up: If this is true, we will map the buffer to get
2497 * the dma address for buf0 and buf1 to give it to the card.
2498 * Else we will sync the already mapped buffer to give it to the card.
2499 * Description:
2500 * The function allocates Rx side skbs and puts the physical
2501 * address of these buffers into the RxD buffer pointers, so that the NIC
2502 * can DMA the received frame into these locations.
2503 * The NIC supports 3 receive modes, viz
2504 * 1. single buffer,
2505 * 2. three buffer and
2506 * 3. Five buffer modes.
2507 * Each mode defines how many fragments the received frame will be split
2508 * up into by the NIC. The frame is split into L3 header, L4 Header,
2509 * L4 payload in three buffer mode and in 5 buffer mode, L4 payload itself
2510 * is split into 3 fragments. As of now only single buffer mode is
2511 * supported.
2512 * Return Value:
2513 * SUCCESS on success or an appropriate -ve value on failure.
2514 */
2515
2516 static int fill_rx_buffers(struct ring_info *ring, int from_card_up)
2517 {
2518 struct sk_buff *skb;
2519 struct RxD_t *rxdp;
2520 int off, size, block_no, block_no1;
2521 u32 alloc_tab = 0;
2522 u32 alloc_cnt;
2523 u64 tmp;
2524 struct buffAdd *ba;
2525 struct RxD_t *first_rxdp = NULL;
2526 u64 Buffer0_ptr = 0, Buffer1_ptr = 0;
2527 int rxd_index = 0;
2528 struct RxD1 *rxdp1;
2529 struct RxD3 *rxdp3;
2530 struct swStat *stats = &ring->nic->mac_control.stats_info->sw_stat;
2531
2532 alloc_cnt = ring->pkt_cnt - ring->rx_bufs_left;
2533
2534 block_no1 = ring->rx_curr_get_info.block_index;
2535 while (alloc_tab < alloc_cnt) {
2536 block_no = ring->rx_curr_put_info.block_index;
2537
2538 off = ring->rx_curr_put_info.offset;
2539
2540 rxdp = ring->rx_blocks[block_no].rxds[off].virt_addr;
2541
2542 rxd_index = off + 1;
2543 if (block_no)
2544 rxd_index += (block_no * ring->rxd_count);
2545
2546 if ((block_no == block_no1) &&
2547 (off == ring->rx_curr_get_info.offset) &&
2548 (rxdp->Host_Control)) {
2549 DBG_PRINT(INTR_DBG, "%s: Get and Put",
2550 ring->dev->name);
2551 DBG_PRINT(INTR_DBG, " info equated\n");
2552 goto end;
2553 }
2554 if (off && (off == ring->rxd_count)) {
2555 ring->rx_curr_put_info.block_index++;
2556 if (ring->rx_curr_put_info.block_index ==
2557 ring->block_count)
2558 ring->rx_curr_put_info.block_index = 0;
2559 block_no = ring->rx_curr_put_info.block_index;
2560 off = 0;
2561 ring->rx_curr_put_info.offset = off;
2562 rxdp = ring->rx_blocks[block_no].block_virt_addr;
2563 DBG_PRINT(INTR_DBG, "%s: Next block at: %p\n",
2564 ring->dev->name, rxdp);
2565
2566 }
2567
2568 if ((rxdp->Control_1 & RXD_OWN_XENA) &&
2569 ((ring->rxd_mode == RXD_MODE_3B) &&
2570 (rxdp->Control_2 & s2BIT(0)))) {
2571 ring->rx_curr_put_info.offset = off;
2572 goto end;
2573 }
2574 /* calculate size of skb based on ring mode */
2575 size = ring->mtu + HEADER_ETHERNET_II_802_3_SIZE +
2576 HEADER_802_2_SIZE + HEADER_SNAP_SIZE;
2577 if (ring->rxd_mode == RXD_MODE_1)
2578 size += NET_IP_ALIGN;
2579 else
2580 size = ring->mtu + ALIGN_SIZE + BUF0_LEN + 4;
2581
2582 /* allocate skb */
2583 skb = dev_alloc_skb(size);
2584 if(!skb) {
2585 DBG_PRINT(INFO_DBG, "%s: Out of ", ring->dev->name);
2586 DBG_PRINT(INFO_DBG, "memory to allocate SKBs\n");
2587 if (first_rxdp) {
2588 wmb();
2589 first_rxdp->Control_1 |= RXD_OWN_XENA;
2590 }
2591 stats->mem_alloc_fail_cnt++;
2592
2593 return -ENOMEM ;
2594 }
2595 stats->mem_allocated += skb->truesize;
2596
2597 if (ring->rxd_mode == RXD_MODE_1) {
2598 /* 1 buffer mode - normal operation mode */
2599 rxdp1 = (struct RxD1*)rxdp;
2600 memset(rxdp, 0, sizeof(struct RxD1));
2601 skb_reserve(skb, NET_IP_ALIGN);
2602 rxdp1->Buffer0_ptr = pci_map_single
2603 (ring->pdev, skb->data, size - NET_IP_ALIGN,
2604 PCI_DMA_FROMDEVICE);
2605 if(pci_dma_mapping_error(rxdp1->Buffer0_ptr))
2606 goto pci_map_failed;
2607
2608 rxdp->Control_2 =
2609 SET_BUFFER0_SIZE_1(size - NET_IP_ALIGN);
2610 rxdp->Host_Control = (unsigned long) (skb);
2611 } else if (ring->rxd_mode == RXD_MODE_3B) {
2612 /*
2613 * 2 buffer mode -
2614 * 2 buffer mode provides 128
2615 * byte aligned receive buffers.
2616 */
2617
2618 rxdp3 = (struct RxD3*)rxdp;
2619 /* save buffer pointers to avoid frequent dma mapping */
2620 Buffer0_ptr = rxdp3->Buffer0_ptr;
2621 Buffer1_ptr = rxdp3->Buffer1_ptr;
2622 memset(rxdp, 0, sizeof(struct RxD3));
2623 /* restore the buffer pointers for dma sync*/
2624 rxdp3->Buffer0_ptr = Buffer0_ptr;
2625 rxdp3->Buffer1_ptr = Buffer1_ptr;
2626
2627 ba = &ring->ba[block_no][off];
2628 skb_reserve(skb, BUF0_LEN);
2629 tmp = (u64)(unsigned long) skb->data;
2630 tmp += ALIGN_SIZE;
2631 tmp &= ~ALIGN_SIZE;
2632 skb->data = (void *) (unsigned long)tmp;
2633 skb_reset_tail_pointer(skb);
2634
2635 if (from_card_up) {
2636 rxdp3->Buffer0_ptr =
2637 pci_map_single(ring->pdev, ba->ba_0,
2638 BUF0_LEN, PCI_DMA_FROMDEVICE);
2639 if (pci_dma_mapping_error(rxdp3->Buffer0_ptr))
2640 goto pci_map_failed;
2641 } else
2642 pci_dma_sync_single_for_device(ring->pdev,
2643 (dma_addr_t) rxdp3->Buffer0_ptr,
2644 BUF0_LEN, PCI_DMA_FROMDEVICE);
2645
2646 rxdp->Control_2 = SET_BUFFER0_SIZE_3(BUF0_LEN);
2647 if (ring->rxd_mode == RXD_MODE_3B) {
2648 /* Two buffer mode */
2649
2650 /*
2651 * Buffer2 will have L3/L4 header plus
2652 * L4 payload
2653 */
2654 rxdp3->Buffer2_ptr = pci_map_single
2655 (ring->pdev, skb->data, ring->mtu + 4,
2656 PCI_DMA_FROMDEVICE);
2657
2658 if (pci_dma_mapping_error(rxdp3->Buffer2_ptr))
2659 goto pci_map_failed;
2660
2661 if (from_card_up) {
2662 rxdp3->Buffer1_ptr =
2663 pci_map_single(ring->pdev,
2664 ba->ba_1, BUF1_LEN,
2665 PCI_DMA_FROMDEVICE);
2666
2667 if (pci_dma_mapping_error
2668 (rxdp3->Buffer1_ptr)) {
2669 pci_unmap_single
2670 (ring->pdev,
2671 (dma_addr_t)(unsigned long)
2672 skb->data,
2673 ring->mtu + 4,
2674 PCI_DMA_FROMDEVICE);
2675 goto pci_map_failed;
2676 }
2677 }
2678 rxdp->Control_2 |= SET_BUFFER1_SIZE_3(1);
2679 rxdp->Control_2 |= SET_BUFFER2_SIZE_3
2680 (ring->mtu + 4);
2681 }
2682 rxdp->Control_2 |= s2BIT(0);
2683 rxdp->Host_Control = (unsigned long) (skb);
2684 }
2685 if (alloc_tab & ((1 << rxsync_frequency) - 1))
2686 rxdp->Control_1 |= RXD_OWN_XENA;
2687 off++;
2688 if (off == (ring->rxd_count + 1))
2689 off = 0;
2690 ring->rx_curr_put_info.offset = off;
2691
2692 rxdp->Control_2 |= SET_RXD_MARKER;
2693 if (!(alloc_tab & ((1 << rxsync_frequency) - 1))) {
2694 if (first_rxdp) {
2695 wmb();
2696 first_rxdp->Control_1 |= RXD_OWN_XENA;
2697 }
2698 first_rxdp = rxdp;
2699 }
2700 ring->rx_bufs_left += 1;
2701 alloc_tab++;
2702 }
2703
2704 end:
2705 /* Transfer ownership of first descriptor to adapter just before
2706 * exiting. Before that, use memory barrier so that ownership
2707 * and other fields are seen by adapter correctly.
2708 */
2709 if (first_rxdp) {
2710 wmb();
2711 first_rxdp->Control_1 |= RXD_OWN_XENA;
2712 }
2713
2714 return SUCCESS;
2715 pci_map_failed:
2716 stats->pci_map_fail_cnt++;
2717 stats->mem_freed += skb->truesize;
2718 dev_kfree_skb_irq(skb);
2719 return -ENOMEM;
2720 }
2721
2722 static void free_rxd_blk(struct s2io_nic *sp, int ring_no, int blk)
2723 {
2724 struct net_device *dev = sp->dev;
2725 int j;
2726 struct sk_buff *skb;
2727 struct RxD_t *rxdp;
2728 struct mac_info *mac_control;
2729 struct buffAdd *ba;
2730 struct RxD1 *rxdp1;
2731 struct RxD3 *rxdp3;
2732
2733 mac_control = &sp->mac_control;
2734 for (j = 0 ; j < rxd_count[sp->rxd_mode]; j++) {
2735 rxdp = mac_control->rings[ring_no].
2736 rx_blocks[blk].rxds[j].virt_addr;
2737 skb = (struct sk_buff *)
2738 ((unsigned long) rxdp->Host_Control);
2739 if (!skb) {
2740 continue;
2741 }
2742 if (sp->rxd_mode == RXD_MODE_1) {
2743 rxdp1 = (struct RxD1*)rxdp;
2744 pci_unmap_single(sp->pdev, (dma_addr_t)
2745 rxdp1->Buffer0_ptr,
2746 dev->mtu +
2747 HEADER_ETHERNET_II_802_3_SIZE
2748 + HEADER_802_2_SIZE +
2749 HEADER_SNAP_SIZE,
2750 PCI_DMA_FROMDEVICE);
2751 memset(rxdp, 0, sizeof(struct RxD1));
2752 } else if(sp->rxd_mode == RXD_MODE_3B) {
2753 rxdp3 = (struct RxD3*)rxdp;
2754 ba = &mac_control->rings[ring_no].
2755 ba[blk][j];
2756 pci_unmap_single(sp->pdev, (dma_addr_t)
2757 rxdp3->Buffer0_ptr,
2758 BUF0_LEN,
2759 PCI_DMA_FROMDEVICE);
2760 pci_unmap_single(sp->pdev, (dma_addr_t)
2761 rxdp3->Buffer1_ptr,
2762 BUF1_LEN,
2763 PCI_DMA_FROMDEVICE);
2764 pci_unmap_single(sp->pdev, (dma_addr_t)
2765 rxdp3->Buffer2_ptr,
2766 dev->mtu + 4,
2767 PCI_DMA_FROMDEVICE);
2768 memset(rxdp, 0, sizeof(struct RxD3));
2769 }
2770 sp->mac_control.stats_info->sw_stat.mem_freed += skb->truesize;
2771 dev_kfree_skb(skb);
2772 mac_control->rings[ring_no].rx_bufs_left -= 1;
2773 }
2774 }
2775
2776 /**
2777 * free_rx_buffers - Frees all Rx buffers
2778 * @sp: device private variable.
2779 * Description:
2780 * This function will free all Rx buffers allocated by host.
2781 * Return Value:
2782 * NONE.
2783 */
2784
2785 static void free_rx_buffers(struct s2io_nic *sp)
2786 {
2787 struct net_device *dev = sp->dev;
2788 int i, blk = 0, buf_cnt = 0;
2789 struct mac_info *mac_control;
2790 struct config_param *config;
2791
2792 mac_control = &sp->mac_control;
2793 config = &sp->config;
2794
2795 for (i = 0; i < config->rx_ring_num; i++) {
2796 for (blk = 0; blk < rx_ring_sz[i]; blk++)
2797 free_rxd_blk(sp,i,blk);
2798
2799 mac_control->rings[i].rx_curr_put_info.block_index = 0;
2800 mac_control->rings[i].rx_curr_get_info.block_index = 0;
2801 mac_control->rings[i].rx_curr_put_info.offset = 0;
2802 mac_control->rings[i].rx_curr_get_info.offset = 0;
2803 mac_control->rings[i].rx_bufs_left = 0;
2804 DBG_PRINT(INIT_DBG, "%s:Freed 0x%x Rx Buffers on ring%d\n",
2805 dev->name, buf_cnt, i);
2806 }
2807 }
2808
2809 static int s2io_chk_rx_buffers(struct ring_info *ring)
2810 {
2811 if (fill_rx_buffers(ring, 0) == -ENOMEM) {
2812 DBG_PRINT(INFO_DBG, "%s:Out of memory", ring->dev->name);
2813 DBG_PRINT(INFO_DBG, " in Rx Intr!!\n");
2814 }
2815 return 0;
2816 }
2817
2818 /**
2819 * s2io_poll - Rx interrupt handler for NAPI support
2820 * @napi : pointer to the napi structure.
2821 * @budget : The number of packets that were budgeted to be processed
2822 * during one pass through the 'Poll" function.
2823 * Description:
2824 * Comes into picture only if NAPI support has been incorporated. It does
2825 * the same thing that rx_intr_handler does, but not in a interrupt context
2826 * also It will process only a given number of packets.
2827 * Return value:
2828 * 0 on success and 1 if there are No Rx packets to be processed.
2829 */
2830
2831 static int s2io_poll_msix(struct napi_struct *napi, int budget)
2832 {
2833 struct ring_info *ring = container_of(napi, struct ring_info, napi);
2834 struct net_device *dev = ring->dev;
2835 struct config_param *config;
2836 struct mac_info *mac_control;
2837 int pkts_processed = 0;
2838 u8 __iomem *addr = NULL;
2839 u8 val8 = 0;
2840 struct s2io_nic *nic = dev->priv;
2841 struct XENA_dev_config __iomem *bar0 = nic->bar0;
2842 int budget_org = budget;
2843
2844 config = &nic->config;
2845 mac_control = &nic->mac_control;
2846
2847 if (unlikely(!is_s2io_card_up(nic)))
2848 return 0;
2849
2850 pkts_processed = rx_intr_handler(ring, budget);
2851 s2io_chk_rx_buffers(ring);
2852
2853 if (pkts_processed < budget_org) {
2854 netif_rx_complete(dev, napi);
2855 /*Re Enable MSI-Rx Vector*/
2856 addr = (u8 __iomem *)&bar0->xmsi_mask_reg;
2857 addr += 7 - ring->ring_no;
2858 val8 = (ring->ring_no == 0) ? 0x3f : 0xbf;
2859 writeb(val8, addr);
2860 val8 = readb(addr);
2861 }
2862 return pkts_processed;
2863 }
2864 static int s2io_poll_inta(struct napi_struct *napi, int budget)
2865 {
2866 struct s2io_nic *nic = container_of(napi, struct s2io_nic, napi);
2867 struct ring_info *ring;
2868 struct net_device *dev = nic->dev;
2869 struct config_param *config;
2870 struct mac_info *mac_control;
2871 int pkts_processed = 0;
2872 int ring_pkts_processed, i;
2873 struct XENA_dev_config __iomem *bar0 = nic->bar0;
2874 int budget_org = budget;
2875
2876 config = &nic->config;
2877 mac_control = &nic->mac_control;
2878
2879 if (unlikely(!is_s2io_card_up(nic)))
2880 return 0;
2881
2882 for (i = 0; i < config->rx_ring_num; i++) {
2883 ring = &mac_control->rings[i];
2884 ring_pkts_processed = rx_intr_handler(ring, budget);
2885 s2io_chk_rx_buffers(ring);
2886 pkts_processed += ring_pkts_processed;
2887 budget -= ring_pkts_processed;
2888 if (budget <= 0)
2889 break;
2890 }
2891 if (pkts_processed < budget_org) {
2892 netif_rx_complete(dev, napi);
2893 /* Re enable the Rx interrupts for the ring */
2894 writeq(0, &bar0->rx_traffic_mask);
2895 readl(&bar0->rx_traffic_mask);
2896 }
2897 return pkts_processed;
2898 }
2899
2900 #ifdef CONFIG_NET_POLL_CONTROLLER
2901 /**
2902 * s2io_netpoll - netpoll event handler entry point
2903 * @dev : pointer to the device structure.
2904 * Description:
2905 * This function will be called by upper layer to check for events on the
2906 * interface in situations where interrupts are disabled. It is used for
2907 * specific in-kernel networking tasks, such as remote consoles and kernel
2908 * debugging over the network (example netdump in RedHat).
2909 */
2910 static void s2io_netpoll(struct net_device *dev)
2911 {
2912 struct s2io_nic *nic = dev->priv;
2913 struct mac_info *mac_control;
2914 struct config_param *config;
2915 struct XENA_dev_config __iomem *bar0 = nic->bar0;
2916 u64 val64 = 0xFFFFFFFFFFFFFFFFULL;
2917 int i;
2918
2919 if (pci_channel_offline(nic->pdev))
2920 return;
2921
2922 disable_irq(dev->irq);
2923
2924 mac_control = &nic->mac_control;
2925 config = &nic->config;
2926
2927 writeq(val64, &bar0->rx_traffic_int);
2928 writeq(val64, &bar0->tx_traffic_int);
2929
2930 /* we need to free up the transmitted skbufs or else netpoll will
2931 * run out of skbs and will fail and eventually netpoll application such
2932 * as netdump will fail.
2933 */
2934 for (i = 0; i < config->tx_fifo_num; i++)
2935 tx_intr_handler(&mac_control->fifos[i]);
2936
2937 /* check for received packet and indicate up to network */
2938 for (i = 0; i < config->rx_ring_num; i++)
2939 rx_intr_handler(&mac_control->rings[i], 0);
2940
2941 for (i = 0; i < config->rx_ring_num; i++) {
2942 if (fill_rx_buffers(&mac_control->rings[i], 0) == -ENOMEM) {
2943 DBG_PRINT(INFO_DBG, "%s:Out of memory", dev->name);
2944 DBG_PRINT(INFO_DBG, " in Rx Netpoll!!\n");
2945 break;
2946 }
2947 }
2948 enable_irq(dev->irq);
2949 return;
2950 }
2951 #endif
2952
2953 /**
2954 * rx_intr_handler - Rx interrupt handler
2955 * @ring_info: per ring structure.
2956 * @budget: budget for napi processing.
2957 * Description:
2958 * If the interrupt is because of a received frame or if the
2959 * receive ring contains fresh as yet un-processed frames,this function is
2960 * called. It picks out the RxD at which place the last Rx processing had
2961 * stopped and sends the skb to the OSM's Rx handler and then increments
2962 * the offset.
2963 * Return Value:
2964 * No. of napi packets processed.
2965 */
2966 static int rx_intr_handler(struct ring_info *ring_data, int budget)
2967 {
2968 int get_block, put_block;
2969 struct rx_curr_get_info get_info, put_info;
2970 struct RxD_t *rxdp;
2971 struct sk_buff *skb;
2972 int pkt_cnt = 0, napi_pkts = 0;
2973 int i;
2974 struct RxD1* rxdp1;
2975 struct RxD3* rxdp3;
2976
2977 get_info = ring_data->rx_curr_get_info;
2978 get_block = get_info.block_index;
2979 memcpy(&put_info, &ring_data->rx_curr_put_info, sizeof(put_info));
2980 put_block = put_info.block_index;
2981 rxdp = ring_data->rx_blocks[get_block].rxds[get_info.offset].virt_addr;
2982
2983 while (RXD_IS_UP2DT(rxdp)) {
2984 /*
2985 * If your are next to put index then it's
2986 * FIFO full condition
2987 */
2988 if ((get_block == put_block) &&
2989 (get_info.offset + 1) == put_info.offset) {
2990 DBG_PRINT(INTR_DBG, "%s: Ring Full\n",
2991 ring_data->dev->name);
2992 break;
2993 }
2994 skb = (struct sk_buff *) ((unsigned long)rxdp->Host_Control);
2995 if (skb == NULL) {
2996 DBG_PRINT(ERR_DBG, "%s: The skb is ",
2997 ring_data->dev->name);
2998 DBG_PRINT(ERR_DBG, "Null in Rx Intr\n");
2999 return 0;
3000 }
3001 if (ring_data->rxd_mode == RXD_MODE_1) {
3002 rxdp1 = (struct RxD1*)rxdp;
3003 pci_unmap_single(ring_data->pdev, (dma_addr_t)
3004 rxdp1->Buffer0_ptr,
3005 ring_data->mtu +
3006 HEADER_ETHERNET_II_802_3_SIZE +
3007 HEADER_802_2_SIZE +
3008 HEADER_SNAP_SIZE,
3009 PCI_DMA_FROMDEVICE);
3010 } else if (ring_data->rxd_mode == RXD_MODE_3B) {
3011 rxdp3 = (struct RxD3*)rxdp;
3012 pci_dma_sync_single_for_cpu(ring_data->pdev, (dma_addr_t)
3013 rxdp3->Buffer0_ptr,
3014 BUF0_LEN, PCI_DMA_FROMDEVICE);
3015 pci_unmap_single(ring_data->pdev, (dma_addr_t)
3016 rxdp3->Buffer2_ptr,
3017 ring_data->mtu + 4,
3018 PCI_DMA_FROMDEVICE);
3019 }
3020 prefetch(skb->data);
3021 rx_osm_handler(ring_data, rxdp);
3022 get_info.offset++;
3023 ring_data->rx_curr_get_info.offset = get_info.offset;
3024 rxdp = ring_data->rx_blocks[get_block].
3025 rxds[get_info.offset].virt_addr;
3026 if (get_info.offset == rxd_count[ring_data->rxd_mode]) {
3027 get_info.offset = 0;
3028 ring_data->rx_curr_get_info.offset = get_info.offset;
3029 get_block++;
3030 if (get_block == ring_data->block_count)
3031 get_block = 0;
3032 ring_data->rx_curr_get_info.block_index = get_block;
3033 rxdp = ring_data->rx_blocks[get_block].block_virt_addr;
3034 }
3035
3036 if (ring_data->nic->config.napi) {
3037 budget--;
3038 napi_pkts++;
3039 if (!budget)
3040 break;
3041 }
3042 pkt_cnt++;
3043 if ((indicate_max_pkts) && (pkt_cnt > indicate_max_pkts))
3044 break;
3045 }
3046 if (ring_data->lro) {
3047 /* Clear all LRO sessions before exiting */
3048 for (i=0; i<MAX_LRO_SESSIONS; i++) {
3049 struct lro *lro = &ring_data->lro0_n[i];
3050 if (lro->in_use) {
3051 update_L3L4_header(ring_data->nic, lro);
3052 queue_rx_frame(lro->parent, lro->vlan_tag);
3053 clear_lro_session(lro);
3054 }
3055 }
3056 }
3057 return(napi_pkts);
3058 }
3059
3060 /**
3061 * tx_intr_handler - Transmit interrupt handler
3062 * @nic : device private variable
3063 * Description:
3064 * If an interrupt was raised to indicate DMA complete of the
3065 * Tx packet, this function is called. It identifies the last TxD
3066 * whose buffer was freed and frees all skbs whose data have already
3067 * DMA'ed into the NICs internal memory.
3068 * Return Value:
3069 * NONE
3070 */
3071
3072 static void tx_intr_handler(struct fifo_info *fifo_data)
3073 {
3074 struct s2io_nic *nic = fifo_data->nic;
3075 struct tx_curr_get_info get_info, put_info;
3076 struct sk_buff *skb = NULL;
3077 struct TxD *txdlp;
3078 int pkt_cnt = 0;
3079 unsigned long flags = 0;
3080 u8 err_mask;
3081
3082 if (!spin_trylock_irqsave(&fifo_data->tx_lock, flags))
3083 return;
3084
3085 get_info = fifo_data->tx_curr_get_info;
3086 memcpy(&put_info, &fifo_data->tx_curr_put_info, sizeof(put_info));
3087 txdlp = (struct TxD *) fifo_data->list_info[get_info.offset].
3088 list_virt_addr;
3089 while ((!(txdlp->Control_1 & TXD_LIST_OWN_XENA)) &&
3090 (get_info.offset != put_info.offset) &&
3091 (txdlp->Host_Control)) {
3092 /* Check for TxD errors */
3093 if (txdlp->Control_1 & TXD_T_CODE) {
3094 unsigned long long err;
3095 err = txdlp->Control_1 & TXD_T_CODE;
3096 if (err & 0x1) {
3097 nic->mac_control.stats_info->sw_stat.
3098 parity_err_cnt++;
3099 }
3100
3101 /* update t_code statistics */
3102 err_mask = err >> 48;
3103 switch(err_mask) {
3104 case 2:
3105 nic->mac_control.stats_info->sw_stat.
3106 tx_buf_abort_cnt++;
3107 break;
3108
3109 case 3:
3110 nic->mac_control.stats_info->sw_stat.
3111 tx_desc_abort_cnt++;
3112 break;
3113
3114 case 7:
3115 nic->mac_control.stats_info->sw_stat.
3116 tx_parity_err_cnt++;
3117 break;
3118
3119 case 10:
3120 nic->mac_control.stats_info->sw_stat.
3121 tx_link_loss_cnt++;
3122 break;
3123
3124 case 15:
3125 nic->mac_control.stats_info->sw_stat.
3126 tx_list_proc_err_cnt++;
3127 break;
3128 }
3129 }
3130
3131 skb = s2io_txdl_getskb(fifo_data, txdlp, get_info.offset);
3132 if (skb == NULL) {
3133 spin_unlock_irqrestore(&fifo_data->tx_lock, flags);
3134 DBG_PRINT(ERR_DBG, "%s: Null skb ",
3135 __FUNCTION__);
3136 DBG_PRINT(ERR_DBG, "in Tx Free Intr\n");
3137 return;
3138 }
3139 pkt_cnt++;
3140
3141 /* Updating the statistics block */
3142 nic->stats.tx_bytes += skb->len;
3143 nic->mac_control.stats_info->sw_stat.mem_freed += skb->truesize;
3144 dev_kfree_skb_irq(skb);
3145
3146 get_info.offset++;
3147 if (get_info.offset == get_info.fifo_len + 1)
3148 get_info.offset = 0;
3149 txdlp = (struct TxD *) fifo_data->list_info
3150 [get_info.offset].list_virt_addr;
3151 fifo_data->tx_curr_get_info.offset =
3152 get_info.offset;
3153 }
3154
3155 s2io_wake_tx_queue(fifo_data, pkt_cnt, nic->config.multiq);
3156
3157 spin_unlock_irqrestore(&fifo_data->tx_lock, flags);
3158 }
3159
3160 /**
3161 * s2io_mdio_write - Function to write in to MDIO registers
3162 * @mmd_type : MMD type value (PMA/PMD/WIS/PCS/PHYXS)
3163 * @addr : address value
3164 * @value : data value
3165 * @dev : pointer to net_device structure
3166 * Description:
3167 * This function is used to write values to the MDIO registers
3168 * NONE
3169 */
3170 static void s2io_mdio_write(u32 mmd_type, u64 addr, u16 value, struct net_device *dev)
3171 {
3172 u64 val64 = 0x0;
3173 struct s2io_nic *sp = dev->priv;
3174 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3175
3176 //address transaction
3177 val64 = val64 | MDIO_MMD_INDX_ADDR(addr)
3178 | MDIO_MMD_DEV_ADDR(mmd_type)
3179 | MDIO_MMS_PRT_ADDR(0x0);
3180 writeq(val64, &bar0->mdio_control);
3181 val64 = val64 | MDIO_CTRL_START_TRANS(0xE);
3182 writeq(val64, &bar0->mdio_control);
3183 udelay(100);
3184
3185 //Data transaction
3186 val64 = 0x0;
3187 val64 = val64 | MDIO_MMD_INDX_ADDR(addr)
3188 | MDIO_MMD_DEV_ADDR(mmd_type)
3189 | MDIO_MMS_PRT_ADDR(0x0)
3190 | MDIO_MDIO_DATA(value)
3191 | MDIO_OP(MDIO_OP_WRITE_TRANS);
3192 writeq(val64, &bar0->mdio_control);
3193 val64 = val64 | MDIO_CTRL_START_TRANS(0xE);
3194 writeq(val64, &bar0->mdio_control);
3195 udelay(100);
3196
3197 val64 = 0x0;
3198 val64 = val64 | MDIO_MMD_INDX_ADDR(addr)
3199 | MDIO_MMD_DEV_ADDR(mmd_type)
3200 | MDIO_MMS_PRT_ADDR(0x0)
3201 | MDIO_OP(MDIO_OP_READ_TRANS);
3202 writeq(val64, &bar0->mdio_control);
3203 val64 = val64 | MDIO_CTRL_START_TRANS(0xE);
3204 writeq(val64, &bar0->mdio_control);
3205 udelay(100);
3206
3207 }
3208
3209 /**
3210 * s2io_mdio_read - Function to write in to MDIO registers
3211 * @mmd_type : MMD type value (PMA/PMD/WIS/PCS/PHYXS)
3212 * @addr : address value
3213 * @dev : pointer to net_device structure
3214 * Description:
3215 * This function is used to read values to the MDIO registers
3216 * NONE
3217 */
3218 static u64 s2io_mdio_read(u32 mmd_type, u64 addr, struct net_device *dev)
3219 {
3220 u64 val64 = 0x0;
3221 u64 rval64 = 0x0;
3222 struct s2io_nic *sp = dev->priv;
3223 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3224
3225 /* address transaction */
3226 val64 = val64 | MDIO_MMD_INDX_ADDR(addr)
3227 | MDIO_MMD_DEV_ADDR(mmd_type)
3228 | MDIO_MMS_PRT_ADDR(0x0);
3229 writeq(val64, &bar0->mdio_control);
3230 val64 = val64 | MDIO_CTRL_START_TRANS(0xE);
3231 writeq(val64, &bar0->mdio_control);
3232 udelay(100);
3233
3234 /* Data transaction */
3235 val64 = 0x0;
3236 val64 = val64 | MDIO_MMD_INDX_ADDR(addr)
3237 | MDIO_MMD_DEV_ADDR(mmd_type)
3238 | MDIO_MMS_PRT_ADDR(0x0)
3239 | MDIO_OP(MDIO_OP_READ_TRANS);
3240 writeq(val64, &bar0->mdio_control);
3241 val64 = val64 | MDIO_CTRL_START_TRANS(0xE);
3242 writeq(val64, &bar0->mdio_control);
3243 udelay(100);
3244
3245 /* Read the value from regs */
3246 rval64 = readq(&bar0->mdio_control);
3247 rval64 = rval64 & 0xFFFF0000;
3248 rval64 = rval64 >> 16;
3249 return rval64;
3250 }
3251 /**
3252 * s2io_chk_xpak_counter - Function to check the status of the xpak counters
3253 * @counter : couter value to be updated
3254 * @flag : flag to indicate the status
3255 * @type : counter type
3256 * Description:
3257 * This function is to check the status of the xpak counters value
3258 * NONE
3259 */
3260
3261 static void s2io_chk_xpak_counter(u64 *counter, u64 * regs_stat, u32 index, u16 flag, u16 type)
3262 {
3263 u64 mask = 0x3;
3264 u64 val64;
3265 int i;
3266 for(i = 0; i <index; i++)
3267 mask = mask << 0x2;
3268
3269 if(flag > 0)
3270 {
3271 *counter = *counter + 1;
3272 val64 = *regs_stat & mask;
3273 val64 = val64 >> (index * 0x2);
3274 val64 = val64 + 1;
3275 if(val64 == 3)
3276 {
3277 switch(type)
3278 {
3279 case 1:
3280 DBG_PRINT(ERR_DBG, "Take Xframe NIC out of "
3281 "service. Excessive temperatures may "
3282 "result in premature transceiver "
3283 "failure \n");
3284 break;
3285 case 2:
3286 DBG_PRINT(ERR_DBG, "Take Xframe NIC out of "
3287 "service Excessive bias currents may "
3288 "indicate imminent laser diode "
3289 "failure \n");
3290 break;
3291 case 3:
3292 DBG_PRINT(ERR_DBG, "Take Xframe NIC out of "
3293 "service Excessive laser output "
3294 "power may saturate far-end "
3295 "receiver\n");
3296 break;
3297 default:
3298 DBG_PRINT(ERR_DBG, "Incorrect XPAK Alarm "
3299 "type \n");
3300 }
3301 val64 = 0x0;
3302 }
3303 val64 = val64 << (index * 0x2);
3304 *regs_stat = (*regs_stat & (~mask)) | (val64);
3305
3306 } else {
3307 *regs_stat = *regs_stat & (~mask);
3308 }
3309 }
3310
3311 /**
3312 * s2io_updt_xpak_counter - Function to update the xpak counters
3313 * @dev : pointer to net_device struct
3314 * Description:
3315 * This function is to upate the status of the xpak counters value
3316 * NONE
3317 */
3318 static void s2io_updt_xpak_counter(struct net_device *dev)
3319 {
3320 u16 flag = 0x0;
3321 u16 type = 0x0;
3322 u16 val16 = 0x0;
3323 u64 val64 = 0x0;
3324 u64 addr = 0x0;
3325
3326 struct s2io_nic *sp = dev->priv;
3327 struct stat_block *stat_info = sp->mac_control.stats_info;
3328
3329 /* Check the communication with the MDIO slave */
3330 addr = 0x0000;
3331 val64 = 0x0;
3332 val64 = s2io_mdio_read(MDIO_MMD_PMA_DEV_ADDR, addr, dev);
3333 if((val64 == 0xFFFF) || (val64 == 0x0000))
3334 {
3335 DBG_PRINT(ERR_DBG, "ERR: MDIO slave access failed - "
3336 "Returned %llx\n", (unsigned long long)val64);
3337 return;
3338 }
3339
3340 /* Check for the expecte value of 2040 at PMA address 0x0000 */
3341 if(val64 != 0x2040)
3342 {
3343 DBG_PRINT(ERR_DBG, "Incorrect value at PMA address 0x0000 - ");
3344 DBG_PRINT(ERR_DBG, "Returned: %llx- Expected: 0x2040\n",
3345 (unsigned long long)val64);
3346 return;
3347 }
3348
3349 /* Loading the DOM register to MDIO register */
3350 addr = 0xA100;
3351 s2io_mdio_write(MDIO_MMD_PMA_DEV_ADDR, addr, val16, dev);
3352 val64 = s2io_mdio_read(MDIO_MMD_PMA_DEV_ADDR, addr, dev);
3353
3354 /* Reading the Alarm flags */
3355 addr = 0xA070;
3356 val64 = 0x0;
3357 val64 = s2io_mdio_read(MDIO_MMD_PMA_DEV_ADDR, addr, dev);
3358
3359 flag = CHECKBIT(val64, 0x7);
3360 type = 1;
3361 s2io_chk_xpak_counter(&stat_info->xpak_stat.alarm_transceiver_temp_high,
3362 &stat_info->xpak_stat.xpak_regs_stat,
3363 0x0, flag, type);
3364
3365 if(CHECKBIT(val64, 0x6))
3366 stat_info->xpak_stat.alarm_transceiver_temp_low++;
3367
3368 flag = CHECKBIT(val64, 0x3);
3369 type = 2;
3370 s2io_chk_xpak_counter(&stat_info->xpak_stat.alarm_laser_bias_current_high,
3371 &stat_info->xpak_stat.xpak_regs_stat,
3372 0x2, flag, type);
3373
3374 if(CHECKBIT(val64, 0x2))
3375 stat_info->xpak_stat.alarm_laser_bias_current_low++;
3376
3377 flag = CHECKBIT(val64, 0x1);
3378 type = 3;
3379 s2io_chk_xpak_counter(&stat_info->xpak_stat.alarm_laser_output_power_high,
3380 &stat_info->xpak_stat.xpak_regs_stat,
3381 0x4, flag, type);
3382
3383 if(CHECKBIT(val64, 0x0))
3384 stat_info->xpak_stat.alarm_laser_output_power_low++;
3385
3386 /* Reading the Warning flags */
3387 addr = 0xA074;
3388 val64 = 0x0;
3389 val64 = s2io_mdio_read(MDIO_MMD_PMA_DEV_ADDR, addr, dev);
3390
3391 if(CHECKBIT(val64, 0x7))
3392 stat_info->xpak_stat.warn_transceiver_temp_high++;
3393
3394 if(CHECKBIT(val64, 0x6))
3395 stat_info->xpak_stat.warn_transceiver_temp_low++;
3396
3397 if(CHECKBIT(val64, 0x3))
3398 stat_info->xpak_stat.warn_laser_bias_current_high++;
3399
3400 if(CHECKBIT(val64, 0x2))
3401 stat_info->xpak_stat.warn_laser_bias_current_low++;
3402
3403 if(CHECKBIT(val64, 0x1))
3404 stat_info->xpak_stat.warn_laser_output_power_high++;
3405
3406 if(CHECKBIT(val64, 0x0))
3407 stat_info->xpak_stat.warn_laser_output_power_low++;
3408 }
3409
3410 /**
3411 * wait_for_cmd_complete - waits for a command to complete.
3412 * @sp : private member of the device structure, which is a pointer to the
3413 * s2io_nic structure.
3414 * Description: Function that waits for a command to Write into RMAC
3415 * ADDR DATA registers to be completed and returns either success or
3416 * error depending on whether the command was complete or not.
3417 * Return value:
3418 * SUCCESS on success and FAILURE on failure.
3419 */
3420
3421 static int wait_for_cmd_complete(void __iomem *addr, u64 busy_bit,
3422 int bit_state)
3423 {
3424 int ret = FAILURE, cnt = 0, delay = 1;
3425 u64 val64;
3426
3427 if ((bit_state != S2IO_BIT_RESET) && (bit_state != S2IO_BIT_SET))
3428 return FAILURE;
3429
3430 do {
3431 val64 = readq(addr);
3432 if (bit_state == S2IO_BIT_RESET) {
3433 if (!(val64 & busy_bit)) {
3434 ret = SUCCESS;
3435 break;
3436 }
3437 } else {
3438 if (!(val64 & busy_bit)) {
3439 ret = SUCCESS;
3440 break;
3441 }
3442 }
3443
3444 if(in_interrupt())
3445 mdelay(delay);
3446 else
3447 msleep(delay);
3448
3449 if (++cnt >= 10)
3450 delay = 50;
3451 } while (cnt < 20);
3452 return ret;
3453 }
3454 /*
3455 * check_pci_device_id - Checks if the device id is supported
3456 * @id : device id
3457 * Description: Function to check if the pci device id is supported by driver.
3458 * Return value: Actual device id if supported else PCI_ANY_ID
3459 */
3460 static u16 check_pci_device_id(u16 id)
3461 {
3462 switch (id) {
3463 case PCI_DEVICE_ID_HERC_WIN:
3464 case PCI_DEVICE_ID_HERC_UNI:
3465 return XFRAME_II_DEVICE;
3466 case PCI_DEVICE_ID_S2IO_UNI:
3467 case PCI_DEVICE_ID_S2IO_WIN:
3468 return XFRAME_I_DEVICE;
3469 default:
3470 return PCI_ANY_ID;
3471 }
3472 }
3473
3474 /**
3475 * s2io_reset - Resets the card.
3476 * @sp : private member of the device structure.
3477 * Description: Function to Reset the card. This function then also
3478 * restores the previously saved PCI configuration space registers as
3479 * the card reset also resets the configuration space.
3480 * Return value:
3481 * void.
3482 */
3483
3484 static void s2io_reset(struct s2io_nic * sp)
3485 {
3486 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3487 u64 val64;
3488 u16 subid, pci_cmd;
3489 int i;
3490 u16 val16;
3491 unsigned long long up_cnt, down_cnt, up_time, down_time, reset_cnt;
3492 unsigned long long mem_alloc_cnt, mem_free_cnt, watchdog_cnt;
3493
3494 DBG_PRINT(INIT_DBG,"%s - Resetting XFrame card %s\n",
3495 __FUNCTION__, sp->dev->name);
3496
3497 /* Back up the PCI-X CMD reg, dont want to lose MMRBC, OST settings */
3498 pci_read_config_word(sp->pdev, PCIX_COMMAND_REGISTER, &(pci_cmd));
3499
3500 val64 = SW_RESET_ALL;
3501 writeq(val64, &bar0->sw_reset);
3502 if (strstr(sp->product_name, "CX4")) {
3503 msleep(750);
3504 }
3505 msleep(250);
3506 for (i = 0; i < S2IO_MAX_PCI_CONFIG_SPACE_REINIT; i++) {
3507
3508 /* Restore the PCI state saved during initialization. */
3509 pci_restore_state(sp->pdev);
3510 pci_read_config_word(sp->pdev, 0x2, &val16);
3511 if (check_pci_device_id(val16) != (u16)PCI_ANY_ID)
3512 break;
3513 msleep(200);
3514 }
3515
3516 if (check_pci_device_id(val16) == (u16)PCI_ANY_ID) {
3517 DBG_PRINT(ERR_DBG,"%s SW_Reset failed!\n", __FUNCTION__);
3518 }
3519
3520 pci_write_config_word(sp->pdev, PCIX_COMMAND_REGISTER, pci_cmd);
3521
3522 s2io_init_pci(sp);
3523
3524 /* Set swapper to enable I/O register access */
3525 s2io_set_swapper(sp);
3526
3527 /* restore mac_addr entries */
3528 do_s2io_restore_unicast_mc(sp);
3529
3530 /* Restore the MSIX table entries from local variables */
3531 restore_xmsi_data(sp);
3532
3533 /* Clear certain PCI/PCI-X fields after reset */
3534 if (sp->device_type == XFRAME_II_DEVICE) {
3535 /* Clear "detected parity error" bit */
3536 pci_write_config_word(sp->pdev, PCI_STATUS, 0x8000);
3537
3538 /* Clearing PCIX Ecc status register */
3539 pci_write_config_dword(sp->pdev, 0x68, 0x7C);
3540
3541 /* Clearing PCI_STATUS error reflected here */
3542 writeq(s2BIT(62), &bar0->txpic_int_reg);
3543 }
3544
3545 /* Reset device statistics maintained by OS */
3546 memset(&sp->stats, 0, sizeof (struct net_device_stats));
3547
3548 up_cnt = sp->mac_control.stats_info->sw_stat.link_up_cnt;
3549 down_cnt = sp->mac_control.stats_info->sw_stat.link_down_cnt;
3550 up_time = sp->mac_control.stats_info->sw_stat.link_up_time;
3551 down_time = sp->mac_control.stats_info->sw_stat.link_down_time;
3552 reset_cnt = sp->mac_control.stats_info->sw_stat.soft_reset_cnt;
3553 mem_alloc_cnt = sp->mac_control.stats_info->sw_stat.mem_allocated;
3554 mem_free_cnt = sp->mac_control.stats_info->sw_stat.mem_freed;
3555 watchdog_cnt = sp->mac_control.stats_info->sw_stat.watchdog_timer_cnt;
3556 /* save link up/down time/cnt, reset/memory/watchdog cnt */
3557 memset(sp->mac_control.stats_info, 0, sizeof(struct stat_block));
3558 /* restore link up/down time/cnt, reset/memory/watchdog cnt */
3559 sp->mac_control.stats_info->sw_stat.link_up_cnt = up_cnt;
3560 sp->mac_control.stats_info->sw_stat.link_down_cnt = down_cnt;
3561 sp->mac_control.stats_info->sw_stat.link_up_time = up_time;
3562 sp->mac_control.stats_info->sw_stat.link_down_time = down_time;
3563 sp->mac_control.stats_info->sw_stat.soft_reset_cnt = reset_cnt;
3564 sp->mac_control.stats_info->sw_stat.mem_allocated = mem_alloc_cnt;
3565 sp->mac_control.stats_info->sw_stat.mem_freed = mem_free_cnt;
3566 sp->mac_control.stats_info->sw_stat.watchdog_timer_cnt = watchdog_cnt;
3567
3568 /* SXE-002: Configure link and activity LED to turn it off */
3569 subid = sp->pdev->subsystem_device;
3570 if (((subid & 0xFF) >= 0x07) &&
3571 (sp->device_type == XFRAME_I_DEVICE)) {
3572 val64 = readq(&bar0->gpio_control);
3573 val64 |= 0x0000800000000000ULL;
3574 writeq(val64, &bar0->gpio_control);
3575 val64 = 0x0411040400000000ULL;
3576 writeq(val64, (void __iomem *)bar0 + 0x2700);
3577 }
3578
3579 /*
3580 * Clear spurious ECC interrupts that would have occured on
3581 * XFRAME II cards after reset.
3582 */
3583 if (sp->device_type == XFRAME_II_DEVICE) {
3584 val64 = readq(&bar0->pcc_err_reg);
3585 writeq(val64, &bar0->pcc_err_reg);
3586 }
3587
3588 sp->device_enabled_once = FALSE;
3589 }
3590
3591 /**
3592 * s2io_set_swapper - to set the swapper controle on the card
3593 * @sp : private member of the device structure,
3594 * pointer to the s2io_nic structure.
3595 * Description: Function to set the swapper control on the card
3596 * correctly depending on the 'endianness' of the system.
3597 * Return value:
3598 * SUCCESS on success and FAILURE on failure.
3599 */
3600
3601 static int s2io_set_swapper(struct s2io_nic * sp)
3602 {
3603 struct net_device *dev = sp->dev;
3604 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3605 u64 val64, valt, valr;
3606
3607 /*
3608 * Set proper endian settings and verify the same by reading
3609 * the PIF Feed-back register.
3610 */
3611
3612 val64 = readq(&bar0->pif_rd_swapper_fb);
3613 if (val64 != 0x0123456789ABCDEFULL) {
3614 int i = 0;
3615 u64 value[] = { 0xC30000C3C30000C3ULL, /* FE=1, SE=1 */
3616 0x8100008181000081ULL, /* FE=1, SE=0 */
3617 0x4200004242000042ULL, /* FE=0, SE=1 */
3618 0}; /* FE=0, SE=0 */
3619
3620 while(i<4) {
3621 writeq(value[i], &bar0->swapper_ctrl);
3622 val64 = readq(&bar0->pif_rd_swapper_fb);
3623 if (val64 == 0x0123456789ABCDEFULL)
3624 break;
3625 i++;
3626 }
3627 if (i == 4) {
3628 DBG_PRINT(ERR_DBG, "%s: Endian settings are wrong, ",
3629 dev->name);
3630 DBG_PRINT(ERR_DBG, "feedback read %llx\n",
3631 (unsigned long long) val64);
3632 return FAILURE;
3633 }
3634 valr = value[i];
3635 } else {
3636 valr = readq(&bar0->swapper_ctrl);
3637 }
3638
3639 valt = 0x0123456789ABCDEFULL;
3640 writeq(valt, &bar0->xmsi_address);
3641 val64 = readq(&bar0->xmsi_address);
3642
3643 if(val64 != valt) {
3644 int i = 0;
3645 u64 value[] = { 0x00C3C30000C3C300ULL, /* FE=1, SE=1 */
3646 0x0081810000818100ULL, /* FE=1, SE=0 */
3647 0x0042420000424200ULL, /* FE=0, SE=1 */
3648 0}; /* FE=0, SE=0 */
3649
3650 while(i<4) {
3651 writeq((value[i] | valr), &bar0->swapper_ctrl);
3652 writeq(valt, &bar0->xmsi_address);
3653 val64 = readq(&bar0->xmsi_address);
3654 if(val64 == valt)
3655 break;
3656 i++;
3657 }
3658 if(i == 4) {
3659 unsigned long long x = val64;
3660 DBG_PRINT(ERR_DBG, "Write failed, Xmsi_addr ");
3661 DBG_PRINT(ERR_DBG, "reads:0x%llx\n", x);
3662 return FAILURE;
3663 }
3664 }
3665 val64 = readq(&bar0->swapper_ctrl);
3666 val64 &= 0xFFFF000000000000ULL;
3667
3668 #ifdef __BIG_ENDIAN
3669 /*
3670 * The device by default set to a big endian format, so a
3671 * big endian driver need not set anything.
3672 */
3673 val64 |= (SWAPPER_CTRL_TXP_FE |
3674 SWAPPER_CTRL_TXP_SE |
3675 SWAPPER_CTRL_TXD_R_FE |
3676 SWAPPER_CTRL_TXD_W_FE |
3677 SWAPPER_CTRL_TXF_R_FE |
3678 SWAPPER_CTRL_RXD_R_FE |
3679 SWAPPER_CTRL_RXD_W_FE |
3680 SWAPPER_CTRL_RXF_W_FE |
3681 SWAPPER_CTRL_XMSI_FE |
3682 SWAPPER_CTRL_STATS_FE | SWAPPER_CTRL_STATS_SE);
3683 if (sp->config.intr_type == INTA)
3684 val64 |= SWAPPER_CTRL_XMSI_SE;
3685 writeq(val64, &bar0->swapper_ctrl);
3686 #else
3687 /*
3688 * Initially we enable all bits to make it accessible by the
3689 * driver, then we selectively enable only those bits that
3690 * we want to set.
3691 */
3692 val64 |= (SWAPPER_CTRL_TXP_FE |
3693 SWAPPER_CTRL_TXP_SE |
3694 SWAPPER_CTRL_TXD_R_FE |
3695 SWAPPER_CTRL_TXD_R_SE |
3696 SWAPPER_CTRL_TXD_W_FE |
3697 SWAPPER_CTRL_TXD_W_SE |
3698 SWAPPER_CTRL_TXF_R_FE |
3699 SWAPPER_CTRL_RXD_R_FE |
3700 SWAPPER_CTRL_RXD_R_SE |
3701 SWAPPER_CTRL_RXD_W_FE |
3702 SWAPPER_CTRL_RXD_W_SE |
3703 SWAPPER_CTRL_RXF_W_FE |
3704 SWAPPER_CTRL_XMSI_FE |
3705 SWAPPER_CTRL_STATS_FE | SWAPPER_CTRL_STATS_SE);
3706 if (sp->config.intr_type == INTA)
3707 val64 |= SWAPPER_CTRL_XMSI_SE;
3708 writeq(val64, &bar0->swapper_ctrl);
3709 #endif
3710 val64 = readq(&bar0->swapper_ctrl);
3711
3712 /*
3713 * Verifying if endian settings are accurate by reading a
3714 * feedback register.
3715 */
3716 val64 = readq(&bar0->pif_rd_swapper_fb);
3717 if (val64 != 0x0123456789ABCDEFULL) {
3718 /* Endian settings are incorrect, calls for another dekko. */
3719 DBG_PRINT(ERR_DBG, "%s: Endian settings are wrong, ",
3720 dev->name);
3721 DBG_PRINT(ERR_DBG, "feedback read %llx\n",
3722 (unsigned long long) val64);
3723 return FAILURE;
3724 }
3725
3726 return SUCCESS;
3727 }
3728
3729 static int wait_for_msix_trans(struct s2io_nic *nic, int i)
3730 {
3731 struct XENA_dev_config __iomem *bar0 = nic->bar0;
3732 u64 val64;
3733 int ret = 0, cnt = 0;
3734
3735 do {
3736 val64 = readq(&bar0->xmsi_access);
3737 if (!(val64 & s2BIT(15)))
3738 break;
3739 mdelay(1);
3740 cnt++;
3741 } while(cnt < 5);
3742 if (cnt == 5) {
3743 DBG_PRINT(ERR_DBG, "XMSI # %d Access failed\n", i);
3744 ret = 1;
3745 }
3746
3747 return ret;
3748 }
3749
3750 static void restore_xmsi_data(struct s2io_nic *nic)
3751 {
3752 struct XENA_dev_config __iomem *bar0 = nic->bar0;
3753 u64 val64;
3754 int i, msix_index;
3755
3756
3757 if (nic->device_type == XFRAME_I_DEVICE)
3758 return;
3759
3760 for (i=0; i < MAX_REQUESTED_MSI_X; i++) {
3761 msix_index = (i) ? ((i-1) * 8 + 1): 0;
3762 writeq(nic->msix_info[i].addr, &bar0->xmsi_address);
3763 writeq(nic->msix_info[i].data, &bar0->xmsi_data);
3764 val64 = (s2BIT(7) | s2BIT(15) | vBIT(msix_index, 26, 6));
3765 writeq(val64, &bar0->xmsi_access);
3766 if (wait_for_msix_trans(nic, msix_index)) {
3767 DBG_PRINT(ERR_DBG, "failed in %s\n", __FUNCTION__);
3768 continue;
3769 }
3770 }
3771 }
3772
3773 static void store_xmsi_data(struct s2io_nic *nic)
3774 {
3775 struct XENA_dev_config __iomem *bar0 = nic->bar0;
3776 u64 val64, addr, data;
3777 int i, msix_index;
3778
3779 if (nic->device_type == XFRAME_I_DEVICE)
3780 return;
3781
3782 /* Store and display */
3783 for (i=0; i < MAX_REQUESTED_MSI_X; i++) {
3784 msix_index = (i) ? ((i-1) * 8 + 1): 0;
3785 val64 = (s2BIT(15) | vBIT(msix_index, 26, 6));
3786 writeq(val64, &bar0->xmsi_access);
3787 if (wait_for_msix_trans(nic, msix_index)) {
3788 DBG_PRINT(ERR_DBG, "failed in %s\n", __FUNCTION__);
3789 continue;
3790 }
3791 addr = readq(&bar0->xmsi_address);
3792 data = readq(&bar0->xmsi_data);
3793 if (addr && data) {
3794 nic->msix_info[i].addr = addr;
3795 nic->msix_info[i].data = data;
3796 }
3797 }
3798 }
3799
3800 static int s2io_enable_msi_x(struct s2io_nic *nic)
3801 {
3802 struct XENA_dev_config __iomem *bar0 = nic->bar0;
3803 u64 rx_mat;
3804 u16 msi_control; /* Temp variable */
3805 int ret, i, j, msix_indx = 1;
3806
3807 nic->entries = kmalloc(nic->num_entries * sizeof(struct msix_entry),
3808 GFP_KERNEL);
3809 if (!nic->entries) {
3810 DBG_PRINT(INFO_DBG, "%s: Memory allocation failed\n", \
3811 __FUNCTION__);
3812 nic->mac_control.stats_info->sw_stat.mem_alloc_fail_cnt++;
3813 return -ENOMEM;
3814 }
3815 nic->mac_control.stats_info->sw_stat.mem_allocated
3816 += (nic->num_entries * sizeof(struct msix_entry));
3817
3818 memset(nic->entries, 0, nic->num_entries * sizeof(struct msix_entry));
3819
3820 nic->s2io_entries =
3821 kmalloc(nic->num_entries * sizeof(struct s2io_msix_entry),
3822 GFP_KERNEL);
3823 if (!nic->s2io_entries) {
3824 DBG_PRINT(INFO_DBG, "%s: Memory allocation failed\n",
3825 __FUNCTION__);
3826 nic->mac_control.stats_info->sw_stat.mem_alloc_fail_cnt++;
3827 kfree(nic->entries);
3828 nic->mac_control.stats_info->sw_stat.mem_freed
3829 += (nic->num_entries * sizeof(struct msix_entry));
3830 return -ENOMEM;
3831 }
3832 nic->mac_control.stats_info->sw_stat.mem_allocated
3833 += (nic->num_entries * sizeof(struct s2io_msix_entry));
3834 memset(nic->s2io_entries, 0,
3835 nic->num_entries * sizeof(struct s2io_msix_entry));
3836
3837 nic->entries[0].entry = 0;
3838 nic->s2io_entries[0].entry = 0;
3839 nic->s2io_entries[0].in_use = MSIX_FLG;
3840 nic->s2io_entries[0].type = MSIX_ALARM_TYPE;
3841 nic->s2io_entries[0].arg = &nic->mac_control.fifos;
3842
3843 for (i = 1; i < nic->num_entries; i++) {
3844 nic->entries[i].entry = ((i - 1) * 8) + 1;
3845 nic->s2io_entries[i].entry = ((i - 1) * 8) + 1;
3846 nic->s2io_entries[i].arg = NULL;
3847 nic->s2io_entries[i].in_use = 0;
3848 }
3849
3850 rx_mat = readq(&bar0->rx_mat);
3851 for (j = 0; j < nic->config.rx_ring_num; j++) {
3852 rx_mat |= RX_MAT_SET(j, msix_indx);
3853 nic->s2io_entries[j+1].arg = &nic->mac_control.rings[j];
3854 nic->s2io_entries[j+1].type = MSIX_RING_TYPE;
3855 nic->s2io_entries[j+1].in_use = MSIX_FLG;
3856 msix_indx += 8;
3857 }
3858 writeq(rx_mat, &bar0->rx_mat);
3859 readq(&bar0->rx_mat);
3860
3861 ret = pci_enable_msix(nic->pdev, nic->entries, nic->num_entries);
3862 /* We fail init if error or we get less vectors than min required */
3863 if (ret) {
3864 DBG_PRINT(ERR_DBG, "%s: Enabling MSIX failed\n", nic->dev->name);
3865 kfree(nic->entries);
3866 nic->mac_control.stats_info->sw_stat.mem_freed
3867 += (nic->num_entries * sizeof(struct msix_entry));
3868 kfree(nic->s2io_entries);
3869 nic->mac_control.stats_info->sw_stat.mem_freed
3870 += (nic->num_entries * sizeof(struct s2io_msix_entry));
3871 nic->entries = NULL;
3872 nic->s2io_entries = NULL;
3873 return -ENOMEM;
3874 }
3875
3876 /*
3877 * To enable MSI-X, MSI also needs to be enabled, due to a bug
3878 * in the herc NIC. (Temp change, needs to be removed later)
3879 */
3880 pci_read_config_word(nic->pdev, 0x42, &msi_control);
3881 msi_control |= 0x1; /* Enable MSI */
3882 pci_write_config_word(nic->pdev, 0x42, msi_control);
3883
3884 return 0;
3885 }
3886
3887 /* Handle software interrupt used during MSI(X) test */
3888 static irqreturn_t s2io_test_intr(int irq, void *dev_id)
3889 {
3890 struct s2io_nic *sp = dev_id;
3891
3892 sp->msi_detected = 1;
3893 wake_up(&sp->msi_wait);
3894
3895 return IRQ_HANDLED;
3896 }
3897
3898 /* Test interrupt path by forcing a a software IRQ */
3899 static int s2io_test_msi(struct s2io_nic *sp)
3900 {
3901 struct pci_dev *pdev = sp->pdev;
3902 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3903 int err;
3904 u64 val64, saved64;
3905
3906 err = request_irq(sp->entries[1].vector, s2io_test_intr, 0,
3907 sp->name, sp);
3908 if (err) {
3909 DBG_PRINT(ERR_DBG, "%s: PCI %s: cannot assign irq %d\n",
3910 sp->dev->name, pci_name(pdev), pdev->irq);
3911 return err;
3912 }
3913
3914 init_waitqueue_head (&sp->msi_wait);
3915 sp->msi_detected = 0;
3916
3917 saved64 = val64 = readq(&bar0->scheduled_int_ctrl);
3918 val64 |= SCHED_INT_CTRL_ONE_SHOT;
3919 val64 |= SCHED_INT_CTRL_TIMER_EN;
3920 val64 |= SCHED_INT_CTRL_INT2MSI(1);
3921 writeq(val64, &bar0->scheduled_int_ctrl);
3922
3923 wait_event_timeout(sp->msi_wait, sp->msi_detected, HZ/10);
3924
3925 if (!sp->msi_detected) {
3926 /* MSI(X) test failed, go back to INTx mode */
3927 DBG_PRINT(ERR_DBG, "%s: PCI %s: No interrupt was generated "
3928 "using MSI(X) during test\n", sp->dev->name,
3929 pci_name(pdev));
3930
3931 err = -EOPNOTSUPP;
3932 }
3933
3934 free_irq(sp->entries[1].vector, sp);
3935
3936 writeq(saved64, &bar0->scheduled_int_ctrl);
3937
3938 return err;
3939 }
3940
3941 static void remove_msix_isr(struct s2io_nic *sp)
3942 {
3943 int i;
3944 u16 msi_control;
3945
3946 for (i = 0; i < sp->num_entries; i++) {
3947 if (sp->s2io_entries[i].in_use ==
3948 MSIX_REGISTERED_SUCCESS) {
3949 int vector = sp->entries[i].vector;
3950 void *arg = sp->s2io_entries[i].arg;
3951 free_irq(vector, arg);
3952 }
3953 }
3954
3955 kfree(sp->entries);
3956 kfree(sp->s2io_entries);
3957 sp->entries = NULL;
3958 sp->s2io_entries = NULL;
3959
3960 pci_read_config_word(sp->pdev, 0x42, &msi_control);
3961 msi_control &= 0xFFFE; /* Disable MSI */
3962 pci_write_config_word(sp->pdev, 0x42, msi_control);
3963
3964 pci_disable_msix(sp->pdev);
3965 }
3966
3967 static void remove_inta_isr(struct s2io_nic *sp)
3968 {
3969 struct net_device *dev = sp->dev;
3970
3971 free_irq(sp->pdev->irq, dev);
3972 }
3973
3974 /* ********************************************************* *
3975 * Functions defined below concern the OS part of the driver *
3976 * ********************************************************* */
3977
3978 /**
3979 * s2io_open - open entry point of the driver
3980 * @dev : pointer to the device structure.
3981 * Description:
3982 * This function is the open entry point of the driver. It mainly calls a
3983 * function to allocate Rx buffers and inserts them into the buffer
3984 * descriptors and then enables the Rx part of the NIC.
3985 * Return value:
3986 * 0 on success and an appropriate (-)ve integer as defined in errno.h
3987 * file on failure.
3988 */
3989
3990 static int s2io_open(struct net_device *dev)
3991 {
3992 struct s2io_nic *sp = dev->priv;
3993 int err = 0;
3994
3995 /*
3996 * Make sure you have link off by default every time
3997 * Nic is initialized
3998 */
3999 netif_carrier_off(dev);
4000 sp->last_link_state = 0;
4001
4002 /* Initialize H/W and enable interrupts */
4003 err = s2io_card_up(sp);
4004 if (err) {
4005 DBG_PRINT(ERR_DBG, "%s: H/W initialization failed\n",
4006 dev->name);
4007 goto hw_init_failed;
4008 }
4009
4010 if (do_s2io_prog_unicast(dev, dev->dev_addr) == FAILURE) {
4011 DBG_PRINT(ERR_DBG, "Set Mac Address Failed\n");
4012 s2io_card_down(sp);
4013 err = -ENODEV;
4014 goto hw_init_failed;
4015 }
4016 s2io_start_all_tx_queue(sp);
4017 return 0;
4018
4019 hw_init_failed:
4020 if (sp->config.intr_type == MSI_X) {
4021 if (sp->entries) {
4022 kfree(sp->entries);
4023 sp->mac_control.stats_info->sw_stat.mem_freed
4024 += (sp->num_entries * sizeof(struct msix_entry));
4025 }
4026 if (sp->s2io_entries) {
4027 kfree(sp->s2io_entries);
4028 sp->mac_control.stats_info->sw_stat.mem_freed
4029 += (sp->num_entries * sizeof(struct s2io_msix_entry));
4030 }
4031 }
4032 return err;
4033 }
4034
4035 /**
4036 * s2io_close -close entry point of the driver
4037 * @dev : device pointer.
4038 * Description:
4039 * This is the stop entry point of the driver. It needs to undo exactly
4040 * whatever was done by the open entry point,thus it's usually referred to
4041 * as the close function.Among other things this function mainly stops the
4042 * Rx side of the NIC and frees all the Rx buffers in the Rx rings.
4043 * Return value:
4044 * 0 on success and an appropriate (-)ve integer as defined in errno.h
4045 * file on failure.
4046 */
4047
4048 static int s2io_close(struct net_device *dev)
4049 {
4050 struct s2io_nic *sp = dev->priv;
4051 struct config_param *config = &sp->config;
4052 u64 tmp64;
4053 int offset;
4054
4055 /* Return if the device is already closed *
4056 * Can happen when s2io_card_up failed in change_mtu *
4057 */
4058 if (!is_s2io_card_up(sp))
4059 return 0;
4060
4061 s2io_stop_all_tx_queue(sp);
4062 /* delete all populated mac entries */
4063 for (offset = 1; offset < config->max_mc_addr; offset++) {
4064 tmp64 = do_s2io_read_unicast_mc(sp, offset);
4065 if (tmp64 != S2IO_DISABLE_MAC_ENTRY)
4066 do_s2io_delete_unicast_mc(sp, tmp64);
4067 }
4068
4069 s2io_card_down(sp);
4070
4071 return 0;
4072 }
4073
4074 /**
4075 * s2io_xmit - Tx entry point of te driver
4076 * @skb : the socket buffer containing the Tx data.
4077 * @dev : device pointer.
4078 * Description :
4079 * This function is the Tx entry point of the driver. S2IO NIC supports
4080 * certain protocol assist features on Tx side, namely CSO, S/G, LSO.
4081 * NOTE: when device cant queue the pkt,just the trans_start variable will
4082 * not be upadted.
4083 * Return value:
4084 * 0 on success & 1 on failure.
4085 */
4086
4087 static int s2io_xmit(struct sk_buff *skb, struct net_device *dev)
4088 {
4089 struct s2io_nic *sp = dev->priv;
4090 u16 frg_cnt, frg_len, i, queue, queue_len, put_off, get_off;
4091 register u64 val64;
4092 struct TxD *txdp;
4093 struct TxFIFO_element __iomem *tx_fifo;
4094 unsigned long flags = 0;
4095 u16 vlan_tag = 0;
4096 struct fifo_info *fifo = NULL;
4097 struct mac_info *mac_control;
4098 struct config_param *config;
4099 int do_spin_lock = 1;
4100 int offload_type;
4101 int enable_per_list_interrupt = 0;
4102 struct swStat *stats = &sp->mac_control.stats_info->sw_stat;
4103
4104 mac_control = &sp->mac_control;
4105 config = &sp->config;
4106
4107 DBG_PRINT(TX_DBG, "%s: In Neterion Tx routine\n", dev->name);
4108
4109 if (unlikely(skb->len <= 0)) {
4110 DBG_PRINT(TX_DBG, "%s:Buffer has no data..\n", dev->name);
4111 dev_kfree_skb_any(skb);
4112 return 0;
4113 }
4114
4115 if (!is_s2io_card_up(sp)) {
4116 DBG_PRINT(TX_DBG, "%s: Card going down for reset\n",
4117 dev->name);
4118 dev_kfree_skb(skb);
4119 return 0;
4120 }
4121
4122 queue = 0;
4123 if (sp->vlgrp && vlan_tx_tag_present(skb))
4124 vlan_tag = vlan_tx_tag_get(skb);
4125 if (sp->config.tx_steering_type == TX_DEFAULT_STEERING) {
4126 if (skb->protocol == htons(ETH_P_IP)) {
4127 struct iphdr *ip;
4128 struct tcphdr *th;
4129 ip = ip_hdr(skb);
4130
4131 if ((ip->frag_off & htons(IP_OFFSET|IP_MF)) == 0) {
4132 th = (struct tcphdr *)(((unsigned char *)ip) +
4133 ip->ihl*4);
4134
4135 if (ip->protocol == IPPROTO_TCP) {
4136 queue_len = sp->total_tcp_fifos;
4137 queue = (ntohs(th->source) +
4138 ntohs(th->dest)) &
4139 sp->fifo_selector[queue_len - 1];
4140 if (queue >= queue_len)
4141 queue = queue_len - 1;
4142 } else if (ip->protocol == IPPROTO_UDP) {
4143 queue_len = sp->total_udp_fifos;
4144 queue = (ntohs(th->source) +
4145 ntohs(th->dest)) &
4146 sp->fifo_selector[queue_len - 1];
4147 if (queue >= queue_len)
4148 queue = queue_len - 1;
4149 queue += sp->udp_fifo_idx;
4150 if (skb->len > 1024)
4151 enable_per_list_interrupt = 1;
4152 do_spin_lock = 0;
4153 }
4154 }
4155 }
4156 } else if (sp->config.tx_steering_type == TX_PRIORITY_STEERING)
4157 /* get fifo number based on skb->priority value */
4158 queue = config->fifo_mapping
4159 [skb->priority & (MAX_TX_FIFOS - 1)];
4160 fifo = &mac_control->fifos[queue];
4161
4162 if (do_spin_lock)
4163 spin_lock_irqsave(&fifo->tx_lock, flags);
4164 else {
4165 if (unlikely(!spin_trylock_irqsave(&fifo->tx_lock, flags)))
4166 return NETDEV_TX_LOCKED;
4167 }
4168
4169 if (sp->config.multiq) {
4170 if (__netif_subqueue_stopped(dev, fifo->fifo_no)) {
4171 spin_unlock_irqrestore(&fifo->tx_lock, flags);
4172 return NETDEV_TX_BUSY;
4173 }
4174 } else if (unlikely(fifo->queue_state == FIFO_QUEUE_STOP)) {
4175 if (netif_queue_stopped(dev)) {
4176 spin_unlock_irqrestore(&fifo->tx_lock, flags);
4177 return NETDEV_TX_BUSY;
4178 }
4179 }
4180
4181 put_off = (u16) fifo->tx_curr_put_info.offset;
4182 get_off = (u16) fifo->tx_curr_get_info.offset;
4183 txdp = (struct TxD *) fifo->list_info[put_off].list_virt_addr;
4184
4185 queue_len = fifo->tx_curr_put_info.fifo_len + 1;
4186 /* Avoid "put" pointer going beyond "get" pointer */
4187 if (txdp->Host_Control ||
4188 ((put_off+1) == queue_len ? 0 : (put_off+1)) == get_off) {
4189 DBG_PRINT(TX_DBG, "Error in xmit, No free TXDs.\n");
4190 s2io_stop_tx_queue(sp, fifo->fifo_no);
4191 dev_kfree_skb(skb);
4192 spin_unlock_irqrestore(&fifo->tx_lock, flags);
4193 return 0;
4194 }
4195
4196 offload_type = s2io_offload_type(skb);
4197 if (offload_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6)) {
4198 txdp->Control_1 |= TXD_TCP_LSO_EN;
4199 txdp->Control_1 |= TXD_TCP_LSO_MSS(s2io_tcp_mss(skb));
4200 }
4201 if (skb->ip_summed == CHECKSUM_PARTIAL) {
4202 txdp->Control_2 |=
4203 (TXD_TX_CKO_IPV4_EN | TXD_TX_CKO_TCP_EN |
4204 TXD_TX_CKO_UDP_EN);
4205 }
4206 txdp->Control_1 |= TXD_GATHER_CODE_FIRST;
4207 txdp->Control_1 |= TXD_LIST_OWN_XENA;
4208 txdp->Control_2 |= TXD_INT_NUMBER(fifo->fifo_no);
4209 if (enable_per_list_interrupt)
4210 if (put_off & (queue_len >> 5))
4211 txdp->Control_2 |= TXD_INT_TYPE_PER_LIST;
4212 if (vlan_tag) {
4213 txdp->Control_2 |= TXD_VLAN_ENABLE;
4214 txdp->Control_2 |= TXD_VLAN_TAG(vlan_tag);
4215 }
4216
4217 frg_len = skb->len - skb->data_len;
4218 if (offload_type == SKB_GSO_UDP) {
4219 int ufo_size;
4220
4221 ufo_size = s2io_udp_mss(skb);
4222 ufo_size &= ~7;
4223 txdp->Control_1 |= TXD_UFO_EN;
4224 txdp->Control_1 |= TXD_UFO_MSS(ufo_size);
4225 txdp->Control_1 |= TXD_BUFFER0_SIZE(8);
4226 #ifdef __BIG_ENDIAN
4227 /* both variants do cpu_to_be64(be32_to_cpu(...)) */
4228 fifo->ufo_in_band_v[put_off] =
4229 (__force u64)skb_shinfo(skb)->ip6_frag_id;
4230 #else
4231 fifo->ufo_in_band_v[put_off] =
4232 (__force u64)skb_shinfo(skb)->ip6_frag_id << 32;
4233 #endif
4234 txdp->Host_Control = (unsigned long)fifo->ufo_in_band_v;
4235 txdp->Buffer_Pointer = pci_map_single(sp->pdev,
4236 fifo->ufo_in_band_v,
4237 sizeof(u64), PCI_DMA_TODEVICE);
4238 if (pci_dma_mapping_error(txdp->Buffer_Pointer))
4239 goto pci_map_failed;
4240 txdp++;
4241 }
4242
4243 txdp->Buffer_Pointer = pci_map_single
4244 (sp->pdev, skb->data, frg_len, PCI_DMA_TODEVICE);
4245 if (pci_dma_mapping_error(txdp->Buffer_Pointer))
4246 goto pci_map_failed;
4247
4248 txdp->Host_Control = (unsigned long) skb;
4249 txdp->Control_1 |= TXD_BUFFER0_SIZE(frg_len);
4250 if (offload_type == SKB_GSO_UDP)
4251 txdp->Control_1 |= TXD_UFO_EN;
4252
4253 frg_cnt = skb_shinfo(skb)->nr_frags;
4254 /* For fragmented SKB. */
4255 for (i = 0; i < frg_cnt; i++) {
4256 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
4257 /* A '0' length fragment will be ignored */
4258 if (!frag->size)
4259 continue;
4260 txdp++;
4261 txdp->Buffer_Pointer = (u64) pci_map_page
4262 (sp->pdev, frag->page, frag->page_offset,
4263 frag->size, PCI_DMA_TODEVICE);
4264 txdp->Control_1 = TXD_BUFFER0_SIZE(frag->size);
4265 if (offload_type == SKB_GSO_UDP)
4266 txdp->Control_1 |= TXD_UFO_EN;
4267 }
4268 txdp->Control_1 |= TXD_GATHER_CODE_LAST;
4269
4270 if (offload_type == SKB_GSO_UDP)
4271 frg_cnt++; /* as Txd0 was used for inband header */
4272
4273 tx_fifo = mac_control->tx_FIFO_start[queue];
4274 val64 = fifo->list_info[put_off].list_phy_addr;
4275 writeq(val64, &tx_fifo->TxDL_Pointer);
4276
4277 val64 = (TX_FIFO_LAST_TXD_NUM(frg_cnt) | TX_FIFO_FIRST_LIST |
4278 TX_FIFO_LAST_LIST);
4279 if (offload_type)
4280 val64 |= TX_FIFO_SPECIAL_FUNC;
4281
4282 writeq(val64, &tx_fifo->List_Control);
4283
4284 mmiowb();
4285
4286 put_off++;
4287 if (put_off == fifo->tx_curr_put_info.fifo_len + 1)
4288 put_off = 0;
4289 fifo->tx_curr_put_info.offset = put_off;
4290
4291 /* Avoid "put" pointer going beyond "get" pointer */
4292 if (((put_off+1) == queue_len ? 0 : (put_off+1)) == get_off) {
4293 sp->mac_control.stats_info->sw_stat.fifo_full_cnt++;
4294 DBG_PRINT(TX_DBG,
4295 "No free TxDs for xmit, Put: 0x%x Get:0x%x\n",
4296 put_off, get_off);
4297 s2io_stop_tx_queue(sp, fifo->fifo_no);
4298 }
4299 mac_control->stats_info->sw_stat.mem_allocated += skb->truesize;
4300 dev->trans_start = jiffies;
4301 spin_unlock_irqrestore(&fifo->tx_lock, flags);
4302
4303 if (sp->config.intr_type == MSI_X)
4304 tx_intr_handler(fifo);
4305
4306 return 0;
4307 pci_map_failed:
4308 stats->pci_map_fail_cnt++;
4309 s2io_stop_tx_queue(sp, fifo->fifo_no);
4310 stats->mem_freed += skb->truesize;
4311 dev_kfree_skb(skb);
4312 spin_unlock_irqrestore(&fifo->tx_lock, flags);
4313 return 0;
4314 }
4315
4316 static void
4317 s2io_alarm_handle(unsigned long data)
4318 {
4319 struct s2io_nic *sp = (struct s2io_nic *)data;
4320 struct net_device *dev = sp->dev;
4321
4322 s2io_handle_errors(dev);
4323 mod_timer(&sp->alarm_timer, jiffies + HZ / 2);
4324 }
4325
4326 static irqreturn_t s2io_msix_ring_handle(int irq, void *dev_id)
4327 {
4328 struct ring_info *ring = (struct ring_info *)dev_id;
4329 struct s2io_nic *sp = ring->nic;
4330 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4331 struct net_device *dev = sp->dev;
4332
4333 if (unlikely(!is_s2io_card_up(sp)))
4334 return IRQ_HANDLED;
4335
4336 if (sp->config.napi) {
4337 u8 __iomem *addr = NULL;
4338 u8 val8 = 0;
4339
4340 addr = (u8 __iomem *)&bar0->xmsi_mask_reg;
4341 addr += (7 - ring->ring_no);
4342 val8 = (ring->ring_no == 0) ? 0x7f : 0xff;
4343 writeb(val8, addr);
4344 val8 = readb(addr);
4345 netif_rx_schedule(dev, &ring->napi);
4346 } else {
4347 rx_intr_handler(ring, 0);
4348 s2io_chk_rx_buffers(ring);
4349 }
4350
4351 return IRQ_HANDLED;
4352 }
4353
4354 static irqreturn_t s2io_msix_fifo_handle(int irq, void *dev_id)
4355 {
4356 int i;
4357 struct fifo_info *fifos = (struct fifo_info *)dev_id;
4358 struct s2io_nic *sp = fifos->nic;
4359 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4360 struct config_param *config = &sp->config;
4361 u64 reason;
4362
4363 if (unlikely(!is_s2io_card_up(sp)))
4364 return IRQ_NONE;
4365
4366 reason = readq(&bar0->general_int_status);
4367 if (unlikely(reason == S2IO_MINUS_ONE))
4368 /* Nothing much can be done. Get out */
4369 return IRQ_HANDLED;
4370
4371 if (reason & (GEN_INTR_TXPIC | GEN_INTR_TXTRAFFIC)) {
4372 writeq(S2IO_MINUS_ONE, &bar0->general_int_mask);
4373
4374 if (reason & GEN_INTR_TXPIC)
4375 s2io_txpic_intr_handle(sp);
4376
4377 if (reason & GEN_INTR_TXTRAFFIC)
4378 writeq(S2IO_MINUS_ONE, &bar0->tx_traffic_int);
4379
4380 for (i = 0; i < config->tx_fifo_num; i++)
4381 tx_intr_handler(&fifos[i]);
4382
4383 writeq(sp->general_int_mask, &bar0->general_int_mask);
4384 readl(&bar0->general_int_status);
4385 return IRQ_HANDLED;
4386 }
4387 /* The interrupt was not raised by us */
4388 return IRQ_NONE;
4389 }
4390
4391 static void s2io_txpic_intr_handle(struct s2io_nic *sp)
4392 {
4393 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4394 u64 val64;
4395
4396 val64 = readq(&bar0->pic_int_status);
4397 if (val64 & PIC_INT_GPIO) {
4398 val64 = readq(&bar0->gpio_int_reg);
4399 if ((val64 & GPIO_INT_REG_LINK_DOWN) &&
4400 (val64 & GPIO_INT_REG_LINK_UP)) {
4401 /*
4402 * This is unstable state so clear both up/down
4403 * interrupt and adapter to re-evaluate the link state.
4404 */
4405 val64 |= GPIO_INT_REG_LINK_DOWN;
4406 val64 |= GPIO_INT_REG_LINK_UP;
4407 writeq(val64, &bar0->gpio_int_reg);
4408 val64 = readq(&bar0->gpio_int_mask);
4409 val64 &= ~(GPIO_INT_MASK_LINK_UP |
4410 GPIO_INT_MASK_LINK_DOWN);
4411 writeq(val64, &bar0->gpio_int_mask);
4412 }
4413 else if (val64 & GPIO_INT_REG_LINK_UP) {
4414 val64 = readq(&bar0->adapter_status);
4415 /* Enable Adapter */
4416 val64 = readq(&bar0->adapter_control);
4417 val64 |= ADAPTER_CNTL_EN;
4418 writeq(val64, &bar0->adapter_control);
4419 val64 |= ADAPTER_LED_ON;
4420 writeq(val64, &bar0->adapter_control);
4421 if (!sp->device_enabled_once)
4422 sp->device_enabled_once = 1;
4423
4424 s2io_link(sp, LINK_UP);
4425 /*
4426 * unmask link down interrupt and mask link-up
4427 * intr
4428 */
4429 val64 = readq(&bar0->gpio_int_mask);
4430 val64 &= ~GPIO_INT_MASK_LINK_DOWN;
4431 val64 |= GPIO_INT_MASK_LINK_UP;
4432 writeq(val64, &bar0->gpio_int_mask);
4433
4434 }else if (val64 & GPIO_INT_REG_LINK_DOWN) {
4435 val64 = readq(&bar0->adapter_status);
4436 s2io_link(sp, LINK_DOWN);
4437 /* Link is down so unmaks link up interrupt */
4438 val64 = readq(&bar0->gpio_int_mask);
4439 val64 &= ~GPIO_INT_MASK_LINK_UP;
4440 val64 |= GPIO_INT_MASK_LINK_DOWN;
4441 writeq(val64, &bar0->gpio_int_mask);
4442
4443 /* turn off LED */
4444 val64 = readq(&bar0->adapter_control);
4445 val64 = val64 &(~ADAPTER_LED_ON);
4446 writeq(val64, &bar0->adapter_control);
4447 }
4448 }
4449 val64 = readq(&bar0->gpio_int_mask);
4450 }
4451
4452 /**
4453 * do_s2io_chk_alarm_bit - Check for alarm and incrment the counter
4454 * @value: alarm bits
4455 * @addr: address value
4456 * @cnt: counter variable
4457 * Description: Check for alarm and increment the counter
4458 * Return Value:
4459 * 1 - if alarm bit set
4460 * 0 - if alarm bit is not set
4461 */
4462 static int do_s2io_chk_alarm_bit(u64 value, void __iomem * addr,
4463 unsigned long long *cnt)
4464 {
4465 u64 val64;
4466 val64 = readq(addr);
4467 if ( val64 & value ) {
4468 writeq(val64, addr);
4469 (*cnt)++;
4470 return 1;
4471 }
4472 return 0;
4473
4474 }
4475
4476 /**
4477 * s2io_handle_errors - Xframe error indication handler
4478 * @nic: device private variable
4479 * Description: Handle alarms such as loss of link, single or
4480 * double ECC errors, critical and serious errors.
4481 * Return Value:
4482 * NONE
4483 */
4484 static void s2io_handle_errors(void * dev_id)
4485 {
4486 struct net_device *dev = (struct net_device *) dev_id;
4487 struct s2io_nic *sp = dev->priv;
4488 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4489 u64 temp64 = 0,val64=0;
4490 int i = 0;
4491
4492 struct swStat *sw_stat = &sp->mac_control.stats_info->sw_stat;
4493 struct xpakStat *stats = &sp->mac_control.stats_info->xpak_stat;
4494
4495 if (!is_s2io_card_up(sp))
4496 return;
4497
4498 if (pci_channel_offline(sp->pdev))
4499 return;
4500
4501 memset(&sw_stat->ring_full_cnt, 0,
4502 sizeof(sw_stat->ring_full_cnt));
4503
4504 /* Handling the XPAK counters update */
4505 if(stats->xpak_timer_count < 72000) {
4506 /* waiting for an hour */
4507 stats->xpak_timer_count++;
4508 } else {
4509 s2io_updt_xpak_counter(dev);
4510 /* reset the count to zero */
4511 stats->xpak_timer_count = 0;
4512 }
4513
4514 /* Handling link status change error Intr */
4515 if (s2io_link_fault_indication(sp) == MAC_RMAC_ERR_TIMER) {
4516 val64 = readq(&bar0->mac_rmac_err_reg);
4517 writeq(val64, &bar0->mac_rmac_err_reg);
4518 if (val64 & RMAC_LINK_STATE_CHANGE_INT)
4519 schedule_work(&sp->set_link_task);
4520 }
4521
4522 /* In case of a serious error, the device will be Reset. */
4523 if (do_s2io_chk_alarm_bit(SERR_SOURCE_ANY, &bar0->serr_source,
4524 &sw_stat->serious_err_cnt))
4525 goto reset;
4526
4527 /* Check for data parity error */
4528 if (do_s2io_chk_alarm_bit(GPIO_INT_REG_DP_ERR_INT, &bar0->gpio_int_reg,
4529 &sw_stat->parity_err_cnt))
4530 goto reset;
4531
4532 /* Check for ring full counter */
4533 if (sp->device_type == XFRAME_II_DEVICE) {
4534 val64 = readq(&bar0->ring_bump_counter1);
4535 for (i=0; i<4; i++) {
4536 temp64 = ( val64 & vBIT(0xFFFF,(i*16),16));
4537 temp64 >>= 64 - ((i+1)*16);
4538 sw_stat->ring_full_cnt[i] += temp64;
4539 }
4540
4541 val64 = readq(&bar0->ring_bump_counter2);
4542 for (i=0; i<4; i++) {
4543 temp64 = ( val64 & vBIT(0xFFFF,(i*16),16));
4544 temp64 >>= 64 - ((i+1)*16);
4545 sw_stat->ring_full_cnt[i+4] += temp64;
4546 }
4547 }
4548
4549 val64 = readq(&bar0->txdma_int_status);
4550 /*check for pfc_err*/
4551 if (val64 & TXDMA_PFC_INT) {
4552 if (do_s2io_chk_alarm_bit(PFC_ECC_DB_ERR | PFC_SM_ERR_ALARM|
4553 PFC_MISC_0_ERR | PFC_MISC_1_ERR|
4554 PFC_PCIX_ERR, &bar0->pfc_err_reg,
4555 &sw_stat->pfc_err_cnt))
4556 goto reset;
4557 do_s2io_chk_alarm_bit(PFC_ECC_SG_ERR, &bar0->pfc_err_reg,
4558 &sw_stat->pfc_err_cnt);
4559 }
4560
4561 /*check for tda_err*/
4562 if (val64 & TXDMA_TDA_INT) {
4563 if(do_s2io_chk_alarm_bit(TDA_Fn_ECC_DB_ERR | TDA_SM0_ERR_ALARM |
4564 TDA_SM1_ERR_ALARM, &bar0->tda_err_reg,
4565 &sw_stat->tda_err_cnt))
4566 goto reset;
4567 do_s2io_chk_alarm_bit(TDA_Fn_ECC_SG_ERR | TDA_PCIX_ERR,
4568 &bar0->tda_err_reg, &sw_stat->tda_err_cnt);
4569 }
4570 /*check for pcc_err*/
4571 if (val64 & TXDMA_PCC_INT) {
4572 if (do_s2io_chk_alarm_bit(PCC_SM_ERR_ALARM | PCC_WR_ERR_ALARM
4573 | PCC_N_SERR | PCC_6_COF_OV_ERR
4574 | PCC_7_COF_OV_ERR | PCC_6_LSO_OV_ERR
4575 | PCC_7_LSO_OV_ERR | PCC_FB_ECC_DB_ERR
4576 | PCC_TXB_ECC_DB_ERR, &bar0->pcc_err_reg,
4577 &sw_stat->pcc_err_cnt))
4578 goto reset;
4579 do_s2io_chk_alarm_bit(PCC_FB_ECC_SG_ERR | PCC_TXB_ECC_SG_ERR,
4580 &bar0->pcc_err_reg, &sw_stat->pcc_err_cnt);
4581 }
4582
4583 /*check for tti_err*/
4584 if (val64 & TXDMA_TTI_INT) {
4585 if (do_s2io_chk_alarm_bit(TTI_SM_ERR_ALARM, &bar0->tti_err_reg,
4586 &sw_stat->tti_err_cnt))
4587 goto reset;
4588 do_s2io_chk_alarm_bit(TTI_ECC_SG_ERR | TTI_ECC_DB_ERR,
4589 &bar0->tti_err_reg, &sw_stat->tti_err_cnt);
4590 }
4591
4592 /*check for lso_err*/
4593 if (val64 & TXDMA_LSO_INT) {
4594 if (do_s2io_chk_alarm_bit(LSO6_ABORT | LSO7_ABORT
4595 | LSO6_SM_ERR_ALARM | LSO7_SM_ERR_ALARM,
4596 &bar0->lso_err_reg, &sw_stat->lso_err_cnt))
4597 goto reset;
4598 do_s2io_chk_alarm_bit(LSO6_SEND_OFLOW | LSO7_SEND_OFLOW,
4599 &bar0->lso_err_reg, &sw_stat->lso_err_cnt);
4600 }
4601
4602 /*check for tpa_err*/
4603 if (val64 & TXDMA_TPA_INT) {
4604 if (do_s2io_chk_alarm_bit(TPA_SM_ERR_ALARM, &bar0->tpa_err_reg,
4605 &sw_stat->tpa_err_cnt))
4606 goto reset;
4607 do_s2io_chk_alarm_bit(TPA_TX_FRM_DROP, &bar0->tpa_err_reg,
4608 &sw_stat->tpa_err_cnt);
4609 }
4610
4611 /*check for sm_err*/
4612 if (val64 & TXDMA_SM_INT) {
4613 if (do_s2io_chk_alarm_bit(SM_SM_ERR_ALARM, &bar0->sm_err_reg,
4614 &sw_stat->sm_err_cnt))
4615 goto reset;
4616 }
4617
4618 val64 = readq(&bar0->mac_int_status);
4619 if (val64 & MAC_INT_STATUS_TMAC_INT) {
4620 if (do_s2io_chk_alarm_bit(TMAC_TX_BUF_OVRN | TMAC_TX_SM_ERR,
4621 &bar0->mac_tmac_err_reg,
4622 &sw_stat->mac_tmac_err_cnt))
4623 goto reset;
4624 do_s2io_chk_alarm_bit(TMAC_ECC_SG_ERR | TMAC_ECC_DB_ERR
4625 | TMAC_DESC_ECC_SG_ERR | TMAC_DESC_ECC_DB_ERR,
4626 &bar0->mac_tmac_err_reg,
4627 &sw_stat->mac_tmac_err_cnt);
4628 }
4629
4630 val64 = readq(&bar0->xgxs_int_status);
4631 if (val64 & XGXS_INT_STATUS_TXGXS) {
4632 if (do_s2io_chk_alarm_bit(TXGXS_ESTORE_UFLOW | TXGXS_TX_SM_ERR,
4633 &bar0->xgxs_txgxs_err_reg,
4634 &sw_stat->xgxs_txgxs_err_cnt))
4635 goto reset;
4636 do_s2io_chk_alarm_bit(TXGXS_ECC_SG_ERR | TXGXS_ECC_DB_ERR,
4637 &bar0->xgxs_txgxs_err_reg,
4638 &sw_stat->xgxs_txgxs_err_cnt);
4639 }
4640
4641 val64 = readq(&bar0->rxdma_int_status);
4642 if (val64 & RXDMA_INT_RC_INT_M) {
4643 if (do_s2io_chk_alarm_bit(RC_PRCn_ECC_DB_ERR | RC_FTC_ECC_DB_ERR
4644 | RC_PRCn_SM_ERR_ALARM |RC_FTC_SM_ERR_ALARM,
4645 &bar0->rc_err_reg, &sw_stat->rc_err_cnt))
4646 goto reset;
4647 do_s2io_chk_alarm_bit(RC_PRCn_ECC_SG_ERR | RC_FTC_ECC_SG_ERR
4648 | RC_RDA_FAIL_WR_Rn, &bar0->rc_err_reg,
4649 &sw_stat->rc_err_cnt);
4650 if (do_s2io_chk_alarm_bit(PRC_PCI_AB_RD_Rn | PRC_PCI_AB_WR_Rn
4651 | PRC_PCI_AB_F_WR_Rn, &bar0->prc_pcix_err_reg,
4652 &sw_stat->prc_pcix_err_cnt))
4653 goto reset;
4654 do_s2io_chk_alarm_bit(PRC_PCI_DP_RD_Rn | PRC_PCI_DP_WR_Rn
4655 | PRC_PCI_DP_F_WR_Rn, &bar0->prc_pcix_err_reg,
4656 &sw_stat->prc_pcix_err_cnt);
4657 }
4658
4659 if (val64 & RXDMA_INT_RPA_INT_M) {
4660 if (do_s2io_chk_alarm_bit(RPA_SM_ERR_ALARM | RPA_CREDIT_ERR,
4661 &bar0->rpa_err_reg, &sw_stat->rpa_err_cnt))
4662 goto reset;
4663 do_s2io_chk_alarm_bit(RPA_ECC_SG_ERR | RPA_ECC_DB_ERR,
4664 &bar0->rpa_err_reg, &sw_stat->rpa_err_cnt);
4665 }
4666
4667 if (val64 & RXDMA_INT_RDA_INT_M) {
4668 if (do_s2io_chk_alarm_bit(RDA_RXDn_ECC_DB_ERR
4669 | RDA_FRM_ECC_DB_N_AERR | RDA_SM1_ERR_ALARM
4670 | RDA_SM0_ERR_ALARM | RDA_RXD_ECC_DB_SERR,
4671 &bar0->rda_err_reg, &sw_stat->rda_err_cnt))
4672 goto reset;
4673 do_s2io_chk_alarm_bit(RDA_RXDn_ECC_SG_ERR | RDA_FRM_ECC_SG_ERR
4674 | RDA_MISC_ERR | RDA_PCIX_ERR,
4675 &bar0->rda_err_reg, &sw_stat->rda_err_cnt);
4676 }
4677
4678 if (val64 & RXDMA_INT_RTI_INT_M) {
4679 if (do_s2io_chk_alarm_bit(RTI_SM_ERR_ALARM, &bar0->rti_err_reg,
4680 &sw_stat->rti_err_cnt))
4681 goto reset;
4682 do_s2io_chk_alarm_bit(RTI_ECC_SG_ERR | RTI_ECC_DB_ERR,
4683 &bar0->rti_err_reg, &sw_stat->rti_err_cnt);
4684 }
4685
4686 val64 = readq(&bar0->mac_int_status);
4687 if (val64 & MAC_INT_STATUS_RMAC_INT) {
4688 if (do_s2io_chk_alarm_bit(RMAC_RX_BUFF_OVRN | RMAC_RX_SM_ERR,
4689 &bar0->mac_rmac_err_reg,
4690 &sw_stat->mac_rmac_err_cnt))
4691 goto reset;
4692 do_s2io_chk_alarm_bit(RMAC_UNUSED_INT|RMAC_SINGLE_ECC_ERR|
4693 RMAC_DOUBLE_ECC_ERR, &bar0->mac_rmac_err_reg,
4694 &sw_stat->mac_rmac_err_cnt);
4695 }
4696
4697 val64 = readq(&bar0->xgxs_int_status);
4698 if (val64 & XGXS_INT_STATUS_RXGXS) {
4699 if (do_s2io_chk_alarm_bit(RXGXS_ESTORE_OFLOW | RXGXS_RX_SM_ERR,
4700 &bar0->xgxs_rxgxs_err_reg,
4701 &sw_stat->xgxs_rxgxs_err_cnt))
4702 goto reset;
4703 }
4704
4705 val64 = readq(&bar0->mc_int_status);
4706 if(val64 & MC_INT_STATUS_MC_INT) {
4707 if (do_s2io_chk_alarm_bit(MC_ERR_REG_SM_ERR, &bar0->mc_err_reg,
4708 &sw_stat->mc_err_cnt))
4709 goto reset;
4710
4711 /* Handling Ecc errors */
4712 if (val64 & (MC_ERR_REG_ECC_ALL_SNG | MC_ERR_REG_ECC_ALL_DBL)) {
4713 writeq(val64, &bar0->mc_err_reg);
4714 if (val64 & MC_ERR_REG_ECC_ALL_DBL) {
4715 sw_stat->double_ecc_errs++;
4716 if (sp->device_type != XFRAME_II_DEVICE) {
4717 /*
4718 * Reset XframeI only if critical error
4719 */
4720 if (val64 &
4721 (MC_ERR_REG_MIRI_ECC_DB_ERR_0 |
4722 MC_ERR_REG_MIRI_ECC_DB_ERR_1))
4723 goto reset;
4724 }
4725 } else
4726 sw_stat->single_ecc_errs++;
4727 }
4728 }
4729 return;
4730
4731 reset:
4732 s2io_stop_all_tx_queue(sp);
4733 schedule_work(&sp->rst_timer_task);
4734 sw_stat->soft_reset_cnt++;
4735 return;
4736 }
4737
4738 /**
4739 * s2io_isr - ISR handler of the device .
4740 * @irq: the irq of the device.
4741 * @dev_id: a void pointer to the dev structure of the NIC.
4742 * Description: This function is the ISR handler of the device. It
4743 * identifies the reason for the interrupt and calls the relevant
4744 * service routines. As a contongency measure, this ISR allocates the
4745 * recv buffers, if their numbers are below the panic value which is
4746 * presently set to 25% of the original number of rcv buffers allocated.
4747 * Return value:
4748 * IRQ_HANDLED: will be returned if IRQ was handled by this routine
4749 * IRQ_NONE: will be returned if interrupt is not from our device
4750 */
4751 static irqreturn_t s2io_isr(int irq, void *dev_id)
4752 {
4753 struct net_device *dev = (struct net_device *) dev_id;
4754 struct s2io_nic *sp = dev->priv;
4755 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4756 int i;
4757 u64 reason = 0;
4758 struct mac_info *mac_control;
4759 struct config_param *config;
4760
4761 /* Pretend we handled any irq's from a disconnected card */
4762 if (pci_channel_offline(sp->pdev))
4763 return IRQ_NONE;
4764
4765 if (!is_s2io_card_up(sp))
4766 return IRQ_NONE;
4767
4768 mac_control = &sp->mac_control;
4769 config = &sp->config;
4770
4771 /*
4772 * Identify the cause for interrupt and call the appropriate
4773 * interrupt handler. Causes for the interrupt could be;
4774 * 1. Rx of packet.
4775 * 2. Tx complete.
4776 * 3. Link down.
4777 */
4778 reason = readq(&bar0->general_int_status);
4779
4780 if (unlikely(reason == S2IO_MINUS_ONE) ) {
4781 /* Nothing much can be done. Get out */
4782 return IRQ_HANDLED;
4783 }
4784
4785 if (reason & (GEN_INTR_RXTRAFFIC |
4786 GEN_INTR_TXTRAFFIC | GEN_INTR_TXPIC))
4787 {
4788 writeq(S2IO_MINUS_ONE, &bar0->general_int_mask);
4789
4790 if (config->napi) {
4791 if (reason & GEN_INTR_RXTRAFFIC) {
4792 netif_rx_schedule(dev, &sp->napi);
4793 writeq(S2IO_MINUS_ONE, &bar0->rx_traffic_mask);
4794 writeq(S2IO_MINUS_ONE, &bar0->rx_traffic_int);
4795 readl(&bar0->rx_traffic_int);
4796 }
4797 } else {
4798 /*
4799 * rx_traffic_int reg is an R1 register, writing all 1's
4800 * will ensure that the actual interrupt causing bit
4801 * get's cleared and hence a read can be avoided.
4802 */
4803 if (reason & GEN_INTR_RXTRAFFIC)
4804 writeq(S2IO_MINUS_ONE, &bar0->rx_traffic_int);
4805
4806 for (i = 0; i < config->rx_ring_num; i++)
4807 rx_intr_handler(&mac_control->rings[i], 0);
4808 }
4809
4810 /*
4811 * tx_traffic_int reg is an R1 register, writing all 1's
4812 * will ensure that the actual interrupt causing bit get's
4813 * cleared and hence a read can be avoided.
4814 */
4815 if (reason & GEN_INTR_TXTRAFFIC)
4816 writeq(S2IO_MINUS_ONE, &bar0->tx_traffic_int);
4817
4818 for (i = 0; i < config->tx_fifo_num; i++)
4819 tx_intr_handler(&mac_control->fifos[i]);
4820
4821 if (reason & GEN_INTR_TXPIC)
4822 s2io_txpic_intr_handle(sp);
4823
4824 /*
4825 * Reallocate the buffers from the interrupt handler itself.
4826 */
4827 if (!config->napi) {
4828 for (i = 0; i < config->rx_ring_num; i++)
4829 s2io_chk_rx_buffers(&mac_control->rings[i]);
4830 }
4831 writeq(sp->general_int_mask, &bar0->general_int_mask);
4832 readl(&bar0->general_int_status);
4833
4834 return IRQ_HANDLED;
4835
4836 }
4837 else if (!reason) {
4838 /* The interrupt was not raised by us */
4839 return IRQ_NONE;
4840 }
4841
4842 return IRQ_HANDLED;
4843 }
4844
4845 /**
4846 * s2io_updt_stats -
4847 */
4848 static void s2io_updt_stats(struct s2io_nic *sp)
4849 {
4850 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4851 u64 val64;
4852 int cnt = 0;
4853
4854 if (is_s2io_card_up(sp)) {
4855 /* Apprx 30us on a 133 MHz bus */
4856 val64 = SET_UPDT_CLICKS(10) |
4857 STAT_CFG_ONE_SHOT_EN | STAT_CFG_STAT_EN;
4858 writeq(val64, &bar0->stat_cfg);
4859 do {
4860 udelay(100);
4861 val64 = readq(&bar0->stat_cfg);
4862 if (!(val64 & s2BIT(0)))
4863 break;
4864 cnt++;
4865 if (cnt == 5)
4866 break; /* Updt failed */
4867 } while(1);
4868 }
4869 }
4870
4871 /**
4872 * s2io_get_stats - Updates the device statistics structure.
4873 * @dev : pointer to the device structure.
4874 * Description:
4875 * This function updates the device statistics structure in the s2io_nic
4876 * structure and returns a pointer to the same.
4877 * Return value:
4878 * pointer to the updated net_device_stats structure.
4879 */
4880
4881 static struct net_device_stats *s2io_get_stats(struct net_device *dev)
4882 {
4883 struct s2io_nic *sp = dev->priv;
4884 struct mac_info *mac_control;
4885 struct config_param *config;
4886 int i;
4887
4888
4889 mac_control = &sp->mac_control;
4890 config = &sp->config;
4891
4892 /* Configure Stats for immediate updt */
4893 s2io_updt_stats(sp);
4894
4895 sp->stats.tx_packets =
4896 le32_to_cpu(mac_control->stats_info->tmac_frms);
4897 sp->stats.tx_errors =
4898 le32_to_cpu(mac_control->stats_info->tmac_any_err_frms);
4899 sp->stats.rx_errors =
4900 le64_to_cpu(mac_control->stats_info->rmac_drop_frms);
4901 sp->stats.multicast =
4902 le32_to_cpu(mac_control->stats_info->rmac_vld_mcst_frms);
4903 sp->stats.rx_length_errors =
4904 le64_to_cpu(mac_control->stats_info->rmac_long_frms);
4905
4906 /* collect per-ring rx_packets and rx_bytes */
4907 sp->stats.rx_packets = sp->stats.rx_bytes = 0;
4908 for (i = 0; i < config->rx_ring_num; i++) {
4909 sp->stats.rx_packets += mac_control->rings[i].rx_packets;
4910 sp->stats.rx_bytes += mac_control->rings[i].rx_bytes;
4911 }
4912
4913 return (&sp->stats);
4914 }
4915
4916 /**
4917 * s2io_set_multicast - entry point for multicast address enable/disable.
4918 * @dev : pointer to the device structure
4919 * Description:
4920 * This function is a driver entry point which gets called by the kernel
4921 * whenever multicast addresses must be enabled/disabled. This also gets
4922 * called to set/reset promiscuous mode. Depending on the deivce flag, we
4923 * determine, if multicast address must be enabled or if promiscuous mode
4924 * is to be disabled etc.
4925 * Return value:
4926 * void.
4927 */
4928
4929 static void s2io_set_multicast(struct net_device *dev)
4930 {
4931 int i, j, prev_cnt;
4932 struct dev_mc_list *mclist;
4933 struct s2io_nic *sp = dev->priv;
4934 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4935 u64 val64 = 0, multi_mac = 0x010203040506ULL, mask =
4936 0xfeffffffffffULL;
4937 u64 dis_addr = S2IO_DISABLE_MAC_ENTRY, mac_addr = 0;
4938 void __iomem *add;
4939 struct config_param *config = &sp->config;
4940
4941 if ((dev->flags & IFF_ALLMULTI) && (!sp->m_cast_flg)) {
4942 /* Enable all Multicast addresses */
4943 writeq(RMAC_ADDR_DATA0_MEM_ADDR(multi_mac),
4944 &bar0->rmac_addr_data0_mem);
4945 writeq(RMAC_ADDR_DATA1_MEM_MASK(mask),
4946 &bar0->rmac_addr_data1_mem);
4947 val64 = RMAC_ADDR_CMD_MEM_WE |
4948 RMAC_ADDR_CMD_MEM_STROBE_NEW_CMD |
4949 RMAC_ADDR_CMD_MEM_OFFSET(config->max_mc_addr - 1);
4950 writeq(val64, &bar0->rmac_addr_cmd_mem);
4951 /* Wait till command completes */
4952 wait_for_cmd_complete(&bar0->rmac_addr_cmd_mem,
4953 RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING,
4954 S2IO_BIT_RESET);
4955
4956 sp->m_cast_flg = 1;
4957 sp->all_multi_pos = config->max_mc_addr - 1;
4958 } else if ((dev->flags & IFF_ALLMULTI) && (sp->m_cast_flg)) {
4959 /* Disable all Multicast addresses */
4960 writeq(RMAC_ADDR_DATA0_MEM_ADDR(dis_addr),
4961 &bar0->rmac_addr_data0_mem);
4962 writeq(RMAC_ADDR_DATA1_MEM_MASK(0x0),
4963 &bar0->rmac_addr_data1_mem);
4964 val64 = RMAC_ADDR_CMD_MEM_WE |
4965 RMAC_ADDR_CMD_MEM_STROBE_NEW_CMD |
4966 RMAC_ADDR_CMD_MEM_OFFSET(sp->all_multi_pos);
4967 writeq(val64, &bar0->rmac_addr_cmd_mem);
4968 /* Wait till command completes */
4969 wait_for_cmd_complete(&bar0->rmac_addr_cmd_mem,
4970 RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING,
4971 S2IO_BIT_RESET);
4972
4973 sp->m_cast_flg = 0;
4974 sp->all_multi_pos = 0;
4975 }
4976
4977 if ((dev->flags & IFF_PROMISC) && (!sp->promisc_flg)) {
4978 /* Put the NIC into promiscuous mode */
4979 add = &bar0->mac_cfg;
4980 val64 = readq(&bar0->mac_cfg);
4981 val64 |= MAC_CFG_RMAC_PROM_ENABLE;
4982
4983 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
4984 writel((u32) val64, add);
4985 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
4986 writel((u32) (val64 >> 32), (add + 4));
4987
4988 if (vlan_tag_strip != 1) {
4989 val64 = readq(&bar0->rx_pa_cfg);
4990 val64 &= ~RX_PA_CFG_STRIP_VLAN_TAG;
4991 writeq(val64, &bar0->rx_pa_cfg);
4992 vlan_strip_flag = 0;
4993 }
4994
4995 val64 = readq(&bar0->mac_cfg);
4996 sp->promisc_flg = 1;
4997 DBG_PRINT(INFO_DBG, "%s: entered promiscuous mode\n",
4998 dev->name);
4999 } else if (!(dev->flags & IFF_PROMISC) && (sp->promisc_flg)) {
5000 /* Remove the NIC from promiscuous mode */
5001 add = &bar0->mac_cfg;
5002 val64 = readq(&bar0->mac_cfg);
5003 val64 &= ~MAC_CFG_RMAC_PROM_ENABLE;
5004
5005 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
5006 writel((u32) val64, add);
5007 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key);
5008 writel((u32) (val64 >> 32), (add + 4));
5009
5010 if (vlan_tag_strip != 0) {
5011 val64 = readq(&bar0->rx_pa_cfg);
5012 val64 |= RX_PA_CFG_STRIP_VLAN_TAG;
5013 writeq(val64, &bar0->rx_pa_cfg);
5014 vlan_strip_flag = 1;
5015 }
5016
5017 val64 = readq(&bar0->mac_cfg);
5018 sp->promisc_flg = 0;
5019 DBG_PRINT(INFO_DBG, "%s: left promiscuous mode\n",
5020 dev->name);
5021 }
5022
5023 /* Update individual M_CAST address list */
5024 if ((!sp->m_cast_flg) && dev->mc_count) {
5025 if (dev->mc_count >
5026 (config->max_mc_addr - config->max_mac_addr)) {
5027 DBG_PRINT(ERR_DBG, "%s: No more Rx filters ",
5028 dev->name);
5029 DBG_PRINT(ERR_DBG, "can be added, please enable ");
5030 DBG_PRINT(ERR_DBG, "ALL_MULTI instead\n");
5031 return;
5032 }
5033
5034 prev_cnt = sp->mc_addr_count;
5035 sp->mc_addr_count = dev->mc_count;
5036
5037 /* Clear out the previous list of Mc in the H/W. */
5038 for (i = 0; i < prev_cnt; i++) {
5039 writeq(RMAC_ADDR_DATA0_MEM_ADDR(dis_addr),
5040 &bar0->rmac_addr_data0_mem);
5041 writeq(RMAC_ADDR_DATA1_MEM_MASK(0ULL),
5042 &bar0->rmac_addr_data1_mem);
5043 val64 = RMAC_ADDR_CMD_MEM_WE |
5044 RMAC_ADDR_CMD_MEM_STROBE_NEW_CMD |
5045 RMAC_ADDR_CMD_MEM_OFFSET
5046 (config->mc_start_offset + i);
5047 writeq(val64, &bar0->rmac_addr_cmd_mem);
5048
5049 /* Wait for command completes */
5050 if (wait_for_cmd_complete(&bar0->rmac_addr_cmd_mem,
5051 RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING,
5052 S2IO_BIT_RESET)) {
5053 DBG_PRINT(ERR_DBG, "%s: Adding ",
5054 dev->name);
5055 DBG_PRINT(ERR_DBG, "Multicasts failed\n");
5056 return;
5057 }
5058 }
5059
5060 /* Create the new Rx filter list and update the same in H/W. */
5061 for (i = 0, mclist = dev->mc_list; i < dev->mc_count;
5062 i++, mclist = mclist->next) {
5063 memcpy(sp->usr_addrs[i].addr, mclist->dmi_addr,
5064 ETH_ALEN);
5065 mac_addr = 0;
5066 for (j = 0; j < ETH_ALEN; j++) {
5067 mac_addr |= mclist->dmi_addr[j];
5068 mac_addr <<= 8;
5069 }
5070 mac_addr >>= 8;
5071 writeq(RMAC_ADDR_DATA0_MEM_ADDR(mac_addr),
5072 &bar0->rmac_addr_data0_mem);
5073 writeq(RMAC_ADDR_DATA1_MEM_MASK(0ULL),
5074 &bar0->rmac_addr_data1_mem);
5075 val64 = RMAC_ADDR_CMD_MEM_WE |
5076 RMAC_ADDR_CMD_MEM_STROBE_NEW_CMD |
5077 RMAC_ADDR_CMD_MEM_OFFSET
5078 (i + config->mc_start_offset);
5079 writeq(val64, &bar0->rmac_addr_cmd_mem);
5080
5081 /* Wait for command completes */
5082 if (wait_for_cmd_complete(&bar0->rmac_addr_cmd_mem,
5083 RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING,
5084 S2IO_BIT_RESET)) {
5085 DBG_PRINT(ERR_DBG, "%s: Adding ",
5086 dev->name);
5087 DBG_PRINT(ERR_DBG, "Multicasts failed\n");
5088 return;
5089 }
5090 }
5091 }
5092 }
5093
5094 /* read from CAM unicast & multicast addresses and store it in
5095 * def_mac_addr structure
5096 */
5097 void do_s2io_store_unicast_mc(struct s2io_nic *sp)
5098 {
5099 int offset;
5100 u64 mac_addr = 0x0;
5101 struct config_param *config = &sp->config;
5102
5103 /* store unicast & multicast mac addresses */
5104 for (offset = 0; offset < config->max_mc_addr; offset++) {
5105 mac_addr = do_s2io_read_unicast_mc(sp, offset);
5106 /* if read fails disable the entry */
5107 if (mac_addr == FAILURE)
5108 mac_addr = S2IO_DISABLE_MAC_ENTRY;
5109 do_s2io_copy_mac_addr(sp, offset, mac_addr);
5110 }
5111 }
5112
5113 /* restore unicast & multicast MAC to CAM from def_mac_addr structure */
5114 static void do_s2io_restore_unicast_mc(struct s2io_nic *sp)
5115 {
5116 int offset;
5117 struct config_param *config = &sp->config;
5118 /* restore unicast mac address */
5119 for (offset = 0; offset < config->max_mac_addr; offset++)
5120 do_s2io_prog_unicast(sp->dev,
5121 sp->def_mac_addr[offset].mac_addr);
5122
5123 /* restore multicast mac address */
5124 for (offset = config->mc_start_offset;
5125 offset < config->max_mc_addr; offset++)
5126 do_s2io_add_mc(sp, sp->def_mac_addr[offset].mac_addr);
5127 }
5128
5129 /* add a multicast MAC address to CAM */
5130 static int do_s2io_add_mc(struct s2io_nic *sp, u8 *addr)
5131 {
5132 int i;
5133 u64 mac_addr = 0;
5134 struct config_param *config = &sp->config;
5135
5136 for (i = 0; i < ETH_ALEN; i++) {
5137 mac_addr <<= 8;
5138 mac_addr |= addr[i];
5139 }
5140 if ((0ULL == mac_addr) || (mac_addr == S2IO_DISABLE_MAC_ENTRY))
5141 return SUCCESS;
5142
5143 /* check if the multicast mac already preset in CAM */
5144 for (i = config->mc_start_offset; i < config->max_mc_addr; i++) {
5145 u64 tmp64;
5146 tmp64 = do_s2io_read_unicast_mc(sp, i);
5147 if (tmp64 == S2IO_DISABLE_MAC_ENTRY) /* CAM entry is empty */
5148 break;
5149
5150 if (tmp64 == mac_addr)
5151 return SUCCESS;
5152 }
5153 if (i == config->max_mc_addr) {
5154 DBG_PRINT(ERR_DBG,
5155 "CAM full no space left for multicast MAC\n");
5156 return FAILURE;
5157 }
5158 /* Update the internal structure with this new mac address */
5159 do_s2io_copy_mac_addr(sp, i, mac_addr);
5160
5161 return (do_s2io_add_mac(sp, mac_addr, i));
5162 }
5163
5164 /* add MAC address to CAM */
5165 static int do_s2io_add_mac(struct s2io_nic *sp, u64 addr, int off)
5166 {
5167 u64 val64;
5168 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5169
5170 writeq(RMAC_ADDR_DATA0_MEM_ADDR(addr),
5171 &bar0->rmac_addr_data0_mem);
5172
5173 val64 =
5174 RMAC_ADDR_CMD_MEM_WE | RMAC_ADDR_CMD_MEM_STROBE_NEW_CMD |
5175 RMAC_ADDR_CMD_MEM_OFFSET(off);
5176 writeq(val64, &bar0->rmac_addr_cmd_mem);
5177
5178 /* Wait till command completes */
5179 if (wait_for_cmd_complete(&bar0->rmac_addr_cmd_mem,
5180 RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING,
5181 S2IO_BIT_RESET)) {
5182 DBG_PRINT(INFO_DBG, "do_s2io_add_mac failed\n");
5183 return FAILURE;
5184 }
5185 return SUCCESS;
5186 }
5187 /* deletes a specified unicast/multicast mac entry from CAM */
5188 static int do_s2io_delete_unicast_mc(struct s2io_nic *sp, u64 addr)
5189 {
5190 int offset;
5191 u64 dis_addr = S2IO_DISABLE_MAC_ENTRY, tmp64;
5192 struct config_param *config = &sp->config;
5193
5194 for (offset = 1;
5195 offset < config->max_mc_addr; offset++) {
5196 tmp64 = do_s2io_read_unicast_mc(sp, offset);
5197 if (tmp64 == addr) {
5198 /* disable the entry by writing 0xffffffffffffULL */
5199 if (do_s2io_add_mac(sp, dis_addr, offset) == FAILURE)
5200 return FAILURE;
5201 /* store the new mac list from CAM */
5202 do_s2io_store_unicast_mc(sp);
5203 return SUCCESS;
5204 }
5205 }
5206 DBG_PRINT(ERR_DBG, "MAC address 0x%llx not found in CAM\n",
5207 (unsigned long long)addr);
5208 return FAILURE;
5209 }
5210
5211 /* read mac entries from CAM */
5212 static u64 do_s2io_read_unicast_mc(struct s2io_nic *sp, int offset)
5213 {
5214 u64 tmp64 = 0xffffffffffff0000ULL, val64;
5215 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5216
5217 /* read mac addr */
5218 val64 =
5219 RMAC_ADDR_CMD_MEM_RD | RMAC_ADDR_CMD_MEM_STROBE_NEW_CMD |
5220 RMAC_ADDR_CMD_MEM_OFFSET(offset);
5221 writeq(val64, &bar0->rmac_addr_cmd_mem);
5222
5223 /* Wait till command completes */
5224 if (wait_for_cmd_complete(&bar0->rmac_addr_cmd_mem,
5225 RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING,
5226 S2IO_BIT_RESET)) {
5227 DBG_PRINT(INFO_DBG, "do_s2io_read_unicast_mc failed\n");
5228 return FAILURE;
5229 }
5230 tmp64 = readq(&bar0->rmac_addr_data0_mem);
5231 return (tmp64 >> 16);
5232 }
5233
5234 /**
5235 * s2io_set_mac_addr driver entry point
5236 */
5237
5238 static int s2io_set_mac_addr(struct net_device *dev, void *p)
5239 {
5240 struct sockaddr *addr = p;
5241
5242 if (!is_valid_ether_addr(addr->sa_data))
5243 return -EINVAL;
5244
5245 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
5246
5247 /* store the MAC address in CAM */
5248 return (do_s2io_prog_unicast(dev, dev->dev_addr));
5249 }
5250 /**
5251 * do_s2io_prog_unicast - Programs the Xframe mac address
5252 * @dev : pointer to the device structure.
5253 * @addr: a uchar pointer to the new mac address which is to be set.
5254 * Description : This procedure will program the Xframe to receive
5255 * frames with new Mac Address
5256 * Return value: SUCCESS on success and an appropriate (-)ve integer
5257 * as defined in errno.h file on failure.
5258 */
5259
5260 static int do_s2io_prog_unicast(struct net_device *dev, u8 *addr)
5261 {
5262 struct s2io_nic *sp = dev->priv;
5263 register u64 mac_addr = 0, perm_addr = 0;
5264 int i;
5265 u64 tmp64;
5266 struct config_param *config = &sp->config;
5267
5268 /*
5269 * Set the new MAC address as the new unicast filter and reflect this
5270 * change on the device address registered with the OS. It will be
5271 * at offset 0.
5272 */
5273 for (i = 0; i < ETH_ALEN; i++) {
5274 mac_addr <<= 8;
5275 mac_addr |= addr[i];
5276 perm_addr <<= 8;
5277 perm_addr |= sp->def_mac_addr[0].mac_addr[i];
5278 }
5279
5280 /* check if the dev_addr is different than perm_addr */
5281 if (mac_addr == perm_addr)
5282 return SUCCESS;
5283
5284 /* check if the mac already preset in CAM */
5285 for (i = 1; i < config->max_mac_addr; i++) {
5286 tmp64 = do_s2io_read_unicast_mc(sp, i);
5287 if (tmp64 == S2IO_DISABLE_MAC_ENTRY) /* CAM entry is empty */
5288 break;
5289
5290 if (tmp64 == mac_addr) {
5291 DBG_PRINT(INFO_DBG,
5292 "MAC addr:0x%llx already present in CAM\n",
5293 (unsigned long long)mac_addr);
5294 return SUCCESS;
5295 }
5296 }
5297 if (i == config->max_mac_addr) {
5298 DBG_PRINT(ERR_DBG, "CAM full no space left for Unicast MAC\n");
5299 return FAILURE;
5300 }
5301 /* Update the internal structure with this new mac address */
5302 do_s2io_copy_mac_addr(sp, i, mac_addr);
5303 return (do_s2io_add_mac(sp, mac_addr, i));
5304 }
5305
5306 /**
5307 * s2io_ethtool_sset - Sets different link parameters.
5308 * @sp : private member of the device structure, which is a pointer to the * s2io_nic structure.
5309 * @info: pointer to the structure with parameters given by ethtool to set
5310 * link information.
5311 * Description:
5312 * The function sets different link parameters provided by the user onto
5313 * the NIC.
5314 * Return value:
5315 * 0 on success.
5316 */
5317
5318 static int s2io_ethtool_sset(struct net_device *dev,
5319 struct ethtool_cmd *info)
5320 {
5321 struct s2io_nic *sp = dev->priv;
5322 if ((info->autoneg == AUTONEG_ENABLE) ||
5323 (info->speed != SPEED_10000) || (info->duplex != DUPLEX_FULL))
5324 return -EINVAL;
5325 else {
5326 s2io_close(sp->dev);
5327 s2io_open(sp->dev);
5328 }
5329
5330 return 0;
5331 }
5332
5333 /**
5334 * s2io_ethtol_gset - Return link specific information.
5335 * @sp : private member of the device structure, pointer to the
5336 * s2io_nic structure.
5337 * @info : pointer to the structure with parameters given by ethtool
5338 * to return link information.
5339 * Description:
5340 * Returns link specific information like speed, duplex etc.. to ethtool.
5341 * Return value :
5342 * return 0 on success.
5343 */
5344
5345 static int s2io_ethtool_gset(struct net_device *dev, struct ethtool_cmd *info)
5346 {
5347 struct s2io_nic *sp = dev->priv;
5348 info->supported = (SUPPORTED_10000baseT_Full | SUPPORTED_FIBRE);
5349 info->advertising = (SUPPORTED_10000baseT_Full | SUPPORTED_FIBRE);
5350 info->port = PORT_FIBRE;
5351
5352 /* info->transceiver */
5353 info->transceiver = XCVR_EXTERNAL;
5354
5355 if (netif_carrier_ok(sp->dev)) {
5356 info->speed = 10000;
5357 info->duplex = DUPLEX_FULL;
5358 } else {
5359 info->speed = -1;
5360 info->duplex = -1;
5361 }
5362
5363 info->autoneg = AUTONEG_DISABLE;
5364 return 0;
5365 }
5366
5367 /**
5368 * s2io_ethtool_gdrvinfo - Returns driver specific information.
5369 * @sp : private member of the device structure, which is a pointer to the
5370 * s2io_nic structure.
5371 * @info : pointer to the structure with parameters given by ethtool to
5372 * return driver information.
5373 * Description:
5374 * Returns driver specefic information like name, version etc.. to ethtool.
5375 * Return value:
5376 * void
5377 */
5378
5379 static void s2io_ethtool_gdrvinfo(struct net_device *dev,
5380 struct ethtool_drvinfo *info)
5381 {
5382 struct s2io_nic *sp = dev->priv;
5383
5384 strncpy(info->driver, s2io_driver_name, sizeof(info->driver));
5385 strncpy(info->version, s2io_driver_version, sizeof(info->version));
5386 strncpy(info->fw_version, "", sizeof(info->fw_version));
5387 strncpy(info->bus_info, pci_name(sp->pdev), sizeof(info->bus_info));
5388 info->regdump_len = XENA_REG_SPACE;
5389 info->eedump_len = XENA_EEPROM_SPACE;
5390 }
5391
5392 /**
5393 * s2io_ethtool_gregs - dumps the entire space of Xfame into the buffer.
5394 * @sp: private member of the device structure, which is a pointer to the
5395 * s2io_nic structure.
5396 * @regs : pointer to the structure with parameters given by ethtool for
5397 * dumping the registers.
5398 * @reg_space: The input argumnet into which all the registers are dumped.
5399 * Description:
5400 * Dumps the entire register space of xFrame NIC into the user given
5401 * buffer area.
5402 * Return value :
5403 * void .
5404 */
5405
5406 static void s2io_ethtool_gregs(struct net_device *dev,
5407 struct ethtool_regs *regs, void *space)
5408 {
5409 int i;
5410 u64 reg;
5411 u8 *reg_space = (u8 *) space;
5412 struct s2io_nic *sp = dev->priv;
5413
5414 regs->len = XENA_REG_SPACE;
5415 regs->version = sp->pdev->subsystem_device;
5416
5417 for (i = 0; i < regs->len; i += 8) {
5418 reg = readq(sp->bar0 + i);
5419 memcpy((reg_space + i), &reg, 8);
5420 }
5421 }
5422
5423 /**
5424 * s2io_phy_id - timer function that alternates adapter LED.
5425 * @data : address of the private member of the device structure, which
5426 * is a pointer to the s2io_nic structure, provided as an u32.
5427 * Description: This is actually the timer function that alternates the
5428 * adapter LED bit of the adapter control bit to set/reset every time on
5429 * invocation. The timer is set for 1/2 a second, hence tha NIC blinks
5430 * once every second.
5431 */
5432 static void s2io_phy_id(unsigned long data)
5433 {
5434 struct s2io_nic *sp = (struct s2io_nic *) data;
5435 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5436 u64 val64 = 0;
5437 u16 subid;
5438
5439 subid = sp->pdev->subsystem_device;
5440 if ((sp->device_type == XFRAME_II_DEVICE) ||
5441 ((subid & 0xFF) >= 0x07)) {
5442 val64 = readq(&bar0->gpio_control);
5443 val64 ^= GPIO_CTRL_GPIO_0;
5444 writeq(val64, &bar0->gpio_control);
5445 } else {
5446 val64 = readq(&bar0->adapter_control);
5447 val64 ^= ADAPTER_LED_ON;
5448 writeq(val64, &bar0->adapter_control);
5449 }
5450
5451 mod_timer(&sp->id_timer, jiffies + HZ / 2);
5452 }
5453
5454 /**
5455 * s2io_ethtool_idnic - To physically identify the nic on the system.
5456 * @sp : private member of the device structure, which is a pointer to the
5457 * s2io_nic structure.
5458 * @id : pointer to the structure with identification parameters given by
5459 * ethtool.
5460 * Description: Used to physically identify the NIC on the system.
5461 * The Link LED will blink for a time specified by the user for
5462 * identification.
5463 * NOTE: The Link has to be Up to be able to blink the LED. Hence
5464 * identification is possible only if it's link is up.
5465 * Return value:
5466 * int , returns 0 on success
5467 */
5468
5469 static int s2io_ethtool_idnic(struct net_device *dev, u32 data)
5470 {
5471 u64 val64 = 0, last_gpio_ctrl_val;
5472 struct s2io_nic *sp = dev->priv;
5473 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5474 u16 subid;
5475
5476 subid = sp->pdev->subsystem_device;
5477 last_gpio_ctrl_val = readq(&bar0->gpio_control);
5478 if ((sp->device_type == XFRAME_I_DEVICE) &&
5479 ((subid & 0xFF) < 0x07)) {
5480 val64 = readq(&bar0->adapter_control);
5481 if (!(val64 & ADAPTER_CNTL_EN)) {
5482 printk(KERN_ERR
5483 "Adapter Link down, cannot blink LED\n");
5484 return -EFAULT;
5485 }
5486 }
5487 if (sp->id_timer.function == NULL) {
5488 init_timer(&sp->id_timer);
5489 sp->id_timer.function = s2io_phy_id;
5490 sp->id_timer.data = (unsigned long) sp;
5491 }
5492 mod_timer(&sp->id_timer, jiffies);
5493 if (data)
5494 msleep_interruptible(data * HZ);
5495 else
5496 msleep_interruptible(MAX_FLICKER_TIME);
5497 del_timer_sync(&sp->id_timer);
5498
5499 if (CARDS_WITH_FAULTY_LINK_INDICATORS(sp->device_type, subid)) {
5500 writeq(last_gpio_ctrl_val, &bar0->gpio_control);
5501 last_gpio_ctrl_val = readq(&bar0->gpio_control);
5502 }
5503
5504 return 0;
5505 }
5506
5507 static void s2io_ethtool_gringparam(struct net_device *dev,
5508 struct ethtool_ringparam *ering)
5509 {
5510 struct s2io_nic *sp = dev->priv;
5511 int i,tx_desc_count=0,rx_desc_count=0;
5512
5513 if (sp->rxd_mode == RXD_MODE_1)
5514 ering->rx_max_pending = MAX_RX_DESC_1;
5515 else if (sp->rxd_mode == RXD_MODE_3B)
5516 ering->rx_max_pending = MAX_RX_DESC_2;
5517
5518 ering->tx_max_pending = MAX_TX_DESC;
5519 for (i = 0 ; i < sp->config.tx_fifo_num ; i++)
5520 tx_desc_count += sp->config.tx_cfg[i].fifo_len;
5521
5522 DBG_PRINT(INFO_DBG,"\nmax txds : %d\n",sp->config.max_txds);
5523 ering->tx_pending = tx_desc_count;
5524 rx_desc_count = 0;
5525 for (i = 0 ; i < sp->config.rx_ring_num ; i++)
5526 rx_desc_count += sp->config.rx_cfg[i].num_rxd;
5527
5528 ering->rx_pending = rx_desc_count;
5529
5530 ering->rx_mini_max_pending = 0;
5531 ering->rx_mini_pending = 0;
5532 if(sp->rxd_mode == RXD_MODE_1)
5533 ering->rx_jumbo_max_pending = MAX_RX_DESC_1;
5534 else if (sp->rxd_mode == RXD_MODE_3B)
5535 ering->rx_jumbo_max_pending = MAX_RX_DESC_2;
5536 ering->rx_jumbo_pending = rx_desc_count;
5537 }
5538
5539 /**
5540 * s2io_ethtool_getpause_data -Pause frame frame generation and reception.
5541 * @sp : private member of the device structure, which is a pointer to the
5542 * s2io_nic structure.
5543 * @ep : pointer to the structure with pause parameters given by ethtool.
5544 * Description:
5545 * Returns the Pause frame generation and reception capability of the NIC.
5546 * Return value:
5547 * void
5548 */
5549 static void s2io_ethtool_getpause_data(struct net_device *dev,
5550 struct ethtool_pauseparam *ep)
5551 {
5552 u64 val64;
5553 struct s2io_nic *sp = dev->priv;
5554 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5555
5556 val64 = readq(&bar0->rmac_pause_cfg);
5557 if (val64 & RMAC_PAUSE_GEN_ENABLE)
5558 ep->tx_pause = TRUE;
5559 if (val64 & RMAC_PAUSE_RX_ENABLE)
5560 ep->rx_pause = TRUE;
5561 ep->autoneg = FALSE;
5562 }
5563
5564 /**
5565 * s2io_ethtool_setpause_data - set/reset pause frame generation.
5566 * @sp : private member of the device structure, which is a pointer to the
5567 * s2io_nic structure.
5568 * @ep : pointer to the structure with pause parameters given by ethtool.
5569 * Description:
5570 * It can be used to set or reset Pause frame generation or reception
5571 * support of the NIC.
5572 * Return value:
5573 * int, returns 0 on Success
5574 */
5575
5576 static int s2io_ethtool_setpause_data(struct net_device *dev,
5577 struct ethtool_pauseparam *ep)
5578 {
5579 u64 val64;
5580 struct s2io_nic *sp = dev->priv;
5581 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5582
5583 val64 = readq(&bar0->rmac_pause_cfg);
5584 if (ep->tx_pause)
5585 val64 |= RMAC_PAUSE_GEN_ENABLE;
5586 else
5587 val64 &= ~RMAC_PAUSE_GEN_ENABLE;
5588 if (ep->rx_pause)
5589 val64 |= RMAC_PAUSE_RX_ENABLE;
5590 else
5591 val64 &= ~RMAC_PAUSE_RX_ENABLE;
5592 writeq(val64, &bar0->rmac_pause_cfg);
5593 return 0;
5594 }
5595
5596 /**
5597 * read_eeprom - reads 4 bytes of data from user given offset.
5598 * @sp : private member of the device structure, which is a pointer to the
5599 * s2io_nic structure.
5600 * @off : offset at which the data must be written
5601 * @data : Its an output parameter where the data read at the given
5602 * offset is stored.
5603 * Description:
5604 * Will read 4 bytes of data from the user given offset and return the
5605 * read data.
5606 * NOTE: Will allow to read only part of the EEPROM visible through the
5607 * I2C bus.
5608 * Return value:
5609 * -1 on failure and 0 on success.
5610 */
5611
5612 #define S2IO_DEV_ID 5
5613 static int read_eeprom(struct s2io_nic * sp, int off, u64 * data)
5614 {
5615 int ret = -1;
5616 u32 exit_cnt = 0;
5617 u64 val64;
5618 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5619
5620 if (sp->device_type == XFRAME_I_DEVICE) {
5621 val64 = I2C_CONTROL_DEV_ID(S2IO_DEV_ID) | I2C_CONTROL_ADDR(off) |
5622 I2C_CONTROL_BYTE_CNT(0x3) | I2C_CONTROL_READ |
5623 I2C_CONTROL_CNTL_START;
5624 SPECIAL_REG_WRITE(val64, &bar0->i2c_control, LF);
5625
5626 while (exit_cnt < 5) {
5627 val64 = readq(&bar0->i2c_control);
5628 if (I2C_CONTROL_CNTL_END(val64)) {
5629 *data = I2C_CONTROL_GET_DATA(val64);
5630 ret = 0;
5631 break;
5632 }
5633 msleep(50);
5634 exit_cnt++;
5635 }
5636 }
5637
5638 if (sp->device_type == XFRAME_II_DEVICE) {
5639 val64 = SPI_CONTROL_KEY(0x9) | SPI_CONTROL_SEL1 |
5640 SPI_CONTROL_BYTECNT(0x3) |
5641 SPI_CONTROL_CMD(0x3) | SPI_CONTROL_ADDR(off);
5642 SPECIAL_REG_WRITE(val64, &bar0->spi_control, LF);
5643 val64 |= SPI_CONTROL_REQ;
5644 SPECIAL_REG_WRITE(val64, &bar0->spi_control, LF);
5645 while (exit_cnt < 5) {
5646 val64 = readq(&bar0->spi_control);
5647 if (val64 & SPI_CONTROL_NACK) {
5648 ret = 1;
5649 break;
5650 } else if (val64 & SPI_CONTROL_DONE) {
5651 *data = readq(&bar0->spi_data);
5652 *data &= 0xffffff;
5653 ret = 0;
5654 break;
5655 }
5656 msleep(50);
5657 exit_cnt++;
5658 }
5659 }
5660 return ret;
5661 }
5662
5663 /**
5664 * write_eeprom - actually writes the relevant part of the data value.
5665 * @sp : private member of the device structure, which is a pointer to the
5666 * s2io_nic structure.
5667 * @off : offset at which the data must be written
5668 * @data : The data that is to be written
5669 * @cnt : Number of bytes of the data that are actually to be written into
5670 * the Eeprom. (max of 3)
5671 * Description:
5672 * Actually writes the relevant part of the data value into the Eeprom
5673 * through the I2C bus.
5674 * Return value:
5675 * 0 on success, -1 on failure.
5676 */
5677
5678 static int write_eeprom(struct s2io_nic * sp, int off, u64 data, int cnt)
5679 {
5680 int exit_cnt = 0, ret = -1;
5681 u64 val64;
5682 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5683
5684 if (sp->device_type == XFRAME_I_DEVICE) {
5685 val64 = I2C_CONTROL_DEV_ID(S2IO_DEV_ID) | I2C_CONTROL_ADDR(off) |
5686 I2C_CONTROL_BYTE_CNT(cnt) | I2C_CONTROL_SET_DATA((u32)data) |
5687 I2C_CONTROL_CNTL_START;
5688 SPECIAL_REG_WRITE(val64, &bar0->i2c_control, LF);
5689
5690 while (exit_cnt < 5) {
5691 val64 = readq(&bar0->i2c_control);
5692 if (I2C_CONTROL_CNTL_END(val64)) {
5693 if (!(val64 & I2C_CONTROL_NACK))
5694 ret = 0;
5695 break;
5696 }
5697 msleep(50);
5698 exit_cnt++;
5699 }
5700 }
5701
5702 if (sp->device_type == XFRAME_II_DEVICE) {
5703 int write_cnt = (cnt == 8) ? 0 : cnt;
5704 writeq(SPI_DATA_WRITE(data,(cnt<<3)), &bar0->spi_data);
5705
5706 val64 = SPI_CONTROL_KEY(0x9) | SPI_CONTROL_SEL1 |
5707 SPI_CONTROL_BYTECNT(write_cnt) |
5708 SPI_CONTROL_CMD(0x2) | SPI_CONTROL_ADDR(off);
5709 SPECIAL_REG_WRITE(val64, &bar0->spi_control, LF);
5710 val64 |= SPI_CONTROL_REQ;
5711 SPECIAL_REG_WRITE(val64, &bar0->spi_control, LF);
5712 while (exit_cnt < 5) {
5713 val64 = readq(&bar0->spi_control);
5714 if (val64 & SPI_CONTROL_NACK) {
5715 ret = 1;
5716 break;
5717 } else if (val64 & SPI_CONTROL_DONE) {
5718 ret = 0;
5719 break;
5720 }
5721 msleep(50);
5722 exit_cnt++;
5723 }
5724 }
5725 return ret;
5726 }
5727 static void s2io_vpd_read(struct s2io_nic *nic)
5728 {
5729 u8 *vpd_data;
5730 u8 data;
5731 int i=0, cnt, fail = 0;
5732 int vpd_addr = 0x80;
5733
5734 if (nic->device_type == XFRAME_II_DEVICE) {
5735 strcpy(nic->product_name, "Xframe II 10GbE network adapter");
5736 vpd_addr = 0x80;
5737 }
5738 else {
5739 strcpy(nic->product_name, "Xframe I 10GbE network adapter");
5740 vpd_addr = 0x50;
5741 }
5742 strcpy(nic->serial_num, "NOT AVAILABLE");
5743
5744 vpd_data = kmalloc(256, GFP_KERNEL);
5745 if (!vpd_data) {
5746 nic->mac_control.stats_info->sw_stat.mem_alloc_fail_cnt++;
5747 return;
5748 }
5749 nic->mac_control.stats_info->sw_stat.mem_allocated += 256;
5750
5751 for (i = 0; i < 256; i +=4 ) {
5752 pci_write_config_byte(nic->pdev, (vpd_addr + 2), i);
5753 pci_read_config_byte(nic->pdev, (vpd_addr + 2), &data);
5754 pci_write_config_byte(nic->pdev, (vpd_addr + 3), 0);
5755 for (cnt = 0; cnt <5; cnt++) {
5756 msleep(2);
5757 pci_read_config_byte(nic->pdev, (vpd_addr + 3), &data);
5758 if (data == 0x80)
5759 break;
5760 }
5761 if (cnt >= 5) {
5762 DBG_PRINT(ERR_DBG, "Read of VPD data failed\n");
5763 fail = 1;
5764 break;
5765 }
5766 pci_read_config_dword(nic->pdev, (vpd_addr + 4),
5767 (u32 *)&vpd_data[i]);
5768 }
5769
5770 if(!fail) {
5771 /* read serial number of adapter */
5772 for (cnt = 0; cnt < 256; cnt++) {
5773 if ((vpd_data[cnt] == 'S') &&
5774 (vpd_data[cnt+1] == 'N') &&
5775 (vpd_data[cnt+2] < VPD_STRING_LEN)) {
5776 memset(nic->serial_num, 0, VPD_STRING_LEN);
5777 memcpy(nic->serial_num, &vpd_data[cnt + 3],
5778 vpd_data[cnt+2]);
5779 break;
5780 }
5781 }
5782 }
5783
5784 if ((!fail) && (vpd_data[1] < VPD_STRING_LEN)) {
5785 memset(nic->product_name, 0, vpd_data[1]);
5786 memcpy(nic->product_name, &vpd_data[3], vpd_data[1]);
5787 }
5788 kfree(vpd_data);
5789 nic->mac_control.stats_info->sw_stat.mem_freed += 256;
5790 }
5791
5792 /**
5793 * s2io_ethtool_geeprom - reads the value stored in the Eeprom.
5794 * @sp : private member of the device structure, which is a pointer to the * s2io_nic structure.
5795 * @eeprom : pointer to the user level structure provided by ethtool,
5796 * containing all relevant information.
5797 * @data_buf : user defined value to be written into Eeprom.
5798 * Description: Reads the values stored in the Eeprom at given offset
5799 * for a given length. Stores these values int the input argument data
5800 * buffer 'data_buf' and returns these to the caller (ethtool.)
5801 * Return value:
5802 * int 0 on success
5803 */
5804
5805 static int s2io_ethtool_geeprom(struct net_device *dev,
5806 struct ethtool_eeprom *eeprom, u8 * data_buf)
5807 {
5808 u32 i, valid;
5809 u64 data;
5810 struct s2io_nic *sp = dev->priv;
5811
5812 eeprom->magic = sp->pdev->vendor | (sp->pdev->device << 16);
5813
5814 if ((eeprom->offset + eeprom->len) > (XENA_EEPROM_SPACE))
5815 eeprom->len = XENA_EEPROM_SPACE - eeprom->offset;
5816
5817 for (i = 0; i < eeprom->len; i += 4) {
5818 if (read_eeprom(sp, (eeprom->offset + i), &data)) {
5819 DBG_PRINT(ERR_DBG, "Read of EEPROM failed\n");
5820 return -EFAULT;
5821 }
5822 valid = INV(data);
5823 memcpy((data_buf + i), &valid, 4);
5824 }
5825 return 0;
5826 }
5827
5828 /**
5829 * s2io_ethtool_seeprom - tries to write the user provided value in Eeprom
5830 * @sp : private member of the device structure, which is a pointer to the
5831 * s2io_nic structure.
5832 * @eeprom : pointer to the user level structure provided by ethtool,
5833 * containing all relevant information.
5834 * @data_buf ; user defined value to be written into Eeprom.
5835 * Description:
5836 * Tries to write the user provided value in the Eeprom, at the offset
5837 * given by the user.
5838 * Return value:
5839 * 0 on success, -EFAULT on failure.
5840 */
5841
5842 static int s2io_ethtool_seeprom(struct net_device *dev,
5843 struct ethtool_eeprom *eeprom,
5844 u8 * data_buf)
5845 {
5846 int len = eeprom->len, cnt = 0;
5847 u64 valid = 0, data;
5848 struct s2io_nic *sp = dev->priv;
5849
5850 if (eeprom->magic != (sp->pdev->vendor | (sp->pdev->device << 16))) {
5851 DBG_PRINT(ERR_DBG,
5852 "ETHTOOL_WRITE_EEPROM Err: Magic value ");
5853 DBG_PRINT(ERR_DBG, "is wrong, Its not 0x%x\n",
5854 eeprom->magic);
5855 return -EFAULT;
5856 }
5857
5858 while (len) {
5859 data = (u32) data_buf[cnt] & 0x000000FF;
5860 if (data) {
5861 valid = (u32) (data << 24);
5862 } else
5863 valid = data;
5864
5865 if (write_eeprom(sp, (eeprom->offset + cnt), valid, 0)) {
5866 DBG_PRINT(ERR_DBG,
5867 "ETHTOOL_WRITE_EEPROM Err: Cannot ");
5868 DBG_PRINT(ERR_DBG,
5869 "write into the specified offset\n");
5870 return -EFAULT;
5871 }
5872 cnt++;
5873 len--;
5874 }
5875
5876 return 0;
5877 }
5878
5879 /**
5880 * s2io_register_test - reads and writes into all clock domains.
5881 * @sp : private member of the device structure, which is a pointer to the
5882 * s2io_nic structure.
5883 * @data : variable that returns the result of each of the test conducted b
5884 * by the driver.
5885 * Description:
5886 * Read and write into all clock domains. The NIC has 3 clock domains,
5887 * see that registers in all the three regions are accessible.
5888 * Return value:
5889 * 0 on success.
5890 */
5891
5892 static int s2io_register_test(struct s2io_nic * sp, uint64_t * data)
5893 {
5894 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5895 u64 val64 = 0, exp_val;
5896 int fail = 0;
5897
5898 val64 = readq(&bar0->pif_rd_swapper_fb);
5899 if (val64 != 0x123456789abcdefULL) {
5900 fail = 1;
5901 DBG_PRINT(INFO_DBG, "Read Test level 1 fails\n");
5902 }
5903
5904 val64 = readq(&bar0->rmac_pause_cfg);
5905 if (val64 != 0xc000ffff00000000ULL) {
5906 fail = 1;
5907 DBG_PRINT(INFO_DBG, "Read Test level 2 fails\n");
5908 }
5909
5910 val64 = readq(&bar0->rx_queue_cfg);
5911 if (sp->device_type == XFRAME_II_DEVICE)
5912 exp_val = 0x0404040404040404ULL;
5913 else
5914 exp_val = 0x0808080808080808ULL;
5915 if (val64 != exp_val) {
5916 fail = 1;
5917 DBG_PRINT(INFO_DBG, "Read Test level 3 fails\n");
5918 }
5919
5920 val64 = readq(&bar0->xgxs_efifo_cfg);
5921 if (val64 != 0x000000001923141EULL) {
5922 fail = 1;
5923 DBG_PRINT(INFO_DBG, "Read Test level 4 fails\n");
5924 }
5925
5926 val64 = 0x5A5A5A5A5A5A5A5AULL;
5927 writeq(val64, &bar0->xmsi_data);
5928 val64 = readq(&bar0->xmsi_data);
5929 if (val64 != 0x5A5A5A5A5A5A5A5AULL) {
5930 fail = 1;
5931 DBG_PRINT(ERR_DBG, "Write Test level 1 fails\n");
5932 }
5933
5934 val64 = 0xA5A5A5A5A5A5A5A5ULL;
5935 writeq(val64, &bar0->xmsi_data);
5936 val64 = readq(&bar0->xmsi_data);
5937 if (val64 != 0xA5A5A5A5A5A5A5A5ULL) {
5938 fail = 1;
5939 DBG_PRINT(ERR_DBG, "Write Test level 2 fails\n");
5940 }
5941
5942 *data = fail;
5943 return fail;
5944 }
5945
5946 /**
5947 * s2io_eeprom_test - to verify that EEprom in the xena can be programmed.
5948 * @sp : private member of the device structure, which is a pointer to the
5949 * s2io_nic structure.
5950 * @data:variable that returns the result of each of the test conducted by
5951 * the driver.
5952 * Description:
5953 * Verify that EEPROM in the xena can be programmed using I2C_CONTROL
5954 * register.
5955 * Return value:
5956 * 0 on success.
5957 */
5958
5959 static int s2io_eeprom_test(struct s2io_nic * sp, uint64_t * data)
5960 {
5961 int fail = 0;
5962 u64 ret_data, org_4F0, org_7F0;
5963 u8 saved_4F0 = 0, saved_7F0 = 0;
5964 struct net_device *dev = sp->dev;
5965
5966 /* Test Write Error at offset 0 */
5967 /* Note that SPI interface allows write access to all areas
5968 * of EEPROM. Hence doing all negative testing only for Xframe I.
5969 */
5970 if (sp->device_type == XFRAME_I_DEVICE)
5971 if (!write_eeprom(sp, 0, 0, 3))
5972 fail = 1;
5973
5974 /* Save current values at offsets 0x4F0 and 0x7F0 */
5975 if (!read_eeprom(sp, 0x4F0, &org_4F0))
5976 saved_4F0 = 1;
5977 if (!read_eeprom(sp, 0x7F0, &org_7F0))
5978 saved_7F0 = 1;
5979
5980 /* Test Write at offset 4f0 */
5981 if (write_eeprom(sp, 0x4F0, 0x012345, 3))
5982 fail = 1;
5983 if (read_eeprom(sp, 0x4F0, &ret_data))
5984 fail = 1;
5985
5986 if (ret_data != 0x012345) {
5987 DBG_PRINT(ERR_DBG, "%s: eeprom test error at offset 0x4F0. "
5988 "Data written %llx Data read %llx\n",
5989 dev->name, (unsigned long long)0x12345,
5990 (unsigned long long)ret_data);
5991 fail = 1;
5992 }
5993
5994 /* Reset the EEPROM data go FFFF */
5995 write_eeprom(sp, 0x4F0, 0xFFFFFF, 3);
5996
5997 /* Test Write Request Error at offset 0x7c */
5998 if (sp->device_type == XFRAME_I_DEVICE)
5999 if (!write_eeprom(sp, 0x07C, 0, 3))
6000 fail = 1;
6001
6002 /* Test Write Request at offset 0x7f0 */
6003 if (write_eeprom(sp, 0x7F0, 0x012345, 3))
6004 fail = 1;
6005 if (read_eeprom(sp, 0x7F0, &ret_data))
6006 fail = 1;
6007
6008 if (ret_data != 0x012345) {
6009 DBG_PRINT(ERR_DBG, "%s: eeprom test error at offset 0x7F0. "
6010 "Data written %llx Data read %llx\n",
6011 dev->name, (unsigned long long)0x12345,
6012 (unsigned long long)ret_data);
6013 fail = 1;
6014 }
6015
6016 /* Reset the EEPROM data go FFFF */
6017 write_eeprom(sp, 0x7F0, 0xFFFFFF, 3);
6018
6019 if (sp->device_type == XFRAME_I_DEVICE) {
6020 /* Test Write Error at offset 0x80 */
6021 if (!write_eeprom(sp, 0x080, 0, 3))
6022 fail = 1;
6023
6024 /* Test Write Error at offset 0xfc */
6025 if (!write_eeprom(sp, 0x0FC, 0, 3))
6026 fail = 1;
6027
6028 /* Test Write Error at offset 0x100 */
6029 if (!write_eeprom(sp, 0x100, 0, 3))
6030 fail = 1;
6031
6032 /* Test Write Error at offset 4ec */
6033 if (!write_eeprom(sp, 0x4EC, 0, 3))
6034 fail = 1;
6035 }
6036
6037 /* Restore values at offsets 0x4F0 and 0x7F0 */
6038 if (saved_4F0)
6039 write_eeprom(sp, 0x4F0, org_4F0, 3);
6040 if (saved_7F0)
6041 write_eeprom(sp, 0x7F0, org_7F0, 3);
6042
6043 *data = fail;
6044 return fail;
6045 }
6046
6047 /**
6048 * s2io_bist_test - invokes the MemBist test of the card .
6049 * @sp : private member of the device structure, which is a pointer to the
6050 * s2io_nic structure.
6051 * @data:variable that returns the result of each of the test conducted by
6052 * the driver.
6053 * Description:
6054 * This invokes the MemBist test of the card. We give around
6055 * 2 secs time for the Test to complete. If it's still not complete
6056 * within this peiod, we consider that the test failed.
6057 * Return value:
6058 * 0 on success and -1 on failure.
6059 */
6060
6061 static int s2io_bist_test(struct s2io_nic * sp, uint64_t * data)
6062 {
6063 u8 bist = 0;
6064 int cnt = 0, ret = -1;
6065
6066 pci_read_config_byte(sp->pdev, PCI_BIST, &bist);
6067 bist |= PCI_BIST_START;
6068 pci_write_config_word(sp->pdev, PCI_BIST, bist);
6069
6070 while (cnt < 20) {
6071 pci_read_config_byte(sp->pdev, PCI_BIST, &bist);
6072 if (!(bist & PCI_BIST_START)) {
6073 *data = (bist & PCI_BIST_CODE_MASK);
6074 ret = 0;
6075 break;
6076 }
6077 msleep(100);
6078 cnt++;
6079 }
6080
6081 return ret;
6082 }
6083
6084 /**
6085 * s2io-link_test - verifies the link state of the nic
6086 * @sp ; private member of the device structure, which is a pointer to the
6087 * s2io_nic structure.
6088 * @data: variable that returns the result of each of the test conducted by
6089 * the driver.
6090 * Description:
6091 * The function verifies the link state of the NIC and updates the input
6092 * argument 'data' appropriately.
6093 * Return value:
6094 * 0 on success.
6095 */
6096
6097 static int s2io_link_test(struct s2io_nic * sp, uint64_t * data)
6098 {
6099 struct XENA_dev_config __iomem *bar0 = sp->bar0;
6100 u64 val64;
6101
6102 val64 = readq(&bar0->adapter_status);
6103 if(!(LINK_IS_UP(val64)))
6104 *data = 1;
6105 else
6106 *data = 0;
6107
6108 return *data;
6109 }
6110
6111 /**
6112 * s2io_rldram_test - offline test for access to the RldRam chip on the NIC
6113 * @sp - private member of the device structure, which is a pointer to the
6114 * s2io_nic structure.
6115 * @data - variable that returns the result of each of the test
6116 * conducted by the driver.
6117 * Description:
6118 * This is one of the offline test that tests the read and write
6119 * access to the RldRam chip on the NIC.
6120 * Return value:
6121 * 0 on success.
6122 */
6123
6124 static int s2io_rldram_test(struct s2io_nic * sp, uint64_t * data)
6125 {
6126 struct XENA_dev_config __iomem *bar0 = sp->bar0;
6127 u64 val64;
6128 int cnt, iteration = 0, test_fail = 0;
6129
6130 val64 = readq(&bar0->adapter_control);
6131 val64 &= ~ADAPTER_ECC_EN;
6132 writeq(val64, &bar0->adapter_control);
6133
6134 val64 = readq(&bar0->mc_rldram_test_ctrl);
6135 val64 |= MC_RLDRAM_TEST_MODE;
6136 SPECIAL_REG_WRITE(val64, &bar0->mc_rldram_test_ctrl, LF);
6137
6138 val64 = readq(&bar0->mc_rldram_mrs);
6139 val64 |= MC_RLDRAM_QUEUE_SIZE_ENABLE;
6140 SPECIAL_REG_WRITE(val64, &bar0->mc_rldram_mrs, UF);
6141
6142 val64 |= MC_RLDRAM_MRS_ENABLE;
6143 SPECIAL_REG_WRITE(val64, &bar0->mc_rldram_mrs, UF);
6144
6145 while (iteration < 2) {
6146 val64 = 0x55555555aaaa0000ULL;
6147 if (iteration == 1) {
6148 val64 ^= 0xFFFFFFFFFFFF0000ULL;
6149 }
6150 writeq(val64, &bar0->mc_rldram_test_d0);
6151
6152 val64 = 0xaaaa5a5555550000ULL;
6153 if (iteration == 1) {
6154 val64 ^= 0xFFFFFFFFFFFF0000ULL;
6155 }
6156 writeq(val64, &bar0->mc_rldram_test_d1);
6157
6158 val64 = 0x55aaaaaaaa5a0000ULL;
6159 if (iteration == 1) {
6160 val64 ^= 0xFFFFFFFFFFFF0000ULL;
6161 }
6162 writeq(val64, &bar0->mc_rldram_test_d2);
6163
6164 val64 = (u64) (0x0000003ffffe0100ULL);
6165 writeq(val64, &bar0->mc_rldram_test_add);
6166
6167 val64 = MC_RLDRAM_TEST_MODE | MC_RLDRAM_TEST_WRITE |
6168 MC_RLDRAM_TEST_GO;
6169 SPECIAL_REG_WRITE(val64, &bar0->mc_rldram_test_ctrl, LF);
6170
6171 for (cnt = 0; cnt < 5; cnt++) {
6172 val64 = readq(&bar0->mc_rldram_test_ctrl);
6173 if (val64 & MC_RLDRAM_TEST_DONE)
6174 break;
6175 msleep(200);
6176 }
6177
6178 if (cnt == 5)
6179 break;
6180
6181 val64 = MC_RLDRAM_TEST_MODE | MC_RLDRAM_TEST_GO;
6182 SPECIAL_REG_WRITE(val64, &bar0->mc_rldram_test_ctrl, LF);
6183
6184 for (cnt = 0; cnt < 5; cnt++) {
6185 val64 = readq(&bar0->mc_rldram_test_ctrl);
6186 if (val64 & MC_RLDRAM_TEST_DONE)
6187 break;
6188 msleep(500);
6189 }
6190
6191 if (cnt == 5)
6192 break;
6193
6194 val64 = readq(&bar0->mc_rldram_test_ctrl);
6195 if (!(val64 & MC_RLDRAM_TEST_PASS))
6196 test_fail = 1;
6197
6198 iteration++;
6199 }
6200
6201 *data = test_fail;
6202
6203 /* Bring the adapter out of test mode */
6204 SPECIAL_REG_WRITE(0, &bar0->mc_rldram_test_ctrl, LF);
6205
6206 return test_fail;
6207 }
6208
6209 /**
6210 * s2io_ethtool_test - conducts 6 tsets to determine the health of card.
6211 * @sp : private member of the device structure, which is a pointer to the
6212 * s2io_nic structure.
6213 * @ethtest : pointer to a ethtool command specific structure that will be
6214 * returned to the user.
6215 * @data : variable that returns the result of each of the test
6216 * conducted by the driver.
6217 * Description:
6218 * This function conducts 6 tests ( 4 offline and 2 online) to determine
6219 * the health of the card.
6220 * Return value:
6221 * void
6222 */
6223
6224 static void s2io_ethtool_test(struct net_device *dev,
6225 struct ethtool_test *ethtest,
6226 uint64_t * data)
6227 {
6228 struct s2io_nic *sp = dev->priv;
6229 int orig_state = netif_running(sp->dev);
6230
6231 if (ethtest->flags == ETH_TEST_FL_OFFLINE) {
6232 /* Offline Tests. */
6233 if (orig_state)
6234 s2io_close(sp->dev);
6235
6236 if (s2io_register_test(sp, &data[0]))
6237 ethtest->flags |= ETH_TEST_FL_FAILED;
6238
6239 s2io_reset(sp);
6240
6241 if (s2io_rldram_test(sp, &data[3]))
6242 ethtest->flags |= ETH_TEST_FL_FAILED;
6243
6244 s2io_reset(sp);
6245
6246 if (s2io_eeprom_test(sp, &data[1]))
6247 ethtest->flags |= ETH_TEST_FL_FAILED;
6248
6249 if (s2io_bist_test(sp, &data[4]))
6250 ethtest->flags |= ETH_TEST_FL_FAILED;
6251
6252 if (orig_state)
6253 s2io_open(sp->dev);
6254
6255 data[2] = 0;
6256 } else {
6257 /* Online Tests. */
6258 if (!orig_state) {
6259 DBG_PRINT(ERR_DBG,
6260 "%s: is not up, cannot run test\n",
6261 dev->name);
6262 data[0] = -1;
6263 data[1] = -1;
6264 data[2] = -1;
6265 data[3] = -1;
6266 data[4] = -1;
6267 }
6268
6269 if (s2io_link_test(sp, &data[2]))
6270 ethtest->flags |= ETH_TEST_FL_FAILED;
6271
6272 data[0] = 0;
6273 data[1] = 0;
6274 data[3] = 0;
6275 data[4] = 0;
6276 }
6277 }
6278
6279 static void s2io_get_ethtool_stats(struct net_device *dev,
6280 struct ethtool_stats *estats,
6281 u64 * tmp_stats)
6282 {
6283 int i = 0, k;
6284 struct s2io_nic *sp = dev->priv;
6285 struct stat_block *stat_info = sp->mac_control.stats_info;
6286
6287 s2io_updt_stats(sp);
6288 tmp_stats[i++] =
6289 (u64)le32_to_cpu(stat_info->tmac_frms_oflow) << 32 |
6290 le32_to_cpu(stat_info->tmac_frms);
6291 tmp_stats[i++] =
6292 (u64)le32_to_cpu(stat_info->tmac_data_octets_oflow) << 32 |
6293 le32_to_cpu(stat_info->tmac_data_octets);
6294 tmp_stats[i++] = le64_to_cpu(stat_info->tmac_drop_frms);
6295 tmp_stats[i++] =
6296 (u64)le32_to_cpu(stat_info->tmac_mcst_frms_oflow) << 32 |
6297 le32_to_cpu(stat_info->tmac_mcst_frms);
6298 tmp_stats[i++] =
6299 (u64)le32_to_cpu(stat_info->tmac_bcst_frms_oflow) << 32 |
6300 le32_to_cpu(stat_info->tmac_bcst_frms);
6301 tmp_stats[i++] = le64_to_cpu(stat_info->tmac_pause_ctrl_frms);
6302 tmp_stats[i++] =
6303 (u64)le32_to_cpu(stat_info->tmac_ttl_octets_oflow) << 32 |
6304 le32_to_cpu(stat_info->tmac_ttl_octets);
6305 tmp_stats[i++] =
6306 (u64)le32_to_cpu(stat_info->tmac_ucst_frms_oflow) << 32 |
6307 le32_to_cpu(stat_info->tmac_ucst_frms);
6308 tmp_stats[i++] =
6309 (u64)le32_to_cpu(stat_info->tmac_nucst_frms_oflow) << 32 |
6310 le32_to_cpu(stat_info->tmac_nucst_frms);
6311 tmp_stats[i++] =
6312 (u64)le32_to_cpu(stat_info->tmac_any_err_frms_oflow) << 32 |
6313 le32_to_cpu(stat_info->tmac_any_err_frms);
6314 tmp_stats[i++] = le64_to_cpu(stat_info->tmac_ttl_less_fb_octets);
6315 tmp_stats[i++] = le64_to_cpu(stat_info->tmac_vld_ip_octets);
6316 tmp_stats[i++] =
6317 (u64)le32_to_cpu(stat_info->tmac_vld_ip_oflow) << 32 |
6318 le32_to_cpu(stat_info->tmac_vld_ip);
6319 tmp_stats[i++] =
6320 (u64)le32_to_cpu(stat_info->tmac_drop_ip_oflow) << 32 |
6321 le32_to_cpu(stat_info->tmac_drop_ip);
6322 tmp_stats[i++] =
6323 (u64)le32_to_cpu(stat_info->tmac_icmp_oflow) << 32 |
6324 le32_to_cpu(stat_info->tmac_icmp);
6325 tmp_stats[i++] =
6326 (u64)le32_to_cpu(stat_info->tmac_rst_tcp_oflow) << 32 |
6327 le32_to_cpu(stat_info->tmac_rst_tcp);
6328 tmp_stats[i++] = le64_to_cpu(stat_info->tmac_tcp);
6329 tmp_stats[i++] = (u64)le32_to_cpu(stat_info->tmac_udp_oflow) << 32 |
6330 le32_to_cpu(stat_info->tmac_udp);
6331 tmp_stats[i++] =
6332 (u64)le32_to_cpu(stat_info->rmac_vld_frms_oflow) << 32 |
6333 le32_to_cpu(stat_info->rmac_vld_frms);
6334 tmp_stats[i++] =
6335 (u64)le32_to_cpu(stat_info->rmac_data_octets_oflow) << 32 |
6336 le32_to_cpu(stat_info->rmac_data_octets);
6337 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_fcs_err_frms);
6338 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_drop_frms);
6339 tmp_stats[i++] =
6340 (u64)le32_to_cpu(stat_info->rmac_vld_mcst_frms_oflow) << 32 |
6341 le32_to_cpu(stat_info->rmac_vld_mcst_frms);
6342 tmp_stats[i++] =
6343 (u64)le32_to_cpu(stat_info->rmac_vld_bcst_frms_oflow) << 32 |
6344 le32_to_cpu(stat_info->rmac_vld_bcst_frms);
6345 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_in_rng_len_err_frms);
6346 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_out_rng_len_err_frms);
6347 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_long_frms);
6348 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_pause_ctrl_frms);
6349 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_unsup_ctrl_frms);
6350 tmp_stats[i++] =
6351 (u64)le32_to_cpu(stat_info->rmac_ttl_octets_oflow) << 32 |
6352 le32_to_cpu(stat_info->rmac_ttl_octets);
6353 tmp_stats[i++] =
6354 (u64)le32_to_cpu(stat_info->rmac_accepted_ucst_frms_oflow)
6355 << 32 | le32_to_cpu(stat_info->rmac_accepted_ucst_frms);
6356 tmp_stats[i++] =
6357 (u64)le32_to_cpu(stat_info->rmac_accepted_nucst_frms_oflow)
6358 << 32 | le32_to_cpu(stat_info->rmac_accepted_nucst_frms);
6359 tmp_stats[i++] =
6360 (u64)le32_to_cpu(stat_info->rmac_discarded_frms_oflow) << 32 |
6361 le32_to_cpu(stat_info->rmac_discarded_frms);
6362 tmp_stats[i++] =
6363 (u64)le32_to_cpu(stat_info->rmac_drop_events_oflow)
6364 << 32 | le32_to_cpu(stat_info->rmac_drop_events);
6365 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ttl_less_fb_octets);
6366 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ttl_frms);
6367 tmp_stats[i++] =
6368 (u64)le32_to_cpu(stat_info->rmac_usized_frms_oflow) << 32 |
6369 le32_to_cpu(stat_info->rmac_usized_frms);
6370 tmp_stats[i++] =
6371 (u64)le32_to_cpu(stat_info->rmac_osized_frms_oflow) << 32 |
6372 le32_to_cpu(stat_info->rmac_osized_frms);
6373 tmp_stats[i++] =
6374 (u64)le32_to_cpu(stat_info->rmac_frag_frms_oflow) << 32 |
6375 le32_to_cpu(stat_info->rmac_frag_frms);
6376 tmp_stats[i++] =
6377 (u64)le32_to_cpu(stat_info->rmac_jabber_frms_oflow) << 32 |
6378 le32_to_cpu(stat_info->rmac_jabber_frms);
6379 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ttl_64_frms);
6380 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ttl_65_127_frms);
6381 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ttl_128_255_frms);
6382 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ttl_256_511_frms);
6383 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ttl_512_1023_frms);
6384 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ttl_1024_1518_frms);
6385 tmp_stats[i++] =
6386 (u64)le32_to_cpu(stat_info->rmac_ip_oflow) << 32 |
6387 le32_to_cpu(stat_info->rmac_ip);
6388 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ip_octets);
6389 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_hdr_err_ip);
6390 tmp_stats[i++] =
6391 (u64)le32_to_cpu(stat_info->rmac_drop_ip_oflow) << 32 |
6392 le32_to_cpu(stat_info->rmac_drop_ip);
6393 tmp_stats[i++] =
6394 (u64)le32_to_cpu(stat_info->rmac_icmp_oflow) << 32 |
6395 le32_to_cpu(stat_info->rmac_icmp);
6396 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_tcp);
6397 tmp_stats[i++] =
6398 (u64)le32_to_cpu(stat_info->rmac_udp_oflow) << 32 |
6399 le32_to_cpu(stat_info->rmac_udp);
6400 tmp_stats[i++] =
6401 (u64)le32_to_cpu(stat_info->rmac_err_drp_udp_oflow) << 32 |
6402 le32_to_cpu(stat_info->rmac_err_drp_udp);
6403 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_xgmii_err_sym);
6404 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_frms_q0);
6405 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_frms_q1);
6406 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_frms_q2);
6407 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_frms_q3);
6408 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_frms_q4);
6409 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_frms_q5);
6410 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_frms_q6);
6411 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_frms_q7);
6412 tmp_stats[i++] = le16_to_cpu(stat_info->rmac_full_q0);
6413 tmp_stats[i++] = le16_to_cpu(stat_info->rmac_full_q1);
6414 tmp_stats[i++] = le16_to_cpu(stat_info->rmac_full_q2);
6415 tmp_stats[i++] = le16_to_cpu(stat_info->rmac_full_q3);
6416 tmp_stats[i++] = le16_to_cpu(stat_info->rmac_full_q4);
6417 tmp_stats[i++] = le16_to_cpu(stat_info->rmac_full_q5);
6418 tmp_stats[i++] = le16_to_cpu(stat_info->rmac_full_q6);
6419 tmp_stats[i++] = le16_to_cpu(stat_info->rmac_full_q7);
6420 tmp_stats[i++] =
6421 (u64)le32_to_cpu(stat_info->rmac_pause_cnt_oflow) << 32 |
6422 le32_to_cpu(stat_info->rmac_pause_cnt);
6423 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_xgmii_data_err_cnt);
6424 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_xgmii_ctrl_err_cnt);
6425 tmp_stats[i++] =
6426 (u64)le32_to_cpu(stat_info->rmac_accepted_ip_oflow) << 32 |
6427 le32_to_cpu(stat_info->rmac_accepted_ip);
6428 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_err_tcp);
6429 tmp_stats[i++] = le32_to_cpu(stat_info->rd_req_cnt);
6430 tmp_stats[i++] = le32_to_cpu(stat_info->new_rd_req_cnt);
6431 tmp_stats[i++] = le32_to_cpu(stat_info->new_rd_req_rtry_cnt);
6432 tmp_stats[i++] = le32_to_cpu(stat_info->rd_rtry_cnt);
6433 tmp_stats[i++] = le32_to_cpu(stat_info->wr_rtry_rd_ack_cnt);
6434 tmp_stats[i++] = le32_to_cpu(stat_info->wr_req_cnt);
6435 tmp_stats[i++] = le32_to_cpu(stat_info->new_wr_req_cnt);
6436 tmp_stats[i++] = le32_to_cpu(stat_info->new_wr_req_rtry_cnt);
6437 tmp_stats[i++] = le32_to_cpu(stat_info->wr_rtry_cnt);
6438 tmp_stats[i++] = le32_to_cpu(stat_info->wr_disc_cnt);
6439 tmp_stats[i++] = le32_to_cpu(stat_info->rd_rtry_wr_ack_cnt);
6440 tmp_stats[i++] = le32_to_cpu(stat_info->txp_wr_cnt);
6441 tmp_stats[i++] = le32_to_cpu(stat_info->txd_rd_cnt);
6442 tmp_stats[i++] = le32_to_cpu(stat_info->txd_wr_cnt);
6443 tmp_stats[i++] = le32_to_cpu(stat_info->rxd_rd_cnt);
6444 tmp_stats[i++] = le32_to_cpu(stat_info->rxd_wr_cnt);
6445 tmp_stats[i++] = le32_to_cpu(stat_info->txf_rd_cnt);
6446 tmp_stats[i++] = le32_to_cpu(stat_info->rxf_wr_cnt);
6447
6448 /* Enhanced statistics exist only for Hercules */
6449 if(sp->device_type == XFRAME_II_DEVICE) {
6450 tmp_stats[i++] =
6451 le64_to_cpu(stat_info->rmac_ttl_1519_4095_frms);
6452 tmp_stats[i++] =
6453 le64_to_cpu(stat_info->rmac_ttl_4096_8191_frms);
6454 tmp_stats[i++] =
6455 le64_to_cpu(stat_info->rmac_ttl_8192_max_frms);
6456 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ttl_gt_max_frms);
6457 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_osized_alt_frms);
6458 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_jabber_alt_frms);
6459 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_gt_max_alt_frms);
6460 tmp_stats[i++] = le64_to_cpu(stat_info->rmac_vlan_frms);
6461 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_len_discard);
6462 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_fcs_discard);
6463 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_pf_discard);
6464 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_da_discard);
6465 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_red_discard);
6466 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_rts_discard);
6467 tmp_stats[i++] = le32_to_cpu(stat_info->rmac_ingm_full_discard);
6468 tmp_stats[i++] = le32_to_cpu(stat_info->link_fault_cnt);
6469 }
6470
6471 tmp_stats[i++] = 0;
6472 tmp_stats[i++] = stat_info->sw_stat.single_ecc_errs;
6473 tmp_stats[i++] = stat_info->sw_stat.double_ecc_errs;
6474 tmp_stats[i++] = stat_info->sw_stat.parity_err_cnt;
6475 tmp_stats[i++] = stat_info->sw_stat.serious_err_cnt;
6476 tmp_stats[i++] = stat_info->sw_stat.soft_reset_cnt;
6477 tmp_stats[i++] = stat_info->sw_stat.fifo_full_cnt;
6478 for (k = 0; k < MAX_RX_RINGS; k++)
6479 tmp_stats[i++] = stat_info->sw_stat.ring_full_cnt[k];
6480 tmp_stats[i++] = stat_info->xpak_stat.alarm_transceiver_temp_high;
6481 tmp_stats[i++] = stat_info->xpak_stat.alarm_transceiver_temp_low;
6482 tmp_stats[i++] = stat_info->xpak_stat.alarm_laser_bias_current_high;
6483 tmp_stats[i++] = stat_info->xpak_stat.alarm_laser_bias_current_low;
6484 tmp_stats[i++] = stat_info->xpak_stat.alarm_laser_output_power_high;
6485 tmp_stats[i++] = stat_info->xpak_stat.alarm_laser_output_power_low;
6486 tmp_stats[i++] = stat_info->xpak_stat.warn_transceiver_temp_high;
6487 tmp_stats[i++] = stat_info->xpak_stat.warn_transceiver_temp_low;
6488 tmp_stats[i++] = stat_info->xpak_stat.warn_laser_bias_current_high;
6489 tmp_stats[i++] = stat_info->xpak_stat.warn_laser_bias_current_low;
6490 tmp_stats[i++] = stat_info->xpak_stat.warn_laser_output_power_high;
6491 tmp_stats[i++] = stat_info->xpak_stat.warn_laser_output_power_low;
6492 tmp_stats[i++] = stat_info->sw_stat.clubbed_frms_cnt;
6493 tmp_stats[i++] = stat_info->sw_stat.sending_both;
6494 tmp_stats[i++] = stat_info->sw_stat.outof_sequence_pkts;
6495 tmp_stats[i++] = stat_info->sw_stat.flush_max_pkts;
6496 if (stat_info->sw_stat.num_aggregations) {
6497 u64 tmp = stat_info->sw_stat.sum_avg_pkts_aggregated;
6498 int count = 0;
6499 /*
6500 * Since 64-bit divide does not work on all platforms,
6501 * do repeated subtraction.
6502 */
6503 while (tmp >= stat_info->sw_stat.num_aggregations) {
6504 tmp -= stat_info->sw_stat.num_aggregations;
6505 count++;
6506 }
6507 tmp_stats[i++] = count;
6508 }
6509 else
6510 tmp_stats[i++] = 0;
6511 tmp_stats[i++] = stat_info->sw_stat.mem_alloc_fail_cnt;
6512 tmp_stats[i++] = stat_info->sw_stat.pci_map_fail_cnt;
6513 tmp_stats[i++] = stat_info->sw_stat.watchdog_timer_cnt;
6514 tmp_stats[i++] = stat_info->sw_stat.mem_allocated;
6515 tmp_stats[i++] = stat_info->sw_stat.mem_freed;
6516 tmp_stats[i++] = stat_info->sw_stat.link_up_cnt;
6517 tmp_stats[i++] = stat_info->sw_stat.link_down_cnt;
6518 tmp_stats[i++] = stat_info->sw_stat.link_up_time;
6519 tmp_stats[i++] = stat_info->sw_stat.link_down_time;
6520
6521 tmp_stats[i++] = stat_info->sw_stat.tx_buf_abort_cnt;
6522 tmp_stats[i++] = stat_info->sw_stat.tx_desc_abort_cnt;
6523 tmp_stats[i++] = stat_info->sw_stat.tx_parity_err_cnt;
6524 tmp_stats[i++] = stat_info->sw_stat.tx_link_loss_cnt;
6525 tmp_stats[i++] = stat_info->sw_stat.tx_list_proc_err_cnt;
6526
6527 tmp_stats[i++] = stat_info->sw_stat.rx_parity_err_cnt;
6528 tmp_stats[i++] = stat_info->sw_stat.rx_abort_cnt;
6529 tmp_stats[i++] = stat_info->sw_stat.rx_parity_abort_cnt;
6530 tmp_stats[i++] = stat_info->sw_stat.rx_rda_fail_cnt;
6531 tmp_stats[i++] = stat_info->sw_stat.rx_unkn_prot_cnt;
6532 tmp_stats[i++] = stat_info->sw_stat.rx_fcs_err_cnt;
6533 tmp_stats[i++] = stat_info->sw_stat.rx_buf_size_err_cnt;
6534 tmp_stats[i++] = stat_info->sw_stat.rx_rxd_corrupt_cnt;
6535 tmp_stats[i++] = stat_info->sw_stat.rx_unkn_err_cnt;
6536 tmp_stats[i++] = stat_info->sw_stat.tda_err_cnt;
6537 tmp_stats[i++] = stat_info->sw_stat.pfc_err_cnt;
6538 tmp_stats[i++] = stat_info->sw_stat.pcc_err_cnt;
6539 tmp_stats[i++] = stat_info->sw_stat.tti_err_cnt;
6540 tmp_stats[i++] = stat_info->sw_stat.tpa_err_cnt;
6541 tmp_stats[i++] = stat_info->sw_stat.sm_err_cnt;
6542 tmp_stats[i++] = stat_info->sw_stat.lso_err_cnt;
6543 tmp_stats[i++] = stat_info->sw_stat.mac_tmac_err_cnt;
6544 tmp_stats[i++] = stat_info->sw_stat.mac_rmac_err_cnt;
6545 tmp_stats[i++] = stat_info->sw_stat.xgxs_txgxs_err_cnt;
6546 tmp_stats[i++] = stat_info->sw_stat.xgxs_rxgxs_err_cnt;
6547 tmp_stats[i++] = stat_info->sw_stat.rc_err_cnt;
6548 tmp_stats[i++] = stat_info->sw_stat.prc_pcix_err_cnt;
6549 tmp_stats[i++] = stat_info->sw_stat.rpa_err_cnt;
6550 tmp_stats[i++] = stat_info->sw_stat.rda_err_cnt;
6551 tmp_stats[i++] = stat_info->sw_stat.rti_err_cnt;
6552 tmp_stats[i++] = stat_info->sw_stat.mc_err_cnt;
6553 }
6554
6555 static int s2io_ethtool_get_regs_len(struct net_device *dev)
6556 {
6557 return (XENA_REG_SPACE);
6558 }
6559
6560
6561 static u32 s2io_ethtool_get_rx_csum(struct net_device * dev)
6562 {
6563 struct s2io_nic *sp = dev->priv;
6564
6565 return (sp->rx_csum);
6566 }
6567
6568 static int s2io_ethtool_set_rx_csum(struct net_device *dev, u32 data)
6569 {
6570 struct s2io_nic *sp = dev->priv;
6571
6572 if (data)
6573 sp->rx_csum = 1;
6574 else
6575 sp->rx_csum = 0;
6576
6577 return 0;
6578 }
6579
6580 static int s2io_get_eeprom_len(struct net_device *dev)
6581 {
6582 return (XENA_EEPROM_SPACE);
6583 }
6584
6585 static int s2io_get_sset_count(struct net_device *dev, int sset)
6586 {
6587 struct s2io_nic *sp = dev->priv;
6588
6589 switch (sset) {
6590 case ETH_SS_TEST:
6591 return S2IO_TEST_LEN;
6592 case ETH_SS_STATS:
6593 switch(sp->device_type) {
6594 case XFRAME_I_DEVICE:
6595 return XFRAME_I_STAT_LEN;
6596 case XFRAME_II_DEVICE:
6597 return XFRAME_II_STAT_LEN;
6598 default:
6599 return 0;
6600 }
6601 default:
6602 return -EOPNOTSUPP;
6603 }
6604 }
6605
6606 static void s2io_ethtool_get_strings(struct net_device *dev,
6607 u32 stringset, u8 * data)
6608 {
6609 int stat_size = 0;
6610 struct s2io_nic *sp = dev->priv;
6611
6612 switch (stringset) {
6613 case ETH_SS_TEST:
6614 memcpy(data, s2io_gstrings, S2IO_STRINGS_LEN);
6615 break;
6616 case ETH_SS_STATS:
6617 stat_size = sizeof(ethtool_xena_stats_keys);
6618 memcpy(data, &ethtool_xena_stats_keys,stat_size);
6619 if(sp->device_type == XFRAME_II_DEVICE) {
6620 memcpy(data + stat_size,
6621 &ethtool_enhanced_stats_keys,
6622 sizeof(ethtool_enhanced_stats_keys));
6623 stat_size += sizeof(ethtool_enhanced_stats_keys);
6624 }
6625
6626 memcpy(data + stat_size, &ethtool_driver_stats_keys,
6627 sizeof(ethtool_driver_stats_keys));
6628 }
6629 }
6630
6631 static int s2io_ethtool_op_set_tx_csum(struct net_device *dev, u32 data)
6632 {
6633 if (data)
6634 dev->features |= NETIF_F_IP_CSUM;
6635 else
6636 dev->features &= ~NETIF_F_IP_CSUM;
6637
6638 return 0;
6639 }
6640
6641 static u32 s2io_ethtool_op_get_tso(struct net_device *dev)
6642 {
6643 return (dev->features & NETIF_F_TSO) != 0;
6644 }
6645 static int s2io_ethtool_op_set_tso(struct net_device *dev, u32 data)
6646 {
6647 if (data)
6648 dev->features |= (NETIF_F_TSO | NETIF_F_TSO6);
6649 else
6650 dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
6651
6652 return 0;
6653 }
6654
6655 static const struct ethtool_ops netdev_ethtool_ops = {
6656 .get_settings = s2io_ethtool_gset,
6657 .set_settings = s2io_ethtool_sset,
6658 .get_drvinfo = s2io_ethtool_gdrvinfo,
6659 .get_regs_len = s2io_ethtool_get_regs_len,
6660 .get_regs = s2io_ethtool_gregs,
6661 .get_link = ethtool_op_get_link,
6662 .get_eeprom_len = s2io_get_eeprom_len,
6663 .get_eeprom = s2io_ethtool_geeprom,
6664 .set_eeprom = s2io_ethtool_seeprom,
6665 .get_ringparam = s2io_ethtool_gringparam,
6666 .get_pauseparam = s2io_ethtool_getpause_data,
6667 .set_pauseparam = s2io_ethtool_setpause_data,
6668 .get_rx_csum = s2io_ethtool_get_rx_csum,
6669 .set_rx_csum = s2io_ethtool_set_rx_csum,
6670 .set_tx_csum = s2io_ethtool_op_set_tx_csum,
6671 .set_sg = ethtool_op_set_sg,
6672 .get_tso = s2io_ethtool_op_get_tso,
6673 .set_tso = s2io_ethtool_op_set_tso,
6674 .set_ufo = ethtool_op_set_ufo,
6675 .self_test = s2io_ethtool_test,
6676 .get_strings = s2io_ethtool_get_strings,
6677 .phys_id = s2io_ethtool_idnic,
6678 .get_ethtool_stats = s2io_get_ethtool_stats,
6679 .get_sset_count = s2io_get_sset_count,
6680 };
6681
6682 /**
6683 * s2io_ioctl - Entry point for the Ioctl
6684 * @dev : Device pointer.
6685 * @ifr : An IOCTL specefic structure, that can contain a pointer to
6686 * a proprietary structure used to pass information to the driver.
6687 * @cmd : This is used to distinguish between the different commands that
6688 * can be passed to the IOCTL functions.
6689 * Description:
6690 * Currently there are no special functionality supported in IOCTL, hence
6691 * function always return EOPNOTSUPPORTED
6692 */
6693
6694 static int s2io_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
6695 {
6696 return -EOPNOTSUPP;
6697 }
6698
6699 /**
6700 * s2io_change_mtu - entry point to change MTU size for the device.
6701 * @dev : device pointer.
6702 * @new_mtu : the new MTU size for the device.
6703 * Description: A driver entry point to change MTU size for the device.
6704 * Before changing the MTU the device must be stopped.
6705 * Return value:
6706 * 0 on success and an appropriate (-)ve integer as defined in errno.h
6707 * file on failure.
6708 */
6709
6710 static int s2io_change_mtu(struct net_device *dev, int new_mtu)
6711 {
6712 struct s2io_nic *sp = dev->priv;
6713 int ret = 0;
6714
6715 if ((new_mtu < MIN_MTU) || (new_mtu > S2IO_JUMBO_SIZE)) {
6716 DBG_PRINT(ERR_DBG, "%s: MTU size is invalid.\n",
6717 dev->name);
6718 return -EPERM;
6719 }
6720
6721 dev->mtu = new_mtu;
6722 if (netif_running(dev)) {
6723 s2io_stop_all_tx_queue(sp);
6724 s2io_card_down(sp);
6725 ret = s2io_card_up(sp);
6726 if (ret) {
6727 DBG_PRINT(ERR_DBG, "%s: Device bring up failed\n",
6728 __FUNCTION__);
6729 return ret;
6730 }
6731 s2io_wake_all_tx_queue(sp);
6732 } else { /* Device is down */
6733 struct XENA_dev_config __iomem *bar0 = sp->bar0;
6734 u64 val64 = new_mtu;
6735
6736 writeq(vBIT(val64, 2, 14), &bar0->rmac_max_pyld_len);
6737 }
6738
6739 return ret;
6740 }
6741
6742 /**
6743 * s2io_set_link - Set the LInk status
6744 * @data: long pointer to device private structue
6745 * Description: Sets the link status for the adapter
6746 */
6747
6748 static void s2io_set_link(struct work_struct *work)
6749 {
6750 struct s2io_nic *nic = container_of(work, struct s2io_nic, set_link_task);
6751 struct net_device *dev = nic->dev;
6752 struct XENA_dev_config __iomem *bar0 = nic->bar0;
6753 register u64 val64;
6754 u16 subid;
6755
6756 rtnl_lock();
6757
6758 if (!netif_running(dev))
6759 goto out_unlock;
6760
6761 if (test_and_set_bit(__S2IO_STATE_LINK_TASK, &(nic->state))) {
6762 /* The card is being reset, no point doing anything */
6763 goto out_unlock;
6764 }
6765
6766 subid = nic->pdev->subsystem_device;
6767 if (s2io_link_fault_indication(nic) == MAC_RMAC_ERR_TIMER) {
6768 /*
6769 * Allow a small delay for the NICs self initiated
6770 * cleanup to complete.
6771 */
6772 msleep(100);
6773 }
6774
6775 val64 = readq(&bar0->adapter_status);
6776 if (LINK_IS_UP(val64)) {
6777 if (!(readq(&bar0->adapter_control) & ADAPTER_CNTL_EN)) {
6778 if (verify_xena_quiescence(nic)) {
6779 val64 = readq(&bar0->adapter_control);
6780 val64 |= ADAPTER_CNTL_EN;
6781 writeq(val64, &bar0->adapter_control);
6782 if (CARDS_WITH_FAULTY_LINK_INDICATORS(
6783 nic->device_type, subid)) {
6784 val64 = readq(&bar0->gpio_control);
6785 val64 |= GPIO_CTRL_GPIO_0;
6786 writeq(val64, &bar0->gpio_control);
6787 val64 = readq(&bar0->gpio_control);
6788 } else {
6789 val64 |= ADAPTER_LED_ON;
6790 writeq(val64, &bar0->adapter_control);
6791 }
6792 nic->device_enabled_once = TRUE;
6793 } else {
6794 DBG_PRINT(ERR_DBG, "%s: Error: ", dev->name);
6795 DBG_PRINT(ERR_DBG, "device is not Quiescent\n");
6796 s2io_stop_all_tx_queue(nic);
6797 }
6798 }
6799 val64 = readq(&bar0->adapter_control);
6800 val64 |= ADAPTER_LED_ON;
6801 writeq(val64, &bar0->adapter_control);
6802 s2io_link(nic, LINK_UP);
6803 } else {
6804 if (CARDS_WITH_FAULTY_LINK_INDICATORS(nic->device_type,
6805 subid)) {
6806 val64 = readq(&bar0->gpio_control);
6807 val64 &= ~GPIO_CTRL_GPIO_0;
6808 writeq(val64, &bar0->gpio_control);
6809 val64 = readq(&bar0->gpio_control);
6810 }
6811 /* turn off LED */
6812 val64 = readq(&bar0->adapter_control);
6813 val64 = val64 &(~ADAPTER_LED_ON);
6814 writeq(val64, &bar0->adapter_control);
6815 s2io_link(nic, LINK_DOWN);
6816 }
6817 clear_bit(__S2IO_STATE_LINK_TASK, &(nic->state));
6818
6819 out_unlock:
6820 rtnl_unlock();
6821 }
6822
6823 static int set_rxd_buffer_pointer(struct s2io_nic *sp, struct RxD_t *rxdp,
6824 struct buffAdd *ba,
6825 struct sk_buff **skb, u64 *temp0, u64 *temp1,
6826 u64 *temp2, int size)
6827 {
6828 struct net_device *dev = sp->dev;
6829 struct swStat *stats = &sp->mac_control.stats_info->sw_stat;
6830
6831 if ((sp->rxd_mode == RXD_MODE_1) && (rxdp->Host_Control == 0)) {
6832 struct RxD1 *rxdp1 = (struct RxD1 *)rxdp;
6833 /* allocate skb */
6834 if (*skb) {
6835 DBG_PRINT(INFO_DBG, "SKB is not NULL\n");
6836 /*
6837 * As Rx frame are not going to be processed,
6838 * using same mapped address for the Rxd
6839 * buffer pointer
6840 */
6841 rxdp1->Buffer0_ptr = *temp0;
6842 } else {
6843 *skb = dev_alloc_skb(size);
6844 if (!(*skb)) {
6845 DBG_PRINT(INFO_DBG, "%s: Out of ", dev->name);
6846 DBG_PRINT(INFO_DBG, "memory to allocate ");
6847 DBG_PRINT(INFO_DBG, "1 buf mode SKBs\n");
6848 sp->mac_control.stats_info->sw_stat. \
6849 mem_alloc_fail_cnt++;
6850 return -ENOMEM ;
6851 }
6852 sp->mac_control.stats_info->sw_stat.mem_allocated
6853 += (*skb)->truesize;
6854 /* storing the mapped addr in a temp variable
6855 * such it will be used for next rxd whose
6856 * Host Control is NULL
6857 */
6858 rxdp1->Buffer0_ptr = *temp0 =
6859 pci_map_single( sp->pdev, (*skb)->data,
6860 size - NET_IP_ALIGN,
6861 PCI_DMA_FROMDEVICE);
6862 if (pci_dma_mapping_error(rxdp1->Buffer0_ptr))
6863 goto memalloc_failed;
6864 rxdp->Host_Control = (unsigned long) (*skb);
6865 }
6866 } else if ((sp->rxd_mode == RXD_MODE_3B) && (rxdp->Host_Control == 0)) {
6867 struct RxD3 *rxdp3 = (struct RxD3 *)rxdp;
6868 /* Two buffer Mode */
6869 if (*skb) {
6870 rxdp3->Buffer2_ptr = *temp2;
6871 rxdp3->Buffer0_ptr = *temp0;
6872 rxdp3->Buffer1_ptr = *temp1;
6873 } else {
6874 *skb = dev_alloc_skb(size);
6875 if (!(*skb)) {
6876 DBG_PRINT(INFO_DBG, "%s: Out of ", dev->name);
6877 DBG_PRINT(INFO_DBG, "memory to allocate ");
6878 DBG_PRINT(INFO_DBG, "2 buf mode SKBs\n");
6879 sp->mac_control.stats_info->sw_stat. \
6880 mem_alloc_fail_cnt++;
6881 return -ENOMEM;
6882 }
6883 sp->mac_control.stats_info->sw_stat.mem_allocated
6884 += (*skb)->truesize;
6885 rxdp3->Buffer2_ptr = *temp2 =
6886 pci_map_single(sp->pdev, (*skb)->data,
6887 dev->mtu + 4,
6888 PCI_DMA_FROMDEVICE);
6889 if (pci_dma_mapping_error(rxdp3->Buffer2_ptr))
6890 goto memalloc_failed;
6891 rxdp3->Buffer0_ptr = *temp0 =
6892 pci_map_single( sp->pdev, ba->ba_0, BUF0_LEN,
6893 PCI_DMA_FROMDEVICE);
6894 if (pci_dma_mapping_error(rxdp3->Buffer0_ptr)) {
6895 pci_unmap_single (sp->pdev,
6896 (dma_addr_t)rxdp3->Buffer2_ptr,
6897 dev->mtu + 4, PCI_DMA_FROMDEVICE);
6898 goto memalloc_failed;
6899 }
6900 rxdp->Host_Control = (unsigned long) (*skb);
6901
6902 /* Buffer-1 will be dummy buffer not used */
6903 rxdp3->Buffer1_ptr = *temp1 =
6904 pci_map_single(sp->pdev, ba->ba_1, BUF1_LEN,
6905 PCI_DMA_FROMDEVICE);
6906 if (pci_dma_mapping_error(rxdp3->Buffer1_ptr)) {
6907 pci_unmap_single (sp->pdev,
6908 (dma_addr_t)rxdp3->Buffer0_ptr,
6909 BUF0_LEN, PCI_DMA_FROMDEVICE);
6910 pci_unmap_single (sp->pdev,
6911 (dma_addr_t)rxdp3->Buffer2_ptr,
6912 dev->mtu + 4, PCI_DMA_FROMDEVICE);
6913 goto memalloc_failed;
6914 }
6915 }
6916 }
6917 return 0;
6918 memalloc_failed:
6919 stats->pci_map_fail_cnt++;
6920 stats->mem_freed += (*skb)->truesize;
6921 dev_kfree_skb(*skb);
6922 return -ENOMEM;
6923 }
6924
6925 static void set_rxd_buffer_size(struct s2io_nic *sp, struct RxD_t *rxdp,
6926 int size)
6927 {
6928 struct net_device *dev = sp->dev;
6929 if (sp->rxd_mode == RXD_MODE_1) {
6930 rxdp->Control_2 = SET_BUFFER0_SIZE_1( size - NET_IP_ALIGN);
6931 } else if (sp->rxd_mode == RXD_MODE_3B) {
6932 rxdp->Control_2 = SET_BUFFER0_SIZE_3(BUF0_LEN);
6933 rxdp->Control_2 |= SET_BUFFER1_SIZE_3(1);
6934 rxdp->Control_2 |= SET_BUFFER2_SIZE_3( dev->mtu + 4);
6935 }
6936 }
6937
6938 static int rxd_owner_bit_reset(struct s2io_nic *sp)
6939 {
6940 int i, j, k, blk_cnt = 0, size;
6941 struct mac_info * mac_control = &sp->mac_control;
6942 struct config_param *config = &sp->config;
6943 struct net_device *dev = sp->dev;
6944 struct RxD_t *rxdp = NULL;
6945 struct sk_buff *skb = NULL;
6946 struct buffAdd *ba = NULL;
6947 u64 temp0_64 = 0, temp1_64 = 0, temp2_64 = 0;
6948
6949 /* Calculate the size based on ring mode */
6950 size = dev->mtu + HEADER_ETHERNET_II_802_3_SIZE +
6951 HEADER_802_2_SIZE + HEADER_SNAP_SIZE;
6952 if (sp->rxd_mode == RXD_MODE_1)
6953 size += NET_IP_ALIGN;
6954 else if (sp->rxd_mode == RXD_MODE_3B)
6955 size = dev->mtu + ALIGN_SIZE + BUF0_LEN + 4;
6956
6957 for (i = 0; i < config->rx_ring_num; i++) {
6958 blk_cnt = config->rx_cfg[i].num_rxd /
6959 (rxd_count[sp->rxd_mode] +1);
6960
6961 for (j = 0; j < blk_cnt; j++) {
6962 for (k = 0; k < rxd_count[sp->rxd_mode]; k++) {
6963 rxdp = mac_control->rings[i].
6964 rx_blocks[j].rxds[k].virt_addr;
6965 if(sp->rxd_mode == RXD_MODE_3B)
6966 ba = &mac_control->rings[i].ba[j][k];
6967 if (set_rxd_buffer_pointer(sp, rxdp, ba,
6968 &skb,(u64 *)&temp0_64,
6969 (u64 *)&temp1_64,
6970 (u64 *)&temp2_64,
6971 size) == -ENOMEM) {
6972 return 0;
6973 }
6974
6975 set_rxd_buffer_size(sp, rxdp, size);
6976 wmb();
6977 /* flip the Ownership bit to Hardware */
6978 rxdp->Control_1 |= RXD_OWN_XENA;
6979 }
6980 }
6981 }
6982 return 0;
6983
6984 }
6985
6986 static int s2io_add_isr(struct s2io_nic * sp)
6987 {
6988 int ret = 0;
6989 struct net_device *dev = sp->dev;
6990 int err = 0;
6991
6992 if (sp->config.intr_type == MSI_X)
6993 ret = s2io_enable_msi_x(sp);
6994 if (ret) {
6995 DBG_PRINT(ERR_DBG, "%s: Defaulting to INTA\n", dev->name);
6996 sp->config.intr_type = INTA;
6997 }
6998
6999 /* Store the values of the MSIX table in the struct s2io_nic structure */
7000 store_xmsi_data(sp);
7001
7002 /* After proper initialization of H/W, register ISR */
7003 if (sp->config.intr_type == MSI_X) {
7004 int i, msix_rx_cnt = 0;
7005
7006 for (i = 0; i < sp->num_entries; i++) {
7007 if (sp->s2io_entries[i].in_use == MSIX_FLG) {
7008 if (sp->s2io_entries[i].type ==
7009 MSIX_RING_TYPE) {
7010 sprintf(sp->desc[i], "%s:MSI-X-%d-RX",
7011 dev->name, i);
7012 err = request_irq(sp->entries[i].vector,
7013 s2io_msix_ring_handle, 0,
7014 sp->desc[i],
7015 sp->s2io_entries[i].arg);
7016 } else if (sp->s2io_entries[i].type ==
7017 MSIX_ALARM_TYPE) {
7018 sprintf(sp->desc[i], "%s:MSI-X-%d-TX",
7019 dev->name, i);
7020 err = request_irq(sp->entries[i].vector,
7021 s2io_msix_fifo_handle, 0,
7022 sp->desc[i],
7023 sp->s2io_entries[i].arg);
7024
7025 }
7026 /* if either data or addr is zero print it. */
7027 if (!(sp->msix_info[i].addr &&
7028 sp->msix_info[i].data)) {
7029 DBG_PRINT(ERR_DBG,
7030 "%s @Addr:0x%llx Data:0x%llx\n",
7031 sp->desc[i],
7032 (unsigned long long)
7033 sp->msix_info[i].addr,
7034 (unsigned long long)
7035 ntohl(sp->msix_info[i].data));
7036 } else
7037 msix_rx_cnt++;
7038 if (err) {
7039 remove_msix_isr(sp);
7040
7041 DBG_PRINT(ERR_DBG,
7042 "%s:MSI-X-%d registration "
7043 "failed\n", dev->name, i);
7044
7045 DBG_PRINT(ERR_DBG,
7046 "%s: Defaulting to INTA\n",
7047 dev->name);
7048 sp->config.intr_type = INTA;
7049 break;
7050 }
7051 sp->s2io_entries[i].in_use =
7052 MSIX_REGISTERED_SUCCESS;
7053 }
7054 }
7055 if (!err) {
7056 printk(KERN_INFO "MSI-X-RX %d entries enabled\n",
7057 --msix_rx_cnt);
7058 DBG_PRINT(INFO_DBG, "MSI-X-TX entries enabled"
7059 " through alarm vector\n");
7060 }
7061 }
7062 if (sp->config.intr_type == INTA) {
7063 err = request_irq((int) sp->pdev->irq, s2io_isr, IRQF_SHARED,
7064 sp->name, dev);
7065 if (err) {
7066 DBG_PRINT(ERR_DBG, "%s: ISR registration failed\n",
7067 dev->name);
7068 return -1;
7069 }
7070 }
7071 return 0;
7072 }
7073 static void s2io_rem_isr(struct s2io_nic * sp)
7074 {
7075 if (sp->config.intr_type == MSI_X)
7076 remove_msix_isr(sp);
7077 else
7078 remove_inta_isr(sp);
7079 }
7080
7081 static void do_s2io_card_down(struct s2io_nic * sp, int do_io)
7082 {
7083 int cnt = 0;
7084 struct XENA_dev_config __iomem *bar0 = sp->bar0;
7085 register u64 val64 = 0;
7086 struct config_param *config;
7087 config = &sp->config;
7088
7089 if (!is_s2io_card_up(sp))
7090 return;
7091
7092 del_timer_sync(&sp->alarm_timer);
7093 /* If s2io_set_link task is executing, wait till it completes. */
7094 while (test_and_set_bit(__S2IO_STATE_LINK_TASK, &(sp->state))) {
7095 msleep(50);
7096 }
7097 clear_bit(__S2IO_STATE_CARD_UP, &sp->state);
7098
7099 /* Disable napi */
7100 if (sp->config.napi) {
7101 int off = 0;
7102 if (config->intr_type == MSI_X) {
7103 for (; off < sp->config.rx_ring_num; off++)
7104 napi_disable(&sp->mac_control.rings[off].napi);
7105 }
7106 else
7107 napi_disable(&sp->napi);
7108 }
7109
7110 /* disable Tx and Rx traffic on the NIC */
7111 if (do_io)
7112 stop_nic(sp);
7113
7114 s2io_rem_isr(sp);
7115
7116 /* stop the tx queue, indicate link down */
7117 s2io_link(sp, LINK_DOWN);
7118
7119 /* Check if the device is Quiescent and then Reset the NIC */
7120 while(do_io) {
7121 /* As per the HW requirement we need to replenish the
7122 * receive buffer to avoid the ring bump. Since there is
7123 * no intention of processing the Rx frame at this pointwe are
7124 * just settting the ownership bit of rxd in Each Rx
7125 * ring to HW and set the appropriate buffer size
7126 * based on the ring mode
7127 */
7128 rxd_owner_bit_reset(sp);
7129
7130 val64 = readq(&bar0->adapter_status);
7131 if (verify_xena_quiescence(sp)) {
7132 if(verify_pcc_quiescent(sp, sp->device_enabled_once))
7133 break;
7134 }
7135
7136 msleep(50);
7137 cnt++;
7138 if (cnt == 10) {
7139 DBG_PRINT(ERR_DBG,
7140 "s2io_close:Device not Quiescent ");
7141 DBG_PRINT(ERR_DBG, "adaper status reads 0x%llx\n",
7142 (unsigned long long) val64);
7143 break;
7144 }
7145 }
7146 if (do_io)
7147 s2io_reset(sp);
7148
7149 /* Free all Tx buffers */
7150 free_tx_buffers(sp);
7151
7152 /* Free all Rx buffers */
7153 free_rx_buffers(sp);
7154
7155 clear_bit(__S2IO_STATE_LINK_TASK, &(sp->state));
7156 }
7157
7158 static void s2io_card_down(struct s2io_nic * sp)
7159 {
7160 do_s2io_card_down(sp, 1);
7161 }
7162
7163 static int s2io_card_up(struct s2io_nic * sp)
7164 {
7165 int i, ret = 0;
7166 struct mac_info *mac_control;
7167 struct config_param *config;
7168 struct net_device *dev = (struct net_device *) sp->dev;
7169 u16 interruptible;
7170
7171 /* Initialize the H/W I/O registers */
7172 ret = init_nic(sp);
7173 if (ret != 0) {
7174 DBG_PRINT(ERR_DBG, "%s: H/W initialization failed\n",
7175 dev->name);
7176 if (ret != -EIO)
7177 s2io_reset(sp);
7178 return ret;
7179 }
7180
7181 /*
7182 * Initializing the Rx buffers. For now we are considering only 1
7183 * Rx ring and initializing buffers into 30 Rx blocks
7184 */
7185 mac_control = &sp->mac_control;
7186 config = &sp->config;
7187
7188 for (i = 0; i < config->rx_ring_num; i++) {
7189 mac_control->rings[i].mtu = dev->mtu;
7190 ret = fill_rx_buffers(&mac_control->rings[i], 1);
7191 if (ret) {
7192 DBG_PRINT(ERR_DBG, "%s: Out of memory in Open\n",
7193 dev->name);
7194 s2io_reset(sp);
7195 free_rx_buffers(sp);
7196 return -ENOMEM;
7197 }
7198 DBG_PRINT(INFO_DBG, "Buf in ring:%d is %d:\n", i,
7199 mac_control->rings[i].rx_bufs_left);
7200 }
7201
7202 /* Initialise napi */
7203 if (config->napi) {
7204 int i;
7205 if (config->intr_type == MSI_X) {
7206 for (i = 0; i < sp->config.rx_ring_num; i++)
7207 napi_enable(&sp->mac_control.rings[i].napi);
7208 } else {
7209 napi_enable(&sp->napi);
7210 }
7211 }
7212
7213 /* Maintain the state prior to the open */
7214 if (sp->promisc_flg)
7215 sp->promisc_flg = 0;
7216 if (sp->m_cast_flg) {
7217 sp->m_cast_flg = 0;
7218 sp->all_multi_pos= 0;
7219 }
7220
7221 /* Setting its receive mode */
7222 s2io_set_multicast(dev);
7223
7224 if (sp->lro) {
7225 /* Initialize max aggregatable pkts per session based on MTU */
7226 sp->lro_max_aggr_per_sess = ((1<<16) - 1) / dev->mtu;
7227 /* Check if we can use(if specified) user provided value */
7228 if (lro_max_pkts < sp->lro_max_aggr_per_sess)
7229 sp->lro_max_aggr_per_sess = lro_max_pkts;
7230 }
7231
7232 /* Enable Rx Traffic and interrupts on the NIC */
7233 if (start_nic(sp)) {
7234 DBG_PRINT(ERR_DBG, "%s: Starting NIC failed\n", dev->name);
7235 s2io_reset(sp);
7236 free_rx_buffers(sp);
7237 return -ENODEV;
7238 }
7239
7240 /* Add interrupt service routine */
7241 if (s2io_add_isr(sp) != 0) {
7242 if (sp->config.intr_type == MSI_X)
7243 s2io_rem_isr(sp);
7244 s2io_reset(sp);
7245 free_rx_buffers(sp);
7246 return -ENODEV;
7247 }
7248
7249 S2IO_TIMER_CONF(sp->alarm_timer, s2io_alarm_handle, sp, (HZ/2));
7250
7251 set_bit(__S2IO_STATE_CARD_UP, &sp->state);
7252
7253 /* Enable select interrupts */
7254 en_dis_err_alarms(sp, ENA_ALL_INTRS, ENABLE_INTRS);
7255 if (sp->config.intr_type != INTA) {
7256 interruptible = TX_TRAFFIC_INTR | TX_PIC_INTR;
7257 en_dis_able_nic_intrs(sp, interruptible, ENABLE_INTRS);
7258 } else {
7259 interruptible = TX_TRAFFIC_INTR | RX_TRAFFIC_INTR;
7260 interruptible |= TX_PIC_INTR;
7261 en_dis_able_nic_intrs(sp, interruptible, ENABLE_INTRS);
7262 }
7263
7264 return 0;
7265 }
7266
7267 /**
7268 * s2io_restart_nic - Resets the NIC.
7269 * @data : long pointer to the device private structure
7270 * Description:
7271 * This function is scheduled to be run by the s2io_tx_watchdog
7272 * function after 0.5 secs to reset the NIC. The idea is to reduce
7273 * the run time of the watch dog routine which is run holding a
7274 * spin lock.
7275 */
7276
7277 static void s2io_restart_nic(struct work_struct *work)
7278 {
7279 struct s2io_nic *sp = container_of(work, struct s2io_nic, rst_timer_task);
7280 struct net_device *dev = sp->dev;
7281
7282 rtnl_lock();
7283
7284 if (!netif_running(dev))
7285 goto out_unlock;
7286
7287 s2io_card_down(sp);
7288 if (s2io_card_up(sp)) {
7289 DBG_PRINT(ERR_DBG, "%s: Device bring up failed\n",
7290 dev->name);
7291 }
7292 s2io_wake_all_tx_queue(sp);
7293 DBG_PRINT(ERR_DBG, "%s: was reset by Tx watchdog timer\n",
7294 dev->name);
7295 out_unlock:
7296 rtnl_unlock();
7297 }
7298
7299 /**
7300 * s2io_tx_watchdog - Watchdog for transmit side.
7301 * @dev : Pointer to net device structure
7302 * Description:
7303 * This function is triggered if the Tx Queue is stopped
7304 * for a pre-defined amount of time when the Interface is still up.
7305 * If the Interface is jammed in such a situation, the hardware is
7306 * reset (by s2io_close) and restarted again (by s2io_open) to
7307 * overcome any problem that might have been caused in the hardware.
7308 * Return value:
7309 * void
7310 */
7311
7312 static void s2io_tx_watchdog(struct net_device *dev)
7313 {
7314 struct s2io_nic *sp = dev->priv;
7315
7316 if (netif_carrier_ok(dev)) {
7317 sp->mac_control.stats_info->sw_stat.watchdog_timer_cnt++;
7318 schedule_work(&sp->rst_timer_task);
7319 sp->mac_control.stats_info->sw_stat.soft_reset_cnt++;
7320 }
7321 }
7322
7323 /**
7324 * rx_osm_handler - To perform some OS related operations on SKB.
7325 * @sp: private member of the device structure,pointer to s2io_nic structure.
7326 * @skb : the socket buffer pointer.
7327 * @len : length of the packet
7328 * @cksum : FCS checksum of the frame.
7329 * @ring_no : the ring from which this RxD was extracted.
7330 * Description:
7331 * This function is called by the Rx interrupt serivce routine to perform
7332 * some OS related operations on the SKB before passing it to the upper
7333 * layers. It mainly checks if the checksum is OK, if so adds it to the
7334 * SKBs cksum variable, increments the Rx packet count and passes the SKB
7335 * to the upper layer. If the checksum is wrong, it increments the Rx
7336 * packet error count, frees the SKB and returns error.
7337 * Return value:
7338 * SUCCESS on success and -1 on failure.
7339 */
7340 static int rx_osm_handler(struct ring_info *ring_data, struct RxD_t * rxdp)
7341 {
7342 struct s2io_nic *sp = ring_data->nic;
7343 struct net_device *dev = (struct net_device *) ring_data->dev;
7344 struct sk_buff *skb = (struct sk_buff *)
7345 ((unsigned long) rxdp->Host_Control);
7346 int ring_no = ring_data->ring_no;
7347 u16 l3_csum, l4_csum;
7348 unsigned long long err = rxdp->Control_1 & RXD_T_CODE;
7349 struct lro *lro;
7350 u8 err_mask;
7351
7352 skb->dev = dev;
7353
7354 if (err) {
7355 /* Check for parity error */
7356 if (err & 0x1) {
7357 sp->mac_control.stats_info->sw_stat.parity_err_cnt++;
7358 }
7359 err_mask = err >> 48;
7360 switch(err_mask) {
7361 case 1:
7362 sp->mac_control.stats_info->sw_stat.
7363 rx_parity_err_cnt++;
7364 break;
7365
7366 case 2:
7367 sp->mac_control.stats_info->sw_stat.
7368 rx_abort_cnt++;
7369 break;
7370
7371 case 3:
7372 sp->mac_control.stats_info->sw_stat.
7373 rx_parity_abort_cnt++;
7374 break;
7375
7376 case 4:
7377 sp->mac_control.stats_info->sw_stat.
7378 rx_rda_fail_cnt++;
7379 break;
7380
7381 case 5:
7382 sp->mac_control.stats_info->sw_stat.
7383 rx_unkn_prot_cnt++;
7384 break;
7385
7386 case 6:
7387 sp->mac_control.stats_info->sw_stat.
7388 rx_fcs_err_cnt++;
7389 break;
7390
7391 case 7:
7392 sp->mac_control.stats_info->sw_stat.
7393 rx_buf_size_err_cnt++;
7394 break;
7395
7396 case 8:
7397 sp->mac_control.stats_info->sw_stat.
7398 rx_rxd_corrupt_cnt++;
7399 break;
7400
7401 case 15:
7402 sp->mac_control.stats_info->sw_stat.
7403 rx_unkn_err_cnt++;
7404 break;
7405 }
7406 /*
7407 * Drop the packet if bad transfer code. Exception being
7408 * 0x5, which could be due to unsupported IPv6 extension header.
7409 * In this case, we let stack handle the packet.
7410 * Note that in this case, since checksum will be incorrect,
7411 * stack will validate the same.
7412 */
7413 if (err_mask != 0x5) {
7414 DBG_PRINT(ERR_DBG, "%s: Rx error Value: 0x%x\n",
7415 dev->name, err_mask);
7416 sp->stats.rx_crc_errors++;
7417 sp->mac_control.stats_info->sw_stat.mem_freed
7418 += skb->truesize;
7419 dev_kfree_skb(skb);
7420 ring_data->rx_bufs_left -= 1;
7421 rxdp->Host_Control = 0;
7422 return 0;
7423 }
7424 }
7425
7426 /* Updating statistics */
7427 ring_data->rx_packets++;
7428 rxdp->Host_Control = 0;
7429 if (sp->rxd_mode == RXD_MODE_1) {
7430 int len = RXD_GET_BUFFER0_SIZE_1(rxdp->Control_2);
7431
7432 ring_data->rx_bytes += len;
7433 skb_put(skb, len);
7434
7435 } else if (sp->rxd_mode == RXD_MODE_3B) {
7436 int get_block = ring_data->rx_curr_get_info.block_index;
7437 int get_off = ring_data->rx_curr_get_info.offset;
7438 int buf0_len = RXD_GET_BUFFER0_SIZE_3(rxdp->Control_2);
7439 int buf2_len = RXD_GET_BUFFER2_SIZE_3(rxdp->Control_2);
7440 unsigned char *buff = skb_push(skb, buf0_len);
7441
7442 struct buffAdd *ba = &ring_data->ba[get_block][get_off];
7443 ring_data->rx_bytes += buf0_len + buf2_len;
7444 memcpy(buff, ba->ba_0, buf0_len);
7445 skb_put(skb, buf2_len);
7446 }
7447
7448 if ((rxdp->Control_1 & TCP_OR_UDP_FRAME) && ((!ring_data->lro) ||
7449 (ring_data->lro && (!(rxdp->Control_1 & RXD_FRAME_IP_FRAG)))) &&
7450 (sp->rx_csum)) {
7451 l3_csum = RXD_GET_L3_CKSUM(rxdp->Control_1);
7452 l4_csum = RXD_GET_L4_CKSUM(rxdp->Control_1);
7453 if ((l3_csum == L3_CKSUM_OK) && (l4_csum == L4_CKSUM_OK)) {
7454 /*
7455 * NIC verifies if the Checksum of the received
7456 * frame is Ok or not and accordingly returns
7457 * a flag in the RxD.
7458 */
7459 skb->ip_summed = CHECKSUM_UNNECESSARY;
7460 if (ring_data->lro) {
7461 u32 tcp_len;
7462 u8 *tcp;
7463 int ret = 0;
7464
7465 ret = s2io_club_tcp_session(ring_data,
7466 skb->data, &tcp, &tcp_len, &lro,
7467 rxdp, sp);
7468 switch (ret) {
7469 case 3: /* Begin anew */
7470 lro->parent = skb;
7471 goto aggregate;
7472 case 1: /* Aggregate */
7473 {
7474 lro_append_pkt(sp, lro,
7475 skb, tcp_len);
7476 goto aggregate;
7477 }
7478 case 4: /* Flush session */
7479 {
7480 lro_append_pkt(sp, lro,
7481 skb, tcp_len);
7482 queue_rx_frame(lro->parent,
7483 lro->vlan_tag);
7484 clear_lro_session(lro);
7485 sp->mac_control.stats_info->
7486 sw_stat.flush_max_pkts++;
7487 goto aggregate;
7488 }
7489 case 2: /* Flush both */
7490 lro->parent->data_len =
7491 lro->frags_len;
7492 sp->mac_control.stats_info->
7493 sw_stat.sending_both++;
7494 queue_rx_frame(lro->parent,
7495 lro->vlan_tag);
7496 clear_lro_session(lro);
7497 goto send_up;
7498 case 0: /* sessions exceeded */
7499 case -1: /* non-TCP or not
7500 * L2 aggregatable
7501 */
7502 case 5: /*
7503 * First pkt in session not
7504 * L3/L4 aggregatable
7505 */
7506 break;
7507 default:
7508 DBG_PRINT(ERR_DBG,
7509 "%s: Samadhana!!\n",
7510 __FUNCTION__);
7511 BUG();
7512 }
7513 }
7514 } else {
7515 /*
7516 * Packet with erroneous checksum, let the
7517 * upper layers deal with it.
7518 */
7519 skb->ip_summed = CHECKSUM_NONE;
7520 }
7521 } else
7522 skb->ip_summed = CHECKSUM_NONE;
7523
7524 sp->mac_control.stats_info->sw_stat.mem_freed += skb->truesize;
7525 send_up:
7526 queue_rx_frame(skb, RXD_GET_VLAN_TAG(rxdp->Control_2));
7527 dev->last_rx = jiffies;
7528 aggregate:
7529 sp->mac_control.rings[ring_no].rx_bufs_left -= 1;
7530 return SUCCESS;
7531 }
7532
7533 /**
7534 * s2io_link - stops/starts the Tx queue.
7535 * @sp : private member of the device structure, which is a pointer to the
7536 * s2io_nic structure.
7537 * @link : inidicates whether link is UP/DOWN.
7538 * Description:
7539 * This function stops/starts the Tx queue depending on whether the link
7540 * status of the NIC is is down or up. This is called by the Alarm
7541 * interrupt handler whenever a link change interrupt comes up.
7542 * Return value:
7543 * void.
7544 */
7545
7546 static void s2io_link(struct s2io_nic * sp, int link)
7547 {
7548 struct net_device *dev = (struct net_device *) sp->dev;
7549
7550 if (link != sp->last_link_state) {
7551 init_tti(sp, link);
7552 if (link == LINK_DOWN) {
7553 DBG_PRINT(ERR_DBG, "%s: Link down\n", dev->name);
7554 s2io_stop_all_tx_queue(sp);
7555 netif_carrier_off(dev);
7556 if(sp->mac_control.stats_info->sw_stat.link_up_cnt)
7557 sp->mac_control.stats_info->sw_stat.link_up_time =
7558 jiffies - sp->start_time;
7559 sp->mac_control.stats_info->sw_stat.link_down_cnt++;
7560 } else {
7561 DBG_PRINT(ERR_DBG, "%s: Link Up\n", dev->name);
7562 if (sp->mac_control.stats_info->sw_stat.link_down_cnt)
7563 sp->mac_control.stats_info->sw_stat.link_down_time =
7564 jiffies - sp->start_time;
7565 sp->mac_control.stats_info->sw_stat.link_up_cnt++;
7566 netif_carrier_on(dev);
7567 s2io_wake_all_tx_queue(sp);
7568 }
7569 }
7570 sp->last_link_state = link;
7571 sp->start_time = jiffies;
7572 }
7573
7574 /**
7575 * s2io_init_pci -Initialization of PCI and PCI-X configuration registers .
7576 * @sp : private member of the device structure, which is a pointer to the
7577 * s2io_nic structure.
7578 * Description:
7579 * This function initializes a few of the PCI and PCI-X configuration registers
7580 * with recommended values.
7581 * Return value:
7582 * void
7583 */
7584
7585 static void s2io_init_pci(struct s2io_nic * sp)
7586 {
7587 u16 pci_cmd = 0, pcix_cmd = 0;
7588
7589 /* Enable Data Parity Error Recovery in PCI-X command register. */
7590 pci_read_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
7591 &(pcix_cmd));
7592 pci_write_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
7593 (pcix_cmd | 1));
7594 pci_read_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
7595 &(pcix_cmd));
7596
7597 /* Set the PErr Response bit in PCI command register. */
7598 pci_read_config_word(sp->pdev, PCI_COMMAND, &pci_cmd);
7599 pci_write_config_word(sp->pdev, PCI_COMMAND,
7600 (pci_cmd | PCI_COMMAND_PARITY));
7601 pci_read_config_word(sp->pdev, PCI_COMMAND, &pci_cmd);
7602 }
7603
7604 static int s2io_verify_parm(struct pci_dev *pdev, u8 *dev_intr_type,
7605 u8 *dev_multiq)
7606 {
7607 if ((tx_fifo_num > MAX_TX_FIFOS) ||
7608 (tx_fifo_num < 1)) {
7609 DBG_PRINT(ERR_DBG, "s2io: Requested number of tx fifos "
7610 "(%d) not supported\n", tx_fifo_num);
7611
7612 if (tx_fifo_num < 1)
7613 tx_fifo_num = 1;
7614 else
7615 tx_fifo_num = MAX_TX_FIFOS;
7616
7617 DBG_PRINT(ERR_DBG, "s2io: Default to %d ", tx_fifo_num);
7618 DBG_PRINT(ERR_DBG, "tx fifos\n");
7619 }
7620
7621 if (multiq)
7622 *dev_multiq = multiq;
7623
7624 if (tx_steering_type && (1 == tx_fifo_num)) {
7625 if (tx_steering_type != TX_DEFAULT_STEERING)
7626 DBG_PRINT(ERR_DBG,
7627 "s2io: Tx steering is not supported with "
7628 "one fifo. Disabling Tx steering.\n");
7629 tx_steering_type = NO_STEERING;
7630 }
7631
7632 if ((tx_steering_type < NO_STEERING) ||
7633 (tx_steering_type > TX_DEFAULT_STEERING)) {
7634 DBG_PRINT(ERR_DBG, "s2io: Requested transmit steering not "
7635 "supported\n");
7636 DBG_PRINT(ERR_DBG, "s2io: Disabling transmit steering\n");
7637 tx_steering_type = NO_STEERING;
7638 }
7639
7640 if (rx_ring_num > MAX_RX_RINGS) {
7641 DBG_PRINT(ERR_DBG, "s2io: Requested number of rx rings not "
7642 "supported\n");
7643 DBG_PRINT(ERR_DBG, "s2io: Default to %d rx rings\n",
7644 MAX_RX_RINGS);
7645 rx_ring_num = MAX_RX_RINGS;
7646 }
7647
7648 if ((*dev_intr_type != INTA) && (*dev_intr_type != MSI_X)) {
7649 DBG_PRINT(ERR_DBG, "s2io: Wrong intr_type requested. "
7650 "Defaulting to INTA\n");
7651 *dev_intr_type = INTA;
7652 }
7653
7654 if ((*dev_intr_type == MSI_X) &&
7655 ((pdev->device != PCI_DEVICE_ID_HERC_WIN) &&
7656 (pdev->device != PCI_DEVICE_ID_HERC_UNI))) {
7657 DBG_PRINT(ERR_DBG, "s2io: Xframe I does not support MSI_X. "
7658 "Defaulting to INTA\n");
7659 *dev_intr_type = INTA;
7660 }
7661
7662 if ((rx_ring_mode != 1) && (rx_ring_mode != 2)) {
7663 DBG_PRINT(ERR_DBG, "s2io: Requested ring mode not supported\n");
7664 DBG_PRINT(ERR_DBG, "s2io: Defaulting to 1-buffer mode\n");
7665 rx_ring_mode = 1;
7666 }
7667 return SUCCESS;
7668 }
7669
7670 /**
7671 * rts_ds_steer - Receive traffic steering based on IPv4 or IPv6 TOS
7672 * or Traffic class respectively.
7673 * @nic: device private variable
7674 * Description: The function configures the receive steering to
7675 * desired receive ring.
7676 * Return Value: SUCCESS on success and
7677 * '-1' on failure (endian settings incorrect).
7678 */
7679 static int rts_ds_steer(struct s2io_nic *nic, u8 ds_codepoint, u8 ring)
7680 {
7681 struct XENA_dev_config __iomem *bar0 = nic->bar0;
7682 register u64 val64 = 0;
7683
7684 if (ds_codepoint > 63)
7685 return FAILURE;
7686
7687 val64 = RTS_DS_MEM_DATA(ring);
7688 writeq(val64, &bar0->rts_ds_mem_data);
7689
7690 val64 = RTS_DS_MEM_CTRL_WE |
7691 RTS_DS_MEM_CTRL_STROBE_NEW_CMD |
7692 RTS_DS_MEM_CTRL_OFFSET(ds_codepoint);
7693
7694 writeq(val64, &bar0->rts_ds_mem_ctrl);
7695
7696 return wait_for_cmd_complete(&bar0->rts_ds_mem_ctrl,
7697 RTS_DS_MEM_CTRL_STROBE_CMD_BEING_EXECUTED,
7698 S2IO_BIT_RESET);
7699 }
7700
7701 /**
7702 * s2io_init_nic - Initialization of the adapter .
7703 * @pdev : structure containing the PCI related information of the device.
7704 * @pre: List of PCI devices supported by the driver listed in s2io_tbl.
7705 * Description:
7706 * The function initializes an adapter identified by the pci_dec structure.
7707 * All OS related initialization including memory and device structure and
7708 * initlaization of the device private variable is done. Also the swapper
7709 * control register is initialized to enable read and write into the I/O
7710 * registers of the device.
7711 * Return value:
7712 * returns 0 on success and negative on failure.
7713 */
7714
7715 static int __devinit
7716 s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
7717 {
7718 struct s2io_nic *sp;
7719 struct net_device *dev;
7720 int i, j, ret;
7721 int dma_flag = FALSE;
7722 u32 mac_up, mac_down;
7723 u64 val64 = 0, tmp64 = 0;
7724 struct XENA_dev_config __iomem *bar0 = NULL;
7725 u16 subid;
7726 struct mac_info *mac_control;
7727 struct config_param *config;
7728 int mode;
7729 u8 dev_intr_type = intr_type;
7730 u8 dev_multiq = 0;
7731 DECLARE_MAC_BUF(mac);
7732
7733 ret = s2io_verify_parm(pdev, &dev_intr_type, &dev_multiq);
7734 if (ret)
7735 return ret;
7736
7737 if ((ret = pci_enable_device(pdev))) {
7738 DBG_PRINT(ERR_DBG,
7739 "s2io_init_nic: pci_enable_device failed\n");
7740 return ret;
7741 }
7742
7743 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
7744 DBG_PRINT(INIT_DBG, "s2io_init_nic: Using 64bit DMA\n");
7745 dma_flag = TRUE;
7746 if (pci_set_consistent_dma_mask
7747 (pdev, DMA_64BIT_MASK)) {
7748 DBG_PRINT(ERR_DBG,
7749 "Unable to obtain 64bit DMA for \
7750 consistent allocations\n");
7751 pci_disable_device(pdev);
7752 return -ENOMEM;
7753 }
7754 } else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
7755 DBG_PRINT(INIT_DBG, "s2io_init_nic: Using 32bit DMA\n");
7756 } else {
7757 pci_disable_device(pdev);
7758 return -ENOMEM;
7759 }
7760 if ((ret = pci_request_regions(pdev, s2io_driver_name))) {
7761 DBG_PRINT(ERR_DBG, "%s: Request Regions failed - %x \n", __FUNCTION__, ret);
7762 pci_disable_device(pdev);
7763 return -ENODEV;
7764 }
7765 if (dev_multiq)
7766 dev = alloc_etherdev_mq(sizeof(struct s2io_nic), tx_fifo_num);
7767 else
7768 dev = alloc_etherdev(sizeof(struct s2io_nic));
7769 if (dev == NULL) {
7770 DBG_PRINT(ERR_DBG, "Device allocation failed\n");
7771 pci_disable_device(pdev);
7772 pci_release_regions(pdev);
7773 return -ENODEV;
7774 }
7775
7776 pci_set_master(pdev);
7777 pci_set_drvdata(pdev, dev);
7778 SET_NETDEV_DEV(dev, &pdev->dev);
7779
7780 /* Private member variable initialized to s2io NIC structure */
7781 sp = dev->priv;
7782 memset(sp, 0, sizeof(struct s2io_nic));
7783 sp->dev = dev;
7784 sp->pdev = pdev;
7785 sp->high_dma_flag = dma_flag;
7786 sp->device_enabled_once = FALSE;
7787 if (rx_ring_mode == 1)
7788 sp->rxd_mode = RXD_MODE_1;
7789 if (rx_ring_mode == 2)
7790 sp->rxd_mode = RXD_MODE_3B;
7791
7792 sp->config.intr_type = dev_intr_type;
7793
7794 if ((pdev->device == PCI_DEVICE_ID_HERC_WIN) ||
7795 (pdev->device == PCI_DEVICE_ID_HERC_UNI))
7796 sp->device_type = XFRAME_II_DEVICE;
7797 else
7798 sp->device_type = XFRAME_I_DEVICE;
7799
7800 sp->lro = lro_enable;
7801
7802 /* Initialize some PCI/PCI-X fields of the NIC. */
7803 s2io_init_pci(sp);
7804
7805 /*
7806 * Setting the device configuration parameters.
7807 * Most of these parameters can be specified by the user during
7808 * module insertion as they are module loadable parameters. If
7809 * these parameters are not not specified during load time, they
7810 * are initialized with default values.
7811 */
7812 mac_control = &sp->mac_control;
7813 config = &sp->config;
7814
7815 config->napi = napi;
7816 config->tx_steering_type = tx_steering_type;
7817
7818 /* Tx side parameters. */
7819 if (config->tx_steering_type == TX_PRIORITY_STEERING)
7820 config->tx_fifo_num = MAX_TX_FIFOS;
7821 else
7822 config->tx_fifo_num = tx_fifo_num;
7823
7824 /* Initialize the fifos used for tx steering */
7825 if (config->tx_fifo_num < 5) {
7826 if (config->tx_fifo_num == 1)
7827 sp->total_tcp_fifos = 1;
7828 else
7829 sp->total_tcp_fifos = config->tx_fifo_num - 1;
7830 sp->udp_fifo_idx = config->tx_fifo_num - 1;
7831 sp->total_udp_fifos = 1;
7832 sp->other_fifo_idx = sp->total_tcp_fifos - 1;
7833 } else {
7834 sp->total_tcp_fifos = (tx_fifo_num - FIFO_UDP_MAX_NUM -
7835 FIFO_OTHER_MAX_NUM);
7836 sp->udp_fifo_idx = sp->total_tcp_fifos;
7837 sp->total_udp_fifos = FIFO_UDP_MAX_NUM;
7838 sp->other_fifo_idx = sp->udp_fifo_idx + FIFO_UDP_MAX_NUM;
7839 }
7840
7841 config->multiq = dev_multiq;
7842 for (i = 0; i < config->tx_fifo_num; i++) {
7843 config->tx_cfg[i].fifo_len = tx_fifo_len[i];
7844 config->tx_cfg[i].fifo_priority = i;
7845 }
7846
7847 /* mapping the QoS priority to the configured fifos */
7848 for (i = 0; i < MAX_TX_FIFOS; i++)
7849 config->fifo_mapping[i] = fifo_map[config->tx_fifo_num - 1][i];
7850
7851 /* map the hashing selector table to the configured fifos */
7852 for (i = 0; i < config->tx_fifo_num; i++)
7853 sp->fifo_selector[i] = fifo_selector[i];
7854
7855
7856 config->tx_intr_type = TXD_INT_TYPE_UTILZ;
7857 for (i = 0; i < config->tx_fifo_num; i++) {
7858 config->tx_cfg[i].f_no_snoop =
7859 (NO_SNOOP_TXD | NO_SNOOP_TXD_BUFFER);
7860 if (config->tx_cfg[i].fifo_len < 65) {
7861 config->tx_intr_type = TXD_INT_TYPE_PER_LIST;
7862 break;
7863 }
7864 }
7865 /* + 2 because one Txd for skb->data and one Txd for UFO */
7866 config->max_txds = MAX_SKB_FRAGS + 2;
7867
7868 /* Rx side parameters. */
7869 config->rx_ring_num = rx_ring_num;
7870 for (i = 0; i < config->rx_ring_num; i++) {
7871 config->rx_cfg[i].num_rxd = rx_ring_sz[i] *
7872 (rxd_count[sp->rxd_mode] + 1);
7873 config->rx_cfg[i].ring_priority = i;
7874 mac_control->rings[i].rx_bufs_left = 0;
7875 mac_control->rings[i].rxd_mode = sp->rxd_mode;
7876 mac_control->rings[i].rxd_count = rxd_count[sp->rxd_mode];
7877 mac_control->rings[i].pdev = sp->pdev;
7878 mac_control->rings[i].dev = sp->dev;
7879 }
7880
7881 for (i = 0; i < rx_ring_num; i++) {
7882 config->rx_cfg[i].ring_org = RING_ORG_BUFF1;
7883 config->rx_cfg[i].f_no_snoop =
7884 (NO_SNOOP_RXD | NO_SNOOP_RXD_BUFFER);
7885 }
7886
7887 /* Setting Mac Control parameters */
7888 mac_control->rmac_pause_time = rmac_pause_time;
7889 mac_control->mc_pause_threshold_q0q3 = mc_pause_threshold_q0q3;
7890 mac_control->mc_pause_threshold_q4q7 = mc_pause_threshold_q4q7;
7891
7892
7893 /* initialize the shared memory used by the NIC and the host */
7894 if (init_shared_mem(sp)) {
7895 DBG_PRINT(ERR_DBG, "%s: Memory allocation failed\n",
7896 dev->name);
7897 ret = -ENOMEM;
7898 goto mem_alloc_failed;
7899 }
7900
7901 sp->bar0 = ioremap(pci_resource_start(pdev, 0),
7902 pci_resource_len(pdev, 0));
7903 if (!sp->bar0) {
7904 DBG_PRINT(ERR_DBG, "%s: Neterion: cannot remap io mem1\n",
7905 dev->name);
7906 ret = -ENOMEM;
7907 goto bar0_remap_failed;
7908 }
7909
7910 sp->bar1 = ioremap(pci_resource_start(pdev, 2),
7911 pci_resource_len(pdev, 2));
7912 if (!sp->bar1) {
7913 DBG_PRINT(ERR_DBG, "%s: Neterion: cannot remap io mem2\n",
7914 dev->name);
7915 ret = -ENOMEM;
7916 goto bar1_remap_failed;
7917 }
7918
7919 dev->irq = pdev->irq;
7920 dev->base_addr = (unsigned long) sp->bar0;
7921
7922 /* Initializing the BAR1 address as the start of the FIFO pointer. */
7923 for (j = 0; j < MAX_TX_FIFOS; j++) {
7924 mac_control->tx_FIFO_start[j] = (struct TxFIFO_element __iomem *)
7925 (sp->bar1 + (j * 0x00020000));
7926 }
7927
7928 /* Driver entry points */
7929 dev->open = &s2io_open;
7930 dev->stop = &s2io_close;
7931 dev->hard_start_xmit = &s2io_xmit;
7932 dev->get_stats = &s2io_get_stats;
7933 dev->set_multicast_list = &s2io_set_multicast;
7934 dev->do_ioctl = &s2io_ioctl;
7935 dev->set_mac_address = &s2io_set_mac_addr;
7936 dev->change_mtu = &s2io_change_mtu;
7937 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
7938 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
7939 dev->vlan_rx_register = s2io_vlan_rx_register;
7940 dev->vlan_rx_kill_vid = (void *)s2io_vlan_rx_kill_vid;
7941
7942 /*
7943 * will use eth_mac_addr() for dev->set_mac_address
7944 * mac address will be set every time dev->open() is called
7945 */
7946 #ifdef CONFIG_NET_POLL_CONTROLLER
7947 dev->poll_controller = s2io_netpoll;
7948 #endif
7949
7950 dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
7951 if (sp->high_dma_flag == TRUE)
7952 dev->features |= NETIF_F_HIGHDMA;
7953 dev->features |= NETIF_F_TSO;
7954 dev->features |= NETIF_F_TSO6;
7955 if ((sp->device_type & XFRAME_II_DEVICE) && (ufo)) {
7956 dev->features |= NETIF_F_UFO;
7957 dev->features |= NETIF_F_HW_CSUM;
7958 }
7959 dev->tx_timeout = &s2io_tx_watchdog;
7960 dev->watchdog_timeo = WATCH_DOG_TIMEOUT;
7961 INIT_WORK(&sp->rst_timer_task, s2io_restart_nic);
7962 INIT_WORK(&sp->set_link_task, s2io_set_link);
7963
7964 pci_save_state(sp->pdev);
7965
7966 /* Setting swapper control on the NIC, for proper reset operation */
7967 if (s2io_set_swapper(sp)) {
7968 DBG_PRINT(ERR_DBG, "%s:swapper settings are wrong\n",
7969 dev->name);
7970 ret = -EAGAIN;
7971 goto set_swap_failed;
7972 }
7973
7974 /* Verify if the Herc works on the slot its placed into */
7975 if (sp->device_type & XFRAME_II_DEVICE) {
7976 mode = s2io_verify_pci_mode(sp);
7977 if (mode < 0) {
7978 DBG_PRINT(ERR_DBG, "%s: ", __FUNCTION__);
7979 DBG_PRINT(ERR_DBG, " Unsupported PCI bus mode\n");
7980 ret = -EBADSLT;
7981 goto set_swap_failed;
7982 }
7983 }
7984
7985 if (sp->config.intr_type == MSI_X) {
7986 sp->num_entries = config->rx_ring_num + 1;
7987 ret = s2io_enable_msi_x(sp);
7988
7989 if (!ret) {
7990 ret = s2io_test_msi(sp);
7991 /* rollback MSI-X, will re-enable during add_isr() */
7992 remove_msix_isr(sp);
7993 }
7994 if (ret) {
7995
7996 DBG_PRINT(ERR_DBG,
7997 "%s: MSI-X requested but failed to enable\n",
7998 dev->name);
7999 sp->config.intr_type = INTA;
8000 }
8001 }
8002
8003 if (config->intr_type == MSI_X) {
8004 for (i = 0; i < config->rx_ring_num ; i++)
8005 netif_napi_add(dev, &mac_control->rings[i].napi,
8006 s2io_poll_msix, 64);
8007 } else {
8008 netif_napi_add(dev, &sp->napi, s2io_poll_inta, 64);
8009 }
8010
8011 /* Not needed for Herc */
8012 if (sp->device_type & XFRAME_I_DEVICE) {
8013 /*
8014 * Fix for all "FFs" MAC address problems observed on
8015 * Alpha platforms
8016 */
8017 fix_mac_address(sp);
8018 s2io_reset(sp);
8019 }
8020
8021 /*
8022 * MAC address initialization.
8023 * For now only one mac address will be read and used.
8024 */
8025 bar0 = sp->bar0;
8026 val64 = RMAC_ADDR_CMD_MEM_RD | RMAC_ADDR_CMD_MEM_STROBE_NEW_CMD |
8027 RMAC_ADDR_CMD_MEM_OFFSET(0 + S2IO_MAC_ADDR_START_OFFSET);
8028 writeq(val64, &bar0->rmac_addr_cmd_mem);
8029 wait_for_cmd_complete(&bar0->rmac_addr_cmd_mem,
8030 RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING, S2IO_BIT_RESET);
8031 tmp64 = readq(&bar0->rmac_addr_data0_mem);
8032 mac_down = (u32) tmp64;
8033 mac_up = (u32) (tmp64 >> 32);
8034
8035 sp->def_mac_addr[0].mac_addr[3] = (u8) (mac_up);
8036 sp->def_mac_addr[0].mac_addr[2] = (u8) (mac_up >> 8);
8037 sp->def_mac_addr[0].mac_addr[1] = (u8) (mac_up >> 16);
8038 sp->def_mac_addr[0].mac_addr[0] = (u8) (mac_up >> 24);
8039 sp->def_mac_addr[0].mac_addr[5] = (u8) (mac_down >> 16);
8040 sp->def_mac_addr[0].mac_addr[4] = (u8) (mac_down >> 24);
8041
8042 /* Set the factory defined MAC address initially */
8043 dev->addr_len = ETH_ALEN;
8044 memcpy(dev->dev_addr, sp->def_mac_addr, ETH_ALEN);
8045 memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);
8046
8047 /* initialize number of multicast & unicast MAC entries variables */
8048 if (sp->device_type == XFRAME_I_DEVICE) {
8049 config->max_mc_addr = S2IO_XENA_MAX_MC_ADDRESSES;
8050 config->max_mac_addr = S2IO_XENA_MAX_MAC_ADDRESSES;
8051 config->mc_start_offset = S2IO_XENA_MC_ADDR_START_OFFSET;
8052 } else if (sp->device_type == XFRAME_II_DEVICE) {
8053 config->max_mc_addr = S2IO_HERC_MAX_MC_ADDRESSES;
8054 config->max_mac_addr = S2IO_HERC_MAX_MAC_ADDRESSES;
8055 config->mc_start_offset = S2IO_HERC_MC_ADDR_START_OFFSET;
8056 }
8057
8058 /* store mac addresses from CAM to s2io_nic structure */
8059 do_s2io_store_unicast_mc(sp);
8060
8061 /* Configure MSIX vector for number of rings configured plus one */
8062 if ((sp->device_type == XFRAME_II_DEVICE) &&
8063 (config->intr_type == MSI_X))
8064 sp->num_entries = config->rx_ring_num + 1;
8065
8066 /* Store the values of the MSIX table in the s2io_nic structure */
8067 store_xmsi_data(sp);
8068 /* reset Nic and bring it to known state */
8069 s2io_reset(sp);
8070
8071 /*
8072 * Initialize link state flags
8073 * and the card state parameter
8074 */
8075 sp->state = 0;
8076
8077 /* Initialize spinlocks */
8078 for (i = 0; i < sp->config.tx_fifo_num; i++)
8079 spin_lock_init(&mac_control->fifos[i].tx_lock);
8080
8081 /*
8082 * SXE-002: Configure link and activity LED to init state
8083 * on driver load.
8084 */
8085 subid = sp->pdev->subsystem_device;
8086 if ((subid & 0xFF) >= 0x07) {
8087 val64 = readq(&bar0->gpio_control);
8088 val64 |= 0x0000800000000000ULL;
8089 writeq(val64, &bar0->gpio_control);
8090 val64 = 0x0411040400000000ULL;
8091 writeq(val64, (void __iomem *) bar0 + 0x2700);
8092 val64 = readq(&bar0->gpio_control);
8093 }
8094
8095 sp->rx_csum = 1; /* Rx chksum verify enabled by default */
8096
8097 if (register_netdev(dev)) {
8098 DBG_PRINT(ERR_DBG, "Device registration failed\n");
8099 ret = -ENODEV;
8100 goto register_failed;
8101 }
8102 s2io_vpd_read(sp);
8103 DBG_PRINT(ERR_DBG, "Copyright(c) 2002-2007 Neterion Inc.\n");
8104 DBG_PRINT(ERR_DBG, "%s: Neterion %s (rev %d)\n",dev->name,
8105 sp->product_name, pdev->revision);
8106 DBG_PRINT(ERR_DBG, "%s: Driver version %s\n", dev->name,
8107 s2io_driver_version);
8108 DBG_PRINT(ERR_DBG, "%s: MAC ADDR: %s\n",
8109 dev->name, print_mac(mac, dev->dev_addr));
8110 DBG_PRINT(ERR_DBG, "SERIAL NUMBER: %s\n", sp->serial_num);
8111 if (sp->device_type & XFRAME_II_DEVICE) {
8112 mode = s2io_print_pci_mode(sp);
8113 if (mode < 0) {
8114 DBG_PRINT(ERR_DBG, " Unsupported PCI bus mode\n");
8115 ret = -EBADSLT;
8116 unregister_netdev(dev);
8117 goto set_swap_failed;
8118 }
8119 }
8120 switch(sp->rxd_mode) {
8121 case RXD_MODE_1:
8122 DBG_PRINT(ERR_DBG, "%s: 1-Buffer receive mode enabled\n",
8123 dev->name);
8124 break;
8125 case RXD_MODE_3B:
8126 DBG_PRINT(ERR_DBG, "%s: 2-Buffer receive mode enabled\n",
8127 dev->name);
8128 break;
8129 }
8130
8131 switch (sp->config.napi) {
8132 case 0:
8133 DBG_PRINT(ERR_DBG, "%s: NAPI disabled\n", dev->name);
8134 break;
8135 case 1:
8136 DBG_PRINT(ERR_DBG, "%s: NAPI enabled\n", dev->name);
8137 break;
8138 }
8139
8140 DBG_PRINT(ERR_DBG, "%s: Using %d Tx fifo(s)\n", dev->name,
8141 sp->config.tx_fifo_num);
8142
8143 DBG_PRINT(ERR_DBG, "%s: Using %d Rx ring(s)\n", dev->name,
8144 sp->config.rx_ring_num);
8145
8146 switch(sp->config.intr_type) {
8147 case INTA:
8148 DBG_PRINT(ERR_DBG, "%s: Interrupt type INTA\n", dev->name);
8149 break;
8150 case MSI_X:
8151 DBG_PRINT(ERR_DBG, "%s: Interrupt type MSI-X\n", dev->name);
8152 break;
8153 }
8154 if (sp->config.multiq) {
8155 for (i = 0; i < sp->config.tx_fifo_num; i++)
8156 mac_control->fifos[i].multiq = config->multiq;
8157 DBG_PRINT(ERR_DBG, "%s: Multiqueue support enabled\n",
8158 dev->name);
8159 } else
8160 DBG_PRINT(ERR_DBG, "%s: Multiqueue support disabled\n",
8161 dev->name);
8162
8163 switch (sp->config.tx_steering_type) {
8164 case NO_STEERING:
8165 DBG_PRINT(ERR_DBG, "%s: No steering enabled for"
8166 " transmit\n", dev->name);
8167 break;
8168 case TX_PRIORITY_STEERING:
8169 DBG_PRINT(ERR_DBG, "%s: Priority steering enabled for"
8170 " transmit\n", dev->name);
8171 break;
8172 case TX_DEFAULT_STEERING:
8173 DBG_PRINT(ERR_DBG, "%s: Default steering enabled for"
8174 " transmit\n", dev->name);
8175 }
8176
8177 if (sp->lro)
8178 DBG_PRINT(ERR_DBG, "%s: Large receive offload enabled\n",
8179 dev->name);
8180 if (ufo)
8181 DBG_PRINT(ERR_DBG, "%s: UDP Fragmentation Offload(UFO)"
8182 " enabled\n", dev->name);
8183 /* Initialize device name */
8184 sprintf(sp->name, "%s Neterion %s", dev->name, sp->product_name);
8185
8186 /*
8187 * Make Link state as off at this point, when the Link change
8188 * interrupt comes the state will be automatically changed to
8189 * the right state.
8190 */
8191 netif_carrier_off(dev);
8192
8193 return 0;
8194
8195 register_failed:
8196 set_swap_failed:
8197 iounmap(sp->bar1);
8198 bar1_remap_failed:
8199 iounmap(sp->bar0);
8200 bar0_remap_failed:
8201 mem_alloc_failed:
8202 free_shared_mem(sp);
8203 pci_disable_device(pdev);
8204 pci_release_regions(pdev);
8205 pci_set_drvdata(pdev, NULL);
8206 free_netdev(dev);
8207
8208 return ret;
8209 }
8210
8211 /**
8212 * s2io_rem_nic - Free the PCI device
8213 * @pdev: structure containing the PCI related information of the device.
8214 * Description: This function is called by the Pci subsystem to release a
8215 * PCI device and free up all resource held up by the device. This could
8216 * be in response to a Hot plug event or when the driver is to be removed
8217 * from memory.
8218 */
8219
8220 static void __devexit s2io_rem_nic(struct pci_dev *pdev)
8221 {
8222 struct net_device *dev =
8223 (struct net_device *) pci_get_drvdata(pdev);
8224 struct s2io_nic *sp;
8225
8226 if (dev == NULL) {
8227 DBG_PRINT(ERR_DBG, "Driver Data is NULL!!\n");
8228 return;
8229 }
8230
8231 flush_scheduled_work();
8232
8233 sp = dev->priv;
8234 unregister_netdev(dev);
8235
8236 free_shared_mem(sp);
8237 iounmap(sp->bar0);
8238 iounmap(sp->bar1);
8239 pci_release_regions(pdev);
8240 pci_set_drvdata(pdev, NULL);
8241 free_netdev(dev);
8242 pci_disable_device(pdev);
8243 }
8244
8245 /**
8246 * s2io_starter - Entry point for the driver
8247 * Description: This function is the entry point for the driver. It verifies
8248 * the module loadable parameters and initializes PCI configuration space.
8249 */
8250
8251 static int __init s2io_starter(void)
8252 {
8253 return pci_register_driver(&s2io_driver);
8254 }
8255
8256 /**
8257 * s2io_closer - Cleanup routine for the driver
8258 * Description: This function is the cleanup routine for the driver. It unregist * ers the driver.
8259 */
8260
8261 static __exit void s2io_closer(void)
8262 {
8263 pci_unregister_driver(&s2io_driver);
8264 DBG_PRINT(INIT_DBG, "cleanup done\n");
8265 }
8266
8267 module_init(s2io_starter);
8268 module_exit(s2io_closer);
8269
8270 static int check_L2_lro_capable(u8 *buffer, struct iphdr **ip,
8271 struct tcphdr **tcp, struct RxD_t *rxdp,
8272 struct s2io_nic *sp)
8273 {
8274 int ip_off;
8275 u8 l2_type = (u8)((rxdp->Control_1 >> 37) & 0x7), ip_len;
8276
8277 if (!(rxdp->Control_1 & RXD_FRAME_PROTO_TCP)) {
8278 DBG_PRINT(INIT_DBG,"%s: Non-TCP frames not supported for LRO\n",
8279 __FUNCTION__);
8280 return -1;
8281 }
8282
8283 /* Checking for DIX type or DIX type with VLAN */
8284 if ((l2_type == 0)
8285 || (l2_type == 4)) {
8286 ip_off = HEADER_ETHERNET_II_802_3_SIZE;
8287 /*
8288 * If vlan stripping is disabled and the frame is VLAN tagged,
8289 * shift the offset by the VLAN header size bytes.
8290 */
8291 if ((!vlan_strip_flag) &&
8292 (rxdp->Control_1 & RXD_FRAME_VLAN_TAG))
8293 ip_off += HEADER_VLAN_SIZE;
8294 } else {
8295 /* LLC, SNAP etc are considered non-mergeable */
8296 return -1;
8297 }
8298
8299 *ip = (struct iphdr *)((u8 *)buffer + ip_off);
8300 ip_len = (u8)((*ip)->ihl);
8301 ip_len <<= 2;
8302 *tcp = (struct tcphdr *)((unsigned long)*ip + ip_len);
8303
8304 return 0;
8305 }
8306
8307 static int check_for_socket_match(struct lro *lro, struct iphdr *ip,
8308 struct tcphdr *tcp)
8309 {
8310 DBG_PRINT(INFO_DBG,"%s: Been here...\n", __FUNCTION__);
8311 if ((lro->iph->saddr != ip->saddr) || (lro->iph->daddr != ip->daddr) ||
8312 (lro->tcph->source != tcp->source) || (lro->tcph->dest != tcp->dest))
8313 return -1;
8314 return 0;
8315 }
8316
8317 static inline int get_l4_pyld_length(struct iphdr *ip, struct tcphdr *tcp)
8318 {
8319 return(ntohs(ip->tot_len) - (ip->ihl << 2) - (tcp->doff << 2));
8320 }
8321
8322 static void initiate_new_session(struct lro *lro, u8 *l2h,
8323 struct iphdr *ip, struct tcphdr *tcp, u32 tcp_pyld_len, u16 vlan_tag)
8324 {
8325 DBG_PRINT(INFO_DBG,"%s: Been here...\n", __FUNCTION__);
8326 lro->l2h = l2h;
8327 lro->iph = ip;
8328 lro->tcph = tcp;
8329 lro->tcp_next_seq = tcp_pyld_len + ntohl(tcp->seq);
8330 lro->tcp_ack = tcp->ack_seq;
8331 lro->sg_num = 1;
8332 lro->total_len = ntohs(ip->tot_len);
8333 lro->frags_len = 0;
8334 lro->vlan_tag = vlan_tag;
8335 /*
8336 * check if we saw TCP timestamp. Other consistency checks have
8337 * already been done.
8338 */
8339 if (tcp->doff == 8) {
8340 __be32 *ptr;
8341 ptr = (__be32 *)(tcp+1);
8342 lro->saw_ts = 1;
8343 lro->cur_tsval = ntohl(*(ptr+1));
8344 lro->cur_tsecr = *(ptr+2);
8345 }
8346 lro->in_use = 1;
8347 }
8348
8349 static void update_L3L4_header(struct s2io_nic *sp, struct lro *lro)
8350 {
8351 struct iphdr *ip = lro->iph;
8352 struct tcphdr *tcp = lro->tcph;
8353 __sum16 nchk;
8354 struct stat_block *statinfo = sp->mac_control.stats_info;
8355 DBG_PRINT(INFO_DBG,"%s: Been here...\n", __FUNCTION__);
8356
8357 /* Update L3 header */
8358 ip->tot_len = htons(lro->total_len);
8359 ip->check = 0;
8360 nchk = ip_fast_csum((u8 *)lro->iph, ip->ihl);
8361 ip->check = nchk;
8362
8363 /* Update L4 header */
8364 tcp->ack_seq = lro->tcp_ack;
8365 tcp->window = lro->window;
8366
8367 /* Update tsecr field if this session has timestamps enabled */
8368 if (lro->saw_ts) {
8369 __be32 *ptr = (__be32 *)(tcp + 1);
8370 *(ptr+2) = lro->cur_tsecr;
8371 }
8372
8373 /* Update counters required for calculation of
8374 * average no. of packets aggregated.
8375 */
8376 statinfo->sw_stat.sum_avg_pkts_aggregated += lro->sg_num;
8377 statinfo->sw_stat.num_aggregations++;
8378 }
8379
8380 static void aggregate_new_rx(struct lro *lro, struct iphdr *ip,
8381 struct tcphdr *tcp, u32 l4_pyld)
8382 {
8383 DBG_PRINT(INFO_DBG,"%s: Been here...\n", __FUNCTION__);
8384 lro->total_len += l4_pyld;
8385 lro->frags_len += l4_pyld;
8386 lro->tcp_next_seq += l4_pyld;
8387 lro->sg_num++;
8388
8389 /* Update ack seq no. and window ad(from this pkt) in LRO object */
8390 lro->tcp_ack = tcp->ack_seq;
8391 lro->window = tcp->window;
8392
8393 if (lro->saw_ts) {
8394 __be32 *ptr;
8395 /* Update tsecr and tsval from this packet */
8396 ptr = (__be32 *)(tcp+1);
8397 lro->cur_tsval = ntohl(*(ptr+1));
8398 lro->cur_tsecr = *(ptr + 2);
8399 }
8400 }
8401
8402 static int verify_l3_l4_lro_capable(struct lro *l_lro, struct iphdr *ip,
8403 struct tcphdr *tcp, u32 tcp_pyld_len)
8404 {
8405 u8 *ptr;
8406
8407 DBG_PRINT(INFO_DBG,"%s: Been here...\n", __FUNCTION__);
8408
8409 if (!tcp_pyld_len) {
8410 /* Runt frame or a pure ack */
8411 return -1;
8412 }
8413
8414 if (ip->ihl != 5) /* IP has options */
8415 return -1;
8416
8417 /* If we see CE codepoint in IP header, packet is not mergeable */
8418 if (INET_ECN_is_ce(ipv4_get_dsfield(ip)))
8419 return -1;
8420
8421 /* If we see ECE or CWR flags in TCP header, packet is not mergeable */
8422 if (tcp->urg || tcp->psh || tcp->rst || tcp->syn || tcp->fin ||
8423 tcp->ece || tcp->cwr || !tcp->ack) {
8424 /*
8425 * Currently recognize only the ack control word and
8426 * any other control field being set would result in
8427 * flushing the LRO session
8428 */
8429 return -1;
8430 }
8431
8432 /*
8433 * Allow only one TCP timestamp option. Don't aggregate if
8434 * any other options are detected.
8435 */
8436 if (tcp->doff != 5 && tcp->doff != 8)
8437 return -1;
8438
8439 if (tcp->doff == 8) {
8440 ptr = (u8 *)(tcp + 1);
8441 while (*ptr == TCPOPT_NOP)
8442 ptr++;
8443 if (*ptr != TCPOPT_TIMESTAMP || *(ptr+1) != TCPOLEN_TIMESTAMP)
8444 return -1;
8445
8446 /* Ensure timestamp value increases monotonically */
8447 if (l_lro)
8448 if (l_lro->cur_tsval > ntohl(*((__be32 *)(ptr+2))))
8449 return -1;
8450
8451 /* timestamp echo reply should be non-zero */
8452 if (*((__be32 *)(ptr+6)) == 0)
8453 return -1;
8454 }
8455
8456 return 0;
8457 }
8458
8459 static int
8460 s2io_club_tcp_session(struct ring_info *ring_data, u8 *buffer, u8 **tcp,
8461 u32 *tcp_len, struct lro **lro, struct RxD_t *rxdp,
8462 struct s2io_nic *sp)
8463 {
8464 struct iphdr *ip;
8465 struct tcphdr *tcph;
8466 int ret = 0, i;
8467 u16 vlan_tag = 0;
8468
8469 if (!(ret = check_L2_lro_capable(buffer, &ip, (struct tcphdr **)tcp,
8470 rxdp, sp))) {
8471 DBG_PRINT(INFO_DBG,"IP Saddr: %x Daddr: %x\n",
8472 ip->saddr, ip->daddr);
8473 } else
8474 return ret;
8475
8476 vlan_tag = RXD_GET_VLAN_TAG(rxdp->Control_2);
8477 tcph = (struct tcphdr *)*tcp;
8478 *tcp_len = get_l4_pyld_length(ip, tcph);
8479 for (i=0; i<MAX_LRO_SESSIONS; i++) {
8480 struct lro *l_lro = &ring_data->lro0_n[i];
8481 if (l_lro->in_use) {
8482 if (check_for_socket_match(l_lro, ip, tcph))
8483 continue;
8484 /* Sock pair matched */
8485 *lro = l_lro;
8486
8487 if ((*lro)->tcp_next_seq != ntohl(tcph->seq)) {
8488 DBG_PRINT(INFO_DBG, "%s:Out of order. expected "
8489 "0x%x, actual 0x%x\n", __FUNCTION__,
8490 (*lro)->tcp_next_seq,
8491 ntohl(tcph->seq));
8492
8493 sp->mac_control.stats_info->
8494 sw_stat.outof_sequence_pkts++;
8495 ret = 2;
8496 break;
8497 }
8498
8499 if (!verify_l3_l4_lro_capable(l_lro, ip, tcph,*tcp_len))
8500 ret = 1; /* Aggregate */
8501 else
8502 ret = 2; /* Flush both */
8503 break;
8504 }
8505 }
8506
8507 if (ret == 0) {
8508 /* Before searching for available LRO objects,
8509 * check if the pkt is L3/L4 aggregatable. If not
8510 * don't create new LRO session. Just send this
8511 * packet up.
8512 */
8513 if (verify_l3_l4_lro_capable(NULL, ip, tcph, *tcp_len)) {
8514 return 5;
8515 }
8516
8517 for (i=0; i<MAX_LRO_SESSIONS; i++) {
8518 struct lro *l_lro = &ring_data->lro0_n[i];
8519 if (!(l_lro->in_use)) {
8520 *lro = l_lro;
8521 ret = 3; /* Begin anew */
8522 break;
8523 }
8524 }
8525 }
8526
8527 if (ret == 0) { /* sessions exceeded */
8528 DBG_PRINT(INFO_DBG,"%s:All LRO sessions already in use\n",
8529 __FUNCTION__);
8530 *lro = NULL;
8531 return ret;
8532 }
8533
8534 switch (ret) {
8535 case 3:
8536 initiate_new_session(*lro, buffer, ip, tcph, *tcp_len,
8537 vlan_tag);
8538 break;
8539 case 2:
8540 update_L3L4_header(sp, *lro);
8541 break;
8542 case 1:
8543 aggregate_new_rx(*lro, ip, tcph, *tcp_len);
8544 if ((*lro)->sg_num == sp->lro_max_aggr_per_sess) {
8545 update_L3L4_header(sp, *lro);
8546 ret = 4; /* Flush the LRO */
8547 }
8548 break;
8549 default:
8550 DBG_PRINT(ERR_DBG,"%s:Dont know, can't say!!\n",
8551 __FUNCTION__);
8552 break;
8553 }
8554
8555 return ret;
8556 }
8557
8558 static void clear_lro_session(struct lro *lro)
8559 {
8560 static u16 lro_struct_size = sizeof(struct lro);
8561
8562 memset(lro, 0, lro_struct_size);
8563 }
8564
8565 static void queue_rx_frame(struct sk_buff *skb, u16 vlan_tag)
8566 {
8567 struct net_device *dev = skb->dev;
8568 struct s2io_nic *sp = dev->priv;
8569
8570 skb->protocol = eth_type_trans(skb, dev);
8571 if (sp->vlgrp && vlan_tag
8572 && (vlan_strip_flag)) {
8573 /* Queueing the vlan frame to the upper layer */
8574 if (sp->config.napi)
8575 vlan_hwaccel_receive_skb(skb, sp->vlgrp, vlan_tag);
8576 else
8577 vlan_hwaccel_rx(skb, sp->vlgrp, vlan_tag);
8578 } else {
8579 if (sp->config.napi)
8580 netif_receive_skb(skb);
8581 else
8582 netif_rx(skb);
8583 }
8584 }
8585
8586 static void lro_append_pkt(struct s2io_nic *sp, struct lro *lro,
8587 struct sk_buff *skb,
8588 u32 tcp_len)
8589 {
8590 struct sk_buff *first = lro->parent;
8591
8592 first->len += tcp_len;
8593 first->data_len = lro->frags_len;
8594 skb_pull(skb, (skb->len - tcp_len));
8595 if (skb_shinfo(first)->frag_list)
8596 lro->last_frag->next = skb;
8597 else
8598 skb_shinfo(first)->frag_list = skb;
8599 first->truesize += skb->truesize;
8600 lro->last_frag = skb;
8601 sp->mac_control.stats_info->sw_stat.clubbed_frms_cnt++;
8602 return;
8603 }
8604
8605 /**
8606 * s2io_io_error_detected - called when PCI error is detected
8607 * @pdev: Pointer to PCI device
8608 * @state: The current pci connection state
8609 *
8610 * This function is called after a PCI bus error affecting
8611 * this device has been detected.
8612 */
8613 static pci_ers_result_t s2io_io_error_detected(struct pci_dev *pdev,
8614 pci_channel_state_t state)
8615 {
8616 struct net_device *netdev = pci_get_drvdata(pdev);
8617 struct s2io_nic *sp = netdev->priv;
8618
8619 netif_device_detach(netdev);
8620
8621 if (netif_running(netdev)) {
8622 /* Bring down the card, while avoiding PCI I/O */
8623 do_s2io_card_down(sp, 0);
8624 }
8625 pci_disable_device(pdev);
8626
8627 return PCI_ERS_RESULT_NEED_RESET;
8628 }
8629
8630 /**
8631 * s2io_io_slot_reset - called after the pci bus has been reset.
8632 * @pdev: Pointer to PCI device
8633 *
8634 * Restart the card from scratch, as if from a cold-boot.
8635 * At this point, the card has exprienced a hard reset,
8636 * followed by fixups by BIOS, and has its config space
8637 * set up identically to what it was at cold boot.
8638 */
8639 static pci_ers_result_t s2io_io_slot_reset(struct pci_dev *pdev)
8640 {
8641 struct net_device *netdev = pci_get_drvdata(pdev);
8642 struct s2io_nic *sp = netdev->priv;
8643
8644 if (pci_enable_device(pdev)) {
8645 printk(KERN_ERR "s2io: "
8646 "Cannot re-enable PCI device after reset.\n");
8647 return PCI_ERS_RESULT_DISCONNECT;
8648 }
8649
8650 pci_set_master(pdev);
8651 s2io_reset(sp);
8652
8653 return PCI_ERS_RESULT_RECOVERED;
8654 }
8655
8656 /**
8657 * s2io_io_resume - called when traffic can start flowing again.
8658 * @pdev: Pointer to PCI device
8659 *
8660 * This callback is called when the error recovery driver tells
8661 * us that its OK to resume normal operation.
8662 */
8663 static void s2io_io_resume(struct pci_dev *pdev)
8664 {
8665 struct net_device *netdev = pci_get_drvdata(pdev);
8666 struct s2io_nic *sp = netdev->priv;
8667
8668 if (netif_running(netdev)) {
8669 if (s2io_card_up(sp)) {
8670 printk(KERN_ERR "s2io: "
8671 "Can't bring device back up after reset.\n");
8672 return;
8673 }
8674
8675 if (s2io_set_mac_addr(netdev, netdev->dev_addr) == FAILURE) {
8676 s2io_card_down(sp);
8677 printk(KERN_ERR "s2io: "
8678 "Can't resetore mac addr after reset.\n");
8679 return;
8680 }
8681 }
8682
8683 netif_device_attach(netdev);
8684 netif_tx_wake_all_queues(netdev);
8685 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree