aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net')
-rw-r--r--drivers/net/benet/be.h4
-rw-r--r--drivers/net/benet/be_cmds.c30
-rw-r--r--drivers/net/benet/be_cmds.h20
-rw-r--r--drivers/net/benet/be_ethtool.c15
-rw-r--r--drivers/net/benet/be_hw.h85
-rw-r--r--drivers/net/benet/be_main.c229
-rw-r--r--drivers/net/hydra.c4
-rw-r--r--drivers/net/netxen/netxen_nic.h97
-rw-r--r--drivers/net/netxen/netxen_nic_ctx.c29
-rw-r--r--drivers/net/netxen/netxen_nic_ethtool.c5
-rw-r--r--drivers/net/netxen/netxen_nic_hdr.h23
-rw-r--r--drivers/net/netxen/netxen_nic_hw.c238
-rw-r--r--drivers/net/netxen/netxen_nic_init.c35
-rw-r--r--drivers/net/netxen/netxen_nic_main.c698
-rw-r--r--drivers/net/niu.c23
-rw-r--r--drivers/net/r8169.c1
-rw-r--r--drivers/net/wan/dlci.c43
-rw-r--r--drivers/net/wan/ixp4xx_hss.c95
-rw-r--r--drivers/net/wan/pci200syn.c11
-rw-r--r--drivers/net/wan/sdla.c8
20 files changed, 1176 insertions, 517 deletions
diff --git a/drivers/net/benet/be.h b/drivers/net/benet/be.h
index 6c45a2233d0d..13b72ce870de 100644
--- a/drivers/net/benet/be.h
+++ b/drivers/net/benet/be.h
@@ -28,10 +28,11 @@
28#include <linux/if_vlan.h> 28#include <linux/if_vlan.h>
29#include <linux/workqueue.h> 29#include <linux/workqueue.h>
30#include <linux/interrupt.h> 30#include <linux/interrupt.h>
31#include <linux/firmware.h>
31 32
32#include "be_hw.h" 33#include "be_hw.h"
33 34
34#define DRV_VER "2.0.400" 35#define DRV_VER "2.101.205"
35#define DRV_NAME "be2net" 36#define DRV_NAME "be2net"
36#define BE_NAME "ServerEngines BladeEngine2 10Gbps NIC" 37#define BE_NAME "ServerEngines BladeEngine2 10Gbps NIC"
37#define OC_NAME "Emulex OneConnect 10Gbps NIC" 38#define OC_NAME "Emulex OneConnect 10Gbps NIC"
@@ -361,4 +362,5 @@ static inline u8 is_udp_pkt(struct sk_buff *skb)
361extern void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, 362extern void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm,
362 u16 num_popped); 363 u16 num_popped);
363extern void be_link_status_update(struct be_adapter *adapter, bool link_up); 364extern void be_link_status_update(struct be_adapter *adapter, bool link_up);
365extern int be_load_fw(struct be_adapter *adapter, u8 *func);
364#endif /* BE_H */ 366#endif /* BE_H */
diff --git a/drivers/net/benet/be_cmds.c b/drivers/net/benet/be_cmds.c
index 2547ee296a7d..1db092498309 100644
--- a/drivers/net/benet/be_cmds.c
+++ b/drivers/net/benet/be_cmds.c
@@ -155,7 +155,7 @@ static int be_mbox_db_ready_wait(struct be_adapter *adapter, void __iomem *db)
155 if (ready) 155 if (ready)
156 break; 156 break;
157 157
158 if (cnt > 200000) { 158 if (cnt > 4000000) {
159 dev_err(&adapter->pdev->dev, "mbox poll timed out\n"); 159 dev_err(&adapter->pdev->dev, "mbox poll timed out\n");
160 return -1; 160 return -1;
161 } 161 }
@@ -1040,3 +1040,31 @@ int be_cmd_reset_function(struct be_adapter *adapter)
1040 spin_unlock(&adapter->mbox_lock); 1040 spin_unlock(&adapter->mbox_lock);
1041 return status; 1041 return status;
1042} 1042}
1043
1044int be_cmd_write_flashrom(struct be_adapter *adapter, struct be_dma_mem *cmd,
1045 u32 flash_type, u32 flash_opcode, u32 buf_size)
1046{
1047 struct be_mcc_wrb *wrb = wrb_from_mbox(&adapter->mbox_mem);
1048 struct be_cmd_write_flashrom *req = cmd->va;
1049 struct be_sge *sge = nonembedded_sgl(wrb);
1050 int status;
1051
1052 spin_lock(&adapter->mbox_lock);
1053 memset(wrb, 0, sizeof(*wrb));
1054 be_wrb_hdr_prepare(wrb, cmd->size, false, 1);
1055
1056 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
1057 OPCODE_COMMON_WRITE_FLASHROM, cmd->size);
1058 sge->pa_hi = cpu_to_le32(upper_32_bits(cmd->dma));
1059 sge->pa_lo = cpu_to_le32(cmd->dma & 0xFFFFFFFF);
1060 sge->len = cpu_to_le32(cmd->size);
1061
1062 req->params.op_type = cpu_to_le32(flash_type);
1063 req->params.op_code = cpu_to_le32(flash_opcode);
1064 req->params.data_buf_size = cpu_to_le32(buf_size);
1065
1066 status = be_mbox_notify(adapter);
1067
1068 spin_unlock(&adapter->mbox_lock);
1069 return status;
1070}
diff --git a/drivers/net/benet/be_cmds.h b/drivers/net/benet/be_cmds.h
index 70618064ae15..fd7028e5b78e 100644
--- a/drivers/net/benet/be_cmds.h
+++ b/drivers/net/benet/be_cmds.h
@@ -117,6 +117,7 @@ struct be_mcc_mailbox {
117#define OPCODE_COMMON_NTWK_MULTICAST_SET 3 117#define OPCODE_COMMON_NTWK_MULTICAST_SET 3
118#define OPCODE_COMMON_NTWK_VLAN_CONFIG 4 118#define OPCODE_COMMON_NTWK_VLAN_CONFIG 4
119#define OPCODE_COMMON_NTWK_LINK_STATUS_QUERY 5 119#define OPCODE_COMMON_NTWK_LINK_STATUS_QUERY 5
120#define OPCODE_COMMON_WRITE_FLASHROM 7
120#define OPCODE_COMMON_CQ_CREATE 12 121#define OPCODE_COMMON_CQ_CREATE 12
121#define OPCODE_COMMON_EQ_CREATE 13 122#define OPCODE_COMMON_EQ_CREATE 13
122#define OPCODE_COMMON_MCC_CREATE 21 123#define OPCODE_COMMON_MCC_CREATE 21
@@ -693,10 +694,24 @@ struct be_cmd_resp_query_fw_cfg {
693 u32 be_config_number; 694 u32 be_config_number;
694 u32 asic_revision; 695 u32 asic_revision;
695 u32 phys_port; 696 u32 phys_port;
696 u32 function_mode; 697 u32 function_cap;
697 u32 rsvd[26]; 698 u32 rsvd[26];
698}; 699};
699 700
701/****************** Firmware Flash ******************/
702struct flashrom_params {
703 u32 op_code;
704 u32 op_type;
705 u32 data_buf_size;
706 u32 offset;
707 u8 data_buf[4];
708};
709
710struct be_cmd_write_flashrom {
711 struct be_cmd_req_hdr hdr;
712 struct flashrom_params params;
713};
714
700extern int be_pci_fnum_get(struct be_adapter *adapter); 715extern int be_pci_fnum_get(struct be_adapter *adapter);
701extern int be_cmd_POST(struct be_adapter *adapter); 716extern int be_cmd_POST(struct be_adapter *adapter);
702extern int be_cmd_mac_addr_query(struct be_adapter *adapter, u8 *mac_addr, 717extern int be_cmd_mac_addr_query(struct be_adapter *adapter, u8 *mac_addr,
@@ -747,3 +762,6 @@ extern int be_cmd_get_flow_control(struct be_adapter *adapter,
747extern int be_cmd_query_fw_cfg(struct be_adapter *adapter, u32 *port_num); 762extern int be_cmd_query_fw_cfg(struct be_adapter *adapter, u32 *port_num);
748extern int be_cmd_reset_function(struct be_adapter *adapter); 763extern int be_cmd_reset_function(struct be_adapter *adapter);
749extern void be_process_mcc(struct be_adapter *adapter); 764extern void be_process_mcc(struct be_adapter *adapter);
765extern int be_cmd_write_flashrom(struct be_adapter *adapter,
766 struct be_dma_mem *cmd, u32 flash_oper,
767 u32 flash_opcode, u32 buf_size);
diff --git a/drivers/net/benet/be_ethtool.c b/drivers/net/benet/be_ethtool.c
index 4ff3cc465406..11445df3dbc0 100644
--- a/drivers/net/benet/be_ethtool.c
+++ b/drivers/net/benet/be_ethtool.c
@@ -332,6 +332,20 @@ be_set_pauseparam(struct net_device *netdev, struct ethtool_pauseparam *ecmd)
332 return status; 332 return status;
333} 333}
334 334
335static int
336be_do_flash(struct net_device *netdev, struct ethtool_flash *efl)
337{
338 struct be_adapter *adapter = netdev_priv(netdev);
339 char file_name[ETHTOOL_FLASH_MAX_FILENAME];
340 u32 region;
341
342 file_name[ETHTOOL_FLASH_MAX_FILENAME - 1] = 0;
343 strcpy(file_name, efl->data);
344 region = efl->region;
345
346 return be_load_fw(adapter, file_name);
347}
348
335const struct ethtool_ops be_ethtool_ops = { 349const struct ethtool_ops be_ethtool_ops = {
336 .get_settings = be_get_settings, 350 .get_settings = be_get_settings,
337 .get_drvinfo = be_get_drvinfo, 351 .get_drvinfo = be_get_drvinfo,
@@ -352,4 +366,5 @@ const struct ethtool_ops be_ethtool_ops = {
352 .get_strings = be_get_stat_strings, 366 .get_strings = be_get_stat_strings,
353 .get_stats_count = be_get_stats_count, 367 .get_stats_count = be_get_stats_count,
354 .get_ethtool_stats = be_get_ethtool_stats, 368 .get_ethtool_stats = be_get_ethtool_stats,
369 .flash_device = be_do_flash,
355}; 370};
diff --git a/drivers/net/benet/be_hw.h b/drivers/net/benet/be_hw.h
index d28f0c679bc8..a3394b4aa14a 100644
--- a/drivers/net/benet/be_hw.h
+++ b/drivers/net/benet/be_hw.h
@@ -204,7 +204,7 @@ struct amap_eth_rx_compl {
204 u8 numfrags[3]; /* dword 1 */ 204 u8 numfrags[3]; /* dword 1 */
205 u8 rss_flush; /* dword 2 */ 205 u8 rss_flush; /* dword 2 */
206 u8 cast_enc[2]; /* dword 2 */ 206 u8 cast_enc[2]; /* dword 2 */
207 u8 qnq; /* dword 2 */ 207 u8 vtm; /* dword 2 */
208 u8 rss_bank; /* dword 2 */ 208 u8 rss_bank; /* dword 2 */
209 u8 rsvd1[23]; /* dword 2 */ 209 u8 rsvd1[23]; /* dword 2 */
210 u8 lro_pkt; /* dword 2 */ 210 u8 lro_pkt; /* dword 2 */
@@ -216,3 +216,86 @@ struct amap_eth_rx_compl {
216struct be_eth_rx_compl { 216struct be_eth_rx_compl {
217 u32 dw[4]; 217 u32 dw[4];
218}; 218};
219
220/* Flashrom related descriptors */
221#define IMAGE_TYPE_FIRMWARE 160
222#define IMAGE_TYPE_BOOTCODE 224
223#define IMAGE_TYPE_OPTIONROM 32
224
225#define NUM_FLASHDIR_ENTRIES 32
226
227#define FLASHROM_TYPE_ISCSI_ACTIVE 0
228#define FLASHROM_TYPE_BIOS 2
229#define FLASHROM_TYPE_PXE_BIOS 3
230#define FLASHROM_TYPE_FCOE_BIOS 8
231#define FLASHROM_TYPE_ISCSI_BACKUP 9
232#define FLASHROM_TYPE_FCOE_FW_ACTIVE 10
233#define FLASHROM_TYPE_FCOE_FW_BACKUP 11
234
235#define FLASHROM_OPER_FLASH 1
236#define FLASHROM_OPER_SAVE 2
237
238#define FLASH_IMAGE_MAX_SIZE (1310720) /* Max firmware image size */
239#define FLASH_BIOS_IMAGE_MAX_SIZE (262144) /* Max OPTION ROM image sz */
240
241/* Offsets for components on Flash. */
242#define FLASH_iSCSI_PRIMARY_IMAGE_START (1048576)
243#define FLASH_iSCSI_BACKUP_IMAGE_START (2359296)
244#define FLASH_FCoE_PRIMARY_IMAGE_START (3670016)
245#define FLASH_FCoE_BACKUP_IMAGE_START (4980736)
246#define FLASH_iSCSI_BIOS_START (7340032)
247#define FLASH_PXE_BIOS_START (7864320)
248#define FLASH_FCoE_BIOS_START (524288)
249
250struct controller_id {
251 u32 vendor;
252 u32 device;
253 u32 subvendor;
254 u32 subdevice;
255};
256
257struct flash_file_hdr {
258 u8 sign[32];
259 u32 cksum;
260 u32 antidote;
261 struct controller_id cont_id;
262 u32 file_len;
263 u32 chunk_num;
264 u32 total_chunks;
265 u32 num_imgs;
266 u8 build[24];
267};
268
269struct flash_section_hdr {
270 u32 format_rev;
271 u32 cksum;
272 u32 antidote;
273 u32 build_no;
274 u8 id_string[64];
275 u32 active_entry_mask;
276 u32 valid_entry_mask;
277 u32 org_content_mask;
278 u32 rsvd0;
279 u32 rsvd1;
280 u32 rsvd2;
281 u32 rsvd3;
282 u32 rsvd4;
283};
284
285struct flash_section_entry {
286 u32 type;
287 u32 offset;
288 u32 pad_size;
289 u32 image_size;
290 u32 cksum;
291 u32 entry_point;
292 u32 rsvd0;
293 u32 rsvd1;
294 u8 ver_data[32];
295};
296
297struct flash_section_info {
298 u8 cookie[32];
299 struct flash_section_hdr fsec_hdr;
300 struct flash_section_entry fsec_entry[32];
301};
diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c
index bac85f950394..ce11bba2cb67 100644
--- a/drivers/net/benet/be_main.c
+++ b/drivers/net/benet/be_main.c
@@ -385,15 +385,19 @@ static int make_tx_wrbs(struct be_adapter *adapter,
385 struct be_eth_wrb *wrb; 385 struct be_eth_wrb *wrb;
386 struct be_eth_hdr_wrb *hdr; 386 struct be_eth_hdr_wrb *hdr;
387 387
388 atomic_add(wrb_cnt, &txq->used);
389 hdr = queue_head_node(txq); 388 hdr = queue_head_node(txq);
389 atomic_add(wrb_cnt, &txq->used);
390 queue_head_inc(txq); 390 queue_head_inc(txq);
391 391
392 if (skb_dma_map(&pdev->dev, skb, DMA_TO_DEVICE)) {
393 dev_err(&pdev->dev, "TX DMA mapping failed\n");
394 return 0;
395 }
396
392 if (skb->len > skb->data_len) { 397 if (skb->len > skb->data_len) {
393 int len = skb->len - skb->data_len; 398 int len = skb->len - skb->data_len;
394 busaddr = pci_map_single(pdev, skb->data, len,
395 PCI_DMA_TODEVICE);
396 wrb = queue_head_node(txq); 399 wrb = queue_head_node(txq);
400 busaddr = skb_shinfo(skb)->dma_head;
397 wrb_fill(wrb, busaddr, len); 401 wrb_fill(wrb, busaddr, len);
398 be_dws_cpu_to_le(wrb, sizeof(*wrb)); 402 be_dws_cpu_to_le(wrb, sizeof(*wrb));
399 queue_head_inc(txq); 403 queue_head_inc(txq);
@@ -403,9 +407,8 @@ static int make_tx_wrbs(struct be_adapter *adapter,
403 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 407 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
404 struct skb_frag_struct *frag = 408 struct skb_frag_struct *frag =
405 &skb_shinfo(skb)->frags[i]; 409 &skb_shinfo(skb)->frags[i];
406 busaddr = pci_map_page(pdev, frag->page, 410
407 frag->page_offset, 411 busaddr = skb_shinfo(skb)->dma_maps[i];
408 frag->size, PCI_DMA_TODEVICE);
409 wrb = queue_head_node(txq); 412 wrb = queue_head_node(txq);
410 wrb_fill(wrb, busaddr, frag->size); 413 wrb_fill(wrb, busaddr, frag->size);
411 be_dws_cpu_to_le(wrb, sizeof(*wrb)); 414 be_dws_cpu_to_le(wrb, sizeof(*wrb));
@@ -429,6 +432,7 @@ static int make_tx_wrbs(struct be_adapter *adapter,
429 432
430static netdev_tx_t be_xmit(struct sk_buff *skb, 433static netdev_tx_t be_xmit(struct sk_buff *skb,
431 struct net_device *netdev) 434 struct net_device *netdev)
435
432{ 436{
433 struct be_adapter *adapter = netdev_priv(netdev); 437 struct be_adapter *adapter = netdev_priv(netdev);
434 struct be_tx_obj *tx_obj = &adapter->tx_obj; 438 struct be_tx_obj *tx_obj = &adapter->tx_obj;
@@ -440,23 +444,28 @@ static netdev_tx_t be_xmit(struct sk_buff *skb,
440 wrb_cnt = wrb_cnt_for_skb(skb, &dummy_wrb); 444 wrb_cnt = wrb_cnt_for_skb(skb, &dummy_wrb);
441 445
442 copied = make_tx_wrbs(adapter, skb, wrb_cnt, dummy_wrb); 446 copied = make_tx_wrbs(adapter, skb, wrb_cnt, dummy_wrb);
447 if (copied) {
448 /* record the sent skb in the sent_skb table */
449 BUG_ON(tx_obj->sent_skb_list[start]);
450 tx_obj->sent_skb_list[start] = skb;
451
452 /* Ensure txq has space for the next skb; Else stop the queue
453 * *BEFORE* ringing the tx doorbell, so that we serialze the
454 * tx compls of the current transmit which'll wake up the queue
455 */
456 if ((BE_MAX_TX_FRAG_COUNT + atomic_read(&txq->used)) >=
457 txq->len) {
458 netif_stop_queue(netdev);
459 stopped = true;
460 }
443 461
444 /* record the sent skb in the sent_skb table */ 462 be_txq_notify(adapter, txq->id, wrb_cnt);
445 BUG_ON(tx_obj->sent_skb_list[start]);
446 tx_obj->sent_skb_list[start] = skb;
447 463
448 /* Ensure that txq has space for the next skb; Else stop the queue 464 be_tx_stats_update(adapter, wrb_cnt, copied, stopped);
449 * *BEFORE* ringing the tx doorbell, so that we serialze the 465 } else {
450 * tx compls of the current transmit which'll wake up the queue 466 txq->head = start;
451 */ 467 dev_kfree_skb_any(skb);
452 if ((BE_MAX_TX_FRAG_COUNT + atomic_read(&txq->used)) >= txq->len) {
453 netif_stop_queue(netdev);
454 stopped = true;
455 } 468 }
456
457 be_txq_notify(adapter, txq->id, wrb_cnt);
458
459 be_tx_stats_update(adapter, wrb_cnt, copied, stopped);
460 return NETDEV_TX_OK; 469 return NETDEV_TX_OK;
461} 470}
462 471
@@ -958,10 +967,8 @@ static struct be_eth_tx_compl *be_tx_compl_get(struct be_queue_info *tx_cq)
958static void be_tx_compl_process(struct be_adapter *adapter, u16 last_index) 967static void be_tx_compl_process(struct be_adapter *adapter, u16 last_index)
959{ 968{
960 struct be_queue_info *txq = &adapter->tx_obj.q; 969 struct be_queue_info *txq = &adapter->tx_obj.q;
961 struct be_eth_wrb *wrb;
962 struct sk_buff **sent_skbs = adapter->tx_obj.sent_skb_list; 970 struct sk_buff **sent_skbs = adapter->tx_obj.sent_skb_list;
963 struct sk_buff *sent_skb; 971 struct sk_buff *sent_skb;
964 u64 busaddr;
965 u16 cur_index, num_wrbs = 0; 972 u16 cur_index, num_wrbs = 0;
966 973
967 cur_index = txq->tail; 974 cur_index = txq->tail;
@@ -971,19 +978,12 @@ static void be_tx_compl_process(struct be_adapter *adapter, u16 last_index)
971 978
972 do { 979 do {
973 cur_index = txq->tail; 980 cur_index = txq->tail;
974 wrb = queue_tail_node(txq);
975 be_dws_le_to_cpu(wrb, sizeof(*wrb));
976 busaddr = ((u64)wrb->frag_pa_hi << 32) | (u64)wrb->frag_pa_lo;
977 if (busaddr != 0) {
978 pci_unmap_single(adapter->pdev, busaddr,
979 wrb->frag_len, PCI_DMA_TODEVICE);
980 }
981 num_wrbs++; 981 num_wrbs++;
982 queue_tail_inc(txq); 982 queue_tail_inc(txq);
983 } while (cur_index != last_index); 983 } while (cur_index != last_index);
984 984
985 atomic_sub(num_wrbs, &txq->used); 985 atomic_sub(num_wrbs, &txq->used);
986 986 skb_dma_unmap(&adapter->pdev->dev, sent_skb, DMA_TO_DEVICE);
987 kfree_skb(sent_skb); 987 kfree_skb(sent_skb);
988} 988}
989 989
@@ -1699,6 +1699,173 @@ static int be_close(struct net_device *netdev)
1699 return 0; 1699 return 0;
1700} 1700}
1701 1701
1702#define FW_FILE_HDR_SIGN "ServerEngines Corp. "
1703char flash_cookie[2][16] = {"*** SE FLAS",
1704 "H DIRECTORY *** "};
1705static int be_flash_image(struct be_adapter *adapter,
1706 const struct firmware *fw,
1707 struct be_dma_mem *flash_cmd, u32 flash_type)
1708{
1709 int status;
1710 u32 flash_op, image_offset = 0, total_bytes, image_size = 0;
1711 int num_bytes;
1712 const u8 *p = fw->data;
1713 struct be_cmd_write_flashrom *req = flash_cmd->va;
1714
1715 switch (flash_type) {
1716 case FLASHROM_TYPE_ISCSI_ACTIVE:
1717 image_offset = FLASH_iSCSI_PRIMARY_IMAGE_START;
1718 image_size = FLASH_IMAGE_MAX_SIZE;
1719 break;
1720 case FLASHROM_TYPE_ISCSI_BACKUP:
1721 image_offset = FLASH_iSCSI_BACKUP_IMAGE_START;
1722 image_size = FLASH_IMAGE_MAX_SIZE;
1723 break;
1724 case FLASHROM_TYPE_FCOE_FW_ACTIVE:
1725 image_offset = FLASH_FCoE_PRIMARY_IMAGE_START;
1726 image_size = FLASH_IMAGE_MAX_SIZE;
1727 break;
1728 case FLASHROM_TYPE_FCOE_FW_BACKUP:
1729 image_offset = FLASH_FCoE_BACKUP_IMAGE_START;
1730 image_size = FLASH_IMAGE_MAX_SIZE;
1731 break;
1732 case FLASHROM_TYPE_BIOS:
1733 image_offset = FLASH_iSCSI_BIOS_START;
1734 image_size = FLASH_BIOS_IMAGE_MAX_SIZE;
1735 break;
1736 case FLASHROM_TYPE_FCOE_BIOS:
1737 image_offset = FLASH_FCoE_BIOS_START;
1738 image_size = FLASH_BIOS_IMAGE_MAX_SIZE;
1739 break;
1740 case FLASHROM_TYPE_PXE_BIOS:
1741 image_offset = FLASH_PXE_BIOS_START;
1742 image_size = FLASH_BIOS_IMAGE_MAX_SIZE;
1743 break;
1744 default:
1745 return 0;
1746 }
1747
1748 p += sizeof(struct flash_file_hdr) + image_offset;
1749 if (p + image_size > fw->data + fw->size)
1750 return -1;
1751
1752 total_bytes = image_size;
1753
1754 while (total_bytes) {
1755 if (total_bytes > 32*1024)
1756 num_bytes = 32*1024;
1757 else
1758 num_bytes = total_bytes;
1759 total_bytes -= num_bytes;
1760
1761 if (!total_bytes)
1762 flash_op = FLASHROM_OPER_FLASH;
1763 else
1764 flash_op = FLASHROM_OPER_SAVE;
1765 memcpy(req->params.data_buf, p, num_bytes);
1766 p += num_bytes;
1767 status = be_cmd_write_flashrom(adapter, flash_cmd,
1768 flash_type, flash_op, num_bytes);
1769 if (status) {
1770 dev_err(&adapter->pdev->dev,
1771 "cmd to write to flash rom failed. type/op %d/%d\n",
1772 flash_type, flash_op);
1773 return -1;
1774 }
1775 yield();
1776 }
1777
1778 return 0;
1779}
1780
1781int be_load_fw(struct be_adapter *adapter, u8 *func)
1782{
1783 char fw_file[ETHTOOL_FLASH_MAX_FILENAME];
1784 const struct firmware *fw;
1785 struct flash_file_hdr *fhdr;
1786 struct flash_section_info *fsec = NULL;
1787 struct be_dma_mem flash_cmd;
1788 int status;
1789 const u8 *p;
1790 bool entry_found = false;
1791 int flash_type;
1792 char fw_ver[FW_VER_LEN];
1793 char fw_cfg;
1794
1795 status = be_cmd_get_fw_ver(adapter, fw_ver);
1796 if (status)
1797 return status;
1798
1799 fw_cfg = *(fw_ver + 2);
1800 if (fw_cfg == '0')
1801 fw_cfg = '1';
1802 strcpy(fw_file, func);
1803
1804 status = request_firmware(&fw, fw_file, &adapter->pdev->dev);
1805 if (status)
1806 goto fw_exit;
1807
1808 p = fw->data;
1809 fhdr = (struct flash_file_hdr *) p;
1810 if (memcmp(fhdr->sign, FW_FILE_HDR_SIGN, strlen(FW_FILE_HDR_SIGN))) {
1811 dev_err(&adapter->pdev->dev,
1812 "Firmware(%s) load error (signature did not match)\n",
1813 fw_file);
1814 status = -1;
1815 goto fw_exit;
1816 }
1817
1818 dev_info(&adapter->pdev->dev, "Flashing firmware file %s\n", fw_file);
1819
1820 p += sizeof(struct flash_file_hdr);
1821 while (p < (fw->data + fw->size)) {
1822 fsec = (struct flash_section_info *)p;
1823 if (!memcmp(flash_cookie, fsec->cookie, sizeof(flash_cookie))) {
1824 entry_found = true;
1825 break;
1826 }
1827 p += 32;
1828 }
1829
1830 if (!entry_found) {
1831 status = -1;
1832 dev_err(&adapter->pdev->dev,
1833 "Flash cookie not found in firmware image\n");
1834 goto fw_exit;
1835 }
1836
1837 flash_cmd.size = sizeof(struct be_cmd_write_flashrom) + 32*1024;
1838 flash_cmd.va = pci_alloc_consistent(adapter->pdev, flash_cmd.size,
1839 &flash_cmd.dma);
1840 if (!flash_cmd.va) {
1841 status = -ENOMEM;
1842 dev_err(&adapter->pdev->dev,
1843 "Memory allocation failure while flashing\n");
1844 goto fw_exit;
1845 }
1846
1847 for (flash_type = FLASHROM_TYPE_ISCSI_ACTIVE;
1848 flash_type <= FLASHROM_TYPE_FCOE_FW_BACKUP; flash_type++) {
1849 status = be_flash_image(adapter, fw, &flash_cmd,
1850 flash_type);
1851 if (status)
1852 break;
1853 }
1854
1855 pci_free_consistent(adapter->pdev, flash_cmd.size, flash_cmd.va,
1856 flash_cmd.dma);
1857 if (status) {
1858 dev_err(&adapter->pdev->dev, "Firmware load error\n");
1859 goto fw_exit;
1860 }
1861
1862 dev_info(&adapter->pdev->dev, "Firmware flashed succesfully\n");
1863
1864fw_exit:
1865 release_firmware(fw);
1866 return status;
1867}
1868
1702static struct net_device_ops be_netdev_ops = { 1869static struct net_device_ops be_netdev_ops = {
1703 .ndo_open = be_open, 1870 .ndo_open = be_open,
1704 .ndo_stop = be_close, 1871 .ndo_stop = be_close,
@@ -1725,6 +1892,8 @@ static void be_netdev_init(struct net_device *netdev)
1725 1892
1726 adapter->rx_csum = true; 1893 adapter->rx_csum = true;
1727 1894
1895 netif_set_gso_max_size(netdev, 65535);
1896
1728 BE_SET_NETDEV_OPS(netdev, &be_netdev_ops); 1897 BE_SET_NETDEV_OPS(netdev, &be_netdev_ops);
1729 1898
1730 SET_ETHTOOL_OPS(netdev, &be_ethtool_ops); 1899 SET_ETHTOOL_OPS(netdev, &be_ethtool_ops);
diff --git a/drivers/net/hydra.c b/drivers/net/hydra.c
index 8ac0930c183c..d496b6f4a478 100644
--- a/drivers/net/hydra.c
+++ b/drivers/net/hydra.c
@@ -173,9 +173,9 @@ static int __devinit hydra_init(struct zorro_dev *z)
173 173
174 zorro_set_drvdata(z, dev); 174 zorro_set_drvdata(z, dev);
175 175
176 printk(KERN_INFO "%s: Hydra at 0x%08lx, address " 176 printk(KERN_INFO "%s: Hydra at 0x%08llx, address "
177 "%pM (hydra.c " HYDRA_VERSION ")\n", 177 "%pM (hydra.c " HYDRA_VERSION ")\n",
178 dev->name, z->resource.start, dev->dev_addr); 178 dev->name, (unsigned long long)z->resource.start, dev->dev_addr);
179 179
180 return 0; 180 return 0;
181} 181}
diff --git a/drivers/net/netxen/netxen_nic.h b/drivers/net/netxen/netxen_nic.h
index ede2fa7477ac..2a52479bcdf0 100644
--- a/drivers/net/netxen/netxen_nic.h
+++ b/drivers/net/netxen/netxen_nic.h
@@ -58,8 +58,8 @@
58 58
59#define _NETXEN_NIC_LINUX_MAJOR 4 59#define _NETXEN_NIC_LINUX_MAJOR 4
60#define _NETXEN_NIC_LINUX_MINOR 0 60#define _NETXEN_NIC_LINUX_MINOR 0
61#define _NETXEN_NIC_LINUX_SUBVERSION 41 61#define _NETXEN_NIC_LINUX_SUBVERSION 50
62#define NETXEN_NIC_LINUX_VERSIONID "4.0.41" 62#define NETXEN_NIC_LINUX_VERSIONID "4.0.50"
63 63
64#define NETXEN_VERSION_CODE(a, b, c) (((a) << 24) + ((b) << 16) + (c)) 64#define NETXEN_VERSION_CODE(a, b, c) (((a) << 24) + ((b) << 16) + (c))
65#define _major(v) (((v) >> 24) & 0xff) 65#define _major(v) (((v) >> 24) & 0xff)
@@ -229,6 +229,8 @@
229#define MPORT_SINGLE_FUNCTION_MODE 0x1111 229#define MPORT_SINGLE_FUNCTION_MODE 0x1111
230#define MPORT_MULTI_FUNCTION_MODE 0x2222 230#define MPORT_MULTI_FUNCTION_MODE 0x2222
231 231
232#define NX_MAX_PCI_FUNC 8
233
232/* 234/*
233 * NetXen host-peg signal message structure 235 * NetXen host-peg signal message structure
234 * 236 *
@@ -582,11 +584,11 @@ struct netxen_adapter_stats {
582 */ 584 */
583struct nx_host_rds_ring { 585struct nx_host_rds_ring {
584 u32 producer; 586 u32 producer;
585 u32 crb_rcv_producer;
586 u32 num_desc; 587 u32 num_desc;
587 u32 dma_size; 588 u32 dma_size;
588 u32 skb_size; 589 u32 skb_size;
589 u32 flags; 590 u32 flags;
591 void __iomem *crb_rcv_producer;
590 struct rcv_desc *desc_head; 592 struct rcv_desc *desc_head;
591 struct netxen_rx_buffer *rx_buf_arr; 593 struct netxen_rx_buffer *rx_buf_arr;
592 struct list_head free_list; 594 struct list_head free_list;
@@ -596,9 +598,9 @@ struct nx_host_rds_ring {
596 598
597struct nx_host_sds_ring { 599struct nx_host_sds_ring {
598 u32 consumer; 600 u32 consumer;
599 u32 crb_sts_consumer;
600 u32 crb_intr_mask;
601 u32 num_desc; 601 u32 num_desc;
602 void __iomem *crb_sts_consumer;
603 void __iomem *crb_intr_mask;
602 604
603 struct status_desc *desc_head; 605 struct status_desc *desc_head;
604 struct netxen_adapter *adapter; 606 struct netxen_adapter *adapter;
@@ -615,8 +617,8 @@ struct nx_host_tx_ring {
615 u32 producer; 617 u32 producer;
616 __le32 *hw_consumer; 618 __le32 *hw_consumer;
617 u32 sw_consumer; 619 u32 sw_consumer;
618 u32 crb_cmd_producer; 620 void __iomem *crb_cmd_producer;
619 u32 crb_cmd_consumer; 621 void __iomem *crb_cmd_consumer;
620 u32 num_desc; 622 u32 num_desc;
621 623
622 struct netdev_queue *txq; 624 struct netdev_queue *txq;
@@ -1101,6 +1103,10 @@ typedef struct {
1101#define NETXEN_ADAPTER_UP_MAGIC 777 1103#define NETXEN_ADAPTER_UP_MAGIC 777
1102#define NETXEN_NIC_PEG_TUNE 0 1104#define NETXEN_NIC_PEG_TUNE 0
1103 1105
1106#define __NX_FW_ATTACHED 0
1107#define __NX_DEV_UP 1
1108#define __NX_RESETTING 2
1109
1104struct netxen_dummy_dma { 1110struct netxen_dummy_dma {
1105 void *addr; 1111 void *addr;
1106 dma_addr_t phys_addr; 1112 dma_addr_t phys_addr;
@@ -1137,7 +1143,9 @@ struct netxen_adapter {
1137 u8 max_mc_count; 1143 u8 max_mc_count;
1138 u8 rss_supported; 1144 u8 rss_supported;
1139 u8 link_changed; 1145 u8 link_changed;
1140 u32 resv3; 1146 u8 fw_wait_cnt;
1147 u8 fw_fail_cnt;
1148 u16 resv4;
1141 1149
1142 u8 has_link_events; 1150 u8 has_link_events;
1143 u8 fw_type; 1151 u8 fw_type;
@@ -1155,8 +1163,8 @@ struct netxen_adapter {
1155 u32 irq; 1163 u32 irq;
1156 u32 temp; 1164 u32 temp;
1157 1165
1158 u32 msi_tgt_status; 1166 u32 int_vec_bit;
1159 u32 resv4; 1167 u32 heartbit;
1160 1168
1161 struct netxen_adapter_stats stats; 1169 struct netxen_adapter_stats stats;
1162 1170
@@ -1172,29 +1180,37 @@ struct netxen_adapter {
1172 int (*init_port) (struct netxen_adapter *, int); 1180 int (*init_port) (struct netxen_adapter *, int);
1173 int (*stop_port) (struct netxen_adapter *); 1181 int (*stop_port) (struct netxen_adapter *);
1174 1182
1175 u32 (*hw_read_wx)(struct netxen_adapter *, ulong); 1183 u32 (*crb_read)(struct netxen_adapter *, ulong);
1176 int (*hw_write_wx)(struct netxen_adapter *, ulong, u32); 1184 int (*crb_write)(struct netxen_adapter *, ulong, u32);
1185
1177 int (*pci_mem_read)(struct netxen_adapter *, u64, void *, int); 1186 int (*pci_mem_read)(struct netxen_adapter *, u64, void *, int);
1178 int (*pci_mem_write)(struct netxen_adapter *, u64, void *, int); 1187 int (*pci_mem_write)(struct netxen_adapter *, u64, void *, int);
1179 int (*pci_write_immediate)(struct netxen_adapter *, u64, u32); 1188
1180 u32 (*pci_read_immediate)(struct netxen_adapter *, u64);
1181 unsigned long (*pci_set_window)(struct netxen_adapter *, 1189 unsigned long (*pci_set_window)(struct netxen_adapter *,
1182 unsigned long long); 1190 unsigned long long);
1183 1191
1184 struct netxen_legacy_intr_set legacy_intr; 1192 u32 (*io_read)(struct netxen_adapter *, void __iomem *);
1193 void (*io_write)(struct netxen_adapter *, void __iomem *, u32);
1194
1195 void __iomem *tgt_mask_reg;
1196 void __iomem *pci_int_reg;
1197 void __iomem *tgt_status_reg;
1198 void __iomem *crb_int_state_reg;
1199 void __iomem *isr_int_vec;
1185 1200
1186 struct msix_entry msix_entries[MSIX_ENTRIES_PER_ADAPTER]; 1201 struct msix_entry msix_entries[MSIX_ENTRIES_PER_ADAPTER];
1187 1202
1188 struct netxen_dummy_dma dummy_dma; 1203 struct netxen_dummy_dma dummy_dma;
1189 1204
1190 struct work_struct watchdog_task; 1205 struct delayed_work fw_work;
1191 struct timer_list watchdog_timer; 1206
1192 struct work_struct tx_timeout_task; 1207 struct work_struct tx_timeout_task;
1193 1208
1194 struct net_device_stats net_stats; 1209 struct net_device_stats net_stats;
1195 1210
1196 nx_nic_intr_coalesce_t coal; 1211 nx_nic_intr_coalesce_t coal;
1197 1212
1213 unsigned long state;
1198 u32 resv5; 1214 u32 resv5;
1199 u32 fw_version; 1215 u32 fw_version;
1200 const struct firmware *fw; 1216 const struct firmware *fw;
@@ -1214,9 +1230,13 @@ int netxen_p2_nic_set_mac_addr(struct netxen_adapter *adapter, u8 *addr);
1214int netxen_p3_nic_set_mac_addr(struct netxen_adapter *adapter, u8 *addr); 1230int netxen_p3_nic_set_mac_addr(struct netxen_adapter *adapter, u8 *addr);
1215 1231
1216#define NXRD32(adapter, off) \ 1232#define NXRD32(adapter, off) \
1217 (adapter->hw_read_wx(adapter, off)) 1233 (adapter->crb_read(adapter, off))
1218#define NXWR32(adapter, off, val) \ 1234#define NXWR32(adapter, off, val) \
1219 (adapter->hw_write_wx(adapter, off, val)) 1235 (adapter->crb_write(adapter, off, val))
1236#define NXRDIO(adapter, addr) \
1237 (adapter->io_read(adapter, addr))
1238#define NXWRIO(adapter, addr, val) \
1239 (adapter->io_write(adapter, addr, val))
1220 1240
1221int netxen_pcie_sem_lock(struct netxen_adapter *, int, u32); 1241int netxen_pcie_sem_lock(struct netxen_adapter *, int, u32);
1222void netxen_pcie_sem_unlock(struct netxen_adapter *, int); 1242void netxen_pcie_sem_unlock(struct netxen_adapter *, int);
@@ -1243,43 +1263,8 @@ void netxen_pcie_sem_unlock(struct netxen_adapter *, int);
1243 netxen_pcie_sem_unlock((a), 7) 1263 netxen_pcie_sem_unlock((a), 7)
1244 1264
1245int netxen_nic_get_board_info(struct netxen_adapter *adapter); 1265int netxen_nic_get_board_info(struct netxen_adapter *adapter);
1246void netxen_nic_get_firmware_info(struct netxen_adapter *adapter);
1247int netxen_nic_wol_supported(struct netxen_adapter *adapter); 1266int netxen_nic_wol_supported(struct netxen_adapter *adapter);
1248 1267
1249u32 netxen_nic_hw_read_wx_128M(struct netxen_adapter *adapter, ulong off);
1250int netxen_nic_hw_write_wx_128M(struct netxen_adapter *adapter,
1251 ulong off, u32 data);
1252int netxen_nic_pci_mem_read_128M(struct netxen_adapter *adapter,
1253 u64 off, void *data, int size);
1254int netxen_nic_pci_mem_write_128M(struct netxen_adapter *adapter,
1255 u64 off, void *data, int size);
1256int netxen_nic_pci_write_immediate_128M(struct netxen_adapter *adapter,
1257 u64 off, u32 data);
1258u32 netxen_nic_pci_read_immediate_128M(struct netxen_adapter *adapter, u64 off);
1259void netxen_nic_pci_write_normalize_128M(struct netxen_adapter *adapter,
1260 u64 off, u32 data);
1261u32 netxen_nic_pci_read_normalize_128M(struct netxen_adapter *adapter, u64 off);
1262unsigned long netxen_nic_pci_set_window_128M(struct netxen_adapter *adapter,
1263 unsigned long long addr);
1264void netxen_nic_pci_change_crbwindow_128M(struct netxen_adapter *adapter,
1265 u32 wndw);
1266
1267u32 netxen_nic_hw_read_wx_2M(struct netxen_adapter *adapter, ulong off);
1268int netxen_nic_hw_write_wx_2M(struct netxen_adapter *adapter,
1269 ulong off, u32 data);
1270int netxen_nic_pci_mem_read_2M(struct netxen_adapter *adapter,
1271 u64 off, void *data, int size);
1272int netxen_nic_pci_mem_write_2M(struct netxen_adapter *adapter,
1273 u64 off, void *data, int size);
1274int netxen_nic_pci_write_immediate_2M(struct netxen_adapter *adapter,
1275 u64 off, u32 data);
1276u32 netxen_nic_pci_read_immediate_2M(struct netxen_adapter *adapter, u64 off);
1277void netxen_nic_pci_write_normalize_2M(struct netxen_adapter *adapter,
1278 u64 off, u32 data);
1279u32 netxen_nic_pci_read_normalize_2M(struct netxen_adapter *adapter, u64 off);
1280unsigned long netxen_nic_pci_set_window_2M(struct netxen_adapter *adapter,
1281 unsigned long long addr);
1282
1283/* Functions from netxen_nic_init.c */ 1268/* Functions from netxen_nic_init.c */
1284int netxen_init_dummy_dma(struct netxen_adapter *adapter); 1269int netxen_init_dummy_dma(struct netxen_adapter *adapter);
1285void netxen_free_dummy_dma(struct netxen_adapter *adapter); 1270void netxen_free_dummy_dma(struct netxen_adapter *adapter);
@@ -1307,13 +1292,15 @@ int netxen_rom_se(struct netxen_adapter *adapter, int addr);
1307int netxen_alloc_sw_resources(struct netxen_adapter *adapter); 1292int netxen_alloc_sw_resources(struct netxen_adapter *adapter);
1308void netxen_free_sw_resources(struct netxen_adapter *adapter); 1293void netxen_free_sw_resources(struct netxen_adapter *adapter);
1309 1294
1295void netxen_setup_hwops(struct netxen_adapter *adapter);
1296void __iomem *netxen_get_ioaddr(struct netxen_adapter *, u32);
1297
1310int netxen_alloc_hw_resources(struct netxen_adapter *adapter); 1298int netxen_alloc_hw_resources(struct netxen_adapter *adapter);
1311void netxen_free_hw_resources(struct netxen_adapter *adapter); 1299void netxen_free_hw_resources(struct netxen_adapter *adapter);
1312 1300
1313void netxen_release_rx_buffers(struct netxen_adapter *adapter); 1301void netxen_release_rx_buffers(struct netxen_adapter *adapter);
1314void netxen_release_tx_buffers(struct netxen_adapter *adapter); 1302void netxen_release_tx_buffers(struct netxen_adapter *adapter);
1315 1303
1316void netxen_initialize_adapter_ops(struct netxen_adapter *adapter);
1317int netxen_init_firmware(struct netxen_adapter *adapter); 1304int netxen_init_firmware(struct netxen_adapter *adapter);
1318void netxen_nic_clear_stats(struct netxen_adapter *adapter); 1305void netxen_nic_clear_stats(struct netxen_adapter *adapter);
1319void netxen_watchdog_task(struct work_struct *work); 1306void netxen_watchdog_task(struct work_struct *work);
diff --git a/drivers/net/netxen/netxen_nic_ctx.c b/drivers/net/netxen/netxen_nic_ctx.c
index 0f42ab998368..33f82db01293 100644
--- a/drivers/net/netxen/netxen_nic_ctx.c
+++ b/drivers/net/netxen/netxen_nic_ctx.c
@@ -229,7 +229,8 @@ nx_fw_cmd_create_rx_ctx(struct netxen_adapter *adapter)
229 rds_ring = &recv_ctx->rds_rings[i]; 229 rds_ring = &recv_ctx->rds_rings[i];
230 230
231 reg = le32_to_cpu(prsp_rds[i].host_producer_crb); 231 reg = le32_to_cpu(prsp_rds[i].host_producer_crb);
232 rds_ring->crb_rcv_producer = NETXEN_NIC_REG(reg - 0x200); 232 rds_ring->crb_rcv_producer = netxen_get_ioaddr(adapter,
233 NETXEN_NIC_REG(reg - 0x200));
233 } 234 }
234 235
235 prsp_sds = ((nx_cardrsp_sds_ring_t *) 236 prsp_sds = ((nx_cardrsp_sds_ring_t *)
@@ -239,10 +240,12 @@ nx_fw_cmd_create_rx_ctx(struct netxen_adapter *adapter)
239 sds_ring = &recv_ctx->sds_rings[i]; 240 sds_ring = &recv_ctx->sds_rings[i];
240 241
241 reg = le32_to_cpu(prsp_sds[i].host_consumer_crb); 242 reg = le32_to_cpu(prsp_sds[i].host_consumer_crb);
242 sds_ring->crb_sts_consumer = NETXEN_NIC_REG(reg - 0x200); 243 sds_ring->crb_sts_consumer = netxen_get_ioaddr(adapter,
244 NETXEN_NIC_REG(reg - 0x200));
243 245
244 reg = le32_to_cpu(prsp_sds[i].interrupt_crb); 246 reg = le32_to_cpu(prsp_sds[i].interrupt_crb);
245 sds_ring->crb_intr_mask = NETXEN_NIC_REG(reg - 0x200); 247 sds_ring->crb_intr_mask = netxen_get_ioaddr(adapter,
248 NETXEN_NIC_REG(reg - 0x200));
246 } 249 }
247 250
248 recv_ctx->state = le32_to_cpu(prsp->host_ctx_state); 251 recv_ctx->state = le32_to_cpu(prsp->host_ctx_state);
@@ -342,7 +345,8 @@ nx_fw_cmd_create_tx_ctx(struct netxen_adapter *adapter)
342 345
343 if (err == NX_RCODE_SUCCESS) { 346 if (err == NX_RCODE_SUCCESS) {
344 temp = le32_to_cpu(prsp->cds_ring.host_producer_crb); 347 temp = le32_to_cpu(prsp->cds_ring.host_producer_crb);
345 tx_ring->crb_cmd_producer = NETXEN_NIC_REG(temp - 0x200); 348 tx_ring->crb_cmd_producer = netxen_get_ioaddr(adapter,
349 NETXEN_NIC_REG(temp - 0x200));
346#if 0 350#if 0
347 adapter->tx_state = 351 adapter->tx_state =
348 le32_to_cpu(prsp->host_ctx_state); 352 le32_to_cpu(prsp->host_ctx_state);
@@ -651,7 +655,8 @@ int netxen_alloc_hw_resources(struct netxen_adapter *adapter)
651 655
652 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) 656 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
653 rds_ring->crb_rcv_producer = 657 rds_ring->crb_rcv_producer =
654 recv_crb_registers[port].crb_rcv_producer[ring]; 658 netxen_get_ioaddr(adapter,
659 recv_crb_registers[port].crb_rcv_producer[ring]);
655 } 660 }
656 661
657 for (ring = 0; ring < adapter->max_sds_rings; ring++) { 662 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
@@ -670,14 +675,19 @@ int netxen_alloc_hw_resources(struct netxen_adapter *adapter)
670 sds_ring->desc_head = (struct status_desc *)addr; 675 sds_ring->desc_head = (struct status_desc *)addr;
671 676
672 sds_ring->crb_sts_consumer = 677 sds_ring->crb_sts_consumer =
673 recv_crb_registers[port].crb_sts_consumer[ring]; 678 netxen_get_ioaddr(adapter,
679 recv_crb_registers[port].crb_sts_consumer[ring]);
674 680
675 sds_ring->crb_intr_mask = 681 sds_ring->crb_intr_mask =
676 recv_crb_registers[port].sw_int_mask[ring]; 682 netxen_get_ioaddr(adapter,
683 recv_crb_registers[port].sw_int_mask[ring]);
677 } 684 }
678 685
679 686
680 if (!NX_IS_REVISION_P2(adapter->ahw.revision_id)) { 687 if (!NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
688 if (test_and_set_bit(__NX_FW_ATTACHED, &adapter->state))
689 goto done;
690
681 err = nx_fw_cmd_create_rx_ctx(adapter); 691 err = nx_fw_cmd_create_rx_ctx(adapter);
682 if (err) 692 if (err)
683 goto err_out_free; 693 goto err_out_free;
@@ -690,6 +700,7 @@ int netxen_alloc_hw_resources(struct netxen_adapter *adapter)
690 goto err_out_free; 700 goto err_out_free;
691 } 701 }
692 702
703done:
693 return 0; 704 return 0;
694 705
695err_out_free: 706err_out_free:
@@ -708,6 +719,9 @@ void netxen_free_hw_resources(struct netxen_adapter *adapter)
708 int port = adapter->portnum; 719 int port = adapter->portnum;
709 720
710 if (!NX_IS_REVISION_P2(adapter->ahw.revision_id)) { 721 if (!NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
722 if (!test_and_clear_bit(__NX_FW_ATTACHED, &adapter->state))
723 goto done;
724
711 nx_fw_cmd_destroy_rx_ctx(adapter); 725 nx_fw_cmd_destroy_rx_ctx(adapter);
712 nx_fw_cmd_destroy_tx_ctx(adapter); 726 nx_fw_cmd_destroy_tx_ctx(adapter);
713 } else { 727 } else {
@@ -720,6 +734,7 @@ void netxen_free_hw_resources(struct netxen_adapter *adapter)
720 /* Allow dma queues to drain after context reset */ 734 /* Allow dma queues to drain after context reset */
721 msleep(20); 735 msleep(20);
722 736
737done:
723 recv_ctx = &adapter->recv_ctx; 738 recv_ctx = &adapter->recv_ctx;
724 739
725 if (recv_ctx->hwctx != NULL) { 740 if (recv_ctx->hwctx != NULL) {
diff --git a/drivers/net/netxen/netxen_nic_ethtool.c b/drivers/net/netxen/netxen_nic_ethtool.c
index e376a1c4eb06..d18832ce4b58 100644
--- a/drivers/net/netxen/netxen_nic_ethtool.c
+++ b/drivers/net/netxen/netxen_nic_ethtool.c
@@ -84,18 +84,17 @@ static void
84netxen_nic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo) 84netxen_nic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
85{ 85{
86 struct netxen_adapter *adapter = netdev_priv(dev); 86 struct netxen_adapter *adapter = netdev_priv(dev);
87 unsigned long flags;
88 u32 fw_major = 0; 87 u32 fw_major = 0;
89 u32 fw_minor = 0; 88 u32 fw_minor = 0;
90 u32 fw_build = 0; 89 u32 fw_build = 0;
91 90
92 strncpy(drvinfo->driver, netxen_nic_driver_name, 32); 91 strncpy(drvinfo->driver, netxen_nic_driver_name, 32);
93 strncpy(drvinfo->version, NETXEN_NIC_LINUX_VERSIONID, 32); 92 strncpy(drvinfo->version, NETXEN_NIC_LINUX_VERSIONID, 32);
94 write_lock_irqsave(&adapter->adapter_lock, flags); 93 read_lock(&adapter->adapter_lock);
95 fw_major = NXRD32(adapter, NETXEN_FW_VERSION_MAJOR); 94 fw_major = NXRD32(adapter, NETXEN_FW_VERSION_MAJOR);
96 fw_minor = NXRD32(adapter, NETXEN_FW_VERSION_MINOR); 95 fw_minor = NXRD32(adapter, NETXEN_FW_VERSION_MINOR);
97 fw_build = NXRD32(adapter, NETXEN_FW_VERSION_SUB); 96 fw_build = NXRD32(adapter, NETXEN_FW_VERSION_SUB);
98 write_unlock_irqrestore(&adapter->adapter_lock, flags); 97 read_unlock(&adapter->adapter_lock);
99 sprintf(drvinfo->fw_version, "%d.%d.%d", fw_major, fw_minor, fw_build); 98 sprintf(drvinfo->fw_version, "%d.%d.%d", fw_major, fw_minor, fw_build);
100 99
101 strncpy(drvinfo->bus_info, pci_name(adapter->pdev), 32); 100 strncpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
diff --git a/drivers/net/netxen/netxen_nic_hdr.h b/drivers/net/netxen/netxen_nic_hdr.h
index 92f5970c9aa9..26188b43abe9 100644
--- a/drivers/net/netxen/netxen_nic_hdr.h
+++ b/drivers/net/netxen/netxen_nic_hdr.h
@@ -433,6 +433,7 @@ enum {
433#define NETXEN_CRB_PEG_NET_1 NETXEN_PCI_CRB_WINDOW(NETXEN_HW_PX_MAP_CRB_PGN1) 433#define NETXEN_CRB_PEG_NET_1 NETXEN_PCI_CRB_WINDOW(NETXEN_HW_PX_MAP_CRB_PGN1)
434#define NETXEN_CRB_PEG_NET_2 NETXEN_PCI_CRB_WINDOW(NETXEN_HW_PX_MAP_CRB_PGN2) 434#define NETXEN_CRB_PEG_NET_2 NETXEN_PCI_CRB_WINDOW(NETXEN_HW_PX_MAP_CRB_PGN2)
435#define NETXEN_CRB_PEG_NET_3 NETXEN_PCI_CRB_WINDOW(NETXEN_HW_PX_MAP_CRB_PGN3) 435#define NETXEN_CRB_PEG_NET_3 NETXEN_PCI_CRB_WINDOW(NETXEN_HW_PX_MAP_CRB_PGN3)
436#define NETXEN_CRB_PEG_NET_4 NETXEN_PCI_CRB_WINDOW(NETXEN_HW_PX_MAP_CRB_SQS2)
436#define NETXEN_CRB_PEG_NET_D NETXEN_PCI_CRB_WINDOW(NETXEN_HW_PX_MAP_CRB_PGND) 437#define NETXEN_CRB_PEG_NET_D NETXEN_PCI_CRB_WINDOW(NETXEN_HW_PX_MAP_CRB_PGND)
437#define NETXEN_CRB_PEG_NET_I NETXEN_PCI_CRB_WINDOW(NETXEN_HW_PX_MAP_CRB_PGNI) 438#define NETXEN_CRB_PEG_NET_I NETXEN_PCI_CRB_WINDOW(NETXEN_HW_PX_MAP_CRB_PGNI)
438#define NETXEN_CRB_DDR_NET NETXEN_PCI_CRB_WINDOW(NETXEN_HW_PX_MAP_CRB_MN) 439#define NETXEN_CRB_DDR_NET NETXEN_PCI_CRB_WINDOW(NETXEN_HW_PX_MAP_CRB_MN)
@@ -945,6 +946,28 @@ enum {
945 946
946#define NETXEN_DMA_WATCHDOG_CTRL (NETXEN_CAM_RAM(0x14)) 947#define NETXEN_DMA_WATCHDOG_CTRL (NETXEN_CAM_RAM(0x14))
947#define NETXEN_PEG_ALIVE_COUNTER (NETXEN_CAM_RAM(0xb0)) 948#define NETXEN_PEG_ALIVE_COUNTER (NETXEN_CAM_RAM(0xb0))
949#define NETXEN_PEG_HALT_STATUS1 (NETXEN_CAM_RAM(0xa8))
950#define NETXEN_PEG_HALT_STATUS2 (NETXEN_CAM_RAM(0xac))
951#define NX_CRB_DEV_REF_COUNT (NETXEN_CAM_RAM(0x138))
952#define NX_CRB_DEV_STATE (NETXEN_CAM_RAM(0x140))
953
954/* Device State */
955#define NX_DEV_COLD 1
956#define NX_DEV_INITALIZING 2
957#define NX_DEV_READY 3
958#define NX_DEV_NEED_RESET 4
959#define NX_DEV_NEED_QUISCENT 5
960#define NX_DEV_FAILED 6
961
962#define NX_RCODE_DRIVER_INFO 0x20000000
963#define NX_RCODE_DRIVER_CAN_RELOAD 0x40000000
964#define NX_RCODE_FATAL_ERROR 0x80000000
965#define NX_FWERROR_PEGNUM(code) ((code) & 0xff)
966#define NX_FWERROR_CODE(code) ((code >> 8) & 0xfffff)
967
968#define FW_POLL_DELAY (2 * HZ)
969#define FW_FAIL_THRESH 3
970#define FW_POLL_THRESH 10
948 971
949#define ISR_MSI_INT_TRIGGER(FUNC) (NETXEN_PCIX_PS_REG(PCIX_MSI_F(FUNC))) 972#define ISR_MSI_INT_TRIGGER(FUNC) (NETXEN_PCIX_PS_REG(PCIX_MSI_F(FUNC)))
950#define ISR_LEGACY_INT_TRIGGERED(VAL) (((VAL) & 0x300) == 0x200) 973#define ISR_LEGACY_INT_TRIGGERED(VAL) (((VAL) & 0x300) == 0x200)
diff --git a/drivers/net/netxen/netxen_nic_hw.c b/drivers/net/netxen/netxen_nic_hw.c
index db510cee8094..555bc4a7e888 100644
--- a/drivers/net/netxen/netxen_nic_hw.c
+++ b/drivers/net/netxen/netxen_nic_hw.c
@@ -566,6 +566,9 @@ netxen_send_cmd_descs(struct netxen_adapter *adapter,
566 566
567 i = 0; 567 i = 0;
568 568
569 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
570 return -EIO;
571
569 tx_ring = adapter->tx_ring; 572 tx_ring = adapter->tx_ring;
570 __netif_tx_lock_bh(tx_ring->txq); 573 __netif_tx_lock_bh(tx_ring->txq);
571 574
@@ -1047,7 +1050,7 @@ int netxen_p3_get_mac_addr(struct netxen_adapter *adapter, __le64 *mac)
1047/* 1050/*
1048 * Changes the CRB window to the specified window. 1051 * Changes the CRB window to the specified window.
1049 */ 1052 */
1050void 1053static void
1051netxen_nic_pci_change_crbwindow_128M(struct netxen_adapter *adapter, u32 wndw) 1054netxen_nic_pci_change_crbwindow_128M(struct netxen_adapter *adapter, u32 wndw)
1052{ 1055{
1053 void __iomem *offset; 1056 void __iomem *offset;
@@ -1160,61 +1163,68 @@ netxen_nic_pci_set_crbwindow_2M(struct netxen_adapter *adapter, ulong *off)
1160 (ulong)adapter->ahw.pci_base0; 1163 (ulong)adapter->ahw.pci_base0;
1161} 1164}
1162 1165
1163int 1166static int
1164netxen_nic_hw_write_wx_128M(struct netxen_adapter *adapter, ulong off, u32 data) 1167netxen_nic_hw_write_wx_128M(struct netxen_adapter *adapter, ulong off, u32 data)
1165{ 1168{
1169 unsigned long flags;
1166 void __iomem *addr; 1170 void __iomem *addr;
1167 1171
1168 if (ADDR_IN_WINDOW1(off)) { 1172 if (ADDR_IN_WINDOW1(off))
1169 addr = NETXEN_CRB_NORMALIZE(adapter, off); 1173 addr = NETXEN_CRB_NORMALIZE(adapter, off);
1174 else
1175 addr = pci_base_offset(adapter, off);
1176
1177 BUG_ON(!addr);
1178
1179 if (ADDR_IN_WINDOW1(off)) { /* Window 1 */
1180 read_lock(&adapter->adapter_lock);
1181 writel(data, addr);
1182 read_unlock(&adapter->adapter_lock);
1170 } else { /* Window 0 */ 1183 } else { /* Window 0 */
1184 write_lock_irqsave(&adapter->adapter_lock, flags);
1171 addr = pci_base_offset(adapter, off); 1185 addr = pci_base_offset(adapter, off);
1172 netxen_nic_pci_change_crbwindow_128M(adapter, 0); 1186 netxen_nic_pci_change_crbwindow_128M(adapter, 0);
1173 } 1187 writel(data, addr);
1174
1175 if (!addr) {
1176 netxen_nic_pci_change_crbwindow_128M(adapter, 1); 1188 netxen_nic_pci_change_crbwindow_128M(adapter, 1);
1177 return 1; 1189 write_unlock_irqrestore(&adapter->adapter_lock, flags);
1178 } 1190 }
1179 1191
1180 writel(data, addr);
1181
1182 if (!ADDR_IN_WINDOW1(off))
1183 netxen_nic_pci_change_crbwindow_128M(adapter, 1);
1184
1185 return 0; 1192 return 0;
1186} 1193}
1187 1194
1188u32 1195static u32
1189netxen_nic_hw_read_wx_128M(struct netxen_adapter *adapter, ulong off) 1196netxen_nic_hw_read_wx_128M(struct netxen_adapter *adapter, ulong off)
1190{ 1197{
1198 unsigned long flags;
1191 void __iomem *addr; 1199 void __iomem *addr;
1192 u32 data; 1200 u32 data;
1193 1201
1194 if (ADDR_IN_WINDOW1(off)) { /* Window 1 */ 1202 if (ADDR_IN_WINDOW1(off))
1195 addr = NETXEN_CRB_NORMALIZE(adapter, off); 1203 addr = NETXEN_CRB_NORMALIZE(adapter, off);
1196 } else { /* Window 0 */ 1204 else
1197 addr = pci_base_offset(adapter, off); 1205 addr = pci_base_offset(adapter, off);
1198 netxen_nic_pci_change_crbwindow_128M(adapter, 0);
1199 }
1200 1206
1201 if (!addr) { 1207 BUG_ON(!addr);
1202 netxen_nic_pci_change_crbwindow_128M(adapter, 1);
1203 return 1;
1204 }
1205
1206 data = readl(addr);
1207 1208
1208 if (!ADDR_IN_WINDOW1(off)) 1209 if (ADDR_IN_WINDOW1(off)) { /* Window 1 */
1210 read_lock(&adapter->adapter_lock);
1211 data = readl(addr);
1212 read_unlock(&adapter->adapter_lock);
1213 } else { /* Window 0 */
1214 write_lock_irqsave(&adapter->adapter_lock, flags);
1215 netxen_nic_pci_change_crbwindow_128M(adapter, 0);
1216 data = readl(addr);
1209 netxen_nic_pci_change_crbwindow_128M(adapter, 1); 1217 netxen_nic_pci_change_crbwindow_128M(adapter, 1);
1218 write_unlock_irqrestore(&adapter->adapter_lock, flags);
1219 }
1210 1220
1211 return data; 1221 return data;
1212} 1222}
1213 1223
1214int 1224static int
1215netxen_nic_hw_write_wx_2M(struct netxen_adapter *adapter, ulong off, u32 data) 1225netxen_nic_hw_write_wx_2M(struct netxen_adapter *adapter, ulong off, u32 data)
1216{ 1226{
1217 unsigned long flags = 0; 1227 unsigned long flags;
1218 int rv; 1228 int rv;
1219 1229
1220 rv = netxen_nic_pci_get_crb_addr_2M(adapter, &off); 1230 rv = netxen_nic_pci_get_crb_addr_2M(adapter, &off);
@@ -1240,10 +1250,10 @@ netxen_nic_hw_write_wx_2M(struct netxen_adapter *adapter, ulong off, u32 data)
1240 return 0; 1250 return 0;
1241} 1251}
1242 1252
1243u32 1253static u32
1244netxen_nic_hw_read_wx_2M(struct netxen_adapter *adapter, ulong off) 1254netxen_nic_hw_read_wx_2M(struct netxen_adapter *adapter, ulong off)
1245{ 1255{
1246 unsigned long flags = 0; 1256 unsigned long flags;
1247 int rv; 1257 int rv;
1248 u32 data; 1258 u32 data;
1249 1259
@@ -1290,7 +1300,7 @@ netxen_nic_pci_mem_bound_check(struct netxen_adapter *adapter,
1290 1300
1291static int netxen_pci_set_window_warning_count; 1301static int netxen_pci_set_window_warning_count;
1292 1302
1293unsigned long 1303static unsigned long
1294netxen_nic_pci_set_window_128M(struct netxen_adapter *adapter, 1304netxen_nic_pci_set_window_128M(struct netxen_adapter *adapter,
1295 unsigned long long addr) 1305 unsigned long long addr)
1296{ 1306{
@@ -1354,22 +1364,56 @@ netxen_nic_pci_set_window_128M(struct netxen_adapter *adapter,
1354 return addr; 1364 return addr;
1355} 1365}
1356 1366
1357/* 1367/* window 1 registers only */
1358 * Note : only 32-bit writes! 1368static void netxen_nic_io_write_128M(struct netxen_adapter *adapter,
1359 */ 1369 void __iomem *addr, u32 data)
1360int netxen_nic_pci_write_immediate_128M(struct netxen_adapter *adapter,
1361 u64 off, u32 data)
1362{ 1370{
1363 writel(data, (void __iomem *)(PCI_OFFSET_SECOND_RANGE(adapter, off))); 1371 read_lock(&adapter->adapter_lock);
1364 return 0; 1372 writel(data, addr);
1373 read_unlock(&adapter->adapter_lock);
1365} 1374}
1366 1375
1367u32 netxen_nic_pci_read_immediate_128M(struct netxen_adapter *adapter, u64 off) 1376static u32 netxen_nic_io_read_128M(struct netxen_adapter *adapter,
1377 void __iomem *addr)
1368{ 1378{
1369 return readl((void __iomem *)(pci_base_offset(adapter, off))); 1379 u32 val;
1380
1381 read_lock(&adapter->adapter_lock);
1382 val = readl(addr);
1383 read_unlock(&adapter->adapter_lock);
1384
1385 return val;
1370} 1386}
1371 1387
1372unsigned long 1388static void netxen_nic_io_write_2M(struct netxen_adapter *adapter,
1389 void __iomem *addr, u32 data)
1390{
1391 writel(data, addr);
1392}
1393
1394static u32 netxen_nic_io_read_2M(struct netxen_adapter *adapter,
1395 void __iomem *addr)
1396{
1397 return readl(addr);
1398}
1399
1400void __iomem *
1401netxen_get_ioaddr(struct netxen_adapter *adapter, u32 offset)
1402{
1403 ulong off = offset;
1404
1405 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
1406 if (offset < NETXEN_CRB_PCIX_HOST2 &&
1407 offset > NETXEN_CRB_PCIX_HOST)
1408 return PCI_OFFSET_SECOND_RANGE(adapter, offset);
1409 return NETXEN_CRB_NORMALIZE(adapter, offset);
1410 }
1411
1412 BUG_ON(netxen_nic_pci_get_crb_addr_2M(adapter, &off));
1413 return (void __iomem *)off;
1414}
1415
1416static unsigned long
1373netxen_nic_pci_set_window_2M(struct netxen_adapter *adapter, 1417netxen_nic_pci_set_window_2M(struct netxen_adapter *adapter,
1374 unsigned long long addr) 1418 unsigned long long addr)
1375{ 1419{
@@ -1613,7 +1657,7 @@ netxen_nic_pci_mem_write_direct(struct netxen_adapter *adapter, u64 off,
1613 1657
1614#define MAX_CTL_CHECK 1000 1658#define MAX_CTL_CHECK 1000
1615 1659
1616int 1660static int
1617netxen_nic_pci_mem_write_128M(struct netxen_adapter *adapter, 1661netxen_nic_pci_mem_write_128M(struct netxen_adapter *adapter,
1618 u64 off, void *data, int size) 1662 u64 off, void *data, int size)
1619{ 1663{
@@ -1706,7 +1750,7 @@ netxen_nic_pci_mem_write_128M(struct netxen_adapter *adapter,
1706 return ret; 1750 return ret;
1707} 1751}
1708 1752
1709int 1753static int
1710netxen_nic_pci_mem_read_128M(struct netxen_adapter *adapter, 1754netxen_nic_pci_mem_read_128M(struct netxen_adapter *adapter,
1711 u64 off, void *data, int size) 1755 u64 off, void *data, int size)
1712{ 1756{
@@ -1797,7 +1841,7 @@ netxen_nic_pci_mem_read_128M(struct netxen_adapter *adapter,
1797 return 0; 1841 return 0;
1798} 1842}
1799 1843
1800int 1844static int
1801netxen_nic_pci_mem_write_2M(struct netxen_adapter *adapter, 1845netxen_nic_pci_mem_write_2M(struct netxen_adapter *adapter,
1802 u64 off, void *data, int size) 1846 u64 off, void *data, int size)
1803{ 1847{
@@ -1825,8 +1869,8 @@ netxen_nic_pci_mem_write_2M(struct netxen_adapter *adapter,
1825 1869
1826 if ((size != 8) || (off0 != 0)) { 1870 if ((size != 8) || (off0 != 0)) {
1827 for (i = 0; i < loop; i++) { 1871 for (i = 0; i < loop; i++) {
1828 if (adapter->pci_mem_read(adapter, off8 + (i << 3), 1872 if (adapter->pci_mem_read(adapter,
1829 &word[i], 8)) 1873 off8 + (i << 3), &word[i], 8))
1830 return -1; 1874 return -1;
1831 } 1875 }
1832 } 1876 }
@@ -1897,7 +1941,7 @@ netxen_nic_pci_mem_write_2M(struct netxen_adapter *adapter,
1897 return ret; 1941 return ret;
1898} 1942}
1899 1943
1900int 1944static int
1901netxen_nic_pci_mem_read_2M(struct netxen_adapter *adapter, 1945netxen_nic_pci_mem_read_2M(struct netxen_adapter *adapter,
1902 u64 off, void *data, int size) 1946 u64 off, void *data, int size)
1903{ 1947{
@@ -1995,20 +2039,43 @@ netxen_nic_pci_mem_read_2M(struct netxen_adapter *adapter,
1995 return 0; 2039 return 0;
1996} 2040}
1997 2041
1998/* 2042void
1999 * Note : only 32-bit writes! 2043netxen_setup_hwops(struct netxen_adapter *adapter)
2000 */
2001int netxen_nic_pci_write_immediate_2M(struct netxen_adapter *adapter,
2002 u64 off, u32 data)
2003{ 2044{
2004 NXWR32(adapter, off, data); 2045 adapter->init_port = netxen_niu_xg_init_port;
2046 adapter->stop_port = netxen_niu_disable_xg_port;
2005 2047
2006 return 0; 2048 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
2007} 2049 adapter->crb_read = netxen_nic_hw_read_wx_128M,
2050 adapter->crb_write = netxen_nic_hw_write_wx_128M,
2051 adapter->pci_set_window = netxen_nic_pci_set_window_128M,
2052 adapter->pci_mem_read = netxen_nic_pci_mem_read_128M,
2053 adapter->pci_mem_write = netxen_nic_pci_mem_write_128M,
2054 adapter->io_read = netxen_nic_io_read_128M,
2055 adapter->io_write = netxen_nic_io_write_128M,
2056
2057 adapter->macaddr_set = netxen_p2_nic_set_mac_addr;
2058 adapter->set_multi = netxen_p2_nic_set_multi;
2059 adapter->set_mtu = netxen_nic_set_mtu_xgb;
2060 adapter->set_promisc = netxen_p2_nic_set_promisc;
2008 2061
2009u32 netxen_nic_pci_read_immediate_2M(struct netxen_adapter *adapter, u64 off) 2062 } else {
2010{ 2063 adapter->crb_read = netxen_nic_hw_read_wx_2M,
2011 return NXRD32(adapter, off); 2064 adapter->crb_write = netxen_nic_hw_write_wx_2M,
2065 adapter->pci_set_window = netxen_nic_pci_set_window_2M,
2066 adapter->pci_mem_read = netxen_nic_pci_mem_read_2M,
2067 adapter->pci_mem_write = netxen_nic_pci_mem_write_2M,
2068 adapter->io_read = netxen_nic_io_read_2M,
2069 adapter->io_write = netxen_nic_io_write_2M,
2070
2071 adapter->set_mtu = nx_fw_cmd_set_mtu;
2072 adapter->set_promisc = netxen_p3_nic_set_promisc;
2073 adapter->macaddr_set = netxen_p3_nic_set_mac_addr;
2074 adapter->set_multi = netxen_p3_nic_set_multi;
2075
2076 adapter->phy_read = nx_fw_cmd_query_phy;
2077 adapter->phy_write = nx_fw_cmd_set_phy;
2078 }
2012} 2079}
2013 2080
2014int netxen_nic_get_board_info(struct netxen_adapter *adapter) 2081int netxen_nic_get_board_info(struct netxen_adapter *adapter)
@@ -2173,65 +2240,6 @@ void netxen_nic_set_link_parameters(struct netxen_adapter *adapter)
2173 } 2240 }
2174} 2241}
2175 2242
2176void netxen_nic_get_firmware_info(struct netxen_adapter *adapter)
2177{
2178 u32 fw_major, fw_minor, fw_build;
2179 char brd_name[NETXEN_MAX_SHORT_NAME];
2180 char serial_num[32];
2181 int i, offset, val;
2182 int *ptr32;
2183 struct pci_dev *pdev = adapter->pdev;
2184
2185 adapter->driver_mismatch = 0;
2186
2187 ptr32 = (int *)&serial_num;
2188 offset = NX_FW_SERIAL_NUM_OFFSET;
2189 for (i = 0; i < 8; i++) {
2190 if (netxen_rom_fast_read(adapter, offset, &val) == -1) {
2191 dev_err(&pdev->dev, "error reading board info\n");
2192 adapter->driver_mismatch = 1;
2193 return;
2194 }
2195 ptr32[i] = cpu_to_le32(val);
2196 offset += sizeof(u32);
2197 }
2198
2199 fw_major = NXRD32(adapter, NETXEN_FW_VERSION_MAJOR);
2200 fw_minor = NXRD32(adapter, NETXEN_FW_VERSION_MINOR);
2201 fw_build = NXRD32(adapter, NETXEN_FW_VERSION_SUB);
2202
2203 adapter->fw_version = NETXEN_VERSION_CODE(fw_major, fw_minor, fw_build);
2204
2205 if (adapter->portnum == 0) {
2206 get_brd_name_by_type(adapter->ahw.board_type, brd_name);
2207
2208 printk(KERN_INFO "NetXen %s Board S/N %s Chip rev 0x%x\n",
2209 brd_name, serial_num, adapter->ahw.revision_id);
2210 }
2211
2212 if (adapter->fw_version < NETXEN_VERSION_CODE(3, 4, 216)) {
2213 adapter->driver_mismatch = 1;
2214 dev_warn(&pdev->dev, "firmware version %d.%d.%d unsupported\n",
2215 fw_major, fw_minor, fw_build);
2216 return;
2217 }
2218
2219 dev_info(&pdev->dev, "firmware version %d.%d.%d\n",
2220 fw_major, fw_minor, fw_build);
2221
2222 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
2223 i = NXRD32(adapter, NETXEN_SRE_MISC);
2224 adapter->ahw.cut_through = (i & 0x8000) ? 1 : 0;
2225 dev_info(&pdev->dev, "firmware running in %s mode\n",
2226 adapter->ahw.cut_through ? "cut-through" : "legacy");
2227 }
2228
2229 if (adapter->fw_version >= NETXEN_VERSION_CODE(4, 0, 222))
2230 adapter->capabilities = NXRD32(adapter, CRB_FW_CAPABILITIES_1);
2231
2232 adapter->flags &= ~NETXEN_NIC_LRO_ENABLED;
2233}
2234
2235int 2243int
2236netxen_nic_wol_supported(struct netxen_adapter *adapter) 2244netxen_nic_wol_supported(struct netxen_adapter *adapter)
2237{ 2245{
diff --git a/drivers/net/netxen/netxen_nic_init.c b/drivers/net/netxen/netxen_nic_init.c
index 04e36f2b1a93..485b947932a1 100644
--- a/drivers/net/netxen/netxen_nic_init.c
+++ b/drivers/net/netxen/netxen_nic_init.c
@@ -323,29 +323,6 @@ err_out:
323 return -ENOMEM; 323 return -ENOMEM;
324} 324}
325 325
326void netxen_initialize_adapter_ops(struct netxen_adapter *adapter)
327{
328 adapter->init_port = netxen_niu_xg_init_port;
329 adapter->stop_port = netxen_niu_disable_xg_port;
330
331 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
332 adapter->macaddr_set = netxen_p2_nic_set_mac_addr;
333 adapter->set_multi = netxen_p2_nic_set_multi;
334 adapter->set_mtu = netxen_nic_set_mtu_xgb;
335 adapter->set_promisc = netxen_p2_nic_set_promisc;
336 } else {
337 adapter->set_mtu = nx_fw_cmd_set_mtu;
338 adapter->set_promisc = netxen_p3_nic_set_promisc;
339 adapter->macaddr_set = netxen_p3_nic_set_mac_addr;
340 adapter->set_multi = netxen_p3_nic_set_multi;
341
342 if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
343 adapter->phy_read = nx_fw_cmd_query_phy;
344 adapter->phy_write = nx_fw_cmd_set_phy;
345 }
346 }
347}
348
349/* 326/*
350 * netxen_decode_crb_addr(0 - utility to translate from internal Phantom CRB 327 * netxen_decode_crb_addr(0 - utility to translate from internal Phantom CRB
351 * address to external PCI CRB address. 328 * address to external PCI CRB address.
@@ -905,6 +882,7 @@ netxen_release_firmware(struct netxen_adapter *adapter)
905{ 882{
906 if (adapter->fw) 883 if (adapter->fw)
907 release_firmware(adapter->fw); 884 release_firmware(adapter->fw);
885 adapter->fw = NULL;
908} 886}
909 887
910int netxen_init_dummy_dma(struct netxen_adapter *adapter) 888int netxen_init_dummy_dma(struct netxen_adapter *adapter)
@@ -1394,7 +1372,7 @@ skip:
1394 1372
1395 if (count) { 1373 if (count) {
1396 sds_ring->consumer = consumer; 1374 sds_ring->consumer = consumer;
1397 NXWR32(adapter, sds_ring->crb_sts_consumer, consumer); 1375 NXWRIO(adapter, sds_ring->crb_sts_consumer, consumer);
1398 } 1376 }
1399 1377
1400 return count; 1378 return count;
@@ -1512,7 +1490,7 @@ netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ringid,
1512 1490
1513 if (count) { 1491 if (count) {
1514 rds_ring->producer = producer; 1492 rds_ring->producer = producer;
1515 NXWR32(adapter, rds_ring->crb_rcv_producer, 1493 NXWRIO(adapter, rds_ring->crb_rcv_producer,
1516 (producer-1) & (rds_ring->num_desc-1)); 1494 (producer-1) & (rds_ring->num_desc-1));
1517 1495
1518 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) { 1496 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
@@ -1528,9 +1506,10 @@ netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ringid,
1528 (rds_ring->num_desc - 1))); 1506 (rds_ring->num_desc - 1)));
1529 netxen_set_msg_ctxid(msg, adapter->portnum); 1507 netxen_set_msg_ctxid(msg, adapter->portnum);
1530 netxen_set_msg_opcode(msg, NETXEN_RCV_PRODUCER(ringid)); 1508 netxen_set_msg_opcode(msg, NETXEN_RCV_PRODUCER(ringid));
1531 writel(msg, 1509 read_lock(&adapter->adapter_lock);
1532 DB_NORMALIZE(adapter, 1510 writel(msg, DB_NORMALIZE(adapter,
1533 NETXEN_RCV_PRODUCER_OFFSET)); 1511 NETXEN_RCV_PRODUCER_OFFSET));
1512 read_unlock(&adapter->adapter_lock);
1534 } 1513 }
1535 } 1514 }
1536} 1515}
@@ -1572,7 +1551,7 @@ netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
1572 1551
1573 if (count) { 1552 if (count) {
1574 rds_ring->producer = producer; 1553 rds_ring->producer = producer;
1575 NXWR32(adapter, rds_ring->crb_rcv_producer, 1554 NXWRIO(adapter, rds_ring->crb_rcv_producer,
1576 (producer - 1) & (rds_ring->num_desc - 1)); 1555 (producer - 1) & (rds_ring->num_desc - 1));
1577 } 1556 }
1578 spin_unlock(&rds_ring->lock); 1557 spin_unlock(&rds_ring->lock);
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index 41b29671fc9a..304618aa09dd 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -67,7 +67,10 @@ static netdev_tx_t netxen_nic_xmit_frame(struct sk_buff *,
67 struct net_device *); 67 struct net_device *);
68static void netxen_tx_timeout(struct net_device *netdev); 68static void netxen_tx_timeout(struct net_device *netdev);
69static void netxen_reset_task(struct work_struct *work); 69static void netxen_reset_task(struct work_struct *work);
70static void netxen_watchdog(unsigned long); 70static void netxen_fw_poll_work(struct work_struct *work);
71static void netxen_schedule_work(struct netxen_adapter *adapter,
72 work_func_t func, int delay);
73static void netxen_cancel_fw_work(struct netxen_adapter *adapter);
71static int netxen_nic_poll(struct napi_struct *napi, int budget); 74static int netxen_nic_poll(struct napi_struct *napi, int budget);
72#ifdef CONFIG_NET_POLL_CONTROLLER 75#ifdef CONFIG_NET_POLL_CONTROLLER
73static void netxen_nic_poll_controller(struct net_device *netdev); 76static void netxen_nic_poll_controller(struct net_device *netdev);
@@ -76,10 +79,15 @@ static void netxen_nic_poll_controller(struct net_device *netdev);
76static void netxen_create_sysfs_entries(struct netxen_adapter *adapter); 79static void netxen_create_sysfs_entries(struct netxen_adapter *adapter);
77static void netxen_remove_sysfs_entries(struct netxen_adapter *adapter); 80static void netxen_remove_sysfs_entries(struct netxen_adapter *adapter);
78 81
82static int nx_decr_dev_ref_cnt(struct netxen_adapter *adapter);
83static int netxen_can_start_firmware(struct netxen_adapter *adapter);
84
79static irqreturn_t netxen_intr(int irq, void *data); 85static irqreturn_t netxen_intr(int irq, void *data);
80static irqreturn_t netxen_msi_intr(int irq, void *data); 86static irqreturn_t netxen_msi_intr(int irq, void *data);
81static irqreturn_t netxen_msix_intr(int irq, void *data); 87static irqreturn_t netxen_msix_intr(int irq, void *data);
82 88
89static void netxen_config_indev_addr(struct net_device *dev, unsigned long);
90
83/* PCI Device ID Table */ 91/* PCI Device ID Table */
84#define ENTRY(device) \ 92#define ENTRY(device) \
85 {PCI_DEVICE(PCI_VENDOR_ID_NETXEN, (device)), \ 93 {PCI_DEVICE(PCI_VENDOR_ID_NETXEN, (device)), \
@@ -108,7 +116,7 @@ void
108netxen_nic_update_cmd_producer(struct netxen_adapter *adapter, 116netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
109 struct nx_host_tx_ring *tx_ring) 117 struct nx_host_tx_ring *tx_ring)
110{ 118{
111 NXWR32(adapter, tx_ring->crb_cmd_producer, tx_ring->producer); 119 NXWRIO(adapter, tx_ring->crb_cmd_producer, tx_ring->producer);
112 120
113 if (netxen_tx_avail(tx_ring) <= TX_STOP_THRESH) { 121 if (netxen_tx_avail(tx_ring) <= TX_STOP_THRESH) {
114 netif_stop_queue(adapter->netdev); 122 netif_stop_queue(adapter->netdev);
@@ -125,7 +133,7 @@ static inline void
125netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter, 133netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
126 struct nx_host_tx_ring *tx_ring) 134 struct nx_host_tx_ring *tx_ring)
127{ 135{
128 NXWR32(adapter, tx_ring->crb_cmd_consumer, tx_ring->sw_consumer); 136 NXWRIO(adapter, tx_ring->crb_cmd_consumer, tx_ring->sw_consumer);
129} 137}
130 138
131static uint32_t msi_tgt_status[8] = { 139static uint32_t msi_tgt_status[8] = {
@@ -141,18 +149,17 @@ static inline void netxen_nic_disable_int(struct nx_host_sds_ring *sds_ring)
141{ 149{
142 struct netxen_adapter *adapter = sds_ring->adapter; 150 struct netxen_adapter *adapter = sds_ring->adapter;
143 151
144 NXWR32(adapter, sds_ring->crb_intr_mask, 0); 152 NXWRIO(adapter, sds_ring->crb_intr_mask, 0);
145} 153}
146 154
147static inline void netxen_nic_enable_int(struct nx_host_sds_ring *sds_ring) 155static inline void netxen_nic_enable_int(struct nx_host_sds_ring *sds_ring)
148{ 156{
149 struct netxen_adapter *adapter = sds_ring->adapter; 157 struct netxen_adapter *adapter = sds_ring->adapter;
150 158
151 NXWR32(adapter, sds_ring->crb_intr_mask, 0x1); 159 NXWRIO(adapter, sds_ring->crb_intr_mask, 0x1);
152 160
153 if (!NETXEN_IS_MSI_FAMILY(adapter)) 161 if (!NETXEN_IS_MSI_FAMILY(adapter))
154 adapter->pci_write_immediate(adapter, 162 NXWRIO(adapter, adapter->tgt_mask_reg, 0xfbff);
155 adapter->legacy_intr.tgt_mask_reg, 0xfbff);
156} 163}
157 164
158static int 165static int
@@ -311,44 +318,6 @@ err_out:
311 return err; 318 return err;
312} 319}
313 320
314static void
315netxen_check_options(struct netxen_adapter *adapter)
316{
317 if (adapter->ahw.port_type == NETXEN_NIC_XGBE) {
318 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
319 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
320 } else if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
321 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
322 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
323 }
324
325 adapter->msix_supported = 0;
326 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
327 adapter->msix_supported = !!use_msi_x;
328 adapter->rss_supported = !!use_msi_x;
329 } else if (adapter->fw_version >= NETXEN_VERSION_CODE(3, 4, 336)) {
330 switch (adapter->ahw.board_type) {
331 case NETXEN_BRDTYPE_P2_SB31_10G:
332 case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
333 adapter->msix_supported = !!use_msi_x;
334 adapter->rss_supported = !!use_msi_x;
335 break;
336 default:
337 break;
338 }
339 }
340
341 adapter->num_txd = MAX_CMD_DESCRIPTORS;
342
343 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
344 adapter->num_lro_rxd = MAX_LRO_RCV_DESCRIPTORS;
345 adapter->max_rds_rings = 3;
346 } else {
347 adapter->num_lro_rxd = 0;
348 adapter->max_rds_rings = 2;
349 }
350}
351
352static int 321static int
353netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot) 322netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot)
354{ 323{
@@ -548,10 +517,22 @@ netxen_setup_intr(struct netxen_adapter *adapter)
548 legacy_intrp = &legacy_intr[adapter->ahw.pci_func]; 517 legacy_intrp = &legacy_intr[adapter->ahw.pci_func];
549 else 518 else
550 legacy_intrp = &legacy_intr[0]; 519 legacy_intrp = &legacy_intr[0];
551 adapter->legacy_intr.int_vec_bit = legacy_intrp->int_vec_bit; 520
552 adapter->legacy_intr.tgt_status_reg = legacy_intrp->tgt_status_reg; 521 adapter->int_vec_bit = legacy_intrp->int_vec_bit;
553 adapter->legacy_intr.tgt_mask_reg = legacy_intrp->tgt_mask_reg; 522 adapter->tgt_status_reg = netxen_get_ioaddr(adapter,
554 adapter->legacy_intr.pci_int_reg = legacy_intrp->pci_int_reg; 523 legacy_intrp->tgt_status_reg);
524 adapter->tgt_mask_reg = netxen_get_ioaddr(adapter,
525 legacy_intrp->tgt_mask_reg);
526 adapter->pci_int_reg = netxen_get_ioaddr(adapter,
527 legacy_intrp->pci_int_reg);
528 adapter->isr_int_vec = netxen_get_ioaddr(adapter, ISR_INT_VECTOR);
529
530 if (adapter->ahw.revision_id >= NX_P3_B1)
531 adapter->crb_int_state_reg = netxen_get_ioaddr(adapter,
532 ISR_INT_STATE_REG);
533 else
534 adapter->crb_int_state_reg = netxen_get_ioaddr(adapter,
535 CRB_INT_VECTOR);
555 536
556 netxen_set_msix_bit(pdev, 0); 537 netxen_set_msix_bit(pdev, 0);
557 538
@@ -578,8 +559,8 @@ netxen_setup_intr(struct netxen_adapter *adapter)
578 559
579 if (use_msi && !pci_enable_msi(pdev)) { 560 if (use_msi && !pci_enable_msi(pdev)) {
580 adapter->flags |= NETXEN_NIC_MSI_ENABLED; 561 adapter->flags |= NETXEN_NIC_MSI_ENABLED;
581 adapter->msi_tgt_status = 562 adapter->tgt_status_reg = netxen_get_ioaddr(adapter,
582 msi_tgt_status[adapter->ahw.pci_func]; 563 msi_tgt_status[adapter->ahw.pci_func]);
583 dev_info(&pdev->dev, "using msi interrupts\n"); 564 dev_info(&pdev->dev, "using msi interrupts\n");
584 adapter->msix_entries[0].vector = pdev->irq; 565 adapter->msix_entries[0].vector = pdev->irq;
585 return; 566 return;
@@ -639,14 +620,6 @@ netxen_setup_pci_map(struct netxen_adapter *adapter)
639 mem_len = pci_resource_len(pdev, 0); 620 mem_len = pci_resource_len(pdev, 0);
640 pci_len0 = 0; 621 pci_len0 = 0;
641 622
642 adapter->hw_write_wx = netxen_nic_hw_write_wx_128M;
643 adapter->hw_read_wx = netxen_nic_hw_read_wx_128M;
644 adapter->pci_read_immediate = netxen_nic_pci_read_immediate_128M;
645 adapter->pci_write_immediate = netxen_nic_pci_write_immediate_128M;
646 adapter->pci_set_window = netxen_nic_pci_set_window_128M;
647 adapter->pci_mem_read = netxen_nic_pci_mem_read_128M;
648 adapter->pci_mem_write = netxen_nic_pci_mem_write_128M;
649
650 /* 128 Meg of memory */ 623 /* 128 Meg of memory */
651 if (mem_len == NETXEN_PCI_128MB_SIZE) { 624 if (mem_len == NETXEN_PCI_128MB_SIZE) {
652 mem_ptr0 = ioremap(mem_base, FIRST_PAGE_GROUP_SIZE); 625 mem_ptr0 = ioremap(mem_base, FIRST_PAGE_GROUP_SIZE);
@@ -659,14 +632,6 @@ netxen_setup_pci_map(struct netxen_adapter *adapter)
659 mem_ptr2 = ioremap(mem_base + THIRD_PAGE_GROUP_START - 632 mem_ptr2 = ioremap(mem_base + THIRD_PAGE_GROUP_START -
660 SECOND_PAGE_GROUP_START, THIRD_PAGE_GROUP_SIZE); 633 SECOND_PAGE_GROUP_START, THIRD_PAGE_GROUP_SIZE);
661 } else if (mem_len == NETXEN_PCI_2MB_SIZE) { 634 } else if (mem_len == NETXEN_PCI_2MB_SIZE) {
662 adapter->hw_write_wx = netxen_nic_hw_write_wx_2M;
663 adapter->hw_read_wx = netxen_nic_hw_read_wx_2M;
664 adapter->pci_read_immediate = netxen_nic_pci_read_immediate_2M;
665 adapter->pci_write_immediate =
666 netxen_nic_pci_write_immediate_2M;
667 adapter->pci_set_window = netxen_nic_pci_set_window_2M;
668 adapter->pci_mem_read = netxen_nic_pci_mem_read_2M;
669 adapter->pci_mem_write = netxen_nic_pci_mem_write_2M;
670 635
671 mem_ptr0 = pci_ioremap_bar(pdev, 0); 636 mem_ptr0 = pci_ioremap_bar(pdev, 0);
672 if (mem_ptr0 == NULL) { 637 if (mem_ptr0 == NULL) {
@@ -690,6 +655,8 @@ netxen_setup_pci_map(struct netxen_adapter *adapter)
690 return -EIO; 655 return -EIO;
691 } 656 }
692 657
658 netxen_setup_hwops(adapter);
659
693 dev_info(&pdev->dev, "%dMB memory map\n", (int)(mem_len>>20)); 660 dev_info(&pdev->dev, "%dMB memory map\n", (int)(mem_len>>20));
694 661
695 adapter->ahw.pci_base0 = mem_ptr0; 662 adapter->ahw.pci_base0 = mem_ptr0;
@@ -728,20 +695,111 @@ err_out:
728 return err; 695 return err;
729} 696}
730 697
698static void
699netxen_check_options(struct netxen_adapter *adapter)
700{
701 u32 fw_major, fw_minor, fw_build;
702 char brd_name[NETXEN_MAX_SHORT_NAME];
703 char serial_num[32];
704 int i, offset, val;
705 int *ptr32;
706 struct pci_dev *pdev = adapter->pdev;
707
708 adapter->driver_mismatch = 0;
709
710 ptr32 = (int *)&serial_num;
711 offset = NX_FW_SERIAL_NUM_OFFSET;
712 for (i = 0; i < 8; i++) {
713 if (netxen_rom_fast_read(adapter, offset, &val) == -1) {
714 dev_err(&pdev->dev, "error reading board info\n");
715 adapter->driver_mismatch = 1;
716 return;
717 }
718 ptr32[i] = cpu_to_le32(val);
719 offset += sizeof(u32);
720 }
721
722 fw_major = NXRD32(adapter, NETXEN_FW_VERSION_MAJOR);
723 fw_minor = NXRD32(adapter, NETXEN_FW_VERSION_MINOR);
724 fw_build = NXRD32(adapter, NETXEN_FW_VERSION_SUB);
725
726 adapter->fw_version = NETXEN_VERSION_CODE(fw_major, fw_minor, fw_build);
727
728 if (adapter->portnum == 0) {
729 get_brd_name_by_type(adapter->ahw.board_type, brd_name);
730
731 printk(KERN_INFO "NetXen %s Board S/N %s Chip rev 0x%x\n",
732 brd_name, serial_num, adapter->ahw.revision_id);
733 }
734
735 if (adapter->fw_version < NETXEN_VERSION_CODE(3, 4, 216)) {
736 adapter->driver_mismatch = 1;
737 dev_warn(&pdev->dev, "firmware version %d.%d.%d unsupported\n",
738 fw_major, fw_minor, fw_build);
739 return;
740 }
741
742 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
743 i = NXRD32(adapter, NETXEN_SRE_MISC);
744 adapter->ahw.cut_through = (i & 0x8000) ? 1 : 0;
745 }
746
747 dev_info(&pdev->dev, "firmware v%d.%d.%d [%s]\n",
748 fw_major, fw_minor, fw_build,
749 adapter->ahw.cut_through ? "cut-through" : "legacy");
750
751 if (adapter->fw_version >= NETXEN_VERSION_CODE(4, 0, 222))
752 adapter->capabilities = NXRD32(adapter, CRB_FW_CAPABILITIES_1);
753
754 adapter->flags &= ~NETXEN_NIC_LRO_ENABLED;
755
756 if (adapter->ahw.port_type == NETXEN_NIC_XGBE) {
757 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
758 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
759 } else if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
760 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
761 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
762 }
763
764 adapter->msix_supported = 0;
765 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
766 adapter->msix_supported = !!use_msi_x;
767 adapter->rss_supported = !!use_msi_x;
768 } else if (adapter->fw_version >= NETXEN_VERSION_CODE(3, 4, 336)) {
769 switch (adapter->ahw.board_type) {
770 case NETXEN_BRDTYPE_P2_SB31_10G:
771 case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
772 adapter->msix_supported = !!use_msi_x;
773 adapter->rss_supported = !!use_msi_x;
774 break;
775 default:
776 break;
777 }
778 }
779
780 adapter->num_txd = MAX_CMD_DESCRIPTORS;
781
782 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
783 adapter->num_lro_rxd = MAX_LRO_RCV_DESCRIPTORS;
784 adapter->max_rds_rings = 3;
785 } else {
786 adapter->num_lro_rxd = 0;
787 adapter->max_rds_rings = 2;
788 }
789}
790
731static int 791static int
732netxen_start_firmware(struct netxen_adapter *adapter, int request_fw) 792netxen_start_firmware(struct netxen_adapter *adapter)
733{ 793{
734 int val, err, first_boot; 794 int val, err, first_boot;
735 struct pci_dev *pdev = adapter->pdev; 795 struct pci_dev *pdev = adapter->pdev;
736 796
737 int first_driver = 0; 797 /* required for NX2031 dummy dma */
738 798 err = nx_set_dma_mask(adapter);
739 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) 799 if (err)
740 first_driver = (adapter->portnum == 0); 800 return err;
741 else
742 first_driver = (adapter->ahw.pci_func == 0);
743 801
744 if (!first_driver) 802 if (!netxen_can_start_firmware(adapter))
745 goto wait_init; 803 goto wait_init;
746 804
747 first_boot = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc)); 805 first_boot = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
@@ -752,12 +810,11 @@ netxen_start_firmware(struct netxen_adapter *adapter, int request_fw)
752 return err; 810 return err;
753 } 811 }
754 812
755 if (request_fw) 813 netxen_request_firmware(adapter);
756 netxen_request_firmware(adapter);
757 814
758 err = netxen_need_fw_reset(adapter); 815 err = netxen_need_fw_reset(adapter);
759 if (err < 0) 816 if (err < 0)
760 return err; 817 goto err_out;
761 if (err == 0) 818 if (err == 0)
762 goto wait_init; 819 goto wait_init;
763 820
@@ -768,10 +825,17 @@ netxen_start_firmware(struct netxen_adapter *adapter, int request_fw)
768 } 825 }
769 826
770 NXWR32(adapter, CRB_DMA_SHIFT, 0x55555555); 827 NXWR32(adapter, CRB_DMA_SHIFT, 0x55555555);
828 NXWR32(adapter, NETXEN_PEG_HALT_STATUS1, 0);
829 NXWR32(adapter, NETXEN_PEG_HALT_STATUS2, 0);
830
771 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) 831 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
772 netxen_set_port_mode(adapter); 832 netxen_set_port_mode(adapter);
773 833
774 netxen_load_firmware(adapter); 834 err = netxen_load_firmware(adapter);
835 if (err)
836 goto err_out;
837
838 netxen_release_firmware(adapter);
775 839
776 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) { 840 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
777 841
@@ -785,7 +849,7 @@ netxen_start_firmware(struct netxen_adapter *adapter, int request_fw)
785 849
786 err = netxen_init_dummy_dma(adapter); 850 err = netxen_init_dummy_dma(adapter);
787 if (err) 851 if (err)
788 return err; 852 goto err_out;
789 853
790 /* 854 /*
791 * Tell the hardware our version number. 855 * Tell the hardware our version number.
@@ -795,19 +859,25 @@ netxen_start_firmware(struct netxen_adapter *adapter, int request_fw)
795 | (_NETXEN_NIC_LINUX_SUBVERSION); 859 | (_NETXEN_NIC_LINUX_SUBVERSION);
796 NXWR32(adapter, CRB_DRIVER_VERSION, val); 860 NXWR32(adapter, CRB_DRIVER_VERSION, val);
797 861
862 NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_READY);
863
798wait_init: 864wait_init:
799 /* Handshake with the card before we register the devices. */ 865 /* Handshake with the card before we register the devices. */
800 err = netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE); 866 err = netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
801 if (err) { 867 if (err) {
802 netxen_free_dummy_dma(adapter); 868 netxen_free_dummy_dma(adapter);
803 return err; 869 goto err_out;
804 } 870 }
805 871
806 nx_update_dma_mask(adapter); 872 nx_update_dma_mask(adapter);
807 873
808 netxen_nic_get_firmware_info(adapter); 874 netxen_check_options(adapter);
809 875
810 return 0; 876 return 0;
877
878err_out:
879 netxen_release_firmware(adapter);
880 return err;
811} 881}
812 882
813static int 883static int
@@ -876,6 +946,9 @@ netxen_nic_up(struct netxen_adapter *adapter, struct net_device *netdev)
876{ 946{
877 int err; 947 int err;
878 948
949 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
950 return -EIO;
951
879 err = adapter->init_port(adapter, adapter->physical_port); 952 err = adapter->init_port(adapter, adapter->physical_port);
880 if (err) { 953 if (err) {
881 printk(KERN_ERR "%s: Failed to initialize port %d\n", 954 printk(KERN_ERR "%s: Failed to initialize port %d\n",
@@ -906,14 +979,18 @@ netxen_nic_up(struct netxen_adapter *adapter, struct net_device *netdev)
906 else 979 else
907 netxen_nic_set_link_parameters(adapter); 980 netxen_nic_set_link_parameters(adapter);
908 981
909 mod_timer(&adapter->watchdog_timer, jiffies); 982 set_bit(__NX_DEV_UP, &adapter->state);
910
911 return 0; 983 return 0;
912} 984}
913 985
914static void 986static void
915netxen_nic_down(struct netxen_adapter *adapter, struct net_device *netdev) 987netxen_nic_down(struct netxen_adapter *adapter, struct net_device *netdev)
916{ 988{
989 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
990 return;
991
992 clear_bit(__NX_DEV_UP, &adapter->state);
993
917 spin_lock(&adapter->tx_clean_lock); 994 spin_lock(&adapter->tx_clean_lock);
918 netif_carrier_off(netdev); 995 netif_carrier_off(netdev);
919 netif_tx_disable(netdev); 996 netif_tx_disable(netdev);
@@ -930,8 +1007,6 @@ netxen_nic_down(struct netxen_adapter *adapter, struct net_device *netdev)
930 1007
931 netxen_release_tx_buffers(adapter); 1008 netxen_release_tx_buffers(adapter);
932 spin_unlock(&adapter->tx_clean_lock); 1009 spin_unlock(&adapter->tx_clean_lock);
933
934 del_timer_sync(&adapter->watchdog_timer);
935} 1010}
936 1011
937 1012
@@ -962,8 +1037,6 @@ netxen_nic_attach(struct netxen_adapter *adapter)
962 return err; 1037 return err;
963 } 1038 }
964 1039
965 netxen_nic_clear_stats(adapter);
966
967 err = netxen_alloc_hw_resources(adapter); 1040 err = netxen_alloc_hw_resources(adapter);
968 if (err) { 1041 if (err) {
969 printk(KERN_ERR "%s: Error in setting hw resources\n", 1042 printk(KERN_ERR "%s: Error in setting hw resources\n",
@@ -973,8 +1046,10 @@ netxen_nic_attach(struct netxen_adapter *adapter)
973 1046
974 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) { 1047 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
975 tx_ring = adapter->tx_ring; 1048 tx_ring = adapter->tx_ring;
976 tx_ring->crb_cmd_producer = crb_cmd_producer[adapter->portnum]; 1049 tx_ring->crb_cmd_producer = netxen_get_ioaddr(adapter,
977 tx_ring->crb_cmd_consumer = crb_cmd_consumer[adapter->portnum]; 1050 crb_cmd_producer[adapter->portnum]);
1051 tx_ring->crb_cmd_consumer = netxen_get_ioaddr(adapter,
1052 crb_cmd_consumer[adapter->portnum]);
978 1053
979 tx_ring->producer = 0; 1054 tx_ring->producer = 0;
980 tx_ring->sw_consumer = 0; 1055 tx_ring->sw_consumer = 0;
@@ -1034,21 +1109,32 @@ netxen_nic_reset_context(struct netxen_adapter *adapter)
1034 int err = 0; 1109 int err = 0;
1035 struct net_device *netdev = adapter->netdev; 1110 struct net_device *netdev = adapter->netdev;
1036 1111
1112 if (test_and_set_bit(__NX_RESETTING, &adapter->state))
1113 return -EBUSY;
1114
1037 if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC) { 1115 if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC) {
1038 1116
1117 netif_device_detach(netdev);
1118
1039 if (netif_running(netdev)) 1119 if (netif_running(netdev))
1040 netxen_nic_down(adapter, netdev); 1120 netxen_nic_down(adapter, netdev);
1041 1121
1042 netxen_nic_detach(adapter); 1122 netxen_nic_detach(adapter);
1043 1123
1044 err = netxen_nic_attach(adapter); 1124 if (netif_running(netdev)) {
1045 if (err) 1125 err = netxen_nic_attach(adapter);
1046 goto done; 1126 if (!err)
1127 err = netxen_nic_up(adapter, netdev);
1047 1128
1048 if (netif_running(netdev)) 1129 if (err)
1049 err = netxen_nic_up(adapter, netdev); 1130 goto done;
1131 }
1132
1133 netif_device_attach(netdev);
1050 } 1134 }
1135
1051done: 1136done:
1137 clear_bit(__NX_RESETTING, &adapter->state);
1052 return err; 1138 return err;
1053} 1139}
1054 1140
@@ -1095,10 +1181,6 @@ netxen_setup_netdev(struct netxen_adapter *adapter,
1095 1181
1096 netdev->irq = adapter->msix_entries[0].vector; 1182 netdev->irq = adapter->msix_entries[0].vector;
1097 1183
1098 init_timer(&adapter->watchdog_timer);
1099 adapter->watchdog_timer.function = &netxen_watchdog;
1100 adapter->watchdog_timer.data = (unsigned long)adapter;
1101 INIT_WORK(&adapter->watchdog_task, netxen_watchdog_task);
1102 INIT_WORK(&adapter->tx_timeout_task, netxen_reset_task); 1184 INIT_WORK(&adapter->tx_timeout_task, netxen_reset_task);
1103 1185
1104 if (netxen_read_mac_addr(adapter)) 1186 if (netxen_read_mac_addr(adapter))
@@ -1168,10 +1250,6 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1168 revision_id = pdev->revision; 1250 revision_id = pdev->revision;
1169 adapter->ahw.revision_id = revision_id; 1251 adapter->ahw.revision_id = revision_id;
1170 1252
1171 err = nx_set_dma_mask(adapter);
1172 if (err)
1173 goto err_out_free_netdev;
1174
1175 rwlock_init(&adapter->adapter_lock); 1253 rwlock_init(&adapter->adapter_lock);
1176 spin_lock_init(&adapter->tx_clean_lock); 1254 spin_lock_init(&adapter->tx_clean_lock);
1177 INIT_LIST_HEAD(&adapter->mac_list); 1255 INIT_LIST_HEAD(&adapter->mac_list);
@@ -1189,8 +1267,6 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1189 goto err_out_iounmap; 1267 goto err_out_iounmap;
1190 } 1268 }
1191 1269
1192 netxen_initialize_adapter_ops(adapter);
1193
1194 /* Mezz cards have PCI function 0,2,3 enabled */ 1270 /* Mezz cards have PCI function 0,2,3 enabled */
1195 switch (adapter->ahw.board_type) { 1271 switch (adapter->ahw.board_type) {
1196 case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ: 1272 case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
@@ -1202,7 +1278,7 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1202 break; 1278 break;
1203 } 1279 }
1204 1280
1205 err = netxen_start_firmware(adapter, 1); 1281 err = netxen_start_firmware(adapter);
1206 if (err) 1282 if (err)
1207 goto err_out_iounmap; 1283 goto err_out_iounmap;
1208 1284
@@ -1216,7 +1292,7 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1216 adapter->physical_port = i; 1292 adapter->physical_port = i;
1217 } 1293 }
1218 1294
1219 netxen_check_options(adapter); 1295 netxen_nic_clear_stats(adapter);
1220 1296
1221 netxen_setup_intr(adapter); 1297 netxen_setup_intr(adapter);
1222 1298
@@ -1226,6 +1302,8 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1226 1302
1227 pci_set_drvdata(pdev, adapter); 1303 pci_set_drvdata(pdev, adapter);
1228 1304
1305 netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
1306
1229 switch (adapter->ahw.port_type) { 1307 switch (adapter->ahw.port_type) {
1230 case NETXEN_NIC_GBE: 1308 case NETXEN_NIC_GBE:
1231 dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n", 1309 dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
@@ -1244,6 +1322,8 @@ err_out_disable_msi:
1244 1322
1245 netxen_free_dummy_dma(adapter); 1323 netxen_free_dummy_dma(adapter);
1246 1324
1325 nx_decr_dev_ref_cnt(adapter);
1326
1247err_out_iounmap: 1327err_out_iounmap:
1248 netxen_cleanup_pci_map(adapter); 1328 netxen_cleanup_pci_map(adapter);
1249 1329
@@ -1270,16 +1350,21 @@ static void __devexit netxen_nic_remove(struct pci_dev *pdev)
1270 1350
1271 netdev = adapter->netdev; 1351 netdev = adapter->netdev;
1272 1352
1353 netxen_cancel_fw_work(adapter);
1354
1273 unregister_netdev(netdev); 1355 unregister_netdev(netdev);
1274 1356
1275 cancel_work_sync(&adapter->watchdog_task);
1276 cancel_work_sync(&adapter->tx_timeout_task); 1357 cancel_work_sync(&adapter->tx_timeout_task);
1277 1358
1278 netxen_nic_detach(adapter); 1359 netxen_nic_detach(adapter);
1279 1360
1361 nx_decr_dev_ref_cnt(adapter);
1362
1280 if (adapter->portnum == 0) 1363 if (adapter->portnum == 0)
1281 netxen_free_dummy_dma(adapter); 1364 netxen_free_dummy_dma(adapter);
1282 1365
1366 clear_bit(__NX_RESETTING, &adapter->state);
1367
1283 netxen_teardown_intr(adapter); 1368 netxen_teardown_intr(adapter);
1284 1369
1285 netxen_cleanup_pci_map(adapter); 1370 netxen_cleanup_pci_map(adapter);
@@ -1300,10 +1385,11 @@ static int __netxen_nic_shutdown(struct pci_dev *pdev)
1300 1385
1301 netif_device_detach(netdev); 1386 netif_device_detach(netdev);
1302 1387
1388 netxen_cancel_fw_work(adapter);
1389
1303 if (netif_running(netdev)) 1390 if (netif_running(netdev))
1304 netxen_nic_down(adapter, netdev); 1391 netxen_nic_down(adapter, netdev);
1305 1392
1306 cancel_work_sync(&adapter->watchdog_task);
1307 cancel_work_sync(&adapter->tx_timeout_task); 1393 cancel_work_sync(&adapter->tx_timeout_task);
1308 1394
1309 netxen_nic_detach(adapter); 1395 netxen_nic_detach(adapter);
@@ -1311,6 +1397,10 @@ static int __netxen_nic_shutdown(struct pci_dev *pdev)
1311 if (adapter->portnum == 0) 1397 if (adapter->portnum == 0)
1312 netxen_free_dummy_dma(adapter); 1398 netxen_free_dummy_dma(adapter);
1313 1399
1400 nx_decr_dev_ref_cnt(adapter);
1401
1402 clear_bit(__NX_RESETTING, &adapter->state);
1403
1314 retval = pci_save_state(pdev); 1404 retval = pci_save_state(pdev);
1315 if (retval) 1405 if (retval)
1316 return retval; 1406 return retval;
@@ -1359,7 +1449,7 @@ netxen_nic_resume(struct pci_dev *pdev)
1359 1449
1360 adapter->curr_window = 255; 1450 adapter->curr_window = 255;
1361 1451
1362 err = netxen_start_firmware(adapter, 0); 1452 err = netxen_start_firmware(adapter);
1363 if (err) { 1453 if (err) {
1364 dev_err(&pdev->dev, "failed to start firmware\n"); 1454 dev_err(&pdev->dev, "failed to start firmware\n");
1365 return err; 1455 return err;
@@ -1368,16 +1458,24 @@ netxen_nic_resume(struct pci_dev *pdev)
1368 if (netif_running(netdev)) { 1458 if (netif_running(netdev)) {
1369 err = netxen_nic_attach(adapter); 1459 err = netxen_nic_attach(adapter);
1370 if (err) 1460 if (err)
1371 return err; 1461 goto err_out;
1372 1462
1373 err = netxen_nic_up(adapter, netdev); 1463 err = netxen_nic_up(adapter, netdev);
1374 if (err) 1464 if (err)
1375 return err; 1465 goto err_out_detach;
1376 1466
1377 netif_device_attach(netdev); 1467 netif_device_attach(netdev);
1468
1469 netxen_config_indev_addr(netdev, NETDEV_UP);
1378 } 1470 }
1379 1471
1380 return 0; 1472 netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
1473
1474err_out_detach:
1475 netxen_nic_detach(adapter);
1476err_out:
1477 nx_decr_dev_ref_cnt(adapter);
1478 return err;
1381} 1479}
1382#endif 1480#endif
1383 1481
@@ -1771,59 +1869,13 @@ static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
1771 netxen_advert_link_change(adapter, linkup); 1869 netxen_advert_link_change(adapter, linkup);
1772} 1870}
1773 1871
1774static void netxen_nic_thermal_shutdown(struct netxen_adapter *adapter)
1775{
1776 struct net_device *netdev = adapter->netdev;
1777
1778 netif_device_detach(netdev);
1779 netxen_nic_down(adapter, netdev);
1780 netxen_nic_detach(adapter);
1781}
1782
1783static void netxen_watchdog(unsigned long v)
1784{
1785 struct netxen_adapter *adapter = (struct netxen_adapter *)v;
1786
1787 if (netxen_nic_check_temp(adapter))
1788 goto do_sched;
1789
1790 if (!adapter->has_link_events) {
1791 netxen_nic_handle_phy_intr(adapter);
1792
1793 if (adapter->link_changed)
1794 goto do_sched;
1795 }
1796
1797 if (netif_running(adapter->netdev))
1798 mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
1799
1800 return;
1801
1802do_sched:
1803 schedule_work(&adapter->watchdog_task);
1804}
1805
1806void netxen_watchdog_task(struct work_struct *work)
1807{
1808 struct netxen_adapter *adapter =
1809 container_of(work, struct netxen_adapter, watchdog_task);
1810
1811 if (adapter->temp == NX_TEMP_PANIC) {
1812 netxen_nic_thermal_shutdown(adapter);
1813 return;
1814 }
1815
1816 if (adapter->link_changed)
1817 netxen_nic_set_link_parameters(adapter);
1818
1819 if (netif_running(adapter->netdev))
1820 mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
1821}
1822
1823static void netxen_tx_timeout(struct net_device *netdev) 1872static void netxen_tx_timeout(struct net_device *netdev)
1824{ 1873{
1825 struct netxen_adapter *adapter = netdev_priv(netdev); 1874 struct netxen_adapter *adapter = netdev_priv(netdev);
1826 1875
1876 if (test_bit(__NX_RESETTING, &adapter->state))
1877 return;
1878
1827 dev_err(&netdev->dev, "transmit timeout, resetting.\n"); 1879 dev_err(&netdev->dev, "transmit timeout, resetting.\n");
1828 schedule_work(&adapter->tx_timeout_task); 1880 schedule_work(&adapter->tx_timeout_task);
1829} 1881}
@@ -1836,6 +1888,9 @@ static void netxen_reset_task(struct work_struct *work)
1836 if (!netif_running(adapter->netdev)) 1888 if (!netif_running(adapter->netdev))
1837 return; 1889 return;
1838 1890
1891 if (test_bit(__NX_RESETTING, &adapter->state))
1892 return;
1893
1839 netxen_napi_disable(adapter); 1894 netxen_napi_disable(adapter);
1840 1895
1841 adapter->netdev->trans_start = jiffies; 1896 adapter->netdev->trans_start = jiffies;
@@ -1867,41 +1922,37 @@ static irqreturn_t netxen_intr(int irq, void *data)
1867 struct netxen_adapter *adapter = sds_ring->adapter; 1922 struct netxen_adapter *adapter = sds_ring->adapter;
1868 u32 status = 0; 1923 u32 status = 0;
1869 1924
1870 status = adapter->pci_read_immediate(adapter, ISR_INT_VECTOR); 1925 status = readl(adapter->isr_int_vec);
1871 1926
1872 if (!(status & adapter->legacy_intr.int_vec_bit)) 1927 if (!(status & adapter->int_vec_bit))
1873 return IRQ_NONE; 1928 return IRQ_NONE;
1874 1929
1875 if (adapter->ahw.revision_id >= NX_P3_B1) { 1930 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
1876 /* check interrupt state machine, to be sure */ 1931 /* check interrupt state machine, to be sure */
1877 status = adapter->pci_read_immediate(adapter, 1932 status = readl(adapter->crb_int_state_reg);
1878 ISR_INT_STATE_REG);
1879 if (!ISR_LEGACY_INT_TRIGGERED(status)) 1933 if (!ISR_LEGACY_INT_TRIGGERED(status))
1880 return IRQ_NONE; 1934 return IRQ_NONE;
1881 1935
1882 } else { 1936 } else {
1883 unsigned long our_int = 0; 1937 unsigned long our_int = 0;
1884 1938
1885 our_int = NXRD32(adapter, CRB_INT_VECTOR); 1939 our_int = readl(adapter->crb_int_state_reg);
1886 1940
1887 /* not our interrupt */ 1941 /* not our interrupt */
1888 if (!test_and_clear_bit((7 + adapter->portnum), &our_int)) 1942 if (!test_and_clear_bit((7 + adapter->portnum), &our_int))
1889 return IRQ_NONE; 1943 return IRQ_NONE;
1890 1944
1891 /* claim interrupt */ 1945 /* claim interrupt */
1892 NXWR32(adapter, CRB_INT_VECTOR, (our_int & 0xffffffff)); 1946 writel((our_int & 0xffffffff), adapter->crb_int_state_reg);
1893 }
1894 1947
1895 /* clear interrupt */ 1948 /* clear interrupt */
1896 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
1897 netxen_nic_disable_int(sds_ring); 1949 netxen_nic_disable_int(sds_ring);
1950 }
1898 1951
1899 adapter->pci_write_immediate(adapter, 1952 writel(0xffffffff, adapter->tgt_status_reg);
1900 adapter->legacy_intr.tgt_status_reg,
1901 0xffffffff);
1902 /* read twice to ensure write is flushed */ 1953 /* read twice to ensure write is flushed */
1903 adapter->pci_read_immediate(adapter, ISR_INT_VECTOR); 1954 readl(adapter->isr_int_vec);
1904 adapter->pci_read_immediate(adapter, ISR_INT_VECTOR); 1955 readl(adapter->isr_int_vec);
1905 1956
1906 napi_schedule(&sds_ring->napi); 1957 napi_schedule(&sds_ring->napi);
1907 1958
@@ -1914,8 +1965,7 @@ static irqreturn_t netxen_msi_intr(int irq, void *data)
1914 struct netxen_adapter *adapter = sds_ring->adapter; 1965 struct netxen_adapter *adapter = sds_ring->adapter;
1915 1966
1916 /* clear interrupt */ 1967 /* clear interrupt */
1917 adapter->pci_write_immediate(adapter, 1968 writel(0xffffffff, adapter->tgt_status_reg);
1918 adapter->msi_tgt_status, 0xffffffff);
1919 1969
1920 napi_schedule(&sds_ring->napi); 1970 napi_schedule(&sds_ring->napi);
1921 return IRQ_HANDLED; 1971 return IRQ_HANDLED;
@@ -1962,6 +2012,240 @@ static void netxen_nic_poll_controller(struct net_device *netdev)
1962} 2012}
1963#endif 2013#endif
1964 2014
2015static int
2016nx_incr_dev_ref_cnt(struct netxen_adapter *adapter)
2017{
2018 int count;
2019 if (netxen_api_lock(adapter))
2020 return -EIO;
2021
2022 count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2023
2024 NXWR32(adapter, NX_CRB_DEV_REF_COUNT, ++count);
2025
2026 netxen_api_unlock(adapter);
2027 return count;
2028}
2029
2030static int
2031nx_decr_dev_ref_cnt(struct netxen_adapter *adapter)
2032{
2033 int count;
2034 if (netxen_api_lock(adapter))
2035 return -EIO;
2036
2037 count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2038 WARN_ON(count == 0);
2039
2040 NXWR32(adapter, NX_CRB_DEV_REF_COUNT, --count);
2041
2042 if (count == 0)
2043 NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_COLD);
2044
2045 netxen_api_unlock(adapter);
2046 return count;
2047}
2048
2049static int
2050netxen_can_start_firmware(struct netxen_adapter *adapter)
2051{
2052 int count;
2053 int can_start = 0;
2054
2055 if (netxen_api_lock(adapter))
2056 return 0;
2057
2058 count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2059
2060 if ((count < 0) || (count >= NX_MAX_PCI_FUNC))
2061 count = 0;
2062
2063 if (count == 0) {
2064 can_start = 1;
2065 NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_INITALIZING);
2066 }
2067
2068 NXWR32(adapter, NX_CRB_DEV_REF_COUNT, ++count);
2069
2070 netxen_api_unlock(adapter);
2071
2072 return can_start;
2073}
2074
2075static void
2076netxen_schedule_work(struct netxen_adapter *adapter,
2077 work_func_t func, int delay)
2078{
2079 INIT_DELAYED_WORK(&adapter->fw_work, func);
2080 schedule_delayed_work(&adapter->fw_work, delay);
2081}
2082
2083static void
2084netxen_cancel_fw_work(struct netxen_adapter *adapter)
2085{
2086 while (test_and_set_bit(__NX_RESETTING, &adapter->state))
2087 msleep(10);
2088
2089 cancel_delayed_work_sync(&adapter->fw_work);
2090}
2091
2092static void
2093netxen_attach_work(struct work_struct *work)
2094{
2095 struct netxen_adapter *adapter = container_of(work,
2096 struct netxen_adapter, fw_work.work);
2097 struct net_device *netdev = adapter->netdev;
2098 int err = 0;
2099
2100 if (netif_running(netdev)) {
2101 err = netxen_nic_attach(adapter);
2102 if (err)
2103 goto done;
2104
2105 err = netxen_nic_up(adapter, netdev);
2106 if (err) {
2107 netxen_nic_detach(adapter);
2108 goto done;
2109 }
2110
2111 netxen_config_indev_addr(netdev, NETDEV_UP);
2112 }
2113
2114 netif_device_attach(netdev);
2115
2116done:
2117 adapter->fw_fail_cnt = 0;
2118 clear_bit(__NX_RESETTING, &adapter->state);
2119 netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
2120}
2121
2122static void
2123netxen_fwinit_work(struct work_struct *work)
2124{
2125 struct netxen_adapter *adapter = container_of(work,
2126 struct netxen_adapter, fw_work.work);
2127 int dev_state;
2128
2129 dev_state = NXRD32(adapter, NX_CRB_DEV_STATE);
2130
2131 switch (dev_state) {
2132 case NX_DEV_COLD:
2133 case NX_DEV_READY:
2134 netxen_start_firmware(adapter);
2135 netxen_schedule_work(adapter, netxen_attach_work, 0);
2136 return;
2137
2138 case NX_DEV_INITALIZING:
2139 if (++adapter->fw_wait_cnt < FW_POLL_THRESH) {
2140 netxen_schedule_work(adapter,
2141 netxen_fwinit_work, 2 * FW_POLL_DELAY);
2142 return;
2143 }
2144 break;
2145
2146 case NX_DEV_FAILED:
2147 default:
2148 break;
2149 }
2150
2151 nx_incr_dev_ref_cnt(adapter);
2152 clear_bit(__NX_RESETTING, &adapter->state);
2153}
2154
2155static void
2156netxen_detach_work(struct work_struct *work)
2157{
2158 struct netxen_adapter *adapter = container_of(work,
2159 struct netxen_adapter, fw_work.work);
2160 struct net_device *netdev = adapter->netdev;
2161 int ref_cnt, delay;
2162 u32 status;
2163
2164 netif_device_detach(netdev);
2165
2166 if (netif_running(netdev))
2167 netxen_nic_down(adapter, netdev);
2168
2169 netxen_nic_detach(adapter);
2170
2171 status = NXRD32(adapter, NETXEN_PEG_HALT_STATUS1);
2172
2173 ref_cnt = nx_decr_dev_ref_cnt(adapter);
2174
2175 if (status & NX_RCODE_FATAL_ERROR)
2176 return;
2177
2178 if (adapter->temp == NX_TEMP_PANIC)
2179 return;
2180
2181 delay = (ref_cnt == 0) ? 0 : (2 * FW_POLL_DELAY);
2182
2183 adapter->fw_wait_cnt = 0;
2184 netxen_schedule_work(adapter, netxen_fwinit_work, delay);
2185}
2186
2187static int
2188netxen_check_health(struct netxen_adapter *adapter)
2189{
2190 u32 state, heartbit;
2191 struct net_device *netdev = adapter->netdev;
2192
2193 if (netxen_nic_check_temp(adapter))
2194 goto detach;
2195
2196 state = NXRD32(adapter, NX_CRB_DEV_STATE);
2197 if (state == NX_DEV_NEED_RESET)
2198 goto detach;
2199
2200 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
2201 return 0;
2202
2203 heartbit = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
2204 if (heartbit != adapter->heartbit) {
2205 adapter->heartbit = heartbit;
2206 adapter->fw_fail_cnt = 0;
2207 return 0;
2208 }
2209
2210 if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
2211 return 0;
2212
2213 clear_bit(__NX_FW_ATTACHED, &adapter->state);
2214
2215 dev_info(&netdev->dev, "firmware hang detected\n");
2216
2217detach:
2218 if (!test_and_set_bit(__NX_RESETTING, &adapter->state))
2219 netxen_schedule_work(adapter, netxen_detach_work, 0);
2220 return 1;
2221}
2222
2223static void
2224netxen_fw_poll_work(struct work_struct *work)
2225{
2226 struct netxen_adapter *adapter = container_of(work,
2227 struct netxen_adapter, fw_work.work);
2228
2229 if (test_bit(__NX_RESETTING, &adapter->state))
2230 goto reschedule;
2231
2232 if (test_bit(__NX_DEV_UP, &adapter->state)) {
2233 if (!adapter->has_link_events) {
2234
2235 netxen_nic_handle_phy_intr(adapter);
2236
2237 if (adapter->link_changed)
2238 netxen_nic_set_link_parameters(adapter);
2239 }
2240 }
2241
2242 if (netxen_check_health(adapter))
2243 return;
2244
2245reschedule:
2246 netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
2247}
2248
1965static ssize_t 2249static ssize_t
1966netxen_store_bridged_mode(struct device *dev, 2250netxen_store_bridged_mode(struct device *dev,
1967 struct device_attribute *attr, const char *buf, size_t len) 2251 struct device_attribute *attr, const char *buf, size_t len)
@@ -2050,12 +2334,43 @@ netxen_destip_supported(struct netxen_adapter *adapter)
2050 return 1; 2334 return 1;
2051} 2335}
2052 2336
2337static void
2338netxen_config_indev_addr(struct net_device *dev, unsigned long event)
2339{
2340 struct in_device *indev;
2341 struct netxen_adapter *adapter = netdev_priv(dev);
2342
2343 if (netxen_destip_supported(adapter))
2344 return;
2345
2346 indev = in_dev_get(dev);
2347 if (!indev)
2348 return;
2349
2350 for_ifa(indev) {
2351 switch (event) {
2352 case NETDEV_UP:
2353 netxen_config_ipaddr(adapter,
2354 ifa->ifa_address, NX_IP_UP);
2355 break;
2356 case NETDEV_DOWN:
2357 netxen_config_ipaddr(adapter,
2358 ifa->ifa_address, NX_IP_DOWN);
2359 break;
2360 default:
2361 break;
2362 }
2363 } endfor_ifa(indev);
2364
2365 in_dev_put(indev);
2366 return;
2367}
2368
2053static int netxen_netdev_event(struct notifier_block *this, 2369static int netxen_netdev_event(struct notifier_block *this,
2054 unsigned long event, void *ptr) 2370 unsigned long event, void *ptr)
2055{ 2371{
2056 struct netxen_adapter *adapter; 2372 struct netxen_adapter *adapter;
2057 struct net_device *dev = (struct net_device *)ptr; 2373 struct net_device *dev = (struct net_device *)ptr;
2058 struct in_device *indev;
2059 2374
2060recheck: 2375recheck:
2061 if (dev == NULL) 2376 if (dev == NULL)
@@ -2071,32 +2386,13 @@ recheck:
2071 2386
2072 adapter = netdev_priv(dev); 2387 adapter = netdev_priv(dev);
2073 2388
2074 if (!adapter || !netxen_destip_supported(adapter)) 2389 if (!adapter)
2075 goto done; 2390 goto done;
2076 2391
2077 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC) 2392 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
2078 goto done; 2393 goto done;
2079 2394
2080 indev = in_dev_get(dev); 2395 netxen_config_indev_addr(dev, event);
2081 if (!indev)
2082 goto done;
2083
2084 for_ifa(indev) {
2085 switch (event) {
2086 case NETDEV_UP:
2087 netxen_config_ipaddr(adapter,
2088 ifa->ifa_address, NX_IP_UP);
2089 break;
2090 case NETDEV_DOWN:
2091 netxen_config_ipaddr(adapter,
2092 ifa->ifa_address, NX_IP_DOWN);
2093 break;
2094 default:
2095 break;
2096 }
2097 } endfor_ifa(indev);
2098
2099 in_dev_put(indev);
2100done: 2396done:
2101 return NOTIFY_DONE; 2397 return NOTIFY_DONE;
2102} 2398}
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index 119fd4e04141..76cc2614f480 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -10145,11 +10145,6 @@ static const struct niu_ops niu_phys_ops = {
10145 .unmap_single = niu_phys_unmap_single, 10145 .unmap_single = niu_phys_unmap_single,
10146}; 10146};
10147 10147
10148static unsigned long res_size(struct resource *r)
10149{
10150 return r->end - r->start + 1UL;
10151}
10152
10153static int __devinit niu_of_probe(struct of_device *op, 10148static int __devinit niu_of_probe(struct of_device *op,
10154 const struct of_device_id *match) 10149 const struct of_device_id *match)
10155{ 10150{
@@ -10189,7 +10184,7 @@ static int __devinit niu_of_probe(struct of_device *op,
10189 dev->features |= (NETIF_F_SG | NETIF_F_HW_CSUM); 10184 dev->features |= (NETIF_F_SG | NETIF_F_HW_CSUM);
10190 10185
10191 np->regs = of_ioremap(&op->resource[1], 0, 10186 np->regs = of_ioremap(&op->resource[1], 0,
10192 res_size(&op->resource[1]), 10187 resource_size(&op->resource[1]),
10193 "niu regs"); 10188 "niu regs");
10194 if (!np->regs) { 10189 if (!np->regs) {
10195 dev_err(&op->dev, PFX "Cannot map device registers, " 10190 dev_err(&op->dev, PFX "Cannot map device registers, "
@@ -10199,7 +10194,7 @@ static int __devinit niu_of_probe(struct of_device *op,
10199 } 10194 }
10200 10195
10201 np->vir_regs_1 = of_ioremap(&op->resource[2], 0, 10196 np->vir_regs_1 = of_ioremap(&op->resource[2], 0,
10202 res_size(&op->resource[2]), 10197 resource_size(&op->resource[2]),
10203 "niu vregs-1"); 10198 "niu vregs-1");
10204 if (!np->vir_regs_1) { 10199 if (!np->vir_regs_1) {
10205 dev_err(&op->dev, PFX "Cannot map device vir registers 1, " 10200 dev_err(&op->dev, PFX "Cannot map device vir registers 1, "
@@ -10209,7 +10204,7 @@ static int __devinit niu_of_probe(struct of_device *op,
10209 } 10204 }
10210 10205
10211 np->vir_regs_2 = of_ioremap(&op->resource[3], 0, 10206 np->vir_regs_2 = of_ioremap(&op->resource[3], 0,
10212 res_size(&op->resource[3]), 10207 resource_size(&op->resource[3]),
10213 "niu vregs-2"); 10208 "niu vregs-2");
10214 if (!np->vir_regs_2) { 10209 if (!np->vir_regs_2) {
10215 dev_err(&op->dev, PFX "Cannot map device vir registers 2, " 10210 dev_err(&op->dev, PFX "Cannot map device vir registers 2, "
@@ -10244,19 +10239,19 @@ static int __devinit niu_of_probe(struct of_device *op,
10244err_out_iounmap: 10239err_out_iounmap:
10245 if (np->vir_regs_1) { 10240 if (np->vir_regs_1) {
10246 of_iounmap(&op->resource[2], np->vir_regs_1, 10241 of_iounmap(&op->resource[2], np->vir_regs_1,
10247 res_size(&op->resource[2])); 10242 resource_size(&op->resource[2]));
10248 np->vir_regs_1 = NULL; 10243 np->vir_regs_1 = NULL;
10249 } 10244 }
10250 10245
10251 if (np->vir_regs_2) { 10246 if (np->vir_regs_2) {
10252 of_iounmap(&op->resource[3], np->vir_regs_2, 10247 of_iounmap(&op->resource[3], np->vir_regs_2,
10253 res_size(&op->resource[3])); 10248 resource_size(&op->resource[3]));
10254 np->vir_regs_2 = NULL; 10249 np->vir_regs_2 = NULL;
10255 } 10250 }
10256 10251
10257 if (np->regs) { 10252 if (np->regs) {
10258 of_iounmap(&op->resource[1], np->regs, 10253 of_iounmap(&op->resource[1], np->regs,
10259 res_size(&op->resource[1])); 10254 resource_size(&op->resource[1]));
10260 np->regs = NULL; 10255 np->regs = NULL;
10261 } 10256 }
10262 10257
@@ -10281,19 +10276,19 @@ static int __devexit niu_of_remove(struct of_device *op)
10281 10276
10282 if (np->vir_regs_1) { 10277 if (np->vir_regs_1) {
10283 of_iounmap(&op->resource[2], np->vir_regs_1, 10278 of_iounmap(&op->resource[2], np->vir_regs_1,
10284 res_size(&op->resource[2])); 10279 resource_size(&op->resource[2]));
10285 np->vir_regs_1 = NULL; 10280 np->vir_regs_1 = NULL;
10286 } 10281 }
10287 10282
10288 if (np->vir_regs_2) { 10283 if (np->vir_regs_2) {
10289 of_iounmap(&op->resource[3], np->vir_regs_2, 10284 of_iounmap(&op->resource[3], np->vir_regs_2,
10290 res_size(&op->resource[3])); 10285 resource_size(&op->resource[3]));
10291 np->vir_regs_2 = NULL; 10286 np->vir_regs_2 = NULL;
10292 } 10287 }
10293 10288
10294 if (np->regs) { 10289 if (np->regs) {
10295 of_iounmap(&op->resource[1], np->regs, 10290 of_iounmap(&op->resource[1], np->regs,
10296 res_size(&op->resource[1])); 10291 resource_size(&op->resource[1]));
10297 np->regs = NULL; 10292 np->regs = NULL;
10298 } 10293 }
10299 10294
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index a91e9b3a3eb6..50c6a3cfe439 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -3416,7 +3416,6 @@ static netdev_tx_t rtl8169_start_xmit(struct sk_buff *skb,
3416 netif_wake_queue(dev); 3416 netif_wake_queue(dev);
3417 } 3417 }
3418 3418
3419out:
3420 return NETDEV_TX_OK; 3419 return NETDEV_TX_OK;
3421 3420
3422err_stop: 3421err_stop:
diff --git a/drivers/net/wan/dlci.c b/drivers/net/wan/dlci.c
index 69d269d32b5b..15d353f268b5 100644
--- a/drivers/net/wan/dlci.c
+++ b/drivers/net/wan/dlci.c
@@ -186,46 +186,13 @@ static void dlci_receive(struct sk_buff *skb, struct net_device *dev)
186 dev_kfree_skb(skb); 186 dev_kfree_skb(skb);
187} 187}
188 188
189static netdev_tx_t dlci_transmit(struct sk_buff *skb, 189static netdev_tx_t dlci_transmit(struct sk_buff *skb, struct net_device *dev)
190 struct net_device *dev)
191{ 190{
192 struct dlci_local *dlp; 191 struct dlci_local *dlp = netdev_priv(dev);
193 netdev_tx_t ret;
194
195 if (!skb || !dev)
196 return NETDEV_TX_OK;
197
198 dlp = netdev_priv(dev);
199
200 netif_stop_queue(dev);
201
202 /* This is hackish, overloads driver specific return values
203 on top of normal transmit return! */
204 ret = dlp->slave->netdev_ops->ndo_start_xmit(skb, dlp->slave);
205 switch (ret)
206 {
207 case DLCI_RET_OK:
208 dev->stats.tx_packets++;
209 ret = NETDEV_TX_OK;
210 break;
211 case DLCI_RET_ERR:
212 dev->stats.tx_errors++;
213 ret = NETDEV_TX_OK;
214 break;
215 case DLCI_RET_DROP:
216 dev->stats.tx_dropped++;
217 ret = NETDEV_TX_BUSY;
218 break;
219 }
220 /* Alan Cox recommends always returning 0, and always freeing the packet */
221 /* experience suggest a slightly more conservative approach */
222 192
223 if (ret == NETDEV_TX_OK) 193 if (skb)
224 { 194 dlp->slave->netdev_ops->ndo_start_xmit(skb, dlp->slave);
225 dev_kfree_skb(skb); 195 return NETDEV_TX_OK;
226 netif_wake_queue(dev);
227 }
228 return(ret);
229} 196}
230 197
231static int dlci_config(struct net_device *dev, struct dlci_conf __user *conf, int get) 198static int dlci_config(struct net_device *dev, struct dlci_conf __user *conf, int get)
diff --git a/drivers/net/wan/ixp4xx_hss.c b/drivers/net/wan/ixp4xx_hss.c
index bb719b6114cb..c705046d8615 100644
--- a/drivers/net/wan/ixp4xx_hss.c
+++ b/drivers/net/wan/ixp4xx_hss.c
@@ -166,6 +166,29 @@
166#define CLK46X_SPEED_4096KHZ (( 16 << 22) | (280 << 12) | 1023) 166#define CLK46X_SPEED_4096KHZ (( 16 << 22) | (280 << 12) | 1023)
167#define CLK46X_SPEED_8192KHZ (( 8 << 22) | (280 << 12) | 2047) 167#define CLK46X_SPEED_8192KHZ (( 8 << 22) | (280 << 12) | 2047)
168 168
169/*
170 * HSS_CONFIG_CLOCK_CR register consists of 3 parts:
171 * A (10 bits), B (10 bits) and C (12 bits).
172 * IXP42x HSS clock generator operation (verified with an oscilloscope):
173 * Each clock bit takes 7.5 ns (1 / 133.xx MHz).
174 * The clock sequence consists of (C - B) states of 0s and 1s, each state is
175 * A bits wide. It's followed by (B + 1) states of 0s and 1s, each state is
176 * (A + 1) bits wide.
177 *
178 * The resulting average clock frequency (assuming 33.333 MHz oscillator) is:
179 * freq = 66.666 MHz / (A + (B + 1) / (C + 1))
180 * minumum freq = 66.666 MHz / (A + 1)
181 * maximum freq = 66.666 MHz / A
182 *
183 * Example: A = 2, B = 2, C = 7, CLOCK_CR register = 2 << 22 | 2 << 12 | 7
184 * freq = 66.666 MHz / (2 + (2 + 1) / (7 + 1)) = 28.07 MHz (Mb/s).
185 * The clock sequence is: 1100110011 (5 doubles) 000111000 (3 triples).
186 * The sequence takes (C - B) * A + (B + 1) * (A + 1) = 5 * 2 + 3 * 3 bits
187 * = 19 bits (each 7.5 ns long) = 142.5 ns (then the sequence repeats).
188 * The sequence consists of 4 complete clock periods, thus the average
189 * frequency (= clock rate) is 4 / 142.5 ns = 28.07 MHz (Mb/s).
190 * (max specified clock rate for IXP42x HSS is 8.192 Mb/s).
191 */
169 192
170/* hss_config, LUT entries */ 193/* hss_config, LUT entries */
171#define TDMMAP_UNASSIGNED 0 194#define TDMMAP_UNASSIGNED 0
@@ -239,6 +262,7 @@ struct port {
239 unsigned int clock_type, clock_rate, loopback; 262 unsigned int clock_type, clock_rate, loopback;
240 unsigned int initialized, carrier; 263 unsigned int initialized, carrier;
241 u8 hdlc_cfg; 264 u8 hdlc_cfg;
265 u32 clock_reg;
242}; 266};
243 267
244/* NPE message structure */ 268/* NPE message structure */
@@ -393,7 +417,7 @@ static void hss_config(struct port *port)
393 msg.cmd = PORT_CONFIG_WRITE; 417 msg.cmd = PORT_CONFIG_WRITE;
394 msg.hss_port = port->id; 418 msg.hss_port = port->id;
395 msg.index = HSS_CONFIG_CLOCK_CR; 419 msg.index = HSS_CONFIG_CLOCK_CR;
396 msg.data32 = CLK42X_SPEED_2048KHZ /* FIXME */; 420 msg.data32 = port->clock_reg;
397 hss_npe_send(port, &msg, "HSS_SET_CLOCK_CR"); 421 hss_npe_send(port, &msg, "HSS_SET_CLOCK_CR");
398 422
399 memset(&msg, 0, sizeof(msg)); 423 memset(&msg, 0, sizeof(msg));
@@ -1160,6 +1184,62 @@ static int hss_hdlc_attach(struct net_device *dev, unsigned short encoding,
1160 } 1184 }
1161} 1185}
1162 1186
1187static u32 check_clock(u32 rate, u32 a, u32 b, u32 c,
1188 u32 *best, u32 *best_diff, u32 *reg)
1189{
1190 /* a is 10-bit, b is 10-bit, c is 12-bit */
1191 u64 new_rate;
1192 u32 new_diff;
1193
1194 new_rate = ixp4xx_timer_freq * (u64)(c + 1);
1195 do_div(new_rate, a * (c + 1) + b + 1);
1196 new_diff = abs((u32)new_rate - rate);
1197
1198 if (new_diff < *best_diff) {
1199 *best = new_rate;
1200 *best_diff = new_diff;
1201 *reg = (a << 22) | (b << 12) | c;
1202 }
1203 return new_diff;
1204}
1205
1206static void find_best_clock(u32 rate, u32 *best, u32 *reg)
1207{
1208 u32 a, b, diff = 0xFFFFFFFF;
1209
1210 a = ixp4xx_timer_freq / rate;
1211
1212 if (a > 0x3FF) { /* 10-bit value - we can go as slow as ca. 65 kb/s */
1213 check_clock(rate, 0x3FF, 1, 1, best, &diff, reg);
1214 return;
1215 }
1216 if (a == 0) { /* > 66.666 MHz */
1217 a = 1; /* minimum divider is 1 (a = 0, b = 1, c = 1) */
1218 rate = ixp4xx_timer_freq;
1219 }
1220
1221 if (rate * a == ixp4xx_timer_freq) { /* don't divide by 0 later */
1222 check_clock(rate, a - 1, 1, 1, best, &diff, reg);
1223 return;
1224 }
1225
1226 for (b = 0; b < 0x400; b++) {
1227 u64 c = (b + 1) * (u64)rate;
1228 do_div(c, ixp4xx_timer_freq - rate * a);
1229 c--;
1230 if (c >= 0xFFF) { /* 12-bit - no need to check more 'b's */
1231 if (b == 0 && /* also try a bit higher rate */
1232 !check_clock(rate, a - 1, 1, 1, best, &diff, reg))
1233 return;
1234 check_clock(rate, a, b, 0xFFF, best, &diff, reg);
1235 return;
1236 }
1237 if (!check_clock(rate, a, b, c, best, &diff, reg))
1238 return;
1239 if (!check_clock(rate, a, b, c + 1, best, &diff, reg))
1240 return;
1241 }
1242}
1163 1243
1164static int hss_hdlc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 1244static int hss_hdlc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1165{ 1245{
@@ -1182,7 +1262,7 @@ static int hss_hdlc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1182 } 1262 }
1183 memset(&new_line, 0, sizeof(new_line)); 1263 memset(&new_line, 0, sizeof(new_line));
1184 new_line.clock_type = port->clock_type; 1264 new_line.clock_type = port->clock_type;
1185 new_line.clock_rate = 2048000; /* FIXME */ 1265 new_line.clock_rate = port->clock_rate;
1186 new_line.loopback = port->loopback; 1266 new_line.loopback = port->loopback;
1187 if (copy_to_user(line, &new_line, size)) 1267 if (copy_to_user(line, &new_line, size))
1188 return -EFAULT; 1268 return -EFAULT;
@@ -1206,7 +1286,13 @@ static int hss_hdlc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1206 return -EINVAL; 1286 return -EINVAL;
1207 1287
1208 port->clock_type = clk; /* Update settings */ 1288 port->clock_type = clk; /* Update settings */
1209 /* FIXME port->clock_rate = new_line.clock_rate */; 1289 if (clk == CLOCK_INT)
1290 find_best_clock(new_line.clock_rate, &port->clock_rate,
1291 &port->clock_reg);
1292 else {
1293 port->clock_rate = 0;
1294 port->clock_reg = CLK42X_SPEED_2048KHZ;
1295 }
1210 port->loopback = new_line.loopback; 1296 port->loopback = new_line.loopback;
1211 1297
1212 spin_lock_irqsave(&npe_lock, flags); 1298 spin_lock_irqsave(&npe_lock, flags);
@@ -1266,7 +1352,8 @@ static int __devinit hss_init_one(struct platform_device *pdev)
1266 dev->netdev_ops = &hss_hdlc_ops; 1352 dev->netdev_ops = &hss_hdlc_ops;
1267 dev->tx_queue_len = 100; 1353 dev->tx_queue_len = 100;
1268 port->clock_type = CLOCK_EXT; 1354 port->clock_type = CLOCK_EXT;
1269 port->clock_rate = 2048000; 1355 port->clock_rate = 0;
1356 port->clock_reg = CLK42X_SPEED_2048KHZ;
1270 port->id = pdev->id; 1357 port->id = pdev->id;
1271 port->dev = &pdev->dev; 1358 port->dev = &pdev->dev;
1272 port->plat = pdev->dev.platform_data; 1359 port->plat = pdev->dev.platform_data;
diff --git a/drivers/net/wan/pci200syn.c b/drivers/net/wan/pci200syn.c
index e035d8c57e11..a52f29c72c33 100644
--- a/drivers/net/wan/pci200syn.c
+++ b/drivers/net/wan/pci200syn.c
@@ -360,15 +360,6 @@ static int __devinit pci200_pci_init_one(struct pci_dev *pdev,
360 " %u RX packets rings\n", ramsize / 1024, ramphys, 360 " %u RX packets rings\n", ramsize / 1024, ramphys,
361 pdev->irq, card->tx_ring_buffers, card->rx_ring_buffers); 361 pdev->irq, card->tx_ring_buffers, card->rx_ring_buffers);
362 362
363 if (pdev->subsystem_device == PCI_DEVICE_ID_PLX_9050) {
364 printk(KERN_ERR "Detected PCI200SYN card with old "
365 "configuration data.\n");
366 printk(KERN_ERR "See <http://www.kernel.org/pub/"
367 "linux/utils/net/hdlc/pci200syn/> for update.\n");
368 printk(KERN_ERR "The card will stop working with"
369 " future versions of Linux if not updated.\n");
370 }
371
372 if (card->tx_ring_buffers < 1) { 363 if (card->tx_ring_buffers < 1) {
373 printk(KERN_ERR "pci200syn: RAM test failed\n"); 364 printk(KERN_ERR "pci200syn: RAM test failed\n");
374 pci200_pci_remove_one(pdev); 365 pci200_pci_remove_one(pdev);
@@ -427,8 +418,6 @@ static int __devinit pci200_pci_init_one(struct pci_dev *pdev,
427 418
428static struct pci_device_id pci200_pci_tbl[] __devinitdata = { 419static struct pci_device_id pci200_pci_tbl[] __devinitdata = {
429 { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_PLX, 420 { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_PLX,
430 PCI_DEVICE_ID_PLX_9050, 0, 0, 0 },
431 { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_PLX,
432 PCI_DEVICE_ID_PLX_PCI200SYN, 0, 0, 0 }, 421 PCI_DEVICE_ID_PLX_PCI200SYN, 0, 0, 0 },
433 { 0, } 422 { 0, }
434}; 423};
diff --git a/drivers/net/wan/sdla.c b/drivers/net/wan/sdla.c
index 63c76458431c..2b15a7e40d5b 100644
--- a/drivers/net/wan/sdla.c
+++ b/drivers/net/wan/sdla.c
@@ -652,7 +652,7 @@ static int sdla_dlci_conf(struct net_device *slave, struct net_device *master, i
652 652
653/* NOTE: the DLCI driver deals with freeing the SKB!! */ 653/* NOTE: the DLCI driver deals with freeing the SKB!! */
654static netdev_tx_t sdla_transmit(struct sk_buff *skb, 654static netdev_tx_t sdla_transmit(struct sk_buff *skb,
655 struct net_device *dev) 655 struct net_device *dev)
656{ 656{
657 struct frad_local *flp; 657 struct frad_local *flp;
658 int ret, addr, accept, i; 658 int ret, addr, accept, i;
@@ -712,23 +712,21 @@ static netdev_tx_t sdla_transmit(struct sk_buff *skb,
712 } 712 }
713 break; 713 break;
714 } 714 }
715
715 switch (ret) 716 switch (ret)
716 { 717 {
717 case SDLA_RET_OK: 718 case SDLA_RET_OK:
718 dev->stats.tx_packets++; 719 dev->stats.tx_packets++;
719 ret = DLCI_RET_OK;
720 break; 720 break;
721 721
722 case SDLA_RET_CIR_OVERFLOW: 722 case SDLA_RET_CIR_OVERFLOW:
723 case SDLA_RET_BUF_OVERSIZE: 723 case SDLA_RET_BUF_OVERSIZE:
724 case SDLA_RET_NO_BUFS: 724 case SDLA_RET_NO_BUFS:
725 dev->stats.tx_dropped++; 725 dev->stats.tx_dropped++;
726 ret = DLCI_RET_DROP;
727 break; 726 break;
728 727
729 default: 728 default:
730 dev->stats.tx_errors++; 729 dev->stats.tx_errors++;
731 ret = DLCI_RET_ERR;
732 break; 730 break;
733 } 731 }
734 } 732 }
@@ -738,6 +736,8 @@ static netdev_tx_t sdla_transmit(struct sk_buff *skb,
738 if(flp->master[i]!=NULL) 736 if(flp->master[i]!=NULL)
739 netif_wake_queue(flp->master[i]); 737 netif_wake_queue(flp->master[i]);
740 } 738 }
739
740 dev_kfree_skb(skb);
741 return NETDEV_TX_OK; 741 return NETDEV_TX_OK;
742} 742}
743 743
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-02 17:35:16 -0500