Merge with master.kernel.org:/pub/scm/linux/kernel/git/torvalds/linux-2.6.git

7 files changed, 124 insertions, 174 deletions

diff --git a/drivers/net/hamradio/baycom_epp.c b/drivers/net/hamradio/baycom_epp.c
index 1c563f905a59..a7f15d9f13e5 100644
--- a/drivers/net/hamradio/baycom_epp.c
+++ b/drivers/net/hamradio/baycom_epp.c
@@ -374,29 +374,6 @@ static inline void do_kiss_params(struct baycom_state *bc,
 }
 
 /* --------------------------------------------------------------------- */
-/*
- * high performance HDLC encoder
- * yes, it's ugly, but generates pretty good code
- */
-
-#define ENCODEITERA(j)                         \
-({                                             \
-        if (!(notbitstream & (0x1f0 << j)))    \
-                goto stuff##j;                 \
-  encodeend##j:         ;                      \
-})
-
-#define ENCODEITERB(j)                                          \
-({                                                              \
-  stuff##j:                                                     \
-        bitstream &= ~(0x100 << j);                             \
-        bitbuf = (bitbuf & (((2 << j) << numbit) - 1)) |        \
-                ((bitbuf & ~(((2 << j) << numbit) - 1)) << 1);  \
-        numbit++;                                               \
-        notbitstream = ~bitstream;                              \
-        goto encodeend##j;                                      \
-})
-
 
 static void encode_hdlc(struct baycom_state *bc)
 {
@@ -405,6 +382,7 @@ static void encode_hdlc(struct baycom_state *bc)
         int pkt_len;
         unsigned bitstream, notbitstream, bitbuf, numbit, crc;
         unsigned char crcarr[2];
+        int j;
         
         if (bc->hdlctx.bufcnt > 0)
                 return;
@@ -429,24 +407,14 @@ static void encode_hdlc(struct baycom_state *bc)
                 pkt_len--;
                 if (!pkt_len)
                         bp = crcarr;
-                ENCODEITERA(0);
-                ENCODEITERA(1);
-                ENCODEITERA(2);
-                ENCODEITERA(3);
-                ENCODEITERA(4);
-                ENCODEITERA(5);
-                ENCODEITERA(6);
-                ENCODEITERA(7);
-                goto enditer;
-                ENCODEITERB(0);
-                ENCODEITERB(1);
-                ENCODEITERB(2);
-                ENCODEITERB(3);
-                ENCODEITERB(4);
-                ENCODEITERB(5);
-                ENCODEITERB(6);
-                ENCODEITERB(7);
-        enditer:
+                for (j = 0; j < 8; j++)
+                        if (unlikely(!(notbitstream & (0x1f0 << j)))) {
+                                bitstream &= ~(0x100 << j);
+                                bitbuf = (bitbuf & (((2 << j) << numbit) - 1)) |
+                                        ((bitbuf & ~(((2 << j) << numbit) - 1)) << 1);
+                                numbit++;
+                                notbitstream = ~bitstream;
+                        }
                 numbit += 8;
                 while (numbit >= 8) {
                         *wp++ = bitbuf;
@@ -610,37 +578,6 @@ static void do_rxpacket(struct net_device *dev)
         bc->stats.rx_packets++;
 }
 
-#define DECODEITERA(j)                                                        \
-({                                                                            \
-        if (!(notbitstream & (0x0fc << j)))              /* flag or abort */  \
-                goto flgabrt##j;                                              \
-        if ((bitstream & (0x1f8 << j)) == (0xf8 << j))   /* stuffed bit */    \
-                goto stuff##j;                                                \
-  enditer##j:      ;                                                           \
-})
-
-#define DECODEITERB(j)                                                                 \
-({                                                                                     \
-  flgabrt##j:                                                                          \
-        if (!(notbitstream & (0x1fc << j))) {              /* abort received */        \
-                state = 0;                                                             \
-                goto enditer##j;                                                       \
-        }                                                                              \
-        if ((bitstream & (0x1fe << j)) != (0x0fc << j))   /* flag received */          \
-                goto enditer##j;                                                       \
-        if (state)                                                                     \
-                do_rxpacket(dev);                                                      \
-        bc->hdlcrx.bufcnt = 0;                                                         \
-        bc->hdlcrx.bufptr = bc->hdlcrx.buf;                                            \
-        state = 1;                                                                     \
-        numbits = 7-j;                                                                 \
-        goto enditer##j;                                                               \
-  stuff##j:                                                                            \
-        numbits--;                                                                     \
-        bitbuf = (bitbuf & ((~0xff) << j)) | ((bitbuf & ~((~0xff) << j)) << 1);        \
-        goto enditer##j;                                                               \
-})
-        
 static int receive(struct net_device *dev, int cnt)
 {
         struct baycom_state *bc = netdev_priv(dev);
@@ -649,6 +586,7 @@ static int receive(struct net_device *dev, int cnt)
         unsigned char tmp[128];
         unsigned char *cp;
         int cnt2, ret = 0;
+        int j;
         
         numbits = bc->hdlcrx.numbits;
         state = bc->hdlcrx.state;
@@ -669,24 +607,32 @@ static int receive(struct net_device *dev, int cnt)
                         bitbuf |= (*cp) << 8;
                         numbits += 8;
                         notbitstream = ~bitstream;
-                        DECODEITERA(0);
-                        DECODEITERA(1);
-                        DECODEITERA(2);
-                        DECODEITERA(3);
-                        DECODEITERA(4);
-                        DECODEITERA(5);
-                        DECODEITERA(6);
-                        DECODEITERA(7);
-                        goto enddec;
-                        DECODEITERB(0);
-                        DECODEITERB(1);
-                        DECODEITERB(2);
-                        DECODEITERB(3);
-                        DECODEITERB(4);
-                        DECODEITERB(5);
-                        DECODEITERB(6);
-                        DECODEITERB(7);
-                enddec:
+                        for (j = 0; j < 8; j++) {
+
+                                /* flag or abort */
+                                if (unlikely(!(notbitstream & (0x0fc << j)))) {
+
+                                        /* abort received */
+                                        if (!(notbitstream & (0x1fc << j)))
+                                                state = 0;
+
+                                        /* not flag received */
+                                        else if (!(bitstream & (0x1fe << j)) != (0x0fc << j)) {
+                                                if (state)
+                                                        do_rxpacket(dev);
+                                                bc->hdlcrx.bufcnt = 0;
+                                                bc->hdlcrx.bufptr = bc->hdlcrx.buf;
+                                                state = 1;
+                                                numbits = 7-j;
+                                                }
+                                        }
+
+                                /* stuffed bit */
+                                else if (unlikely((bitstream & (0x1f8 << j)) == (0xf8 << j))) {
+                                        numbits--;
+                                        bitbuf = (bitbuf & ((~0xff) << j)) | ((bitbuf & ~((~0xff) << j)) << 1);
+                                        }
+                                }
                         while (state && numbits >= 8) {
                                 if (bc->hdlcrx.bufcnt >= TXBUFFER_SIZE) {
                                         state = 0;
diff --git a/drivers/net/irda/Kconfig b/drivers/net/irda/Kconfig
index 1c553d7efdd9..ca5914091d3a 100644
--- a/drivers/net/irda/Kconfig
+++ b/drivers/net/irda/Kconfig
@@ -389,7 +389,7 @@ config VIA_FIR
         help
           Say Y here if you want to build support for the VIA VT8231
           and VIA VT1211 IrDA controllers, found on the motherboards using
-          those those VIA chipsets. To use this controller, you will need
+          those VIA chipsets. To use this controller, you will need
           to plug a specific 5 pins FIR IrDA dongle in the specific
           motherboard connector. The driver provides support for SIR, MIR
           and FIR (4Mbps) speeds.
diff --git a/drivers/net/iseries_veth.c b/drivers/net/iseries_veth.c
index 13ed8dc1e91d..55af32e9bf08 100644
--- a/drivers/net/iseries_veth.c
+++ b/drivers/net/iseries_veth.c
@@ -802,13 +802,14 @@ static void veth_tx_timeout(struct net_device *dev)
 
         spin_lock_irqsave(&port->pending_gate, flags);
 
+        if (!port->pending_lpmask) {
+                spin_unlock_irqrestore(&port->pending_gate, flags);
+                return;
+        }
+
         printk(KERN_WARNING "%s: Tx timeout!  Resetting lp connections: %08x\n",
                dev->name, port->pending_lpmask);
 
-        /* If we've timed out the queue must be stopped, which should
-         * only ever happen when there is a pending packet. */
-        WARN_ON(! port->pending_lpmask);
-
         for (i = 0; i < HVMAXARCHITECTEDLPS; i++) {
                 struct veth_lpar_connection *cnx = veth_cnx[i];
 
diff --git a/drivers/net/pcmcia/3c574_cs.c b/drivers/net/pcmcia/3c574_cs.c
index 41e517114807..c6e8b25f9685 100644
--- a/drivers/net/pcmcia/3c574_cs.c
+++ b/drivers/net/pcmcia/3c574_cs.c
@@ -1274,6 +1274,9 @@ static int el3_close(struct net_device *dev)
                 spin_lock_irqsave(&lp->window_lock, flags);
                 update_stats(dev);
                 spin_unlock_irqrestore(&lp->window_lock, flags);
+
+                /* force interrupts off */
+                outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
         }
 
         link->open--;
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index c59507f8a76b..d6d0e43dab65 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -415,7 +415,7 @@ struct rtl8169_private {
         struct work_struct task;
 };
 
-MODULE_AUTHOR("Realtek and the Linux r8169 crew <netdev@oss.sgi.com>");
+MODULE_AUTHOR("Realtek and the Linux r8169 crew <netdev@vger.kernel.org>");
 MODULE_DESCRIPTION("RealTek RTL-8169 Gigabit Ethernet driver");
 module_param_array(media, int, &num_media, 0);
 module_param(rx_copybreak, int, 0);
@@ -1585,8 +1585,8 @@ rtl8169_hw_start(struct net_device *dev)
         RTL_W8(ChipCmd, CmdTxEnb | CmdRxEnb);
         RTL_W8(EarlyTxThres, EarlyTxThld);
 
-        /* For gigabit rtl8169, MTU + header + CRC + VLAN */
-        RTL_W16(RxMaxSize, tp->rx_buf_sz);
+        /* Low hurts. Let's disable the filtering. */
+        RTL_W16(RxMaxSize, 16383);
 
         /* Set Rx Config register */
         i = rtl8169_rx_config |
@@ -2127,6 +2127,11 @@ rtl8169_tx_interrupt(struct net_device *dev, struct rtl8169_private *tp,
         }
 }
 
+static inline int rtl8169_fragmented_frame(u32 status)
+{
+        return (status & (FirstFrag | LastFrag)) != (FirstFrag | LastFrag);
+}
+
 static inline void rtl8169_rx_csum(struct sk_buff *skb, struct RxDesc *desc)
 {
         u32 opts1 = le32_to_cpu(desc->opts1);
@@ -2177,27 +2182,41 @@ rtl8169_rx_interrupt(struct net_device *dev, struct rtl8169_private *tp,
 
         while (rx_left > 0) {
                 unsigned int entry = cur_rx % NUM_RX_DESC;
+                struct RxDesc *desc = tp->RxDescArray + entry;
                 u32 status;
 
                 rmb();
-                status = le32_to_cpu(tp->RxDescArray[entry].opts1);
+                status = le32_to_cpu(desc->opts1);
 
                 if (status & DescOwn)
                         break;
                 if (status & RxRES) {
-                        printk(KERN_INFO "%s: Rx ERROR!!!\n", dev->name);
+                        printk(KERN_INFO "%s: Rx ERROR. status = %08x\n",
+                               dev->name, status);
                         tp->stats.rx_errors++;
                         if (status & (RxRWT | RxRUNT))
                                 tp->stats.rx_length_errors++;
                         if (status & RxCRC)
                                 tp->stats.rx_crc_errors++;
+                        rtl8169_mark_to_asic(desc, tp->rx_buf_sz);
                 } else {
-                        struct RxDesc *desc = tp->RxDescArray + entry;
                         struct sk_buff *skb = tp->Rx_skbuff[entry];
                         int pkt_size = (status & 0x00001FFF) - 4;
                         void (*pci_action)(struct pci_dev *, dma_addr_t,
                                 size_t, int) = pci_dma_sync_single_for_device;
 
+                        /*
+                         * The driver does not support incoming fragmented
+                         * frames. They are seen as a symptom of over-mtu
+                         * sized frames.
+                         */
+                        if (unlikely(rtl8169_fragmented_frame(status))) {
+                                tp->stats.rx_dropped++;
+                                tp->stats.rx_length_errors++;
+                                rtl8169_mark_to_asic(desc, tp->rx_buf_sz);
+                                goto move_on;
+                        }
+
                         rtl8169_rx_csum(skb, desc);
                         
                         pci_dma_sync_single_for_cpu(tp->pci_dev,
@@ -2224,7 +2243,7 @@ rtl8169_rx_interrupt(struct net_device *dev, struct rtl8169_private *tp,
                         tp->stats.rx_bytes += pkt_size;
                         tp->stats.rx_packets++;
                 }
-                
+move_on:                
                 cur_rx++; 
                 rx_left--;
         }
diff --git a/drivers/net/shaper.c b/drivers/net/shaper.c
index e68cf5fb4920..20edeb345792 100644
--- a/drivers/net/shaper.c
+++ b/drivers/net/shaper.c
@@ -100,35 +100,8 @@ static int sh_debug;		/* Debug flag */
 
 #define SHAPER_BANNER   "CymruNet Traffic Shaper BETA 0.04 for Linux 2.1\n"
 
-/*
- *      Locking
- */
- 
-static int shaper_lock(struct shaper *sh)
-{
-        /*
-         *      Lock in an interrupt must fail
-         */
-        while (test_and_set_bit(0, &sh->locked))
-        {
-                if (!in_interrupt())
-                        sleep_on(&sh->wait_queue);
-                else
-                        return 0;
-                        
-        }
-        return 1;
-}
-
 static void shaper_kick(struct shaper *sh);
 
-static void shaper_unlock(struct shaper *sh)
-{
-        clear_bit(0, &sh->locked);
-        wake_up(&sh->wait_queue);
-        shaper_kick(sh);
-}
-
 /*
  *      Compute clocks on a buffer
  */
@@ -157,17 +130,15 @@ static void shaper_setspeed(struct shaper *shaper, int bitspersec)
  *      Throw a frame at a shaper.
  */
   
-static int shaper_qframe(struct shaper *shaper, struct sk_buff *skb)
+
+static int shaper_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
+        struct shaper *shaper = dev->priv;
         struct sk_buff *ptr;
    
-        /*
-         *      Get ready to work on this shaper. Lock may fail if its
-         *      an interrupt and locked.
-         */
-         
-        if(!shaper_lock(shaper))
-                return -1;
+        if (down_trylock(&shaper->sem))
+                return -1;
+
         ptr=shaper->sendq.prev;
         
         /*
@@ -260,7 +231,8 @@ static int shaper_qframe(struct shaper *shaper, struct sk_buff *skb)
                 dev_kfree_skb(ptr);
                 shaper->stats.collisions++;
         }
-        shaper_unlock(shaper);
+        shaper_kick(shaper);
+        up(&shaper->sem);
         return 0;
 }
 
@@ -297,8 +269,13 @@ static void shaper_queue_xmit(struct shaper *shaper, struct sk_buff *skb)
  
 static void shaper_timer(unsigned long data)
 {
-        struct shaper *sh=(struct shaper *)data;
-        shaper_kick(sh);
+        struct shaper *shaper = (struct shaper *)data;
+
+        if (!down_trylock(&shaper->sem)) {
+                shaper_kick(shaper);
+                up(&shaper->sem);
+        } else
+                mod_timer(&shaper->timer, jiffies);
 }
 
 /*
@@ -311,19 +288,6 @@ static void shaper_kick(struct shaper *shaper)
         struct sk_buff *skb;
         
         /*
-         *      Shaper unlock will kick
-         */
-         
-        if (test_and_set_bit(0, &shaper->locked))
-        {
-                if(sh_debug)
-                        printk("Shaper locked.\n");
-                mod_timer(&shaper->timer, jiffies);
-                return;
-        }
-
-                
-        /*
          *      Walk the list (may be empty)
          */
          
@@ -364,8 +328,6 @@ static void shaper_kick(struct shaper *shaper)
          
         if(skb!=NULL)
                 mod_timer(&shaper->timer, SHAPERCB(skb)->shapeclock);
-
-        clear_bit(0, &shaper->locked);
 }
 
 
@@ -376,14 +338,12 @@ static void shaper_kick(struct shaper *shaper)
 static void shaper_flush(struct shaper *shaper)
 {
         struct sk_buff *skb;
-        if(!shaper_lock(shaper))
-        {
-                printk(KERN_ERR "shaper: shaper_flush() called by an irq!\n");
-                return;
-        }
+
+        down(&shaper->sem);
         while((skb=skb_dequeue(&shaper->sendq))!=NULL)
                 dev_kfree_skb(skb);
-        shaper_unlock(shaper);
+        shaper_kick(shaper);
+        up(&shaper->sem);
 }
 
 /*
@@ -426,13 +386,6 @@ static int shaper_close(struct net_device *dev)
  *      ARP and other resolutions and not before.
  */
 
-
-static int shaper_start_xmit(struct sk_buff *skb, struct net_device *dev)
-{
-        struct shaper *sh=dev->priv;
-        return shaper_qframe(sh, skb);
-}
-
 static struct net_device_stats *shaper_get_stats(struct net_device *dev)
 {
         struct shaper *sh=dev->priv;
@@ -623,7 +576,6 @@ static void shaper_init_priv(struct net_device *dev)
         init_timer(&sh->timer);
         sh->timer.function=shaper_timer;
         sh->timer.data=(unsigned long)sh;
-        init_waitqueue_head(&sh->wait_queue);
 }
 
 /*
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index fc9b5cd957aa..a0b8848049c9 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -7,7 +7,12 @@
  * Copyright (C) 2005 Broadcom Corporation.
  *
  * Firmware is:
- *      Copyright (C) 2000-2003 Broadcom Corporation.
+ *      Derived from proprietary unpublished source code,
+ *      Copyright (C) 2000-2003 Broadcom Corporation.
+ *
+ *      Permission is hereby granted for the distribution of this firmware
+ *      data in hexadecimal or equivalent format, provided this copyright
+ *      notice is accompanying it.
  */
 
 #include <linux/config.h>
@@ -61,8 +66,8 @@
 
 #define DRV_MODULE_NAME         "tg3"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "3.29"
-#define DRV_MODULE_RELDATE      "May 23, 2005"
+#define DRV_MODULE_VERSION      "3.31"
+#define DRV_MODULE_RELDATE      "June 8, 2005"
 
 #define TG3_DEF_MAC_MODE        0
 #define TG3_DEF_RX_MODE         0
@@ -8555,6 +8560,16 @@ static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp)
 
                 case NIC_SRAM_DATA_CFG_LED_MODE_MAC:
                         tp->led_ctrl = LED_CTRL_MODE_MAC;
+
+                        /* Default to PHY_1_MODE if 0 (MAC_MODE) is
+                         * read on some older 5700/5701 bootcode.
+                         */
+                        if (GET_ASIC_REV(tp->pci_chip_rev_id) ==
+                            ASIC_REV_5700 ||
+                            GET_ASIC_REV(tp->pci_chip_rev_id) ==
+                            ASIC_REV_5701)
+                                tp->led_ctrl = LED_CTRL_MODE_PHY_1;
+
                         break;
 
                 case SHASTA_EXT_LED_SHARED:
@@ -9680,10 +9695,24 @@ static int __devinit tg3_test_dma(struct tg3 *tp)
         }
         if ((tp->dma_rwctrl & DMA_RWCTRL_WRITE_BNDRY_MASK) !=
             DMA_RWCTRL_WRITE_BNDRY_16) {
+                static struct pci_device_id dma_wait_state_chipsets[] = {
+                        { PCI_DEVICE(PCI_VENDOR_ID_APPLE,
+                                     PCI_DEVICE_ID_APPLE_UNI_N_PCI15) },
+                        { },
+                };
+
                 /* DMA test passed without adjusting DMA boundary,
-                 * just restore the calculated DMA boundary
+                 * now look for chipsets that are known to expose the
+                 * DMA bug without failing the test.
                  */
-                tp->dma_rwctrl = saved_dma_rwctrl;
+                if (pci_dev_present(dma_wait_state_chipsets)) {
+                        tp->dma_rwctrl &= ~DMA_RWCTRL_WRITE_BNDRY_MASK;
+                        tp->dma_rwctrl |= DMA_RWCTRL_WRITE_BNDRY_16;
+                }
+                else
+                        /* Safe to use the calculated DMA boundary. */
+                        tp->dma_rwctrl = saved_dma_rwctrl;
+
                 tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
         }