Lines Matching refs:adapter
54 static void netxen_schedule_work(struct netxen_adapter *adapter,
56 static void netxen_cancel_fw_work(struct netxen_adapter *adapter);
59 static void netxen_create_sysfs_entries(struct netxen_adapter *adapter);
60 static void netxen_remove_sysfs_entries(struct netxen_adapter *adapter);
61 static void netxen_create_diag_entries(struct netxen_adapter *adapter);
62 static void netxen_remove_diag_entries(struct netxen_adapter *adapter);
63 static int nx_dev_request_aer(struct netxen_adapter *adapter);
64 static int nx_decr_dev_ref_cnt(struct netxen_adapter *adapter);
65 static int netxen_can_start_firmware(struct netxen_adapter *adapter);
102 netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
105 NXWRIO(adapter, tx_ring->crb_cmd_producer, tx_ring->producer);
114 netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
117 NXWRIO(adapter, tx_ring->crb_cmd_consumer, tx_ring->sw_consumer);
131 struct netxen_adapter *adapter = sds_ring->adapter;
133 NXWRIO(adapter, sds_ring->crb_intr_mask, 0);
138 struct netxen_adapter *adapter = sds_ring->adapter;
140 NXWRIO(adapter, sds_ring->crb_intr_mask, 0x1);
142 if (!NETXEN_IS_MSI_FAMILY(adapter))
143 NXWRIO(adapter, adapter->tgt_mask_reg, 0xfbff);
164 netxen_napi_add(struct netxen_adapter *adapter, struct net_device *netdev)
168 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
170 if (netxen_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
173 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
182 netxen_napi_del(struct netxen_adapter *adapter)
186 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
188 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
193 netxen_free_sds_rings(&adapter->recv_ctx);
197 netxen_napi_enable(struct netxen_adapter *adapter)
201 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
203 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
211 netxen_napi_disable(struct netxen_adapter *adapter)
215 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
217 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
225 static int nx_set_dma_mask(struct netxen_adapter *adapter)
227 struct pci_dev *pdev = adapter->pdev;
230 adapter->pci_using_dac = 0;
235 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
244 adapter->pci_using_dac = 1;
253 nx_update_dma_mask(struct netxen_adapter *adapter)
257 struct pci_dev *pdev = adapter->pdev;
261 shift = NXRD32(adapter, CRB_DMA_SHIFT);
265 if (NX_IS_REVISION_P3(adapter->ahw.revision_id) && (shift > 9))
267 else if ((adapter->ahw.revision_id == NX_P2_C1) && (shift <= 4))
280 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
298 netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot)
304 NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
306 if (!NX_IS_REVISION_P2(adapter->ahw.revision_id))
310 first_boot = NXRD32(adapter, NETXEN_PCIE_REG(0x4));
313 NXWR32(adapter, NETXEN_PCIE_REG(0x4), first_boot);
314 NXRD32(adapter, NETXEN_PCIE_REG(0x4));
318 first_boot = NXRD32(adapter, NETXEN_ROMUSB_GLB_SW_RESET);
321 NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), 0);
326 val = NXRD32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
327 NXWR32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE, val | 0x1);
331 val = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
341 static void netxen_set_port_mode(struct netxen_adapter *adapter)
345 val = adapter->ahw.board_type;
350 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
353 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
356 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
359 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
362 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
371 NXWR32(adapter, NETXEN_WOL_PORT_MODE, wol_port_mode);
377 static void netxen_pcie_strap_init(struct netxen_adapter *adapter)
386 pdev = adapter->pdev;
388 chicken = NXRD32(adapter, NETXEN_PCIE_REG(PCIE_CHICKEN3));
402 dev_info(&adapter->pdev->dev, "Gen2 strapping detected\n");
407 dev_info(&adapter->pdev->dev, "Gen1 strapping detected\n");
408 if (adapter->ahw.revision_id == NX_P3_B0)
414 NXWR32(adapter, NETXEN_PCIE_REG(PCIE_CHICKEN3), chicken);
446 static void netxen_init_msix_entries(struct netxen_adapter *adapter, int count)
451 adapter->msix_entries[i].entry = i;
455 netxen_read_mac_addr(struct netxen_adapter *adapter)
460 struct net_device *netdev = adapter->netdev;
461 struct pci_dev *pdev = adapter->pdev;
464 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
465 if (netxen_p3_get_mac_addr(adapter, &mac_addr) != 0)
468 if (netxen_get_flash_mac_addr(adapter, &mac_addr) != 0)
477 memcpy(adapter->mac_addr, netdev->dev_addr, netdev->addr_len);
489 struct netxen_adapter *adapter = netdev_priv(netdev);
497 netxen_napi_disable(adapter);
500 memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
502 adapter->macaddr_set(adapter, addr->sa_data);
506 netxen_napi_enable(adapter);
513 struct netxen_adapter *adapter = netdev_priv(dev);
515 adapter->set_multi(dev);
533 struct netxen_adapter *adapter = netdev_priv(dev);
542 if (netxen_config_hw_lro(adapter, hw_lro))
545 if (!(features & NETIF_F_LRO) && netxen_send_lro_cleanup(adapter))
565 static inline void netxen_set_interrupt_mode(struct netxen_adapter *adapter,
568 NXWR32(adapter, NETXEN_INTR_MODE_REG, mode);
571 static inline u32 netxen_get_interrupt_mode(struct netxen_adapter *adapter)
573 return NXRD32(adapter, NETXEN_INTR_MODE_REG);
577 netxen_initialize_interrupt_registers(struct netxen_adapter *adapter)
582 if (adapter->ahw.revision_id >= NX_P3_B0)
583 legacy_intrp = &legacy_intr[adapter->ahw.pci_func];
590 adapter->int_vec_bit = legacy_intrp->int_vec_bit;
591 adapter->tgt_status_reg = netxen_get_ioaddr(adapter, tgt_status_reg);
592 adapter->tgt_mask_reg = netxen_get_ioaddr(adapter,
594 adapter->pci_int_reg = netxen_get_ioaddr(adapter,
596 adapter->isr_int_vec = netxen_get_ioaddr(adapter, ISR_INT_VECTOR);
598 if (adapter->ahw.revision_id >= NX_P3_B1)
599 adapter->crb_int_state_reg = netxen_get_ioaddr(adapter,
602 adapter->crb_int_state_reg = netxen_get_ioaddr(adapter,
606 static int netxen_setup_msi_interrupts(struct netxen_adapter *adapter,
609 struct pci_dev *pdev = adapter->pdev;
613 if (adapter->msix_supported) {
614 netxen_init_msix_entries(adapter, num_msix);
615 err = pci_enable_msix_range(pdev, adapter->msix_entries,
618 adapter->flags |= NETXEN_NIC_MSIX_ENABLED;
621 if (adapter->rss_supported)
622 adapter->max_sds_rings = num_msix;
631 value = msi_tgt_status[adapter->ahw.pci_func];
632 adapter->flags |= NETXEN_NIC_MSI_ENABLED;
633 adapter->tgt_status_reg = netxen_get_ioaddr(adapter, value);
634 adapter->msix_entries[0].vector = pdev->irq;
643 static int netxen_setup_intr(struct netxen_adapter *adapter)
645 struct pci_dev *pdev = adapter->pdev;
648 if (adapter->rss_supported)
654 adapter->max_sds_rings = 1;
655 adapter->flags &= ~(NETXEN_NIC_MSI_ENABLED | NETXEN_NIC_MSIX_ENABLED);
657 netxen_initialize_interrupt_registers(adapter);
660 if (adapter->portnum == 0) {
661 if (!netxen_setup_msi_interrupts(adapter, num_msix))
662 netxen_set_interrupt_mode(adapter, NETXEN_MSI_MODE);
664 netxen_set_interrupt_mode(adapter, NETXEN_INTX_MODE);
666 if (netxen_get_interrupt_mode(adapter) == NETXEN_MSI_MODE &&
667 netxen_setup_msi_interrupts(adapter, num_msix)) {
673 if (!NETXEN_IS_MSI_FAMILY(adapter)) {
674 adapter->msix_entries[0].vector = pdev->irq;
681 netxen_teardown_intr(struct netxen_adapter *adapter)
683 if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
684 pci_disable_msix(adapter->pdev);
685 if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
686 pci_disable_msi(adapter->pdev);
690 netxen_cleanup_pci_map(struct netxen_adapter *adapter)
692 if (adapter->ahw.db_base != NULL)
693 iounmap(adapter->ahw.db_base);
694 if (adapter->ahw.pci_base0 != NULL)
695 iounmap(adapter->ahw.pci_base0);
696 if (adapter->ahw.pci_base1 != NULL)
697 iounmap(adapter->ahw.pci_base1);
698 if (adapter->ahw.pci_base2 != NULL)
699 iounmap(adapter->ahw.pci_base2);
703 netxen_setup_pci_map(struct netxen_adapter *adapter)
710 struct pci_dev *pdev = adapter->pdev;
711 int pci_func = adapter->ahw.pci_func;
712 struct netxen_hardware_context *ahw = &adapter->ahw;
720 adapter->ahw.crb_win = -1;
721 adapter->ahw.ocm_win = -1;
767 netxen_setup_hwops(adapter);
771 if (NX_IS_REVISION_P3P(adapter->ahw.revision_id)) {
772 adapter->ahw.ocm_win_crb = netxen_get_ioaddr(adapter,
775 } else if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
776 adapter->ahw.ocm_win_crb = netxen_get_ioaddr(adapter,
780 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
802 adapter->ahw.db_base = db_ptr;
803 adapter->ahw.db_len = db_len;
807 netxen_cleanup_pci_map(adapter);
812 netxen_check_options(struct netxen_adapter *adapter)
819 struct pci_dev *pdev = adapter->pdev;
821 adapter->driver_mismatch = 0;
826 err = netxen_rom_fast_read(adapter, offset, &val);
829 adapter->driver_mismatch = 1;
836 fw_major = NXRD32(adapter, NETXEN_FW_VERSION_MAJOR);
837 fw_minor = NXRD32(adapter, NETXEN_FW_VERSION_MINOR);
838 fw_build = NXRD32(adapter, NETXEN_FW_VERSION_SUB);
839 prev_fw_version = adapter->fw_version;
840 adapter->fw_version = NETXEN_VERSION_CODE(fw_major, fw_minor, fw_build);
843 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
844 if (adapter->mdump.md_template == NULL ||
845 adapter->fw_version > prev_fw_version) {
846 kfree(adapter->mdump.md_template);
847 adapter->mdump.md_template = NULL;
848 err = netxen_setup_minidump(adapter);
850 dev_err(&adapter->pdev->dev,
855 if (adapter->portnum == 0) {
856 if (netxen_nic_get_brd_name_by_type(adapter->ahw.board_type,
862 brd_name, serial_num, adapter->ahw.revision_id);
865 if (adapter->fw_version < NETXEN_VERSION_CODE(3, 4, 216)) {
866 adapter->driver_mismatch = 1;
872 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
873 i = NXRD32(adapter, NETXEN_SRE_MISC);
874 adapter->ahw.cut_through = (i & 0x8000) ? 1 : 0;
879 adapter->ahw.cut_through ? "cut-through" : "legacy");
881 if (adapter->fw_version >= NETXEN_VERSION_CODE(4, 0, 222))
882 adapter->capabilities = NXRD32(adapter, CRB_FW_CAPABILITIES_1);
884 if (adapter->ahw.port_type == NETXEN_NIC_XGBE) {
885 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
886 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
887 } else if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
888 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
889 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
892 adapter->msix_supported = 0;
893 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
894 adapter->msix_supported = !!use_msi_x;
895 adapter->rss_supported = !!use_msi_x;
898 netxen_rom_fast_read(adapter,
903 switch (adapter->ahw.board_type) {
906 adapter->msix_supported = !!use_msi_x;
907 adapter->rss_supported = !!use_msi_x;
915 adapter->num_txd = MAX_CMD_DESCRIPTORS;
917 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
918 adapter->num_lro_rxd = MAX_LRO_RCV_DESCRIPTORS;
919 adapter->max_rds_rings = 3;
921 adapter->num_lro_rxd = 0;
922 adapter->max_rds_rings = 2;
927 netxen_start_firmware(struct netxen_adapter *adapter)
930 struct pci_dev *pdev = adapter->pdev;
933 err = nx_set_dma_mask(adapter);
937 err = netxen_can_start_firmware(adapter);
945 first_boot = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
947 err = netxen_check_hw_init(adapter, first_boot);
953 netxen_request_firmware(adapter);
955 err = netxen_need_fw_reset(adapter);
962 NXWR32(adapter, CRB_CMDPEG_STATE, 0);
963 netxen_pinit_from_rom(adapter);
967 NXWR32(adapter, CRB_DMA_SHIFT, 0x55555555);
968 NXWR32(adapter, NETXEN_PEG_HALT_STATUS1, 0);
969 NXWR32(adapter, NETXEN_PEG_HALT_STATUS2, 0);
971 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
972 netxen_set_port_mode(adapter);
974 err = netxen_load_firmware(adapter);
978 netxen_release_firmware(adapter);
980 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
984 if (adapter->ahw.port_type == NETXEN_NIC_XGBE)
986 NXWR32(adapter, NETXEN_MAC_ADDR_CNTL_REG, val);
990 err = netxen_init_dummy_dma(adapter);
1000 NXWR32(adapter, CRB_DRIVER_VERSION, val);
1003 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1004 netxen_pcie_strap_init(adapter);
1008 err = netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
1010 netxen_free_dummy_dma(adapter);
1014 NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_READY);
1016 nx_update_dma_mask(adapter);
1018 netxen_check_options(adapter);
1020 adapter->need_fw_reset = 0;
1025 netxen_release_firmware(adapter);
1030 netxen_nic_request_irq(struct netxen_adapter *adapter)
1037 struct net_device *netdev = adapter->netdev;
1038 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
1040 if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
1042 else if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
1048 adapter->irq = netdev->irq;
1050 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1063 netxen_nic_free_irq(struct netxen_adapter *adapter)
1068 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
1070 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1077 netxen_nic_init_coalesce_defaults(struct netxen_adapter *adapter)
1079 adapter->coal.flags = NETXEN_NIC_INTR_DEFAULT;
1080 adapter->coal.normal.data.rx_time_us =
1082 adapter->coal.normal.data.rx_packets =
1084 adapter->coal.normal.data.tx_time_us =
1086 adapter->coal.normal.data.tx_packets =
1092 __netxen_nic_up(struct netxen_adapter *adapter, struct net_device *netdev)
1096 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
1099 err = adapter->init_port(adapter, adapter->physical_port);
1102 netxen_nic_driver_name, adapter->portnum);
1105 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
1106 adapter->macaddr_set(adapter, adapter->mac_addr);
1108 adapter->set_multi(netdev);
1109 adapter->set_mtu(adapter, netdev->mtu);
1111 adapter->ahw.linkup = 0;
1113 if (adapter->max_sds_rings > 1)
1114 netxen_config_rss(adapter, 1);
1116 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1117 netxen_config_intr_coalesce(adapter);
1120 netxen_config_hw_lro(adapter, NETXEN_NIC_LRO_ENABLED);
1122 netxen_napi_enable(adapter);
1124 if (adapter->capabilities & NX_FW_CAPABILITY_LINK_NOTIFICATION)
1125 netxen_linkevent_request(adapter, 1);
1127 netxen_nic_set_link_parameters(adapter);
1129 set_bit(__NX_DEV_UP, &adapter->state);
1136 netxen_nic_up(struct netxen_adapter *adapter, struct net_device *netdev)
1142 err = __netxen_nic_up(adapter, netdev);
1150 __netxen_nic_down(struct netxen_adapter *adapter, struct net_device *netdev)
1152 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
1155 if (!test_and_clear_bit(__NX_DEV_UP, &adapter->state))
1162 if (adapter->capabilities & NX_FW_CAPABILITY_LINK_NOTIFICATION)
1163 netxen_linkevent_request(adapter, 0);
1165 if (adapter->stop_port)
1166 adapter->stop_port(adapter);
1168 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1169 netxen_p3_free_mac_list(adapter);
1171 adapter->set_promisc(adapter, NETXEN_NIU_NON_PROMISC_MODE);
1173 netxen_napi_disable(adapter);
1175 netxen_release_tx_buffers(adapter);
1181 netxen_nic_down(struct netxen_adapter *adapter, struct net_device *netdev)
1185 __netxen_nic_down(adapter, netdev);
1191 netxen_nic_attach(struct netxen_adapter *adapter)
1193 struct net_device *netdev = adapter->netdev;
1194 struct pci_dev *pdev = adapter->pdev;
1200 if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC)
1203 err = netxen_init_firmware(adapter);
1207 adapter->flags &= ~NETXEN_FW_MSS_CAP;
1208 if (adapter->capabilities & NX_FW_CAPABILITY_MORE_CAPS) {
1209 capab2 = NXRD32(adapter, CRB_FW_CAPABILITIES_2);
1211 adapter->flags |= NETXEN_FW_MSS_CAP;
1214 err = netxen_napi_add(adapter, netdev);
1218 err = netxen_alloc_sw_resources(adapter);
1225 err = netxen_alloc_hw_resources(adapter);
1232 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
1233 tx_ring = adapter->tx_ring;
1234 tx_ring->crb_cmd_producer = netxen_get_ioaddr(adapter,
1235 crb_cmd_producer[adapter->portnum]);
1236 tx_ring->crb_cmd_consumer = netxen_get_ioaddr(adapter,
1237 crb_cmd_consumer[adapter->portnum]);
1242 netxen_nic_update_cmd_producer(adapter, tx_ring);
1243 netxen_nic_update_cmd_consumer(adapter, tx_ring);
1246 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1247 rds_ring = &adapter->recv_ctx.rds_rings[ring];
1248 netxen_post_rx_buffers(adapter, ring, rds_ring);
1251 err = netxen_nic_request_irq(adapter);
1258 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1259 netxen_nic_init_coalesce_defaults(adapter);
1261 netxen_create_sysfs_entries(adapter);
1263 adapter->is_up = NETXEN_ADAPTER_UP_MAGIC;
1267 netxen_release_rx_buffers(adapter);
1268 netxen_free_hw_resources(adapter);
1270 netxen_free_sw_resources(adapter);
1275 netxen_nic_detach(struct netxen_adapter *adapter)
1277 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
1280 netxen_remove_sysfs_entries(adapter);
1282 netxen_free_hw_resources(adapter);
1283 netxen_release_rx_buffers(adapter);
1284 netxen_nic_free_irq(adapter);
1285 netxen_napi_del(adapter);
1286 netxen_free_sw_resources(adapter);
1288 adapter->is_up = 0;
1292 netxen_nic_reset_context(struct netxen_adapter *adapter)
1295 struct net_device *netdev = adapter->netdev;
1297 if (test_and_set_bit(__NX_RESETTING, &adapter->state))
1300 if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC) {
1305 __netxen_nic_down(adapter, netdev);
1307 netxen_nic_detach(adapter);
1310 err = netxen_nic_attach(adapter);
1312 err = __netxen_nic_up(adapter, netdev);
1322 clear_bit(__NX_RESETTING, &adapter->state);
1327 netxen_setup_netdev(struct netxen_adapter *adapter,
1331 struct pci_dev *pdev = adapter->pdev;
1333 adapter->mc_enabled = 0;
1334 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1335 adapter->max_mc_count = 38;
1337 adapter->max_mc_count = 16;
1349 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1354 if (adapter->pci_using_dac) {
1359 if (adapter->capabilities & NX_FW_CAPABILITY_FVLANTX)
1362 if (adapter->capabilities & NX_FW_CAPABILITY_HW_LRO)
1367 netdev->irq = adapter->msix_entries[0].vector;
1369 INIT_WORK(&adapter->tx_timeout_task, netxen_tx_timeout_task);
1371 if (netxen_read_mac_addr(adapter))
1388 static void netxen_read_ula_info(struct netxen_adapter *adapter)
1392 /* Print ULA info only once for an adapter */
1393 if (adapter->portnum != 0)
1396 temp = NXRD32(adapter, NETXEN_ULA_KEY);
1399 dev_info(&adapter->pdev->dev, "ULA adapter");
1402 dev_info(&adapter->pdev->dev, "non ULA adapter");
1412 static void netxen_mask_aer_correctable(struct netxen_adapter *adapter)
1414 struct pci_dev *pdev = adapter->pdev;
1422 if (adapter->ahw.board_type != NETXEN_BRDTYPE_P3_4_GB_MM &&
1423 adapter->ahw.board_type != NETXEN_BRDTYPE_P3_10G_TP)
1441 struct netxen_adapter *adapter = NULL;
1474 adapter = netdev_priv(netdev);
1475 adapter->netdev = netdev;
1476 adapter->pdev = pdev;
1477 adapter->ahw.pci_func = pci_func_id;
1480 adapter->ahw.revision_id = revision_id;
1482 rwlock_init(&adapter->ahw.crb_lock);
1483 spin_lock_init(&adapter->ahw.mem_lock);
1485 spin_lock_init(&adapter->tx_clean_lock);
1486 INIT_LIST_HEAD(&adapter->mac_list);
1487 INIT_LIST_HEAD(&adapter->ip_list);
1489 err = netxen_setup_pci_map(adapter);
1494 adapter->portnum = pci_func_id;
1496 err = netxen_nic_get_board_info(adapter);
1503 netxen_mask_aer_correctable(adapter);
1507 switch (adapter->ahw.board_type) {
1511 adapter->portnum = pci_func_id - 2;
1517 err = netxen_check_flash_fw_compatibility(adapter);
1521 if (adapter->portnum == 0) {
1522 val = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
1524 NXWR32(adapter, NX_CRB_DEV_REF_COUNT, 0);
1525 adapter->need_fw_reset = 1;
1529 err = netxen_start_firmware(adapter);
1536 adapter->physical_port = adapter->portnum;
1537 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
1538 i = NXRD32(adapter, CRB_V2P(adapter->portnum));
1540 adapter->physical_port = i;
1545 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1550 netxen_nic_clear_stats(adapter);
1552 err = netxen_setup_intr(adapter);
1555 dev_err(&adapter->pdev->dev,
1560 netxen_read_ula_info(adapter);
1562 err = netxen_setup_netdev(adapter, netdev);
1566 pci_set_drvdata(pdev, adapter);
1568 netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
1570 switch (adapter->ahw.port_type) {
1572 dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
1573 adapter->netdev->name);
1576 dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
1577 adapter->netdev->name);
1581 netxen_create_diag_entries(adapter);
1586 netxen_teardown_intr(adapter);
1588 netxen_free_dummy_dma(adapter);
1591 nx_decr_dev_ref_cnt(adapter);
1594 netxen_cleanup_pci_map(adapter);
1608 void netxen_cleanup_minidump(struct netxen_adapter *adapter)
1610 kfree(adapter->mdump.md_template);
1611 adapter->mdump.md_template = NULL;
1613 if (adapter->mdump.md_capture_buff) {
1614 vfree(adapter->mdump.md_capture_buff);
1615 adapter->mdump.md_capture_buff = NULL;
1621 struct netxen_adapter *adapter;
1624 adapter = pci_get_drvdata(pdev);
1625 if (adapter == NULL)
1628 netdev = adapter->netdev;
1630 netxen_cancel_fw_work(adapter);
1634 cancel_work_sync(&adapter->tx_timeout_task);
1636 netxen_free_ip_list(adapter, false);
1637 netxen_nic_detach(adapter);
1639 nx_decr_dev_ref_cnt(adapter);
1641 if (adapter->portnum == 0)
1642 netxen_free_dummy_dma(adapter);
1644 clear_bit(__NX_RESETTING, &adapter->state);
1646 netxen_teardown_intr(adapter);
1647 netxen_set_interrupt_mode(adapter, 0);
1648 netxen_remove_diag_entries(adapter);
1650 netxen_cleanup_pci_map(adapter);
1652 netxen_release_firmware(adapter);
1655 netxen_cleanup_minidump(adapter);
1663 static void netxen_nic_detach_func(struct netxen_adapter *adapter)
1665 struct net_device *netdev = adapter->netdev;
1669 netxen_cancel_fw_work(adapter);
1672 netxen_nic_down(adapter, netdev);
1674 cancel_work_sync(&adapter->tx_timeout_task);
1676 netxen_nic_detach(adapter);
1678 if (adapter->portnum == 0)
1679 netxen_free_dummy_dma(adapter);
1681 nx_decr_dev_ref_cnt(adapter);
1683 clear_bit(__NX_RESETTING, &adapter->state);
1688 struct netxen_adapter *adapter = pci_get_drvdata(pdev);
1689 struct net_device *netdev = adapter->netdev;
1694 adapter->ahw.crb_win = -1;
1695 adapter->ahw.ocm_win = -1;
1697 err = netxen_start_firmware(adapter);
1704 err = netxen_nic_attach(adapter);
1708 err = netxen_nic_up(adapter, netdev);
1716 netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
1720 netxen_nic_detach(adapter);
1722 nx_decr_dev_ref_cnt(adapter);
1743 struct netxen_adapter *adapter = pci_get_drvdata(pdev);
1748 if (nx_dev_request_aer(adapter))
1751 netxen_nic_detach_func(adapter);
1769 struct netxen_adapter *adapter = pci_get_drvdata(pdev);
1771 netxen_nic_detach_func(adapter);
1776 if (netxen_nic_wol_supported(adapter)) {
1787 struct netxen_adapter *adapter = dev_get_drvdata(dev_d);
1789 netxen_nic_detach_func(adapter);
1791 if (netxen_nic_wol_supported(adapter))
1805 struct netxen_adapter *adapter = netdev_priv(netdev);
1808 if (adapter->driver_mismatch)
1811 err = netxen_nic_attach(adapter);
1815 err = __netxen_nic_up(adapter, netdev);
1824 netxen_nic_detach(adapter);
1833 struct netxen_adapter *adapter = netdev_priv(netdev);
1835 __netxen_nic_down(adapter, netdev);
2022 struct netxen_adapter *adapter = netdev_priv(netdev);
2023 struct nx_host_tx_ring *tx_ring = adapter->tx_ring;
2066 pdev = adapter->pdev;
2078 netxen_set_tx_port(first_desc, adapter->portnum);
2115 adapter->stats.txbytes += skb->len;
2116 adapter->stats.xmitcalled++;
2118 netxen_nic_update_cmd_producer(adapter, tx_ring);
2123 adapter->stats.txdropped++;
2128 static int netxen_nic_check_temp(struct netxen_adapter *adapter)
2130 struct net_device *netdev = adapter->netdev;
2134 temp = NXRD32(adapter, CRB_TEMP_STATE);
2146 if (adapter->temp == NX_TEMP_NORMAL) {
2154 if (adapter->temp == NX_TEMP_WARN) {
2161 adapter->temp = temp_state;
2165 void netxen_advert_link_change(struct netxen_adapter *adapter, int linkup)
2167 struct net_device *netdev = adapter->netdev;
2169 if (adapter->ahw.linkup && !linkup) {
2172 adapter->ahw.linkup = 0;
2177 adapter->link_changed = !adapter->has_link_events;
2178 } else if (!adapter->ahw.linkup && linkup) {
2181 adapter->ahw.linkup = 1;
2186 adapter->link_changed = !adapter->has_link_events;
2190 static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
2194 port = adapter->physical_port;
2196 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
2197 val = NXRD32(adapter, CRB_XG_STATE_P3);
2198 val = XG_LINK_STATE_P3(adapter->ahw.pci_func, val);
2201 val = NXRD32(adapter, CRB_XG_STATE);
2206 netxen_advert_link_change(adapter, linkup);
2211 struct netxen_adapter *adapter = netdev_priv(netdev);
2213 if (test_bit(__NX_RESETTING, &adapter->state))
2217 schedule_work(&adapter->tx_timeout_task);
2222 struct netxen_adapter *adapter =
2225 if (!netif_running(adapter->netdev))
2228 if (test_and_set_bit(__NX_RESETTING, &adapter->state))
2231 if (++adapter->tx_timeo_cnt >= NX_MAX_TX_TIMEOUTS)
2235 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
2237 netxen_napi_disable(adapter);
2239 netxen_napi_enable(adapter);
2241 netif_wake_queue(adapter->netdev);
2243 clear_bit(__NX_RESETTING, &adapter->state);
2245 clear_bit(__NX_RESETTING, &adapter->state);
2246 if (netxen_nic_reset_context(adapter)) {
2251 netif_trans_update(adapter->netdev);
2256 adapter->need_fw_reset = 1;
2257 clear_bit(__NX_RESETTING, &adapter->state);
2263 struct netxen_adapter *adapter = netdev_priv(netdev);
2265 stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
2266 stats->tx_packets = adapter->stats.xmitfinished;
2267 stats->rx_bytes = adapter->stats.rxbytes;
2268 stats->tx_bytes = adapter->stats.txbytes;
2269 stats->rx_dropped = adapter->stats.rxdropped;
2270 stats->tx_dropped = adapter->stats.txdropped;
2276 struct netxen_adapter *adapter = sds_ring->adapter;
2279 status = readl(adapter->isr_int_vec);
2281 if (!(status & adapter->int_vec_bit))
2284 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
2286 status = readl(adapter->crb_int_state_reg);
2293 our_int = readl(adapter->crb_int_state_reg);
2296 if (!test_and_clear_bit((7 + adapter->portnum), &our_int))
2300 writel((our_int & 0xffffffff), adapter->crb_int_state_reg);
2306 writel(0xffffffff, adapter->tgt_status_reg);
2308 readl(adapter->isr_int_vec);
2309 readl(adapter->isr_int_vec);
2319 struct netxen_adapter *adapter = sds_ring->adapter;
2322 writel(0xffffffff, adapter->tgt_status_reg);
2341 struct netxen_adapter *adapter = sds_ring->adapter;
2346 tx_complete = netxen_process_cmd_ring(adapter);
2355 if (test_bit(__NX_DEV_UP, &adapter->state))
2363 nx_incr_dev_ref_cnt(struct netxen_adapter *adapter)
2366 if (netxen_api_lock(adapter))
2369 count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2371 NXWR32(adapter, NX_CRB_DEV_REF_COUNT, ++count);
2373 netxen_api_unlock(adapter);
2378 nx_decr_dev_ref_cnt(struct netxen_adapter *adapter)
2381 if (netxen_api_lock(adapter))
2384 count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2387 NXWR32(adapter, NX_CRB_DEV_REF_COUNT, --count);
2388 state = NXRD32(adapter, NX_CRB_DEV_STATE);
2391 NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_COLD);
2393 netxen_api_unlock(adapter);
2398 nx_dev_request_aer(struct netxen_adapter *adapter)
2403 if (netxen_api_lock(adapter))
2406 state = NXRD32(adapter, NX_CRB_DEV_STATE);
2411 NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_NEED_AER);
2415 netxen_api_unlock(adapter);
2420 nx_dev_request_reset(struct netxen_adapter *adapter)
2425 if (netxen_api_lock(adapter))
2428 state = NXRD32(adapter, NX_CRB_DEV_STATE);
2433 NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_NEED_RESET);
2434 adapter->flags |= NETXEN_FW_RESET_OWNER;
2438 netxen_api_unlock(adapter);
2444 netxen_can_start_firmware(struct netxen_adapter *adapter)
2449 if (netxen_api_lock(adapter)) {
2450 nx_incr_dev_ref_cnt(adapter);
2454 count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2461 NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_INITALIZING);
2464 NXWR32(adapter, NX_CRB_DEV_REF_COUNT, ++count);
2466 netxen_api_unlock(adapter);
2472 netxen_schedule_work(struct netxen_adapter *adapter,
2475 INIT_DELAYED_WORK(&adapter->fw_work, func);
2476 schedule_delayed_work(&adapter->fw_work, delay);
2480 netxen_cancel_fw_work(struct netxen_adapter *adapter)
2482 while (test_and_set_bit(__NX_RESETTING, &adapter->state))
2485 cancel_delayed_work_sync(&adapter->fw_work);
2491 struct netxen_adapter *adapter = container_of(work,
2493 struct net_device *netdev = adapter->netdev;
2497 err = netxen_nic_attach(adapter);
2501 err = netxen_nic_up(adapter, netdev);
2503 netxen_nic_detach(adapter);
2513 adapter->fw_fail_cnt = 0;
2514 clear_bit(__NX_RESETTING, &adapter->state);
2515 netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
2521 struct netxen_adapter *adapter = container_of(work,
2525 dev_state = NXRD32(adapter, NX_CRB_DEV_STATE);
2526 if (adapter->flags & NETXEN_FW_RESET_OWNER) {
2527 count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2530 if (adapter->mdump.md_enabled) {
2532 netxen_dump_fw(adapter);
2535 adapter->flags &= ~NETXEN_FW_RESET_OWNER;
2536 if (netxen_api_lock(adapter)) {
2537 clear_bit(__NX_RESETTING, &adapter->state);
2538 NXWR32(adapter, NX_CRB_DEV_STATE,
2542 count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2543 NXWR32(adapter, NX_CRB_DEV_REF_COUNT, --count);
2544 NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_COLD);
2546 netxen_api_unlock(adapter);
2553 if (!netxen_start_firmware(adapter)) {
2554 netxen_schedule_work(adapter, netxen_attach_work, 0);
2561 netxen_schedule_work(adapter,
2567 nx_incr_dev_ref_cnt(adapter);
2571 if (netxen_api_lock(adapter)) {
2572 clear_bit(__NX_RESETTING, &adapter->state);
2575 NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_FAILED);
2576 netxen_api_unlock(adapter);
2577 dev_err(&adapter->pdev->dev, "%s: Device initialization Failed\n",
2578 adapter->netdev->name);
2580 clear_bit(__NX_RESETTING, &adapter->state);
2586 struct netxen_adapter *adapter = container_of(work,
2588 struct net_device *netdev = adapter->netdev;
2594 netxen_nic_down(adapter, netdev);
2597 netxen_nic_detach(adapter);
2600 status = NXRD32(adapter, NETXEN_PEG_HALT_STATUS1);
2605 if (adapter->temp == NX_TEMP_PANIC)
2608 if (!(adapter->flags & NETXEN_FW_RESET_OWNER))
2609 ref_cnt = nx_decr_dev_ref_cnt(adapter);
2616 adapter->fw_wait_cnt = 0;
2617 netxen_schedule_work(adapter, netxen_fwinit_work, delay);
2622 clear_bit(__NX_RESETTING, &adapter->state);
2626 netxen_check_health(struct netxen_adapter *adapter)
2630 struct net_device *netdev = adapter->netdev;
2632 state = NXRD32(adapter, NX_CRB_DEV_STATE);
2636 if (netxen_nic_check_temp(adapter))
2639 if (adapter->need_fw_reset) {
2640 if (nx_dev_request_reset(adapter))
2651 adapter->need_fw_reset = 1;
2652 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
2656 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
2659 heartbit = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
2660 if (heartbit != adapter->heartbit) {
2661 adapter->heartbit = heartbit;
2662 adapter->fw_fail_cnt = 0;
2663 if (adapter->need_fw_reset)
2668 if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
2671 if (nx_dev_request_reset(adapter))
2674 clear_bit(__NX_FW_ATTACHED, &adapter->state);
2677 peg_status = NXRD32(adapter, NETXEN_PEG_HALT_STATUS1);
2678 dev_err(&adapter->pdev->dev, "Dumping hw/fw registers\n"
2684 NXRD32(adapter, NETXEN_PEG_HALT_STATUS2),
2685 NXRD32(adapter, NETXEN_CRB_PEG_NET_0 + 0x3c),
2686 NXRD32(adapter, NETXEN_CRB_PEG_NET_1 + 0x3c),
2687 NXRD32(adapter, NETXEN_CRB_PEG_NET_2 + 0x3c),
2688 NXRD32(adapter, NETXEN_CRB_PEG_NET_3 + 0x3c),
2689 NXRD32(adapter, NETXEN_CRB_PEG_NET_4 + 0x3c));
2691 dev_err(&adapter->pdev->dev,
2696 !test_and_set_bit(__NX_RESETTING, &adapter->state))
2697 netxen_schedule_work(adapter, netxen_detach_work, 0);
2704 struct netxen_adapter *adapter = container_of(work,
2707 if (test_bit(__NX_RESETTING, &adapter->state))
2710 if (test_bit(__NX_DEV_UP, &adapter->state) &&
2711 !(adapter->capabilities & NX_FW_CAPABILITY_LINK_NOTIFICATION)) {
2712 if (!adapter->has_link_events) {
2714 netxen_nic_handle_phy_intr(adapter);
2716 if (adapter->link_changed)
2717 netxen_nic_set_link_parameters(adapter);
2721 if (netxen_check_health(adapter))
2725 netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
2733 struct netxen_adapter *adapter = netdev_priv(net);
2737 if (!(adapter->capabilities & NX_FW_CAPABILITY_BDG))
2740 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
2746 if (!netxen_config_bridged_mode(adapter, !!new))
2758 struct netxen_adapter *adapter;
2761 adapter = netdev_priv(net);
2763 if (adapter->capabilities & NX_FW_CAPABILITY_BDG)
2764 bridged_mode = !!(adapter->flags & NETXEN_NIC_BRIDGE_ENABLED);
2779 struct netxen_adapter *adapter = dev_get_drvdata(dev);
2785 if (!!new != !!(adapter->flags & NETXEN_NIC_DIAG_ENABLED))
2786 adapter->flags ^= NETXEN_NIC_DIAG_ENABLED;
2795 struct netxen_adapter *adapter = dev_get_drvdata(dev);
2798 !!(adapter->flags & NETXEN_NIC_DIAG_ENABLED));
2808 netxen_sysfs_validate_crb(struct netxen_adapter *adapter,
2813 if (!(adapter->flags & NETXEN_NIC_DIAG_ENABLED))
2817 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
2839 struct netxen_adapter *adapter = dev_get_drvdata(dev);
2844 ret = netxen_sysfs_validate_crb(adapter, offset, size);
2848 if (NX_IS_REVISION_P3(adapter->ahw.revision_id) &&
2851 netxen_pci_camqm_read_2M(adapter, offset, &qmdata);
2854 data = NXRD32(adapter, offset);
2867 struct netxen_adapter *adapter = dev_get_drvdata(dev);
2872 ret = netxen_sysfs_validate_crb(adapter, offset, size);
2876 if (NX_IS_REVISION_P3(adapter->ahw.revision_id) &&
2880 netxen_pci_camqm_write_2M(adapter, offset, qmdata);
2883 NXWR32(adapter, offset, data);
2890 netxen_sysfs_validate_mem(struct netxen_adapter *adapter,
2893 if (!(adapter->flags & NETXEN_NIC_DIAG_ENABLED))
2908 struct netxen_adapter *adapter = dev_get_drvdata(dev);
2912 ret = netxen_sysfs_validate_mem(adapter, offset, size);
2916 if (adapter->pci_mem_read(adapter, offset, &data))
2929 struct netxen_adapter *adapter = dev_get_drvdata(dev);
2933 ret = netxen_sysfs_validate_mem(adapter, offset, size);
2939 if (adapter->pci_mem_write(adapter, offset, data))
2966 struct netxen_adapter *adapter = dev_get_drvdata(dev);
2967 struct net_device *netdev = adapter->netdev;
2978 val = NXRD32(adapter, NETXEN_DIMM_CAPABILITY);
3090 netxen_create_sysfs_entries(struct netxen_adapter *adapter)
3092 struct device *dev = &adapter->pdev->dev;
3094 if (adapter->capabilities & NX_FW_CAPABILITY_BDG) {
3104 netxen_remove_sysfs_entries(struct netxen_adapter *adapter)
3106 struct device *dev = &adapter->pdev->dev;
3108 if (adapter->capabilities & NX_FW_CAPABILITY_BDG)
3113 netxen_create_diag_entries(struct netxen_adapter *adapter)
3115 struct pci_dev *pdev = adapter->pdev;
3131 netxen_remove_diag_entries(struct netxen_adapter *adapter)
3133 struct pci_dev *pdev = adapter->pdev;
3147 netxen_destip_supported(struct netxen_adapter *adapter)
3149 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
3152 if (adapter->ahw.cut_through)
3159 netxen_free_ip_list(struct netxen_adapter *adapter, bool master)
3163 list_for_each_entry_safe(cur, tmp_cur, &adapter->ip_list, list) {
3166 netxen_config_ipaddr(adapter, cur->ip_addr,
3172 netxen_config_ipaddr(adapter, cur->ip_addr, NX_IP_DOWN);
3180 netxen_list_config_ip(struct netxen_adapter *adapter,
3195 list_for_each(head, &adapter->ip_list) {
3209 list_add_tail(&cur->list, &adapter->ip_list);
3210 netxen_config_ipaddr(adapter, ifa->ifa_address, NX_IP_UP);
3215 &adapter->ip_list, list) {
3219 netxen_config_ipaddr(adapter, ifa->ifa_address,
3231 netxen_config_indev_addr(struct netxen_adapter *adapter,
3237 if (!netxen_destip_supported(adapter))
3248 netxen_list_config_ip(adapter, ifa, NX_IP_UP);
3251 netxen_list_config_ip(adapter, ifa, NX_IP_DOWN);
3265 struct netxen_adapter *adapter = netdev_priv(netdev);
3270 netxen_config_indev_addr(adapter, netdev, event);
3272 list_for_each_entry_safe(pos, tmp_pos, &adapter->ip_list, list) {
3273 netxen_config_ipaddr(adapter, pos->ip_addr, ip_event);
3280 struct netxen_adapter *adapter;
3284 adapter = netdev_priv(dev);
3285 if (!adapter)
3287 if (!netxen_destip_supported(adapter))
3289 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
3303 struct netxen_adapter *adapter = netdev_priv(dev);
3315 netxen_config_indev_addr(adapter, master, event);
3319 netxen_config_indev_addr(adapter, slave, event);
3328 netxen_free_ip_list(adapter, true);
3334 struct netxen_adapter *adapter;
3354 adapter = netdev_priv(slave);
3355 netxen_config_indev_addr(adapter,
3362 adapter = netdev_priv(dev);
3366 netxen_config_indev_addr(adapter, orig_dev, event);
3377 struct netxen_adapter *adapter;
3399 adapter = netdev_priv(slave);
3400 netxen_list_config_ip(adapter, ifa, ip_event);
3406 adapter = netdev_priv(dev);
3407 netxen_list_config_ip(adapter, ifa, ip_event);
3426 netxen_free_ip_list(struct netxen_adapter *adapter, bool master)