Merge branch 'dmaengine' into async-tx-next

Conflicts:
	crypto/async_tx/async_xor.c
	drivers/dma/ioat/dma_v2.h
	drivers/dma/ioat/pci.c
	drivers/md/raid5.c

12 files changed, 410 insertions, 100 deletions

diff --git a/drivers/net/usb/Kconfig b/drivers/net/usb/Kconfig
index dfc6cf765fbd..a906d3998131 100644
--- a/drivers/net/usb/Kconfig
+++ b/drivers/net/usb/Kconfig
@@ -169,10 +169,12 @@ config USB_NET_CDCETHER
           The Linux-USB CDC Ethernet Gadget driver is an open implementation.
           This driver should work with at least the following devices:
 
+            * Dell Wireless 5530 HSPA
             * Ericsson PipeRider (all variants)
+            * Ericsson Mobile Broadband Module (all variants)
             * Motorola (DM100 and SB4100)
             * Broadcom Cable Modem (reference design)
-            * Toshiba PCX1100U
+            * Toshiba (PCX1100U and F3507g)
             * ...
 
           This driver creates an interface named "ethX", where X depends on
@@ -359,4 +361,12 @@ config USB_HSO
           To compile this driver as a module, choose M here: the
           module will be called hso.
 
+config USB_NET_INT51X1
+        tristate "Intellon PLC based usb adapter"
+        depends on USB_USBNET
+        help
+          Choose this option if you're using a 14Mb USB-based PLC
+          (Powerline Communications) solution with an Intellon
+          INT51x1/INT5200 chip, like the "devolo dLan duo".
+
 endmenu
diff --git a/drivers/net/usb/Makefile b/drivers/net/usb/Makefile
index c8aef62cf2b7..b870b0b1cbe0 100644
--- a/drivers/net/usb/Makefile
+++ b/drivers/net/usb/Makefile
@@ -20,4 +20,5 @@ obj-$(CONFIG_USB_NET_CDC_SUBSET)	+= cdc_subset.o
 obj-$(CONFIG_USB_NET_ZAURUS)    += zaurus.o
 obj-$(CONFIG_USB_NET_MCS7830)   += mcs7830.o
 obj-$(CONFIG_USB_USBNET)        += usbnet.o
+obj-$(CONFIG_USB_NET_INT51X1)   += int51x1.o
 
diff --git a/drivers/net/usb/cdc_ether.c b/drivers/net/usb/cdc_ether.c
index 55e8ecc3a9e5..4a6aff579403 100644
--- a/drivers/net/usb/cdc_ether.c
+++ b/drivers/net/usb/cdc_ether.c
@@ -25,7 +25,6 @@
 #include <linux/init.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
-#include <linux/ctype.h>
 #include <linux/ethtool.h>
 #include <linux/workqueue.h>
 #include <linux/mii.h>
@@ -389,36 +388,6 @@ static void cdc_status(struct usbnet *dev, struct urb *urb)
         }
 }
 
-static u8 nibble(unsigned char c)
-{
-        if (likely(isdigit(c)))
-                return c - '0';
-        c = toupper(c);
-        if (likely(isxdigit(c)))
-                return 10 + c - 'A';
-        return 0;
-}
-
-static inline int
-get_ethernet_addr(struct usbnet *dev, struct usb_cdc_ether_desc *e)
-{
-        int             tmp, i;
-        unsigned char   buf [13];
-
-        tmp = usb_string(dev->udev, e->iMACAddress, buf, sizeof buf);
-        if (tmp != 12) {
-                dev_dbg(&dev->udev->dev,
-                        "bad MAC string %d fetch, %d\n", e->iMACAddress, tmp);
-                if (tmp >= 0)
-                        tmp = -EINVAL;
-                return tmp;
-        }
-        for (i = tmp = 0; i < 6; i++, tmp += 2)
-                dev->net->dev_addr [i] =
-                        (nibble(buf [tmp]) << 4) + nibble(buf [tmp + 1]);
-        return 0;
-}
-
 static int cdc_bind(struct usbnet *dev, struct usb_interface *intf)
 {
         int                             status;
@@ -428,7 +397,7 @@ static int cdc_bind(struct usbnet *dev, struct usb_interface *intf)
         if (status < 0)
                 return status;
 
-        status = get_ethernet_addr(dev, info->ether);
+        status = usbnet_get_ethernet_addr(dev, info->ether->iMACAddress);
         if (status < 0) {
                 usb_set_intfdata(info->data, NULL);
                 usb_driver_release_interface(driver_of(intf), info->data);
@@ -564,6 +533,31 @@ static const struct usb_device_id	products [] = {
         USB_DEVICE_AND_INTERFACE_INFO(0x0bdb, 0x1900, USB_CLASS_COMM,
                         USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
         .driver_info = (unsigned long) &cdc_info,
+}, {
+        /* Ericsson F3507g ver. 2 */
+        USB_DEVICE_AND_INTERFACE_INFO(0x0bdb, 0x1902, USB_CLASS_COMM,
+                        USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
+        .driver_info = (unsigned long) &cdc_info,
+}, {
+        /* Ericsson F3607gw */
+        USB_DEVICE_AND_INTERFACE_INFO(0x0bdb, 0x1904, USB_CLASS_COMM,
+                        USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
+        .driver_info = (unsigned long) &cdc_info,
+}, {
+        /* Ericsson F3307 */
+        USB_DEVICE_AND_INTERFACE_INFO(0x0bdb, 0x1906, USB_CLASS_COMM,
+                        USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
+        .driver_info = (unsigned long) &cdc_info,
+}, {
+        /* Toshiba F3507g */
+        USB_DEVICE_AND_INTERFACE_INFO(0x0930, 0x130b, USB_CLASS_COMM,
+                        USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
+        .driver_info = (unsigned long) &cdc_info,
+}, {
+        /* Dell F3507g */
+        USB_DEVICE_AND_INTERFACE_INFO(0x413c, 0x8147, USB_CLASS_COMM,
+                        USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
+        .driver_info = (unsigned long) &cdc_info,
 },
         { },            // END
 };
diff --git a/drivers/net/usb/cdc_subset.c b/drivers/net/usb/cdc_subset.c
index c66b9c324f54..ca39ace0b0eb 100644
--- a/drivers/net/usb/cdc_subset.c
+++ b/drivers/net/usb/cdc_subset.c
@@ -307,9 +307,10 @@ static const struct usb_device_id	products [] = {
         USB_DEVICE (0x1286, 0x8001),    // "blob" bootloader
         .driver_info =  (unsigned long) &blob_info,
 }, {
-        // Linux Ethernet/RNDIS gadget on pxa210/25x/26x, second config
-        // e.g. Gumstix, current OpenZaurus, ...
-        USB_DEVICE_VER (0x0525, 0xa4a2, 0x0203, 0x0203),
+        // Linux Ethernet/RNDIS gadget, mostly on PXA, second config
+        // e.g. Gumstix, current OpenZaurus, ... or anything else
+        // that just enables this gadget option.
+        USB_DEVICE (0x0525, 0xa4a2),
         .driver_info =  (unsigned long) &linuxdev_info,
 },
 #endif
diff --git a/drivers/net/usb/dm9601.c b/drivers/net/usb/dm9601.c
index 6fc4f82b0beb..7ae82446b93a 100644
--- a/drivers/net/usb/dm9601.c
+++ b/drivers/net/usb/dm9601.c
@@ -497,10 +497,10 @@ static int dm9601_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
         int len;
 
         /* format:
-           b0: rx status
-           b1: packet length (incl crc) low
-           b2: packet length (incl crc) high
-           b3..n-4: packet data
+           b1: rx status
+           b2: packet length (incl crc) low
+           b3: packet length (incl crc) high
+           b4..n-4: packet data
            bn-3..bn: ethernet crc
          */
 
@@ -533,8 +533,8 @@ static struct sk_buff *dm9601_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
         int len;
 
         /* format:
-           b0: packet length low
-           b1: packet length high
+           b1: packet length low
+           b2: packet length high
            b3..n: packet data
         */
 
diff --git a/drivers/net/usb/hso.c b/drivers/net/usb/hso.c
index f84b78d94c40..f8c6d7ea7264 100644
--- a/drivers/net/usb/hso.c
+++ b/drivers/net/usb/hso.c
@@ -482,7 +482,7 @@ static ssize_t hso_sysfs_show_porttype(struct device *dev,
                                        struct device_attribute *attr,
                                        char *buf)
 {
-        struct hso_device *hso_dev = dev->driver_data;
+        struct hso_device *hso_dev = dev_get_drvdata(dev);
         char *port_name;
 
         if (!hso_dev)
@@ -816,7 +816,7 @@ static int hso_net_start_xmit(struct sk_buff *skb, struct net_device *net)
         }
         dev_kfree_skb(skb);
         /* we're done */
-        return result;
+        return NETDEV_TX_OK;
 }
 
 static void hso_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info)
@@ -899,15 +899,14 @@ static void packetizeRx(struct hso_net *odev, unsigned char *ip_pkt,
                                         continue;
                                 }
                                 /* Allocate an sk_buff */
-                                odev->skb_rx_buf = dev_alloc_skb(frame_len);
+                                odev->skb_rx_buf = netdev_alloc_skb(odev->net,
+                                                                    frame_len);
                                 if (!odev->skb_rx_buf) {
                                         /* We got no receive buffer. */
                                         D1("could not allocate memory");
                                         odev->rx_parse_state = WAIT_SYNC;
                                         return;
                                 }
-                                /* Here's where it came from */
-                                odev->skb_rx_buf->dev = odev->net;
 
                                 /* Copy what we got so far. make room for iphdr
                                  * after tail. */
@@ -2313,7 +2312,7 @@ static int hso_serial_common_create(struct hso_serial *serial, int num_urbs,
         serial->parent->dev = tty_register_device(tty_drv, minor,
                                         &serial->parent->interface->dev);
         dev = serial->parent->dev;
-        dev->driver_data = serial->parent;
+        dev_set_drvdata(dev, serial->parent);
         i = device_create_file(dev, &dev_attr_hsotype);
 
         /* fill in specific data for later use */
@@ -2481,10 +2480,10 @@ static int add_net_device(struct hso_device *hso_dev)
         return 0;
 }
 
-static int hso_radio_toggle(void *data, enum rfkill_state state)
+static int hso_rfkill_set_block(void *data, bool blocked)
 {
         struct hso_device *hso_dev = data;
-        int enabled = (state == RFKILL_STATE_ON);
+        int enabled = !blocked;
         int rv;
 
         mutex_lock(&hso_dev->mutex);
@@ -2498,6 +2497,10 @@ static int hso_radio_toggle(void *data, enum rfkill_state state)
         return rv;
 }
 
+static const struct rfkill_ops hso_rfkill_ops = {
+        .set_block = hso_rfkill_set_block,
+};
+
 /* Creates and sets up everything for rfkill */
 static void hso_create_rfkill(struct hso_device *hso_dev,
                              struct usb_interface *interface)
@@ -2506,29 +2509,25 @@ static void hso_create_rfkill(struct hso_device *hso_dev,
         struct device *dev = &hso_net->net->dev;
         char *rfkn;
 
-        hso_net->rfkill = rfkill_allocate(&interface_to_usbdev(interface)->dev,
-                                 RFKILL_TYPE_WWAN);
-        if (!hso_net->rfkill) {
-                dev_err(dev, "%s - Out of memory\n", __func__);
-                return;
-        }
         rfkn = kzalloc(20, GFP_KERNEL);
-        if (!rfkn) {
-                rfkill_free(hso_net->rfkill);
-                hso_net->rfkill = NULL;
+        if (!rfkn)
                 dev_err(dev, "%s - Out of memory\n", __func__);
-                return;
-        }
+
         snprintf(rfkn, 20, "hso-%d",
                  interface->altsetting->desc.bInterfaceNumber);
-        hso_net->rfkill->name = rfkn;
-        hso_net->rfkill->state = RFKILL_STATE_ON;
-        hso_net->rfkill->data = hso_dev;
-        hso_net->rfkill->toggle_radio = hso_radio_toggle;
+
+        hso_net->rfkill = rfkill_alloc(rfkn,
+                                       &interface_to_usbdev(interface)->dev,
+                                       RFKILL_TYPE_WWAN,
+                                       &hso_rfkill_ops, hso_dev);
+        if (!hso_net->rfkill) {
+                dev_err(dev, "%s - Out of memory\n", __func__);
+                kfree(rfkn);
+                return;
+        }
         if (rfkill_register(hso_net->rfkill) < 0) {
+                rfkill_destroy(hso_net->rfkill);
                 kfree(rfkn);
-                hso_net->rfkill->name = NULL;
-                rfkill_free(hso_net->rfkill);
                 hso_net->rfkill = NULL;
                 dev_err(dev, "%s - Failed to register rfkill\n", __func__);
                 return;
@@ -3165,8 +3164,10 @@ static void hso_free_interface(struct usb_interface *interface)
                         hso_stop_net_device(network_table[i]);
                         cancel_work_sync(&network_table[i]->async_put_intf);
                         cancel_work_sync(&network_table[i]->async_get_intf);
-                        if (rfk)
+                        if (rfk) {
                                 rfkill_unregister(rfk);
+                                rfkill_destroy(rfk);
+                        }
                         hso_free_net_device(network_table[i]);
                 }
         }
diff --git a/drivers/net/usb/int51x1.c b/drivers/net/usb/int51x1.c
new file mode 100644
index 000000000000..55cf7081de10
--- /dev/null
+++ b/drivers/net/usb/int51x1.c
@@ -0,0 +1,253 @@
+/*
+ * Copyright (c) 2009 Peter Holik
+ *
+ * Intellon usb PLC (Powerline Communications) usb net driver
+ *
+ * http://www.tandel.be/downloads/INT51X1_Datasheet.pdf
+ *
+ * Based on the work of Jan 'RedBully' Seiffert
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or.
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <linux/module.h>
+#include <linux/ctype.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/ethtool.h>
+#include <linux/mii.h>
+#include <linux/usb.h>
+#include <linux/usb/usbnet.h>
+
+#define INT51X1_VENDOR_ID       0x09e1
+#define INT51X1_PRODUCT_ID      0x5121
+
+#define INT51X1_HEADER_SIZE     2       /* 2 byte header */
+
+#define PACKET_TYPE_PROMISCUOUS         (1 << 0)
+#define PACKET_TYPE_ALL_MULTICAST       (1 << 1) /* no filter */
+#define PACKET_TYPE_DIRECTED            (1 << 2)
+#define PACKET_TYPE_BROADCAST           (1 << 3)
+#define PACKET_TYPE_MULTICAST           (1 << 4) /* filtered */
+
+#define SET_ETHERNET_PACKET_FILTER      0x43
+
+static int int51x1_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
+{
+        int len;
+
+        if (!(pskb_may_pull(skb, INT51X1_HEADER_SIZE))) {
+                deverr(dev, "unexpected tiny rx frame");
+                return 0;
+        }
+
+        len = le16_to_cpu(*(__le16 *)&skb->data[skb->len - 2]);
+
+        skb_trim(skb, len);
+
+        return 1;
+}
+
+static struct sk_buff *int51x1_tx_fixup(struct usbnet *dev,
+                struct sk_buff *skb, gfp_t flags)
+{
+        int pack_len = skb->len;
+        int pack_with_header_len = pack_len + INT51X1_HEADER_SIZE;
+        int headroom = skb_headroom(skb);
+        int tailroom = skb_tailroom(skb);
+        int need_tail = 0;
+        __le16 *len;
+
+        /* if packet and our header is smaler than 64 pad to 64 (+ ZLP) */
+        if ((pack_with_header_len) < dev->maxpacket)
+                need_tail = dev->maxpacket - pack_with_header_len + 1;
+        /*
+         * usbnet would send a ZLP if packetlength mod urbsize == 0 for us,
+         * but we need to know ourself, because this would add to the length
+         * we send down to the device...
+         */
+        else if (!(pack_with_header_len % dev->maxpacket))
+                need_tail = 1;
+
+        if (!skb_cloned(skb) &&
+                        (headroom + tailroom >= need_tail + INT51X1_HEADER_SIZE)) {
+                if (headroom < INT51X1_HEADER_SIZE || tailroom < need_tail) {
+                        skb->data = memmove(skb->head + INT51X1_HEADER_SIZE,
+                                        skb->data, skb->len);
+                        skb_set_tail_pointer(skb, skb->len);
+                }
+        } else {
+                struct sk_buff *skb2;
+
+                skb2 = skb_copy_expand(skb,
+                                INT51X1_HEADER_SIZE,
+                                need_tail,
+                                flags);
+                dev_kfree_skb_any(skb);
+                if (!skb2)
+                        return NULL;
+                skb = skb2;
+        }
+
+        pack_len += need_tail;
+        pack_len &= 0x07ff;
+
+        len = (__le16 *) __skb_push(skb, INT51X1_HEADER_SIZE);
+        *len = cpu_to_le16(pack_len);
+
+        if(need_tail)
+                memset(__skb_put(skb, need_tail), 0, need_tail);
+
+        return skb;
+}
+
+static void int51x1_async_cmd_callback(struct urb *urb)
+{
+        struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context;
+        int status = urb->status;
+
+        if (status < 0)
+                dev_warn(&urb->dev->dev, "async callback failed with %d\n", status);
+
+        kfree(req);
+        usb_free_urb(urb);
+}
+
+static void int51x1_set_multicast(struct net_device *netdev)
+{
+        struct usb_ctrlrequest *req;
+        int status;
+        struct urb *urb;
+        struct usbnet *dev = netdev_priv(netdev);
+        u16 filter = PACKET_TYPE_DIRECTED | PACKET_TYPE_BROADCAST;
+
+        if (netdev->flags & IFF_PROMISC) {
+                /* do not expect to see traffic of other PLCs */
+                filter |= PACKET_TYPE_PROMISCUOUS;
+                devinfo(dev, "promiscuous mode enabled");
+        } else if (netdev->mc_count ||
+                  (netdev->flags & IFF_ALLMULTI)) {
+                filter |= PACKET_TYPE_ALL_MULTICAST;
+                devdbg(dev, "receive all multicast enabled");
+        } else {
+                /* ~PROMISCUOUS, ~MULTICAST */
+                devdbg(dev, "receive own packets only");
+        }
+
+        urb = usb_alloc_urb(0, GFP_ATOMIC);
+        if (!urb) {
+                devwarn(dev, "Error allocating URB");
+                return;
+        }
+
+        req = kmalloc(sizeof(*req), GFP_ATOMIC);
+        if (!req) {
+                devwarn(dev, "Error allocating control msg");
+                goto out;
+        }
+
+        req->bRequestType = USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
+        req->bRequest = SET_ETHERNET_PACKET_FILTER;
+        req->wValue = cpu_to_le16(filter);
+        req->wIndex = 0;
+        req->wLength = 0;
+
+        usb_fill_control_urb(urb, dev->udev, usb_sndctrlpipe(dev->udev, 0),
+                (void *)req, NULL, 0,
+                int51x1_async_cmd_callback,
+                (void *)req);
+
+        status = usb_submit_urb(urb, GFP_ATOMIC);
+        if (status < 0) {
+                devwarn(dev, "Error submitting control msg, sts=%d", status);
+                goto out1;
+        }
+        return;
+out1:
+        kfree(req);
+out:
+        usb_free_urb(urb);
+}
+
+static const struct net_device_ops int51x1_netdev_ops = {
+        .ndo_open               = usbnet_open,
+        .ndo_stop               = usbnet_stop,
+        .ndo_start_xmit         = usbnet_start_xmit,
+        .ndo_tx_timeout         = usbnet_tx_timeout,
+        .ndo_change_mtu         = usbnet_change_mtu,
+        .ndo_set_mac_address    = eth_mac_addr,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_multicast_list = int51x1_set_multicast,
+};
+
+static int int51x1_bind(struct usbnet *dev, struct usb_interface *intf)
+{
+        int status = usbnet_get_ethernet_addr(dev, 3);
+
+        if (status)
+                return status;
+
+        dev->net->hard_header_len += INT51X1_HEADER_SIZE;
+        dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
+        dev->net->netdev_ops = &int51x1_netdev_ops;
+
+        return usbnet_get_endpoints(dev, intf);
+}
+
+static const struct driver_info int51x1_info = {
+        .description = "Intellon usb powerline adapter",
+        .bind        = int51x1_bind,
+        .rx_fixup    = int51x1_rx_fixup,
+        .tx_fixup    = int51x1_tx_fixup,
+        .in          = 1,
+        .out         = 2,
+        .flags       = FLAG_ETHER,
+};
+
+static const struct usb_device_id products[] = {
+        {
+        USB_DEVICE(INT51X1_VENDOR_ID, INT51X1_PRODUCT_ID),
+                .driver_info = (unsigned long) &int51x1_info,
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(usb, products);
+
+static struct usb_driver int51x1_driver = {
+        .name       = "int51x1",
+        .id_table   = products,
+        .probe      = usbnet_probe,
+        .disconnect = usbnet_disconnect,
+        .suspend    = usbnet_suspend,
+        .resume     = usbnet_resume,
+};
+
+static int __init int51x1_init(void)
+{
+        return usb_register(&int51x1_driver);
+}
+module_init(int51x1_init);
+
+static void __exit int51x1_exit(void)
+{
+        usb_deregister(&int51x1_driver);
+}
+module_exit(int51x1_exit);
+
+MODULE_AUTHOR("Peter Holik");
+MODULE_DESCRIPTION("Intellon usb powerline adapter");
+MODULE_LICENSE("GPL");
diff --git a/drivers/net/usb/kaweth.c b/drivers/net/usb/kaweth.c
index 3d0d0b0b37c5..e01314789718 100644
--- a/drivers/net/usb/kaweth.c
+++ b/drivers/net/usb/kaweth.c
@@ -31,7 +31,6 @@
  ****************************************************************/
 
 /* TODO:
- * Fix in_interrupt() problem
  * Develop test procedures for USB net interfaces
  * Run test procedures
  * Fix bugs from previous two steps
@@ -606,14 +605,30 @@ static void kaweth_usb_receive(struct urb *urb)
 
         struct sk_buff *skb;
 
-        if(unlikely(status == -ECONNRESET || status == -ESHUTDOWN))
-        /* we are killed - set a flag and wake the disconnect handler */
-        {
+        if (unlikely(status == -EPIPE)) {
+                kaweth->stats.rx_errors++;
                 kaweth->end = 1;
                 wake_up(&kaweth->term_wait);
+                dbg("Status was -EPIPE.");
                 return;
         }
-
+        if (unlikely(status == -ECONNRESET || status == -ESHUTDOWN)) {
+                /* we are killed - set a flag and wake the disconnect handler */
+                kaweth->end = 1;
+                wake_up(&kaweth->term_wait);
+                dbg("Status was -ECONNRESET or -ESHUTDOWN.");
+                return;
+        }
+        if (unlikely(status == -EPROTO || status == -ETIME ||
+                     status == -EILSEQ)) {
+                kaweth->stats.rx_errors++;
+                dbg("Status was -EPROTO, -ETIME, or -EILSEQ.");
+                return;
+        }
+        if (unlikely(status == -EOVERFLOW)) {
+                kaweth->stats.rx_errors++;
+                dbg("Status was -EOVERFLOW.");
+        }
         spin_lock(&kaweth->device_lock);
         if (IS_BLOCKED(kaweth->status)) {
                 spin_unlock(&kaweth->device_lock);
@@ -883,13 +898,16 @@ static void kaweth_set_rx_mode(struct net_device *net)
  ****************************************************************/
 static void kaweth_async_set_rx_mode(struct kaweth_device *kaweth)
 {
+        int result;
         __u16 packet_filter_bitmap = kaweth->packet_filter_bitmap;
+
         kaweth->packet_filter_bitmap = 0;
         if (packet_filter_bitmap == 0)
                 return;
 
-        {
-        int result;
+        if (in_interrupt())
+                return;
+
         result = kaweth_control(kaweth,
                                 usb_sndctrlpipe(kaweth->dev, 0),
                                 KAWETH_COMMAND_SET_PACKET_FILTER,
@@ -906,7 +924,6 @@ static void kaweth_async_set_rx_mode(struct kaweth_device *kaweth)
         else {
                 dbg("Set Rx mode to %d", packet_filter_bitmap);
         }
-        }
 }
 
 /****************************************************************
diff --git a/drivers/net/usb/pegasus.c b/drivers/net/usb/pegasus.c
index 2138535f2339..73acbd244aa1 100644
--- a/drivers/net/usb/pegasus.c
+++ b/drivers/net/usb/pegasus.c
@@ -297,7 +297,7 @@ static int update_eth_regs_async(pegasus_t * pegasus)
 
         pegasus->dr.bRequestType = PEGASUS_REQT_WRITE;
         pegasus->dr.bRequest = PEGASUS_REQ_SET_REGS;
-        pegasus->dr.wValue = 0;
+        pegasus->dr.wValue = cpu_to_le16(0);
         pegasus->dr.wIndex = cpu_to_le16(EthCtrl0);
         pegasus->dr.wLength = cpu_to_le16(3);
         pegasus->ctrl_urb->transfer_buffer_length = 3;
@@ -446,11 +446,12 @@ static int write_eprom_word(pegasus_t * pegasus, __u8 index, __u16 data)
         int i;
         __u8 tmp, d[4] = { 0x3f, 0, 0, EPROM_WRITE };
         int ret;
+        __le16 le_data = cpu_to_le16(data);
 
         set_registers(pegasus, EpromOffset, 4, d);
         enable_eprom_write(pegasus);
         set_register(pegasus, EpromOffset, index);
-        set_registers(pegasus, EpromData, 2, &data);
+        set_registers(pegasus, EpromData, 2, &le_data);
         set_register(pegasus, EpromCtrl, EPROM_WRITE);
 
         for (i = 0; i < REG_TIMEOUT; i++) {
@@ -923,29 +924,32 @@ static struct net_device_stats *pegasus_netdev_stats(struct net_device *dev)
 
 static inline void disable_net_traffic(pegasus_t * pegasus)
 {
-        int tmp = 0;
+        __le16 tmp = cpu_to_le16(0);
 
-        set_registers(pegasus, EthCtrl0, 2, &tmp);
+        set_registers(pegasus, EthCtrl0, sizeof(tmp), &tmp);
 }
 
 static inline void get_interrupt_interval(pegasus_t * pegasus)
 {
-        __u8 data[2];
+        u16 data;
+        u8 interval;
 
-        read_eprom_word(pegasus, 4, (__u16 *) data);
+        read_eprom_word(pegasus, 4, &data);
+        interval = data >> 8;
         if (pegasus->usb->speed != USB_SPEED_HIGH) {
-                if (data[1] < 0x80) {
+                if (interval < 0x80) {
                         if (netif_msg_timer(pegasus))
                                 dev_info(&pegasus->intf->dev, "intr interval "
                                         "changed from %ums to %ums\n",
-                                        data[1], 0x80);
-                        data[1] = 0x80;
+                                        interval, 0x80);
+                        interval = 0x80;
+                        data = (data & 0x00FF) | ((u16)interval << 8);
 #ifdef PEGASUS_WRITE_EEPROM
-                        write_eprom_word(pegasus, 4, *(__u16 *) data);
+                        write_eprom_word(pegasus, 4, data);
 #endif
                 }
         }
-        pegasus->intr_interval = data[1];
+        pegasus->intr_interval = interval;
 }
 
 static void set_carrier(struct net_device *net)
@@ -1299,7 +1303,8 @@ static int pegasus_blacklisted(struct usb_device *udev)
         /* Special quirk to keep the driver from handling the Belkin Bluetooth
          * dongle which happens to have the same ID.
          */
-        if ((udd->idVendor == VENDOR_BELKIN && udd->idProduct == 0x0121) &&
+        if ((udd->idVendor == cpu_to_le16(VENDOR_BELKIN)) &&
+            (udd->idProduct == cpu_to_le16(0x0121)) &&
             (udd->bDeviceClass == USB_CLASS_WIRELESS_CONTROLLER) &&
             (udd->bDeviceProtocol == 1))
                 return 1;
diff --git a/drivers/net/usb/rtl8150.c b/drivers/net/usb/rtl8150.c
index f9fb454ffa8b..fcc6fa0905d1 100644
--- a/drivers/net/usb/rtl8150.c
+++ b/drivers/net/usb/rtl8150.c
@@ -221,7 +221,8 @@ static void ctrl_callback(struct urb *urb)
         case -ENOENT:
                 break;
         default:
-                dev_warn(&urb->dev->dev, "ctrl urb status %d\n", status);
+                if (printk_ratelimit())
+                        dev_warn(&urb->dev->dev, "ctrl urb status %d\n", status);
         }
         dev = urb->context;
         clear_bit(RX_REG_SET, &dev->flags);
@@ -442,10 +443,12 @@ static void read_bulk_callback(struct urb *urb)
         case -ENOENT:
                 return; /* the urb is in unlink state */
         case -ETIME:
-                dev_warn(&urb->dev->dev, "may be reset is needed?..\n");
+                if (printk_ratelimit())
+                        dev_warn(&urb->dev->dev, "may be reset is needed?..\n");
                 goto goon;
         default:
-                dev_warn(&urb->dev->dev, "Rx status %d\n", status);
+                if (printk_ratelimit())
+                        dev_warn(&urb->dev->dev, "Rx status %d\n", status);
                 goto goon;
         }
 
diff --git a/drivers/net/usb/smsc95xx.c b/drivers/net/usb/smsc95xx.c
index 5a7283372b53..89a91f8c22de 100644
--- a/drivers/net/usb/smsc95xx.c
+++ b/drivers/net/usb/smsc95xx.c
@@ -1134,7 +1134,7 @@ static int smsc95xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
                         if (skb->len == size) {
                                 if (pdata->use_rx_csum)
                                         smsc95xx_rx_csum_offload(skb);
-
+                                skb_trim(skb, skb->len - 4); /* remove fcs */
                                 skb->truesize = size + sizeof(struct sk_buff);
 
                                 return 1;
@@ -1152,7 +1152,7 @@ static int smsc95xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
 
                         if (pdata->use_rx_csum)
                                 smsc95xx_rx_csum_offload(ax_skb);
-
+                        skb_trim(ax_skb, ax_skb->len - 4); /* remove fcs */
                         ax_skb->truesize = size + sizeof(struct sk_buff);
 
                         usbnet_skb_return(dev, ax_skb);
diff --git a/drivers/net/usb/usbnet.c b/drivers/net/usb/usbnet.c
index f3a2fce6166c..22c0585a0319 100644
--- a/drivers/net/usb/usbnet.c
+++ b/drivers/net/usb/usbnet.c
@@ -37,6 +37,7 @@
 #include <linux/init.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
+#include <linux/ctype.h>
 #include <linux/ethtool.h>
 #include <linux/workqueue.h>
 #include <linux/mii.h>
@@ -156,6 +157,36 @@ int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf)
 }
 EXPORT_SYMBOL_GPL(usbnet_get_endpoints);
 
+static u8 nibble(unsigned char c)
+{
+        if (likely(isdigit(c)))
+                return c - '0';
+        c = toupper(c);
+        if (likely(isxdigit(c)))
+                return 10 + c - 'A';
+        return 0;
+}
+
+int usbnet_get_ethernet_addr(struct usbnet *dev, int iMACAddress)
+{
+        int             tmp, i;
+        unsigned char   buf [13];
+
+        tmp = usb_string(dev->udev, iMACAddress, buf, sizeof buf);
+        if (tmp != 12) {
+                dev_dbg(&dev->udev->dev,
+                        "bad MAC string %d fetch, %d\n", iMACAddress, tmp);
+                if (tmp >= 0)
+                        tmp = -EINVAL;
+                return tmp;
+        }
+        for (i = tmp = 0; i < 6; i++, tmp += 2)
+                dev->net->dev_addr [i] =
+                        (nibble(buf [tmp]) << 4) + nibble(buf [tmp + 1]);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(usbnet_get_ethernet_addr);
+
 static void intr_complete (struct urb *urb);
 
 static int init_status (struct usbnet *dev, struct usb_interface *intf)
@@ -398,7 +429,7 @@ static void rx_complete (struct urb *urb)
 
         /* stalls need manual reset. this is rare ... except that
          * when going through USB 2.0 TTs, unplug appears this way.
-         * we avoid the highspeed version of the ETIMEOUT/EILSEQ
+         * we avoid the highspeed version of the ETIMEDOUT/EILSEQ
          * storm, recovering as needed.
          */
         case -EPIPE:
@@ -1185,12 +1216,6 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
 #endif
 
         net->netdev_ops = &usbnet_netdev_ops;
-#ifdef CONFIG_COMPAT_NET_DEV_OPS
-        net->hard_start_xmit = usbnet_start_xmit;
-        net->open = usbnet_open;
-        net->stop = usbnet_stop;
-        net->tx_timeout = usbnet_tx_timeout;
-#endif
         net->watchdog_timeo = TX_TIMEOUT_JIFFIES;
         net->ethtool_ops = &usbnet_ethtool_ops;