git.oblomov.eu Git - linux-2.6/blob - drivers/net/s2io.c

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