Lines Matching refs:sp
124 static inline int is_s2io_card_up(const struct s2io_nic *sp)
126 return test_bit(__S2IO_STATE_CARD_UP, &sp->state);
349 static void do_s2io_copy_mac_addr(struct s2io_nic *sp, int offset, u64 mac_addr)
351 sp->def_mac_addr[offset].mac_addr[5] = (u8) (mac_addr);
352 sp->def_mac_addr[offset].mac_addr[4] = (u8) (mac_addr >> 8);
353 sp->def_mac_addr[offset].mac_addr[3] = (u8) (mac_addr >> 16);
354 sp->def_mac_addr[offset].mac_addr[2] = (u8) (mac_addr >> 24);
355 sp->def_mac_addr[offset].mac_addr[1] = (u8) (mac_addr >> 32);
356 sp->def_mac_addr[offset].mac_addr[0] = (u8) (mac_addr >> 40);
506 static inline void s2io_stop_all_tx_queue(struct s2io_nic *sp)
508 if (!sp->config.multiq) {
511 for (i = 0; i < sp->config.tx_fifo_num; i++)
512 sp->mac_control.fifos[i].queue_state = FIFO_QUEUE_STOP;
514 netif_tx_stop_all_queues(sp->dev);
517 static inline void s2io_stop_tx_queue(struct s2io_nic *sp, int fifo_no)
519 if (!sp->config.multiq)
520 sp->mac_control.fifos[fifo_no].queue_state =
523 netif_tx_stop_all_queues(sp->dev);
526 static inline void s2io_start_all_tx_queue(struct s2io_nic *sp)
528 if (!sp->config.multiq) {
531 for (i = 0; i < sp->config.tx_fifo_num; i++)
532 sp->mac_control.fifos[i].queue_state = FIFO_QUEUE_START;
534 netif_tx_start_all_queues(sp->dev);
537 static inline void s2io_wake_all_tx_queue(struct s2io_nic *sp)
539 if (!sp->config.multiq) {
542 for (i = 0; i < sp->config.tx_fifo_num; i++)
543 sp->mac_control.fifos[i].queue_state = FIFO_QUEUE_START;
545 netif_tx_wake_all_queues(sp->dev);
2079 static int verify_pcc_quiescent(struct s2io_nic *sp, int flag)
2082 struct XENA_dev_config __iomem *bar0 = sp->bar0;
2085 herc = (sp->device_type == XFRAME_II_DEVICE);
2088 if ((!herc && (sp->pdev->revision >= 4)) || herc) {
2096 if ((!herc && (sp->pdev->revision >= 4)) || herc) {
2119 static int verify_xena_quiescence(struct s2io_nic *sp)
2122 struct XENA_dev_config __iomem *bar0 = sp->bar0;
2124 mode = s2io_verify_pci_mode(sp);
2165 sp->device_type == XFRAME_II_DEVICE &&
2180 * @sp: Pointer to device specifc structure
2186 static void fix_mac_address(struct s2io_nic *sp)
2188 struct XENA_dev_config __iomem *bar0 = sp->bar0;
2665 static void free_rxd_blk(struct s2io_nic *sp, int ring_no, int blk)
2667 struct net_device *dev = sp->dev;
2673 struct mac_info *mac_control = &sp->mac_control;
2677 for (j = 0 ; j < rxd_count[sp->rxd_mode]; j++) {
2683 if (sp->rxd_mode == RXD_MODE_1) {
2685 pci_unmap_single(sp->pdev,
2692 } else if (sp->rxd_mode == RXD_MODE_3B) {
2694 pci_unmap_single(sp->pdev,
2698 pci_unmap_single(sp->pdev,
2702 pci_unmap_single(sp->pdev,
2716 * @sp: device private variable.
2723 static void free_rx_buffers(struct s2io_nic *sp)
2725 struct net_device *dev = sp->dev;
2727 struct config_param *config = &sp->config;
2728 struct mac_info *mac_control = &sp->mac_control;
2734 free_rxd_blk(sp, i, blk);
3099 struct s2io_nic *sp = netdev_priv(dev);
3100 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3145 struct s2io_nic *sp = netdev_priv(dev);
3146 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3247 struct s2io_nic *sp = netdev_priv(dev);
3248 struct stat_block *stats = sp->mac_control.stats_info;
3333 * @sp : private member of the device structure, which is a pointer to the
3397 * @sp : private member of the device structure.
3405 static void s2io_reset(struct s2io_nic *sp)
3407 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3418 __func__, pci_name(sp->pdev));
3421 pci_read_config_word(sp->pdev, PCIX_COMMAND_REGISTER, &(pci_cmd));
3425 if (strstr(sp->product_name, "CX4"))
3431 pci_restore_state(sp->pdev);
3432 pci_save_state(sp->pdev);
3433 pci_read_config_word(sp->pdev, 0x2, &val16);
3442 pci_write_config_word(sp->pdev, PCIX_COMMAND_REGISTER, pci_cmd);
3444 s2io_init_pci(sp);
3447 s2io_set_swapper(sp);
3450 do_s2io_restore_unicast_mc(sp);
3453 restore_xmsi_data(sp);
3456 if (sp->device_type == XFRAME_II_DEVICE) {
3458 pci_write_config_word(sp->pdev, PCI_STATUS, 0x8000);
3461 pci_write_config_dword(sp->pdev, 0x68, 0x7C);
3468 memset(&sp->stats, 0, sizeof(struct net_device_stats));
3470 stats = sp->mac_control.stats_info;
3496 subid = sp->pdev->subsystem_device;
3498 (sp->device_type == XFRAME_I_DEVICE)) {
3510 if (sp->device_type == XFRAME_II_DEVICE) {
3515 sp->device_enabled_once = false;
3520 * @sp : private member of the device structure,
3528 static int s2io_set_swapper(struct s2io_nic *sp)
3530 struct net_device *dev = sp->dev;
3531 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3614 if (sp->config.intr_type == INTA)
3638 if (sp->config.intr_type == INTA)
3819 struct s2io_nic *sp = dev_id;
3821 sp->msi_detected = 1;
3822 wake_up(&sp->msi_wait);
3828 static int s2io_test_msi(struct s2io_nic *sp)
3830 struct pci_dev *pdev = sp->pdev;
3831 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3835 err = request_irq(sp->entries[1].vector, s2io_test_intr, 0,
3836 sp->name, sp);
3839 sp->dev->name, pci_name(pdev), pdev->irq);
3843 init_waitqueue_head(&sp->msi_wait);
3844 sp->msi_detected = 0;
3852 wait_event_timeout(sp->msi_wait, sp->msi_detected, HZ/10);
3854 if (!sp->msi_detected) {
3858 sp->dev->name, pci_name(pdev));
3863 free_irq(sp->entries[1].vector, sp);
3870 static void remove_msix_isr(struct s2io_nic *sp)
3875 for (i = 0; i < sp->num_entries; i++) {
3876 if (sp->s2io_entries[i].in_use == MSIX_REGISTERED_SUCCESS) {
3877 int vector = sp->entries[i].vector;
3878 void *arg = sp->s2io_entries[i].arg;
3883 kfree(sp->entries);
3884 kfree(sp->s2io_entries);
3885 sp->entries = NULL;
3886 sp->s2io_entries = NULL;
3888 pci_read_config_word(sp->pdev, 0x42, &msi_control);
3890 pci_write_config_word(sp->pdev, 0x42, msi_control);
3892 pci_disable_msix(sp->pdev);
3895 static void remove_inta_isr(struct s2io_nic *sp)
3897 free_irq(sp->pdev->irq, sp->dev);
3918 struct s2io_nic *sp = netdev_priv(dev);
3919 struct swStat *swstats = &sp->mac_control.stats_info->sw_stat;
3927 sp->last_link_state = 0;
3930 err = s2io_card_up(sp);
3939 s2io_card_down(sp);
3943 s2io_start_all_tx_queue(sp);
3947 if (sp->config.intr_type == MSI_X) {
3948 if (sp->entries) {
3949 kfree(sp->entries);
3950 swstats->mem_freed += sp->num_entries *
3953 if (sp->s2io_entries) {
3954 kfree(sp->s2io_entries);
3955 swstats->mem_freed += sp->num_entries *
3977 struct s2io_nic *sp = netdev_priv(dev);
3978 struct config_param *config = &sp->config;
3985 if (!is_s2io_card_up(sp))
3988 s2io_stop_all_tx_queue(sp);
3991 tmp64 = do_s2io_read_unicast_mc(sp, offset);
3993 do_s2io_delete_unicast_mc(sp, tmp64);
3996 s2io_card_down(sp);
4016 struct s2io_nic *sp = netdev_priv(dev);
4027 struct config_param *config = &sp->config;
4028 struct mac_info *mac_control = &sp->mac_control;
4040 if (!is_s2io_card_up(sp)) {
4050 if (sp->config.tx_steering_type == TX_DEFAULT_STEERING) {
4061 queue_len = sp->total_tcp_fifos;
4064 sp->fifo_selector[queue_len - 1];
4068 queue_len = sp->total_udp_fifos;
4071 sp->fifo_selector[queue_len - 1];
4074 queue += sp->udp_fifo_idx;
4081 } else if (sp->config.tx_steering_type == TX_PRIORITY_STEERING)
4094 if (sp->config.multiq) {
4115 s2io_stop_tx_queue(sp, fifo->fifo_no);
4160 txdp->Buffer_Pointer = pci_map_single(sp->pdev,
4164 if (pci_dma_mapping_error(sp->pdev, txdp->Buffer_Pointer))
4169 txdp->Buffer_Pointer = pci_map_single(sp->pdev, skb->data,
4171 if (pci_dma_mapping_error(sp->pdev, txdp->Buffer_Pointer))
4187 txdp->Buffer_Pointer = (u64)skb_frag_dma_map(&sp->pdev->dev,
4224 s2io_stop_tx_queue(sp, fifo->fifo_no);
4229 if (sp->config.intr_type == MSI_X)
4236 s2io_stop_tx_queue(sp, fifo->fifo_no);
4246 struct s2io_nic *sp = (struct s2io_nic *)data;
4247 struct net_device *dev = sp->dev;
4250 mod_timer(&sp->alarm_timer, jiffies + HZ / 2);
4256 struct s2io_nic *sp = ring->nic;
4257 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4259 if (unlikely(!is_s2io_card_up(sp)))
4262 if (sp->config.napi) {
4274 s2io_chk_rx_buffers(sp, ring);
4284 struct s2io_nic *sp = fifos->nic;
4285 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4286 struct config_param *config = &sp->config;
4289 if (unlikely(!is_s2io_card_up(sp)))
4301 s2io_txpic_intr_handle(sp);
4309 writeq(sp->general_int_mask, &bar0->general_int_mask);
4317 static void s2io_txpic_intr_handle(struct s2io_nic *sp)
4319 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4346 if (!sp->device_enabled_once)
4347 sp->device_enabled_once = 1;
4349 s2io_link(sp, LINK_UP);
4361 s2io_link(sp, LINK_DOWN);
4412 struct s2io_nic *sp = netdev_priv(dev);
4413 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4417 struct swStat *sw_stat = &sp->mac_control.stats_info->sw_stat;
4418 struct xpakStat *stats = &sp->mac_control.stats_info->xpak_stat;
4420 if (!is_s2io_card_up(sp))
4423 if (pci_channel_offline(sp->pdev))
4440 if (s2io_link_fault_indication(sp) == MAC_RMAC_ERR_TIMER) {
4444 schedule_work(&sp->set_link_task);
4458 if (sp->device_type == XFRAME_II_DEVICE) {
4677 if (sp->device_type != XFRAME_II_DEVICE) {
4693 s2io_stop_all_tx_queue(sp);
4694 schedule_work(&sp->rst_timer_task);
4714 struct s2io_nic *sp = netdev_priv(dev);
4715 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4722 if (pci_channel_offline(sp->pdev))
4725 if (!is_s2io_card_up(sp))
4728 config = &sp->config;
4729 mac_control = &sp->mac_control;
4749 napi_schedule(&sp->napi);
4782 s2io_txpic_intr_handle(sp);
4791 s2io_chk_rx_buffers(sp, ring);
4794 writeq(sp->general_int_mask, &bar0->general_int_mask);
4810 static void s2io_updt_stats(struct s2io_nic *sp)
4812 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4816 if (is_s2io_card_up(sp)) {
4844 struct s2io_nic *sp = netdev_priv(dev);
4845 struct mac_info *mac_control = &sp->mac_control;
4850 s2io_updt_stats(sp);
4860 le32_to_cpu(stats->rmac_vld_frms)) - sp->stats.rx_packets;
4861 sp->stats.rx_packets += delta;
4865 le32_to_cpu(stats->tmac_frms)) - sp->stats.tx_packets;
4866 sp->stats.tx_packets += delta;
4870 le32_to_cpu(stats->rmac_data_octets)) - sp->stats.rx_bytes;
4871 sp->stats.rx_bytes += delta;
4875 le32_to_cpu(stats->tmac_data_octets)) - sp->stats.tx_bytes;
4876 sp->stats.tx_bytes += delta;
4879 delta = le64_to_cpu(stats->rmac_drop_frms) - sp->stats.rx_errors;
4880 sp->stats.rx_errors += delta;
4884 le32_to_cpu(stats->tmac_any_err_frms)) - sp->stats.tx_errors;
4885 sp->stats.tx_errors += delta;
4888 delta = le64_to_cpu(stats->rmac_drop_frms) - sp->stats.rx_dropped;
4889 sp->stats.rx_dropped += delta;
4892 delta = le64_to_cpu(stats->tmac_drop_frms) - sp->stats.tx_dropped;
4893 sp->stats.tx_dropped += delta;
4904 delta -= sp->stats.multicast;
4905 sp->stats.multicast += delta;
4910 le64_to_cpu(stats->rmac_long_frms) - sp->stats.rx_length_errors;
4911 sp->stats.rx_length_errors += delta;
4914 delta = le64_to_cpu(stats->rmac_fcs_err_frms) - sp->stats.rx_crc_errors;
4915 sp->stats.rx_crc_errors += delta;
4938 struct s2io_nic *sp = netdev_priv(dev);
4939 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4944 struct config_param *config = &sp->config;
4946 if ((dev->flags & IFF_ALLMULTI) && (!sp->m_cast_flg)) {
4961 sp->m_cast_flg = 1;
4962 sp->all_multi_pos = config->max_mc_addr - 1;
4963 } else if ((dev->flags & IFF_ALLMULTI) && (sp->m_cast_flg)) {
4971 RMAC_ADDR_CMD_MEM_OFFSET(sp->all_multi_pos);
4978 sp->m_cast_flg = 0;
4979 sp->all_multi_pos = 0;
4982 if ((dev->flags & IFF_PROMISC) && (!sp->promisc_flg)) {
4997 sp->vlan_strip_flag = 0;
5001 sp->promisc_flg = 1;
5004 } else if (!(dev->flags & IFF_PROMISC) && (sp->promisc_flg)) {
5019 sp->vlan_strip_flag = 1;
5023 sp->promisc_flg = 0;
5028 if ((!sp->m_cast_flg) && netdev_mc_count(dev)) {
5038 prev_cnt = sp->mc_addr_count;
5039 sp->mc_addr_count = netdev_mc_count(dev);
5100 static void do_s2io_store_unicast_mc(struct s2io_nic *sp)
5104 struct config_param *config = &sp->config;
5108 mac_addr = do_s2io_read_unicast_mc(sp, offset);
5112 do_s2io_copy_mac_addr(sp, offset, mac_addr);
5117 static void do_s2io_restore_unicast_mc(struct s2io_nic *sp)
5120 struct config_param *config = &sp->config;
5123 do_s2io_prog_unicast(sp->dev,
5124 sp->def_mac_addr[offset].mac_addr);
5129 do_s2io_add_mc(sp, sp->def_mac_addr[offset].mac_addr);
5133 static int do_s2io_add_mc(struct s2io_nic *sp, u8 *addr)
5137 struct config_param *config = &sp->config;
5149 tmp64 = do_s2io_read_unicast_mc(sp, i);
5162 do_s2io_copy_mac_addr(sp, i, mac_addr);
5164 return do_s2io_add_mac(sp, mac_addr, i);
5168 static int do_s2io_add_mac(struct s2io_nic *sp, u64 addr, int off)
5171 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5190 static int do_s2io_delete_unicast_mc(struct s2io_nic *sp, u64 addr)
5194 struct config_param *config = &sp->config;
5198 tmp64 = do_s2io_read_unicast_mc(sp, offset);
5201 if (do_s2io_add_mac(sp, dis_addr, offset) == FAILURE)
5204 do_s2io_store_unicast_mc(sp);
5214 static u64 do_s2io_read_unicast_mc(struct s2io_nic *sp, int offset)
5217 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5264 struct s2io_nic *sp = netdev_priv(dev);
5268 struct config_param *config = &sp->config;
5279 perm_addr |= sp->def_mac_addr[0].mac_addr[i];
5288 tmp64 = do_s2io_read_unicast_mc(sp, i);
5304 do_s2io_copy_mac_addr(sp, i, mac_addr);
5306 return do_s2io_add_mac(sp, mac_addr, i);
5311 * @sp : private member of the device structure, which is a pointer to the * s2io_nic structure.
5324 struct s2io_nic *sp = netdev_priv(dev);
5330 s2io_close(sp->dev);
5331 s2io_open(sp->dev);
5339 * @sp : private member of the device structure, pointer to the
5351 struct s2io_nic *sp = netdev_priv(dev);
5359 if (netif_carrier_ok(sp->dev)) {
5373 * @sp : private member of the device structure, which is a pointer to the
5386 struct s2io_nic *sp = netdev_priv(dev);
5390 strlcpy(info->bus_info, pci_name(sp->pdev), sizeof(info->bus_info));
5397 * @sp: private member of the device structure, which is a pointer to the
5415 struct s2io_nic *sp = netdev_priv(dev);
5418 regs->version = sp->pdev->subsystem_device;
5421 reg = readq(sp->bar0 + i);
5429 static void s2io_set_led(struct s2io_nic *sp, bool on)
5431 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5432 u16 subid = sp->pdev->subsystem_device;
5435 if ((sp->device_type == XFRAME_II_DEVICE) ||
5471 struct s2io_nic *sp = netdev_priv(dev);
5472 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5473 u16 subid = sp->pdev->subsystem_device;
5475 if ((sp->device_type == XFRAME_I_DEVICE) && ((subid & 0xFF) < 0x07)) {
5485 sp->adapt_ctrl_org = readq(&bar0->gpio_control);
5489 s2io_set_led(sp, true);
5493 s2io_set_led(sp, false);
5497 if (CARDS_WITH_FAULTY_LINK_INDICATORS(sp->device_type, subid))
5498 writeq(sp->adapt_ctrl_org, &bar0->gpio_control);
5507 struct s2io_nic *sp = netdev_priv(dev);
5510 if (sp->rxd_mode == RXD_MODE_1) {
5520 for (i = 0; i < sp->config.rx_ring_num; i++)
5521 rx_desc_count += sp->config.rx_cfg[i].num_rxd;
5525 for (i = 0; i < sp->config.tx_fifo_num; i++)
5526 tx_desc_count += sp->config.tx_cfg[i].fifo_len;
5528 DBG_PRINT(INFO_DBG, "max txds: %d\n", sp->config.max_txds);
5533 * @sp : private member of the device structure, which is a pointer to the
5545 struct s2io_nic *sp = netdev_priv(dev);
5546 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5558 * @sp : private member of the device structure, which is a pointer to the
5572 struct s2io_nic *sp = netdev_priv(dev);
5573 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5590 * @sp : private member of the device structure, which is a pointer to the
5605 static int read_eeprom(struct s2io_nic *sp, int off, u64 *data)
5610 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5612 if (sp->device_type == XFRAME_I_DEVICE) {
5632 if (sp->device_type == XFRAME_II_DEVICE) {
5659 * @sp : private member of the device structure, which is a pointer to the
5672 static int write_eeprom(struct s2io_nic *sp, int off, u64 data, int cnt)
5676 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5678 if (sp->device_type == XFRAME_I_DEVICE) {
5698 if (sp->device_type == XFRAME_II_DEVICE) {
5796 * @sp : private member of the device structure, which is a pointer to the * s2io_nic structure.
5812 struct s2io_nic *sp = netdev_priv(dev);
5814 eeprom->magic = sp->pdev->vendor | (sp->pdev->device << 16);
5820 if (read_eeprom(sp, (eeprom->offset + i), &data)) {
5832 * @sp : private member of the device structure, which is a pointer to the
5850 struct s2io_nic *sp = netdev_priv(dev);
5852 if (eeprom->magic != (sp->pdev->vendor | (sp->pdev->device << 16))) {
5856 (sp->pdev->vendor | (sp->pdev->device << 16)),
5868 if (write_eeprom(sp, (eeprom->offset + cnt), valid, 0)) {
5883 * @sp : private member of the device structure, which is a pointer to the
5894 static int s2io_register_test(struct s2io_nic *sp, uint64_t *data)
5896 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5913 if (sp->device_type == XFRAME_II_DEVICE)
5950 * @sp : private member of the device structure, which is a pointer to the
5961 static int s2io_eeprom_test(struct s2io_nic *sp, uint64_t *data)
5966 struct net_device *dev = sp->dev;
5972 if (sp->device_type == XFRAME_I_DEVICE)
5973 if (!write_eeprom(sp, 0, 0, 3))
5977 if (!read_eeprom(sp, 0x4F0, &org_4F0))
5979 if (!read_eeprom(sp, 0x7F0, &org_7F0))
5983 if (write_eeprom(sp, 0x4F0, 0x012345, 3))
5985 if (read_eeprom(sp, 0x4F0, &ret_data))
5997 write_eeprom(sp, 0x4F0, 0xFFFFFF, 3);
6000 if (sp->device_type == XFRAME_I_DEVICE)
6001 if (!write_eeprom(sp, 0x07C, 0, 3))
6005 if (write_eeprom(sp, 0x7F0, 0x012345, 3))
6007 if (read_eeprom(sp, 0x7F0, &ret_data))
6019 write_eeprom(sp, 0x7F0, 0xFFFFFF, 3);
6021 if (sp->device_type == XFRAME_I_DEVICE) {
6023 if (!write_eeprom(sp, 0x080, 0, 3))
6027 if (!write_eeprom(sp, 0x0FC, 0, 3))
6031 if (!write_eeprom(sp, 0x100, 0, 3))
6035 if (!write_eeprom(sp, 0x4EC, 0, 3))
6041 write_eeprom(sp, 0x4F0, org_4F0, 3);
6043 write_eeprom(sp, 0x7F0, org_7F0, 3);
6051 * @sp : private member of the device structure, which is a pointer to the
6063 static int s2io_bist_test(struct s2io_nic *sp, uint64_t *data)
6068 pci_read_config_byte(sp->pdev, PCI_BIST, &bist);
6070 pci_write_config_word(sp->pdev, PCI_BIST, bist);
6073 pci_read_config_byte(sp->pdev, PCI_BIST, &bist);
6088 * @sp ; private member of the device structure, which is a pointer to the
6099 static int s2io_link_test(struct s2io_nic *sp, uint64_t *data)
6101 struct XENA_dev_config __iomem *bar0 = sp->bar0;
6115 * @sp: private member of the device structure, which is a pointer to the
6126 static int s2io_rldram_test(struct s2io_nic *sp, uint64_t *data)
6128 struct XENA_dev_config __iomem *bar0 = sp->bar0;
6211 * @sp : private member of the device structure, which is a pointer to the
6228 struct s2io_nic *sp = netdev_priv(dev);
6229 int orig_state = netif_running(sp->dev);
6234 s2io_close(sp->dev);
6236 if (s2io_register_test(sp, &data[0]))
6239 s2io_reset(sp);
6241 if (s2io_rldram_test(sp, &data[3]))
6244 s2io_reset(sp);
6246 if (s2io_eeprom_test(sp, &data[1]))
6249 if (s2io_bist_test(sp, &data[4]))
6253 s2io_open(sp->dev);
6268 if (s2io_link_test(sp, &data[2]))
6283 struct s2io_nic *sp = netdev_priv(dev);
6284 struct stat_block *stats = sp->mac_control.stats_info;
6288 s2io_updt_stats(sp);
6450 if (sp->device_type == XFRAME_II_DEVICE) {
6568 struct s2io_nic *sp = netdev_priv(dev);
6574 switch (sp->device_type) {
6591 struct s2io_nic *sp = netdev_priv(dev);
6600 if (sp->device_type == XFRAME_II_DEVICE) {
6614 struct s2io_nic *sp = netdev_priv(dev);
6620 s2io_stop_all_tx_queue(sp);
6621 s2io_card_down(sp);
6623 rc = s2io_card_up(sp);
6625 s2io_reset(sp);
6627 s2io_start_all_tx_queue(sp);
6685 struct s2io_nic *sp = netdev_priv(dev);
6695 s2io_stop_all_tx_queue(sp);
6696 s2io_card_down(sp);
6697 ret = s2io_card_up(sp);
6703 s2io_wake_all_tx_queue(sp);
6705 struct XENA_dev_config __iomem *bar0 = sp->bar0;
6797 static int set_rxd_buffer_pointer(struct s2io_nic *sp, struct RxD_t *rxdp,
6802 struct net_device *dev = sp->dev;
6803 struct swStat *stats = &sp->mac_control.stats_info->sw_stat;
6805 if ((sp->rxd_mode == RXD_MODE_1) && (rxdp->Host_Control == 0)) {
6831 pci_map_single(sp->pdev, (*skb)->data,
6834 if (pci_dma_mapping_error(sp->pdev, rxdp1->Buffer0_ptr))
6838 } else if ((sp->rxd_mode == RXD_MODE_3B) && (rxdp->Host_Control == 0)) {
6857 pci_map_single(sp->pdev, (*skb)->data,
6860 if (pci_dma_mapping_error(sp->pdev, rxdp3->Buffer2_ptr))
6863 pci_map_single(sp->pdev, ba->ba_0, BUF0_LEN,
6865 if (pci_dma_mapping_error(sp->pdev,
6867 pci_unmap_single(sp->pdev,
6877 pci_map_single(sp->pdev, ba->ba_1, BUF1_LEN,
6879 if (pci_dma_mapping_error(sp->pdev,
6881 pci_unmap_single(sp->pdev,
6884 pci_unmap_single(sp->pdev,
6901 static void set_rxd_buffer_size(struct s2io_nic *sp, struct RxD_t *rxdp,
6904 struct net_device *dev = sp->dev;
6905 if (sp->rxd_mode == RXD_MODE_1) {
6907 } else if (sp->rxd_mode == RXD_MODE_3B) {
6914 static int rxd_owner_bit_reset(struct s2io_nic *sp)
6917 struct config_param *config = &sp->config;
6918 struct mac_info *mac_control = &sp->mac_control;
6919 struct net_device *dev = sp->dev;
6928 if (sp->rxd_mode == RXD_MODE_1)
6930 else if (sp->rxd_mode == RXD_MODE_3B)
6937 blk_cnt = rx_cfg->num_rxd / (rxd_count[sp->rxd_mode] + 1);
6940 for (k = 0; k < rxd_count[sp->rxd_mode]; k++) {
6942 if (sp->rxd_mode == RXD_MODE_3B)
6944 if (set_rxd_buffer_pointer(sp, rxdp, ba, &skb,
6952 set_rxd_buffer_size(sp, rxdp, size);
6963 static int s2io_add_isr(struct s2io_nic *sp)
6966 struct net_device *dev = sp->dev;
6969 if (sp->config.intr_type == MSI_X)
6970 ret = s2io_enable_msi_x(sp);
6973 sp->config.intr_type = INTA;
6980 store_xmsi_data(sp);
6983 if (sp->config.intr_type == MSI_X) {
6986 for (i = 0; i < sp->num_entries; i++) {
6987 if (sp->s2io_entries[i].in_use == MSIX_FLG) {
6988 if (sp->s2io_entries[i].type ==
6990 sprintf(sp->desc[i], "%s:MSI-X-%d-RX",
6992 err = request_irq(sp->entries[i].vector,
6995 sp->desc[i],
6996 sp->s2io_entries[i].arg);
6997 } else if (sp->s2io_entries[i].type ==
6999 sprintf(sp->desc[i], "%s:MSI-X-%d-TX",
7001 err = request_irq(sp->entries[i].vector,
7004 sp->desc[i],
7005 sp->s2io_entries[i].arg);
7009 if (!(sp->msix_info[i].addr &&
7010 sp->msix_info[i].data)) {
7013 sp->desc[i],
7015 sp->msix_info[i].addr,
7017 ntohl(sp->msix_info[i].data));
7021 remove_msix_isr(sp);
7030 sp->config.intr_type = INTA;
7033 sp->s2io_entries[i].in_use =
7043 if (sp->config.intr_type == INTA) {
7044 err = request_irq(sp->pdev->irq, s2io_isr, IRQF_SHARED,
7045 sp->name, dev);
7055 static void s2io_rem_isr(struct s2io_nic *sp)
7057 if (sp->config.intr_type == MSI_X)
7058 remove_msix_isr(sp);
7060 remove_inta_isr(sp);
7063 static void do_s2io_card_down(struct s2io_nic *sp, int do_io)
7066 struct XENA_dev_config __iomem *bar0 = sp->bar0;
7069 config = &sp->config;
7071 if (!is_s2io_card_up(sp))
7074 del_timer_sync(&sp->alarm_timer);
7076 while (test_and_set_bit(__S2IO_STATE_LINK_TASK, &(sp->state)))
7078 clear_bit(__S2IO_STATE_CARD_UP, &sp->state);
7081 if (sp->config.napi) {
7084 for (; off < sp->config.rx_ring_num; off++)
7085 napi_disable(&sp->mac_control.rings[off].napi);
7088 napi_disable(&sp->napi);
7093 stop_nic(sp);
7095 s2io_rem_isr(sp);
7098 s2io_link(sp, LINK_DOWN);
7109 rxd_owner_bit_reset(sp);
7112 if (verify_xena_quiescence(sp)) {
7113 if (verify_pcc_quiescent(sp, sp->device_enabled_once))
7127 s2io_reset(sp);
7130 free_tx_buffers(sp);
7133 free_rx_buffers(sp);
7135 clear_bit(__S2IO_STATE_LINK_TASK, &(sp->state));
7138 static void s2io_card_down(struct s2io_nic *sp)
7140 do_s2io_card_down(sp, 1);
7143 static int s2io_card_up(struct s2io_nic *sp)
7148 struct net_device *dev = sp->dev;
7152 ret = init_nic(sp);
7157 s2io_reset(sp);
7165 config = &sp->config;
7166 mac_control = &sp->mac_control;
7173 ret = fill_rx_buffers(sp, ring, 1);
7177 s2io_reset(sp);
7178 free_rx_buffers(sp);
7188 for (i = 0; i < sp->config.rx_ring_num; i++)
7189 napi_enable(&sp->mac_control.rings[i].napi);
7191 napi_enable(&sp->napi);
7196 if (sp->promisc_flg)
7197 sp->promisc_flg = 0;
7198 if (sp->m_cast_flg) {
7199 sp->m_cast_flg = 0;
7200 sp->all_multi_pos = 0;
7208 sp->lro_max_aggr_per_sess = ((1<<16) - 1) / dev->mtu;
7210 if (lro_max_pkts < sp->lro_max_aggr_per_sess)
7211 sp->lro_max_aggr_per_sess = lro_max_pkts;
7215 if (start_nic(sp)) {
7217 s2io_reset(sp);
7218 free_rx_buffers(sp);
7223 if (s2io_add_isr(sp) != 0) {
7224 if (sp->config.intr_type == MSI_X)
7225 s2io_rem_isr(sp);
7226 s2io_reset(sp);
7227 free_rx_buffers(sp);
7231 S2IO_TIMER_CONF(sp->alarm_timer, s2io_alarm_handle, sp, (HZ/2));
7233 set_bit(__S2IO_STATE_CARD_UP, &sp->state);
7236 en_dis_err_alarms(sp, ENA_ALL_INTRS, ENABLE_INTRS);
7237 if (sp->config.intr_type != INTA) {
7239 en_dis_able_nic_intrs(sp, interruptible, ENABLE_INTRS);
7243 en_dis_able_nic_intrs(sp, interruptible, ENABLE_INTRS);
7261 struct s2io_nic *sp = container_of(work, struct s2io_nic, rst_timer_task);
7262 struct net_device *dev = sp->dev;
7269 s2io_card_down(sp);
7270 if (s2io_card_up(sp)) {
7273 s2io_wake_all_tx_queue(sp);
7294 struct s2io_nic *sp = netdev_priv(dev);
7295 struct swStat *swstats = &sp->mac_control.stats_info->sw_stat;
7299 schedule_work(&sp->rst_timer_task);
7306 * @sp: private member of the device structure,pointer to s2io_nic structure.
7323 struct s2io_nic *sp = ring_data->nic;
7332 struct swStat *swstats = &sp->mac_control.stats_info->sw_stat;
7400 if (sp->rxd_mode == RXD_MODE_1) {
7404 } else if (sp->rxd_mode == RXD_MODE_3B) {
7437 rxdp, sp);
7443 lro_append_pkt(sp, lro, skb, tcp_len);
7446 lro_append_pkt(sp, lro, skb, tcp_len);
7488 sp->mac_control.rings[ring_no].rx_bufs_left -= 1;
7494 * @sp : private member of the device structure, which is a pointer to the
7505 static void s2io_link(struct s2io_nic *sp, int link)
7507 struct net_device *dev = sp->dev;
7508 struct swStat *swstats = &sp->mac_control.stats_info->sw_stat;
7510 if (link != sp->last_link_state) {
7511 init_tti(sp, link);
7514 s2io_stop_all_tx_queue(sp);
7518 jiffies - sp->start_time;
7524 jiffies - sp->start_time;
7527 s2io_wake_all_tx_queue(sp);
7530 sp->last_link_state = link;
7531 sp->start_time = jiffies;
7536 * @sp : private member of the device structure, which is a pointer to the
7545 static void s2io_init_pci(struct s2io_nic *sp)
7550 pci_read_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
7552 pci_write_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
7554 pci_read_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
7558 pci_read_config_word(sp->pdev, PCI_COMMAND, &pci_cmd);
7559 pci_write_config_word(sp->pdev, PCI_COMMAND,
7561 pci_read_config_word(sp->pdev, PCI_COMMAND, &pci_cmd);
7704 struct s2io_nic *sp;
7767 sp = netdev_priv(dev);
7768 sp->dev = dev;
7769 sp->pdev = pdev;
7770 sp->high_dma_flag = dma_flag;
7771 sp->device_enabled_once = false;
7773 sp->rxd_mode = RXD_MODE_1;
7775 sp->rxd_mode = RXD_MODE_3B;
7777 sp->config.intr_type = dev_intr_type;
7781 sp->device_type = XFRAME_II_DEVICE;
7783 sp->device_type = XFRAME_I_DEVICE;
7787 s2io_init_pci(sp);
7796 config = &sp->config;
7797 mac_control = &sp->mac_control;
7811 sp->total_tcp_fifos = 1;
7813 sp->total_tcp_fifos = config->tx_fifo_num - 1;
7814 sp->udp_fifo_idx = config->tx_fifo_num - 1;
7815 sp->total_udp_fifos = 1;
7816 sp->other_fifo_idx = sp->total_tcp_fifos - 1;
7818 sp->total_tcp_fifos = (tx_fifo_num - FIFO_UDP_MAX_NUM -
7820 sp->udp_fifo_idx = sp->total_tcp_fifos;
7821 sp->total_udp_fifos = FIFO_UDP_MAX_NUM;
7822 sp->other_fifo_idx = sp->udp_fifo_idx + FIFO_UDP_MAX_NUM;
7839 sp->fifo_selector[i] = fifo_selector[i];
7861 rx_cfg->num_rxd = rx_ring_sz[i] * (rxd_count[sp->rxd_mode] + 1);
7864 ring->rxd_mode = sp->rxd_mode;
7865 ring->rxd_count = rxd_count[sp->rxd_mode];
7866 ring->pdev = sp->pdev;
7867 ring->dev = sp->dev;
7884 if (init_shared_mem(sp)) {
7890 sp->bar0 = pci_ioremap_bar(pdev, 0);
7891 if (!sp->bar0) {
7898 sp->bar1 = pci_ioremap_bar(pdev, 2);
7899 if (!sp->bar1) {
7908 mac_control->tx_FIFO_start[j] = sp->bar1 + (j * 0x00020000);
7919 if (sp->device_type & XFRAME_II_DEVICE) {
7924 if (sp->high_dma_flag == true)
7927 INIT_WORK(&sp->rst_timer_task, s2io_restart_nic);
7928 INIT_WORK(&sp->set_link_task, s2io_set_link);
7930 pci_save_state(sp->pdev);
7933 if (s2io_set_swapper(sp)) {
7941 if (sp->device_type & XFRAME_II_DEVICE) {
7942 mode = s2io_verify_pci_mode(sp);
7951 if (sp->config.intr_type == MSI_X) {
7952 sp->num_entries = config->rx_ring_num + 1;
7953 ret = s2io_enable_msi_x(sp);
7956 ret = s2io_test_msi(sp);
7958 remove_msix_isr(sp);
7964 sp->config.intr_type = INTA;
7975 netif_napi_add(dev, &sp->napi, s2io_poll_inta, 64);
7979 if (sp->device_type & XFRAME_I_DEVICE) {
7984 fix_mac_address(sp);
7985 s2io_reset(sp);
7992 bar0 = sp->bar0;
8003 sp->def_mac_addr[0].mac_addr[3] = (u8) (mac_up);
8004 sp->def_mac_addr[0].mac_addr[2] = (u8) (mac_up >> 8);
8005 sp->def_mac_addr[0].mac_addr[1] = (u8) (mac_up >> 16);
8006 sp->def_mac_addr[0].mac_addr[0] = (u8) (mac_up >> 24);
8007 sp->def_mac_addr[0].mac_addr[5] = (u8) (mac_down >> 16);
8008 sp->def_mac_addr[0].mac_addr[4] = (u8) (mac_down >> 24);
8012 memcpy(dev->dev_addr, sp->def_mac_addr, ETH_ALEN);
8015 if (sp->device_type == XFRAME_I_DEVICE) {
8019 } else if (sp->device_type == XFRAME_II_DEVICE) {
8026 do_s2io_store_unicast_mc(sp);
8029 if ((sp->device_type == XFRAME_II_DEVICE) &&
8031 sp->num_entries = config->rx_ring_num + 1;
8034 store_xmsi_data(sp);
8036 s2io_reset(sp);
8042 sp->state = 0;
8045 for (i = 0; i < sp->config.tx_fifo_num; i++) {
8055 subid = sp->pdev->subsystem_device;
8065 sp->rx_csum = 1; /* Rx chksum verify enabled by default */
8072 s2io_vpd_read(sp);
8075 sp->product_name, pdev->revision);
8079 DBG_PRINT(ERR_DBG, "Serial number: %s\n", sp->serial_num);
8080 if (sp->device_type & XFRAME_II_DEVICE) {
8081 mode = s2io_print_pci_mode(sp);
8088 switch (sp->rxd_mode) {
8099 switch (sp->config.napi) {
8109 sp->config.tx_fifo_num);
8112 sp->config.rx_ring_num);
8114 switch (sp->config.intr_type) {
8122 if (sp->config.multiq) {
8123 for (i = 0; i < sp->config.tx_fifo_num; i++) {
8134 switch (sp->config.tx_steering_type) {
8157 sprintf(sp->name, "%s Neterion %s", dev->name, sp->product_name);
8160 sp->vlan_strip_flag = 1;
8162 sp->vlan_strip_flag = 0;
8175 iounmap(sp->bar1);
8177 iounmap(sp->bar0);
8180 free_shared_mem(sp);
8200 struct s2io_nic *sp;
8207 sp = netdev_priv(dev);
8209 cancel_work_sync(&sp->rst_timer_task);
8210 cancel_work_sync(&sp->set_link_task);
8214 free_shared_mem(sp);
8215 iounmap(sp->bar0);
8216 iounmap(sp->bar1);
8250 struct s2io_nic *sp)
8269 if ((!sp->vlan_strip_flag) &&
8330 static void update_L3L4_header(struct s2io_nic *sp, struct lro *lro)
8334 struct swStat *swstats = &sp->mac_control.stats_info->sw_stat;
8441 struct RxD_t *rxdp, struct s2io_nic *sp)
8447 struct swStat *swstats = &sp->mac_control.stats_info->sw_stat;
8450 rxdp, sp);
8520 update_L3L4_header(sp, *lro);
8524 if ((*lro)->sg_num == sp->lro_max_aggr_per_sess) {
8525 update_L3L4_header(sp, *lro);
8547 struct s2io_nic *sp = netdev_priv(dev);
8550 if (vlan_tag && sp->vlan_strip_flag)
8552 if (sp->config.napi)
8558 static void lro_append_pkt(struct s2io_nic *sp, struct lro *lro,
8562 struct swStat *swstats = &sp->mac_control.stats_info->sw_stat;
8588 struct s2io_nic *sp = netdev_priv(netdev);
8597 do_s2io_card_down(sp, 0);
8616 struct s2io_nic *sp = netdev_priv(netdev);
8624 s2io_reset(sp);
8639 struct s2io_nic *sp = netdev_priv(netdev);
8642 if (s2io_card_up(sp)) {
8648 s2io_card_down(sp);