aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorMithlesh Thukral <mithlesh@netxen.com>2007-04-20 10:52:37 -0400
committerJeff Garzik <jeff@garzik.org>2007-04-28 11:01:05 -0400
commit3176ff3ee71bddbd1d68e6a9e28dbcf0a2960c95 (patch)
tree260ba783bbd24bf21f17c11f9a6f06a7c50a9fc6
parentd52df4a35af569071fda3f4eb08e47cc7023f094 (diff)
NetXen: Use multiple PCI functions
NetXen: Make driver use multiple PCI functions. This patch will make NetXen driver work with multiple PCI functions. This will make the usage of memory resources as well as interrupts more independent among different functions which results in better throughput. This change has been done after the multiport support is added in firmware. Signed-off by: Mithlesh Thukral <mithlesh@netxen.com> Signed-off-by: Jeff Garzik <jeff@garzik.org>
Diffstat
-rw-r--r--drivers/net/netxen/netxen_nic.h125
-rw-r--r--drivers/net/netxen/netxen_nic_ethtool.c83
-rw-r--r--drivers/net/netxen/netxen_nic_hdr.h8
-rw-r--r--drivers/net/netxen/netxen_nic_hw.c221
-rw-r--r--drivers/net/netxen/netxen_nic_hw.h18
-rw-r--r--drivers/net/netxen/netxen_nic_init.c117
-rw-r--r--drivers/net/netxen/netxen_nic_isr.c87
-rw-r--r--drivers/net/netxen/netxen_nic_main.c526
-rw-r--r--drivers/net/netxen/netxen_nic_niu.c27
-rw-r--r--drivers/net/netxen/netxen_nic_phan_reg.h125
10 files changed, 646 insertions, 691 deletions
diff --git a/drivers/net/netxen/netxen_nic.h b/drivers/net/netxen/netxen_nic.h
index dd8ce35332fe..b996cb38ecb5 100644
--- a/drivers/net/netxen/netxen_nic.h
+++ b/drivers/net/netxen/netxen_nic.h
@@ -230,7 +230,9 @@ enum {
230 (((index) + (count)) & ((length) - 1)) 230 (((index) + (count)) & ((length) - 1))
231 231
232#define MPORT_SINGLE_FUNCTION_MODE 0x1111 232#define MPORT_SINGLE_FUNCTION_MODE 0x1111
233#define MPORT_MULTI_FUNCTION_MODE 0x2222
233 234
235#include "netxen_nic_phan_reg.h"
234extern unsigned long long netxen_dma_mask; 236extern unsigned long long netxen_dma_mask;
235extern unsigned long last_schedule_time; 237extern unsigned long last_schedule_time;
236 238
@@ -703,10 +705,8 @@ extern char netxen_nic_driver_name[];
703#else 705#else
704#define DPRINTK(klevel, fmt, args...) do { \ 706#define DPRINTK(klevel, fmt, args...) do { \
705 printk(KERN_##klevel PFX "%s: %s: " fmt, __FUNCTION__,\ 707 printk(KERN_##klevel PFX "%s: %s: " fmt, __FUNCTION__,\
706 (adapter != NULL && \ 708 (adapter != NULL && adapter->netdev != NULL) ? \
707 adapter->port[0] != NULL && \ 709 adapter->netdev->name : NULL, \
708 adapter->port[0]->netdev != NULL) ? \
709 adapter->port[0]->netdev->name : NULL, \
710 ## args); } while(0) 710 ## args); } while(0)
711#endif 711#endif
712 712
@@ -788,17 +788,27 @@ struct netxen_hardware_context {
788#define ETHERNET_FCS_SIZE 4 788#define ETHERNET_FCS_SIZE 4
789 789
790struct netxen_adapter_stats { 790struct netxen_adapter_stats {
791 u64 ints; 791 u64 rcvdbadskb;
792 u64 hostints; 792 u64 xmitcalled;
793 u64 otherints; 793 u64 xmitedframes;
794 u64 process_rcv; 794 u64 xmitfinished;
795 u64 process_xmit; 795 u64 badskblen;
796 u64 noxmitdone; 796 u64 nocmddescriptor;
797 u64 xmitcsummed; 797 u64 polled;
798 u64 post_called; 798 u64 uphappy;
799 u64 posted; 799 u64 updropped;
800 u64 lastposted; 800 u64 uplcong;
801 u64 goodskbposts; 801 u64 uphcong;
802 u64 upmcong;
803 u64 updunno;
804 u64 skbfreed;
805 u64 txdropped;
806 u64 txnullskb;
807 u64 csummed;
808 u64 no_rcv;
809 u64 rxbytes;
810 u64 txbytes;
811 u64 ints;
802}; 812};
803 813
804/* 814/*
@@ -846,13 +856,19 @@ struct netxen_dummy_dma {
846 856
847struct netxen_adapter { 857struct netxen_adapter {
848 struct netxen_hardware_context ahw; 858 struct netxen_hardware_context ahw;
849 int port_count; /* Number of configured ports */ 859
850 int active_ports; /* Number of open ports */ 860 struct netxen_adapter *master;
851 struct netxen_port *port[NETXEN_MAX_PORTS]; /* ptr to each port */ 861 struct net_device *netdev;
862 struct pci_dev *pdev;
863 unsigned char mac_addr[ETH_ALEN];
864 int mtu;
865 int portnum;
866
852 spinlock_t tx_lock; 867 spinlock_t tx_lock;
853 spinlock_t lock; 868 spinlock_t lock;
854 struct work_struct watchdog_task; 869 struct work_struct watchdog_task;
855 struct timer_list watchdog_timer; 870 struct timer_list watchdog_timer;
871 struct work_struct tx_timeout_task;
856 872
857 u32 curr_window; 873 u32 curr_window;
858 874
@@ -875,6 +891,15 @@ struct netxen_adapter {
875 u32 temp; 891 u32 temp;
876 892
877 struct netxen_adapter_stats stats; 893 struct netxen_adapter_stats stats;
894
895 u16 portno;
896 u16 link_speed;
897 u16 link_duplex;
898 u16 state;
899 u16 link_autoneg;
900 int rcsum;
901 int status;
902 spinlock_t stats_lock;
878 903
879 struct netxen_cmd_buffer *cmd_buf_arr; /* Command buffers for xmit */ 904 struct netxen_cmd_buffer *cmd_buf_arr; /* Command buffers for xmit */
880 905
@@ -894,62 +919,20 @@ struct netxen_adapter {
894 int (*enable_phy_interrupts) (struct netxen_adapter *, int); 919 int (*enable_phy_interrupts) (struct netxen_adapter *, int);
895 int (*disable_phy_interrupts) (struct netxen_adapter *, int); 920 int (*disable_phy_interrupts) (struct netxen_adapter *, int);
896 void (*handle_phy_intr) (struct netxen_adapter *); 921 void (*handle_phy_intr) (struct netxen_adapter *);
897 int (*macaddr_set) (struct netxen_port *, netxen_ethernet_macaddr_t); 922 int (*macaddr_set) (struct netxen_adapter *, netxen_ethernet_macaddr_t);
898 int (*set_mtu) (struct netxen_port *, int); 923 int (*set_mtu) (struct netxen_adapter *, int);
899 int (*set_promisc) (struct netxen_adapter *, int, 924 int (*set_promisc) (struct netxen_adapter *, netxen_niu_prom_mode_t);
900 netxen_niu_prom_mode_t); 925 int (*unset_promisc) (struct netxen_adapter *, netxen_niu_prom_mode_t);
901 int (*unset_promisc) (struct netxen_adapter *, int,
902 netxen_niu_prom_mode_t);
903 int (*phy_read) (struct netxen_adapter *, long phy, long reg, u32 *); 926 int (*phy_read) (struct netxen_adapter *, long phy, long reg, u32 *);
904 int (*phy_write) (struct netxen_adapter *, long phy, long reg, u32 val); 927 int (*phy_write) (struct netxen_adapter *, long phy, long reg, u32 val);
905 int (*init_port) (struct netxen_adapter *, int); 928 int (*init_port) (struct netxen_adapter *, int);
906 void (*init_niu) (struct netxen_adapter *); 929 void (*init_niu) (struct netxen_adapter *);
907 int (*stop_port) (struct netxen_adapter *, int); 930 int (*stop_port) (struct netxen_adapter *);
908}; /* netxen_adapter structure */ 931}; /* netxen_adapter structure */
909 932
910/* Max number of xmit producer threads that can run simultaneously */ 933/* Max number of xmit producer threads that can run simultaneously */
911#define MAX_XMIT_PRODUCERS 16 934#define MAX_XMIT_PRODUCERS 16
912 935
913struct netxen_port_stats {
914 u64 rcvdbadskb;
915 u64 xmitcalled;
916 u64 xmitedframes;
917 u64 xmitfinished;
918 u64 badskblen;
919 u64 nocmddescriptor;
920 u64 polled;
921 u64 uphappy;
922 u64 updropped;
923 u64 uplcong;
924 u64 uphcong;
925 u64 upmcong;
926 u64 updunno;
927 u64 skbfreed;
928 u64 txdropped;
929 u64 txnullskb;
930 u64 csummed;
931 u64 no_rcv;
932 u64 rxbytes;
933 u64 txbytes;
934};
935
936struct netxen_port {
937 struct netxen_adapter *adapter;
938
939 u16 portnum; /* GBE port number */
940 u16 link_speed;
941 u16 link_duplex;
942 u16 link_autoneg;
943
944 int flags;
945
946 struct net_device *netdev;
947 struct pci_dev *pdev;
948 struct net_device_stats net_stats;
949 struct netxen_port_stats stats;
950 struct work_struct tx_timeout_task;
951};
952
953#define PCI_OFFSET_FIRST_RANGE(adapter, off) \ 936#define PCI_OFFSET_FIRST_RANGE(adapter, off) \
954 ((adapter)->ahw.pci_base0 + (off)) 937 ((adapter)->ahw.pci_base0 + (off))
955#define PCI_OFFSET_SECOND_RANGE(adapter, off) \ 938#define PCI_OFFSET_SECOND_RANGE(adapter, off) \
@@ -1011,8 +994,8 @@ int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long phy,
1011 long reg, __u32 val); 994 long reg, __u32 val);
1012 995
1013/* Functions available from netxen_nic_hw.c */ 996/* Functions available from netxen_nic_hw.c */
1014int netxen_nic_set_mtu_xgb(struct netxen_port *port, int new_mtu); 997int netxen_nic_set_mtu_xgb(struct netxen_adapter *adapter, int new_mtu);
1015int netxen_nic_set_mtu_gb(struct netxen_port *port, int new_mtu); 998int netxen_nic_set_mtu_gb(struct netxen_adapter *adapter, int new_mtu);
1016void netxen_nic_init_niu_gb(struct netxen_adapter *adapter); 999void netxen_nic_init_niu_gb(struct netxen_adapter *adapter);
1017void netxen_nic_pci_change_crbwindow(struct netxen_adapter *adapter, u32 wndw); 1000void netxen_nic_pci_change_crbwindow(struct netxen_adapter *adapter, u32 wndw);
1018void netxen_nic_reg_write(struct netxen_adapter *adapter, u64 off, u32 val); 1001void netxen_nic_reg_write(struct netxen_adapter *adapter, u64 off, u32 val);
@@ -1051,11 +1034,8 @@ int netxen_do_rom_se(struct netxen_adapter *adapter, int addr);
1051 1034
1052/* Functions from netxen_nic_isr.c */ 1035/* Functions from netxen_nic_isr.c */
1053void netxen_nic_isr_other(struct netxen_adapter *adapter); 1036void netxen_nic_isr_other(struct netxen_adapter *adapter);
1054void netxen_indicate_link_status(struct netxen_adapter *adapter, u32 port, 1037void netxen_indicate_link_status(struct netxen_adapter *adapter, u32 link);
1055 u32 link); 1038void netxen_handle_port_int(struct netxen_adapter *adapter, u32 enable);
1056void netxen_handle_port_int(struct netxen_adapter *adapter, u32 port,
1057 u32 enable);
1058void netxen_nic_stop_all_ports(struct netxen_adapter *adapter);
1059void netxen_initialize_adapter_sw(struct netxen_adapter *adapter); 1039void netxen_initialize_adapter_sw(struct netxen_adapter *adapter);
1060void netxen_initialize_adapter_hw(struct netxen_adapter *adapter); 1040void netxen_initialize_adapter_hw(struct netxen_adapter *adapter);
1061void *netxen_alloc(struct pci_dev *pdev, size_t sz, dma_addr_t * ptr, 1041void *netxen_alloc(struct pci_dev *pdev, size_t sz, dma_addr_t * ptr,
@@ -1110,6 +1090,7 @@ static inline void netxen_nic_enable_int(struct netxen_adapter *adapter)
1110 1090
1111 if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) { 1091 if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) {
1112 mask = 0xbff; 1092 mask = 0xbff;
1093 writel(0X0, NETXEN_CRB_NORMALIZE(adapter, CRB_INT_VECTOR));
1113 writel(mask, PCI_OFFSET_SECOND_RANGE(adapter, 1094 writel(mask, PCI_OFFSET_SECOND_RANGE(adapter,
1114 ISR_INT_TARGET_MASK)); 1095 ISR_INT_TARGET_MASK));
1115 } 1096 }
diff --git a/drivers/net/netxen/netxen_nic_ethtool.c b/drivers/net/netxen/netxen_nic_ethtool.c
index ee1b5a24cbe7..c400f264ea43 100644
--- a/drivers/net/netxen/netxen_nic_ethtool.c
+++ b/drivers/net/netxen/netxen_nic_ethtool.c
@@ -50,8 +50,8 @@ struct netxen_nic_stats {
50 int stat_offset; 50 int stat_offset;
51}; 51};
52 52
53#define NETXEN_NIC_STAT(m) sizeof(((struct netxen_port *)0)->m), \ 53#define NETXEN_NIC_STAT(m) sizeof(((struct netxen_adapter *)0)->m), \
54 offsetof(struct netxen_port, m) 54 offsetof(struct netxen_adapter, m)
55 55
56#define NETXEN_NIC_PORT_WINDOW 0x10000 56#define NETXEN_NIC_PORT_WINDOW 0x10000
57#define NETXEN_NIC_INVALID_DATA 0xDEADBEEF 57#define NETXEN_NIC_INVALID_DATA 0xDEADBEEF
@@ -100,8 +100,7 @@ static int netxen_nic_get_eeprom_len(struct net_device *dev)
100static void 100static void
101netxen_nic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo) 101netxen_nic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
102{ 102{
103 struct netxen_port *port = netdev_priv(dev); 103 struct netxen_adapter *adapter = netdev_priv(dev);
104 struct netxen_adapter *adapter = port->adapter;
105 u32 fw_major = 0; 104 u32 fw_major = 0;
106 u32 fw_minor = 0; 105 u32 fw_minor = 0;
107 u32 fw_build = 0; 106 u32 fw_build = 0;
@@ -115,7 +114,7 @@ netxen_nic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
115 fw_build = readl(NETXEN_CRB_NORMALIZE(adapter, NETXEN_FW_VERSION_SUB)); 114 fw_build = readl(NETXEN_CRB_NORMALIZE(adapter, NETXEN_FW_VERSION_SUB));
116 sprintf(drvinfo->fw_version, "%d.%d.%d", fw_major, fw_minor, fw_build); 115 sprintf(drvinfo->fw_version, "%d.%d.%d", fw_major, fw_minor, fw_build);
117 116
118 strncpy(drvinfo->bus_info, pci_name(port->pdev), 32); 117 strncpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
119 drvinfo->n_stats = NETXEN_NIC_STATS_LEN; 118 drvinfo->n_stats = NETXEN_NIC_STATS_LEN;
120 drvinfo->testinfo_len = NETXEN_NIC_TEST_LEN; 119 drvinfo->testinfo_len = NETXEN_NIC_TEST_LEN;
121 drvinfo->regdump_len = NETXEN_NIC_REGS_LEN; 120 drvinfo->regdump_len = NETXEN_NIC_REGS_LEN;
@@ -125,8 +124,7 @@ netxen_nic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
125static int 124static int
126netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd) 125netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
127{ 126{
128 struct netxen_port *port = netdev_priv(dev); 127 struct netxen_adapter *adapter = netdev_priv(dev);
129 struct netxen_adapter *adapter = port->adapter;
130 struct netxen_board_info *boardinfo = &adapter->ahw.boardcfg; 128 struct netxen_board_info *boardinfo = &adapter->ahw.boardcfg;
131 129
132 /* read which mode */ 130 /* read which mode */
@@ -146,8 +144,8 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
146 ecmd->port = PORT_TP; 144 ecmd->port = PORT_TP;
147 145
148 if (netif_running(dev)) { 146 if (netif_running(dev)) {
149 ecmd->speed = port->link_speed; 147 ecmd->speed = adapter->link_speed;
150 ecmd->duplex = port->link_duplex; 148 ecmd->duplex = adapter->link_duplex;
151 } else 149 } else
152 return -EIO; /* link absent */ 150 return -EIO; /* link absent */
153 } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) { 151 } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
@@ -165,7 +163,7 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
165 } else 163 } else
166 return -EIO; 164 return -EIO;
167 165
168 ecmd->phy_address = port->portnum; 166 ecmd->phy_address = adapter->portnum;
169 ecmd->transceiver = XCVR_EXTERNAL; 167 ecmd->transceiver = XCVR_EXTERNAL;
170 168
171 switch ((netxen_brdtype_t) boardinfo->board_type) { 169 switch ((netxen_brdtype_t) boardinfo->board_type) {
@@ -179,7 +177,7 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
179 ecmd->port = PORT_TP; 177 ecmd->port = PORT_TP;
180 ecmd->autoneg = (boardinfo->board_type == 178 ecmd->autoneg = (boardinfo->board_type ==
181 NETXEN_BRDTYPE_P2_SB31_10G_CX4) ? 179 NETXEN_BRDTYPE_P2_SB31_10G_CX4) ?
182 (AUTONEG_DISABLE) : (port->link_autoneg); 180 (AUTONEG_DISABLE) : (adapter->link_autoneg);
183 break; 181 break;
184 case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ: 182 case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
185 case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ: 183 case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
@@ -206,23 +204,22 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
206static int 204static int
207netxen_nic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd) 205netxen_nic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
208{ 206{
209 struct netxen_port *port = netdev_priv(dev); 207 struct netxen_adapter *adapter = netdev_priv(dev);
210 struct netxen_adapter *adapter = port->adapter;
211 __u32 status; 208 __u32 status;
212 209
213 /* read which mode */ 210 /* read which mode */
214 if (adapter->ahw.board_type == NETXEN_NIC_GBE) { 211 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
215 /* autonegotiation */ 212 /* autonegotiation */
216 if (adapter->phy_write 213 if (adapter->phy_write
217 && adapter->phy_write(adapter, port->portnum, 214 && adapter->phy_write(adapter, adapter->portnum,
218 NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG, 215 NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
219 ecmd->autoneg) != 0) 216 ecmd->autoneg) != 0)
220 return -EIO; 217 return -EIO;
221 else 218 else
222 port->link_autoneg = ecmd->autoneg; 219 adapter->link_autoneg = ecmd->autoneg;
223 220
224 if (adapter->phy_read 221 if (adapter->phy_read
225 && adapter->phy_read(adapter, port->portnum, 222 && adapter->phy_read(adapter, adapter->portnum,
226 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS, 223 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
227 &status) != 0) 224 &status) != 0)
228 return -EIO; 225 return -EIO;
@@ -245,13 +242,13 @@ netxen_nic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
245 if (ecmd->duplex == DUPLEX_FULL) 242 if (ecmd->duplex == DUPLEX_FULL)
246 netxen_set_phy_duplex(status); 243 netxen_set_phy_duplex(status);
247 if (adapter->phy_write 244 if (adapter->phy_write
248 && adapter->phy_write(adapter, port->portnum, 245 && adapter->phy_write(adapter, adapter->portnum,
249 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS, 246 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
250 *((int *)&status)) != 0) 247 *((int *)&status)) != 0)
251 return -EIO; 248 return -EIO;
252 else { 249 else {
253 port->link_speed = ecmd->speed; 250 adapter->link_speed = ecmd->speed;
254 port->link_duplex = ecmd->duplex; 251 adapter->link_duplex = ecmd->duplex;
255 } 252 }
256 } else 253 } else
257 return -EOPNOTSUPP; 254 return -EOPNOTSUPP;
@@ -360,15 +357,14 @@ static struct netxen_niu_regs niu_registers[] = {
360static void 357static void
361netxen_nic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p) 358netxen_nic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
362{ 359{
363 struct netxen_port *port = netdev_priv(dev); 360 struct netxen_adapter *adapter = netdev_priv(dev);
364 struct netxen_adapter *adapter = port->adapter;
365 __u32 mode, *regs_buff = p; 361 __u32 mode, *regs_buff = p;
366 void __iomem *addr; 362 void __iomem *addr;
367 int i, window; 363 int i, window;
368 364
369 memset(p, 0, NETXEN_NIC_REGS_LEN); 365 memset(p, 0, NETXEN_NIC_REGS_LEN);
370 regs->version = (1 << 24) | (adapter->ahw.revision_id << 16) | 366 regs->version = (1 << 24) | (adapter->ahw.revision_id << 16) |
371 (port->pdev)->device; 367 (adapter->pdev)->device;
372 /* which mode */ 368 /* which mode */
373 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_MODE, &regs_buff[0]); 369 NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_MODE, &regs_buff[0]);
374 mode = regs_buff[0]; 370 mode = regs_buff[0];
@@ -383,7 +379,8 @@ netxen_nic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
383 for (i = 3; niu_registers[mode].reg[i - 3] != -1; i++) { 379 for (i = 3; niu_registers[mode].reg[i - 3] != -1; i++) {
384 /* GB: port specific registers */ 380 /* GB: port specific registers */
385 if (mode == 0 && i >= 19) 381 if (mode == 0 && i >= 19)
386 window = port->portnum * NETXEN_NIC_PORT_WINDOW; 382 window = adapter->portnum *
383 NETXEN_NIC_PORT_WINDOW;
387 384
388 NETXEN_NIC_LOCKED_READ_REG(niu_registers[mode]. 385 NETXEN_NIC_LOCKED_READ_REG(niu_registers[mode].
389 reg[i - 3] + window, 386 reg[i - 3] + window,
@@ -395,15 +392,14 @@ netxen_nic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
395 392
396static u32 netxen_nic_test_link(struct net_device *dev) 393static u32 netxen_nic_test_link(struct net_device *dev)
397{ 394{
398 struct netxen_port *port = netdev_priv(dev); 395 struct netxen_adapter *adapter = netdev_priv(dev);
399 struct netxen_adapter *adapter = port->adapter;
400 __u32 status; 396 __u32 status;
401 int val; 397 int val;
402 398
403 /* read which mode */ 399 /* read which mode */
404 if (adapter->ahw.board_type == NETXEN_NIC_GBE) { 400 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
405 if (adapter->phy_read 401 if (adapter->phy_read
406 && adapter->phy_read(adapter, port->portnum, 402 && adapter->phy_read(adapter, adapter->portnum,
407 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS, 403 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
408 &status) != 0) 404 &status) != 0)
409 return -EIO; 405 return -EIO;
@@ -422,15 +418,15 @@ static int
422netxen_nic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, 418netxen_nic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
423 u8 * bytes) 419 u8 * bytes)
424{ 420{
425 struct netxen_port *port = netdev_priv(dev); 421 struct netxen_adapter *adapter = netdev_priv(dev);
426 struct netxen_adapter *adapter = port->adapter;
427 int offset; 422 int offset;
428 int ret; 423 int ret;
429 424
430 if (eeprom->len == 0) 425 if (eeprom->len == 0)
431 return -EINVAL; 426 return -EINVAL;
432 427
433 eeprom->magic = (port->pdev)->vendor | ((port->pdev)->device << 16); 428 eeprom->magic = (adapter->pdev)->vendor |
429 ((adapter->pdev)->device << 16);
434 offset = eeprom->offset; 430 offset = eeprom->offset;
435 431
436 ret = netxen_rom_fast_read_words(adapter, offset, bytes, 432 ret = netxen_rom_fast_read_words(adapter, offset, bytes,
@@ -445,8 +441,7 @@ static int
445netxen_nic_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, 441netxen_nic_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
446 u8 * bytes) 442 u8 * bytes)
447{ 443{
448 struct netxen_port *port = netdev_priv(dev); 444 struct netxen_adapter *adapter = netdev_priv(dev);
449 struct netxen_adapter *adapter = port->adapter;
450 int offset = eeprom->offset; 445 int offset = eeprom->offset;
451 static int flash_start; 446 static int flash_start;
452 static int ready_to_flash; 447 static int ready_to_flash;
@@ -516,8 +511,7 @@ netxen_nic_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
516static void 511static void
517netxen_nic_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring) 512netxen_nic_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
518{ 513{
519 struct netxen_port *port = netdev_priv(dev); 514 struct netxen_adapter *adapter = netdev_priv(dev);
520 struct netxen_adapter *adapter = port->adapter;
521 int i; 515 int i;
522 516
523 ring->rx_pending = 0; 517 ring->rx_pending = 0;
@@ -541,19 +535,18 @@ static void
541netxen_nic_get_pauseparam(struct net_device *dev, 535netxen_nic_get_pauseparam(struct net_device *dev,
542 struct ethtool_pauseparam *pause) 536 struct ethtool_pauseparam *pause)
543{ 537{
544 struct netxen_port *port = netdev_priv(dev); 538 struct netxen_adapter *adapter = netdev_priv(dev);
545 struct netxen_adapter *adapter = port->adapter;
546 __u32 val; 539 __u32 val;
547 540
548 if (adapter->ahw.board_type == NETXEN_NIC_GBE) { 541 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
549 /* get flow control settings */ 542 /* get flow control settings */
550 netxen_nic_read_w0(adapter, 543 netxen_nic_read_w0(adapter,
551 NETXEN_NIU_GB_MAC_CONFIG_0(port->portnum), 544 NETXEN_NIU_GB_MAC_CONFIG_0(adapter->portnum),
552 &val); 545 &val);
553 pause->rx_pause = netxen_gb_get_rx_flowctl(val); 546 pause->rx_pause = netxen_gb_get_rx_flowctl(val);
554 pause->tx_pause = netxen_gb_get_tx_flowctl(val); 547 pause->tx_pause = netxen_gb_get_tx_flowctl(val);
555 /* get autoneg settings */ 548 /* get autoneg settings */
556 pause->autoneg = port->link_autoneg; 549 pause->autoneg = adapter->link_autoneg;
557 } 550 }
558} 551}
559 552
@@ -561,8 +554,7 @@ static int
561netxen_nic_set_pauseparam(struct net_device *dev, 554netxen_nic_set_pauseparam(struct net_device *dev,
562 struct ethtool_pauseparam *pause) 555 struct ethtool_pauseparam *pause)
563{ 556{
564 struct netxen_port *port = netdev_priv(dev); 557 struct netxen_adapter *adapter = netdev_priv(dev);
565 struct netxen_adapter *adapter = port->adapter;
566 __u32 val; 558 __u32 val;
567 unsigned int autoneg; 559 unsigned int autoneg;
568 560
@@ -570,7 +562,7 @@ netxen_nic_set_pauseparam(struct net_device *dev,
570 if (adapter->ahw.board_type == NETXEN_NIC_GBE) { 562 if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
571 /* set flow control */ 563 /* set flow control */
572 netxen_nic_read_w0(adapter, 564 netxen_nic_read_w0(adapter,
573 NETXEN_NIU_GB_MAC_CONFIG_0(port->portnum), 565 NETXEN_NIU_GB_MAC_CONFIG_0(adapter->portnum),
574 (u32 *) & val); 566 (u32 *) & val);
575 if (pause->tx_pause) 567 if (pause->tx_pause)
576 netxen_gb_tx_flowctl(val); 568 netxen_gb_tx_flowctl(val);
@@ -582,17 +574,17 @@ netxen_nic_set_pauseparam(struct net_device *dev,
582 netxen_gb_unset_rx_flowctl(val); 574 netxen_gb_unset_rx_flowctl(val);
583 575
584 netxen_nic_write_w0(adapter, 576 netxen_nic_write_w0(adapter,
585 NETXEN_NIU_GB_MAC_CONFIG_0(port->portnum), 577 NETXEN_NIU_GB_MAC_CONFIG_0(adapter->portnum),
586 *&val); 578 *&val);
587 /* set autoneg */ 579 /* set autoneg */
588 autoneg = pause->autoneg; 580 autoneg = pause->autoneg;
589 if (adapter->phy_write 581 if (adapter->phy_write
590 && adapter->phy_write(adapter, port->portnum, 582 && adapter->phy_write(adapter, adapter->portnum,
591 NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG, 583 NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
592 autoneg) != 0) 584 autoneg) != 0)
593 return -EIO; 585 return -EIO;
594 else { 586 else {
595 port->link_autoneg = pause->autoneg; 587 adapter->link_autoneg = pause->autoneg;
596 return 0; 588 return 0;
597 } 589 }
598 } else 590 } else
@@ -675,12 +667,13 @@ static void
675netxen_nic_get_ethtool_stats(struct net_device *dev, 667netxen_nic_get_ethtool_stats(struct net_device *dev,
676 struct ethtool_stats *stats, u64 * data) 668 struct ethtool_stats *stats, u64 * data)
677{ 669{
678 struct netxen_port *port = netdev_priv(dev); 670 struct netxen_adapter *adapter = netdev_priv(dev);
679 int index; 671 int index;
680 672
681 for (index = 0; index < NETXEN_NIC_STATS_LEN; index++) { 673 for (index = 0; index < NETXEN_NIC_STATS_LEN; index++) {
682 char *p = 674 char *p =
683 (char *)port + netxen_nic_gstrings_stats[index].stat_offset; 675 (char *)adapter +
676 netxen_nic_gstrings_stats[index].stat_offset;
684 data[index] = 677 data[index] =
685 (netxen_nic_gstrings_stats[index].sizeof_stat == 678 (netxen_nic_gstrings_stats[index].sizeof_stat ==
686 sizeof(u64)) ? *(u64 *) p : *(u32 *) p; 679 sizeof(u64)) ? *(u64 *) p : *(u32 *) p;
diff --git a/drivers/net/netxen/netxen_nic_hdr.h b/drivers/net/netxen/netxen_nic_hdr.h
index fe8b675f9e72..b67a5c3ca99d 100644
--- a/drivers/net/netxen/netxen_nic_hdr.h
+++ b/drivers/net/netxen/netxen_nic_hdr.h
@@ -649,11 +649,19 @@ enum {
649#define PCIX_MS_WINDOW (0x10204) 649#define PCIX_MS_WINDOW (0x10204)
650#define PCIX_SN_WINDOW (0x10208) 650#define PCIX_SN_WINDOW (0x10208)
651#define PCIX_CRB_WINDOW (0x10210) 651#define PCIX_CRB_WINDOW (0x10210)
652#define PCIX_CRB_WINDOW_F0 (0x10210)
653#define PCIX_CRB_WINDOW_F1 (0x10230)
654#define PCIX_CRB_WINDOW_F2 (0x10250)
655#define PCIX_CRB_WINDOW_F3 (0x10270)
652 656
653#define PCIX_TARGET_STATUS (0x10118) 657#define PCIX_TARGET_STATUS (0x10118)
654#define PCIX_TARGET_MASK (0x10128) 658#define PCIX_TARGET_MASK (0x10128)
655 659
656#define PCIX_MSI_F0 (0x13000) 660#define PCIX_MSI_F0 (0x13000)
661#define PCIX_MSI_F1 (0x13004)
662#define PCIX_MSI_F2 (0x13008)
663#define PCIX_MSI_F3 (0x1300c)
664#define PCIX_MSI_F(i) (0x13000+((i)*4))
657 665
658#define PCIX_PS_MEM_SPACE (0x90000) 666#define PCIX_PS_MEM_SPACE (0x90000)
659 667
diff --git a/drivers/net/netxen/netxen_nic_hw.c b/drivers/net/netxen/netxen_nic_hw.c
index 0fba8f190762..50430911c800 100644
--- a/drivers/net/netxen/netxen_nic_hw.c
+++ b/drivers/net/netxen/netxen_nic_hw.c
@@ -33,10 +33,128 @@
33 33
34#include "netxen_nic.h" 34#include "netxen_nic.h"
35#include "netxen_nic_hw.h" 35#include "netxen_nic_hw.h"
36#define DEFINE_GLOBAL_RECV_CRB
36#include "netxen_nic_phan_reg.h" 37#include "netxen_nic_phan_reg.h"
37 38
39
38#include <net/ip.h> 40#include <net/ip.h>
39 41
42struct netxen_recv_crb recv_crb_registers[] = {
43 /*
44 * Instance 0.
45 */
46 {
47 /* rcv_desc_crb: */
48 {
49 {
50 /* crb_rcv_producer_offset: */
51 NETXEN_NIC_REG(0x100),
52 /* crb_rcv_consumer_offset: */
53 NETXEN_NIC_REG(0x104),
54 /* crb_gloablrcv_ring: */
55 NETXEN_NIC_REG(0x108),
56 /* crb_rcv_ring_size */
57 NETXEN_NIC_REG(0x10c),
58
59 },
60 /* Jumbo frames */
61 {
62 /* crb_rcv_producer_offset: */
63 NETXEN_NIC_REG(0x110),
64 /* crb_rcv_consumer_offset: */
65 NETXEN_NIC_REG(0x114),
66 /* crb_gloablrcv_ring: */
67 NETXEN_NIC_REG(0x118),
68 /* crb_rcv_ring_size */
69 NETXEN_NIC_REG(0x11c),
70 },
71 /* LRO */
72 {
73 /* crb_rcv_producer_offset: */
74 NETXEN_NIC_REG(0x120),
75 /* crb_rcv_consumer_offset: */
76 NETXEN_NIC_REG(0x124),
77 /* crb_gloablrcv_ring: */
78 NETXEN_NIC_REG(0x128),
79 /* crb_rcv_ring_size */
80 NETXEN_NIC_REG(0x12c),
81 }
82 },
83 /* crb_rcvstatus_ring: */
84 NETXEN_NIC_REG(0x130),
85 /* crb_rcv_status_producer: */
86 NETXEN_NIC_REG(0x134),
87 /* crb_rcv_status_consumer: */
88 NETXEN_NIC_REG(0x138),
89 /* crb_rcvpeg_state: */
90 NETXEN_NIC_REG(0x13c),
91 /* crb_status_ring_size */
92 NETXEN_NIC_REG(0x140),
93
94 },
95 /*
96 * Instance 1,
97 */
98 {
99 /* rcv_desc_crb: */
100 {
101 {
102 /* crb_rcv_producer_offset: */
103 NETXEN_NIC_REG(0x144),
104 /* crb_rcv_consumer_offset: */
105 NETXEN_NIC_REG(0x148),
106 /* crb_globalrcv_ring: */
107 NETXEN_NIC_REG(0x14c),
108 /* crb_rcv_ring_size */
109 NETXEN_NIC_REG(0x150),
110
111 },
112 /* Jumbo frames */
113 {
114 /* crb_rcv_producer_offset: */
115 NETXEN_NIC_REG(0x154),
116 /* crb_rcv_consumer_offset: */
117 NETXEN_NIC_REG(0x158),
118 /* crb_globalrcv_ring: */
119 NETXEN_NIC_REG(0x15c),
120 /* crb_rcv_ring_size */
121 NETXEN_NIC_REG(0x160),
122 },
123 /* LRO */
124 {
125 /* crb_rcv_producer_offset: */
126 NETXEN_NIC_REG(0x164),
127 /* crb_rcv_consumer_offset: */
128 NETXEN_NIC_REG(0x168),
129 /* crb_globalrcv_ring: */
130 NETXEN_NIC_REG(0x16c),
131 /* crb_rcv_ring_size */
132 NETXEN_NIC_REG(0x170),
133 }
134
135 },
136 /* crb_rcvstatus_ring: */
137 NETXEN_NIC_REG(0x174),
138 /* crb_rcv_status_producer: */
139 NETXEN_NIC_REG(0x178),
140 /* crb_rcv_status_consumer: */
141 NETXEN_NIC_REG(0x17c),
142 /* crb_rcvpeg_state: */
143 NETXEN_NIC_REG(0x180),
144 /* crb_status_ring_size */
145 NETXEN_NIC_REG(0x184),
146
147 },
148};
149
150u64 ctx_addr_sig_regs[][3] = {
151 {NETXEN_NIC_REG(0x188), NETXEN_NIC_REG(0x18c), NETXEN_NIC_REG(0x1c0)},
152 {NETXEN_NIC_REG(0x190), NETXEN_NIC_REG(0x194), NETXEN_NIC_REG(0x1c4)},
153 {NETXEN_NIC_REG(0x198), NETXEN_NIC_REG(0x19c), NETXEN_NIC_REG(0x1c8)},
154 {NETXEN_NIC_REG(0x1a0), NETXEN_NIC_REG(0x1a4), NETXEN_NIC_REG(0x1cc)}
155};
156
157
40/* PCI Windowing for DDR regions. */ 158/* PCI Windowing for DDR regions. */
41 159
42#define ADDR_IN_RANGE(addr, low, high) \ 160#define ADDR_IN_RANGE(addr, low, high) \
@@ -70,8 +188,7 @@ void netxen_free_hw_resources(struct netxen_adapter *adapter);
70 188
71int netxen_nic_set_mac(struct net_device *netdev, void *p) 189int netxen_nic_set_mac(struct net_device *netdev, void *p)
72{ 190{
73 struct netxen_port *port = netdev_priv(netdev); 191 struct netxen_adapter *adapter = netdev_priv(netdev);
74 struct netxen_adapter *adapter = port->adapter;
75 struct sockaddr *addr = p; 192 struct sockaddr *addr = p;
76 193
77 if (netif_running(netdev)) 194 if (netif_running(netdev))
@@ -84,7 +201,7 @@ int netxen_nic_set_mac(struct net_device *netdev, void *p)
84 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len); 201 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
85 202
86 if (adapter->macaddr_set) 203 if (adapter->macaddr_set)
87 adapter->macaddr_set(port, addr->sa_data); 204 adapter->macaddr_set(adapter, addr->sa_data);
88 205
89 return 0; 206 return 0;
90} 207}
@@ -94,8 +211,7 @@ int netxen_nic_set_mac(struct net_device *netdev, void *p)
94 */ 211 */
95void netxen_nic_set_multi(struct net_device *netdev) 212void netxen_nic_set_multi(struct net_device *netdev)
96{ 213{
97 struct netxen_port *port = netdev_priv(netdev); 214 struct netxen_adapter *adapter = netdev_priv(netdev);
98 struct netxen_adapter *adapter = port->adapter;
99 struct dev_mc_list *mc_ptr; 215 struct dev_mc_list *mc_ptr;
100 __u32 netxen_mac_addr_cntl_data = 0; 216 __u32 netxen_mac_addr_cntl_data = 0;
101 217
@@ -103,14 +219,12 @@ void netxen_nic_set_multi(struct net_device *netdev)
103 if (netdev->flags & IFF_PROMISC) { 219 if (netdev->flags & IFF_PROMISC) {
104 if (adapter->set_promisc) 220 if (adapter->set_promisc)
105 adapter->set_promisc(adapter, 221 adapter->set_promisc(adapter,
106 port->portnum,
107 NETXEN_NIU_PROMISC_MODE); 222 NETXEN_NIU_PROMISC_MODE);
108 } else { 223 } else {
109 if (adapter->unset_promisc && 224 if (adapter->unset_promisc &&
110 adapter->ahw.boardcfg.board_type 225 adapter->ahw.boardcfg.board_type
111 != NETXEN_BRDTYPE_P2_SB31_10G_IMEZ) 226 != NETXEN_BRDTYPE_P2_SB31_10G_IMEZ)
112 adapter->unset_promisc(adapter, 227 adapter->unset_promisc(adapter,
113 port->portnum,
114 NETXEN_NIU_NON_PROMISC_MODE); 228 NETXEN_NIU_NON_PROMISC_MODE);
115 } 229 }
116 if (adapter->ahw.board_type == NETXEN_NIC_XGBE) { 230 if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
@@ -152,8 +266,7 @@ void netxen_nic_set_multi(struct net_device *netdev)
152 */ 266 */
153int netxen_nic_change_mtu(struct net_device *netdev, int mtu) 267int netxen_nic_change_mtu(struct net_device *netdev, int mtu)
154{ 268{
155 struct netxen_port *port = netdev_priv(netdev); 269 struct netxen_adapter *adapter = netdev_priv(netdev);
156 struct netxen_adapter *adapter = port->adapter;
157 int eff_mtu = mtu + NETXEN_ENET_HEADER_SIZE + NETXEN_ETH_FCS_SIZE; 270 int eff_mtu = mtu + NETXEN_ENET_HEADER_SIZE + NETXEN_ETH_FCS_SIZE;
158 271
159 if ((eff_mtu > NETXEN_MAX_MTU) || (eff_mtu < NETXEN_MIN_MTU)) { 272 if ((eff_mtu > NETXEN_MAX_MTU) || (eff_mtu < NETXEN_MIN_MTU)) {
@@ -163,7 +276,7 @@ int netxen_nic_change_mtu(struct net_device *netdev, int mtu)
163 } 276 }
164 277
165 if (adapter->set_mtu) 278 if (adapter->set_mtu)
166 adapter->set_mtu(port, mtu); 279 adapter->set_mtu(adapter, mtu);
167 netdev->mtu = mtu; 280 netdev->mtu = mtu;
168 281
169 return 0; 282 return 0;
@@ -229,7 +342,7 @@ int netxen_nic_hw_resources(struct netxen_adapter *adapter)
229 (dma_addr_t *) & adapter->ctx_desc_phys_addr, 342 (dma_addr_t *) & adapter->ctx_desc_phys_addr,
230 &adapter->ctx_desc_pdev); 343 &adapter->ctx_desc_pdev);
231 344
232 printk("ctx_desc_phys_addr: 0x%llx\n", 345 printk(KERN_INFO "ctx_desc_phys_addr: 0x%llx\n",
233 (unsigned long long) adapter->ctx_desc_phys_addr); 346 (unsigned long long) adapter->ctx_desc_phys_addr);
234 if (addr == NULL) { 347 if (addr == NULL) {
235 DPRINTK(ERR, "bad return from pci_alloc_consistent\n"); 348 DPRINTK(ERR, "bad return from pci_alloc_consistent\n");
@@ -249,7 +362,7 @@ int netxen_nic_hw_resources(struct netxen_adapter *adapter)
249 adapter->max_tx_desc_count, 362 adapter->max_tx_desc_count,
250 (dma_addr_t *) & hw->cmd_desc_phys_addr, 363 (dma_addr_t *) & hw->cmd_desc_phys_addr,
251 &adapter->ahw.cmd_desc_pdev); 364 &adapter->ahw.cmd_desc_pdev);
252 printk("cmd_desc_phys_addr: 0x%llx\n", 365 printk(KERN_INFO "cmd_desc_phys_addr: 0x%llx\n",
253 (unsigned long long) hw->cmd_desc_phys_addr); 366 (unsigned long long) hw->cmd_desc_phys_addr);
254 367
255 if (addr == NULL) { 368 if (addr == NULL) {
@@ -385,7 +498,6 @@ void netxen_tso_check(struct netxen_adapter *adapter,
385 return; 498 return;
386 } 499 }
387 } 500 }
388 adapter->stats.xmitcsummed++;
389 desc->tcp_hdr_offset = skb_transport_offset(skb); 501 desc->tcp_hdr_offset = skb_transport_offset(skb);
390 desc->ip_hdr_offset = skb_network_offset(skb); 502 desc->ip_hdr_offset = skb_network_offset(skb);
391} 503}
@@ -475,7 +587,30 @@ void netxen_nic_pci_change_crbwindow(struct netxen_adapter *adapter, u32 wndw)
475 587
476 if (adapter->curr_window == wndw) 588 if (adapter->curr_window == wndw)
477 return; 589 return;
478 590 switch(adapter->portnum) {
591 case 0:
592 offset = PCI_OFFSET_SECOND_RANGE(adapter,
593 NETXEN_PCIX_PH_REG(PCIX_CRB_WINDOW));
594 break;
595 case 1:
596 offset = PCI_OFFSET_SECOND_RANGE(adapter,
597 NETXEN_PCIX_PH_REG(PCIX_CRB_WINDOW_F1));
598 break;
599 case 2:
600 offset = PCI_OFFSET_SECOND_RANGE(adapter,
601 NETXEN_PCIX_PH_REG(PCIX_CRB_WINDOW_F2));
602 break;
603 case 3:
604 offset = PCI_OFFSET_SECOND_RANGE(adapter,
605 NETXEN_PCIX_PH_REG(PCIX_CRB_WINDOW_F3));
606 break;
607 default:
608 printk(KERN_INFO "Changing the window for PCI function"
609 "%d\n", adapter->portnum);
610 offset = PCI_OFFSET_SECOND_RANGE(adapter,
611 NETXEN_PCIX_PH_REG(PCIX_CRB_WINDOW));
612 break;
613 }
479 /* 614 /*
480 * Move the CRB window. 615 * Move the CRB window.
481 * We need to write to the "direct access" region of PCI 616 * We need to write to the "direct access" region of PCI
@@ -484,9 +619,6 @@ void netxen_nic_pci_change_crbwindow(struct netxen_adapter *adapter, u32 wndw)
484 * register address is received by PCI. The direct region bypasses 619 * register address is received by PCI. The direct region bypasses
485 * the CRB bus. 620 * the CRB bus.
486 */ 621 */
487 offset =
488 PCI_OFFSET_SECOND_RANGE(adapter,
489 NETXEN_PCIX_PH_REG(PCIX_CRB_WINDOW));
490 622
491 if (wndw & 0x1) 623 if (wndw & 0x1)
492 wndw = NETXEN_WINDOW_ONE; 624 wndw = NETXEN_WINDOW_ONE;
@@ -810,43 +942,27 @@ int netxen_nic_get_board_info(struct netxen_adapter *adapter)
810 942
811/* NIU access sections */ 943/* NIU access sections */
812 944
813int netxen_nic_set_mtu_gb(struct netxen_port *port, int new_mtu) 945int netxen_nic_set_mtu_gb(struct netxen_adapter *adapter, int new_mtu)
814{ 946{
815 struct netxen_adapter *adapter = port->adapter;
816 netxen_nic_write_w0(adapter, 947 netxen_nic_write_w0(adapter,
817 NETXEN_NIU_GB_MAX_FRAME_SIZE(port->portnum), 948 NETXEN_NIU_GB_MAX_FRAME_SIZE(adapter->portnum),
818 new_mtu); 949 new_mtu);
819 return 0; 950 return 0;
820} 951}
821 952
822int netxen_nic_set_mtu_xgb(struct netxen_port *port, int new_mtu) 953int netxen_nic_set_mtu_xgb(struct netxen_adapter *adapter, int new_mtu)
823{ 954{
824 struct netxen_adapter *adapter = port->adapter;
825 new_mtu += NETXEN_NIU_HDRSIZE + NETXEN_NIU_TLRSIZE; 955 new_mtu += NETXEN_NIU_HDRSIZE + NETXEN_NIU_TLRSIZE;
826 if (port->portnum == 0) 956 if (adapter->portnum == 0)
827 netxen_nic_write_w0(adapter, NETXEN_NIU_XGE_MAX_FRAME_SIZE, new_mtu); 957 netxen_nic_write_w0(adapter, NETXEN_NIU_XGE_MAX_FRAME_SIZE, new_mtu);
828 else if (port->portnum == 1) 958 else if (adapter->portnum == 1)
829 netxen_nic_write_w0(adapter, NETXEN_NIU_XG1_MAX_FRAME_SIZE, new_mtu); 959 netxen_nic_write_w0(adapter, NETXEN_NIU_XG1_MAX_FRAME_SIZE, new_mtu);
830 return 0; 960 return 0;
831} 961}
832 962
833void netxen_nic_init_niu_gb(struct netxen_adapter *adapter) 963void netxen_nic_init_niu_gb(struct netxen_adapter *adapter)
834{ 964{
835 int portno; 965 netxen_niu_gbe_init_port(adapter, adapter->portnum);
836 for (portno = 0; portno < NETXEN_NIU_MAX_GBE_PORTS; portno++)
837 netxen_niu_gbe_init_port(adapter, portno);
838}
839
840void netxen_nic_stop_all_ports(struct netxen_adapter *adapter)
841{
842 int port_nr;
843 struct netxen_port *port;
844
845 for (port_nr = 0; port_nr < adapter->ahw.max_ports; port_nr++) {
846 port = adapter->port[port_nr];
847 if (adapter->stop_port)
848 adapter->stop_port(adapter, port->portnum);
849 }
850} 966}
851 967
852void 968void
@@ -865,9 +981,8 @@ netxen_crb_writelit_adapter(struct netxen_adapter *adapter, unsigned long off,
865 } 981 }
866} 982}
867 983
868void netxen_nic_set_link_parameters(struct netxen_port *port) 984void netxen_nic_set_link_parameters(struct netxen_adapter *adapter)
869{ 985{
870 struct netxen_adapter *adapter = port->adapter;
871 __u32 status; 986 __u32 status;
872 __u32 autoneg; 987 __u32 autoneg;
873 __u32 mode; 988 __u32 mode;
@@ -876,47 +991,47 @@ void netxen_nic_set_link_parameters(struct netxen_port *port)
876 if (netxen_get_niu_enable_ge(mode)) { /* Gb 10/100/1000 Mbps mode */ 991 if (netxen_get_niu_enable_ge(mode)) { /* Gb 10/100/1000 Mbps mode */
877 if (adapter->phy_read 992 if (adapter->phy_read
878 && adapter-> 993 && adapter->
879 phy_read(adapter, port->portnum, 994 phy_read(adapter, adapter->portnum,
880 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS, 995 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
881 &status) == 0) { 996 &status) == 0) {
882 if (netxen_get_phy_link(status)) { 997 if (netxen_get_phy_link(status)) {
883 switch (netxen_get_phy_speed(status)) { 998 switch (netxen_get_phy_speed(status)) {
884 case 0: 999 case 0:
885 port->link_speed = SPEED_10; 1000 adapter->link_speed = SPEED_10;
886 break; 1001 break;
887 case 1: 1002 case 1:
888 port->link_speed = SPEED_100; 1003 adapter->link_speed = SPEED_100;
889 break; 1004 break;
890 case 2: 1005 case 2:
891 port->link_speed = SPEED_1000; 1006 adapter->link_speed = SPEED_1000;
892 break; 1007 break;
893 default: 1008 default:
894 port->link_speed = -1; 1009 adapter->link_speed = -1;
895 break; 1010 break;
896 } 1011 }
897 switch (netxen_get_phy_duplex(status)) { 1012 switch (netxen_get_phy_duplex(status)) {
898 case 0: 1013 case 0:
899 port->link_duplex = DUPLEX_HALF; 1014 adapter->link_duplex = DUPLEX_HALF;
900 break; 1015 break;
901 case 1: 1016 case 1:
902 port->link_duplex = DUPLEX_FULL; 1017 adapter->link_duplex = DUPLEX_FULL;
903 break; 1018 break;
904 default: 1019 default:
905 port->link_duplex = -1; 1020 adapter->link_duplex = -1;
906 break; 1021 break;
907 } 1022 }
908 if (adapter->phy_read 1023 if (adapter->phy_read
909 && adapter-> 1024 && adapter->
910 phy_read(adapter, port->portnum, 1025 phy_read(adapter, adapter->portnum,
911 NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG, 1026 NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
912 &autoneg) != 0) 1027 &autoneg) != 0)
913 port->link_autoneg = autoneg; 1028 adapter->link_autoneg = autoneg;
914 } else 1029 } else
915 goto link_down; 1030 goto link_down;
916 } else { 1031 } else {
917 link_down: 1032 link_down:
918 port->link_speed = -1; 1033 adapter->link_speed = -1;
919 port->link_duplex = -1; 1034 adapter->link_duplex = -1;
920 } 1035 }
921 } 1036 }
922} 1037}
diff --git a/drivers/net/netxen/netxen_nic_hw.h b/drivers/net/netxen/netxen_nic_hw.h
index ab1112eb1b0d..841341d52dce 100644
--- a/drivers/net/netxen/netxen_nic_hw.h
+++ b/drivers/net/netxen/netxen_nic_hw.h
@@ -6,12 +6,12 @@
6 * modify it under the terms of the GNU General Public License 6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2 7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version. 8 * of the License, or (at your option) any later version.
9 * 9 *
10 * This program is distributed in the hope that it will be useful, but 10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of 11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details. 13 * GNU General Public License for more details.
14 * 14 *
15 * You should have received a copy of the GNU General Public License 15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software 16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, 17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
@@ -87,7 +87,7 @@ struct netxen_adapter;
87 *(u32 *)Y = readl((void __iomem*) addr); 87 *(u32 *)Y = readl((void __iomem*) addr);
88 88
89struct netxen_port; 89struct netxen_port;
90void netxen_nic_set_link_parameters(struct netxen_port *port); 90void netxen_nic_set_link_parameters(struct netxen_adapter *adapter);
91void netxen_nic_flash_print(struct netxen_adapter *adapter); 91void netxen_nic_flash_print(struct netxen_adapter *adapter);
92int netxen_nic_hw_write_wx(struct netxen_adapter *adapter, u64 off, 92int netxen_nic_hw_write_wx(struct netxen_adapter *adapter, u64 off,
93 void *data, int len); 93 void *data, int len);
@@ -452,21 +452,21 @@ typedef enum {
452 ((config) |= (((val) & 0x0f) << 28)) 452 ((config) |= (((val) & 0x0f) << 28))
453 453
454/* Set promiscuous mode for a GbE interface */ 454/* Set promiscuous mode for a GbE interface */
455int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter, int port, 455int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter,
456 netxen_niu_prom_mode_t mode); 456 netxen_niu_prom_mode_t mode);
457int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter, 457int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter,
458 int port, netxen_niu_prom_mode_t mode); 458 netxen_niu_prom_mode_t mode);
459 459
460/* get/set the MAC address for a given MAC */ 460/* get/set the MAC address for a given MAC */
461int netxen_niu_macaddr_get(struct netxen_adapter *adapter, int port, 461int netxen_niu_macaddr_get(struct netxen_adapter *adapter, int port,
462 netxen_ethernet_macaddr_t * addr); 462 netxen_ethernet_macaddr_t * addr);
463int netxen_niu_macaddr_set(struct netxen_port *port, 463int netxen_niu_macaddr_set(struct netxen_adapter *adapter,
464 netxen_ethernet_macaddr_t addr); 464 netxen_ethernet_macaddr_t addr);
465 465
466/* XG versons */ 466/* XG versons */
467int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter, int port, 467int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter, int port,
468 netxen_ethernet_macaddr_t * addr); 468 netxen_ethernet_macaddr_t * addr);
469int netxen_niu_xg_macaddr_set(struct netxen_port *port, 469int netxen_niu_xg_macaddr_set(struct netxen_adapter *adapter,
470 netxen_ethernet_macaddr_t addr); 470 netxen_ethernet_macaddr_t addr);
471 471
472/* Generic enable for GbE ports. Will detect the speed of the link. */ 472/* Generic enable for GbE ports. Will detect the speed of the link. */
@@ -475,8 +475,8 @@ int netxen_niu_gbe_init_port(struct netxen_adapter *adapter, int port);
475int netxen_niu_xg_init_port(struct netxen_adapter *adapter, int port); 475int netxen_niu_xg_init_port(struct netxen_adapter *adapter, int port);
476 476
477/* Disable a GbE interface */ 477/* Disable a GbE interface */
478int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter, int port); 478int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter);
479 479
480int netxen_niu_disable_xg_port(struct netxen_adapter *adapter, int port); 480int netxen_niu_disable_xg_port(struct netxen_adapter *adapter);
481 481
482#endif /* __NETXEN_NIC_HW_H_ */ 482#endif /* __NETXEN_NIC_HW_H_ */
diff --git a/drivers/net/netxen/netxen_nic_init.c b/drivers/net/netxen/netxen_nic_init.c
index 5cd40562da7c..4df38c7e71ac 100644
--- a/drivers/net/netxen/netxen_nic_init.c
+++ b/drivers/net/netxen/netxen_nic_init.c
@@ -139,7 +139,7 @@ int netxen_init_firmware(struct netxen_adapter *adapter)
139 return err; 139 return err;
140 } 140 }
141 /* Window 1 call */ 141 /* Window 1 call */
142 writel(MPORT_SINGLE_FUNCTION_MODE, 142 writel(MPORT_MULTI_FUNCTION_MODE,
143 NETXEN_CRB_NORMALIZE(adapter, CRB_MPORT_MODE)); 143 NETXEN_CRB_NORMALIZE(adapter, CRB_MPORT_MODE));
144 writel(PHAN_INITIALIZE_ACK, 144 writel(PHAN_INITIALIZE_ACK,
145 NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE)); 145 NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
@@ -990,9 +990,7 @@ int netxen_nic_rx_has_work(struct netxen_adapter *adapter)
990 990
991static inline int netxen_nic_check_temp(struct netxen_adapter *adapter) 991static inline int netxen_nic_check_temp(struct netxen_adapter *adapter)
992{ 992{
993 int port_num; 993 struct net_device *netdev = adapter->netdev;
994 struct netxen_port *port;
995 struct net_device *netdev;
996 uint32_t temp, temp_state, temp_val; 994 uint32_t temp, temp_state, temp_val;
997 int rv = 0; 995 int rv = 0;
998 996
@@ -1006,14 +1004,9 @@ static inline int netxen_nic_check_temp(struct netxen_adapter *adapter)
1006 "%s: Device temperature %d degrees C exceeds" 1004 "%s: Device temperature %d degrees C exceeds"
1007 " maximum allowed. Hardware has been shut down.\n", 1005 " maximum allowed. Hardware has been shut down.\n",
1008 netxen_nic_driver_name, temp_val); 1006 netxen_nic_driver_name, temp_val);
1009 for (port_num = 0; port_num < adapter->ahw.max_ports;
1010 port_num++) {
1011 port = adapter->port[port_num];
1012 netdev = port->netdev;
1013 1007
1014 netif_carrier_off(netdev); 1008 netif_carrier_off(netdev);
1015 netif_stop_queue(netdev); 1009 netif_stop_queue(netdev);
1016 }
1017 rv = 1; 1010 rv = 1;
1018 } else if (temp_state == NX_TEMP_WARN) { 1011 } else if (temp_state == NX_TEMP_WARN) {
1019 if (adapter->temp == NX_TEMP_NORMAL) { 1012 if (adapter->temp == NX_TEMP_NORMAL) {
@@ -1037,8 +1030,6 @@ static inline int netxen_nic_check_temp(struct netxen_adapter *adapter)
1037 1030
1038void netxen_watchdog_task(struct work_struct *work) 1031void netxen_watchdog_task(struct work_struct *work)
1039{ 1032{
1040 int port_num;
1041 struct netxen_port *port;
1042 struct net_device *netdev; 1033 struct net_device *netdev;
1043 struct netxen_adapter *adapter = 1034 struct netxen_adapter *adapter =
1044 container_of(work, struct netxen_adapter, watchdog_task); 1035 container_of(work, struct netxen_adapter, watchdog_task);
@@ -1046,20 +1037,16 @@ void netxen_watchdog_task(struct work_struct *work)
1046 if (netxen_nic_check_temp(adapter)) 1037 if (netxen_nic_check_temp(adapter))
1047 return; 1038 return;
1048 1039
1049 for (port_num = 0; port_num < adapter->ahw.max_ports; port_num++) { 1040 netdev = adapter->netdev;
1050 port = adapter->port[port_num]; 1041 if ((netif_running(netdev)) && !netif_carrier_ok(netdev)) {
1051 netdev = port->netdev; 1042 printk(KERN_INFO "%s port %d, %s carrier is now ok\n",
1052 1043 netxen_nic_driver_name, adapter->portnum, netdev->name);
1053 if ((netif_running(netdev)) && !netif_carrier_ok(netdev)) { 1044 netif_carrier_on(netdev);
1054 printk(KERN_INFO "%s port %d, %s carrier is now ok\n",
1055 netxen_nic_driver_name, port_num, netdev->name);
1056 netif_carrier_on(netdev);
1057 }
1058
1059 if (netif_queue_stopped(netdev))
1060 netif_wake_queue(netdev);
1061 } 1045 }
1062 1046
1047 if (netif_queue_stopped(netdev))
1048 netif_wake_queue(netdev);
1049
1063 if (adapter->handle_phy_intr) 1050 if (adapter->handle_phy_intr)
1064 adapter->handle_phy_intr(adapter); 1051 adapter->handle_phy_intr(adapter);
1065 mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ); 1052 mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
@@ -1074,9 +1061,8 @@ void
1074netxen_process_rcv(struct netxen_adapter *adapter, int ctxid, 1061netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
1075 struct status_desc *desc) 1062 struct status_desc *desc)
1076{ 1063{
1077 struct netxen_port *port = adapter->port[netxen_get_sts_port(desc)]; 1064 struct pci_dev *pdev = adapter->pdev;
1078 struct pci_dev *pdev = port->pdev; 1065 struct net_device *netdev = adapter->netdev;
1079 struct net_device *netdev = port->netdev;
1080 int index = netxen_get_sts_refhandle(desc); 1066 int index = netxen_get_sts_refhandle(desc);
1081 struct netxen_recv_context *recv_ctx = &(adapter->recv_ctx[ctxid]); 1067 struct netxen_recv_context *recv_ctx = &(adapter->recv_ctx[ctxid]);
1082 struct netxen_rx_buffer *buffer; 1068 struct netxen_rx_buffer *buffer;
@@ -1126,7 +1112,7 @@ netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
1126 skb = (struct sk_buff *)buffer->skb; 1112 skb = (struct sk_buff *)buffer->skb;
1127 1113
1128 if (likely(netxen_get_sts_status(desc) == STATUS_CKSUM_OK)) { 1114 if (likely(netxen_get_sts_status(desc) == STATUS_CKSUM_OK)) {
1129 port->stats.csummed++; 1115 adapter->stats.csummed++;
1130 skb->ip_summed = CHECKSUM_UNNECESSARY; 1116 skb->ip_summed = CHECKSUM_UNNECESSARY;
1131 } 1117 }
1132 if (desc_ctx == RCV_DESC_LRO_CTXID) { 1118 if (desc_ctx == RCV_DESC_LRO_CTXID) {
@@ -1146,27 +1132,27 @@ netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
1146 */ 1132 */
1147 switch (ret) { 1133 switch (ret) {
1148 case NET_RX_SUCCESS: 1134 case NET_RX_SUCCESS:
1149 port->stats.uphappy++; 1135 adapter->stats.uphappy++;
1150 break; 1136 break;
1151 1137
1152 case NET_RX_CN_LOW: 1138 case NET_RX_CN_LOW:
1153 port->stats.uplcong++; 1139 adapter->stats.uplcong++;
1154 break; 1140 break;
1155 1141
1156 case NET_RX_CN_MOD: 1142 case NET_RX_CN_MOD:
1157 port->stats.upmcong++; 1143 adapter->stats.upmcong++;
1158 break; 1144 break;
1159 1145
1160 case NET_RX_CN_HIGH: 1146 case NET_RX_CN_HIGH:
1161 port->stats.uphcong++; 1147 adapter->stats.uphcong++;
1162 break; 1148 break;
1163 1149
1164 case NET_RX_DROP: 1150 case NET_RX_DROP:
1165 port->stats.updropped++; 1151 adapter->stats.updropped++;
1166 break; 1152 break;
1167 1153
1168 default: 1154 default:
1169 port->stats.updunno++; 1155 adapter->stats.updunno++;
1170 break; 1156 break;
1171 } 1157 }
1172 1158
@@ -1178,14 +1164,13 @@ netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
1178 /* 1164 /*
1179 * We just consumed one buffer so post a buffer. 1165 * We just consumed one buffer so post a buffer.
1180 */ 1166 */
1181 adapter->stats.post_called++;
1182 buffer->skb = NULL; 1167 buffer->skb = NULL;
1183 buffer->state = NETXEN_BUFFER_FREE; 1168 buffer->state = NETXEN_BUFFER_FREE;
1184 buffer->lro_current_frags = 0; 1169 buffer->lro_current_frags = 0;
1185 buffer->lro_expected_frags = 0; 1170 buffer->lro_expected_frags = 0;
1186 1171
1187 port->stats.no_rcv++; 1172 adapter->stats.no_rcv++;
1188 port->stats.rxbytes += length; 1173 adapter->stats.rxbytes += length;
1189} 1174}
1190 1175
1191/* Process Receive status ring */ 1176/* Process Receive status ring */
@@ -1226,7 +1211,6 @@ u32 netxen_process_rcv_ring(struct netxen_adapter *adapter, int ctxid, int max)
1226 1211
1227 /* update the consumer index in phantom */ 1212 /* update the consumer index in phantom */
1228 if (count) { 1213 if (count) {
1229 adapter->stats.process_rcv++;
1230 recv_ctx->status_rx_consumer = consumer; 1214 recv_ctx->status_rx_consumer = consumer;
1231 recv_ctx->status_rx_producer = producer; 1215 recv_ctx->status_rx_producer = producer;
1232 1216
@@ -1249,13 +1233,10 @@ int netxen_process_cmd_ring(unsigned long data)
1249 int count1 = 0; 1233 int count1 = 0;
1250 int count2 = 0; 1234 int count2 = 0;
1251 struct netxen_cmd_buffer *buffer; 1235 struct netxen_cmd_buffer *buffer;
1252 struct netxen_port *port; /* port #1 */
1253 struct netxen_port *nport;
1254 struct pci_dev *pdev; 1236 struct pci_dev *pdev;
1255 struct netxen_skb_frag *frag; 1237 struct netxen_skb_frag *frag;
1256 u32 i; 1238 u32 i;
1257 struct sk_buff *skb = NULL; 1239 struct sk_buff *skb = NULL;
1258 int p;
1259 int done; 1240 int done;
1260 1241
1261 spin_lock(&adapter->tx_lock); 1242 spin_lock(&adapter->tx_lock);
@@ -1276,7 +1257,6 @@ int netxen_process_cmd_ring(unsigned long data)
1276 } 1257 }
1277 1258
1278 adapter->proc_cmd_buf_counter++; 1259 adapter->proc_cmd_buf_counter++;
1279 adapter->stats.process_xmit++;
1280 /* 1260 /*
1281 * Not needed - does not seem to be used anywhere. 1261 * Not needed - does not seem to be used anywhere.
1282 * adapter->cmd_consumer = consumer; 1262 * adapter->cmd_consumer = consumer;
@@ -1285,8 +1265,7 @@ int netxen_process_cmd_ring(unsigned long data)
1285 1265
1286 while ((last_consumer != consumer) && (count1 < MAX_STATUS_HANDLE)) { 1266 while ((last_consumer != consumer) && (count1 < MAX_STATUS_HANDLE)) {
1287 buffer = &adapter->cmd_buf_arr[last_consumer]; 1267 buffer = &adapter->cmd_buf_arr[last_consumer];
1288 port = adapter->port[buffer->port]; 1268 pdev = adapter->pdev;
1289 pdev = port->pdev;
1290 frag = &buffer->frag_array[0]; 1269 frag = &buffer->frag_array[0];
1291 skb = buffer->skb; 1270 skb = buffer->skb;
1292 if (skb && (cmpxchg(&buffer->skb, skb, 0) == skb)) { 1271 if (skb && (cmpxchg(&buffer->skb, skb, 0) == skb)) {
@@ -1299,24 +1278,23 @@ int netxen_process_cmd_ring(unsigned long data)
1299 PCI_DMA_TODEVICE); 1278 PCI_DMA_TODEVICE);
1300 } 1279 }
1301 1280
1302 port->stats.skbfreed++; 1281 adapter->stats.skbfreed++;
1303 dev_kfree_skb_any(skb); 1282 dev_kfree_skb_any(skb);
1304 skb = NULL; 1283 skb = NULL;
1305 } else if (adapter->proc_cmd_buf_counter == 1) { 1284 } else if (adapter->proc_cmd_buf_counter == 1) {
1306 port->stats.txnullskb++; 1285 adapter->stats.txnullskb++;
1307 } 1286 }
1308 if (unlikely(netif_queue_stopped(port->netdev) 1287 if (unlikely(netif_queue_stopped(adapter->netdev)
1309 && netif_carrier_ok(port->netdev)) 1288 && netif_carrier_ok(adapter->netdev))
1310 && ((jiffies - port->netdev->trans_start) > 1289 && ((jiffies - adapter->netdev->trans_start) >
1311 port->netdev->watchdog_timeo)) { 1290 adapter->netdev->watchdog_timeo)) {
1312 SCHEDULE_WORK(&port->tx_timeout_task); 1291 SCHEDULE_WORK(&adapter->tx_timeout_task);
1313 } 1292 }
1314 1293
1315 last_consumer = get_next_index(last_consumer, 1294 last_consumer = get_next_index(last_consumer,
1316 adapter->max_tx_desc_count); 1295 adapter->max_tx_desc_count);
1317 count1++; 1296 count1++;
1318 } 1297 }
1319 adapter->stats.noxmitdone += count1;
1320 1298
1321 count2 = 0; 1299 count2 = 0;
1322 spin_lock(&adapter->tx_lock); 1300 spin_lock(&adapter->tx_lock);
@@ -1336,13 +1314,10 @@ int netxen_process_cmd_ring(unsigned long data)
1336 } 1314 }
1337 } 1315 }
1338 if (count1 || count2) { 1316 if (count1 || count2) {
1339 for (p = 0; p < adapter->ahw.max_ports; p++) { 1317 if (netif_queue_stopped(adapter->netdev)
1340 nport = adapter->port[p]; 1318 && (adapter->flags & NETXEN_NETDEV_STATUS)) {
1341 if (netif_queue_stopped(nport->netdev) 1319 netif_wake_queue(adapter->netdev);
1342 && (nport->flags & NETXEN_NETDEV_STATUS)) { 1320 adapter->flags &= ~NETXEN_NETDEV_STATUS;
1343 netif_wake_queue(nport->netdev);
1344 nport->flags &= ~NETXEN_NETDEV_STATUS;
1345 }
1346 } 1321 }
1347 } 1322 }
1348 /* 1323 /*
@@ -1388,7 +1363,6 @@ void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx, u32 ringid)
1388 netxen_ctx_msg msg = 0; 1363 netxen_ctx_msg msg = 0;
1389 dma_addr_t dma; 1364 dma_addr_t dma;
1390 1365
1391 adapter->stats.post_called++;
1392 rcv_desc = &recv_ctx->rcv_desc[ringid]; 1366 rcv_desc = &recv_ctx->rcv_desc[ringid];
1393 1367
1394 producer = rcv_desc->producer; 1368 producer = rcv_desc->producer;
@@ -1441,8 +1415,6 @@ void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx, u32 ringid)
1441 if (count) { 1415 if (count) {
1442 rcv_desc->begin_alloc = index; 1416 rcv_desc->begin_alloc = index;
1443 rcv_desc->rcv_pending += count; 1417 rcv_desc->rcv_pending += count;
1444 adapter->stats.lastposted = count;
1445 adapter->stats.posted += count;
1446 rcv_desc->producer = producer; 1418 rcv_desc->producer = producer;
1447 if (rcv_desc->rcv_free >= 32) { 1419 if (rcv_desc->rcv_free >= 32) {
1448 rcv_desc->rcv_free = 0; 1420 rcv_desc->rcv_free = 0;
@@ -1450,7 +1422,8 @@ void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx, u32 ringid)
1450 writel((producer - 1) & 1422 writel((producer - 1) &
1451 (rcv_desc->max_rx_desc_count - 1), 1423 (rcv_desc->max_rx_desc_count - 1),
1452 NETXEN_CRB_NORMALIZE(adapter, 1424 NETXEN_CRB_NORMALIZE(adapter,
1453 recv_crb_registers[0]. 1425 recv_crb_registers[
1426 adapter->portnum].
1454 rcv_desc_crb[ringid]. 1427 rcv_desc_crb[ringid].
1455 crb_rcv_producer_offset)); 1428 crb_rcv_producer_offset));
1456 /* 1429 /*
@@ -1463,7 +1436,7 @@ void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx, u32 ringid)
1463 ((producer - 1436 ((producer -
1464 1) & (rcv_desc-> 1437 1) & (rcv_desc->
1465 max_rx_desc_count - 1))); 1438 max_rx_desc_count - 1)));
1466 netxen_set_msg_ctxid(msg, 0); 1439 netxen_set_msg_ctxid(msg, adapter->portnum);
1467 netxen_set_msg_opcode(msg, NETXEN_RCV_PRODUCER(ringid)); 1440 netxen_set_msg_opcode(msg, NETXEN_RCV_PRODUCER(ringid));
1468 writel(msg, 1441 writel(msg,
1469 DB_NORMALIZE(adapter, 1442 DB_NORMALIZE(adapter,
@@ -1485,7 +1458,6 @@ void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter, uint32_t ctx,
1485 int count = 0; 1458 int count = 0;
1486 int index = 0; 1459 int index = 0;
1487 1460
1488 adapter->stats.post_called++;
1489 rcv_desc = &recv_ctx->rcv_desc[ringid]; 1461 rcv_desc = &recv_ctx->rcv_desc[ringid];
1490 1462
1491 producer = rcv_desc->producer; 1463 producer = rcv_desc->producer;
@@ -1532,8 +1504,6 @@ void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter, uint32_t ctx,
1532 if (count) { 1504 if (count) {
1533 rcv_desc->begin_alloc = index; 1505 rcv_desc->begin_alloc = index;
1534 rcv_desc->rcv_pending += count; 1506 rcv_desc->rcv_pending += count;
1535 adapter->stats.lastposted = count;
1536 adapter->stats.posted += count;
1537 rcv_desc->producer = producer; 1507 rcv_desc->producer = producer;
1538 if (rcv_desc->rcv_free >= 32) { 1508 if (rcv_desc->rcv_free >= 32) {
1539 rcv_desc->rcv_free = 0; 1509 rcv_desc->rcv_free = 0;
@@ -1541,7 +1511,8 @@ void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter, uint32_t ctx,
1541 writel((producer - 1) & 1511 writel((producer - 1) &
1542 (rcv_desc->max_rx_desc_count - 1), 1512 (rcv_desc->max_rx_desc_count - 1),
1543 NETXEN_CRB_NORMALIZE(adapter, 1513 NETXEN_CRB_NORMALIZE(adapter,
1544 recv_crb_registers[0]. 1514 recv_crb_registers[
1515 adapter->portnum].
1545 rcv_desc_crb[ringid]. 1516 rcv_desc_crb[ringid].
1546 crb_rcv_producer_offset)); 1517 crb_rcv_producer_offset));
1547 wmb(); 1518 wmb();
@@ -1562,13 +1533,7 @@ int netxen_nic_tx_has_work(struct netxen_adapter *adapter)
1562 1533
1563void netxen_nic_clear_stats(struct netxen_adapter *adapter) 1534void netxen_nic_clear_stats(struct netxen_adapter *adapter)
1564{ 1535{
1565 struct netxen_port *port;
1566 int port_num;
1567
1568 memset(&adapter->stats, 0, sizeof(adapter->stats)); 1536 memset(&adapter->stats, 0, sizeof(adapter->stats));
1569 for (port_num = 0; port_num < adapter->ahw.max_ports; port_num++) { 1537 return;
1570 port = adapter->port[port_num];
1571 memset(&port->stats, 0, sizeof(port->stats));
1572 }
1573} 1538}
1574 1539
diff --git a/drivers/net/netxen/netxen_nic_isr.c b/drivers/net/netxen/netxen_nic_isr.c
index be366e48007c..f60c96991913 100644
--- a/drivers/net/netxen/netxen_nic_isr.c
+++ b/drivers/net/netxen/netxen_nic_isr.c
@@ -6,12 +6,12 @@
6 * modify it under the terms of the GNU General Public License 6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2 7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version. 8 * of the License, or (at your option) any later version.
9 * 9 *
10 * This program is distributed in the hope that it will be useful, but 10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of 11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details. 13 * GNU General Public License for more details.
14 * 14 *
15 * You should have received a copy of the GNU General Public License 15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software 16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, 17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
@@ -34,6 +34,7 @@
34#include "netxen_nic_hw.h" 34#include "netxen_nic_hw.h"
35#include "netxen_nic_phan_reg.h" 35#include "netxen_nic_phan_reg.h"
36 36
37#if 0
37/* 38/*
38 * netxen_nic_get_stats - Get System Network Statistics 39 * netxen_nic_get_stats - Get System Network Statistics
39 * @netdev: network interface device structure 40 * @netdev: network interface device structure
@@ -41,7 +42,7 @@
41struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev) 42struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev)
42{ 43{
43 struct netxen_port *port = netdev_priv(netdev); 44 struct netxen_port *port = netdev_priv(netdev);
44 struct net_device_stats *stats = &port->net_stats; 45 struct net_device_stats *stats = &adapter->net_stats;
45 46
46 memset(stats, 0, sizeof(*stats)); 47 memset(stats, 0, sizeof(*stats));
47 48
@@ -64,11 +65,10 @@ struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev)
64 65
65 return stats; 66 return stats;
66} 67}
67 68#endif
68void netxen_indicate_link_status(struct netxen_adapter *adapter, u32 portno, 69void netxen_indicate_link_status(struct netxen_adapter *adapter, u32 link)
69 u32 link)
70{ 70{
71 struct net_device *netdev = (adapter->port[portno])->netdev; 71 struct net_device *netdev = adapter->netdev;
72 72
73 if (link) 73 if (link)
74 netif_carrier_on(netdev); 74 netif_carrier_on(netdev);
@@ -76,15 +76,13 @@ void netxen_indicate_link_status(struct netxen_adapter *adapter, u32 portno,
76 netif_carrier_off(netdev); 76 netif_carrier_off(netdev);
77} 77}
78 78
79void netxen_handle_port_int(struct netxen_adapter *adapter, u32 portno, 79void netxen_handle_port_int(struct netxen_adapter *adapter, u32 enable)
80 u32 enable)
81{ 80{
82 __u32 int_src; 81 __u32 int_src;
83 struct netxen_port *port;
84 82
85 /* This should clear the interrupt source */ 83 /* This should clear the interrupt source */
86 if (adapter->phy_read) 84 if (adapter->phy_read)
87 adapter->phy_read(adapter, portno, 85 adapter->phy_read(adapter, adapter->portnum,
88 NETXEN_NIU_GB_MII_MGMT_ADDR_INT_STATUS, 86 NETXEN_NIU_GB_MII_MGMT_ADDR_INT_STATUS,
89 &int_src); 87 &int_src);
90 if (int_src == 0) { 88 if (int_src == 0) {
@@ -92,9 +90,7 @@ void netxen_handle_port_int(struct netxen_adapter *adapter, u32 portno,
92 return; 90 return;
93 } 91 }
94 if (adapter->disable_phy_interrupts) 92 if (adapter->disable_phy_interrupts)
95 adapter->disable_phy_interrupts(adapter, portno); 93 adapter->disable_phy_interrupts(adapter, adapter->portnum);
96
97 port = adapter->port[portno];
98 94
99 if (netxen_get_phy_int_jabber(int_src)) 95 if (netxen_get_phy_int_jabber(int_src))
100 DPRINTK(INFO, "Jabber interrupt \n"); 96 DPRINTK(INFO, "Jabber interrupt \n");
@@ -115,64 +111,60 @@ void netxen_handle_port_int(struct netxen_adapter *adapter, u32 portno,
115 DPRINTK(INFO, "SPEED CHANGED OR LINK STATUS CHANGED \n"); 111 DPRINTK(INFO, "SPEED CHANGED OR LINK STATUS CHANGED \n");
116 112
117 if (adapter->phy_read 113 if (adapter->phy_read
118 && adapter->phy_read(adapter, portno, 114 && adapter->phy_read(adapter, adapter->portnum,
119 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS, 115 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
120 &status) == 0) { 116 &status) == 0) {
121 if (netxen_get_phy_int_link_status_changed(int_src)) { 117 if (netxen_get_phy_int_link_status_changed(int_src)) {
122 if (netxen_get_phy_link(status)) { 118 if (netxen_get_phy_link(status)) {
123 netxen_niu_gbe_init_port(adapter, 119 netxen_niu_gbe_init_port(
124 portno); 120 adapter,
125 printk("%s: %s Link UP\n", 121 adapter->portnum);
122 printk(KERN_INFO "%s: %s Link UP\n",
126 netxen_nic_driver_name, 123 netxen_nic_driver_name,
127 port->netdev->name); 124 adapter->netdev->name);
128 125
129 } else { 126 } else {
130 printk("%s: %s Link DOWN\n", 127 printk(KERN_INFO "%s: %s Link DOWN\n",
131 netxen_nic_driver_name, 128 netxen_nic_driver_name,
132 port->netdev->name); 129 adapter->netdev->name);
133 } 130 }
134 netxen_indicate_link_status(adapter, portno, 131 netxen_indicate_link_status(adapter,
135 netxen_get_phy_link 132 netxen_get_phy_link
136 (status)); 133 (status));
137 } 134 }
138 } 135 }
139 } 136 }
140 if (adapter->enable_phy_interrupts) 137 if (adapter->enable_phy_interrupts)
141 adapter->enable_phy_interrupts(adapter, portno); 138 adapter->enable_phy_interrupts(adapter, adapter->portnum);
142} 139}
143 140
144void netxen_nic_isr_other(struct netxen_adapter *adapter) 141void netxen_nic_isr_other(struct netxen_adapter *adapter)
145{ 142{
146 u32 portno; 143 int portno = adapter->portnum;
147 u32 val, linkup, qg_linksup; 144 u32 val, linkup, qg_linksup;
148 145
149 /* verify the offset */ 146 /* verify the offset */
150 val = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_XG_STATE)); 147 val = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_XG_STATE));
148 val = val >> adapter->portnum;
151 if (val == adapter->ahw.qg_linksup) 149 if (val == adapter->ahw.qg_linksup)
152 return; 150 return;
153 151
154 qg_linksup = adapter->ahw.qg_linksup; 152 qg_linksup = adapter->ahw.qg_linksup;
155 adapter->ahw.qg_linksup = val; 153 adapter->ahw.qg_linksup = val;
156 DPRINTK(INFO, "link update 0x%08x\n", val); 154 DPRINTK(INFO, "link update 0x%08x\n", val);
157 for (portno = 0; portno < NETXEN_NIU_MAX_GBE_PORTS; portno++) {
158 linkup = val & 1;
159 if (linkup != (qg_linksup & 1)) {
160 printk(KERN_INFO "%s: %s PORT %d link %s\n",
161 adapter->port[portno]->netdev->name,
162 netxen_nic_driver_name, portno,
163 ((linkup == 0) ? "down" : "up"));
164 netxen_indicate_link_status(adapter, portno, linkup);
165 if (linkup)
166 netxen_nic_set_link_parameters(adapter->
167 port[portno]);
168 155
169 } 156 linkup = val & 1;
170 val = val >> 1;
171 qg_linksup = qg_linksup >> 1;
172 }
173 157
174 adapter->stats.otherints++; 158 if (linkup != (qg_linksup & 1)) {
159 printk(KERN_INFO "%s: %s PORT %d link %s\n",
160 adapter->netdev->name,
161 netxen_nic_driver_name, portno,
162 ((linkup == 0) ? "down" : "up"));
163 netxen_indicate_link_status(adapter, linkup);
164 if (linkup)
165 netxen_nic_set_link_parameters(adapter);
175 166
167 }
176} 168}
177 169
178void netxen_nic_gbe_handle_phy_intr(struct netxen_adapter *adapter) 170void netxen_nic_gbe_handle_phy_intr(struct netxen_adapter *adapter)
@@ -182,26 +174,27 @@ void netxen_nic_gbe_handle_phy_intr(struct netxen_adapter *adapter)
182 174
183void netxen_nic_xgbe_handle_phy_intr(struct netxen_adapter *adapter) 175void netxen_nic_xgbe_handle_phy_intr(struct netxen_adapter *adapter)
184{ 176{
185 struct net_device *netdev = adapter->port[0]->netdev; 177 struct net_device *netdev = adapter->netdev;
186 u32 val; 178 u32 val, val1;
187 179
188 /* WINDOW = 1 */ 180 /* WINDOW = 1 */
189 val = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_XG_STATE)); 181 val = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_XG_STATE));
182 val1 = val & 0xff;
190 183
191 if (adapter->ahw.xg_linkup == 1 && val != XG_LINK_UP) { 184 if (adapter->ahw.xg_linkup == 1 && val1 != XG_LINK_UP) {
192 printk(KERN_INFO "%s: %s NIC Link is down\n", 185 printk(KERN_INFO "%s: %s NIC Link is down\n",
193 netxen_nic_driver_name, netdev->name); 186 netxen_nic_driver_name, netdev->name);
194 adapter->ahw.xg_linkup = 0; 187 adapter->ahw.xg_linkup = 0;
195 /* read twice to clear sticky bits */ 188 /* read twice to clear sticky bits */
196 /* WINDOW = 0 */ 189 /* WINDOW = 0 */
197 netxen_nic_read_w0(adapter, NETXEN_NIU_XG_STATUS, &val); 190 netxen_nic_read_w0(adapter, NETXEN_NIU_XG_STATUS, &val1);
198 netxen_nic_read_w0(adapter, NETXEN_NIU_XG_STATUS, &val); 191 netxen_nic_read_w0(adapter, NETXEN_NIU_XG_STATUS, &val1);
199 192
200 if ((val & 0xffb) != 0xffb) { 193 if ((val & 0xffb) != 0xffb) {
201 printk(KERN_INFO "%s ISR: Sync/Align BAD: 0x%08x\n", 194 printk(KERN_INFO "%s ISR: Sync/Align BAD: 0x%08x\n",
202 netxen_nic_driver_name, val); 195 netxen_nic_driver_name, val1);
203 } 196 }
204 } else if (adapter->ahw.xg_linkup == 0 && val == XG_LINK_UP) { 197 } else if (adapter->ahw.xg_linkup == 0 && val1 == XG_LINK_UP) {
205 printk(KERN_INFO "%s: %s NIC Link is up\n", 198 printk(KERN_INFO "%s: %s NIC Link is up\n",
206 netxen_nic_driver_name, netdev->name); 199 netxen_nic_driver_name, netdev->name);
207 adapter->ahw.xg_linkup = 1; 200 adapter->ahw.xg_linkup = 1;
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index ab25c225a07e..514cb393f489 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -36,7 +36,6 @@
36#include "netxen_nic_hw.h" 36#include "netxen_nic_hw.h"
37 37
38#include "netxen_nic.h" 38#include "netxen_nic.h"
39#define DEFINE_GLOBAL_RECV_CRB
40#include "netxen_nic_phan_reg.h" 39#include "netxen_nic_phan_reg.h"
41 40
42#include <linux/dma-mapping.h> 41#include <linux/dma-mapping.h>
@@ -94,6 +93,67 @@ MODULE_DEVICE_TABLE(pci, netxen_pci_tbl);
94struct workqueue_struct *netxen_workq; 93struct workqueue_struct *netxen_workq;
95static void netxen_watchdog(unsigned long); 94static void netxen_watchdog(unsigned long);
96 95
96static inline void netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
97 uint32_t crb_producer)
98{
99 switch (adapter->portnum) {
100 case 0:
101 writel(crb_producer, NETXEN_CRB_NORMALIZE
102 (adapter, CRB_CMD_PRODUCER_OFFSET));
103 return;
104 case 1:
105 writel(crb_producer, NETXEN_CRB_NORMALIZE
106 (adapter, CRB_CMD_PRODUCER_OFFSET_1));
107 return;
108 case 2:
109 writel(crb_producer, NETXEN_CRB_NORMALIZE
110 (adapter, CRB_CMD_PRODUCER_OFFSET_2));
111 return;
112 case 3:
113 writel(crb_producer, NETXEN_CRB_NORMALIZE
114 (adapter, CRB_CMD_PRODUCER_OFFSET_3));
115 return;
116 default:
117 printk(KERN_WARNING "We tried to update "
118 "CRB_CMD_PRODUCER_OFFSET for invalid "
119 "PCI function id %d\n",
120 adapter->portnum);
121 return;
122 }
123}
124
125static inline void netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
126 u32 crb_consumer)
127{
128 switch (adapter->portnum) {
129 case 0:
130 writel(crb_consumer, NETXEN_CRB_NORMALIZE
131 (adapter, CRB_CMD_CONSUMER_OFFSET));
132 return;
133 case 1:
134 writel(crb_consumer, NETXEN_CRB_NORMALIZE
135 (adapter, CRB_CMD_CONSUMER_OFFSET_1));
136 return;
137 case 2:
138 writel(crb_consumer, NETXEN_CRB_NORMALIZE
139 (adapter, CRB_CMD_CONSUMER_OFFSET_2));
140 return;
141 case 3:
142 writel(crb_consumer, NETXEN_CRB_NORMALIZE
143 (adapter, CRB_CMD_CONSUMER_OFFSET_3));
144 return;
145 default:
146 printk(KERN_WARNING "We tried to update "
147 "CRB_CMD_PRODUCER_OFFSET for invalid "
148 "PCI function id %d\n",
149 adapter->portnum);
150 return;
151 }
152}
153
154#define ADAPTER_LIST_SIZE 12
155int netxen_cards_found;
156
97/* 157/*
98 * netxen_nic_probe() 158 * netxen_nic_probe()
99 * 159 *
@@ -111,26 +171,26 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
111{ 171{
112 struct net_device *netdev = NULL; 172 struct net_device *netdev = NULL;
113 struct netxen_adapter *adapter = NULL; 173 struct netxen_adapter *adapter = NULL;
114 struct netxen_port *port = NULL;
115 void __iomem *mem_ptr0 = NULL; 174 void __iomem *mem_ptr0 = NULL;
116 void __iomem *mem_ptr1 = NULL; 175 void __iomem *mem_ptr1 = NULL;
117 void __iomem *mem_ptr2 = NULL; 176 void __iomem *mem_ptr2 = NULL;
118 177
119 u8 __iomem *db_ptr = NULL; 178 u8 __iomem *db_ptr = NULL;
120 unsigned long mem_base, mem_len, db_base, db_len; 179 unsigned long mem_base, mem_len, db_base, db_len;
121 int pci_using_dac, i, err; 180 int pci_using_dac, i = 0, err;
122 int ring; 181 int ring;
123 struct netxen_recv_context *recv_ctx = NULL; 182 struct netxen_recv_context *recv_ctx = NULL;
124 struct netxen_rcv_desc_ctx *rcv_desc = NULL; 183 struct netxen_rcv_desc_ctx *rcv_desc = NULL;
125 struct netxen_cmd_buffer *cmd_buf_arr = NULL; 184 struct netxen_cmd_buffer *cmd_buf_arr = NULL;
126 u64 mac_addr[FLASH_NUM_PORTS + 1]; 185 u64 mac_addr[FLASH_NUM_PORTS + 1];
127 int valid_mac = 0; 186 static int valid_mac = 0;
187 static int netxen_probe_flag;
188 int pci_func_id = PCI_FUNC(pdev->devfn);
128 189
129 printk(KERN_INFO "%s \n", netxen_nic_driver_string); 190 printk(KERN_INFO "%s \n", netxen_nic_driver_string);
130 /* In current scheme, we use only PCI function 0 */ 191 if (pdev->class != 0x020000) {
131 if (PCI_FUNC(pdev->devfn) != 0) { 192 printk(KERN_ERR"NetXen function %d, class %x will not"
132 DPRINTK(ERR, "NetXen function %d will not be enabled.\n", 193 "be enabled.\n",pci_func_id, pdev->class);
133 PCI_FUNC(pdev->devfn));
134 return -ENODEV; 194 return -ENODEV;
135 } 195 }
136 if ((err = pci_enable_device(pdev))) 196 if ((err = pci_enable_device(pdev)))
@@ -157,6 +217,22 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
157 pci_using_dac = 0; 217 pci_using_dac = 0;
158 } 218 }
159 219
220
221 netdev = alloc_etherdev(sizeof(struct netxen_adapter));
222 if(!netdev) {
223 printk(KERN_ERR"%s: Failed to allocate memory for the "
224 "device block.Check system memory resource"
225 " usage.\n", netxen_nic_driver_name);
226 goto err_out_free_res;
227 }
228
229 SET_MODULE_OWNER(netdev);
230 SET_NETDEV_DEV(netdev, &pdev->dev);
231
232 adapter = netdev->priv;
233 memset(adapter, 0 , sizeof(struct netxen_adapter));
234
235 adapter->ahw.pdev = pdev;
160 /* remap phys address */ 236 /* remap phys address */
161 mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */ 237 mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
162 mem_len = pci_resource_len(pdev, 0); 238 mem_len = pci_resource_len(pdev, 0);
@@ -198,23 +274,6 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
198 } 274 }
199 DPRINTK(INFO, "doorbell ioremaped at %p\n", db_ptr); 275 DPRINTK(INFO, "doorbell ioremaped at %p\n", db_ptr);
200 276
201/*
202 * Allocate a adapter structure which will manage all the initialization
203 * as well as the common resources for all ports...
204 * all the ports will have pointer to this adapter as well as Adapter
205 * will have pointers of all the ports structures.
206 */
207
208 /* One adapter structure for all 4 ports.... */
209 adapter = kzalloc(sizeof(struct netxen_adapter), GFP_KERNEL);
210 if (adapter == NULL) {
211 printk(KERN_ERR "%s: Could not allocate adapter memory:%d\n",
212 netxen_nic_driver_name,
213 (int)sizeof(struct netxen_adapter));
214 err = -ENOMEM;
215 goto err_out_dbunmap;
216 }
217
218 adapter->max_tx_desc_count = MAX_CMD_DESCRIPTORS; 277 adapter->max_tx_desc_count = MAX_CMD_DESCRIPTORS;
219 adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS; 278 adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS;
220 adapter->max_jumbo_rx_desc_count = MAX_JUMBO_RCV_DESCRIPTORS; 279 adapter->max_jumbo_rx_desc_count = MAX_JUMBO_RCV_DESCRIPTORS;
@@ -222,6 +281,42 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
222 281
223 pci_set_drvdata(pdev, adapter); 282 pci_set_drvdata(pdev, adapter);
224 283
284 adapter->netdev = netdev;
285 adapter->pdev = pdev;
286 adapter->portnum = pci_func_id;
287
288 netdev->open = netxen_nic_open;
289 netdev->stop = netxen_nic_close;
290 netdev->hard_start_xmit = netxen_nic_xmit_frame;
291 netdev->set_multicast_list = netxen_nic_set_multi;
292 netdev->set_mac_address = netxen_nic_set_mac;
293 netdev->change_mtu = netxen_nic_change_mtu;
294 netdev->tx_timeout = netxen_tx_timeout;
295 netdev->watchdog_timeo = HZ;
296
297 netxen_nic_change_mtu(netdev, netdev->mtu);
298
299 SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
300 netdev->poll = netxen_nic_poll;
301 netdev->weight = NETXEN_NETDEV_WEIGHT;
302#ifdef CONFIG_NET_POLL_CONTROLLER
303 netdev->poll_controller = netxen_nic_poll_controller;
304#endif
305 /* ScatterGather support */
306 netdev->features = NETIF_F_SG;
307 netdev->features |= NETIF_F_IP_CSUM;
308 netdev->features |= NETIF_F_TSO;
309
310 if (pci_using_dac)
311 netdev->features |= NETIF_F_HIGHDMA;
312
313 if (pci_enable_msi(pdev)) {
314 adapter->flags &= ~NETXEN_NIC_MSI_ENABLED;
315 printk(KERN_WARNING "%s: unable to allocate MSI interrupt"
316 " error\n", netxen_nic_driver_name);
317 } else
318 adapter->flags |= NETXEN_NIC_MSI_ENABLED;
319
225 cmd_buf_arr = (struct netxen_cmd_buffer *)vmalloc(TX_RINGSIZE); 320 cmd_buf_arr = (struct netxen_cmd_buffer *)vmalloc(TX_RINGSIZE);
226 if (cmd_buf_arr == NULL) { 321 if (cmd_buf_arr == NULL) {
227 printk(KERN_ERR 322 printk(KERN_ERR
@@ -288,9 +383,11 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
288 spin_lock_init(&adapter->lock); 383 spin_lock_init(&adapter->lock);
289 netxen_initialize_adapter_sw(adapter); /* initialize the buffers in adapter */ 384 netxen_initialize_adapter_sw(adapter); /* initialize the buffers in adapter */
290#ifdef CONFIG_IA64 385#ifdef CONFIG_IA64
291 netxen_pinit_from_rom(adapter, 0); 386 if(netxen_probe_flag == 0) {
292 udelay(500); 387 netxen_pinit_from_rom(adapter, 0);
293 netxen_load_firmware(adapter); 388 udelay(500);
389 netxen_load_firmware(adapter);
390 }
294#endif 391#endif
295 392
296 /* 393 /*
@@ -304,6 +401,10 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
304 */ 401 */
305 netxen_initialize_adapter_hw(adapter); /* initialize the adapter */ 402 netxen_initialize_adapter_hw(adapter); /* initialize the adapter */
306 403
404 if (adapter->ahw.boardcfg.board_type == NETXEN_BRDTYPE_P2_SB31_10G_IMEZ)
405 if (pci_func_id >= 2)
406 adapter->portnum = pci_func_id - 2;
407
307 netxen_initialize_adapter_ops(adapter); 408 netxen_initialize_adapter_ops(adapter);
308 409
309 init_timer(&adapter->watchdog_timer); 410 init_timer(&adapter->watchdog_timer);
@@ -315,12 +416,8 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
315 adapter->proc_cmd_buf_counter = 0; 416 adapter->proc_cmd_buf_counter = 0;
316 adapter->ahw.revision_id = nx_p2_id; 417 adapter->ahw.revision_id = nx_p2_id;
317 418
318 if (pci_enable_msi(pdev)) { 419 netxen_nic_update_cmd_producer(adapter, 0);
319 adapter->flags &= ~NETXEN_NIC_MSI_ENABLED; 420 netxen_nic_update_cmd_consumer(adapter, 0);
320 printk(KERN_WARNING "%s: unable to allocate MSI interrupt"
321 " error\n", netxen_nic_driver_name);
322 } else
323 adapter->flags |= NETXEN_NIC_MSI_ENABLED;
324 421
325 if (netxen_is_flash_supported(adapter) == 0 && 422 if (netxen_is_flash_supported(adapter) == 0 &&
326 netxen_get_flash_mac_addr(adapter, mac_addr) == 0) 423 netxen_get_flash_mac_addr(adapter, mac_addr) == 0)
@@ -328,6 +425,34 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
328 else 425 else
329 valid_mac = 0; 426 valid_mac = 0;
330 427
428 if (valid_mac) {
429 unsigned char *p = (unsigned char *)&mac_addr[i];
430 netdev->dev_addr[0] = *(p + 5);
431 netdev->dev_addr[1] = *(p + 4);
432 netdev->dev_addr[2] = *(p + 3);
433 netdev->dev_addr[3] = *(p + 2);
434 netdev->dev_addr[4] = *(p + 1);
435 netdev->dev_addr[5] = *(p + 0);
436
437 memcpy(netdev->perm_addr, netdev->dev_addr,
438 netdev->addr_len);
439 if (!is_valid_ether_addr(netdev->perm_addr)) {
440 printk(KERN_ERR "%s: Bad MAC address "
441 "%02x:%02x:%02x:%02x:%02x:%02x.\n",
442 netxen_nic_driver_name,
443 netdev->dev_addr[0],
444 netdev->dev_addr[1],
445 netdev->dev_addr[2],
446 netdev->dev_addr[3],
447 netdev->dev_addr[4],
448 netdev->dev_addr[5]);
449 } else {
450 if (adapter->macaddr_set)
451 adapter->macaddr_set(adapter,
452 netdev->dev_addr);
453 }
454 }
455
331 /* 456 /*
332 * Initialize all the CRB registers here. 457 * Initialize all the CRB registers here.
333 */ 458 */
@@ -337,140 +462,62 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
337 462
338 /* do this before waking up pegs so that we have valid dummy dma addr */ 463 /* do this before waking up pegs so that we have valid dummy dma addr */
339 err = netxen_initialize_adapter_offload(adapter); 464 err = netxen_initialize_adapter_offload(adapter);
340 if (err) { 465 if (err)
341 goto err_out_free_dev; 466 goto err_out_free_dev;
342 }
343
344 /* Unlock the HW, prompting the boot sequence */
345 writel(1,
346 NETXEN_CRB_NORMALIZE(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE));
347
348 /* Handshake with the card before we register the devices. */
349 netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
350
351 /* initialize the all the ports */
352 adapter->active_ports = 0;
353
354 for (i = 0; i < adapter->ahw.max_ports; i++) {
355 netdev = alloc_etherdev(sizeof(struct netxen_port));
356 if (!netdev) {
357 printk(KERN_ERR "%s: could not allocate netdev for port"
358 " %d\n", netxen_nic_driver_name, i + 1);
359 goto err_out_free_dev;
360 }
361 467
362 SET_MODULE_OWNER(netdev); 468 if (netxen_probe_flag == 0) {
363 SET_NETDEV_DEV(netdev, &pdev->dev); 469 /* Unlock the HW, prompting the boot sequence */
364 470 writel(1,
365 port = netdev_priv(netdev); 471 NETXEN_CRB_NORMALIZE(adapter,
366 port->netdev = netdev; 472 NETXEN_ROMUSB_GLB_PEGTUNE_DONE));
367 port->pdev = pdev; 473 /* Handshake with the card before we register the devices. */
368 port->adapter = adapter; 474 netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
369 port->portnum = i; /* Gigabit port number from 0-3 */ 475 }
370
371 netdev->open = netxen_nic_open;
372 netdev->stop = netxen_nic_close;
373 netdev->hard_start_xmit = netxen_nic_xmit_frame;
374 netdev->get_stats = netxen_nic_get_stats;
375 netdev->set_multicast_list = netxen_nic_set_multi;
376 netdev->set_mac_address = netxen_nic_set_mac;
377 netdev->change_mtu = netxen_nic_change_mtu;
378 netdev->tx_timeout = netxen_tx_timeout;
379 netdev->watchdog_timeo = HZ;
380
381 netxen_nic_change_mtu(netdev, netdev->mtu);
382
383 SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
384 netdev->poll = netxen_nic_poll;
385 netdev->weight = NETXEN_NETDEV_WEIGHT;
386#ifdef CONFIG_NET_POLL_CONTROLLER
387 netdev->poll_controller = netxen_nic_poll_controller;
388#endif
389 /* ScatterGather support */
390 netdev->features = NETIF_F_SG;
391 netdev->features |= NETIF_F_IP_CSUM;
392 netdev->features |= NETIF_F_TSO;
393
394 if (pci_using_dac)
395 netdev->features |= NETIF_F_HIGHDMA;
396
397 if (valid_mac) {
398 unsigned char *p = (unsigned char *)&mac_addr[i];
399 netdev->dev_addr[0] = *(p + 5);
400 netdev->dev_addr[1] = *(p + 4);
401 netdev->dev_addr[2] = *(p + 3);
402 netdev->dev_addr[3] = *(p + 2);
403 netdev->dev_addr[4] = *(p + 1);
404 netdev->dev_addr[5] = *(p + 0);
405
406 memcpy(netdev->perm_addr, netdev->dev_addr,
407 netdev->addr_len);
408 if (!is_valid_ether_addr(netdev->perm_addr)) {
409 printk(KERN_ERR "%s: Bad MAC address "
410 "%02x:%02x:%02x:%02x:%02x:%02x.\n",
411 netxen_nic_driver_name,
412 netdev->dev_addr[0],
413 netdev->dev_addr[1],
414 netdev->dev_addr[2],
415 netdev->dev_addr[3],
416 netdev->dev_addr[4],
417 netdev->dev_addr[5]);
418 } else {
419 if (adapter->macaddr_set)
420 adapter->macaddr_set(port,
421 netdev->dev_addr);
422 }
423 }
424 INIT_WORK(&port->tx_timeout_task, netxen_tx_timeout_task);
425 netif_carrier_off(netdev);
426 netif_stop_queue(netdev);
427 476
428 if ((err = register_netdev(netdev))) { 477 if(netxen_probe_flag == 0) {
429 printk(KERN_ERR "%s: register_netdev failed port #%d" 478 writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
430 " aborting\n", netxen_nic_driver_name, i + 1); 479 netxen_pinit_from_rom(adapter, 0);
431 err = -EIO; 480 udelay(500);
432 free_netdev(netdev); 481 netxen_load_firmware(adapter);
433 goto err_out_free_dev; 482 netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
434 }
435 adapter->port_count++;
436 adapter->port[i] = port;
437 } 483 }
438 writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
439 netxen_pinit_from_rom(adapter, 0);
440 udelay(500);
441 netxen_load_firmware(adapter);
442 netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
443 /* 484 /*
444 * delay a while to ensure that the Pegs are up & running. 485 * delay a while to ensure that the Pegs are up & running.
445 * Otherwise, we might see some flaky behaviour. 486 * Otherwise, we might see some flaky behaviour.
446 */ 487 */
447 udelay(100); 488 udelay(100);
489 INIT_WORK(&adapter->tx_timeout_task, netxen_tx_timeout_task);
490 netif_carrier_off(netdev);
491 netif_stop_queue(netdev);
492
493 if((err = register_netdev(netdev)))
494 DPRINTK(1, ERR, "register_netdev failed port #%d"
495 " aborting\n", i+1);
448 496
449 switch (adapter->ahw.board_type) { 497 switch (adapter->ahw.board_type) {
450 case NETXEN_NIC_GBE: 498 case NETXEN_NIC_GBE:
451 printk("%s: QUAD GbE board initialized\n", 499 printk(KERN_INFO "%s: QUAD GbE board initialized\n",
452 netxen_nic_driver_name); 500 netxen_nic_driver_name);
453 break; 501 break;
454 502
455 case NETXEN_NIC_XGBE: 503 case NETXEN_NIC_XGBE:
456 printk("%s: XGbE board initialized\n", netxen_nic_driver_name); 504 printk(KERN_INFO "%s: XGbE board initialized\n",
457 break; 505 netxen_nic_driver_name);
506 break;
458 } 507 }
459 508
460 adapter->driver_mismatch = 0; 509 adapter->driver_mismatch = 0;
510 if(netxen_probe_flag == 0)
511 netxen_probe_flag ++;
461 512
462 return 0; 513 return 0;
463 514
464 err_out_free_dev: 515 err_out_free_dev:
465 if (adapter->flags & NETXEN_NIC_MSI_ENABLED) 516 if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
466 pci_disable_msi(pdev); 517 pci_disable_msi(pdev);
467 for (i = 0; i < adapter->port_count; i++) { 518
468 port = adapter->port[i]; 519 unregister_netdev(adapter->netdev);
469 if ((port) && (port->netdev)) { 520 free_netdev(adapter->netdev);
470 unregister_netdev(port->netdev);
471 free_netdev(port->netdev);
472 }
473 }
474 521
475 netxen_free_adapter_offload(adapter); 522 netxen_free_adapter_offload(adapter);
476 523
@@ -491,7 +538,6 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
491 pci_set_drvdata(pdev, NULL); 538 pci_set_drvdata(pdev, NULL);
492 kfree(adapter); 539 kfree(adapter);
493 540
494 err_out_dbunmap:
495 if (db_ptr) 541 if (db_ptr)
496 iounmap(db_ptr); 542 iounmap(db_ptr);
497 543
@@ -513,35 +559,32 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
513static void __devexit netxen_nic_remove(struct pci_dev *pdev) 559static void __devexit netxen_nic_remove(struct pci_dev *pdev)
514{ 560{
515 struct netxen_adapter *adapter; 561 struct netxen_adapter *adapter;
516 struct netxen_port *port; 562 struct net_device *netdev;
517 struct netxen_rx_buffer *buffer; 563 struct netxen_rx_buffer *buffer;
518 struct netxen_recv_context *recv_ctx; 564 struct netxen_recv_context *recv_ctx;
519 struct netxen_rcv_desc_ctx *rcv_desc; 565 struct netxen_rcv_desc_ctx *rcv_desc;
520 int i; 566 int i;
521 int ctxid, ring; 567 int ctxid, ring;
522 568
523 adapter = pci_get_drvdata(pdev); 569 netdev = pci_get_drvdata(pdev);
570 adapter = netdev_priv(netdev);
524 if (adapter == NULL) 571 if (adapter == NULL)
525 return; 572 return;
526 573
574 if (adapter->stop_port)
575 adapter->stop_port(adapter);
576
527 if (adapter->irq) 577 if (adapter->irq)
528 free_irq(adapter->irq, adapter); 578 free_irq(adapter->irq, adapter);
529 netxen_nic_stop_all_ports(adapter);
530 /* leave the hw in the same state as reboot */ 579 /* leave the hw in the same state as reboot */
531 writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE)); 580 writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
532 netxen_pinit_from_rom(adapter, 0); 581 netxen_pinit_from_rom(adapter, 0);
533 udelay(500);
534 netxen_load_firmware(adapter); 582 netxen_load_firmware(adapter);
535 netxen_free_adapter_offload(adapter); 583 netxen_free_adapter_offload(adapter);
536 584
537 mdelay(1000); /* Delay for a while to drain the DMA engines */ 585 udelay(500);
538 for (i = 0; i < adapter->port_count; i++) { 586 unregister_netdev(netdev);
539 port = adapter->port[i]; 587 free_netdev(netdev);
540 if ((port) && (port->netdev)) {
541 unregister_netdev(port->netdev);
542 free_netdev(port->netdev);
543 }
544 }
545 588
546 if ((adapter->flags & NETXEN_NIC_MSI_ENABLED)) 589 if ((adapter->flags & NETXEN_NIC_MSI_ENABLED))
547 pci_disable_msi(pdev); 590 pci_disable_msi(pdev);
@@ -585,8 +628,7 @@ static void __devexit netxen_nic_remove(struct pci_dev *pdev)
585 */ 628 */
586static int netxen_nic_open(struct net_device *netdev) 629static int netxen_nic_open(struct net_device *netdev)
587{ 630{
588 struct netxen_port *port = netdev_priv(netdev); 631 struct netxen_adapter *adapter = (struct netxen_adapter *)netdev->priv;
589 struct netxen_adapter *adapter = port->adapter;
590 int err = 0; 632 int err = 0;
591 int ctx, ring; 633 int ctx, ring;
592 634
@@ -610,9 +652,9 @@ static int netxen_nic_open(struct net_device *netdev)
610 return err; 652 return err;
611 } 653 }
612 if (adapter->init_port 654 if (adapter->init_port
613 && adapter->init_port(adapter, port->portnum) != 0) { 655 && adapter->init_port(adapter, adapter->portnum) != 0) {
614 printk(KERN_ERR "%s: Failed to initialize port %d\n", 656 printk(KERN_ERR "%s: Failed to initialize port %d\n",
615 netxen_nic_driver_name, port->portnum); 657 netxen_nic_driver_name, adapter->portnum);
616 netxen_free_hw_resources(adapter); 658 netxen_free_hw_resources(adapter);
617 return -EIO; 659 return -EIO;
618 } 660 }
@@ -632,23 +674,20 @@ static int netxen_nic_open(struct net_device *netdev)
632 674
633 adapter->is_up = NETXEN_ADAPTER_UP_MAGIC; 675 adapter->is_up = NETXEN_ADAPTER_UP_MAGIC;
634 } 676 }
635 adapter->active_ports++; 677 if (!adapter->driver_mismatch)
636 if (adapter->active_ports == 1) { 678 mod_timer(&adapter->watchdog_timer, jiffies);
637 if (!adapter->driver_mismatch)
638 mod_timer(&adapter->watchdog_timer, jiffies);
639 679
640 netxen_nic_enable_int(adapter); 680 netxen_nic_enable_int(adapter);
641 }
642 681
643 /* Done here again so that even if phantom sw overwrote it, 682 /* Done here again so that even if phantom sw overwrote it,
644 * we set it */ 683 * we set it */
645 if (adapter->macaddr_set) 684 if (adapter->macaddr_set)
646 adapter->macaddr_set(port, netdev->dev_addr); 685 adapter->macaddr_set(adapter, netdev->dev_addr);
647 netxen_nic_set_link_parameters(port); 686 netxen_nic_set_link_parameters(adapter);
648 687
649 netxen_nic_set_multi(netdev); 688 netxen_nic_set_multi(netdev);
650 if (adapter->set_mtu) 689 if (adapter->set_mtu)
651 adapter->set_mtu(port, netdev->mtu); 690 adapter->set_mtu(adapter, netdev->mtu);
652 691
653 if (!adapter->driver_mismatch) 692 if (!adapter->driver_mismatch)
654 netif_start_queue(netdev); 693 netif_start_queue(netdev);
@@ -661,8 +700,7 @@ static int netxen_nic_open(struct net_device *netdev)
661 */ 700 */
662static int netxen_nic_close(struct net_device *netdev) 701static int netxen_nic_close(struct net_device *netdev)
663{ 702{
664 struct netxen_port *port = netdev_priv(netdev); 703 struct netxen_adapter *adapter = netdev_priv(netdev);
665 struct netxen_adapter *adapter = port->adapter;
666 int i, j; 704 int i, j;
667 struct netxen_cmd_buffer *cmd_buff; 705 struct netxen_cmd_buffer *cmd_buff;
668 struct netxen_skb_frag *buffrag; 706 struct netxen_skb_frag *buffrag;
@@ -670,47 +708,43 @@ static int netxen_nic_close(struct net_device *netdev)
670 netif_carrier_off(netdev); 708 netif_carrier_off(netdev);
671 netif_stop_queue(netdev); 709 netif_stop_queue(netdev);
672 710
673 adapter->active_ports--; 711 netxen_nic_disable_int(adapter);
674 712 if (adapter->irq)
675 if (!adapter->active_ports) { 713 free_irq(adapter->irq, adapter);
676 netxen_nic_disable_int(adapter); 714
677 cmd_buff = adapter->cmd_buf_arr; 715 cmd_buff = adapter->cmd_buf_arr;
678 for (i = 0; i < adapter->max_tx_desc_count; i++) { 716 for (i = 0; i < adapter->max_tx_desc_count; i++) {
679 buffrag = cmd_buff->frag_array; 717 buffrag = cmd_buff->frag_array;
718 if (buffrag->dma) {
719 pci_unmap_single(adapter->pdev, buffrag->dma,
720 buffrag->length, PCI_DMA_TODEVICE);
721 buffrag->dma = (u64) NULL;
722 }
723 for (j = 0; j < cmd_buff->frag_count; j++) {
724 buffrag++;
680 if (buffrag->dma) { 725 if (buffrag->dma) {
681 pci_unmap_single(port->pdev, buffrag->dma, 726 pci_unmap_page(adapter->pdev, buffrag->dma,
682 buffrag->length, 727 buffrag->length,
683 PCI_DMA_TODEVICE); 728 PCI_DMA_TODEVICE);
684 buffrag->dma = (u64) NULL; 729 buffrag->dma = (u64) NULL;
685 } 730 }
686 for (j = 0; j < cmd_buff->frag_count; j++) {
687 buffrag++;
688 if (buffrag->dma) {
689 pci_unmap_page(port->pdev,
690 buffrag->dma,
691 buffrag->length,
692 PCI_DMA_TODEVICE);
693 buffrag->dma = (u64) NULL;
694 }
695 }
696 /* Free the skb we received in netxen_nic_xmit_frame */
697 if (cmd_buff->skb) {
698 dev_kfree_skb_any(cmd_buff->skb);
699 cmd_buff->skb = NULL;
700 }
701 cmd_buff++;
702 } 731 }
703 FLUSH_SCHEDULED_WORK(); 732 /* Free the skb we received in netxen_nic_xmit_frame */
704 del_timer_sync(&adapter->watchdog_timer); 733 if (cmd_buff->skb) {
734 dev_kfree_skb_any(cmd_buff->skb);
735 cmd_buff->skb = NULL;
736 }
737 cmd_buff++;
705 } 738 }
739 FLUSH_SCHEDULED_WORK();
740 del_timer_sync(&adapter->watchdog_timer);
706 741
707 return 0; 742 return 0;
708} 743}
709 744
710static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev) 745static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
711{ 746{
712 struct netxen_port *port = netdev_priv(netdev); 747 struct netxen_adapter *adapter = netdev_priv(netdev);
713 struct netxen_adapter *adapter = port->adapter;
714 struct netxen_hardware_context *hw = &adapter->ahw; 748 struct netxen_hardware_context *hw = &adapter->ahw;
715 unsigned int first_seg_len = skb->len - skb->data_len; 749 unsigned int first_seg_len = skb->len - skb->data_len;
716 struct netxen_skb_frag *buffrag; 750 struct netxen_skb_frag *buffrag;
@@ -728,12 +762,12 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
728 u32 last_cmd_consumer = 0; 762 u32 last_cmd_consumer = 0;
729 int no_of_desc; 763 int no_of_desc;
730 764
731 port->stats.xmitcalled++; 765 adapter->stats.xmitcalled++;
732 frag_count = skb_shinfo(skb)->nr_frags + 1; 766 frag_count = skb_shinfo(skb)->nr_frags + 1;
733 767
734 if (unlikely(skb->len <= 0)) { 768 if (unlikely(skb->len <= 0)) {
735 dev_kfree_skb_any(skb); 769 dev_kfree_skb_any(skb);
736 port->stats.badskblen++; 770 adapter->stats.badskblen++;
737 return NETDEV_TX_OK; 771 return NETDEV_TX_OK;
738 } 772 }
739 773
@@ -742,7 +776,7 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
742 "too large, can handle only %d frags\n", 776 "too large, can handle only %d frags\n",
743 netxen_nic_driver_name, netdev->name, 777 netxen_nic_driver_name, netdev->name,
744 frag_count, MAX_BUFFERS_PER_CMD); 778 frag_count, MAX_BUFFERS_PER_CMD);
745 port->stats.txdropped++; 779 adapter->stats.txdropped++;
746 if ((++dropped_packet & 0xff) == 0xff) 780 if ((++dropped_packet & 0xff) == 0xff)
747 printk("%s: %s droppped packets = %d\n", 781 printk("%s: %s droppped packets = %d\n",
748 netxen_nic_driver_name, netdev->name, 782 netxen_nic_driver_name, netdev->name,
@@ -759,7 +793,7 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
759 */ 793 */
760 retry_getting_window: 794 retry_getting_window:
761 spin_lock_bh(&adapter->tx_lock); 795 spin_lock_bh(&adapter->tx_lock);
762 if (adapter->total_threads == MAX_XMIT_PRODUCERS) { 796 if (adapter->total_threads >= MAX_XMIT_PRODUCERS) {
763 spin_unlock_bh(&adapter->tx_lock); 797 spin_unlock_bh(&adapter->tx_lock);
764 /* 798 /*
765 * Yield CPU 799 * Yield CPU
@@ -792,15 +826,8 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
792 if ((k + no_of_desc) >= 826 if ((k + no_of_desc) >=
793 ((last_cmd_consumer <= k) ? last_cmd_consumer + max_tx_desc_count : 827 ((last_cmd_consumer <= k) ? last_cmd_consumer + max_tx_desc_count :
794 last_cmd_consumer)) { 828 last_cmd_consumer)) {
795 port->stats.nocmddescriptor++;
796 DPRINTK(ERR, "No command descriptors available,"
797 " producer = %d, consumer = %d count=%llu,"
798 " dropping packet\n", producer,
799 adapter->last_cmd_consumer,
800 port->stats.nocmddescriptor);
801
802 netif_stop_queue(netdev); 829 netif_stop_queue(netdev);
803 port->flags |= NETXEN_NETDEV_STATUS; 830 adapter->flags |= NETXEN_NETDEV_STATUS;
804 spin_unlock_bh(&adapter->tx_lock); 831 spin_unlock_bh(&adapter->tx_lock);
805 return NETDEV_TX_BUSY; 832 return NETDEV_TX_BUSY;
806 } 833 }
@@ -828,16 +855,16 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
828 pbuf->skb = skb; 855 pbuf->skb = skb;
829 pbuf->cmd = TX_ETHER_PKT; 856 pbuf->cmd = TX_ETHER_PKT;
830 pbuf->frag_count = frag_count; 857 pbuf->frag_count = frag_count;
831 pbuf->port = port->portnum; 858 pbuf->port = adapter->portnum;
832 buffrag = &pbuf->frag_array[0]; 859 buffrag = &pbuf->frag_array[0];
833 buffrag->dma = pci_map_single(port->pdev, skb->data, first_seg_len, 860 buffrag->dma = pci_map_single(adapter->pdev, skb->data, first_seg_len,
834 PCI_DMA_TODEVICE); 861 PCI_DMA_TODEVICE);
835 buffrag->length = first_seg_len; 862 buffrag->length = first_seg_len;
836 netxen_set_cmd_desc_totallength(hwdesc, skb->len); 863 netxen_set_cmd_desc_totallength(hwdesc, skb->len);
837 netxen_set_cmd_desc_num_of_buff(hwdesc, frag_count); 864 netxen_set_cmd_desc_num_of_buff(hwdesc, frag_count);
838 netxen_set_cmd_desc_opcode(hwdesc, TX_ETHER_PKT); 865 netxen_set_cmd_desc_opcode(hwdesc, TX_ETHER_PKT);
839 866
840 netxen_set_cmd_desc_port(hwdesc, port->portnum); 867 netxen_set_cmd_desc_port(hwdesc, adapter->portnum);
841 hwdesc->buffer1_length = cpu_to_le16(first_seg_len); 868 hwdesc->buffer1_length = cpu_to_le16(first_seg_len);
842 hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma); 869 hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
843 870
@@ -860,7 +887,7 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
860 offset = frag->page_offset; 887 offset = frag->page_offset;
861 888
862 temp_len = len; 889 temp_len = len;
863 temp_dma = pci_map_page(port->pdev, frag->page, offset, 890 temp_dma = pci_map_page(adapter->pdev, frag->page, offset,
864 len, PCI_DMA_TODEVICE); 891 len, PCI_DMA_TODEVICE);
865 892
866 buffrag++; 893 buffrag++;
@@ -928,20 +955,19 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
928 } 955 }
929 } 956 }
930 spin_lock_bh(&adapter->tx_lock); 957 spin_lock_bh(&adapter->tx_lock);
931 port->stats.txbytes += 958 adapter->stats.txbytes +=
932 netxen_get_cmd_desc_totallength(&hw->cmd_desc_head[saved_producer]); 959 netxen_get_cmd_desc_totallength(&hw->cmd_desc_head[saved_producer]);
933 /* Code to update the adapter considering how many producer threads 960 /* Code to update the adapter considering how many producer threads
934 are currently working */ 961 are currently working */
935 if ((--adapter->num_threads) == 0) { 962 if ((--adapter->num_threads) == 0) {
936 /* This is the last thread */ 963 /* This is the last thread */
937 u32 crb_producer = adapter->cmd_producer; 964 u32 crb_producer = adapter->cmd_producer;
938 writel(crb_producer, 965 netxen_nic_update_cmd_producer(adapter, crb_producer);
939 NETXEN_CRB_NORMALIZE(adapter, CRB_CMD_PRODUCER_OFFSET));
940 wmb(); 966 wmb();
941 adapter->total_threads = 0; 967 adapter->total_threads = 0;
942 } 968 }
943 969
944 port->stats.xmitfinished++; 970 adapter->stats.xmitfinished++;
945 spin_unlock_bh(&adapter->tx_lock); 971 spin_unlock_bh(&adapter->tx_lock);
946 972
947 netdev->trans_start = jiffies; 973 netdev->trans_start = jiffies;
@@ -961,25 +987,25 @@ static void netxen_watchdog(unsigned long v)
961 987
962static void netxen_tx_timeout(struct net_device *netdev) 988static void netxen_tx_timeout(struct net_device *netdev)
963{ 989{
964 struct netxen_port *port = (struct netxen_port *)netdev_priv(netdev); 990 struct netxen_adapter *adapter = (struct netxen_adapter *)
965 991 netdev_priv(netdev);
966 SCHEDULE_WORK(&port->tx_timeout_task); 992 SCHEDULE_WORK(&adapter->tx_timeout_task);
967} 993}
968 994
969static void netxen_tx_timeout_task(struct work_struct *work) 995static void netxen_tx_timeout_task(struct work_struct *work)
970{ 996{
971 struct netxen_port *port = 997 struct netxen_adapter *adapter =
972 container_of(work, struct netxen_port, tx_timeout_task); 998 container_of(work, struct netxen_adapter, tx_timeout_task);
973 struct net_device *netdev = port->netdev; 999 struct net_device *netdev = adapter->netdev;
974 unsigned long flags; 1000 unsigned long flags;
975 1001
976 printk(KERN_ERR "%s %s: transmit timeout, resetting.\n", 1002 printk(KERN_ERR "%s %s: transmit timeout, resetting.\n",
977 netxen_nic_driver_name, netdev->name); 1003 netxen_nic_driver_name, netdev->name);
978 1004
979 spin_lock_irqsave(&port->adapter->lock, flags); 1005 spin_lock_irqsave(&adapter->lock, flags);
980 netxen_nic_close(netdev); 1006 netxen_nic_close(netdev);
981 netxen_nic_open(netdev); 1007 netxen_nic_open(netdev);
982 spin_unlock_irqrestore(&port->adapter->lock, flags); 1008 spin_unlock_irqrestore(&adapter->lock, flags);
983 netdev->trans_start = jiffies; 1009 netdev->trans_start = jiffies;
984 netif_wake_queue(netdev); 1010 netif_wake_queue(netdev);
985} 1011}
@@ -991,16 +1017,14 @@ netxen_handle_int(struct netxen_adapter *adapter, struct net_device *netdev)
991 1017
992 DPRINTK(INFO, "Entered handle ISR\n"); 1018 DPRINTK(INFO, "Entered handle ISR\n");
993 1019
994 adapter->stats.ints++;
995
996 if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) { 1020 if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) {
997 int count = 0; 1021 int count = 0;
998 u32 mask; 1022 u32 mask;
999 mask = readl(pci_base_offset(adapter, ISR_INT_VECTOR)); 1023 u32 our_int = 0;
1000 if ((mask & 0x80) == 0) { 1024 our_int = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_INT_VECTOR));
1001 /* not our interrupt */ 1025 /* not our interrupt */
1026 if ((our_int & (0x80 << adapter->portnum)) == 0)
1002 return ret; 1027 return ret;
1003 }
1004 netxen_nic_disable_int(adapter); 1028 netxen_nic_disable_int(adapter);
1005 /* Window = 0 or 1 */ 1029 /* Window = 0 or 1 */
1006 do { 1030 do {
@@ -1012,7 +1036,6 @@ netxen_handle_int(struct netxen_adapter *adapter, struct net_device *netdev)
1012 printk("Could not disable interrupt completely\n"); 1036 printk("Could not disable interrupt completely\n");
1013 1037
1014 } 1038 }
1015 adapter->stats.hostints++;
1016 1039
1017 if (netxen_nic_rx_has_work(adapter) || netxen_nic_tx_has_work(adapter)) { 1040 if (netxen_nic_rx_has_work(adapter) || netxen_nic_tx_has_work(adapter)) {
1018 if (netif_rx_schedule_prep(netdev)) { 1041 if (netif_rx_schedule_prep(netdev)) {
@@ -1046,33 +1069,24 @@ netxen_handle_int(struct netxen_adapter *adapter, struct net_device *netdev)
1046irqreturn_t netxen_intr(int irq, void *data) 1069irqreturn_t netxen_intr(int irq, void *data)
1047{ 1070{
1048 struct netxen_adapter *adapter; 1071 struct netxen_adapter *adapter;
1049 struct netxen_port *port;
1050 struct net_device *netdev; 1072 struct net_device *netdev;
1051 int i;
1052 1073
1053 if (unlikely(!irq)) { 1074 if (unlikely(!irq)) {
1054 return IRQ_NONE; /* Not our interrupt */ 1075 return IRQ_NONE; /* Not our interrupt */
1055 } 1076 }
1056 1077
1057 adapter = (struct netxen_adapter *)data; 1078 adapter = (struct netxen_adapter *)data;
1058 for (i = 0; i < adapter->ahw.max_ports; i++) { 1079 netdev = adapter->netdev;
1059 port = adapter->port[i]; 1080 /* process our status queue (for all 4 ports) */
1060 netdev = port->netdev; 1081 if (netif_running(netdev))
1061 1082 netxen_handle_int(adapter, netdev);
1062 /* process our status queue (for all 4 ports) */
1063 if (netif_running(netdev)) {
1064 netxen_handle_int(adapter, netdev);
1065 break;
1066 }
1067 }
1068 1083
1069 return IRQ_HANDLED; 1084 return IRQ_HANDLED;
1070} 1085}
1071 1086
1072static int netxen_nic_poll(struct net_device *netdev, int *budget) 1087static int netxen_nic_poll(struct net_device *netdev, int *budget)
1073{ 1088{
1074 struct netxen_port *port = (struct netxen_port *)netdev_priv(netdev); 1089 struct netxen_adapter *adapter = netdev_priv(netdev);
1075 struct netxen_adapter *adapter = port->adapter;
1076 int work_to_do = min(*budget, netdev->quota); 1090 int work_to_do = min(*budget, netdev->quota);
1077 int done = 1; 1091 int done = 1;
1078 int ctx; 1092 int ctx;
@@ -1080,7 +1094,6 @@ static int netxen_nic_poll(struct net_device *netdev, int *budget)
1080 int work_done = 0; 1094 int work_done = 0;
1081 1095
1082 DPRINTK(INFO, "polling for %d descriptors\n", *budget); 1096 DPRINTK(INFO, "polling for %d descriptors\n", *budget);
1083 port->stats.polled++;
1084 1097
1085 work_done = 0; 1098 work_done = 0;
1086 for (ctx = 0; ctx < MAX_RCV_CTX; ++ctx) { 1099 for (ctx = 0; ctx < MAX_RCV_CTX; ++ctx) {
@@ -1124,8 +1137,7 @@ static int netxen_nic_poll(struct net_device *netdev, int *budget)
1124#ifdef CONFIG_NET_POLL_CONTROLLER 1137#ifdef CONFIG_NET_POLL_CONTROLLER
1125static void netxen_nic_poll_controller(struct net_device *netdev) 1138static void netxen_nic_poll_controller(struct net_device *netdev)
1126{ 1139{
1127 struct netxen_port *port = netdev_priv(netdev); 1140 struct netxen_adapter *adapter = netdev_priv(netdev);
1128 struct netxen_adapter *adapter = port->adapter;
1129 disable_irq(adapter->irq); 1141 disable_irq(adapter->irq);
1130 netxen_intr(adapter->irq, adapter); 1142 netxen_intr(adapter->irq, adapter);
1131 enable_irq(adapter->irq); 1143 enable_irq(adapter->irq);
diff --git a/drivers/net/netxen/netxen_nic_niu.c b/drivers/net/netxen/netxen_nic_niu.c
index d5d95074e569..f6befc32aa58 100644
--- a/drivers/net/netxen/netxen_nic_niu.c
+++ b/drivers/net/netxen/netxen_nic_niu.c
@@ -610,13 +610,12 @@ int netxen_niu_macaddr_get(struct netxen_adapter *adapter,
610 * Set the station MAC address. 610 * Set the station MAC address.
611 * Note that the passed-in value must already be in network byte order. 611 * Note that the passed-in value must already be in network byte order.
612 */ 612 */
613int netxen_niu_macaddr_set(struct netxen_port *port, 613int netxen_niu_macaddr_set(struct netxen_adapter *adapter,
614 netxen_ethernet_macaddr_t addr) 614 netxen_ethernet_macaddr_t addr)
615{ 615{
616 u8 temp[4]; 616 u8 temp[4];
617 u32 val; 617 u32 val;
618 struct netxen_adapter *adapter = port->adapter; 618 int phy = adapter->portnum;
619 int phy = port->portnum;
620 unsigned char mac_addr[6]; 619 unsigned char mac_addr[6];
621 int i; 620 int i;
622 621
@@ -642,7 +641,7 @@ int netxen_niu_macaddr_set(struct netxen_port *port,
642 641
643 if (i == 10) { 642 if (i == 10) {
644 printk(KERN_ERR "%s: cannot set Mac addr for %s\n", 643 printk(KERN_ERR "%s: cannot set Mac addr for %s\n",
645 netxen_nic_driver_name, port->netdev->name); 644 netxen_nic_driver_name, adapter->netdev->name);
646 printk(KERN_ERR "MAC address set: " 645 printk(KERN_ERR "MAC address set: "
647 "%02x:%02x:%02x:%02x:%02x:%02x.\n", 646 "%02x:%02x:%02x:%02x:%02x:%02x.\n",
648 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]); 647 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
@@ -735,12 +734,10 @@ int netxen_niu_enable_gbe_port(struct netxen_adapter *adapter,
735} 734}
736 735
737/* Disable a GbE interface */ 736/* Disable a GbE interface */
738int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter, int port) 737int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter)
739{ 738{
740 __u32 mac_cfg0; 739 __u32 mac_cfg0;
741 740 int port = adapter->portnum;
742 if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
743 return -EINVAL;
744 741
745 mac_cfg0 = 0; 742 mac_cfg0 = 0;
746 netxen_gb_soft_reset(mac_cfg0); 743 netxen_gb_soft_reset(mac_cfg0);
@@ -751,13 +748,10 @@ int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter, int port)
751} 748}
752 749
753/* Disable an XG interface */ 750/* Disable an XG interface */
754int netxen_niu_disable_xg_port(struct netxen_adapter *adapter, int port) 751int netxen_niu_disable_xg_port(struct netxen_adapter *adapter)
755{ 752{
756 __u32 mac_cfg; 753 __u32 mac_cfg;
757 754
758 if (port != 0)
759 return -EINVAL;
760
761 mac_cfg = 0; 755 mac_cfg = 0;
762 netxen_xg_soft_reset(mac_cfg); 756 netxen_xg_soft_reset(mac_cfg);
763 if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XGE_CONFIG_0, 757 if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XGE_CONFIG_0,
@@ -767,10 +761,11 @@ int netxen_niu_disable_xg_port(struct netxen_adapter *adapter, int port)
767} 761}
768 762
769/* Set promiscuous mode for a GbE interface */ 763/* Set promiscuous mode for a GbE interface */
770int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter, int port, 764int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter,
771 netxen_niu_prom_mode_t mode) 765 netxen_niu_prom_mode_t mode)
772{ 766{
773 __u32 reg; 767 __u32 reg;
768 int port = adapter->portnum;
774 769
775 if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS)) 770 if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
776 return -EINVAL; 771 return -EINVAL;
@@ -824,12 +819,11 @@ int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter, int port,
824 * Set the MAC address for an XG port 819 * Set the MAC address for an XG port
825 * Note that the passed-in value must already be in network byte order. 820 * Note that the passed-in value must already be in network byte order.
826 */ 821 */
827int netxen_niu_xg_macaddr_set(struct netxen_port *port, 822int netxen_niu_xg_macaddr_set(struct netxen_adapter *adapter,
828 netxen_ethernet_macaddr_t addr) 823 netxen_ethernet_macaddr_t addr)
829{ 824{
830 u8 temp[4]; 825 u8 temp[4];
831 u32 val; 826 u32 val;
832 struct netxen_adapter *adapter = port->adapter;
833 827
834 temp[0] = temp[1] = 0; 828 temp[0] = temp[1] = 0;
835 memcpy(temp + 2, addr, 2); 829 memcpy(temp + 2, addr, 2);
@@ -878,9 +872,10 @@ int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter, int phy,
878} 872}
879 873
880int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter, 874int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter,
881 int port, netxen_niu_prom_mode_t mode) 875 netxen_niu_prom_mode_t mode)
882{ 876{
883 __u32 reg; 877 __u32 reg;
878 int port = adapter->portnum;
884 879
885 if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS)) 880 if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
886 return -EINVAL; 881 return -EINVAL;
diff --git a/drivers/net/netxen/netxen_nic_phan_reg.h b/drivers/net/netxen/netxen_nic_phan_reg.h
index 0c7c94328b7f..f7eb627f81c2 100644
--- a/drivers/net/netxen/netxen_nic_phan_reg.h
+++ b/drivers/net/netxen/netxen_nic_phan_reg.h
@@ -100,6 +100,14 @@
100 100
101#define CRB_CMD_PRODUCER_OFFSET_1 NETXEN_NIC_REG(0x1ac) 101#define CRB_CMD_PRODUCER_OFFSET_1 NETXEN_NIC_REG(0x1ac)
102#define CRB_CMD_CONSUMER_OFFSET_1 NETXEN_NIC_REG(0x1b0) 102#define CRB_CMD_CONSUMER_OFFSET_1 NETXEN_NIC_REG(0x1b0)
103#define CRB_CMD_PRODUCER_OFFSET_1 NETXEN_NIC_REG(0x1ac)
104#define CRB_CMD_CONSUMER_OFFSET_1 NETXEN_NIC_REG(0x1b0)
105#define CRB_CMD_PRODUCER_OFFSET_2 NETXEN_NIC_REG(0x1b8)
106#define CRB_CMD_CONSUMER_OFFSET_2 NETXEN_NIC_REG(0x1bc)
107
108// 1c0 to 1cc used for signature reg
109#define CRB_CMD_PRODUCER_OFFSET_3 NETXEN_NIC_REG(0x1d0)
110#define CRB_CMD_CONSUMER_OFFSET_3 NETXEN_NIC_REG(0x1d4)
103#define CRB_TEMP_STATE NETXEN_NIC_REG(0x1b4) 111#define CRB_TEMP_STATE NETXEN_NIC_REG(0x1b4)
104 112
105/* used for ethtool tests */ 113/* used for ethtool tests */
@@ -139,128 +147,13 @@ struct netxen_recv_crb {
139}; 147};
140 148
141#if defined(DEFINE_GLOBAL_RECV_CRB) 149#if defined(DEFINE_GLOBAL_RECV_CRB)
142struct netxen_recv_crb recv_crb_registers[] = {
143 /*
144 * Instance 0.
145 */
146 {
147 /* rcv_desc_crb: */
148 {
149 {
150 /* crb_rcv_producer_offset: */
151 NETXEN_NIC_REG(0x100),
152 /* crb_rcv_consumer_offset: */
153 NETXEN_NIC_REG(0x104),
154 /* crb_gloablrcv_ring: */
155 NETXEN_NIC_REG(0x108),
156 /* crb_rcv_ring_size */
157 NETXEN_NIC_REG(0x10c),
158
159 },
160 /* Jumbo frames */
161 {
162 /* crb_rcv_producer_offset: */
163 NETXEN_NIC_REG(0x110),
164 /* crb_rcv_consumer_offset: */
165 NETXEN_NIC_REG(0x114),
166 /* crb_gloablrcv_ring: */
167 NETXEN_NIC_REG(0x118),
168 /* crb_rcv_ring_size */
169 NETXEN_NIC_REG(0x11c),
170 },
171 /* LRO */
172 {
173 /* crb_rcv_producer_offset: */
174 NETXEN_NIC_REG(0x120),
175 /* crb_rcv_consumer_offset: */
176 NETXEN_NIC_REG(0x124),
177 /* crb_gloablrcv_ring: */
178 NETXEN_NIC_REG(0x128),
179 /* crb_rcv_ring_size */
180 NETXEN_NIC_REG(0x12c),
181 }
182 },
183 /* crb_rcvstatus_ring: */
184 NETXEN_NIC_REG(0x130),
185 /* crb_rcv_status_producer: */
186 NETXEN_NIC_REG(0x134),
187 /* crb_rcv_status_consumer: */
188 NETXEN_NIC_REG(0x138),
189 /* crb_rcvpeg_state: */
190 NETXEN_NIC_REG(0x13c),
191 /* crb_status_ring_size */
192 NETXEN_NIC_REG(0x140),
193
194 },
195 /*
196 * Instance 1,
197 */
198 {
199 /* rcv_desc_crb: */
200 {
201 {
202 /* crb_rcv_producer_offset: */
203 NETXEN_NIC_REG(0x144),
204 /* crb_rcv_consumer_offset: */
205 NETXEN_NIC_REG(0x148),
206 /* crb_globalrcv_ring: */
207 NETXEN_NIC_REG(0x14c),
208 /* crb_rcv_ring_size */
209 NETXEN_NIC_REG(0x150),
210
211 },
212 /* Jumbo frames */
213 {
214 /* crb_rcv_producer_offset: */
215 NETXEN_NIC_REG(0x154),
216 /* crb_rcv_consumer_offset: */
217 NETXEN_NIC_REG(0x158),
218 /* crb_globalrcv_ring: */
219 NETXEN_NIC_REG(0x15c),
220 /* crb_rcv_ring_size */
221 NETXEN_NIC_REG(0x160),
222 },
223 /* LRO */
224 {
225 /* crb_rcv_producer_offset: */
226 NETXEN_NIC_REG(0x164),
227 /* crb_rcv_consumer_offset: */
228 NETXEN_NIC_REG(0x168),
229 /* crb_globalrcv_ring: */
230 NETXEN_NIC_REG(0x16c),
231 /* crb_rcv_ring_size */
232 NETXEN_NIC_REG(0x170),
233 }
234
235 },
236 /* crb_rcvstatus_ring: */
237 NETXEN_NIC_REG(0x174),
238 /* crb_rcv_status_producer: */
239 NETXEN_NIC_REG(0x178),
240 /* crb_rcv_status_consumer: */
241 NETXEN_NIC_REG(0x17c),
242 /* crb_rcvpeg_state: */
243 NETXEN_NIC_REG(0x180),
244 /* crb_status_ring_size */
245 NETXEN_NIC_REG(0x184),
246
247 },
248};
249
250u64 ctx_addr_sig_regs[][3] = {
251 {NETXEN_NIC_REG(0x188), NETXEN_NIC_REG(0x18c), NETXEN_NIC_REG(0x1c0)},
252 {NETXEN_NIC_REG(0x190), NETXEN_NIC_REG(0x194), NETXEN_NIC_REG(0x1c4)},
253 {NETXEN_NIC_REG(0x198), NETXEN_NIC_REG(0x19c), NETXEN_NIC_REG(0x1c8)},
254 {NETXEN_NIC_REG(0x1a0), NETXEN_NIC_REG(0x1a4), NETXEN_NIC_REG(0x1cc)}
255};
256
257#else 150#else
258extern struct netxen_recv_crb recv_crb_registers[]; 151extern struct netxen_recv_crb recv_crb_registers[];
259extern u64 ctx_addr_sig_regs[][3]; 152extern u64 ctx_addr_sig_regs[][3];
153#endif /* DEFINE_GLOBAL_RECEIVE_CRB */
260#define CRB_CTX_ADDR_REG_LO (ctx_addr_sig_regs[0][0]) 154#define CRB_CTX_ADDR_REG_LO (ctx_addr_sig_regs[0][0])
261#define CRB_CTX_ADDR_REG_HI (ctx_addr_sig_regs[0][2]) 155#define CRB_CTX_ADDR_REG_HI (ctx_addr_sig_regs[0][2])
262#define CRB_CTX_SIGNATURE_REG (ctx_addr_sig_regs[0][1]) 156#define CRB_CTX_SIGNATURE_REG (ctx_addr_sig_regs[0][1])
263#endif /* DEFINE_GLOBAL_RECEIVE_CRB */
264 157
265/* 158/*
266 * Temperature control. 159 * Temperature control.
generated by cgit v1.2.2 (git 2.25.0) at 2024-09-22 19:29:52 -0400