1 files changed, 168 insertions, 22 deletions

diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 54161aef3cac..702d546567ad 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -32,6 +32,7 @@
 #include <asm/irq.h>
 #include <linux/delay.h>
 #include <asm/byteorder.h>
+#include <asm/page.h>
 #include <linux/time.h>
 #include <linux/ethtool.h>
 #include <linux/mii.h>
@@ -49,14 +50,15 @@
 #include <linux/crc32.h>
 #include <linux/prefetch.h>
 #include <linux/cache.h>
+#include <linux/zlib.h>
 
 #include "bnx2.h"
 #include "bnx2_fw.h"
 
 #define DRV_MODULE_NAME         "bnx2"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "1.4.40"
-#define DRV_MODULE_RELDATE      "May 22, 2006"
+#define DRV_MODULE_VERSION      "1.4.42"
+#define DRV_MODULE_RELDATE      "June 12, 2006"
 
 #define RUN_AT(x) (jiffies + (x))
 
@@ -1820,7 +1822,7 @@ reuse_rx:
                 skb->protocol = eth_type_trans(skb, bp->dev);
 
                 if ((len > (bp->dev->mtu + ETH_HLEN)) &&
-                        (htons(skb->protocol) != 0x8100)) {
+                        (ntohs(skb->protocol) != 0x8100)) {
 
                         dev_kfree_skb_irq(skb);
                         goto next_rx;
@@ -2009,7 +2011,7 @@ bnx2_poll(struct net_device *dev, int *budget)
         return 1;
 }
 
-/* Called with rtnl_lock from vlan functions and also dev->xmit_lock
+/* Called with rtnl_lock from vlan functions and also netif_tx_lock
  * from set_multicast.
  */
 static void
@@ -2083,6 +2085,92 @@ bnx2_set_rx_mode(struct net_device *dev)
         spin_unlock_bh(&bp->phy_lock);
 }
 
+#define FW_BUF_SIZE     0x8000
+
+static int
+bnx2_gunzip_init(struct bnx2 *bp)
+{
+        if ((bp->gunzip_buf = vmalloc(FW_BUF_SIZE)) == NULL)
+                goto gunzip_nomem1;
+
+        if ((bp->strm = kmalloc(sizeof(*bp->strm), GFP_KERNEL)) == NULL)
+                goto gunzip_nomem2;
+
+        bp->strm->workspace = kmalloc(zlib_inflate_workspacesize(), GFP_KERNEL);
+        if (bp->strm->workspace == NULL)
+                goto gunzip_nomem3;
+
+        return 0;
+
+gunzip_nomem3:
+        kfree(bp->strm);
+        bp->strm = NULL;
+
+gunzip_nomem2:
+        vfree(bp->gunzip_buf);
+        bp->gunzip_buf = NULL;
+
+gunzip_nomem1:
+        printk(KERN_ERR PFX "%s: Cannot allocate firmware buffer for "
+                            "uncompression.\n", bp->dev->name);
+        return -ENOMEM;
+}
+
+static void
+bnx2_gunzip_end(struct bnx2 *bp)
+{
+        kfree(bp->strm->workspace);
+
+        kfree(bp->strm);
+        bp->strm = NULL;
+
+        if (bp->gunzip_buf) {
+                vfree(bp->gunzip_buf);
+                bp->gunzip_buf = NULL;
+        }
+}
+
+static int
+bnx2_gunzip(struct bnx2 *bp, u8 *zbuf, int len, void **outbuf, int *outlen)
+{
+        int n, rc;
+
+        /* check gzip header */
+        if ((zbuf[0] != 0x1f) || (zbuf[1] != 0x8b) || (zbuf[2] != Z_DEFLATED))
+                return -EINVAL;
+
+        n = 10;
+
+#define FNAME   0x8
+        if (zbuf[3] & FNAME)
+                while ((zbuf[n++] != 0) && (n < len));
+
+        bp->strm->next_in = zbuf + n;
+        bp->strm->avail_in = len - n;
+        bp->strm->next_out = bp->gunzip_buf;
+        bp->strm->avail_out = FW_BUF_SIZE;
+
+        rc = zlib_inflateInit2(bp->strm, -MAX_WBITS);
+        if (rc != Z_OK)
+                return rc;
+
+        rc = zlib_inflate(bp->strm, Z_FINISH);
+
+        *outlen = FW_BUF_SIZE - bp->strm->avail_out;
+        *outbuf = bp->gunzip_buf;
+
+        if ((rc != Z_OK) && (rc != Z_STREAM_END))
+                printk(KERN_ERR PFX "%s: Firmware decompression error: %s\n",
+                       bp->dev->name, bp->strm->msg);
+
+        zlib_inflateEnd(bp->strm);
+
+        if (rc == Z_STREAM_END)
+                return 0;
+
+        return rc;
+}
+
 static void
 load_rv2p_fw(struct bnx2 *bp, u32 *rv2p_code, u32 rv2p_code_len,
         u32 rv2p_proc)
@@ -2092,9 +2180,9 @@ load_rv2p_fw(struct bnx2 *bp, u32 *rv2p_code, u32 rv2p_code_len,
 
 
         for (i = 0; i < rv2p_code_len; i += 8) {
-                REG_WR(bp, BNX2_RV2P_INSTR_HIGH, *rv2p_code);
+                REG_WR(bp, BNX2_RV2P_INSTR_HIGH, cpu_to_le32(*rv2p_code));
                 rv2p_code++;
-                REG_WR(bp, BNX2_RV2P_INSTR_LOW, *rv2p_code);
+                REG_WR(bp, BNX2_RV2P_INSTR_LOW, cpu_to_le32(*rv2p_code));
                 rv2p_code++;
 
                 if (rv2p_proc == RV2P_PROC1) {
@@ -2134,7 +2222,7 @@ load_cpu_fw(struct bnx2 *bp, struct cpu_reg *cpu_reg, struct fw_info *fw)
                 int j;
 
                 for (j = 0; j < (fw->text_len / 4); j++, offset += 4) {
-                        REG_WR_IND(bp, offset, fw->text[j]);
+                        REG_WR_IND(bp, offset, cpu_to_le32(fw->text[j]));
                 }
         }
 
@@ -2190,15 +2278,32 @@ load_cpu_fw(struct bnx2 *bp, struct cpu_reg *cpu_reg, struct fw_info *fw)
         REG_WR_IND(bp, cpu_reg->mode, val);
 }
 
-static void
+static int
 bnx2_init_cpus(struct bnx2 *bp)
 {
         struct cpu_reg cpu_reg;
         struct fw_info fw;
+        int rc = 0;
+        void *text;
+        u32 text_len;
+
+        if ((rc = bnx2_gunzip_init(bp)) != 0)
+                return rc;
 
         /* Initialize the RV2P processor. */
-        load_rv2p_fw(bp, bnx2_rv2p_proc1, sizeof(bnx2_rv2p_proc1), RV2P_PROC1);
-        load_rv2p_fw(bp, bnx2_rv2p_proc2, sizeof(bnx2_rv2p_proc2), RV2P_PROC2);
+        rc = bnx2_gunzip(bp, bnx2_rv2p_proc1, sizeof(bnx2_rv2p_proc1), &text,
+                         &text_len);
+        if (rc)
+                goto init_cpu_err;
+
+        load_rv2p_fw(bp, text, text_len, RV2P_PROC1);
+
+        rc = bnx2_gunzip(bp, bnx2_rv2p_proc2, sizeof(bnx2_rv2p_proc2), &text,
+                         &text_len);
+        if (rc)
+                goto init_cpu_err;
+
+        load_rv2p_fw(bp, text, text_len, RV2P_PROC2);
 
         /* Initialize the RX Processor. */
         cpu_reg.mode = BNX2_RXP_CPU_MODE;
@@ -2222,7 +2327,13 @@ bnx2_init_cpus(struct bnx2 *bp)
         fw.text_addr = bnx2_RXP_b06FwTextAddr;
         fw.text_len = bnx2_RXP_b06FwTextLen;
         fw.text_index = 0;
-        fw.text = bnx2_RXP_b06FwText;
+
+        rc = bnx2_gunzip(bp, bnx2_RXP_b06FwText, sizeof(bnx2_RXP_b06FwText),
+                         &text, &text_len);
+        if (rc)
+                goto init_cpu_err;
+
+        fw.text = text;
 
         fw.data_addr = bnx2_RXP_b06FwDataAddr;
         fw.data_len = bnx2_RXP_b06FwDataLen;
@@ -2268,7 +2379,13 @@ bnx2_init_cpus(struct bnx2 *bp)
         fw.text_addr = bnx2_TXP_b06FwTextAddr;
         fw.text_len = bnx2_TXP_b06FwTextLen;
         fw.text_index = 0;
-        fw.text = bnx2_TXP_b06FwText;
+
+        rc = bnx2_gunzip(bp, bnx2_TXP_b06FwText, sizeof(bnx2_TXP_b06FwText),
+                         &text, &text_len);
+        if (rc)
+                goto init_cpu_err;
+
+        fw.text = text;
 
         fw.data_addr = bnx2_TXP_b06FwDataAddr;
         fw.data_len = bnx2_TXP_b06FwDataLen;
@@ -2314,7 +2431,13 @@ bnx2_init_cpus(struct bnx2 *bp)
         fw.text_addr = bnx2_TPAT_b06FwTextAddr;
         fw.text_len = bnx2_TPAT_b06FwTextLen;
         fw.text_index = 0;
-        fw.text = bnx2_TPAT_b06FwText;
+
+        rc = bnx2_gunzip(bp, bnx2_TPAT_b06FwText, sizeof(bnx2_TPAT_b06FwText),
+                         &text, &text_len);
+        if (rc)
+                goto init_cpu_err;
+
+        fw.text = text;
 
         fw.data_addr = bnx2_TPAT_b06FwDataAddr;
         fw.data_len = bnx2_TPAT_b06FwDataLen;
@@ -2360,7 +2483,13 @@ bnx2_init_cpus(struct bnx2 *bp)
         fw.text_addr = bnx2_COM_b06FwTextAddr;
         fw.text_len = bnx2_COM_b06FwTextLen;
         fw.text_index = 0;
-        fw.text = bnx2_COM_b06FwText;
+
+        rc = bnx2_gunzip(bp, bnx2_COM_b06FwText, sizeof(bnx2_COM_b06FwText),
+                         &text, &text_len);
+        if (rc)
+                goto init_cpu_err;
+
+        fw.text = text;
 
         fw.data_addr = bnx2_COM_b06FwDataAddr;
         fw.data_len = bnx2_COM_b06FwDataLen;
@@ -2384,6 +2513,9 @@ bnx2_init_cpus(struct bnx2 *bp)
 
         load_cpu_fw(bp, &cpu_reg, &fw);
 
+init_cpu_err:
+        bnx2_gunzip_end(bp);
+        return rc;
 }
 
 static int
@@ -3256,7 +3388,9 @@ bnx2_init_chip(struct bnx2 *bp)
          * context block must have already been enabled. */
         bnx2_init_context(bp);
 
-        bnx2_init_cpus(bp);
+        if ((rc = bnx2_init_cpus(bp)) != 0)
+                return rc;
+
         bnx2_init_nvram(bp);
 
         bnx2_set_mac_addr(bp);
@@ -3556,7 +3690,9 @@ bnx2_reset_nic(struct bnx2 *bp, u32 reset_code)
         if (rc)
                 return rc;
 
-        bnx2_init_chip(bp);
+        if ((rc = bnx2_init_chip(bp)) != 0)
+                return rc;
+
         bnx2_init_tx_ring(bp);
         bnx2_init_rx_ring(bp);
         return 0;
@@ -4034,6 +4170,8 @@ bnx2_timer(unsigned long data)
         msg = (u32) ++bp->fw_drv_pulse_wr_seq;
         REG_WR_IND(bp, bp->shmem_base + BNX2_DRV_PULSE_MB, msg);
 
+        bp->stats_blk->stat_FwRxDrop = REG_RD_IND(bp, BNX2_FW_RX_DROP_COUNT);
+
         if ((bp->phy_flags & PHY_SERDES_FLAG) &&
             (CHIP_NUM(bp) == CHIP_NUM_5706)) {
 
@@ -4252,7 +4390,7 @@ bnx2_vlan_rx_kill_vid(struct net_device *dev, uint16_t vid)
 }
 #endif
 
-/* Called with dev->xmit_lock.
+/* Called with netif_tx_lock.
  * hard_start_xmit is pseudo-lockless - a lock is only required when
  * the tx queue is full. This way, we get the benefit of lockless
  * operations most of the time without the complexities to handle
@@ -4310,7 +4448,7 @@ bnx2_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 ip_tcp_len = (skb->nh.iph->ihl << 2) + sizeof(struct tcphdr);
 
                 skb->nh.iph->check = 0;
-                skb->nh.iph->tot_len = ntohs(mss + ip_tcp_len + tcp_opt_len);
+                skb->nh.iph->tot_len = htons(mss + ip_tcp_len + tcp_opt_len);
                 skb->h.th->check =
                         ~csum_tcpudp_magic(skb->nh.iph->saddr,
                                             skb->nh.iph->daddr,
@@ -4504,6 +4642,10 @@ bnx2_get_stats(struct net_device *dev)
                 net_stats->tx_aborted_errors +
                 net_stats->tx_carrier_errors;
 
+        net_stats->rx_missed_errors =
+                (unsigned long) (stats_blk->stat_IfInMBUFDiscards +
+                stats_blk->stat_FwRxDrop);
+
         return net_stats;
 }
 
@@ -4986,7 +5128,7 @@ bnx2_set_rx_csum(struct net_device *dev, u32 data)
         return 0;
 }
 
-#define BNX2_NUM_STATS 45
+#define BNX2_NUM_STATS 46
 
 static struct {
         char string[ETH_GSTRING_LEN];
@@ -5036,6 +5178,7 @@ static struct {
         { "rx_mac_ctrl_frames" },
         { "rx_filtered_packets" },
         { "rx_discards" },
+        { "rx_fw_discards" },
 };
 
 #define STATS_OFFSET32(offset_name) (offsetof(struct statistics_block, offset_name) / 4)
@@ -5086,6 +5229,7 @@ static const unsigned long bnx2_stats_offset_arr[BNX2_NUM_STATS] = {
     STATS_OFFSET32(stat_MacControlFramesReceived),                    
     STATS_OFFSET32(stat_IfInFramesL2FilterDiscards),                  
     STATS_OFFSET32(stat_IfInMBUFDiscards),                            
+    STATS_OFFSET32(stat_FwRxDrop),
 };
 
 /* stat_IfHCInBadOctets and stat_Dot3StatsCarrierSenseErrors are
@@ -5096,7 +5240,7 @@ static u8 bnx2_5706_stats_len_arr[BNX2_NUM_STATS] = {
         4,0,4,4,4,4,4,4,4,4,
         4,4,4,4,4,4,4,4,4,4,
         4,4,4,4,4,4,4,4,4,4,
-        4,4,4,4,4,
+        4,4,4,4,4,4,
 };
 
 static u8 bnx2_5708_stats_len_arr[BNX2_NUM_STATS] = {
@@ -5104,7 +5248,7 @@ static u8 bnx2_5708_stats_len_arr[BNX2_NUM_STATS] = {
         4,4,4,4,4,4,4,4,4,4,
         4,4,4,4,4,4,4,4,4,4,
         4,4,4,4,4,4,4,4,4,4,
-        4,4,4,4,4,
+        4,4,4,4,4,4,
 };
 
 #define BNX2_NUM_TESTS 6
@@ -5634,7 +5778,9 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
                 }
         }
 
-        if (CHIP_NUM(bp) == CHIP_NUM_5708)
+        if ((CHIP_ID(bp) == CHIP_ID_5708_A0) ||
+            (CHIP_ID(bp) == CHIP_ID_5708_B0) ||
+            (CHIP_ID(bp) == CHIP_ID_5708_B1))
                 bp->flags |= NO_WOL_FLAG;
 
         if (CHIP_ID(bp) == CHIP_ID_5706_A0) {