Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6

* master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6: (160 commits)
  [ETHTOOL]: Remove some entries from non-root command list.
  [Bluetooth]: Fix section mismatch of bt_sysfs_cleanup()
  [Bluetooth]: Don't update disconnect timer for incoming connections
  [ETHTOOL]: let mortals use ethtool
  [NetLabel]: add audit support for configuration changes
  [TCP]: Fix and simplify microsecond rtt sampling
  [TCP] tcp-lp: prevent chance for oops
  [SUNRPC]: Remove unnecessary check in net/sunrpc/svcsock.c
  [IPVS] bug: endianness breakage in ip_vs_ftp
  [IPVS]: ipvs annotations
  [NETFILTER]: h323 annotations
  [NETFILTER]: ipt annotations
  [NETFILTER]: NAT annotations
  [NETFILTER]: conntrack annotations
  [NETFILTER]: netfilter misc annotations
  [NET]: Annotate dst_ops protocol
  [NET]: is it Andy or Andi ??
  [IPVS]: Make sure ip_vs_ftp ports are valid: module_param_array approach
  [IPVS]: Reverse valid ip_vs_ftp ports fix: port check approach
  [IrDA] stir4200: removing undocumented bits handling
  ...

247 files changed, 3164 insertions, 1990 deletions

diff --git a/Documentation/networking/pktgen.txt b/Documentation/networking/pktgen.txt
index 44f2f769e865..18d385c068fc 100644
--- a/Documentation/networking/pktgen.txt
+++ b/Documentation/networking/pktgen.txt
@@ -100,6 +100,7 @@ Examples:
                          are: IPSRC_RND #IP Source is random (between min/max),
                               IPDST_RND, UDPSRC_RND,
                               UDPDST_RND, MACSRC_RND, MACDST_RND 
+                              MPLS_RND, VID_RND, SVID_RND
 
  pgset "udp_src_min 9"   set UDP source port min, If < udp_src_max, then
                          cycle through the port range.
@@ -125,6 +126,21 @@ Examples:
 
  pgset "mpls 0"           turn off mpls (or any invalid argument works too!)
 
+ pgset "vlan_id 77"       set VLAN ID 0-4095
+ pgset "vlan_p 3"         set priority bit 0-7 (default 0)
+ pgset "vlan_cfi 0"       set canonical format identifier 0-1 (default 0)
+
+ pgset "svlan_id 22"      set SVLAN ID 0-4095
+ pgset "svlan_p 3"        set priority bit 0-7 (default 0)
+ pgset "svlan_cfi 0"      set canonical format identifier 0-1 (default 0)
+
+ pgset "vlan_id 9999"     > 4095 remove vlan and svlan tags
+ pgset "svlan 9999"       > 4095 remove svlan tag
+
+
+ pgset "tos XX"           set former IPv4 TOS field (e.g. "tos 28" for AF11 no ECN, default 00)
+ pgset "traffic_class XX" set former IPv6 TRAFFIC CLASS (e.g. "traffic_class B8" for EF no ECN, default 00)
+
  pgset stop               aborts injection. Also, ^C aborts generator.
 
 
diff --git a/arch/ia64/hp/sim/simeth.c b/arch/ia64/hp/sim/simeth.c
index b5195be62818..e1a1b11473e2 100644
--- a/arch/ia64/hp/sim/simeth.c
+++ b/arch/ia64/hp/sim/simeth.c
@@ -320,7 +320,7 @@ simeth_device_event(struct notifier_block *this,unsigned long event, void *ptr)
         }
 
         printk(KERN_INFO "simeth_device_event: %s ipaddr=0x%x\n",
-               dev->name, htonl(ifa->ifa_local));
+               dev->name, ntohl(ifa->ifa_local));
 
         /*
          * XXX Fix me
@@ -331,7 +331,7 @@ simeth_device_event(struct notifier_block *this,unsigned long event, void *ptr)
         local = dev->priv;
         /* now do it for real */
         r = event == NETDEV_UP ?
-                netdev_attach(local->simfd, dev->irq, htonl(ifa->ifa_local)):
+                netdev_attach(local->simfd, dev->irq, ntohl(ifa->ifa_local)):
                 netdev_detach(local->simfd);
 
         printk(KERN_INFO "simeth: netdev_attach/detach: event=%s ->%d\n",
diff --git a/arch/um/drivers/net_kern.c b/arch/um/drivers/net_kern.c
index 664c2e2fb820..bd1178fa4e9a 100644
--- a/arch/um/drivers/net_kern.c
+++ b/arch/um/drivers/net_kern.c
@@ -825,7 +825,7 @@ int dev_netmask(void *d, void *m)
         struct net_device *dev = d;
         struct in_device *ip = dev->ip_ptr;
         struct in_ifaddr *in;
-        __u32 *mask_out = m;
+        __be32 *mask_out = m;
 
         if(ip == NULL) 
                 return(1);
diff --git a/arch/xtensa/platform-iss/network.c b/arch/xtensa/platform-iss/network.c
index d96164e602fe..15d64414bd60 100644
--- a/arch/xtensa/platform-iss/network.c
+++ b/arch/xtensa/platform-iss/network.c
@@ -201,7 +201,7 @@ static void dev_ip_addr(void *d, char *buf, char *bin_buf)
         struct net_device *dev = d;
         struct in_device *ip = dev->ip_ptr;
         struct in_ifaddr *in;
-        u32 addr;
+        __be32 addr;
 
         if ((ip == NULL) || ((in = ip->ifa_list) == NULL)) {
                 printk(KERN_WARNING "Device not assigned an IP address!\n");
diff --git a/drivers/bluetooth/bfusb.c b/drivers/bluetooth/bfusb.c
index 23f96213f4ac..efcc28ec9d9a 100644
--- a/drivers/bluetooth/bfusb.c
+++ b/drivers/bluetooth/bfusb.c
@@ -2,7 +2,7 @@
  *
  *  AVM BlueFRITZ! USB driver
  *
- *  Copyright (C) 2003  Marcel Holtmann <marcel@holtmann.org>
+ *  Copyright (C) 2003-2006  Marcel Holtmann <marcel@holtmann.org>
  *
  *
  *  This program is free software; you can redistribute it and/or modify
@@ -59,7 +59,6 @@ static struct usb_device_id bfusb_table[] = {
 
 MODULE_DEVICE_TABLE(usb, bfusb_table);
 
-
 #define BFUSB_MAX_BLOCK_SIZE    256
 
 #define BFUSB_BLOCK_TIMEOUT     3000
@@ -70,7 +69,7 @@ MODULE_DEVICE_TABLE(usb, bfusb_table);
 #define BFUSB_MAX_BULK_TX       2
 #define BFUSB_MAX_BULK_RX       2
 
-struct bfusb {
+struct bfusb_data {
         struct hci_dev          *hdev;
 
         unsigned long           state;
@@ -92,137 +91,136 @@ struct bfusb {
         struct sk_buff_head     completed_q;
 };
 
-struct bfusb_scb {
+struct bfusb_data_scb {
         struct urb *urb;
 };
 
 static void bfusb_tx_complete(struct urb *urb, struct pt_regs *regs);
 static void bfusb_rx_complete(struct urb *urb, struct pt_regs *regs);
 
-static struct urb *bfusb_get_completed(struct bfusb *bfusb)
+static struct urb *bfusb_get_completed(struct bfusb_data *data)
 {
         struct sk_buff *skb;
         struct urb *urb = NULL;
 
-        BT_DBG("bfusb %p", bfusb);
+        BT_DBG("bfusb %p", data);
 
-        skb = skb_dequeue(&bfusb->completed_q);
+        skb = skb_dequeue(&data->completed_q);
         if (skb) {
-                urb = ((struct bfusb_scb *) skb->cb)->urb;
+                urb = ((struct bfusb_data_scb *) skb->cb)->urb;
                 kfree_skb(skb);
         }
 
         return urb;
 }
 
-static void bfusb_unlink_urbs(struct bfusb *bfusb)
+static void bfusb_unlink_urbs(struct bfusb_data *data)
 {
         struct sk_buff *skb;
         struct urb *urb;
 
-        BT_DBG("bfusb %p", bfusb);
+        BT_DBG("bfusb %p", data);
 
-        while ((skb = skb_dequeue(&bfusb->pending_q))) {
-                urb = ((struct bfusb_scb *) skb->cb)->urb;
+        while ((skb = skb_dequeue(&data->pending_q))) {
+                urb = ((struct bfusb_data_scb *) skb->cb)->urb;
                 usb_kill_urb(urb);
-                skb_queue_tail(&bfusb->completed_q, skb);
+                skb_queue_tail(&data->completed_q, skb);
         }
 
-        while ((urb = bfusb_get_completed(bfusb)))
+        while ((urb = bfusb_get_completed(data)))
                 usb_free_urb(urb);
 }
 
-
-static int bfusb_send_bulk(struct bfusb *bfusb, struct sk_buff *skb)
+static int bfusb_send_bulk(struct bfusb_data *data, struct sk_buff *skb)
 {
-        struct bfusb_scb *scb = (void *) skb->cb;
-        struct urb *urb = bfusb_get_completed(bfusb);
+        struct bfusb_data_scb *scb = (void *) skb->cb;
+        struct urb *urb = bfusb_get_completed(data);
         int err, pipe;
 
-        BT_DBG("bfusb %p skb %p len %d", bfusb, skb, skb->len);
+        BT_DBG("bfusb %p skb %p len %d", data, skb, skb->len);
 
         if (!urb && !(urb = usb_alloc_urb(0, GFP_ATOMIC)))
                 return -ENOMEM;
 
-        pipe = usb_sndbulkpipe(bfusb->udev, bfusb->bulk_out_ep);
+        pipe = usb_sndbulkpipe(data->udev, data->bulk_out_ep);
 
-        usb_fill_bulk_urb(urb, bfusb->udev, pipe, skb->data, skb->len,
+        usb_fill_bulk_urb(urb, data->udev, pipe, skb->data, skb->len,
                         bfusb_tx_complete, skb);
 
         scb->urb = urb;
 
-        skb_queue_tail(&bfusb->pending_q, skb);
+        skb_queue_tail(&data->pending_q, skb);
 
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err) {
                 BT_ERR("%s bulk tx submit failed urb %p err %d", 
-                                        bfusb->hdev->name, urb, err);
-                skb_unlink(skb, &bfusb->pending_q);
+                                        data->hdev->name, urb, err);
+                skb_unlink(skb, &data->pending_q);
                 usb_free_urb(urb);
         } else
-                atomic_inc(&bfusb->pending_tx);
+                atomic_inc(&data->pending_tx);
 
         return err;
 }
 
-static void bfusb_tx_wakeup(struct bfusb *bfusb)
+static void bfusb_tx_wakeup(struct bfusb_data *data)
 {
         struct sk_buff *skb;
 
-        BT_DBG("bfusb %p", bfusb);
+        BT_DBG("bfusb %p", data);
 
-        if (test_and_set_bit(BFUSB_TX_PROCESS, &bfusb->state)) {
-                set_bit(BFUSB_TX_WAKEUP, &bfusb->state);
+        if (test_and_set_bit(BFUSB_TX_PROCESS, &data->state)) {
+                set_bit(BFUSB_TX_WAKEUP, &data->state);
                 return;
         }
 
         do {
-                clear_bit(BFUSB_TX_WAKEUP, &bfusb->state);
+                clear_bit(BFUSB_TX_WAKEUP, &data->state);
 
-                while ((atomic_read(&bfusb->pending_tx) < BFUSB_MAX_BULK_TX) &&
-                                (skb = skb_dequeue(&bfusb->transmit_q))) {
-                        if (bfusb_send_bulk(bfusb, skb) < 0) {
-                                skb_queue_head(&bfusb->transmit_q, skb);
+                while ((atomic_read(&data->pending_tx) < BFUSB_MAX_BULK_TX) &&
+                                (skb = skb_dequeue(&data->transmit_q))) {
+                        if (bfusb_send_bulk(data, skb) < 0) {
+                                skb_queue_head(&data->transmit_q, skb);
                                 break;
                         }
                 }
 
-        } while (test_bit(BFUSB_TX_WAKEUP, &bfusb->state));
+        } while (test_bit(BFUSB_TX_WAKEUP, &data->state));
 
-        clear_bit(BFUSB_TX_PROCESS, &bfusb->state);
+        clear_bit(BFUSB_TX_PROCESS, &data->state);
 }
 
 static void bfusb_tx_complete(struct urb *urb, struct pt_regs *regs)
 {
         struct sk_buff *skb = (struct sk_buff *) urb->context;
-        struct bfusb *bfusb = (struct bfusb *) skb->dev;
+        struct bfusb_data *data = (struct bfusb_data *) skb->dev;
 
-        BT_DBG("bfusb %p urb %p skb %p len %d", bfusb, urb, skb, skb->len);
+        BT_DBG("bfusb %p urb %p skb %p len %d", data, urb, skb, skb->len);
 
-        atomic_dec(&bfusb->pending_tx);
+        atomic_dec(&data->pending_tx);
 
-        if (!test_bit(HCI_RUNNING, &bfusb->hdev->flags))
+        if (!test_bit(HCI_RUNNING, &data->hdev->flags))
                 return;
 
         if (!urb->status)
-                bfusb->hdev->stat.byte_tx += skb->len;
+                data->hdev->stat.byte_tx += skb->len;
         else
-                bfusb->hdev->stat.err_tx++;
+                data->hdev->stat.err_tx++;
 
-        read_lock(&bfusb->lock);
+        read_lock(&data->lock);
 
-        skb_unlink(skb, &bfusb->pending_q);
-        skb_queue_tail(&bfusb->completed_q, skb);
+        skb_unlink(skb, &data->pending_q);
+        skb_queue_tail(&data->completed_q, skb);
 
-        bfusb_tx_wakeup(bfusb);
+        bfusb_tx_wakeup(data);
 
-        read_unlock(&bfusb->lock);
+        read_unlock(&data->lock);
 }
 
 
-static int bfusb_rx_submit(struct bfusb *bfusb, struct urb *urb)
+static int bfusb_rx_submit(struct bfusb_data *data, struct urb *urb)
 {
-        struct bfusb_scb *scb;
+        struct bfusb_data_scb *scb;
         struct sk_buff *skb;
         int err, pipe, size = HCI_MAX_FRAME_SIZE + 32;
 
@@ -231,28 +229,29 @@ static int bfusb_rx_submit(struct bfusb *bfusb, struct urb *urb)
         if (!urb && !(urb = usb_alloc_urb(0, GFP_ATOMIC)))
                 return -ENOMEM;
 
-        if (!(skb = bt_skb_alloc(size, GFP_ATOMIC))) {
+        skb = bt_skb_alloc(size, GFP_ATOMIC);
+        if (!skb) {
                 usb_free_urb(urb);
                 return -ENOMEM;
         }
 
-        skb->dev = (void *) bfusb;
+        skb->dev = (void *) data;
 
-        scb = (struct bfusb_scb *) skb->cb;
+        scb = (struct bfusb_data_scb *) skb->cb;
         scb->urb = urb;
 
-        pipe = usb_rcvbulkpipe(bfusb->udev, bfusb->bulk_in_ep);
+        pipe = usb_rcvbulkpipe(data->udev, data->bulk_in_ep);
 
-        usb_fill_bulk_urb(urb, bfusb->udev, pipe, skb->data, size,
+        usb_fill_bulk_urb(urb, data->udev, pipe, skb->data, size,
                         bfusb_rx_complete, skb);
 
-        skb_queue_tail(&bfusb->pending_q, skb);
+        skb_queue_tail(&data->pending_q, skb);
 
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err) {
                 BT_ERR("%s bulk rx submit failed urb %p err %d",
-                                        bfusb->hdev->name, urb, err);
-                skb_unlink(skb, &bfusb->pending_q);
+                                        data->hdev->name, urb, err);
+                skb_unlink(skb, &data->pending_q);
                 kfree_skb(skb);
                 usb_free_urb(urb);
         }
@@ -260,15 +259,15 @@ static int bfusb_rx_submit(struct bfusb *bfusb, struct urb *urb)
         return err;
 }
 
-static inline int bfusb_recv_block(struct bfusb *bfusb, int hdr, unsigned char *data, int len)
+static inline int bfusb_recv_block(struct bfusb_data *data, int hdr, unsigned char *buf, int len)
 {
-        BT_DBG("bfusb %p hdr 0x%02x data %p len %d", bfusb, hdr, data, len);
+        BT_DBG("bfusb %p hdr 0x%02x data %p len %d", data, hdr, buf, len);
 
         if (hdr & 0x10) {
-                BT_ERR("%s error in block", bfusb->hdev->name);
-                if (bfusb->reassembly)
-                        kfree_skb(bfusb->reassembly);
-                bfusb->reassembly = NULL;
+                BT_ERR("%s error in block", data->hdev->name);
+                if (data->reassembly)
+                        kfree_skb(data->reassembly);
+                data->reassembly = NULL;
                 return -EIO;
         }
 
@@ -277,46 +276,46 @@ static inline int bfusb_recv_block(struct bfusb *bfusb, int hdr, unsigned char *
                 unsigned char pkt_type;
                 int pkt_len = 0;
 
-                if (bfusb->reassembly) {
-                        BT_ERR("%s unexpected start block", bfusb->hdev->name);
-                        kfree_skb(bfusb->reassembly);
-                        bfusb->reassembly = NULL;
+                if (data->reassembly) {
+                        BT_ERR("%s unexpected start block", data->hdev->name);
+                        kfree_skb(data->reassembly);
+                        data->reassembly = NULL;
                 }
 
                 if (len < 1) {
-                        BT_ERR("%s no packet type found", bfusb->hdev->name);
+                        BT_ERR("%s no packet type found", data->hdev->name);
                         return -EPROTO;
                 }
 
-                pkt_type = *data++; len--;
+                pkt_type = *buf++; len--;
 
                 switch (pkt_type) {
                 case HCI_EVENT_PKT:
                         if (len >= HCI_EVENT_HDR_SIZE) {
-                                struct hci_event_hdr *hdr = (struct hci_event_hdr *) data;
+                                struct hci_event_hdr *hdr = (struct hci_event_hdr *) buf;
                                 pkt_len = HCI_EVENT_HDR_SIZE + hdr->plen;
                         } else {
-                                BT_ERR("%s event block is too short", bfusb->hdev->name);
+                                BT_ERR("%s event block is too short", data->hdev->name);
                                 return -EILSEQ;
                         }
                         break;
 
                 case HCI_ACLDATA_PKT:
                         if (len >= HCI_ACL_HDR_SIZE) {
-                                struct hci_acl_hdr *hdr = (struct hci_acl_hdr *) data;
+                                struct hci_acl_hdr *hdr = (struct hci_acl_hdr *) buf;
                                 pkt_len = HCI_ACL_HDR_SIZE + __le16_to_cpu(hdr->dlen);
                         } else {
-                                BT_ERR("%s data block is too short", bfusb->hdev->name);
+                                BT_ERR("%s data block is too short", data->hdev->name);
                                 return -EILSEQ;
                         }
                         break;
 
                 case HCI_SCODATA_PKT:
                         if (len >= HCI_SCO_HDR_SIZE) {
-                                struct hci_sco_hdr *hdr = (struct hci_sco_hdr *) data;
+                                struct hci_sco_hdr *hdr = (struct hci_sco_hdr *) buf;
                                 pkt_len = HCI_SCO_HDR_SIZE + hdr->dlen;
                         } else {
-                                BT_ERR("%s audio block is too short", bfusb->hdev->name);
+                                BT_ERR("%s audio block is too short", data->hdev->name);
                                 return -EILSEQ;
                         }
                         break;
@@ -324,27 +323,27 @@ static inline int bfusb_recv_block(struct bfusb *bfusb, int hdr, unsigned char *
 
                 skb = bt_skb_alloc(pkt_len, GFP_ATOMIC);
                 if (!skb) {
-                        BT_ERR("%s no memory for the packet", bfusb->hdev->name);
+                        BT_ERR("%s no memory for the packet", data->hdev->name);
                         return -ENOMEM;
                 }
 
-                skb->dev = (void *) bfusb->hdev;
+                skb->dev = (void *) data->hdev;
                 bt_cb(skb)->pkt_type = pkt_type;
 
-                bfusb->reassembly = skb;
+                data->reassembly = skb;
         } else {
-                if (!bfusb->reassembly) {
-                        BT_ERR("%s unexpected continuation block", bfusb->hdev->name);
+                if (!data->reassembly) {
+                        BT_ERR("%s unexpected continuation block", data->hdev->name);
                         return -EIO;
                 }
         }
 
         if (len > 0)
-                memcpy(skb_put(bfusb->reassembly, len), data, len);
+                memcpy(skb_put(data->reassembly, len), buf, len);
 
         if (hdr & 0x08) {
-                hci_recv_frame(bfusb->reassembly);
-                bfusb->reassembly = NULL;
+                hci_recv_frame(data->reassembly);
+                data->reassembly = NULL;
         }
 
         return 0;
@@ -353,22 +352,22 @@ static inline int bfusb_recv_block(struct bfusb *bfusb, int hdr, unsigned char *
 static void bfusb_rx_complete(struct urb *urb, struct pt_regs *regs)
 {
         struct sk_buff *skb = (struct sk_buff *) urb->context;
-        struct bfusb *bfusb = (struct bfusb *) skb->dev;
+        struct bfusb_data *data = (struct bfusb_data *) skb->dev;
         unsigned char *buf = urb->transfer_buffer;
         int count = urb->actual_length;
         int err, hdr, len;
 
         BT_DBG("bfusb %p urb %p skb %p len %d", bfusb, urb, skb, skb->len);
 
-        read_lock(&bfusb->lock);
+        read_lock(&data->lock);
 
-        if (!test_bit(HCI_RUNNING, &bfusb->hdev->flags))
+        if (!test_bit(HCI_RUNNING, &data->hdev->flags))
                 goto unlock;
 
         if (urb->status || !count)
                 goto resubmit;
 
-        bfusb->hdev->stat.byte_rx += count;
+        data->hdev->stat.byte_rx += count;
 
         skb_put(skb, count);
 
@@ -387,90 +386,89 @@ static void bfusb_rx_complete(struct urb *urb, struct pt_regs *regs)
 
                 if (count < len) {
                         BT_ERR("%s block extends over URB buffer ranges",
-                                        bfusb->hdev->name);
+                                        data->hdev->name);
                 }
 
                 if ((hdr & 0xe1) == 0xc1)
-                        bfusb_recv_block(bfusb, hdr, buf, len);
+                        bfusb_recv_block(data, hdr, buf, len);
 
                 count -= len;
                 buf   += len;
         }
 
-        skb_unlink(skb, &bfusb->pending_q);
+        skb_unlink(skb, &data->pending_q);
         kfree_skb(skb);
 
-        bfusb_rx_submit(bfusb, urb);
+        bfusb_rx_submit(data, urb);
 
-        read_unlock(&bfusb->lock);
+        read_unlock(&data->lock);
 
         return;
 
 resubmit:
-        urb->dev = bfusb->udev;
+        urb->dev = data->udev;
 
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err) {
                 BT_ERR("%s bulk resubmit failed urb %p err %d",
-                                        bfusb->hdev->name, urb, err);
+                                        data->hdev->name, urb, err);
         }
 
 unlock:
-        read_unlock(&bfusb->lock);
+        read_unlock(&data->lock);
 }
 
-
 static int bfusb_open(struct hci_dev *hdev)
 {
-        struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
+        struct bfusb_data *data = hdev->driver_data;
         unsigned long flags;
         int i, err;
 
-        BT_DBG("hdev %p bfusb %p", hdev, bfusb);
+        BT_DBG("hdev %p bfusb %p", hdev, data);
 
         if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
                 return 0;
 
-        write_lock_irqsave(&bfusb->lock, flags);
+        write_lock_irqsave(&data->lock, flags);
 
-        err = bfusb_rx_submit(bfusb, NULL);
+        err = bfusb_rx_submit(data, NULL);
         if (!err) {
                 for (i = 1; i < BFUSB_MAX_BULK_RX; i++)
-                        bfusb_rx_submit(bfusb, NULL);
+                        bfusb_rx_submit(data, NULL);
         } else {
                 clear_bit(HCI_RUNNING, &hdev->flags);
         }
 
-        write_unlock_irqrestore(&bfusb->lock, flags);
+        write_unlock_irqrestore(&data->lock, flags);
 
         return err;
 }
 
 static int bfusb_flush(struct hci_dev *hdev)
 {
-        struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
+        struct bfusb_data *data = hdev->driver_data;
 
-        BT_DBG("hdev %p bfusb %p", hdev, bfusb);
+        BT_DBG("hdev %p bfusb %p", hdev, data);
 
-        skb_queue_purge(&bfusb->transmit_q);
+        skb_queue_purge(&data->transmit_q);
 
         return 0;
 }
 
 static int bfusb_close(struct hci_dev *hdev)
 {
-        struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
+        struct bfusb_data *data = hdev->driver_data;
         unsigned long flags;
 
-        BT_DBG("hdev %p bfusb %p", hdev, bfusb);
+        BT_DBG("hdev %p bfusb %p", hdev, data);
 
         if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
                 return 0;
 
-        write_lock_irqsave(&bfusb->lock, flags);
-        write_unlock_irqrestore(&bfusb->lock, flags);
+        write_lock_irqsave(&data->lock, flags);
+        write_unlock_irqrestore(&data->lock, flags);
 
-        bfusb_unlink_urbs(bfusb);
+        bfusb_unlink_urbs(data);
         bfusb_flush(hdev);
 
         return 0;
@@ -479,7 +477,7 @@ static int bfusb_close(struct hci_dev *hdev)
 static int bfusb_send_frame(struct sk_buff *skb)
 {
         struct hci_dev *hdev = (struct hci_dev *) skb->dev;
-        struct bfusb *bfusb;
+        struct bfusb_data *data;
         struct sk_buff *nskb;
         unsigned char buf[3];
         int sent = 0, size, count;
@@ -494,7 +492,7 @@ static int bfusb_send_frame(struct sk_buff *skb)
         if (!test_bit(HCI_RUNNING, &hdev->flags))
                 return -EBUSY;
 
-        bfusb = (struct bfusb *) hdev->driver_data;
+        data = hdev->driver_data;
 
         switch (bt_cb(skb)->pkt_type) {
         case HCI_COMMAND_PKT:
@@ -514,12 +512,13 @@ static int bfusb_send_frame(struct sk_buff *skb)
         count = skb->len;
 
         /* Max HCI frame size seems to be 1511 + 1 */
-        if (!(nskb = bt_skb_alloc(count + 32, GFP_ATOMIC))) {
+        nskb = bt_skb_alloc(count + 32, GFP_ATOMIC);
+        if (!nskb) {
                 BT_ERR("Can't allocate memory for new packet");
                 return -ENOMEM;
         }
 
-        nskb->dev = (void *) bfusb;
+        nskb->dev = (void *) data;
 
         while (count) {
                 size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE);
@@ -536,18 +535,18 @@ static int bfusb_send_frame(struct sk_buff *skb)
         }
 
         /* Don't send frame with multiple size of bulk max packet */
-        if ((nskb->len % bfusb->bulk_pkt_size) == 0) {
+        if ((nskb->len % data->bulk_pkt_size) == 0) {
                 buf[0] = 0xdd;
                 buf[1] = 0x00;
                 memcpy(skb_put(nskb, 2), buf, 2);
         }
 
-        read_lock(&bfusb->lock);
+        read_lock(&data->lock);
 
-        skb_queue_tail(&bfusb->transmit_q, nskb);
-        bfusb_tx_wakeup(bfusb);
+        skb_queue_tail(&data->transmit_q, nskb);
+        bfusb_tx_wakeup(data);
 
-        read_unlock(&bfusb->lock);
+        read_unlock(&data->lock);
 
         kfree_skb(skb);
 
@@ -556,11 +555,11 @@ static int bfusb_send_frame(struct sk_buff *skb)
 
 static void bfusb_destruct(struct hci_dev *hdev)
 {
-        struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
+        struct bfusb_data *data = hdev->driver_data;
 
-        BT_DBG("hdev %p bfusb %p", hdev, bfusb);
+        BT_DBG("hdev %p bfusb %p", hdev, data);
 
-        kfree(bfusb);
+        kfree(data);
 }
 
 static int bfusb_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
@@ -568,25 +567,24 @@ static int bfusb_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg
         return -ENOIOCTLCMD;
 }
 
-
-static int bfusb_load_firmware(struct bfusb *bfusb, unsigned char *firmware, int count)
+static int bfusb_load_firmware(struct bfusb_data *data, unsigned char *firmware, int count)
 {
         unsigned char *buf;
         int err, pipe, len, size, sent = 0;
 
-        BT_DBG("bfusb %p udev %p", bfusb, bfusb->udev);
+        BT_DBG("bfusb %p udev %p", data, data->udev);
 
         BT_INFO("BlueFRITZ! USB loading firmware");
 
-        pipe = usb_sndctrlpipe(bfusb->udev, 0);
+        pipe = usb_sndctrlpipe(data->udev, 0);
 
-        if (usb_control_msg(bfusb->udev, pipe, USB_REQ_SET_CONFIGURATION,
+        if (usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,
                                 0, 1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT) < 0) {
                 BT_ERR("Can't change to loading configuration");
                 return -EBUSY;
         }
 
-        bfusb->udev->toggle[0] = bfusb->udev->toggle[1] = 0;
+        data->udev->toggle[0] = data->udev->toggle[1] = 0;
 
         buf = kmalloc(BFUSB_MAX_BLOCK_SIZE + 3, GFP_ATOMIC);
         if (!buf) {
@@ -594,14 +592,14 @@ static int bfusb_load_firmware(struct bfusb *bfusb, unsigned char *firmware, int
                 return -ENOMEM;
         }
 
-        pipe = usb_sndbulkpipe(bfusb->udev, bfusb->bulk_out_ep);
+        pipe = usb_sndbulkpipe(data->udev, data->bulk_out_ep);
 
         while (count) {
                 size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE + 3);
 
                 memcpy(buf, firmware + sent, size);
 
-                err = usb_bulk_msg(bfusb->udev, pipe, buf, size,
+                err = usb_bulk_msg(data->udev, pipe, buf, size,
                                         &len, BFUSB_BLOCK_TIMEOUT);
 
                 if (err || (len != size)) {
@@ -613,21 +611,23 @@ static int bfusb_load_firmware(struct bfusb *bfusb, unsigned char *firmware, int
                 count -= size;
         }
 
-        if ((err = usb_bulk_msg(bfusb->udev, pipe, NULL, 0,
-                                &len, BFUSB_BLOCK_TIMEOUT)) < 0) {
+        err = usb_bulk_msg(data->udev, pipe, NULL, 0,
+                                        &len, BFUSB_BLOCK_TIMEOUT);
+        if (err < 0) {
                 BT_ERR("Error in null packet request");
                 goto error;
         }
 
-        pipe = usb_sndctrlpipe(bfusb->udev, 0);
+        pipe = usb_sndctrlpipe(data->udev, 0);
 
-        if ((err = usb_control_msg(bfusb->udev, pipe, USB_REQ_SET_CONFIGURATION,
-                                0, 2, 0, NULL, 0, USB_CTRL_SET_TIMEOUT)) < 0) {
+        err = usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,
+                                0, 2, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
+        if (err < 0) {
                 BT_ERR("Can't change to running configuration");
                 goto error;
         }
 
-        bfusb->udev->toggle[0] = bfusb->udev->toggle[1] = 0;
+        data->udev->toggle[0] = data->udev->toggle[1] = 0;
 
         BT_INFO("BlueFRITZ! USB device ready");
 
@@ -637,9 +637,9 @@ static int bfusb_load_firmware(struct bfusb *bfusb, unsigned char *firmware, int
 error:
         kfree(buf);
 
-        pipe = usb_sndctrlpipe(bfusb->udev, 0);
+        pipe = usb_sndctrlpipe(data->udev, 0);
 
-        usb_control_msg(bfusb->udev, pipe, USB_REQ_SET_CONFIGURATION,
+        usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,
                                 0, 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
 
         return err;
@@ -652,7 +652,7 @@ static int bfusb_probe(struct usb_interface *intf, const struct usb_device_id *i
         struct usb_host_endpoint *bulk_out_ep;
         struct usb_host_endpoint *bulk_in_ep;
         struct hci_dev *hdev;
-        struct bfusb *bfusb;
+        struct bfusb_data *data;
 
         BT_DBG("intf %p id %p", intf, id);
 
@@ -672,23 +672,24 @@ static int bfusb_probe(struct usb_interface *intf, const struct usb_device_id *i
         }
 
         /* Initialize control structure and load firmware */
-        if (!(bfusb = kzalloc(sizeof(struct bfusb), GFP_KERNEL))) {
+        data = kzalloc(sizeof(struct bfusb_data), GFP_KERNEL);
+        if (!data) {
                 BT_ERR("Can't allocate memory for control structure");
                 goto done;
         }
 
-        bfusb->udev = udev;
-        bfusb->bulk_in_ep    = bulk_in_ep->desc.bEndpointAddress;
-        bfusb->bulk_out_ep   = bulk_out_ep->desc.bEndpointAddress;
-        bfusb->bulk_pkt_size = le16_to_cpu(bulk_out_ep->desc.wMaxPacketSize);
+        data->udev = udev;
+        data->bulk_in_ep    = bulk_in_ep->desc.bEndpointAddress;
+        data->bulk_out_ep   = bulk_out_ep->desc.bEndpointAddress;
+        data->bulk_pkt_size = le16_to_cpu(bulk_out_ep->desc.wMaxPacketSize);
 
-        rwlock_init(&bfusb->lock);
+        rwlock_init(&data->lock);
 
-        bfusb->reassembly = NULL;
+        data->reassembly = NULL;
 
-        skb_queue_head_init(&bfusb->transmit_q);
-        skb_queue_head_init(&bfusb->pending_q);
-        skb_queue_head_init(&bfusb->completed_q);
+        skb_queue_head_init(&data->transmit_q);
+        skb_queue_head_init(&data->pending_q);
+        skb_queue_head_init(&data->completed_q);
 
         if (request_firmware(&firmware, "bfubase.frm", &udev->dev) < 0) {
                 BT_ERR("Firmware request failed");
@@ -697,7 +698,7 @@ static int bfusb_probe(struct usb_interface *intf, const struct usb_device_id *i
 
         BT_DBG("firmware data %p size %d", firmware->data, firmware->size);
 
-        if (bfusb_load_firmware(bfusb, firmware->data, firmware->size) < 0) {
+        if (bfusb_load_firmware(data, firmware->data, firmware->size) < 0) {
                 BT_ERR("Firmware loading failed");
                 goto release;
         }
@@ -711,10 +712,10 @@ static int bfusb_probe(struct usb_interface *intf, const struct usb_device_id *i
                 goto error;
         }
 
-        bfusb->hdev = hdev;
+        data->hdev = hdev;
 
         hdev->type = HCI_USB;
-        hdev->driver_data = bfusb;
+        hdev->driver_data = data;
         SET_HCIDEV_DEV(hdev, &intf->dev);
 
         hdev->open     = bfusb_open;
@@ -732,7 +733,7 @@ static int bfusb_probe(struct usb_interface *intf, const struct usb_device_id *i
                 goto error;
         }
 
-        usb_set_intfdata(intf, bfusb);
+        usb_set_intfdata(intf, data);
 
         return 0;
 
@@ -740,7 +741,7 @@ release:
         release_firmware(firmware);
 
 error:
-        kfree(bfusb);
+        kfree(data);
 
 done:
         return -EIO;
@@ -748,8 +749,8 @@ done:
 
 static void bfusb_disconnect(struct usb_interface *intf)
 {
-        struct bfusb *bfusb = usb_get_intfdata(intf);
-        struct hci_dev *hdev = bfusb->hdev;
+        struct bfusb_data *data = usb_get_intfdata(intf);
+        struct hci_dev *hdev = data->hdev;
 
         BT_DBG("intf %p", intf);
 
@@ -779,7 +780,8 @@ static int __init bfusb_init(void)
 
         BT_INFO("BlueFRITZ! USB driver ver %s", VERSION);
 
-        if ((err = usb_register(&bfusb_driver)) < 0)
+        err = usb_register(&bfusb_driver);
+        if (err < 0)
                 BT_ERR("Failed to register BlueFRITZ! USB driver");
 
         return err;
diff --git a/drivers/bluetooth/hci_ldisc.c b/drivers/bluetooth/hci_ldisc.c
index 93ba25b7ea32..420b645c4c9f 100644
--- a/drivers/bluetooth/hci_ldisc.c
+++ b/drivers/bluetooth/hci_ldisc.c
@@ -241,15 +241,11 @@ static int hci_uart_send_frame(struct sk_buff *skb)
 
 static void hci_uart_destruct(struct hci_dev *hdev)
 {
-        struct hci_uart *hu;
-
         if (!hdev)
                 return;
 
         BT_DBG("%s", hdev->name);
-
-        hu = (struct hci_uart *) hdev->driver_data;
-        kfree(hu);
+        kfree(hdev->driver_data);
 }
 
 /* ------ LDISC part ------ */
@@ -272,7 +268,7 @@ static int hci_uart_tty_open(struct tty_struct *tty)
                 return -EEXIST;
 
         if (!(hu = kzalloc(sizeof(struct hci_uart), GFP_KERNEL))) {
-                BT_ERR("Can't allocate controll structure");
+                BT_ERR("Can't allocate control structure");
                 return -ENFILE;
         }
 
@@ -360,7 +356,7 @@ static void hci_uart_tty_wakeup(struct tty_struct *tty)
  *     
  * Return Value:    None
  */
-static void hci_uart_tty_receive(struct tty_struct *tty, const __u8 *data, char *flags, int count)
+static void hci_uart_tty_receive(struct tty_struct *tty, const u8 *data, char *flags, int count)
 {
         struct hci_uart *hu = (void *)tty->disc_data;
 
@@ -375,7 +371,8 @@ static void hci_uart_tty_receive(struct tty_struct *tty, const __u8 *data, char
         hu->hdev->stat.byte_rx += count;
         spin_unlock(&hu->rx_lock);
 
-        if (test_and_clear_bit(TTY_THROTTLED,&tty->flags) && tty->driver->unthrottle)
+        if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
+                                        tty->driver->unthrottle)
                 tty->driver->unthrottle(tty);
 }
 
diff --git a/drivers/bluetooth/hci_usb.c b/drivers/bluetooth/hci_usb.c
index e2d4beac7420..0801af4ad2b9 100644
--- a/drivers/bluetooth/hci_usb.c
+++ b/drivers/bluetooth/hci_usb.c
@@ -96,6 +96,9 @@ static struct usb_device_id bluetooth_ids[] = {
         /* Ericsson with non-standard id */
         { USB_DEVICE(0x0bdb, 0x1002) },
 
+        /* Canyon CN-BTU1 with HID interfaces */
+        { USB_DEVICE(0x0c10, 0x0000), .driver_info = HCI_RESET },
+
         { }     /* Terminating entry */
 };
 
diff --git a/drivers/bluetooth/hci_vhci.c b/drivers/bluetooth/hci_vhci.c
index aac67a3a6019..a278d98a9151 100644
--- a/drivers/bluetooth/hci_vhci.c
+++ b/drivers/bluetooth/hci_vhci.c
@@ -2,9 +2,9 @@
  *
  *  Bluetooth virtual HCI driver
  *
- *  Copyright (C) 2000-2001 Qualcomm Incorporated
- *  Copyright (C) 2002-2003 Maxim Krasnyansky <maxk@qualcomm.com>
- *  Copyright (C) 2004-2005 Marcel Holtmann <marcel@holtmann.org>
+ *  Copyright (C) 2000-2001  Qualcomm Incorporated
+ *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
+ *  Copyright (C) 2004-2006  Marcel Holtmann <marcel@holtmann.org>
  *
  *
  *  This program is free software; you can redistribute it and/or modify
@@ -72,21 +72,21 @@ static int vhci_open_dev(struct hci_dev *hdev)
 
 static int vhci_close_dev(struct hci_dev *hdev)
 {
-        struct vhci_data *vhci = hdev->driver_data;
+        struct vhci_data *data = hdev->driver_data;
 
         if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
                 return 0;
 
-        skb_queue_purge(&vhci->readq);
+        skb_queue_purge(&data->readq);
 
         return 0;
 }
 
 static int vhci_flush(struct hci_dev *hdev)
 {
-        struct vhci_data *vhci = hdev->driver_data;
+        struct vhci_data *data = hdev->driver_data;
 
-        skb_queue_purge(&vhci->readq);
+        skb_queue_purge(&data->readq);
 
         return 0;
 }
@@ -94,7 +94,7 @@ static int vhci_flush(struct hci_dev *hdev)
 static int vhci_send_frame(struct sk_buff *skb)
 {
         struct hci_dev* hdev = (struct hci_dev *) skb->dev;
-        struct vhci_data *vhci;
+        struct vhci_data *data;
 
         if (!hdev) {
                 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
@@ -104,15 +104,15 @@ static int vhci_send_frame(struct sk_buff *skb)
         if (!test_bit(HCI_RUNNING, &hdev->flags))
                 return -EBUSY;
 
-        vhci = hdev->driver_data;
+        data = hdev->driver_data;
 
         memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
-        skb_queue_tail(&vhci->readq, skb);
+        skb_queue_tail(&data->readq, skb);
 
-        if (vhci->flags & VHCI_FASYNC)
-                kill_fasync(&vhci->fasync, SIGIO, POLL_IN);
+        if (data->flags & VHCI_FASYNC)
+                kill_fasync(&data->fasync, SIGIO, POLL_IN);
 
-        wake_up_interruptible(&vhci->read_wait);
+        wake_up_interruptible(&data->read_wait);
 
         return 0;
 }
@@ -122,7 +122,7 @@ static void vhci_destruct(struct hci_dev *hdev)
         kfree(hdev->driver_data);
 }
 
-static inline ssize_t vhci_get_user(struct vhci_data *vhci,
+static inline ssize_t vhci_get_user(struct vhci_data *data,
                                         const char __user *buf, size_t count)
 {
         struct sk_buff *skb;
@@ -139,7 +139,7 @@ static inline ssize_t vhci_get_user(struct vhci_data *vhci,
                 return -EFAULT;
         }
 
-        skb->dev = (void *) vhci->hdev;
+        skb->dev = (void *) data->hdev;
         bt_cb(skb)->pkt_type = *((__u8 *) skb->data);
         skb_pull(skb, 1);
 
@@ -148,7 +148,7 @@ static inline ssize_t vhci_get_user(struct vhci_data *vhci,
         return count;
 }
 
-static inline ssize_t vhci_put_user(struct vhci_data *vhci,
+static inline ssize_t vhci_put_user(struct vhci_data *data,
                         struct sk_buff *skb, char __user *buf, int count)
 {
         char __user *ptr = buf;
@@ -161,42 +161,43 @@ static inline ssize_t vhci_put_user(struct vhci_data *vhci,
 
         total += len;
 
-        vhci->hdev->stat.byte_tx += len;
+        data->hdev->stat.byte_tx += len;
 
         switch (bt_cb(skb)->pkt_type) {
         case HCI_COMMAND_PKT:
-                vhci->hdev->stat.cmd_tx++;
+                data->hdev->stat.cmd_tx++;
                 break;
 
         case HCI_ACLDATA_PKT:
-                vhci->hdev->stat.acl_tx++;
+                data->hdev->stat.acl_tx++;
                 break;
 
         case HCI_SCODATA_PKT:
-                vhci->hdev->stat.cmd_tx++;
+                data->hdev->stat.cmd_tx++;
                 break;
         };
 
         return total;
 }
 
-static loff_t vhci_llseek(struct file * file, loff_t offset, int origin)
+static loff_t vhci_llseek(struct file *file, loff_t offset, int origin)
 {
         return -ESPIPE;
 }
 
-static ssize_t vhci_read(struct file * file, char __user * buf, size_t count, loff_t *pos)
+static ssize_t vhci_read(struct file *file,
+                                char __user *buf, size_t count, loff_t *pos)
 {
         DECLARE_WAITQUEUE(wait, current);
-        struct vhci_data *vhci = file->private_data;
+        struct vhci_data *data = file->private_data;
         struct sk_buff *skb;
         ssize_t ret = 0;
 
-        add_wait_queue(&vhci->read_wait, &wait);
+        add_wait_queue(&data->read_wait, &wait);
         while (count) {
                 set_current_state(TASK_INTERRUPTIBLE);
 
-                skb = skb_dequeue(&vhci->readq);
+                skb = skb_dequeue(&data->readq);
                 if (!skb) {
                         if (file->f_flags & O_NONBLOCK) {
                                 ret = -EAGAIN;
@@ -213,7 +214,7 @@ static ssize_t vhci_read(struct file * file, char __user * buf, size_t count, lo
                 }
 
                 if (access_ok(VERIFY_WRITE, buf, count))
-                        ret = vhci_put_user(vhci, skb, buf, count);
+                        ret = vhci_put_user(data, skb, buf, count);
                 else
                         ret = -EFAULT;
 
@@ -221,7 +222,7 @@ static ssize_t vhci_read(struct file * file, char __user * buf, size_t count, lo
                 break;
         }
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(&vhci->read_wait, &wait);
+        remove_wait_queue(&data->read_wait, &wait);
 
         return ret;
 }
@@ -229,21 +230,21 @@ static ssize_t vhci_read(struct file * file, char __user * buf, size_t count, lo
 static ssize_t vhci_write(struct file *file,
                         const char __user *buf, size_t count, loff_t *pos)
 {
-        struct vhci_data *vhci = file->private_data;
+        struct vhci_data *data = file->private_data;
 
         if (!access_ok(VERIFY_READ, buf, count))
                 return -EFAULT;
 
-        return vhci_get_user(vhci, buf, count);
+        return vhci_get_user(data, buf, count);
 }
 
 static unsigned int vhci_poll(struct file *file, poll_table *wait)
 {
-        struct vhci_data *vhci = file->private_data;
+        struct vhci_data *data = file->private_data;
 
-        poll_wait(file, &vhci->read_wait, wait);
+        poll_wait(file, &data->read_wait, wait);
 
-        if (!skb_queue_empty(&vhci->readq))
+        if (!skb_queue_empty(&data->readq))
                 return POLLIN | POLLRDNORM;
 
         return POLLOUT | POLLWRNORM;
@@ -257,26 +258,26 @@ static int vhci_ioctl(struct inode *inode, struct file *file,
 
 static int vhci_open(struct inode *inode, struct file *file)
 {
-        struct vhci_data *vhci;
+        struct vhci_data *data;
         struct hci_dev *hdev;
 
-        vhci = kzalloc(sizeof(struct vhci_data), GFP_KERNEL);
-        if (!vhci)
+        data = kzalloc(sizeof(struct vhci_data), GFP_KERNEL);
+        if (!data)
                 return -ENOMEM;
 
-        skb_queue_head_init(&vhci->readq);
-        init_waitqueue_head(&vhci->read_wait);
+        skb_queue_head_init(&data->readq);
+        init_waitqueue_head(&data->read_wait);
 
         hdev = hci_alloc_dev();
         if (!hdev) {
-                kfree(vhci);
+                kfree(data);
                 return -ENOMEM;
         }
 
-        vhci->hdev = hdev;
+        data->hdev = hdev;
 
-        hdev->type = HCI_VHCI;
-        hdev->driver_data = vhci;
+        hdev->type = HCI_VIRTUAL;
+        hdev->driver_data = data;
 
         hdev->open     = vhci_open_dev;
         hdev->close    = vhci_close_dev;
@@ -288,20 +289,20 @@ static int vhci_open(struct inode *inode, struct file *file)
 
         if (hci_register_dev(hdev) < 0) {
                 BT_ERR("Can't register HCI device");
-                kfree(vhci);
+                kfree(data);
                 hci_free_dev(hdev);
                 return -EBUSY;
         }
 
-        file->private_data = vhci;
+        file->private_data = data;
 
         return nonseekable_open(inode, file);
 }
 
 static int vhci_release(struct inode *inode, struct file *file)
 {
-        struct vhci_data *vhci = file->private_data;
-        struct hci_dev *hdev = vhci->hdev;
+        struct vhci_data *data = file->private_data;
+        struct hci_dev *hdev = data->hdev;
 
         if (hci_unregister_dev(hdev) < 0) {
                 BT_ERR("Can't unregister HCI device %s", hdev->name);
@@ -316,17 +317,17 @@ static int vhci_release(struct inode *inode, struct file *file)
 
 static int vhci_fasync(int fd, struct file *file, int on)
 {
-        struct vhci_data *vhci = file->private_data;
+        struct vhci_data *data = file->private_data;
         int err;
 
-        err = fasync_helper(fd, file, on, &vhci->fasync);
+        err = fasync_helper(fd, file, on, &data->fasync);
         if (err < 0)
                 return err;
 
         if (on)
-                vhci->flags |= VHCI_FASYNC;
+                data->flags |= VHCI_FASYNC;
         else
-                vhci->flags &= ~VHCI_FASYNC;
+                data->flags &= ~VHCI_FASYNC;
 
         return 0;
 }
diff --git a/drivers/infiniband/core/addr.c b/drivers/infiniband/core/addr.c
index 9cbf09e2052f..60d3fbdd216c 100644
--- a/drivers/infiniband/core/addr.c
+++ b/drivers/infiniband/core/addr.c
@@ -86,7 +86,7 @@ EXPORT_SYMBOL(rdma_copy_addr);
 int rdma_translate_ip(struct sockaddr *addr, struct rdma_dev_addr *dev_addr)
 {
         struct net_device *dev;
-        u32 ip = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
+        __be32 ip = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
         int ret;
 
         dev = ip_dev_find(ip);
@@ -239,7 +239,7 @@ static int addr_resolve_local(struct sockaddr_in *src_in,
 {
         struct net_device *dev;
         u32 src_ip = src_in->sin_addr.s_addr;
-        u32 dst_ip = dst_in->sin_addr.s_addr;
+        __be32 dst_ip = dst_in->sin_addr.s_addr;
         int ret;
 
         dev = ip_dev_find(dst_ip);
diff --git a/drivers/isdn/i4l/isdn_net.c b/drivers/isdn/i4l/isdn_net.c
index 43da8ae1b2ad..1f8d6ae66b41 100644
--- a/drivers/isdn/i4l/isdn_net.c
+++ b/drivers/isdn/i4l/isdn_net.c
@@ -1614,8 +1614,8 @@ isdn_net_ciscohdlck_slarp_send_reply(isdn_net_local *lp)
         struct sk_buff *skb;
         unsigned char *p;
         struct in_device *in_dev = NULL;
-        u32 addr = 0;           /* local ipv4 address */
-        u32 mask = 0;           /* local netmask */
+        __be32 addr = 0;                /* local ipv4 address */
+        __be32 mask = 0;                /* local netmask */
 
         if ((in_dev = lp->netdev->dev.ip_ptr) != NULL) {
                 /* take primary(first) address of interface */
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 63154774c257..ff8a8c0a26d5 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -24,6 +24,9 @@ config NETDEVICES
 
           If unsure, say Y.
 
+# All the following symbols are dependent on NETDEVICES - do not repeat
+# that for each of the symbols.
+if NETDEVICES
 
 config IFB
         tristate "Intermediate Functional Block support"
@@ -2852,6 +2855,8 @@ config NETCONSOLE
         If you want to log kernel messages over the network, enable this.
         See <file:Documentation/networking/netconsole.txt> for details.
 
+endif #NETDEVICES
+
 config NETPOLL
         def_bool NETCONSOLE
 
diff --git a/drivers/net/appletalk/ipddp.c b/drivers/net/appletalk/ipddp.c
index 7f7dd450226a..b98592a8bac8 100644
--- a/drivers/net/appletalk/ipddp.c
+++ b/drivers/net/appletalk/ipddp.c
@@ -145,9 +145,7 @@ static int ipddp_xmit(struct sk_buff *skb, struct net_device *dev)
 
         /* Create the Extended DDP header */
         ddp = (struct ddpehdr *)skb->data;
-        ddp->deh_len = skb->len;
-        ddp->deh_hops = 1;
-        ddp->deh_pad = 0;
+        ddp->deh_len_hops = htons(skb->len + (1<<10));
         ddp->deh_sum = 0;
 
         /*
@@ -170,7 +168,6 @@ static int ipddp_xmit(struct sk_buff *skb, struct net_device *dev)
         ddp->deh_sport = 72;
 
         *((__u8 *)(ddp+1)) = 22;                /* ddp type = IP */
-        *((__u16 *)ddp)=ntohs(*((__u16 *)ddp)); /* fix up length field */
 
         skb->protocol = htons(ETH_P_ATALK);     /* Protocol has changed */
 
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 0fb5f653d3ce..c0bbddae4ec4 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -2252,7 +2252,7 @@ static u32 bond_glean_dev_ip(struct net_device *dev)
 {
         struct in_device *idev;
         struct in_ifaddr *ifa;
-        u32 addr = 0;
+        __be32 addr = 0;
 
         if (!dev)
                 return 0;
diff --git a/drivers/net/irda/Kconfig b/drivers/net/irda/Kconfig
index e9e6d99a9add..7c8ccc09b601 100644
--- a/drivers/net/irda/Kconfig
+++ b/drivers/net/irda/Kconfig
@@ -287,6 +287,7 @@ comment "FIR device drivers"
 config USB_IRDA
         tristate "IrDA USB dongles"
         depends on IRDA && USB
+        select FW_LOADER
         ---help---
           Say Y here if you want to build support for the USB IrDA FIR Dongle
           device driver.  To compile it as a module, choose M here: the module
diff --git a/drivers/net/irda/nsc-ircc.c b/drivers/net/irda/nsc-ircc.c
index cb62f2a9676a..7185a4ee3c1e 100644
--- a/drivers/net/irda/nsc-ircc.c
+++ b/drivers/net/irda/nsc-ircc.c
@@ -110,7 +110,7 @@ static nsc_chip_t chips[] = {
         { "PC87338", { 0x398, 0x15c, 0x2e }, 0x08, 0xb0, 0xf8, 
           nsc_ircc_probe_338, nsc_ircc_init_338 },
         /* Contributed by Steffen Pingel - IBM X40 */
-        { "PC8738x", { 0x164e, 0x4e, 0x0 }, 0x20, 0xf4, 0xff,
+        { "PC8738x", { 0x164e, 0x4e, 0x2e }, 0x20, 0xf4, 0xff,
           nsc_ircc_probe_39x, nsc_ircc_init_39x },
         /* Contributed by Jan Frey - IBM A30/A31 */
         { "PC8739x", { 0x2e, 0x4e, 0x0 }, 0x20, 0xea, 0xff, 
diff --git a/drivers/net/irda/smsc-ircc2.c b/drivers/net/irda/smsc-ircc2.c
index 2eff45bedc7c..22358ff68c4c 100644
--- a/drivers/net/irda/smsc-ircc2.c
+++ b/drivers/net/irda/smsc-ircc2.c
@@ -2354,6 +2354,26 @@ static int __init smsc_superio_lpc(unsigned short cfg_base)
 #define PCIID_VENDOR_INTEL 0x8086
 #define PCIID_VENDOR_ALI 0x10b9
 static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __initdata = {
+        /*
+         * Subsystems needing entries:
+         * 0x10b9:0x1533 0x103c:0x0850 HP nx9010 family
+         * 0x10b9:0x1533 0x0e11:0x005a Compaq nc4000 family
+         * 0x8086:0x24cc 0x0e11:0x002a HP nx9000 family
+         */
+        {
+                /* Guessed entry */
+                .vendor = PCIID_VENDOR_INTEL, /* Intel 82801DBM LPC bridge */
+                .device = 0x24cc,
+                .subvendor = 0x103c,
+                .subdevice = 0x08bc,
+                .sir_io = 0x02f8,
+                .fir_io = 0x0130,
+                .fir_irq = 0x05,
+                .fir_dma = 0x03,
+                .cfg_base = 0x004e,
+                .preconfigure = preconfigure_through_82801,
+                .name = "HP nx5000 family",
+        },
         {
                 .vendor = PCIID_VENDOR_INTEL, /* Intel 82801DBM LPC bridge */
                 .device = 0x24cc,
@@ -2366,7 +2386,7 @@ static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __ini
                 .fir_dma = 0x03,
                 .cfg_base = 0x004e,
                 .preconfigure = preconfigure_through_82801,
-                .name = "HP nc8000",
+                .name = "HP nc8000 family",
         },
         {
                 .vendor = PCIID_VENDOR_INTEL, /* Intel 82801DBM LPC bridge */
@@ -2379,7 +2399,21 @@ static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __ini
                 .fir_dma = 0x03,
                 .cfg_base = 0x004e,
                 .preconfigure = preconfigure_through_82801,
-                .name = "HP nc6000",
+                .name = "HP nc6000 family",
+        },
+        {
+                .vendor = PCIID_VENDOR_INTEL, /* Intel 82801DBM LPC bridge */
+                .device = 0x24cc,
+                .subvendor = 0x0e11,
+                .subdevice = 0x0860,
+                /* I assume these are the same for x1000 as for the others */
+                .sir_io = 0x02e8,
+                .fir_io = 0x02f8,
+                .fir_irq = 0x07,
+                .fir_dma = 0x03,
+                .cfg_base = 0x002e,
+                .preconfigure = preconfigure_through_82801,
+                .name = "Compaq x1000 family",
         },
         {
                 /* Intel 82801DB/DBL (ICH4/ICH4-L) LPC Interface Bridge */
diff --git a/drivers/net/irda/stir4200.c b/drivers/net/irda/stir4200.c
index d61b208b52a2..12103c93f7ef 100644
--- a/drivers/net/irda/stir4200.c
+++ b/drivers/net/irda/stir4200.c
@@ -149,8 +149,6 @@ enum StirFifoCtlMask {
         FIFOCTL_DIR = 0x10,
         FIFOCTL_CLR = 0x08,
         FIFOCTL_EMPTY = 0x04,
-        FIFOCTL_RXERR = 0x02,
-        FIFOCTL_TXERR = 0x01,
 };
 
 enum StirDiagMask {
@@ -615,19 +613,6 @@ static int fifo_txwait(struct stir_cb *stir, int space)
 
                 pr_debug("fifo status 0x%lx count %lu\n", status, count);
 
-                /* error when receive/transmit fifo gets confused */
-                if (status & FIFOCTL_RXERR) {
-                        stir->stats.rx_fifo_errors++;
-                        stir->stats.rx_errors++;
-                        break;
-                }
-
-                if (status & FIFOCTL_TXERR) {
-                        stir->stats.tx_fifo_errors++;
-                        stir->stats.tx_errors++;
-                        break;
-                }
-
                 /* is fifo receiving already, or empty */
                 if (!(status & FIFOCTL_DIR)
                     || (status & FIFOCTL_EMPTY))
diff --git a/drivers/net/irda/via-ircc.c b/drivers/net/irda/via-ircc.c
index 79b85f327500..d916e1257c47 100644
--- a/drivers/net/irda/via-ircc.c
+++ b/drivers/net/irda/via-ircc.c
@@ -1223,8 +1223,13 @@ static int upload_rxdata(struct via_ircc_cb *self, int iobase)
 
         IRDA_DEBUG(2, "%s(): len=%x\n", __FUNCTION__, len);
 
+        if ((len - 4) < 2) {
+                self->stats.rx_dropped++;
+                return FALSE;
+        }
+
         skb = dev_alloc_skb(len + 1);
-        if ((skb == NULL) || ((len - 4) < 2)) {
+        if (skb == NULL) {
                 self->stats.rx_dropped++;
                 return FALSE;
         }
diff --git a/drivers/net/loopback.c b/drivers/net/loopback.c
index f429b19bf620..4178b4b1d2df 100644
--- a/drivers/net/loopback.c
+++ b/drivers/net/loopback.c
@@ -161,15 +161,13 @@ static int loopback_xmit(struct sk_buff *skb, struct net_device *dev)
         return(0);
 }
 
+static struct net_device_stats loopback_stats;
+
 static struct net_device_stats *get_stats(struct net_device *dev)
 {
-        struct net_device_stats *stats = dev->priv;
+        struct net_device_stats *stats = &loopback_stats;
         int i;
 
-        if (!stats) {
-                return NULL;
-        }
-
         memset(stats, 0, sizeof(struct net_device_stats));
 
         for_each_possible_cpu(i) {
@@ -185,19 +183,28 @@ static struct net_device_stats *get_stats(struct net_device *dev)
         return stats;
 }
 
-static u32 loopback_get_link(struct net_device *dev)
+static u32 always_on(struct net_device *dev)
 {
         return 1;
 }
 
 static const struct ethtool_ops loopback_ethtool_ops = {
-        .get_link               = loopback_get_link,
+        .get_link               = always_on,
         .get_tso                = ethtool_op_get_tso,
         .set_tso                = ethtool_op_set_tso,
+        .get_tx_csum            = always_on,
+        .get_sg                 = always_on,
+        .get_rx_csum            = always_on,
 };
 
+/*
+ * The loopback device is special. There is only one instance and
+ * it is statically allocated. Don't do this for other devices.
+ */
 struct net_device loopback_dev = {
         .name                   = "lo",
+        .get_stats              = &get_stats,
+        .priv                   = &loopback_stats,
         .mtu                    = (16 * 1024) + 20 + 20 + 12,
         .hard_start_xmit        = loopback_xmit,
         .hard_header            = eth_header,
@@ -221,16 +228,6 @@ struct net_device loopback_dev = {
 /* Setup and register the loopback device. */
 int __init loopback_init(void)
 {
-        struct net_device_stats *stats;
-
-        /* Can survive without statistics */
-        stats = kmalloc(sizeof(struct net_device_stats), GFP_KERNEL);
-        if (stats) {
-                memset(stats, 0, sizeof(struct net_device_stats));
-                loopback_dev.priv = stats;
-                loopback_dev.get_stats = &get_stats;
-        }
-
         return register_netdev(&loopback_dev);
 };
 
diff --git a/drivers/net/pppoe.c b/drivers/net/pppoe.c
index 5666ed998142..0adee733b761 100644
--- a/drivers/net/pppoe.c
+++ b/drivers/net/pppoe.c
@@ -600,6 +600,7 @@ static int pppoe_connect(struct socket *sock, struct sockaddr *uservaddr,
                 po->chan.hdrlen = (sizeof(struct pppoe_hdr) +
                                    dev->hard_header_len);
 
+                po->chan.mtu = dev->mtu - sizeof(struct pppoe_hdr);
                 po->chan.private = sk;
                 po->chan.ops = &pppoe_chan_ops;
 
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index aaf45b907a78..c25ba273b745 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -68,8 +68,8 @@
 
 #define DRV_MODULE_NAME         "tg3"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "3.65"
-#define DRV_MODULE_RELDATE      "August 07, 2006"
+#define DRV_MODULE_VERSION      "3.66"
+#define DRV_MODULE_RELDATE      "September 23, 2006"
 
 #define TG3_DEF_MAC_MODE        0
 #define TG3_DEF_RX_MODE         0
@@ -173,6 +173,7 @@ static struct pci_device_id tg3_pci_tbl[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705F)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5720)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5721)},
+        {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5722)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5750)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5751)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5750M)},
@@ -187,6 +188,7 @@ static struct pci_device_id tg3_pci_tbl[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5754M)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5755)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5755M)},
+        {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5756)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5786)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787M)},
@@ -197,6 +199,8 @@ static struct pci_device_id tg3_pci_tbl[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5780)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5780S)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5781)},
+        {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5906)},
+        {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5906M)},
         {PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_9DXX)},
         {PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_9MXX)},
         {PCI_DEVICE(PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC1000)},
@@ -424,6 +428,16 @@ static void tg3_write32_tx_mbox(struct tg3 *tp, u32 off, u32 val)
                 readl(mbox);
 }
 
+static u32 tg3_read32_mbox_5906(struct tg3 *tp, u32 off)
+{
+        return (readl(tp->regs + off + GRCMBOX_BASE));
+}
+
+static void tg3_write32_mbox_5906(struct tg3 *tp, u32 off, u32 val)
+{
+        writel(val, tp->regs + off + GRCMBOX_BASE);
+}
+
 #define tw32_mailbox(reg, val)  tp->write32_mbox(tp, reg, val)
 #define tw32_mailbox_f(reg, val)        tw32_mailbox_flush(tp, (reg), (val))
 #define tw32_rx_mbox(reg, val)  tp->write32_rx_mbox(tp, reg, val)
@@ -439,6 +453,10 @@ static void tg3_write_mem(struct tg3 *tp, u32 off, u32 val)
 {
         unsigned long flags;
 
+        if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) &&
+            (off >= NIC_SRAM_STATS_BLK) && (off < NIC_SRAM_TX_BUFFER_DESC))
+                return;
+
         spin_lock_irqsave(&tp->indirect_lock, flags);
         if (tp->tg3_flags & TG3_FLAG_SRAM_USE_CONFIG) {
                 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, off);
@@ -460,6 +478,12 @@ static void tg3_read_mem(struct tg3 *tp, u32 off, u32 *val)
 {
         unsigned long flags;
 
+        if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) &&
+            (off >= NIC_SRAM_STATS_BLK) && (off < NIC_SRAM_TX_BUFFER_DESC)) {
+                *val = 0;
+                return;
+        }
+
         spin_lock_irqsave(&tp->indirect_lock, flags);
         if (tp->tg3_flags & TG3_FLAG_SRAM_USE_CONFIG) {
                 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, off);
@@ -489,6 +513,9 @@ static inline void tg3_cond_int(struct tg3 *tp)
         if (!(tp->tg3_flags & TG3_FLAG_TAGGED_STATUS) &&
             (tp->hw_status->status & SD_STATUS_UPDATED))
                 tw32(GRC_LOCAL_CTRL, tp->grc_local_ctrl | GRC_LCLCTRL_SETINT);
+        else
+                tw32(HOSTCC_MODE, tp->coalesce_mode |
+                     (HOSTCC_MODE_ENABLE | HOSTCC_MODE_NOW));
 }
 
 static void tg3_enable_ints(struct tg3 *tp)
@@ -654,6 +681,10 @@ static int tg3_writephy(struct tg3 *tp, int reg, u32 val)
         unsigned int loops;
         int ret;
 
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906 &&
+            (reg == MII_TG3_CTRL || reg == MII_TG3_AUX_CTRL))
+                return 0;
+
         if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
                 tw32_f(MAC_MI_MODE,
                      (tp->mi_mode & ~MAC_MI_MODE_AUTO_POLL));
@@ -1004,6 +1035,24 @@ out:
                                  phy_reg | MII_TG3_EXT_CTRL_FIFO_ELASTIC);
         }
 
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
+                u32 phy_reg;
+
+                /* adjust output voltage */
+                tg3_writephy(tp, MII_TG3_EPHY_PTEST, 0x12);
+
+                if (!tg3_readphy(tp, MII_TG3_EPHY_TEST, &phy_reg)) {
+                        u32 phy_reg2;
+
+                        tg3_writephy(tp, MII_TG3_EPHY_TEST,
+                                     phy_reg | MII_TG3_EPHY_SHADOW_EN);
+                        /* Enable auto-MDIX */
+                        if (!tg3_readphy(tp, 0x10, &phy_reg2))
+                                tg3_writephy(tp, 0x10, phy_reg2 | 0x4000);
+                        tg3_writephy(tp, MII_TG3_EPHY_TEST, phy_reg);
+                }
+        }
+
         tg3_phy_set_wirespeed(tp);
         return 0;
 }
@@ -1117,6 +1166,15 @@ static void tg3_nvram_unlock(struct tg3 *);
 
 static void tg3_power_down_phy(struct tg3 *tp)
 {
+        if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
+                return;
+
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5906) {
+                tg3_writephy(tp, MII_TG3_EXT_CTRL,
+                             MII_TG3_EXT_CTRL_FORCE_LED_OFF);
+                tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x01b2);
+        }
+
         /* The PHY should not be powered down on some chips because
          * of bugs.
          */
@@ -1199,7 +1257,12 @@ static int tg3_set_power_state(struct tg3 *tp, pci_power_t state)
                 tg3_setup_phy(tp, 0);
         }
 
-        if (!(tp->tg3_flags & TG3_FLAG_ENABLE_ASF)) {
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
+                u32 val;
+
+                val = tr32(GRC_VCPU_EXT_CTRL);
+                tw32(GRC_VCPU_EXT_CTRL, val | GRC_VCPU_EXT_CTRL_DISABLE_WOL);
+        } else if (!(tp->tg3_flags & TG3_FLAG_ENABLE_ASF)) {
                 int i;
                 u32 val;
 
@@ -1223,7 +1286,10 @@ static int tg3_set_power_state(struct tg3 *tp, pci_power_t state)
                         tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x5a);
                         udelay(40);
 
-                        mac_mode = MAC_MODE_PORT_MODE_MII;
+                        if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES)
+                                mac_mode = MAC_MODE_PORT_MODE_GMII;
+                        else
+                                mac_mode = MAC_MODE_PORT_MODE_MII;
 
                         if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700 ||
                             !(tp->tg3_flags & TG3_FLAG_WOL_SPEED_100MB))
@@ -1301,15 +1367,8 @@ static int tg3_set_power_state(struct tg3 *tp, pci_power_t state)
         }
 
         if (!(tp->tg3_flags & TG3_FLAG_WOL_ENABLE) &&
-            !(tp->tg3_flags & TG3_FLAG_ENABLE_ASF)) {
-                /* Turn off the PHY */
-                if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)) {
-                        tg3_writephy(tp, MII_TG3_EXT_CTRL,
-                                     MII_TG3_EXT_CTRL_FORCE_LED_OFF);
-                        tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x01b2);
-                        tg3_power_down_phy(tp);
-                }
-        }
+            !(tp->tg3_flags & TG3_FLAG_ENABLE_ASF))
+                tg3_power_down_phy(tp);
 
         tg3_frob_aux_power(tp);
 
@@ -1467,6 +1526,13 @@ static void tg3_aux_stat_to_speed_duplex(struct tg3 *tp, u32 val, u16 *speed, u8
                 break;
 
         default:
+                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
+                        *speed = (val & MII_TG3_AUX_STAT_100) ? SPEED_100 :
+                                 SPEED_10;
+                        *duplex = (val & MII_TG3_AUX_STAT_FULL) ? DUPLEX_FULL :
+                                  DUPLEX_HALF;
+                        break;
+                }
                 *speed = SPEED_INVALID;
                 *duplex = DUPLEX_INVALID;
                 break;
@@ -1749,7 +1815,7 @@ static int tg3_setup_copper_phy(struct tg3 *tp, int force_reset)
 
         if (tp->tg3_flags & TG3_FLAG_USE_MI_INTERRUPT)
                 tg3_writephy(tp, MII_TG3_IMASK, ~MII_TG3_INT_LINKCHG);
-        else
+        else if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5906)
                 tg3_writephy(tp, MII_TG3_IMASK, ~0);
 
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
@@ -2406,24 +2472,27 @@ static int tg3_setup_fiber_hw_autoneg(struct tg3 *tp, u32 mac_status)
         expected_sg_dig_ctrl |= (1 << 12);
 
         if (sg_dig_ctrl != expected_sg_dig_ctrl) {
+                if ((tp->tg3_flags2 & TG3_FLG2_PARALLEL_DETECT) &&
+                    tp->serdes_counter &&
+                    ((mac_status & (MAC_STATUS_PCS_SYNCED |
+                                    MAC_STATUS_RCVD_CFG)) ==
+                     MAC_STATUS_PCS_SYNCED)) {
+                        tp->serdes_counter--;
+                        current_link_up = 1;
+                        goto out;
+                }
+restart_autoneg:
                 if (workaround)
                         tw32_f(MAC_SERDES_CFG, serdes_cfg | 0xc011000);
                 tw32_f(SG_DIG_CTRL, expected_sg_dig_ctrl | (1 << 30));
                 udelay(5);
                 tw32_f(SG_DIG_CTRL, expected_sg_dig_ctrl);
 
-                tp->tg3_flags2 |= TG3_FLG2_PHY_JUST_INITTED;
+                tp->serdes_counter = SERDES_AN_TIMEOUT_5704S;
+                tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
         } else if (mac_status & (MAC_STATUS_PCS_SYNCED |
                                  MAC_STATUS_SIGNAL_DET)) {
-                int i;
-
-                /* Giver time to negotiate (~200ms) */
-                for (i = 0; i < 40000; i++) {
-                        sg_dig_status = tr32(SG_DIG_STATUS);
-                        if (sg_dig_status & (0x3))
-                                break;
-                        udelay(5);
-                }
+                sg_dig_status = tr32(SG_DIG_STATUS);
                 mac_status = tr32(MAC_STATUS);
 
                 if ((sg_dig_status & (1 << 1)) &&
@@ -2439,10 +2508,11 @@ static int tg3_setup_fiber_hw_autoneg(struct tg3 *tp, u32 mac_status)
 
                         tg3_setup_flow_control(tp, local_adv, remote_adv);
                         current_link_up = 1;
-                        tp->tg3_flags2 &= ~TG3_FLG2_PHY_JUST_INITTED;
+                        tp->serdes_counter = 0;
+                        tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
                 } else if (!(sg_dig_status & (1 << 1))) {
-                        if (tp->tg3_flags2 & TG3_FLG2_PHY_JUST_INITTED)
-                                tp->tg3_flags2 &= ~TG3_FLG2_PHY_JUST_INITTED;
+                        if (tp->serdes_counter)
+                                tp->serdes_counter--;
                         else {
                                 if (workaround) {
                                         u32 val = serdes_cfg;
@@ -2466,9 +2536,17 @@ static int tg3_setup_fiber_hw_autoneg(struct tg3 *tp, u32 mac_status)
                                     !(mac_status & MAC_STATUS_RCVD_CFG)) {
                                         tg3_setup_flow_control(tp, 0, 0);
                                         current_link_up = 1;
-                                }
+                                        tp->tg3_flags2 |=
+                                                TG3_FLG2_PARALLEL_DETECT;
+                                        tp->serdes_counter =
+                                                SERDES_PARALLEL_DET_TIMEOUT;
+                                } else
+                                        goto restart_autoneg;
                         }
                 }
+        } else {
+                tp->serdes_counter = SERDES_AN_TIMEOUT_5704S;
+                tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
         }
 
 out:
@@ -2599,14 +2677,16 @@ static int tg3_setup_fiber_phy(struct tg3 *tp, int force_reset)
                                     MAC_STATUS_CFG_CHANGED));
                 udelay(5);
                 if ((tr32(MAC_STATUS) & (MAC_STATUS_SYNC_CHANGED |
-                                         MAC_STATUS_CFG_CHANGED)) == 0)
+                                         MAC_STATUS_CFG_CHANGED |
+                                         MAC_STATUS_LNKSTATE_CHANGED)) == 0)
                         break;
         }
 
         mac_status = tr32(MAC_STATUS);
         if ((mac_status & MAC_STATUS_PCS_SYNCED) == 0) {
                 current_link_up = 0;
-                if (tp->link_config.autoneg == AUTONEG_ENABLE) {
+                if (tp->link_config.autoneg == AUTONEG_ENABLE &&
+                    tp->serdes_counter == 0) {
                         tw32_f(MAC_MODE, (tp->mac_mode |
                                           MAC_MODE_SEND_CONFIGS));
                         udelay(1);
@@ -2711,7 +2791,7 @@ static int tg3_setup_fiber_mii_phy(struct tg3 *tp, int force_reset)
                         tg3_writephy(tp, MII_BMCR, bmcr);
 
                         tw32_f(MAC_EVENT, MAC_EVENT_LNKSTATE_CHANGED);
-                        tp->tg3_flags2 |= TG3_FLG2_PHY_JUST_INITTED;
+                        tp->serdes_counter = SERDES_AN_TIMEOUT_5714S;
                         tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
 
                         return err;
@@ -2816,9 +2896,9 @@ static int tg3_setup_fiber_mii_phy(struct tg3 *tp, int force_reset)
 
 static void tg3_serdes_parallel_detect(struct tg3 *tp)
 {
-        if (tp->tg3_flags2 & TG3_FLG2_PHY_JUST_INITTED) {
+        if (tp->serdes_counter) {
                 /* Give autoneg time to complete. */
-                tp->tg3_flags2 &= ~TG3_FLG2_PHY_JUST_INITTED;
+                tp->serdes_counter--;
                 return;
         }
         if (!netif_carrier_ok(tp->dev) &&
@@ -3535,8 +3615,7 @@ static irqreturn_t tg3_test_isr(int irq, void *dev_id,
 
         if ((sblk->status & SD_STATUS_UPDATED) ||
             !(tr32(TG3PCI_PCISTATE) & PCISTATE_INT_NOT_ACTIVE)) {
-                tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
-                             0x00000001);
+                tg3_disable_ints(tp);
                 return IRQ_RETVAL(1);
         }
         return IRQ_RETVAL(0);
@@ -4644,6 +4723,44 @@ static void tg3_write_sig_legacy(struct tg3 *tp, int kind)
         }
 }
 
+static int tg3_poll_fw(struct tg3 *tp)
+{
+        int i;
+        u32 val;
+
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
+                for (i = 0; i < 400; i++) {
+                        if (tr32(VCPU_STATUS) & VCPU_STATUS_INIT_DONE)
+                                return 0;
+                        udelay(10);
+                }
+                return -ENODEV;
+        }
+
+        /* Wait for firmware initialization to complete. */
+        for (i = 0; i < 100000; i++) {
+                tg3_read_mem(tp, NIC_SRAM_FIRMWARE_MBOX, &val);
+                if (val == ~NIC_SRAM_FIRMWARE_MBOX_MAGIC1)
+                        break;
+                udelay(10);
+        }
+
+        /* Chip might not be fitted with firmware.  Some Sun onboard
+         * parts are configured like that.  So don't signal the timeout
+         * of the above loop as an error, but do report the lack of
+         * running firmware once.
+         */
+        if (i >= 100000 &&
+            !(tp->tg3_flags2 & TG3_FLG2_NO_FWARE_REPORTED)) {
+                tp->tg3_flags2 |= TG3_FLG2_NO_FWARE_REPORTED;
+
+                printk(KERN_INFO PFX "%s: No firmware running.\n",
+                       tp->dev->name);
+        }
+
+        return 0;
+}
+
 static void tg3_stop_fw(struct tg3 *);
 
 /* tp->lock is held. */
@@ -4651,7 +4768,7 @@ static int tg3_chip_reset(struct tg3 *tp)
 {
         u32 val;
         void (*write_op)(struct tg3 *, u32, u32);
-        int i;
+        int err;
 
         tg3_nvram_lock(tp);
 
@@ -4688,6 +4805,12 @@ static int tg3_chip_reset(struct tg3 *tp)
                 }
         }
 
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
+                tw32(VCPU_STATUS, tr32(VCPU_STATUS) | VCPU_STATUS_DRV_RESET);
+                tw32(GRC_VCPU_EXT_CTRL,
+                     tr32(GRC_VCPU_EXT_CTRL) & ~GRC_VCPU_EXT_CTRL_HALT_CPU);
+        }
+
         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)
                 val |= GRC_MISC_CFG_KEEP_GPHY_POWER;
         tw32(GRC_MISC_CFG, val);
@@ -4811,26 +4934,9 @@ static int tg3_chip_reset(struct tg3 *tp)
                 tw32_f(MAC_MODE, 0);
         udelay(40);
 
-        /* Wait for firmware initialization to complete. */
-        for (i = 0; i < 100000; i++) {
-                tg3_read_mem(tp, NIC_SRAM_FIRMWARE_MBOX, &val);
-                if (val == ~NIC_SRAM_FIRMWARE_MBOX_MAGIC1)
-                        break;
-                udelay(10);
-        }
-
-        /* Chip might not be fitted with firmare.  Some Sun onboard
-         * parts are configured like that.  So don't signal the timeout
-         * of the above loop as an error, but do report the lack of
-         * running firmware once.
-         */
-        if (i >= 100000 &&
-            !(tp->tg3_flags2 & TG3_FLG2_NO_FWARE_REPORTED)) {
-                tp->tg3_flags2 |= TG3_FLG2_NO_FWARE_REPORTED;
-
-                printk(KERN_INFO PFX "%s: No firmware running.\n",
-                       tp->dev->name);
-        }
+        err = tg3_poll_fw(tp);
+        if (err)
+                return err;
 
         if ((tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) &&
             tp->pci_chip_rev_id != CHIPREV_ID_5750_A0) {
@@ -5036,6 +5142,12 @@ static int tg3_halt_cpu(struct tg3 *tp, u32 offset)
         BUG_ON(offset == TX_CPU_BASE &&
             (tp->tg3_flags2 & TG3_FLG2_5705_PLUS));
 
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
+                u32 val = tr32(GRC_VCPU_EXT_CTRL);
+
+                tw32(GRC_VCPU_EXT_CTRL, val | GRC_VCPU_EXT_CTRL_HALT_CPU);
+                return 0;
+        }
         if (offset == RX_CPU_BASE) {
                 for (i = 0; i < 10000; i++) {
                         tw32(offset + CPU_STATE, 0xffffffff);
@@ -6040,6 +6152,13 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
                 val = 1;
         else if (val > tp->rx_std_max_post)
                 val = tp->rx_std_max_post;
+        else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
+                if (tp->pci_chip_rev_id == CHIPREV_ID_5906_A1)
+                        tw32(ISO_PKT_TX, (tr32(ISO_PKT_TX) & ~0x3) | 0x2);
+
+                if (val > (TG3_RX_INTERNAL_RING_SZ_5906 / 2))
+                        val = TG3_RX_INTERNAL_RING_SZ_5906 / 2;
+        }
 
         tw32(RCVBDI_STD_THRESH, val);
 
@@ -6460,7 +6579,8 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
         if (err)
                 return err;
 
-        if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)) {
+        if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) &&
+            GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5906) {
                 u32 tmp;
 
                 /* Clear CRC stats. */
@@ -6660,12 +6780,14 @@ static void tg3_timer(unsigned long __opaque)
                                 need_setup = 1;
                         }
                         if (need_setup) {
-                                tw32_f(MAC_MODE,
-                                     (tp->mac_mode &
-                                      ~MAC_MODE_PORT_MODE_MASK));
-                                udelay(40);
-                                tw32_f(MAC_MODE, tp->mac_mode);
-                                udelay(40);
+                                if (!tp->serdes_counter) {
+                                        tw32_f(MAC_MODE,
+                                             (tp->mac_mode &
+                                              ~MAC_MODE_PORT_MODE_MASK));
+                                        udelay(40);
+                                        tw32_f(MAC_MODE, tp->mac_mode);
+                                        udelay(40);
+                                }
                                 tg3_setup_phy(tp, 0);
                         }
                 } else if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES)
@@ -6674,13 +6796,29 @@ static void tg3_timer(unsigned long __opaque)
                 tp->timer_counter = tp->timer_multiplier;
         }
 
-        /* Heartbeat is only sent once every 2 seconds.  */
+        /* Heartbeat is only sent once every 2 seconds.
+         *
+         * The heartbeat is to tell the ASF firmware that the host
+         * driver is still alive.  In the event that the OS crashes,
+         * ASF needs to reset the hardware to free up the FIFO space
+         * that may be filled with rx packets destined for the host.
+         * If the FIFO is full, ASF will no longer function properly.
+         *
+         * Unintended resets have been reported on real time kernels
+         * where the timer doesn't run on time.  Netpoll will also have
+         * same problem.
+         *
+         * The new FWCMD_NICDRV_ALIVE3 command tells the ASF firmware
+         * to check the ring condition when the heartbeat is expiring
+         * before doing the reset.  This will prevent most unintended
+         * resets.
+         */
         if (!--tp->asf_counter) {
                 if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) {
                         u32 val;
 
                         tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX,
-                                      FWCMD_NICDRV_ALIVE2);
+                                      FWCMD_NICDRV_ALIVE3);
                         tg3_write_mem(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 4);
                         /* 5 seconds timeout */
                         tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX, 5);
@@ -6721,8 +6859,7 @@ static int tg3_request_irq(struct tg3 *tp)
 static int tg3_test_interrupt(struct tg3 *tp)
 {
         struct net_device *dev = tp->dev;
-        int err, i;
-        u32 int_mbox = 0;
+        int err, i, intr_ok = 0;
 
         if (!netif_running(dev))
                 return -ENODEV;
@@ -6743,10 +6880,18 @@ static int tg3_test_interrupt(struct tg3 *tp)
                HOSTCC_MODE_NOW);
 
         for (i = 0; i < 5; i++) {
+                u32 int_mbox, misc_host_ctrl;
+
                 int_mbox = tr32_mailbox(MAILBOX_INTERRUPT_0 +
                                         TG3_64BIT_REG_LOW);
-                if (int_mbox != 0)
+                misc_host_ctrl = tr32(TG3PCI_MISC_HOST_CTRL);
+
+                if ((int_mbox != 0) ||
+                    (misc_host_ctrl & MISC_HOST_CTRL_MASK_PCI_INT)) {
+                        intr_ok = 1;
                         break;
+                }
+
                 msleep(10);
         }
 
@@ -6759,7 +6904,7 @@ static int tg3_test_interrupt(struct tg3 *tp)
         if (err)
                 return err;
 
-        if (int_mbox != 0)
+        if (intr_ok)
                 return 0;
 
         return -EIO;
@@ -6936,9 +7081,10 @@ static int tg3_open(struct net_device *dev)
 
                 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
                         if (tp->tg3_flags2 & TG3_FLG2_1SHOT_MSI) {
-                                u32 val = tr32(0x7c04);
+                                u32 val = tr32(PCIE_TRANSACTION_CFG);
 
-                                tw32(0x7c04, val | (1 << 29));
+                                tw32(PCIE_TRANSACTION_CFG,
+                                     val | PCIE_TRANS_CFG_1SHOT_MSI);
                         }
                 }
         }
@@ -7857,7 +8003,7 @@ static int tg3_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
         if (wol->wolopts & ~WAKE_MAGIC)
                 return -EINVAL;
         if ((wol->wolopts & WAKE_MAGIC) &&
-            tp->tg3_flags2 & TG3_FLG2_PHY_SERDES &&
+            tp->tg3_flags2 & TG3_FLG2_ANY_SERDES &&
             !(tp->tg3_flags & TG3_FLAG_SERDES_WOL_CAP))
                 return -EINVAL;
 
@@ -7893,7 +8039,8 @@ static int tg3_set_tso(struct net_device *dev, u32 value)
                         return -EINVAL;
                 return 0;
         }
-        if (tp->tg3_flags2 & TG3_FLG2_HW_TSO_2) {
+        if ((tp->tg3_flags2 & TG3_FLG2_HW_TSO_2) &&
+            (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5906)) {
                 if (value)
                         dev->features |= NETIF_F_TSO6;
                 else
@@ -8147,6 +8294,8 @@ static void tg3_get_ethtool_stats (struct net_device *dev,
 
 #define NVRAM_TEST_SIZE 0x100
 #define NVRAM_SELFBOOT_FORMAT1_SIZE 0x14
+#define NVRAM_SELFBOOT_HW_SIZE 0x20
+#define NVRAM_SELFBOOT_DATA_SIZE 0x1c
 
 static int tg3_test_nvram(struct tg3 *tp)
 {
@@ -8158,12 +8307,14 @@ static int tg3_test_nvram(struct tg3 *tp)
 
         if (magic == TG3_EEPROM_MAGIC)
                 size = NVRAM_TEST_SIZE;
-        else if ((magic & 0xff000000) == 0xa5000000) {
+        else if ((magic & TG3_EEPROM_MAGIC_FW_MSK) == TG3_EEPROM_MAGIC_FW) {
                 if ((magic & 0xe00000) == 0x200000)
                         size = NVRAM_SELFBOOT_FORMAT1_SIZE;
                 else
                         return 0;
-        } else
+        } else if ((magic & TG3_EEPROM_MAGIC_HW_MSK) == TG3_EEPROM_MAGIC_HW)
+                size = NVRAM_SELFBOOT_HW_SIZE;
+        else
                 return -EIO;
 
         buf = kmalloc(size, GFP_KERNEL);
@@ -8182,7 +8333,8 @@ static int tg3_test_nvram(struct tg3 *tp)
                 goto out;
 
         /* Selfboot format */
-        if (cpu_to_be32(buf[0]) != TG3_EEPROM_MAGIC) {
+        if ((cpu_to_be32(buf[0]) & TG3_EEPROM_MAGIC_FW_MSK) ==
+            TG3_EEPROM_MAGIC_FW) {
                 u8 *buf8 = (u8 *) buf, csum8 = 0;
 
                 for (i = 0; i < size; i++)
@@ -8197,6 +8349,51 @@ static int tg3_test_nvram(struct tg3 *tp)
                 goto out;
         }
 
+        if ((cpu_to_be32(buf[0]) & TG3_EEPROM_MAGIC_HW_MSK) ==
+            TG3_EEPROM_MAGIC_HW) {
+                u8 data[NVRAM_SELFBOOT_DATA_SIZE];
+                u8 parity[NVRAM_SELFBOOT_DATA_SIZE];
+                u8 *buf8 = (u8 *) buf;
+                int j, k;
+
+                /* Separate the parity bits and the data bytes.  */
+                for (i = 0, j = 0, k = 0; i < NVRAM_SELFBOOT_HW_SIZE; i++) {
+                        if ((i == 0) || (i == 8)) {
+                                int l;
+                                u8 msk;
+
+                                for (l = 0, msk = 0x80; l < 7; l++, msk >>= 1)
+                                        parity[k++] = buf8[i] & msk;
+                                i++;
+                        }
+                        else if (i == 16) {
+                                int l;
+                                u8 msk;
+
+                                for (l = 0, msk = 0x20; l < 6; l++, msk >>= 1)
+                                        parity[k++] = buf8[i] & msk;
+                                i++;
+
+                                for (l = 0, msk = 0x80; l < 8; l++, msk >>= 1)
+                                        parity[k++] = buf8[i] & msk;
+                                i++;
+                        }
+                        data[j++] = buf8[i];
+                }
+
+                err = -EIO;
+                for (i = 0; i < NVRAM_SELFBOOT_DATA_SIZE; i++) {
+                        u8 hw8 = hweight8(data[i]);
+
+                        if ((hw8 & 0x1) && parity[i])
+                                goto out;
+                        else if (!(hw8 & 0x1) && !parity[i])
+                                goto out;
+                }
+                err = 0;
+                goto out;
+        }
+
         /* Bootstrap checksum at offset 0x10 */
         csum = calc_crc((unsigned char *) buf, 0x10);
         if(csum != cpu_to_le32(buf[0x10/4]))
@@ -8243,7 +8440,7 @@ static int tg3_test_link(struct tg3 *tp)
 /* Only test the commonly used registers */
 static int tg3_test_registers(struct tg3 *tp)
 {
-        int i, is_5705;
+        int i, is_5705, is_5750;
         u32 offset, read_mask, write_mask, val, save_val, read_val;
         static struct {
                 u16 offset;
@@ -8251,6 +8448,7 @@ static int tg3_test_registers(struct tg3 *tp)
 #define TG3_FL_5705     0x1
 #define TG3_FL_NOT_5705 0x2
 #define TG3_FL_NOT_5788 0x4
+#define TG3_FL_NOT_5750 0x8
                 u32 read_mask;
                 u32 write_mask;
         } reg_tbl[] = {
@@ -8361,9 +8559,9 @@ static int tg3_test_registers(struct tg3 *tp)
                         0xffffffff, 0x00000000 },
 
                 /* Buffer Manager Control Registers. */
-                { BUFMGR_MB_POOL_ADDR, 0x0000,
+                { BUFMGR_MB_POOL_ADDR, TG3_FL_NOT_5750,
                         0x00000000, 0x007fff80 },
-                { BUFMGR_MB_POOL_SIZE, 0x0000,
+                { BUFMGR_MB_POOL_SIZE, TG3_FL_NOT_5750,
                         0x00000000, 0x007fffff },
                 { BUFMGR_MB_RDMA_LOW_WATER, 0x0000,
                         0x00000000, 0x0000003f },
@@ -8389,10 +8587,12 @@ static int tg3_test_registers(struct tg3 *tp)
                 { 0xffff, 0x0000, 0x00000000, 0x00000000 },
         };
 
-        if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)
+        is_5705 = is_5750 = 0;
+        if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
                 is_5705 = 1;
-        else
-                is_5705 = 0;
+                if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
+                        is_5750 = 1;
+        }
 
         for (i = 0; reg_tbl[i].offset != 0xffff; i++) {
                 if (is_5705 && (reg_tbl[i].flags & TG3_FL_NOT_5705))
@@ -8405,6 +8605,9 @@ static int tg3_test_registers(struct tg3 *tp)
                     (reg_tbl[i].flags & TG3_FL_NOT_5788))
                         continue;
 
+                if (is_5750 && (reg_tbl[i].flags & TG3_FL_NOT_5750))
+                        continue;
+
                 offset = (u32) reg_tbl[i].offset;
                 read_mask = reg_tbl[i].read_mask;
                 write_mask = reg_tbl[i].write_mask;
@@ -8496,6 +8699,13 @@ static int tg3_test_memory(struct tg3 *tp)
                 { 0x00008000, 0x02000},
                 { 0x00010000, 0x0c000},
                 { 0xffffffff, 0x00000}
+        }, mem_tbl_5906[] = {
+                { 0x00000200, 0x00008},
+                { 0x00004000, 0x00400},
+                { 0x00006000, 0x00400},
+                { 0x00008000, 0x01000},
+                { 0x00010000, 0x01000},
+                { 0xffffffff, 0x00000}
         };
         struct mem_entry *mem_tbl;
         int err = 0;
@@ -8505,6 +8715,8 @@ static int tg3_test_memory(struct tg3 *tp)
                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
                         mem_tbl = mem_tbl_5755;
+                else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
+                        mem_tbl = mem_tbl_5906;
                 else
                         mem_tbl = mem_tbl_5705;
         } else
@@ -8541,13 +8753,41 @@ static int tg3_run_loopback(struct tg3 *tp, int loopback_mode)
                         return 0;
 
                 mac_mode = (tp->mac_mode & ~MAC_MODE_PORT_MODE_MASK) |
-                           MAC_MODE_PORT_INT_LPBACK | MAC_MODE_LINK_POLARITY |
-                           MAC_MODE_PORT_MODE_GMII;
+                           MAC_MODE_PORT_INT_LPBACK | MAC_MODE_LINK_POLARITY;
+                if (tp->tg3_flags & TG3_FLAG_10_100_ONLY)
+                        mac_mode |= MAC_MODE_PORT_MODE_MII;
+                else
+                        mac_mode |= MAC_MODE_PORT_MODE_GMII;
                 tw32(MAC_MODE, mac_mode);
         } else if (loopback_mode == TG3_PHY_LOOPBACK) {
-                tg3_writephy(tp, MII_BMCR, BMCR_LOOPBACK | BMCR_FULLDPLX |
-                                           BMCR_SPEED1000);
+                u32 val;
+
+                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
+                        u32 phytest;
+
+                        if (!tg3_readphy(tp, MII_TG3_EPHY_TEST, &phytest)) {
+                                u32 phy;
+
+                                tg3_writephy(tp, MII_TG3_EPHY_TEST,
+                                             phytest | MII_TG3_EPHY_SHADOW_EN);
+                                if (!tg3_readphy(tp, 0x1b, &phy))
+                                        tg3_writephy(tp, 0x1b, phy & ~0x20);
+                                if (!tg3_readphy(tp, 0x10, &phy))
+                                        tg3_writephy(tp, 0x10, phy & ~0x4000);
+                                tg3_writephy(tp, MII_TG3_EPHY_TEST, phytest);
+                        }
+                }
+                val = BMCR_LOOPBACK | BMCR_FULLDPLX;
+                if (tp->tg3_flags & TG3_FLAG_10_100_ONLY)
+                        val |= BMCR_SPEED100;
+                else
+                        val |= BMCR_SPEED1000;
+
+                tg3_writephy(tp, MII_BMCR, val);
                 udelay(40);
+                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
+                        tg3_writephy(tp, MII_TG3_EPHY_PTEST, 0x1800);
+
                 /* reset to prevent losing 1st rx packet intermittently */
                 if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES) {
                         tw32_f(MAC_RX_MODE, RX_MODE_RESET);
@@ -8555,7 +8795,11 @@ static int tg3_run_loopback(struct tg3 *tp, int loopback_mode)
                         tw32_f(MAC_RX_MODE, tp->rx_mode);
                 }
                 mac_mode = (tp->mac_mode & ~MAC_MODE_PORT_MODE_MASK) |
-                           MAC_MODE_LINK_POLARITY | MAC_MODE_PORT_MODE_GMII;
+                           MAC_MODE_LINK_POLARITY;
+                if (tp->tg3_flags & TG3_FLAG_10_100_ONLY)
+                        mac_mode |= MAC_MODE_PORT_MODE_MII;
+                else
+                        mac_mode |= MAC_MODE_PORT_MODE_GMII;
                 if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401) {
                         mac_mode &= ~MAC_MODE_LINK_POLARITY;
                         tg3_writephy(tp, MII_TG3_EXT_CTRL,
@@ -8604,7 +8848,8 @@ static int tg3_run_loopback(struct tg3 *tp, int loopback_mode)
 
         udelay(10);
 
-        for (i = 0; i < 10; i++) {
+        /* 250 usec to allow enough time on some 10/100 Mbps devices.  */
+        for (i = 0; i < 25; i++) {
                 tw32_f(HOSTCC_MODE, tp->coalesce_mode | HOSTCC_MODE_ENABLE |
                        HOSTCC_MODE_NOW);
 
@@ -8956,7 +9201,9 @@ static void __devinit tg3_get_eeprom_size(struct tg3 *tp)
         if (tg3_nvram_read_swab(tp, 0, &magic) != 0)
                 return;
 
-        if ((magic != TG3_EEPROM_MAGIC) && ((magic & 0xff000000) != 0xa5000000))
+        if ((magic != TG3_EEPROM_MAGIC) &&
+            ((magic & TG3_EEPROM_MAGIC_FW_MSK) != TG3_EEPROM_MAGIC_FW) &&
+            ((magic & TG3_EEPROM_MAGIC_HW_MSK) != TG3_EEPROM_MAGIC_HW))
                 return;
 
         /*
@@ -9194,6 +9441,13 @@ static void __devinit tg3_get_5787_nvram_info(struct tg3 *tp)
         }
 }
 
+static void __devinit tg3_get_5906_nvram_info(struct tg3 *tp)
+{
+        tp->nvram_jedecnum = JEDEC_ATMEL;
+        tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
+        tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
+}
+
 /* Chips other than 5700/5701 use the NVRAM for fetching info. */
 static void __devinit tg3_nvram_init(struct tg3 *tp)
 {
@@ -9230,6 +9484,8 @@ static void __devinit tg3_nvram_init(struct tg3 *tp)
                         tg3_get_5755_nvram_info(tp);
                 else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
                         tg3_get_5787_nvram_info(tp);
+                else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
+                        tg3_get_5906_nvram_info(tp);
                 else
                         tg3_get_nvram_info(tp);
 
@@ -9703,6 +9959,12 @@ static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp)
         /* Assume an onboard device by default.  */
         tp->tg3_flags |= TG3_FLAG_EEPROM_WRITE_PROT;
 
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
+                if (!(tr32(PCIE_TRANSACTION_CFG) & PCIE_TRANS_CFG_LOM))
+                        tp->tg3_flags &= ~TG3_FLAG_EEPROM_WRITE_PROT;
+                return;
+        }
+
         tg3_read_mem(tp, NIC_SRAM_DATA_SIG, &val);
         if (val == NIC_SRAM_DATA_SIG_MAGIC) {
                 u32 nic_cfg, led_cfg;
@@ -10034,7 +10296,10 @@ static void __devinit tg3_read_partno(struct tg3 *tp)
         }
 
 out_not_found:
-        strcpy(tp->board_part_number, "none");
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
+                strcpy(tp->board_part_number, "BCM95906");
+        else
+                strcpy(tp->board_part_number, "none");
 }
 
 static void __devinit tg3_read_fw_ver(struct tg3 *tp)
@@ -10236,6 +10501,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906 ||
             (tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
                 tp->tg3_flags2 |= TG3_FLG2_5750_PLUS;
 
@@ -10245,7 +10511,8 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
 
         if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS) {
                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
-                    GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787) {
+                    GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
+                    GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
                         tp->tg3_flags2 |= TG3_FLG2_HW_TSO_2;
                         tp->tg3_flags2 |= TG3_FLG2_1SHOT_MSI;
                 } else {
@@ -10262,7 +10529,8 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5750 &&
             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5752 &&
             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5755 &&
-            GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5787)
+            GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5787 &&
+            GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5906)
                 tp->tg3_flags2 |= TG3_FLG2_JUMBO_CAPABLE;
 
         if (pci_find_capability(tp->pdev, PCI_CAP_ID_EXP) != 0)
@@ -10392,6 +10660,12 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
                 pci_cmd &= ~PCI_COMMAND_MEMORY;
                 pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
         }
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
+                tp->read32_mbox = tg3_read32_mbox_5906;
+                tp->write32_mbox = tg3_write32_mbox_5906;
+                tp->write32_tx_mbox = tg3_write32_mbox_5906;
+                tp->write32_rx_mbox = tg3_write32_mbox_5906;
+        }
 
         if (tp->write32 == tg3_write_indirect_reg32 ||
             ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) &&
@@ -10463,6 +10737,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
             ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) &&
              (tp->pci_chip_rev_id != CHIPREV_ID_5705_A0) &&
              (tp->pci_chip_rev_id != CHIPREV_ID_5705_A1)) ||
+            (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) ||
             (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES))
                 tp->tg3_flags2 |= TG3_FLG2_NO_ETH_WIRE_SPEED;
 
@@ -10476,7 +10751,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
                         tp->tg3_flags2 |= TG3_FLG2_PHY_JITTER_BUG;
-                else
+                else if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5906)
                         tp->tg3_flags2 |= TG3_FLG2_PHY_BER_BUG;
         }
 
@@ -10566,7 +10841,8 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
               tp->pdev->device == PCI_DEVICE_ID_TIGON3_5705F)) ||
             (tp->pdev->vendor == PCI_VENDOR_ID_BROADCOM &&
              (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5751F ||
-              tp->pdev->device == PCI_DEVICE_ID_TIGON3_5753F)))
+              tp->pdev->device == PCI_DEVICE_ID_TIGON3_5753F)) ||
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
                 tp->tg3_flags |= TG3_FLAG_10_100_ONLY;
 
         err = tg3_phy_probe(tp);
@@ -10617,7 +10893,8 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
          * straddle the 4GB address boundary in some cases.
          */
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
-            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
                 tp->dev->hard_start_xmit = tg3_start_xmit;
         else
                 tp->dev->hard_start_xmit = tg3_start_xmit_dma_bug;
@@ -10698,6 +10975,8 @@ static int __devinit tg3_get_device_address(struct tg3 *tp)
                 else
                         tg3_nvram_unlock(tp);
         }
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
+                mac_offset = 0x10;
 
         /* First try to get it from MAC address mailbox. */
         tg3_read_mem(tp, NIC_SRAM_MAC_ADDR_HIGH_MBOX, &hi);
@@ -11181,6 +11460,12 @@ static void __devinit tg3_init_bufmgr_config(struct tg3 *tp)
                         DEFAULT_MB_MACRX_LOW_WATER_5705;
                 tp->bufmgr_config.mbuf_high_water =
                         DEFAULT_MB_HIGH_WATER_5705;
+                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
+                        tp->bufmgr_config.mbuf_mac_rx_low_water =
+                                DEFAULT_MB_MACRX_LOW_WATER_5906;
+                        tp->bufmgr_config.mbuf_high_water =
+                                DEFAULT_MB_HIGH_WATER_5906;
+                }
 
                 tp->bufmgr_config.mbuf_read_dma_low_water_jumbo =
                         DEFAULT_MB_RDMA_LOW_WATER_JUMBO_5780;
@@ -11224,6 +11509,8 @@ static char * __devinit tg3_phy_string(struct tg3 *tp)
         case PHY_ID_BCM5780:    return "5780";
         case PHY_ID_BCM5755:    return "5755";
         case PHY_ID_BCM5787:    return "5787";
+        case PHY_ID_BCM5756:    return "5722/5756";
+        case PHY_ID_BCM5906:    return "5906";
         case PHY_ID_BCM8002:    return "8002/serdes";
         case 0:                 return "serdes";
         default:                return "unknown";
@@ -11526,7 +11813,8 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
          */
         if (tp->tg3_flags2 & TG3_FLG2_HW_TSO) {
                 dev->features |= NETIF_F_TSO;
-                if (tp->tg3_flags2 & TG3_FLG2_HW_TSO_2)
+                if ((tp->tg3_flags2 & TG3_FLG2_HW_TSO_2) &&
+                    (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5906))
                         dev->features |= NETIF_F_TSO6;
         }
 
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index 3ecf356cfb08..92f53000bce6 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -24,6 +24,8 @@
 
 #define RX_COPY_THRESHOLD               256
 
+#define TG3_RX_INTERNAL_RING_SZ_5906    32
+
 #define RX_STD_MAX_SIZE                 1536
 #define RX_STD_MAX_SIZE_5705            512
 #define RX_JUMBO_MAX_SIZE               0xdeadbeef /* XXX */
@@ -129,6 +131,7 @@
 #define  CHIPREV_ID_5752_A0_HW           0x5000
 #define  CHIPREV_ID_5752_A0              0x6000
 #define  CHIPREV_ID_5752_A1              0x6001
+#define  CHIPREV_ID_5906_A1              0xc001
 #define  GET_ASIC_REV(CHIP_REV_ID)      ((CHIP_REV_ID) >> 12)
 #define   ASIC_REV_5700                  0x07
 #define   ASIC_REV_5701                  0x00
@@ -141,6 +144,7 @@
 #define   ASIC_REV_5714                  0x09
 #define   ASIC_REV_5755                  0x0a
 #define   ASIC_REV_5787                  0x0b
+#define   ASIC_REV_5906                  0x0c
 #define  GET_CHIP_REV(CHIP_REV_ID)      ((CHIP_REV_ID) >> 8)
 #define   CHIPREV_5700_AX                0x70
 #define   CHIPREV_5700_BX                0x71
@@ -646,7 +650,8 @@
 #define  SNDDATAI_SCTRL_FORCE_ZERO       0x00000010
 #define SNDDATAI_STATSENAB              0x00000c0c
 #define SNDDATAI_STATSINCMASK           0x00000c10
-/* 0xc14 --> 0xc80 unused */
+#define ISO_PKT_TX                      0x00000c20
+/* 0xc24 --> 0xc80 unused */
 #define SNDDATAI_COS_CNT_0              0x00000c80
 #define SNDDATAI_COS_CNT_1              0x00000c84
 #define SNDDATAI_COS_CNT_2              0x00000c88
@@ -997,11 +1002,13 @@
 #define BUFMGR_MB_MACRX_LOW_WATER       0x00004414
 #define  DEFAULT_MB_MACRX_LOW_WATER       0x00000020
 #define  DEFAULT_MB_MACRX_LOW_WATER_5705  0x00000010
+#define  DEFAULT_MB_MACRX_LOW_WATER_5906  0x00000004
 #define  DEFAULT_MB_MACRX_LOW_WATER_JUMBO 0x00000098
 #define  DEFAULT_MB_MACRX_LOW_WATER_JUMBO_5780 0x0000004b
 #define BUFMGR_MB_HIGH_WATER            0x00004418
 #define  DEFAULT_MB_HIGH_WATER           0x00000060
 #define  DEFAULT_MB_HIGH_WATER_5705      0x00000060
+#define  DEFAULT_MB_HIGH_WATER_5906      0x00000010
 #define  DEFAULT_MB_HIGH_WATER_JUMBO     0x0000017c
 #define  DEFAULT_MB_HIGH_WATER_JUMBO_5780 0x00000096
 #define BUFMGR_RX_MB_ALLOC_REQ          0x0000441c
@@ -1138,7 +1145,12 @@
 #define TX_CPU_STATE                    0x00005404
 #define TX_CPU_PGMCTR                   0x0000541c
 
+#define VCPU_STATUS                     0x00005100
+#define  VCPU_STATUS_INIT_DONE           0x04000000
+#define  VCPU_STATUS_DRV_RESET           0x08000000
+
 /* Mailboxes */
+#define GRCMBOX_BASE                    0x00005600
 #define GRCMBOX_INTERRUPT_0             0x00005800 /* 64-bit */
 #define GRCMBOX_INTERRUPT_1             0x00005808 /* 64-bit */
 #define GRCMBOX_INTERRUPT_2             0x00005810 /* 64-bit */
@@ -1398,7 +1410,10 @@
 #define GRC_EEPROM_CTRL                 0x00006840
 #define GRC_MDI_CTRL                    0x00006844
 #define GRC_SEEPROM_DELAY               0x00006848
-/* 0x684c --> 0x6c00 unused */
+/* 0x684c --> 0x6890 unused */
+#define GRC_VCPU_EXT_CTRL               0x00006890
+#define GRC_VCPU_EXT_CTRL_HALT_CPU       0x00400000
+#define GRC_VCPU_EXT_CTRL_DISABLE_WOL    0x20000000
 #define GRC_FASTBOOT_PC                 0x00006894      /* 5752, 5755, 5787 */
 
 /* 0x6c00 --> 0x7000 unused */
@@ -1485,9 +1500,17 @@
 #define NVRAM_WRITE1                    0x00007028
 /* 0x702c --> 0x7400 unused */
 
-/* 0x7400 --> 0x8000 unused */
+/* 0x7400 --> 0x7c00 unused */
+#define PCIE_TRANSACTION_CFG            0x00007c04
+#define PCIE_TRANS_CFG_1SHOT_MSI         0x20000000
+#define PCIE_TRANS_CFG_LOM               0x00000020
+
 
 #define TG3_EEPROM_MAGIC                0x669955aa
+#define TG3_EEPROM_MAGIC_FW             0xa5000000
+#define TG3_EEPROM_MAGIC_FW_MSK         0xff000000
+#define TG3_EEPROM_MAGIC_HW             0xabcd
+#define TG3_EEPROM_MAGIC_HW_MSK         0xffff
 
 /* 32K Window into NIC internal memory */
 #define NIC_SRAM_WIN_BASE               0x00008000
@@ -1537,6 +1560,7 @@
 #define  FWCMD_NICDRV_FIX_DMAR           0x00000005
 #define  FWCMD_NICDRV_FIX_DMAW           0x00000006
 #define  FWCMD_NICDRV_ALIVE2             0x0000000d
+#define  FWCMD_NICDRV_ALIVE3             0x0000000e
 #define NIC_SRAM_FW_CMD_LEN_MBOX        0x00000b7c
 #define NIC_SRAM_FW_CMD_DATA_MBOX       0x00000b80
 #define NIC_SRAM_FW_ASF_STATUS_MBOX     0x00000c00
@@ -1604,6 +1628,7 @@
 #define MII_TG3_DSP_RW_PORT             0x15 /* DSP coefficient read/write port */
 
 #define MII_TG3_DSP_ADDRESS             0x17 /* DSP address register */
+#define MII_TG3_EPHY_PTEST              0x17 /* 5906 PHY register */
 
 #define MII_TG3_AUX_CTRL                0x18 /* auxilliary control register */
 
@@ -1617,6 +1642,8 @@
 #define MII_TG3_AUX_STAT_100FULL        0x0500
 #define MII_TG3_AUX_STAT_1000HALF       0x0600
 #define MII_TG3_AUX_STAT_1000FULL       0x0700
+#define MII_TG3_AUX_STAT_100            0x0008
+#define MII_TG3_AUX_STAT_FULL           0x0001
 
 #define MII_TG3_ISTAT                   0x1a /* IRQ status register */
 #define MII_TG3_IMASK                   0x1b /* IRQ mask register */
@@ -1627,6 +1654,9 @@
 #define MII_TG3_INT_DUPLEXCHG           0x0008
 #define MII_TG3_INT_ANEG_PAGE_RX        0x0400
 
+#define MII_TG3_EPHY_TEST               0x1f /* 5906 PHY register */
+#define MII_TG3_EPHY_SHADOW_EN          0x80
+
 /* There are two ways to manage the TX descriptors on the tigon3.
  * Either the descriptors are in host DMA'able memory, or they
  * exist only in the cards on-chip SRAM.  All 16 send bds are under
@@ -2203,7 +2233,6 @@ struct tg3 {
 #define TG3_FLG2_PCI_EXPRESS            0x00000200
 #define TG3_FLG2_ASF_NEW_HANDSHAKE      0x00000400
 #define TG3_FLG2_HW_AUTONEG             0x00000800
-#define TG3_FLG2_PHY_JUST_INITTED       0x00001000
 #define TG3_FLG2_PHY_SERDES             0x00002000
 #define TG3_FLG2_CAPACITIVE_COUPLING    0x00004000
 #define TG3_FLG2_FLASH                  0x00008000
@@ -2236,6 +2265,12 @@ struct tg3 {
         u16                             asf_counter;
         u16                             asf_multiplier;
 
+        /* 1 second counter for transient serdes link events */
+        u32                             serdes_counter;
+#define SERDES_AN_TIMEOUT_5704S         2
+#define SERDES_PARALLEL_DET_TIMEOUT     1
+#define SERDES_AN_TIMEOUT_5714S         1
+
         struct tg3_link_config          link_config;
         struct tg3_bufmgr_config        bufmgr_config;
 
@@ -2276,6 +2311,8 @@ struct tg3 {
 #define PHY_ID_BCM5780                  0x60008350
 #define PHY_ID_BCM5755                  0xbc050cc0
 #define PHY_ID_BCM5787                  0xbc050ce0
+#define PHY_ID_BCM5756                  0xbc050ed0
+#define PHY_ID_BCM5906                  0xdc00ac40
 #define PHY_ID_BCM8002                  0x60010140
 #define PHY_ID_INVALID                  0xffffffff
 #define PHY_ID_REV_MASK                 0x0000000f
@@ -2302,7 +2339,8 @@ struct tg3 {
          (X) == PHY_ID_BCM5705 || (X) == PHY_ID_BCM5750 || \
          (X) == PHY_ID_BCM5752 || (X) == PHY_ID_BCM5714 || \
          (X) == PHY_ID_BCM5780 || (X) == PHY_ID_BCM5787 || \
-         (X) == PHY_ID_BCM5755 || (X) == PHY_ID_BCM8002)
+         (X) == PHY_ID_BCM5755 || (X) == PHY_ID_BCM5756 || \
+         (X) == PHY_ID_BCM5906 || (X) == PHY_ID_BCM8002)
 
         struct tg3_hw_stats             *hw_stats;
         dma_addr_t                      stats_mapping;
diff --git a/drivers/net/wan/hdlc_cisco.c b/drivers/net/wan/hdlc_cisco.c
index 7ec2b2f9b7ee..b0bc5ddcf1b1 100644
--- a/drivers/net/wan/hdlc_cisco.c
+++ b/drivers/net/wan/hdlc_cisco.c
@@ -161,7 +161,7 @@ static int cisco_rx(struct sk_buff *skb)
         struct hdlc_header *data = (struct hdlc_header*)skb->data;
         struct cisco_packet *cisco_data;
         struct in_device *in_dev;
-        u32 addr, mask;
+        __be32 addr, mask;
 
         if (skb->len < sizeof(struct hdlc_header))
                 goto rx_error;
diff --git a/drivers/net/wan/syncppp.c b/drivers/net/wan/syncppp.c
index c13b459a0137..d1173089f334 100644
--- a/drivers/net/wan/syncppp.c
+++ b/drivers/net/wan/syncppp.c
@@ -763,7 +763,7 @@ static void sppp_cisco_input (struct sppp *sp, struct sk_buff *skb)
                 {
                 struct in_device *in_dev;
                 struct in_ifaddr *ifa;
-                u32 addr = 0, mask = ~0; /* FIXME: is the mask correct? */
+                __be32 addr = 0, mask = ~0; /* FIXME: is the mask correct? */
 #ifdef CONFIG_INET
                 rcu_read_lock();
                 if ((in_dev = __in_dev_get_rcu(dev)) != NULL)
diff --git a/drivers/net/wireless/strip.c b/drivers/net/wireless/strip.c
index ccaf28e8db0a..337c692f6fd6 100644
--- a/drivers/net/wireless/strip.c
+++ b/drivers/net/wireless/strip.c
@@ -1342,7 +1342,7 @@ static unsigned char *strip_make_packet(unsigned char *buffer,
          * 'broadcast hub' radio (First byte of address being 0xFF means broadcast)
          */
         if (haddr.c[0] == 0xFF) {
-                u32 brd = 0;
+                __be32 brd = 0;
                 struct in_device *in_dev;
 
                 rcu_read_lock();
@@ -1406,7 +1406,7 @@ static void strip_send(struct strip *strip_info, struct sk_buff *skb)
         int doreset = (long) jiffies - strip_info->watchdog_doreset >= 0;
         int doprobe = (long) jiffies - strip_info->watchdog_doprobe >= 0
             && !doreset;
-        u32 addr, brd;
+        __be32 addr, brd;
 
         /*
          * 1. If we have a packet, encapsulate it and put it in the buffer
diff --git a/drivers/s390/net/qeth_main.c b/drivers/s390/net/qeth_main.c
index 5613b4564fa2..8364d5475ac7 100644
--- a/drivers/s390/net/qeth_main.c
+++ b/drivers/s390/net/qeth_main.c
@@ -8067,7 +8067,7 @@ qeth_arp_constructor(struct neighbour *neigh)
         neigh->parms = neigh_parms_clone(parms);
         rcu_read_unlock();
 
-        neigh->type = inet_addr_type(*(u32 *) neigh->primary_key);
+        neigh->type = inet_addr_type(*(__be32 *) neigh->primary_key);
         neigh->nud_state = NUD_NOARP;
         neigh->ops = arp_direct_ops;
         neigh->output = neigh->ops->queue_xmit;
diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index 1df2ac30a4d2..f7a52e19b4be 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -58,6 +58,7 @@ header-y += elf-em.h
 header-y += fadvise.h
 header-y += fd.h
 header-y += fdreg.h
+header-y += fib_rules.h
 header-y += ftape-header-segment.h
 header-y += ftape-vendors.h
 header-y += fuse.h
@@ -70,6 +71,7 @@ header-y += hysdn_if.h
 header-y += i2c-dev.h
 header-y += i8k.h
 header-y += icmp.h
+header-y += if_addr.h
 header-y += if_arcnet.h
 header-y += if_arp.h
 header-y += if_bonding.h
@@ -79,6 +81,7 @@ header-y += if_fddi.h
 header-y += if.h
 header-y += if_hippi.h
 header-y += if_infiniband.h
+header-y += if_link.h
 header-y += if_packet.h
 header-y += if_plip.h
 header-y += if_ppp.h
@@ -110,6 +113,7 @@ header-y += mmtimer.h
 header-y += mqueue.h
 header-y += mtio.h
 header-y += ncp_no.h
+header-y += neighbour.h
 header-y += netfilter_arp.h
 header-y += netrom.h
 header-y += nfs2.h
diff --git a/include/linux/atalk.h b/include/linux/atalk.h
index 6ba3aa8a81f4..75b8baca08f3 100644
--- a/include/linux/atalk.h
+++ b/include/linux/atalk.h
@@ -88,15 +88,7 @@ static inline struct atalk_sock *at_sk(struct sock *sk)
 #include <asm/byteorder.h>
 
 struct ddpehdr {
-#ifdef __LITTLE_ENDIAN_BITFIELD
-        __u16   deh_len:10,
-                deh_hops:4,
-                deh_pad:2;
-#else
-        __u16   deh_pad:2,
-                deh_hops:4,
-                deh_len:10;
-#endif
+        __be16  deh_len_hops;   /* lower 10 bits are length, next 4 - hops */
         __be16  deh_sum;
         __be16  deh_dnet;
         __be16  deh_snet;
@@ -112,36 +104,6 @@ static __inline__ struct ddpehdr *ddp_hdr(struct sk_buff *skb)
         return (struct ddpehdr *)skb->h.raw;
 }
 
-/*
- *      Don't drop the struct into the struct above.  You'll get some
- *      surprise padding.
- */
-struct ddpebits {
-#ifdef __LITTLE_ENDIAN_BITFIELD
-        __u16   deh_len:10,
-                deh_hops:4,
-                deh_pad:2;
-#else
-        __u16   deh_pad:2,
-                deh_hops:4,
-                deh_len:10;
-#endif
-};
-
-/* Short form header */
-struct ddpshdr {
-#ifdef __LITTLE_ENDIAN_BITFIELD
-        __u16   dsh_len:10,
-                dsh_pad:6;
-#else
-        __u16   dsh_pad:6,
-                dsh_len:10;
-#endif
-        __u8    dsh_dport;
-        __u8    dsh_sport;
-        /* And netatalk apps expect to stick the type in themselves */
-};
-
 /* AppleTalk AARP headers */
 struct elapaarp {
         __be16  hw_type;
diff --git a/include/linux/audit.h b/include/linux/audit.h
index 40a6c26294ae..42719d07612a 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -95,6 +95,12 @@
 #define AUDIT_MAC_POLICY_LOAD   1403    /* Policy file load */
 #define AUDIT_MAC_STATUS        1404    /* Changed enforcing,permissive,off */
 #define AUDIT_MAC_CONFIG_CHANGE 1405    /* Changes to booleans */
+#define AUDIT_MAC_UNLBL_ACCEPT  1406    /* NetLabel: allow unlabeled traffic */
+#define AUDIT_MAC_UNLBL_DENY    1407    /* NetLabel: deny unlabeled traffic */
+#define AUDIT_MAC_CIPSOV4_ADD   1408    /* NetLabel: add CIPSOv4 DOI entry */
+#define AUDIT_MAC_CIPSOV4_DEL   1409    /* NetLabel: del CIPSOv4 DOI entry */
+#define AUDIT_MAC_MAP_ADD       1410    /* NetLabel: add LSM domain mapping */
+#define AUDIT_MAC_MAP_DEL       1411    /* NetLabel: del LSM domain mapping */
 
 #define AUDIT_FIRST_KERN_ANOM_MSG   1700
 #define AUDIT_LAST_KERN_ANOM_MSG    1799
diff --git a/include/linux/errqueue.h b/include/linux/errqueue.h
index 408118a07763..92f8d4fab32b 100644
--- a/include/linux/errqueue.h
+++ b/include/linux/errqueue.h
@@ -38,7 +38,7 @@ struct sock_exterr_skb
         } header;
         struct sock_extended_err        ee;
         u16                             addr_offset;
-        u16                             port;
+        __be16                          port;
 };
 
 #endif
diff --git a/include/linux/icmp.h b/include/linux/icmp.h
index f0b571f1060b..878cfe4e587f 100644
--- a/include/linux/icmp.h
+++ b/include/linux/icmp.h
@@ -68,16 +68,16 @@
 struct icmphdr {
   __u8          type;
   __u8          code;
-  __u16         checksum;
+  __be16        checksum;
   union {
         struct {
-                __u16   id;
-                __u16   sequence;
+                __be16  id;
+                __be16  sequence;
         } echo;
-        __u32   gateway;
+        __be32  gateway;
         struct {
-                __u16   __unused;
-                __u16   mtu;
+                __be16  __unused;
+                __be16  mtu;
         } frag;
   } un;
 };
diff --git a/include/linux/if.h b/include/linux/if.h
index 8018c2e22c0c..32bf419351f1 100644
--- a/include/linux/if.h
+++ b/include/linux/if.h
@@ -214,134 +214,4 @@ struct ifconf
 #define ifc_buf ifc_ifcu.ifcu_buf               /* buffer address       */
 #define ifc_req ifc_ifcu.ifcu_req               /* array of structures  */
 
-/* The struct should be in sync with struct net_device_stats */
-struct rtnl_link_stats
-{
-        __u32   rx_packets;             /* total packets received       */
-        __u32   tx_packets;             /* total packets transmitted    */
-        __u32   rx_bytes;               /* total bytes received         */
-        __u32   tx_bytes;               /* total bytes transmitted      */
-        __u32   rx_errors;              /* bad packets received         */
-        __u32   tx_errors;              /* packet transmit problems     */
-        __u32   rx_dropped;             /* no space in linux buffers    */
-        __u32   tx_dropped;             /* no space available in linux  */
-        __u32   multicast;              /* multicast packets received   */
-        __u32   collisions;
-
-        /* detailed rx_errors: */
-        __u32   rx_length_errors;
-        __u32   rx_over_errors;         /* receiver ring buff overflow  */
-        __u32   rx_crc_errors;          /* recved pkt with crc error    */
-        __u32   rx_frame_errors;        /* recv'd frame alignment error */
-        __u32   rx_fifo_errors;         /* recv'r fifo overrun          */
-        __u32   rx_missed_errors;       /* receiver missed packet       */
-
-        /* detailed tx_errors */
-        __u32   tx_aborted_errors;
-        __u32   tx_carrier_errors;
-        __u32   tx_fifo_errors;
-        __u32   tx_heartbeat_errors;
-        __u32   tx_window_errors;
-
-        /* for cslip etc */
-        __u32   rx_compressed;
-        __u32   tx_compressed;
-};
-
-/* The struct should be in sync with struct ifmap */
-struct rtnl_link_ifmap
-{
-        __u64   mem_start;
-        __u64   mem_end;
-        __u64   base_addr;
-        __u16   irq;
-        __u8    dma;
-        __u8    port;
-};
-
-enum
-{
-        IFLA_UNSPEC,
-        IFLA_ADDRESS,
-        IFLA_BROADCAST,
-        IFLA_IFNAME,
-        IFLA_MTU,
-        IFLA_LINK,
-        IFLA_QDISC,
-        IFLA_STATS,
-        IFLA_COST,
-#define IFLA_COST IFLA_COST
-        IFLA_PRIORITY,
-#define IFLA_PRIORITY IFLA_PRIORITY
-        IFLA_MASTER,
-#define IFLA_MASTER IFLA_MASTER
-        IFLA_WIRELESS,          /* Wireless Extension event - see wireless.h */
-#define IFLA_WIRELESS IFLA_WIRELESS
-        IFLA_PROTINFO,          /* Protocol specific information for a link */
-#define IFLA_PROTINFO IFLA_PROTINFO
-        IFLA_TXQLEN,
-#define IFLA_TXQLEN IFLA_TXQLEN
-        IFLA_MAP,
-#define IFLA_MAP IFLA_MAP
-        IFLA_WEIGHT,
-#define IFLA_WEIGHT IFLA_WEIGHT
-        IFLA_OPERSTATE,
-        IFLA_LINKMODE,
-        __IFLA_MAX
-};
-
-
-#define IFLA_MAX (__IFLA_MAX - 1)
-
-/* ifi_flags.
-
-   IFF_* flags.
-
-   The only change is:
-   IFF_LOOPBACK, IFF_BROADCAST and IFF_POINTOPOINT are
-   more not changeable by user. They describe link media
-   characteristics and set by device driver.
-
-   Comments:
-   - Combination IFF_BROADCAST|IFF_POINTOPOINT is invalid
-   - If neither of these three flags are set;
-     the interface is NBMA.
-
-   - IFF_MULTICAST does not mean anything special:
-   multicasts can be used on all not-NBMA links.
-   IFF_MULTICAST means that this media uses special encapsulation
-   for multicast frames. Apparently, all IFF_POINTOPOINT and
-   IFF_BROADCAST devices are able to use multicasts too.
- */
-
-/* IFLA_LINK.
-   For usual devices it is equal ifi_index.
-   If it is a "virtual interface" (f.e. tunnel), ifi_link
-   can point to real physical interface (f.e. for bandwidth calculations),
-   or maybe 0, what means, that real media is unknown (usual
-   for IPIP tunnels, when route to endpoint is allowed to change)
- */
-
-/* Subtype attributes for IFLA_PROTINFO */
-enum
-{
-        IFLA_INET6_UNSPEC,
-        IFLA_INET6_FLAGS,       /* link flags                   */
-        IFLA_INET6_CONF,        /* sysctl parameters            */
-        IFLA_INET6_STATS,       /* statistics                   */
-        IFLA_INET6_MCAST,       /* MC things. What of them?     */
-        IFLA_INET6_CACHEINFO,   /* time values and max reasm size */
-        __IFLA_INET6_MAX
-};
-
-#define IFLA_INET6_MAX  (__IFLA_INET6_MAX - 1)
-
-struct ifla_cacheinfo
-{
-        __u32   max_reasm_len;
-        __u32   tstamp;         /* ipv6InterfaceTable updated timestamp */
-        __u32   reachable_time;
-        __u32   retrans_time;
-};
-
 #endif /* _LINUX_IF_H */
diff --git a/include/linux/if_arp.h b/include/linux/if_arp.h
index a8b1a2071838..7f5714214ee3 100644
--- a/include/linux/if_arp.h
+++ b/include/linux/if_arp.h
@@ -130,11 +130,11 @@ struct arpreq_old {
 
 struct arphdr
 {
-        unsigned short  ar_hrd;         /* format of hardware address   */
-        unsigned short  ar_pro;         /* format of protocol address   */
+        __be16          ar_hrd;         /* format of hardware address   */
+        __be16          ar_pro;         /* format of protocol address   */
         unsigned char   ar_hln;         /* length of hardware address   */
         unsigned char   ar_pln;         /* length of protocol address   */
-        unsigned short  ar_op;          /* ARP opcode (command)         */
+        __be16          ar_op;          /* ARP opcode (command)         */
 
 #if 0
          /*
diff --git a/include/linux/if_link.h b/include/linux/if_link.h
new file mode 100644
index 000000000000..e963a077e6f5
--- /dev/null
+++ b/include/linux/if_link.h
@@ -0,0 +1,136 @@
+#ifndef _LINUX_IF_LINK_H
+#define _LINUX_IF_LINK_H
+
+#include <linux/netlink.h>
+
+/* The struct should be in sync with struct net_device_stats */
+struct rtnl_link_stats
+{
+        __u32   rx_packets;             /* total packets received       */
+        __u32   tx_packets;             /* total packets transmitted    */
+        __u32   rx_bytes;               /* total bytes received         */
+        __u32   tx_bytes;               /* total bytes transmitted      */
+        __u32   rx_errors;              /* bad packets received         */
+        __u32   tx_errors;              /* packet transmit problems     */
+        __u32   rx_dropped;             /* no space in linux buffers    */
+        __u32   tx_dropped;             /* no space available in linux  */
+        __u32   multicast;              /* multicast packets received   */
+        __u32   collisions;
+
+        /* detailed rx_errors: */
+        __u32   rx_length_errors;
+        __u32   rx_over_errors;         /* receiver ring buff overflow  */
+        __u32   rx_crc_errors;          /* recved pkt with crc error    */
+        __u32   rx_frame_errors;        /* recv'd frame alignment error */
+        __u32   rx_fifo_errors;         /* recv'r fifo overrun          */
+        __u32   rx_missed_errors;       /* receiver missed packet       */
+
+        /* detailed tx_errors */
+        __u32   tx_aborted_errors;
+        __u32   tx_carrier_errors;
+        __u32   tx_fifo_errors;
+        __u32   tx_heartbeat_errors;
+        __u32   tx_window_errors;
+
+        /* for cslip etc */
+        __u32   rx_compressed;
+        __u32   tx_compressed;
+};
+
+/* The struct should be in sync with struct ifmap */
+struct rtnl_link_ifmap
+{
+        __u64   mem_start;
+        __u64   mem_end;
+        __u64   base_addr;
+        __u16   irq;
+        __u8    dma;
+        __u8    port;
+};
+
+enum
+{
+        IFLA_UNSPEC,
+        IFLA_ADDRESS,
+        IFLA_BROADCAST,
+        IFLA_IFNAME,
+        IFLA_MTU,
+        IFLA_LINK,
+        IFLA_QDISC,
+        IFLA_STATS,
+        IFLA_COST,
+#define IFLA_COST IFLA_COST
+        IFLA_PRIORITY,
+#define IFLA_PRIORITY IFLA_PRIORITY
+        IFLA_MASTER,
+#define IFLA_MASTER IFLA_MASTER
+        IFLA_WIRELESS,          /* Wireless Extension event - see wireless.h */
+#define IFLA_WIRELESS IFLA_WIRELESS
+        IFLA_PROTINFO,          /* Protocol specific information for a link */
+#define IFLA_PROTINFO IFLA_PROTINFO
+        IFLA_TXQLEN,
+#define IFLA_TXQLEN IFLA_TXQLEN
+        IFLA_MAP,
+#define IFLA_MAP IFLA_MAP
+        IFLA_WEIGHT,
+#define IFLA_WEIGHT IFLA_WEIGHT
+        IFLA_OPERSTATE,
+        IFLA_LINKMODE,
+        __IFLA_MAX
+};
+
+
+#define IFLA_MAX (__IFLA_MAX - 1)
+
+/* ifi_flags.
+
+   IFF_* flags.
+
+   The only change is:
+   IFF_LOOPBACK, IFF_BROADCAST and IFF_POINTOPOINT are
+   more not changeable by user. They describe link media
+   characteristics and set by device driver.
+
+   Comments:
+   - Combination IFF_BROADCAST|IFF_POINTOPOINT is invalid
+   - If neither of these three flags are set;
+     the interface is NBMA.
+
+   - IFF_MULTICAST does not mean anything special:
+   multicasts can be used on all not-NBMA links.
+   IFF_MULTICAST means that this media uses special encapsulation
+   for multicast frames. Apparently, all IFF_POINTOPOINT and
+   IFF_BROADCAST devices are able to use multicasts too.
+ */
+
+/* IFLA_LINK.
+   For usual devices it is equal ifi_index.
+   If it is a "virtual interface" (f.e. tunnel), ifi_link
+   can point to real physical interface (f.e. for bandwidth calculations),
+   or maybe 0, what means, that real media is unknown (usual
+   for IPIP tunnels, when route to endpoint is allowed to change)
+ */
+
+/* Subtype attributes for IFLA_PROTINFO */
+enum
+{
+        IFLA_INET6_UNSPEC,
+        IFLA_INET6_FLAGS,       /* link flags                   */
+        IFLA_INET6_CONF,        /* sysctl parameters            */
+        IFLA_INET6_STATS,       /* statistics                   */
+        IFLA_INET6_MCAST,       /* MC things. What of them?     */
+        IFLA_INET6_CACHEINFO,   /* time values and max reasm size */
+        __IFLA_INET6_MAX
+};
+
+#define IFLA_INET6_MAX  (__IFLA_INET6_MAX - 1)
+
+struct ifla_cacheinfo
+{
+        __u32   max_reasm_len;
+        __u32   tstamp;         /* ipv6InterfaceTable updated timestamp */
+        __u32   reachable_time;
+        __u32   retrans_time;
+};
+
+#endif /* _LINUX_IF_LINK_H */
diff --git a/include/linux/igmp.h b/include/linux/igmp.h
index 899c3d4776f3..03f43e2893a4 100644
--- a/include/linux/igmp.h
+++ b/include/linux/igmp.h
@@ -30,8 +30,8 @@ struct igmphdr
 {
         __u8 type;
         __u8 code;              /* For newer IGMP */
-        __u16 csum;
-        __u32 group;
+        __be16 csum;
+        __be32 group;
 };
 
 /* V3 group record types [grec_type] */
@@ -45,25 +45,25 @@ struct igmphdr
 struct igmpv3_grec {
         __u8    grec_type;
         __u8    grec_auxwords;
-        __u16   grec_nsrcs;
-        __u32   grec_mca;
-        __u32   grec_src[0];
+        __be16  grec_nsrcs;
+        __be32  grec_mca;
+        __be32  grec_src[0];
 };
 
 struct igmpv3_report {
         __u8 type;
         __u8 resv1;
-        __u16 csum;
-        __u16 resv2;
-        __u16 ngrec;
+        __be16 csum;
+        __be16 resv2;
+        __be16 ngrec;
         struct igmpv3_grec grec[0];
 };
 
 struct igmpv3_query {
         __u8 type;
         __u8 code;
-        __u16 csum;
-        __u32 group;
+        __be16 csum;
+        __be32 group;
 #if defined(__LITTLE_ENDIAN_BITFIELD)
         __u8 qrv:3,
              suppress:1,
@@ -76,8 +76,8 @@ struct igmpv3_query {
 #error "Please fix <asm/byteorder.h>"
 #endif
         __u8 qqic;
-        __u16 nsrcs;
-        __u32 srcs[0];
+        __be16 nsrcs;
+        __be32 srcs[0];
 };
 
 #define IGMP_HOST_MEMBERSHIP_QUERY      0x11    /* From RFC1112 */
@@ -136,11 +136,11 @@ struct ip_sf_socklist
 {
         unsigned int            sl_max;
         unsigned int            sl_count;
-        __u32                   sl_addr[0];
+        __be32                  sl_addr[0];
 };
 
 #define IP_SFLSIZE(count)       (sizeof(struct ip_sf_socklist) + \
-        (count) * sizeof(__u32))
+        (count) * sizeof(__be32))
 
 #define IP_SFBLOCK      10      /* allocate this many at once */
 
@@ -159,7 +159,7 @@ struct ip_mc_socklist
 struct ip_sf_list
 {
         struct ip_sf_list       *sf_next;
-        __u32                   sf_inaddr;
+        __be32                  sf_inaddr;
         unsigned long           sf_count[2];    /* include/exclude counts */
         unsigned char           sf_gsresp;      /* include in g & s response? */
         unsigned char           sf_oldin;       /* change state */
@@ -197,7 +197,7 @@ struct ip_mc_list
 #define IGMPV3_QQIC(value) IGMPV3_EXP(0x80, 4, 3, value)
 #define IGMPV3_MRC(value) IGMPV3_EXP(0x80, 4, 3, value)
 
-extern int ip_check_mc(struct in_device *dev, u32 mc_addr, u32 src_addr, u16 proto);
+extern int ip_check_mc(struct in_device *dev, __be32 mc_addr, __be32 src_addr, u16 proto);
 extern int igmp_rcv(struct sk_buff *);
 extern int ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr);
 extern int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr);
@@ -209,13 +209,13 @@ extern int ip_mc_msfget(struct sock *sk, struct ip_msfilter *msf,
                 struct ip_msfilter __user *optval, int __user *optlen);
 extern int ip_mc_gsfget(struct sock *sk, struct group_filter *gsf,
                 struct group_filter __user *optval, int __user *optlen);
-extern int ip_mc_sf_allow(struct sock *sk, u32 local, u32 rmt, int dif);
+extern int ip_mc_sf_allow(struct sock *sk, __be32 local, __be32 rmt, int dif);
 extern void ip_mr_init(void);
 extern void ip_mc_init_dev(struct in_device *);
 extern void ip_mc_destroy_dev(struct in_device *);
 extern void ip_mc_up(struct in_device *);
 extern void ip_mc_down(struct in_device *);
-extern void ip_mc_dec_group(struct in_device *in_dev, u32 addr);
-extern void ip_mc_inc_group(struct in_device *in_dev, u32 addr);
+extern void ip_mc_dec_group(struct in_device *in_dev, __be32 addr);
+extern void ip_mc_inc_group(struct in_device *in_dev, __be32 addr);
 #endif
 #endif
diff --git a/include/linux/in.h b/include/linux/in.h
index bcaca8399aed..d79fc75fa7c2 100644
--- a/include/linux/in.h
+++ b/include/linux/in.h
@@ -123,17 +123,17 @@ struct ip_mreqn
 };
 
 struct ip_mreq_source {
-        __u32           imr_multiaddr;
-        __u32           imr_interface;
-        __u32           imr_sourceaddr;
+        __be32          imr_multiaddr;
+        __be32          imr_interface;
+        __be32          imr_sourceaddr;
 };
 
 struct ip_msfilter {
-        __u32           imsf_multiaddr;
-        __u32           imsf_interface;
+        __be32          imsf_multiaddr;
+        __be32          imsf_interface;
         __u32           imsf_fmode;
         __u32           imsf_numsrc;
-        __u32           imsf_slist[1];
+        __be32          imsf_slist[1];
 };
 
 #define IP_MSFILTER_SIZE(numsrc) \
diff --git a/include/linux/in6.h b/include/linux/in6.h
index d776829b443f..9be6a4756f0b 100644
--- a/include/linux/in6.h
+++ b/include/linux/in6.h
@@ -32,8 +32,8 @@ struct in6_addr
         union 
         {
                 __u8            u6_addr8[16];
-                __u16           u6_addr16[8];
-                __u32           u6_addr32[4];
+                __be16          u6_addr16[8];
+                __be32          u6_addr32[4];
         } in6_u;
 #define s6_addr                 in6_u.u6_addr8
 #define s6_addr16               in6_u.u6_addr16
@@ -53,7 +53,7 @@ extern const struct in6_addr in6addr_loopback;
 
 struct sockaddr_in6 {
         unsigned short int      sin6_family;    /* AF_INET6 */
-        __u16                   sin6_port;      /* Transport layer port # */
+        __be16                  sin6_port;      /* Transport layer port # */
         __u32                   sin6_flowinfo;  /* IPv6 flow information */
         struct in6_addr         sin6_addr;      /* IPv6 address */
         __u32                   sin6_scope_id;  /* scope id (new in RFC2553) */
diff --git a/include/linux/inet_diag.h b/include/linux/inet_diag.h
index a4606e5810e5..6e8bc548635a 100644
--- a/include/linux/inet_diag.h
+++ b/include/linux/inet_diag.h
@@ -9,10 +9,10 @@
 
 /* Socket identity */
 struct inet_diag_sockid {
-        __u16   idiag_sport;
-        __u16   idiag_dport;
-        __u32   idiag_src[4];
-        __u32   idiag_dst[4];
+        __be16  idiag_sport;
+        __be16  idiag_dport;
+        __be32  idiag_src[4];
+        __be32  idiag_dst[4];
         __u32   idiag_if;
         __u32   idiag_cookie[2];
 #define INET_DIAG_NOCOOKIE (~0U)
@@ -67,7 +67,7 @@ struct inet_diag_hostcond {
         __u8    family;
         __u8    prefix_len;
         int     port;
-        __u32   addr[0];
+        __be32  addr[0];
 };
 
 /* Base info structure. It contains socket identity (addrs/ports/cookie)
diff --git a/include/linux/inetdevice.h b/include/linux/inetdevice.h
index 92297ff24e85..5a0ab04627bc 100644
--- a/include/linux/inetdevice.h
+++ b/include/linux/inetdevice.h
@@ -90,11 +90,11 @@ struct in_ifaddr
         struct in_ifaddr        *ifa_next;
         struct in_device        *ifa_dev;
         struct rcu_head         rcu_head;
-        u32                     ifa_local;
-        u32                     ifa_address;
-        u32                     ifa_mask;
-        u32                     ifa_broadcast;
-        u32                     ifa_anycast;
+        __be32                  ifa_local;
+        __be32                  ifa_address;
+        __be32                  ifa_mask;
+        __be32                  ifa_broadcast;
+        __be32                  ifa_anycast;
         unsigned char           ifa_scope;
         unsigned char           ifa_flags;
         unsigned char           ifa_prefixlen;
@@ -104,18 +104,18 @@ struct in_ifaddr
 extern int register_inetaddr_notifier(struct notifier_block *nb);
 extern int unregister_inetaddr_notifier(struct notifier_block *nb);
 
-extern struct net_device        *ip_dev_find(u32 addr);
-extern int              inet_addr_onlink(struct in_device *in_dev, u32 a, u32 b);
+extern struct net_device        *ip_dev_find(__be32 addr);
+extern int              inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b);
 extern int              devinet_ioctl(unsigned int cmd, void __user *);
 extern void             devinet_init(void);
 extern struct in_device *inetdev_init(struct net_device *dev);
 extern struct in_device *inetdev_by_index(int);
-extern u32              inet_select_addr(const struct net_device *dev, u32 dst, int scope);
-extern u32              inet_confirm_addr(const struct net_device *dev, u32 dst, u32 local, int scope);
-extern struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, u32 prefix, u32 mask);
+extern __be32           inet_select_addr(const struct net_device *dev, __be32 dst, int scope);
+extern __be32           inet_confirm_addr(const struct net_device *dev, __be32 dst, __be32 local, int scope);
+extern struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix, __be32 mask);
 extern void             inet_forward_change(void);
 
-static __inline__ int inet_ifa_match(u32 addr, struct in_ifaddr *ifa)
+static __inline__ int inet_ifa_match(__be32 addr, struct in_ifaddr *ifa)
 {
         return !((addr^ifa->ifa_address)&ifa->ifa_mask);
 }
@@ -183,7 +183,7 @@ static inline void in_dev_put(struct in_device *idev)
 
 #endif /* __KERNEL__ */
 
-static __inline__ __u32 inet_make_mask(int logmask)
+static __inline__ __be32 inet_make_mask(int logmask)
 {
         if (logmask)
                 return htonl(~((1<<(32-logmask))-1));
diff --git a/include/linux/ip.h b/include/linux/ip.h
index 2f4600146f83..6b25d36fc54c 100644
--- a/include/linux/ip.h
+++ b/include/linux/ip.h
@@ -96,7 +96,7 @@ struct iphdr {
         __be16  frag_off;
         __u8    ttl;
         __u8    protocol;
-        __u16   check;
+        __be16  check;
         __be32  saddr;
         __be32  daddr;
         /*The options start here. */
@@ -105,22 +105,22 @@ struct iphdr {
 struct ip_auth_hdr {
         __u8  nexthdr;
         __u8  hdrlen;           /* This one is measured in 32 bit units! */
-        __u16 reserved;
-        __u32 spi;
-        __u32 seq_no;           /* Sequence number */
+        __be16 reserved;
+        __be32 spi;
+        __be32 seq_no;          /* Sequence number */
         __u8  auth_data[0];     /* Variable len but >=4. Mind the 64 bit alignment! */
 };
 
 struct ip_esp_hdr {
-        __u32 spi;
-        __u32 seq_no;           /* Sequence number */
+        __be32 spi;
+        __be32 seq_no;          /* Sequence number */
         __u8  enc_data[0];      /* Variable len but >=8. Mind the 64 bit alignment! */
 };
 
 struct ip_comp_hdr {
         __u8 nexthdr;
         __u8 flags;
-        __u16 cpi;
+        __be16 cpi;
 };
 
 #endif  /* _LINUX_IP_H */
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index caca57df0d7d..4f435c59de06 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -99,22 +99,22 @@ struct ipv6_destopt_hao {
 struct ipv6_auth_hdr {
         __u8  nexthdr;
         __u8  hdrlen;           /* This one is measured in 32 bit units! */
-        __u16 reserved;
-        __u32 spi;
-        __u32 seq_no;           /* Sequence number */
+        __be16 reserved;
+        __be32 spi;
+        __be32 seq_no;           /* Sequence number */
         __u8  auth_data[0];     /* Length variable but >=4. Mind the 64 bit alignment! */
 };
 
 struct ipv6_esp_hdr {
-        __u32 spi;
-        __u32 seq_no;           /* Sequence number */
+        __be32 spi;
+        __be32 seq_no;           /* Sequence number */
         __u8  enc_data[0];      /* Length variable but >=8. Mind the 64 bit alignment! */
 };
 
 struct ipv6_comp_hdr {
         __u8 nexthdr;
         __u8 flags;
-        __u16 cpi;
+        __be16 cpi;
 };
 
 /*
@@ -136,7 +136,7 @@ struct ipv6hdr {
 #endif
         __u8                    flow_lbl[3];
 
-        __u16                   payload_len;
+        __be16                  payload_len;
         __u8                    nexthdr;
         __u8                    hop_limit;
 
@@ -461,7 +461,7 @@ static inline struct raw6_sock *raw6_sk(const struct sock *sk)
 
 #define INET6_MATCH(__sk, __hash, __saddr, __daddr, __ports, __dif)\
         (((__sk)->sk_hash == (__hash))                          && \
-         ((*((__u32 *)&(inet_sk(__sk)->dport))) == (__ports))   && \
+         ((*((__portpair *)&(inet_sk(__sk)->dport))) == (__ports))      && \
          ((__sk)->sk_family             == AF_INET6)            && \
          ipv6_addr_equal(&inet6_sk(__sk)->daddr, (__saddr))     && \
          ipv6_addr_equal(&inet6_sk(__sk)->rcv_saddr, (__daddr)) && \
diff --git a/include/linux/mroute.h b/include/linux/mroute.h
index e05d54a90743..7da2cee8e132 100644
--- a/include/linux/mroute.h
+++ b/include/linux/mroute.h
@@ -142,7 +142,7 @@ struct vif_device
         unsigned long   rate_limit;             /* Traffic shaping (NI)         */
         unsigned char   threshold;              /* TTL threshold                */
         unsigned short  flags;                  /* Control flags                */
-        __u32           local,remote;           /* Addresses(remote for tunnels)*/
+        __be32          local,remote;           /* Addresses(remote for tunnels)*/
         int             link;                   /* Physical interface index     */
 };
 
@@ -151,8 +151,8 @@ struct vif_device
 struct mfc_cache 
 {
         struct mfc_cache *next;                 /* Next entry on cache line     */
-        __u32 mfc_mcastgrp;                     /* Group the entry belongs to   */
-        __u32 mfc_origin;                       /* Source of packet             */
+        __be32 mfc_mcastgrp;                    /* Group the entry belongs to   */
+        __be32 mfc_origin;                      /* Source of packet             */
         vifi_t mfc_parent;                      /* Source interface             */
         int mfc_flags;                          /* Flags on line                */
 
@@ -179,9 +179,9 @@ struct mfc_cache
 #define MFC_LINES               64
 
 #ifdef __BIG_ENDIAN
-#define MFC_HASH(a,b)   ((((a)>>24)^((b)>>26))&(MFC_LINES-1))
+#define MFC_HASH(a,b)   (((((__force u32)(__be32)a)>>24)^(((__force u32)(__be32)b)>>26))&(MFC_LINES-1))
 #else
-#define MFC_HASH(a,b)   (((a)^((b)>>2))&(MFC_LINES-1))
+#define MFC_HASH(a,b)   ((((__force u32)(__be32)a)^(((__force u32)(__be32)b)>>2))&(MFC_LINES-1))
 #endif          
 
 #endif
@@ -213,8 +213,8 @@ struct pimreghdr
 {
         __u8    type;
         __u8    reserved;
-        __u16   csum;
-        __u32   flags;
+        __be16  csum;
+        __be32  flags;
 };
 
 extern int pim_rcv_v1(struct sk_buff *);
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 13d6d4eb8b3a..9264139bd8df 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -187,7 +187,7 @@ struct hh_cache
 {
         struct hh_cache *hh_next;       /* Next entry                        */
         atomic_t        hh_refcnt;      /* number of users                   */
-        unsigned short  hh_type;        /* protocol identifier, f.e ETH_P_IP
+        __be16          hh_type;        /* protocol identifier, f.e ETH_P_IP
                                          *  NOTE:  For VLANs, this will be the
                                          *  encapuslated type. --BLG
                                          */
diff --git a/include/linux/netfilter_arp/arp_tables.h b/include/linux/netfilter_arp/arp_tables.h
index 149e87c9ab13..44e39b61d9e7 100644
--- a/include/linux/netfilter_arp/arp_tables.h
+++ b/include/linux/netfilter_arp/arp_tables.h
@@ -46,11 +46,11 @@ struct arpt_arp {
         struct arpt_devaddr_info tgt_devaddr;
 
         /* ARP operation code. */
-        u_int16_t arpop, arpop_mask;
+        __be16 arpop, arpop_mask;
 
         /* ARP hardware address and protocol address format. */
-        u_int16_t arhrd, arhrd_mask;
-        u_int16_t arpro, arpro_mask;
+        __be16 arhrd, arhrd_mask;
+        __be16 arpro, arpro_mask;
 
         /* The protocol address length is only accepted if it is 4
          * so there is no use in offering a way to do filtering on it.
diff --git a/include/linux/netfilter_ipv4/ip_conntrack.h b/include/linux/netfilter_ipv4/ip_conntrack.h
index 51dbec1892c8..64e868034c4a 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack.h
@@ -157,7 +157,7 @@ struct ip_conntrack_expect
         unsigned int flags;
 
 #ifdef CONFIG_IP_NF_NAT_NEEDED
-        u_int32_t saved_ip;
+        __be32 saved_ip;
         /* This is the original per-proto part, used to map the
          * expected connection the way the recipient expects. */
         union ip_conntrack_manip_proto saved_proto;
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_h323.h b/include/linux/netfilter_ipv4/ip_conntrack_h323.h
index 3cbff7379002..943cc6a4871d 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack_h323.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack_h323.h
@@ -30,7 +30,7 @@ struct ip_ct_h323_master {
 struct ip_conntrack_expect;
 
 extern int get_h225_addr(unsigned char *data, TransportAddress * addr,
-                         u_int32_t * ip, u_int16_t * port);
+                         __be32 * ip, u_int16_t * port);
 extern void ip_conntrack_h245_expect(struct ip_conntrack *new,
                                      struct ip_conntrack_expect *this);
 extern void ip_conntrack_q931_expect(struct ip_conntrack *new,
@@ -38,11 +38,11 @@ extern void ip_conntrack_q931_expect(struct ip_conntrack *new,
 extern int (*set_h245_addr_hook) (struct sk_buff ** pskb,
                                   unsigned char **data, int dataoff,
                                   H245_TransportAddress * addr,
-                                  u_int32_t ip, u_int16_t port);
+                                  __be32 ip, u_int16_t port);
 extern int (*set_h225_addr_hook) (struct sk_buff ** pskb,
                                   unsigned char **data, int dataoff,
                                   TransportAddress * addr,
-                                  u_int32_t ip, u_int16_t port);
+                                  __be32 ip, u_int16_t port);
 extern int (*set_sig_addr_hook) (struct sk_buff ** pskb,
                                  struct ip_conntrack * ct,
                                  enum ip_conntrack_info ctinfo,
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_tuple.h b/include/linux/netfilter_ipv4/ip_conntrack_tuple.h
index 2fdabdb4c0ef..c228bde74c33 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack_tuple.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack_tuple.h
@@ -23,13 +23,13 @@ union ip_conntrack_manip_proto
                 __be16 port;
         } tcp;
         struct {
-                u_int16_t port;
+                __be16 port;
         } udp;
         struct {
-                u_int16_t id;
+                __be16 id;
         } icmp;
         struct {
-                u_int16_t port;
+                __be16 port;
         } sctp;
         struct {
                 __be16 key;     /* key is 32bit, pptp only uses 16 */
@@ -39,7 +39,7 @@ union ip_conntrack_manip_proto
 /* The manipulable part of the tuple. */
 struct ip_conntrack_manip
 {
-        u_int32_t ip;
+        __be32 ip;
         union ip_conntrack_manip_proto u;
 };
 
@@ -50,22 +50,22 @@ struct ip_conntrack_tuple
 
         /* These are the parts of the tuple which are fixed. */
         struct {
-                u_int32_t ip;
+                __be32 ip;
                 union {
                         /* Add other protocols here. */
                         u_int16_t all;
 
                         struct {
-                                u_int16_t port;
+                                __be16 port;
                         } tcp;
                         struct {
-                                u_int16_t port;
+                                __be16 port;
                         } udp;
                         struct {
                                 u_int8_t type, code;
                         } icmp;
                         struct {
-                                u_int16_t port;
+                                __be16 port;
                         } sctp;
                         struct {
                                 __be16 key;     /* key is 32bit, 
diff --git a/include/linux/netfilter_ipv4/ip_nat.h b/include/linux/netfilter_ipv4/ip_nat.h
index 98f8407e4cb5..bdf553620ca1 100644
--- a/include/linux/netfilter_ipv4/ip_nat.h
+++ b/include/linux/netfilter_ipv4/ip_nat.h
@@ -33,7 +33,7 @@ struct ip_nat_range
         unsigned int flags;
 
         /* Inclusive: network order. */
-        u_int32_t min_ip, max_ip;
+        __be32 min_ip, max_ip;
 
         /* Inclusive: network order */
         union ip_conntrack_manip_proto min, max;
diff --git a/include/linux/netfilter_ipv4/ip_queue.h b/include/linux/netfilter_ipv4/ip_queue.h
index aa08d68c4841..a03507f465f8 100644
--- a/include/linux/netfilter_ipv4/ip_queue.h
+++ b/include/linux/netfilter_ipv4/ip_queue.h
@@ -26,7 +26,7 @@ typedef struct ipq_packet_msg {
         unsigned int hook;              /* Netfilter hook we rode in on */
         char indev_name[IFNAMSIZ];      /* Name of incoming interface */
         char outdev_name[IFNAMSIZ];     /* Name of outgoing interface */
-        unsigned short hw_protocol;     /* Hardware protocol (network order) */
+        __be16 hw_protocol;             /* Hardware protocol (network order) */
         unsigned short hw_type;         /* Hardware type */
         unsigned char hw_addrlen;       /* Hardware address length */
         unsigned char hw_addr[8];       /* Hardware address */
diff --git a/include/linux/netfilter_ipv4/ipt_iprange.h b/include/linux/netfilter_ipv4/ipt_iprange.h
index 3ecb3bd63676..34ab0fb736e2 100644
--- a/include/linux/netfilter_ipv4/ipt_iprange.h
+++ b/include/linux/netfilter_ipv4/ipt_iprange.h
@@ -8,7 +8,7 @@
 
 struct ipt_iprange {
         /* Inclusive: network order. */
-        u_int32_t min_ip, max_ip;
+        __be32 min_ip, max_ip;
 };
 
 struct ipt_iprange_info
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 61db1907f06f..b7e85ff045ea 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1904,6 +1904,7 @@
 #define PCI_DEVICE_ID_TIGON3_5705_2     0x1654
 #define PCI_DEVICE_ID_TIGON3_5720       0x1658
 #define PCI_DEVICE_ID_TIGON3_5721       0x1659
+#define PCI_DEVICE_ID_TIGON3_5722       0x165a
 #define PCI_DEVICE_ID_TIGON3_5705M      0x165d
 #define PCI_DEVICE_ID_TIGON3_5705M_2    0x165e
 #define PCI_DEVICE_ID_TIGON3_5714       0x1668
@@ -1913,6 +1914,7 @@
 #define PCI_DEVICE_ID_TIGON3_5705F      0x166e
 #define PCI_DEVICE_ID_TIGON3_5754M      0x1672
 #define PCI_DEVICE_ID_TIGON3_5755M      0x1673
+#define PCI_DEVICE_ID_TIGON3_5756       0x1674
 #define PCI_DEVICE_ID_TIGON3_5750       0x1676
 #define PCI_DEVICE_ID_TIGON3_5751       0x1677
 #define PCI_DEVICE_ID_TIGON3_5715       0x1678
@@ -1942,6 +1944,8 @@
 #define PCI_DEVICE_ID_TIGON3_5901       0x170d
 #define PCI_DEVICE_ID_BCM4401B1         0x170c
 #define PCI_DEVICE_ID_TIGON3_5901_2     0x170e
+#define PCI_DEVICE_ID_TIGON3_5906       0x1712
+#define PCI_DEVICE_ID_TIGON3_5906M      0x1713
 #define PCI_DEVICE_ID_BCM4401           0x4401
 #define PCI_DEVICE_ID_BCM4401B0         0x4402
 
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index 9c92dc8b9a08..3a18addaed4c 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -2,7 +2,7 @@
 #define __LINUX_RTNETLINK_H
 
 #include <linux/netlink.h>
-#include <linux/if.h>
+#include <linux/if_link.h>
 
 /****
  *              Routing/neighbour discovery messages.
diff --git a/include/linux/sunrpc/auth.h b/include/linux/sunrpc/auth.h
index a6de332e57d4..862c0d8c8381 100644
--- a/include/linux/sunrpc/auth.h
+++ b/include/linux/sunrpc/auth.h
@@ -109,13 +109,13 @@ struct rpc_credops {
         void                    (*crdestroy)(struct rpc_cred *);
 
         int                     (*crmatch)(struct auth_cred *, struct rpc_cred *, int);
-        u32 *                   (*crmarshal)(struct rpc_task *, u32 *);
+        __be32 *                (*crmarshal)(struct rpc_task *, __be32 *);
         int                     (*crrefresh)(struct rpc_task *);
-        u32 *                   (*crvalidate)(struct rpc_task *, u32 *);
+        __be32 *                (*crvalidate)(struct rpc_task *, __be32 *);
         int                     (*crwrap_req)(struct rpc_task *, kxdrproc_t,
-                                                void *, u32 *, void *);
+                                                void *, __be32 *, void *);
         int                     (*crunwrap_resp)(struct rpc_task *, kxdrproc_t,
-                                                void *, u32 *, void *);
+                                                void *, __be32 *, void *);
 };
 
 extern struct rpc_authops       authunix_ops;
@@ -134,10 +134,10 @@ struct rpc_cred *	rpcauth_bindcred(struct rpc_task *);
 void                    rpcauth_holdcred(struct rpc_task *);
 void                    put_rpccred(struct rpc_cred *);
 void                    rpcauth_unbindcred(struct rpc_task *);
-u32 *                   rpcauth_marshcred(struct rpc_task *, u32 *);
-u32 *                   rpcauth_checkverf(struct rpc_task *, u32 *);
-int                     rpcauth_wrap_req(struct rpc_task *task, kxdrproc_t encode, void *rqstp, u32 *data, void *obj);
-int                     rpcauth_unwrap_resp(struct rpc_task *task, kxdrproc_t decode, void *rqstp, u32 *data, void *obj);
+__be32 *                rpcauth_marshcred(struct rpc_task *, __be32 *);
+__be32 *                rpcauth_checkverf(struct rpc_task *, __be32 *);
+int                     rpcauth_wrap_req(struct rpc_task *task, kxdrproc_t encode, void *rqstp, __be32 *data, void *obj);
+int                     rpcauth_unwrap_resp(struct rpc_task *task, kxdrproc_t decode, void *rqstp, __be32 *data, void *obj);
 int                     rpcauth_refreshcred(struct rpc_task *);
 void                    rpcauth_invalcred(struct rpc_task *);
 int                     rpcauth_uptodatecred(struct rpc_task *);
diff --git a/include/linux/sunrpc/msg_prot.h b/include/linux/sunrpc/msg_prot.h
index f43f237360ae..d9f5934ac9fe 100644
--- a/include/linux/sunrpc/msg_prot.h
+++ b/include/linux/sunrpc/msg_prot.h
@@ -95,7 +95,7 @@ enum rpc_auth_stat {
  * 2GB.
  */
 
-typedef u32     rpc_fraghdr;
+typedef __be32  rpc_fraghdr;
 
 #define RPC_LAST_STREAM_FRAGMENT        (1U << 31)
 #define RPC_FRAGMENT_SIZE_MASK          (~RPC_LAST_STREAM_FRAGMENT)
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index 7b27c09b5604..73140ee5c638 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -78,28 +78,45 @@ struct svc_serv {
  */
 #define RPCSVC_MAXPAGES         ((RPCSVC_MAXPAYLOAD+PAGE_SIZE-1)/PAGE_SIZE + 2)
 
-static inline u32 svc_getu32(struct kvec *iov)
+static inline u32 svc_getnl(struct kvec *iov)
 {
-        u32 val, *vp;
+        __be32 val, *vp;
         vp = iov->iov_base;
         val = *vp++;
         iov->iov_base = (void*)vp;
-        iov->iov_len -= sizeof(u32);
+        iov->iov_len -= sizeof(__be32);
+        return ntohl(val);
+}
+
+static inline void svc_putnl(struct kvec *iov, u32 val)
+{
+        __be32 *vp = iov->iov_base + iov->iov_len;
+        *vp = htonl(val);
+        iov->iov_len += sizeof(__be32);
+}
+
+static inline __be32 svc_getu32(struct kvec *iov)
+{
+        __be32 val, *vp;
+        vp = iov->iov_base;
+        val = *vp++;
+        iov->iov_base = (void*)vp;
+        iov->iov_len -= sizeof(__be32);
         return val;
 }
 
 static inline void svc_ungetu32(struct kvec *iov)
 {
-        u32 *vp = (u32 *)iov->iov_base;
+        __be32 *vp = (__be32 *)iov->iov_base;
         iov->iov_base = (void *)(vp - 1);
         iov->iov_len += sizeof(*vp);
 }
 
-static inline void svc_putu32(struct kvec *iov, u32 val)
+static inline void svc_putu32(struct kvec *iov, __be32 val)
 {
-        u32 *vp = iov->iov_base + iov->iov_len;
+        __be32 *vp = iov->iov_base + iov->iov_len;
         *vp = val;
-        iov->iov_len += sizeof(u32);
+        iov->iov_len += sizeof(__be32);
 }
 
         
@@ -130,7 +147,7 @@ struct svc_rqst {
         short                   rq_arghi;       /* pages available in argument page list */
         short                   rq_resused;     /* pages used for result */
 
-        u32                     rq_xid;         /* transmission id */
+        __be32                  rq_xid;         /* transmission id */
         u32                     rq_prog;        /* program number */
         u32                     rq_vers;        /* program version */
         u32                     rq_proc;        /* procedure number */
@@ -139,7 +156,7 @@ struct svc_rqst {
                                 rq_secure  : 1; /* secure port */
 
 
-        __u32                   rq_daddr;       /* dest addr of request - reply from here */
+        __be32                  rq_daddr;       /* dest addr of request - reply from here */
 
         void *                  rq_argp;        /* decoded arguments */
         void *                  rq_resp;        /* xdr'd results */
@@ -169,7 +186,7 @@ struct svc_rqst {
  * Check buffer bounds after decoding arguments
  */
 static inline int
-xdr_argsize_check(struct svc_rqst *rqstp, u32 *p)
+xdr_argsize_check(struct svc_rqst *rqstp, __be32 *p)
 {
         char *cp = (char *)p;
         struct kvec *vec = &rqstp->rq_arg.head[0];
@@ -178,7 +195,7 @@ xdr_argsize_check(struct svc_rqst *rqstp, u32 *p)
 }
 
 static inline int
-xdr_ressize_check(struct svc_rqst *rqstp, u32 *p)
+xdr_ressize_check(struct svc_rqst *rqstp, __be32 *p)
 {
         struct kvec *vec = &rqstp->rq_res.head[0];
         char *cp = (char*)p;
@@ -249,10 +266,10 @@ struct svc_deferred_req {
         u32                     prot;   /* protocol (UDP or TCP) */
         struct sockaddr_in      addr;
         struct svc_sock         *svsk;  /* where reply must go */
-        u32                     daddr;  /* where reply must come from */
+        __be32                  daddr;  /* where reply must come from */
         struct cache_deferred_req handle;
         int                     argslen;
-        u32                     args[0];
+        __be32                  args[0];
 };
 
 /*
@@ -284,7 +301,7 @@ struct svc_version {
          * A return value of 0 means drop the request. 
          * vs_dispatch == NULL means use default dispatcher.
          */
-        int                     (*vs_dispatch)(struct svc_rqst *, u32 *);
+        int                     (*vs_dispatch)(struct svc_rqst *, __be32 *);
 };
 
 /*
diff --git a/include/linux/sunrpc/svcauth.h b/include/linux/sunrpc/svcauth.h
index 2fe2087edd66..a6601650deeb 100644
--- a/include/linux/sunrpc/svcauth.h
+++ b/include/linux/sunrpc/svcauth.h
@@ -95,7 +95,7 @@ struct auth_ops {
         char *  name;
         struct module *owner;
         int     flavour;
-        int     (*accept)(struct svc_rqst *rq, u32 *authp);
+        int     (*accept)(struct svc_rqst *rq, __be32 *authp);
         int     (*release)(struct svc_rqst *rq);
         void    (*domain_release)(struct auth_domain *);
         int     (*set_client)(struct svc_rqst *rq);
@@ -112,7 +112,7 @@ struct auth_ops {
 #define SVC_COMPLETE    9
 
 
-extern int      svc_authenticate(struct svc_rqst *rqstp, u32 *authp);
+extern int      svc_authenticate(struct svc_rqst *rqstp, __be32 *authp);
 extern int      svc_authorise(struct svc_rqst *rqstp);
 extern int      svc_set_client(struct svc_rqst *rqstp);
 extern int      svc_auth_register(rpc_authflavor_t flavor, struct auth_ops *aops);
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
index e6d3d349506c..953723b09bc6 100644
--- a/include/linux/sunrpc/xdr.h
+++ b/include/linux/sunrpc/xdr.h
@@ -32,7 +32,7 @@ struct xdr_netobj {
  * side) or svc_rqst pointer (server side).
  * Encode functions always assume there's enough room in the buffer.
  */
-typedef int     (*kxdrproc_t)(void *rqstp, u32 *data, void *obj);
+typedef int     (*kxdrproc_t)(void *rqstp, __be32 *data, void *obj);
 
 /*
  * Basic structure for transmission/reception of a client XDR message.
@@ -88,19 +88,19 @@ struct xdr_buf {
 /*
  * Miscellaneous XDR helper functions
  */
-u32 *   xdr_encode_opaque_fixed(u32 *p, const void *ptr, unsigned int len);
-u32 *   xdr_encode_opaque(u32 *p, const void *ptr, unsigned int len);
-u32 *   xdr_encode_string(u32 *p, const char *s);
-u32 *   xdr_decode_string_inplace(u32 *p, char **sp, int *lenp, int maxlen);
-u32 *   xdr_encode_netobj(u32 *p, const struct xdr_netobj *);
-u32 *   xdr_decode_netobj(u32 *p, struct xdr_netobj *);
+__be32 *xdr_encode_opaque_fixed(__be32 *p, const void *ptr, unsigned int len);
+__be32 *xdr_encode_opaque(__be32 *p, const void *ptr, unsigned int len);
+__be32 *xdr_encode_string(__be32 *p, const char *s);
+__be32 *xdr_decode_string_inplace(__be32 *p, char **sp, int *lenp, int maxlen);
+__be32 *xdr_encode_netobj(__be32 *p, const struct xdr_netobj *);
+__be32 *xdr_decode_netobj(__be32 *p, struct xdr_netobj *);
 
 void    xdr_encode_pages(struct xdr_buf *, struct page **, unsigned int,
                          unsigned int);
 void    xdr_inline_pages(struct xdr_buf *, unsigned int,
                          struct page **, unsigned int, unsigned int);
 
-static inline u32 *xdr_encode_array(u32 *p, const void *s, unsigned int len)
+static inline __be32 *xdr_encode_array(__be32 *p, const void *s, unsigned int len)
 {
         return xdr_encode_opaque(p, s, len);
 }
@@ -108,16 +108,16 @@ static inline u32 *xdr_encode_array(u32 *p, const void *s, unsigned int len)
 /*
  * Decode 64bit quantities (NFSv3 support)
  */
-static inline u32 *
-xdr_encode_hyper(u32 *p, __u64 val)
+static inline __be32 *
+xdr_encode_hyper(__be32 *p, __u64 val)
 {
         *p++ = htonl(val >> 32);
         *p++ = htonl(val & 0xFFFFFFFF);
         return p;
 }
 
-static inline u32 *
-xdr_decode_hyper(u32 *p, __u64 *valp)
+static inline __be32 *
+xdr_decode_hyper(__be32 *p, __u64 *valp)
 {
         *valp  = ((__u64) ntohl(*p++)) << 32;
         *valp |= ntohl(*p++);
@@ -128,7 +128,7 @@ xdr_decode_hyper(u32 *p, __u64 *valp)
  * Adjust kvec to reflect end of xdr'ed data (RPC client XDR)
  */
 static inline int
-xdr_adjust_iovec(struct kvec *iov, u32 *p)
+xdr_adjust_iovec(struct kvec *iov, __be32 *p)
 {
         return iov->iov_len = ((u8 *) p - (u8 *) iov->iov_base);
 }
@@ -180,19 +180,19 @@ extern int xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
  * Provide some simple tools for XDR buffer overflow-checking etc.
  */
 struct xdr_stream {
-        uint32_t *p;            /* start of available buffer */
+        __be32 *p;              /* start of available buffer */
         struct xdr_buf *buf;    /* XDR buffer to read/write */
 
-        uint32_t *end;          /* end of available buffer space */
+        __be32 *end;            /* end of available buffer space */
         struct kvec *iov;       /* pointer to the current kvec */
 };
 
-extern void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, uint32_t *p);
-extern uint32_t *xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes);
+extern void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p);
+extern __be32 *xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes);
 extern void xdr_write_pages(struct xdr_stream *xdr, struct page **pages,
                 unsigned int base, unsigned int len);
-extern void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, uint32_t *p);
-extern uint32_t *xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes);
+extern void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p);
+extern __be32 *xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes);
 extern void xdr_read_pages(struct xdr_stream *xdr, unsigned int len);
 extern void xdr_enter_page(struct xdr_stream *xdr, unsigned int len);
 
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index bdeba8538c71..6cf626580752 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -79,7 +79,7 @@ struct rpc_rqst {
          * This is the private part
          */
         struct rpc_task *       rq_task;        /* RPC task data */
-        __u32                   rq_xid;         /* request XID */
+        __be32                  rq_xid;         /* request XID */
         int                     rq_cong;        /* has incremented xprt->cong */
         int                     rq_received;    /* receive completed */
         u32                     rq_seqno;       /* gss seq no. used on req. */
@@ -171,9 +171,9 @@ struct rpc_xprt {
         /*
          * State of TCP reply receive stuff
          */
-        u32                     tcp_recm,       /* Fragment header */
-                                tcp_xid,        /* Current XID */
-                                tcp_reclen,     /* fragment length */
+        __be32                  tcp_recm,       /* Fragment header */
+                                tcp_xid;        /* Current XID */
+        u32                     tcp_reclen,     /* fragment length */
                                 tcp_offset;     /* fragment offset */
         unsigned long           tcp_copied,     /* copied to request */
                                 tcp_flags;
@@ -253,7 +253,7 @@ void			xprt_release(struct rpc_task *task);
 struct rpc_xprt *       xprt_get(struct rpc_xprt *xprt);
 void                    xprt_put(struct rpc_xprt *xprt);
 
-static inline u32 *xprt_skip_transport_header(struct rpc_xprt *xprt, u32 *p)
+static inline __be32 *xprt_skip_transport_header(struct rpc_xprt *xprt, __be32 *p)
 {
         return p + xprt->tsh_size;
 }
@@ -268,7 +268,7 @@ void			xprt_wait_for_buffer_space(struct rpc_task *task);
 void                    xprt_write_space(struct rpc_xprt *xprt);
 void                    xprt_update_rtt(struct rpc_task *task);
 void                    xprt_adjust_cwnd(struct rpc_task *task, int result);
-struct rpc_rqst *       xprt_lookup_rqst(struct rpc_xprt *xprt, u32 xid);
+struct rpc_rqst *       xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid);
 void                    xprt_complete_rqst(struct rpc_task *task, int copied);
 void                    xprt_release_rqst_cong(struct rpc_task *task);
 void                    xprt_disconnect(struct rpc_xprt *xprt);
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 8ebf497907f8..0e058a2d1c6d 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -21,10 +21,10 @@
 #include <asm/byteorder.h>
 
 struct tcphdr {
-        __u16   source;
-        __u16   dest;
-        __u32   seq;
-        __u32   ack_seq;
+        __be16  source;
+        __be16  dest;
+        __be32  seq;
+        __be32  ack_seq;
 #if defined(__LITTLE_ENDIAN_BITFIELD)
         __u16   res1:4,
                 doff:4,
@@ -50,9 +50,9 @@ struct tcphdr {
 #else
 #error  "Adjust your <asm/byteorder.h> defines"
 #endif  
-        __u16   window;
-        __u16   check;
-        __u16   urg_ptr;
+        __be16  window;
+        __be16  check;
+        __be16  urg_ptr;
 };
 
 /*
@@ -62,7 +62,7 @@ struct tcphdr {
  */
 union tcp_word_hdr { 
         struct tcphdr hdr;
-        __u32             words[5];
+        __be32            words[5];
 }; 
 
 #define tcp_flag_word(tp) ( ((union tcp_word_hdr *)(tp))->words [3]) 
@@ -166,6 +166,11 @@ struct tcp_info
 #include <net/inet_timewait_sock.h>
 
 /* This defines a selective acknowledgement block. */
+struct tcp_sack_block_wire {
+        __be32  start_seq;
+        __be32  end_seq;
+};
+
 struct tcp_sack_block {
         __u32   start_seq;
         __u32   end_seq;
@@ -211,7 +216,7 @@ struct tcp_sock {
  *      Header prediction flags
  *      0x5?10 << 16 + snd_wnd in net byte order
  */
-        __u32   pred_flags;
+        __be32  pred_flags;
 
 /*
  *      RFC793 variables by their proper names. This means you can
diff --git a/include/linux/trdevice.h b/include/linux/trdevice.h
index 99e02ef54c47..bfc84a7aecc5 100644
--- a/include/linux/trdevice.h
+++ b/include/linux/trdevice.h
@@ -28,7 +28,7 @@
 #include <linux/if_tr.h>
 
 #ifdef __KERNEL__
-extern unsigned short   tr_type_trans(struct sk_buff *skb, struct net_device *dev);
+extern __be16 tr_type_trans(struct sk_buff *skb, struct net_device *dev);
 extern void tr_source_route(struct sk_buff *skb, struct trh_hdr *trh, struct net_device *dev);
 extern struct net_device *alloc_trdev(int sizeof_priv);
 
diff --git a/include/linux/udp.h b/include/linux/udp.h
index 90223f057d50..014b41d1e308 100644
--- a/include/linux/udp.h
+++ b/include/linux/udp.h
@@ -20,10 +20,10 @@
 #include <linux/types.h>
 
 struct udphdr {
-        __u16   source;
-        __u16   dest;
-        __u16   len;
-        __u16   check;
+        __be16  source;
+        __be16  dest;
+        __be16  len;
+        __be16  check;
 };
 
 /* UDP socket options */
diff --git a/include/linux/xfrm.h b/include/linux/xfrm.h
index 14ecd19f4cdc..430afd058269 100644
--- a/include/linux/xfrm.h
+++ b/include/linux/xfrm.h
@@ -12,8 +12,8 @@
  */
 typedef union
 {
-        __u32           a4;
-        __u32           a6[4];
+        __be32          a4;
+        __be32          a6[4];
 } xfrm_address_t;
 
 /* Ident of a specific xfrm_state. It is used on input to lookup
@@ -23,7 +23,7 @@ typedef union
 struct xfrm_id
 {
         xfrm_address_t  daddr;
-        __u32           spi;
+        __be32          spi;
         __u8            proto;
 };
 
@@ -49,10 +49,10 @@ struct xfrm_selector
 {
         xfrm_address_t  daddr;
         xfrm_address_t  saddr;
-        __u16   dport;
-        __u16   dport_mask;
-        __u16   sport;
-        __u16   sport_mask;
+        __be16  dport;
+        __be16  dport_mask;
+        __be16  sport;
+        __be16  sport_mask;
         __u16   family;
         __u8    prefixlen_d;
         __u8    prefixlen_s;
@@ -281,7 +281,7 @@ struct xfrm_usersa_info {
 
 struct xfrm_usersa_id {
         xfrm_address_t                  daddr;
-        __u32                           spi;
+        __be32                          spi;
         __u16                           family;
         __u8                            proto;
 };
diff --git a/include/net/arp.h b/include/net/arp.h
index 643bded9f557..6a3d9a7d302b 100644
--- a/include/net/arp.h
+++ b/include/net/arp.h
@@ -12,15 +12,15 @@ extern struct neigh_table arp_tbl;
 extern void     arp_init(void);
 extern int      arp_find(unsigned char *haddr, struct sk_buff *skb);
 extern int      arp_ioctl(unsigned int cmd, void __user *arg);
-extern void     arp_send(int type, int ptype, u32 dest_ip, 
-                         struct net_device *dev, u32 src_ip, 
+extern void     arp_send(int type, int ptype, __be32 dest_ip,
+                         struct net_device *dev, __be32 src_ip,
                          unsigned char *dest_hw, unsigned char *src_hw, unsigned char *th);
 extern int      arp_bind_neighbour(struct dst_entry *dst);
 extern int      arp_mc_map(u32 addr, u8 *haddr, struct net_device *dev, int dir);
 extern void     arp_ifdown(struct net_device *dev);
 
-extern struct sk_buff *arp_create(int type, int ptype, u32 dest_ip,
-                                  struct net_device *dev, u32 src_ip,
+extern struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
+                                  struct net_device *dev, __be32 src_ip,
                                   unsigned char *dest_hw, unsigned char *src_hw,
                                   unsigned char *target_hw);
 extern void arp_xmit(struct sk_buff *skb);
diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h
index b2bdb1aa0429..10a3eec191fd 100644
--- a/include/net/bluetooth/hci.h
+++ b/include/net/bluetooth/hci.h
@@ -44,12 +44,13 @@
 #define HCI_NOTIFY_VOICE_SETTING        3
 
 /* HCI device types */
-#define HCI_VHCI        0
+#define HCI_VIRTUAL     0
 #define HCI_USB         1
 #define HCI_PCCARD      2
 #define HCI_UART        3
 #define HCI_RS232       4
 #define HCI_PCI         5
+#define HCI_SDIO        6
 
 /* HCI device quirks */
 enum {
@@ -296,6 +297,7 @@ struct hci_cp_host_buffer_size {
 
 /* Link Control */
 #define OGF_LINK_CTL    0x01 
+
 #define OCF_CREATE_CONN         0x0005
 struct hci_cp_create_conn {
         bdaddr_t bdaddr;
@@ -306,6 +308,11 @@ struct hci_cp_create_conn {
         __u8     role_switch;
 } __attribute__ ((packed));
 
+#define OCF_CREATE_CONN_CANCEL  0x0008
+struct hci_cp_create_conn_cancel {
+        bdaddr_t bdaddr;
+} __attribute__ ((packed));
+
 #define OCF_ACCEPT_CONN_REQ     0x0009
 struct hci_cp_accept_conn_req {
         bdaddr_t bdaddr;
@@ -339,6 +346,8 @@ struct hci_cp_inquiry {
 
 #define OCF_INQUIRY_CANCEL      0x0002
 
+#define OCF_EXIT_PERIODIC_INQ   0x0004
+
 #define OCF_LINK_KEY_REPLY      0x000B
 struct hci_cp_link_key_reply {
         bdaddr_t bdaddr;
diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index d84855fe7336..df22efcfcc0b 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -72,6 +72,9 @@ struct hci_dev {
         __u8            type;
         bdaddr_t        bdaddr;
         __u8            features[8];
+        __u8            hci_ver;
+        __u16           hci_rev;
+        __u16           manufacturer;
         __u16           voice_setting;
 
         __u16           pkt_type;
@@ -165,6 +168,10 @@ struct hci_conn {
         struct timer_list disc_timer;
         struct timer_list idle_timer;
 
+        struct work_struct work;
+
+        struct device   dev;
+
         struct hci_dev  *hdev;
         void            *l2cap_data;
         void            *sco_data;
@@ -309,10 +316,13 @@ static inline void hci_conn_put(struct hci_conn *conn)
         if (atomic_dec_and_test(&conn->refcnt)) {
                 unsigned long timeo;
                 if (conn->type == ACL_LINK) {
-                        timeo = msecs_to_jiffies(HCI_DISCONN_TIMEOUT);
-                        if (!conn->out)
-                                timeo *= 2;
                         del_timer(&conn->idle_timer);
+                        if (conn->state == BT_CONNECTED) {
+                                timeo = msecs_to_jiffies(HCI_DISCONN_TIMEOUT);
+                                if (!conn->out)
+                                        timeo *= 2;
+                        } else
+                                timeo = msecs_to_jiffies(10);
                 } else
                         timeo = msecs_to_jiffies(10);
                 mod_timer(&conn->disc_timer, jiffies + timeo);
@@ -412,6 +422,8 @@ static inline int hci_recv_frame(struct sk_buff *skb)
 
 int hci_register_sysfs(struct hci_dev *hdev);
 void hci_unregister_sysfs(struct hci_dev *hdev);
+void hci_conn_add_sysfs(struct hci_conn *conn);
+void hci_conn_del_sysfs(struct hci_conn *conn);
 
 #define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->parent = (pdev))
 
diff --git a/include/net/cipso_ipv4.h b/include/net/cipso_ipv4.h
index 2d72496c2029..5d6ae1b2b196 100644
--- a/include/net/cipso_ipv4.h
+++ b/include/net/cipso_ipv4.h
@@ -128,7 +128,9 @@ extern int cipso_v4_rbm_strictvalid;
 
 #ifdef CONFIG_NETLABEL
 int cipso_v4_doi_add(struct cipso_v4_doi *doi_def);
-int cipso_v4_doi_remove(u32 doi, void (*callback) (struct rcu_head * head));
+int cipso_v4_doi_remove(u32 doi,
+                        u32 audit_secid,
+                        void (*callback) (struct rcu_head * head));
 struct cipso_v4_doi *cipso_v4_doi_getdef(u32 doi);
 int cipso_v4_doi_walk(u32 *skip_cnt,
                      int (*callback) (struct cipso_v4_doi *doi_def, void *arg),
@@ -143,6 +145,7 @@ static inline int cipso_v4_doi_add(struct cipso_v4_doi *doi_def)
 }
 
 static inline int cipso_v4_doi_remove(u32 doi,
+                                    u32 audit_secid,
                                     void (*callback) (struct rcu_head * head))
 {
         return 0;
diff --git a/include/net/dst.h b/include/net/dst.h
index a8d825f90305..e156e38e4ac3 100644
--- a/include/net/dst.h
+++ b/include/net/dst.h
@@ -84,7 +84,7 @@ struct dst_entry
 struct dst_ops
 {
         unsigned short          family;
-        unsigned short          protocol;
+        __be16                  protocol;
         unsigned                gc_thresh;
 
         int                     (*gc)(void);
diff --git a/include/net/flow.h b/include/net/flow.h
index 3ca210ec1379..ddf5f3ca1720 100644
--- a/include/net/flow.h
+++ b/include/net/flow.h
@@ -16,8 +16,8 @@ struct flowi {
 
         union {
                 struct {
-                        __u32                   daddr;
-                        __u32                   saddr;
+                        __be32                  daddr;
+                        __be32                  saddr;
                         __u32                   fwmark;
                         __u8                    tos;
                         __u8                    scope;
@@ -56,8 +56,8 @@ struct flowi {
 #define FLOWI_FLAG_MULTIPATHOLDROUTE 0x01
         union {
                 struct {
-                        __u16   sport;
-                        __u16   dport;
+                        __be16  sport;
+                        __be16  dport;
                 } ports;
 
                 struct {
@@ -73,7 +73,7 @@ struct flowi {
                         __u8    objname[16]; /* Not zero terminated */
                 } dnports;
 
-                __u32           spi;
+                __be32          spi;
 
 #ifdef CONFIG_IPV6_MIP6
                 struct {
diff --git a/include/net/icmp.h b/include/net/icmp.h
index 05f8ff7d9316..dc09474efcf3 100644
--- a/include/net/icmp.h
+++ b/include/net/icmp.h
@@ -38,7 +38,7 @@ struct dst_entry;
 struct net_proto_family;
 struct sk_buff;
 
-extern void     icmp_send(struct sk_buff *skb_in,  int type, int code, u32 info);
+extern void     icmp_send(struct sk_buff *skb_in,  int type, int code, __be32 info);
 extern int      icmp_rcv(struct sk_buff *skb);
 extern int      icmp_ioctl(struct sock *sk, int cmd, unsigned long arg);
 extern void     icmp_init(struct net_proto_family *ops);
diff --git a/include/net/inet_connection_sock.h b/include/net/inet_connection_sock.h
index de4e83b6da4b..0bcf9f237e1f 100644
--- a/include/net/inet_connection_sock.h
+++ b/include/net/inet_connection_sock.h
@@ -238,9 +238,9 @@ extern struct sock *inet_csk_accept(struct sock *sk, int flags, int *err);
 
 extern struct request_sock *inet_csk_search_req(const struct sock *sk,
                                                 struct request_sock ***prevp,
-                                                const __u16 rport,
-                                                const __u32 raddr,
-                                                const __u32 laddr);
+                                                const __be16 rport,
+                                                const __be32 raddr,
+                                                const __be32 laddr);
 extern int inet_csk_bind_conflict(const struct sock *sk,
                                   const struct inet_bind_bucket *tb);
 extern int inet_csk_get_port(struct inet_hashinfo *hashinfo,
diff --git a/include/net/inet_hashtables.h b/include/net/inet_hashtables.h
index b4491c9e2a5a..a9eb2eaf094e 100644
--- a/include/net/inet_hashtables.h
+++ b/include/net/inet_hashtables.h
@@ -272,42 +272,56 @@ static inline int inet_iif(const struct sk_buff *skb)
 }
 
 extern struct sock *__inet_lookup_listener(struct inet_hashinfo *hashinfo,
-                                           const u32 daddr,
+                                           const __be32 daddr,
                                            const unsigned short hnum,
                                            const int dif);
 
 static inline struct sock *inet_lookup_listener(struct inet_hashinfo *hashinfo,
-                                                u32 daddr, u16 dport, int dif)
+                                                __be32 daddr, __be16 dport, int dif)
 {
         return __inet_lookup_listener(hashinfo, daddr, ntohs(dport), dif);
 }
 
 /* Socket demux engine toys. */
+/* What happens here is ugly; there's a pair of adjacent fields in
+   struct inet_sock; __be16 dport followed by __u16 num.  We want to
+   search by pair, so we combine the keys into a single 32bit value
+   and compare with 32bit value read from &...->dport.  Let's at least
+   make sure that it's not mixed with anything else...
+   On 64bit targets we combine comparisons with pair of adjacent __be32
+   fields in the same way.
+*/
+typedef __u32 __bitwise __portpair;
 #ifdef __BIG_ENDIAN
 #define INET_COMBINED_PORTS(__sport, __dport) \
-        (((__u32)(__sport) << 16) | (__u32)(__dport))
+        ((__force __portpair)(((__force __u32)(__be16)(__sport) << 16) | (__u32)(__dport)))
 #else /* __LITTLE_ENDIAN */
 #define INET_COMBINED_PORTS(__sport, __dport) \
-        (((__u32)(__dport) << 16) | (__u32)(__sport))
+        ((__force __portpair)(((__u32)(__dport) << 16) | (__force __u32)(__be16)(__sport)))
 #endif
 
 #if (BITS_PER_LONG == 64)
+typedef __u64 __bitwise __addrpair;
 #ifdef __BIG_ENDIAN
 #define INET_ADDR_COOKIE(__name, __saddr, __daddr) \
-        const __u64 __name = (((__u64)(__saddr)) << 32) | ((__u64)(__daddr));
+        const __addrpair __name = (__force __addrpair) ( \
+                                   (((__force __u64)(__be32)(__saddr)) << 32) | \
+                                   ((__force __u64)(__be32)(__daddr)));
 #else /* __LITTLE_ENDIAN */
 #define INET_ADDR_COOKIE(__name, __saddr, __daddr) \
-        const __u64 __name = (((__u64)(__daddr)) << 32) | ((__u64)(__saddr));
+        const __addrpair __name = (__force __addrpair) ( \
+                                   (((__force __u64)(__be32)(__daddr)) << 32) | \
+                                   ((__force __u64)(__be32)(__saddr)));
 #endif /* __BIG_ENDIAN */
 #define INET_MATCH(__sk, __hash, __cookie, __saddr, __daddr, __ports, __dif)\
         (((__sk)->sk_hash == (__hash))                          &&      \
-         ((*((__u64 *)&(inet_sk(__sk)->daddr))) == (__cookie))  &&      \
-         ((*((__u32 *)&(inet_sk(__sk)->dport))) == (__ports))   &&      \
+         ((*((__addrpair *)&(inet_sk(__sk)->daddr))) == (__cookie))     &&      \
+         ((*((__portpair *)&(inet_sk(__sk)->dport))) == (__ports))      &&      \
          (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
 #define INET_TW_MATCH(__sk, __hash, __cookie, __saddr, __daddr, __ports, __dif)\
         (((__sk)->sk_hash == (__hash))                          &&      \
-         ((*((__u64 *)&(inet_twsk(__sk)->tw_daddr))) == (__cookie)) &&  \
-         ((*((__u32 *)&(inet_twsk(__sk)->tw_dport))) == (__ports)) &&   \
+         ((*((__addrpair *)&(inet_twsk(__sk)->tw_daddr))) == (__cookie)) &&     \
+         ((*((__portpair *)&(inet_twsk(__sk)->tw_dport))) == (__ports)) &&      \
          (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
 #else /* 32-bit arch */
 #define INET_ADDR_COOKIE(__name, __saddr, __daddr)
@@ -315,13 +329,13 @@ static inline struct sock *inet_lookup_listener(struct inet_hashinfo *hashinfo,
         (((__sk)->sk_hash == (__hash))                          &&      \
          (inet_sk(__sk)->daddr          == (__saddr))           &&      \
          (inet_sk(__sk)->rcv_saddr      == (__daddr))           &&      \
-         ((*((__u32 *)&(inet_sk(__sk)->dport))) == (__ports))   &&      \
+         ((*((__portpair *)&(inet_sk(__sk)->dport))) == (__ports))      &&      \
          (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
 #define INET_TW_MATCH(__sk, __hash,__cookie, __saddr, __daddr, __ports, __dif)  \
         (((__sk)->sk_hash == (__hash))                          &&      \
          (inet_twsk(__sk)->tw_daddr     == (__saddr))           &&      \
          (inet_twsk(__sk)->tw_rcv_saddr == (__daddr))           &&      \
-         ((*((__u32 *)&(inet_twsk(__sk)->tw_dport))) == (__ports)) &&   \
+         ((*((__portpair *)&(inet_twsk(__sk)->tw_dport))) == (__ports)) &&      \
          (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
 #endif /* 64-bit arch */
 
@@ -333,12 +347,12 @@ static inline struct sock *inet_lookup_listener(struct inet_hashinfo *hashinfo,
  */
 static inline struct sock *
         __inet_lookup_established(struct inet_hashinfo *hashinfo,
-                                  const u32 saddr, const u16 sport,
-                                  const u32 daddr, const u16 hnum,
+                                  const __be32 saddr, const __be16 sport,
+                                  const __be32 daddr, const u16 hnum,
                                   const int dif)
 {
         INET_ADDR_COOKIE(acookie, saddr, daddr)
-        const __u32 ports = INET_COMBINED_PORTS(sport, hnum);
+        const __portpair ports = INET_COMBINED_PORTS(sport, hnum);
         struct sock *sk;
         const struct hlist_node *node;
         /* Optimize here for direct hit, only listening connections can
@@ -370,8 +384,8 @@ hit:
 
 static inline struct sock *
         inet_lookup_established(struct inet_hashinfo *hashinfo,
-                                const u32 saddr, const u16 sport,
-                                const u32 daddr, const u16 dport,
+                                const __be32 saddr, const __be16 sport,
+                                const __be32 daddr, const __be16 dport,
                                 const int dif)
 {
         return __inet_lookup_established(hashinfo, saddr, sport, daddr,
@@ -379,8 +393,8 @@ static inline struct sock *
 }
 
 static inline struct sock *__inet_lookup(struct inet_hashinfo *hashinfo,
-                                         const u32 saddr, const u16 sport,
-                                         const u32 daddr, const u16 dport,
+                                         const __be32 saddr, const __be16 sport,
+                                         const __be32 daddr, const __be16 dport,
                                          const int dif)
 {
         u16 hnum = ntohs(dport);
@@ -390,8 +404,8 @@ static inline struct sock *__inet_lookup(struct inet_hashinfo *hashinfo,
 }
 
 static inline struct sock *inet_lookup(struct inet_hashinfo *hashinfo,
-                                       const u32 saddr, const u16 sport,
-                                       const u32 daddr, const u16 dport,
+                                       const __be32 saddr, const __be16 sport,
+                                       const __be32 daddr, const __be16 dport,
                                        const int dif)
 {
         struct sock *sk;
diff --git a/include/net/inet_sock.h b/include/net/inet_sock.h
index f6242710f2ff..ce6da97bc848 100644
--- a/include/net/inet_sock.h
+++ b/include/net/inet_sock.h
@@ -36,7 +36,7 @@
  * @ts_needaddr - Need to record addr of outgoing dev
  */
 struct ip_options {
-        __u32           faddr;
+        __be32          faddr;
         unsigned char   optlen;
         unsigned char   srr;
         unsigned char   rr;
@@ -62,9 +62,9 @@ struct inet_request_sock {
         u16                     inet6_rsk_offset;
         /* 2 bytes hole, try to pack */
 #endif
-        u32                     loc_addr;
-        u32                     rmt_addr;
-        u16                     rmt_port;
+        __be32                  loc_addr;
+        __be32                  rmt_addr;
+        __be16                  rmt_port;
         u16                     snd_wscale : 4, 
                                 rcv_wscale : 4, 
                                 tstamp_ok  : 1,
@@ -110,15 +110,15 @@ struct inet_sock {
         struct ipv6_pinfo       *pinet6;
 #endif
         /* Socket demultiplex comparisons on incoming packets. */
-        __u32                   daddr;
-        __u32                   rcv_saddr;
-        __u16                   dport;
+        __be32                  daddr;
+        __be32                  rcv_saddr;
+        __be16                  dport;
         __u16                   num;
-        __u32                   saddr;
+        __be32                  saddr;
         __s16                   uc_ttl;
         __u16                   cmsg_flags;
         struct ip_options       *opt;
-        __u16                   sport;
+        __be16                  sport;
         __u16                   id;
         __u8                    tos;
         __u8                    mc_ttl;
@@ -129,7 +129,7 @@ struct inet_sock {
                                 hdrincl:1,
                                 mc_loop:1;
         int                     mc_index;
-        __u32                   mc_addr;
+        __be32                  mc_addr;
         struct ip_mc_socklist   *mc_list;
         struct {
                 unsigned int            flags;
@@ -137,7 +137,7 @@ struct inet_sock {
                 struct ip_options       *opt;
                 struct rtable           *rt;
                 int                     length; /* Total length of all frames */
-                u32                     addr;
+                __be32                  addr;
                 struct flowi            fl;
         } cork;
 };
@@ -167,10 +167,10 @@ static inline void inet_sk_copy_descendant(struct sock *sk_to,
 
 extern int inet_sk_rebuild_header(struct sock *sk);
 
-static inline unsigned int inet_ehashfn(const __u32 laddr, const __u16 lport,
-                                        const __u32 faddr, const __u16 fport)
+static inline unsigned int inet_ehashfn(const __be32 laddr, const __u16 lport,
+                                        const __be32 faddr, const __be16 fport)
 {
-        unsigned int h = (laddr ^ lport) ^ (faddr ^ fport);
+        unsigned int h = ((__force __u32)laddr ^ lport) ^ ((__force __u32)faddr ^ (__force __u32)fport);
         h ^= h >> 16;
         h ^= h >> 8;
         return h;
@@ -179,10 +179,10 @@ static inline unsigned int inet_ehashfn(const __u32 laddr, const __u16 lport,
 static inline int inet_sk_ehashfn(const struct sock *sk)
 {
         const struct inet_sock *inet = inet_sk(sk);
-        const __u32 laddr = inet->rcv_saddr;
+        const __be32 laddr = inet->rcv_saddr;
         const __u16 lport = inet->num;
-        const __u32 faddr = inet->daddr;
-        const __u16 fport = inet->dport;
+        const __be32 faddr = inet->daddr;
+        const __be16 fport = inet->dport;
 
         return inet_ehashfn(laddr, lport, faddr, fport);
 }
diff --git a/include/net/inet_timewait_sock.h b/include/net/inet_timewait_sock.h
index 600cb543550d..6d14c22a00c5 100644
--- a/include/net/inet_timewait_sock.h
+++ b/include/net/inet_timewait_sock.h
@@ -120,10 +120,10 @@ struct inet_timewait_sock {
         unsigned char           tw_rcv_wscale;
         /* Socket demultiplex comparisons on incoming packets. */
         /* these five are in inet_sock */
-        __u16                   tw_sport;
-        __u32                   tw_daddr __attribute__((aligned(INET_TIMEWAIT_ADDRCMP_ALIGN_BYTES)));
-        __u32                   tw_rcv_saddr;
-        __u16                   tw_dport;
+        __be16                  tw_sport;
+        __be32                  tw_daddr __attribute__((aligned(INET_TIMEWAIT_ADDRCMP_ALIGN_BYTES)));
+        __be32                  tw_rcv_saddr;
+        __be16                  tw_dport;
         __u16                   tw_num;
         /* And these are ours. */
         __u8                    tw_ipv6only:1;
@@ -186,7 +186,7 @@ static inline struct inet_timewait_sock *inet_twsk(const struct sock *sk)
         return (struct inet_timewait_sock *)sk;
 }
 
-static inline u32 inet_rcv_saddr(const struct sock *sk)
+static inline __be32 inet_rcv_saddr(const struct sock *sk)
 {
         return likely(sk->sk_state != TCP_TIME_WAIT) ?
                 inet_sk(sk)->rcv_saddr : inet_twsk(sk)->tw_rcv_saddr;
diff --git a/include/net/inetpeer.h b/include/net/inetpeer.h
index 0965515f40cf..925573fd2aed 100644
--- a/include/net/inetpeer.h
+++ b/include/net/inetpeer.h
@@ -22,7 +22,7 @@ struct inet_peer
         unsigned long           dtime;          /* the time of last use of not
                                                  * referenced entries */
         atomic_t                refcnt;
-        __u32                   v4daddr;        /* peer's address */
+        __be32                  v4daddr;        /* peer's address */
         __u16                   avl_height;
         __u16                   ip_id_count;    /* IP ID for the next packet */
         atomic_t                rid;            /* Frag reception counter */
@@ -33,7 +33,7 @@ struct inet_peer
 void                    inet_initpeers(void) __init;
 
 /* can be called with or without local BH being disabled */
-struct inet_peer        *inet_getpeer(__u32 daddr, int create);
+struct inet_peer        *inet_getpeer(__be32 daddr, int create);
 
 extern spinlock_t inet_peer_unused_lock;
 extern struct inet_peer **inet_peer_unused_tailp;
diff --git a/include/net/ip.h b/include/net/ip.h
index 98f908400771..b6d95e553401 100644
--- a/include/net/ip.h
+++ b/include/net/ip.h
@@ -45,7 +45,7 @@ struct inet_skb_parm
 
 struct ipcm_cookie
 {
-        u32                     addr;
+        __be32                  addr;
         int                     oif;
         struct ip_options       *opt;
 };
@@ -86,7 +86,7 @@ extern int		igmp_mc_proc_init(void);
  */
 
 extern int              ip_build_and_send_pkt(struct sk_buff *skb, struct sock *sk,
-                                              u32 saddr, u32 daddr,
+                                              __be32 saddr, __be32 daddr,
                                               struct ip_options *opt);
 extern int              ip_rcv(struct sk_buff *skb, struct net_device *dev,
                                struct packet_type *pt, struct net_device *orig_dev);
@@ -335,7 +335,7 @@ extern int ip_net_unreachable(struct sk_buff *skb);
  *      Functions provided by ip_options.c
  */
  
-extern void ip_options_build(struct sk_buff *skb, struct ip_options *opt, u32 daddr, struct rtable *rt, int is_frag);
+extern void ip_options_build(struct sk_buff *skb, struct ip_options *opt, __be32 daddr, struct rtable *rt, int is_frag);
 extern int ip_options_echo(struct ip_options *dopt, struct sk_buff *skb);
 extern void ip_options_fragment(struct sk_buff *skb);
 extern int ip_options_compile(struct ip_options *opt, struct sk_buff *skb);
@@ -363,8 +363,8 @@ extern int	ip_ra_control(struct sock *sk, unsigned char on, void (*destructor)(s
 
 extern int      ip_recv_error(struct sock *sk, struct msghdr *msg, int len);
 extern void     ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err, 
-                              u16 port, u32 info, u8 *payload);
-extern void     ip_local_error(struct sock *sk, int err, u32 daddr, u16 dport,
+                              __be16 port, u32 info, u8 *payload);
+extern void     ip_local_error(struct sock *sk, int err, __be32 daddr, __be16 dport,
                                u32 info);
 
 /* sysctl helpers - any sysctl which holds a value that ends up being
diff --git a/include/net/ip_fib.h b/include/net/ip_fib.h
index fcc159a4ac17..82229146bac7 100644
--- a/include/net/ip_fib.h
+++ b/include/net/ip_fib.h
@@ -30,13 +30,13 @@ struct fib_config {
         u8                      fc_type;
         /* 1 byte unused */
         u32                     fc_table;
-        u32                     fc_dst;
-        u32                     fc_src;
-        u32                     fc_gw;
+        __be32                  fc_dst;
+        __be32                  fc_src;
+        __be32                  fc_gw;
         int                     fc_oif;
         u32                     fc_flags;
         u32                     fc_priority;
-        u32                     fc_prefsrc;
+        __be32                  fc_prefsrc;
         struct nlattr           *fc_mx;
         struct rtnexthop        *fc_mp;
         int                     fc_mx_len;
@@ -63,7 +63,7 @@ struct fib_nh {
         __u32                   nh_tclassid;
 #endif
         int                     nh_oif;
-        u32                     nh_gw;
+        __be32                  nh_gw;
 };
 
 /*
@@ -78,7 +78,7 @@ struct fib_info {
         int                     fib_dead;
         unsigned                fib_flags;
         int                     fib_protocol;
-        u32                     fib_prefsrc;
+        __be32                  fib_prefsrc;
         u32                     fib_priority;
         u32                     fib_metrics[RTAX_MAX];
 #define fib_mtu fib_metrics[RTAX_MTU-1]
@@ -107,8 +107,8 @@ struct fib_result {
         unsigned char   type;
         unsigned char   scope;
 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
-        __u32           network;
-        __u32           netmask;
+        __be32          network;
+        __be32          netmask;
 #endif
         struct fib_info *fi;
 #ifdef CONFIG_IP_MULTIPLE_TABLES
@@ -117,7 +117,7 @@ struct fib_result {
 };
 
 struct fib_result_nl {
-        u32             fl_addr;   /* To be looked up*/ 
+        __be32          fl_addr;   /* To be looked up*/
         u32             fl_fwmark; 
         unsigned char   fl_tos;
         unsigned char   fl_scope;
@@ -222,17 +222,17 @@ extern int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *ar
 extern int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg);
 extern int inet_rtm_getroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg);
 extern int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb);
-extern int fib_validate_source(u32 src, u32 dst, u8 tos, int oif,
-                               struct net_device *dev, u32 *spec_dst, u32 *itag);
+extern int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
+                               struct net_device *dev, __be32 *spec_dst, u32 *itag);
 extern void fib_select_multipath(const struct flowi *flp, struct fib_result *res);
 
 struct rtentry;
 
 /* Exported by fib_semantics.c */
-extern int ip_fib_check_default(u32 gw, struct net_device *dev);
-extern int fib_sync_down(u32 local, struct net_device *dev, int force);
+extern int ip_fib_check_default(__be32 gw, struct net_device *dev);
+extern int fib_sync_down(__be32 local, struct net_device *dev, int force);
 extern int fib_sync_up(struct net_device *dev);
-extern u32  __fib_res_prefsrc(struct fib_result *res);
+extern __be32  __fib_res_prefsrc(struct fib_result *res);
 
 /* Exported by fib_hash.c */
 extern struct fib_table *fib_hash_init(u32 id);
diff --git a/include/net/ip_mp_alg.h b/include/net/ip_mp_alg.h
index ac747b64734c..beffdd66ad74 100644
--- a/include/net/ip_mp_alg.h
+++ b/include/net/ip_mp_alg.h
@@ -17,7 +17,7 @@ struct ip_mp_alg_ops {
         void    (*mp_alg_select_route)(const struct flowi *flp,
                                        struct rtable *rth, struct rtable **rp);
         void    (*mp_alg_flush)(void);
-        void    (*mp_alg_set_nhinfo)(__u32 network, __u32 netmask,
+        void    (*mp_alg_set_nhinfo)(__be32 network, __be32 netmask,
                                      unsigned char prefixlen,
                                      const struct fib_nh *nh);
         void    (*mp_alg_remove)(struct rtable *rth);
@@ -59,7 +59,7 @@ static inline void multipath_flush(void)
 }
 
 static inline void multipath_set_nhinfo(struct rtable *rth,
-                                        __u32 network, __u32 netmask,
+                                        __be32 network, __be32 netmask,
                                         unsigned char prefixlen,
                                         const struct fib_nh *nh)
 {
diff --git a/include/net/ip_vs.h b/include/net/ip_vs.h
index 3b57b159b653..49c717e3b040 100644
--- a/include/net/ip_vs.h
+++ b/include/net/ip_vs.h
@@ -100,22 +100,22 @@
 struct ip_vs_service_user {
         /* virtual service addresses */
         u_int16_t               protocol;
-        u_int32_t               addr;           /* virtual ip address */
-        u_int16_t               port;
+        __be32                  addr;           /* virtual ip address */
+        __be16                  port;
         u_int32_t               fwmark;         /* firwall mark of service */
 
         /* virtual service options */
         char                    sched_name[IP_VS_SCHEDNAME_MAXLEN];
         unsigned                flags;          /* virtual service flags */
         unsigned                timeout;        /* persistent timeout in sec */
-        u_int32_t               netmask;        /* persistent netmask */
+        __be32                  netmask;        /* persistent netmask */
 };
 
 
 struct ip_vs_dest_user {
         /* destination server address */
-        u_int32_t               addr;
-        u_int16_t               port;
+        __be32                  addr;
+        __be16                  port;
 
         /* real server options */
         unsigned                conn_flags;     /* connection flags */
@@ -163,15 +163,15 @@ struct ip_vs_getinfo {
 struct ip_vs_service_entry {
         /* which service: user fills in these */
         u_int16_t               protocol;
-        u_int32_t               addr;           /* virtual address */
-        u_int16_t               port;
+        __be32                  addr;           /* virtual address */
+        __be16                  port;
         u_int32_t               fwmark;         /* firwall mark of service */
 
         /* service options */
         char                    sched_name[IP_VS_SCHEDNAME_MAXLEN];
         unsigned                flags;          /* virtual service flags */
         unsigned                timeout;        /* persistent timeout */
-        u_int32_t               netmask;        /* persistent netmask */
+        __be32                  netmask;        /* persistent netmask */
 
         /* number of real servers */
         unsigned int            num_dests;
@@ -182,8 +182,8 @@ struct ip_vs_service_entry {
 
 
 struct ip_vs_dest_entry {
-        u_int32_t               addr;           /* destination address */
-        u_int16_t               port;
+        __be32                  addr;           /* destination address */
+        __be16                  port;
         unsigned                conn_flags;     /* connection flags */
         int                     weight;         /* destination weight */
 
@@ -203,8 +203,8 @@ struct ip_vs_dest_entry {
 struct ip_vs_get_dests {
         /* which service: user fills in these */
         u_int16_t               protocol;
-        u_int32_t               addr;           /* virtual address */
-        u_int16_t               port;
+        __be32                  addr;           /* virtual address */
+        __be16                  port;
         u_int32_t               fwmark;         /* firwall mark of service */
 
         /* number of real servers */
@@ -502,12 +502,12 @@ struct ip_vs_conn {
         struct list_head        c_list;         /* hashed list heads */
 
         /* Protocol, addresses and port numbers */
-        __u32                   caddr;          /* client address */
-        __u32                   vaddr;          /* virtual address */
-        __u32                   daddr;          /* destination address */
-        __u16                   cport;
-        __u16                   vport;
-        __u16                   dport;
+        __be32                   caddr;          /* client address */
+        __be32                   vaddr;          /* virtual address */
+        __be32                   daddr;          /* destination address */
+        __be16                   cport;
+        __be16                   vport;
+        __be16                   dport;
         __u16                   protocol;       /* Which protocol (TCP/UDP) */
 
         /* counter and timer */
@@ -554,12 +554,12 @@ struct ip_vs_service {
         atomic_t                usecnt;   /* use counter */
 
         __u16                   protocol; /* which protocol (TCP/UDP) */
-        __u32                   addr;     /* IP address for virtual service */
-        __u16                   port;     /* port number for the service */
+        __be32                  addr;     /* IP address for virtual service */
+        __be16                  port;     /* port number for the service */
         __u32                   fwmark;   /* firewall mark of the service */
         unsigned                flags;    /* service status flags */
         unsigned                timeout;  /* persistent timeout in ticks */
-        __u32                   netmask;  /* grouping granularity */
+        __be32                  netmask;  /* grouping granularity */
 
         struct list_head        destinations;  /* real server d-linked list */
         __u32                   num_dests;     /* number of servers */
@@ -581,8 +581,8 @@ struct ip_vs_dest {
         struct list_head        n_list;   /* for the dests in the service */
         struct list_head        d_list;   /* for table with all the dests */
 
-        __u32                   addr;           /* IP address of the server */
-        __u16                   port;           /* port number of the server */
+        __be32                  addr;           /* IP address of the server */
+        __be16                  port;           /* port number of the server */
         volatile unsigned       flags;          /* dest status flags */
         atomic_t                conn_flags;     /* flags to copy to conn */
         atomic_t                weight;         /* server weight */
@@ -605,8 +605,8 @@ struct ip_vs_dest {
         /* for virtual service */
         struct ip_vs_service    *svc;           /* service it belongs to */
         __u16                   protocol;       /* which protocol (TCP/UDP) */
-        __u32                   vaddr;          /* virtual IP address */
-        __u16                   vport;          /* virtual port number */
+        __be32                  vaddr;          /* virtual IP address */
+        __be16                  vport;          /* virtual port number */
         __u32                   vfwmark;        /* firewall mark of service */
 };
 
@@ -648,7 +648,7 @@ struct ip_vs_app
         /* members for application incarnations */
         struct list_head        p_list;         /* member in proto app list */
         struct ip_vs_app        *app;           /* its real application */
-        __u16                   port;           /* port number in net order */
+        __be16                  port;           /* port number in net order */
         atomic_t                usecnt;         /* usage counter */
 
         /* output hook: return false if can't linearize. diff set for TCP.  */
@@ -740,11 +740,11 @@ enum {
 };
 
 extern struct ip_vs_conn *ip_vs_conn_in_get
-(int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port);
+(int protocol, __be32 s_addr, __be16 s_port, __be32 d_addr, __be16 d_port);
 extern struct ip_vs_conn *ip_vs_ct_in_get
-(int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port);
+(int protocol, __be32 s_addr, __be16 s_port, __be32 d_addr, __be16 d_port);
 extern struct ip_vs_conn *ip_vs_conn_out_get
-(int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port);
+(int protocol, __be32 s_addr, __be16 s_port, __be32 d_addr, __be16 d_port);
 
 /* put back the conn without restarting its timer */
 static inline void __ip_vs_conn_put(struct ip_vs_conn *cp)
@@ -752,11 +752,11 @@ static inline void __ip_vs_conn_put(struct ip_vs_conn *cp)
         atomic_dec(&cp->refcnt);
 }
 extern void ip_vs_conn_put(struct ip_vs_conn *cp);
-extern void ip_vs_conn_fill_cport(struct ip_vs_conn *cp, __u16 cport);
+extern void ip_vs_conn_fill_cport(struct ip_vs_conn *cp, __be16 cport);
 
 extern struct ip_vs_conn *
-ip_vs_conn_new(int proto, __u32 caddr, __u16 cport, __u32 vaddr, __u16 vport,
-               __u32 daddr, __u16 dport, unsigned flags,
+ip_vs_conn_new(int proto, __be32 caddr, __be16 cport, __be32 vaddr, __be16 vport,
+               __be32 daddr, __be16 dport, unsigned flags,
                struct ip_vs_dest *dest);
 extern void ip_vs_conn_expire_now(struct ip_vs_conn *cp);
 
@@ -887,7 +887,7 @@ extern int sysctl_ip_vs_nat_icmp_send;
 extern struct ip_vs_stats ip_vs_stats;
 
 extern struct ip_vs_service *
-ip_vs_service_get(__u32 fwmark, __u16 protocol, __u32 vaddr, __u16 vport);
+ip_vs_service_get(__u32 fwmark, __u16 protocol, __be32 vaddr, __be16 vport);
 
 static inline void ip_vs_service_put(struct ip_vs_service *svc)
 {
@@ -895,7 +895,7 @@ static inline void ip_vs_service_put(struct ip_vs_service *svc)
 }
 
 extern struct ip_vs_dest *
-ip_vs_lookup_real_service(__u16 protocol, __u32 daddr, __u16 dport);
+ip_vs_lookup_real_service(__u16 protocol, __be32 daddr, __be16 dport);
 extern int ip_vs_use_count_inc(void);
 extern void ip_vs_use_count_dec(void);
 extern int ip_vs_control_init(void);
diff --git a/include/net/ipv6.h b/include/net/ipv6.h
index 72bf47b2a4e0..8223c4410b4b 100644
--- a/include/net/ipv6.h
+++ b/include/net/ipv6.h
@@ -318,8 +318,8 @@ static inline void ipv6_addr_prefix(struct in6_addr *pfx,
 
 #ifndef __HAVE_ARCH_ADDR_SET
 static inline void ipv6_addr_set(struct in6_addr *addr, 
-                                     __u32 w1, __u32 w2,
-                                     __u32 w3, __u32 w4)
+                                     __be32 w1, __be32 w2,
+                                     __be32 w3, __be32 w4)
 {
         addr->s6_addr32[0] = w1;
         addr->s6_addr32[1] = w2;
@@ -337,7 +337,7 @@ static inline int ipv6_addr_equal(const struct in6_addr *a1,
                 a1->s6_addr32[3] == a2->s6_addr32[3]);
 }
 
-static inline int __ipv6_prefix_equal(const u32 *a1, const u32 *a2,
+static inline int __ipv6_prefix_equal(const __be32 *a1, const __be32 *a2,
                                       unsigned int prefixlen)
 {
         unsigned pdw, pbi;
diff --git a/include/net/irda/irlan_common.h b/include/net/irda/irlan_common.h
index 1c73bdbc3eb3..9592c374b41d 100644
--- a/include/net/irda/irlan_common.h
+++ b/include/net/irda/irlan_common.h
@@ -98,7 +98,15 @@
 #define IRLAN_SHORT  1
 #define IRLAN_ARRAY  2
 
-#define IRLAN_MAX_HEADER (TTP_HEADER+LMP_HEADER+LAP_MAX_HEADER)
+/* IrLAN sits on top if IrTTP */
+#define IRLAN_MAX_HEADER (TTP_HEADER+LMP_HEADER)
+/* 1 byte for the command code and 1 byte for the parameter count */
+#define IRLAN_CMD_HEADER 2
+
+#define IRLAN_STRING_PARAMETER_LEN(name, value) (1 + strlen((name)) + 2 \
+                                                + strlen ((value)))
+#define IRLAN_BYTE_PARAMETER_LEN(name)          (1 + strlen((name)) + 2 + 1)
+#define IRLAN_SHORT_PARAMETER_LEN(name)         (1 + strlen((name)) + 2 + 2)
 
 /*
  *  IrLAN client
diff --git a/include/net/irda/irlap_frame.h b/include/net/irda/irlap_frame.h
index 3452ae257c84..9dd54a5002b2 100644
--- a/include/net/irda/irlap_frame.h
+++ b/include/net/irda/irlap_frame.h
@@ -74,6 +74,19 @@ struct discovery_t;
 
 #define PF_BIT    0x10 /* Poll/final bit */
 
+/* Some IrLAP field lengths */
+/*
+ * Only baud rate triplet is 4 bytes (PV can be 2 bytes).
+ * All others params (7) are 3 bytes, so that's 7*3 + 1*4 bytes.
+ */
+#define IRLAP_NEGOCIATION_PARAMS_LEN 25
+#define IRLAP_DISCOVERY_INFO_LEN     32
+
+struct disc_frame {
+        __u8 caddr;          /* Connection address */
+        __u8 control;
+} IRDA_PACK;
+
 struct xid_frame {
         __u8  caddr; /* Connection address */
         __u8  control;
@@ -95,11 +108,25 @@ struct test_frame {
 struct ua_frame {
         __u8 caddr;
         __u8 control;
-
         __u32 saddr; /* Source device address */
         __u32 daddr; /* Dest device address */
 } IRDA_PACK;
-        
+
+struct dm_frame {
+        __u8 caddr;          /* Connection address */
+        __u8 control;
+} IRDA_PACK;
+
+struct rd_frame {
+        __u8 caddr;          /* Connection address */
+        __u8 control;
+} IRDA_PACK;
+
+struct rr_frame {
+        __u8 caddr;          /* Connection address */
+        __u8 control;
+} IRDA_PACK;
+
 struct i_frame {
         __u8 caddr;
         __u8 control;
diff --git a/include/net/irda/irlmp.h b/include/net/irda/irlmp.h
index 11ecfa58a648..e212b9bc2503 100644
--- a/include/net/irda/irlmp.h
+++ b/include/net/irda/irlmp.h
@@ -48,7 +48,7 @@
 #define DEV_ADDR_ANY  0xffffffff
 
 #define LMP_HEADER          2    /* Dest LSAP + Source LSAP */
-#define LMP_CONTROL_HEADER  4
+#define LMP_CONTROL_HEADER  4    /* LMP_HEADER + opcode + parameter */
 #define LMP_PID_HEADER      1    /* Used by Ultra */
 #define LMP_MAX_HEADER      (LMP_CONTROL_HEADER+LAP_MAX_HEADER)
 
diff --git a/include/net/netlabel.h b/include/net/netlabel.h
index 6692430063fd..190bfdbbdba6 100644
--- a/include/net/netlabel.h
+++ b/include/net/netlabel.h
@@ -96,7 +96,7 @@
 struct netlbl_dom_map;
 
 /* Domain mapping operations */
-int netlbl_domhsh_remove(const char *domain);
+int netlbl_domhsh_remove(const char *domain, u32 audit_secid);
 
 /* LSM security attributes */
 struct netlbl_lsm_cache {
diff --git a/include/net/netlink.h b/include/net/netlink.h
index 4ab68a7a636a..ce5cba19c393 100644
--- a/include/net/netlink.h
+++ b/include/net/netlink.h
@@ -831,6 +831,9 @@ static inline int nla_put_msecs(struct sk_buff *skb, int attrtype,
 #define NLA_PUT_U32(skb, attrtype, value) \
         NLA_PUT_TYPE(skb, u32, attrtype, value)
 
+#define NLA_PUT_BE32(skb, attrtype, value) \
+        NLA_PUT_TYPE(skb, __be32, attrtype, value)
+
 #define NLA_PUT_U64(skb, attrtype, value) \
         NLA_PUT_TYPE(skb, u64, attrtype, value)
 
@@ -853,6 +856,15 @@ static inline u32 nla_get_u32(struct nlattr *nla)
 }
 
 /**
+ * nla_get_be32 - return payload of __be32 attribute
+ * @nla: __be32 netlink attribute
+ */
+static inline __be32 nla_get_be32(struct nlattr *nla)
+{
+        return *(__be32 *) nla_data(nla);
+}
+
+/**
  * nla_get_u16 - return payload of u16 attribute
  * @nla: u16 netlink attribute
  */
diff --git a/include/net/route.h b/include/net/route.h
index 7f93ac0e0899..486e37aff06c 100644
--- a/include/net/route.h
+++ b/include/net/route.h
@@ -62,18 +62,18 @@ struct rtable
         __u16                   rt_type;
         __u16                   rt_multipath_alg;
 
-        __u32                   rt_dst; /* Path destination     */
-        __u32                   rt_src; /* Path source          */
+        __be32                  rt_dst; /* Path destination     */
+        __be32                  rt_src; /* Path source          */
         int                     rt_iif;
 
         /* Info on neighbour */
-        __u32                   rt_gateway;
+        __be32                  rt_gateway;
 
         /* Cache lookup keys */
         struct flowi            fl;
 
         /* Miscellaneous cached information */
-        __u32                   rt_spec_dst; /* RFC1122 specific destination */
+        __be32                  rt_spec_dst; /* RFC1122 specific destination */
         struct inet_peer        *peer; /* long-living peer info */
 };
 
@@ -109,18 +109,18 @@ extern struct ip_rt_acct *ip_rt_acct;
 
 struct in_device;
 extern int              ip_rt_init(void);
-extern void             ip_rt_redirect(u32 old_gw, u32 dst, u32 new_gw,
-                                       u32 src, struct net_device *dev);
+extern void             ip_rt_redirect(__be32 old_gw, __be32 dst, __be32 new_gw,
+                                       __be32 src, struct net_device *dev);
 extern void             ip_rt_advice(struct rtable **rp, int advice);
 extern void             rt_cache_flush(int how);
 extern int              __ip_route_output_key(struct rtable **, const struct flowi *flp);
 extern int              ip_route_output_key(struct rtable **, struct flowi *flp);
 extern int              ip_route_output_flow(struct rtable **rp, struct flowi *flp, struct sock *sk, int flags);
-extern int              ip_route_input(struct sk_buff*, u32 dst, u32 src, u8 tos, struct net_device *devin);
+extern int              ip_route_input(struct sk_buff*, __be32 dst, __be32 src, u8 tos, struct net_device *devin);
 extern unsigned short   ip_rt_frag_needed(struct iphdr *iph, unsigned short new_mtu);
 extern void             ip_rt_send_redirect(struct sk_buff *skb);
 
-extern unsigned         inet_addr_type(u32 addr);
+extern unsigned         inet_addr_type(__be32 addr);
 extern void             ip_rt_multicast_event(struct in_device *);
 extern int              ip_rt_ioctl(unsigned int cmd, void __user *arg);
 extern void             ip_rt_get_source(u8 *src, struct rtable *rt);
@@ -144,9 +144,9 @@ static inline char rt_tos2priority(u8 tos)
         return ip_tos2prio[IPTOS_TOS(tos)>>1];
 }
 
-static inline int ip_route_connect(struct rtable **rp, u32 dst,
-                                   u32 src, u32 tos, int oif, u8 protocol,
-                                   u16 sport, u16 dport, struct sock *sk)
+static inline int ip_route_connect(struct rtable **rp, __be32 dst,
+                                   __be32 src, u32 tos, int oif, u8 protocol,
+                                   __be16 sport, __be16 dport, struct sock *sk)
 {
         struct flowi fl = { .oif = oif,
                             .nl_u = { .ip4_u = { .daddr = dst,
@@ -172,7 +172,7 @@ static inline int ip_route_connect(struct rtable **rp, u32 dst,
 }
 
 static inline int ip_route_newports(struct rtable **rp, u8 protocol,
-                                    u16 sport, u16 dport, struct sock *sk)
+                                    __be16 sport, __be16 dport, struct sock *sk)
 {
         if (sport != (*rp)->fl.fl_ip_sport ||
             dport != (*rp)->fl.fl_ip_dport) {
diff --git a/include/net/xfrm.h b/include/net/xfrm.h
index 11e0b1d6bd47..1e2a4ddec96e 100644
--- a/include/net/xfrm.h
+++ b/include/net/xfrm.h
@@ -437,8 +437,8 @@ static inline void xfrm_state_hold(struct xfrm_state *x)
 
 static __inline__ int addr_match(void *token1, void *token2, int prefixlen)
 {
-        __u32 *a1 = token1;
-        __u32 *a2 = token2;
+        __be32 *a1 = token1;
+        __be32 *a2 = token2;
         int pdw;
         int pbi;
 
@@ -450,7 +450,7 @@ static __inline__ int addr_match(void *token1, void *token2, int prefixlen)
                         return 0;
 
         if (pbi) {
-                __u32 mask;
+                __be32 mask;
 
                 mask = htonl((0xffffffff) << (32 - pbi));
 
@@ -462,9 +462,9 @@ static __inline__ int addr_match(void *token1, void *token2, int prefixlen)
 }
 
 static __inline__
-u16 xfrm_flowi_sport(struct flowi *fl)
+__be16 xfrm_flowi_sport(struct flowi *fl)
 {
-        u16 port;
+        __be16 port;
         switch(fl->proto) {
         case IPPROTO_TCP:
         case IPPROTO_UDP:
@@ -487,9 +487,9 @@ u16 xfrm_flowi_sport(struct flowi *fl)
 }
 
 static __inline__
-u16 xfrm_flowi_dport(struct flowi *fl)
+__be16 xfrm_flowi_dport(struct flowi *fl)
 {
-        u16 port;
+        __be16 port;
         switch(fl->proto) {
         case IPPROTO_TCP:
         case IPPROTO_UDP:
@@ -912,7 +912,7 @@ extern int xfrm_state_check_expire(struct xfrm_state *x);
 extern void xfrm_state_insert(struct xfrm_state *x);
 extern int xfrm_state_add(struct xfrm_state *x);
 extern int xfrm_state_update(struct xfrm_state *x);
-extern struct xfrm_state *xfrm_state_lookup(xfrm_address_t *daddr, u32 spi, u8 proto, unsigned short family);
+extern struct xfrm_state *xfrm_state_lookup(xfrm_address_t *daddr, __be32 spi, u8 proto, unsigned short family);
 extern struct xfrm_state *xfrm_state_lookup_byaddr(xfrm_address_t *daddr, xfrm_address_t *saddr, u8 proto, unsigned short family);
 #ifdef CONFIG_XFRM_SUB_POLICY
 extern int xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src,
@@ -935,8 +935,8 @@ static inline int xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **s
 extern struct xfrm_state *xfrm_find_acq_byseq(u32 seq);
 extern int xfrm_state_delete(struct xfrm_state *x);
 extern void xfrm_state_flush(u8 proto);
-extern int xfrm_replay_check(struct xfrm_state *x, u32 seq);
-extern void xfrm_replay_advance(struct xfrm_state *x, u32 seq);
+extern int xfrm_replay_check(struct xfrm_state *x, __be32 seq);
+extern void xfrm_replay_advance(struct xfrm_state *x, __be32 seq);
 extern void xfrm_replay_notify(struct xfrm_state *x, int event);
 extern int xfrm_state_check(struct xfrm_state *x, struct sk_buff *skb);
 extern int xfrm_state_mtu(struct xfrm_state *x, int mtu);
@@ -945,7 +945,7 @@ extern int xfrm4_rcv(struct sk_buff *skb);
 extern int xfrm4_output(struct sk_buff *skb);
 extern int xfrm4_tunnel_register(struct xfrm_tunnel *handler);
 extern int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler);
-extern int xfrm6_rcv_spi(struct sk_buff *skb, u32 spi);
+extern int xfrm6_rcv_spi(struct sk_buff *skb, __be32 spi);
 extern int xfrm6_rcv(struct sk_buff **pskb);
 extern int xfrm6_input_addr(struct sk_buff *skb, xfrm_address_t *daddr,
                             xfrm_address_t *saddr, u8 proto);
@@ -989,7 +989,7 @@ struct xfrm_policy *xfrm_policy_bysel_ctx(u8 type, int dir,
 struct xfrm_policy *xfrm_policy_byid(u8, int dir, u32 id, int delete);
 void xfrm_policy_flush(u8 type);
 u32 xfrm_get_acqseq(void);
-void xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi);
+void xfrm_alloc_spi(struct xfrm_state *x, __be32 minspi, __be32 maxspi);
 struct xfrm_state * xfrm_find_acq(u8 mode, u32 reqid, u8 proto, 
                                   xfrm_address_t *daddr, xfrm_address_t *saddr, 
                                   int create, unsigned short family);
@@ -1004,7 +1004,7 @@ extern void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 pi
 extern int km_report(u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
 
 extern void xfrm_input_init(void);
-extern int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, u32 *spi, u32 *seq);
+extern int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq);
 
 extern void xfrm_probe_algs(void);
 extern int xfrm_count_auth_supported(void);
diff --git a/net/802/tr.c b/net/802/tr.c
index d7d8f40c4fed..829deb41ce81 100644
--- a/net/802/tr.c
+++ b/net/802/tr.c
@@ -164,7 +164,7 @@ static int tr_rebuild_header(struct sk_buff *skb)
          */
          
         if(trllc->ethertype != htons(ETH_P_IP)) {
-                printk("tr_rebuild_header: Don't know how to resolve type %04X addresses ?\n",(unsigned int)htons(trllc->ethertype));
+                printk("tr_rebuild_header: Don't know how to resolve type %04X addresses ?\n", ntohs(trllc->ethertype));
                 return 0;
         }
 
@@ -186,7 +186,7 @@ static int tr_rebuild_header(struct sk_buff *skb)
  *      it via SNAP.
  */
  
-unsigned short tr_type_trans(struct sk_buff *skb, struct net_device *dev) 
+__be16 tr_type_trans(struct sk_buff *skb, struct net_device *dev)
 {
 
         struct trh_hdr *trh=(struct trh_hdr *)skb->data;
@@ -229,15 +229,15 @@ unsigned short tr_type_trans(struct sk_buff *skb, struct net_device *dev)
          */
 
         if (trllc->dsap == EXTENDED_SAP &&
-            (trllc->ethertype == ntohs(ETH_P_IP) ||
-             trllc->ethertype == ntohs(ETH_P_IPV6) ||
-             trllc->ethertype == ntohs(ETH_P_ARP)))
+            (trllc->ethertype == htons(ETH_P_IP) ||
+             trllc->ethertype == htons(ETH_P_IPV6) ||
+             trllc->ethertype == htons(ETH_P_ARP)))
         {
                 skb_pull(skb, sizeof(struct trllc));
                 return trllc->ethertype;
         }
 
-        return ntohs(ETH_P_TR_802_2);
+        return htons(ETH_P_TR_802_2);
 }
 
 /*
diff --git a/net/Kconfig b/net/Kconfig
index 6528a935622c..a81aca43932f 100644
--- a/net/Kconfig
+++ b/net/Kconfig
@@ -231,7 +231,7 @@ config NET_TCPPROBE
         TCP congestion avoidance modules. If you don't understand
         what was just said, you don't need it: say N.
 
-        Documentation on how to use the packet generator can be found
+        Documentation on how to use TCP connection probing can be found
         at http://linux-net.osdl.org/index.php/TcpProbe
 
         To compile this code as a module, choose M here: the
diff --git a/net/appletalk/ddp.c b/net/appletalk/ddp.c
index 96dc6bb52d14..708e2e0371af 100644
--- a/net/appletalk/ddp.c
+++ b/net/appletalk/ddp.c
@@ -1002,7 +1002,7 @@ static unsigned long atalk_sum_skb(const struct sk_buff *skb, int offset,
         return sum;
 }
 
-static unsigned short atalk_checksum(const struct sk_buff *skb, int len)
+static __be16 atalk_checksum(const struct sk_buff *skb, int len)
 {
         unsigned long sum;
 
@@ -1010,7 +1010,7 @@ static unsigned short atalk_checksum(const struct sk_buff *skb, int len)
         sum = atalk_sum_skb(skb, 4, len-4, 0);
 
         /* Use 0xFFFF for 0. 0 itself means none */
-        return sum ? htons((unsigned short)sum) : 0xFFFF;
+        return sum ? htons((unsigned short)sum) : htons(0xFFFF);
 }
 
 static struct proto ddp_proto = {
@@ -1289,7 +1289,7 @@ static int handle_ip_over_ddp(struct sk_buff *skb)
 #endif
 
 static void atalk_route_packet(struct sk_buff *skb, struct net_device *dev,
-                               struct ddpehdr *ddp, struct ddpebits *ddphv,
+                               struct ddpehdr *ddp, __u16 len_hops,
                                int origlen)
 {
         struct atalk_route *rt;
@@ -1317,10 +1317,12 @@ static void atalk_route_packet(struct sk_buff *skb, struct net_device *dev,
 
         /* Route the packet */
         rt = atrtr_find(&ta);
-        if (!rt || ddphv->deh_hops == DDP_MAXHOPS)
+        /* increment hops count */
+        len_hops += 1 << 10;
+        if (!rt || !(len_hops & (15 << 10)))
                 goto free_it;
+
         /* FIXME: use skb->cb to be able to use shared skbs */
-        ddphv->deh_hops++;
 
         /*
          * Route goes through another gateway, so set the target to the
@@ -1335,11 +1337,10 @@ static void atalk_route_packet(struct sk_buff *skb, struct net_device *dev,
         /* Fix up skb->len field */
         skb_trim(skb, min_t(unsigned int, origlen,
                             (rt->dev->hard_header_len +
-                             ddp_dl->header_length + ddphv->deh_len)));
+                             ddp_dl->header_length + (len_hops & 1023))));
 
-        /* Mend the byte order */
         /* FIXME: use skb->cb to be able to use shared skbs */
-        *((__u16 *)ddp) = ntohs(*((__u16 *)ddphv));
+        ddp->deh_len_hops = htons(len_hops);
 
         /*
          * Send the buffer onwards
@@ -1394,7 +1395,7 @@ static int atalk_rcv(struct sk_buff *skb, struct net_device *dev,
         struct atalk_iface *atif;
         struct sockaddr_at tosat;
         int origlen;
-        struct ddpebits ddphv;
+        __u16 len_hops;
 
         /* Don't mangle buffer if shared */
         if (!(skb = skb_share_check(skb, GFP_ATOMIC))) 
@@ -1406,16 +1407,11 @@ static int atalk_rcv(struct sk_buff *skb, struct net_device *dev,
 
         ddp = ddp_hdr(skb);
 
-        /*
-         *      Fix up the length field [Ok this is horrible but otherwise
-         *      I end up with unions of bit fields and messy bit field order
-         *      compiler/endian dependencies..]
-         */
-        *((__u16 *)&ddphv) = ntohs(*((__u16 *)ddp));
+        len_hops = ntohs(ddp->deh_len_hops);
 
         /* Trim buffer in case of stray trailing data */
         origlen = skb->len;
-        skb_trim(skb, min_t(unsigned int, skb->len, ddphv.deh_len));
+        skb_trim(skb, min_t(unsigned int, skb->len, len_hops & 1023));
 
         /*
          * Size check to see if ddp->deh_len was crap
@@ -1430,7 +1426,7 @@ static int atalk_rcv(struct sk_buff *skb, struct net_device *dev,
          * valid for net byte orders all over the networking code...
          */
         if (ddp->deh_sum &&
-            atalk_checksum(skb, ddphv.deh_len) != ddp->deh_sum)
+            atalk_checksum(skb, len_hops & 1023) != ddp->deh_sum)
                 /* Not a valid AppleTalk frame - dustbin time */
                 goto freeit;
 
@@ -1444,7 +1440,7 @@ static int atalk_rcv(struct sk_buff *skb, struct net_device *dev,
                 /* Not ours, so we route the packet via the correct
                  * AppleTalk iface
                  */
-                atalk_route_packet(skb, dev, ddp, &ddphv, origlen);
+                atalk_route_packet(skb, dev, ddp, len_hops, origlen);
                 goto out;
         }
 
@@ -1489,7 +1485,7 @@ static int ltalk_rcv(struct sk_buff *skb, struct net_device *dev,
                 /* Find our address */
                 struct atalk_addr *ap = atalk_find_dev_addr(dev);
 
-                if (!ap || skb->len < sizeof(struct ddpshdr))
+                if (!ap || skb->len < sizeof(__be16) || skb->len > 1023)
                         goto freeit;
 
                 /* Don't mangle buffer if shared */
@@ -1519,11 +1515,8 @@ static int ltalk_rcv(struct sk_buff *skb, struct net_device *dev,
                 /*
                  * Not sure about this bit...
                  */
-                ddp->deh_len   = skb->len;
-                ddp->deh_hops  = DDP_MAXHOPS;   /* Non routable, so force a drop
-                                                   if we slip up later */
-                /* Mend the byte order */
-                *((__u16 *)ddp) = htons(*((__u16 *)ddp));
+                /* Non routable, so force a drop if we slip up later */
+                ddp->deh_len_hops = htons(skb->len + (DDP_MAXHOPS << 10));
         }
         skb->h.raw = skb->data;
 
@@ -1622,16 +1615,7 @@ static int atalk_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr
         SOCK_DEBUG(sk, "SK %p: Begin build.\n", sk);
 
         ddp = (struct ddpehdr *)skb_put(skb, sizeof(struct ddpehdr));
-        ddp->deh_pad  = 0;
-        ddp->deh_hops = 0;
-        ddp->deh_len  = len + sizeof(*ddp);
-        /*
-         * Fix up the length field [Ok this is horrible but otherwise
-         * I end up with unions of bit fields and messy bit field order
-         * compiler/endian dependencies..
-         */
-        *((__u16 *)ddp) = ntohs(*((__u16 *)ddp));
-
+        ddp->deh_len_hops  = htons(len + sizeof(*ddp));
         ddp->deh_dnet  = usat->sat_addr.s_net;
         ddp->deh_snet  = at->src_net;
         ddp->deh_dnode = usat->sat_addr.s_node;
@@ -1712,8 +1696,8 @@ static int atalk_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr
         struct sockaddr_at *sat = (struct sockaddr_at *)msg->msg_name;
         struct ddpehdr *ddp;
         int copied = 0;
+        int offset = 0;
         int err = 0;
-        struct ddpebits ddphv;
         struct sk_buff *skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
                                                 flags & MSG_DONTWAIT, &err);
         if (!skb)
@@ -1721,25 +1705,18 @@ static int atalk_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr
 
         /* FIXME: use skb->cb to be able to use shared skbs */
         ddp = ddp_hdr(skb);
-        *((__u16 *)&ddphv) = ntohs(*((__u16 *)ddp));
+        copied = ntohs(ddp->deh_len_hops) & 1023;
 
-        if (sk->sk_type == SOCK_RAW) {
-                copied = ddphv.deh_len;
-                if (copied > size) {
-                        copied = size;
-                        msg->msg_flags |= MSG_TRUNC;
-                }
+        if (sk->sk_type != SOCK_RAW) {
+                offset = sizeof(*ddp);
+                copied -= offset;
+        }
 
-                err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
-        } else {
-                copied = ddphv.deh_len - sizeof(*ddp);
-                if (copied > size) {
-                        copied = size;
-                        msg->msg_flags |= MSG_TRUNC;
-                }
-                err = skb_copy_datagram_iovec(skb, sizeof(*ddp),
-                                              msg->msg_iov, copied);
+        if (copied > size) {
+                copied = size;
+                msg->msg_flags |= MSG_TRUNC;
         }
+        err = skb_copy_datagram_iovec(skb, offset, msg->msg_iov, copied);
 
         if (!err) {
                 if (sat) {
diff --git a/net/atm/mpc.c b/net/atm/mpc.c
index b87c2a88bdce..0d2b994af511 100644
--- a/net/atm/mpc.c
+++ b/net/atm/mpc.c
@@ -560,7 +560,6 @@ static int atm_mpoa_vcc_attach(struct atm_vcc *vcc, void __user *arg)
         struct atmmpc_ioc ioc_data;
         in_cache_entry *in_entry;
         uint32_t  ipaddr;
-        unsigned char *ip;
 
         bytes_left = copy_from_user(&ioc_data, arg, sizeof(struct atmmpc_ioc));
         if (bytes_left != 0) {
@@ -583,9 +582,8 @@ static int atm_mpoa_vcc_attach(struct atm_vcc *vcc, void __user *arg)
                         if (in_entry != NULL) mpc->in_ops->put(in_entry);
                         return -EINVAL;
                 }
-                ip = (unsigned char*)&in_entry->ctrl_info.in_dst_ip;
                 printk("mpoa: (%s) mpc_vcc_attach: attaching ingress SVC, entry = %u.%u.%u.%u\n",
-                       mpc->dev->name, ip[0], ip[1], ip[2], ip[3]);
+                       mpc->dev->name, NIPQUAD(in_entry->ctrl_info.in_dst_ip));
                 in_entry->shortcut = vcc;
                 mpc->in_ops->put(in_entry);
         } else {
@@ -616,10 +614,8 @@ static void mpc_vcc_close(struct atm_vcc *vcc, struct net_device *dev)
         dprintk("mpoa: (%s) mpc_vcc_close:\n", dev->name);
         in_entry = mpc->in_ops->get_by_vcc(vcc, mpc);
         if (in_entry) {
-                unsigned char *ip __attribute__ ((unused)) =
-                    (unsigned char *)&in_entry->ctrl_info.in_dst_ip;
                 dprintk("mpoa: (%s) mpc_vcc_close: ingress SVC closed ip = %u.%u.%u.%u\n",
-                       mpc->dev->name, ip[0], ip[1], ip[2], ip[3]);
+                       mpc->dev->name, NIPQUAD(in_entry->ctrl_info.in_dst_ip));
                 in_entry->shortcut = NULL;
                 mpc->in_ops->put(in_entry);
         }
@@ -1154,18 +1150,17 @@ static void ingress_purge_rcvd(struct k_message *msg, struct mpoa_client *mpc)
 {
         uint32_t dst_ip = msg->content.in_info.in_dst_ip;
         uint32_t mask = msg->ip_mask;
-        unsigned char *ip = (unsigned char *)&dst_ip;
         in_cache_entry *entry = mpc->in_ops->get_with_mask(dst_ip, mpc, mask);
 
         if(entry == NULL){
                 printk("mpoa: (%s) ingress_purge_rcvd: purge for a non-existing entry, ", mpc->dev->name);
-                printk("ip = %u.%u.%u.%u\n", ip[0], ip[1], ip[2], ip[3]);
+                printk("ip = %u.%u.%u.%u\n", NIPQUAD(dst_ip));
                 return;
         }
 
         do {
                 dprintk("mpoa: (%s) ingress_purge_rcvd: removing an ingress entry, ip = %u.%u.%u.%u\n" ,
-                        mpc->dev->name, ip[0], ip[1], ip[2], ip[3]);
+                        mpc->dev->name, NIPQUAD(dst_ip));
                 write_lock_bh(&mpc->ingress_lock);
                 mpc->in_ops->remove_entry(entry, mpc);
                 write_unlock_bh(&mpc->ingress_lock);
diff --git a/net/atm/mpoa_caches.c b/net/atm/mpoa_caches.c
index 781ed1b9329d..fbf13cdcf46e 100644
--- a/net/atm/mpoa_caches.c
+++ b/net/atm/mpoa_caches.c
@@ -87,7 +87,6 @@ static in_cache_entry *in_cache_get_by_vcc(struct atm_vcc *vcc,
 static in_cache_entry *in_cache_add_entry(uint32_t dst_ip,
                                           struct mpoa_client *client)
 {
-        unsigned char *ip __attribute__ ((unused)) = (unsigned char *)&dst_ip;
         in_cache_entry* entry = kmalloc(sizeof(in_cache_entry), GFP_KERNEL);
 
         if (entry == NULL) {
@@ -95,7 +94,7 @@ static in_cache_entry *in_cache_add_entry(uint32_t dst_ip,
                 return NULL;
         }
 
-        dprintk("mpoa: mpoa_caches.c: adding an ingress entry, ip = %u.%u.%u.%u\n", ip[0], ip[1], ip[2], ip[3]);
+        dprintk("mpoa: mpoa_caches.c: adding an ingress entry, ip = %u.%u.%u.%u\n", NIPQUAD(dst_ip));
         memset(entry,0,sizeof(in_cache_entry));
 
         atomic_set(&entry->use, 1);
@@ -152,10 +151,7 @@ static int cache_hit(in_cache_entry *entry, struct mpoa_client *mpc)
 
         if( entry->count > mpc->parameters.mpc_p1 &&
             entry->entry_state == INGRESS_INVALID){
-                unsigned char *ip __attribute__ ((unused)) =
-                    (unsigned char *)&entry->ctrl_info.in_dst_ip;
-
-                dprintk("mpoa: (%s) mpoa_caches.c: threshold exceeded for ip %u.%u.%u.%u, sending MPOA res req\n", mpc->dev->name, ip[0], ip[1], ip[2], ip[3]);
+                dprintk("mpoa: (%s) mpoa_caches.c: threshold exceeded for ip %u.%u.%u.%u, sending MPOA res req\n", mpc->dev->name, NIPQUAD(entry->ctrl_info.in_dst_ip));
                 entry->entry_state = INGRESS_RESOLVING;
                 msg.type =  SND_MPOA_RES_RQST;
                 memcpy(msg.MPS_ctrl, mpc->mps_ctrl_addr, ATM_ESA_LEN );
@@ -187,11 +183,9 @@ static void in_cache_remove_entry(in_cache_entry *entry,
 {
         struct atm_vcc *vcc;
         struct k_message msg;
-        unsigned char *ip;
 
         vcc = entry->shortcut;
-        ip = (unsigned char *)&entry->ctrl_info.in_dst_ip;
-        dprintk("mpoa: mpoa_caches.c: removing an ingress entry, ip = %u.%u.%u.%u\n",ip[0], ip[1], ip[2], ip[3]);
+        dprintk("mpoa: mpoa_caches.c: removing an ingress entry, ip = %u.%u.%u.%u\n",NIPQUAD(entry->ctrl_info.in_dst_ip));
 
         if (entry->prev != NULL)
                 entry->prev->next = entry->next;
diff --git a/net/bluetooth/af_bluetooth.c b/net/bluetooth/af_bluetooth.c
index 788ea7a2b744..305a099b7477 100644
--- a/net/bluetooth/af_bluetooth.c
+++ b/net/bluetooth/af_bluetooth.c
@@ -276,7 +276,7 @@ int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
                 set_current_state(TASK_INTERRUPTIBLE);
 
                 if (!timeo) {
-                        err = -EAGAIN;
+                        err = -EINPROGRESS;
                         break;
                 }
 
diff --git a/net/bluetooth/bnep/core.c b/net/bluetooth/bnep/core.c
index e620061fb50f..2312d050eeed 100644
--- a/net/bluetooth/bnep/core.c
+++ b/net/bluetooth/bnep/core.c
@@ -51,6 +51,7 @@
 #include <asm/unaligned.h>
 
 #include <net/bluetooth/bluetooth.h>
+#include <net/bluetooth/hci_core.h>
 #include <net/bluetooth/l2cap.h>
 
 #include "bnep.h"
@@ -515,6 +516,26 @@ static int bnep_session(void *arg)
         return 0;
 }
 
+static struct device *bnep_get_device(struct bnep_session *session)
+{
+        bdaddr_t *src = &bt_sk(session->sock->sk)->src;
+        bdaddr_t *dst = &bt_sk(session->sock->sk)->dst;
+        struct hci_dev *hdev;
+        struct hci_conn *conn;
+
+        hdev = hci_get_route(dst, src);
+        if (!hdev)
+                return NULL;
+
+        conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
+        if (!conn)
+                return NULL;
+
+        hci_dev_put(hdev);
+
+        return &conn->dev;
+}
+
 int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
 {
         struct net_device *dev;
@@ -534,7 +555,6 @@ int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
         if (!dev)
                 return -ENOMEM;
 
-
         down_write(&bnep_session_sem);
 
         ss = __bnep_get_session(dst);
@@ -551,7 +571,7 @@ int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
         memcpy(s->eh.h_source, &dst, ETH_ALEN);
         memcpy(dev->dev_addr, s->eh.h_dest, ETH_ALEN);
 
-        s->dev = dev;
+        s->dev   = dev;
         s->sock  = sock;
         s->role  = req->role;
         s->state = BT_CONNECTED;
@@ -568,6 +588,8 @@ int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
         bnep_set_default_proto_filter(s);
 #endif
 
+        SET_NETDEV_DEV(dev, bnep_get_device(s));
+
         err = register_netdev(dev);
         if (err) {
                 goto failed;
diff --git a/net/bluetooth/hci_conn.c b/net/bluetooth/hci_conn.c
index 420ed4d7e57e..90e3a285a17e 100644
--- a/net/bluetooth/hci_conn.c
+++ b/net/bluetooth/hci_conn.c
@@ -84,6 +84,20 @@ static void hci_acl_connect(struct hci_conn *conn)
         hci_send_cmd(hdev, OGF_LINK_CTL, OCF_CREATE_CONN, sizeof(cp), &cp);
 }
 
+static void hci_acl_connect_cancel(struct hci_conn *conn)
+{
+        struct hci_cp_create_conn_cancel cp;
+
+        BT_DBG("%p", conn);
+
+        if (conn->hdev->hci_ver < 2)
+                return;
+
+        bacpy(&cp.bdaddr, &conn->dst);
+        hci_send_cmd(conn->hdev, OGF_LINK_CTL,
+                                OCF_CREATE_CONN_CANCEL, sizeof(cp), &cp);
+}
+
 void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
 {
         struct hci_cp_disconnect cp;
@@ -94,7 +108,8 @@ void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
 
         cp.handle = __cpu_to_le16(conn->handle);
         cp.reason = reason;
-        hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_DISCONNECT, sizeof(cp), &cp);
+        hci_send_cmd(conn->hdev, OGF_LINK_CTL,
+                                OCF_DISCONNECT, sizeof(cp), &cp);
 }
 
 void hci_add_sco(struct hci_conn *conn, __u16 handle)
@@ -124,12 +139,20 @@ static void hci_conn_timeout(unsigned long arg)
                 return;
 
         hci_dev_lock(hdev);
-        if (conn->state == BT_CONNECTED)
+
+        switch (conn->state) {
+        case BT_CONNECT:
+                hci_acl_connect_cancel(conn);
+                break;
+        case BT_CONNECTED:
                 hci_acl_disconn(conn, 0x13);
-        else
+                break;
+        default:
                 conn->state = BT_CLOSED;
+                break;
+        }
+
         hci_dev_unlock(hdev);
-        return;
 }
 
 static void hci_conn_idle(unsigned long arg)
@@ -179,6 +202,8 @@ struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
         if (hdev->notify)
                 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
 
+        hci_conn_add_sysfs(conn);
+
         tasklet_enable(&hdev->tx_task);
 
         return conn;
@@ -211,6 +236,8 @@ int hci_conn_del(struct hci_conn *conn)
 
         tasklet_disable(&hdev->tx_task);
 
+        hci_conn_del_sysfs(conn);
+
         hci_conn_hash_del(hdev, conn);
         if (hdev->notify)
                 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
@@ -221,7 +248,9 @@ int hci_conn_del(struct hci_conn *conn)
 
         hci_dev_put(hdev);
 
-        kfree(conn);
+        /* will free via device release */
+        put_device(&conn->dev);
+
         return 0;
 }
 
diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c
index 5ed474277903..338ae977a31b 100644
--- a/net/bluetooth/hci_core.c
+++ b/net/bluetooth/hci_core.c
@@ -206,6 +206,9 @@ static void hci_init_req(struct hci_dev *hdev, unsigned long opt)
         /* Read Local Supported Features */
         hci_send_cmd(hdev, OGF_INFO_PARAM, OCF_READ_LOCAL_FEATURES, 0, NULL);
 
+        /* Read Local Version */
+        hci_send_cmd(hdev, OGF_INFO_PARAM, OCF_READ_LOCAL_VERSION, 0, NULL);
+
         /* Read Buffer Size (ACL mtu, max pkt, etc.) */
         hci_send_cmd(hdev, OGF_INFO_PARAM, OCF_READ_BUFFER_SIZE, 0, NULL);
 
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 3896dabab11d..d43d0c890975 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -62,6 +62,7 @@ static void hci_cc_link_ctl(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb
 
         switch (ocf) {
         case OCF_INQUIRY_CANCEL:
+        case OCF_EXIT_PERIODIC_INQ:
                 status = *((__u8 *) skb->data);
 
                 if (status) {
@@ -297,6 +298,7 @@ static void hci_cc_host_ctl(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb
 /* Command Complete OGF INFO_PARAM  */
 static void hci_cc_info_param(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb)
 {
+        struct hci_rp_read_loc_version *lv;
         struct hci_rp_read_local_features *lf;
         struct hci_rp_read_buffer_size *bs;
         struct hci_rp_read_bd_addr *ba;
@@ -304,6 +306,23 @@ static void hci_cc_info_param(struct hci_dev *hdev, __u16 ocf, struct sk_buff *s
         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
 
         switch (ocf) {
+        case OCF_READ_LOCAL_VERSION:
+                lv = (struct hci_rp_read_loc_version *) skb->data;
+
+                if (lv->status) {
+                        BT_DBG("%s READ_LOCAL_VERSION failed %d", hdev->name, lf->status);
+                        break;
+                }
+
+                hdev->hci_ver = lv->hci_ver;
+                hdev->hci_rev = btohs(lv->hci_rev);
+                hdev->manufacturer = btohs(lv->manufacturer);
+
+                BT_DBG("%s: manufacturer %d hci_ver %d hci_rev %d", hdev->name,
+                                hdev->manufacturer, hdev->hci_ver, hdev->hci_rev);
+
+                break;
+
         case OCF_READ_LOCAL_FEATURES:
                 lf = (struct hci_rp_read_local_features *) skb->data;
 
@@ -328,7 +347,8 @@ static void hci_cc_info_param(struct hci_dev *hdev, __u16 ocf, struct sk_buff *s
                 if (hdev->features[1] & LMP_HV3)
                         hdev->pkt_type |= (HCI_HV3);
 
-                BT_DBG("%s: features 0x%x 0x%x 0x%x", hdev->name, lf->features[0], lf->features[1], lf->features[2]);
+                BT_DBG("%s: features 0x%x 0x%x 0x%x", hdev->name,
+                                lf->features[0], lf->features[1], lf->features[2]);
 
                 break;
 
@@ -757,6 +777,10 @@ static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *s
 
                         hci_send_cmd(hdev, OGF_LINK_CTL,
                                 OCF_CHANGE_CONN_PTYPE, sizeof(cp), &cp);
+                } else {
+                        /* Update disconnect timer */
+                        hci_conn_hold(conn);
+                        hci_conn_put(conn);
                 }
         } else
                 conn->state = BT_CLOSED;
diff --git a/net/bluetooth/hci_sysfs.c b/net/bluetooth/hci_sysfs.c
index 3987d167f04e..989b22d9042e 100644
--- a/net/bluetooth/hci_sysfs.c
+++ b/net/bluetooth/hci_sysfs.c
@@ -13,16 +13,32 @@
 #define BT_DBG(D...)
 #endif
 
-static ssize_t show_name(struct device *dev, struct device_attribute *attr, char *buf)
+static inline char *typetostr(int type)
 {
-        struct hci_dev *hdev = dev_get_drvdata(dev);
-        return sprintf(buf, "%s\n", hdev->name);
+        switch (type) {
+        case HCI_VIRTUAL:
+                return "VIRTUAL";
+        case HCI_USB:
+                return "USB";
+        case HCI_PCCARD:
+                return "PCCARD";
+        case HCI_UART:
+                return "UART";
+        case HCI_RS232:
+                return "RS232";
+        case HCI_PCI:
+                return "PCI";
+        case HCI_SDIO:
+                return "SDIO";
+        default:
+                return "UNKNOWN";
+        }
 }
 
 static ssize_t show_type(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct hci_dev *hdev = dev_get_drvdata(dev);
-        return sprintf(buf, "%d\n", hdev->type);
+        return sprintf(buf, "%s\n", typetostr(hdev->type));
 }
 
 static ssize_t show_address(struct device *dev, struct device_attribute *attr, char *buf)
@@ -33,10 +49,22 @@ static ssize_t show_address(struct device *dev, struct device_attribute *attr, c
         return sprintf(buf, "%s\n", batostr(&bdaddr));
 }
 
-static ssize_t show_flags(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_manufacturer(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct hci_dev *hdev = dev_get_drvdata(dev);
+        return sprintf(buf, "%d\n", hdev->manufacturer);
+}
+
+static ssize_t show_hci_version(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct hci_dev *hdev = dev_get_drvdata(dev);
-        return sprintf(buf, "0x%lx\n", hdev->flags);
+        return sprintf(buf, "%d\n", hdev->hci_ver);
+}
+
+static ssize_t show_hci_revision(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct hci_dev *hdev = dev_get_drvdata(dev);
+        return sprintf(buf, "%d\n", hdev->hci_rev);
 }
 
 static ssize_t show_inquiry_cache(struct device *dev, struct device_attribute *attr, char *buf)
@@ -141,10 +169,11 @@ static ssize_t store_sniff_min_interval(struct device *dev, struct device_attrib
         return count;
 }
 
-static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 static DEVICE_ATTR(type, S_IRUGO, show_type, NULL);
 static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
-static DEVICE_ATTR(flags, S_IRUGO, show_flags, NULL);
+static DEVICE_ATTR(manufacturer, S_IRUGO, show_manufacturer, NULL);
+static DEVICE_ATTR(hci_version, S_IRUGO, show_hci_version, NULL);
+static DEVICE_ATTR(hci_revision, S_IRUGO, show_hci_revision, NULL);
 static DEVICE_ATTR(inquiry_cache, S_IRUGO, show_inquiry_cache, NULL);
 
 static DEVICE_ATTR(idle_timeout, S_IRUGO | S_IWUSR,
@@ -155,10 +184,11 @@ static DEVICE_ATTR(sniff_min_interval, S_IRUGO | S_IWUSR,
                                 show_sniff_min_interval, store_sniff_min_interval);
 
 static struct device_attribute *bt_attrs[] = {
-        &dev_attr_name,
         &dev_attr_type,
         &dev_attr_address,
-        &dev_attr_flags,
+        &dev_attr_manufacturer,
+        &dev_attr_hci_version,
+        &dev_attr_hci_revision,
         &dev_attr_inquiry_cache,
         &dev_attr_idle_timeout,
         &dev_attr_sniff_max_interval,
@@ -166,6 +196,32 @@ static struct device_attribute *bt_attrs[] = {
         NULL
 };
 
+static ssize_t show_conn_type(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct hci_conn *conn = dev_get_drvdata(dev);
+        return sprintf(buf, "%s\n", conn->type == ACL_LINK ? "ACL" : "SCO");
+}
+
+static ssize_t show_conn_address(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct hci_conn *conn = dev_get_drvdata(dev);
+        bdaddr_t bdaddr;
+        baswap(&bdaddr, &conn->dst);
+        return sprintf(buf, "%s\n", batostr(&bdaddr));
+}
+
+#define CONN_ATTR(_name,_mode,_show,_store) \
+struct device_attribute conn_attr_##_name = __ATTR(_name,_mode,_show,_store)
+
+static CONN_ATTR(type, S_IRUGO, show_conn_type, NULL);
+static CONN_ATTR(address, S_IRUGO, show_conn_address, NULL);
+
+static struct device_attribute *conn_attrs[] = {
+        &conn_attr_type,
+        &conn_attr_address,
+        NULL
+};
+
 struct class *bt_class = NULL;
 EXPORT_SYMBOL_GPL(bt_class);
 
@@ -177,8 +233,57 @@ static struct platform_device *bt_platform;
 
 static void bt_release(struct device *dev)
 {
-        struct hci_dev *hdev = dev_get_drvdata(dev);
-        kfree(hdev);
+        void *data = dev_get_drvdata(dev);
+        kfree(data);
+}
+
+static void add_conn(void *data)
+{
+        struct hci_conn *conn = data;
+        int i;
+
+        device_register(&conn->dev);
+
+        for (i = 0; conn_attrs[i]; i++)
+                device_create_file(&conn->dev, conn_attrs[i]);
+}
+
+void hci_conn_add_sysfs(struct hci_conn *conn)
+{
+        struct hci_dev *hdev = conn->hdev;
+        bdaddr_t *ba = &conn->dst;
+
+        BT_DBG("conn %p", conn);
+
+        conn->dev.parent  = &hdev->dev;
+        conn->dev.release = bt_release;
+
+        snprintf(conn->dev.bus_id, BUS_ID_SIZE,
+                        "%s%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X",
+                        conn->type == ACL_LINK ? "acl" : "sco",
+                        ba->b[5], ba->b[4], ba->b[3],
+                        ba->b[2], ba->b[1], ba->b[0]);
+
+        dev_set_drvdata(&conn->dev, conn);
+
+        INIT_WORK(&conn->work, add_conn, (void *) conn);
+
+        schedule_work(&conn->work);
+}
+
+static void del_conn(void *data)
+{
+        struct hci_conn *conn = data;
+        device_del(&conn->dev);
+}
+
+void hci_conn_del_sysfs(struct hci_conn *conn)
+{
+        BT_DBG("conn %p", conn);
+
+        INIT_WORK(&conn->work, del_conn, (void *) conn);
+
+        schedule_work(&conn->work);
 }
 
 int hci_register_sysfs(struct hci_dev *hdev)
@@ -214,11 +319,9 @@ int hci_register_sysfs(struct hci_dev *hdev)
 
 void hci_unregister_sysfs(struct hci_dev *hdev)
 {
-        struct device *dev = &hdev->dev;
-
         BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type);
 
-        device_del(dev);
+        device_del(&hdev->dev);
 }
 
 int __init bt_sysfs_init(void)
@@ -245,7 +348,7 @@ int __init bt_sysfs_init(void)
         return 0;
 }
 
-void __exit bt_sysfs_cleanup(void)
+void bt_sysfs_cleanup(void)
 {
         class_destroy(bt_class);
 
diff --git a/net/bluetooth/hidp/core.c b/net/bluetooth/hidp/core.c
index c6e3a2c27c6e..03b5dadb4951 100644
--- a/net/bluetooth/hidp/core.c
+++ b/net/bluetooth/hidp/core.c
@@ -40,6 +40,7 @@
 #include <linux/input.h>
 
 #include <net/bluetooth/bluetooth.h>
+#include <net/bluetooth/hci_core.h>
 #include <net/bluetooth/l2cap.h>
 
 #include "hidp.h"
@@ -528,6 +529,26 @@ static int hidp_session(void *arg)
         return 0;
 }
 
+static struct device *hidp_get_device(struct hidp_session *session)
+{
+        bdaddr_t *src = &bt_sk(session->ctrl_sock->sk)->src;
+        bdaddr_t *dst = &bt_sk(session->ctrl_sock->sk)->dst;
+        struct hci_dev *hdev;
+        struct hci_conn *conn;
+
+        hdev = hci_get_route(dst, src);
+        if (!hdev)
+                return NULL;
+
+        conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
+        if (!conn)
+                return NULL;
+
+        hci_dev_put(hdev);
+
+        return &conn->dev;
+}
+
 static inline void hidp_setup_input(struct hidp_session *session, struct hidp_connadd_req *req)
 {
         struct input_dev *input = session->input;
@@ -566,6 +587,8 @@ static inline void hidp_setup_input(struct hidp_session *session, struct hidp_co
                 input->relbit[0] |= BIT(REL_WHEEL);
         }
 
+        input->cdev.dev = hidp_get_device(session);
+
         input->event = hidp_input_event;
 
         input_register_device(input);
diff --git a/net/bluetooth/rfcomm/core.c b/net/bluetooth/rfcomm/core.c
index 332dd8f436ea..468df3b953f6 100644
--- a/net/bluetooth/rfcomm/core.c
+++ b/net/bluetooth/rfcomm/core.c
@@ -644,7 +644,7 @@ static struct rfcomm_session *rfcomm_session_create(bdaddr_t *src, bdaddr_t *dst
         addr.l2_family = AF_BLUETOOTH;
         addr.l2_psm    = htobs(RFCOMM_PSM);
         *err = sock->ops->connect(sock, (struct sockaddr *) &addr, sizeof(addr), O_NONBLOCK);
-        if (*err == 0 || *err == -EAGAIN)
+        if (*err == 0 || *err == -EINPROGRESS)
                 return s;
 
         rfcomm_session_del(s);
diff --git a/net/bluetooth/rfcomm/tty.c b/net/bluetooth/rfcomm/tty.c
index bd8d671a0ba6..26f322737db0 100644
--- a/net/bluetooth/rfcomm/tty.c
+++ b/net/bluetooth/rfcomm/tty.c
@@ -38,6 +38,7 @@
 #include <linux/skbuff.h>
 
 #include <net/bluetooth/bluetooth.h>
+#include <net/bluetooth/hci_core.h>
 #include <net/bluetooth/rfcomm.h>
 
 #ifndef CONFIG_BT_RFCOMM_DEBUG
@@ -161,6 +162,24 @@ static inline struct rfcomm_dev *rfcomm_dev_get(int id)
         return dev;
 }
 
+static struct device *rfcomm_get_device(struct rfcomm_dev *dev)
+{
+        struct hci_dev *hdev;
+        struct hci_conn *conn;
+
+        hdev = hci_get_route(&dev->dst, &dev->src);
+        if (!hdev)
+                return NULL;
+
+        conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &dev->dst);
+        if (!conn)
+                return NULL;
+
+        hci_dev_put(hdev);
+
+        return &conn->dev;
+}
+
 static int rfcomm_dev_add(struct rfcomm_dev_req *req, struct rfcomm_dlc *dlc)
 {
         struct rfcomm_dev *dev;
@@ -244,7 +263,7 @@ out:
                 return err;
         }
 
-        tty_register_device(rfcomm_tty_driver, dev->id, NULL);
+        tty_register_device(rfcomm_tty_driver, dev->id, rfcomm_get_device(dev));
 
         return dev->id;
 }
diff --git a/net/bridge/netfilter/ebt_arpreply.c b/net/bridge/netfilter/ebt_arpreply.c
index d19fc4b328dc..0aa7b9910a86 100644
--- a/net/bridge/netfilter/ebt_arpreply.c
+++ b/net/bridge/netfilter/ebt_arpreply.c
@@ -20,7 +20,7 @@ static int ebt_target_reply(struct sk_buff **pskb, unsigned int hooknr,
    const void *data, unsigned int datalen)
 {
         struct ebt_arpreply_info *info = (struct ebt_arpreply_info *)data;
-        u32 _sip, *siptr, _dip, *diptr;
+        __be32 _sip, *siptr, _dip, *diptr;
         struct arphdr _ah, *ap;
         unsigned char _sha[ETH_ALEN], *shp;
         struct sk_buff *skb = *pskb;
diff --git a/net/core/dev.c b/net/core/dev.c
index 14de297d024d..4d891beab138 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1480,14 +1480,16 @@ gso:
         if (q->enqueue) {
                 /* Grab device queue */
                 spin_lock(&dev->queue_lock);
+                q = dev->qdisc;
+                if (q->enqueue) {
+                        rc = q->enqueue(skb, q);
+                        qdisc_run(dev);
+                        spin_unlock(&dev->queue_lock);
 
-                rc = q->enqueue(skb, q);
-
-                qdisc_run(dev);
-
+                        rc = rc == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : rc;
+                        goto out;
+                }
                 spin_unlock(&dev->queue_lock);
-                rc = rc == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : rc;
-                goto out;
         }
 
         /* The device has no queue. Common case for software devices:
diff --git a/net/core/ethtool.c b/net/core/ethtool.c
index e0ca04f38cef..87dc556fd9d6 100644
--- a/net/core/ethtool.c
+++ b/net/core/ethtool.c
@@ -806,13 +806,6 @@ int dev_ethtool(struct ifreq *ifr)
         int rc;
         unsigned long old_features;
 
-        /*
-         * XXX: This can be pushed down into the ethtool_* handlers that
-         * need it.  Keep existing behaviour for the moment.
-         */
-        if (!capable(CAP_NET_ADMIN))
-                return -EPERM;
-
         if (!dev || !netif_device_present(dev))
                 return -ENODEV;
 
@@ -822,6 +815,27 @@ int dev_ethtool(struct ifreq *ifr)
         if (copy_from_user(&ethcmd, useraddr, sizeof (ethcmd)))
                 return -EFAULT;
 
+        /* Allow some commands to be done by anyone */
+        switch(ethcmd) {
+        case ETHTOOL_GDRVINFO:
+        case ETHTOOL_GMSGLVL:
+        case ETHTOOL_GCOALESCE:
+        case ETHTOOL_GRINGPARAM:
+        case ETHTOOL_GPAUSEPARAM:
+        case ETHTOOL_GRXCSUM:
+        case ETHTOOL_GTXCSUM:
+        case ETHTOOL_GSG:
+        case ETHTOOL_GSTRINGS:
+        case ETHTOOL_GTSO:
+        case ETHTOOL_GPERMADDR:
+        case ETHTOOL_GUFO:
+        case ETHTOOL_GGSO:
+                break;
+        default:
+                if (!capable(CAP_NET_ADMIN))
+                        return -EPERM;
+        }
+
         if(dev->ethtool_ops->begin)
                 if ((rc = dev->ethtool_ops->begin(dev)) < 0)
                         return rc;
@@ -947,6 +961,10 @@ int dev_ethtool(struct ifreq *ifr)
         return rc;
 
  ioctl:
+        /* Keep existing behaviour for the moment.       */
+        if (!capable(CAP_NET_ADMIN))
+                return -EPERM;
+
         if (dev->do_ioctl)
                 return dev->do_ioctl(dev, ifr, SIOCETHTOOL);
         return -EOPNOTSUPP;
diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index b6c69e1463e8..8ce8c471d868 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -1079,7 +1079,7 @@ struct neighbour *neigh_event_ns(struct neigh_table *tbl,
 }
 
 static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst,
-                          u16 protocol)
+                          __be16 protocol)
 {
         struct hh_cache *hh;
         struct net_device *dev = dst->dev;
diff --git a/net/core/pktgen.c b/net/core/pktgen.c
index 72145d4a2600..dd023fd28304 100644
--- a/net/core/pktgen.c
+++ b/net/core/pktgen.c
@@ -109,6 +109,8 @@
  *
  * MPLS support by Steven Whitehouse <steve@chygwyn.com>
  *
+ * 802.1Q/Q-in-Q support by Francesco Fondelli (FF) <francesco.fondelli@gmail.com>
+ *
  */
 #include <linux/sys.h>
 #include <linux/types.h>
@@ -137,6 +139,7 @@
 #include <linux/inetdevice.h>
 #include <linux/rtnetlink.h>
 #include <linux/if_arp.h>
+#include <linux/if_vlan.h>
 #include <linux/in.h>
 #include <linux/ip.h>
 #include <linux/ipv6.h>
@@ -157,7 +160,7 @@
 #include <asm/div64.h>          /* do_div */
 #include <asm/timex.h>
 
-#define VERSION  "pktgen v2.67: Packet Generator for packet performance testing.\n"
+#define VERSION  "pktgen v2.68: Packet Generator for packet performance testing.\n"
 
 /* #define PG_DEBUG(a) a */
 #define PG_DEBUG(a)
@@ -178,6 +181,8 @@
 #define F_TXSIZE_RND  (1<<6)    /* Transmit size is random */
 #define F_IPV6        (1<<7)    /* Interface in IPV6 Mode */
 #define F_MPLS_RND    (1<<8)    /* Random MPLS labels */
+#define F_VID_RND     (1<<9)    /* Random VLAN ID */
+#define F_SVID_RND    (1<<10)   /* Random SVLAN ID */
 
 /* Thread control flag bits */
 #define T_TERMINATE   (1<<0)
@@ -198,6 +203,9 @@ static struct proc_dir_entry *pg_proc_dir = NULL;
 
 #define MAX_CFLOWS  65536
 
+#define VLAN_TAG_SIZE(x) ((x)->vlan_id == 0xffff ? 0 : 4)
+#define SVLAN_TAG_SIZE(x) ((x)->svlan_id == 0xffff ? 0 : 4)
+
 struct flow_state {
         __u32 cur_daddr;
         int count;
@@ -284,10 +292,23 @@ struct pktgen_dev {
         __u16 udp_dst_min;      /* inclusive, dest UDP port */
         __u16 udp_dst_max;      /* exclusive, dest UDP port */
 
+        /* DSCP + ECN */
+        __u8 tos;            /* six most significant bits of (former) IPv4 TOS are for dscp codepoint */
+        __u8 traffic_class;  /* ditto for the (former) Traffic Class in IPv6 (see RFC 3260, sec. 4) */
+
         /* MPLS */
         unsigned nr_labels;     /* Depth of stack, 0 = no MPLS */
         __be32 labels[MAX_MPLS_LABELS];
 
+        /* VLAN/SVLAN (802.1Q/Q-in-Q) */
+        __u8  vlan_p;
+        __u8  vlan_cfi;
+        __u16 vlan_id;  /* 0xffff means no vlan tag */
+
+        __u8  svlan_p;
+        __u8  svlan_cfi;
+        __u16 svlan_id; /* 0xffff means no svlan tag */
+
         __u32 src_mac_count;    /* How many MACs to iterate through */
         __u32 dst_mac_count;    /* How many MACs to iterate through */
 
@@ -644,6 +665,24 @@ static int pktgen_if_show(struct seq_file *seq, void *v)
                                    i == pkt_dev->nr_labels-1 ? "\n" : ", ");
         }
 
+        if (pkt_dev->vlan_id != 0xffff) {
+                seq_printf(seq, "     vlan_id: %u  vlan_p: %u  vlan_cfi: %u\n",
+                           pkt_dev->vlan_id, pkt_dev->vlan_p, pkt_dev->vlan_cfi);
+        }
+
+        if (pkt_dev->svlan_id != 0xffff) {
+                seq_printf(seq, "     svlan_id: %u  vlan_p: %u  vlan_cfi: %u\n",
+                           pkt_dev->svlan_id, pkt_dev->svlan_p, pkt_dev->svlan_cfi);
+        }
+
+        if (pkt_dev->tos) {
+                seq_printf(seq, "     tos: 0x%02x\n", pkt_dev->tos);
+        }
+
+        if (pkt_dev->traffic_class) {
+                seq_printf(seq, "     traffic_class: 0x%02x\n", pkt_dev->traffic_class);
+        }
+
         seq_printf(seq, "     Flags: ");
 
         if (pkt_dev->flags & F_IPV6)
@@ -673,6 +712,12 @@ static int pktgen_if_show(struct seq_file *seq, void *v)
         if (pkt_dev->flags & F_MACDST_RND)
                 seq_printf(seq, "MACDST_RND  ");
 
+        if (pkt_dev->flags & F_VID_RND)
+                seq_printf(seq, "VID_RND  ");
+
+        if (pkt_dev->flags & F_SVID_RND)
+                seq_printf(seq, "SVID_RND  ");
+
         seq_puts(seq, "\n");
 
         sa = pkt_dev->started_at;
@@ -715,12 +760,12 @@ static int pktgen_if_show(struct seq_file *seq, void *v)
 }
 
 
-static int hex32_arg(const char __user *user_buffer, __u32 *num)
+static int hex32_arg(const char __user *user_buffer, unsigned long maxlen, __u32 *num)
 {
         int i = 0;
         *num = 0;
 
-        for(; i < 8; i++) {
+        for(; i < maxlen; i++) {
                 char c;
                 *num <<= 4;
                 if (get_user(c, &user_buffer[i]))
@@ -815,7 +860,7 @@ static ssize_t get_labels(const char __user *buffer, struct pktgen_dev *pkt_dev)
         pkt_dev->nr_labels = 0;
         do {
                 __u32 tmp;
-                len = hex32_arg(&buffer[i], &tmp);
+                len = hex32_arg(&buffer[i], 8, &tmp);
                 if (len <= 0)
                         return len;
                 pkt_dev->labels[n] = htonl(tmp);
@@ -1140,11 +1185,27 @@ static ssize_t pktgen_if_write(struct file *file,
                 else if (strcmp(f, "!MPLS_RND") == 0)
                         pkt_dev->flags &= ~F_MPLS_RND;
 
+                else if (strcmp(f, "VID_RND") == 0)
+                        pkt_dev->flags |= F_VID_RND;
+
+                else if (strcmp(f, "!VID_RND") == 0)
+                        pkt_dev->flags &= ~F_VID_RND;
+
+                else if (strcmp(f, "SVID_RND") == 0)
+                        pkt_dev->flags |= F_SVID_RND;
+
+                else if (strcmp(f, "!SVID_RND") == 0)
+                        pkt_dev->flags &= ~F_SVID_RND;
+
+                else if (strcmp(f, "!IPV6") == 0)
+                        pkt_dev->flags &= ~F_IPV6;
+
                 else {
                         sprintf(pg_result,
                                 "Flag -:%s:- unknown\nAvailable flags, (prepend ! to un-set flag):\n%s",
                                 f,
-                                "IPSRC_RND, IPDST_RND, TXSIZE_RND, UDPSRC_RND, UDPDST_RND, MACSRC_RND, MACDST_RND\n");
+                                "IPSRC_RND, IPDST_RND, UDPSRC_RND, UDPDST_RND, "
+                                "MACSRC_RND, MACDST_RND, TXSIZE_RND, IPV6, MPLS_RND, VID_RND, SVID_RND\n");
                         return count;
                 }
                 sprintf(pg_result, "OK: flags=0x%x", pkt_dev->flags);
@@ -1445,6 +1506,160 @@ static ssize_t pktgen_if_write(struct file *file,
                         offset += sprintf(pg_result + offset,
                                           "%08x%s", ntohl(pkt_dev->labels[n]),
                                           n == pkt_dev->nr_labels-1 ? "" : ",");
+
+                if (pkt_dev->nr_labels && pkt_dev->vlan_id != 0xffff) {
+                        pkt_dev->vlan_id = 0xffff; /* turn off VLAN/SVLAN */
+                        pkt_dev->svlan_id = 0xffff;
+
+                        if (debug)
+                                printk("pktgen: VLAN/SVLAN auto turned off\n");
+                }
+                return count;
+        }
+
+        if (!strcmp(name, "vlan_id")) {
+                len = num_arg(&user_buffer[i], 4, &value);
+                if (len < 0) {
+                        return len;
+                }
+                i += len;
+                if (value <= 4095) {
+                        pkt_dev->vlan_id = value;  /* turn on VLAN */
+
+                        if (debug)
+                                printk("pktgen: VLAN turned on\n");
+
+                        if (debug && pkt_dev->nr_labels)
+                                printk("pktgen: MPLS auto turned off\n");
+
+                        pkt_dev->nr_labels = 0;    /* turn off MPLS */
+                        sprintf(pg_result, "OK: vlan_id=%u", pkt_dev->vlan_id);
+                } else {
+                        pkt_dev->vlan_id = 0xffff; /* turn off VLAN/SVLAN */
+                        pkt_dev->svlan_id = 0xffff;
+
+                        if (debug)
+                                printk("pktgen: VLAN/SVLAN turned off\n");
+                }
+                return count;
+        }
+
+        if (!strcmp(name, "vlan_p")) {
+                len = num_arg(&user_buffer[i], 1, &value);
+                if (len < 0) {
+                        return len;
+                }
+                i += len;
+                if ((value <= 7) && (pkt_dev->vlan_id != 0xffff)) {
+                        pkt_dev->vlan_p = value;
+                        sprintf(pg_result, "OK: vlan_p=%u", pkt_dev->vlan_p);
+                } else {
+                        sprintf(pg_result, "ERROR: vlan_p must be 0-7");
+                }
+                return count;
+        }
+
+        if (!strcmp(name, "vlan_cfi")) {
+                len = num_arg(&user_buffer[i], 1, &value);
+                if (len < 0) {
+                        return len;
+                }
+                i += len;
+                if ((value <= 1) && (pkt_dev->vlan_id != 0xffff)) {
+                        pkt_dev->vlan_cfi = value;
+                        sprintf(pg_result, "OK: vlan_cfi=%u", pkt_dev->vlan_cfi);
+                } else {
+                        sprintf(pg_result, "ERROR: vlan_cfi must be 0-1");
+                }
+                return count;
+        }
+
+        if (!strcmp(name, "svlan_id")) {
+                len = num_arg(&user_buffer[i], 4, &value);
+                if (len < 0) {
+                        return len;
+                }
+                i += len;
+                if ((value <= 4095) && ((pkt_dev->vlan_id != 0xffff))) {
+                        pkt_dev->svlan_id = value;  /* turn on SVLAN */
+
+                        if (debug)
+                                printk("pktgen: SVLAN turned on\n");
+
+                        if (debug && pkt_dev->nr_labels)
+                                printk("pktgen: MPLS auto turned off\n");
+
+                        pkt_dev->nr_labels = 0;    /* turn off MPLS */
+                        sprintf(pg_result, "OK: svlan_id=%u", pkt_dev->svlan_id);
+                } else {
+                        pkt_dev->vlan_id = 0xffff; /* turn off VLAN/SVLAN */
+                        pkt_dev->svlan_id = 0xffff;
+
+                        if (debug)
+                                printk("pktgen: VLAN/SVLAN turned off\n");
+                }
+                return count;
+        }
+
+        if (!strcmp(name, "svlan_p")) {
+                len = num_arg(&user_buffer[i], 1, &value);
+                if (len < 0) {
+                        return len;
+                }
+                i += len;
+                if ((value <= 7) && (pkt_dev->svlan_id != 0xffff)) {
+                        pkt_dev->svlan_p = value;
+                        sprintf(pg_result, "OK: svlan_p=%u", pkt_dev->svlan_p);
+                } else {
+                        sprintf(pg_result, "ERROR: svlan_p must be 0-7");
+                }
+                return count;
+        }
+
+        if (!strcmp(name, "svlan_cfi")) {
+                len = num_arg(&user_buffer[i], 1, &value);
+                if (len < 0) {
+                        return len;
+                }
+                i += len;
+                if ((value <= 1) && (pkt_dev->svlan_id != 0xffff)) {
+                        pkt_dev->svlan_cfi = value;
+                        sprintf(pg_result, "OK: svlan_cfi=%u", pkt_dev->svlan_cfi);
+                } else {
+                        sprintf(pg_result, "ERROR: svlan_cfi must be 0-1");
+                }
+                return count;
+        }
+
+        if (!strcmp(name, "tos")) {
+                __u32 tmp_value = 0;
+                len = hex32_arg(&user_buffer[i], 2, &tmp_value);
+                if (len < 0) {
+                        return len;
+                }
+                i += len;
+                if (len == 2) {
+                        pkt_dev->tos = tmp_value;
+                        sprintf(pg_result, "OK: tos=0x%02x", pkt_dev->tos);
+                } else {
+                        sprintf(pg_result, "ERROR: tos must be 00-ff");
+                }
+                return count;
+        }
+
+        if (!strcmp(name, "traffic_class")) {
+                __u32 tmp_value = 0;
+                len = hex32_arg(&user_buffer[i], 2, &tmp_value);
+                if (len < 0) {
+                        return len;
+                }
+                i += len;
+                if (len == 2) {
+                        pkt_dev->traffic_class = tmp_value;
+                        sprintf(pg_result, "OK: traffic_class=0x%02x", pkt_dev->traffic_class);
+                } else {
+                        sprintf(pg_result, "ERROR: traffic_class must be 00-ff");
+                }
                 return count;
         }
 
@@ -1949,6 +2164,14 @@ static void mod_cur_headers(struct pktgen_dev *pkt_dev)
                                                       htonl(0x000fffff));
         }
 
+        if ((pkt_dev->flags & F_VID_RND) && (pkt_dev->vlan_id != 0xffff)) {
+                pkt_dev->vlan_id = pktgen_random() % 4096;
+        }
+
+        if ((pkt_dev->flags & F_SVID_RND) && (pkt_dev->svlan_id != 0xffff)) {
+                pkt_dev->svlan_id = pktgen_random() % 4096;
+        }
+
         if (pkt_dev->udp_src_min < pkt_dev->udp_src_max) {
                 if (pkt_dev->flags & F_UDPSRC_RND)
                         pkt_dev->cur_udp_src =
@@ -2092,10 +2315,18 @@ static struct sk_buff *fill_packet_ipv4(struct net_device *odev,
         struct pktgen_hdr *pgh = NULL;
         __be16 protocol = __constant_htons(ETH_P_IP);
         __be32 *mpls;
+        __be16 *vlan_tci = NULL;                 /* Encapsulates priority and VLAN ID */
+        __be16 *vlan_encapsulated_proto = NULL;  /* packet type ID field (or len) for VLAN tag */
+        __be16 *svlan_tci = NULL;                /* Encapsulates priority and SVLAN ID */
+        __be16 *svlan_encapsulated_proto = NULL; /* packet type ID field (or len) for SVLAN tag */
+
 
         if (pkt_dev->nr_labels)
                 protocol = __constant_htons(ETH_P_MPLS_UC);
 
+        if (pkt_dev->vlan_id != 0xffff)
+                protocol = __constant_htons(ETH_P_8021Q);
+
         /* Update any of the values, used when we're incrementing various
          * fields.
          */
@@ -2103,7 +2334,9 @@ static struct sk_buff *fill_packet_ipv4(struct net_device *odev,
 
         datalen = (odev->hard_header_len + 16) & ~0xf;
         skb = alloc_skb(pkt_dev->cur_pkt_size + 64 + datalen +
-                        pkt_dev->nr_labels*sizeof(u32), GFP_ATOMIC);
+                        pkt_dev->nr_labels*sizeof(u32) +
+                        VLAN_TAG_SIZE(pkt_dev) + SVLAN_TAG_SIZE(pkt_dev),
+                        GFP_ATOMIC);
         if (!skb) {
                 sprintf(pkt_dev->result, "No memory");
                 return NULL;
@@ -2116,6 +2349,24 @@ static struct sk_buff *fill_packet_ipv4(struct net_device *odev,
         mpls = (__be32 *)skb_put(skb, pkt_dev->nr_labels*sizeof(__u32));
         if (pkt_dev->nr_labels)
                 mpls_push(mpls, pkt_dev);
+
+        if (pkt_dev->vlan_id != 0xffff) {
+                if(pkt_dev->svlan_id != 0xffff) {
+                        svlan_tci = (__be16 *)skb_put(skb, sizeof(__be16));
+                        *svlan_tci = htons(pkt_dev->svlan_id);
+                        *svlan_tci |= pkt_dev->svlan_p << 5;
+                        *svlan_tci |= pkt_dev->svlan_cfi << 4;
+                        svlan_encapsulated_proto = (__be16 *)skb_put(skb, sizeof(__be16));
+                        *svlan_encapsulated_proto = __constant_htons(ETH_P_8021Q);
+                }
+                vlan_tci = (__be16 *)skb_put(skb, sizeof(__be16));
+                *vlan_tci = htons(pkt_dev->vlan_id);
+                *vlan_tci |= pkt_dev->vlan_p << 5;
+                *vlan_tci |= pkt_dev->vlan_cfi << 4;
+                vlan_encapsulated_proto = (__be16 *)skb_put(skb, sizeof(__be16));
+                *vlan_encapsulated_proto = __constant_htons(ETH_P_IP);
+        }
+
         iph = (struct iphdr *)skb_put(skb, sizeof(struct iphdr));
         udph = (struct udphdr *)skb_put(skb, sizeof(struct udphdr));
 
@@ -2124,7 +2375,7 @@ static struct sk_buff *fill_packet_ipv4(struct net_device *odev,
 
         /* Eth + IPh + UDPh + mpls */
         datalen = pkt_dev->cur_pkt_size - 14 - 20 - 8 -
-                  pkt_dev->nr_labels*sizeof(u32);
+                  pkt_dev->nr_labels*sizeof(u32) - VLAN_TAG_SIZE(pkt_dev) - SVLAN_TAG_SIZE(pkt_dev);
         if (datalen < sizeof(struct pktgen_hdr))
                 datalen = sizeof(struct pktgen_hdr);
 
@@ -2136,7 +2387,7 @@ static struct sk_buff *fill_packet_ipv4(struct net_device *odev,
         iph->ihl = 5;
         iph->version = 4;
         iph->ttl = 32;
-        iph->tos = 0;
+        iph->tos = pkt_dev->tos;
         iph->protocol = IPPROTO_UDP;    /* UDP */
         iph->saddr = pkt_dev->cur_saddr;
         iph->daddr = pkt_dev->cur_daddr;
@@ -2146,7 +2397,8 @@ static struct sk_buff *fill_packet_ipv4(struct net_device *odev,
         iph->check = 0;
         iph->check = ip_fast_csum((void *)iph, iph->ihl);
         skb->protocol = protocol;
-        skb->mac.raw = ((u8 *) iph) - 14 - pkt_dev->nr_labels*sizeof(u32);
+        skb->mac.raw = ((u8 *) iph) - 14 - pkt_dev->nr_labels*sizeof(u32) -
+                VLAN_TAG_SIZE(pkt_dev) - SVLAN_TAG_SIZE(pkt_dev);
         skb->dev = odev;
         skb->pkt_type = PACKET_HOST;
         skb->nh.iph = iph;
@@ -2218,7 +2470,6 @@ static struct sk_buff *fill_packet_ipv4(struct net_device *odev,
                 pgh->tv_sec = htonl(timestamp.tv_sec);
                 pgh->tv_usec = htonl(timestamp.tv_usec);
         }
-        pkt_dev->seq_num++;
 
         return skb;
 }
@@ -2402,17 +2653,26 @@ static struct sk_buff *fill_packet_ipv6(struct net_device *odev,
         struct pktgen_hdr *pgh = NULL;
         __be16 protocol = __constant_htons(ETH_P_IPV6);
         __be32 *mpls;
+        __be16 *vlan_tci = NULL;                 /* Encapsulates priority and VLAN ID */
+        __be16 *vlan_encapsulated_proto = NULL;  /* packet type ID field (or len) for VLAN tag */
+        __be16 *svlan_tci = NULL;                /* Encapsulates priority and SVLAN ID */
+        __be16 *svlan_encapsulated_proto = NULL; /* packet type ID field (or len) for SVLAN tag */
 
         if (pkt_dev->nr_labels)
                 protocol = __constant_htons(ETH_P_MPLS_UC);
 
+        if (pkt_dev->vlan_id != 0xffff)
+                protocol = __constant_htons(ETH_P_8021Q);
+
         /* Update any of the values, used when we're incrementing various
          * fields.
          */
         mod_cur_headers(pkt_dev);
 
         skb = alloc_skb(pkt_dev->cur_pkt_size + 64 + 16 +
-                        pkt_dev->nr_labels*sizeof(u32), GFP_ATOMIC);
+                        pkt_dev->nr_labels*sizeof(u32) +
+                        VLAN_TAG_SIZE(pkt_dev) + SVLAN_TAG_SIZE(pkt_dev),
+                        GFP_ATOMIC);
         if (!skb) {
                 sprintf(pkt_dev->result, "No memory");
                 return NULL;
@@ -2425,16 +2685,34 @@ static struct sk_buff *fill_packet_ipv6(struct net_device *odev,
         mpls = (__be32 *)skb_put(skb, pkt_dev->nr_labels*sizeof(__u32));
         if (pkt_dev->nr_labels)
                 mpls_push(mpls, pkt_dev);
+
+        if (pkt_dev->vlan_id != 0xffff) {
+                if(pkt_dev->svlan_id != 0xffff) {
+                        svlan_tci = (__be16 *)skb_put(skb, sizeof(__be16));
+                        *svlan_tci = htons(pkt_dev->svlan_id);
+                        *svlan_tci |= pkt_dev->svlan_p << 5;
+                        *svlan_tci |= pkt_dev->svlan_cfi << 4;
+                        svlan_encapsulated_proto = (__be16 *)skb_put(skb, sizeof(__be16));
+                        *svlan_encapsulated_proto = __constant_htons(ETH_P_8021Q);
+                }
+                vlan_tci = (__be16 *)skb_put(skb, sizeof(__be16));
+                *vlan_tci = htons(pkt_dev->vlan_id);
+                *vlan_tci |= pkt_dev->vlan_p << 5;
+                *vlan_tci |= pkt_dev->vlan_cfi << 4;
+                vlan_encapsulated_proto = (__be16 *)skb_put(skb, sizeof(__be16));
+                *vlan_encapsulated_proto = __constant_htons(ETH_P_IPV6);
+        }
+
         iph = (struct ipv6hdr *)skb_put(skb, sizeof(struct ipv6hdr));
         udph = (struct udphdr *)skb_put(skb, sizeof(struct udphdr));
 
         memcpy(eth, pkt_dev->hh, 12);
-        *(u16 *) & eth[12] = __constant_htons(ETH_P_IPV6);
+        *(u16 *) & eth[12] = protocol;
 
         /* Eth + IPh + UDPh + mpls */
         datalen = pkt_dev->cur_pkt_size - 14 -
                   sizeof(struct ipv6hdr) - sizeof(struct udphdr) -
-                  pkt_dev->nr_labels*sizeof(u32);
+                  pkt_dev->nr_labels*sizeof(u32) - VLAN_TAG_SIZE(pkt_dev) - SVLAN_TAG_SIZE(pkt_dev);
 
         if (datalen < sizeof(struct pktgen_hdr)) {
                 datalen = sizeof(struct pktgen_hdr);
@@ -2450,6 +2728,11 @@ static struct sk_buff *fill_packet_ipv6(struct net_device *odev,
 
         *(u32 *) iph = __constant_htonl(0x60000000);    /* Version + flow */
 
+        if (pkt_dev->traffic_class) {
+                /* Version + traffic class + flow (0) */
+                *(u32 *)iph |= htonl(0x60000000 | (pkt_dev->traffic_class << 20));
+        }
+
         iph->hop_limit = 32;
 
         iph->payload_len = htons(sizeof(struct udphdr) + datalen);
@@ -2458,7 +2741,8 @@ static struct sk_buff *fill_packet_ipv6(struct net_device *odev,
         ipv6_addr_copy(&iph->daddr, &pkt_dev->cur_in6_daddr);
         ipv6_addr_copy(&iph->saddr, &pkt_dev->cur_in6_saddr);
 
-        skb->mac.raw = ((u8 *) iph) - 14 - pkt_dev->nr_labels*sizeof(u32);
+        skb->mac.raw = ((u8 *) iph) - 14 - pkt_dev->nr_labels*sizeof(u32) -
+                VLAN_TAG_SIZE(pkt_dev) - SVLAN_TAG_SIZE(pkt_dev);
         skb->protocol = protocol;
         skb->dev = odev;
         skb->pkt_type = PACKET_HOST;
@@ -2531,7 +2815,7 @@ static struct sk_buff *fill_packet_ipv6(struct net_device *odev,
                 pgh->tv_sec = htonl(timestamp.tv_sec);
                 pgh->tv_usec = htonl(timestamp.tv_usec);
         }
-        pkt_dev->seq_num++;
+        /* pkt_dev->seq_num++; FF: you really mean this? */
 
         return skb;
 }
@@ -3177,6 +3461,13 @@ static int pktgen_add_device(struct pktgen_thread *t, const char *ifname)
         pkt_dev->udp_dst_min = 9;
         pkt_dev->udp_dst_max = 9;
 
+        pkt_dev->vlan_p = 0;
+        pkt_dev->vlan_cfi = 0;
+        pkt_dev->vlan_id = 0xffff;
+        pkt_dev->svlan_p = 0;
+        pkt_dev->svlan_cfi = 0;
+        pkt_dev->svlan_id = 0xffff;
+
         strncpy(pkt_dev->ifname, ifname, IFNAMSIZ);
 
         if (!pktgen_setup_dev(pkt_dev)) {
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index d8e25e08cb7e..221e4038216b 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -562,7 +562,7 @@ static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
 
         err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
         if (err < 0)
-                goto errout;
+                return err;
 
         ifm = nlmsg_data(nlh);
         if (ifm->ifi_index >= 0) {
diff --git a/net/core/utils.c b/net/core/utils.c
index 2682490777de..94c5d761c830 100644
--- a/net/core/utils.c
+++ b/net/core/utils.c
@@ -3,7 +3,7 @@
  *
  *      Authors:
  *      net_random Alan Cox
- *      net_ratelimit Andy Kleen
+ *      net_ratelimit Andi Kleen
  *      in{4,6}_pton YOSHIFUJI Hideaki, Copyright (C)2006 USAGI/WIDE Project
  *
  *      Created by Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
diff --git a/net/dccp/ipv4.c b/net/dccp/ipv4.c
index 66be29b6f508..bf692c1c116f 100644
--- a/net/dccp/ipv4.c
+++ b/net/dccp/ipv4.c
@@ -50,7 +50,7 @@ int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
         struct dccp_sock *dp = dccp_sk(sk);
         const struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
         struct rtable *rt;
-        u32 daddr, nexthop;
+        __be32 daddr, nexthop;
         int tmp;
         int err;
 
diff --git a/net/ethernet/eth.c b/net/ethernet/eth.c
index 43863933f27f..4bd78c8cfb26 100644
--- a/net/ethernet/eth.c
+++ b/net/ethernet/eth.c
@@ -223,7 +223,7 @@ static int eth_header_parse(struct sk_buff *skb, unsigned char *haddr)
  */
 int eth_header_cache(struct neighbour *neigh, struct hh_cache *hh)
 {
-        unsigned short type = hh->hh_type;
+        __be16 type = hh->hh_type;
         struct ethhdr *eth;
         struct net_device *dev = neigh->dev;
 
diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c
index fdd89e37b9aa..edcf0932ac6d 100644
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ -996,7 +996,7 @@ static int inet_sk_reselect_saddr(struct sock *sk)
         struct rtable *rt;
         __u32 old_saddr = inet->saddr;
         __u32 new_saddr;
-        __u32 daddr = inet->daddr;
+        __be32 daddr = inet->daddr;
 
         if (inet->opt && inet->opt->srr)
                 daddr = inet->opt->faddr;
@@ -1043,7 +1043,7 @@ int inet_sk_rebuild_header(struct sock *sk)
 {
         struct inet_sock *inet = inet_sk(sk);
         struct rtable *rt = (struct rtable *)__sk_dst_check(sk, 0);
-        u32 daddr;
+        __be32 daddr;
         int err;
 
         /* Route is OK, nothing to do. */
@@ -1342,10 +1342,10 @@ static int __init inet_init(void)
         rc = 0;
 out:
         return rc;
-out_unregister_tcp_proto:
-        proto_unregister(&tcp_prot);
 out_unregister_udp_proto:
         proto_unregister(&udp_prot);
+out_unregister_tcp_proto:
+        proto_unregister(&tcp_prot);
         goto out;
 }
 
diff --git a/net/ipv4/arp.c b/net/ipv4/arp.c
index c8a3723bc001..cfe5c8474286 100644
--- a/net/ipv4/arp.c
+++ b/net/ipv4/arp.c
@@ -234,7 +234,7 @@ static u32 arp_hash(const void *pkey, const struct net_device *dev)
 
 static int arp_constructor(struct neighbour *neigh)
 {
-        u32 addr = *(u32*)neigh->primary_key;
+        __be32 addr = *(__be32*)neigh->primary_key;
         struct net_device *dev = neigh->dev;
         struct in_device *in_dev;
         struct neigh_parms *parms;
@@ -330,10 +330,10 @@ static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb)
 
 static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
 {
-        u32 saddr = 0;
+        __be32 saddr = 0;
         u8  *dst_ha = NULL;
         struct net_device *dev = neigh->dev;
-        u32 target = *(u32*)neigh->primary_key;
+        __be32 target = *(__be32*)neigh->primary_key;
         int probes = atomic_read(&neigh->probes);
         struct in_device *in_dev = in_dev_get(dev);
 
@@ -385,7 +385,7 @@ static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
 }
 
 static int arp_ignore(struct in_device *in_dev, struct net_device *dev,
-                      u32 sip, u32 tip)
+                      __be32 sip, __be32 tip)
 {
         int scope;
 
@@ -420,7 +420,7 @@ static int arp_ignore(struct in_device *in_dev, struct net_device *dev,
         return !inet_confirm_addr(dev, sip, tip, scope);
 }
 
-static int arp_filter(__u32 sip, __u32 tip, struct net_device *dev)
+static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev)
 {
         struct flowi fl = { .nl_u = { .ip4_u = { .daddr = sip,
                                                  .saddr = tip } } };
@@ -449,7 +449,7 @@ static int arp_filter(__u32 sip, __u32 tip, struct net_device *dev)
  *      is allowed to use this function, it is scheduled to be removed. --ANK
  */
 
-static int arp_set_predefined(int addr_hint, unsigned char * haddr, u32 paddr, struct net_device * dev)
+static int arp_set_predefined(int addr_hint, unsigned char * haddr, __be32 paddr, struct net_device * dev)
 {
         switch (addr_hint) {
         case RTN_LOCAL:
@@ -470,7 +470,7 @@ static int arp_set_predefined(int addr_hint, unsigned char * haddr, u32 paddr, s
 int arp_find(unsigned char *haddr, struct sk_buff *skb)
 {
         struct net_device *dev = skb->dev;
-        u32 paddr;
+        __be32 paddr;
         struct neighbour *n;
 
         if (!skb->dst) {
@@ -511,7 +511,7 @@ int arp_bind_neighbour(struct dst_entry *dst)
         if (dev == NULL)
                 return -EINVAL;
         if (n == NULL) {
-                u32 nexthop = ((struct rtable*)dst)->rt_gateway;
+                __be32 nexthop = ((struct rtable*)dst)->rt_gateway;
                 if (dev->flags&(IFF_LOOPBACK|IFF_POINTOPOINT))
                         nexthop = 0;
                 n = __neigh_lookup_errno(
@@ -560,8 +560,8 @@ static inline int arp_fwd_proxy(struct in_device *in_dev, struct rtable *rt)
  *      Create an arp packet. If (dest_hw == NULL), we create a broadcast
  *      message.
  */
-struct sk_buff *arp_create(int type, int ptype, u32 dest_ip,
-                           struct net_device *dev, u32 src_ip,
+struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
+                           struct net_device *dev, __be32 src_ip,
                            unsigned char *dest_hw, unsigned char *src_hw,
                            unsigned char *target_hw)
 {
@@ -675,8 +675,8 @@ void arp_xmit(struct sk_buff *skb)
 /*
  *      Create and send an arp packet.
  */
-void arp_send(int type, int ptype, u32 dest_ip, 
-              struct net_device *dev, u32 src_ip, 
+void arp_send(int type, int ptype, __be32 dest_ip,
+              struct net_device *dev, __be32 src_ip,
               unsigned char *dest_hw, unsigned char *src_hw,
               unsigned char *target_hw)
 {
@@ -710,7 +710,7 @@ static int arp_process(struct sk_buff *skb)
         unsigned char *arp_ptr;
         struct rtable *rt;
         unsigned char *sha, *tha;
-        u32 sip, tip;
+        __be32 sip, tip;
         u16 dev_type = dev->type;
         int addr_type;
         struct neighbour *n;
@@ -969,13 +969,13 @@ out_of_mem:
 
 static int arp_req_set(struct arpreq *r, struct net_device * dev)
 {
-        u32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
+        __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
         struct neighbour *neigh;
         int err;
 
         if (r->arp_flags&ATF_PUBL) {
-                u32 mask = ((struct sockaddr_in *) &r->arp_netmask)->sin_addr.s_addr;
-                if (mask && mask != 0xFFFFFFFF)
+                __be32 mask = ((struct sockaddr_in *) &r->arp_netmask)->sin_addr.s_addr;
+                if (mask && mask != htonl(0xFFFFFFFF))
                         return -EINVAL;
                 if (!dev && (r->arp_flags & ATF_COM)) {
                         dev = dev_getbyhwaddr(r->arp_ha.sa_family, r->arp_ha.sa_data);
@@ -1063,7 +1063,7 @@ static unsigned arp_state_to_flags(struct neighbour *neigh)
 
 static int arp_req_get(struct arpreq *r, struct net_device *dev)
 {
-        u32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
+        __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
         struct neighbour *neigh;
         int err = -ENXIO;
 
@@ -1084,13 +1084,13 @@ static int arp_req_get(struct arpreq *r, struct net_device *dev)
 static int arp_req_delete(struct arpreq *r, struct net_device * dev)
 {
         int err;
-        u32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
+        __be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
         struct neighbour *neigh;
 
         if (r->arp_flags & ATF_PUBL) {
-                u32 mask =
+                __be32 mask =
                        ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
-                if (mask == 0xFFFFFFFF)
+                if (mask == htonl(0xFFFFFFFF))
                         return pneigh_delete(&arp_tbl, &ip, dev);
                 if (mask == 0) {
                         if (dev == NULL) {
diff --git a/net/ipv4/cipso_ipv4.c b/net/ipv4/cipso_ipv4.c
index e6ce0b3ba62a..c4e469ff842d 100644
--- a/net/ipv4/cipso_ipv4.c
+++ b/net/ipv4/cipso_ipv4.c
@@ -474,6 +474,7 @@ doi_add_failure_rlock:
 /**
  * cipso_v4_doi_remove - Remove an existing DOI from the CIPSO protocol engine
  * @doi: the DOI value
+ * @audit_secid: the LSM secid to use in the audit message
  * @callback: the DOI cleanup/free callback
  *
  * Description:
@@ -483,7 +484,9 @@ doi_add_failure_rlock:
  * success and negative values on failure.
  *
  */
-int cipso_v4_doi_remove(u32 doi, void (*callback) (struct rcu_head * head))
+int cipso_v4_doi_remove(u32 doi,
+                        u32 audit_secid,
+                        void (*callback) (struct rcu_head * head))
 {
         struct cipso_v4_doi *doi_def;
         struct cipso_v4_domhsh_entry *dom_iter;
@@ -502,7 +505,8 @@ int cipso_v4_doi_remove(u32 doi, void (*callback) (struct rcu_head * head))
                 spin_unlock(&cipso_v4_doi_list_lock);
                 list_for_each_entry_rcu(dom_iter, &doi_def->dom_list, list)
                         if (dom_iter->valid)
-                                netlbl_domhsh_remove(dom_iter->domain);
+                                netlbl_domhsh_remove(dom_iter->domain,
+                                                     audit_secid);
                 cipso_v4_cache_invalidate();
                 rcu_read_unlock();
 
diff --git a/net/ipv4/datagram.c b/net/ipv4/datagram.c
index ec5da4fbd9f4..7b068a891953 100644
--- a/net/ipv4/datagram.c
+++ b/net/ipv4/datagram.c
@@ -25,7 +25,7 @@ int ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
         struct inet_sock *inet = inet_sk(sk);
         struct sockaddr_in *usin = (struct sockaddr_in *) uaddr;
         struct rtable *rt;
-        u32 saddr;
+        __be32 saddr;
         int oif;
         int err;
 
diff --git a/net/ipv4/devinet.c b/net/ipv4/devinet.c
index 8e8d1f17d77a..7602c79a389b 100644
--- a/net/ipv4/devinet.c
+++ b/net/ipv4/devinet.c
@@ -224,7 +224,7 @@ static void inetdev_destroy(struct in_device *in_dev)
         call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
 }
 
-int inet_addr_onlink(struct in_device *in_dev, u32 a, u32 b)
+int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
 {
         rcu_read_lock();
         for_primary_ifa(in_dev) {
@@ -429,8 +429,8 @@ struct in_device *inetdev_by_index(int ifindex)
 
 /* Called only from RTNL semaphored context. No locks. */
 
-struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, u32 prefix,
-                                    u32 mask)
+struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
+                                    __be32 mask)
 {
         ASSERT_RTNL();
 
@@ -467,7 +467,7 @@ static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg
         for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
              ifap = &ifa->ifa_next) {
                 if (tb[IFA_LOCAL] &&
-                    ifa->ifa_local != nla_get_u32(tb[IFA_LOCAL]))
+                    ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
                         continue;
 
                 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
@@ -475,7 +475,7 @@ static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg
 
                 if (tb[IFA_ADDRESS] &&
                     (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
-                    !inet_ifa_match(nla_get_u32(tb[IFA_ADDRESS]), ifa)))
+                    !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
                         continue;
 
                 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid);
@@ -540,14 +540,14 @@ static struct in_ifaddr *rtm_to_ifaddr(struct nlmsghdr *nlh)
         ifa->ifa_scope = ifm->ifa_scope;
         ifa->ifa_dev = in_dev;
 
-        ifa->ifa_local = nla_get_u32(tb[IFA_LOCAL]);
-        ifa->ifa_address = nla_get_u32(tb[IFA_ADDRESS]);
+        ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
+        ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
 
         if (tb[IFA_BROADCAST])
-                ifa->ifa_broadcast = nla_get_u32(tb[IFA_BROADCAST]);
+                ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
 
         if (tb[IFA_ANYCAST])
-                ifa->ifa_anycast = nla_get_u32(tb[IFA_ANYCAST]);
+                ifa->ifa_anycast = nla_get_be32(tb[IFA_ANYCAST]);
 
         if (tb[IFA_LABEL])
                 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
@@ -805,7 +805,7 @@ int devinet_ioctl(unsigned int cmd, void __user *arg)
                         break;
                 ret = 0;
                 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
-                        u32 old_mask = ifa->ifa_mask;
+                        __be32 old_mask = ifa->ifa_mask;
                         inet_del_ifa(in_dev, ifap, 0);
                         ifa->ifa_mask = sin->sin_addr.s_addr;
                         ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
@@ -876,9 +876,9 @@ out:
         return done;
 }
 
-u32 inet_select_addr(const struct net_device *dev, u32 dst, int scope)
+__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
 {
-        u32 addr = 0;
+        __be32 addr = 0;
         struct in_device *in_dev;
 
         rcu_read_lock();
@@ -927,11 +927,11 @@ out:
         return addr;
 }
 
-static u32 confirm_addr_indev(struct in_device *in_dev, u32 dst,
-                              u32 local, int scope)
+static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
+                              __be32 local, int scope)
 {
         int same = 0;
-        u32 addr = 0;
+        __be32 addr = 0;
 
         for_ifa(in_dev) {
                 if (!addr &&
@@ -971,9 +971,9 @@ static u32 confirm_addr_indev(struct in_device *in_dev, u32 dst,
  * - local: address, 0=autoselect the local address
  * - scope: maximum allowed scope value for the local address
  */
-u32 inet_confirm_addr(const struct net_device *dev, u32 dst, u32 local, int scope)
+__be32 inet_confirm_addr(const struct net_device *dev, __be32 dst, __be32 local, int scope)
 {
-        u32 addr = 0;
+        __be32 addr = 0;
         struct in_device *in_dev;
 
         if (dev) {
@@ -1138,16 +1138,16 @@ static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
         ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
 
         if (ifa->ifa_address)
-                NLA_PUT_U32(skb, IFA_ADDRESS, ifa->ifa_address);
+                NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
 
         if (ifa->ifa_local)
-                NLA_PUT_U32(skb, IFA_LOCAL, ifa->ifa_local);
+                NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
 
         if (ifa->ifa_broadcast)
-                NLA_PUT_U32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
+                NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
 
         if (ifa->ifa_anycast)
-                NLA_PUT_U32(skb, IFA_ANYCAST, ifa->ifa_anycast);
+                NLA_PUT_BE32(skb, IFA_ANYCAST, ifa->ifa_anycast);
 
         if (ifa->ifa_label[0])
                 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
diff --git a/net/ipv4/fib_frontend.c b/net/ipv4/fib_frontend.c
index cfb527c060e4..9c399a70dd5d 100644
--- a/net/ipv4/fib_frontend.c
+++ b/net/ipv4/fib_frontend.c
@@ -122,7 +122,7 @@ static void fib_flush(void)
  *      Find the first device with a given source address.
  */
 
-struct net_device * ip_dev_find(u32 addr)
+struct net_device * ip_dev_find(__be32 addr)
 {
         struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
         struct fib_result res;
@@ -146,7 +146,7 @@ out:
         return dev;
 }
 
-unsigned inet_addr_type(u32 addr)
+unsigned inet_addr_type(__be32 addr)
 {
         struct flowi            fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
         struct fib_result       res;
@@ -180,8 +180,8 @@ unsigned inet_addr_type(u32 addr)
    - check, that packet arrived from expected physical interface.
  */
 
-int fib_validate_source(u32 src, u32 dst, u8 tos, int oif,
-                        struct net_device *dev, u32 *spec_dst, u32 *itag)
+int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
+                        struct net_device *dev, __be32 *spec_dst, u32 *itag)
 {
         struct in_device *in_dev;
         struct flowi fl = { .nl_u = { .ip4_u =
@@ -253,7 +253,7 @@ e_inval:
 
 #ifndef CONFIG_IP_NOSIOCRT
 
-static inline u32 sk_extract_addr(struct sockaddr *addr)
+static inline __be32 sk_extract_addr(struct sockaddr *addr)
 {
         return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
 }
@@ -273,7 +273,7 @@ static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
 static int rtentry_to_fib_config(int cmd, struct rtentry *rt,
                                  struct fib_config *cfg)
 {
-        u32 addr;
+        __be32 addr;
         int plen;
 
         memset(cfg, 0, sizeof(*cfg));
@@ -292,7 +292,7 @@ static int rtentry_to_fib_config(int cmd, struct rtentry *rt,
         plen = 32;
         addr = sk_extract_addr(&rt->rt_dst);
         if (!(rt->rt_flags & RTF_HOST)) {
-                u32 mask = sk_extract_addr(&rt->rt_genmask);
+                __be32 mask = sk_extract_addr(&rt->rt_genmask);
 
                 if (rt->rt_genmask.sa_family != AF_INET) {
                         if (mask || rt->rt_genmask.sa_family)
@@ -499,22 +499,22 @@ static int rtm_to_fib_config(struct sk_buff *skb, struct nlmsghdr *nlh,
         nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
                 switch (attr->nla_type) {
                 case RTA_DST:
-                        cfg->fc_dst = nla_get_u32(attr);
+                        cfg->fc_dst = nla_get_be32(attr);
                         break;
                 case RTA_SRC:
-                        cfg->fc_src = nla_get_u32(attr);
+                        cfg->fc_src = nla_get_be32(attr);
                         break;
                 case RTA_OIF:
                         cfg->fc_oif = nla_get_u32(attr);
                         break;
                 case RTA_GATEWAY:
-                        cfg->fc_gw = nla_get_u32(attr);
+                        cfg->fc_gw = nla_get_be32(attr);
                         break;
                 case RTA_PRIORITY:
                         cfg->fc_priority = nla_get_u32(attr);
                         break;
                 case RTA_PREFSRC:
-                        cfg->fc_prefsrc = nla_get_u32(attr);
+                        cfg->fc_prefsrc = nla_get_be32(attr);
                         break;
                 case RTA_METRICS:
                         cfg->fc_mx = nla_data(attr);
@@ -627,8 +627,7 @@ out:
    only when netlink is already locked.
  */
 
-static void fib_magic(int cmd, int type, u32 dst, int dst_len,
-                      struct in_ifaddr *ifa)
+static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
 {
         struct fib_table *tb;
         struct fib_config cfg = {
@@ -667,9 +666,9 @@ void fib_add_ifaddr(struct in_ifaddr *ifa)
         struct in_device *in_dev = ifa->ifa_dev;
         struct net_device *dev = in_dev->dev;
         struct in_ifaddr *prim = ifa;
-        u32 mask = ifa->ifa_mask;
-        u32 addr = ifa->ifa_local;
-        u32 prefix = ifa->ifa_address&mask;
+        __be32 mask = ifa->ifa_mask;
+        __be32 addr = ifa->ifa_local;
+        __be32 prefix = ifa->ifa_address&mask;
 
         if (ifa->ifa_flags&IFA_F_SECONDARY) {
                 prim = inet_ifa_byprefix(in_dev, prefix, mask);
@@ -685,7 +684,7 @@ void fib_add_ifaddr(struct in_ifaddr *ifa)
                 return;
 
         /* Add broadcast address, if it is explicitly assigned. */
-        if (ifa->ifa_broadcast && ifa->ifa_broadcast != 0xFFFFFFFF)
+        if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
                 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
 
         if (!ZERONET(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
@@ -707,8 +706,8 @@ static void fib_del_ifaddr(struct in_ifaddr *ifa)
         struct net_device *dev = in_dev->dev;
         struct in_ifaddr *ifa1;
         struct in_ifaddr *prim = ifa;
-        u32 brd = ifa->ifa_address|~ifa->ifa_mask;
-        u32 any = ifa->ifa_address&ifa->ifa_mask;
+        __be32 brd = ifa->ifa_address|~ifa->ifa_mask;
+        __be32 any = ifa->ifa_address&ifa->ifa_mask;
 #define LOCAL_OK        1
 #define BRD_OK          2
 #define BRD0_OK         4
diff --git a/net/ipv4/fib_hash.c b/net/ipv4/fib_hash.c
index 88133b383dc5..107bb6cbb0b3 100644
--- a/net/ipv4/fib_hash.c
+++ b/net/ipv4/fib_hash.c
@@ -51,7 +51,7 @@ static kmem_cache_t *fn_alias_kmem __read_mostly;
 struct fib_node {
         struct hlist_node       fn_hash;
         struct list_head        fn_alias;
-        u32                     fn_key;
+        __be32                  fn_key;
 };
 
 struct fn_zone {
@@ -64,7 +64,7 @@ struct fn_zone {
 #define FZ_HASHMASK(fz)         ((fz)->fz_hashmask)
 
         int                     fz_order;       /* Zone order           */
-        u32                     fz_mask;
+        __be32                  fz_mask;
 #define FZ_MASK(fz)             ((fz)->fz_mask)
 };
 
@@ -77,7 +77,7 @@ struct fn_hash {
         struct fn_zone  *fn_zone_list;
 };
 
-static inline u32 fn_hash(u32 key, struct fn_zone *fz)
+static inline u32 fn_hash(__be32 key, struct fn_zone *fz)
 {
         u32 h = ntohl(key)>>(32 - fz->fz_order);
         h ^= (h>>20);
@@ -87,7 +87,7 @@ static inline u32 fn_hash(u32 key, struct fn_zone *fz)
         return h;
 }
 
-static inline u32 fz_key(u32 dst, struct fn_zone *fz)
+static inline __be32 fz_key(__be32 dst, struct fn_zone *fz)
 {
         return dst & FZ_MASK(fz);
 }
@@ -254,7 +254,7 @@ fn_hash_lookup(struct fib_table *tb, const struct flowi *flp, struct fib_result
                 struct hlist_head *head;
                 struct hlist_node *node;
                 struct fib_node *f;
-                u32 k = fz_key(flp->fl4_dst, fz);
+                __be32 k = fz_key(flp->fl4_dst, fz);
 
                 head = &fz->fz_hash[fn_hash(k, fz)];
                 hlist_for_each_entry(f, node, head, fn_hash) {
@@ -365,7 +365,7 @@ static inline void fib_insert_node(struct fn_zone *fz, struct fib_node *f)
 }
 
 /* Return the node in FZ matching KEY. */
-static struct fib_node *fib_find_node(struct fn_zone *fz, u32 key)
+static struct fib_node *fib_find_node(struct fn_zone *fz, __be32 key)
 {
         struct hlist_head *head = &fz->fz_hash[fn_hash(key, fz)];
         struct hlist_node *node;
@@ -387,7 +387,7 @@ static int fn_hash_insert(struct fib_table *tb, struct fib_config *cfg)
         struct fn_zone *fz;
         struct fib_info *fi;
         u8 tos = cfg->fc_tos;
-        u32 key;
+        __be32 key;
         int err;
 
         if (cfg->fc_dst_len > 32)
@@ -541,7 +541,7 @@ static int fn_hash_delete(struct fib_table *tb, struct fib_config *cfg)
         struct fib_node *f;
         struct fib_alias *fa, *fa_to_delete;
         struct fn_zone *fz;
-        u32 key;
+        __be32 key;
 
         if (cfg->fc_dst_len > 32)
                 return -EINVAL;
@@ -966,7 +966,7 @@ static void fib_seq_stop(struct seq_file *seq, void *v)
         read_unlock(&fib_hash_lock);
 }
 
-static unsigned fib_flag_trans(int type, u32 mask, struct fib_info *fi)
+static unsigned fib_flag_trans(int type, __be32 mask, struct fib_info *fi)
 {
         static const unsigned type2flags[RTN_MAX + 1] = {
                 [7] = RTF_REJECT, [8] = RTF_REJECT,
@@ -975,7 +975,7 @@ static unsigned fib_flag_trans(int type, u32 mask, struct fib_info *fi)
 
         if (fi && fi->fib_nh->nh_gw)
                 flags |= RTF_GATEWAY;
-        if (mask == 0xFFFFFFFF)
+        if (mask == htonl(0xFFFFFFFF))
                 flags |= RTF_HOST;
         flags |= RTF_UP;
         return flags;
@@ -991,7 +991,7 @@ static int fib_seq_show(struct seq_file *seq, void *v)
 {
         struct fib_iter_state *iter;
         char bf[128];
-        u32 prefix, mask;
+        __be32 prefix, mask;
         unsigned flags;
         struct fib_node *f;
         struct fib_alias *fa;
diff --git a/net/ipv4/fib_lookup.h b/net/ipv4/fib_lookup.h
index fd6f7769f8ab..0e8b70bad4e1 100644
--- a/net/ipv4/fib_lookup.h
+++ b/net/ipv4/fib_lookup.h
@@ -20,16 +20,16 @@ struct fib_alias {
 /* Exported by fib_semantics.c */
 extern int fib_semantic_match(struct list_head *head,
                               const struct flowi *flp,
-                              struct fib_result *res, __u32 zone, __u32 mask,
+                              struct fib_result *res, __be32 zone, __be32 mask,
                                 int prefixlen);
 extern void fib_release_info(struct fib_info *);
 extern struct fib_info *fib_create_info(struct fib_config *cfg);
 extern int fib_nh_match(struct fib_config *cfg, struct fib_info *fi);
 extern int fib_dump_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
-                         u32 tb_id, u8 type, u8 scope, u32 dst,
+                         u32 tb_id, u8 type, u8 scope, __be32 dst,
                          int dst_len, u8 tos, struct fib_info *fi,
                          unsigned int);
-extern void rtmsg_fib(int event, u32 key, struct fib_alias *fa,
+extern void rtmsg_fib(int event, __be32 key, struct fib_alias *fa,
                       int dst_len, u32 tb_id, struct nl_info *info);
 extern struct fib_alias *fib_find_alias(struct list_head *fah,
                                         u8 tos, u32 prio);
diff --git a/net/ipv4/fib_rules.c b/net/ipv4/fib_rules.c
index 52b2adae4f22..0852b9cd065a 100644
--- a/net/ipv4/fib_rules.c
+++ b/net/ipv4/fib_rules.c
@@ -40,10 +40,10 @@ struct fib4_rule
         u8                      dst_len;
         u8                      src_len;
         u8                      tos;
-        u32                     src;
-        u32                     srcmask;
-        u32                     dst;
-        u32                     dstmask;
+        __be32                  src;
+        __be32                  srcmask;
+        __be32                  dst;
+        __be32                  dstmask;
 #ifdef CONFIG_IP_ROUTE_FWMARK
         u32                     fwmark;
         u32                     fwmask;
@@ -150,8 +150,8 @@ void fib_select_default(const struct flowi *flp, struct fib_result *res)
 static int fib4_rule_match(struct fib_rule *rule, struct flowi *fl, int flags)
 {
         struct fib4_rule *r = (struct fib4_rule *) rule;
-        u32 daddr = fl->fl4_dst;
-        u32 saddr = fl->fl4_src;
+        __be32 daddr = fl->fl4_dst;
+        __be32 saddr = fl->fl4_src;
 
         if (((saddr ^ r->src) & r->srcmask) ||
             ((daddr ^ r->dst) & r->dstmask))
@@ -215,10 +215,10 @@ static int fib4_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
         }
 
         if (tb[FRA_SRC])
-                rule4->src = nla_get_u32(tb[FRA_SRC]);
+                rule4->src = nla_get_be32(tb[FRA_SRC]);
 
         if (tb[FRA_DST])
-                rule4->dst = nla_get_u32(tb[FRA_DST]);
+                rule4->dst = nla_get_be32(tb[FRA_DST]);
 
 #ifdef CONFIG_IP_ROUTE_FWMARK
         if (tb[FRA_FWMARK]) {
@@ -277,10 +277,10 @@ static int fib4_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
                 return 0;
 #endif
 
-        if (tb[FRA_SRC] && (rule4->src != nla_get_u32(tb[FRA_SRC])))
+        if (tb[FRA_SRC] && (rule4->src != nla_get_be32(tb[FRA_SRC])))
                 return 0;
 
-        if (tb[FRA_DST] && (rule4->dst != nla_get_u32(tb[FRA_DST])))
+        if (tb[FRA_DST] && (rule4->dst != nla_get_be32(tb[FRA_DST])))
                 return 0;
 
         return 1;
@@ -305,10 +305,10 @@ static int fib4_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
 #endif
 
         if (rule4->dst_len)
-                NLA_PUT_U32(skb, FRA_DST, rule4->dst);
+                NLA_PUT_BE32(skb, FRA_DST, rule4->dst);
 
         if (rule4->src_len)
-                NLA_PUT_U32(skb, FRA_SRC, rule4->src);
+                NLA_PUT_BE32(skb, FRA_SRC, rule4->src);
 
 #ifdef CONFIG_NET_CLS_ROUTE
         if (rule4->tclassid)
diff --git a/net/ipv4/fib_semantics.c b/net/ipv4/fib_semantics.c
index 2ead09543f68..884d176e0082 100644
--- a/net/ipv4/fib_semantics.c
+++ b/net/ipv4/fib_semantics.c
@@ -203,7 +203,7 @@ static inline unsigned int fib_info_hashfn(const struct fib_info *fi)
         unsigned int val = fi->fib_nhs;
 
         val ^= fi->fib_protocol;
-        val ^= fi->fib_prefsrc;
+        val ^= (__force u32)fi->fib_prefsrc;
         val ^= fi->fib_priority;
 
         return (val ^ (val >> 7) ^ (val >> 12)) & mask;
@@ -248,7 +248,7 @@ static inline unsigned int fib_devindex_hashfn(unsigned int val)
    Used only by redirect accept routine.
  */
 
-int ip_fib_check_default(u32 gw, struct net_device *dev)
+int ip_fib_check_default(__be32 gw, struct net_device *dev)
 {
         struct hlist_head *head;
         struct hlist_node *node;
@@ -273,7 +273,7 @@ int ip_fib_check_default(u32 gw, struct net_device *dev)
         return -1;
 }
 
-void rtmsg_fib(int event, u32 key, struct fib_alias *fa,
+void rtmsg_fib(int event, __be32 key, struct fib_alias *fa,
                int dst_len, u32 tb_id, struct nl_info *info)
 {
         struct sk_buff *skb;
@@ -374,7 +374,7 @@ static int fib_get_nhs(struct fib_info *fi, struct rtnexthop *rtnh,
                         struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
 
                         nla = nla_find(attrs, attrlen, RTA_GATEWAY);
-                        nh->nh_gw = nla ? nla_get_u32(nla) : 0;
+                        nh->nh_gw = nla ? nla_get_be32(nla) : 0;
 #ifdef CONFIG_NET_CLS_ROUTE
                         nla = nla_find(attrs, attrlen, RTA_FLOW);
                         nh->nh_tclassid = nla ? nla_get_u32(nla) : 0;
@@ -427,7 +427,7 @@ int fib_nh_match(struct fib_config *cfg, struct fib_info *fi)
                         struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
 
                         nla = nla_find(attrs, attrlen, RTA_GATEWAY);
-                        if (nla && nla_get_u32(nla) != nh->nh_gw)
+                        if (nla && nla_get_be32(nla) != nh->nh_gw)
                                 return 1;
 #ifdef CONFIG_NET_CLS_ROUTE
                         nla = nla_find(attrs, attrlen, RTA_FLOW);
@@ -568,11 +568,11 @@ out:
         return 0;
 }
 
-static inline unsigned int fib_laddr_hashfn(u32 val)
+static inline unsigned int fib_laddr_hashfn(__be32 val)
 {
         unsigned int mask = (fib_hash_size - 1);
 
-        return (val ^ (val >> 7) ^ (val >> 14)) & mask;
+        return ((__force u32)val ^ ((__force u32)val >> 7) ^ ((__force u32)val >> 14)) & mask;
 }
 
 static struct hlist_head *fib_hash_alloc(int bytes)
@@ -847,7 +847,7 @@ failure:
 
 /* Note! fib_semantic_match intentionally uses  RCU list functions. */
 int fib_semantic_match(struct list_head *head, const struct flowi *flp,
-                       struct fib_result *res, __u32 zone, __u32 mask, 
+                       struct fib_result *res, __be32 zone, __be32 mask,
                         int prefixlen)
 {
         struct fib_alias *fa;
@@ -914,8 +914,7 @@ out_fill_res:
         res->fi = fa->fa_info;
 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
         res->netmask = mask;
-        res->network = zone &
-                (0xFFFFFFFF >> (32 - prefixlen));
+        res->network = zone & inet_make_mask(prefixlen);
 #endif
         atomic_inc(&res->fi->fib_clntref);
         return 0;
@@ -923,13 +922,13 @@ out_fill_res:
 
 /* Find appropriate source address to this destination */
 
-u32 __fib_res_prefsrc(struct fib_result *res)
+__be32 __fib_res_prefsrc(struct fib_result *res)
 {
         return inet_select_addr(FIB_RES_DEV(*res), FIB_RES_GW(*res), res->scope);
 }
 
 int fib_dump_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
-                  u32 tb_id, u8 type, u8 scope, u32 dst, int dst_len, u8 tos,
+                  u32 tb_id, u8 type, u8 scope, __be32 dst, int dst_len, u8 tos,
                   struct fib_info *fi, unsigned int flags)
 {
         struct nlmsghdr *nlh;
@@ -952,7 +951,7 @@ int fib_dump_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
         rtm->rtm_protocol = fi->fib_protocol;
 
         if (rtm->rtm_dst_len)
-                NLA_PUT_U32(skb, RTA_DST, dst);
+                NLA_PUT_BE32(skb, RTA_DST, dst);
 
         if (fi->fib_priority)
                 NLA_PUT_U32(skb, RTA_PRIORITY, fi->fib_priority);
@@ -961,11 +960,11 @@ int fib_dump_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
                 goto nla_put_failure;
 
         if (fi->fib_prefsrc)
-                NLA_PUT_U32(skb, RTA_PREFSRC, fi->fib_prefsrc);
+                NLA_PUT_BE32(skb, RTA_PREFSRC, fi->fib_prefsrc);
 
         if (fi->fib_nhs == 1) {
                 if (fi->fib_nh->nh_gw)
-                        NLA_PUT_U32(skb, RTA_GATEWAY, fi->fib_nh->nh_gw);
+                        NLA_PUT_BE32(skb, RTA_GATEWAY, fi->fib_nh->nh_gw);
 
                 if (fi->fib_nh->nh_oif)
                         NLA_PUT_U32(skb, RTA_OIF, fi->fib_nh->nh_oif);
@@ -993,7 +992,7 @@ int fib_dump_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
                         rtnh->rtnh_ifindex = nh->nh_oif;
 
                         if (nh->nh_gw)
-                                NLA_PUT_U32(skb, RTA_GATEWAY, nh->nh_gw);
+                                NLA_PUT_BE32(skb, RTA_GATEWAY, nh->nh_gw);
 #ifdef CONFIG_NET_CLS_ROUTE
                         if (nh->nh_tclassid)
                                 NLA_PUT_U32(skb, RTA_FLOW, nh->nh_tclassid);
@@ -1018,7 +1017,7 @@ nla_put_failure:
    - device went down -> we must shutdown all nexthops going via it.
  */
 
-int fib_sync_down(u32 local, struct net_device *dev, int force)
+int fib_sync_down(__be32 local, struct net_device *dev, int force)
 {
         int ret = 0;
         int scope = RT_SCOPE_NOWHERE;
diff --git a/net/ipv4/fib_trie.c b/net/ipv4/fib_trie.c
index 9c3ff6ba6e21..d17990ec724f 100644
--- a/net/ipv4/fib_trie.c
+++ b/net/ipv4/fib_trie.c
@@ -1834,7 +1834,7 @@ static int fn_trie_dump_fa(t_key key, int plen, struct list_head *fah, struct fi
         int i, s_i;
         struct fib_alias *fa;
 
-        u32 xkey = htonl(key);
+        __be32 xkey = htonl(key);
 
         s_i = cb->args[4];
         i = 0;
@@ -2281,7 +2281,7 @@ static int fib_trie_seq_show(struct seq_file *seq, void *v)
 
         if (IS_TNODE(n)) {
                 struct tnode *tn = (struct tnode *) n;
-                t_key prf = ntohl(MASK_PFX(tn->key, tn->pos));
+                __be32 prf = htonl(MASK_PFX(tn->key, tn->pos));
 
                 if (!NODE_PARENT(n)) {
                         if (iter->trie == trie_local)
@@ -2297,7 +2297,7 @@ static int fib_trie_seq_show(struct seq_file *seq, void *v)
         } else {
                 struct leaf *l = (struct leaf *) n;
                 int i;
-                u32 val = ntohl(l->key);
+                __be32 val = htonl(l->key);
 
                 seq_indent(seq, iter->depth);
                 seq_printf(seq, "  |-- %d.%d.%d.%d\n", NIPQUAD(val));
@@ -2360,7 +2360,7 @@ static struct file_operations fib_trie_fops = {
         .release = seq_release_private,
 };
 
-static unsigned fib_flag_trans(int type, u32 mask, const struct fib_info *fi)
+static unsigned fib_flag_trans(int type, __be32 mask, const struct fib_info *fi)
 {
         static unsigned type2flags[RTN_MAX + 1] = {
                 [7] = RTF_REJECT, [8] = RTF_REJECT,
@@ -2369,7 +2369,7 @@ static unsigned fib_flag_trans(int type, u32 mask, const struct fib_info *fi)
 
         if (fi && fi->fib_nh->nh_gw)
                 flags |= RTF_GATEWAY;
-        if (mask == 0xFFFFFFFF)
+        if (mask == htonl(0xFFFFFFFF))
                 flags |= RTF_HOST;
         flags |= RTF_UP;
         return flags;
@@ -2403,7 +2403,7 @@ static int fib_route_seq_show(struct seq_file *seq, void *v)
         for (i=32; i>=0; i--) {
                 struct leaf_info *li = find_leaf_info(l, i);
                 struct fib_alias *fa;
-                u32 mask, prefix;
+                __be32 mask, prefix;
 
                 if (!li)
                         continue;
diff --git a/net/ipv4/icmp.c b/net/ipv4/icmp.c
index c2ad07e48ab4..b39a37a47545 100644
--- a/net/ipv4/icmp.c
+++ b/net/ipv4/icmp.c
@@ -104,7 +104,7 @@ struct icmp_bxm {
 
         struct {
                 struct icmphdr icmph;
-                __u32          times[3];
+                __be32         times[3];
         } data;
         int head_len;
         struct ip_options replyopts;
@@ -381,7 +381,7 @@ static void icmp_reply(struct icmp_bxm *icmp_param, struct sk_buff *skb)
         struct inet_sock *inet = inet_sk(sk);
         struct ipcm_cookie ipc;
         struct rtable *rt = (struct rtable *)skb->dst;
-        u32 daddr;
+        __be32 daddr;
 
         if (ip_options_echo(&icmp_param->replyopts, skb))
                 return;
@@ -430,14 +430,14 @@ out_unlock:
  *                      MUST reply to only the first fragment.
  */
 
-void icmp_send(struct sk_buff *skb_in, int type, int code, u32 info)
+void icmp_send(struct sk_buff *skb_in, int type, int code, __be32 info)
 {
         struct iphdr *iph;
         int room;
         struct icmp_bxm icmp_param;
         struct rtable *rt = (struct rtable *)skb_in->dst;
         struct ipcm_cookie ipc;
-        u32 saddr;
+        __be32 saddr;
         u8  tos;
 
         if (!rt)
@@ -895,7 +895,7 @@ static void icmp_address_reply(struct sk_buff *skb)
         if (in_dev->ifa_list &&
             IN_DEV_LOG_MARTIANS(in_dev) &&
             IN_DEV_FORWARD(in_dev)) {
-                u32 _mask, *mp;
+                __be32 _mask, *mp;
 
                 mp = skb_header_pointer(skb, 0, sizeof(_mask), &_mask);
                 BUG_ON(mp == NULL);
diff --git a/net/ipv4/igmp.c b/net/ipv4/igmp.c
index 58be8227b0cb..6eee71647b7c 100644
--- a/net/ipv4/igmp.c
+++ b/net/ipv4/igmp.c
@@ -138,14 +138,14 @@
                 time_before(jiffies, (in_dev)->mr_v2_seen)))
 
 static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im);
-static void igmpv3_del_delrec(struct in_device *in_dev, __u32 multiaddr);
+static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr);
 static void igmpv3_clear_delrec(struct in_device *in_dev);
 static int sf_setstate(struct ip_mc_list *pmc);
 static void sf_markstate(struct ip_mc_list *pmc);
 #endif
 static void ip_mc_clear_src(struct ip_mc_list *pmc);
-static int ip_mc_add_src(struct in_device *in_dev, __u32 *pmca, int sfmode,
-                         int sfcount, __u32 *psfsrc, int delta);
+static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
+                         int sfcount, __be32 *psfsrc, int delta);
 
 static void ip_ma_put(struct ip_mc_list *im)
 {
@@ -426,7 +426,7 @@ static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc,
         first = 1;
         psf_prev = NULL;
         for (psf=*psf_list; psf; psf=psf_next) {
-                u32 *psrc;
+                __be32 *psrc;
 
                 psf_next = psf->sf_next;
 
@@ -439,7 +439,7 @@ static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc,
                 if (isquery)
                         psf->sf_gsresp = 0;
 
-                if (AVAILABLE(skb) < sizeof(u32) +
+                if (AVAILABLE(skb) < sizeof(__be32) +
                     first*sizeof(struct igmpv3_grec)) {
                         if (truncate && !first)
                                 break;   /* truncate these */
@@ -455,7 +455,7 @@ static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc,
                         skb = add_grhead(skb, pmc, type, &pgr);
                         first = 0;
                 }
-                psrc = (u32 *)skb_put(skb, sizeof(u32));
+                psrc = (__be32 *)skb_put(skb, sizeof(__be32));
                 *psrc = psf->sf_inaddr;
                 scount++; stotal++;
                 if ((type == IGMPV3_ALLOW_NEW_SOURCES ||
@@ -630,8 +630,8 @@ static int igmp_send_report(struct in_device *in_dev, struct ip_mc_list *pmc,
         struct igmphdr *ih;
         struct rtable *rt;
         struct net_device *dev = in_dev->dev;
-        u32     group = pmc ? pmc->multiaddr : 0;
-        u32     dst;
+        __be32  group = pmc ? pmc->multiaddr : 0;
+        __be32  dst;
 
         if (type == IGMPV3_HOST_MEMBERSHIP_REPORT)
                 return igmpv3_send_report(in_dev, pmc);
@@ -748,7 +748,7 @@ static void igmp_timer_expire(unsigned long data)
 }
 
 /* mark EXCLUDE-mode sources */
-static int igmp_xmarksources(struct ip_mc_list *pmc, int nsrcs, __u32 *srcs)
+static int igmp_xmarksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs)
 {
         struct ip_sf_list *psf;
         int i, scount;
@@ -775,7 +775,7 @@ static int igmp_xmarksources(struct ip_mc_list *pmc, int nsrcs, __u32 *srcs)
         return 1;
 }
 
-static int igmp_marksources(struct ip_mc_list *pmc, int nsrcs, __u32 *srcs)
+static int igmp_marksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs)
 {
         struct ip_sf_list *psf;
         int i, scount;
@@ -803,7 +803,7 @@ static int igmp_marksources(struct ip_mc_list *pmc, int nsrcs, __u32 *srcs)
         return 1;
 }
 
-static void igmp_heard_report(struct in_device *in_dev, u32 group)
+static void igmp_heard_report(struct in_device *in_dev, __be32 group)
 {
         struct ip_mc_list *im;
 
@@ -828,7 +828,7 @@ static void igmp_heard_query(struct in_device *in_dev, struct sk_buff *skb,
         struct igmphdr          *ih = skb->h.igmph;
         struct igmpv3_query *ih3 = (struct igmpv3_query *)ih;
         struct ip_mc_list       *im;
-        u32                     group = ih->group;
+        __be32                  group = ih->group;
         int                     max_delay;
         int                     mark = 0;
 
@@ -862,7 +862,7 @@ static void igmp_heard_query(struct in_device *in_dev, struct sk_buff *skb,
                 ih3 = (struct igmpv3_query *) skb->h.raw;
                 if (ih3->nsrcs) {
                         if (!pskb_may_pull(skb, sizeof(struct igmpv3_query) 
-                                           + ntohs(ih3->nsrcs)*sizeof(__u32)))
+                                           + ntohs(ih3->nsrcs)*sizeof(__be32)))
                                 return;
                         ih3 = (struct igmpv3_query *) skb->h.raw;
                 }
@@ -985,7 +985,7 @@ drop:
  *      Add a filter to a device
  */
 
-static void ip_mc_filter_add(struct in_device *in_dev, u32 addr)
+static void ip_mc_filter_add(struct in_device *in_dev, __be32 addr)
 {
         char buf[MAX_ADDR_LEN];
         struct net_device *dev = in_dev->dev;
@@ -1005,7 +1005,7 @@ static void ip_mc_filter_add(struct in_device *in_dev, u32 addr)
  *      Remove a filter from a device
  */
 
-static void ip_mc_filter_del(struct in_device *in_dev, u32 addr)
+static void ip_mc_filter_del(struct in_device *in_dev, __be32 addr)
 {
         char buf[MAX_ADDR_LEN];
         struct net_device *dev = in_dev->dev;
@@ -1055,7 +1055,7 @@ static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im)
         spin_unlock_bh(&in_dev->mc_tomb_lock);
 }
 
-static void igmpv3_del_delrec(struct in_device *in_dev, __u32 multiaddr)
+static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr)
 {
         struct ip_mc_list *pmc, *pmc_prev;
         struct ip_sf_list *psf, *psf_next;
@@ -1193,7 +1193,7 @@ static void igmp_group_added(struct ip_mc_list *im)
  *      A socket has joined a multicast group on device dev.
  */
 
-void ip_mc_inc_group(struct in_device *in_dev, u32 addr)
+void ip_mc_inc_group(struct in_device *in_dev, __be32 addr)
 {
         struct ip_mc_list *im;
 
@@ -1252,7 +1252,7 @@ out:
  *      A socket has left a multicast group on device dev
  */
 
-void ip_mc_dec_group(struct in_device *in_dev, u32 addr)
+void ip_mc_dec_group(struct in_device *in_dev, __be32 addr)
 {
         struct ip_mc_list *i, **ip;
         
@@ -1402,7 +1402,7 @@ int sysctl_igmp_max_msf __read_mostly = IP_MAX_MSF;
 
 
 static int ip_mc_del1_src(struct ip_mc_list *pmc, int sfmode,
-        __u32 *psfsrc)
+        __be32 *psfsrc)
 {
         struct ip_sf_list *psf, *psf_prev;
         int rv = 0;
@@ -1450,8 +1450,8 @@ static int ip_mc_del1_src(struct ip_mc_list *pmc, int sfmode,
 #define igmp_ifc_event(x)       do { } while (0)
 #endif
 
-static int ip_mc_del_src(struct in_device *in_dev, __u32 *pmca, int sfmode,
-                         int sfcount, __u32 *psfsrc, int delta)
+static int ip_mc_del_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
+                         int sfcount, __be32 *psfsrc, int delta)
 {
         struct ip_mc_list *pmc;
         int     changerec = 0;
@@ -1517,7 +1517,7 @@ out_unlock:
  * Add multicast single-source filter to the interface list
  */
 static int ip_mc_add1_src(struct ip_mc_list *pmc, int sfmode,
-        __u32 *psfsrc, int delta)
+        __be32 *psfsrc, int delta)
 {
         struct ip_sf_list *psf, *psf_prev;
 
@@ -1623,8 +1623,8 @@ static int sf_setstate(struct ip_mc_list *pmc)
 /*
  * Add multicast source filter list to the interface list
  */
-static int ip_mc_add_src(struct in_device *in_dev, __u32 *pmca, int sfmode,
-                         int sfcount, __u32 *psfsrc, int delta)
+static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
+                         int sfcount, __be32 *psfsrc, int delta)
 {
         struct ip_mc_list *pmc;
         int     isexclude;
@@ -1717,7 +1717,7 @@ static void ip_mc_clear_src(struct ip_mc_list *pmc)
 int ip_mc_join_group(struct sock *sk , struct ip_mreqn *imr)
 {
         int err;
-        u32 addr = imr->imr_multiaddr.s_addr;
+        __be32 addr = imr->imr_multiaddr.s_addr;
         struct ip_mc_socklist *iml=NULL, *i;
         struct in_device *in_dev;
         struct inet_sock *inet = inet_sk(sk);
@@ -1791,7 +1791,7 @@ int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr)
         struct inet_sock *inet = inet_sk(sk);
         struct ip_mc_socklist *iml, **imlp;
         struct in_device *in_dev;
-        u32 group = imr->imr_multiaddr.s_addr;
+        __be32 group = imr->imr_multiaddr.s_addr;
         u32 ifindex;
         int ret = -EADDRNOTAVAIL;
 
@@ -1829,7 +1829,7 @@ int ip_mc_source(int add, int omode, struct sock *sk, struct
 {
         int err;
         struct ip_mreqn imr;
-        u32 addr = mreqs->imr_multiaddr;
+        __be32 addr = mreqs->imr_multiaddr;
         struct ip_mc_socklist *pmc;
         struct in_device *in_dev = NULL;
         struct inet_sock *inet = inet_sk(sk);
@@ -1883,7 +1883,7 @@ int ip_mc_source(int add, int omode, struct sock *sk, struct
                 rv = !0;
                 for (i=0; i<psl->sl_count; i++) {
                         rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr,
-                                sizeof(__u32));
+                                sizeof(__be32));
                         if (rv == 0)
                                 break;
                 }
@@ -1935,7 +1935,7 @@ int ip_mc_source(int add, int omode, struct sock *sk, struct
         rv = 1; /* > 0 for insert logic below if sl_count is 0 */
         for (i=0; i<psl->sl_count; i++) {
                 rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr,
-                        sizeof(__u32));
+                        sizeof(__be32));
                 if (rv == 0)
                         break;
         }
@@ -1960,7 +1960,7 @@ int ip_mc_msfilter(struct sock *sk, struct ip_msfilter *msf, int ifindex)
 {
         int err = 0;
         struct ip_mreqn imr;
-        u32 addr = msf->imsf_multiaddr;
+        __be32 addr = msf->imsf_multiaddr;
         struct ip_mc_socklist *pmc;
         struct in_device *in_dev;
         struct inet_sock *inet = inet_sk(sk);
@@ -2044,7 +2044,7 @@ int ip_mc_msfget(struct sock *sk, struct ip_msfilter *msf,
 {
         int err, len, count, copycount;
         struct ip_mreqn imr;
-        u32 addr = msf->imsf_multiaddr;
+        __be32 addr = msf->imsf_multiaddr;
         struct ip_mc_socklist *pmc;
         struct in_device *in_dev;
         struct inet_sock *inet = inet_sk(sk);
@@ -2103,7 +2103,7 @@ int ip_mc_gsfget(struct sock *sk, struct group_filter *gsf,
 {
         int err, i, count, copycount;
         struct sockaddr_in *psin;
-        u32 addr;
+        __be32 addr;
         struct ip_mc_socklist *pmc;
         struct inet_sock *inet = inet_sk(sk);
         struct ip_sf_socklist *psl;
@@ -2156,7 +2156,7 @@ done:
 /*
  * check if a multicast source filter allows delivery for a given <src,dst,intf>
  */
-int ip_mc_sf_allow(struct sock *sk, u32 loc_addr, u32 rmt_addr, int dif)
+int ip_mc_sf_allow(struct sock *sk, __be32 loc_addr, __be32 rmt_addr, int dif)
 {
         struct inet_sock *inet = inet_sk(sk);
         struct ip_mc_socklist *pmc;
@@ -2216,7 +2216,7 @@ void ip_mc_drop_socket(struct sock *sk)
         rtnl_unlock();
 }
 
-int ip_check_mc(struct in_device *in_dev, u32 mc_addr, u32 src_addr, u16 proto)
+int ip_check_mc(struct in_device *in_dev, __be32 mc_addr, __be32 src_addr, u16 proto)
 {
         struct ip_mc_list *im;
         struct ip_sf_list *psf;
diff --git a/net/ipv4/inet_connection_sock.c b/net/ipv4/inet_connection_sock.c
index 07204391d083..96bbe2a0aa1b 100644
--- a/net/ipv4/inet_connection_sock.c
+++ b/net/ipv4/inet_connection_sock.c
@@ -39,7 +39,7 @@ int sysctl_local_port_range[2] = { 1024, 4999 };
 int inet_csk_bind_conflict(const struct sock *sk,
                            const struct inet_bind_bucket *tb)
 {
-        const u32 sk_rcv_saddr = inet_rcv_saddr(sk);
+        const __be32 sk_rcv_saddr = inet_rcv_saddr(sk);
         struct sock *sk2;
         struct hlist_node *node;
         int reuse = sk->sk_reuse;
@@ -52,7 +52,7 @@ int inet_csk_bind_conflict(const struct sock *sk,
                      sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) {
                         if (!reuse || !sk2->sk_reuse ||
                             sk2->sk_state == TCP_LISTEN) {
-                                const u32 sk2_rcv_saddr = inet_rcv_saddr(sk2);
+                                const __be32 sk2_rcv_saddr = inet_rcv_saddr(sk2);
                                 if (!sk2_rcv_saddr || !sk_rcv_saddr ||
                                     sk2_rcv_saddr == sk_rcv_saddr)
                                         break;
@@ -342,10 +342,10 @@ struct dst_entry* inet_csk_route_req(struct sock *sk,
 
 EXPORT_SYMBOL_GPL(inet_csk_route_req);
 
-static inline u32 inet_synq_hash(const u32 raddr, const u16 rport,
+static inline u32 inet_synq_hash(const __be32 raddr, const __be16 rport,
                                  const u32 rnd, const u16 synq_hsize)
 {
-        return jhash_2words(raddr, (u32)rport, rnd) & (synq_hsize - 1);
+        return jhash_2words((__force u32)raddr, (__force u32)rport, rnd) & (synq_hsize - 1);
 }
 
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
@@ -356,8 +356,8 @@ static inline u32 inet_synq_hash(const u32 raddr, const u16 rport,
 
 struct request_sock *inet_csk_search_req(const struct sock *sk,
                                          struct request_sock ***prevp,
-                                         const __u16 rport, const __u32 raddr,
-                                         const __u32 laddr)
+                                         const __be16 rport, const __be32 raddr,
+                                         const __be32 laddr)
 {
         const struct inet_connection_sock *icsk = inet_csk(sk);
         struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt;
diff --git a/net/ipv4/inet_diag.c b/net/ipv4/inet_diag.c
index 492858e6faf0..77761ac4f7bb 100644
--- a/net/ipv4/inet_diag.c
+++ b/net/ipv4/inet_diag.c
@@ -36,8 +36,8 @@
 static const struct inet_diag_handler **inet_diag_table;
 
 struct inet_diag_entry {
-        u32 *saddr;
-        u32 *daddr;
+        __be32 *saddr;
+        __be32 *daddr;
         u16 sport;
         u16 dport;
         u16 family;
@@ -294,7 +294,7 @@ out:
         return err;
 }
 
-static int bitstring_match(const u32 *a1, const u32 *a2, int bits)
+static int bitstring_match(const __be32 *a1, const __be32 *a2, int bits)
 {
         int words = bits >> 5;
 
@@ -305,8 +305,8 @@ static int bitstring_match(const u32 *a1, const u32 *a2, int bits)
                         return 0;
         }
         if (bits) {
-                __u32 w1, w2;
-                __u32 mask;
+                __be32 w1, w2;
+                __be32 mask;
 
                 w1 = a1[words];
                 w2 = a2[words];
@@ -352,7 +352,7 @@ static int inet_diag_bc_run(const void *bc, int len,
                 case INET_DIAG_BC_S_COND:
                 case INET_DIAG_BC_D_COND: {
                         struct inet_diag_hostcond *cond;
-                        u32 *addr;
+                        __be32 *addr;
 
                         cond = (struct inet_diag_hostcond *)(op + 1);
                         if (cond->port != -1 &&
diff --git a/net/ipv4/inet_hashtables.c b/net/ipv4/inet_hashtables.c
index fb296c9a7f3f..244c4f445c7d 100644
--- a/net/ipv4/inet_hashtables.c
+++ b/net/ipv4/inet_hashtables.c
@@ -125,7 +125,7 @@ EXPORT_SYMBOL(inet_listen_wlock);
  * wildcarded during the search since they can never be otherwise.
  */
 static struct sock *inet_lookup_listener_slow(const struct hlist_head *head,
-                                              const u32 daddr,
+                                              const __be32 daddr,
                                               const unsigned short hnum,
                                               const int dif)
 {
@@ -137,7 +137,7 @@ static struct sock *inet_lookup_listener_slow(const struct hlist_head *head,
                 const struct inet_sock *inet = inet_sk(sk);
 
                 if (inet->num == hnum && !ipv6_only_sock(sk)) {
-                        const __u32 rcv_saddr = inet->rcv_saddr;
+                        const __be32 rcv_saddr = inet->rcv_saddr;
                         int score = sk->sk_family == PF_INET ? 1 : 0;
 
                         if (rcv_saddr) {
@@ -163,7 +163,7 @@ static struct sock *inet_lookup_listener_slow(const struct hlist_head *head,
 
 /* Optimize the common listener case. */
 struct sock *__inet_lookup_listener(struct inet_hashinfo *hashinfo,
-                                    const u32 daddr, const unsigned short hnum,
+                                    const __be32 daddr, const unsigned short hnum,
                                     const int dif)
 {
         struct sock *sk = NULL;
@@ -197,11 +197,11 @@ static int __inet_check_established(struct inet_timewait_death_row *death_row,
 {
         struct inet_hashinfo *hinfo = death_row->hashinfo;
         struct inet_sock *inet = inet_sk(sk);
-        u32 daddr = inet->rcv_saddr;
-        u32 saddr = inet->daddr;
+        __be32 daddr = inet->rcv_saddr;
+        __be32 saddr = inet->daddr;
         int dif = sk->sk_bound_dev_if;
         INET_ADDR_COOKIE(acookie, saddr, daddr)
-        const __u32 ports = INET_COMBINED_PORTS(inet->dport, lport);
+        const __portpair ports = INET_COMBINED_PORTS(inet->dport, lport);
         unsigned int hash = inet_ehashfn(daddr, lport, saddr, inet->dport);
         struct inet_ehash_bucket *head = inet_ehash_bucket(hinfo, hash);
         struct sock *sk2;
diff --git a/net/ipv4/inetpeer.c b/net/ipv4/inetpeer.c
index a675602ef295..2b1a54b59c48 100644
--- a/net/ipv4/inetpeer.c
+++ b/net/ipv4/inetpeer.c
@@ -163,7 +163,7 @@ static void unlink_from_unused(struct inet_peer *p)
         for (u = peer_root; u != peer_avl_empty; ) {            \
                 if (daddr == u->v4daddr)                        \
                         break;                                  \
-                if (daddr < u->v4daddr)                         \
+                if ((__force __u32)daddr < (__force __u32)u->v4daddr)   \
                         v = &u->avl_left;                       \
                 else                                            \
                         v = &u->avl_right;                      \
@@ -368,7 +368,7 @@ static int cleanup_once(unsigned long ttl)
 }
 
 /* Called with or without local BH being disabled. */
-struct inet_peer *inet_getpeer(__u32 daddr, int create)
+struct inet_peer *inet_getpeer(__be32 daddr, int create)
 {
         struct inet_peer *p, *n;
         struct inet_peer **stack[PEER_MAXDEPTH], ***stackptr;
diff --git a/net/ipv4/ip_fragment.c b/net/ipv4/ip_fragment.c
index 165d72859ddf..74046efdf875 100644
--- a/net/ipv4/ip_fragment.c
+++ b/net/ipv4/ip_fragment.c
@@ -77,9 +77,9 @@ struct ipq {
         struct hlist_node list;
         struct list_head lru_list;      /* lru list member                      */
         u32             user;
-        u32             saddr;
-        u32             daddr;
-        u16             id;
+        __be32          saddr;
+        __be32          daddr;
+        __be16          id;
         u8              protocol;
         u8              last_in;
 #define COMPLETE                4
@@ -123,9 +123,10 @@ static __inline__ void ipq_unlink(struct ipq *ipq)
         write_unlock(&ipfrag_lock);
 }
 
-static unsigned int ipqhashfn(u16 id, u32 saddr, u32 daddr, u8 prot)
+static unsigned int ipqhashfn(__be16 id, __be32 saddr, __be32 daddr, u8 prot)
 {
-        return jhash_3words((u32)id << 16 | prot, saddr, daddr,
+        return jhash_3words((__force u32)id << 16 | prot,
+                            (__force u32)saddr, (__force u32)daddr,
                             ipfrag_hash_rnd) & (IPQ_HASHSZ - 1);
 }
 
@@ -387,8 +388,8 @@ out_nomem:
 static inline struct ipq *ip_find(struct iphdr *iph, u32 user)
 {
         __be16 id = iph->id;
-        __u32 saddr = iph->saddr;
-        __u32 daddr = iph->daddr;
+        __be32 saddr = iph->saddr;
+        __be32 daddr = iph->daddr;
         __u8 protocol = iph->protocol;
         unsigned int hash;
         struct ipq *qp;
diff --git a/net/ipv4/ip_options.c b/net/ipv4/ip_options.c
index e7437c091326..8dabbfc31267 100644
--- a/net/ipv4/ip_options.c
+++ b/net/ipv4/ip_options.c
@@ -38,7 +38,7 @@
  */
 
 void ip_options_build(struct sk_buff * skb, struct ip_options * opt,
-                            u32 daddr, struct rtable *rt, int is_frag) 
+                            __be32 daddr, struct rtable *rt, int is_frag)
 {
         unsigned char * iph = skb->nh.raw;
 
@@ -57,7 +57,7 @@ void ip_options_build(struct sk_buff * skb, struct ip_options * opt,
                         ip_rt_get_source(iph+opt->ts+iph[opt->ts+2]-9, rt);
                 if (opt->ts_needtime) {
                         struct timeval tv;
-                        __u32 midtime;
+                        __be32 midtime;
                         do_gettimeofday(&tv);
                         midtime = htonl((tv.tv_sec % 86400) * 1000 + tv.tv_usec / 1000);
                         memcpy(iph+opt->ts+iph[opt->ts+2]-5, &midtime, 4);
@@ -91,7 +91,7 @@ int ip_options_echo(struct ip_options * dopt, struct sk_buff * skb)
         unsigned char *sptr, *dptr;
         int soffset, doffset;
         int     optlen;
-        u32     daddr;
+        __be32  daddr;
 
         memset(dopt, 0, sizeof(struct ip_options));
 
@@ -148,7 +148,7 @@ int ip_options_echo(struct ip_options * dopt, struct sk_buff * skb)
                                         dopt->ts_needtime = 0;
 
                                         if (soffset + 8 <= optlen) {
-                                                __u32 addr;
+                                                __be32 addr;
 
                                                 memcpy(&addr, sptr+soffset-1, 4);
                                                 if (inet_addr_type(addr) != RTN_LOCAL) {
@@ -165,7 +165,7 @@ int ip_options_echo(struct ip_options * dopt, struct sk_buff * skb)
         }
         if (sopt->srr) {
                 unsigned char * start = sptr+sopt->srr;
-                u32 faddr;
+                __be32 faddr;
 
                 optlen  = start[1];
                 soffset = start[2];
@@ -362,7 +362,7 @@ int ip_options_compile(struct ip_options * opt, struct sk_buff * skb)
                                 goto error;
                         }
                         if (optptr[2] <= optlen) {
-                                __u32 * timeptr = NULL;
+                                __be32 *timeptr = NULL;
                                 if (optptr[2]+3 > optptr[1]) {
                                         pp_ptr = optptr + 2;
                                         goto error;
@@ -371,7 +371,7 @@ int ip_options_compile(struct ip_options * opt, struct sk_buff * skb)
                                       case IPOPT_TS_TSONLY:
                                         opt->ts = optptr - iph;
                                         if (skb) 
-                                                timeptr = (__u32*)&optptr[optptr[2]-1];
+                                                timeptr = (__be32*)&optptr[optptr[2]-1];
                                         opt->ts_needtime = 1;
                                         optptr[2] += 4;
                                         break;
@@ -383,7 +383,7 @@ int ip_options_compile(struct ip_options * opt, struct sk_buff * skb)
                                         opt->ts = optptr - iph;
                                         if (skb) {
                                                 memcpy(&optptr[optptr[2]-1], &rt->rt_spec_dst, 4);
-                                                timeptr = (__u32*)&optptr[optptr[2]+3];
+                                                timeptr = (__be32*)&optptr[optptr[2]+3];
                                         }
                                         opt->ts_needaddr = 1;
                                         opt->ts_needtime = 1;
@@ -396,12 +396,12 @@ int ip_options_compile(struct ip_options * opt, struct sk_buff * skb)
                                         }
                                         opt->ts = optptr - iph;
                                         {
-                                                u32 addr;
+                                                __be32 addr;
                                                 memcpy(&addr, &optptr[optptr[2]-1], 4);
                                                 if (inet_addr_type(addr) == RTN_UNICAST)
                                                         break;
                                                 if (skb)
-                                                        timeptr = (__u32*)&optptr[optptr[2]+3];
+                                                        timeptr = (__be32*)&optptr[optptr[2]+3];
                                         }
                                         opt->ts_needtime = 1;
                                         optptr[2] += 8;
@@ -415,10 +415,10 @@ int ip_options_compile(struct ip_options * opt, struct sk_buff * skb)
                                 }
                                 if (timeptr) {
                                         struct timeval tv;
-                                        __u32  midtime;
+                                        __be32  midtime;
                                         do_gettimeofday(&tv);
                                         midtime = htonl((tv.tv_sec % 86400) * 1000 + tv.tv_usec / 1000);
-                                        memcpy(timeptr, &midtime, sizeof(__u32));
+                                        memcpy(timeptr, &midtime, sizeof(__be32));
                                         opt->is_changed = 1;
                                 }
                         } else {
@@ -607,7 +607,7 @@ int ip_options_rcv_srr(struct sk_buff *skb)
 {
         struct ip_options *opt = &(IPCB(skb)->opt);
         int srrspace, srrptr;
-        u32 nexthop;
+        __be32 nexthop;
         struct iphdr *iph = skb->nh.iph;
         unsigned char * optptr = skb->nh.raw + opt->srr;
         struct rtable *rt = (struct rtable*)skb->dst;
diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c
index 97aee76fb746..fc195a44fc2e 100644
--- a/net/ipv4/ip_output.c
+++ b/net/ipv4/ip_output.c
@@ -118,7 +118,7 @@ static inline int ip_select_ttl(struct inet_sock *inet, struct dst_entry *dst)
  *
  */
 int ip_build_and_send_pkt(struct sk_buff *skb, struct sock *sk,
-                          u32 saddr, u32 daddr, struct ip_options *opt)
+                          __be32 saddr, __be32 daddr, struct ip_options *opt)
 {
         struct inet_sock *inet = inet_sk(sk);
         struct rtable *rt = (struct rtable *)skb->dst;
@@ -306,7 +306,7 @@ int ip_queue_xmit(struct sk_buff *skb, int ipfragok)
         /* Make sure we can route this packet. */
         rt = (struct rtable *)__sk_dst_check(sk, 0);
         if (rt == NULL) {
-                u32 daddr;
+                __be32 daddr;
 
                 /* Use correct destination address if we have options. */
                 daddr = inet->daddr;
@@ -1340,7 +1340,7 @@ void ip_send_reply(struct sock *sk, struct sk_buff *skb, struct ip_reply_arg *ar
                 char                    data[40];
         } replyopts;
         struct ipcm_cookie ipc;
-        u32 daddr;
+        __be32 daddr;
         struct rtable *rt = (struct rtable*)skb->dst;
 
         if (ip_options_echo(&replyopts.opt, skb))
diff --git a/net/ipv4/ip_sockglue.c b/net/ipv4/ip_sockglue.c
index 2d05c4133d3e..4b132953bcc2 100644
--- a/net/ipv4/ip_sockglue.c
+++ b/net/ipv4/ip_sockglue.c
@@ -254,7 +254,7 @@ int ip_ra_control(struct sock *sk, unsigned char on, void (*destructor)(struct s
 }
 
 void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err, 
-                   u16 port, u32 info, u8 *payload)
+                   __be16 port, u32 info, u8 *payload)
 {
         struct inet_sock *inet = inet_sk(sk);
         struct sock_exterr_skb *serr;
@@ -283,7 +283,7 @@ void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
                 kfree_skb(skb);
 }
 
-void ip_local_error(struct sock *sk, int err, u32 daddr, u16 port, u32 info)
+void ip_local_error(struct sock *sk, int err, __be32 daddr, __be16 port, u32 info)
 {
         struct inet_sock *inet = inet_sk(sk);
         struct sock_exterr_skb *serr;
diff --git a/net/ipv4/ipcomp.c b/net/ipv4/ipcomp.c
index 17342430a843..2017d36024d4 100644
--- a/net/ipv4/ipcomp.c
+++ b/net/ipv4/ipcomp.c
@@ -183,7 +183,7 @@ out_ok:
 
 static void ipcomp4_err(struct sk_buff *skb, u32 info)
 {
-        u32 spi;
+        __be32 spi;
         struct iphdr *iph = (struct iphdr *)skb->data;
         struct ip_comp_hdr *ipch = (struct ip_comp_hdr *)(skb->data+(iph->ihl<<2));
         struct xfrm_state *x;
diff --git a/net/ipv4/ipmr.c b/net/ipv4/ipmr.c
index ba49588da242..97cfa97c8abb 100644
--- a/net/ipv4/ipmr.c
+++ b/net/ipv4/ipmr.c
@@ -462,7 +462,7 @@ static int vif_add(struct vifctl *vifc, int mrtsock)
         return 0;
 }
 
-static struct mfc_cache *ipmr_cache_find(__u32 origin, __u32 mcastgrp)
+static struct mfc_cache *ipmr_cache_find(__be32 origin, __be32 mcastgrp)
 {
         int line=MFC_HASH(mcastgrp,origin);
         struct mfc_cache *c;
@@ -1097,7 +1097,7 @@ static struct notifier_block ip_mr_notifier={
  *      important for multicast video.
  */
  
-static void ip_encap(struct sk_buff *skb, u32 saddr, u32 daddr)
+static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
 {
         struct iphdr *iph = (struct iphdr *)skb_push(skb,sizeof(struct iphdr));
 
diff --git a/net/ipv4/ipvs/ip_vs_conn.c b/net/ipv4/ipvs/ip_vs_conn.c
index 87b83813cf2c..8832eb517d52 100644
--- a/net/ipv4/ipvs/ip_vs_conn.c
+++ b/net/ipv4/ipvs/ip_vs_conn.c
@@ -115,9 +115,9 @@ static inline void ct_write_unlock_bh(unsigned key)
 /*
  *      Returns hash value for IPVS connection entry
  */
-static unsigned int ip_vs_conn_hashkey(unsigned proto, __u32 addr, __u16 port)
+static unsigned int ip_vs_conn_hashkey(unsigned proto, __be32 addr, __be16 port)
 {
-        return jhash_3words(addr, port, proto, ip_vs_conn_rnd)
+        return jhash_3words((__force u32)addr, (__force u32)port, proto, ip_vs_conn_rnd)
                 & IP_VS_CONN_TAB_MASK;
 }
 
@@ -188,7 +188,7 @@ static inline int ip_vs_conn_unhash(struct ip_vs_conn *cp)
  *      d_addr, d_port: pkt dest address (load balancer)
  */
 static inline struct ip_vs_conn *__ip_vs_conn_in_get
-(int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port)
+(int protocol, __be32 s_addr, __be16 s_port, __be32 d_addr, __be16 d_port)
 {
         unsigned hash;
         struct ip_vs_conn *cp;
@@ -215,7 +215,7 @@ static inline struct ip_vs_conn *__ip_vs_conn_in_get
 }
 
 struct ip_vs_conn *ip_vs_conn_in_get
-(int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port)
+(int protocol, __be32 s_addr, __be16 s_port, __be32 d_addr, __be16 d_port)
 {
         struct ip_vs_conn *cp;
 
@@ -234,7 +234,7 @@ struct ip_vs_conn *ip_vs_conn_in_get
 
 /* Get reference to connection template */
 struct ip_vs_conn *ip_vs_ct_in_get
-(int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port)
+(int protocol, __be32 s_addr, __be16 s_port, __be32 d_addr, __be16 d_port)
 {
         unsigned hash;
         struct ip_vs_conn *cp;
@@ -274,7 +274,7 @@ struct ip_vs_conn *ip_vs_ct_in_get
  *      d_addr, d_port: pkt dest address (foreign host)
  */
 struct ip_vs_conn *ip_vs_conn_out_get
-(int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port)
+(int protocol, __be32 s_addr, __be16 s_port, __be32 d_addr, __be16 d_port)
 {
         unsigned hash;
         struct ip_vs_conn *cp, *ret=NULL;
@@ -324,7 +324,7 @@ void ip_vs_conn_put(struct ip_vs_conn *cp)
 /*
  *      Fill a no_client_port connection with a client port number
  */
-void ip_vs_conn_fill_cport(struct ip_vs_conn *cp, __u16 cport)
+void ip_vs_conn_fill_cport(struct ip_vs_conn *cp, __be16 cport)
 {
         if (ip_vs_conn_unhash(cp)) {
                 spin_lock(&cp->lock);
@@ -508,10 +508,10 @@ int ip_vs_check_template(struct ip_vs_conn *ct)
                 /*
                  * Invalidate the connection template
                  */
-                if (ct->vport != 65535) {
+                if (ct->vport != htons(0xffff)) {
                         if (ip_vs_conn_unhash(ct)) {
-                                ct->dport = 65535;
-                                ct->vport = 65535;
+                                ct->dport = htons(0xffff);
+                                ct->vport = htons(0xffff);
                                 ct->cport = 0;
                                 ip_vs_conn_hash(ct);
                         }
@@ -596,8 +596,8 @@ void ip_vs_conn_expire_now(struct ip_vs_conn *cp)
  *      Create a new connection entry and hash it into the ip_vs_conn_tab
  */
 struct ip_vs_conn *
-ip_vs_conn_new(int proto, __u32 caddr, __u16 cport, __u32 vaddr, __u16 vport,
-               __u32 daddr, __u16 dport, unsigned flags,
+ip_vs_conn_new(int proto, __be32 caddr, __be16 cport, __be32 vaddr, __be16 vport,
+               __be32 daddr, __be16 dport, unsigned flags,
                struct ip_vs_dest *dest)
 {
         struct ip_vs_conn *cp;
diff --git a/net/ipv4/ipvs/ip_vs_core.c b/net/ipv4/ipvs/ip_vs_core.c
index 3f47ad8e1cad..6dee03935f78 100644
--- a/net/ipv4/ipvs/ip_vs_core.c
+++ b/net/ipv4/ipvs/ip_vs_core.c
@@ -209,14 +209,14 @@ int ip_vs_make_skb_writable(struct sk_buff **pskb, int writable_len)
 static struct ip_vs_conn *
 ip_vs_sched_persist(struct ip_vs_service *svc,
                     const struct sk_buff *skb,
-                    __u16 ports[2])
+                    __be16 ports[2])
 {
         struct ip_vs_conn *cp = NULL;
         struct iphdr *iph = skb->nh.iph;
         struct ip_vs_dest *dest;
         struct ip_vs_conn *ct;
-        __u16  dport;    /* destination port to forward */
-        __u32  snet;     /* source network of the client, after masking */
+        __be16  dport;   /* destination port to forward */
+        __be32  snet;    /* source network of the client, after masking */
 
         /* Mask saddr with the netmask to adjust template granularity */
         snet = iph->saddr & svc->netmask;
@@ -383,7 +383,7 @@ ip_vs_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)
         struct ip_vs_conn *cp = NULL;
         struct iphdr *iph = skb->nh.iph;
         struct ip_vs_dest *dest;
-        __u16 _ports[2], *pptr;
+        __be16 _ports[2], *pptr;
 
         pptr = skb_header_pointer(skb, iph->ihl*4,
                                   sizeof(_ports), _ports);
@@ -446,7 +446,7 @@ ip_vs_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)
 int ip_vs_leave(struct ip_vs_service *svc, struct sk_buff *skb,
                 struct ip_vs_protocol *pp)
 {
-        __u16 _ports[2], *pptr;
+        __be16 _ports[2], *pptr;
         struct iphdr *iph = skb->nh.iph;
 
         pptr = skb_header_pointer(skb, iph->ihl*4,
@@ -576,7 +576,7 @@ void ip_vs_nat_icmp(struct sk_buff *skb, struct ip_vs_protocol *pp,
 
         /* the TCP/UDP port */
         if (IPPROTO_TCP == ciph->protocol || IPPROTO_UDP == ciph->protocol) {
-                __u16 *ports = (void *)ciph + ciph->ihl*4;
+                __be16 *ports = (void *)ciph + ciph->ihl*4;
 
                 if (inout)
                         ports[1] = cp->vport;
@@ -775,7 +775,7 @@ ip_vs_out(unsigned int hooknum, struct sk_buff **pskb,
                 if (sysctl_ip_vs_nat_icmp_send &&
                     (pp->protocol == IPPROTO_TCP ||
                      pp->protocol == IPPROTO_UDP)) {
-                        __u16 _ports[2], *pptr;
+                        __be16 _ports[2], *pptr;
 
                         pptr = skb_header_pointer(skb, ihl,
                                                   sizeof(_ports), _ports);
diff --git a/net/ipv4/ipvs/ip_vs_ctl.c b/net/ipv4/ipvs/ip_vs_ctl.c
index 6a28fafe910c..f261616e4602 100644
--- a/net/ipv4/ipvs/ip_vs_ctl.c
+++ b/net/ipv4/ipvs/ip_vs_ctl.c
@@ -283,7 +283,7 @@ static atomic_t ip_vs_nullsvc_counter = ATOMIC_INIT(0);
  *      Returns hash value for virtual service
  */
 static __inline__ unsigned
-ip_vs_svc_hashkey(unsigned proto, __u32 addr, __u16 port)
+ip_vs_svc_hashkey(unsigned proto, __be32 addr, __be16 port)
 {
         register unsigned porth = ntohs(port);
 
@@ -365,7 +365,7 @@ static int ip_vs_svc_unhash(struct ip_vs_service *svc)
  *      Get service by {proto,addr,port} in the service table.
  */
 static __inline__ struct ip_vs_service *
-__ip_vs_service_get(__u16 protocol, __u32 vaddr, __u16 vport)
+__ip_vs_service_get(__u16 protocol, __be32 vaddr, __be16 vport)
 {
         unsigned hash;
         struct ip_vs_service *svc;
@@ -410,7 +410,7 @@ static __inline__ struct ip_vs_service *__ip_vs_svc_fwm_get(__u32 fwmark)
 }
 
 struct ip_vs_service *
-ip_vs_service_get(__u32 fwmark, __u16 protocol, __u32 vaddr, __u16 vport)
+ip_vs_service_get(__u32 fwmark, __u16 protocol, __be32 vaddr, __be16 vport)
 {
         struct ip_vs_service *svc;
 
@@ -480,7 +480,7 @@ __ip_vs_unbind_svc(struct ip_vs_dest *dest)
 /*
  *      Returns hash value for real service
  */
-static __inline__ unsigned ip_vs_rs_hashkey(__u32 addr, __u16 port)
+static __inline__ unsigned ip_vs_rs_hashkey(__be32 addr, __be16 port)
 {
         register unsigned porth = ntohs(port);
 
@@ -531,7 +531,7 @@ static int ip_vs_rs_unhash(struct ip_vs_dest *dest)
  *      Lookup real service by <proto,addr,port> in the real service table.
  */
 struct ip_vs_dest *
-ip_vs_lookup_real_service(__u16 protocol, __u32 daddr, __u16 dport)
+ip_vs_lookup_real_service(__u16 protocol, __be32 daddr, __be16 dport)
 {
         unsigned hash;
         struct ip_vs_dest *dest;
@@ -562,7 +562,7 @@ ip_vs_lookup_real_service(__u16 protocol, __u32 daddr, __u16 dport)
  *      Lookup destination by {addr,port} in the given service
  */
 static struct ip_vs_dest *
-ip_vs_lookup_dest(struct ip_vs_service *svc, __u32 daddr, __u16 dport)
+ip_vs_lookup_dest(struct ip_vs_service *svc, __be32 daddr, __be16 dport)
 {
         struct ip_vs_dest *dest;
 
@@ -591,7 +591,7 @@ ip_vs_lookup_dest(struct ip_vs_service *svc, __u32 daddr, __u16 dport)
  *  scheduling.
  */
 static struct ip_vs_dest *
-ip_vs_trash_get_dest(struct ip_vs_service *svc, __u32 daddr, __u16 dport)
+ip_vs_trash_get_dest(struct ip_vs_service *svc, __be32 daddr, __be16 dport)
 {
         struct ip_vs_dest *dest, *nxt;
 
@@ -773,8 +773,8 @@ static int
 ip_vs_add_dest(struct ip_vs_service *svc, struct ip_vs_dest_user *udest)
 {
         struct ip_vs_dest *dest;
-        __u32 daddr = udest->addr;
-        __u16 dport = udest->port;
+        __be32 daddr = udest->addr;
+        __be16 dport = udest->port;
         int ret;
 
         EnterFunction(2);
@@ -879,8 +879,8 @@ static int
 ip_vs_edit_dest(struct ip_vs_service *svc, struct ip_vs_dest_user *udest)
 {
         struct ip_vs_dest *dest;
-        __u32 daddr = udest->addr;
-        __u16 dport = udest->port;
+        __be32 daddr = udest->addr;
+        __be16 dport = udest->port;
 
         EnterFunction(2);
 
@@ -991,8 +991,8 @@ static int
 ip_vs_del_dest(struct ip_vs_service *svc,struct ip_vs_dest_user *udest)
 {
         struct ip_vs_dest *dest;
-        __u32 daddr = udest->addr;
-        __u16 dport = udest->port;
+        __be32 daddr = udest->addr;
+        __be16 dport = udest->port;
 
         EnterFunction(2);
 
diff --git a/net/ipv4/ipvs/ip_vs_dh.c b/net/ipv4/ipvs/ip_vs_dh.c
index 9fee19c4c617..502111fba872 100644
--- a/net/ipv4/ipvs/ip_vs_dh.c
+++ b/net/ipv4/ipvs/ip_vs_dh.c
@@ -66,7 +66,7 @@ struct ip_vs_dh_bucket {
 /*
  *      Returns hash value for IPVS DH entry
  */
-static inline unsigned ip_vs_dh_hashkey(__u32 addr)
+static inline unsigned ip_vs_dh_hashkey(__be32 addr)
 {
         return (ntohl(addr)*2654435761UL) & IP_VS_DH_TAB_MASK;
 }
@@ -76,7 +76,7 @@ static inline unsigned ip_vs_dh_hashkey(__u32 addr)
  *      Get ip_vs_dest associated with supplied parameters.
  */
 static inline struct ip_vs_dest *
-ip_vs_dh_get(struct ip_vs_dh_bucket *tbl, __u32 addr)
+ip_vs_dh_get(struct ip_vs_dh_bucket *tbl, __be32 addr)
 {
         return (tbl[ip_vs_dh_hashkey(addr)]).dest;
 }
diff --git a/net/ipv4/ipvs/ip_vs_ftp.c b/net/ipv4/ipvs/ip_vs_ftp.c
index 37fafb1fbcff..e433cb0ff894 100644
--- a/net/ipv4/ipvs/ip_vs_ftp.c
+++ b/net/ipv4/ipvs/ip_vs_ftp.c
@@ -32,6 +32,7 @@
 #include <linux/ip.h>
 #include <net/protocol.h>
 #include <net/tcp.h>
+#include <asm/unaligned.h>
 
 #include <net/ip_vs.h>
 
@@ -44,8 +45,8 @@
  * List of ports (up to IP_VS_APP_MAX_PORTS) to be handled by helper
  * First port is set to the default port.
  */
-static int ports[IP_VS_APP_MAX_PORTS] = {21, 0};
-module_param_array(ports, int, NULL, 0);
+static unsigned short ports[IP_VS_APP_MAX_PORTS] = {21, 0};
+module_param_array(ports, ushort, NULL, 0);
 MODULE_PARM_DESC(ports, "Ports to monitor for FTP control commands");
 
 
@@ -74,7 +75,7 @@ ip_vs_ftp_done_conn(struct ip_vs_app *app, struct ip_vs_conn *cp)
  */
 static int ip_vs_ftp_get_addrport(char *data, char *data_limit,
                                   const char *pattern, size_t plen, char term,
-                                  __u32 *addr, __u16 *port,
+                                  __be32 *addr, __be16 *port,
                                   char **start, char **end)
 {
         unsigned char p[6];
@@ -114,8 +115,8 @@ static int ip_vs_ftp_get_addrport(char *data, char *data_limit,
         if (i != 5)
                 return -1;
 
-        *addr = (p[3]<<24) | (p[2]<<16) | (p[1]<<8) | p[0];
-        *port = (p[5]<<8) | p[4];
+        *addr = get_unaligned((__be32 *)p);
+        *port = get_unaligned((__be16 *)(p + 4));
         return 1;
 }
 
@@ -140,8 +141,8 @@ static int ip_vs_ftp_out(struct ip_vs_app *app, struct ip_vs_conn *cp,
         struct tcphdr *th;
         char *data, *data_limit;
         char *start, *end;
-        __u32 from;
-        __u16 port;
+        __be32 from;
+        __be16 port;
         struct ip_vs_conn *n_cp;
         char buf[24];           /* xxx.xxx.xxx.xxx,ppp,ppp\000 */
         unsigned buf_len;
@@ -199,7 +200,7 @@ static int ip_vs_ftp_out(struct ip_vs_app *app, struct ip_vs_conn *cp,
                 from = n_cp->vaddr;
                 port = n_cp->vport;
                 sprintf(buf,"%d,%d,%d,%d,%d,%d", NIPQUAD(from),
-                        port&255, (port>>8)&255);
+                        ntohs(port)&255, (ntohs(port)>>8)&255);
                 buf_len = strlen(buf);
 
                 /*
@@ -243,8 +244,8 @@ static int ip_vs_ftp_in(struct ip_vs_app *app, struct ip_vs_conn *cp,
         struct tcphdr *th;
         char *data, *data_start, *data_limit;
         char *start, *end;
-        __u32 to;
-        __u16 port;
+        __be32 to;
+        __be16 port;
         struct ip_vs_conn *n_cp;
 
         /* no diff required for incoming packets */
@@ -365,12 +366,6 @@ static int __init ip_vs_ftp_init(void)
         for (i=0; i<IP_VS_APP_MAX_PORTS; i++) {
                 if (!ports[i])
                         continue;
-                if (ports[i] < 0 || ports[i] > 0xffff) {
-                        IP_VS_WARNING("ip_vs_ftp: Ignoring invalid "
-                                      "configuration port[%d] = %d\n",
-                                      i, ports[i]);
-                        continue;
-                }
                 ret = register_ip_vs_app_inc(app, app->protocol, ports[i]);
                 if (ret)
                         break;
diff --git a/net/ipv4/ipvs/ip_vs_lblc.c b/net/ipv4/ipvs/ip_vs_lblc.c
index 6e5cb92a5c83..524751e031de 100644
--- a/net/ipv4/ipvs/ip_vs_lblc.c
+++ b/net/ipv4/ipvs/ip_vs_lblc.c
@@ -87,7 +87,7 @@ static int sysctl_ip_vs_lblc_expiration = 24*60*60*HZ;
  */
 struct ip_vs_lblc_entry {
         struct list_head        list;
-        __u32                   addr;           /* destination IP address */
+        __be32                  addr;           /* destination IP address */
         struct ip_vs_dest       *dest;          /* real server (cache) */
         unsigned long           lastuse;        /* last used time */
 };
@@ -160,7 +160,7 @@ static struct ctl_table_header * sysctl_header;
  *      IP address to a server.
  */
 static inline struct ip_vs_lblc_entry *
-ip_vs_lblc_new(__u32 daddr, struct ip_vs_dest *dest)
+ip_vs_lblc_new(__be32 daddr, struct ip_vs_dest *dest)
 {
         struct ip_vs_lblc_entry *en;
 
@@ -195,7 +195,7 @@ static inline void ip_vs_lblc_free(struct ip_vs_lblc_entry *en)
 /*
  *      Returns hash value for IPVS LBLC entry
  */
-static inline unsigned ip_vs_lblc_hashkey(__u32 addr)
+static inline unsigned ip_vs_lblc_hashkey(__be32 addr)
 {
         return (ntohl(addr)*2654435761UL) & IP_VS_LBLC_TAB_MASK;
 }
@@ -234,7 +234,7 @@ ip_vs_lblc_hash(struct ip_vs_lblc_table *tbl, struct ip_vs_lblc_entry *en)
  *  Get ip_vs_lblc_entry associated with supplied parameters.
  */
 static inline struct ip_vs_lblc_entry *
-ip_vs_lblc_get(struct ip_vs_lblc_table *tbl, __u32 addr)
+ip_vs_lblc_get(struct ip_vs_lblc_table *tbl, __be32 addr)
 {
         unsigned hash;
         struct ip_vs_lblc_entry *en;
diff --git a/net/ipv4/ipvs/ip_vs_lblcr.c b/net/ipv4/ipvs/ip_vs_lblcr.c
index 32ba37ba72d8..08990192b6ec 100644
--- a/net/ipv4/ipvs/ip_vs_lblcr.c
+++ b/net/ipv4/ipvs/ip_vs_lblcr.c
@@ -276,7 +276,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_max(struct ip_vs_dest_set *set)
  */
 struct ip_vs_lblcr_entry {
         struct list_head        list;
-        __u32                   addr;           /* destination IP address */
+        __be32                   addr;           /* destination IP address */
         struct ip_vs_dest_set   set;            /* destination server set */
         unsigned long           lastuse;        /* last used time */
 };
@@ -348,7 +348,7 @@ static struct ctl_table_header * sysctl_header;
  *      new/free a ip_vs_lblcr_entry, which is a mapping of a destination
  *      IP address to a server.
  */
-static inline struct ip_vs_lblcr_entry *ip_vs_lblcr_new(__u32 daddr)
+static inline struct ip_vs_lblcr_entry *ip_vs_lblcr_new(__be32 daddr)
 {
         struct ip_vs_lblcr_entry *en;
 
@@ -381,7 +381,7 @@ static inline void ip_vs_lblcr_free(struct ip_vs_lblcr_entry *en)
 /*
  *      Returns hash value for IPVS LBLCR entry
  */
-static inline unsigned ip_vs_lblcr_hashkey(__u32 addr)
+static inline unsigned ip_vs_lblcr_hashkey(__be32 addr)
 {
         return (ntohl(addr)*2654435761UL) & IP_VS_LBLCR_TAB_MASK;
 }
@@ -420,7 +420,7 @@ ip_vs_lblcr_hash(struct ip_vs_lblcr_table *tbl, struct ip_vs_lblcr_entry *en)
  *  Get ip_vs_lblcr_entry associated with supplied parameters.
  */
 static inline struct ip_vs_lblcr_entry *
-ip_vs_lblcr_get(struct ip_vs_lblcr_table *tbl, __u32 addr)
+ip_vs_lblcr_get(struct ip_vs_lblcr_table *tbl, __be32 addr)
 {
         unsigned hash;
         struct ip_vs_lblcr_entry *en;
diff --git a/net/ipv4/ipvs/ip_vs_proto.c b/net/ipv4/ipvs/ip_vs_proto.c
index 867d4e9c6594..c4528b5c800d 100644
--- a/net/ipv4/ipvs/ip_vs_proto.c
+++ b/net/ipv4/ipvs/ip_vs_proto.c
@@ -176,7 +176,7 @@ ip_vs_tcpudp_debug_packet(struct ip_vs_protocol *pp,
                         pp->name, NIPQUAD(ih->saddr),
                         NIPQUAD(ih->daddr));
         else {
-                __u16 _ports[2], *pptr
+                __be16 _ports[2], *pptr
 ;
                 pptr = skb_header_pointer(skb, offset + ih->ihl*4,
                                           sizeof(_ports), _ports);
diff --git a/net/ipv4/ipvs/ip_vs_proto_tcp.c b/net/ipv4/ipvs/ip_vs_proto_tcp.c
index 820e8318d10d..bfe779e74590 100644
--- a/net/ipv4/ipvs/ip_vs_proto_tcp.c
+++ b/net/ipv4/ipvs/ip_vs_proto_tcp.c
@@ -29,7 +29,7 @@ static struct ip_vs_conn *
 tcp_conn_in_get(const struct sk_buff *skb, struct ip_vs_protocol *pp,
                 const struct iphdr *iph, unsigned int proto_off, int inverse)
 {
-        __u16 _ports[2], *pptr;
+        __be16 _ports[2], *pptr;
 
         pptr = skb_header_pointer(skb, proto_off, sizeof(_ports), _ports);
         if (pptr == NULL)
@@ -50,7 +50,7 @@ static struct ip_vs_conn *
 tcp_conn_out_get(const struct sk_buff *skb, struct ip_vs_protocol *pp,
                  const struct iphdr *iph, unsigned int proto_off, int inverse)
 {
-        __u16 _ports[2], *pptr;
+        __be16 _ports[2], *pptr;
 
         pptr = skb_header_pointer(skb, proto_off, sizeof(_ports), _ports);
         if (pptr == NULL)
@@ -112,12 +112,12 @@ tcp_conn_schedule(struct sk_buff *skb,
 
 
 static inline void
-tcp_fast_csum_update(struct tcphdr *tcph, u32 oldip, u32 newip,
-                     u16 oldport, u16 newport)
+tcp_fast_csum_update(struct tcphdr *tcph, __be32 oldip, __be32 newip,
+                     __be16 oldport, __be16 newport)
 {
         tcph->check =
                 ip_vs_check_diff(~oldip, newip,
-                                 ip_vs_check_diff(oldport ^ 0xFFFF,
+                                 ip_vs_check_diff(oldport ^ htonl(0xFFFF),
                                                   newport, tcph->check));
 }
 
diff --git a/net/ipv4/ipvs/ip_vs_proto_udp.c b/net/ipv4/ipvs/ip_vs_proto_udp.c
index 90c8166c0ec1..54aa7603591f 100644
--- a/net/ipv4/ipvs/ip_vs_proto_udp.c
+++ b/net/ipv4/ipvs/ip_vs_proto_udp.c
@@ -29,7 +29,7 @@ udp_conn_in_get(const struct sk_buff *skb, struct ip_vs_protocol *pp,
                 const struct iphdr *iph, unsigned int proto_off, int inverse)
 {
         struct ip_vs_conn *cp;
-        __u16 _ports[2], *pptr;
+        __be16 _ports[2], *pptr;
 
         pptr = skb_header_pointer(skb, proto_off, sizeof(_ports), _ports);
         if (pptr == NULL)
@@ -54,7 +54,7 @@ udp_conn_out_get(const struct sk_buff *skb, struct ip_vs_protocol *pp,
                  const struct iphdr *iph, unsigned int proto_off, int inverse)
 {
         struct ip_vs_conn *cp;
-        __u16 _ports[2], *pptr;
+        __be16 _ports[2], *pptr;
 
         pptr = skb_header_pointer(skb, skb->nh.iph->ihl*4,
                                   sizeof(_ports), _ports);
@@ -117,15 +117,15 @@ udp_conn_schedule(struct sk_buff *skb, struct ip_vs_protocol *pp,
 
 
 static inline void
-udp_fast_csum_update(struct udphdr *uhdr, u32 oldip, u32 newip,
-                     u16 oldport, u16 newport)
+udp_fast_csum_update(struct udphdr *uhdr, __be32 oldip, __be32 newip,
+                     __be16 oldport, __be16 newport)
 {
         uhdr->check =
                 ip_vs_check_diff(~oldip, newip,
-                                 ip_vs_check_diff(oldport ^ 0xFFFF,
+                                 ip_vs_check_diff(oldport ^ htonl(0xFFFF),
                                                   newport, uhdr->check));
         if (!uhdr->check)
-                uhdr->check = 0xFFFF;
+                uhdr->check = htonl(0xFFFF);
 }
 
 static int
@@ -173,7 +173,7 @@ udp_snat_handler(struct sk_buff **pskb,
                                                 cp->protocol,
                                                 (*pskb)->csum);
                 if (udph->check == 0)
-                        udph->check = 0xFFFF;
+                        udph->check = htonl(0xFFFF);
                 IP_VS_DBG(11, "O-pkt: %s O-csum=%d (+%zd)\n",
                           pp->name, udph->check,
                           (char*)&(udph->check) - (char*)udph);
diff --git a/net/ipv4/ipvs/ip_vs_sh.c b/net/ipv4/ipvs/ip_vs_sh.c
index 7775e6cc68be..338668f88fe2 100644
--- a/net/ipv4/ipvs/ip_vs_sh.c
+++ b/net/ipv4/ipvs/ip_vs_sh.c
@@ -63,7 +63,7 @@ struct ip_vs_sh_bucket {
 /*
  *      Returns hash value for IPVS SH entry
  */
-static inline unsigned ip_vs_sh_hashkey(__u32 addr)
+static inline unsigned ip_vs_sh_hashkey(__be32 addr)
 {
         return (ntohl(addr)*2654435761UL) & IP_VS_SH_TAB_MASK;
 }
@@ -73,7 +73,7 @@ static inline unsigned ip_vs_sh_hashkey(__u32 addr)
  *      Get ip_vs_dest associated with supplied parameters.
  */
 static inline struct ip_vs_dest *
-ip_vs_sh_get(struct ip_vs_sh_bucket *tbl, __u32 addr)
+ip_vs_sh_get(struct ip_vs_sh_bucket *tbl, __be32 addr)
 {
         return (tbl[ip_vs_sh_hashkey(addr)]).dest;
 }
diff --git a/net/ipv4/ipvs/ip_vs_sync.c b/net/ipv4/ipvs/ip_vs_sync.c
index 1bca714bda3d..6ab57d72b615 100644
--- a/net/ipv4/ipvs/ip_vs_sync.c
+++ b/net/ipv4/ipvs/ip_vs_sync.c
@@ -48,16 +48,16 @@ struct ip_vs_sync_conn {
 
         /* Protocol, addresses and port numbers */
         __u8                    protocol;       /* Which protocol (TCP/UDP) */
-        __u16                   cport;
-        __u16                   vport;
-        __u16                   dport;
-        __u32                   caddr;          /* client address */
-        __u32                   vaddr;          /* virtual address */
-        __u32                   daddr;          /* destination address */
+        __be16                  cport;
+        __be16                  vport;
+        __be16                  dport;
+        __be32                  caddr;          /* client address */
+        __be32                  vaddr;          /* virtual address */
+        __be32                  daddr;          /* destination address */
 
         /* Flags and state transition */
-        __u16                   flags;          /* status flags */
-        __u16                   state;          /* state info */
+        __be16                  flags;          /* status flags */
+        __be16                  state;          /* state info */
 
         /* The sequence options start here */
 };
@@ -464,7 +464,7 @@ join_mcast_group(struct sock *sk, struct in_addr *addr, char *ifname)
 static int bind_mcastif_addr(struct socket *sock, char *ifname)
 {
         struct net_device *dev;
-        u32 addr;
+        __be32 addr;
         struct sockaddr_in sin;
 
         if ((dev = __dev_get_by_name(ifname)) == NULL)
diff --git a/net/ipv4/ipvs/ip_vs_xmit.c b/net/ipv4/ipvs/ip_vs_xmit.c
index 52c12e9edbbc..e1f77bd7c9a5 100644
--- a/net/ipv4/ipvs/ip_vs_xmit.c
+++ b/net/ipv4/ipvs/ip_vs_xmit.c
@@ -232,7 +232,7 @@ ip_vs_nat_xmit(struct sk_buff *skb, struct ip_vs_conn *cp,
 
         /* check if it is a connection of no-client-port */
         if (unlikely(cp->flags & IP_VS_CONN_F_NO_CPORT)) {
-                __u16 _pt, *p;
+                __be16 _pt, *p;
                 p = skb_header_pointer(skb, iph->ihl*4, sizeof(_pt), &_pt);
                 if (p == NULL)
                         goto tx_error;
diff --git a/net/ipv4/multipath_wrandom.c b/net/ipv4/multipath_wrandom.c
index d25ec4ae09e5..92b04823e034 100644
--- a/net/ipv4/multipath_wrandom.c
+++ b/net/ipv4/multipath_wrandom.c
@@ -60,8 +60,8 @@ struct multipath_dest {
         struct list_head        list;
 
         const struct fib_nh     *nh_info;
-        __u32                   netmask;
-        __u32                   network;
+        __be32                  netmask;
+        __be32                  network;
         unsigned char           prefixlen;
 
         struct rcu_head         rcu;
@@ -76,7 +76,7 @@ struct multipath_route {
         struct list_head        list;
 
         int                     oif;
-        __u32                   gw;
+        __be32                  gw;
         struct list_head        dests;
 
         struct rcu_head         rcu;
@@ -128,8 +128,8 @@ static unsigned char __multipath_lookup_weight(const struct flowi *fl,
 
         /* find state entry for destination */
         list_for_each_entry_rcu(d, &target_route->dests, list) {
-                __u32 targetnetwork = fl->fl4_dst & 
-                        (0xFFFFFFFF >> (32 - d->prefixlen));
+                __be32 targetnetwork = fl->fl4_dst &
+                        inet_make_mask(d->prefixlen);
 
                 if ((targetnetwork & d->netmask) == d->network) {
                         weight = d->nh_info->nh_weight;
@@ -217,8 +217,8 @@ static void wrandom_select_route(const struct flowi *flp,
         *rp = decision;
 }
 
-static void wrandom_set_nhinfo(__u32 network,
-                               __u32 netmask,
+static void wrandom_set_nhinfo(__be32 network,
+                               __be32 netmask,
                                unsigned char prefixlen,
                                const struct fib_nh *nh)
 {
diff --git a/net/ipv4/netfilter.c b/net/ipv4/netfilter.c
index f88347de21a9..5ac15379a0cf 100644
--- a/net/ipv4/netfilter.c
+++ b/net/ipv4/netfilter.c
@@ -128,8 +128,8 @@ EXPORT_SYMBOL(ip_nat_decode_session);
  */
 
 struct ip_rt_info {
-        u_int32_t daddr;
-        u_int32_t saddr;
+        __be32 daddr;
+        __be32 saddr;
         u_int8_t tos;
 };
 
diff --git a/net/ipv4/netfilter/arp_tables.c b/net/ipv4/netfilter/arp_tables.c
index 85f0d73ebfb4..17e1a687ab45 100644
--- a/net/ipv4/netfilter/arp_tables.c
+++ b/net/ipv4/netfilter/arp_tables.c
@@ -80,7 +80,7 @@ static inline int arp_packet_match(const struct arphdr *arphdr,
 {
         char *arpptr = (char *)(arphdr + 1);
         char *src_devaddr, *tgt_devaddr;
-        u32 src_ipaddr, tgt_ipaddr;
+        __be32 src_ipaddr, tgt_ipaddr;
         int i, ret;
 
 #define FWINV(bool,invflg) ((bool) ^ !!(arpinfo->invflags & invflg))
diff --git a/net/ipv4/netfilter/ip_conntrack_amanda.c b/net/ipv4/netfilter/ip_conntrack_amanda.c
index 0a7bd7f04061..6c7383a8e42b 100644
--- a/net/ipv4/netfilter/ip_conntrack_amanda.c
+++ b/net/ipv4/netfilter/ip_conntrack_amanda.c
@@ -155,11 +155,11 @@ static int help(struct sk_buff **pskb,
                 exp->tuple.dst.protonum = IPPROTO_TCP;
                 exp->tuple.dst.u.tcp.port = htons(port);
 
-                exp->mask.src.ip = 0xFFFFFFFF;
+                exp->mask.src.ip = htonl(0xFFFFFFFF);
                 exp->mask.src.u.tcp.port = 0;
-                exp->mask.dst.ip = 0xFFFFFFFF;
+                exp->mask.dst.ip = htonl(0xFFFFFFFF);
                 exp->mask.dst.protonum = 0xFF;
-                exp->mask.dst.u.tcp.port = 0xFFFF;
+                exp->mask.dst.u.tcp.port = htons(0xFFFF);
 
                 if (ip_nat_amanda_hook)
                         ret = ip_nat_amanda_hook(pskb, ctinfo, off - dataoff,
diff --git a/net/ipv4/netfilter/ip_conntrack_core.c b/net/ipv4/netfilter/ip_conntrack_core.c
index c432b3163609..143c4668538b 100644
--- a/net/ipv4/netfilter/ip_conntrack_core.c
+++ b/net/ipv4/netfilter/ip_conntrack_core.c
@@ -149,8 +149,8 @@ static unsigned int ip_conntrack_hash_rnd;
 static u_int32_t __hash_conntrack(const struct ip_conntrack_tuple *tuple,
                             unsigned int size, unsigned int rnd)
 {
-        return (jhash_3words(tuple->src.ip,
-                             (tuple->dst.ip ^ tuple->dst.protonum),
+        return (jhash_3words((__force u32)tuple->src.ip,
+                             ((__force u32)tuple->dst.ip ^ tuple->dst.protonum),
                              (tuple->src.u.all | (tuple->dst.u.all << 16)),
                              rnd) % size);
 }
@@ -1169,9 +1169,9 @@ void __ip_ct_refresh_acct(struct ip_conntrack *ct,
 int ip_ct_port_tuple_to_nfattr(struct sk_buff *skb,
                                const struct ip_conntrack_tuple *tuple)
 {
-        NFA_PUT(skb, CTA_PROTO_SRC_PORT, sizeof(u_int16_t),
+        NFA_PUT(skb, CTA_PROTO_SRC_PORT, sizeof(__be16),
                 &tuple->src.u.tcp.port);
-        NFA_PUT(skb, CTA_PROTO_DST_PORT, sizeof(u_int16_t),
+        NFA_PUT(skb, CTA_PROTO_DST_PORT, sizeof(__be16),
                 &tuple->dst.u.tcp.port);
         return 0;
 
@@ -1186,9 +1186,9 @@ int ip_ct_port_nfattr_to_tuple(struct nfattr *tb[],
                 return -EINVAL;
 
         t->src.u.tcp.port =
-                *(u_int16_t *)NFA_DATA(tb[CTA_PROTO_SRC_PORT-1]);
+                *(__be16 *)NFA_DATA(tb[CTA_PROTO_SRC_PORT-1]);
         t->dst.u.tcp.port =
-                *(u_int16_t *)NFA_DATA(tb[CTA_PROTO_DST_PORT-1]);
+                *(__be16 *)NFA_DATA(tb[CTA_PROTO_DST_PORT-1]);
 
         return 0;
 }
diff --git a/net/ipv4/netfilter/ip_conntrack_ftp.c b/net/ipv4/netfilter/ip_conntrack_ftp.c
index 1d18c863f064..93dcf960662f 100644
--- a/net/ipv4/netfilter/ip_conntrack_ftp.c
+++ b/net/ipv4/netfilter/ip_conntrack_ftp.c
@@ -425,8 +425,8 @@ static int help(struct sk_buff **pskb,
         exp->tuple.src.u.tcp.port = 0; /* Don't care. */
         exp->tuple.dst.protonum = IPPROTO_TCP;
         exp->mask = ((struct ip_conntrack_tuple)
-                { { 0xFFFFFFFF, { 0 } },
-                  { 0xFFFFFFFF, { .tcp = { 0xFFFF } }, 0xFF }});
+                { { htonl(0xFFFFFFFF), { 0 } },
+                  { htonl(0xFFFFFFFF), { .tcp = { htons(0xFFFF) } }, 0xFF }});
 
         exp->expectfn = NULL;
         exp->flags = 0;
@@ -488,7 +488,7 @@ static int __init ip_conntrack_ftp_init(void)
         for (i = 0; i < ports_c; i++) {
                 ftp[i].tuple.src.u.tcp.port = htons(ports[i]);
                 ftp[i].tuple.dst.protonum = IPPROTO_TCP;
-                ftp[i].mask.src.u.tcp.port = 0xFFFF;
+                ftp[i].mask.src.u.tcp.port = htons(0xFFFF);
                 ftp[i].mask.dst.protonum = 0xFF;
                 ftp[i].max_expected = 1;
                 ftp[i].timeout = 5 * 60; /* 5 minutes */
diff --git a/net/ipv4/netfilter/ip_conntrack_helper_h323.c b/net/ipv4/netfilter/ip_conntrack_helper_h323.c
index 9a39e2969712..7b7441202bfd 100644
--- a/net/ipv4/netfilter/ip_conntrack_helper_h323.c
+++ b/net/ipv4/netfilter/ip_conntrack_helper_h323.c
@@ -49,11 +49,11 @@ MODULE_PARM_DESC(callforward_filter, "only create call forwarding expectations "
 int (*set_h245_addr_hook) (struct sk_buff ** pskb,
                            unsigned char **data, int dataoff,
                            H245_TransportAddress * addr,
-                           u_int32_t ip, u_int16_t port);
+                           __be32 ip, u_int16_t port);
 int (*set_h225_addr_hook) (struct sk_buff ** pskb,
                            unsigned char **data, int dataoff,
                            TransportAddress * addr,
-                           u_int32_t ip, u_int16_t port);
+                           __be32 ip, u_int16_t port);
 int (*set_sig_addr_hook) (struct sk_buff ** pskb,
                           struct ip_conntrack * ct,
                           enum ip_conntrack_info ctinfo,
@@ -209,7 +209,7 @@ static int get_tpkt_data(struct sk_buff **pskb, struct ip_conntrack *ct,
 
 /****************************************************************************/
 static int get_h245_addr(unsigned char *data, H245_TransportAddress * addr,
-                         u_int32_t * ip, u_int16_t * port)
+                         __be32 * ip, u_int16_t * port)
 {
         unsigned char *p;
 
@@ -232,7 +232,7 @@ static int expect_rtp_rtcp(struct sk_buff **pskb, struct ip_conntrack *ct,
 {
         int dir = CTINFO2DIR(ctinfo);
         int ret = 0;
-        u_int32_t ip;
+        __be32 ip;
         u_int16_t port;
         u_int16_t rtp_port;
         struct ip_conntrack_expect *rtp_exp;
@@ -254,10 +254,10 @@ static int expect_rtp_rtcp(struct sk_buff **pskb, struct ip_conntrack *ct,
         rtp_exp->tuple.dst.ip = ct->tuplehash[!dir].tuple.dst.ip;
         rtp_exp->tuple.dst.u.udp.port = htons(rtp_port);
         rtp_exp->tuple.dst.protonum = IPPROTO_UDP;
-        rtp_exp->mask.src.ip = 0xFFFFFFFF;
+        rtp_exp->mask.src.ip = htonl(0xFFFFFFFF);
         rtp_exp->mask.src.u.udp.port = 0;
-        rtp_exp->mask.dst.ip = 0xFFFFFFFF;
-        rtp_exp->mask.dst.u.udp.port = 0xFFFF;
+        rtp_exp->mask.dst.ip = htonl(0xFFFFFFFF);
+        rtp_exp->mask.dst.u.udp.port = htons(0xFFFF);
         rtp_exp->mask.dst.protonum = 0xFF;
         rtp_exp->flags = 0;
 
@@ -271,10 +271,10 @@ static int expect_rtp_rtcp(struct sk_buff **pskb, struct ip_conntrack *ct,
         rtcp_exp->tuple.dst.ip = ct->tuplehash[!dir].tuple.dst.ip;
         rtcp_exp->tuple.dst.u.udp.port = htons(rtp_port + 1);
         rtcp_exp->tuple.dst.protonum = IPPROTO_UDP;
-        rtcp_exp->mask.src.ip = 0xFFFFFFFF;
+        rtcp_exp->mask.src.ip = htonl(0xFFFFFFFF);
         rtcp_exp->mask.src.u.udp.port = 0;
-        rtcp_exp->mask.dst.ip = 0xFFFFFFFF;
-        rtcp_exp->mask.dst.u.udp.port = 0xFFFF;
+        rtcp_exp->mask.dst.ip = htonl(0xFFFFFFFF);
+        rtcp_exp->mask.dst.u.udp.port = htons(0xFFFF);
         rtcp_exp->mask.dst.protonum = 0xFF;
         rtcp_exp->flags = 0;
 
@@ -325,7 +325,7 @@ static int expect_t120(struct sk_buff **pskb,
 {
         int dir = CTINFO2DIR(ctinfo);
         int ret = 0;
-        u_int32_t ip;
+        __be32 ip;
         u_int16_t port;
         struct ip_conntrack_expect *exp = NULL;
 
@@ -342,10 +342,10 @@ static int expect_t120(struct sk_buff **pskb,
         exp->tuple.dst.ip = ct->tuplehash[!dir].tuple.dst.ip;
         exp->tuple.dst.u.tcp.port = htons(port);
         exp->tuple.dst.protonum = IPPROTO_TCP;
-        exp->mask.src.ip = 0xFFFFFFFF;
+        exp->mask.src.ip = htonl(0xFFFFFFFF);
         exp->mask.src.u.tcp.port = 0;
-        exp->mask.dst.ip = 0xFFFFFFFF;
-        exp->mask.dst.u.tcp.port = 0xFFFF;
+        exp->mask.dst.ip = htonl(0xFFFFFFFF);
+        exp->mask.dst.u.tcp.port = htons(0xFFFF);
         exp->mask.dst.protonum = 0xFF;
         exp->flags = IP_CT_EXPECT_PERMANENT;    /* Accept multiple channels */
 
@@ -626,7 +626,7 @@ void ip_conntrack_h245_expect(struct ip_conntrack *new,
 
 /****************************************************************************/
 int get_h225_addr(unsigned char *data, TransportAddress * addr,
-                  u_int32_t * ip, u_int16_t * port)
+                  __be32 * ip, u_int16_t * port)
 {
         unsigned char *p;
 
@@ -648,7 +648,7 @@ static int expect_h245(struct sk_buff **pskb, struct ip_conntrack *ct,
 {
         int dir = CTINFO2DIR(ctinfo);
         int ret = 0;
-        u_int32_t ip;
+        __be32 ip;
         u_int16_t port;
         struct ip_conntrack_expect *exp = NULL;
 
@@ -665,10 +665,10 @@ static int expect_h245(struct sk_buff **pskb, struct ip_conntrack *ct,
         exp->tuple.dst.ip = ct->tuplehash[!dir].tuple.dst.ip;
         exp->tuple.dst.u.tcp.port = htons(port);
         exp->tuple.dst.protonum = IPPROTO_TCP;
-        exp->mask.src.ip = 0xFFFFFFFF;
+        exp->mask.src.ip = htonl(0xFFFFFFFF);
         exp->mask.src.u.tcp.port = 0;
-        exp->mask.dst.ip = 0xFFFFFFFF;
-        exp->mask.dst.u.tcp.port = 0xFFFF;
+        exp->mask.dst.ip = htonl(0xFFFFFFFF);
+        exp->mask.dst.u.tcp.port = htons(0xFFFF);
         exp->mask.dst.protonum = 0xFF;
         exp->flags = 0;
 
@@ -709,7 +709,7 @@ static int expect_callforwarding(struct sk_buff **pskb,
 {
         int dir = CTINFO2DIR(ctinfo);
         int ret = 0;
-        u_int32_t ip;
+        __be32 ip;
         u_int16_t port;
         struct ip_conntrack_expect *exp = NULL;
 
@@ -751,10 +751,10 @@ static int expect_callforwarding(struct sk_buff **pskb,
         exp->tuple.dst.ip = ip;
         exp->tuple.dst.u.tcp.port = htons(port);
         exp->tuple.dst.protonum = IPPROTO_TCP;
-        exp->mask.src.ip = 0xFFFFFFFF;
+        exp->mask.src.ip = htonl(0xFFFFFFFF);
         exp->mask.src.u.tcp.port = 0;
-        exp->mask.dst.ip = 0xFFFFFFFF;
-        exp->mask.dst.u.tcp.port = 0xFFFF;
+        exp->mask.dst.ip = htonl(0xFFFFFFFF);
+        exp->mask.dst.u.tcp.port = htons(0xFFFF);
         exp->mask.dst.protonum = 0xFF;
         exp->flags = 0;
 
@@ -791,7 +791,7 @@ static int process_setup(struct sk_buff **pskb, struct ip_conntrack *ct,
         int dir = CTINFO2DIR(ctinfo);
         int ret;
         int i;
-        u_int32_t ip;
+        __be32 ip;
         u_int16_t port;
 
         DEBUGP("ip_ct_q931: Setup\n");
@@ -1188,7 +1188,7 @@ static unsigned char *get_udp_data(struct sk_buff **pskb, int *datalen)
 
 /****************************************************************************/
 static struct ip_conntrack_expect *find_expect(struct ip_conntrack *ct,
-                                               u_int32_t ip, u_int16_t port)
+                                               __be32 ip, u_int16_t port)
 {
         struct ip_conntrack_expect *exp;
         struct ip_conntrack_tuple tuple;
@@ -1228,7 +1228,7 @@ static int expect_q931(struct sk_buff **pskb, struct ip_conntrack *ct,
         int dir = CTINFO2DIR(ctinfo);
         int ret = 0;
         int i;
-        u_int32_t ip;
+        __be32 ip;
         u_int16_t port;
         struct ip_conntrack_expect *exp;
 
@@ -1251,10 +1251,10 @@ static int expect_q931(struct sk_buff **pskb, struct ip_conntrack *ct,
         exp->tuple.dst.ip = ct->tuplehash[!dir].tuple.dst.ip;
         exp->tuple.dst.u.tcp.port = htons(port);
         exp->tuple.dst.protonum = IPPROTO_TCP;
-        exp->mask.src.ip = gkrouted_only ? 0xFFFFFFFF : 0;
+        exp->mask.src.ip = gkrouted_only ? htonl(0xFFFFFFFF) : 0;
         exp->mask.src.u.tcp.port = 0;
-        exp->mask.dst.ip = 0xFFFFFFFF;
-        exp->mask.dst.u.tcp.port = 0xFFFF;
+        exp->mask.dst.ip = htonl(0xFFFFFFFF);
+        exp->mask.dst.u.tcp.port = htons(0xFFFF);
         exp->mask.dst.protonum = 0xFF;
         exp->flags = IP_CT_EXPECT_PERMANENT;    /* Accept multiple calls */
 
@@ -1307,7 +1307,7 @@ static int process_gcf(struct sk_buff **pskb, struct ip_conntrack *ct,
 {
         int dir = CTINFO2DIR(ctinfo);
         int ret = 0;
-        u_int32_t ip;
+        __be32 ip;
         u_int16_t port;
         struct ip_conntrack_expect *exp;
 
@@ -1333,10 +1333,10 @@ static int process_gcf(struct sk_buff **pskb, struct ip_conntrack *ct,
         exp->tuple.dst.ip = ip;
         exp->tuple.dst.u.tcp.port = htons(port);
         exp->tuple.dst.protonum = IPPROTO_UDP;
-        exp->mask.src.ip = 0xFFFFFFFF;
+        exp->mask.src.ip = htonl(0xFFFFFFFF);
         exp->mask.src.u.tcp.port = 0;
-        exp->mask.dst.ip = 0xFFFFFFFF;
-        exp->mask.dst.u.tcp.port = 0xFFFF;
+        exp->mask.dst.ip = htonl(0xFFFFFFFF);
+        exp->mask.dst.u.tcp.port = htons(0xFFFF);
         exp->mask.dst.protonum = 0xFF;
         exp->flags = 0;
         exp->expectfn = ip_conntrack_ras_expect;
@@ -1477,7 +1477,7 @@ static int process_arq(struct sk_buff **pskb, struct ip_conntrack *ct,
 {
         struct ip_ct_h323_master *info = &ct->help.ct_h323_info;
         int dir = CTINFO2DIR(ctinfo);
-        u_int32_t ip;
+        __be32 ip;
         u_int16_t port;
 
         DEBUGP("ip_ct_ras: ARQ\n");
@@ -1513,7 +1513,7 @@ static int process_acf(struct sk_buff **pskb, struct ip_conntrack *ct,
 {
         int dir = CTINFO2DIR(ctinfo);
         int ret = 0;
-        u_int32_t ip;
+        __be32 ip;
         u_int16_t port;
         struct ip_conntrack_expect *exp;
 
@@ -1538,10 +1538,10 @@ static int process_acf(struct sk_buff **pskb, struct ip_conntrack *ct,
         exp->tuple.dst.ip = ip;
         exp->tuple.dst.u.tcp.port = htons(port);
         exp->tuple.dst.protonum = IPPROTO_TCP;
-        exp->mask.src.ip = 0xFFFFFFFF;
+        exp->mask.src.ip = htonl(0xFFFFFFFF);
         exp->mask.src.u.tcp.port = 0;
-        exp->mask.dst.ip = 0xFFFFFFFF;
-        exp->mask.dst.u.tcp.port = 0xFFFF;
+        exp->mask.dst.ip = htonl(0xFFFFFFFF);
+        exp->mask.dst.u.tcp.port = htons(0xFFFF);
         exp->mask.dst.protonum = 0xFF;
         exp->flags = IP_CT_EXPECT_PERMANENT;
         exp->expectfn = ip_conntrack_q931_expect;
@@ -1581,7 +1581,7 @@ static int process_lcf(struct sk_buff **pskb, struct ip_conntrack *ct,
 {
         int dir = CTINFO2DIR(ctinfo);
         int ret = 0;
-        u_int32_t ip;
+        __be32 ip;
         u_int16_t port;
         struct ip_conntrack_expect *exp = NULL;
 
@@ -1598,10 +1598,10 @@ static int process_lcf(struct sk_buff **pskb, struct ip_conntrack *ct,
         exp->tuple.dst.ip = ip;
         exp->tuple.dst.u.tcp.port = htons(port);
         exp->tuple.dst.protonum = IPPROTO_TCP;
-        exp->mask.src.ip = 0xFFFFFFFF;
+        exp->mask.src.ip = htonl(0xFFFFFFFF);
         exp->mask.src.u.tcp.port = 0;
-        exp->mask.dst.ip = 0xFFFFFFFF;
-        exp->mask.dst.u.tcp.port = 0xFFFF;
+        exp->mask.dst.ip = htonl(0xFFFFFFFF);
+        exp->mask.dst.u.tcp.port = htons(0xFFFF);
         exp->mask.dst.protonum = 0xFF;
         exp->flags = IP_CT_EXPECT_PERMANENT;
         exp->expectfn = ip_conntrack_q931_expect;
diff --git a/net/ipv4/netfilter/ip_conntrack_helper_pptp.c b/net/ipv4/netfilter/ip_conntrack_helper_pptp.c
index fb0aee691721..a2af5e0c7f99 100644
--- a/net/ipv4/netfilter/ip_conntrack_helper_pptp.c
+++ b/net/ipv4/netfilter/ip_conntrack_helper_pptp.c
@@ -242,10 +242,10 @@ exp_gre(struct ip_conntrack *ct,
         exp_orig->tuple.dst.u.gre.key = callid;
         exp_orig->tuple.dst.protonum = IPPROTO_GRE;
 
-        exp_orig->mask.src.ip = 0xffffffff;
+        exp_orig->mask.src.ip = htonl(0xffffffff);
         exp_orig->mask.src.u.all = 0;
         exp_orig->mask.dst.u.gre.key = htons(0xffff);
-        exp_orig->mask.dst.ip = 0xffffffff;
+        exp_orig->mask.dst.ip = htonl(0xffffffff);
         exp_orig->mask.dst.protonum = 0xff;
 
         exp_orig->master = ct;
diff --git a/net/ipv4/netfilter/ip_conntrack_irc.c b/net/ipv4/netfilter/ip_conntrack_irc.c
index 44889075f3b2..75f7c3db1619 100644
--- a/net/ipv4/netfilter/ip_conntrack_irc.c
+++ b/net/ipv4/netfilter/ip_conntrack_irc.c
@@ -218,7 +218,8 @@ static int help(struct sk_buff **pskb,
                                     IPPROTO_TCP }});
                         exp->mask = ((struct ip_conntrack_tuple)
                                 { { 0, { 0 } },
-                                  { 0xFFFFFFFF, { .tcp = { 0xFFFF } }, 0xFF }});
+                                  { htonl(0xFFFFFFFF),
+                                        { .tcp = { htons(0xFFFF) } }, 0xFF }});
                         exp->expectfn = NULL;
                         exp->flags = 0;
                         if (ip_nat_irc_hook)
@@ -266,7 +267,7 @@ static int __init ip_conntrack_irc_init(void)
                 hlpr = &irc_helpers[i];
                 hlpr->tuple.src.u.tcp.port = htons(ports[i]);
                 hlpr->tuple.dst.protonum = IPPROTO_TCP;
-                hlpr->mask.src.u.tcp.port = 0xFFFF;
+                hlpr->mask.src.u.tcp.port = htons(0xFFFF);
                 hlpr->mask.dst.protonum = 0xFF;
                 hlpr->max_expected = max_dcc_channels;
                 hlpr->timeout = dcc_timeout;
diff --git a/net/ipv4/netfilter/ip_conntrack_netbios_ns.c b/net/ipv4/netfilter/ip_conntrack_netbios_ns.c
index 3d0b438783db..a1d6a89f64aa 100644
--- a/net/ipv4/netfilter/ip_conntrack_netbios_ns.c
+++ b/net/ipv4/netfilter/ip_conntrack_netbios_ns.c
@@ -48,7 +48,7 @@ static int help(struct sk_buff **pskb,
         struct iphdr *iph = (*pskb)->nh.iph;
         struct rtable *rt = (struct rtable *)(*pskb)->dst;
         struct in_device *in_dev;
-        u_int32_t mask = 0;
+        __be32 mask = 0;
 
         /* we're only interested in locally generated packets */
         if ((*pskb)->sk == NULL)
@@ -78,12 +78,12 @@ static int help(struct sk_buff **pskb,
                 goto out;
 
         exp->tuple                = ct->tuplehash[IP_CT_DIR_REPLY].tuple;
-        exp->tuple.src.u.udp.port = ntohs(NMBD_PORT);
+        exp->tuple.src.u.udp.port = htons(NMBD_PORT);
 
         exp->mask.src.ip          = mask;
-        exp->mask.src.u.udp.port  = 0xFFFF;
-        exp->mask.dst.ip          = 0xFFFFFFFF;
-        exp->mask.dst.u.udp.port  = 0xFFFF;
+        exp->mask.src.u.udp.port  = htons(0xFFFF);
+        exp->mask.dst.ip          = htonl(0xFFFFFFFF);
+        exp->mask.dst.u.udp.port  = htons(0xFFFF);
         exp->mask.dst.protonum    = 0xFF;
 
         exp->expectfn             = NULL;
@@ -115,7 +115,7 @@ static struct ip_conntrack_helper helper = {
                 .src = {
                         .u = {
                                 .udp = {
-                                        .port   = 0xFFFF,
+                                        .port   = __constant_htons(0xFFFF),
                                 }
                         }
                 },
diff --git a/net/ipv4/netfilter/ip_conntrack_netlink.c b/net/ipv4/netfilter/ip_conntrack_netlink.c
index 52eddea27e93..53b6dffea6c2 100644
--- a/net/ipv4/netfilter/ip_conntrack_netlink.c
+++ b/net/ipv4/netfilter/ip_conntrack_netlink.c
@@ -78,8 +78,8 @@ ctnetlink_dump_tuples_ip(struct sk_buff *skb,
 {
         struct nfattr *nest_parms = NFA_NEST(skb, CTA_TUPLE_IP);
         
-        NFA_PUT(skb, CTA_IP_V4_SRC, sizeof(u_int32_t), &tuple->src.ip);
-        NFA_PUT(skb, CTA_IP_V4_DST, sizeof(u_int32_t), &tuple->dst.ip);
+        NFA_PUT(skb, CTA_IP_V4_SRC, sizeof(__be32), &tuple->src.ip);
+        NFA_PUT(skb, CTA_IP_V4_DST, sizeof(__be32), &tuple->dst.ip);
 
         NFA_NEST_END(skb, nest_parms);
 
@@ -110,7 +110,7 @@ ctnetlink_dump_tuples(struct sk_buff *skb,
 static inline int
 ctnetlink_dump_status(struct sk_buff *skb, const struct ip_conntrack *ct)
 {
-        u_int32_t status = htonl((u_int32_t) ct->status);
+        __be32 status = htonl((u_int32_t) ct->status);
         NFA_PUT(skb, CTA_STATUS, sizeof(status), &status);
         return 0;
 
@@ -122,7 +122,7 @@ static inline int
 ctnetlink_dump_timeout(struct sk_buff *skb, const struct ip_conntrack *ct)
 {
         long timeout_l = ct->timeout.expires - jiffies;
-        u_int32_t timeout;
+        __be32 timeout;
 
         if (timeout_l < 0)
                 timeout = 0;
@@ -192,13 +192,13 @@ ctnetlink_dump_counters(struct sk_buff *skb, const struct ip_conntrack *ct,
 {
         enum ctattr_type type = dir ? CTA_COUNTERS_REPLY: CTA_COUNTERS_ORIG;
         struct nfattr *nest_count = NFA_NEST(skb, type);
-        u_int32_t tmp;
+        __be32 tmp;
 
         tmp = htonl(ct->counters[dir].packets);
-        NFA_PUT(skb, CTA_COUNTERS32_PACKETS, sizeof(u_int32_t), &tmp);
+        NFA_PUT(skb, CTA_COUNTERS32_PACKETS, sizeof(__be32), &tmp);
 
         tmp = htonl(ct->counters[dir].bytes);
-        NFA_PUT(skb, CTA_COUNTERS32_BYTES, sizeof(u_int32_t), &tmp);
+        NFA_PUT(skb, CTA_COUNTERS32_BYTES, sizeof(__be32), &tmp);
 
         NFA_NEST_END(skb, nest_count);
 
@@ -215,9 +215,9 @@ nfattr_failure:
 static inline int
 ctnetlink_dump_mark(struct sk_buff *skb, const struct ip_conntrack *ct)
 {
-        u_int32_t mark = htonl(ct->mark);
+        __be32 mark = htonl(ct->mark);
 
-        NFA_PUT(skb, CTA_MARK, sizeof(u_int32_t), &mark);
+        NFA_PUT(skb, CTA_MARK, sizeof(__be32), &mark);
         return 0;
 
 nfattr_failure:
@@ -230,8 +230,8 @@ nfattr_failure:
 static inline int
 ctnetlink_dump_id(struct sk_buff *skb, const struct ip_conntrack *ct)
 {
-        u_int32_t id = htonl(ct->id);
-        NFA_PUT(skb, CTA_ID, sizeof(u_int32_t), &id);
+        __be32 id = htonl(ct->id);
+        NFA_PUT(skb, CTA_ID, sizeof(__be32), &id);
         return 0;
 
 nfattr_failure:
@@ -241,9 +241,9 @@ nfattr_failure:
 static inline int
 ctnetlink_dump_use(struct sk_buff *skb, const struct ip_conntrack *ct)
 {
-        u_int32_t use = htonl(atomic_read(&ct->ct_general.use));
+        __be32 use = htonl(atomic_read(&ct->ct_general.use));
         
-        NFA_PUT(skb, CTA_USE, sizeof(u_int32_t), &use);
+        NFA_PUT(skb, CTA_USE, sizeof(__be32), &use);
         return 0;
 
 nfattr_failure:
@@ -457,8 +457,8 @@ out:
 }
 
 static const size_t cta_min_ip[CTA_IP_MAX] = {
-        [CTA_IP_V4_SRC-1]       = sizeof(u_int32_t),
-        [CTA_IP_V4_DST-1]       = sizeof(u_int32_t),
+        [CTA_IP_V4_SRC-1]       = sizeof(__be32),
+        [CTA_IP_V4_DST-1]       = sizeof(__be32),
 };
 
 static inline int
@@ -475,11 +475,11 @@ ctnetlink_parse_tuple_ip(struct nfattr *attr, struct ip_conntrack_tuple *tuple)
 
         if (!tb[CTA_IP_V4_SRC-1])
                 return -EINVAL;
-        tuple->src.ip = *(u_int32_t *)NFA_DATA(tb[CTA_IP_V4_SRC-1]);
+        tuple->src.ip = *(__be32 *)NFA_DATA(tb[CTA_IP_V4_SRC-1]);
 
         if (!tb[CTA_IP_V4_DST-1])
                 return -EINVAL;
-        tuple->dst.ip = *(u_int32_t *)NFA_DATA(tb[CTA_IP_V4_DST-1]);
+        tuple->dst.ip = *(__be32 *)NFA_DATA(tb[CTA_IP_V4_DST-1]);
 
         DEBUGP("leaving\n");
 
@@ -602,8 +602,8 @@ static int ctnetlink_parse_nat_proto(struct nfattr *attr,
 }
 
 static const size_t cta_min_nat[CTA_NAT_MAX] = {
-        [CTA_NAT_MINIP-1]       = sizeof(u_int32_t),
-        [CTA_NAT_MAXIP-1]       = sizeof(u_int32_t),
+        [CTA_NAT_MINIP-1]       = sizeof(__be32),
+        [CTA_NAT_MAXIP-1]       = sizeof(__be32),
 };
 
 static inline int
@@ -623,12 +623,12 @@ ctnetlink_parse_nat(struct nfattr *nat,
                 return -EINVAL;
 
         if (tb[CTA_NAT_MINIP-1])
-                range->min_ip = *(u_int32_t *)NFA_DATA(tb[CTA_NAT_MINIP-1]);
+                range->min_ip = *(__be32 *)NFA_DATA(tb[CTA_NAT_MINIP-1]);
 
         if (!tb[CTA_NAT_MAXIP-1])
                 range->max_ip = range->min_ip;
         else
-                range->max_ip = *(u_int32_t *)NFA_DATA(tb[CTA_NAT_MAXIP-1]);
+                range->max_ip = *(__be32 *)NFA_DATA(tb[CTA_NAT_MAXIP-1]);
 
         if (range->min_ip)
                 range->flags |= IP_NAT_RANGE_MAP_IPS;
@@ -663,11 +663,11 @@ ctnetlink_parse_help(struct nfattr *attr, char **helper_name)
 }
 
 static const size_t cta_min[CTA_MAX] = {
-        [CTA_STATUS-1]          = sizeof(u_int32_t),
-        [CTA_TIMEOUT-1]         = sizeof(u_int32_t),
-        [CTA_MARK-1]            = sizeof(u_int32_t),
-        [CTA_USE-1]             = sizeof(u_int32_t),
-        [CTA_ID-1]              = sizeof(u_int32_t)
+        [CTA_STATUS-1]          = sizeof(__be32),
+        [CTA_TIMEOUT-1]         = sizeof(__be32),
+        [CTA_MARK-1]            = sizeof(__be32),
+        [CTA_USE-1]             = sizeof(__be32),
+        [CTA_ID-1]              = sizeof(__be32)
 };
 
 static int
@@ -706,7 +706,7 @@ ctnetlink_del_conntrack(struct sock *ctnl, struct sk_buff *skb,
         ct = tuplehash_to_ctrack(h);
         
         if (cda[CTA_ID-1]) {
-                u_int32_t id = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_ID-1]));
+                u_int32_t id = ntohl(*(__be32 *)NFA_DATA(cda[CTA_ID-1]));
                 if (ct->id != id) {
                         ip_conntrack_put(ct);
                         return -ENOENT;
@@ -808,7 +808,7 @@ static inline int
 ctnetlink_change_status(struct ip_conntrack *ct, struct nfattr *cda[])
 {
         unsigned long d;
-        unsigned status = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_STATUS-1]));
+        unsigned status = ntohl(*(__be32 *)NFA_DATA(cda[CTA_STATUS-1]));
         d = ct->status ^ status;
 
         if (d & (IPS_EXPECTED|IPS_CONFIRMED|IPS_DYING))
@@ -903,7 +903,7 @@ ctnetlink_change_helper(struct ip_conntrack *ct, struct nfattr *cda[])
 static inline int
 ctnetlink_change_timeout(struct ip_conntrack *ct, struct nfattr *cda[])
 {
-        u_int32_t timeout = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_TIMEOUT-1]));
+        u_int32_t timeout = ntohl(*(__be32 *)NFA_DATA(cda[CTA_TIMEOUT-1]));
         
         if (!del_timer(&ct->timeout))
                 return -ETIME;
@@ -966,7 +966,7 @@ ctnetlink_change_conntrack(struct ip_conntrack *ct, struct nfattr *cda[])
 
 #if defined(CONFIG_IP_NF_CONNTRACK_MARK)
         if (cda[CTA_MARK-1])
-                ct->mark = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_MARK-1]));
+                ct->mark = ntohl(*(__be32 *)NFA_DATA(cda[CTA_MARK-1]));
 #endif
 
         DEBUGP("all done\n");
@@ -989,7 +989,7 @@ ctnetlink_create_conntrack(struct nfattr *cda[],
 
         if (!cda[CTA_TIMEOUT-1])
                 goto err;
-        ct->timeout.expires = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_TIMEOUT-1]));
+        ct->timeout.expires = ntohl(*(__be32 *)NFA_DATA(cda[CTA_TIMEOUT-1]));
 
         ct->timeout.expires = jiffies + ct->timeout.expires * HZ;
         ct->status |= IPS_CONFIRMED;
@@ -1006,7 +1006,7 @@ ctnetlink_create_conntrack(struct nfattr *cda[],
 
 #if defined(CONFIG_IP_NF_CONNTRACK_MARK)
         if (cda[CTA_MARK-1])
-                ct->mark = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_MARK-1]));
+                ct->mark = ntohl(*(__be32 *)NFA_DATA(cda[CTA_MARK-1]));
 #endif
 
         ct->helper = ip_conntrack_helper_find_get(rtuple);
@@ -1138,8 +1138,8 @@ ctnetlink_exp_dump_expect(struct sk_buff *skb,
                           const struct ip_conntrack_expect *exp)
 {
         struct ip_conntrack *master = exp->master;
-        u_int32_t timeout = htonl((exp->timeout.expires - jiffies) / HZ);
-        u_int32_t id = htonl(exp->id);
+        __be32 timeout = htonl((exp->timeout.expires - jiffies) / HZ);
+        __be32 id = htonl(exp->id);
 
         if (ctnetlink_exp_dump_tuple(skb, &exp->tuple, CTA_EXPECT_TUPLE) < 0)
                 goto nfattr_failure;
@@ -1150,8 +1150,8 @@ ctnetlink_exp_dump_expect(struct sk_buff *skb,
                                  CTA_EXPECT_MASTER) < 0)
                 goto nfattr_failure;
         
-        NFA_PUT(skb, CTA_EXPECT_TIMEOUT, sizeof(timeout), &timeout);
-        NFA_PUT(skb, CTA_EXPECT_ID, sizeof(u_int32_t), &id);
+        NFA_PUT(skb, CTA_EXPECT_TIMEOUT, sizeof(__be32), &timeout);
+        NFA_PUT(skb, CTA_EXPECT_ID, sizeof(__be32), &id);
 
         return 0;
         
@@ -1272,8 +1272,8 @@ out:
 }
 
 static const size_t cta_min_exp[CTA_EXPECT_MAX] = {
-        [CTA_EXPECT_TIMEOUT-1]          = sizeof(u_int32_t),
-        [CTA_EXPECT_ID-1]               = sizeof(u_int32_t)
+        [CTA_EXPECT_TIMEOUT-1]          = sizeof(__be32),
+        [CTA_EXPECT_ID-1]               = sizeof(__be32)
 };
 
 static int
@@ -1321,7 +1321,7 @@ ctnetlink_get_expect(struct sock *ctnl, struct sk_buff *skb,
                 return -ENOENT;
 
         if (cda[CTA_EXPECT_ID-1]) {
-                u_int32_t id = *(u_int32_t *)NFA_DATA(cda[CTA_EXPECT_ID-1]);
+                __be32 id = *(__be32 *)NFA_DATA(cda[CTA_EXPECT_ID-1]);
                 if (exp->id != ntohl(id)) {
                         ip_conntrack_expect_put(exp);
                         return -ENOENT;
@@ -1375,8 +1375,8 @@ ctnetlink_del_expect(struct sock *ctnl, struct sk_buff *skb,
                         return -ENOENT;
 
                 if (cda[CTA_EXPECT_ID-1]) {
-                        u_int32_t id = 
-                                *(u_int32_t *)NFA_DATA(cda[CTA_EXPECT_ID-1]);
+                        __be32 id =
+                                *(__be32 *)NFA_DATA(cda[CTA_EXPECT_ID-1]);
                         if (exp->id != ntohl(id)) {
                                 ip_conntrack_expect_put(exp);
                                 return -ENOENT;
diff --git a/net/ipv4/netfilter/ip_conntrack_proto_icmp.c b/net/ipv4/netfilter/ip_conntrack_proto_icmp.c
index 09c40ebe3345..295b6fa340db 100644
--- a/net/ipv4/netfilter/ip_conntrack_proto_icmp.c
+++ b/net/ipv4/netfilter/ip_conntrack_proto_icmp.c
@@ -261,7 +261,7 @@ icmp_error(struct sk_buff *skb, enum ip_conntrack_info *ctinfo,
 static int icmp_tuple_to_nfattr(struct sk_buff *skb,
                                 const struct ip_conntrack_tuple *t)
 {
-        NFA_PUT(skb, CTA_PROTO_ICMP_ID, sizeof(u_int16_t),
+        NFA_PUT(skb, CTA_PROTO_ICMP_ID, sizeof(__be16),
                 &t->src.u.icmp.id);
         NFA_PUT(skb, CTA_PROTO_ICMP_TYPE, sizeof(u_int8_t),
                 &t->dst.u.icmp.type);
@@ -287,7 +287,7 @@ static int icmp_nfattr_to_tuple(struct nfattr *tb[],
         tuple->dst.u.icmp.code =
                         *(u_int8_t *)NFA_DATA(tb[CTA_PROTO_ICMP_CODE-1]);
         tuple->src.u.icmp.id =
-                        *(u_int16_t *)NFA_DATA(tb[CTA_PROTO_ICMP_ID-1]);
+                        *(__be16 *)NFA_DATA(tb[CTA_PROTO_ICMP_ID-1]);
 
         if (tuple->dst.u.icmp.type >= sizeof(invmap)
             || !invmap[tuple->dst.u.icmp.type])
diff --git a/net/ipv4/netfilter/ip_conntrack_proto_sctp.c b/net/ipv4/netfilter/ip_conntrack_proto_sctp.c
index b908a4842e18..2443322e4128 100644
--- a/net/ipv4/netfilter/ip_conntrack_proto_sctp.c
+++ b/net/ipv4/netfilter/ip_conntrack_proto_sctp.c
@@ -210,7 +210,7 @@ static int sctp_print_conntrack(struct seq_file *s,
 for (offset = skb->nh.iph->ihl * 4 + sizeof(sctp_sctphdr_t), count = 0; \
         offset < skb->len &&                                            \
         (sch = skb_header_pointer(skb, offset, sizeof(_sch), &_sch));   \
-        offset += (htons(sch->length) + 3) & ~3, count++)
+        offset += (ntohs(sch->length) + 3) & ~3, count++)
 
 /* Some validity checks to make sure the chunks are fine */
 static int do_basic_checks(struct ip_conntrack *conntrack,
diff --git a/net/ipv4/netfilter/ip_conntrack_proto_tcp.c b/net/ipv4/netfilter/ip_conntrack_proto_tcp.c
index 03ae9a04cb37..06e4e8a6dd9f 100644
--- a/net/ipv4/netfilter/ip_conntrack_proto_tcp.c
+++ b/net/ipv4/netfilter/ip_conntrack_proto_tcp.c
@@ -519,8 +519,8 @@ static void tcp_sack(const struct sk_buff *skb,
 
         /* Fast path for timestamp-only option */
         if (length == TCPOLEN_TSTAMP_ALIGNED*4
-            && *(__u32 *)ptr ==
-                __constant_ntohl((TCPOPT_NOP << 24) 
+            && *(__be32 *)ptr ==
+                __constant_htonl((TCPOPT_NOP << 24)
                                  | (TCPOPT_NOP << 16)
                                  | (TCPOPT_TIMESTAMP << 8)
                                  | TCPOLEN_TIMESTAMP))
@@ -551,7 +551,7 @@ static void tcp_sack(const struct sk_buff *skb,
                                 for (i = 0;
                                      i < (opsize - TCPOLEN_SACK_BASE);
                                      i += TCPOLEN_SACK_PERBLOCK) {
-                                        tmp = ntohl(*((u_int32_t *)(ptr+i)+1));
+                                        tmp = ntohl(*((__be32 *)(ptr+i)+1));
                                         
                                         if (after(tmp, *sack))
                                                 *sack = tmp;
diff --git a/net/ipv4/netfilter/ip_conntrack_sip.c b/net/ipv4/netfilter/ip_conntrack_sip.c
index 2893e9c74850..f4f75995a9e4 100644
--- a/net/ipv4/netfilter/ip_conntrack_sip.c
+++ b/net/ipv4/netfilter/ip_conntrack_sip.c
@@ -193,7 +193,7 @@ static int skp_digits_len(const char *dptr, const char *limit, int *shift)
 
 /* Simple ipaddr parser.. */
 static int parse_ipaddr(const char *cp, const char **endp,
-                        u_int32_t *ipaddr, const char *limit)
+                        __be32 *ipaddr, const char *limit)
 {
         unsigned long int val;
         int i, digit = 0;
@@ -227,7 +227,7 @@ static int parse_ipaddr(const char *cp,	const char **endp,
 static int epaddr_len(const char *dptr, const char *limit, int *shift)
 {
         const char *aux = dptr;
-        u_int32_t ip;
+        __be32 ip;
 
         if (parse_ipaddr(dptr, &dptr, &ip, limit) < 0) {
                 DEBUGP("ip: %s parse failed.!\n", dptr);
@@ -302,7 +302,7 @@ int ct_sip_get_info(const char *dptr, size_t dlen,
 static int set_expected_rtp(struct sk_buff **pskb,
                             struct ip_conntrack *ct,
                             enum ip_conntrack_info ctinfo,
-                            u_int32_t ipaddr, u_int16_t port,
+                            __be32 ipaddr, u_int16_t port,
                             const char *dptr)
 {
         struct ip_conntrack_expect *exp;
@@ -319,10 +319,10 @@ static int set_expected_rtp(struct sk_buff **pskb,
         exp->tuple.dst.u.udp.port = htons(port);
         exp->tuple.dst.protonum = IPPROTO_UDP;
 
-        exp->mask.src.ip = 0xFFFFFFFF;
+        exp->mask.src.ip = htonl(0xFFFFFFFF);
         exp->mask.src.u.udp.port = 0;
-        exp->mask.dst.ip = 0xFFFFFFFF;
-        exp->mask.dst.u.udp.port = 0xFFFF;
+        exp->mask.dst.ip = htonl(0xFFFFFFFF);
+        exp->mask.dst.u.udp.port = htons(0xFFFF);
         exp->mask.dst.protonum = 0xFF;
 
         exp->expectfn = NULL;
@@ -349,7 +349,7 @@ static int sip_help(struct sk_buff **pskb,
         const char *dptr;
         int ret = NF_ACCEPT;
         int matchoff, matchlen;
-        u_int32_t ipaddr;
+        __be32 ipaddr;
         u_int16_t port;
 
         /* No Data ? */
@@ -439,7 +439,7 @@ static int __init init(void)
 
                 sip[i].tuple.dst.protonum = IPPROTO_UDP;
                 sip[i].tuple.src.u.udp.port = htons(ports[i]);
-                sip[i].mask.src.u.udp.port = 0xFFFF;
+                sip[i].mask.src.u.udp.port = htons(0xFFFF);
                 sip[i].mask.dst.protonum = 0xFF;
                 sip[i].max_expected = 2;
                 sip[i].timeout = 3 * 60; /* 3 minutes */
diff --git a/net/ipv4/netfilter/ip_conntrack_tftp.c b/net/ipv4/netfilter/ip_conntrack_tftp.c
index 7e33d3bed5e3..fe0b634dd377 100644
--- a/net/ipv4/netfilter/ip_conntrack_tftp.c
+++ b/net/ipv4/netfilter/ip_conntrack_tftp.c
@@ -70,10 +70,10 @@ static int tftp_help(struct sk_buff **pskb,
                         return NF_DROP;
 
                 exp->tuple = ct->tuplehash[IP_CT_DIR_REPLY].tuple;
-                exp->mask.src.ip = 0xffffffff;
+                exp->mask.src.ip = htonl(0xffffffff);
                 exp->mask.src.u.udp.port = 0;
-                exp->mask.dst.ip = 0xffffffff;
-                exp->mask.dst.u.udp.port = 0xffff;
+                exp->mask.dst.ip = htonl(0xffffffff);
+                exp->mask.dst.u.udp.port = htons(0xffff);
                 exp->mask.dst.protonum = 0xff;
                 exp->expectfn = NULL;
                 exp->flags = 0;
@@ -129,7 +129,7 @@ static int __init ip_conntrack_tftp_init(void)
                 tftp[i].tuple.dst.protonum = IPPROTO_UDP;
                 tftp[i].tuple.src.u.udp.port = htons(ports[i]);
                 tftp[i].mask.dst.protonum = 0xFF;
-                tftp[i].mask.src.u.udp.port = 0xFFFF;
+                tftp[i].mask.src.u.udp.port = htons(0xFFFF);
                 tftp[i].max_expected = 1;
                 tftp[i].timeout = 5 * 60; /* 5 minutes */
                 tftp[i].me = THIS_MODULE;
diff --git a/net/ipv4/netfilter/ip_nat_core.c b/net/ipv4/netfilter/ip_nat_core.c
index 71f3e09cbc84..4b6260a97408 100644
--- a/net/ipv4/netfilter/ip_nat_core.c
+++ b/net/ipv4/netfilter/ip_nat_core.c
@@ -82,7 +82,7 @@ static inline unsigned int
 hash_by_src(const struct ip_conntrack_tuple *tuple)
 {
         /* Original src, to ensure we map it consistently if poss. */
-        return jhash_3words(tuple->src.ip, tuple->src.u.all,
+        return jhash_3words((__force u32)tuple->src.ip, tuple->src.u.all,
                             tuple->dst.protonum, 0) % ip_nat_htable_size;
 }
 
@@ -190,7 +190,7 @@ find_best_ips_proto(struct ip_conntrack_tuple *tuple,
                     const struct ip_conntrack *conntrack,
                     enum ip_nat_manip_type maniptype)
 {
-        u_int32_t *var_ipp;
+        __be32 *var_ipp;
         /* Host order */
         u_int32_t minip, maxip, j;
 
@@ -217,7 +217,7 @@ find_best_ips_proto(struct ip_conntrack_tuple *tuple,
          * like this), even across reboots. */
         minip = ntohl(range->min_ip);
         maxip = ntohl(range->max_ip);
-        j = jhash_2words(tuple->src.ip, tuple->dst.ip, 0);
+        j = jhash_2words((__force u32)tuple->src.ip, (__force u32)tuple->dst.ip, 0);
         *var_ipp = htonl(minip + j % (maxip - minip + 1));
 }
 
@@ -534,9 +534,9 @@ int
 ip_nat_port_range_to_nfattr(struct sk_buff *skb, 
                             const struct ip_nat_range *range)
 {
-        NFA_PUT(skb, CTA_PROTONAT_PORT_MIN, sizeof(u_int16_t),
+        NFA_PUT(skb, CTA_PROTONAT_PORT_MIN, sizeof(__be16),
                 &range->min.tcp.port);
-        NFA_PUT(skb, CTA_PROTONAT_PORT_MAX, sizeof(u_int16_t),
+        NFA_PUT(skb, CTA_PROTONAT_PORT_MAX, sizeof(__be16),
                 &range->max.tcp.port);
 
         return 0;
@@ -555,7 +555,7 @@ ip_nat_port_nfattr_to_range(struct nfattr *tb[], struct ip_nat_range *range)
         if (tb[CTA_PROTONAT_PORT_MIN-1]) {
                 ret = 1;
                 range->min.tcp.port = 
-                        *(u_int16_t *)NFA_DATA(tb[CTA_PROTONAT_PORT_MIN-1]);
+                        *(__be16 *)NFA_DATA(tb[CTA_PROTONAT_PORT_MIN-1]);
         }
         
         if (!tb[CTA_PROTONAT_PORT_MAX-1]) {
@@ -564,7 +564,7 @@ ip_nat_port_nfattr_to_range(struct nfattr *tb[], struct ip_nat_range *range)
         } else {
                 ret = 1;
                 range->max.tcp.port = 
-                        *(u_int16_t *)NFA_DATA(tb[CTA_PROTONAT_PORT_MAX-1]);
+                        *(__be16 *)NFA_DATA(tb[CTA_PROTONAT_PORT_MAX-1]);
         }
 
         return ret;
diff --git a/net/ipv4/netfilter/ip_nat_ftp.c b/net/ipv4/netfilter/ip_nat_ftp.c
index 3328fc5c5f50..a71c233d8112 100644
--- a/net/ipv4/netfilter/ip_nat_ftp.c
+++ b/net/ipv4/netfilter/ip_nat_ftp.c
@@ -34,7 +34,7 @@ MODULE_DESCRIPTION("ftp NAT helper");
 
 static int
 mangle_rfc959_packet(struct sk_buff **pskb,
-                     u_int32_t newip,
+                     __be32 newip,
                      u_int16_t port,
                      unsigned int matchoff,
                      unsigned int matchlen,
@@ -57,7 +57,7 @@ mangle_rfc959_packet(struct sk_buff **pskb,
 /* |1|132.235.1.2|6275| */
 static int
 mangle_eprt_packet(struct sk_buff **pskb,
-                   u_int32_t newip,
+                   __be32 newip,
                    u_int16_t port,
                    unsigned int matchoff,
                    unsigned int matchlen,
@@ -79,7 +79,7 @@ mangle_eprt_packet(struct sk_buff **pskb,
 /* |1|132.235.1.2|6275| */
 static int
 mangle_epsv_packet(struct sk_buff **pskb,
-                   u_int32_t newip,
+                   __be32 newip,
                    u_int16_t port,
                    unsigned int matchoff,
                    unsigned int matchlen,
@@ -98,7 +98,7 @@ mangle_epsv_packet(struct sk_buff **pskb,
                                         matchlen, buffer, strlen(buffer));
 }
 
-static int (*mangle[])(struct sk_buff **, u_int32_t, u_int16_t,
+static int (*mangle[])(struct sk_buff **, __be32, u_int16_t,
                      unsigned int,
                      unsigned int,
                      struct ip_conntrack *,
@@ -120,7 +120,7 @@ static unsigned int ip_nat_ftp(struct sk_buff **pskb,
                                struct ip_conntrack_expect *exp,
                                u32 *seq)
 {
-        u_int32_t newip;
+        __be32 newip;
         u_int16_t port;
         int dir = CTINFO2DIR(ctinfo);
         struct ip_conntrack *ct = exp->master;
diff --git a/net/ipv4/netfilter/ip_nat_helper.c b/net/ipv4/netfilter/ip_nat_helper.c
index 7f6a75984f6c..3bf858480558 100644
--- a/net/ipv4/netfilter/ip_nat_helper.c
+++ b/net/ipv4/netfilter/ip_nat_helper.c
@@ -189,7 +189,7 @@ ip_nat_mangle_tcp_packet(struct sk_buff **pskb,
                                                         datalen, 0));
         } else
                 tcph->check = nf_proto_csum_update(*pskb,
-                                                   htons(oldlen) ^ 0xFFFF,
+                                                   htons(oldlen) ^ htons(0xFFFF),
                                                    htons(datalen),
                                                    tcph->check, 1);
 
@@ -267,7 +267,7 @@ ip_nat_mangle_udp_packet(struct sk_buff **pskb,
                         udph->check = -1;
         } else
                 udph->check = nf_proto_csum_update(*pskb,
-                                                   htons(oldlen) ^ 0xFFFF,
+                                                   htons(oldlen) ^ htons(0xFFFF),
                                                    htons(datalen),
                                                    udph->check, 1);
         return 1;
@@ -283,27 +283,25 @@ sack_adjust(struct sk_buff *skb,
             struct ip_nat_seq *natseq)
 {
         while (sackoff < sackend) {
-                struct tcp_sack_block *sack;
-                u_int32_t new_start_seq, new_end_seq;
+                struct tcp_sack_block_wire *sack;
+                __be32 new_start_seq, new_end_seq;
 
                 sack = (void *)skb->data + sackoff;
                 if (after(ntohl(sack->start_seq) - natseq->offset_before,
                           natseq->correction_pos))
-                        new_start_seq = ntohl(sack->start_seq) 
-                                        - natseq->offset_after;
+                        new_start_seq = htonl(ntohl(sack->start_seq)
+                                        - natseq->offset_after);
                 else
-                        new_start_seq = ntohl(sack->start_seq) 
-                                        - natseq->offset_before;
-                new_start_seq = htonl(new_start_seq);
+                        new_start_seq = htonl(ntohl(sack->start_seq)
+                                        - natseq->offset_before);
 
                 if (after(ntohl(sack->end_seq) - natseq->offset_before,
                           natseq->correction_pos))
-                        new_end_seq = ntohl(sack->end_seq)
-                                      - natseq->offset_after;
+                        new_end_seq = htonl(ntohl(sack->end_seq)
+                                      - natseq->offset_after);
                 else
-                        new_end_seq = ntohl(sack->end_seq)
-                                      - natseq->offset_before;
-                new_end_seq = htonl(new_end_seq);
+                        new_end_seq = htonl(ntohl(sack->end_seq)
+                                      - natseq->offset_before);
 
                 DEBUGP("sack_adjust: start_seq: %d->%d, end_seq: %d->%d\n",
                         ntohl(sack->start_seq), new_start_seq,
@@ -375,7 +373,8 @@ ip_nat_seq_adjust(struct sk_buff **pskb,
                   enum ip_conntrack_info ctinfo)
 {
         struct tcphdr *tcph;
-        int dir, newseq, newack;
+        int dir;
+        __be32 newseq, newack;
         struct ip_nat_seq *this_way, *other_way;        
 
         dir = CTINFO2DIR(ctinfo);
@@ -388,17 +387,15 @@ ip_nat_seq_adjust(struct sk_buff **pskb,
 
         tcph = (void *)(*pskb)->data + (*pskb)->nh.iph->ihl*4;
         if (after(ntohl(tcph->seq), this_way->correction_pos))
-                newseq = ntohl(tcph->seq) + this_way->offset_after;
+                newseq = htonl(ntohl(tcph->seq) + this_way->offset_after);
         else
-                newseq = ntohl(tcph->seq) + this_way->offset_before;
-        newseq = htonl(newseq);
+                newseq = htonl(ntohl(tcph->seq) + this_way->offset_before);
 
         if (after(ntohl(tcph->ack_seq) - other_way->offset_before,
                   other_way->correction_pos))
-                newack = ntohl(tcph->ack_seq) - other_way->offset_after;
+                newack = htonl(ntohl(tcph->ack_seq) - other_way->offset_after);
         else
-                newack = ntohl(tcph->ack_seq) - other_way->offset_before;
-        newack = htonl(newack);
+                newack = htonl(ntohl(tcph->ack_seq) - other_way->offset_before);
 
         tcph->check = nf_proto_csum_update(*pskb, ~tcph->seq, newseq,
                                            tcph->check, 0);
diff --git a/net/ipv4/netfilter/ip_nat_helper_h323.c b/net/ipv4/netfilter/ip_nat_helper_h323.c
index 419b878fb467..4a7d34466ee2 100644
--- a/net/ipv4/netfilter/ip_nat_helper_h323.c
+++ b/net/ipv4/netfilter/ip_nat_helper_h323.c
@@ -32,13 +32,13 @@
 /****************************************************************************/
 static int set_addr(struct sk_buff **pskb,
                     unsigned char **data, int dataoff,
-                    unsigned int addroff, u_int32_t ip, u_int16_t port)
+                    unsigned int addroff, __be32 ip, u_int16_t port)
 {
         enum ip_conntrack_info ctinfo;
         struct ip_conntrack *ct = ip_conntrack_get(*pskb, &ctinfo);
         struct {
-                u_int32_t ip;
-                u_int16_t port;
+                __be32 ip;
+                __be16 port;
         } __attribute__ ((__packed__)) buf;
         struct tcphdr _tcph, *th;
 
@@ -86,7 +86,7 @@ static int set_addr(struct sk_buff **pskb,
 static int set_h225_addr(struct sk_buff **pskb,
                          unsigned char **data, int dataoff,
                          TransportAddress * addr,
-                         u_int32_t ip, u_int16_t port)
+                         __be32 ip, u_int16_t port)
 {
         return set_addr(pskb, data, dataoff, addr->ipAddress.ip, ip, port);
 }
@@ -95,7 +95,7 @@ static int set_h225_addr(struct sk_buff **pskb,
 static int set_h245_addr(struct sk_buff **pskb,
                          unsigned char **data, int dataoff,
                          H245_TransportAddress * addr,
-                         u_int32_t ip, u_int16_t port)
+                         __be32 ip, u_int16_t port)
 {
         return set_addr(pskb, data, dataoff,
                         addr->unicastAddress.iPAddress.network, ip, port);
@@ -110,7 +110,7 @@ static int set_sig_addr(struct sk_buff **pskb, struct ip_conntrack *ct,
         struct ip_ct_h323_master *info = &ct->help.ct_h323_info;
         int dir = CTINFO2DIR(ctinfo);
         int i;
-        u_int32_t ip;
+        __be32 ip;
         u_int16_t port;
 
         for (i = 0; i < count; i++) {
@@ -164,7 +164,7 @@ static int set_ras_addr(struct sk_buff **pskb, struct ip_conntrack *ct,
 {
         int dir = CTINFO2DIR(ctinfo);
         int i;
-        u_int32_t ip;
+        __be32 ip;
         u_int16_t port;
 
         for (i = 0; i < count; i++) {
@@ -433,7 +433,7 @@ static int nat_q931(struct sk_buff **pskb, struct ip_conntrack *ct,
         struct ip_ct_h323_master *info = &ct->help.ct_h323_info;
         int dir = CTINFO2DIR(ctinfo);
         u_int16_t nated_port = port;
-        u_int32_t ip;
+        __be32 ip;
 
         /* Set expectations for NAT */
         exp->saved_proto.tcp.port = exp->tuple.dst.u.tcp.port;
diff --git a/net/ipv4/netfilter/ip_nat_helper_pptp.c b/net/ipv4/netfilter/ip_nat_helper_pptp.c
index 2ff578807123..329fdcd7d702 100644
--- a/net/ipv4/netfilter/ip_nat_helper_pptp.c
+++ b/net/ipv4/netfilter/ip_nat_helper_pptp.c
@@ -51,7 +51,7 @@
 
 #define IP_NAT_PPTP_VERSION "3.0"
 
-#define REQ_CID(req, off)               (*(u_int16_t *)((char *)(req) + (off)))
+#define REQ_CID(req, off)               (*(__be16 *)((char *)(req) + (off)))
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Harald Welte <laforge@gnumonks.org>");
diff --git a/net/ipv4/netfilter/ip_nat_proto_icmp.c b/net/ipv4/netfilter/ip_nat_proto_icmp.c
index ec50cc295317..3f6efc13ac74 100644
--- a/net/ipv4/netfilter/ip_nat_proto_icmp.c
+++ b/net/ipv4/netfilter/ip_nat_proto_icmp.c
@@ -67,7 +67,7 @@ icmp_manip_pkt(struct sk_buff **pskb,
 
         hdr = (struct icmphdr *)((*pskb)->data + hdroff);
         hdr->checksum = nf_proto_csum_update(*pskb,
-                                             hdr->un.echo.id ^ 0xFFFF,
+                                             hdr->un.echo.id ^ htons(0xFFFF),
                                              tuple->src.u.icmp.id,
                                              hdr->checksum, 0);
         hdr->un.echo.id = tuple->src.u.icmp.id;
diff --git a/net/ipv4/netfilter/ip_nat_proto_tcp.c b/net/ipv4/netfilter/ip_nat_proto_tcp.c
index 72a6307bd2db..12deb13b93b1 100644
--- a/net/ipv4/netfilter/ip_nat_proto_tcp.c
+++ b/net/ipv4/netfilter/ip_nat_proto_tcp.c
@@ -24,7 +24,7 @@ tcp_in_range(const struct ip_conntrack_tuple *tuple,
              const union ip_conntrack_manip_proto *min,
              const union ip_conntrack_manip_proto *max)
 {
-        u_int16_t port;
+        __be16 port;
 
         if (maniptype == IP_NAT_MANIP_SRC)
                 port = tuple->src.u.tcp.port;
@@ -42,7 +42,7 @@ tcp_unique_tuple(struct ip_conntrack_tuple *tuple,
                  const struct ip_conntrack *conntrack)
 {
         static u_int16_t port;
-        u_int16_t *portptr;
+        __be16 *portptr;
         unsigned int range_size, min, i;
 
         if (maniptype == IP_NAT_MANIP_SRC)
@@ -93,8 +93,8 @@ tcp_manip_pkt(struct sk_buff **pskb,
         struct iphdr *iph = (struct iphdr *)((*pskb)->data + iphdroff);
         struct tcphdr *hdr;
         unsigned int hdroff = iphdroff + iph->ihl*4;
-        u32 oldip, newip;
-        u16 *portptr, newport, oldport;
+        __be32 oldip, newip;
+        __be16 *portptr, newport, oldport;
         int hdrsize = 8; /* TCP connection tracking guarantees this much */
 
         /* this could be a inner header returned in icmp packet; in such
@@ -130,7 +130,7 @@ tcp_manip_pkt(struct sk_buff **pskb,
                 return 1;
 
         hdr->check = nf_proto_csum_update(*pskb, ~oldip, newip, hdr->check, 1);
-        hdr->check = nf_proto_csum_update(*pskb, oldport ^ 0xFFFF, newport,
+        hdr->check = nf_proto_csum_update(*pskb, oldport ^ htons(0xFFFF), newport,
                                           hdr->check, 0);
         return 1;
 }
diff --git a/net/ipv4/netfilter/ip_nat_proto_udp.c b/net/ipv4/netfilter/ip_nat_proto_udp.c
index 5da196ae758c..4bbec7730d18 100644
--- a/net/ipv4/netfilter/ip_nat_proto_udp.c
+++ b/net/ipv4/netfilter/ip_nat_proto_udp.c
@@ -24,7 +24,7 @@ udp_in_range(const struct ip_conntrack_tuple *tuple,
              const union ip_conntrack_manip_proto *min,
              const union ip_conntrack_manip_proto *max)
 {
-        u_int16_t port;
+        __be16 port;
 
         if (maniptype == IP_NAT_MANIP_SRC)
                 port = tuple->src.u.udp.port;
@@ -42,7 +42,7 @@ udp_unique_tuple(struct ip_conntrack_tuple *tuple,
                  const struct ip_conntrack *conntrack)
 {
         static u_int16_t port;
-        u_int16_t *portptr;
+        __be16 *portptr;
         unsigned int range_size, min, i;
 
         if (maniptype == IP_NAT_MANIP_SRC)
@@ -91,8 +91,8 @@ udp_manip_pkt(struct sk_buff **pskb,
         struct iphdr *iph = (struct iphdr *)((*pskb)->data + iphdroff);
         struct udphdr *hdr;
         unsigned int hdroff = iphdroff + iph->ihl*4;
-        u32 oldip, newip;
-        u16 *portptr, newport;
+        __be32 oldip, newip;
+        __be16 *portptr, newport;
 
         if (!skb_make_writable(pskb, hdroff + sizeof(*hdr)))
                 return 0;
@@ -118,7 +118,7 @@ udp_manip_pkt(struct sk_buff **pskb,
                 hdr->check = nf_proto_csum_update(*pskb, ~oldip, newip,
                                                   hdr->check, 1);
                 hdr->check = nf_proto_csum_update(*pskb,
-                                                  *portptr ^ 0xFFFF, newport,
+                                                  *portptr ^ htons(0xFFFF), newport,
                                                   hdr->check, 0);
                 if (!hdr->check)
                         hdr->check = -1;
diff --git a/net/ipv4/netfilter/ip_nat_rule.c b/net/ipv4/netfilter/ip_nat_rule.c
index 7b703839aa58..a176aa3031e0 100644
--- a/net/ipv4/netfilter/ip_nat_rule.c
+++ b/net/ipv4/netfilter/ip_nat_rule.c
@@ -119,7 +119,7 @@ static unsigned int ipt_snat_target(struct sk_buff **pskb,
 }
 
 /* Before 2.6.11 we did implicit source NAT if required. Warn about change. */
-static void warn_if_extra_mangle(u32 dstip, u32 srcip)
+static void warn_if_extra_mangle(__be32 dstip, __be32 srcip)
 {
         static int warned = 0;
         struct flowi fl = { .nl_u = { .ip4_u = { .daddr = dstip } } };
@@ -205,7 +205,7 @@ alloc_null_binding(struct ip_conntrack *conntrack,
            per-proto parts (hence not IP_NAT_RANGE_PROTO_SPECIFIED).
            Use reply in case it's already been mangled (eg local packet).
         */
-        u_int32_t ip
+        __be32 ip
                 = (HOOK2MANIP(hooknum) == IP_NAT_MANIP_SRC
                    ? conntrack->tuplehash[IP_CT_DIR_REPLY].tuple.dst.ip
                    : conntrack->tuplehash[IP_CT_DIR_REPLY].tuple.src.ip);
@@ -222,7 +222,7 @@ alloc_null_binding_confirmed(struct ip_conntrack *conntrack,
                              struct ip_nat_info *info,
                              unsigned int hooknum)
 {
-        u_int32_t ip
+        __be32 ip
                 = (HOOK2MANIP(hooknum) == IP_NAT_MANIP_SRC
                    ? conntrack->tuplehash[IP_CT_DIR_REPLY].tuple.dst.ip
                    : conntrack->tuplehash[IP_CT_DIR_REPLY].tuple.src.ip);
diff --git a/net/ipv4/netfilter/ip_nat_sip.c b/net/ipv4/netfilter/ip_nat_sip.c
index 6ffba63adca2..71fc2730a007 100644
--- a/net/ipv4/netfilter/ip_nat_sip.c
+++ b/net/ipv4/netfilter/ip_nat_sip.c
@@ -60,8 +60,8 @@ static unsigned int ip_nat_sip(struct sk_buff **pskb,
         enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
         char buffer[sizeof("nnn.nnn.nnn.nnn:nnnnn")];
         unsigned int bufflen, dataoff;
-        u_int32_t ip;
-        u_int16_t port;
+        __be32 ip;
+        __be16 port;
 
         dataoff = (*pskb)->nh.iph->ihl*4 + sizeof(struct udphdr);
 
@@ -159,7 +159,7 @@ static int mangle_content_len(struct sk_buff **pskb,
 static unsigned int mangle_sdp(struct sk_buff **pskb,
                                enum ip_conntrack_info ctinfo,
                                struct ip_conntrack *ct,
-                               u_int32_t newip, u_int16_t port,
+                               __be32 newip, u_int16_t port,
                                const char *dptr)
 {
         char buffer[sizeof("nnn.nnn.nnn.nnn")];
@@ -195,7 +195,7 @@ static unsigned int ip_nat_sdp(struct sk_buff **pskb,
 {
         struct ip_conntrack *ct = exp->master;
         enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
-        u_int32_t newip;
+        __be32 newip;
         u_int16_t port;
 
         DEBUGP("ip_nat_sdp():\n");
diff --git a/net/ipv4/netfilter/ip_nat_snmp_basic.c b/net/ipv4/netfilter/ip_nat_snmp_basic.c
index 18b7fbdccb61..168f45fa1898 100644
--- a/net/ipv4/netfilter/ip_nat_snmp_basic.c
+++ b/net/ipv4/netfilter/ip_nat_snmp_basic.c
@@ -1211,7 +1211,7 @@ static int snmp_translate(struct ip_conntrack *ct,
                           struct sk_buff **pskb)
 {
         struct iphdr *iph = (*pskb)->nh.iph;
-        struct udphdr *udph = (struct udphdr *)((u_int32_t *)iph + iph->ihl);
+        struct udphdr *udph = (struct udphdr *)((__be32 *)iph + iph->ihl);
         u_int16_t udplen = ntohs(udph->len);
         u_int16_t paylen = udplen - sizeof(struct udphdr);
         int dir = CTINFO2DIR(ctinfo);
diff --git a/net/ipv4/netfilter/ip_nat_standalone.c b/net/ipv4/netfilter/ip_nat_standalone.c
index 9c577db62047..021395b67463 100644
--- a/net/ipv4/netfilter/ip_nat_standalone.c
+++ b/net/ipv4/netfilter/ip_nat_standalone.c
@@ -191,7 +191,7 @@ ip_nat_in(unsigned int hooknum,
           int (*okfn)(struct sk_buff *))
 {
         unsigned int ret;
-        u_int32_t daddr = (*pskb)->nh.iph->daddr;
+        __be32 daddr = (*pskb)->nh.iph->daddr;
 
         ret = ip_nat_fn(hooknum, pskb, in, out, okfn);
         if (ret != NF_DROP && ret != NF_STOLEN
diff --git a/net/ipv4/netfilter/ipt_CLUSTERIP.c b/net/ipv4/netfilter/ipt_CLUSTERIP.c
index 41589665fc5d..7a29d6e7baa7 100644
--- a/net/ipv4/netfilter/ipt_CLUSTERIP.c
+++ b/net/ipv4/netfilter/ipt_CLUSTERIP.c
@@ -52,7 +52,7 @@ struct clusterip_config {
         atomic_t entries;                       /* number of entries/rules
                                                  * referencing us */
 
-        u_int32_t clusterip;                    /* the IP address */
+        __be32 clusterip;                       /* the IP address */
         u_int8_t clustermac[ETH_ALEN];          /* the MAC address */
         struct net_device *dev;                 /* device */
         u_int16_t num_total_nodes;              /* total number of nodes */
@@ -119,7 +119,7 @@ clusterip_config_entry_put(struct clusterip_config *c)
 }
 
 static struct clusterip_config *
-__clusterip_config_find(u_int32_t clusterip)
+__clusterip_config_find(__be32 clusterip)
 {
         struct list_head *pos;
 
@@ -136,7 +136,7 @@ __clusterip_config_find(u_int32_t clusterip)
 }
 
 static inline struct clusterip_config *
-clusterip_config_find_get(u_int32_t clusterip, int entry)
+clusterip_config_find_get(__be32 clusterip, int entry)
 {
         struct clusterip_config *c;
 
@@ -166,7 +166,7 @@ clusterip_config_init_nodelist(struct clusterip_config *c,
 }
 
 static struct clusterip_config *
-clusterip_config_init(struct ipt_clusterip_tgt_info *i, u_int32_t ip,
+clusterip_config_init(struct ipt_clusterip_tgt_info *i, __be32 ip,
                         struct net_device *dev)
 {
         struct clusterip_config *c;
@@ -387,7 +387,7 @@ checkentry(const char *tablename,
                 return 0;
 
         }
-        if (e->ip.dmsk.s_addr != 0xffffffff
+        if (e->ip.dmsk.s_addr != htonl(0xffffffff)
             || e->ip.dst.s_addr == 0) {
                 printk(KERN_ERR "CLUSTERIP: Please specify destination IP\n");
                 return 0;
@@ -476,9 +476,9 @@ static struct ipt_target clusterip_tgt = {
 /* hardcoded for 48bit ethernet and 32bit ipv4 addresses */
 struct arp_payload {
         u_int8_t src_hw[ETH_ALEN];
-        u_int32_t src_ip;
+        __be32 src_ip;
         u_int8_t dst_hw[ETH_ALEN];
-        u_int32_t dst_ip;
+        __be32 dst_ip;
 } __attribute__ ((packed));
 
 #ifdef CLUSTERIP_DEBUG
diff --git a/net/ipv4/netfilter/ipt_ECN.c b/net/ipv4/netfilter/ipt_ECN.c
index 23f9c7ebe7eb..12a818a2462f 100644
--- a/net/ipv4/netfilter/ipt_ECN.c
+++ b/net/ipv4/netfilter/ipt_ECN.c
@@ -28,7 +28,7 @@ static inline int
 set_ect_ip(struct sk_buff **pskb, const struct ipt_ECN_info *einfo)
 {
         struct iphdr *iph = (*pskb)->nh.iph;
-        u_int16_t oldtos;
+        __be16 oldtos;
 
         if ((iph->tos & IPT_ECN_IP_MASK) != (einfo->ip_ect & IPT_ECN_IP_MASK)) {
                 if (!skb_make_writable(pskb, sizeof(struct iphdr)))
@@ -37,7 +37,7 @@ set_ect_ip(struct sk_buff **pskb, const struct ipt_ECN_info *einfo)
                 oldtos = iph->tos;
                 iph->tos &= ~IPT_ECN_IP_MASK;
                 iph->tos |= (einfo->ip_ect & IPT_ECN_IP_MASK);
-                iph->check = nf_csum_update(oldtos ^ 0xFFFF, iph->tos,
+                iph->check = nf_csum_update(oldtos ^ htons(0xFFFF), iph->tos,
                                             iph->check);
         } 
         return 1;
@@ -48,7 +48,7 @@ static inline int
 set_ect_tcp(struct sk_buff **pskb, const struct ipt_ECN_info *einfo)
 {
         struct tcphdr _tcph, *tcph;
-        u_int16_t oldval;
+        __be16 oldval;
 
         /* Not enought header? */
         tcph = skb_header_pointer(*pskb, (*pskb)->nh.iph->ihl*4,
@@ -66,15 +66,15 @@ set_ect_tcp(struct sk_buff **pskb, const struct ipt_ECN_info *einfo)
                 return 0;
         tcph = (void *)(*pskb)->nh.iph + (*pskb)->nh.iph->ihl*4;
 
-        oldval = ((u_int16_t *)tcph)[6];
+        oldval = ((__be16 *)tcph)[6];
         if (einfo->operation & IPT_ECN_OP_SET_ECE)
                 tcph->ece = einfo->proto.tcp.ece;
         if (einfo->operation & IPT_ECN_OP_SET_CWR)
                 tcph->cwr = einfo->proto.tcp.cwr;
 
         tcph->check = nf_proto_csum_update((*pskb),
-                                           oldval ^ 0xFFFF,
-                                           ((u_int16_t *)tcph)[6],
+                                           oldval ^ htons(0xFFFF),
+                                           ((__be16 *)tcph)[6],
                                            tcph->check, 0);
         return 1;
 }
diff --git a/net/ipv4/netfilter/ipt_MASQUERADE.c b/net/ipv4/netfilter/ipt_MASQUERADE.c
index bc65168a3437..3dbfcfac8a84 100644
--- a/net/ipv4/netfilter/ipt_MASQUERADE.c
+++ b/net/ipv4/netfilter/ipt_MASQUERADE.c
@@ -70,7 +70,7 @@ masquerade_target(struct sk_buff **pskb,
         const struct ip_nat_multi_range_compat *mr;
         struct ip_nat_range newrange;
         struct rtable *rt;
-        u_int32_t newsrc;
+        __be32 newsrc;
 
         IP_NF_ASSERT(hooknum == NF_IP_POST_ROUTING);
 
diff --git a/net/ipv4/netfilter/ipt_NETMAP.c b/net/ipv4/netfilter/ipt_NETMAP.c
index beb2914225ff..58a88f227108 100644
--- a/net/ipv4/netfilter/ipt_NETMAP.c
+++ b/net/ipv4/netfilter/ipt_NETMAP.c
@@ -58,7 +58,7 @@ target(struct sk_buff **pskb,
 {
         struct ip_conntrack *ct;
         enum ip_conntrack_info ctinfo;
-        u_int32_t new_ip, netmask;
+        __be32 new_ip, netmask;
         const struct ip_nat_multi_range_compat *mr = targinfo;
         struct ip_nat_range newrange;
 
diff --git a/net/ipv4/netfilter/ipt_REDIRECT.c b/net/ipv4/netfilter/ipt_REDIRECT.c
index f03d43671c6d..c0dcfe9d610c 100644
--- a/net/ipv4/netfilter/ipt_REDIRECT.c
+++ b/net/ipv4/netfilter/ipt_REDIRECT.c
@@ -61,7 +61,7 @@ redirect_target(struct sk_buff **pskb,
 {
         struct ip_conntrack *ct;
         enum ip_conntrack_info ctinfo;
-        u_int32_t newdst;
+        __be32 newdst;
         const struct ip_nat_multi_range_compat *mr = targinfo;
         struct ip_nat_range newrange;
 
diff --git a/net/ipv4/netfilter/ipt_REJECT.c b/net/ipv4/netfilter/ipt_REJECT.c
index b81821edd893..fd0c05efed8a 100644
--- a/net/ipv4/netfilter/ipt_REJECT.c
+++ b/net/ipv4/netfilter/ipt_REJECT.c
@@ -104,8 +104,8 @@ static void send_reset(struct sk_buff *oldskb, int hook)
         struct iphdr *iph = oldskb->nh.iph;
         struct tcphdr _otcph, *oth, *tcph;
         struct rtable *rt;
-        u_int16_t tmp_port;
-        u_int32_t tmp_addr;
+        __be16 tmp_port;
+        __be32 tmp_addr;
         int needs_ack;
         int hh_len;
 
diff --git a/net/ipv4/netfilter/ipt_SAME.c b/net/ipv4/netfilter/ipt_SAME.c
index efbcb1198832..b38b13328d73 100644
--- a/net/ipv4/netfilter/ipt_SAME.c
+++ b/net/ipv4/netfilter/ipt_SAME.c
@@ -135,7 +135,8 @@ same_target(struct sk_buff **pskb,
 {
         struct ip_conntrack *ct;
         enum ip_conntrack_info ctinfo;
-        u_int32_t tmpip, aindex, new_ip;
+        u_int32_t tmpip, aindex;
+        __be32 new_ip;
         const struct ipt_same_info *same = targinfo;
         struct ip_nat_range newrange;
         const struct ip_conntrack_tuple *t;
diff --git a/net/ipv4/netfilter/ipt_TCPMSS.c b/net/ipv4/netfilter/ipt_TCPMSS.c
index 4246c4321e5b..108b6b76311f 100644
--- a/net/ipv4/netfilter/ipt_TCPMSS.c
+++ b/net/ipv4/netfilter/ipt_TCPMSS.c
@@ -42,7 +42,8 @@ ipt_tcpmss_target(struct sk_buff **pskb,
         const struct ipt_tcpmss_info *tcpmssinfo = targinfo;
         struct tcphdr *tcph;
         struct iphdr *iph;
-        u_int16_t tcplen, newtotlen, oldval, newmss;
+        u_int16_t tcplen, newmss;
+        __be16 newtotlen, oldval;
         unsigned int i;
         u_int8_t *opt;
 
@@ -97,7 +98,7 @@ ipt_tcpmss_target(struct sk_buff **pskb,
                         opt[i+3] = (newmss & 0x00ff);
 
                         tcph->check = nf_proto_csum_update(*pskb,
-                                                           htons(oldmss)^0xFFFF,
+                                                           htons(oldmss)^htons(0xFFFF),
                                                            htons(newmss),
                                                            tcph->check, 0);
                         return IPT_CONTINUE;
@@ -126,7 +127,7 @@ ipt_tcpmss_target(struct sk_buff **pskb,
         memmove(opt + TCPOLEN_MSS, opt, tcplen - sizeof(struct tcphdr));
 
         tcph->check = nf_proto_csum_update(*pskb,
-                                           htons(tcplen) ^ 0xFFFF,
+                                           htons(tcplen) ^ htons(0xFFFF),
                                            htons(tcplen + TCPOLEN_MSS),
                                            tcph->check, 1);
         opt[0] = TCPOPT_MSS;
@@ -134,18 +135,18 @@ ipt_tcpmss_target(struct sk_buff **pskb,
         opt[2] = (newmss & 0xff00) >> 8;
         opt[3] = (newmss & 0x00ff);
 
-        tcph->check = nf_proto_csum_update(*pskb, ~0, *((u_int32_t *)opt),
+        tcph->check = nf_proto_csum_update(*pskb, htonl(~0), *((__be32 *)opt),
                                            tcph->check, 0);
 
-        oldval = ((u_int16_t *)tcph)[6];
+        oldval = ((__be16 *)tcph)[6];
         tcph->doff += TCPOLEN_MSS/4;
         tcph->check = nf_proto_csum_update(*pskb,
-                                           oldval ^ 0xFFFF,
-                                           ((u_int16_t *)tcph)[6],
+                                           oldval ^ htons(0xFFFF),
+                                           ((__be16 *)tcph)[6],
                                            tcph->check, 0);
 
         newtotlen = htons(ntohs(iph->tot_len) + TCPOLEN_MSS);
-        iph->check = nf_csum_update(iph->tot_len ^ 0xFFFF,
+        iph->check = nf_csum_update(iph->tot_len ^ htons(0xFFFF),
                                     newtotlen, iph->check);
         iph->tot_len = newtotlen;
         return IPT_CONTINUE;
diff --git a/net/ipv4/netfilter/ipt_TOS.c b/net/ipv4/netfilter/ipt_TOS.c
index 471a4c438b0a..6b8b14ccc3d3 100644
--- a/net/ipv4/netfilter/ipt_TOS.c
+++ b/net/ipv4/netfilter/ipt_TOS.c
@@ -30,7 +30,7 @@ target(struct sk_buff **pskb,
 {
         const struct ipt_tos_target_info *tosinfo = targinfo;
         struct iphdr *iph = (*pskb)->nh.iph;
-        u_int16_t oldtos;
+        __be16 oldtos;
 
         if ((iph->tos & IPTOS_TOS_MASK) != tosinfo->tos) {
                 if (!skb_make_writable(pskb, sizeof(struct iphdr)))
@@ -38,7 +38,7 @@ target(struct sk_buff **pskb,
                 iph = (*pskb)->nh.iph;
                 oldtos = iph->tos;
                 iph->tos = (iph->tos & IPTOS_PREC_MASK) | tosinfo->tos;
-                iph->check = nf_csum_update(oldtos ^ 0xFFFF, iph->tos,
+                iph->check = nf_csum_update(oldtos ^ htons(0xFFFF), iph->tos,
                                             iph->check);
         }
         return IPT_CONTINUE;
diff --git a/net/ipv4/netfilter/ipt_TTL.c b/net/ipv4/netfilter/ipt_TTL.c
index 96e79cc6d0f2..ac9517d62af0 100644
--- a/net/ipv4/netfilter/ipt_TTL.c
+++ b/net/ipv4/netfilter/ipt_TTL.c
@@ -54,8 +54,8 @@ ipt_ttl_target(struct sk_buff **pskb,
         }
 
         if (new_ttl != iph->ttl) {
-                iph->check = nf_csum_update(ntohs((iph->ttl << 8)) ^ 0xFFFF,
-                                            ntohs(new_ttl << 8),
+                iph->check = nf_csum_update(htons((iph->ttl << 8)) ^ htons(0xFFFF),
+                                            htons(new_ttl << 8),
                                             iph->check);
                 iph->ttl = new_ttl;
         }
diff --git a/net/ipv4/netfilter/ipt_addrtype.c b/net/ipv4/netfilter/ipt_addrtype.c
index 893dae210b04..7b60eb74788b 100644
--- a/net/ipv4/netfilter/ipt_addrtype.c
+++ b/net/ipv4/netfilter/ipt_addrtype.c
@@ -22,7 +22,7 @@ MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
 MODULE_DESCRIPTION("iptables addrtype match");
 
-static inline int match_type(u_int32_t addr, u_int16_t mask)
+static inline int match_type(__be32 addr, u_int16_t mask)
 {
         return !!(mask & (1 << inet_addr_type(addr)));
 }
diff --git a/net/ipv4/netfilter/ipt_hashlimit.c b/net/ipv4/netfilter/ipt_hashlimit.c
index 4f73a61aa3dd..33ccdbf8e794 100644
--- a/net/ipv4/netfilter/ipt_hashlimit.c
+++ b/net/ipv4/netfilter/ipt_hashlimit.c
@@ -50,11 +50,11 @@ static struct file_operations dl_file_ops;
 /* hash table crap */
 
 struct dsthash_dst {
-        u_int32_t src_ip;
-        u_int32_t dst_ip;
+        __be32 src_ip;
+        __be32 dst_ip;
         /* ports have to be consecutive !!! */
-        u_int16_t src_port;
-        u_int16_t dst_port;
+        __be16 src_port;
+        __be16 dst_port;
 };
 
 struct dsthash_ent {
@@ -106,8 +106,10 @@ static inline int dst_cmp(const struct dsthash_ent *ent, struct dsthash_dst *b)
 static inline u_int32_t
 hash_dst(const struct ipt_hashlimit_htable *ht, const struct dsthash_dst *dst)
 {
-        return (jhash_3words(dst->dst_ip, (dst->dst_port<<16 | dst->src_port), 
-                             dst->src_ip, ht->rnd) % ht->cfg.size);
+        return (jhash_3words((__force u32)dst->dst_ip,
+                            ((__force u32)dst->dst_port<<16 |
+                             (__force u32)dst->src_port),
+                             (__force u32)dst->src_ip, ht->rnd) % ht->cfg.size);
 }
 
 static inline struct dsthash_ent *
@@ -406,7 +408,7 @@ hashlimit_match(const struct sk_buff *skb,
                 dst.src_ip = skb->nh.iph->saddr;
         if (hinfo->cfg.mode & IPT_HASHLIMIT_HASH_DPT
             ||hinfo->cfg.mode & IPT_HASHLIMIT_HASH_SPT) {
-                u_int16_t _ports[2], *ports;
+                __be16 _ports[2], *ports;
 
                 switch (skb->nh.iph->protocol) {
                 case IPPROTO_TCP:
diff --git a/net/ipv4/netfilter/ipt_recent.c b/net/ipv4/netfilter/ipt_recent.c
index 32ae8d7ac506..126db44e71a8 100644
--- a/net/ipv4/netfilter/ipt_recent.c
+++ b/net/ipv4/netfilter/ipt_recent.c
@@ -50,11 +50,10 @@ MODULE_PARM_DESC(ip_list_perms, "permissions on /proc/net/ipt_recent/* files");
 MODULE_PARM_DESC(ip_list_uid,"owner of /proc/net/ipt_recent/* files");
 MODULE_PARM_DESC(ip_list_gid,"owning group of /proc/net/ipt_recent/* files");
 
-
 struct recent_entry {
         struct list_head        list;
         struct list_head        lru_list;
-        u_int32_t               addr;
+        __be32                  addr;
         u_int8_t                ttl;
         u_int8_t                index;
         u_int16_t               nstamps;
@@ -85,17 +84,17 @@ static struct file_operations	recent_fops;
 static u_int32_t hash_rnd;
 static int hash_rnd_initted;
 
-static unsigned int recent_entry_hash(u_int32_t addr)
+static unsigned int recent_entry_hash(__be32 addr)
 {
         if (!hash_rnd_initted) {
                 get_random_bytes(&hash_rnd, 4);
                 hash_rnd_initted = 1;
         }
-        return jhash_1word(addr, hash_rnd) & (ip_list_hash_size - 1);
+        return jhash_1word((__force u32)addr, hash_rnd) & (ip_list_hash_size - 1);
 }
 
 static struct recent_entry *
-recent_entry_lookup(const struct recent_table *table, u_int32_t addr, u_int8_t ttl)
+recent_entry_lookup(const struct recent_table *table, __be32 addr, u_int8_t ttl)
 {
         struct recent_entry *e;
         unsigned int h;
@@ -116,7 +115,7 @@ static void recent_entry_remove(struct recent_table *t, struct recent_entry *e)
 }
 
 static struct recent_entry *
-recent_entry_init(struct recent_table *t, u_int32_t addr, u_int8_t ttl)
+recent_entry_init(struct recent_table *t, __be32 addr, u_int8_t ttl)
 {
         struct recent_entry *e;
 
@@ -178,7 +177,7 @@ ipt_recent_match(const struct sk_buff *skb,
         const struct ipt_recent_info *info = matchinfo;
         struct recent_table *t;
         struct recent_entry *e;
-        u_int32_t addr;
+        __be32 addr;
         u_int8_t ttl;
         int ret = info->invert;
 
@@ -406,7 +405,7 @@ static ssize_t recent_proc_write(struct file *file, const char __user *input,
         struct recent_table *t = pde->data;
         struct recent_entry *e;
         char buf[sizeof("+255.255.255.255")], *c = buf;
-        u_int32_t addr;
+        __be32 addr;
         int add;
 
         if (size > sizeof(buf))
diff --git a/net/ipv4/netfilter/iptable_mangle.c b/net/ipv4/netfilter/iptable_mangle.c
index 79336cb42527..e62ea2bb9c0a 100644
--- a/net/ipv4/netfilter/iptable_mangle.c
+++ b/net/ipv4/netfilter/iptable_mangle.c
@@ -131,7 +131,7 @@ ipt_local_hook(unsigned int hook,
 {
         unsigned int ret;
         u_int8_t tos;
-        u_int32_t saddr, daddr;
+        __be32 saddr, daddr;
         unsigned long nfmark;
 
         /* root is playing with raw sockets. */
diff --git a/net/ipv4/raw.c b/net/ipv4/raw.c
index 0e935b4c8741..b430cf2a4f66 100644
--- a/net/ipv4/raw.c
+++ b/net/ipv4/raw.c
@@ -381,8 +381,8 @@ static int raw_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
         struct ipcm_cookie ipc;
         struct rtable *rt = NULL;
         int free = 0;
-        u32 daddr;
-        u32 saddr;
+        __be32 daddr;
+        __be32 saddr;
         u8  tos;
         int err;
 
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index 20ffe8e88c0f..c41ddba02e9d 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -261,6 +261,10 @@ static unsigned int rt_hash_code(u32 daddr, u32 saddr)
                 & rt_hash_mask);
 }
 
+#define rt_hash(daddr, saddr, idx) \
+        rt_hash_code((__force u32)(__be32)(daddr),\
+                     (__force u32)(__be32)(saddr) ^ ((idx) << 5))
+
 #ifdef CONFIG_PROC_FS
 struct rt_cache_iter_state {
         int bucket;
@@ -1074,7 +1078,7 @@ static void ip_select_fb_ident(struct iphdr *iph)
         u32 salt;
 
         spin_lock_bh(&ip_fb_id_lock);
-        salt = secure_ip_id(ip_fallback_id ^ iph->daddr);
+        salt = secure_ip_id((__force __be32)ip_fallback_id ^ iph->daddr);
         iph->id = htons(salt & 0xFFFF);
         ip_fallback_id = salt;
         spin_unlock_bh(&ip_fb_id_lock);
@@ -1118,13 +1122,13 @@ static void rt_del(unsigned hash, struct rtable *rt)
         spin_unlock_bh(rt_hash_lock_addr(hash));
 }
 
-void ip_rt_redirect(u32 old_gw, u32 daddr, u32 new_gw,
-                    u32 saddr, struct net_device *dev)
+void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw,
+                    __be32 saddr, struct net_device *dev)
 {
         int i, k;
         struct in_device *in_dev = in_dev_get(dev);
         struct rtable *rth, **rthp;
-        u32  skeys[2] = { saddr, 0 };
+        __be32  skeys[2] = { saddr, 0 };
         int  ikeys[2] = { dev->ifindex, 0 };
         struct netevent_redirect netevent;
 
@@ -1147,8 +1151,7 @@ void ip_rt_redirect(u32 old_gw, u32 daddr, u32 new_gw,
 
         for (i = 0; i < 2; i++) {
                 for (k = 0; k < 2; k++) {
-                        unsigned hash = rt_hash_code(daddr,
-                                                     skeys[i] ^ (ikeys[k] << 5));
+                        unsigned hash = rt_hash(daddr, skeys[i], ikeys[k]);
 
                         rthp=&rt_hash_table[hash].chain;
 
@@ -1260,9 +1263,8 @@ static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
                         ret = NULL;
                 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
                            rt->u.dst.expires) {
-                        unsigned hash = rt_hash_code(rt->fl.fl4_dst,
-                                                     rt->fl.fl4_src ^
-                                                        (rt->fl.oif << 5));
+                        unsigned hash = rt_hash(rt->fl.fl4_dst, rt->fl.fl4_src,
+                                                rt->fl.oif);
 #if RT_CACHE_DEBUG >= 1
                         printk(KERN_DEBUG "ip_rt_advice: redirect to "
                                           "%u.%u.%u.%u/%02x dropped\n",
@@ -1397,15 +1399,15 @@ unsigned short ip_rt_frag_needed(struct iphdr *iph, unsigned short new_mtu)
         int i;
         unsigned short old_mtu = ntohs(iph->tot_len);
         struct rtable *rth;
-        u32  skeys[2] = { iph->saddr, 0, };
-        u32  daddr = iph->daddr;
+        __be32  skeys[2] = { iph->saddr, 0, };
+        __be32  daddr = iph->daddr;
         unsigned short est_mtu = 0;
 
         if (ipv4_config.no_pmtu_disc)
                 return 0;
 
         for (i = 0; i < 2; i++) {
-                unsigned hash = rt_hash_code(daddr, skeys[i]);
+                unsigned hash = rt_hash(daddr, skeys[i], 0);
 
                 rcu_read_lock();
                 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
@@ -1530,7 +1532,7 @@ static int ip_rt_bug(struct sk_buff *skb)
 
 void ip_rt_get_source(u8 *addr, struct rtable *rt)
 {
-        u32 src;
+        __be32 src;
         struct fib_result res;
 
         if (rt->fl.iif == 0)
@@ -1596,12 +1598,12 @@ static void rt_set_nexthop(struct rtable *rt, struct fib_result *res, u32 itag)
         rt->rt_type = res->type;
 }
 
-static int ip_route_input_mc(struct sk_buff *skb, u32 daddr, u32 saddr,
+static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
                                 u8 tos, struct net_device *dev, int our)
 {
         unsigned hash;
         struct rtable *rth;
-        u32 spec_dst;
+        __be32 spec_dst;
         struct in_device *in_dev = in_dev_get(dev);
         u32 itag = 0;
 
@@ -1665,7 +1667,7 @@ static int ip_route_input_mc(struct sk_buff *skb, u32 daddr, u32 saddr,
         RT_CACHE_STAT_INC(in_slow_mc);
 
         in_dev_put(in_dev);
-        hash = rt_hash_code(daddr, saddr ^ (dev->ifindex << 5));
+        hash = rt_hash(daddr, saddr, dev->ifindex);
         return rt_intern_hash(hash, rth, (struct rtable**) &skb->dst);
 
 e_nobufs:
@@ -1681,8 +1683,8 @@ e_inval:
 static void ip_handle_martian_source(struct net_device *dev,
                                      struct in_device *in_dev,
                                      struct sk_buff *skb,
-                                     u32 daddr,
-                                     u32 saddr) 
+                                     __be32 daddr,
+                                     __be32 saddr)
 {
         RT_CACHE_STAT_INC(in_martian_src);
 #ifdef CONFIG_IP_ROUTE_VERBOSE
@@ -1712,7 +1714,7 @@ static void ip_handle_martian_source(struct net_device *dev,
 static inline int __mkroute_input(struct sk_buff *skb, 
                                   struct fib_result* res, 
                                   struct in_device *in_dev, 
-                                  u32 daddr, u32 saddr, u32 tos, 
+                                  __be32 daddr, __be32 saddr, u32 tos,
                                   struct rtable **result) 
 {
 
@@ -1720,7 +1722,8 @@ static inline int __mkroute_input(struct sk_buff *skb,
         int err;
         struct in_device *out_dev;
         unsigned flags = 0;
-        u32 spec_dst, itag;
+        __be32 spec_dst;
+        u32 itag;
 
         /* get a working reference to the output device */
         out_dev = in_dev_get(FIB_RES_DEV(*res));
@@ -1813,7 +1816,7 @@ static inline int ip_mkroute_input_def(struct sk_buff *skb,
                                        struct fib_result* res, 
                                        const struct flowi *fl,
                                        struct in_device *in_dev,
-                                       u32 daddr, u32 saddr, u32 tos)
+                                       __be32 daddr, __be32 saddr, u32 tos)
 {
         struct rtable* rth = NULL;
         int err;
@@ -1830,7 +1833,7 @@ static inline int ip_mkroute_input_def(struct sk_buff *skb,
                 return err;
 
         /* put it into the cache */
-        hash = rt_hash_code(daddr, saddr ^ (fl->iif << 5));
+        hash = rt_hash(daddr, saddr, fl->iif);
         return rt_intern_hash(hash, rth, (struct rtable**)&skb->dst);   
 }
 
@@ -1838,7 +1841,7 @@ static inline int ip_mkroute_input(struct sk_buff *skb,
                                    struct fib_result* res, 
                                    const struct flowi *fl,
                                    struct in_device *in_dev,
-                                   u32 daddr, u32 saddr, u32 tos)
+                                   __be32 daddr, __be32 saddr, u32 tos)
 {
 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
         struct rtable* rth = NULL, *rtres;
@@ -1871,7 +1874,7 @@ static inline int ip_mkroute_input(struct sk_buff *skb,
                         return err;
 
                 /* put it into the cache */
-                hash = rt_hash_code(daddr, saddr ^ (fl->iif << 5));
+                hash = rt_hash(daddr, saddr, fl->iif);
                 err = rt_intern_hash(hash, rth, &rtres);
                 if (err)
                         return err;
@@ -1901,7 +1904,7 @@ static inline int ip_mkroute_input(struct sk_buff *skb,
  *      2. IP spoofing attempts are filtered with 100% of guarantee.
  */
 
-static int ip_route_input_slow(struct sk_buff *skb, u32 daddr, u32 saddr,
+static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
                                u8 tos, struct net_device *dev)
 {
         struct fib_result res;
@@ -1920,7 +1923,7 @@ static int ip_route_input_slow(struct sk_buff *skb, u32 daddr, u32 saddr,
         u32             itag = 0;
         struct rtable * rth;
         unsigned        hash;
-        u32             spec_dst;
+        __be32          spec_dst;
         int             err = -EINVAL;
         int             free_res = 0;
 
@@ -1936,7 +1939,7 @@ static int ip_route_input_slow(struct sk_buff *skb, u32 daddr, u32 saddr,
         if (MULTICAST(saddr) || BADCLASS(saddr) || LOOPBACK(saddr))
                 goto martian_source;
 
-        if (daddr == 0xFFFFFFFF || (saddr == 0 && daddr == 0))
+        if (daddr == htonl(0xFFFFFFFF) || (saddr == 0 && daddr == 0))
                 goto brd_input;
 
         /* Accept zero addresses only to limited broadcast;
@@ -2048,7 +2051,7 @@ local_input:
                 rth->rt_flags   &= ~RTCF_LOCAL;
         }
         rth->rt_type    = res.type;
-        hash = rt_hash_code(daddr, saddr ^ (fl.iif << 5));
+        hash = rt_hash(daddr, saddr, fl.iif);
         err = rt_intern_hash(hash, rth, (struct rtable**)&skb->dst);
         goto done;
 
@@ -2087,7 +2090,7 @@ martian_source:
         goto e_inval;
 }
 
-int ip_route_input(struct sk_buff *skb, u32 daddr, u32 saddr,
+int ip_route_input(struct sk_buff *skb, __be32 daddr, __be32 saddr,
                    u8 tos, struct net_device *dev)
 {
         struct rtable * rth;
@@ -2095,7 +2098,7 @@ int ip_route_input(struct sk_buff *skb, u32 daddr, u32 saddr,
         int iif = dev->ifindex;
 
         tos &= IPTOS_RT_MASK;
-        hash = rt_hash_code(daddr, saddr ^ (iif << 5));
+        hash = rt_hash(daddr, saddr, iif);
 
         rcu_read_lock();
         for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
@@ -2169,7 +2172,7 @@ static inline int __mkroute_output(struct rtable **result,
         if (LOOPBACK(fl->fl4_src) && !(dev_out->flags&IFF_LOOPBACK))
                 return -EINVAL;
 
-        if (fl->fl4_dst == 0xFFFFFFFF)
+        if (fl->fl4_dst == htonl(0xFFFFFFFF))
                 res->type = RTN_BROADCAST;
         else if (MULTICAST(fl->fl4_dst))
                 res->type = RTN_MULTICAST;
@@ -2293,8 +2296,7 @@ static inline int ip_mkroute_output_def(struct rtable **rp,
         int err = __mkroute_output(&rth, res, fl, oldflp, dev_out, flags);
         unsigned hash;
         if (err == 0) {
-                hash = rt_hash_code(oldflp->fl4_dst, 
-                                    oldflp->fl4_src ^ (oldflp->oif << 5));
+                hash = rt_hash(oldflp->fl4_dst, oldflp->fl4_src, oldflp->oif);
                 err = rt_intern_hash(hash, rth, rp);
         }
         
@@ -2336,9 +2338,8 @@ static inline int ip_mkroute_output(struct rtable** rp,
                         if (err != 0)
                                 goto cleanup;
 
-                        hash = rt_hash_code(oldflp->fl4_dst, 
-                                            oldflp->fl4_src ^
-                                            (oldflp->oif << 5));
+                        hash = rt_hash(oldflp->fl4_dst, oldflp->fl4_src,
+                                        oldflp->oif);
                         err = rt_intern_hash(hash, rth, rp);
 
                         /* forward hop information to multipath impl. */
@@ -2417,7 +2418,7 @@ static int ip_route_output_slow(struct rtable **rp, const struct flowi *oldflp)
                  */
 
                 if (oldflp->oif == 0
-                    && (MULTICAST(oldflp->fl4_dst) || oldflp->fl4_dst == 0xFFFFFFFF)) {
+                    && (MULTICAST(oldflp->fl4_dst) || oldflp->fl4_dst == htonl(0xFFFFFFFF))) {
                         /* Special hack: user can direct multicasts
                            and limited broadcast via necessary interface
                            without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
@@ -2454,7 +2455,7 @@ static int ip_route_output_slow(struct rtable **rp, const struct flowi *oldflp)
                         goto out;       /* Wrong error code */
                 }
 
-                if (LOCAL_MCAST(oldflp->fl4_dst) || oldflp->fl4_dst == 0xFFFFFFFF) {
+                if (LOCAL_MCAST(oldflp->fl4_dst) || oldflp->fl4_dst == htonl(0xFFFFFFFF)) {
                         if (!fl.fl4_src)
                                 fl.fl4_src = inet_select_addr(dev_out, 0,
                                                               RT_SCOPE_LINK);
@@ -2567,7 +2568,7 @@ int __ip_route_output_key(struct rtable **rp, const struct flowi *flp)
         unsigned hash;
         struct rtable *rth;
 
-        hash = rt_hash_code(flp->fl4_dst, flp->fl4_src ^ (flp->oif << 5));
+        hash = rt_hash(flp->fl4_dst, flp->fl4_src, flp->oif);
 
         rcu_read_lock_bh();
         for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
@@ -2660,11 +2661,11 @@ static int rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
         if (rt->rt_flags & RTCF_NOTIFY)
                 r->rtm_flags |= RTM_F_NOTIFY;
 
-        NLA_PUT_U32(skb, RTA_DST, rt->rt_dst);
+        NLA_PUT_BE32(skb, RTA_DST, rt->rt_dst);
 
         if (rt->fl.fl4_src) {
                 r->rtm_src_len = 32;
-                NLA_PUT_U32(skb, RTA_SRC, rt->fl.fl4_src);
+                NLA_PUT_BE32(skb, RTA_SRC, rt->fl.fl4_src);
         }
         if (rt->u.dst.dev)
                 NLA_PUT_U32(skb, RTA_OIF, rt->u.dst.dev->ifindex);
@@ -2677,12 +2678,12 @@ static int rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
                 NLA_PUT_U32(skb, RTA_MP_ALGO, rt->rt_multipath_alg);
 #endif
         if (rt->fl.iif)
-                NLA_PUT_U32(skb, RTA_PREFSRC, rt->rt_spec_dst);
+                NLA_PUT_BE32(skb, RTA_PREFSRC, rt->rt_spec_dst);
         else if (rt->rt_src != rt->fl.fl4_src)
-                NLA_PUT_U32(skb, RTA_PREFSRC, rt->rt_src);
+                NLA_PUT_BE32(skb, RTA_PREFSRC, rt->rt_src);
 
         if (rt->rt_dst != rt->rt_gateway)
-                NLA_PUT_U32(skb, RTA_GATEWAY, rt->rt_gateway);
+                NLA_PUT_BE32(skb, RTA_GATEWAY, rt->rt_gateway);
 
         if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
                 goto nla_put_failure;
@@ -2706,7 +2707,7 @@ static int rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
 
         if (rt->fl.iif) {
 #ifdef CONFIG_IP_MROUTE
-                u32 dst = rt->rt_dst;
+                __be32 dst = rt->rt_dst;
 
                 if (MULTICAST(dst) && !LOCAL_MCAST(dst) &&
                     ipv4_devconf.mc_forwarding) {
@@ -2740,7 +2741,9 @@ int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
         struct rtmsg *rtm;
         struct nlattr *tb[RTA_MAX+1];
         struct rtable *rt = NULL;
-        u32 dst, src, iif;
+        __be32 dst = 0;
+        __be32 src = 0;
+        u32 iif;
         int err;
         struct sk_buff *skb;
 
@@ -2765,8 +2768,8 @@ int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
         skb->nh.iph->protocol = IPPROTO_ICMP;
         skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
 
-        src = tb[RTA_SRC] ? nla_get_u32(tb[RTA_SRC]) : 0;
-        dst = tb[RTA_DST] ? nla_get_u32(tb[RTA_DST]) : 0;
+        src = tb[RTA_SRC] ? nla_get_be32(tb[RTA_SRC]) : 0;
+        dst = tb[RTA_DST] ? nla_get_be32(tb[RTA_DST]) : 0;
         iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
 
         if (iif) {
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index b3def0df14fb..3f884cea14ff 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -935,7 +935,7 @@ tcp_sacktag_write_queue(struct sock *sk, struct sk_buff *ack_skb, u32 prior_snd_
         const struct inet_connection_sock *icsk = inet_csk(sk);
         struct tcp_sock *tp = tcp_sk(sk);
         unsigned char *ptr = ack_skb->h.raw + TCP_SKB_CB(ack_skb)->sacked;
-        struct tcp_sack_block *sp = (struct tcp_sack_block *)(ptr+2);
+        struct tcp_sack_block_wire *sp = (struct tcp_sack_block_wire *)(ptr+2);
         int num_sacks = (ptr[1] - TCPOLEN_SACK_BASE)>>3;
         int reord = tp->packets_out;
         int prior_fackets;
@@ -2239,13 +2239,12 @@ static int tcp_tso_acked(struct sock *sk, struct sk_buff *skb,
         return acked;
 }
 
-static u32 tcp_usrtt(const struct sk_buff *skb)
+static u32 tcp_usrtt(struct timeval *tv)
 {
-        struct timeval tv, now;
+        struct timeval now;
 
         do_gettimeofday(&now);
-        skb_get_timestamp(skb, &tv);
-        return (now.tv_sec - tv.tv_sec) * 1000000 + (now.tv_usec - tv.tv_usec);
+        return (now.tv_sec - tv->tv_sec) * 1000000 + (now.tv_usec - tv->tv_usec);
 }
 
 /* Remove acknowledged frames from the retransmission queue. */
@@ -2260,6 +2259,7 @@ static int tcp_clean_rtx_queue(struct sock *sk, __s32 *seq_rtt_p)
         u32 pkts_acked = 0;
         void (*rtt_sample)(struct sock *sk, u32 usrtt)
                 = icsk->icsk_ca_ops->rtt_sample;
+        struct timeval tv;
 
         while ((skb = skb_peek(&sk->sk_write_queue)) &&
                skb != sk->sk_send_head) {
@@ -2308,8 +2308,7 @@ static int tcp_clean_rtx_queue(struct sock *sk, __s32 *seq_rtt_p)
                                 seq_rtt = -1;
                         } else if (seq_rtt < 0) {
                                 seq_rtt = now - scb->when;
-                                if (rtt_sample)
-                                        (*rtt_sample)(sk, tcp_usrtt(skb));
+                                skb_get_timestamp(skb, &tv);
                         }
                         if (sacked & TCPCB_SACKED_ACKED)
                                 tp->sacked_out -= tcp_skb_pcount(skb);
@@ -2322,8 +2321,7 @@ static int tcp_clean_rtx_queue(struct sock *sk, __s32 *seq_rtt_p)
                         }
                 } else if (seq_rtt < 0) {
                         seq_rtt = now - scb->when;
-                        if (rtt_sample)
-                                (*rtt_sample)(sk, tcp_usrtt(skb));
+                        skb_get_timestamp(skb, &tv);
                 }
                 tcp_dec_pcount_approx(&tp->fackets_out, skb);
                 tcp_packets_out_dec(tp, skb);
@@ -2335,6 +2333,8 @@ static int tcp_clean_rtx_queue(struct sock *sk, __s32 *seq_rtt_p)
         if (acked&FLAG_ACKED) {
                 tcp_ack_update_rtt(sk, acked, seq_rtt);
                 tcp_ack_packets_out(sk, tp);
+                if (rtt_sample && !(acked & FLAG_RETRANS_DATA_ACKED))
+                        (*rtt_sample)(sk, tcp_usrtt(&tv));
 
                 if (icsk->icsk_ca_ops->pkts_acked)
                         icsk->icsk_ca_ops->pkts_acked(sk, pkts_acked);
@@ -2629,7 +2629,7 @@ void tcp_parse_options(struct sk_buff *skb, struct tcp_options_received *opt_rx,
                                 switch(opcode) {
                                 case TCPOPT_MSS:
                                         if(opsize==TCPOLEN_MSS && th->syn && !estab) {
-                                                u16 in_mss = ntohs(get_unaligned((__u16 *)ptr));
+                                                u16 in_mss = ntohs(get_unaligned((__be16 *)ptr));
                                                 if (in_mss) {
                                                         if (opt_rx->user_mss && opt_rx->user_mss < in_mss)
                                                                 in_mss = opt_rx->user_mss;
@@ -2657,8 +2657,8 @@ void tcp_parse_options(struct sk_buff *skb, struct tcp_options_received *opt_rx,
                                                 if ((estab && opt_rx->tstamp_ok) ||
                                                     (!estab && sysctl_tcp_timestamps)) {
                                                         opt_rx->saw_tstamp = 1;
-                                                        opt_rx->rcv_tsval = ntohl(get_unaligned((__u32 *)ptr));
-                                                        opt_rx->rcv_tsecr = ntohl(get_unaligned((__u32 *)(ptr+4)));
+                                                        opt_rx->rcv_tsval = ntohl(get_unaligned((__be32 *)ptr));
+                                                        opt_rx->rcv_tsecr = ntohl(get_unaligned((__be32 *)(ptr+4)));
                                                 }
                                         }
                                         break;
@@ -2695,8 +2695,8 @@ static int tcp_fast_parse_options(struct sk_buff *skb, struct tcphdr *th,
                 return 0;
         } else if (tp->rx_opt.tstamp_ok &&
                    th->doff == (sizeof(struct tcphdr)>>2)+(TCPOLEN_TSTAMP_ALIGNED>>2)) {
-                __u32 *ptr = (__u32 *)(th + 1);
-                if (*ptr == ntohl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16)
+                __be32 *ptr = (__be32 *)(th + 1);
+                if (*ptr == htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16)
                                   | (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP)) {
                         tp->rx_opt.saw_tstamp = 1;
                         ++ptr;
@@ -3911,10 +3911,10 @@ int tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
 
                 /* Check timestamp */
                 if (tcp_header_len == sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) {
-                        __u32 *ptr = (__u32 *)(th + 1);
+                        __be32 *ptr = (__be32 *)(th + 1);
 
                         /* No? Slow path! */
-                        if (*ptr != ntohl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16)
+                        if (*ptr != htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16)
                                           | (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP))
                                 goto slow_path;
 
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 39b179856082..c83938b8fcb1 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -159,7 +159,7 @@ int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
         struct tcp_sock *tp = tcp_sk(sk);
         struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
         struct rtable *rt;
-        u32 daddr, nexthop;
+        __be32 daddr, nexthop;
         int tmp;
         int err;
 
@@ -734,8 +734,8 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
         struct inet_request_sock *ireq;
         struct tcp_options_received tmp_opt;
         struct request_sock *req;
-        __u32 saddr = skb->nh.iph->saddr;
-        __u32 daddr = skb->nh.iph->daddr;
+        __be32 saddr = skb->nh.iph->saddr;
+        __be32 daddr = skb->nh.iph->daddr;
         __u32 isn = TCP_SKB_CB(skb)->when;
         struct dst_entry *dst = NULL;
 #ifdef CONFIG_SYN_COOKIES
@@ -1763,7 +1763,7 @@ static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
 
 static void get_timewait4_sock(struct inet_timewait_sock *tw, char *tmpbuf, int i)
 {
-        unsigned int dest, src;
+        __be32 dest, src;
         __u16 destp, srcp;
         int ttd = tw->tw_ttd - jiffies;
 
diff --git a/net/ipv4/tcp_lp.c b/net/ipv4/tcp_lp.c
index 308fb7e071c5..f0ebaf0e21cb 100644
--- a/net/ipv4/tcp_lp.c
+++ b/net/ipv4/tcp_lp.c
@@ -31,8 +31,6 @@
  *   Hung Hing Lun, Mike <hlhung3i@gmail.com>
  * SourceForge project page:
  *   http://tcp-lp-mod.sourceforge.net/
- *
- * Version: $Id: tcp_lp.c,v 1.24 2006/09/05 20:22:53 hswong3i Exp $
  */
 
 #include <linux/module.h>
@@ -164,7 +162,7 @@ static u32 tcp_lp_remote_hz_estimator(struct sock *sk)
 
  out:
         /* record time for successful remote HZ calc */
-        if (rhz > 0)
+        if ((rhz >> 6) > 0)
                 lp->flag |= LP_VALID_RHZ;
         else
                 lp->flag &= ~LP_VALID_RHZ;
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 061edfae0c29..9a253faefc81 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -269,7 +269,7 @@ static u16 tcp_select_window(struct sock *sk)
         return new_win;
 }
 
-static void tcp_build_and_update_options(__u32 *ptr, struct tcp_sock *tp,
+static void tcp_build_and_update_options(__be32 *ptr, struct tcp_sock *tp,
                                          __u32 tstamp)
 {
         if (tp->rx_opt.tstamp_ok) {
@@ -305,7 +305,7 @@ static void tcp_build_and_update_options(__u32 *ptr, struct tcp_sock *tp,
  * MAX_SYN_SIZE to match the new maximum number of options that you
  * can generate.
  */
-static void tcp_syn_build_options(__u32 *ptr, int mss, int ts, int sack,
+static void tcp_syn_build_options(__be32 *ptr, int mss, int ts, int sack,
                                   int offer_wscale, int wscale, __u32 tstamp,
                                   __u32 ts_recent)
 {
@@ -424,7 +424,7 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
         th->dest                = inet->dport;
         th->seq                 = htonl(tcb->seq);
         th->ack_seq             = htonl(tp->rcv_nxt);
-        *(((__u16 *)th) + 6)    = htons(((tcp_header_size >> 2) << 12) |
+        *(((__be16 *)th) + 6)   = htons(((tcp_header_size >> 2) << 12) |
                                         tcb->flags);
 
         if (unlikely(tcb->flags & TCPCB_FLAG_SYN)) {
@@ -445,7 +445,7 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
         }
 
         if (unlikely(tcb->flags & TCPCB_FLAG_SYN)) {
-                tcp_syn_build_options((__u32 *)(th + 1),
+                tcp_syn_build_options((__be32 *)(th + 1),
                                       tcp_advertise_mss(sk),
                                       (sysctl_flags & SYSCTL_FLAG_TSTAMPS),
                                       (sysctl_flags & SYSCTL_FLAG_SACK),
@@ -454,7 +454,7 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
                                       tcb->when,
                                       tp->rx_opt.ts_recent);
         } else {
-                tcp_build_and_update_options((__u32 *)(th + 1),
+                tcp_build_and_update_options((__be32 *)(th + 1),
                                              tp, tcb->when);
                 TCP_ECN_send(sk, tp, skb, tcp_header_size);
         }
@@ -2070,7 +2070,7 @@ struct sk_buff * tcp_make_synack(struct sock *sk, struct dst_entry *dst,
         th->window = htons(req->rcv_wnd);
 
         TCP_SKB_CB(skb)->when = tcp_time_stamp;
-        tcp_syn_build_options((__u32 *)(th + 1), dst_metric(dst, RTAX_ADVMSS), ireq->tstamp_ok,
+        tcp_syn_build_options((__be32 *)(th + 1), dst_metric(dst, RTAX_ADVMSS), ireq->tstamp_ok,
                               ireq->sack_ok, ireq->wscale_ok, ireq->rcv_wscale,
                               TCP_SKB_CB(skb)->when,
                               req->ts_recent);
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 77e265d7bb8f..6d6142f9c478 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -243,8 +243,8 @@ static void udp_v4_unhash(struct sock *sk)
 /* UDP is nearly always wildcards out the wazoo, it makes no sense to try
  * harder than this. -DaveM
  */
-static struct sock *udp_v4_lookup_longway(u32 saddr, u16 sport,
-                                          u32 daddr, u16 dport, int dif)
+static struct sock *udp_v4_lookup_longway(__be32 saddr, __be16 sport,
+                                          __be32 daddr, __be16 dport, int dif)
 {
         struct sock *sk, *result = NULL;
         struct hlist_node *node;
@@ -288,8 +288,8 @@ static struct sock *udp_v4_lookup_longway(u32 saddr, u16 sport,
         return result;
 }
 
-static __inline__ struct sock *udp_v4_lookup(u32 saddr, u16 sport,
-                                             u32 daddr, u16 dport, int dif)
+static __inline__ struct sock *udp_v4_lookup(__be32 saddr, __be16 sport,
+                                             __be32 daddr, __be16 dport, int dif)
 {
         struct sock *sk;
 
@@ -302,8 +302,8 @@ static __inline__ struct sock *udp_v4_lookup(u32 saddr, u16 sport,
 }
 
 static inline struct sock *udp_v4_mcast_next(struct sock *sk,
-                                             u16 loc_port, u32 loc_addr,
-                                             u16 rmt_port, u32 rmt_addr,
+                                             __be16 loc_port, __be32 loc_addr,
+                                             __be16 rmt_port, __be32 rmt_addr,
                                              int dif)
 {
         struct hlist_node *node;
@@ -498,7 +498,7 @@ out:
 }
 
 
-static unsigned short udp_check(struct udphdr *uh, int len, unsigned long saddr, unsigned long daddr, unsigned long base)
+static unsigned short udp_check(struct udphdr *uh, int len, __be32 saddr, __be32 daddr, unsigned long base)
 {
         return(csum_tcpudp_magic(saddr, daddr, len, IPPROTO_UDP, base));
 }
@@ -513,8 +513,8 @@ int udp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
         struct rtable *rt = NULL;
         int free = 0;
         int connected = 0;
-        u32 daddr, faddr, saddr;
-        u16 dport;
+        __be32 daddr, faddr, saddr;
+        __be16 dport;
         u8  tos;
         int err;
         int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
@@ -931,7 +931,7 @@ static int udp_encap_rcv(struct sock * sk, struct sk_buff *skb)
         int iphlen, len;
   
         __u8 *udpdata = (__u8 *)uh + sizeof(struct udphdr);
-        __u32 *udpdata32 = (__u32 *)udpdata;
+        __be32 *udpdata32 = (__be32 *)udpdata;
         __u16 encap_type = up->encap_type;
 
         /* if we're overly short, let UDP handle it */
@@ -1080,7 +1080,7 @@ static int udp_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
  *      so we don't need to lock the hashes.
  */
 static int udp_v4_mcast_deliver(struct sk_buff *skb, struct udphdr *uh,
-                                 u32 saddr, u32 daddr)
+                                 __be32 saddr, __be32 daddr)
 {
         struct sock *sk;
         int dif;
@@ -1121,7 +1121,7 @@ static int udp_v4_mcast_deliver(struct sk_buff *skb, struct udphdr *uh,
  * including udp header and folding it to skb->csum.
  */
 static void udp_checksum_init(struct sk_buff *skb, struct udphdr *uh,
-                             unsigned short ulen, u32 saddr, u32 daddr)
+                             unsigned short ulen, __be32 saddr, __be32 daddr)
 {
         if (uh->check == 0) {
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
@@ -1146,8 +1146,8 @@ int udp_rcv(struct sk_buff *skb)
         struct udphdr *uh;
         unsigned short ulen;
         struct rtable *rt = (struct rtable*)skb->dst;
-        u32 saddr = skb->nh.iph->saddr;
-        u32 daddr = skb->nh.iph->daddr;
+        __be32 saddr = skb->nh.iph->saddr;
+        __be32 daddr = skb->nh.iph->daddr;
         int len = skb->len;
 
         /*
@@ -1563,8 +1563,8 @@ void udp_proc_unregister(struct udp_seq_afinfo *afinfo)
 static void udp4_format_sock(struct sock *sp, char *tmpbuf, int bucket)
 {
         struct inet_sock *inet = inet_sk(sp);
-        unsigned int dest = inet->daddr;
-        unsigned int src  = inet->rcv_saddr;
+        __be32 dest = inet->daddr;
+        __be32 src  = inet->rcv_saddr;
         __u16 destp       = ntohs(inet->dport);
         __u16 srcp        = ntohs(inet->sport);
 
diff --git a/net/ipv4/xfrm4_input.c b/net/ipv4/xfrm4_input.c
index 040e8475f295..8655d038364c 100644
--- a/net/ipv4/xfrm4_input.c
+++ b/net/ipv4/xfrm4_input.c
@@ -23,7 +23,7 @@ int xfrm4_rcv(struct sk_buff *skb)
 
 EXPORT_SYMBOL(xfrm4_rcv);
 
-static int xfrm4_parse_spi(struct sk_buff *skb, u8 nexthdr, u32 *spi, u32 *seq)
+static int xfrm4_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq)
 {
         switch (nexthdr) {
         case IPPROTO_IPIP:
@@ -55,7 +55,7 @@ drop:
 int xfrm4_rcv_encap(struct sk_buff *skb, __u16 encap_type)
 {
         int err;
-        u32 spi, seq;
+        __be32 spi, seq;
         struct xfrm_state *xfrm_vec[XFRM_MAX_DEPTH];
         struct xfrm_state *x;
         int xfrm_nr = 0;
diff --git a/net/ipv4/xfrm4_policy.c b/net/ipv4/xfrm4_policy.c
index eabcd27b1767..7a7a00147e55 100644
--- a/net/ipv4/xfrm4_policy.c
+++ b/net/ipv4/xfrm4_policy.c
@@ -221,7 +221,7 @@ _decode_session4(struct sk_buff *skb, struct flowi *fl)
 
                 case IPPROTO_ESP:
                         if (pskb_may_pull(skb, xprth + 4 - skb->data)) {
-                                u32 *ehdr = (u32 *)xprth;
+                                __be32 *ehdr = (__be32 *)xprth;
 
                                 fl->fl_ipsec_spi = ehdr[0];
                         }
@@ -229,7 +229,7 @@ _decode_session4(struct sk_buff *skb, struct flowi *fl)
 
                 case IPPROTO_AH:
                         if (pskb_may_pull(skb, xprth + 8 - skb->data)) {
-                                u32 *ah_hdr = (u32*)xprth;
+                                __be32 *ah_hdr = (__be32*)xprth;
 
                                 fl->fl_ipsec_spi = ah_hdr[1];
                         }
@@ -237,7 +237,7 @@ _decode_session4(struct sk_buff *skb, struct flowi *fl)
 
                 case IPPROTO_COMP:
                         if (pskb_may_pull(skb, xprth + 4 - skb->data)) {
-                                u16 *ipcomp_hdr = (u16 *)xprth;
+                                __be16 *ipcomp_hdr = (__be16 *)xprth;
 
                                 fl->fl_ipsec_spi = htonl(ntohs(ipcomp_hdr[1]));
                         }
diff --git a/net/ipv4/xfrm4_state.c b/net/ipv4/xfrm4_state.c
index fe2034494d08..3cc3df0c6ece 100644
--- a/net/ipv4/xfrm4_state.c
+++ b/net/ipv4/xfrm4_state.c
@@ -29,9 +29,9 @@ __xfrm4_init_tempsel(struct xfrm_state *x, struct flowi *fl,
         x->sel.daddr.a4 = fl->fl4_dst;
         x->sel.saddr.a4 = fl->fl4_src;
         x->sel.dport = xfrm_flowi_dport(fl);
-        x->sel.dport_mask = ~0;
+        x->sel.dport_mask = htons(0xffff);
         x->sel.sport = xfrm_flowi_sport(fl);
-        x->sel.sport_mask = ~0;
+        x->sel.sport_mask = htons(0xffff);
         x->sel.prefixlen_d = 32;
         x->sel.prefixlen_s = 32;
         x->sel.proto = fl->proto;
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index c18676352397..e03c33b2465b 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -1258,8 +1258,8 @@ int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2)
 {
         const struct in6_addr *sk_rcv_saddr6 = &inet6_sk(sk)->rcv_saddr;
         const struct in6_addr *sk2_rcv_saddr6 = inet6_rcv_saddr(sk2);
-        u32 sk_rcv_saddr = inet_sk(sk)->rcv_saddr;
-        u32 sk2_rcv_saddr = inet_rcv_saddr(sk2);
+        __be32 sk_rcv_saddr = inet_sk(sk)->rcv_saddr;
+        __be32 sk2_rcv_saddr = inet_rcv_saddr(sk2);
         int sk_ipv6only = ipv6_only_sock(sk);
         int sk2_ipv6only = inet_v6_ipv6only(sk2);
         int addr_type = ipv6_addr_type(sk_rcv_saddr6);
diff --git a/net/ipv6/af_inet6.c b/net/ipv6/af_inet6.c
index bf6e8aff19d4..e94eccb99707 100644
--- a/net/ipv6/af_inet6.c
+++ b/net/ipv6/af_inet6.c
@@ -246,7 +246,7 @@ int inet6_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
         struct sock *sk = sock->sk;
         struct inet_sock *inet = inet_sk(sk);
         struct ipv6_pinfo *np = inet6_sk(sk);
-        __u32 v4addr = 0;
+        __be32 v4addr = 0;
         unsigned short snum;
         int addr_type = 0;
         int err = 0;
diff --git a/net/ipv6/inet6_hashtables.c b/net/ipv6/inet6_hashtables.c
index d2f3fc990bfa..8accd1fbeeda 100644
--- a/net/ipv6/inet6_hashtables.c
+++ b/net/ipv6/inet6_hashtables.c
@@ -64,7 +64,7 @@ struct sock *__inet6_lookup_established(struct inet_hashinfo *hashinfo,
 {
         struct sock *sk;
         const struct hlist_node *node;
-        const __u32 ports = INET_COMBINED_PORTS(sport, hnum);
+        const __portpair ports = INET_COMBINED_PORTS(sport, hnum);
         /* Optimize here for direct hit, only listening connections can
          * have wildcards anyways.
          */
@@ -82,7 +82,7 @@ struct sock *__inet6_lookup_established(struct inet_hashinfo *hashinfo,
         sk_for_each(sk, node, &(head + hashinfo->ehash_size)->chain) {
                 const struct inet_timewait_sock *tw = inet_twsk(sk);
 
-                if(*((__u32 *)&(tw->tw_dport))  == ports        &&
+                if(*((__portpair *)&(tw->tw_dport))     == ports        &&
                    sk->sk_family                == PF_INET6) {
                         const struct inet6_timewait_sock *tw6 = inet6_twsk(sk);
 
@@ -171,7 +171,7 @@ static int __inet6_check_established(struct inet_timewait_death_row *death_row,
         const struct in6_addr *daddr = &np->rcv_saddr;
         const struct in6_addr *saddr = &np->daddr;
         const int dif = sk->sk_bound_dev_if;
-        const u32 ports = INET_COMBINED_PORTS(inet->dport, lport);
+        const __portpair ports = INET_COMBINED_PORTS(inet->dport, lport);
         const unsigned int hash = inet6_ehashfn(daddr, inet->num, saddr,
                                                 inet->dport);
         struct inet_ehash_bucket *head = inet_ehash_bucket(hinfo, hash);
@@ -188,7 +188,7 @@ static int __inet6_check_established(struct inet_timewait_death_row *death_row,
 
                 tw = inet_twsk(sk2);
 
-                if(*((__u32 *)&(tw->tw_dport)) == ports          &&
+                if(*((__portpair *)&(tw->tw_dport)) == ports             &&
                    sk2->sk_family              == PF_INET6       &&
                    ipv6_addr_equal(&tw6->tw_v6_daddr, saddr)     &&
                    ipv6_addr_equal(&tw6->tw_v6_rcv_saddr, daddr) &&
diff --git a/net/ipv6/ipcomp6.c b/net/ipv6/ipcomp6.c
index ad9c6e824e62..a2860e35efd7 100644
--- a/net/ipv6/ipcomp6.c
+++ b/net/ipv6/ipcomp6.c
@@ -178,7 +178,7 @@ out_ok:
 static void ipcomp6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
                                 int type, int code, int offset, __u32 info)
 {
-        u32 spi;
+        __be32 spi;
         struct ipv6hdr *iph = (struct ipv6hdr*)skb->data;
         struct ipv6_comp_hdr *ipcomph = (struct ipv6_comp_hdr*)(skb->data+offset);
         struct xfrm_state *x;
@@ -234,7 +234,7 @@ static int ipcomp6_tunnel_attach(struct xfrm_state *x)
 {
         int err = 0;
         struct xfrm_state *t = NULL;
-        u32 spi;
+        __be32 spi;
 
         spi = xfrm6_tunnel_spi_lookup((xfrm_address_t *)&x->props.saddr);
         if (spi)
diff --git a/net/ipv6/ipv6_sockglue.c b/net/ipv6/ipv6_sockglue.c
index 4f3bb7fcc8b5..de6b91981b30 100644
--- a/net/ipv6/ipv6_sockglue.c
+++ b/net/ipv6/ipv6_sockglue.c
@@ -123,6 +123,9 @@ static struct sk_buff *ipv6_gso_segment(struct sk_buff *skb, int features)
         struct ipv6hdr *ipv6h;
         struct inet6_protocol *ops;
 
+        if (!(features & NETIF_F_HW_CSUM))
+                features &= ~NETIF_F_SG;
+
         if (unlikely(skb_shinfo(skb)->gso_type &
                      ~(SKB_GSO_UDP |
                        SKB_GSO_DODGY |
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 2546fc9f0a78..3b6575478fcc 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -1237,7 +1237,7 @@ process:
 
         skb->dev = NULL;
 
-        bh_lock_sock(sk);
+        bh_lock_sock_nested(sk);
         ret = 0;
         if (!sock_owned_by_user(sk)) {
 #ifdef CONFIG_NET_DMA
diff --git a/net/ipv6/xfrm6_input.c b/net/ipv6/xfrm6_input.c
index a40a05789013..5c8b7a568800 100644
--- a/net/ipv6/xfrm6_input.c
+++ b/net/ipv6/xfrm6_input.c
@@ -16,10 +16,10 @@
 #include <net/ipv6.h>
 #include <net/xfrm.h>
 
-int xfrm6_rcv_spi(struct sk_buff *skb, u32 spi)
+int xfrm6_rcv_spi(struct sk_buff *skb, __be32 spi)
 {
         int err;
-        u32 seq;
+        __be32 seq;
         struct xfrm_state *xfrm_vec[XFRM_MAX_DEPTH];
         struct xfrm_state *x;
         int xfrm_nr = 0;
diff --git a/net/ipv6/xfrm6_state.c b/net/ipv6/xfrm6_state.c
index 711bfafb2472..9ddaa9d41539 100644
--- a/net/ipv6/xfrm6_state.c
+++ b/net/ipv6/xfrm6_state.c
@@ -29,9 +29,9 @@ __xfrm6_init_tempsel(struct xfrm_state *x, struct flowi *fl,
         ipv6_addr_copy((struct in6_addr *)&x->sel.daddr, &fl->fl6_dst);
         ipv6_addr_copy((struct in6_addr *)&x->sel.saddr, &fl->fl6_src);
         x->sel.dport = xfrm_flowi_dport(fl);
-        x->sel.dport_mask = ~0;
+        x->sel.dport_mask = htons(0xffff);
         x->sel.sport = xfrm_flowi_sport(fl);
-        x->sel.sport_mask = ~0;
+        x->sel.sport_mask = htons(0xffff);
         x->sel.prefixlen_d = 128;
         x->sel.prefixlen_s = 128;
         x->sel.proto = fl->proto;
diff --git a/net/ipv6/xfrm6_tunnel.c b/net/ipv6/xfrm6_tunnel.c
index 59685ee8f700..7af227bb1551 100644
--- a/net/ipv6/xfrm6_tunnel.c
+++ b/net/ipv6/xfrm6_tunnel.c
@@ -258,7 +258,7 @@ static int xfrm6_tunnel_input(struct xfrm_state *x, struct sk_buff *skb)
 static int xfrm6_tunnel_rcv(struct sk_buff *skb)
 {
         struct ipv6hdr *iph = skb->nh.ipv6h;
-        u32 spi;
+        __be32 spi;
 
         spi = xfrm6_tunnel_spi_lookup((xfrm_address_t *)&iph->saddr);
         return xfrm6_rcv_spi(skb, spi);
diff --git a/net/irda/af_irda.c b/net/irda/af_irda.c
index 17699eeb64d7..7e1aea89ef05 100644
--- a/net/irda/af_irda.c
+++ b/net/irda/af_irda.c
@@ -132,13 +132,14 @@ static void irda_disconnect_indication(void *instance, void *sap,
 
         /* Prevent race conditions with irda_release() and irda_shutdown() */
         if (!sock_flag(sk, SOCK_DEAD) && sk->sk_state != TCP_CLOSE) {
+                lock_sock(sk);
                 sk->sk_state     = TCP_CLOSE;
                 sk->sk_err       = ECONNRESET;
                 sk->sk_shutdown |= SEND_SHUTDOWN;
 
                 sk->sk_state_change(sk);
-                /* Uh-oh... Should use sock_orphan ? */
-                sock_set_flag(sk, SOCK_DEAD);
+                sock_orphan(sk);
+                release_sock(sk);
 
                 /* Close our TSAP.
                  * If we leave it open, IrLMP put it back into the list of
@@ -308,7 +309,8 @@ static void irda_connect_response(struct irda_sock *self)
 
         IRDA_ASSERT(self != NULL, return;);
 
-        skb = alloc_skb(64, GFP_ATOMIC);
+        skb = alloc_skb(TTP_MAX_HEADER + TTP_SAR_HEADER,
+                        GFP_ATOMIC);
         if (skb == NULL) {
                 IRDA_DEBUG(0, "%s() Unable to allocate sk_buff!\n",
                            __FUNCTION__);
@@ -1212,6 +1214,7 @@ static int irda_release(struct socket *sock)
         if (sk == NULL)
                 return 0;
 
+        lock_sock(sk);
         sk->sk_state       = TCP_CLOSE;
         sk->sk_shutdown   |= SEND_SHUTDOWN;
         sk->sk_state_change(sk);
@@ -1221,6 +1224,7 @@ static int irda_release(struct socket *sock)
 
         sock_orphan(sk);
         sock->sk   = NULL;
+        release_sock(sk);
 
         /* Purge queues (see sock_init_data()) */
         skb_queue_purge(&sk->sk_receive_queue);
@@ -1353,6 +1357,7 @@ static int irda_recvmsg_dgram(struct kiocb *iocb, struct socket *sock,
         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
         IRDA_ASSERT(self != NULL, return -1;);
+        IRDA_ASSERT(!sock_error(sk), return -1;);
 
         skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
                                 flags & MSG_DONTWAIT, &err);
@@ -1405,6 +1410,7 @@ static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock,
         IRDA_DEBUG(3, "%s()\n", __FUNCTION__);
 
         IRDA_ASSERT(self != NULL, return -1;);
+        IRDA_ASSERT(!sock_error(sk), return -1;);
 
         if (sock->flags & __SO_ACCEPTCON)
                 return(-EINVAL);
diff --git a/net/irda/ircomm/ircomm_lmp.c b/net/irda/ircomm/ircomm_lmp.c
index 959874b6451f..c8e0d89ee11f 100644
--- a/net/irda/ircomm/ircomm_lmp.c
+++ b/net/irda/ircomm/ircomm_lmp.c
@@ -81,7 +81,7 @@ static int ircomm_lmp_connect_response(struct ircomm_cb *self,
         
         /* Any userdata supplied? */
         if (userdata == NULL) {
-                tx_skb = alloc_skb(64, GFP_ATOMIC);
+                tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
                 if (!tx_skb)
                         return -ENOMEM;
 
@@ -115,7 +115,7 @@ static int ircomm_lmp_disconnect_request(struct ircomm_cb *self,
         IRDA_DEBUG(0, "%s()\n", __FUNCTION__ );
 
         if (!userdata) {
-                tx_skb = alloc_skb(64, GFP_ATOMIC);
+                tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
                 if (!tx_skb)
                         return -ENOMEM;
                 
diff --git a/net/irda/iriap.c b/net/irda/iriap.c
index 61128aa05b40..415cf4eec23b 100644
--- a/net/irda/iriap.c
+++ b/net/irda/iriap.c
@@ -345,10 +345,11 @@ static void iriap_disconnect_request(struct iriap_cb *self)
         IRDA_ASSERT(self != NULL, return;);
         IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
-        tx_skb = alloc_skb(64, GFP_ATOMIC);
+        tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
         if (tx_skb == NULL) {
-                IRDA_DEBUG(0, "%s(), Could not allocate an sk_buff of length %d\n", 
-                        __FUNCTION__, 64);
+                IRDA_DEBUG(0,
+                           "%s(), Could not allocate an sk_buff of length %d\n",
+                           __FUNCTION__, LMP_MAX_HEADER);
                 return;
         }
 
@@ -701,7 +702,7 @@ void iriap_send_ack(struct iriap_cb *self)
         IRDA_ASSERT(self != NULL, return;);
         IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
-        tx_skb = alloc_skb(64, GFP_ATOMIC);
+        tx_skb = alloc_skb(LMP_MAX_HEADER + 1, GFP_ATOMIC);
         if (!tx_skb)
                 return;
 
diff --git a/net/irda/iriap_event.c b/net/irda/iriap_event.c
index da17395df05a..99b18dc7a0b7 100644
--- a/net/irda/iriap_event.c
+++ b/net/irda/iriap_event.c
@@ -365,7 +365,7 @@ static void state_r_disconnect(struct iriap_cb *self, IRIAP_EVENT event,
 
         switch (event) {
         case IAP_LM_CONNECT_INDICATION:
-                tx_skb = alloc_skb(64, GFP_ATOMIC);
+                tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
                 if (tx_skb == NULL) {
                         IRDA_WARNING("%s: unable to malloc!\n", __FUNCTION__);
                         return;
diff --git a/net/irda/irlan/irlan_common.c b/net/irda/irlan/irlan_common.c
index 7dd0a2fe1d20..9b962f247714 100644
--- a/net/irda/irlan/irlan_common.c
+++ b/net/irda/irlan/irlan_common.c
@@ -636,7 +636,8 @@ void irlan_get_provider_info(struct irlan_cb *self)
         IRDA_ASSERT(self != NULL, return;);
         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 
-        skb = alloc_skb(64, GFP_ATOMIC);
+        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER,
+                        GFP_ATOMIC);
         if (!skb)
                 return;
 
@@ -668,7 +669,10 @@ void irlan_open_data_channel(struct irlan_cb *self)
         IRDA_ASSERT(self != NULL, return;);
         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
         
-        skb = alloc_skb(64, GFP_ATOMIC);
+        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
+                        IRLAN_STRING_PARAMETER_LEN("MEDIA", "802.3") +
+                        IRLAN_STRING_PARAMETER_LEN("ACCESS_TYPE", "DIRECT"),
+                        GFP_ATOMIC);
         if (!skb)
                 return;
 
@@ -704,7 +708,9 @@ void irlan_close_data_channel(struct irlan_cb *self)
         if (self->client.tsap_ctrl == NULL)
                 return;
 
-        skb = alloc_skb(64, GFP_ATOMIC);
+        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
+                        IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN"),
+                        GFP_ATOMIC);
         if (!skb)
                 return;
 
@@ -715,7 +721,7 @@ void irlan_close_data_channel(struct irlan_cb *self)
         
         /* Build frame */
         frame[0] = CMD_CLOSE_DATA_CHAN;
-        frame[1] = 0x01; /* Two parameters */
+        frame[1] = 0x01; /* One parameter */
 
         irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
 
@@ -739,7 +745,11 @@ static void irlan_open_unicast_addr(struct irlan_cb *self)
         IRDA_ASSERT(self != NULL, return;);
         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);       
         
-        skb = alloc_skb(128, GFP_ATOMIC);
+        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
+                        IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
+                        IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
+                        IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "FILTER"),
+                        GFP_ATOMIC);
         if (!skb)
                 return;
 
@@ -777,7 +787,12 @@ void irlan_set_broadcast_filter(struct irlan_cb *self, int status)
         IRDA_ASSERT(self != NULL, return;);
         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
         
-        skb = alloc_skb(128, GFP_ATOMIC);
+        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
+                        IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
+                        IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "BROADCAST") +
+                        /* We may waste one byte here...*/
+                        IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "FILTER"),
+                        GFP_ATOMIC);
         if (!skb)
                 return;
 
@@ -816,7 +831,12 @@ void irlan_set_multicast_filter(struct irlan_cb *self, int status)
         IRDA_ASSERT(self != NULL, return;);
         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 
-        skb = alloc_skb(128, GFP_ATOMIC);
+        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
+                        IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
+                        IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "MULTICAST") +
+                        /* We may waste one byte here...*/
+                        IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "NONE"),
+                        GFP_ATOMIC);
         if (!skb)
                 return;
         
@@ -856,7 +876,12 @@ static void irlan_get_unicast_addr(struct irlan_cb *self)
         IRDA_ASSERT(self != NULL, return;);
         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
         
-        skb = alloc_skb(128, GFP_ATOMIC);
+        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
+                        IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
+                        IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
+                        IRLAN_STRING_PARAMETER_LEN("FILTER_OPERATION",
+                                                   "DYNAMIC"),
+                        GFP_ATOMIC);
         if (!skb)
                 return;
 
@@ -891,7 +916,10 @@ void irlan_get_media_char(struct irlan_cb *self)
         IRDA_ASSERT(self != NULL, return;);
         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
         
-        skb = alloc_skb(64, GFP_ATOMIC);
+        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
+                        IRLAN_STRING_PARAMETER_LEN("MEDIA", "802.3"),
+                        GFP_ATOMIC);
+
         if (!skb)
                 return;
 
diff --git a/net/irda/irlan/irlan_provider.c b/net/irda/irlan/irlan_provider.c
index 9c0df86044d7..58efde919667 100644
--- a/net/irda/irlan/irlan_provider.c
+++ b/net/irda/irlan/irlan_provider.c
@@ -296,7 +296,14 @@ void irlan_provider_send_reply(struct irlan_cb *self, int command,
         IRDA_ASSERT(self != NULL, return;);
         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 
-        skb = alloc_skb(128, GFP_ATOMIC);
+        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
+                        /* Bigger param length comes from CMD_GET_MEDIA_CHAR */
+                        IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
+                        IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "BORADCAST") +
+                        IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "MULTICAST") +
+                        IRLAN_STRING_PARAMETER_LEN("ACCESS_TYPE", "HOSTED"),
+                        GFP_ATOMIC);
+
         if (!skb)
                 return;
 
@@ -354,8 +361,7 @@ void irlan_provider_send_reply(struct irlan_cb *self, int command,
                 } else
                         skb->data[1] = 0x02; /* 2 parameters */
                 irlan_insert_byte_param(skb, "DATA_CHAN", self->stsap_sel_data);
-                irlan_insert_array_param(skb, "RECONNECT_KEY", "LINUX RULES!",
-                                         12);
+                irlan_insert_string_param(skb, "RECONNECT_KEY", "LINUX RULES!");
                 break;
         case CMD_FILTER_OPERATION:
                 irlan_filter_request(self, skb);
diff --git a/net/irda/irlap_frame.c b/net/irda/irlap_frame.c
index ccb983bf0f4a..dba349c832d0 100644
--- a/net/irda/irlap_frame.c
+++ b/net/irda/irlap_frame.c
@@ -117,7 +117,9 @@ void irlap_send_snrm_frame(struct irlap_cb *self, struct qos_info *qos)
         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
         /* Allocate frame */
-        tx_skb = alloc_skb(64, GFP_ATOMIC);
+        tx_skb = alloc_skb(sizeof(struct snrm_frame) +
+                           IRLAP_NEGOCIATION_PARAMS_LEN,
+                           GFP_ATOMIC);
         if (!tx_skb)
                 return;
 
@@ -136,7 +138,7 @@ void irlap_send_snrm_frame(struct irlap_cb *self, struct qos_info *qos)
          *  If we are establishing a connection then insert QoS paramerters
          */
         if (qos) {
-                skb_put(tx_skb, 9); /* 21 left */
+                skb_put(tx_skb, 9); /* 25 left */
                 frame->saddr = cpu_to_le32(self->saddr);
                 frame->daddr = cpu_to_le32(self->daddr);
 
@@ -210,7 +212,9 @@ void irlap_send_ua_response_frame(struct irlap_cb *self, struct qos_info *qos)
         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
         /* Allocate frame */
-        tx_skb = alloc_skb(64, GFP_ATOMIC);
+        tx_skb = alloc_skb(sizeof(struct ua_frame) +
+                           IRLAP_NEGOCIATION_PARAMS_LEN,
+                           GFP_ATOMIC);
         if (!tx_skb)
                 return;
 
@@ -245,23 +249,23 @@ void irlap_send_ua_response_frame(struct irlap_cb *self, struct qos_info *qos)
 void irlap_send_dm_frame( struct irlap_cb *self)
 {
         struct sk_buff *tx_skb = NULL;
-        __u8 *frame;
+        struct dm_frame *frame;
 
         IRDA_ASSERT(self != NULL, return;);
         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
-        tx_skb = alloc_skb(32, GFP_ATOMIC);
+        tx_skb = alloc_skb(sizeof(struct dm_frame), GFP_ATOMIC);
         if (!tx_skb)
                 return;
 
-        frame = skb_put(tx_skb, 2);
+        frame = (struct dm_frame *)skb_put(tx_skb, 2);
 
         if (self->state == LAP_NDM)
-                frame[0] = CBROADCAST;
+                frame->caddr = CBROADCAST;
         else
-                frame[0] = self->caddr;
+                frame->caddr = self->caddr;
 
-        frame[1] = DM_RSP | PF_BIT;
+        frame->control = DM_RSP | PF_BIT;
 
         irlap_queue_xmit(self, tx_skb);
 }
@@ -275,21 +279,21 @@ void irlap_send_dm_frame( struct irlap_cb *self)
 void irlap_send_disc_frame(struct irlap_cb *self)
 {
         struct sk_buff *tx_skb = NULL;
-        __u8 *frame;
+        struct disc_frame *frame;
 
         IRDA_DEBUG(3, "%s()\n", __FUNCTION__);
 
         IRDA_ASSERT(self != NULL, return;);
         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
-        tx_skb = alloc_skb(16, GFP_ATOMIC);
+        tx_skb = alloc_skb(sizeof(struct disc_frame), GFP_ATOMIC);
         if (!tx_skb)
                 return;
 
-        frame = skb_put(tx_skb, 2);
+        frame = (struct disc_frame *)skb_put(tx_skb, 2);
 
-        frame[0] = self->caddr | CMD_FRAME;
-        frame[1] = DISC_CMD | PF_BIT;
+        frame->caddr = self->caddr | CMD_FRAME;
+        frame->control = DISC_CMD | PF_BIT;
 
         irlap_queue_xmit(self, tx_skb);
 }
@@ -315,7 +319,8 @@ void irlap_send_discovery_xid_frame(struct irlap_cb *self, int S, __u8 s,
         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
         IRDA_ASSERT(discovery != NULL, return;);
 
-        tx_skb = alloc_skb(64, GFP_ATOMIC);
+        tx_skb = alloc_skb(sizeof(struct xid_frame) + IRLAP_DISCOVERY_INFO_LEN,
+                           GFP_ATOMIC);
         if (!tx_skb)
                 return;
 
@@ -573,18 +578,18 @@ static void irlap_recv_discovery_xid_cmd(struct irlap_cb *self,
 void irlap_send_rr_frame(struct irlap_cb *self, int command)
 {
         struct sk_buff *tx_skb;
-        __u8 *frame;
+        struct rr_frame *frame;
 
-        tx_skb = alloc_skb(16, GFP_ATOMIC);
+        tx_skb = alloc_skb(sizeof(struct rr_frame), GFP_ATOMIC);
         if (!tx_skb)
                 return;
 
-        frame = skb_put(tx_skb, 2);
+        frame = (struct rr_frame *)skb_put(tx_skb, 2);
 
-        frame[0] = self->caddr;
-        frame[0] |= (command) ? CMD_FRAME : 0;
+        frame->caddr = self->caddr;
+        frame->caddr |= (command) ? CMD_FRAME : 0;
 
-        frame[1] = RR | PF_BIT | (self->vr << 5);
+        frame->control = RR | PF_BIT | (self->vr << 5);
 
         irlap_queue_xmit(self, tx_skb);
 }
@@ -598,16 +603,16 @@ void irlap_send_rr_frame(struct irlap_cb *self, int command)
 void irlap_send_rd_frame(struct irlap_cb *self)
 {
         struct sk_buff *tx_skb;
-        __u8 *frame;
+        struct rd_frame *frame;
 
-        tx_skb = alloc_skb(16, GFP_ATOMIC);
+        tx_skb = alloc_skb(sizeof(struct rd_frame), GFP_ATOMIC);
         if (!tx_skb)
                 return;
 
-        frame = skb_put(tx_skb, 2);
+        frame = (struct rd_frame *)skb_put(tx_skb, 2);
 
-        frame[0] = self->caddr;
-        frame[1] = RD_RSP | PF_BIT;
+        frame->caddr = self->caddr;
+        frame->caddr = RD_RSP | PF_BIT;
 
         irlap_queue_xmit(self, tx_skb);
 }
@@ -1214,7 +1219,7 @@ void irlap_send_test_frame(struct irlap_cb *self, __u8 caddr, __u32 daddr,
         struct test_frame *frame;
         __u8 *info;
 
-        tx_skb = alloc_skb(cmd->len+sizeof(struct test_frame), GFP_ATOMIC);
+        tx_skb = alloc_skb(cmd->len + sizeof(struct test_frame), GFP_ATOMIC);
         if (!tx_skb)
                 return;
 
diff --git a/net/irda/irlmp.c b/net/irda/irlmp.c
index c440913dee14..5073261b9d0c 100644
--- a/net/irda/irlmp.c
+++ b/net/irda/irlmp.c
@@ -392,7 +392,7 @@ int irlmp_connect_request(struct lsap_cb *self, __u8 dlsap_sel,
 
         /* Any userdata? */
         if (tx_skb == NULL) {
-                tx_skb = alloc_skb(64, GFP_ATOMIC);
+                tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
                 if (!tx_skb)
                         return -ENOMEM;
 
diff --git a/net/irda/irttp.c b/net/irda/irttp.c
index 42acf1cde737..3c2e70b77df1 100644
--- a/net/irda/irttp.c
+++ b/net/irda/irttp.c
@@ -804,12 +804,12 @@ static inline void irttp_give_credit(struct tsap_cb *self)
                    self->send_credit, self->avail_credit, self->remote_credit);
 
         /* Give credit to peer */
-        tx_skb = alloc_skb(64, GFP_ATOMIC);
+        tx_skb = alloc_skb(TTP_MAX_HEADER, GFP_ATOMIC);
         if (!tx_skb)
                 return;
 
         /* Reserve space for LMP, and LAP header */
-        skb_reserve(tx_skb, self->max_header_size);
+        skb_reserve(tx_skb, LMP_MAX_HEADER);
 
         /*
          *  Since we can transmit and receive frames concurrently,
@@ -1093,7 +1093,8 @@ int irttp_connect_request(struct tsap_cb *self, __u8 dtsap_sel,
 
         /* Any userdata supplied? */
         if (userdata == NULL) {
-                tx_skb = alloc_skb(64, GFP_ATOMIC);
+                tx_skb = alloc_skb(TTP_MAX_HEADER + TTP_SAR_HEADER,
+                                   GFP_ATOMIC);
                 if (!tx_skb)
                         return -ENOMEM;
 
@@ -1341,7 +1342,8 @@ int irttp_connect_response(struct tsap_cb *self, __u32 max_sdu_size,
 
         /* Any userdata supplied? */
         if (userdata == NULL) {
-                tx_skb = alloc_skb(64, GFP_ATOMIC);
+                tx_skb = alloc_skb(TTP_MAX_HEADER + TTP_SAR_HEADER,
+                                   GFP_ATOMIC);
                 if (!tx_skb)
                         return -ENOMEM;
 
@@ -1540,14 +1542,14 @@ int irttp_disconnect_request(struct tsap_cb *self, struct sk_buff *userdata,
 
         if (!userdata) {
                 struct sk_buff *tx_skb;
-                tx_skb = alloc_skb(64, GFP_ATOMIC);
+                tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
                 if (!tx_skb)
                         return -ENOMEM;
 
                 /*
                  *  Reserve space for MUX and LAP header
                  */
-                skb_reserve(tx_skb, TTP_MAX_HEADER);
+                skb_reserve(tx_skb, LMP_MAX_HEADER);
 
                 userdata = tx_skb;
         }
diff --git a/net/key/af_key.c b/net/key/af_key.c
index 83b443ddc72f..ff98e70b0931 100644
--- a/net/key/af_key.c
+++ b/net/key/af_key.c
@@ -2140,7 +2140,7 @@ static int pfkey_spdadd(struct sock *sk, struct sk_buff *skb, struct sadb_msg *h
         xp->selector.proto = pfkey_proto_to_xfrm(sa->sadb_address_proto);
         xp->selector.sport = ((struct sockaddr_in *)(sa+1))->sin_port;
         if (xp->selector.sport)
-                xp->selector.sport_mask = ~0;
+                xp->selector.sport_mask = htons(0xffff);
 
         sa = ext_hdrs[SADB_EXT_ADDRESS_DST-1], 
         pfkey_sadb_addr2xfrm_addr(sa, &xp->selector.daddr);
@@ -2153,7 +2153,7 @@ static int pfkey_spdadd(struct sock *sk, struct sk_buff *skb, struct sadb_msg *h
 
         xp->selector.dport = ((struct sockaddr_in *)(sa+1))->sin_port;
         if (xp->selector.dport)
-                xp->selector.dport_mask = ~0;
+                xp->selector.dport_mask = htons(0xffff);
 
         sec_ctx = (struct sadb_x_sec_ctx *) ext_hdrs[SADB_X_EXT_SEC_CTX-1];
         if (sec_ctx != NULL) {
@@ -2243,7 +2243,7 @@ static int pfkey_spddelete(struct sock *sk, struct sk_buff *skb, struct sadb_msg
         sel.proto = pfkey_proto_to_xfrm(sa->sadb_address_proto);
         sel.sport = ((struct sockaddr_in *)(sa+1))->sin_port;
         if (sel.sport)
-                sel.sport_mask = ~0;
+                sel.sport_mask = htons(0xffff);
 
         sa = ext_hdrs[SADB_EXT_ADDRESS_DST-1], 
         pfkey_sadb_addr2xfrm_addr(sa, &sel.daddr);
@@ -2251,7 +2251,7 @@ static int pfkey_spddelete(struct sock *sk, struct sk_buff *skb, struct sadb_msg
         sel.proto = pfkey_proto_to_xfrm(sa->sadb_address_proto);
         sel.dport = ((struct sockaddr_in *)(sa+1))->sin_port;
         if (sel.dport)
-                sel.dport_mask = ~0;
+                sel.dport_mask = htons(0xffff);
 
         sec_ctx = (struct sadb_x_sec_ctx *) ext_hdrs[SADB_X_EXT_SEC_CTX-1];
         memset(&tmp, 0, sizeof(struct xfrm_policy));
diff --git a/net/netlabel/netlabel_cipso_v4.c b/net/netlabel/netlabel_cipso_v4.c
index 4125a55f469f..09986ca962a6 100644
--- a/net/netlabel/netlabel_cipso_v4.c
+++ b/net/netlabel/netlabel_cipso_v4.c
@@ -32,6 +32,7 @@
 #include <linux/socket.h>
 #include <linux/string.h>
 #include <linux/skbuff.h>
+#include <linux/audit.h>
 #include <net/sock.h>
 #include <net/netlink.h>
 #include <net/genetlink.h>
@@ -162,8 +163,7 @@ static int netlbl_cipsov4_add_std(struct genl_info *info)
         int nla_a_rem;
         int nla_b_rem;
 
-        if (!info->attrs[NLBL_CIPSOV4_A_DOI] ||
-            !info->attrs[NLBL_CIPSOV4_A_TAGLST] ||
+        if (!info->attrs[NLBL_CIPSOV4_A_TAGLST] ||
             !info->attrs[NLBL_CIPSOV4_A_MLSLVLLST])
                 return -EINVAL;
 
@@ -344,8 +344,7 @@ static int netlbl_cipsov4_add_pass(struct genl_info *info)
         int ret_val;
         struct cipso_v4_doi *doi_def = NULL;
 
-        if (!info->attrs[NLBL_CIPSOV4_A_DOI] ||
-            !info->attrs[NLBL_CIPSOV4_A_TAGLST])
+        if (!info->attrs[NLBL_CIPSOV4_A_TAGLST])
                 return -EINVAL;
 
         doi_def = kmalloc(sizeof(*doi_def), GFP_KERNEL);
@@ -381,21 +380,35 @@ static int netlbl_cipsov4_add(struct sk_buff *skb, struct genl_info *info)
 
 {
         int ret_val = -EINVAL;
-        u32 map_type;
+        u32 type;
+        u32 doi;
+        const char *type_str = "(unknown)";
+        struct audit_buffer *audit_buf;
 
-        if (!info->attrs[NLBL_CIPSOV4_A_MTYPE])
+        if (!info->attrs[NLBL_CIPSOV4_A_DOI] ||
+            !info->attrs[NLBL_CIPSOV4_A_MTYPE])
                 return -EINVAL;
 
-        map_type = nla_get_u32(info->attrs[NLBL_CIPSOV4_A_MTYPE]);
-        switch (map_type) {
+        type = nla_get_u32(info->attrs[NLBL_CIPSOV4_A_MTYPE]);
+        switch (type) {
         case CIPSO_V4_MAP_STD:
+                type_str = "std";
                 ret_val = netlbl_cipsov4_add_std(info);
                 break;
         case CIPSO_V4_MAP_PASS:
+                type_str = "pass";
                 ret_val = netlbl_cipsov4_add_pass(info);
                 break;
         }
 
+        if (ret_val == 0) {
+                doi = nla_get_u32(info->attrs[NLBL_CIPSOV4_A_DOI]);
+                audit_buf = netlbl_audit_start_common(AUDIT_MAC_CIPSOV4_ADD,
+                                                      NETLINK_CB(skb).sid);
+                audit_log_format(audit_buf, " doi=%u type=%s", doi, type_str);
+                audit_log_end(audit_buf);
+        }
+
         return ret_val;
 }
 
@@ -653,11 +666,21 @@ static int netlbl_cipsov4_listall(struct sk_buff *skb,
 static int netlbl_cipsov4_remove(struct sk_buff *skb, struct genl_info *info)
 {
         int ret_val = -EINVAL;
-        u32 doi;
+        u32 doi = 0;
+        struct audit_buffer *audit_buf;
 
         if (info->attrs[NLBL_CIPSOV4_A_DOI]) {
                 doi = nla_get_u32(info->attrs[NLBL_CIPSOV4_A_DOI]);
-                ret_val = cipso_v4_doi_remove(doi, netlbl_cipsov4_doi_free);
+                ret_val = cipso_v4_doi_remove(doi,
+                                              NETLINK_CB(skb).sid,
+                                              netlbl_cipsov4_doi_free);
+        }
+
+        if (ret_val == 0) {
+                audit_buf = netlbl_audit_start_common(AUDIT_MAC_CIPSOV4_DEL,
+                                                      NETLINK_CB(skb).sid);
+                audit_log_format(audit_buf, " doi=%u", doi);
+                audit_log_end(audit_buf);
         }
 
         return ret_val;
diff --git a/net/netlabel/netlabel_domainhash.c b/net/netlabel/netlabel_domainhash.c
index f56d7a8ac7b7..d64e2ae3b129 100644
--- a/net/netlabel/netlabel_domainhash.c
+++ b/net/netlabel/netlabel_domainhash.c
@@ -35,12 +35,14 @@
 #include <linux/skbuff.h>
 #include <linux/spinlock.h>
 #include <linux/string.h>
+#include <linux/audit.h>
 #include <net/netlabel.h>
 #include <net/cipso_ipv4.h>
 #include <asm/bug.h>
 
 #include "netlabel_mgmt.h"
 #include "netlabel_domainhash.h"
+#include "netlabel_user.h"
 
 struct netlbl_domhsh_tbl {
         struct list_head *tbl;
@@ -186,6 +188,7 @@ int netlbl_domhsh_init(u32 size)
 /**
  * netlbl_domhsh_add - Adds a entry to the domain hash table
  * @entry: the entry to add
+ * @audit_secid: the LSM secid to use in the audit message
  *
  * Description:
  * Adds a new entry to the domain hash table and handles any updates to the
@@ -193,10 +196,12 @@ int netlbl_domhsh_init(u32 size)
  * negative on failure.
  *
  */
-int netlbl_domhsh_add(struct netlbl_dom_map *entry)
+int netlbl_domhsh_add(struct netlbl_dom_map *entry, u32 audit_secid)
 {
         int ret_val;
         u32 bkt;
+        struct audit_buffer *audit_buf;
+        char *audit_domain;
 
         switch (entry->type) {
         case NETLBL_NLTYPE_UNLABELED:
@@ -236,6 +241,26 @@ int netlbl_domhsh_add(struct netlbl_dom_map *entry)
                 spin_unlock(&netlbl_domhsh_def_lock);
         } else
                 ret_val = -EINVAL;
+        if (ret_val == 0) {
+                if (entry->domain != NULL)
+                        audit_domain = entry->domain;
+                else
+                        audit_domain = "(default)";
+                audit_buf = netlbl_audit_start_common(AUDIT_MAC_MAP_ADD,
+                                                      audit_secid);
+                audit_log_format(audit_buf, " domain=%s", audit_domain);
+                switch (entry->type) {
+                case NETLBL_NLTYPE_UNLABELED:
+                        audit_log_format(audit_buf, " protocol=unlbl");
+                        break;
+                case NETLBL_NLTYPE_CIPSOV4:
+                        audit_log_format(audit_buf,
+                                         " protocol=cipsov4 doi=%u",
+                                         entry->type_def.cipsov4->doi);
+                        break;
+                }
+                audit_log_end(audit_buf);
+        }
         rcu_read_unlock();
 
         if (ret_val != 0) {
@@ -254,6 +279,7 @@ int netlbl_domhsh_add(struct netlbl_dom_map *entry)
 /**
  * netlbl_domhsh_add_default - Adds the default entry to the domain hash table
  * @entry: the entry to add
+ * @audit_secid: the LSM secid to use in the audit message
  *
  * Description:
  * Adds a new default entry to the domain hash table and handles any updates
@@ -261,14 +287,15 @@ int netlbl_domhsh_add(struct netlbl_dom_map *entry)
  * negative on failure.
  *
  */
-int netlbl_domhsh_add_default(struct netlbl_dom_map *entry)
+int netlbl_domhsh_add_default(struct netlbl_dom_map *entry, u32 audit_secid)
 {
-        return netlbl_domhsh_add(entry);
+        return netlbl_domhsh_add(entry, audit_secid);
 }
 
 /**
  * netlbl_domhsh_remove - Removes an entry from the domain hash table
  * @domain: the domain to remove
+ * @audit_secid: the LSM secid to use in the audit message
  *
  * Description:
  * Removes an entry from the domain hash table and handles any updates to the
@@ -276,10 +303,12 @@ int netlbl_domhsh_add_default(struct netlbl_dom_map *entry)
  * negative on failure.
  *
  */
-int netlbl_domhsh_remove(const char *domain)
+int netlbl_domhsh_remove(const char *domain, u32 audit_secid)
 {
         int ret_val = -ENOENT;
         struct netlbl_dom_map *entry;
+        struct audit_buffer *audit_buf;
+        char *audit_domain;
 
         rcu_read_lock();
         if (domain != NULL)
@@ -316,8 +345,18 @@ int netlbl_domhsh_remove(const char *domain)
                         ret_val = -ENOENT;
                 spin_unlock(&netlbl_domhsh_def_lock);
         }
-        if (ret_val == 0)
+        if (ret_val == 0) {
+                if (entry->domain != NULL)
+                        audit_domain = entry->domain;
+                else
+                        audit_domain = "(default)";
+                audit_buf = netlbl_audit_start_common(AUDIT_MAC_MAP_DEL,
+                                                      audit_secid);
+                audit_log_format(audit_buf, " domain=%s", audit_domain);
+                audit_log_end(audit_buf);
+
                 call_rcu(&entry->rcu, netlbl_domhsh_free_entry);
+        }
 
 remove_return:
         rcu_read_unlock();
@@ -326,6 +365,7 @@ remove_return:
 
 /**
  * netlbl_domhsh_remove_default - Removes the default entry from the table
+ * @audit_secid: the LSM secid to use in the audit message
  *
  * Description:
  * Removes/resets the default entry for the domain hash table and handles any
@@ -333,9 +373,9 @@ remove_return:
  * success, non-zero on failure.
  *
  */
-int netlbl_domhsh_remove_default(void)
+int netlbl_domhsh_remove_default(u32 audit_secid)
 {
-        return netlbl_domhsh_remove(NULL);
+        return netlbl_domhsh_remove(NULL, audit_secid);
 }
 
 /**
diff --git a/net/netlabel/netlabel_domainhash.h b/net/netlabel/netlabel_domainhash.h
index 02af72a7877c..d50f13cacdca 100644
--- a/net/netlabel/netlabel_domainhash.h
+++ b/net/netlabel/netlabel_domainhash.h
@@ -57,9 +57,9 @@ struct netlbl_dom_map {
 int netlbl_domhsh_init(u32 size);
 
 /* Manipulate the domain hash table */
-int netlbl_domhsh_add(struct netlbl_dom_map *entry);
-int netlbl_domhsh_add_default(struct netlbl_dom_map *entry);
-int netlbl_domhsh_remove_default(void);
+int netlbl_domhsh_add(struct netlbl_dom_map *entry, u32 audit_secid);
+int netlbl_domhsh_add_default(struct netlbl_dom_map *entry, u32 audit_secid);
+int netlbl_domhsh_remove_default(u32 audit_secid);
 struct netlbl_dom_map *netlbl_domhsh_getentry(const char *domain);
 int netlbl_domhsh_walk(u32 *skip_bkt,
                      u32 *skip_chain,
diff --git a/net/netlabel/netlabel_mgmt.c b/net/netlabel/netlabel_mgmt.c
index 8626c9f678eb..0ac314f18ad1 100644
--- a/net/netlabel/netlabel_mgmt.c
+++ b/net/netlabel/netlabel_mgmt.c
@@ -108,7 +108,7 @@ static int netlbl_mgmt_add(struct sk_buff *skb, struct genl_info *info)
 
         switch (entry->type) {
         case NETLBL_NLTYPE_UNLABELED:
-                ret_val = netlbl_domhsh_add(entry);
+                ret_val = netlbl_domhsh_add(entry, NETLINK_CB(skb).sid);
                 break;
         case NETLBL_NLTYPE_CIPSOV4:
                 if (!info->attrs[NLBL_MGMT_A_CV4DOI])
@@ -125,7 +125,7 @@ static int netlbl_mgmt_add(struct sk_buff *skb, struct genl_info *info)
                         rcu_read_unlock();
                         goto add_failure;
                 }
-                ret_val = netlbl_domhsh_add(entry);
+                ret_val = netlbl_domhsh_add(entry, NETLINK_CB(skb).sid);
                 rcu_read_unlock();
                 break;
         default:
@@ -161,7 +161,7 @@ static int netlbl_mgmt_remove(struct sk_buff *skb, struct genl_info *info)
                 return -EINVAL;
 
         domain = nla_data(info->attrs[NLBL_MGMT_A_DOMAIN]);
-        return netlbl_domhsh_remove(domain);
+        return netlbl_domhsh_remove(domain, NETLINK_CB(skb).sid);
 }
 
 /**
@@ -277,7 +277,8 @@ static int netlbl_mgmt_adddef(struct sk_buff *skb, struct genl_info *info)
 
         switch (entry->type) {
         case NETLBL_NLTYPE_UNLABELED:
-                ret_val = netlbl_domhsh_add_default(entry);
+                ret_val = netlbl_domhsh_add_default(entry,
+                                                    NETLINK_CB(skb).sid);
                 break;
         case NETLBL_NLTYPE_CIPSOV4:
                 if (!info->attrs[NLBL_MGMT_A_CV4DOI])
@@ -294,7 +295,8 @@ static int netlbl_mgmt_adddef(struct sk_buff *skb, struct genl_info *info)
                         rcu_read_unlock();
                         goto adddef_failure;
                 }
-                ret_val = netlbl_domhsh_add_default(entry);
+                ret_val = netlbl_domhsh_add_default(entry,
+                                                    NETLINK_CB(skb).sid);
                 rcu_read_unlock();
                 break;
         default:
@@ -322,7 +324,7 @@ adddef_failure:
  */
 static int netlbl_mgmt_removedef(struct sk_buff *skb, struct genl_info *info)
 {
-        return netlbl_domhsh_remove_default();
+        return netlbl_domhsh_remove_default(NETLINK_CB(skb).sid);
 }
 
 /**
diff --git a/net/netlabel/netlabel_unlabeled.c b/net/netlabel/netlabel_unlabeled.c
index 440f5c4e1e2d..ab36675fee8c 100644
--- a/net/netlabel/netlabel_unlabeled.c
+++ b/net/netlabel/netlabel_unlabeled.c
@@ -64,6 +64,27 @@ static struct nla_policy netlbl_unlabel_genl_policy[NLBL_UNLABEL_A_MAX + 1] = {
 };
 
 /*
+ * Helper Functions
+ */
+
+/**
+ * netlbl_unlabel_acceptflg_set - Set the unlabeled accept flag
+ * @value: desired value
+ * @audit_secid: the LSM secid to use in the audit message
+ *
+ * Description:
+ * Set the value of the unlabeled accept flag to @value.
+ *
+ */
+static void netlbl_unlabel_acceptflg_set(u8 value, u32 audit_secid)
+{
+        atomic_set(&netlabel_unlabel_accept_flg, value);
+        netlbl_audit_nomsg((value ?
+                            AUDIT_MAC_UNLBL_ACCEPT : AUDIT_MAC_UNLBL_DENY),
+                           audit_secid);
+}
+
+/*
  * NetLabel Command Handlers
  */
 
@@ -79,18 +100,18 @@ static struct nla_policy netlbl_unlabel_genl_policy[NLBL_UNLABEL_A_MAX + 1] = {
  */
 static int netlbl_unlabel_accept(struct sk_buff *skb, struct genl_info *info)
 {
-        int ret_val = -EINVAL;
         u8 value;
 
         if (info->attrs[NLBL_UNLABEL_A_ACPTFLG]) {
                 value = nla_get_u8(info->attrs[NLBL_UNLABEL_A_ACPTFLG]);
                 if (value == 1 || value == 0) {
-                        atomic_set(&netlabel_unlabel_accept_flg, value);
-                        ret_val = 0;
+                        netlbl_unlabel_acceptflg_set(value,
+                                                     NETLINK_CB(skb).sid);
+                        return 0;
                 }
         }
 
-        return ret_val;
+        return -EINVAL;
 }
 
 /**
@@ -229,16 +250,19 @@ int netlbl_unlabel_defconf(void)
 {
         int ret_val;
         struct netlbl_dom_map *entry;
+        u32 secid;
+
+        security_task_getsecid(current, &secid);
 
         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
         if (entry == NULL)
                 return -ENOMEM;
         entry->type = NETLBL_NLTYPE_UNLABELED;
-        ret_val = netlbl_domhsh_add_default(entry);
+        ret_val = netlbl_domhsh_add_default(entry, secid);
         if (ret_val != 0)
                 return ret_val;
 
-        atomic_set(&netlabel_unlabel_accept_flg, 1);
+        netlbl_unlabel_acceptflg_set(1, secid);
 
         return 0;
 }
diff --git a/net/netlabel/netlabel_user.c b/net/netlabel/netlabel_user.c
index eeb7d768d2bb..c2343af584cb 100644
--- a/net/netlabel/netlabel_user.c
+++ b/net/netlabel/netlabel_user.c
@@ -32,6 +32,9 @@
 #include <linux/types.h>
 #include <linux/list.h>
 #include <linux/socket.h>
+#include <linux/audit.h>
+#include <linux/tty.h>
+#include <linux/security.h>
 #include <net/sock.h>
 #include <net/netlink.h>
 #include <net/genetlink.h>
@@ -74,3 +77,91 @@ int netlbl_netlink_init(void)
 
         return 0;
 }
+
+/*
+ * NetLabel Audit Functions
+ */
+
+/**
+ * netlbl_audit_start_common - Start an audit message
+ * @type: audit message type
+ * @secid: LSM context ID
+ *
+ * Description:
+ * Start an audit message using the type specified in @type and fill the audit
+ * message with some fields common to all NetLabel audit messages.  Returns
+ * a pointer to the audit buffer on success, NULL on failure.
+ *
+ */
+struct audit_buffer *netlbl_audit_start_common(int type, u32 secid)
+{
+        struct audit_context *audit_ctx = current->audit_context;
+        struct audit_buffer *audit_buf;
+        uid_t audit_loginuid;
+        const char *audit_tty;
+        char audit_comm[sizeof(current->comm)];
+        struct vm_area_struct *vma;
+        char *secctx;
+        u32 secctx_len;
+
+        audit_buf = audit_log_start(audit_ctx, GFP_ATOMIC, type);
+        if (audit_buf == NULL)
+                return NULL;
+
+        audit_loginuid = audit_get_loginuid(audit_ctx);
+        if (current->signal &&
+            current->signal->tty &&
+            current->signal->tty->name)
+                audit_tty = current->signal->tty->name;
+        else
+                audit_tty = "(none)";
+        get_task_comm(audit_comm, current);
+
+        audit_log_format(audit_buf,
+                         "netlabel: auid=%u uid=%u tty=%s pid=%d",
+                         audit_loginuid,
+                         current->uid,
+                         audit_tty,
+                         current->pid);
+        audit_log_format(audit_buf, " comm=");
+        audit_log_untrustedstring(audit_buf, audit_comm);
+        if (current->mm) {
+                down_read(&current->mm->mmap_sem);
+                vma = current->mm->mmap;
+                while (vma) {
+                        if ((vma->vm_flags & VM_EXECUTABLE) &&
+                            vma->vm_file) {
+                                audit_log_d_path(audit_buf,
+                                                 " exe=",
+                                                 vma->vm_file->f_dentry,
+                                                 vma->vm_file->f_vfsmnt);
+                                break;
+                        }
+                        vma = vma->vm_next;
+                }
+                up_read(&current->mm->mmap_sem);
+        }
+
+        if (secid != 0 &&
+            security_secid_to_secctx(secid, &secctx, &secctx_len) == 0)
+                audit_log_format(audit_buf, " subj=%s", secctx);
+
+        return audit_buf;
+}
+
+/**
+ * netlbl_audit_nomsg - Send an audit message without additional text
+ * @type: audit message type
+ * @secid: LSM context ID
+ *
+ * Description:
+ * Send an audit message with only the common NetLabel audit fields.
+ *
+ */
+void netlbl_audit_nomsg(int type, u32 secid)
+{
+        struct audit_buffer *audit_buf;
+
+        audit_buf = netlbl_audit_start_common(type, secid);
+        audit_log_end(audit_buf);
+}
diff --git a/net/netlabel/netlabel_user.h b/net/netlabel/netlabel_user.h
index 3f9386b917df..ab840acfc964 100644
--- a/net/netlabel/netlabel_user.h
+++ b/net/netlabel/netlabel_user.h
@@ -34,6 +34,7 @@
 #include <linux/types.h>
 #include <linux/skbuff.h>
 #include <linux/capability.h>
+#include <linux/audit.h>
 #include <net/netlink.h>
 #include <net/genetlink.h>
 #include <net/netlabel.h>
@@ -75,4 +76,9 @@ static inline void *netlbl_netlink_hdr_put(struct sk_buff *skb,
 
 int netlbl_netlink_init(void);
 
+/* NetLabel Audit Functions */
+
+struct audit_buffer *netlbl_audit_start_common(int type, u32 secid);
+void netlbl_audit_nomsg(int type, u32 secid);
+
 #endif
diff --git a/net/sched/cls_api.c b/net/sched/cls_api.c
index 7e14f14058e9..37a184021647 100644
--- a/net/sched/cls_api.c
+++ b/net/sched/cls_api.c
@@ -401,7 +401,7 @@ static int tc_dump_tfilter(struct sk_buff *skb, struct netlink_callback *cb)
         if ((dev = dev_get_by_index(tcm->tcm_ifindex)) == NULL)
                 return skb->len;
 
-        read_lock_bh(&qdisc_tree_lock);
+        read_lock(&qdisc_tree_lock);
         if (!tcm->tcm_parent)
                 q = dev->qdisc_sleeping;
         else
@@ -458,7 +458,7 @@ errout:
         if (cl)
                 cops->put(q, cl);
 out:
-        read_unlock_bh(&qdisc_tree_lock);
+        read_unlock(&qdisc_tree_lock);
         dev_put(dev);
         return skb->len;
 }
diff --git a/net/sched/cls_basic.c b/net/sched/cls_basic.c
index 86cac49a0531..09fda68c8b39 100644
--- a/net/sched/cls_basic.c
+++ b/net/sched/cls_basic.c
@@ -194,7 +194,7 @@ static int basic_change(struct tcf_proto *tp, unsigned long base, u32 handle,
         if (handle)
                 f->handle = handle;
         else {
-                int i = 0x80000000;
+                unsigned int i = 0x80000000;
                 do {
                         if (++head->hgenerator == 0x7FFFFFFF)
                                 head->hgenerator = 1;
diff --git a/net/sched/sch_api.c b/net/sched/sch_api.c
index a19eff12cf78..0b6489291140 100644
--- a/net/sched/sch_api.c
+++ b/net/sched/sch_api.c
@@ -195,14 +195,14 @@ struct Qdisc *qdisc_lookup(struct net_device *dev, u32 handle)
 {
         struct Qdisc *q;
 
-        read_lock_bh(&qdisc_tree_lock);
+        read_lock(&qdisc_tree_lock);
         list_for_each_entry(q, &dev->qdisc_list, list) {
                 if (q->handle == handle) {
-                        read_unlock_bh(&qdisc_tree_lock);
+                        read_unlock(&qdisc_tree_lock);
                         return q;
                 }
         }
-        read_unlock_bh(&qdisc_tree_lock);
+        read_unlock(&qdisc_tree_lock);
         return NULL;
 }
 
@@ -837,7 +837,7 @@ static int tc_dump_qdisc(struct sk_buff *skb, struct netlink_callback *cb)
                         continue;
                 if (idx > s_idx)
                         s_q_idx = 0;
-                read_lock_bh(&qdisc_tree_lock);
+                read_lock(&qdisc_tree_lock);
                 q_idx = 0;
                 list_for_each_entry(q, &dev->qdisc_list, list) {
                         if (q_idx < s_q_idx) {
@@ -846,12 +846,12 @@ static int tc_dump_qdisc(struct sk_buff *skb, struct netlink_callback *cb)
                         }
                         if (tc_fill_qdisc(skb, q, q->parent, NETLINK_CB(cb->skb).pid,
                                           cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWQDISC) <= 0) {
-                                read_unlock_bh(&qdisc_tree_lock);
+                                read_unlock(&qdisc_tree_lock);
                                 goto done;
                         }
                         q_idx++;
                 }
-                read_unlock_bh(&qdisc_tree_lock);
+                read_unlock(&qdisc_tree_lock);
         }
 
 done:
@@ -1074,7 +1074,7 @@ static int tc_dump_tclass(struct sk_buff *skb, struct netlink_callback *cb)
         s_t = cb->args[0];
         t = 0;
 
-        read_lock_bh(&qdisc_tree_lock);
+        read_lock(&qdisc_tree_lock);
         list_for_each_entry(q, &dev->qdisc_list, list) {
                 if (t < s_t || !q->ops->cl_ops ||
                     (tcm->tcm_parent &&
@@ -1096,7 +1096,7 @@ static int tc_dump_tclass(struct sk_buff *skb, struct netlink_callback *cb)
                         break;
                 t++;
         }
-        read_unlock_bh(&qdisc_tree_lock);
+        read_unlock(&qdisc_tree_lock);
 
         cb->args[0] = t;
 
diff --git a/net/sched/sch_generic.c b/net/sched/sch_generic.c
index 6f9151899795..88c6a99ce53c 100644
--- a/net/sched/sch_generic.c
+++ b/net/sched/sch_generic.c
@@ -45,11 +45,10 @@
    The idea is the following:
    - enqueue, dequeue are serialized via top level device
      spinlock dev->queue_lock.
-   - tree walking is protected by read_lock_bh(qdisc_tree_lock)
+   - tree walking is protected by read_lock(qdisc_tree_lock)
      and this lock is used only in process context.
-   - updates to tree are made under rtnl semaphore or
-     from softirq context (__qdisc_destroy rcu-callback)
-     hence this lock needs local bh disabling.
+   - updates to tree are made only under rtnl semaphore,
+     hence this lock may be made without local bh disabling.
 
    qdisc_tree_lock must be grabbed BEFORE dev->queue_lock!
  */
@@ -57,14 +56,14 @@ DEFINE_RWLOCK(qdisc_tree_lock);
 
 void qdisc_lock_tree(struct net_device *dev)
 {
-        write_lock_bh(&qdisc_tree_lock);
+        write_lock(&qdisc_tree_lock);
         spin_lock_bh(&dev->queue_lock);
 }
 
 void qdisc_unlock_tree(struct net_device *dev)
 {
         spin_unlock_bh(&dev->queue_lock);
-        write_unlock_bh(&qdisc_tree_lock);
+        write_unlock(&qdisc_tree_lock);
 }
 
 /* 
@@ -483,20 +482,6 @@ void qdisc_reset(struct Qdisc *qdisc)
 static void __qdisc_destroy(struct rcu_head *head)
 {
         struct Qdisc *qdisc = container_of(head, struct Qdisc, q_rcu);
-        struct Qdisc_ops  *ops = qdisc->ops;
-
-#ifdef CONFIG_NET_ESTIMATOR
-        gen_kill_estimator(&qdisc->bstats, &qdisc->rate_est);
-#endif
-        write_lock(&qdisc_tree_lock);
-        if (ops->reset)
-                ops->reset(qdisc);
-        if (ops->destroy)
-                ops->destroy(qdisc);
-        write_unlock(&qdisc_tree_lock);
-        module_put(ops->owner);
-
-        dev_put(qdisc->dev);
         kfree((char *) qdisc - qdisc->padded);
 }
 
@@ -504,32 +489,23 @@ static void __qdisc_destroy(struct rcu_head *head)
 
 void qdisc_destroy(struct Qdisc *qdisc)
 {
-        struct list_head cql = LIST_HEAD_INIT(cql);
-        struct Qdisc *cq, *q, *n;
+        struct Qdisc_ops  *ops = qdisc->ops;
 
         if (qdisc->flags & TCQ_F_BUILTIN ||
-                !atomic_dec_and_test(&qdisc->refcnt))
+            !atomic_dec_and_test(&qdisc->refcnt))
                 return;
 
-        if (!list_empty(&qdisc->list)) {
-                if (qdisc->ops->cl_ops == NULL)
-                        list_del(&qdisc->list);
-                else
-                        list_move(&qdisc->list, &cql);
-        }
-
-        /* unlink inner qdiscs from dev->qdisc_list immediately */
-        list_for_each_entry(cq, &cql, list)
-                list_for_each_entry_safe(q, n, &qdisc->dev->qdisc_list, list)
-                        if (TC_H_MAJ(q->parent) == TC_H_MAJ(cq->handle)) {
-                                if (q->ops->cl_ops == NULL)
-                                        list_del_init(&q->list);
-                                else
-                                        list_move_tail(&q->list, &cql);
-                        }
-        list_for_each_entry_safe(cq, n, &cql, list)
-                list_del_init(&cq->list);
+        list_del(&qdisc->list);
+#ifdef CONFIG_NET_ESTIMATOR
+        gen_kill_estimator(&qdisc->bstats, &qdisc->rate_est);
+#endif
+        if (ops->reset)
+                ops->reset(qdisc);
+        if (ops->destroy)
+                ops->destroy(qdisc);
 
+        module_put(ops->owner);
+        dev_put(qdisc->dev);
         call_rcu(&qdisc->q_rcu, __qdisc_destroy);
 }
 
@@ -549,15 +525,15 @@ void dev_activate(struct net_device *dev)
                                 printk(KERN_INFO "%s: activation failed\n", dev->name);
                                 return;
                         }
-                        write_lock_bh(&qdisc_tree_lock);
+                        write_lock(&qdisc_tree_lock);
                         list_add_tail(&qdisc->list, &dev->qdisc_list);
-                        write_unlock_bh(&qdisc_tree_lock);
+                        write_unlock(&qdisc_tree_lock);
                 } else {
                         qdisc =  &noqueue_qdisc;
                 }
-                write_lock_bh(&qdisc_tree_lock);
+                write_lock(&qdisc_tree_lock);
                 dev->qdisc_sleeping = qdisc;
-                write_unlock_bh(&qdisc_tree_lock);
+                write_unlock(&qdisc_tree_lock);
         }
 
         if (!netif_carrier_ok(dev))
diff --git a/net/sched/sch_htb.c b/net/sched/sch_htb.c
index bb3ddd4784b1..6c058e3660c0 100644
--- a/net/sched/sch_htb.c
+++ b/net/sched/sch_htb.c
@@ -391,7 +391,7 @@ static inline void htb_add_class_to_row(struct htb_sched *q,
 /* If this triggers, it is a bug in this code, but it need not be fatal */
 static void htb_safe_rb_erase(struct rb_node *rb, struct rb_root *root)
 {
-        if (RB_EMPTY_NODE(rb)) {
+        if (!RB_EMPTY_NODE(rb)) {
                 WARN_ON(1);
         } else {
                 rb_erase(rb, root);
diff --git a/net/sunrpc/auth.c b/net/sunrpc/auth.c
index 55163af3dcaf..993ff1a5d945 100644
--- a/net/sunrpc/auth.c
+++ b/net/sunrpc/auth.c
@@ -331,8 +331,8 @@ rpcauth_unbindcred(struct rpc_task *task)
         task->tk_msg.rpc_cred = NULL;
 }
 
-u32 *
-rpcauth_marshcred(struct rpc_task *task, u32 *p)
+__be32 *
+rpcauth_marshcred(struct rpc_task *task, __be32 *p)
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
 
@@ -342,8 +342,8 @@ rpcauth_marshcred(struct rpc_task *task, u32 *p)
         return cred->cr_ops->crmarshal(task, p);
 }
 
-u32 *
-rpcauth_checkverf(struct rpc_task *task, u32 *p)
+__be32 *
+rpcauth_checkverf(struct rpc_task *task, __be32 *p)
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
 
@@ -355,7 +355,7 @@ rpcauth_checkverf(struct rpc_task *task, u32 *p)
 
 int
 rpcauth_wrap_req(struct rpc_task *task, kxdrproc_t encode, void *rqstp,
-                u32 *data, void *obj)
+                __be32 *data, void *obj)
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
 
@@ -369,7 +369,7 @@ rpcauth_wrap_req(struct rpc_task *task, kxdrproc_t encode, void *rqstp,
 
 int
 rpcauth_unwrap_resp(struct rpc_task *task, kxdrproc_t decode, void *rqstp,
-                u32 *data, void *obj)
+                __be32 *data, void *obj)
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
 
diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index 6eed3e166ba3..a6ed2d22a6e6 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -826,14 +826,14 @@ out:
 * Marshal credentials.
 * Maybe we should keep a cached credential for performance reasons.
 */
-static u32 *
-gss_marshal(struct rpc_task *task, u32 *p)
+static __be32 *
+gss_marshal(struct rpc_task *task, __be32 *p)
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
         struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
                                                  gc_base);
         struct gss_cl_ctx       *ctx = gss_cred_get_ctx(cred);
-        u32             *cred_len;
+        __be32          *cred_len;
         struct rpc_rqst *req = task->tk_rqstp;
         u32             maj_stat = 0;
         struct xdr_netobj mic;
@@ -894,12 +894,12 @@ gss_refresh(struct rpc_task *task)
         return 0;
 }
 
-static u32 *
-gss_validate(struct rpc_task *task, u32 *p)
+static __be32 *
+gss_validate(struct rpc_task *task, __be32 *p)
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
         struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
-        u32             seq;
+        __be32          seq;
         struct kvec     iov;
         struct xdr_buf  verf_buf;
         struct xdr_netobj mic;
@@ -940,13 +940,14 @@ out_bad:
 
 static inline int
 gss_wrap_req_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
-                kxdrproc_t encode, struct rpc_rqst *rqstp, u32 *p, void *obj)
+                kxdrproc_t encode, struct rpc_rqst *rqstp, __be32 *p, void *obj)
 {
         struct xdr_buf  *snd_buf = &rqstp->rq_snd_buf;
         struct xdr_buf  integ_buf;
-        u32             *integ_len = NULL;
+        __be32          *integ_len = NULL;
         struct xdr_netobj mic;
-        u32             offset, *q;
+        u32             offset;
+        __be32          *q;
         struct kvec     *iov;
         u32             maj_stat = 0;
         int             status = -EIO;
@@ -1032,13 +1033,13 @@ out:
 
 static inline int
 gss_wrap_req_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
-                kxdrproc_t encode, struct rpc_rqst *rqstp, u32 *p, void *obj)
+                kxdrproc_t encode, struct rpc_rqst *rqstp, __be32 *p, void *obj)
 {
         struct xdr_buf  *snd_buf = &rqstp->rq_snd_buf;
         u32             offset;
         u32             maj_stat;
         int             status;
-        u32             *opaque_len;
+        __be32          *opaque_len;
         struct page     **inpages;
         int             first;
         int             pad;
@@ -1095,7 +1096,7 @@ gss_wrap_req_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
 
 static int
 gss_wrap_req(struct rpc_task *task,
-             kxdrproc_t encode, void *rqstp, u32 *p, void *obj)
+             kxdrproc_t encode, void *rqstp, __be32 *p, void *obj)
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
         struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
@@ -1132,7 +1133,7 @@ out:
 
 static inline int
 gss_unwrap_resp_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
-                struct rpc_rqst *rqstp, u32 **p)
+                struct rpc_rqst *rqstp, __be32 **p)
 {
         struct xdr_buf  *rcv_buf = &rqstp->rq_rcv_buf;
         struct xdr_buf integ_buf;
@@ -1169,7 +1170,7 @@ gss_unwrap_resp_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
 
 static inline int
 gss_unwrap_resp_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
-                struct rpc_rqst *rqstp, u32 **p)
+                struct rpc_rqst *rqstp, __be32 **p)
 {
         struct xdr_buf  *rcv_buf = &rqstp->rq_rcv_buf;
         u32 offset;
@@ -1198,13 +1199,13 @@ gss_unwrap_resp_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
 
 static int
 gss_unwrap_resp(struct rpc_task *task,
-                kxdrproc_t decode, void *rqstp, u32 *p, void *obj)
+                kxdrproc_t decode, void *rqstp, __be32 *p, void *obj)
 {
         struct rpc_cred *cred = task->tk_msg.rpc_cred;
         struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
                         gc_base);
         struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
-        u32             *savedp = p;
+        __be32          *savedp = p;
         struct kvec     *head = ((struct rpc_rqst *)rqstp)->rq_rcv_buf.head;
         int             savedlen = head->iov_len;
         int             status = -EIO;
diff --git a/net/sunrpc/auth_gss/gss_krb5_seal.c b/net/sunrpc/auth_gss/gss_krb5_seal.c
index 2f312164d6d5..08601ee4cd73 100644
--- a/net/sunrpc/auth_gss/gss_krb5_seal.c
+++ b/net/sunrpc/auth_gss/gss_krb5_seal.c
@@ -115,7 +115,7 @@ gss_get_mic_kerberos(struct gss_ctx *gss_ctx, struct xdr_buf *text,
         krb5_hdr = ptr - 2;
         msg_start = krb5_hdr + 24;
 
-        *(u16 *)(krb5_hdr + 2) = htons(ctx->signalg);
+        *(__be16 *)(krb5_hdr + 2) = htons(ctx->signalg);
         memset(krb5_hdr + 4, 0xff, 4);
 
         if (make_checksum(checksum_type, krb5_hdr, 8, text, 0, &md5cksum))
diff --git a/net/sunrpc/auth_gss/gss_krb5_wrap.c b/net/sunrpc/auth_gss/gss_krb5_wrap.c
index f179415d0c38..cc45c1605f80 100644
--- a/net/sunrpc/auth_gss/gss_krb5_wrap.c
+++ b/net/sunrpc/auth_gss/gss_krb5_wrap.c
@@ -177,9 +177,9 @@ gss_wrap_kerberos(struct gss_ctx *ctx, int offset,
         msg_start = krb5_hdr + 24;
         /* XXXJBF: */ BUG_ON(buf->head[0].iov_base + offset + headlen != msg_start + blocksize);
 
-        *(u16 *)(krb5_hdr + 2) = htons(kctx->signalg);
+        *(__be16 *)(krb5_hdr + 2) = htons(kctx->signalg);
         memset(krb5_hdr + 4, 0xff, 4);
-        *(u16 *)(krb5_hdr + 4) = htons(kctx->sealalg);
+        *(__be16 *)(krb5_hdr + 4) = htons(kctx->sealalg);
 
         make_confounder(msg_start, blocksize);
 
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index 94217ec9e2dd..638c0b576203 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -607,7 +607,7 @@ svc_safe_getnetobj(struct kvec *argv, struct xdr_netobj *o)
 
         if (argv->iov_len < 4)
                 return -1;
-        o->len = ntohl(svc_getu32(argv));
+        o->len = svc_getnl(argv);
         l = round_up_to_quad(o->len);
         if (argv->iov_len < l)
                 return -1;
@@ -620,17 +620,17 @@ svc_safe_getnetobj(struct kvec *argv, struct xdr_netobj *o)
 static inline int
 svc_safe_putnetobj(struct kvec *resv, struct xdr_netobj *o)
 {
-        u32 *p;
+        u8 *p;
 
         if (resv->iov_len + 4 > PAGE_SIZE)
                 return -1;
-        svc_putu32(resv, htonl(o->len));
+        svc_putnl(resv, o->len);
         p = resv->iov_base + resv->iov_len;
         resv->iov_len += round_up_to_quad(o->len);
         if (resv->iov_len > PAGE_SIZE)
                 return -1;
         memcpy(p, o->data, o->len);
-        memset((u8 *)p + o->len, 0, round_up_to_quad(o->len) - o->len);
+        memset(p + o->len, 0, round_up_to_quad(o->len) - o->len);
         return 0;
 }
 
@@ -640,7 +640,7 @@ svc_safe_putnetobj(struct kvec *resv, struct xdr_netobj *o)
  */
 static int
 gss_verify_header(struct svc_rqst *rqstp, struct rsc *rsci,
-                  u32 *rpcstart, struct rpc_gss_wire_cred *gc, u32 *authp)
+                  __be32 *rpcstart, struct rpc_gss_wire_cred *gc, __be32 *authp)
 {
         struct gss_ctx          *ctx_id = rsci->mechctx;
         struct xdr_buf          rpchdr;
@@ -657,7 +657,7 @@ gss_verify_header(struct svc_rqst *rqstp, struct rsc *rsci,
         *authp = rpc_autherr_badverf;
         if (argv->iov_len < 4)
                 return SVC_DENIED;
-        flavor = ntohl(svc_getu32(argv));
+        flavor = svc_getnl(argv);
         if (flavor != RPC_AUTH_GSS)
                 return SVC_DENIED;
         if (svc_safe_getnetobj(argv, &checksum))
@@ -687,9 +687,9 @@ gss_verify_header(struct svc_rqst *rqstp, struct rsc *rsci,
 static int
 gss_write_null_verf(struct svc_rqst *rqstp)
 {
-        u32     *p;
+        __be32     *p;
 
-        svc_putu32(rqstp->rq_res.head, htonl(RPC_AUTH_NULL));
+        svc_putnl(rqstp->rq_res.head, RPC_AUTH_NULL);
         p = rqstp->rq_res.head->iov_base + rqstp->rq_res.head->iov_len;
         /* don't really need to check if head->iov_len > PAGE_SIZE ... */
         *p++ = 0;
@@ -701,14 +701,14 @@ gss_write_null_verf(struct svc_rqst *rqstp)
 static int
 gss_write_verf(struct svc_rqst *rqstp, struct gss_ctx *ctx_id, u32 seq)
 {
-        u32                     xdr_seq;
+        __be32                  xdr_seq;
         u32                     maj_stat;
         struct xdr_buf          verf_data;
         struct xdr_netobj       mic;
-        u32                     *p;
+        __be32                  *p;
         struct kvec             iov;
 
-        svc_putu32(rqstp->rq_res.head, htonl(RPC_AUTH_GSS));
+        svc_putnl(rqstp->rq_res.head, RPC_AUTH_GSS);
         xdr_seq = htonl(seq);
 
         iov.iov_base = &xdr_seq;
@@ -782,7 +782,7 @@ EXPORT_SYMBOL(svcauth_gss_register_pseudoflavor);
 static inline int
 read_u32_from_xdr_buf(struct xdr_buf *buf, int base, u32 *obj)
 {
-        u32     raw;
+        __be32  raw;
         int     status;
 
         status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj));
@@ -805,7 +805,7 @@ unwrap_integ_data(struct xdr_buf *buf, u32 seq, struct gss_ctx *ctx)
         struct xdr_netobj mic;
         struct xdr_buf integ_buf;
 
-        integ_len = ntohl(svc_getu32(&buf->head[0]));
+        integ_len = svc_getnl(&buf->head[0]);
         if (integ_len & 3)
                 goto out;
         if (integ_len > buf->len)
@@ -825,7 +825,7 @@ unwrap_integ_data(struct xdr_buf *buf, u32 seq, struct gss_ctx *ctx)
         maj_stat = gss_verify_mic(ctx, &integ_buf, &mic);
         if (maj_stat != GSS_S_COMPLETE)
                 goto out;
-        if (ntohl(svc_getu32(&buf->head[0])) != seq)
+        if (svc_getnl(&buf->head[0]) != seq)
                 goto out;
         stat = 0;
 out:
@@ -857,7 +857,7 @@ unwrap_priv_data(struct svc_rqst *rqstp, struct xdr_buf *buf, u32 seq, struct gs
 
         rqstp->rq_sendfile_ok = 0;
 
-        priv_len = ntohl(svc_getu32(&buf->head[0]));
+        priv_len = svc_getnl(&buf->head[0]);
         if (rqstp->rq_deferred) {
                 /* Already decrypted last time through! The sequence number
                  * check at out_seq is unnecessary but harmless: */
@@ -895,7 +895,7 @@ unwrap_priv_data(struct svc_rqst *rqstp, struct xdr_buf *buf, u32 seq, struct gs
         if (maj_stat != GSS_S_COMPLETE)
                 return -EINVAL;
 out_seq:
-        if (ntohl(svc_getu32(&buf->head[0])) != seq)
+        if (svc_getnl(&buf->head[0]) != seq)
                 return -EINVAL;
         return 0;
 }
@@ -905,7 +905,7 @@ struct gss_svc_data {
         struct rpc_gss_wire_cred        clcred;
         /* pointer to the beginning of the procedure-specific results,
          * which may be encrypted/checksummed in svcauth_gss_release: */
-        u32                             *body_start;
+        __be32                          *body_start;
         struct rsc                      *rsci;
 };
 
@@ -946,7 +946,7 @@ gss_write_init_verf(struct svc_rqst *rqstp, struct rsi *rsip)
  * response here and return SVC_COMPLETE.
  */
 static int
-svcauth_gss_accept(struct svc_rqst *rqstp, u32 *authp)
+svcauth_gss_accept(struct svc_rqst *rqstp, __be32 *authp)
 {
         struct kvec     *argv = &rqstp->rq_arg.head[0];
         struct kvec     *resv = &rqstp->rq_res.head[0];
@@ -956,8 +956,8 @@ svcauth_gss_accept(struct svc_rqst *rqstp, u32 *authp)
         struct rpc_gss_wire_cred *gc;
         struct rsc      *rsci = NULL;
         struct rsi      *rsip, rsikey;
-        u32             *rpcstart;
-        u32             *reject_stat = resv->iov_base + resv->iov_len;
+        __be32          *rpcstart;
+        __be32          *reject_stat = resv->iov_base + resv->iov_len;
         int             ret;
 
         dprintk("RPC:      svcauth_gss: argv->iov_len = %zd\n",argv->iov_len);
@@ -985,12 +985,12 @@ svcauth_gss_accept(struct svc_rqst *rqstp, u32 *authp)
 
         if (argv->iov_len < 5 * 4)
                 goto auth_err;
-        crlen = ntohl(svc_getu32(argv));
-        if (ntohl(svc_getu32(argv)) != RPC_GSS_VERSION)
+        crlen = svc_getnl(argv);
+        if (svc_getnl(argv) != RPC_GSS_VERSION)
                 goto auth_err;
-        gc->gc_proc = ntohl(svc_getu32(argv));
-        gc->gc_seq = ntohl(svc_getu32(argv));
-        gc->gc_svc = ntohl(svc_getu32(argv));
+        gc->gc_proc = svc_getnl(argv);
+        gc->gc_seq = svc_getnl(argv);
+        gc->gc_svc = svc_getnl(argv);
         if (svc_safe_getnetobj(argv, &gc->gc_ctx))
                 goto auth_err;
         if (crlen != round_up_to_quad(gc->gc_ctx.len) + 5 * 4)
@@ -1016,9 +1016,9 @@ svcauth_gss_accept(struct svc_rqst *rqstp, u32 *authp)
         case RPC_GSS_PROC_CONTINUE_INIT:
                 if (argv->iov_len < 2 * 4)
                         goto auth_err;
-                if (ntohl(svc_getu32(argv)) != RPC_AUTH_NULL)
+                if (svc_getnl(argv) != RPC_AUTH_NULL)
                         goto auth_err;
-                if (ntohl(svc_getu32(argv)) != 0)
+                if (svc_getnl(argv) != 0)
                         goto auth_err;
                 break;
         case RPC_GSS_PROC_DATA:
@@ -1076,14 +1076,14 @@ svcauth_gss_accept(struct svc_rqst *rqstp, u32 *authp)
                                 goto drop;
                         if (resv->iov_len + 4 > PAGE_SIZE)
                                 goto drop;
-                        svc_putu32(resv, rpc_success);
+                        svc_putnl(resv, RPC_SUCCESS);
                         if (svc_safe_putnetobj(resv, &rsip->out_handle))
                                 goto drop;
                         if (resv->iov_len + 3 * 4 > PAGE_SIZE)
                                 goto drop;
-                        svc_putu32(resv, htonl(rsip->major_status));
-                        svc_putu32(resv, htonl(rsip->minor_status));
-                        svc_putu32(resv, htonl(GSS_SEQ_WIN));
+                        svc_putnl(resv, rsip->major_status);
+                        svc_putnl(resv, rsip->minor_status);
+                        svc_putnl(resv, GSS_SEQ_WIN);
                         if (svc_safe_putnetobj(resv, &rsip->out_token))
                                 goto drop;
                         rqstp->rq_client = NULL;
@@ -1093,7 +1093,7 @@ svcauth_gss_accept(struct svc_rqst *rqstp, u32 *authp)
                 set_bit(CACHE_NEGATIVE, &rsci->h.flags);
                 if (resv->iov_len + 4 > PAGE_SIZE)
                         goto drop;
-                svc_putu32(resv, rpc_success);
+                svc_putnl(resv, RPC_SUCCESS);
                 goto complete;
         case RPC_GSS_PROC_DATA:
                 *authp = rpcsec_gsserr_ctxproblem;
@@ -1111,8 +1111,8 @@ svcauth_gss_accept(struct svc_rqst *rqstp, u32 *authp)
                                 goto auth_err;
                         /* placeholders for length and seq. number: */
                         svcdata->body_start = resv->iov_base + resv->iov_len;
-                        svc_putu32(resv, 0);
-                        svc_putu32(resv, 0);
+                        svc_putnl(resv, 0);
+                        svc_putnl(resv, 0);
                         break;
                 case RPC_GSS_SVC_PRIVACY:
                         if (unwrap_priv_data(rqstp, &rqstp->rq_arg,
@@ -1120,8 +1120,8 @@ svcauth_gss_accept(struct svc_rqst *rqstp, u32 *authp)
                                 goto auth_err;
                         /* placeholders for length and seq. number: */
                         svcdata->body_start = resv->iov_base + resv->iov_len;
-                        svc_putu32(resv, 0);
-                        svc_putu32(resv, 0);
+                        svc_putnl(resv, 0);
+                        svc_putnl(resv, 0);
                         break;
                 default:
                         goto auth_err;
@@ -1156,7 +1156,7 @@ svcauth_gss_wrap_resp_integ(struct svc_rqst *rqstp)
         struct xdr_buf integ_buf;
         struct xdr_netobj mic;
         struct kvec *resv;
-        u32 *p;
+        __be32 *p;
         int integ_offset, integ_len;
         int stat = -EINVAL;
 
@@ -1199,7 +1199,7 @@ svcauth_gss_wrap_resp_integ(struct svc_rqst *rqstp)
         mic.data = (u8 *)resv->iov_base + resv->iov_len + 4;
         if (gss_get_mic(gsd->rsci->mechctx, &integ_buf, &mic))
                 goto out_err;
-        svc_putu32(resv, htonl(mic.len));
+        svc_putnl(resv, mic.len);
         memset(mic.data + mic.len, 0,
                         round_up_to_quad(mic.len) - mic.len);
         resv->iov_len += XDR_QUADLEN(mic.len) << 2;
@@ -1219,8 +1219,8 @@ svcauth_gss_wrap_resp_priv(struct svc_rqst *rqstp)
         struct rpc_gss_wire_cred *gc = &gsd->clcred;
         struct xdr_buf *resbuf = &rqstp->rq_res;
         struct page **inpages = NULL;
-        u32 *p;
-        int offset, *len;
+        __be32 *p, *len;
+        int offset;
         int pad;
 
         p = gsd->body_start;
@@ -1264,7 +1264,7 @@ svcauth_gss_wrap_resp_priv(struct svc_rqst *rqstp)
                 return -ENOMEM;
         *len = htonl(resbuf->len - offset);
         pad = 3 - ((resbuf->len - offset - 1)&3);
-        p = (u32 *)(resbuf->tail[0].iov_base + resbuf->tail[0].iov_len);
+        p = (__be32 *)(resbuf->tail[0].iov_base + resbuf->tail[0].iov_len);
         memset(p, 0, pad);
         resbuf->tail[0].iov_len += pad;
         resbuf->len += pad;
diff --git a/net/sunrpc/auth_null.c b/net/sunrpc/auth_null.c
index 2eccffa96ba1..3be257dc32b2 100644
--- a/net/sunrpc/auth_null.c
+++ b/net/sunrpc/auth_null.c
@@ -60,8 +60,8 @@ nul_match(struct auth_cred *acred, struct rpc_cred *cred, int taskflags)
 /*
  * Marshal credential.
  */
-static u32 *
-nul_marshal(struct rpc_task *task, u32 *p)
+static __be32 *
+nul_marshal(struct rpc_task *task, __be32 *p)
 {
         *p++ = htonl(RPC_AUTH_NULL);
         *p++ = 0;
@@ -81,8 +81,8 @@ nul_refresh(struct rpc_task *task)
         return 0;
 }
 
-static u32 *
-nul_validate(struct rpc_task *task, u32 *p)
+static __be32 *
+nul_validate(struct rpc_task *task, __be32 *p)
 {
         rpc_authflavor_t        flavor;
         u32                     size;
diff --git a/net/sunrpc/auth_unix.c b/net/sunrpc/auth_unix.c
index 74c7406a1054..f7f990c9afe2 100644
--- a/net/sunrpc/auth_unix.c
+++ b/net/sunrpc/auth_unix.c
@@ -137,12 +137,12 @@ unx_match(struct auth_cred *acred, struct rpc_cred *rcred, int flags)
  * Marshal credentials.
  * Maybe we should keep a cached credential for performance reasons.
  */
-static u32 *
-unx_marshal(struct rpc_task *task, u32 *p)
+static __be32 *
+unx_marshal(struct rpc_task *task, __be32 *p)
 {
         struct rpc_clnt *clnt = task->tk_client;
         struct unx_cred *cred = (struct unx_cred *) task->tk_msg.rpc_cred;
-        u32             *base, *hold;
+        __be32          *base, *hold;
         int             i;
 
         *p++ = htonl(RPC_AUTH_UNIX);
@@ -178,8 +178,8 @@ unx_refresh(struct rpc_task *task)
         return 0;
 }
 
-static u32 *
-unx_validate(struct rpc_task *task, u32 *p)
+static __be32 *
+unx_validate(struct rpc_task *task, __be32 *p)
 {
         rpc_authflavor_t        flavor;
         u32                     size;
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index 084a0ad5c64e..124ff0ceb55b 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -60,8 +60,8 @@ static void	call_refreshresult(struct rpc_task *task);
 static void     call_timeout(struct rpc_task *task);
 static void     call_connect(struct rpc_task *task);
 static void     call_connect_status(struct rpc_task *task);
-static u32 *    call_header(struct rpc_task *task);
-static u32 *    call_verify(struct rpc_task *task);
+static __be32 * call_header(struct rpc_task *task);
+static __be32 * call_verify(struct rpc_task *task);
 
 
 static int
@@ -782,7 +782,7 @@ call_encode(struct rpc_task *task)
         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
         unsigned int    bufsiz;
         kxdrproc_t      encode;
-        u32             *p;
+        __be32          *p;
 
         dprintk("RPC: %4d call_encode (status %d)\n", 
                                 task->tk_pid, task->tk_status);
@@ -1100,7 +1100,7 @@ call_decode(struct rpc_task *task)
         struct rpc_clnt *clnt = task->tk_client;
         struct rpc_rqst *req = task->tk_rqstp;
         kxdrproc_t      decode = task->tk_msg.rpc_proc->p_decode;
-        u32             *p;
+        __be32          *p;
 
         dprintk("RPC: %4d call_decode (status %d)\n", 
                                 task->tk_pid, task->tk_status);
@@ -1197,12 +1197,12 @@ call_refreshresult(struct rpc_task *task)
 /*
  * Call header serialization
  */
-static u32 *
+static __be32 *
 call_header(struct rpc_task *task)
 {
         struct rpc_clnt *clnt = task->tk_client;
         struct rpc_rqst *req = task->tk_rqstp;
-        u32             *p = req->rq_svec[0].iov_base;
+        __be32          *p = req->rq_svec[0].iov_base;
 
         /* FIXME: check buffer size? */
 
@@ -1221,12 +1221,13 @@ call_header(struct rpc_task *task)
 /*
  * Reply header verification
  */
-static u32 *
+static __be32 *
 call_verify(struct rpc_task *task)
 {
         struct kvec *iov = &task->tk_rqstp->rq_rcv_buf.head[0];
         int len = task->tk_rqstp->rq_rcv_buf.len >> 2;
-        u32     *p = iov->iov_base, n;
+        __be32  *p = iov->iov_base;
+        u32 n;
         int error = -EACCES;
 
         if ((task->tk_rqstp->rq_rcv_buf.len & 3) != 0) {
@@ -1303,7 +1304,7 @@ call_verify(struct rpc_task *task)
                 printk(KERN_WARNING "call_verify: auth check failed\n");
                 goto out_garbage;               /* bad verifier, retry */
         }
-        len = p - (u32 *)iov->iov_base - 1;
+        len = p - (__be32 *)iov->iov_base - 1;
         if (len < 0)
                 goto out_overflow;
         switch ((n = ntohl(*p++))) {
@@ -1358,12 +1359,12 @@ out_overflow:
         goto out_garbage;
 }
 
-static int rpcproc_encode_null(void *rqstp, u32 *data, void *obj)
+static int rpcproc_encode_null(void *rqstp, __be32 *data, void *obj)
 {
         return 0;
 }
 
-static int rpcproc_decode_null(void *rqstp, u32 *data, void *obj)
+static int rpcproc_decode_null(void *rqstp, __be32 *data, void *obj)
 {
         return 0;
 }
diff --git a/net/sunrpc/pmap_clnt.c b/net/sunrpc/pmap_clnt.c
index c04609d3476a..919d5ba7ca0a 100644
--- a/net/sunrpc/pmap_clnt.c
+++ b/net/sunrpc/pmap_clnt.c
@@ -300,7 +300,7 @@ static struct rpc_clnt *pmap_create(char *hostname, struct sockaddr_in *srvaddr,
 /*
  * XDR encode/decode functions for PMAP
  */
-static int xdr_encode_mapping(struct rpc_rqst *req, u32 *p, struct portmap_args *map)
+static int xdr_encode_mapping(struct rpc_rqst *req, __be32 *p, struct portmap_args *map)
 {
         dprintk("RPC: xdr_encode_mapping(%u, %u, %u, %u)\n",
                 map->pm_prog, map->pm_vers, map->pm_prot, map->pm_port);
@@ -313,13 +313,13 @@ static int xdr_encode_mapping(struct rpc_rqst *req, u32 *p, struct portmap_args
         return 0;
 }
 
-static int xdr_decode_port(struct rpc_rqst *req, u32 *p, unsigned short *portp)
+static int xdr_decode_port(struct rpc_rqst *req, __be32 *p, unsigned short *portp)
 {
         *portp = (unsigned short) ntohl(*p++);
         return 0;
 }
 
-static int xdr_decode_bool(struct rpc_rqst *req, u32 *p, unsigned int *boolp)
+static int xdr_decode_bool(struct rpc_rqst *req, __be32 *p, unsigned int *boolp)
 {
         *boolp = (unsigned int) ntohl(*p++);
         return 0;
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index b76a227dd3ad..44b8d9d4c18a 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -256,11 +256,11 @@ svc_process(struct svc_serv *serv, struct svc_rqst *rqstp)
         struct kvec *           argv = &rqstp->rq_arg.head[0];
         struct kvec *           resv = &rqstp->rq_res.head[0];
         kxdrproc_t              xdr;
-        u32                     *statp;
-        u32                     dir, prog, vers, proc,
-                                auth_stat, rpc_stat;
+        __be32                  *statp;
+        u32                     dir, prog, vers, proc;
+        __be32                  auth_stat, rpc_stat;
         int                     auth_res;
-        u32                     *accept_statp;
+        __be32                  *accept_statp;
 
         rpc_stat = rpc_success;
 
@@ -284,16 +284,16 @@ svc_process(struct svc_serv *serv, struct svc_rqst *rqstp)
         rqstp->rq_sendfile_ok = 1;
         /* tcp needs a space for the record length... */
         if (rqstp->rq_prot == IPPROTO_TCP)
-                svc_putu32(resv, 0);
+                svc_putnl(resv, 0);
 
         rqstp->rq_xid = svc_getu32(argv);
         svc_putu32(resv, rqstp->rq_xid);
 
-        dir  = ntohl(svc_getu32(argv));
-        vers = ntohl(svc_getu32(argv));
+        dir  = svc_getnl(argv);
+        vers = svc_getnl(argv);
 
         /* First words of reply: */
-        svc_putu32(resv, xdr_one);              /* REPLY */
+        svc_putnl(resv, 1);             /* REPLY */
 
         if (dir != 0)           /* direction != CALL */
                 goto err_bad_dir;
@@ -303,11 +303,11 @@ svc_process(struct svc_serv *serv, struct svc_rqst *rqstp)
         /* Save position in case we later decide to reject: */
         accept_statp = resv->iov_base + resv->iov_len;
 
-        svc_putu32(resv, xdr_zero);             /* ACCEPT */
+        svc_putnl(resv, 0);             /* ACCEPT */
 
-        rqstp->rq_prog = prog = ntohl(svc_getu32(argv));        /* program number */
-        rqstp->rq_vers = vers = ntohl(svc_getu32(argv));        /* version number */
-        rqstp->rq_proc = proc = ntohl(svc_getu32(argv));        /* procedure number */
+        rqstp->rq_prog = prog = svc_getnl(argv);        /* program number */
+        rqstp->rq_vers = vers = svc_getnl(argv);        /* version number */
+        rqstp->rq_proc = proc = svc_getnl(argv);        /* procedure number */
 
         progp = serv->sv_program;
 
@@ -361,7 +361,7 @@ svc_process(struct svc_serv *serv, struct svc_rqst *rqstp)
 
         /* Build the reply header. */
         statp = resv->iov_base +resv->iov_len;
-        svc_putu32(resv, rpc_success);          /* RPC_SUCCESS */
+        svc_putnl(resv, RPC_SUCCESS);
 
         /* Bump per-procedure stats counter */
         procp->pc_count++;
@@ -439,10 +439,10 @@ err_bad_dir:
 
 err_bad_rpc:
         serv->sv_stats->rpcbadfmt++;
-        svc_putu32(resv, xdr_one);      /* REJECT */
-        svc_putu32(resv, xdr_zero);     /* RPC_MISMATCH */
-        svc_putu32(resv, xdr_two);      /* Only RPCv2 supported */
-        svc_putu32(resv, xdr_two);
+        svc_putnl(resv, 1);     /* REJECT */
+        svc_putnl(resv, 0);     /* RPC_MISMATCH */
+        svc_putnl(resv, 2);     /* Only RPCv2 supported */
+        svc_putnl(resv, 2);
         goto sendit;
 
 err_bad_auth:
@@ -450,15 +450,15 @@ err_bad_auth:
         serv->sv_stats->rpcbadauth++;
         /* Restore write pointer to location of accept status: */
         xdr_ressize_check(rqstp, accept_statp);
-        svc_putu32(resv, xdr_one);      /* REJECT */
-        svc_putu32(resv, xdr_one);      /* AUTH_ERROR */
-        svc_putu32(resv, auth_stat);    /* status */
+        svc_putnl(resv, 1);     /* REJECT */
+        svc_putnl(resv, 1);     /* AUTH_ERROR */
+        svc_putnl(resv, ntohl(auth_stat));      /* status */
         goto sendit;
 
 err_bad_prog:
         dprintk("svc: unknown program %d\n", prog);
         serv->sv_stats->rpcbadfmt++;
-        svc_putu32(resv, rpc_prog_unavail);
+        svc_putnl(resv, RPC_PROG_UNAVAIL);
         goto sendit;
 
 err_bad_vers:
@@ -466,9 +466,9 @@ err_bad_vers:
         printk("svc: unknown version (%d)\n", vers);
 #endif
         serv->sv_stats->rpcbadfmt++;
-        svc_putu32(resv, rpc_prog_mismatch);
-        svc_putu32(resv, htonl(progp->pg_lovers));
-        svc_putu32(resv, htonl(progp->pg_hivers));
+        svc_putnl(resv, RPC_PROG_MISMATCH);
+        svc_putnl(resv, progp->pg_lovers);
+        svc_putnl(resv, progp->pg_hivers);
         goto sendit;
 
 err_bad_proc:
@@ -476,7 +476,7 @@ err_bad_proc:
         printk("svc: unknown procedure (%d)\n", proc);
 #endif
         serv->sv_stats->rpcbadfmt++;
-        svc_putu32(resv, rpc_proc_unavail);
+        svc_putnl(resv, RPC_PROC_UNAVAIL);
         goto sendit;
 
 err_garbage:
@@ -486,6 +486,6 @@ err_garbage:
         rpc_stat = rpc_garbage_args;
 err_bad:
         serv->sv_stats->rpcbadfmt++;
-        svc_putu32(resv, rpc_stat);
+        svc_putnl(resv, ntohl(rpc_stat));
         goto sendit;
 }
diff --git a/net/sunrpc/svcauth.c b/net/sunrpc/svcauth.c
index 5b28c6176806..8f2320aded5c 100644
--- a/net/sunrpc/svcauth.c
+++ b/net/sunrpc/svcauth.c
@@ -35,14 +35,14 @@ static struct auth_ops	*authtab[RPC_AUTH_MAXFLAVOR] = {
 };
 
 int
-svc_authenticate(struct svc_rqst *rqstp, u32 *authp)
+svc_authenticate(struct svc_rqst *rqstp, __be32 *authp)
 {
         rpc_authflavor_t        flavor;
         struct auth_ops         *aops;
 
         *authp = rpc_auth_ok;
 
-        flavor = ntohl(svc_getu32(&rqstp->rq_arg.head[0]));
+        flavor = svc_getnl(&rqstp->rq_arg.head[0]);
 
         dprintk("svc: svc_authenticate (%d)\n", flavor);
 
diff --git a/net/sunrpc/svcauth_unix.c b/net/sunrpc/svcauth_unix.c
index 7e5707e2d6b6..1020d54b01d0 100644
--- a/net/sunrpc/svcauth_unix.c
+++ b/net/sunrpc/svcauth_unix.c
@@ -145,7 +145,7 @@ static void ip_map_request(struct cache_detail *cd,
 {
         char text_addr[20];
         struct ip_map *im = container_of(h, struct ip_map, h);
-        __u32 addr = im->m_addr.s_addr;
+        __be32 addr = im->m_addr.s_addr;
         
         snprintf(text_addr, 20, "%u.%u.%u.%u",
                  ntohl(addr) >> 24 & 0xff,
@@ -249,10 +249,10 @@ static int ip_map_show(struct seq_file *m,
 
         seq_printf(m, "%s %d.%d.%d.%d %s\n",
                    im->m_class,
-                   htonl(addr.s_addr) >> 24 & 0xff,
-                   htonl(addr.s_addr) >> 16 & 0xff,
-                   htonl(addr.s_addr) >>  8 & 0xff,
-                   htonl(addr.s_addr) >>  0 & 0xff,
+                   ntohl(addr.s_addr) >> 24 & 0xff,
+                   ntohl(addr.s_addr) >> 16 & 0xff,
+                   ntohl(addr.s_addr) >>  8 & 0xff,
+                   ntohl(addr.s_addr) >>  0 & 0xff,
                    dom
                    );
         return 0;
@@ -410,7 +410,7 @@ svcauth_unix_set_client(struct svc_rqst *rqstp)
 }
 
 static int
-svcauth_null_accept(struct svc_rqst *rqstp, u32 *authp)
+svcauth_null_accept(struct svc_rqst *rqstp, __be32 *authp)
 {
         struct kvec     *argv = &rqstp->rq_arg.head[0];
         struct kvec     *resv = &rqstp->rq_res.head[0];
@@ -427,7 +427,7 @@ svcauth_null_accept(struct svc_rqst *rqstp, u32 *authp)
                 *authp = rpc_autherr_badcred;
                 return SVC_DENIED;
         }
-        if (svc_getu32(argv) != RPC_AUTH_NULL || svc_getu32(argv) != 0) {
+        if (svc_getu32(argv) != htonl(RPC_AUTH_NULL) || svc_getu32(argv) != 0) {
                 dprintk("svc: bad null verf\n");
                 *authp = rpc_autherr_badverf;
                 return SVC_DENIED;
@@ -441,8 +441,8 @@ svcauth_null_accept(struct svc_rqst *rqstp, u32 *authp)
                 return SVC_DROP; /* kmalloc failure - client must retry */
 
         /* Put NULL verifier */
-        svc_putu32(resv, RPC_AUTH_NULL);
-        svc_putu32(resv, 0);
+        svc_putnl(resv, RPC_AUTH_NULL);
+        svc_putnl(resv, 0);
 
         return SVC_OK;
 }
@@ -472,7 +472,7 @@ struct auth_ops svcauth_null = {
 
 
 static int
-svcauth_unix_accept(struct svc_rqst *rqstp, u32 *authp)
+svcauth_unix_accept(struct svc_rqst *rqstp, __be32 *authp)
 {
         struct kvec     *argv = &rqstp->rq_arg.head[0];
         struct kvec     *resv = &rqstp->rq_res.head[0];
@@ -488,31 +488,31 @@ svcauth_unix_accept(struct svc_rqst *rqstp, u32 *authp)
 
         svc_getu32(argv);                       /* length */
         svc_getu32(argv);                       /* time stamp */
-        slen = XDR_QUADLEN(ntohl(svc_getu32(argv)));    /* machname length */
+        slen = XDR_QUADLEN(svc_getnl(argv));    /* machname length */
         if (slen > 64 || (len -= (slen + 3)*4) < 0)
                 goto badcred;
-        argv->iov_base = (void*)((u32*)argv->iov_base + slen);  /* skip machname */
+        argv->iov_base = (void*)((__be32*)argv->iov_base + slen);       /* skip machname */
         argv->iov_len -= slen*4;
 
-        cred->cr_uid = ntohl(svc_getu32(argv));         /* uid */
-        cred->cr_gid = ntohl(svc_getu32(argv));         /* gid */
-        slen = ntohl(svc_getu32(argv));                 /* gids length */
+        cred->cr_uid = svc_getnl(argv);         /* uid */
+        cred->cr_gid = svc_getnl(argv);         /* gid */
+        slen = svc_getnl(argv);                 /* gids length */
         if (slen > 16 || (len -= (slen + 2)*4) < 0)
                 goto badcred;
         cred->cr_group_info = groups_alloc(slen);
         if (cred->cr_group_info == NULL)
                 return SVC_DROP;
         for (i = 0; i < slen; i++)
-                GROUP_AT(cred->cr_group_info, i) = ntohl(svc_getu32(argv));
+                GROUP_AT(cred->cr_group_info, i) = svc_getnl(argv);
 
-        if (svc_getu32(argv) != RPC_AUTH_NULL || svc_getu32(argv) != 0) {
+        if (svc_getu32(argv) != htonl(RPC_AUTH_NULL) || svc_getu32(argv) != 0) {
                 *authp = rpc_autherr_badverf;
                 return SVC_DENIED;
         }
 
         /* Put NULL verifier */
-        svc_putu32(resv, RPC_AUTH_NULL);
-        svc_putu32(resv, 0);
+        svc_putnl(resv, RPC_AUTH_NULL);
+        svc_putnl(resv, 0);
 
         return SVC_OK;
 
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index 953aff89bcac..5b0fe1b66a23 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -1030,7 +1030,7 @@ svc_tcp_sendto(struct svc_rqst *rqstp)
 {
         struct xdr_buf  *xbufp = &rqstp->rq_res;
         int sent;
-        u32 reclen;
+        __be32 reclen;
 
         /* Set up the first element of the reply kvec.
          * Any other kvecs that may be in use have been taken
@@ -1393,14 +1393,12 @@ svc_create_socket(struct svc_serv *serv, int protocol, struct sockaddr_in *sin)
         if ((error = sock_create_kern(PF_INET, type, protocol, &sock)) < 0)
                 return error;
 
-        if (sin != NULL) {
-                if (type == SOCK_STREAM)
-                        sock->sk->sk_reuse = 1; /* allow address reuse */
-                error = kernel_bind(sock, (struct sockaddr *) sin,
-                                                sizeof(*sin));
-                if (error < 0)
-                        goto bummer;
-        }
+        if (type == SOCK_STREAM)
+                sock->sk->sk_reuse = 1; /* allow address reuse */
+        error = kernel_bind(sock, (struct sockaddr *) sin,
+                                        sizeof(*sin));
+        if (error < 0)
+                goto bummer;
 
         if (protocol == IPPROTO_TCP) {
                 if ((error = kernel_listen(sock, 64)) < 0)
diff --git a/net/sunrpc/xdr.c b/net/sunrpc/xdr.c
index 6ac45103a272..9022eb8b37ed 100644
--- a/net/sunrpc/xdr.c
+++ b/net/sunrpc/xdr.c
@@ -18,8 +18,8 @@
 /*
  * XDR functions for basic NFS types
  */
-u32 *
-xdr_encode_netobj(u32 *p, const struct xdr_netobj *obj)
+__be32 *
+xdr_encode_netobj(__be32 *p, const struct xdr_netobj *obj)
 {
         unsigned int    quadlen = XDR_QUADLEN(obj->len);
 
@@ -29,8 +29,8 @@ xdr_encode_netobj(u32 *p, const struct xdr_netobj *obj)
         return p + XDR_QUADLEN(obj->len);
 }
 
-u32 *
-xdr_decode_netobj(u32 *p, struct xdr_netobj *obj)
+__be32 *
+xdr_decode_netobj(__be32 *p, struct xdr_netobj *obj)
 {
         unsigned int    len;
 
@@ -55,7 +55,7 @@ xdr_decode_netobj(u32 *p, struct xdr_netobj *obj)
  * Returns the updated current XDR buffer position
  *
  */
-u32 *xdr_encode_opaque_fixed(u32 *p, const void *ptr, unsigned int nbytes)
+__be32 *xdr_encode_opaque_fixed(__be32 *p, const void *ptr, unsigned int nbytes)
 {
         if (likely(nbytes != 0)) {
                 unsigned int quadlen = XDR_QUADLEN(nbytes);
@@ -79,21 +79,21 @@ EXPORT_SYMBOL(xdr_encode_opaque_fixed);
  *
  * Returns the updated current XDR buffer position
  */
-u32 *xdr_encode_opaque(u32 *p, const void *ptr, unsigned int nbytes)
+__be32 *xdr_encode_opaque(__be32 *p, const void *ptr, unsigned int nbytes)
 {
         *p++ = htonl(nbytes);
         return xdr_encode_opaque_fixed(p, ptr, nbytes);
 }
 EXPORT_SYMBOL(xdr_encode_opaque);
 
-u32 *
-xdr_encode_string(u32 *p, const char *string)
+__be32 *
+xdr_encode_string(__be32 *p, const char *string)
 {
         return xdr_encode_array(p, string, strlen(string));
 }
 
-u32 *
-xdr_decode_string_inplace(u32 *p, char **sp, int *lenp, int maxlen)
+__be32 *
+xdr_decode_string_inplace(__be32 *p, char **sp, int *lenp, int maxlen)
 {
         unsigned int    len;
 
@@ -432,7 +432,7 @@ xdr_shift_buf(struct xdr_buf *buf, size_t len)
  *       of the buffer length, and takes care of adjusting the kvec
  *       length for us.
  */
-void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, uint32_t *p)
+void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
 {
         struct kvec *iov = buf->head;
         int scratch_len = buf->buflen - buf->page_len - buf->tail[0].iov_len;
@@ -440,8 +440,8 @@ void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, uint32_t *p)
         BUG_ON(scratch_len < 0);
         xdr->buf = buf;
         xdr->iov = iov;
-        xdr->p = (uint32_t *)((char *)iov->iov_base + iov->iov_len);
-        xdr->end = (uint32_t *)((char *)iov->iov_base + scratch_len);
+        xdr->p = (__be32 *)((char *)iov->iov_base + iov->iov_len);
+        xdr->end = (__be32 *)((char *)iov->iov_base + scratch_len);
         BUG_ON(iov->iov_len > scratch_len);
 
         if (p != xdr->p && p != NULL) {
@@ -465,10 +465,10 @@ EXPORT_SYMBOL(xdr_init_encode);
  * bytes of data. If so, update the total xdr_buf length, and
  * adjust the length of the current kvec.
  */
-uint32_t * xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes)
+__be32 * xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes)
 {
-        uint32_t *p = xdr->p;
-        uint32_t *q;
+        __be32 *p = xdr->p;
+        __be32 *q;
 
         /* align nbytes on the next 32-bit boundary */
         nbytes += 3;
@@ -524,7 +524,7 @@ EXPORT_SYMBOL(xdr_write_pages);
  * @buf: pointer to XDR buffer from which to decode data
  * @p: current pointer inside XDR buffer
  */
-void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, uint32_t *p)
+void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
 {
         struct kvec *iov = buf->head;
         unsigned int len = iov->iov_len;
@@ -534,7 +534,7 @@ void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, uint32_t *p)
         xdr->buf = buf;
         xdr->iov = iov;
         xdr->p = p;
-        xdr->end = (uint32_t *)((char *)iov->iov_base + len);
+        xdr->end = (__be32 *)((char *)iov->iov_base + len);
 }
 EXPORT_SYMBOL(xdr_init_decode);
 
@@ -548,10 +548,10 @@ EXPORT_SYMBOL(xdr_init_decode);
  * If so return the current pointer, then update the current
  * pointer position.
  */
-uint32_t * xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)
+__be32 * xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)
 {
-        uint32_t *p = xdr->p;
-        uint32_t *q = p + XDR_QUADLEN(nbytes);
+        __be32 *p = xdr->p;
+        __be32 *q = p + XDR_QUADLEN(nbytes);
 
         if (unlikely(q > xdr->end || q < p))
                 return NULL;
@@ -599,8 +599,8 @@ void xdr_read_pages(struct xdr_stream *xdr, unsigned int len)
          * Position current pointer at beginning of tail, and
          * set remaining message length.
          */
-        xdr->p = (uint32_t *)((char *)iov->iov_base + padding);
-        xdr->end = (uint32_t *)((char *)iov->iov_base + end);
+        xdr->p = (__be32 *)((char *)iov->iov_base + padding);
+        xdr->end = (__be32 *)((char *)iov->iov_base + end);
 }
 EXPORT_SYMBOL(xdr_read_pages);
 
@@ -624,8 +624,8 @@ void xdr_enter_page(struct xdr_stream *xdr, unsigned int len)
          */
         if (len > PAGE_CACHE_SIZE - xdr->buf->page_base)
                 len = PAGE_CACHE_SIZE - xdr->buf->page_base;
-        xdr->p = (uint32_t *)(kaddr + xdr->buf->page_base);
-        xdr->end = (uint32_t *)((char *)xdr->p + len);
+        xdr->p = (__be32 *)(kaddr + xdr->buf->page_base);
+        xdr->end = (__be32 *)((char *)xdr->p + len);
 }
 EXPORT_SYMBOL(xdr_enter_page);
 
@@ -743,7 +743,7 @@ out:
 int
 xdr_decode_word(struct xdr_buf *buf, int base, u32 *obj)
 {
-        u32     raw;
+        __be32  raw;
         int     status;
 
         status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj));
@@ -756,7 +756,7 @@ xdr_decode_word(struct xdr_buf *buf, int base, u32 *obj)
 int
 xdr_encode_word(struct xdr_buf *buf, int base, u32 obj)
 {
-        u32     raw = htonl(obj);
+        __be32  raw = htonl(obj);
 
         return write_bytes_to_xdr_buf(buf, base, &raw, sizeof(obj));
 }
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index 1f786f68729d..80857470dc11 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -594,7 +594,7 @@ static void xprt_connect_status(struct rpc_task *task)
  * @xid: RPC XID of incoming reply
  *
  */
-struct rpc_rqst *xprt_lookup_rqst(struct rpc_xprt *xprt, u32 xid)
+struct rpc_rqst *xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid)
 {
         struct list_head *pos;
 
@@ -801,7 +801,7 @@ void xprt_reserve(struct rpc_task *task)
         spin_unlock(&xprt->reserve_lock);
 }
 
-static inline u32 xprt_alloc_xid(struct rpc_xprt *xprt)
+static inline __be32 xprt_alloc_xid(struct rpc_xprt *xprt)
 {
         return xprt->xid++;
 }
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 9b62923a9c06..28100e019225 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -548,7 +548,8 @@ static void xs_udp_data_ready(struct sock *sk, int len)
         struct rpc_rqst *rovr;
         struct sk_buff *skb;
         int err, repsize, copied;
-        u32 _xid, *xp;
+        u32 _xid;
+        __be32 *xp;
 
         read_lock(&sk->sk_callback_lock);
         dprintk("RPC:      xs_udp_data_ready...\n");
diff --git a/net/xfrm/xfrm_hash.h b/net/xfrm/xfrm_hash.h
index d3abb0b7dc62..6ac4e4f033ac 100644
--- a/net/xfrm/xfrm_hash.h
+++ b/net/xfrm/xfrm_hash.h
@@ -58,10 +58,10 @@ static inline unsigned __xfrm_src_hash(xfrm_address_t *saddr,
 }
 
 static inline unsigned int
-__xfrm_spi_hash(xfrm_address_t *daddr, u32 spi, u8 proto, unsigned short family,
+__xfrm_spi_hash(xfrm_address_t *daddr, __be32 spi, u8 proto, unsigned short family,
                 unsigned int hmask)
 {
-        unsigned int h = spi ^ proto;
+        unsigned int h = (__force u32)spi ^ proto;
         switch (family) {
         case AF_INET:
                 h ^= __xfrm4_addr_hash(daddr);
diff --git a/net/xfrm/xfrm_input.c b/net/xfrm/xfrm_input.c
index dfc90bb1cf1f..e8198a2c785d 100644
--- a/net/xfrm/xfrm_input.c
+++ b/net/xfrm/xfrm_input.c
@@ -46,7 +46,7 @@ EXPORT_SYMBOL(secpath_dup);
 
 /* Fetch spi and seq from ipsec header */
 
-int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, u32 *spi, u32 *seq)
+int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq)
 {
         int offset, offset_seq;
 
@@ -62,7 +62,7 @@ int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, u32 *spi, u32 *seq)
         case IPPROTO_COMP:
                 if (!pskb_may_pull(skb, sizeof(struct ip_comp_hdr)))
                         return -EINVAL;
-                *spi = htonl(ntohs(*(u16*)(skb->h.raw + 2)));
+                *spi = htonl(ntohs(*(__be16*)(skb->h.raw + 2)));
                 *seq = 0;
                 return 0;
         default:
@@ -72,8 +72,8 @@ int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, u32 *spi, u32 *seq)
         if (!pskb_may_pull(skb, 16))
                 return -EINVAL;
 
-        *spi = *(u32*)(skb->h.raw + offset);
-        *seq = *(u32*)(skb->h.raw + offset_seq);
+        *spi = *(__be32*)(skb->h.raw + offset);
+        *seq = *(__be32*)(skb->h.raw + offset_seq);
         return 0;
 }
 EXPORT_SYMBOL(xfrm_parse_spi);
diff --git a/net/xfrm/xfrm_state.c b/net/xfrm/xfrm_state.c
index 9f63edd39346..f927b7330f02 100644
--- a/net/xfrm/xfrm_state.c
+++ b/net/xfrm/xfrm_state.c
@@ -70,7 +70,7 @@ static inline unsigned int xfrm_src_hash(xfrm_address_t *addr,
 }
 
 static inline unsigned int
-xfrm_spi_hash(xfrm_address_t *daddr, u32 spi, u8 proto, unsigned short family)
+xfrm_spi_hash(xfrm_address_t *daddr, __be32 spi, u8 proto, unsigned short family)
 {
         return __xfrm_spi_hash(daddr, spi, proto, family, xfrm_state_hmask);
 }
@@ -96,9 +96,12 @@ static void xfrm_hash_transfer(struct hlist_head *list,
                                     nhashmask);
                 hlist_add_head(&x->bysrc, nsrctable+h);
 
-                h = __xfrm_spi_hash(&x->id.daddr, x->id.spi, x->id.proto,
-                                    x->props.family, nhashmask);
-                hlist_add_head(&x->byspi, nspitable+h);
+                if (x->id.spi) {
+                        h = __xfrm_spi_hash(&x->id.daddr, x->id.spi,
+                                            x->id.proto, x->props.family,
+                                            nhashmask);
+                        hlist_add_head(&x->byspi, nspitable+h);
+                }
         }
 }
 
@@ -421,7 +424,7 @@ xfrm_init_tempsel(struct xfrm_state *x, struct flowi *fl,
         return 0;
 }
 
-static struct xfrm_state *__xfrm_state_lookup(xfrm_address_t *daddr, u32 spi, u8 proto, unsigned short family)
+static struct xfrm_state *__xfrm_state_lookup(xfrm_address_t *daddr, __be32 spi, u8 proto, unsigned short family)
 {
         unsigned int h = xfrm_spi_hash(daddr, spi, proto, family);
         struct xfrm_state *x;
@@ -622,7 +625,7 @@ static void __xfrm_state_insert(struct xfrm_state *x)
         h = xfrm_src_hash(&x->props.saddr, x->props.family);
         hlist_add_head(&x->bysrc, xfrm_state_bysrc+h);
 
-        if (xfrm_id_proto_match(x->id.proto, IPSEC_PROTO_ANY)) {
+        if (x->id.spi) {
                 h = xfrm_spi_hash(&x->id.daddr, x->id.spi, x->id.proto,
                                   x->props.family);
 
@@ -916,7 +919,7 @@ err:
 EXPORT_SYMBOL(xfrm_state_check);
 
 struct xfrm_state *
-xfrm_state_lookup(xfrm_address_t *daddr, u32 spi, u8 proto,
+xfrm_state_lookup(xfrm_address_t *daddr, __be32 spi, u8 proto,
                   unsigned short family)
 {
         struct xfrm_state *x;
@@ -1040,7 +1043,7 @@ u32 xfrm_get_acqseq(void)
 EXPORT_SYMBOL(xfrm_get_acqseq);
 
 void
-xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi)
+xfrm_alloc_spi(struct xfrm_state *x, __be32 minspi, __be32 maxspi)
 {
         unsigned int h;
         struct xfrm_state *x0;
@@ -1057,10 +1060,10 @@ xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi)
                 x->id.spi = minspi;
         } else {
                 u32 spi = 0;
-                minspi = ntohl(minspi);
-                maxspi = ntohl(maxspi);
-                for (h=0; h<maxspi-minspi+1; h++) {
-                        spi = minspi + net_random()%(maxspi-minspi+1);
+                u32 low = ntohl(minspi);
+                u32 high = ntohl(maxspi);
+                for (h=0; h<high-low+1; h++) {
+                        spi = low + net_random()%(high-low+1);
                         x0 = xfrm_state_lookup(&x->id.daddr, htonl(spi), x->id.proto, x->props.family);
                         if (x0 == NULL) {
                                 x->id.spi = htonl(spi);
@@ -1180,11 +1183,10 @@ static void xfrm_replay_timer_handler(unsigned long data)
         spin_unlock(&x->lock);
 }
 
-int xfrm_replay_check(struct xfrm_state *x, u32 seq)
+int xfrm_replay_check(struct xfrm_state *x, __be32 net_seq)
 {
         u32 diff;
-
-        seq = ntohl(seq);
+        u32 seq = ntohl(net_seq);
 
         if (unlikely(seq == 0))
                 return -EINVAL;
@@ -1206,11 +1208,10 @@ int xfrm_replay_check(struct xfrm_state *x, u32 seq)
 }
 EXPORT_SYMBOL(xfrm_replay_check);
 
-void xfrm_replay_advance(struct xfrm_state *x, u32 seq)
+void xfrm_replay_advance(struct xfrm_state *x, __be32 net_seq)
 {
         u32 diff;
-
-        seq = ntohl(seq);
+        u32 seq = ntohl(net_seq);
 
         if (seq > x->replay.seq) {
                 diff = seq - x->replay.seq;