Lines Matching refs:sp
123 static inline int is_s2io_card_up(const struct s2io_nic *sp)
125 return test_bit(__S2IO_STATE_CARD_UP, &sp->state);
348 static void do_s2io_copy_mac_addr(struct s2io_nic *sp, int offset, u64 mac_addr)
350 sp->def_mac_addr[offset].mac_addr[5] = (u8) (mac_addr);
351 sp->def_mac_addr[offset].mac_addr[4] = (u8) (mac_addr >> 8);
352 sp->def_mac_addr[offset].mac_addr[3] = (u8) (mac_addr >> 16);
353 sp->def_mac_addr[offset].mac_addr[2] = (u8) (mac_addr >> 24);
354 sp->def_mac_addr[offset].mac_addr[1] = (u8) (mac_addr >> 32);
355 sp->def_mac_addr[offset].mac_addr[0] = (u8) (mac_addr >> 40);
505 static inline void s2io_stop_all_tx_queue(struct s2io_nic *sp)
507 if (!sp->config.multiq) {
510 for (i = 0; i < sp->config.tx_fifo_num; i++)
511 sp->mac_control.fifos[i].queue_state = FIFO_QUEUE_STOP;
513 netif_tx_stop_all_queues(sp->dev);
516 static inline void s2io_stop_tx_queue(struct s2io_nic *sp, int fifo_no)
518 if (!sp->config.multiq)
519 sp->mac_control.fifos[fifo_no].queue_state =
522 netif_tx_stop_all_queues(sp->dev);
525 static inline void s2io_start_all_tx_queue(struct s2io_nic *sp)
527 if (!sp->config.multiq) {
530 for (i = 0; i < sp->config.tx_fifo_num; i++)
531 sp->mac_control.fifos[i].queue_state = FIFO_QUEUE_START;
533 netif_tx_start_all_queues(sp->dev);
536 static inline void s2io_start_tx_queue(struct s2io_nic *sp, int fifo_no)
538 if (!sp->config.multiq)
539 sp->mac_control.fifos[fifo_no].queue_state =
542 netif_tx_start_all_queues(sp->dev);
545 static inline void s2io_wake_all_tx_queue(struct s2io_nic *sp)
547 if (!sp->config.multiq) {
550 for (i = 0; i < sp->config.tx_fifo_num; i++)
551 sp->mac_control.fifos[i].queue_state = FIFO_QUEUE_START;
553 netif_tx_wake_all_queues(sp->dev);
2087 static int verify_pcc_quiescent(struct s2io_nic *sp, int flag)
2090 struct XENA_dev_config __iomem *bar0 = sp->bar0;
2093 herc = (sp->device_type == XFRAME_II_DEVICE);
2096 if ((!herc && (sp->pdev->revision >= 4)) || herc) {
2104 if ((!herc && (sp->pdev->revision >= 4)) || herc) {
2127 static int verify_xena_quiescence(struct s2io_nic *sp)
2130 struct XENA_dev_config __iomem *bar0 = sp->bar0;
2132 mode = s2io_verify_pci_mode(sp);
2173 sp->device_type == XFRAME_II_DEVICE &&
2188 * @sp: Pointer to device specifc structure
2194 static void fix_mac_address(struct s2io_nic *sp)
2196 struct XENA_dev_config __iomem *bar0 = sp->bar0;
2673 static void free_rxd_blk(struct s2io_nic *sp, int ring_no, int blk)
2675 struct net_device *dev = sp->dev;
2681 struct mac_info *mac_control = &sp->mac_control;
2685 for (j = 0 ; j < rxd_count[sp->rxd_mode]; j++) {
2691 if (sp->rxd_mode == RXD_MODE_1) {
2693 pci_unmap_single(sp->pdev,
2700 } else if (sp->rxd_mode == RXD_MODE_3B) {
2702 pci_unmap_single(sp->pdev,
2706 pci_unmap_single(sp->pdev,
2710 pci_unmap_single(sp->pdev,
2724 * @sp: device private variable.
2731 static void free_rx_buffers(struct s2io_nic *sp)
2733 struct net_device *dev = sp->dev;
2735 struct config_param *config = &sp->config;
2736 struct mac_info *mac_control = &sp->mac_control;
2742 free_rxd_blk(sp, i, blk);
3103 struct s2io_nic *sp = netdev_priv(dev);
3104 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3149 struct s2io_nic *sp = netdev_priv(dev);
3150 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3251 struct s2io_nic *sp = netdev_priv(dev);
3252 struct stat_block *stats = sp->mac_control.stats_info;
3337 * @sp : private member of the device structure, which is a pointer to the
3401 * @sp : private member of the device structure.
3409 static void s2io_reset(struct s2io_nic *sp)
3411 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3422 __func__, pci_name(sp->pdev));
3425 pci_read_config_word(sp->pdev, PCIX_COMMAND_REGISTER, &(pci_cmd));
3429 if (strstr(sp->product_name, "CX4"))
3435 pci_restore_state(sp->pdev);
3436 pci_save_state(sp->pdev);
3437 pci_read_config_word(sp->pdev, 0x2, &val16);
3446 pci_write_config_word(sp->pdev, PCIX_COMMAND_REGISTER, pci_cmd);
3448 s2io_init_pci(sp);
3451 s2io_set_swapper(sp);
3454 do_s2io_restore_unicast_mc(sp);
3457 restore_xmsi_data(sp);
3460 if (sp->device_type == XFRAME_II_DEVICE) {
3462 pci_write_config_word(sp->pdev, PCI_STATUS, 0x8000);
3465 pci_write_config_dword(sp->pdev, 0x68, 0x7C);
3472 memset(&sp->stats, 0, sizeof(struct net_device_stats));
3474 stats = sp->mac_control.stats_info;
3500 subid = sp->pdev->subsystem_device;
3502 (sp->device_type == XFRAME_I_DEVICE)) {
3514 if (sp->device_type == XFRAME_II_DEVICE) {
3519 sp->device_enabled_once = false;
3524 * @sp : private member of the device structure,
3532 static int s2io_set_swapper(struct s2io_nic *sp)
3534 struct net_device *dev = sp->dev;
3535 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3618 if (sp->config.intr_type == INTA)
3642 if (sp->config.intr_type == INTA)
3822 struct s2io_nic *sp = dev_id;
3824 sp->msi_detected = 1;
3825 wake_up(&sp->msi_wait);
3831 static int s2io_test_msi(struct s2io_nic *sp)
3833 struct pci_dev *pdev = sp->pdev;
3834 struct XENA_dev_config __iomem *bar0 = sp->bar0;
3838 err = request_irq(sp->entries[1].vector, s2io_test_intr, 0,
3839 sp->name, sp);
3842 sp->dev->name, pci_name(pdev), pdev->irq);
3846 init_waitqueue_head(&sp->msi_wait);
3847 sp->msi_detected = 0;
3855 wait_event_timeout(sp->msi_wait, sp->msi_detected, HZ/10);
3857 if (!sp->msi_detected) {
3861 sp->dev->name, pci_name(pdev));
3866 free_irq(sp->entries[1].vector, sp);
3873 static void remove_msix_isr(struct s2io_nic *sp)
3878 for (i = 0; i < sp->num_entries; i++) {
3879 if (sp->s2io_entries[i].in_use == MSIX_REGISTERED_SUCCESS) {
3880 int vector = sp->entries[i].vector;
3881 void *arg = sp->s2io_entries[i].arg;
3886 kfree(sp->entries);
3887 kfree(sp->s2io_entries);
3888 sp->entries = NULL;
3889 sp->s2io_entries = NULL;
3891 pci_read_config_word(sp->pdev, 0x42, &msi_control);
3893 pci_write_config_word(sp->pdev, 0x42, msi_control);
3895 pci_disable_msix(sp->pdev);
3898 static void remove_inta_isr(struct s2io_nic *sp)
3900 struct net_device *dev = sp->dev;
3902 free_irq(sp->pdev->irq, dev);
3923 struct s2io_nic *sp = netdev_priv(dev);
3924 struct swStat *swstats = &sp->mac_control.stats_info->sw_stat;
3932 sp->last_link_state = 0;
3935 err = s2io_card_up(sp);
3944 s2io_card_down(sp);
3948 s2io_start_all_tx_queue(sp);
3952 if (sp->config.intr_type == MSI_X) {
3953 if (sp->entries) {
3954 kfree(sp->entries);
3955 swstats->mem_freed += sp->num_entries *
3958 if (sp->s2io_entries) {
3959 kfree(sp->s2io_entries);
3960 swstats->mem_freed += sp->num_entries *
3982 struct s2io_nic *sp = netdev_priv(dev);
3983 struct config_param *config = &sp->config;
3990 if (!is_s2io_card_up(sp))
3993 s2io_stop_all_tx_queue(sp);
3996 tmp64 = do_s2io_read_unicast_mc(sp, offset);
3998 do_s2io_delete_unicast_mc(sp, tmp64);
4001 s2io_card_down(sp);
4021 struct s2io_nic *sp = netdev_priv(dev);
4032 struct config_param *config = &sp->config;
4033 struct mac_info *mac_control = &sp->mac_control;
4045 if (!is_s2io_card_up(sp)) {
4055 if (sp->config.tx_steering_type == TX_DEFAULT_STEERING) {
4066 queue_len = sp->total_tcp_fifos;
4069 sp->fifo_selector[queue_len - 1];
4073 queue_len = sp->total_udp_fifos;
4076 sp->fifo_selector[queue_len - 1];
4079 queue += sp->udp_fifo_idx;
4086 } else if (sp->config.tx_steering_type == TX_PRIORITY_STEERING)
4099 if (sp->config.multiq) {
4120 s2io_stop_tx_queue(sp, fifo->fifo_no);
4165 txdp->Buffer_Pointer = pci_map_single(sp->pdev,
4169 if (pci_dma_mapping_error(sp->pdev, txdp->Buffer_Pointer))
4174 txdp->Buffer_Pointer = pci_map_single(sp->pdev, skb->data,
4176 if (pci_dma_mapping_error(sp->pdev, txdp->Buffer_Pointer))
4192 txdp->Buffer_Pointer = (u64)skb_frag_dma_map(&sp->pdev->dev,
4229 s2io_stop_tx_queue(sp, fifo->fifo_no);
4234 if (sp->config.intr_type == MSI_X)
4241 s2io_stop_tx_queue(sp, fifo->fifo_no);
4251 struct s2io_nic *sp = (struct s2io_nic *)data;
4252 struct net_device *dev = sp->dev;
4255 mod_timer(&sp->alarm_timer, jiffies + HZ / 2);
4261 struct s2io_nic *sp = ring->nic;
4262 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4264 if (unlikely(!is_s2io_card_up(sp)))
4267 if (sp->config.napi) {
4279 s2io_chk_rx_buffers(sp, ring);
4289 struct s2io_nic *sp = fifos->nic;
4290 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4291 struct config_param *config = &sp->config;
4294 if (unlikely(!is_s2io_card_up(sp)))
4306 s2io_txpic_intr_handle(sp);
4314 writeq(sp->general_int_mask, &bar0->general_int_mask);
4322 static void s2io_txpic_intr_handle(struct s2io_nic *sp)
4324 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4351 if (!sp->device_enabled_once)
4352 sp->device_enabled_once = 1;
4354 s2io_link(sp, LINK_UP);
4366 s2io_link(sp, LINK_DOWN);
4417 struct s2io_nic *sp = netdev_priv(dev);
4418 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4422 struct swStat *sw_stat = &sp->mac_control.stats_info->sw_stat;
4423 struct xpakStat *stats = &sp->mac_control.stats_info->xpak_stat;
4425 if (!is_s2io_card_up(sp))
4428 if (pci_channel_offline(sp->pdev))
4445 if (s2io_link_fault_indication(sp) == MAC_RMAC_ERR_TIMER) {
4449 schedule_work(&sp->set_link_task);
4463 if (sp->device_type == XFRAME_II_DEVICE) {
4682 if (sp->device_type != XFRAME_II_DEVICE) {
4698 s2io_stop_all_tx_queue(sp);
4699 schedule_work(&sp->rst_timer_task);
4719 struct s2io_nic *sp = netdev_priv(dev);
4720 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4727 if (pci_channel_offline(sp->pdev))
4730 if (!is_s2io_card_up(sp))
4733 config = &sp->config;
4734 mac_control = &sp->mac_control;
4754 napi_schedule(&sp->napi);
4787 s2io_txpic_intr_handle(sp);
4796 s2io_chk_rx_buffers(sp, ring);
4799 writeq(sp->general_int_mask, &bar0->general_int_mask);
4815 static void s2io_updt_stats(struct s2io_nic *sp)
4817 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4821 if (is_s2io_card_up(sp)) {
4849 struct s2io_nic *sp = netdev_priv(dev);
4850 struct mac_info *mac_control = &sp->mac_control;
4855 s2io_updt_stats(sp);
4865 le32_to_cpu(stats->rmac_vld_frms)) - sp->stats.rx_packets;
4866 sp->stats.rx_packets += delta;
4870 le32_to_cpu(stats->tmac_frms)) - sp->stats.tx_packets;
4871 sp->stats.tx_packets += delta;
4875 le32_to_cpu(stats->rmac_data_octets)) - sp->stats.rx_bytes;
4876 sp->stats.rx_bytes += delta;
4880 le32_to_cpu(stats->tmac_data_octets)) - sp->stats.tx_bytes;
4881 sp->stats.tx_bytes += delta;
4884 delta = le64_to_cpu(stats->rmac_drop_frms) - sp->stats.rx_errors;
4885 sp->stats.rx_errors += delta;
4889 le32_to_cpu(stats->tmac_any_err_frms)) - sp->stats.tx_errors;
4890 sp->stats.tx_errors += delta;
4893 delta = le64_to_cpu(stats->rmac_drop_frms) - sp->stats.rx_dropped;
4894 sp->stats.rx_dropped += delta;
4897 delta = le64_to_cpu(stats->tmac_drop_frms) - sp->stats.tx_dropped;
4898 sp->stats.tx_dropped += delta;
4909 delta -= sp->stats.multicast;
4910 sp->stats.multicast += delta;
4915 le64_to_cpu(stats->rmac_long_frms) - sp->stats.rx_length_errors;
4916 sp->stats.rx_length_errors += delta;
4919 delta = le64_to_cpu(stats->rmac_fcs_err_frms) - sp->stats.rx_crc_errors;
4920 sp->stats.rx_crc_errors += delta;
4943 struct s2io_nic *sp = netdev_priv(dev);
4944 struct XENA_dev_config __iomem *bar0 = sp->bar0;
4949 struct config_param *config = &sp->config;
4951 if ((dev->flags & IFF_ALLMULTI) && (!sp->m_cast_flg)) {
4966 sp->m_cast_flg = 1;
4967 sp->all_multi_pos = config->max_mc_addr - 1;
4968 } else if ((dev->flags & IFF_ALLMULTI) && (sp->m_cast_flg)) {
4976 RMAC_ADDR_CMD_MEM_OFFSET(sp->all_multi_pos);
4983 sp->m_cast_flg = 0;
4984 sp->all_multi_pos = 0;
4987 if ((dev->flags & IFF_PROMISC) && (!sp->promisc_flg)) {
5002 sp->vlan_strip_flag = 0;
5006 sp->promisc_flg = 1;
5009 } else if (!(dev->flags & IFF_PROMISC) && (sp->promisc_flg)) {
5024 sp->vlan_strip_flag = 1;
5028 sp->promisc_flg = 0;
5033 if ((!sp->m_cast_flg) && netdev_mc_count(dev)) {
5043 prev_cnt = sp->mc_addr_count;
5044 sp->mc_addr_count = netdev_mc_count(dev);
5105 static void do_s2io_store_unicast_mc(struct s2io_nic *sp)
5109 struct config_param *config = &sp->config;
5113 mac_addr = do_s2io_read_unicast_mc(sp, offset);
5117 do_s2io_copy_mac_addr(sp, offset, mac_addr);
5122 static void do_s2io_restore_unicast_mc(struct s2io_nic *sp)
5125 struct config_param *config = &sp->config;
5128 do_s2io_prog_unicast(sp->dev,
5129 sp->def_mac_addr[offset].mac_addr);
5134 do_s2io_add_mc(sp, sp->def_mac_addr[offset].mac_addr);
5138 static int do_s2io_add_mc(struct s2io_nic *sp, u8 *addr)
5142 struct config_param *config = &sp->config;
5154 tmp64 = do_s2io_read_unicast_mc(sp, i);
5167 do_s2io_copy_mac_addr(sp, i, mac_addr);
5169 return do_s2io_add_mac(sp, mac_addr, i);
5173 static int do_s2io_add_mac(struct s2io_nic *sp, u64 addr, int off)
5176 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5195 static int do_s2io_delete_unicast_mc(struct s2io_nic *sp, u64 addr)
5199 struct config_param *config = &sp->config;
5203 tmp64 = do_s2io_read_unicast_mc(sp, offset);
5206 if (do_s2io_add_mac(sp, dis_addr, offset) == FAILURE)
5209 do_s2io_store_unicast_mc(sp);
5219 static u64 do_s2io_read_unicast_mc(struct s2io_nic *sp, int offset)
5222 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5269 struct s2io_nic *sp = netdev_priv(dev);
5273 struct config_param *config = &sp->config;
5284 perm_addr |= sp->def_mac_addr[0].mac_addr[i];
5293 tmp64 = do_s2io_read_unicast_mc(sp, i);
5309 do_s2io_copy_mac_addr(sp, i, mac_addr);
5311 return do_s2io_add_mac(sp, mac_addr, i);
5316 * @sp : private member of the device structure, which is a pointer to the * s2io_nic structure.
5329 struct s2io_nic *sp = netdev_priv(dev);
5335 s2io_close(sp->dev);
5336 s2io_open(sp->dev);
5344 * @sp : private member of the device structure, pointer to the
5356 struct s2io_nic *sp = netdev_priv(dev);
5364 if (netif_carrier_ok(sp->dev)) {
5378 * @sp : private member of the device structure, which is a pointer to the
5391 struct s2io_nic *sp = netdev_priv(dev);
5395 strlcpy(info->bus_info, pci_name(sp->pdev), sizeof(info->bus_info));
5402 * @sp: private member of the device structure, which is a pointer to the
5420 struct s2io_nic *sp = netdev_priv(dev);
5423 regs->version = sp->pdev->subsystem_device;
5426 reg = readq(sp->bar0 + i);
5434 static void s2io_set_led(struct s2io_nic *sp, bool on)
5436 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5437 u16 subid = sp->pdev->subsystem_device;
5440 if ((sp->device_type == XFRAME_II_DEVICE) ||
5476 struct s2io_nic *sp = netdev_priv(dev);
5477 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5478 u16 subid = sp->pdev->subsystem_device;
5480 if ((sp->device_type == XFRAME_I_DEVICE) && ((subid & 0xFF) < 0x07)) {
5490 sp->adapt_ctrl_org = readq(&bar0->gpio_control);
5494 s2io_set_led(sp, true);
5498 s2io_set_led(sp, false);
5502 if (CARDS_WITH_FAULTY_LINK_INDICATORS(sp->device_type, subid))
5503 writeq(sp->adapt_ctrl_org, &bar0->gpio_control);
5512 struct s2io_nic *sp = netdev_priv(dev);
5515 if (sp->rxd_mode == RXD_MODE_1) {
5525 for (i = 0; i < sp->config.rx_ring_num; i++)
5526 rx_desc_count += sp->config.rx_cfg[i].num_rxd;
5530 for (i = 0; i < sp->config.tx_fifo_num; i++)
5531 tx_desc_count += sp->config.tx_cfg[i].fifo_len;
5533 DBG_PRINT(INFO_DBG, "max txds: %d\n", sp->config.max_txds);
5538 * @sp : private member of the device structure, which is a pointer to the
5550 struct s2io_nic *sp = netdev_priv(dev);
5551 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5563 * @sp : private member of the device structure, which is a pointer to the
5577 struct s2io_nic *sp = netdev_priv(dev);
5578 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5595 * @sp : private member of the device structure, which is a pointer to the
5610 static int read_eeprom(struct s2io_nic *sp, int off, u64 *data)
5615 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5617 if (sp->device_type == XFRAME_I_DEVICE) {
5637 if (sp->device_type == XFRAME_II_DEVICE) {
5664 * @sp : private member of the device structure, which is a pointer to the
5677 static int write_eeprom(struct s2io_nic *sp, int off, u64 data, int cnt)
5681 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5683 if (sp->device_type == XFRAME_I_DEVICE) {
5703 if (sp->device_type == XFRAME_II_DEVICE) {
5801 * @sp : private member of the device structure, which is a pointer to the * s2io_nic structure.
5817 struct s2io_nic *sp = netdev_priv(dev);
5819 eeprom->magic = sp->pdev->vendor | (sp->pdev->device << 16);
5825 if (read_eeprom(sp, (eeprom->offset + i), &data)) {
5837 * @sp : private member of the device structure, which is a pointer to the
5855 struct s2io_nic *sp = netdev_priv(dev);
5857 if (eeprom->magic != (sp->pdev->vendor | (sp->pdev->device << 16))) {
5861 (sp->pdev->vendor | (sp->pdev->device << 16)),
5873 if (write_eeprom(sp, (eeprom->offset + cnt), valid, 0)) {
5888 * @sp : private member of the device structure, which is a pointer to the
5899 static int s2io_register_test(struct s2io_nic *sp, uint64_t *data)
5901 struct XENA_dev_config __iomem *bar0 = sp->bar0;
5918 if (sp->device_type == XFRAME_II_DEVICE)
5955 * @sp : private member of the device structure, which is a pointer to the
5966 static int s2io_eeprom_test(struct s2io_nic *sp, uint64_t *data)
5971 struct net_device *dev = sp->dev;
5977 if (sp->device_type == XFRAME_I_DEVICE)
5978 if (!write_eeprom(sp, 0, 0, 3))
5982 if (!read_eeprom(sp, 0x4F0, &org_4F0))
5984 if (!read_eeprom(sp, 0x7F0, &org_7F0))
5988 if (write_eeprom(sp, 0x4F0, 0x012345, 3))
5990 if (read_eeprom(sp, 0x4F0, &ret_data))
6002 write_eeprom(sp, 0x4F0, 0xFFFFFF, 3);
6005 if (sp->device_type == XFRAME_I_DEVICE)
6006 if (!write_eeprom(sp, 0x07C, 0, 3))
6010 if (write_eeprom(sp, 0x7F0, 0x012345, 3))
6012 if (read_eeprom(sp, 0x7F0, &ret_data))
6024 write_eeprom(sp, 0x7F0, 0xFFFFFF, 3);
6026 if (sp->device_type == XFRAME_I_DEVICE) {
6028 if (!write_eeprom(sp, 0x080, 0, 3))
6032 if (!write_eeprom(sp, 0x0FC, 0, 3))
6036 if (!write_eeprom(sp, 0x100, 0, 3))
6040 if (!write_eeprom(sp, 0x4EC, 0, 3))
6046 write_eeprom(sp, 0x4F0, org_4F0, 3);
6048 write_eeprom(sp, 0x7F0, org_7F0, 3);
6056 * @sp : private member of the device structure, which is a pointer to the
6068 static int s2io_bist_test(struct s2io_nic *sp, uint64_t *data)
6073 pci_read_config_byte(sp->pdev, PCI_BIST, &bist);
6075 pci_write_config_word(sp->pdev, PCI_BIST, bist);
6078 pci_read_config_byte(sp->pdev, PCI_BIST, &bist);
6093 * @sp ; private member of the device structure, which is a pointer to the
6104 static int s2io_link_test(struct s2io_nic *sp, uint64_t *data)
6106 struct XENA_dev_config __iomem *bar0 = sp->bar0;
6120 * @sp - private member of the device structure, which is a pointer to the
6131 static int s2io_rldram_test(struct s2io_nic *sp, uint64_t *data)
6133 struct XENA_dev_config __iomem *bar0 = sp->bar0;
6216 * @sp : private member of the device structure, which is a pointer to the
6233 struct s2io_nic *sp = netdev_priv(dev);
6234 int orig_state = netif_running(sp->dev);
6239 s2io_close(sp->dev);
6241 if (s2io_register_test(sp, &data[0]))
6244 s2io_reset(sp);
6246 if (s2io_rldram_test(sp, &data[3]))
6249 s2io_reset(sp);
6251 if (s2io_eeprom_test(sp, &data[1]))
6254 if (s2io_bist_test(sp, &data[4]))
6258 s2io_open(sp->dev);
6273 if (s2io_link_test(sp, &data[2]))
6288 struct s2io_nic *sp = netdev_priv(dev);
6289 struct stat_block *stats = sp->mac_control.stats_info;
6293 s2io_updt_stats(sp);
6455 if (sp->device_type == XFRAME_II_DEVICE) {
6573 struct s2io_nic *sp = netdev_priv(dev);
6579 switch (sp->device_type) {
6596 struct s2io_nic *sp = netdev_priv(dev);
6605 if (sp->device_type == XFRAME_II_DEVICE) {
6619 struct s2io_nic *sp = netdev_priv(dev);
6625 s2io_stop_all_tx_queue(sp);
6626 s2io_card_down(sp);
6628 rc = s2io_card_up(sp);
6630 s2io_reset(sp);
6632 s2io_start_all_tx_queue(sp);
6690 struct s2io_nic *sp = netdev_priv(dev);
6700 s2io_stop_all_tx_queue(sp);
6701 s2io_card_down(sp);
6702 ret = s2io_card_up(sp);
6708 s2io_wake_all_tx_queue(sp);
6710 struct XENA_dev_config __iomem *bar0 = sp->bar0;
6802 static int set_rxd_buffer_pointer(struct s2io_nic *sp, struct RxD_t *rxdp,
6807 struct net_device *dev = sp->dev;
6808 struct swStat *stats = &sp->mac_control.stats_info->sw_stat;
6810 if ((sp->rxd_mode == RXD_MODE_1) && (rxdp->Host_Control == 0)) {
6836 pci_map_single(sp->pdev, (*skb)->data,
6839 if (pci_dma_mapping_error(sp->pdev, rxdp1->Buffer0_ptr))
6843 } else if ((sp->rxd_mode == RXD_MODE_3B) && (rxdp->Host_Control == 0)) {
6862 pci_map_single(sp->pdev, (*skb)->data,
6865 if (pci_dma_mapping_error(sp->pdev, rxdp3->Buffer2_ptr))
6868 pci_map_single(sp->pdev, ba->ba_0, BUF0_LEN,
6870 if (pci_dma_mapping_error(sp->pdev,
6872 pci_unmap_single(sp->pdev,
6882 pci_map_single(sp->pdev, ba->ba_1, BUF1_LEN,
6884 if (pci_dma_mapping_error(sp->pdev,
6886 pci_unmap_single(sp->pdev,
6889 pci_unmap_single(sp->pdev,
6906 static void set_rxd_buffer_size(struct s2io_nic *sp, struct RxD_t *rxdp,
6909 struct net_device *dev = sp->dev;
6910 if (sp->rxd_mode == RXD_MODE_1) {
6912 } else if (sp->rxd_mode == RXD_MODE_3B) {
6919 static int rxd_owner_bit_reset(struct s2io_nic *sp)
6922 struct config_param *config = &sp->config;
6923 struct mac_info *mac_control = &sp->mac_control;
6924 struct net_device *dev = sp->dev;
6933 if (sp->rxd_mode == RXD_MODE_1)
6935 else if (sp->rxd_mode == RXD_MODE_3B)
6942 blk_cnt = rx_cfg->num_rxd / (rxd_count[sp->rxd_mode] + 1);
6945 for (k = 0; k < rxd_count[sp->rxd_mode]; k++) {
6947 if (sp->rxd_mode == RXD_MODE_3B)
6949 if (set_rxd_buffer_pointer(sp, rxdp, ba, &skb,
6957 set_rxd_buffer_size(sp, rxdp, size);
6968 static int s2io_add_isr(struct s2io_nic *sp)
6971 struct net_device *dev = sp->dev;
6974 if (sp->config.intr_type == MSI_X)
6975 ret = s2io_enable_msi_x(sp);
6978 sp->config.intr_type = INTA;
6985 store_xmsi_data(sp);
6988 if (sp->config.intr_type == MSI_X) {
6991 for (i = 0; i < sp->num_entries; i++) {
6992 if (sp->s2io_entries[i].in_use == MSIX_FLG) {
6993 if (sp->s2io_entries[i].type ==
6995 sprintf(sp->desc[i], "%s:MSI-X-%d-RX",
6997 err = request_irq(sp->entries[i].vector,
7000 sp->desc[i],
7001 sp->s2io_entries[i].arg);
7002 } else if (sp->s2io_entries[i].type ==
7004 sprintf(sp->desc[i], "%s:MSI-X-%d-TX",
7006 err = request_irq(sp->entries[i].vector,
7009 sp->desc[i],
7010 sp->s2io_entries[i].arg);
7014 if (!(sp->msix_info[i].addr &&
7015 sp->msix_info[i].data)) {
7018 sp->desc[i],
7020 sp->msix_info[i].addr,
7022 ntohl(sp->msix_info[i].data));
7026 remove_msix_isr(sp);
7035 sp->config.intr_type = INTA;
7038 sp->s2io_entries[i].in_use =
7048 if (sp->config.intr_type == INTA) {
7049 err = request_irq((int)sp->pdev->irq, s2io_isr, IRQF_SHARED,
7050 sp->name, dev);
7060 static void s2io_rem_isr(struct s2io_nic *sp)
7062 if (sp->config.intr_type == MSI_X)
7063 remove_msix_isr(sp);
7065 remove_inta_isr(sp);
7068 static void do_s2io_card_down(struct s2io_nic *sp, int do_io)
7071 struct XENA_dev_config __iomem *bar0 = sp->bar0;
7074 config = &sp->config;
7076 if (!is_s2io_card_up(sp))
7079 del_timer_sync(&sp->alarm_timer);
7081 while (test_and_set_bit(__S2IO_STATE_LINK_TASK, &(sp->state)))
7083 clear_bit(__S2IO_STATE_CARD_UP, &sp->state);
7086 if (sp->config.napi) {
7089 for (; off < sp->config.rx_ring_num; off++)
7090 napi_disable(&sp->mac_control.rings[off].napi);
7093 napi_disable(&sp->napi);
7098 stop_nic(sp);
7100 s2io_rem_isr(sp);
7103 s2io_link(sp, LINK_DOWN);
7114 rxd_owner_bit_reset(sp);
7117 if (verify_xena_quiescence(sp)) {
7118 if (verify_pcc_quiescent(sp, sp->device_enabled_once))
7132 s2io_reset(sp);
7135 free_tx_buffers(sp);
7138 free_rx_buffers(sp);
7140 clear_bit(__S2IO_STATE_LINK_TASK, &(sp->state));
7143 static void s2io_card_down(struct s2io_nic *sp)
7145 do_s2io_card_down(sp, 1);
7148 static int s2io_card_up(struct s2io_nic *sp)
7153 struct net_device *dev = (struct net_device *)sp->dev;
7157 ret = init_nic(sp);
7162 s2io_reset(sp);
7170 config = &sp->config;
7171 mac_control = &sp->mac_control;
7178 ret = fill_rx_buffers(sp, ring, 1);
7182 s2io_reset(sp);
7183 free_rx_buffers(sp);
7193 for (i = 0; i < sp->config.rx_ring_num; i++)
7194 napi_enable(&sp->mac_control.rings[i].napi);
7196 napi_enable(&sp->napi);
7201 if (sp->promisc_flg)
7202 sp->promisc_flg = 0;
7203 if (sp->m_cast_flg) {
7204 sp->m_cast_flg = 0;
7205 sp->all_multi_pos = 0;
7213 sp->lro_max_aggr_per_sess = ((1<<16) - 1) / dev->mtu;
7215 if (lro_max_pkts < sp->lro_max_aggr_per_sess)
7216 sp->lro_max_aggr_per_sess = lro_max_pkts;
7220 if (start_nic(sp)) {
7222 s2io_reset(sp);
7223 free_rx_buffers(sp);
7228 if (s2io_add_isr(sp) != 0) {
7229 if (sp->config.intr_type == MSI_X)
7230 s2io_rem_isr(sp);
7231 s2io_reset(sp);
7232 free_rx_buffers(sp);
7236 S2IO_TIMER_CONF(sp->alarm_timer, s2io_alarm_handle, sp, (HZ/2));
7238 set_bit(__S2IO_STATE_CARD_UP, &sp->state);
7241 en_dis_err_alarms(sp, ENA_ALL_INTRS, ENABLE_INTRS);
7242 if (sp->config.intr_type != INTA) {
7244 en_dis_able_nic_intrs(sp, interruptible, ENABLE_INTRS);
7248 en_dis_able_nic_intrs(sp, interruptible, ENABLE_INTRS);
7266 struct s2io_nic *sp = container_of(work, struct s2io_nic, rst_timer_task);
7267 struct net_device *dev = sp->dev;
7274 s2io_card_down(sp);
7275 if (s2io_card_up(sp)) {
7278 s2io_wake_all_tx_queue(sp);
7299 struct s2io_nic *sp = netdev_priv(dev);
7300 struct swStat *swstats = &sp->mac_control.stats_info->sw_stat;
7304 schedule_work(&sp->rst_timer_task);
7311 * @sp: private member of the device structure,pointer to s2io_nic structure.
7328 struct s2io_nic *sp = ring_data->nic;
7337 struct swStat *swstats = &sp->mac_control.stats_info->sw_stat;
7405 if (sp->rxd_mode == RXD_MODE_1) {
7409 } else if (sp->rxd_mode == RXD_MODE_3B) {
7442 rxdp, sp);
7448 lro_append_pkt(sp, lro, skb, tcp_len);
7451 lro_append_pkt(sp, lro, skb, tcp_len);
7493 sp->mac_control.rings[ring_no].rx_bufs_left -= 1;
7499 * @sp : private member of the device structure, which is a pointer to the
7510 static void s2io_link(struct s2io_nic *sp, int link)
7512 struct net_device *dev = (struct net_device *)sp->dev;
7513 struct swStat *swstats = &sp->mac_control.stats_info->sw_stat;
7515 if (link != sp->last_link_state) {
7516 init_tti(sp, link);
7519 s2io_stop_all_tx_queue(sp);
7523 jiffies - sp->start_time;
7529 jiffies - sp->start_time;
7532 s2io_wake_all_tx_queue(sp);
7535 sp->last_link_state = link;
7536 sp->start_time = jiffies;
7541 * @sp : private member of the device structure, which is a pointer to the
7550 static void s2io_init_pci(struct s2io_nic *sp)
7555 pci_read_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
7557 pci_write_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
7559 pci_read_config_word(sp->pdev, PCIX_COMMAND_REGISTER,
7563 pci_read_config_word(sp->pdev, PCI_COMMAND, &pci_cmd);
7564 pci_write_config_word(sp->pdev, PCI_COMMAND,
7566 pci_read_config_word(sp->pdev, PCI_COMMAND, &pci_cmd);
7709 struct s2io_nic *sp;
7772 sp = netdev_priv(dev);
7773 sp->dev = dev;
7774 sp->pdev = pdev;
7775 sp->high_dma_flag = dma_flag;
7776 sp->device_enabled_once = false;
7778 sp->rxd_mode = RXD_MODE_1;
7780 sp->rxd_mode = RXD_MODE_3B;
7782 sp->config.intr_type = dev_intr_type;
7786 sp->device_type = XFRAME_II_DEVICE;
7788 sp->device_type = XFRAME_I_DEVICE;
7792 s2io_init_pci(sp);
7801 config = &sp->config;
7802 mac_control = &sp->mac_control;
7816 sp->total_tcp_fifos = 1;
7818 sp->total_tcp_fifos = config->tx_fifo_num - 1;
7819 sp->udp_fifo_idx = config->tx_fifo_num - 1;
7820 sp->total_udp_fifos = 1;
7821 sp->other_fifo_idx = sp->total_tcp_fifos - 1;
7823 sp->total_tcp_fifos = (tx_fifo_num - FIFO_UDP_MAX_NUM -
7825 sp->udp_fifo_idx = sp->total_tcp_fifos;
7826 sp->total_udp_fifos = FIFO_UDP_MAX_NUM;
7827 sp->other_fifo_idx = sp->udp_fifo_idx + FIFO_UDP_MAX_NUM;
7844 sp->fifo_selector[i] = fifo_selector[i];
7866 rx_cfg->num_rxd = rx_ring_sz[i] * (rxd_count[sp->rxd_mode] + 1);
7869 ring->rxd_mode = sp->rxd_mode;
7870 ring->rxd_count = rxd_count[sp->rxd_mode];
7871 ring->pdev = sp->pdev;
7872 ring->dev = sp->dev;
7889 if (init_shared_mem(sp)) {
7895 sp->bar0 = pci_ioremap_bar(pdev, 0);
7896 if (!sp->bar0) {
7903 sp->bar1 = pci_ioremap_bar(pdev, 2);
7904 if (!sp->bar1) {
7912 dev->base_addr = (unsigned long)sp->bar0;
7916 mac_control->tx_FIFO_start[j] = sp->bar1 + (j * 0x00020000);
7927 if (sp->device_type & XFRAME_II_DEVICE) {
7932 if (sp->high_dma_flag == true)
7935 INIT_WORK(&sp->rst_timer_task, s2io_restart_nic);
7936 INIT_WORK(&sp->set_link_task, s2io_set_link);
7938 pci_save_state(sp->pdev);
7941 if (s2io_set_swapper(sp)) {
7949 if (sp->device_type & XFRAME_II_DEVICE) {
7950 mode = s2io_verify_pci_mode(sp);
7959 if (sp->config.intr_type == MSI_X) {
7960 sp->num_entries = config->rx_ring_num + 1;
7961 ret = s2io_enable_msi_x(sp);
7964 ret = s2io_test_msi(sp);
7966 remove_msix_isr(sp);
7972 sp->config.intr_type = INTA;
7983 netif_napi_add(dev, &sp->napi, s2io_poll_inta, 64);
7987 if (sp->device_type & XFRAME_I_DEVICE) {
7992 fix_mac_address(sp);
7993 s2io_reset(sp);
8000 bar0 = sp->bar0;
8011 sp->def_mac_addr[0].mac_addr[3] = (u8) (mac_up);
8012 sp->def_mac_addr[0].mac_addr[2] = (u8) (mac_up >> 8);
8013 sp->def_mac_addr[0].mac_addr[1] = (u8) (mac_up >> 16);
8014 sp->def_mac_addr[0].mac_addr[0] = (u8) (mac_up >> 24);
8015 sp->def_mac_addr[0].mac_addr[5] = (u8) (mac_down >> 16);
8016 sp->def_mac_addr[0].mac_addr[4] = (u8) (mac_down >> 24);
8020 memcpy(dev->dev_addr, sp->def_mac_addr, ETH_ALEN);
8024 if (sp->device_type == XFRAME_I_DEVICE) {
8028 } else if (sp->device_type == XFRAME_II_DEVICE) {
8035 do_s2io_store_unicast_mc(sp);
8038 if ((sp->device_type == XFRAME_II_DEVICE) &&
8040 sp->num_entries = config->rx_ring_num + 1;
8043 store_xmsi_data(sp);
8045 s2io_reset(sp);
8051 sp->state = 0;
8054 for (i = 0; i < sp->config.tx_fifo_num; i++) {
8064 subid = sp->pdev->subsystem_device;
8074 sp->rx_csum = 1; /* Rx chksum verify enabled by default */
8081 s2io_vpd_read(sp);
8084 sp->product_name, pdev->revision);
8088 DBG_PRINT(ERR_DBG, "Serial number: %s\n", sp->serial_num);
8089 if (sp->device_type & XFRAME_II_DEVICE) {
8090 mode = s2io_print_pci_mode(sp);
8097 switch (sp->rxd_mode) {
8108 switch (sp->config.napi) {
8118 sp->config.tx_fifo_num);
8121 sp->config.rx_ring_num);
8123 switch (sp->config.intr_type) {
8131 if (sp->config.multiq) {
8132 for (i = 0; i < sp->config.tx_fifo_num; i++) {
8143 switch (sp->config.tx_steering_type) {
8166 sprintf(sp->name, "%s Neterion %s", dev->name, sp->product_name);
8169 sp->vlan_strip_flag = 1;
8171 sp->vlan_strip_flag = 0;
8184 iounmap(sp->bar1);
8186 iounmap(sp->bar0);
8189 free_shared_mem(sp);
8210 struct s2io_nic *sp;
8217 sp = netdev_priv(dev);
8219 cancel_work_sync(&sp->rst_timer_task);
8220 cancel_work_sync(&sp->set_link_task);
8224 free_shared_mem(sp);
8225 iounmap(sp->bar0);
8226 iounmap(sp->bar1);
8260 struct s2io_nic *sp)
8279 if ((!sp->vlan_strip_flag) &&
8340 static void update_L3L4_header(struct s2io_nic *sp, struct lro *lro)
8345 struct swStat *swstats = &sp->mac_control.stats_info->sw_stat;
8454 struct RxD_t *rxdp, struct s2io_nic *sp)
8460 struct swStat *swstats = &sp->mac_control.stats_info->sw_stat;
8463 rxdp, sp);
8533 update_L3L4_header(sp, *lro);
8537 if ((*lro)->sg_num == sp->lro_max_aggr_per_sess) {
8538 update_L3L4_header(sp, *lro);
8560 struct s2io_nic *sp = netdev_priv(dev);
8563 if (vlan_tag && sp->vlan_strip_flag)
8565 if (sp->config.napi)
8571 static void lro_append_pkt(struct s2io_nic *sp, struct lro *lro,
8575 struct swStat *swstats = &sp->mac_control.stats_info->sw_stat;
8601 struct s2io_nic *sp = netdev_priv(netdev);
8610 do_s2io_card_down(sp, 0);
8629 struct s2io_nic *sp = netdev_priv(netdev);
8637 s2io_reset(sp);
8652 struct s2io_nic *sp = netdev_priv(netdev);
8655 if (s2io_card_up(sp)) {
8661 s2io_card_down(sp);