Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

187 files changed, 5585 insertions, 1158 deletions

diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index e2ea0b2159cd..2fc8e14cc24a 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -94,6 +94,7 @@ header-y += if_ppp.h
 header-y += if_slip.h
 header-y += if_strip.h
 header-y += if_tun.h
+header-y += if_x25.h
 header-y += in_route.h
 header-y += ioctl.h
 header-y += ip6_tunnel.h
diff --git a/include/linux/ahci_platform.h b/include/linux/ahci_platform.h
new file mode 100644
index 000000000000..f7dd576dd5a4
--- /dev/null
+++ b/include/linux/ahci_platform.h
@@ -0,0 +1,29 @@
+/*
+ * AHCI SATA platform driver
+ *
+ * Copyright 2004-2005  Red Hat, Inc.
+ *   Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2010  MontaVista Software, LLC.
+ *   Anton Vorontsov <avorontsov@ru.mvista.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ */
+
+#ifndef _AHCI_PLATFORM_H
+#define _AHCI_PLATFORM_H
+
+struct device;
+struct ata_port_info;
+
+struct ahci_platform_data {
+        int (*init)(struct device *dev);
+        void (*exit)(struct device *dev);
+        const struct ata_port_info *ata_port_info;
+        unsigned int force_port_map;
+        unsigned int mask_port_map;
+};
+
+#endif /* _AHCI_PLATFORM_H */
diff --git a/include/linux/altera_jtaguart.h b/include/linux/altera_jtaguart.h
new file mode 100644
index 000000000000..953b178a1650
--- /dev/null
+++ b/include/linux/altera_jtaguart.h
@@ -0,0 +1,16 @@
+/*
+ * altera_jtaguart.h -- Altera JTAG UART driver defines.
+ */
+
+#ifndef __ALTJUART_H
+#define __ALTJUART_H
+
+#define ALTERA_JTAGUART_MAJOR   204
+#define ALTERA_JTAGUART_MINOR   186
+
+struct altera_jtaguart_platform_uart {
+        unsigned long mapbase;  /* Physical address base */
+        unsigned int irq;       /* Interrupt vector */
+};
+
+#endif /* __ALTJUART_H */
diff --git a/include/linux/altera_uart.h b/include/linux/altera_uart.h
new file mode 100644
index 000000000000..8d441064a30d
--- /dev/null
+++ b/include/linux/altera_uart.h
@@ -0,0 +1,14 @@
+/*
+ * altera_uart.h -- Altera UART driver defines.
+ */
+
+#ifndef __ALTUART_H
+#define __ALTUART_H
+
+struct altera_uart_platform_uart {
+        unsigned long mapbase;  /* Physical address base */
+        unsigned int irq;       /* Interrupt vector */
+        unsigned int uartclk;   /* UART clock rate */
+};
+
+#endif /* __ALTUART_H */
diff --git a/include/linux/ata.h b/include/linux/ata.h
index 700c5b9b3583..fe6e681a9d74 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -467,7 +467,7 @@ enum ata_ioctls {
 
 /* core structures */
 
-struct ata_prd {
+struct ata_bmdma_prd {
         __le32                  addr;
         __le32                  flags_len;
 };
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index bd0e3c6f323f..e6e0cb5437e6 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -14,6 +14,7 @@
 #include <linux/kernel.h>
 #include <linux/fs.h>
 #include <linux/sched.h>
+#include <linux/timer.h>
 #include <linux/writeback.h>
 #include <asm/atomic.h>
 
@@ -88,6 +89,8 @@ struct backing_dev_info {
 
         struct device *dev;
 
+        struct timer_list laptop_mode_wb_timer;
+
 #ifdef CONFIG_DEBUG_FS
         struct dentry *debug_dir;
         struct dentry *debug_stats;
@@ -103,9 +106,10 @@ int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
 void bdi_unregister(struct backing_dev_info *bdi);
 int bdi_setup_and_register(struct backing_dev_info *, char *, unsigned int);
 void bdi_start_writeback(struct backing_dev_info *bdi, struct super_block *sb,
-                                long nr_pages);
+                                long nr_pages, int sb_locked);
 int bdi_writeback_task(struct bdi_writeback *wb);
 int bdi_has_dirty_io(struct backing_dev_info *bdi);
+void bdi_arm_supers_timer(void);
 
 extern spinlock_t bdi_lock;
 extern struct list_head bdi_list;
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 6690e8bae7bb..8b7f5e0914ad 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -186,15 +186,19 @@ struct request {
         };
 
         /*
-         * two pointers are available for the IO schedulers, if they need
+         * Three pointers are available for the IO schedulers, if they need
          * more they have to dynamically allocate it.
          */
         void *elevator_private;
         void *elevator_private2;
+        void *elevator_private3;
 
         struct gendisk *rq_disk;
         unsigned long start_time;
-
+#ifdef CONFIG_BLK_CGROUP
+        unsigned long long start_time_ns;
+        unsigned long long io_start_time_ns;    /* when passed to hardware */
+#endif
         /* Number of scatter-gather DMA addr+len pairs after
          * physical address coalescing is performed.
          */
@@ -917,7 +921,12 @@ extern void blk_abort_queue(struct request_queue *);
  */
 extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
                                         spinlock_t *lock, int node_id);
+extern struct request_queue *blk_init_allocated_queue_node(struct request_queue *,
+                                                           request_fn_proc *,
+                                                           spinlock_t *, int node_id);
 extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
+extern struct request_queue *blk_init_allocated_queue(struct request_queue *,
+                                                      request_fn_proc *, spinlock_t *);
 extern void blk_cleanup_queue(struct request_queue *);
 extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
 extern void blk_queue_bounce_limit(struct request_queue *, u64);
@@ -994,20 +1003,25 @@ static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
                 return NULL;
         return bqt->tag_index[tag];
 }
-
-extern int blkdev_issue_flush(struct block_device *, sector_t *);
-#define DISCARD_FL_WAIT         0x01    /* wait for completion */
-#define DISCARD_FL_BARRIER      0x02    /* issue DISCARD_BARRIER request */
-extern int blkdev_issue_discard(struct block_device *, sector_t sector,
-                sector_t nr_sects, gfp_t, int flags);
-
+enum{
+        BLKDEV_WAIT,    /* wait for completion */
+        BLKDEV_BARRIER, /*issue request with barrier */
+};
+#define BLKDEV_IFL_WAIT         (1 << BLKDEV_WAIT)
+#define BLKDEV_IFL_BARRIER      (1 << BLKDEV_BARRIER)
+extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *,
+                        unsigned long);
+extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
+                sector_t nr_sects, gfp_t gfp_mask, unsigned long flags);
+extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
+                        sector_t nr_sects, gfp_t gfp_mask, unsigned long flags);
 static inline int sb_issue_discard(struct super_block *sb,
                                    sector_t block, sector_t nr_blocks)
 {
         block <<= (sb->s_blocksize_bits - 9);
         nr_blocks <<= (sb->s_blocksize_bits - 9);
         return blkdev_issue_discard(sb->s_bdev, block, nr_blocks, GFP_KERNEL,
-                                    DISCARD_FL_BARRIER);
+                                   BLKDEV_IFL_WAIT | BLKDEV_IFL_BARRIER);
 }
 
 extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
@@ -1196,6 +1210,39 @@ static inline void put_dev_sector(Sector p)
 struct work_struct;
 int kblockd_schedule_work(struct request_queue *q, struct work_struct *work);
 
+#ifdef CONFIG_BLK_CGROUP
+static inline void set_start_time_ns(struct request *req)
+{
+        req->start_time_ns = sched_clock();
+}
+
+static inline void set_io_start_time_ns(struct request *req)
+{
+        req->io_start_time_ns = sched_clock();
+}
+
+static inline uint64_t rq_start_time_ns(struct request *req)
+{
+        return req->start_time_ns;
+}
+
+static inline uint64_t rq_io_start_time_ns(struct request *req)
+{
+        return req->io_start_time_ns;
+}
+#else
+static inline void set_start_time_ns(struct request *req) {}
+static inline void set_io_start_time_ns(struct request *req) {}
+static inline uint64_t rq_start_time_ns(struct request *req)
+{
+        return 0;
+}
+static inline uint64_t rq_io_start_time_ns(struct request *req)
+{
+        return 0;
+}
+#endif
+
 #define MODULE_ALIAS_BLOCKDEV(major,minor) \
         MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
 #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
@@ -1283,10 +1330,11 @@ struct block_device_operations {
         int (*direct_access) (struct block_device *, sector_t,
                                                 void **, unsigned long *);
         int (*media_changed) (struct gendisk *);
-        unsigned long long (*set_capacity) (struct gendisk *,
-                                                unsigned long long);
+        void (*unlock_native_capacity) (struct gendisk *);
         int (*revalidate_disk) (struct gendisk *);
         int (*getgeo)(struct block_device *, struct hd_geometry *);
+        /* this callback is with swap_lock and sometimes page table lock held */
+        void (*swap_slot_free_notify) (struct block_device *, unsigned long);
         struct module *owner;
 };
 
diff --git a/include/linux/caif/caif_socket.h b/include/linux/caif/caif_socket.h
new file mode 100644
index 000000000000..2a61eb1beb85
--- /dev/null
+++ b/include/linux/caif/caif_socket.h
@@ -0,0 +1,165 @@
+/* linux/caif_socket.h
+ * CAIF Definitions for CAIF socket and network layer
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:       Sjur Brendeland/ sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#ifndef _LINUX_CAIF_SOCKET_H
+#define _LINUX_CAIF_SOCKET_H
+
+#include <linux/types.h>
+
+#ifdef __KERNEL__
+#include <linux/socket.h>
+#else
+#include <sys/socket.h>
+#endif
+
+/**
+ * enum caif_link_selector -    Physical Link Selection.
+ * @CAIF_LINK_HIGH_BANDW:       Physical interface for high-bandwidth
+ *                              traffic.
+ * @CAIF_LINK_LOW_LATENCY:      Physical interface for low-latency
+ *                              traffic.
+ *
+ * CAIF Link Layers can register their link properties.
+ * This enum is used for choosing between CAIF Link Layers when
+ * setting up CAIF Channels when multiple CAIF Link Layers exists.
+ */
+enum caif_link_selector {
+        CAIF_LINK_HIGH_BANDW,
+        CAIF_LINK_LOW_LATENCY
+};
+
+/**
+ * enum caif_channel_priority - CAIF channel priorities.
+ *
+ * @CAIF_PRIO_MIN:      Min priority for a channel.
+ * @CAIF_PRIO_LOW:      Low-priority channel.
+ * @CAIF_PRIO_NORMAL:   Normal/default priority level.
+ * @CAIF_PRIO_HIGH:     High priority level
+ * @CAIF_PRIO_MAX:      Max priority for channel
+ *
+ * Priority can be set on CAIF Channels in order to
+ * prioritize between traffic on different CAIF Channels.
+ * These priority levels are recommended, but the priority value
+ * is not restricted to the values defined in this enum, any value
+ * between CAIF_PRIO_MIN and CAIF_PRIO_MAX could be used.
+ */
+enum caif_channel_priority {
+        CAIF_PRIO_MIN    = 0x01,
+        CAIF_PRIO_LOW    = 0x04,
+        CAIF_PRIO_NORMAL = 0x0f,
+        CAIF_PRIO_HIGH   = 0x14,
+        CAIF_PRIO_MAX    = 0x1F
+};
+
+/**
+ * enum caif_protocol_type  -   CAIF Channel type.
+ * @CAIFPROTO_AT:               Classic AT channel.
+ * @CAIFPROTO_DATAGRAM: Datagram channel.
+ * @CAIFPROTO_DATAGRAM_LOOP:    Datagram loopback channel, used for testing.
+ * @CAIFPROTO_UTIL:             Utility (Psock) channel.
+ * @CAIFPROTO_RFM:              Remote File Manager
+ *
+ * This enum defines the CAIF Channel type to be used. This defines
+ * the service to connect to on the modem.
+ */
+enum caif_protocol_type {
+        CAIFPROTO_AT,
+        CAIFPROTO_DATAGRAM,
+        CAIFPROTO_DATAGRAM_LOOP,
+        CAIFPROTO_UTIL,
+        CAIFPROTO_RFM,
+        _CAIFPROTO_MAX
+};
+#define CAIFPROTO_MAX _CAIFPROTO_MAX
+
+/**
+ * enum caif_at_type - AT Service Endpoint
+ * @CAIF_ATTYPE_PLAIN:       Connects to a plain vanilla AT channel.
+ */
+enum caif_at_type {
+        CAIF_ATTYPE_PLAIN = 2
+};
+
+/**
+ * struct sockaddr_caif - the sockaddr structure for CAIF sockets.
+ * @family:                  Address family number, must be AF_CAIF.
+ * @u:                       Union of address data 'switched' by family.
+ * :
+ * @u.at:                    Applies when family = CAIFPROTO_AT.
+ *
+ * @u.at.type:               Type of AT link to set up (enum caif_at_type).
+ *
+ * @u.util:                  Applies when family = CAIFPROTO_UTIL
+ *
+ * @u.util.service:          Utility service name.
+ *
+ * @u.dgm:                   Applies when family = CAIFPROTO_DATAGRAM
+ *
+ * @u.dgm.connection_id:     Datagram connection id.
+ *
+ * @u.dgm.nsapi:             NSAPI of the PDP-Context.
+ *
+ * @u.rfm:                   Applies when family = CAIFPROTO_RFM
+ *
+ * @u.rfm.connection_id:     Connection ID for RFM.
+ *
+ * @u.rfm.volume:            Volume to mount.
+ *
+ * Description:
+ * This structure holds the connect parameters used for setting up a
+ * CAIF Channel. It defines the service to connect to on the modem.
+ */
+struct sockaddr_caif {
+        sa_family_t  family;
+        union {
+                struct {
+                        __u8  type;             /* type: enum caif_at_type */
+                } at;                           /* CAIFPROTO_AT */
+                struct {
+                        char      service[16];
+                } util;                         /* CAIFPROTO_UTIL */
+                union {
+                        __u32 connection_id;
+                        __u8  nsapi;
+                } dgm;                          /* CAIFPROTO_DATAGRAM(_LOOP)*/
+                struct {
+                        __u32 connection_id;
+                        char      volume[16];
+                } rfm;                          /* CAIFPROTO_RFM */
+        } u;
+};
+
+/**
+ * enum caif_socket_opts - CAIF option values for getsockopt and setsockopt.
+ *
+ * @CAIFSO_LINK_SELECT:         Selector used if multiple CAIF Link layers are
+ *                              available. Either a high bandwidth
+ *                              link can be selected (CAIF_LINK_HIGH_BANDW) or
+ *                              or a low latency link (CAIF_LINK_LOW_LATENCY).
+ *                              This option is of type __u32.
+ *                              Alternatively SO_BINDTODEVICE can be used.
+ *
+ * @CAIFSO_REQ_PARAM:           Used to set the request parameters for a
+ *                              utility channel. (maximum 256 bytes). This
+ *                              option must be set before connecting.
+ *
+ * @CAIFSO_RSP_PARAM:           Gets the response parameters for a utility
+ *                              channel. (maximum 256 bytes). This option
+ *                              is valid after a successful connect.
+ *
+ *
+ * This enum defines the CAIF Socket options to be used on a socket
+ * of type PF_CAIF.
+ *
+ */
+enum caif_socket_opts {
+        CAIFSO_LINK_SELECT      = 127,
+        CAIFSO_REQ_PARAM        = 128,
+        CAIFSO_RSP_PARAM        = 129,
+};
+
+#endif /* _LINUX_CAIF_SOCKET_H */
diff --git a/include/linux/caif/if_caif.h b/include/linux/caif/if_caif.h
new file mode 100644
index 000000000000..5e7eed4edf51
--- /dev/null
+++ b/include/linux/caif/if_caif.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2010
+ * Author:      Sjur Brendeland/ sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#ifndef IF_CAIF_H_
+#define IF_CAIF_H_
+#include <linux/sockios.h>
+#include <linux/types.h>
+#include <linux/socket.h>
+
+/**
+ * enum ifla_caif - CAIF NetlinkRT parameters.
+ * @IFLA_CAIF_IPV4_CONNID:  Connection ID for IPv4 PDP Context.
+ *                          The type of attribute is NLA_U32.
+ * @IFLA_CAIF_IPV6_CONNID:  Connection ID for IPv6 PDP Context.
+ *                          The type of attribute is NLA_U32.
+ * @IFLA_CAIF_LOOPBACK:     If different from zero, device is doing loopback
+ *                          The type of attribute is NLA_U8.
+ *
+ * When using RT Netlink to create, destroy or configure a CAIF IP interface,
+ * enum ifla_caif is used to specify the configuration attributes.
+ */
+enum ifla_caif {
+        __IFLA_CAIF_UNSPEC,
+        IFLA_CAIF_IPV4_CONNID,
+        IFLA_CAIF_IPV6_CONNID,
+        IFLA_CAIF_LOOPBACK,
+        __IFLA_CAIF_MAX
+};
+#define IFLA_CAIF_MAX (__IFLA_CAIF_MAX-1)
+
+#endif /*IF_CAIF_H_*/
diff --git a/include/linux/can/dev.h b/include/linux/can/dev.h
index 6e5a7f00223d..cc0bb4961669 100644
--- a/include/linux/can/dev.h
+++ b/include/linux/can/dev.h
@@ -14,6 +14,7 @@
 #ifndef CAN_DEV_H
 #define CAN_DEV_H
 
+#include <linux/can.h>
 #include <linux/can/netlink.h>
 #include <linux/can/error.h>
 
diff --git a/include/linux/can/platform/mcp251x.h b/include/linux/can/platform/mcp251x.h
index 1448177d86d5..dba28268e651 100644
--- a/include/linux/can/platform/mcp251x.h
+++ b/include/linux/can/platform/mcp251x.h
@@ -26,8 +26,8 @@
 struct mcp251x_platform_data {
         unsigned long oscillator_frequency;
         int model;
-#define CAN_MCP251X_MCP2510 0
-#define CAN_MCP251X_MCP2515 1
+#define CAN_MCP251X_MCP2510 0x2510
+#define CAN_MCP251X_MCP2515 0x2515
         int (*board_specific_setup)(struct spi_device *spi);
         int (*transceiver_enable)(int enable);
         int (*power_enable) (int enable);
diff --git a/include/linux/can/platform/sja1000.h b/include/linux/can/platform/sja1000.h
index 01ee2aeb048d..96f8fcc78d78 100644
--- a/include/linux/can/platform/sja1000.h
+++ b/include/linux/can/platform/sja1000.h
@@ -26,7 +26,7 @@
 #define OCR_TX_SHIFT      2
 
 struct sja1000_platform_data {
-        u32 clock;      /* CAN bus oscillator frequency in Hz */
+        u32 osc_freq;   /* CAN bus oscillator frequency in Hz */
 
         u8 ocr;         /* output control register */
         u8 cdr;         /* clock divider register */
diff --git a/include/linux/dcbnl.h b/include/linux/dcbnl.h
index b7cdbb4373df..8723491f7dfd 100644
--- a/include/linux/dcbnl.h
+++ b/include/linux/dcbnl.h
@@ -22,8 +22,6 @@
 
 #include <linux/types.h>
 
-#define DCB_PROTO_VERSION 1
-
 struct dcbmsg {
         __u8               dcb_family;
         __u8               cmd;
diff --git a/include/linux/device.h b/include/linux/device.h
index 241b96bcd7ad..7bb9f426f3e6 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -22,7 +22,6 @@
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/pm.h>
-#include <linux/semaphore.h>
 #include <asm/atomic.h>
 #include <asm/device.h>
 
@@ -203,6 +202,9 @@ struct class {
         int (*suspend)(struct device *dev, pm_message_t state);
         int (*resume)(struct device *dev);
 
+        const struct kobj_ns_type_operations *ns_type;
+        const void *(*namespace)(struct device *dev);
+
         const struct dev_pm_ops *pm;
 
         struct class_private *p;
@@ -404,7 +406,7 @@ struct device {
         const char              *init_name; /* initial name of the device */
         struct device_type      *type;
 
-        struct semaphore        sem;    /* semaphore to synchronize calls to
+        struct mutex            mutex;  /* mutex to synchronize calls to
                                          * its driver.
                                          */
 
@@ -514,17 +516,17 @@ static inline bool device_async_suspend_enabled(struct device *dev)
 
 static inline void device_lock(struct device *dev)
 {
-        down(&dev->sem);
+        mutex_lock(&dev->mutex);
 }
 
 static inline int device_trylock(struct device *dev)
 {
-        return down_trylock(&dev->sem);
+        return mutex_trylock(&dev->mutex);
 }
 
 static inline void device_unlock(struct device *dev)
 {
-        up(&dev->sem);
+        mutex_unlock(&dev->mutex);
 }
 
 void driver_init(void);
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 20ea12c86fd0..5204f018931b 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -40,11 +40,13 @@ typedef s32 dma_cookie_t;
  * enum dma_status - DMA transaction status
  * @DMA_SUCCESS: transaction completed successfully
  * @DMA_IN_PROGRESS: transaction not yet processed
+ * @DMA_PAUSED: transaction is paused
  * @DMA_ERROR: transaction failed
  */
 enum dma_status {
         DMA_SUCCESS,
         DMA_IN_PROGRESS,
+        DMA_PAUSED,
         DMA_ERROR,
 };
 
@@ -107,6 +109,19 @@ enum dma_ctrl_flags {
 };
 
 /**
+ * enum dma_ctrl_cmd - DMA operations that can optionally be exercised
+ * on a running channel.
+ * @DMA_TERMINATE_ALL: terminate all ongoing transfers
+ * @DMA_PAUSE: pause ongoing transfers
+ * @DMA_RESUME: resume paused transfer
+ */
+enum dma_ctrl_cmd {
+        DMA_TERMINATE_ALL,
+        DMA_PAUSE,
+        DMA_RESUME,
+};
+
+/**
  * enum sum_check_bits - bit position of pq_check_flags
  */
 enum sum_check_bits {
@@ -230,9 +245,84 @@ struct dma_async_tx_descriptor {
         dma_cookie_t (*tx_submit)(struct dma_async_tx_descriptor *tx);
         dma_async_tx_callback callback;
         void *callback_param;
+#ifndef CONFIG_ASYNC_TX_DISABLE_CHANNEL_SWITCH
         struct dma_async_tx_descriptor *next;
         struct dma_async_tx_descriptor *parent;
         spinlock_t lock;
+#endif
+};
+
+#ifdef CONFIG_ASYNC_TX_DISABLE_CHANNEL_SWITCH
+static inline void txd_lock(struct dma_async_tx_descriptor *txd)
+{
+}
+static inline void txd_unlock(struct dma_async_tx_descriptor *txd)
+{
+}
+static inline void txd_chain(struct dma_async_tx_descriptor *txd, struct dma_async_tx_descriptor *next)
+{
+        BUG();
+}
+static inline void txd_clear_parent(struct dma_async_tx_descriptor *txd)
+{
+}
+static inline void txd_clear_next(struct dma_async_tx_descriptor *txd)
+{
+}
+static inline struct dma_async_tx_descriptor *txd_next(struct dma_async_tx_descriptor *txd)
+{
+        return NULL;
+}
+static inline struct dma_async_tx_descriptor *txd_parent(struct dma_async_tx_descriptor *txd)
+{
+        return NULL;
+}
+
+#else
+static inline void txd_lock(struct dma_async_tx_descriptor *txd)
+{
+        spin_lock_bh(&txd->lock);
+}
+static inline void txd_unlock(struct dma_async_tx_descriptor *txd)
+{
+        spin_unlock_bh(&txd->lock);
+}
+static inline void txd_chain(struct dma_async_tx_descriptor *txd, struct dma_async_tx_descriptor *next)
+{
+        txd->next = next;
+        next->parent = txd;
+}
+static inline void txd_clear_parent(struct dma_async_tx_descriptor *txd)
+{
+        txd->parent = NULL;
+}
+static inline void txd_clear_next(struct dma_async_tx_descriptor *txd)
+{
+        txd->next = NULL;
+}
+static inline struct dma_async_tx_descriptor *txd_parent(struct dma_async_tx_descriptor *txd)
+{
+        return txd->parent;
+}
+static inline struct dma_async_tx_descriptor *txd_next(struct dma_async_tx_descriptor *txd)
+{
+        return txd->next;
+}
+#endif
+
+/**
+ * struct dma_tx_state - filled in to report the status of
+ * a transfer.
+ * @last: last completed DMA cookie
+ * @used: last issued DMA cookie (i.e. the one in progress)
+ * @residue: the remaining number of bytes left to transmit
+ *      on the selected transfer for states DMA_IN_PROGRESS and
+ *      DMA_PAUSED if this is implemented in the driver, else 0
+ */
+struct dma_tx_state {
+        dma_cookie_t last;
+        dma_cookie_t used;
+        u32 residue;
 };
 
 /**
@@ -261,8 +351,12 @@ struct dma_async_tx_descriptor {
  * @device_prep_dma_memset: prepares a memset operation
  * @device_prep_dma_interrupt: prepares an end of chain interrupt operation
  * @device_prep_slave_sg: prepares a slave dma operation
- * @device_terminate_all: terminate all pending operations
- * @device_is_tx_complete: poll for transaction completion
+ * @device_control: manipulate all pending operations on a channel, returns
+ *      zero or error code
+ * @device_tx_status: poll for transaction completion, the optional
+ *      txstate parameter can be supplied with a pointer to get a
+ *      struct with auxilary transfer status information, otherwise the call
+ *      will just return a simple status code
  * @device_issue_pending: push pending transactions to hardware
  */
 struct dma_device {
@@ -313,11 +407,12 @@ struct dma_device {
                 struct dma_chan *chan, struct scatterlist *sgl,
                 unsigned int sg_len, enum dma_data_direction direction,
                 unsigned long flags);
-        void (*device_terminate_all)(struct dma_chan *chan);
+        int (*device_control)(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
+                unsigned long arg);
 
-        enum dma_status (*device_is_tx_complete)(struct dma_chan *chan,
-                        dma_cookie_t cookie, dma_cookie_t *last,
-                        dma_cookie_t *used);
+        enum dma_status (*device_tx_status)(struct dma_chan *chan,
+                                            dma_cookie_t cookie,
+                                            struct dma_tx_state *txstate);
         void (*device_issue_pending)(struct dma_chan *chan);
 };
 
@@ -558,7 +653,15 @@ static inline void dma_async_issue_pending(struct dma_chan *chan)
 static inline enum dma_status dma_async_is_tx_complete(struct dma_chan *chan,
         dma_cookie_t cookie, dma_cookie_t *last, dma_cookie_t *used)
 {
-        return chan->device->device_is_tx_complete(chan, cookie, last, used);
+        struct dma_tx_state state;
+        enum dma_status status;
+
+        status = chan->device->device_tx_status(chan, cookie, &state);
+        if (last)
+                *last = state.last;
+        if (used)
+                *used = state.used;
+        return status;
 }
 
 #define dma_async_memcpy_complete(chan, cookie, last, used)\
@@ -586,6 +689,16 @@ static inline enum dma_status dma_async_is_complete(dma_cookie_t cookie,
         return DMA_IN_PROGRESS;
 }
 
+static inline void
+dma_set_tx_state(struct dma_tx_state *st, dma_cookie_t last, dma_cookie_t used, u32 residue)
+{
+        if (st) {
+                st->last = last;
+                st->used = used;
+                st->residue = residue;
+        }
+}
+
 enum dma_status dma_sync_wait(struct dma_chan *chan, dma_cookie_t cookie);
 #ifdef CONFIG_DMA_ENGINE
 enum dma_status dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx);
diff --git a/include/linux/dqblk_xfs.h b/include/linux/dqblk_xfs.h
index 527504c11c5e..4389ae72024e 100644
--- a/include/linux/dqblk_xfs.h
+++ b/include/linux/dqblk_xfs.h
@@ -110,6 +110,15 @@ typedef struct fs_disk_quota {
 #define FS_DQ_WARNS_MASK        (FS_DQ_BWARNS | FS_DQ_IWARNS | FS_DQ_RTBWARNS)
 
 /*
+ * Accounting values.  These can only be set for filesystem with
+ * non-transactional quotas that require quotacheck(8) in userspace.
+ */
+#define FS_DQ_BCOUNT            (1<<12)
+#define FS_DQ_ICOUNT            (1<<13)
+#define FS_DQ_RTBCOUNT          (1<<14)
+#define FS_DQ_ACCT_MASK         (FS_DQ_BCOUNT | FS_DQ_ICOUNT | FS_DQ_RTBCOUNT)
+
+/*
  * Various flags related to quotactl(2).  Only relevant to XFS filesystems.
  */
 #define XFS_QUOTA_UDQ_ACCT      (1<<0)  /* user quota accounting */
diff --git a/include/linux/drbd.h b/include/linux/drbd.h
index 4341b1a97a34..68530521ad00 100644
--- a/include/linux/drbd.h
+++ b/include/linux/drbd.h
@@ -53,10 +53,10 @@
 
 
 extern const char *drbd_buildtag(void);
-#define REL_VERSION "8.3.7"
+#define REL_VERSION "8.3.8rc1"
 #define API_VERSION 88
 #define PRO_VERSION_MIN 86
-#define PRO_VERSION_MAX 92
+#define PRO_VERSION_MAX 94
 
 
 enum drbd_io_error_p {
@@ -139,6 +139,7 @@ enum drbd_ret_codes {
         ERR_DATA_NOT_CURRENT    = 150,
         ERR_CONNECTED           = 151, /* DRBD 8.3 only */
         ERR_PERM                = 152,
+        ERR_NEED_APV_93         = 153,
 
         /* insert new ones above this line */
         AFTER_LAST_ERR_CODE
diff --git a/include/linux/drbd_limits.h b/include/linux/drbd_limits.h
index 51f47a586ad8..440b42e38e89 100644
--- a/include/linux/drbd_limits.h
+++ b/include/linux/drbd_limits.h
@@ -133,5 +133,21 @@
 #define DRBD_MAX_BIO_BVECS_MAX 128
 #define DRBD_MAX_BIO_BVECS_DEF 0
 
+#define DRBD_DP_VOLUME_MIN 4
+#define DRBD_DP_VOLUME_MAX 1048576
+#define DRBD_DP_VOLUME_DEF 16384
+
+#define DRBD_DP_INTERVAL_MIN 1
+#define DRBD_DP_INTERVAL_MAX 600
+#define DRBD_DP_INTERVAL_DEF 5
+
+#define DRBD_RS_THROTTLE_TH_MIN 1
+#define DRBD_RS_THROTTLE_TH_MAX 600
+#define DRBD_RS_THROTTLE_TH_DEF 20
+
+#define DRBD_RS_HOLD_OFF_TH_MIN 1
+#define DRBD_RS_HOLD_OFF_TH_MAX 6000
+#define DRBD_RS_HOLD_OFF_TH_DEF 100
+
 #undef RANGE
 #endif
diff --git a/include/linux/drbd_nl.h b/include/linux/drbd_nl.h
index f7431a4ca608..ce77a746fc9d 100644
--- a/include/linux/drbd_nl.h
+++ b/include/linux/drbd_nl.h
@@ -71,12 +71,17 @@ NL_PACKET(disconnect, 6, )
 NL_PACKET(resize, 7,
         NL_INT64(               29,     T_MAY_IGNORE,   resize_size)
         NL_BIT(                 68,     T_MAY_IGNORE,   resize_force)
+        NL_BIT(                 69,     T_MANDATORY,    no_resync)
 )
 
 NL_PACKET(syncer_conf, 8,
         NL_INTEGER(     30,     T_MAY_IGNORE,   rate)
         NL_INTEGER(     31,     T_MAY_IGNORE,   after)
         NL_INTEGER(     32,     T_MAY_IGNORE,   al_extents)
+        NL_INTEGER(     71,     T_MAY_IGNORE,   dp_volume)
+        NL_INTEGER(     72,     T_MAY_IGNORE,   dp_interval)
+        NL_INTEGER(     73,     T_MAY_IGNORE,   throttle_th)
+        NL_INTEGER(     74,     T_MAY_IGNORE,   hold_off_th)
         NL_STRING(      52,     T_MAY_IGNORE,   verify_alg,     SHARED_SECRET_MAX)
         NL_STRING(      51,     T_MAY_IGNORE,   cpu_mask,       32)
         NL_STRING(      64,     T_MAY_IGNORE,   csums_alg,      SHARED_SECRET_MAX)
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index 1cb3372e65d8..2c958f4fce1e 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -14,6 +14,9 @@ typedef void (elevator_merged_fn) (struct request_queue *, struct request *, int
 
 typedef int (elevator_allow_merge_fn) (struct request_queue *, struct request *, struct bio *);
 
+typedef void (elevator_bio_merged_fn) (struct request_queue *,
+                                                struct request *, struct bio *);
+
 typedef int (elevator_dispatch_fn) (struct request_queue *, int);
 
 typedef void (elevator_add_req_fn) (struct request_queue *, struct request *);
@@ -36,6 +39,7 @@ struct elevator_ops
         elevator_merged_fn *elevator_merged_fn;
         elevator_merge_req_fn *elevator_merge_req_fn;
         elevator_allow_merge_fn *elevator_allow_merge_fn;
+        elevator_bio_merged_fn *elevator_bio_merged_fn;
 
         elevator_dispatch_fn *elevator_dispatch_fn;
         elevator_add_req_fn *elevator_add_req_fn;
@@ -103,6 +107,8 @@ extern int elv_merge(struct request_queue *, struct request **, struct bio *);
 extern void elv_merge_requests(struct request_queue *, struct request *,
                                struct request *);
 extern void elv_merged_request(struct request_queue *, struct request *, int);
+extern void elv_bio_merged(struct request_queue *q, struct request *,
+                                struct bio *);
 extern void elv_requeue_request(struct request_queue *, struct request *);
 extern int elv_queue_empty(struct request_queue *);
 extern struct request *elv_former_request(struct request_queue *, struct request *);
diff --git a/include/linux/elfcore.h b/include/linux/elfcore.h
index e687bc3ba4da..394a3e0e4a6b 100644
--- a/include/linux/elfcore.h
+++ b/include/linux/elfcore.h
@@ -150,8 +150,6 @@ static inline int elf_core_copy_task_xfpregs(struct task_struct *t, elf_fpxregse
 }
 #endif
 
-#endif /* __KERNEL__ */
-
 /*
  * These functions parameterize elf_core_dump in fs/binfmt_elf.c to write out
  * extra segments containing the gate DSO contents.  Dumping its
@@ -168,4 +166,6 @@ extern int
 elf_core_write_extra_data(struct file *file, size_t *size, unsigned long limit);
 extern size_t elf_core_extra_data_size(void);
 
+#endif /* __KERNEL__ */
+
 #endif /* _LINUX_ELFCORE_H */
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index b33f316bb92e..276b40a16835 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -310,6 +310,7 @@ struct ethtool_perm_addr {
 enum ethtool_flags {
         ETH_FLAG_LRO            = (1 << 15),    /* LRO is enabled */
         ETH_FLAG_NTUPLE         = (1 << 27),    /* N-tuple filters enabled */
+        ETH_FLAG_RXHASH         = (1 << 28),
 };
 
 /* The following structures are for supporting RX network flow
@@ -490,12 +491,12 @@ void ethtool_ntuple_flush(struct net_device *dev);
  * get_ufo: Report whether UDP fragmentation offload is enabled
  * set_ufo: Turn UDP fragmentation offload on or off
  * self_test: Run specified self-tests
- * get_strings: Return a set of strings that describe the requested objects 
+ * get_strings: Return a set of strings that describe the requested objects
  * phys_id: Identify the device
  * get_stats: Return statistics about the device
  * get_flags: get 32-bit flags bitmap
  * set_flags: set 32-bit flags bitmap
- * 
+ *
  * Description:
  *
  * get_settings:
@@ -531,14 +532,20 @@ struct ethtool_ops {
         int     (*nway_reset)(struct net_device *);
         u32     (*get_link)(struct net_device *);
         int     (*get_eeprom_len)(struct net_device *);
-        int     (*get_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *);
-        int     (*set_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *);
+        int     (*get_eeprom)(struct net_device *,
+                              struct ethtool_eeprom *, u8 *);
+        int     (*set_eeprom)(struct net_device *,
+                              struct ethtool_eeprom *, u8 *);
         int     (*get_coalesce)(struct net_device *, struct ethtool_coalesce *);
         int     (*set_coalesce)(struct net_device *, struct ethtool_coalesce *);
-        void    (*get_ringparam)(struct net_device *, struct ethtool_ringparam *);
-        int     (*set_ringparam)(struct net_device *, struct ethtool_ringparam *);
-        void    (*get_pauseparam)(struct net_device *, struct ethtool_pauseparam*);
-        int     (*set_pauseparam)(struct net_device *, struct ethtool_pauseparam*);
+        void    (*get_ringparam)(struct net_device *,
+                                 struct ethtool_ringparam *);
+        int     (*set_ringparam)(struct net_device *,
+                                 struct ethtool_ringparam *);
+        void    (*get_pauseparam)(struct net_device *,
+                                  struct ethtool_pauseparam*);
+        int     (*set_pauseparam)(struct net_device *,
+                                  struct ethtool_pauseparam*);
         u32     (*get_rx_csum)(struct net_device *);
         int     (*set_rx_csum)(struct net_device *, u32);
         u32     (*get_tx_csum)(struct net_device *);
@@ -550,21 +557,24 @@ struct ethtool_ops {
         void    (*self_test)(struct net_device *, struct ethtool_test *, u64 *);
         void    (*get_strings)(struct net_device *, u32 stringset, u8 *);
         int     (*phys_id)(struct net_device *, u32);
-        void    (*get_ethtool_stats)(struct net_device *, struct ethtool_stats *, u64 *);
+        void    (*get_ethtool_stats)(struct net_device *,
+                                     struct ethtool_stats *, u64 *);
         int     (*begin)(struct net_device *);
         void    (*complete)(struct net_device *);
-        u32     (*get_ufo)(struct net_device *);
-        int     (*set_ufo)(struct net_device *, u32);
-        u32     (*get_flags)(struct net_device *);
-        int     (*set_flags)(struct net_device *, u32);
-        u32     (*get_priv_flags)(struct net_device *);
-        int     (*set_priv_flags)(struct net_device *, u32);
+        u32     (*get_ufo)(struct net_device *);
+        int     (*set_ufo)(struct net_device *, u32);
+        u32     (*get_flags)(struct net_device *);
+        int     (*set_flags)(struct net_device *, u32);
+        u32     (*get_priv_flags)(struct net_device *);
+        int     (*set_priv_flags)(struct net_device *, u32);
         int     (*get_sset_count)(struct net_device *, int);
-        int     (*get_rxnfc)(struct net_device *, struct ethtool_rxnfc *, void *);
+        int     (*get_rxnfc)(struct net_device *,
+                             struct ethtool_rxnfc *, void *);
         int     (*set_rxnfc)(struct net_device *, struct ethtool_rxnfc *);
-        int     (*flash_device)(struct net_device *, struct ethtool_flash *);
+        int     (*flash_device)(struct net_device *, struct ethtool_flash *);
         int     (*reset)(struct net_device *, u32 *);
-        int     (*set_rx_ntuple)(struct net_device *, struct ethtool_rx_ntuple *);
+        int     (*set_rx_ntuple)(struct net_device *,
+                                 struct ethtool_rx_ntuple *);
         int     (*get_rx_ntuple)(struct net_device *, u32 stringset, void *);
 };
 #endif /* __KERNEL__ */
@@ -576,29 +586,29 @@ struct ethtool_ops {
 #define ETHTOOL_GREGS           0x00000004 /* Get NIC registers. */
 #define ETHTOOL_GWOL            0x00000005 /* Get wake-on-lan options. */
 #define ETHTOOL_SWOL            0x00000006 /* Set wake-on-lan options. */
-#define ETHTOOL_GMSGLVL         0x00000007 /* Get driver message level */
-#define ETHTOOL_SMSGLVL         0x00000008 /* Set driver msg level. */
+#define ETHTOOL_GMSGLVL 0x00000007 /* Get driver message level */
+#define ETHTOOL_SMSGLVL 0x00000008 /* Set driver msg level. */
 #define ETHTOOL_NWAY_RST        0x00000009 /* Restart autonegotiation. */
 #define ETHTOOL_GLINK           0x0000000a /* Get link status (ethtool_value) */
-#define ETHTOOL_GEEPROM         0x0000000b /* Get EEPROM data */
-#define ETHTOOL_SEEPROM         0x0000000c /* Set EEPROM data. */
+#define ETHTOOL_GEEPROM 0x0000000b /* Get EEPROM data */
+#define ETHTOOL_SEEPROM 0x0000000c /* Set EEPROM data. */
 #define ETHTOOL_GCOALESCE       0x0000000e /* Get coalesce config */
 #define ETHTOOL_SCOALESCE       0x0000000f /* Set coalesce config. */
 #define ETHTOOL_GRINGPARAM      0x00000010 /* Get ring parameters */
 #define ETHTOOL_SRINGPARAM      0x00000011 /* Set ring parameters. */
 #define ETHTOOL_GPAUSEPARAM     0x00000012 /* Get pause parameters */
 #define ETHTOOL_SPAUSEPARAM     0x00000013 /* Set pause parameters. */
-#define ETHTOOL_GRXCSUM         0x00000014 /* Get RX hw csum enable (ethtool_value) */
-#define ETHTOOL_SRXCSUM         0x00000015 /* Set RX hw csum enable (ethtool_value) */
-#define ETHTOOL_GTXCSUM         0x00000016 /* Get TX hw csum enable (ethtool_value) */
-#define ETHTOOL_STXCSUM         0x00000017 /* Set TX hw csum enable (ethtool_value) */
+#define ETHTOOL_GRXCSUM 0x00000014 /* Get RX hw csum enable (ethtool_value) */
+#define ETHTOOL_SRXCSUM 0x00000015 /* Set RX hw csum enable (ethtool_value) */
+#define ETHTOOL_GTXCSUM 0x00000016 /* Get TX hw csum enable (ethtool_value) */
+#define ETHTOOL_STXCSUM 0x00000017 /* Set TX hw csum enable (ethtool_value) */
 #define ETHTOOL_GSG             0x00000018 /* Get scatter-gather enable
                                             * (ethtool_value) */
 #define ETHTOOL_SSG             0x00000019 /* Set scatter-gather enable
                                             * (ethtool_value). */
 #define ETHTOOL_TEST            0x0000001a /* execute NIC self-test. */
 #define ETHTOOL_GSTRINGS        0x0000001b /* get specified string set */
-#define ETHTOOL_PHYS_ID         0x0000001c /* identify the NIC */
+#define ETHTOOL_PHYS_ID 0x0000001c /* identify the NIC */
 #define ETHTOOL_GSTATS          0x0000001d /* get NIC-specific statistics */
 #define ETHTOOL_GTSO            0x0000001e /* Get TSO enable (ethtool_value) */
 #define ETHTOOL_STSO            0x0000001f /* Set TSO enable (ethtool_value) */
@@ -609,24 +619,24 @@ struct ethtool_ops {
 #define ETHTOOL_SGSO            0x00000024 /* Set GSO enable (ethtool_value) */
 #define ETHTOOL_GFLAGS          0x00000025 /* Get flags bitmap(ethtool_value) */
 #define ETHTOOL_SFLAGS          0x00000026 /* Set flags bitmap(ethtool_value) */
-#define ETHTOOL_GPFLAGS         0x00000027 /* Get driver-private flags bitmap */
-#define ETHTOOL_SPFLAGS         0x00000028 /* Set driver-private flags bitmap */
+#define ETHTOOL_GPFLAGS 0x00000027 /* Get driver-private flags bitmap */
+#define ETHTOOL_SPFLAGS 0x00000028 /* Set driver-private flags bitmap */
 
-#define ETHTOOL_GRXFH           0x00000029 /* Get RX flow hash configuration */
-#define ETHTOOL_SRXFH           0x0000002a /* Set RX flow hash configuration */
+#define ETHTOOL_GRXFH           0x00000029 /* Get RX flow hash configuration */
+#define ETHTOOL_SRXFH           0x0000002a /* Set RX flow hash configuration */
 #define ETHTOOL_GGRO            0x0000002b /* Get GRO enable (ethtool_value) */
 #define ETHTOOL_SGRO            0x0000002c /* Set GRO enable (ethtool_value) */
-#define ETHTOOL_GRXRINGS        0x0000002d /* Get RX rings available for LB */
-#define ETHTOOL_GRXCLSRLCNT     0x0000002e /* Get RX class rule count */
-#define ETHTOOL_GRXCLSRULE      0x0000002f /* Get RX classification rule */
-#define ETHTOOL_GRXCLSRLALL     0x00000030 /* Get all RX classification rule */
-#define ETHTOOL_SRXCLSRLDEL     0x00000031 /* Delete RX classification rule */
-#define ETHTOOL_SRXCLSRLINS     0x00000032 /* Insert RX classification rule */
-#define ETHTOOL_FLASHDEV        0x00000033 /* Flash firmware to device */
-#define ETHTOOL_RESET           0x00000034 /* Reset hardware */
-#define ETHTOOL_SRXNTUPLE       0x00000035 /* Add an n-tuple filter to device */
-#define ETHTOOL_GRXNTUPLE       0x00000036 /* Get n-tuple filters from device */
-#define ETHTOOL_GSSET_INFO      0x00000037 /* Get string set info */
+#define ETHTOOL_GRXRINGS        0x0000002d /* Get RX rings available for LB */
+#define ETHTOOL_GRXCLSRLCNT     0x0000002e /* Get RX class rule count */
+#define ETHTOOL_GRXCLSRULE      0x0000002f /* Get RX classification rule */
+#define ETHTOOL_GRXCLSRLALL     0x00000030 /* Get all RX classification rule */
+#define ETHTOOL_SRXCLSRLDEL     0x00000031 /* Delete RX classification rule */
+#define ETHTOOL_SRXCLSRLINS     0x00000032 /* Insert RX classification rule */
+#define ETHTOOL_FLASHDEV        0x00000033 /* Flash firmware to device */
+#define ETHTOOL_RESET           0x00000034 /* Reset hardware */
+#define ETHTOOL_SRXNTUPLE       0x00000035 /* Add an n-tuple filter to device */
+#define ETHTOOL_GRXNTUPLE       0x00000036 /* Get n-tuple filters from device */
+#define ETHTOOL_GSSET_INFO      0x00000037 /* Get string set info */
 
 /* compatibility with older code */
 #define SPARC_ETH_GSET          ETHTOOL_GSET
@@ -635,18 +645,18 @@ struct ethtool_ops {
 /* Indicates what features are supported by the interface. */
 #define SUPPORTED_10baseT_Half          (1 << 0)
 #define SUPPORTED_10baseT_Full          (1 << 1)
-#define SUPPORTED_100baseT_Half         (1 << 2)
-#define SUPPORTED_100baseT_Full         (1 << 3)
+#define SUPPORTED_100baseT_Half (1 << 2)
+#define SUPPORTED_100baseT_Full (1 << 3)
 #define SUPPORTED_1000baseT_Half        (1 << 4)
 #define SUPPORTED_1000baseT_Full        (1 << 5)
 #define SUPPORTED_Autoneg               (1 << 6)
 #define SUPPORTED_TP                    (1 << 7)
 #define SUPPORTED_AUI                   (1 << 8)
 #define SUPPORTED_MII                   (1 << 9)
-#define SUPPORTED_FIBRE                 (1 << 10)
+#define SUPPORTED_FIBRE         (1 << 10)
 #define SUPPORTED_BNC                   (1 << 11)
 #define SUPPORTED_10000baseT_Full       (1 << 12)
-#define SUPPORTED_Pause                 (1 << 13)
+#define SUPPORTED_Pause         (1 << 13)
 #define SUPPORTED_Asym_Pause            (1 << 14)
 #define SUPPORTED_2500baseX_Full        (1 << 15)
 #define SUPPORTED_Backplane             (1 << 16)
@@ -656,8 +666,8 @@ struct ethtool_ops {
 #define SUPPORTED_10000baseR_FEC        (1 << 20)
 
 /* Indicates what features are advertised by the interface. */
-#define ADVERTISED_10baseT_Half         (1 << 0)
-#define ADVERTISED_10baseT_Full         (1 << 1)
+#define ADVERTISED_10baseT_Half (1 << 0)
+#define ADVERTISED_10baseT_Full (1 << 1)
 #define ADVERTISED_100baseT_Half        (1 << 2)
 #define ADVERTISED_100baseT_Full        (1 << 3)
 #define ADVERTISED_1000baseT_Half       (1 << 4)
@@ -696,12 +706,12 @@ struct ethtool_ops {
 #define DUPLEX_FULL             0x01
 
 /* Which connector port. */
-#define PORT_TP                 0x00
+#define PORT_TP         0x00
 #define PORT_AUI                0x01
 #define PORT_MII                0x02
 #define PORT_FIBRE              0x03
 #define PORT_BNC                0x04
-#define PORT_DA                 0x05
+#define PORT_DA         0x05
 #define PORT_NONE               0xef
 #define PORT_OTHER              0xff
 
@@ -715,7 +725,7 @@ struct ethtool_ops {
 /* Enable or disable autonegotiation.  If this is set to enable,
  * the forced link modes above are completely ignored.
  */
-#define AUTONEG_DISABLE         0x00
+#define AUTONEG_DISABLE 0x00
 #define AUTONEG_ENABLE          0x01
 
 /* Mode MDI or MDI-X */
@@ -746,8 +756,8 @@ struct ethtool_ops {
 #define AH_V6_FLOW      0x0b
 #define ESP_V6_FLOW     0x0c
 #define IP_USER_FLOW    0x0d
-#define IPV4_FLOW       0x10
-#define IPV6_FLOW       0x11
+#define IPV4_FLOW       0x10
+#define IPV6_FLOW       0x11
 
 /* L3-L4 network traffic flow hash options */
 #define RXH_L2DA        (1 << 1)
diff --git a/include/linux/ext2_fs_sb.h b/include/linux/ext2_fs_sb.h
index 1cdb66367c98..db4d9f586bb6 100644
--- a/include/linux/ext2_fs_sb.h
+++ b/include/linux/ext2_fs_sb.h
@@ -106,6 +106,15 @@ struct ext2_sb_info {
         spinlock_t s_rsv_window_lock;
         struct rb_root s_rsv_window_root;
         struct ext2_reserve_window_node s_rsv_window_head;
+        /*
+         * s_lock protects against concurrent modifications of s_mount_state,
+         * s_blocks_last, s_overhead_last and the content of superblock's
+         * buffer pointed to by sbi->s_es.
+         *
+         * Note: It is used in ext2_show_options() to provide a consistent view
+         * of the mount options.
+         */
+        spinlock_t s_lock;
 };
 
 static inline spinlock_t *
diff --git a/include/linux/fb.h b/include/linux/fb.h
index c10163b4c40e..1296af45169d 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -403,6 +403,7 @@ struct fb_cursor {
 #include <linux/notifier.h>
 #include <linux/list.h>
 #include <linux/backlight.h>
+#include <linux/slab.h>
 #include <asm/io.h>
 
 struct vm_area_struct;
@@ -862,10 +863,22 @@ struct fb_info {
         /* we need the PCI or similiar aperture base/size not
            smem_start/size as smem_start may just be an object
            allocated inside the aperture so may not actually overlap */
-        resource_size_t aperture_base;
-        resource_size_t aperture_size;
+        struct apertures_struct {
+                unsigned int count;
+                struct aperture {
+                        resource_size_t base;
+                        resource_size_t size;
+                } ranges[0];
+        } *apertures;
 };
 
+static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
+        struct apertures_struct *a = kzalloc(sizeof(struct apertures_struct)
+                        + max_num * sizeof(struct aperture), GFP_KERNEL);
+        a->count = max_num;
+        return a;
+}
+
 #ifdef MODULE
 #define FBINFO_DEFAULT  FBINFO_MODULE
 #else
@@ -958,6 +971,8 @@ extern ssize_t fb_sys_write(struct fb_info *info, const char __user *buf,
 /* drivers/video/fbmem.c */
 extern int register_framebuffer(struct fb_info *fb_info);
 extern int unregister_framebuffer(struct fb_info *fb_info);
+extern void remove_conflicting_framebuffers(struct apertures_struct *a,
+                                const char *name, bool primary);
 extern int fb_prepare_logo(struct fb_info *fb_info, int rotate);
 extern int fb_show_logo(struct fb_info *fb_info, int rotate);
 extern char* fb_get_buffer_offset(struct fb_info *info, struct fb_pixmap *buf, u32 size);
diff --git a/include/linux/fcntl.h b/include/linux/fcntl.h
index 86037400a6e3..afc00af3229b 100644
--- a/include/linux/fcntl.h
+++ b/include/linux/fcntl.h
@@ -22,6 +22,12 @@
 #define F_NOTIFY        (F_LINUX_SPECIFIC_BASE+2)
 
 /*
+ * Set and get of pipe page size array
+ */
+#define F_SETPIPE_SZ    (F_LINUX_SPECIFIC_BASE + 7)
+#define F_GETPIPE_SZ    (F_LINUX_SPECIFIC_BASE + 8)
+
+/*
  * Types of directory notifications that may be requested.
  */
 #define DN_ACCESS       0x00000001      /* File accessed */
diff --git a/include/linux/filter.h b/include/linux/filter.h
index 29a0e3db9f43..151f5d703b7e 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -123,7 +123,8 @@ struct sock_fprog {	/* Required for SO_ATTACH_FILTER. */
 #define SKF_AD_NLATTR_NEST      16
 #define SKF_AD_MARK     20
 #define SKF_AD_QUEUE    24
-#define SKF_AD_MAX      28
+#define SKF_AD_HATYPE   28
+#define SKF_AD_MAX      32
 #define SKF_NET_OFF   (-0x100000)
 #define SKF_LL_OFF    (-0x200000)
 
diff --git a/include/linux/firmware.h b/include/linux/firmware.h
index 043811f0d277..53d1e6c4f848 100644
--- a/include/linux/firmware.h
+++ b/include/linux/firmware.h
@@ -12,6 +12,7 @@
 struct firmware {
         size_t size;
         const u8 *data;
+        struct page **pages;
 };
 
 struct device;
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 44f35aea2f1f..b336cb9ca9a0 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -651,6 +651,7 @@ struct block_device {
         int                     bd_openers;
         struct mutex            bd_mutex;       /* open/close mutex */
         struct list_head        bd_inodes;
+        void *                  bd_claiming;
         void *                  bd_holder;
         int                     bd_holders;
 #ifdef CONFIG_SYSFS
@@ -1280,10 +1281,12 @@ static inline int lock_may_write(struct inode *inode, loff_t start,
 
 
 struct fasync_struct {
-        int     magic;
-        int     fa_fd;
-        struct  fasync_struct   *fa_next; /* singly linked list */
-        struct  file            *fa_file;
+        spinlock_t              fa_lock;
+        int                     magic;
+        int                     fa_fd;
+        struct fasync_struct    *fa_next; /* singly linked list */
+        struct file             *fa_file;
+        struct rcu_head         fa_rcu;
 };
 
 #define FASYNC_MAGIC 0x4601
@@ -1292,8 +1295,6 @@ struct fasync_struct {
 extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
 /* can be called from interrupts */
 extern void kill_fasync(struct fasync_struct **, int, int);
-/* only for net: no internal synchronization */
-extern void __kill_fasync(struct fasync_struct *, int, int);
 
 extern int __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
 extern int f_setown(struct file *filp, unsigned long arg, int force);
@@ -1314,8 +1315,6 @@ extern int send_sigurg(struct fown_struct *fown);
 extern struct list_head super_blocks;
 extern spinlock_t sb_lock;
 
-#define sb_entry(list)  list_entry((list), struct super_block, s_list)
-#define S_BIAS (1<<30)
 struct super_block {
         struct list_head        s_list;         /* Keep this first */
         dev_t                   s_dev;          /* search index; _not_ kdev_t */
@@ -1334,12 +1333,11 @@ struct super_block {
         struct rw_semaphore     s_umount;
         struct mutex            s_lock;
         int                     s_count;
-        int                     s_need_sync;
         atomic_t                s_active;
 #ifdef CONFIG_SECURITY
         void                    *s_security;
 #endif
-        struct xattr_handler    **s_xattr;
+        const struct xattr_handler **s_xattr;
 
         struct list_head        s_inodes;       /* all inodes */
         struct hlist_head       s_anon;         /* anonymous dentries for (nfs) exporting */
@@ -1431,7 +1429,8 @@ extern void dentry_unhash(struct dentry *dentry);
  * VFS file helper functions.
  */
 extern int file_permission(struct file *, int);
-
+extern void inode_init_owner(struct inode *inode, const struct inode *dir,
+                        mode_t mode);
 /*
  * VFS FS_IOC_FIEMAP helper definitions.
  */
@@ -1744,6 +1743,7 @@ struct file_system_type {
 
         struct lock_class_key s_lock_key;
         struct lock_class_key s_umount_key;
+        struct lock_class_key s_vfs_rename_key;
 
         struct lock_class_key i_lock_key;
         struct lock_class_key i_mutex_key;
@@ -1781,8 +1781,6 @@ extern int get_sb_pseudo(struct file_system_type *, char *,
         const struct super_operations *ops, unsigned long,
         struct vfsmount *mnt);
 extern void simple_set_mnt(struct vfsmount *mnt, struct super_block *sb);
-int __put_super_and_need_restart(struct super_block *sb);
-void put_super(struct super_block *sb);
 
 /* Alas, no aliases. Too much hassle with bringing module.h everywhere */
 #define fops_get(fops) \
@@ -1802,6 +1800,8 @@ extern void drop_collected_mounts(struct vfsmount *);
 extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
                           struct vfsmount *);
 extern int vfs_statfs(struct dentry *, struct kstatfs *);
+extern int freeze_super(struct super_block *super);
+extern int thaw_super(struct super_block *super);
 
 extern int current_umask(void);
 
@@ -2087,9 +2087,9 @@ extern int __filemap_fdatawrite_range(struct address_space *mapping,
 extern int filemap_fdatawrite_range(struct address_space *mapping,
                                 loff_t start, loff_t end);
 
-extern int vfs_fsync_range(struct file *file, struct dentry *dentry,
-                           loff_t start, loff_t end, int datasync);
-extern int vfs_fsync(struct file *file, struct dentry *dentry, int datasync);
+extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
+                           int datasync);
+extern int vfs_fsync(struct file *file, int datasync);
 extern int generic_write_sync(struct file *file, loff_t pos, loff_t count);
 extern void sync_supers(void);
 extern void emergency_sync(void);
@@ -2329,6 +2329,7 @@ extern struct super_block *get_super(struct block_device *);
 extern struct super_block *get_active_super(struct block_device *bdev);
 extern struct super_block *user_get_super(dev_t);
 extern void drop_super(struct super_block *sb);
+extern void iterate_supers(void (*)(struct super_block *, void *), void *);
 
 extern int dcache_dir_open(struct inode *, struct file *);
 extern int dcache_dir_close(struct inode *, struct file *);
@@ -2362,6 +2363,8 @@ extern void simple_release_fs(struct vfsmount **mount, int *count);
 
 extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
                         loff_t *ppos, const void *from, size_t available);
+extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
+                const void __user *from, size_t count);
 
 extern int simple_fsync(struct file *, struct dentry *, int);
 
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index 39e71b0a3bfd..c082f223e2fe 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -25,6 +25,9 @@ const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
 const char *ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
                                      const struct trace_print_flags *symbol_array);
 
+const char *ftrace_print_hex_seq(struct trace_seq *p,
+                                 const unsigned char *buf, int len);
+
 /*
  * The trace entry - the most basic unit of tracing. This is what
  * is printed in the end as a single line in the trace output, such as:
diff --git a/include/linux/generic_acl.h b/include/linux/generic_acl.h
index ca666d18ed67..574bea4013b6 100644
--- a/include/linux/generic_acl.h
+++ b/include/linux/generic_acl.h
@@ -5,8 +5,8 @@
 
 struct inode;
 
-extern struct xattr_handler generic_acl_access_handler;
-extern struct xattr_handler generic_acl_default_handler;
+extern const struct xattr_handler generic_acl_access_handler;
+extern const struct xattr_handler generic_acl_default_handler;
 
 int generic_acl_init(struct inode *, struct inode *);
 int generic_acl_chmod(struct inode *);
diff --git a/include/linux/genetlink.h b/include/linux/genetlink.h
index b834ef6d59fa..61549b26ad6f 100644
--- a/include/linux/genetlink.h
+++ b/include/linux/genetlink.h
@@ -80,4 +80,12 @@ enum {
 
 #define CTRL_ATTR_MCAST_GRP_MAX (__CTRL_ATTR_MCAST_GRP_MAX - 1)
 
+#ifdef __KERNEL__
+
+/* All generic netlink requests are serialized by a global lock.  */
+extern void genl_lock(void);
+extern void genl_unlock(void);
+
+#endif /* __KERNEL__ */
+
 #endif  /* __LINUX_GENERIC_NETLINK_H */
diff --git a/include/linux/gsmmux.h b/include/linux/gsmmux.h
new file mode 100644
index 000000000000..378de4195caf
--- /dev/null
+++ b/include/linux/gsmmux.h
@@ -0,0 +1,25 @@
+#ifndef _LINUX_GSMMUX_H
+#define _LINUX_GSMMUX_H
+
+struct gsm_config
+{
+        unsigned int adaption;
+        unsigned int encapsulation;
+        unsigned int initiator;
+        unsigned int t1;
+        unsigned int t2;
+        unsigned int t3;
+        unsigned int n2;
+        unsigned int mru;
+        unsigned int mtu;
+        unsigned int k;
+        unsigned int i;
+        unsigned int unused[8];         /* Padding for expansion without
+                                           breaking stuff */
+};
+
+#define GSMIOC_GETCONF          _IOR('G', 0, struct gsm_config)
+#define GSMIOC_SETCONF          _IOW('G', 1, struct gsm_config)
+
+
+#endif
diff --git a/include/linux/hdpu_features.h b/include/linux/hdpu_features.h
deleted file mode 100644
index 6a8715431ae4..000000000000
--- a/include/linux/hdpu_features.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <linux/spinlock.h>
-
-struct cpustate_t {
-        spinlock_t lock;
-        int excl;
-        int open_count;
-        unsigned char cached_val;
-        int inited;
-        unsigned long *set_addr;
-        unsigned long *clr_addr;
-};
-
-
-#define HDPU_CPUSTATE_NAME "hdpu cpustate"
-#define HDPU_NEXUS_NAME "hdpu nexus"
-
-#define CPUSTATE_KERNEL_MAJOR  0x10
-
-#define CPUSTATE_KERNEL_INIT_DRV   0 /* CPU State Driver Initialized */
-#define CPUSTATE_KERNEL_INIT_PCI   1 /* 64360 PCI Busses Init */
-#define CPUSTATE_KERNEL_INIT_REG   2 /* 64360 Bridge Init */
-#define CPUSTATE_KERNEL_CPU1_KICK  3 /* Boot cpu 1 */
-#define CPUSTATE_KERNEL_CPU1_OK    4  /* Cpu 1 has checked in */
-#define CPUSTATE_KERNEL_OK         5 /* Terminal state */
-#define CPUSTATE_KERNEL_RESET   14 /* Board reset via SW*/
-#define CPUSTATE_KERNEL_HALT   15 /* Board halted via SW*/
diff --git a/include/linux/hid.h b/include/linux/hid.h
index b1344ec4b7fc..895001f7f4b2 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -308,11 +308,13 @@ struct hid_item {
 #define HID_QUIRK_NOTOUCH                       0x00000002
 #define HID_QUIRK_IGNORE                        0x00000004
 #define HID_QUIRK_NOGET                         0x00000008
+#define HID_QUIRK_HIDDEV_FORCE                  0x00000010
 #define HID_QUIRK_BADPAD                        0x00000020
 #define HID_QUIRK_MULTI_INPUT                   0x00000040
 #define HID_QUIRK_SKIP_OUTPUT_REPORTS           0x00010000
 #define HID_QUIRK_FULLSPEED_INTERVAL            0x10000000
 #define HID_QUIRK_NO_INIT_REPORTS               0x20000000
+#define HID_QUIRK_NO_IGNORE                     0x40000000
 
 /*
  * This is the global environment of the parser. This information is
@@ -589,6 +591,9 @@ struct hid_usage_id {
  * @report_fixup: called before report descriptor parsing (NULL means nop)
  * @input_mapping: invoked on input registering before mapping an usage
  * @input_mapped: invoked on input registering after mapping an usage
+ * @suspend: invoked on suspend (NULL means nop)
+ * @resume: invoked on resume if device was not reset (NULL means nop)
+ * @reset_resume: invoked on resume if device was reset (NULL means nop)
  *
  * raw_event and event should return 0 on no action performed, 1 when no
  * further processing should be done and negative on error
@@ -629,6 +634,11 @@ struct hid_driver {
         int (*input_mapped)(struct hid_device *hdev,
                         struct hid_input *hidinput, struct hid_field *field,
                         struct hid_usage *usage, unsigned long **bit, int *max);
+#ifdef CONFIG_PM
+        int (*suspend)(struct hid_device *hdev, pm_message_t message);
+        int (*resume)(struct hid_device *hdev);
+        int (*reset_resume)(struct hid_device *hdev);
+#endif
 /* private: */
         struct device_driver driver;
 };
diff --git a/include/linux/i2c-omap.h b/include/linux/i2c-omap.h
new file mode 100644
index 000000000000..78ebf507ce56
--- /dev/null
+++ b/include/linux/i2c-omap.h
@@ -0,0 +1,9 @@
+#ifndef __I2C_OMAP_H__
+#define __I2C_OMAP_H__
+
+struct omap_i2c_bus_platform_data {
+        u32             clkrate;
+        void            (*set_mpu_wkup_lat)(struct device *dev, long set);
+};
+
+#endif
diff --git a/include/linux/i2c/twl.h b/include/linux/i2c/twl.h
index fb6784e86d5f..6de90bfc6acd 100644
--- a/include/linux/i2c/twl.h
+++ b/include/linux/i2c/twl.h
@@ -496,7 +496,7 @@ struct twl4030_madc_platform_data {
         int             irq_line;
 };
 
-/* Boards have uniqe mappings of {row, col} --> keycode.
+/* Boards have unique mappings of {row, col} --> keycode.
  * Column and row are 8 bits each, but range only from 0..7.
  * a PERSISTENT_KEY is "always on" and never reported.
  */
@@ -569,9 +569,9 @@ struct twl4030_codec_data {
         struct twl4030_codec_audio_data         *audio;
         struct twl4030_codec_vibra_data         *vibra;
 
-        /* twl6030 */
-        int audpwron_gpio;      /* audio power-on gpio */
-        int naudint_irq;        /* audio interrupt */
+        /* twl6040 */
+        int audpwron_gpio;      /* audio power-on gpio */
+        int naudint_irq;        /* audio interrupt */
 };
 
 struct twl4030_platform_data {
@@ -664,15 +664,15 @@ static inline int twl4030charger_usb_en(int enable) { return 0; }
 #define TWL4030_REG_VUSB3V1     19
 
 /* TWL6030 SMPS/LDO's */
-/* EXTERNAL dc-to-dc buck convertor contollable via SR */
+/* EXTERNAL dc-to-dc buck convertor controllable via SR */
 #define TWL6030_REG_VDD1        30
 #define TWL6030_REG_VDD2        31
 #define TWL6030_REG_VDD3        32
 
 /* Non SR compliant dc-to-dc buck convertors */
-#define TWL6030_REG_VMEM        33
+#define TWL6030_REG_VMEM        33
 #define TWL6030_REG_V2V1        34
-#define TWL6030_REG_V1V29       35
+#define TWL6030_REG_V1V29       35
 #define TWL6030_REG_V1V8        36
 
 /* EXTERNAL LDOs */
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 3239d1c10acb..b6d448048ae2 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -362,7 +362,7 @@ struct ide_drive_s;
 struct ide_disk_ops {
         int             (*check)(struct ide_drive_s *, const char *);
         int             (*get_capacity)(struct ide_drive_s *);
-        u64             (*set_capacity)(struct ide_drive_s *, u64);
+        void            (*unlock_native_capacity)(struct ide_drive_s *);
         void            (*setup)(struct ide_drive_s *);
         void            (*flush)(struct ide_drive_s *);
         int             (*init_media)(struct ide_drive_s *, struct gendisk *);
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index 19984958ab7b..97b2eae6a22c 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -876,6 +876,7 @@ struct ieee80211_ht_cap {
 #define IEEE80211_HT_CAP_SGI_40                 0x0040
 #define IEEE80211_HT_CAP_TX_STBC                0x0080
 #define IEEE80211_HT_CAP_RX_STBC                0x0300
+#define         IEEE80211_HT_CAP_RX_STBC_SHIFT  8
 #define IEEE80211_HT_CAP_DELAY_BA               0x0400
 #define IEEE80211_HT_CAP_MAX_AMSDU              0x0800
 #define IEEE80211_HT_CAP_DSSSCCK40              0x1000
@@ -1211,6 +1212,8 @@ enum ieee80211_category {
         WLAN_CATEGORY_SA_QUERY = 8,
         WLAN_CATEGORY_PROTECTED_DUAL_OF_ACTION = 9,
         WLAN_CATEGORY_WMM = 17,
+        WLAN_CATEGORY_MESH_PLINK = 30,          /* Pending ANA approval */
+        WLAN_CATEGORY_MESH_PATH_SEL = 32,       /* Pending ANA approval */
         WLAN_CATEGORY_VENDOR_SPECIFIC_PROTECTED = 126,
         WLAN_CATEGORY_VENDOR_SPECIFIC = 127,
 };
@@ -1324,7 +1327,6 @@ enum ieee80211_back_actioncode {
 enum ieee80211_back_parties {
         WLAN_BACK_RECIPIENT = 0,
         WLAN_BACK_INITIATOR = 1,
-        WLAN_BACK_TIMER = 2,
 };
 
 /* SA Query action */
diff --git a/include/linux/if.h b/include/linux/if.h
index 3a9f410a296b..be350e62a905 100644
--- a/include/linux/if.h
+++ b/include/linux/if.h
@@ -71,6 +71,8 @@
                                          * release skb->dst
                                          */
 #define IFF_DONT_BRIDGE 0x800           /* disallow bridging this ether dev */
+#define IFF_IN_NETPOLL  0x1000          /* whether we are processing netpoll */
+#define IFF_DISABLE_NETPOLL     0x2000  /* disable netpoll at run-time */
 
 #define IF_GET_IFACE    0x0001          /* for querying only */
 #define IF_GET_PROTO    0x0002
diff --git a/include/linux/if_arp.h b/include/linux/if_arp.h
index e80b7f88f7c6..6d722f41ee7c 100644
--- a/include/linux/if_arp.h
+++ b/include/linux/if_arp.h
@@ -90,6 +90,7 @@
 
 #define ARPHRD_PHONET   820             /* PhoNet media type            */
 #define ARPHRD_PHONET_PIPE 821          /* PhoNet pipe header           */
+#define ARPHRD_CAIF     822             /* CAIF media type              */
 
 #define ARPHRD_VOID       0xFFFF        /* Void type, nothing is known */
 #define ARPHRD_NONE       0xFFFE        /* zero header length */
diff --git a/include/linux/if_ether.h b/include/linux/if_ether.h
index 299b4121f914..bed7a4682b90 100644
--- a/include/linux/if_ether.h
+++ b/include/linux/if_ether.h
@@ -109,6 +109,7 @@
 #define ETH_P_TRAILER   0x001C          /* Trailer switch tagging       */
 #define ETH_P_PHONET    0x00F5          /* Nokia Phonet frames          */
 #define ETH_P_IEEE802154 0x00F6         /* IEEE802.15.4 frame           */
+#define ETH_P_CAIF      0x00F7          /* ST-Ericsson CAIF protocol    */
 
 /*
  *      This is an Ethernet frame header.
diff --git a/include/linux/if_link.h b/include/linux/if_link.h
index d94963b379d9..85c812db5a3f 100644
--- a/include/linux/if_link.h
+++ b/include/linux/if_link.h
@@ -37,6 +37,38 @@ struct rtnl_link_stats {
         __u32   tx_compressed;
 };
 
+struct rtnl_link_stats64 {
+        __u64   rx_packets;             /* total packets received       */
+        __u64   tx_packets;             /* total packets transmitted    */
+        __u64   rx_bytes;               /* total bytes received         */
+        __u64   tx_bytes;               /* total bytes transmitted      */
+        __u64   rx_errors;              /* bad packets received         */
+        __u64   tx_errors;              /* packet transmit problems     */
+        __u64   rx_dropped;             /* no space in linux buffers    */
+        __u64   tx_dropped;             /* no space available in linux  */
+        __u64   multicast;              /* multicast packets received   */
+        __u64   collisions;
+
+        /* detailed rx_errors: */
+        __u64   rx_length_errors;
+        __u64   rx_over_errors;         /* receiver ring buff overflow  */
+        __u64   rx_crc_errors;          /* recved pkt with crc error    */
+        __u64   rx_frame_errors;        /* recv'd frame alignment error */
+        __u64   rx_fifo_errors;         /* recv'r fifo overrun          */
+        __u64   rx_missed_errors;       /* receiver missed packet       */
+
+        /* detailed tx_errors */
+        __u64   tx_aborted_errors;
+        __u64   tx_carrier_errors;
+        __u64   tx_fifo_errors;
+        __u64   tx_heartbeat_errors;
+        __u64   tx_window_errors;
+
+        /* for cslip etc */
+        __u64   rx_compressed;
+        __u64   tx_compressed;
+};
+
 /* The struct should be in sync with struct ifmap */
 struct rtnl_link_ifmap {
         __u64   mem_start;
@@ -80,6 +112,9 @@ enum {
         IFLA_IFALIAS,
         IFLA_NUM_VF,            /* Number of VFs if device is SR-IOV PF */
         IFLA_VFINFO_LIST,
+        IFLA_STATS64,
+        IFLA_VF_PORTS,
+        IFLA_PORT_SELF,
         __IFLA_MAX
 };
 
@@ -241,4 +276,77 @@ struct ifla_vf_info {
         __u32 qos;
         __u32 tx_rate;
 };
+
+/* VF ports management section
+ *
+ *      Nested layout of set/get msg is:
+ *
+ *              [IFLA_NUM_VF]
+ *              [IFLA_VF_PORTS]
+ *                      [IFLA_VF_PORT]
+ *                              [IFLA_PORT_*], ...
+ *                      [IFLA_VF_PORT]
+ *                              [IFLA_PORT_*], ...
+ *                      ...
+ *              [IFLA_PORT_SELF]
+ *                      [IFLA_PORT_*], ...
+ */
+
+enum {
+        IFLA_VF_PORT_UNSPEC,
+        IFLA_VF_PORT,                   /* nest */
+        __IFLA_VF_PORT_MAX,
+};
+
+#define IFLA_VF_PORT_MAX (__IFLA_VF_PORT_MAX - 1)
+
+enum {
+        IFLA_PORT_UNSPEC,
+        IFLA_PORT_VF,                   /* __u32 */
+        IFLA_PORT_PROFILE,              /* string */
+        IFLA_PORT_VSI_TYPE,             /* 802.1Qbg (pre-)standard VDP */
+        IFLA_PORT_INSTANCE_UUID,        /* binary UUID */
+        IFLA_PORT_HOST_UUID,            /* binary UUID */
+        IFLA_PORT_REQUEST,              /* __u8 */
+        IFLA_PORT_RESPONSE,             /* __u16, output only */
+        __IFLA_PORT_MAX,
+};
+
+#define IFLA_PORT_MAX (__IFLA_PORT_MAX - 1)
+
+#define PORT_PROFILE_MAX        40
+#define PORT_UUID_MAX           16
+#define PORT_SELF_VF            -1
+
+enum {
+        PORT_REQUEST_PREASSOCIATE = 0,
+        PORT_REQUEST_PREASSOCIATE_RR,
+        PORT_REQUEST_ASSOCIATE,
+        PORT_REQUEST_DISASSOCIATE,
+};
+
+enum {
+        PORT_VDP_RESPONSE_SUCCESS = 0,
+        PORT_VDP_RESPONSE_INVALID_FORMAT,
+        PORT_VDP_RESPONSE_INSUFFICIENT_RESOURCES,
+        PORT_VDP_RESPONSE_UNUSED_VTID,
+        PORT_VDP_RESPONSE_VTID_VIOLATION,
+        PORT_VDP_RESPONSE_VTID_VERSION_VIOALTION,
+        PORT_VDP_RESPONSE_OUT_OF_SYNC,
+        /* 0x08-0xFF reserved for future VDP use */
+        PORT_PROFILE_RESPONSE_SUCCESS = 0x100,
+        PORT_PROFILE_RESPONSE_INPROGRESS,
+        PORT_PROFILE_RESPONSE_INVALID,
+        PORT_PROFILE_RESPONSE_BADSTATE,
+        PORT_PROFILE_RESPONSE_INSUFFICIENT_RESOURCES,
+        PORT_PROFILE_RESPONSE_ERROR,
+};
+
+struct ifla_port_vsi {
+        __u8 vsi_mgr_id;
+        __u8 vsi_type_id[3];
+        __u8 vsi_type_version;
+        __u8 pad[3];
+};
+
 #endif /* _LINUX_IF_LINK_H */
diff --git a/include/linux/if_macvlan.h b/include/linux/if_macvlan.h
index b78a712247da..9ea047aca795 100644
--- a/include/linux/if_macvlan.h
+++ b/include/linux/if_macvlan.h
@@ -85,6 +85,7 @@ extern netdev_tx_t macvlan_start_xmit(struct sk_buff *skb,
                                       struct net_device *dev);
 
 
-extern struct sk_buff *(*macvlan_handle_frame_hook)(struct sk_buff *);
+extern struct sk_buff *(*macvlan_handle_frame_hook)(struct macvlan_port *,
+                                                    struct sk_buff *);
 
 #endif /* _LINUX_IF_MACVLAN_H */
diff --git a/include/linux/if_packet.h b/include/linux/if_packet.h
index aa57a5f993fc..6ac23ef1801a 100644
--- a/include/linux/if_packet.h
+++ b/include/linux/if_packet.h
@@ -47,6 +47,7 @@ struct sockaddr_ll {
 #define PACKET_TX_RING                  13
 #define PACKET_LOSS                     14
 #define PACKET_VNET_HDR                 15
+#define PACKET_TX_TIMESTAMP             16
 
 struct tpacket_stats {
         unsigned int    tp_packets;
diff --git a/include/linux/if_pppol2tp.h b/include/linux/if_pppol2tp.h
index c58baea4a25b..184bc5566207 100644
--- a/include/linux/if_pppol2tp.h
+++ b/include/linux/if_pppol2tp.h
@@ -2,7 +2,7 @@
  * Linux PPP over L2TP (PPPoL2TP) Socket Implementation (RFC 2661)
  *
  * This file supplies definitions required by the PPP over L2TP driver
- * (pppol2tp.c).  All version information wrt this file is located in pppol2tp.c
+ * (l2tp_ppp.c).  All version information wrt this file is located in l2tp_ppp.c
  *
  * License:
  *              This program is free software; you can redistribute it and/or
@@ -35,6 +35,20 @@ struct pppol2tp_addr {
         __u16 d_tunnel, d_session;      /* For sending outgoing packets */
 };
 
+/* The L2TPv3 protocol changes tunnel and session ids from 16 to 32
+ * bits. So we need a different sockaddr structure.
+ */
+struct pppol2tpv3_addr {
+        pid_t   pid;                    /* pid that owns the fd.
+                                         * 0 => current */
+        int     fd;                     /* FD of UDP or IP socket to use */
+
+        struct sockaddr_in addr;        /* IP address and port to send to */
+
+        __u32 s_tunnel, s_session;      /* For matching incoming packets */
+        __u32 d_tunnel, d_session;      /* For sending outgoing packets */
+};
+
 /* Socket options:
  * DEBUG        - bitmask of debug message categories
  * SENDSEQ      - 0 => don't send packets with sequence numbers
diff --git a/include/linux/if_pppox.h b/include/linux/if_pppox.h
index 90b5fae5d714..a6577af0c4e6 100644
--- a/include/linux/if_pppox.h
+++ b/include/linux/if_pppox.h
@@ -72,6 +72,15 @@ struct sockaddr_pppol2tp {
         struct pppol2tp_addr pppol2tp;
 }__attribute__ ((packed));
 
+/* The L2TPv3 protocol changes tunnel and session ids from 16 to 32
+ * bits. So we need a different sockaddr structure.
+ */
+struct sockaddr_pppol2tpv3 {
+        sa_family_t     sa_family;      /* address family, AF_PPPOX */
+        unsigned int    sa_protocol;    /* protocol identifier */
+        struct pppol2tpv3_addr pppol2tp;
+} __attribute__ ((packed));
+
 /*********************************************************************
  *
  * ioctl interface for defining forwarding of connections
diff --git a/include/linux/if_tun.h b/include/linux/if_tun.h
index 1350a246893a..06b1829731fd 100644
--- a/include/linux/if_tun.h
+++ b/include/linux/if_tun.h
@@ -51,6 +51,8 @@
 #define TUNSETSNDBUF   _IOW('T', 212, int)
 #define TUNATTACHFILTER _IOW('T', 213, struct sock_fprog)
 #define TUNDETACHFILTER _IOW('T', 214, struct sock_fprog)
+#define TUNGETVNETHDRSZ _IOR('T', 215, int)
+#define TUNSETVNETHDRSZ _IOW('T', 216, int)
 
 /* TUNSETIFF ifr flags */
 #define IFF_TUN         0x0001
diff --git a/include/linux/if_x25.h b/include/linux/if_x25.h
new file mode 100644
index 000000000000..897765f5feb8
--- /dev/null
+++ b/include/linux/if_x25.h
@@ -0,0 +1,26 @@
+/*
+ *  Linux X.25 packet to device interface
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ */
+
+#ifndef _IF_X25_H
+#define _IF_X25_H
+
+#include <linux/types.h>
+
+/* Documentation/networking/x25-iface.txt */
+#define X25_IFACE_DATA          0x00
+#define X25_IFACE_CONNECT       0x01
+#define X25_IFACE_DISCONNECT    0x02
+#define X25_IFACE_PARAMS        0x03
+
+#endif /* _IF_X25_H */
diff --git a/include/linux/in6.h b/include/linux/in6.h
index bd55c6e46b2e..c4bf46f764bf 100644
--- a/include/linux/in6.h
+++ b/include/linux/in6.h
@@ -221,10 +221,10 @@ struct in6_flowlabel_req {
 #define IPV6_RTHDR              57
 #define IPV6_RECVDSTOPTS        58
 #define IPV6_DSTOPTS            59
-#if 0   /* not yet */
 #define IPV6_RECVPATHMTU        60
 #define IPV6_PATHMTU            61
 #define IPV6_DONTFRAG           62
+#if 0   /* not yet */
 #define IPV6_USE_MIN_MTU        63
 #endif
 
@@ -265,6 +265,9 @@ struct in6_flowlabel_req {
 #define IPV6_PREFER_SRC_CGA             0x0008
 #define IPV6_PREFER_SRC_NONCGA          0x0800
 
+/* RFC5082: Generalized Ttl Security Mechanism */
+#define IPV6_MINHOPCOUNT                73
+
 /*
  * Multicast Routing:
  * see include/linux/mroute6.h.
diff --git a/include/linux/input.h b/include/linux/input.h
index 7ed2251b33f1..83524e4f3290 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -806,6 +806,7 @@ struct input_absinfo {
 #define BUS_HOST                0x19
 #define BUS_GSC                 0x1A
 #define BUS_ATARI               0x1B
+#define BUS_SPI                 0x1C
 
 /*
  * MT_TOOL types
diff --git a/include/linux/input/ad714x.h b/include/linux/input/ad714x.h
new file mode 100644
index 000000000000..0cbe5e81482e
--- /dev/null
+++ b/include/linux/input/ad714x.h
@@ -0,0 +1,63 @@
+/*
+ * include/linux/input/ad714x.h
+ *
+ * AD714x is very flexible, it can be used as buttons, scrollwheel,
+ * slider, touchpad at the same time. That depends on the boards.
+ * The platform_data for the device's "struct device" holds this
+ * information.
+ *
+ * Copyright 2009 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#ifndef __LINUX_INPUT_AD714X_H__
+#define __LINUX_INPUT_AD714X_H__
+
+#define STAGE_NUM              12
+#define STAGE_CFGREG_NUM       8
+#define SYS_CFGREG_NUM         8
+
+/* board information which need be initialized in arch/mach... */
+struct ad714x_slider_plat {
+        int start_stage;
+        int end_stage;
+        int max_coord;
+};
+
+struct ad714x_wheel_plat {
+        int start_stage;
+        int end_stage;
+        int max_coord;
+};
+
+struct ad714x_touchpad_plat {
+        int x_start_stage;
+        int x_end_stage;
+        int x_max_coord;
+
+        int y_start_stage;
+        int y_end_stage;
+        int y_max_coord;
+};
+
+struct ad714x_button_plat {
+        int keycode;
+        unsigned short l_mask;
+        unsigned short h_mask;
+};
+
+struct ad714x_platform_data {
+        int slider_num;
+        int wheel_num;
+        int touchpad_num;
+        int button_num;
+        struct ad714x_slider_plat *slider;
+        struct ad714x_wheel_plat *wheel;
+        struct ad714x_touchpad_plat *touchpad;
+        struct ad714x_button_plat *button;
+        unsigned short stage_cfg_reg[STAGE_NUM][STAGE_CFGREG_NUM];
+        unsigned short sys_cfg_reg[SYS_CFGREG_NUM];
+};
+
+#endif
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 5137db3317f9..c2331138ca1b 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -78,7 +78,7 @@ enum {
         IRQTF_AFFINITY,
 };
 
-/**
+/*
  * These values can be returned by request_any_context_irq() and
  * describe the context the interrupt will be run in.
  *
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index 26fad187d661..b22790268b64 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -52,6 +52,7 @@ struct resource_list {
 
 #define IORESOURCE_MEM_64       0x00100000
 #define IORESOURCE_WINDOW       0x00200000      /* forwarded by bridge */
+#define IORESOURCE_MUXED        0x00400000      /* Resource is software muxed */
 
 #define IORESOURCE_EXCLUSIVE    0x08000000      /* Userland may not map this resource */
 #define IORESOURCE_DISABLED     0x10000000
@@ -143,7 +144,8 @@ static inline unsigned long resource_type(const struct resource *res)
 }
 
 /* Convenience shorthand with allocation */
-#define request_region(start,n,name)    __request_region(&ioport_resource, (start), (n), (name), 0)
+#define request_region(start,n,name)            __request_region(&ioport_resource, (start), (n), (name), 0)
+#define request_muxed_region(start,n,name)      __request_region(&ioport_resource, (start), (n), (name), IORESOURCE_MUXED)
 #define __request_mem_region(start,n,name, excl) __request_region(&iomem_resource, (start), (n), (name), excl)
 #define request_mem_region(start,n,name) __request_region(&iomem_resource, (start), (n), (name), 0)
 #define request_mem_region_exclusive(start,n,name) \
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index e0cc9a7db2b5..99e1ab7e3eec 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -21,6 +21,10 @@ struct in6_pktinfo {
         int             ipi6_ifindex;
 };
 
+struct ip6_mtuinfo {
+        struct sockaddr_in6     ip6m_addr;
+        __u32                   ip6m_mtu;
+};
 
 struct in6_ifreq {
         struct in6_addr ifr6_addr;
@@ -250,9 +254,11 @@ struct inet6_skb_parm {
 
 #define IP6SKB_XFRM_TRANSFORMED 1
 #define IP6SKB_FORWARDED        2
+#define IP6SKB_REROUTED         4
 };
 
 #define IP6CB(skb)      ((struct inet6_skb_parm*)((skb)->cb))
+#define IP6CBMTU(skb)   ((struct ip6_mtuinfo *)((skb)->cb))
 
 static inline int inet6_iif(const struct sk_buff *skb)
 {
@@ -334,21 +340,25 @@ struct ipv6_pinfo {
                                 dstopts:1,
                                 odstopts:1,
                                 rxflow:1,
-                                rxtclass:1;
+                                rxtclass:1,
+                                rxpmtu:1;
                 } bits;
                 __u16           all;
         } rxopt;
 
         /* sockopt flags */
-        __u8                    recverr:1,
+        __u16                   recverr:1,
                                 sndflow:1,
                                 pmtudisc:2,
                                 ipv6only:1,
-                                srcprefs:3;     /* 001: prefer temporary address
+                                srcprefs:3,     /* 001: prefer temporary address
                                                  * 010: prefer public address
                                                  * 100: prefer care-of address
                                                  */
+                                dontfrag:1;
+        __u8                    min_hopcount;
         __u8                    tclass;
+        __u8                    padding;
 
         __u32                   dst_cookie;
 
@@ -358,6 +368,7 @@ struct ipv6_pinfo {
 
         struct ipv6_txoptions   *opt;
         struct sk_buff          *pktoptions;
+        struct sk_buff          *rxpmtu;
         struct {
                 struct ipv6_txoptions *opt;
                 u8 hop_limit;
@@ -372,6 +383,7 @@ struct raw6_sock {
         __u32                   checksum;       /* perform checksum */
         __u32                   offset;         /* checksum offset  */
         struct icmp6_filter     filter;
+        __u32                   ip6mr_table;
         /* ipv6_pinfo has to be the last member of raw6_sock, see inet6_sk_generic */
         struct ipv6_pinfo       inet6;
 };
diff --git a/include/linux/isapnp.h b/include/linux/isapnp.h
index cd5a269fdb5e..e2d28b026a8c 100644
--- a/include/linux/isapnp.h
+++ b/include/linux/isapnp.h
@@ -43,10 +43,10 @@
  */
 
 #ifdef __KERNEL__
+#include <linux/mod_devicetable.h>
 
 #define DEVICE_COUNT_COMPATIBLE 4
 
-#define ISAPNP_ANY_ID           0xffff
 #define ISAPNP_CARD_DEVS        8
 
 #define ISAPNP_CARD_ID(_va, _vb, _vc, _device) \
@@ -74,12 +74,6 @@ struct isapnp_card_id {
 #define ISAPNP_DEVICE_SINGLE_END \
                 .card_vendor = 0, .card_device = 0
 
-struct isapnp_device_id {
-        unsigned short card_vendor, card_device;
-        unsigned short vendor, function;
-        unsigned long driver_data;      /* data private to the driver */
-};
-
 #if defined(CONFIG_ISAPNP) || (defined(CONFIG_ISAPNP_MODULE) && defined(MODULE))
 
 #define __ISAPNP__
diff --git a/include/linux/jbd.h b/include/linux/jbd.h
index 516a2a27e87a..e06965081ba5 100644
--- a/include/linux/jbd.h
+++ b/include/linux/jbd.h
@@ -427,9 +427,9 @@ struct transaction_s
         enum {
                 T_RUNNING,
                 T_LOCKED,
-                T_RUNDOWN,
                 T_FLUSH,
                 T_COMMIT,
+                T_COMMIT_RECORD,
                 T_FINISHED
         }                       t_state;
 
@@ -991,6 +991,7 @@ int journal_start_commit(journal_t *journal, tid_t *tid);
 int journal_force_commit_nested(journal_t *journal);
 int log_wait_commit(journal_t *journal, tid_t tid);
 int log_do_checkpoint(journal_t *journal);
+int journal_trans_will_send_data_barrier(journal_t *journal, tid_t tid);
 
 void __log_wait_for_space(journal_t *journal);
 extern void     __journal_drop_transaction(journal_t *, transaction_t *);
diff --git a/include/linux/jffs2.h b/include/linux/jffs2.h
index 2b32d638147d..0874ab59ffef 100644
--- a/include/linux/jffs2.h
+++ b/include/linux/jffs2.h
@@ -215,8 +215,8 @@ union jffs2_node_union
 
 /* Data payload for device nodes. */
 union jffs2_device_node {
-        jint16_t old;
-        jint32_t new;
+        jint16_t old_id;
+        jint32_t new_id;
 };
 
 #endif /* __LINUX_JFFS2_H__ */
diff --git a/include/linux/kdb.h b/include/linux/kdb.h
new file mode 100644
index 000000000000..ccb2b3ec0fe8
--- /dev/null
+++ b/include/linux/kdb.h
@@ -0,0 +1,117 @@
+#ifndef _KDB_H
+#define _KDB_H
+
+/*
+ * Kernel Debugger Architecture Independent Global Headers
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (c) 2000-2007 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (C) 2000 Stephane Eranian <eranian@hpl.hp.com>
+ * Copyright (C) 2009 Jason Wessel <jason.wessel@windriver.com>
+ */
+
+#ifdef  CONFIG_KGDB_KDB
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <asm/atomic.h>
+
+#define KDB_POLL_FUNC_MAX       5
+extern int kdb_poll_idx;
+
+/*
+ * kdb_initial_cpu is initialized to -1, and is set to the cpu
+ * number whenever the kernel debugger is entered.
+ */
+extern int kdb_initial_cpu;
+extern atomic_t kdb_event;
+
+/*
+ * kdb_diemsg
+ *
+ *      Contains a pointer to the last string supplied to the
+ *      kernel 'die' panic function.
+ */
+extern const char *kdb_diemsg;
+
+#define KDB_FLAG_EARLYKDB       (1 << 0) /* set from boot parameter kdb=early */
+#define KDB_FLAG_CATASTROPHIC   (1 << 1) /* A catastrophic event has occurred */
+#define KDB_FLAG_CMD_INTERRUPT  (1 << 2) /* Previous command was interrupted */
+#define KDB_FLAG_NOIPI          (1 << 3) /* Do not send IPIs */
+#define KDB_FLAG_ONLY_DO_DUMP   (1 << 4) /* Only do a dump, used when
+                                          * kdb is off */
+#define KDB_FLAG_NO_CONSOLE     (1 << 5) /* No console is available,
+                                          * kdb is disabled */
+#define KDB_FLAG_NO_VT_CONSOLE  (1 << 6) /* No VT console is available, do
+                                          * not use keyboard */
+#define KDB_FLAG_NO_I8042       (1 << 7) /* No i8042 chip is available, do
+                                          * not use keyboard */
+
+extern int kdb_flags;   /* Global flags, see kdb_state for per cpu state */
+
+extern void kdb_save_flags(void);
+extern void kdb_restore_flags(void);
+
+#define KDB_FLAG(flag)          (kdb_flags & KDB_FLAG_##flag)
+#define KDB_FLAG_SET(flag)      ((void)(kdb_flags |= KDB_FLAG_##flag))
+#define KDB_FLAG_CLEAR(flag)    ((void)(kdb_flags &= ~KDB_FLAG_##flag))
+
+/*
+ * External entry point for the kernel debugger.  The pt_regs
+ * at the time of entry are supplied along with the reason for
+ * entry to the kernel debugger.
+ */
+
+typedef enum {
+        KDB_REASON_ENTER = 1,   /* KDB_ENTER() trap/fault - regs valid */
+        KDB_REASON_ENTER_SLAVE, /* KDB_ENTER_SLAVE() trap/fault - regs valid */
+        KDB_REASON_BREAK,       /* Breakpoint inst. - regs valid */
+        KDB_REASON_DEBUG,       /* Debug Fault - regs valid */
+        KDB_REASON_OOPS,        /* Kernel Oops - regs valid */
+        KDB_REASON_SWITCH,      /* CPU switch - regs valid*/
+        KDB_REASON_KEYBOARD,    /* Keyboard entry - regs valid */
+        KDB_REASON_NMI,         /* Non-maskable interrupt; regs valid */
+        KDB_REASON_RECURSE,     /* Recursive entry to kdb;
+                                 * regs probably valid */
+        KDB_REASON_SSTEP,       /* Single Step trap. - regs valid */
+} kdb_reason_t;
+
+extern int kdb_trap_printk;
+extern int vkdb_printf(const char *fmt, va_list args)
+            __attribute__ ((format (printf, 1, 0)));
+extern int kdb_printf(const char *, ...)
+            __attribute__ ((format (printf, 1, 2)));
+typedef int (*kdb_printf_t)(const char *, ...)
+             __attribute__ ((format (printf, 1, 2)));
+
+extern void kdb_init(int level);
+
+/* Access to kdb specific polling devices */
+typedef int (*get_char_func)(void);
+extern get_char_func kdb_poll_funcs[];
+extern int kdb_get_kbd_char(void);
+
+static inline
+int kdb_process_cpu(const struct task_struct *p)
+{
+        unsigned int cpu = task_thread_info(p)->cpu;
+        if (cpu > num_possible_cpus())
+                cpu = 0;
+        return cpu;
+}
+
+/* kdb access to register set for stack dumping */
+extern struct pt_regs *kdb_current_regs;
+
+#else /* ! CONFIG_KGDB_KDB */
+#define kdb_printf(...)
+#define kdb_init(x)
+#endif  /* CONFIG_KGDB_KDB */
+enum {
+        KDB_NOT_INITIALIZED,
+        KDB_INIT_EARLY,
+        KDB_INIT_FULL,
+};
+#endif  /* !_KDB_H */
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 9fb1c1299032..cc5e3ffe9fce 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -4,6 +4,8 @@
 /*
  * 'kernel.h' contains some often-used function prototypes etc
  */
+#define __ALIGN_KERNEL(x, a)            __ALIGN_KERNEL_MASK(x, (typeof(x))(a) - 1)
+#define __ALIGN_KERNEL_MASK(x, mask)    (((x) + (mask)) & ~(mask))
 
 #ifdef __KERNEL__
 
@@ -37,8 +39,8 @@ extern const char linux_proc_banner[];
 
 #define STACK_MAGIC     0xdeadbeef
 
-#define ALIGN(x,a)              __ALIGN_MASK(x,(typeof(x))(a)-1)
-#define __ALIGN_MASK(x,mask)    (((x)+(mask))&~(mask))
+#define ALIGN(x, a)             __ALIGN_KERNEL((x), (a))
+#define __ALIGN_MASK(x, mask)   __ALIGN_KERNEL_MASK((x), (mask))
 #define PTR_ALIGN(p, a)         ((typeof(p))ALIGN((unsigned long)(p), (a)))
 #define IS_ALIGNED(x, a)                (((x) & ((typeof(x))(a) - 1)) == 0)
 
@@ -344,6 +346,7 @@ extern enum system_states {
 #define TAINT_OVERRIDDEN_ACPI_TABLE     8
 #define TAINT_WARN                      9
 #define TAINT_CRAP                      10
+#define TAINT_FIRMWARE_WORKAROUND       11
 
 extern void dump_stack(void) __cold;
 
diff --git a/include/linux/kfifo.h b/include/linux/kfifo.h
index e117b1aee69c..9fad0527344f 100644
--- a/include/linux/kfifo.h
+++ b/include/linux/kfifo.h
@@ -201,7 +201,7 @@ static inline __must_check unsigned int kfifo_avail(struct kfifo *fifo)
  * @n: the length of the data to be added.
  * @lock: pointer to the spinlock to use for locking.
  *
- * This function copies at most @len bytes from the @from buffer into
+ * This function copies at most @n bytes from the @from buffer into
  * the FIFO depending on the free space, and returns the number of
  * bytes copied.
  */
@@ -227,7 +227,7 @@ static inline unsigned int kfifo_in_locked(struct kfifo *fifo,
  * @n: the size of the destination buffer.
  * @lock: pointer to the spinlock to use for locking.
  *
- * This function copies at most @len bytes from the FIFO into the
+ * This function copies at most @n bytes from the FIFO into the
  * @to buffer and returns the number of copied bytes.
  */
 static inline __must_check unsigned int kfifo_out_locked(struct kfifo *fifo,
diff --git a/include/linux/kgdb.h b/include/linux/kgdb.h
index 19ec41a183f5..9340f34d1bb5 100644
--- a/include/linux/kgdb.h
+++ b/include/linux/kgdb.h
@@ -16,10 +16,12 @@
 #include <linux/serial_8250.h>
 #include <linux/linkage.h>
 #include <linux/init.h>
-
 #include <asm/atomic.h>
+#ifdef CONFIG_HAVE_ARCH_KGDB
 #include <asm/kgdb.h>
+#endif
 
+#ifdef CONFIG_KGDB
 struct pt_regs;
 
 /**
@@ -34,20 +36,6 @@ struct pt_regs;
 extern int kgdb_skipexception(int exception, struct pt_regs *regs);
 
 /**
- *      kgdb_post_primary_code - (optional) Save error vector/code numbers.
- *      @regs: Original pt_regs.
- *      @e_vector: Original error vector.
- *      @err_code: Original error code.
- *
- *      This is usually needed on architectures which support SMP and
- *      KGDB.  This function is called after all the secondary cpus have
- *      been put to a know spin state and the primary CPU has control over
- *      KGDB.
- */
-extern void kgdb_post_primary_code(struct pt_regs *regs, int e_vector,
-                                  int err_code);
-
-/**
  *      kgdb_disable_hw_debug - (optional) Disable hardware debugging hook
  *      @regs: Current &struct pt_regs.
  *
@@ -72,6 +60,7 @@ struct uart_port;
 void kgdb_breakpoint(void);
 
 extern int kgdb_connected;
+extern int kgdb_io_module_registered;
 
 extern atomic_t                 kgdb_setting_breakpoint;
 extern atomic_t                 kgdb_cpu_doing_single_step;
@@ -202,12 +191,34 @@ kgdb_arch_handle_exception(int vector, int signo, int err_code,
  */
 extern void kgdb_roundup_cpus(unsigned long flags);
 
+/**
+ *      kgdb_arch_set_pc - Generic call back to the program counter
+ *      @regs: Current &struct pt_regs.
+ *  @pc: The new value for the program counter
+ *
+ *      This function handles updating the program counter and requires an
+ *      architecture specific implementation.
+ */
+extern void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc);
+
+
 /* Optional functions. */
 extern int kgdb_validate_break_address(unsigned long addr);
 extern int kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr);
 extern int kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle);
 
 /**
+ *      kgdb_arch_late - Perform any architecture specific initalization.
+ *
+ *      This function will handle the late initalization of any
+ *      architecture specific callbacks.  This is an optional function for
+ *      handling things like late initialization of hw breakpoints.  The
+ *      default implementation does nothing.
+ */
+extern void kgdb_arch_late(void);
+
+
+/**
  * struct kgdb_arch - Describe architecture specific values.
  * @gdb_bpt_instr: The instruction to trigger a breakpoint.
  * @flags: Flags for the breakpoint, currently just %KGDB_HW_BREAKPOINT.
@@ -247,6 +258,8 @@ struct kgdb_arch {
  * the I/O driver.
  * @post_exception: Pointer to a function that will do any cleanup work
  * for the I/O driver.
+ * @is_console: 1 if the end device is a console 0 if the I/O device is
+ * not a console
  */
 struct kgdb_io {
         const char              *name;
@@ -256,6 +269,7 @@ struct kgdb_io {
         int                     (*init) (void);
         void                    (*pre_exception) (void);
         void                    (*post_exception) (void);
+        int                     is_console;
 };
 
 extern struct kgdb_arch         arch_kgdb_ops;
@@ -264,12 +278,14 @@ extern unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs);
 
 extern int kgdb_register_io_module(struct kgdb_io *local_kgdb_io_ops);
 extern void kgdb_unregister_io_module(struct kgdb_io *local_kgdb_io_ops);
+extern struct kgdb_io *dbg_io_ops;
 
 extern int kgdb_hex2long(char **ptr, unsigned long *long_val);
 extern int kgdb_mem2hex(char *mem, char *buf, int count);
 extern int kgdb_hex2mem(char *buf, char *mem, int count);
 
 extern int kgdb_isremovedbreak(unsigned long addr);
+extern void kgdb_schedule_breakpoint(void);
 
 extern int
 kgdb_handle_exception(int ex_vector, int signo, int err_code,
@@ -278,5 +294,12 @@ extern int kgdb_nmicallback(int cpu, void *regs);
 
 extern int                      kgdb_single_step;
 extern atomic_t                 kgdb_active;
-
+#define in_dbg_master() \
+        (raw_smp_processor_id() == atomic_read(&kgdb_active))
+extern bool dbg_is_early;
+extern void __init dbg_late_init(void);
+#else /* ! CONFIG_KGDB */
+#define in_dbg_master() (0)
+#define dbg_late_init()
+#endif /* ! CONFIG_KGDB */
 #endif /* _KGDB_H_ */
diff --git a/include/linux/kobj_map.h b/include/linux/kobj_map.h
index 73717ed9ea79..18ca75ffcc5a 100644
--- a/include/linux/kobj_map.h
+++ b/include/linux/kobj_map.h
@@ -1,3 +1,10 @@
+/*
+ * kobj_map.h
+ */
+
+#ifndef _KOBJ_MAP_H_
+#define _KOBJ_MAP_H_
+
 #include <linux/mutex.h>
 
 typedef struct kobject *kobj_probe_t(dev_t, int *, void *);
@@ -8,3 +15,5 @@ int kobj_map(struct kobj_map *, dev_t, unsigned long, struct module *,
 void kobj_unmap(struct kobj_map *, dev_t, unsigned long);
 struct kobject *kobj_lookup(struct kobj_map *, dev_t, int *);
 struct kobj_map *kobj_map_init(kobj_probe_t *, struct mutex *);
+
+#endif /* _KOBJ_MAP_H_ */
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
index 3950d3c2850d..cf343a852534 100644
--- a/include/linux/kobject.h
+++ b/include/linux/kobject.h
@@ -108,6 +108,8 @@ struct kobj_type {
         void (*release)(struct kobject *kobj);
         const struct sysfs_ops *sysfs_ops;
         struct attribute **default_attrs;
+        const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
+        const void *(*namespace)(struct kobject *kobj);
 };
 
 struct kobj_uevent_env {
@@ -134,6 +136,42 @@ struct kobj_attribute {
 
 extern const struct sysfs_ops kobj_sysfs_ops;
 
+/*
+ * Namespace types which are used to tag kobjects and sysfs entries.
+ * Network namespace will likely be the first.
+ */
+enum kobj_ns_type {
+        KOBJ_NS_TYPE_NONE = 0,
+        KOBJ_NS_TYPE_NET,
+        KOBJ_NS_TYPES
+};
+
+struct sock;
+
+/*
+ * Callbacks so sysfs can determine namespaces
+ *   @current_ns: return calling task's namespace
+ *   @netlink_ns: return namespace to which a sock belongs (right?)
+ *   @initial_ns: return the initial namespace (i.e. init_net_ns)
+ */
+struct kobj_ns_type_operations {
+        enum kobj_ns_type type;
+        const void *(*current_ns)(void);
+        const void *(*netlink_ns)(struct sock *sk);
+        const void *(*initial_ns)(void);
+};
+
+int kobj_ns_type_register(const struct kobj_ns_type_operations *ops);
+int kobj_ns_type_registered(enum kobj_ns_type type);
+const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent);
+const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj);
+
+const void *kobj_ns_current(enum kobj_ns_type type);
+const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk);
+const void *kobj_ns_initial(enum kobj_ns_type type);
+void kobj_ns_exit(enum kobj_ns_type type, const void *ns);
+
+
 /**
  * struct kset - a set of kobjects of a specific type, belonging to a specific subsystem.
  *
diff --git a/include/linux/kref.h b/include/linux/kref.h
index b0cb0ebad9e6..6cc38fc07ab7 100644
--- a/include/linux/kref.h
+++ b/include/linux/kref.h
@@ -1,5 +1,5 @@
 /*
- * kref.c - library routines for handling generic reference counted objects
+ * kref.h - library routines for handling generic reference counted objects
  *
  * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
  * Copyright (C) 2004 IBM Corp.
@@ -21,7 +21,6 @@ struct kref {
         atomic_t refcount;
 };
 
-void kref_set(struct kref *kref, int num);
 void kref_init(struct kref *kref);
 void kref_get(struct kref *kref);
 int kref_put(struct kref *kref, void (*release) (struct kref *kref));
diff --git a/include/linux/ks8842.h b/include/linux/ks8842.h
new file mode 100644
index 000000000000..da0341b8ca0a
--- /dev/null
+++ b/include/linux/ks8842.h
@@ -0,0 +1,34 @@
+/*
+ * ks8842.h KS8842 platform data struct definition
+ * Copyright (c) 2010 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _LINUX_KS8842_H
+#define _LINUX_KS8842_H
+
+#include <linux/if_ether.h>
+
+/**
+ * struct ks8842_platform_data - Platform data of the KS8842 network driver
+ * @macaddr:    The MAC address of the device, set to all 0:s to use the on in
+ *              the chip.
+ *
+ */
+struct ks8842_platform_data {
+        u8 macaddr[ETH_ALEN];
+};
+
+#endif
diff --git a/include/linux/kvm.h b/include/linux/kvm.h
index 60df9c84ecae..23ea02253900 100644
--- a/include/linux/kvm.h
+++ b/include/linux/kvm.h
@@ -160,6 +160,7 @@ struct kvm_pit_config {
 #define KVM_EXIT_DCR              15
 #define KVM_EXIT_NMI              16
 #define KVM_EXIT_INTERNAL_ERROR   17
+#define KVM_EXIT_OSI              18
 
 /* For KVM_EXIT_INTERNAL_ERROR */
 #define KVM_INTERNAL_ERROR_EMULATION 1
@@ -259,6 +260,10 @@ struct kvm_run {
                         __u32 ndata;
                         __u64 data[16];
                 } internal;
+                /* KVM_EXIT_OSI */
+                struct {
+                        __u64 gprs[32];
+                } osi;
                 /* Fix the size of the union. */
                 char padding[256];
         };
@@ -400,6 +405,15 @@ struct kvm_ioeventfd {
         __u8  pad[36];
 };
 
+/* for KVM_ENABLE_CAP */
+struct kvm_enable_cap {
+        /* in */
+        __u32 cap;
+        __u32 flags;
+        __u64 args[4];
+        __u8  pad[64];
+};
+
 #define KVMIO 0xAE
 
 /*
@@ -501,7 +515,15 @@ struct kvm_ioeventfd {
 #define KVM_CAP_HYPERV_VAPIC 45
 #define KVM_CAP_HYPERV_SPIN 46
 #define KVM_CAP_PCI_SEGMENT 47
+#define KVM_CAP_PPC_PAIRED_SINGLES 48
+#define KVM_CAP_INTR_SHADOW 49
+#ifdef __KVM_HAVE_DEBUGREGS
+#define KVM_CAP_DEBUGREGS 50
+#endif
 #define KVM_CAP_X86_ROBUST_SINGLESTEP 51
+#define KVM_CAP_PPC_OSI 52
+#define KVM_CAP_PPC_UNSET_IRQ 53
+#define KVM_CAP_ENABLE_CAP 54
 
 #ifdef KVM_CAP_IRQ_ROUTING
 
@@ -688,6 +710,10 @@ struct kvm_clock_data {
 /* Available with KVM_CAP_VCPU_EVENTS */
 #define KVM_GET_VCPU_EVENTS       _IOR(KVMIO,  0x9f, struct kvm_vcpu_events)
 #define KVM_SET_VCPU_EVENTS       _IOW(KVMIO,  0xa0, struct kvm_vcpu_events)
+/* Available with KVM_CAP_DEBUGREGS */
+#define KVM_GET_DEBUGREGS         _IOR(KVMIO,  0xa1, struct kvm_debugregs)
+#define KVM_SET_DEBUGREGS         _IOW(KVMIO,  0xa2, struct kvm_debugregs)
+#define KVM_ENABLE_CAP            _IOW(KVMIO,  0xa3, struct kvm_enable_cap)
 
 #define KVM_DEV_ASSIGN_ENABLE_IOMMU     (1 << 0)
 
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 169d07758ee5..7cb116afa1cd 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -105,6 +105,12 @@ struct kvm_vcpu {
         struct kvm_vcpu_arch arch;
 };
 
+/*
+ * Some of the bitops functions do not support too long bitmaps.
+ * This number must be determined not to exceed such limits.
+ */
+#define KVM_MEM_MAX_NR_PAGES ((1UL << 31) - 1)
+
 struct kvm_memory_slot {
         gfn_t base_gfn;
         unsigned long npages;
@@ -237,17 +243,23 @@ void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);
 void vcpu_load(struct kvm_vcpu *vcpu);
 void vcpu_put(struct kvm_vcpu *vcpu);
 
-int kvm_init(void *opaque, unsigned int vcpu_size,
+int kvm_init(void *opaque, unsigned vcpu_size, unsigned vcpu_align,
                   struct module *module);
 void kvm_exit(void);
 
 void kvm_get_kvm(struct kvm *kvm);
 void kvm_put_kvm(struct kvm *kvm);
 
+static inline struct kvm_memslots *kvm_memslots(struct kvm *kvm)
+{
+        return rcu_dereference_check(kvm->memslots,
+                        srcu_read_lock_held(&kvm->srcu)
+                        || lockdep_is_held(&kvm->slots_lock));
+}
+
 #define HPA_MSB ((sizeof(hpa_t) * 8) - 1)
 #define HPA_ERR_MASK ((hpa_t)1 << HPA_MSB)
 static inline int is_error_hpa(hpa_t hpa) { return hpa >> HPA_MSB; }
-struct page *gva_to_page(struct kvm_vcpu *vcpu, gva_t gva);
 
 extern struct page *bad_page;
 extern pfn_t bad_pfn;
diff --git a/include/linux/l2tp.h b/include/linux/l2tp.h
new file mode 100644
index 000000000000..4bdb31df8e72
--- /dev/null
+++ b/include/linux/l2tp.h
@@ -0,0 +1,163 @@
+/*
+ * L2TP-over-IP socket for L2TPv3.
+ *
+ * Author: James Chapman <jchapman@katalix.com>
+ */
+
+#ifndef _LINUX_L2TP_H_
+#define _LINUX_L2TP_H_
+
+#include <linux/types.h>
+#ifdef __KERNEL__
+#include <linux/socket.h>
+#include <linux/in.h>
+#else
+#include <netinet/in.h>
+#endif
+
+#define IPPROTO_L2TP            115
+
+/**
+ * struct sockaddr_l2tpip - the sockaddr structure for L2TP-over-IP sockets
+ * @l2tp_family:  address family number AF_L2TPIP.
+ * @l2tp_addr:    protocol specific address information
+ * @l2tp_conn_id: connection id of tunnel
+ */
+#define __SOCK_SIZE__   16              /* sizeof(struct sockaddr)      */
+struct sockaddr_l2tpip {
+        /* The first fields must match struct sockaddr_in */
+        sa_family_t     l2tp_family;    /* AF_INET */
+        __be16          l2tp_unused;    /* INET port number (unused) */
+        struct in_addr  l2tp_addr;      /* Internet address */
+
+        __u32           l2tp_conn_id;   /* Connection ID of tunnel */
+
+        /* Pad to size of `struct sockaddr'. */
+        unsigned char   __pad[sizeof(struct sockaddr) - sizeof(sa_family_t) -
+                              sizeof(__be16) - sizeof(struct in_addr) -
+                              sizeof(__u32)];
+};
+
+/*****************************************************************************
+ *  NETLINK_GENERIC netlink family.
+ *****************************************************************************/
+
+/*
+ * Commands.
+ * Valid TLVs of each command are:-
+ * TUNNEL_CREATE        - CONN_ID, pw_type, netns, ifname, ipinfo, udpinfo, udpcsum, vlanid
+ * TUNNEL_DELETE        - CONN_ID
+ * TUNNEL_MODIFY        - CONN_ID, udpcsum
+ * TUNNEL_GETSTATS      - CONN_ID, (stats)
+ * TUNNEL_GET           - CONN_ID, (...)
+ * SESSION_CREATE       - SESSION_ID, PW_TYPE, offset, data_seq, cookie, peer_cookie, offset, l2spec
+ * SESSION_DELETE       - SESSION_ID
+ * SESSION_MODIFY       - SESSION_ID, data_seq
+ * SESSION_GET          - SESSION_ID, (...)
+ * SESSION_GETSTATS     - SESSION_ID, (stats)
+ *
+ */
+enum {
+        L2TP_CMD_NOOP,
+        L2TP_CMD_TUNNEL_CREATE,
+        L2TP_CMD_TUNNEL_DELETE,
+        L2TP_CMD_TUNNEL_MODIFY,
+        L2TP_CMD_TUNNEL_GET,
+        L2TP_CMD_SESSION_CREATE,
+        L2TP_CMD_SESSION_DELETE,
+        L2TP_CMD_SESSION_MODIFY,
+        L2TP_CMD_SESSION_GET,
+        __L2TP_CMD_MAX,
+};
+
+#define L2TP_CMD_MAX                    (__L2TP_CMD_MAX - 1)
+
+/*
+ * ATTR types defined for L2TP
+ */
+enum {
+        L2TP_ATTR_NONE,                 /* no data */
+        L2TP_ATTR_PW_TYPE,              /* u16, enum l2tp_pwtype */
+        L2TP_ATTR_ENCAP_TYPE,           /* u16, enum l2tp_encap_type */
+        L2TP_ATTR_OFFSET,               /* u16 */
+        L2TP_ATTR_DATA_SEQ,             /* u16 */
+        L2TP_ATTR_L2SPEC_TYPE,          /* u8, enum l2tp_l2spec_type */
+        L2TP_ATTR_L2SPEC_LEN,           /* u8, enum l2tp_l2spec_type */
+        L2TP_ATTR_PROTO_VERSION,        /* u8 */
+        L2TP_ATTR_IFNAME,               /* string */
+        L2TP_ATTR_CONN_ID,              /* u32 */
+        L2TP_ATTR_PEER_CONN_ID,         /* u32 */
+        L2TP_ATTR_SESSION_ID,           /* u32 */
+        L2TP_ATTR_PEER_SESSION_ID,      /* u32 */
+        L2TP_ATTR_UDP_CSUM,             /* u8 */
+        L2TP_ATTR_VLAN_ID,              /* u16 */
+        L2TP_ATTR_COOKIE,               /* 0, 4 or 8 bytes */
+        L2TP_ATTR_PEER_COOKIE,          /* 0, 4 or 8 bytes */
+        L2TP_ATTR_DEBUG,                /* u32 */
+        L2TP_ATTR_RECV_SEQ,             /* u8 */
+        L2TP_ATTR_SEND_SEQ,             /* u8 */
+        L2TP_ATTR_LNS_MODE,             /* u8 */
+        L2TP_ATTR_USING_IPSEC,          /* u8 */
+        L2TP_ATTR_RECV_TIMEOUT,         /* msec */
+        L2TP_ATTR_FD,                   /* int */
+        L2TP_ATTR_IP_SADDR,             /* u32 */
+        L2TP_ATTR_IP_DADDR,             /* u32 */
+        L2TP_ATTR_UDP_SPORT,            /* u16 */
+        L2TP_ATTR_UDP_DPORT,            /* u16 */
+        L2TP_ATTR_MTU,                  /* u16 */
+        L2TP_ATTR_MRU,                  /* u16 */
+        L2TP_ATTR_STATS,                /* nested */
+        __L2TP_ATTR_MAX,
+};
+
+#define L2TP_ATTR_MAX                   (__L2TP_ATTR_MAX - 1)
+
+/* Nested in L2TP_ATTR_STATS */
+enum {
+        L2TP_ATTR_STATS_NONE,           /* no data */
+        L2TP_ATTR_TX_PACKETS,           /* u64 */
+        L2TP_ATTR_TX_BYTES,             /* u64 */
+        L2TP_ATTR_TX_ERRORS,            /* u64 */
+        L2TP_ATTR_RX_PACKETS,           /* u64 */
+        L2TP_ATTR_RX_BYTES,             /* u64 */
+        L2TP_ATTR_RX_SEQ_DISCARDS,      /* u64 */
+        L2TP_ATTR_RX_OOS_PACKETS,       /* u64 */
+        L2TP_ATTR_RX_ERRORS,            /* u64 */
+        __L2TP_ATTR_STATS_MAX,
+};
+
+#define L2TP_ATTR_STATS_MAX             (__L2TP_ATTR_STATS_MAX - 1)
+
+enum l2tp_pwtype {
+        L2TP_PWTYPE_NONE = 0x0000,
+        L2TP_PWTYPE_ETH_VLAN = 0x0004,
+        L2TP_PWTYPE_ETH = 0x0005,
+        L2TP_PWTYPE_PPP = 0x0007,
+        L2TP_PWTYPE_PPP_AC = 0x0008,
+        L2TP_PWTYPE_IP = 0x000b,
+        __L2TP_PWTYPE_MAX
+};
+
+enum l2tp_l2spec_type {
+        L2TP_L2SPECTYPE_NONE,
+        L2TP_L2SPECTYPE_DEFAULT,
+};
+
+enum l2tp_encap_type {
+        L2TP_ENCAPTYPE_UDP,
+        L2TP_ENCAPTYPE_IP,
+};
+
+enum l2tp_seqmode {
+        L2TP_SEQ_NONE = 0,
+        L2TP_SEQ_IP = 1,
+        L2TP_SEQ_ALL = 2,
+};
+
+/*
+ * NETLINK_GENERIC related info
+ */
+#define L2TP_GENL_NAME          "l2tp"
+#define L2TP_GENL_VERSION       0x1
+
+#endif
diff --git a/include/linux/libata.h b/include/linux/libata.h
index b2f2003b92e5..ee84e7e12039 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -202,12 +202,6 @@ enum {
         ATA_FLAG_SW_ACTIVITY    = (1 << 22), /* driver supports sw activity
                                               * led */
 
-        /* The following flag belongs to ap->pflags but is kept in
-         * ap->flags because it's referenced in many LLDs and will be
-         * removed in not-too-distant future.
-         */
-        ATA_FLAG_DISABLED       = (1 << 23), /* port is disabled, ignore it */
-
         /* bits 24:31 of ap->flags are reserved for LLD specific flags */
 
 
@@ -256,12 +250,13 @@ enum {
         ATA_TMOUT_INTERNAL_QUICK = 5000,
         ATA_TMOUT_MAX_PARK      = 30000,
 
-        /* FIXME: GoVault needs 2s but we can't afford that without
-         * parallel probing.  800ms is enough for iVDR disk
-         * HHD424020F7SV00.  Increase to 2secs when parallel probing
-         * is in place.
+        /*
+         * GoVault needs 2s and iVDR disk HHD424020F7SV00 800ms.  2s
+         * is too much without parallel probing.  Use 2s if parallel
+         * probing is available, 800ms otherwise.
          */
-        ATA_TMOUT_FF_WAIT       =  800,
+        ATA_TMOUT_FF_WAIT_LONG  =  2000,
+        ATA_TMOUT_FF_WAIT       =   800,
 
         /* Spec mandates to wait for ">= 2ms" before checking status
          * after reset.  We wait 150ms, because that was the magic
@@ -721,15 +716,15 @@ struct ata_port {
         unsigned int            print_id; /* user visible unique port ID */
         unsigned int            port_no; /* 0 based port no. inside the host */
 
-        struct ata_prd          *prd;    /* our SG list */
-        dma_addr_t              prd_dma; /* and its DMA mapping */
-
 #ifdef CONFIG_ATA_SFF
         struct ata_ioports      ioaddr; /* ATA cmd/ctl/dma register blocks */
-#endif /* CONFIG_ATA_SFF */
-
         u8                      ctl;    /* cache of ATA control register */
         u8                      last_ctl;       /* Cache last written value */
+        struct delayed_work     sff_pio_task;
+        struct ata_bmdma_prd    *bmdma_prd;     /* BMDMA SG list */
+        dma_addr_t              bmdma_prd_dma;  /* and its DMA mapping */
+#endif /* CONFIG_ATA_SFF */
+
         unsigned int            pio_mask;
         unsigned int            mwdma_mask;
         unsigned int            udma_mask;
@@ -751,8 +746,6 @@ struct ata_port {
         struct ata_host         *host;
         struct device           *dev;
 
-        void                    *port_task_data;
-        struct delayed_work     port_task;
         struct delayed_work     hotplug_task;
         struct work_struct      scsi_rescan_task;
 
@@ -849,6 +842,7 @@ struct ata_port_operations {
          * SFF / taskfile oriented ops
          */
         void (*sff_dev_select)(struct ata_port *ap, unsigned int device);
+        void (*sff_set_devctl)(struct ata_port *ap, u8 ctl);
         u8   (*sff_check_status)(struct ata_port *ap);
         u8   (*sff_check_altstatus)(struct ata_port *ap);
         void (*sff_tf_load)(struct ata_port *ap, const struct ata_taskfile *tf);
@@ -857,16 +851,15 @@ struct ata_port_operations {
                                  const struct ata_taskfile *tf);
         unsigned int (*sff_data_xfer)(struct ata_device *dev,
                         unsigned char *buf, unsigned int buflen, int rw);
-        u8   (*sff_irq_on)(struct ata_port *);
+        void (*sff_irq_on)(struct ata_port *);
         bool (*sff_irq_check)(struct ata_port *);
         void (*sff_irq_clear)(struct ata_port *);
+        void (*sff_drain_fifo)(struct ata_queued_cmd *qc);
 
         void (*bmdma_setup)(struct ata_queued_cmd *qc);
         void (*bmdma_start)(struct ata_queued_cmd *qc);
         void (*bmdma_stop)(struct ata_queued_cmd *qc);
         u8   (*bmdma_status)(struct ata_port *ap);
-
-        void (*drain_fifo)(struct ata_queued_cmd *qc);
 #endif /* CONFIG_ATA_SFF */
 
         ssize_t (*em_show)(struct ata_port *ap, char *buf);
@@ -935,7 +928,6 @@ static inline int ata_port_is_dummy(struct ata_port *ap)
         return ap->ops == &ata_dummy_port_ops;
 }
 
-extern void ata_port_probe(struct ata_port *);
 extern int sata_set_spd(struct ata_link *link);
 extern int ata_std_prereset(struct ata_link *link, unsigned long deadline);
 extern int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
@@ -950,7 +942,6 @@ extern int sata_link_hardreset(struct ata_link *link,
 extern int sata_std_hardreset(struct ata_link *link, unsigned int *class,
                               unsigned long deadline);
 extern void ata_std_postreset(struct ata_link *link, unsigned int *classes);
-extern void ata_port_disable(struct ata_port *);
 
 extern struct ata_host *ata_host_alloc(struct device *dev, int max_ports);
 extern struct ata_host *ata_host_alloc_pinfo(struct device *dev,
@@ -1006,7 +997,6 @@ extern unsigned long ata_xfer_mode2mask(u8 xfer_mode);
 extern int ata_xfer_mode2shift(unsigned long xfer_mode);
 extern const char *ata_mode_string(unsigned long xfer_mask);
 extern unsigned long ata_id_xfermask(const u16 *id);
-extern int ata_port_start(struct ata_port *ap);
 extern int ata_std_qc_defer(struct ata_queued_cmd *qc);
 extern void ata_noop_qc_prep(struct ata_queued_cmd *qc);
 extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
@@ -1039,9 +1029,6 @@ extern int ata_cable_sata(struct ata_port *ap);
 extern int ata_cable_ignore(struct ata_port *ap);
 extern int ata_cable_unknown(struct ata_port *ap);
 
-extern void ata_pio_queue_task(struct ata_port *ap, void *data,
-                               unsigned long delay);
-
 /* Timing helpers */
 extern unsigned int ata_pio_need_iordy(const struct ata_device *);
 extern const struct ata_timing *ata_timing_find_mode(u8 xfer_mode);
@@ -1443,7 +1430,11 @@ static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf)
 {
         memset(tf, 0, sizeof(*tf));
 
+#ifdef CONFIG_ATA_SFF
         tf->ctl = dev->link->ap->ctl;
+#else
+        tf->ctl = ATA_DEVCTL_OBS;
+#endif
         if (dev->devno == 0)
                 tf->device = ATA_DEVICE_OBS;
         else
@@ -1578,8 +1569,6 @@ extern const struct ata_port_operations ata_bmdma32_port_ops;
         .sg_tablesize           = LIBATA_MAX_PRD,               \
         .dma_boundary           = ATA_DMA_BOUNDARY
 
-extern void ata_sff_qc_prep(struct ata_queued_cmd *qc);
-extern void ata_sff_dumb_qc_prep(struct ata_queued_cmd *qc);
 extern void ata_sff_dev_select(struct ata_port *ap, unsigned int device);
 extern u8 ata_sff_check_status(struct ata_port *ap);
 extern void ata_sff_pause(struct ata_port *ap);
@@ -1597,10 +1586,11 @@ extern unsigned int ata_sff_data_xfer32(struct ata_device *dev,
                         unsigned char *buf, unsigned int buflen, int rw);
 extern unsigned int ata_sff_data_xfer_noirq(struct ata_device *dev,
                         unsigned char *buf, unsigned int buflen, int rw);
-extern u8 ata_sff_irq_on(struct ata_port *ap);
+extern void ata_sff_irq_on(struct ata_port *ap);
 extern void ata_sff_irq_clear(struct ata_port *ap);
 extern int ata_sff_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
                             u8 status, int in_wq);
+extern void ata_sff_queue_pio_task(struct ata_port *ap, unsigned long delay);
 extern unsigned int ata_sff_qc_issue(struct ata_queued_cmd *qc);
 extern bool ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc);
 extern unsigned int ata_sff_host_intr(struct ata_port *ap,
@@ -1621,21 +1611,8 @@ extern int sata_sff_hardreset(struct ata_link *link, unsigned int *class,
 extern void ata_sff_postreset(struct ata_link *link, unsigned int *classes);
 extern void ata_sff_drain_fifo(struct ata_queued_cmd *qc);
 extern void ata_sff_error_handler(struct ata_port *ap);
-extern void ata_sff_post_internal_cmd(struct ata_queued_cmd *qc);
-extern int ata_sff_port_start(struct ata_port *ap);
-extern int ata_sff_port_start32(struct ata_port *ap);
 extern void ata_sff_std_ports(struct ata_ioports *ioaddr);
-extern unsigned long ata_bmdma_mode_filter(struct ata_device *dev,
-                                           unsigned long xfer_mask);
-extern void ata_bmdma_setup(struct ata_queued_cmd *qc);
-extern void ata_bmdma_start(struct ata_queued_cmd *qc);
-extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
-extern u8 ata_bmdma_status(struct ata_port *ap);
-extern void ata_bus_reset(struct ata_port *ap);
-
 #ifdef CONFIG_PCI
-extern int ata_pci_bmdma_clear_simplex(struct pci_dev *pdev);
-extern int ata_pci_bmdma_init(struct ata_host *host);
 extern int ata_pci_sff_init_host(struct ata_host *host);
 extern int ata_pci_sff_prepare_host(struct pci_dev *pdev,
                                     const struct ata_port_info * const * ppi,
@@ -1648,6 +1625,23 @@ extern int ata_pci_sff_init_one(struct pci_dev *pdev,
                 struct scsi_host_template *sht, void *host_priv, int hflags);
 #endif /* CONFIG_PCI */
 
+extern void ata_bmdma_qc_prep(struct ata_queued_cmd *qc);
+extern unsigned int ata_bmdma_qc_issue(struct ata_queued_cmd *qc);
+extern void ata_bmdma_dumb_qc_prep(struct ata_queued_cmd *qc);
+extern void ata_bmdma_error_handler(struct ata_port *ap);
+extern void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc);
+extern void ata_bmdma_setup(struct ata_queued_cmd *qc);
+extern void ata_bmdma_start(struct ata_queued_cmd *qc);
+extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
+extern u8 ata_bmdma_status(struct ata_port *ap);
+extern int ata_bmdma_port_start(struct ata_port *ap);
+extern int ata_bmdma_port_start32(struct ata_port *ap);
+
+#ifdef CONFIG_PCI
+extern int ata_pci_bmdma_clear_simplex(struct pci_dev *pdev);
+extern void ata_pci_bmdma_init(struct ata_host *host);
+#endif /* CONFIG_PCI */
+
 /**
  *      ata_sff_busy_wait - Wait for a port status register
  *      @ap: Port to wait for.
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index a03977a96d7e..06aed8305bf3 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -44,6 +44,8 @@ struct lock_class_key {
         struct lockdep_subclass_key     subkeys[MAX_LOCKDEP_SUBCLASSES];
 };
 
+extern struct lock_class_key __lockdep_no_validate__;
+
 #define LOCKSTAT_POINTS         4
 
 /*
@@ -270,6 +272,9 @@ extern void lockdep_init_map(struct lockdep_map *lock, const char *name,
 #define lockdep_set_subclass(lock, sub) \
                 lockdep_init_map(&(lock)->dep_map, #lock, \
                                  (lock)->dep_map.key, sub)
+
+#define lockdep_set_novalidate_class(lock) \
+        lockdep_set_class(lock, &__lockdep_no_validate__)
 /*
  * Compare locking classes
  */
@@ -354,6 +359,9 @@ static inline void lockdep_on(void)
 #define lockdep_set_class_and_subclass(lock, key, sub) \
                 do { (void)(key); } while (0)
 #define lockdep_set_subclass(lock, sub)         do { } while (0)
+
+#define lockdep_set_novalidate_class(lock) do { } while (0)
+
 /*
  * We don't define lockdep_match_class() and lockdep_match_key() for !LOCKDEP
  * case since the result is not well defined and the caller should rather
diff --git a/include/linux/lsm_audit.h b/include/linux/lsm_audit.h
index f78f83d7663f..6907251d5200 100644
--- a/include/linux/lsm_audit.h
+++ b/include/linux/lsm_audit.h
@@ -33,7 +33,7 @@ struct common_audit_data {
 #define LSM_AUDIT_DATA_IPC      4
 #define LSM_AUDIT_DATA_TASK     5
 #define LSM_AUDIT_DATA_KEY      6
-#define LSM_AUDIT_NO_AUDIT      7
+#define LSM_AUDIT_DATA_NONE     7
 #define LSM_AUDIT_DATA_KMOD     8
         struct task_struct *tsk;
         union   {
diff --git a/include/linux/meye.h b/include/linux/meye.h
index 12010ace1f04..0dd49954f746 100644
--- a/include/linux/meye.h
+++ b/include/linux/meye.h
@@ -44,17 +44,17 @@ struct meye_params {
 };
 
 /* query the extended parameters */
-#define MEYEIOC_G_PARAMS        _IOR ('v', BASE_VIDIOCPRIVATE+0, struct meye_params)
+#define MEYEIOC_G_PARAMS        _IOR ('v', BASE_VIDIOC_PRIVATE+0, struct meye_params)
 /* set the extended parameters */
-#define MEYEIOC_S_PARAMS        _IOW ('v', BASE_VIDIOCPRIVATE+1, struct meye_params)
+#define MEYEIOC_S_PARAMS        _IOW ('v', BASE_VIDIOC_PRIVATE+1, struct meye_params)
 /* queue a buffer for mjpeg capture */
-#define MEYEIOC_QBUF_CAPT       _IOW ('v', BASE_VIDIOCPRIVATE+2, int)
+#define MEYEIOC_QBUF_CAPT       _IOW ('v', BASE_VIDIOC_PRIVATE+2, int)
 /* sync a previously queued mjpeg buffer */
-#define MEYEIOC_SYNC            _IOWR('v', BASE_VIDIOCPRIVATE+3, int)
+#define MEYEIOC_SYNC            _IOWR('v', BASE_VIDIOC_PRIVATE+3, int)
 /* get a still uncompressed snapshot */
-#define MEYEIOC_STILLCAPT       _IO  ('v', BASE_VIDIOCPRIVATE+4)
+#define MEYEIOC_STILLCAPT       _IO  ('v', BASE_VIDIOC_PRIVATE+4)
 /* get a jpeg compressed snapshot */
-#define MEYEIOC_STILLJCAPT      _IOR ('v', BASE_VIDIOCPRIVATE+5, int)
+#define MEYEIOC_STILLJCAPT      _IOR ('v', BASE_VIDIOC_PRIVATE+5, int)
 
 /* V4L2 private controls */
 #define V4L2_CID_AGC            V4L2_CID_PRIVATE_BASE
diff --git a/include/linux/mfd/davinci_voicecodec.h b/include/linux/mfd/davinci_voicecodec.h
new file mode 100644
index 000000000000..0ab61320ffa8
--- /dev/null
+++ b/include/linux/mfd/davinci_voicecodec.h
@@ -0,0 +1,126 @@
+/*
+ * DaVinci Voice Codec Core Interface for TI platforms
+ *
+ * Copyright (C) 2010 Texas Instruments, Inc
+ *
+ * Author: Miguel Aguilar <miguel.aguilar@ridgerun.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef __LINUX_MFD_DAVINCI_VOICECODEC_H_
+#define __LINUX_MFD_DAVINIC_VOICECODEC_H_
+
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/core.h>
+
+#include <mach/edma.h>
+
+/*
+ * Register values.
+ */
+#define DAVINCI_VC_PID                  0x00
+#define DAVINCI_VC_CTRL                 0x04
+#define DAVINCI_VC_INTEN                0x08
+#define DAVINCI_VC_INTSTATUS            0x0c
+#define DAVINCI_VC_INTCLR               0x10
+#define DAVINCI_VC_EMUL_CTRL            0x14
+#define DAVINCI_VC_RFIFO                0x20
+#define DAVINCI_VC_WFIFO                0x24
+#define DAVINCI_VC_FIFOSTAT             0x28
+#define DAVINCI_VC_TST_CTRL             0x2C
+#define DAVINCI_VC_REG05                0x94
+#define DAVINCI_VC_REG09                0xA4
+#define DAVINCI_VC_REG12                0xB0
+
+/* DAVINCI_VC_CTRL bit fields */
+#define DAVINCI_VC_CTRL_MASK            0x5500
+#define DAVINCI_VC_CTRL_RSTADC          BIT(0)
+#define DAVINCI_VC_CTRL_RSTDAC          BIT(1)
+#define DAVINCI_VC_CTRL_RD_BITS_8       BIT(4)
+#define DAVINCI_VC_CTRL_RD_UNSIGNED     BIT(5)
+#define DAVINCI_VC_CTRL_WD_BITS_8       BIT(6)
+#define DAVINCI_VC_CTRL_WD_UNSIGNED     BIT(7)
+#define DAVINCI_VC_CTRL_RFIFOEN         BIT(8)
+#define DAVINCI_VC_CTRL_RFIFOCL         BIT(9)
+#define DAVINCI_VC_CTRL_RFIFOMD_WORD_1  BIT(10)
+#define DAVINCI_VC_CTRL_WFIFOEN         BIT(12)
+#define DAVINCI_VC_CTRL_WFIFOCL         BIT(13)
+#define DAVINCI_VC_CTRL_WFIFOMD_WORD_1  BIT(14)
+
+/* DAVINCI_VC_INT bit fields */
+#define DAVINCI_VC_INT_MASK             0x3F
+#define DAVINCI_VC_INT_RDRDY_MASK       BIT(0)
+#define DAVINCI_VC_INT_RERROVF_MASK     BIT(1)
+#define DAVINCI_VC_INT_RERRUDR_MASK     BIT(2)
+#define DAVINCI_VC_INT_WDREQ_MASK       BIT(3)
+#define DAVINCI_VC_INT_WERROVF_MASKBIT  BIT(4)
+#define DAVINCI_VC_INT_WERRUDR_MASK     BIT(5)
+
+/* DAVINCI_VC_REG05 bit fields */
+#define DAVINCI_VC_REG05_PGA_GAIN       0x07
+
+/* DAVINCI_VC_REG09 bit fields */
+#define DAVINCI_VC_REG09_MUTE           0x40
+#define DAVINCI_VC_REG09_DIG_ATTEN      0x3F
+
+/* DAVINCI_VC_REG12 bit fields */
+#define DAVINCI_VC_REG12_POWER_ALL_ON   0xFD
+#define DAVINCI_VC_REG12_POWER_ALL_OFF  0x00
+
+#define DAVINCI_VC_CELLS                2
+
+enum davinci_vc_cells {
+        DAVINCI_VC_VCIF_CELL,
+        DAVINCI_VC_CQ93VC_CELL,
+};
+
+struct davinci_vcif {
+        struct platform_device  *pdev;
+        u32 dma_tx_channel;
+        u32 dma_rx_channel;
+        dma_addr_t dma_tx_addr;
+        dma_addr_t dma_rx_addr;
+};
+
+struct cq93vc {
+        struct platform_device *pdev;
+        struct snd_soc_codec *codec;
+        u32 sysclk;
+};
+
+struct davinci_vc;
+
+struct davinci_vc {
+        /* Device data */
+        struct device *dev;
+        struct platform_device *pdev;
+        struct clk *clk;
+
+        /* Memory resources */
+        void __iomem *base;
+        resource_size_t pbase;
+        size_t base_size;
+
+        /* MFD cells */
+        struct mfd_cell cells[DAVINCI_VC_CELLS];
+
+        /* Client devices */
+        struct davinci_vcif davinci_vcif;
+        struct cq93vc cq93vc;
+};
+
+#endif
diff --git a/include/linux/mfd/wm8350/audio.h b/include/linux/mfd/wm8350/audio.h
index d899dc0223ba..a95141eafce3 100644
--- a/include/linux/mfd/wm8350/audio.h
+++ b/include/linux/mfd/wm8350/audio.h
@@ -492,6 +492,8 @@
  */
 #define WM8350_JACK_L_LVL                       0x0800
 #define WM8350_JACK_R_LVL                       0x0400
+#define WM8350_JACK_MICSCD_LVL                  0x0200
+#define WM8350_JACK_MICSD_LVL                   0x0100
 
 /*
  * WM8350 Platform setup
diff --git a/include/linux/mfd/wm8994/core.h b/include/linux/mfd/wm8994/core.h
index b06ff2846748..de79baee4925 100644
--- a/include/linux/mfd/wm8994/core.h
+++ b/include/linux/mfd/wm8994/core.h
@@ -15,14 +15,38 @@
 #ifndef __MFD_WM8994_CORE_H__
 #define __MFD_WM8994_CORE_H__
 
+#include <linux/interrupt.h>
+
 struct regulator_dev;
 struct regulator_bulk_data;
 
 #define WM8994_NUM_GPIO_REGS 11
-#define WM8994_NUM_LDO_REGS 2
+#define WM8994_NUM_LDO_REGS   2
+#define WM8994_NUM_IRQ_REGS   2
+
+#define WM8994_IRQ_TEMP_SHUT            0
+#define WM8994_IRQ_MIC1_DET             1
+#define WM8994_IRQ_MIC1_SHRT            2
+#define WM8994_IRQ_MIC2_DET             3
+#define WM8994_IRQ_MIC2_SHRT            4
+#define WM8994_IRQ_FLL1_LOCK            5
+#define WM8994_IRQ_FLL2_LOCK            6
+#define WM8994_IRQ_SRC1_LOCK            7
+#define WM8994_IRQ_SRC2_LOCK            8
+#define WM8994_IRQ_AIF1DRC1_SIG_DET     9
+#define WM8994_IRQ_AIF1DRC2_SIG_DET     10
+#define WM8994_IRQ_AIF2DRC_SIG_DET      11
+#define WM8994_IRQ_FIFOS_ERR            12
+#define WM8994_IRQ_WSEQ_DONE            13
+#define WM8994_IRQ_DCS_DONE             14
+#define WM8994_IRQ_TEMP_WARN            15
+
+/* GPIOs in the chip are numbered from 1-11 */
+#define WM8994_IRQ_GPIO(x) (x + WM8994_IRQ_TEMP_WARN)
 
 struct wm8994 {
         struct mutex io_lock;
+        struct mutex irq_lock;
 
         struct device *dev;
         int (*read_dev)(struct wm8994 *wm8994, unsigned short reg,
@@ -33,6 +57,11 @@ struct wm8994 {
         void *control_data;
 
         int gpio_base;
+        int irq_base;
+
+        int irq;
+        u16 irq_masks_cur[WM8994_NUM_IRQ_REGS];
+        u16 irq_masks_cache[WM8994_NUM_IRQ_REGS];
 
         /* Used over suspend/resume */
         u16 ldo_regs[WM8994_NUM_LDO_REGS];
@@ -51,4 +80,26 @@ int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
 int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
                      int count, u16 *buf);
 
+
+/* Helper to save on boilerplate */
+static inline int wm8994_request_irq(struct wm8994 *wm8994, int irq,
+                                     irq_handler_t handler, const char *name,
+                                     void *data)
+{
+        if (!wm8994->irq_base)
+                return -EINVAL;
+        return request_threaded_irq(wm8994->irq_base + irq, NULL, handler,
+                                    IRQF_TRIGGER_RISING, name,
+                                    data);
+}
+static inline void wm8994_free_irq(struct wm8994 *wm8994, int irq, void *data)
+{
+        if (!wm8994->irq_base)
+                return;
+        free_irq(wm8994->irq_base + irq, data);
+}
+
+int wm8994_irq_init(struct wm8994 *wm8994);
+void wm8994_irq_exit(struct wm8994 *wm8994);
+
 #endif
diff --git a/include/linux/mfd/wm8994/pdata.h b/include/linux/mfd/wm8994/pdata.h
index 70d6a8687dc5..5c51f367c061 100644
--- a/include/linux/mfd/wm8994/pdata.h
+++ b/include/linux/mfd/wm8994/pdata.h
@@ -70,6 +70,7 @@ struct wm8994_pdata {
 
         struct wm8994_ldo_pdata ldo[WM8994_NUM_LDO];
 
+        int irq_base;  /** Base IRQ number for WM8994, required for IRQs */
 
         int num_drc_cfgs;
         struct wm8994_drc_cfg *drc_cfgs;
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index e92d1bfdb330..7a7f9c1e679a 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -123,8 +123,8 @@ enum {
         MLX4_OPCODE_RDMA_READ           = 0x10,
         MLX4_OPCODE_ATOMIC_CS           = 0x11,
         MLX4_OPCODE_ATOMIC_FA           = 0x12,
-        MLX4_OPCODE_ATOMIC_MASK_CS      = 0x14,
-        MLX4_OPCODE_ATOMIC_MASK_FA      = 0x15,
+        MLX4_OPCODE_MASKED_ATOMIC_CS    = 0x14,
+        MLX4_OPCODE_MASKED_ATOMIC_FA    = 0x15,
         MLX4_OPCODE_BIND_MW             = 0x18,
         MLX4_OPCODE_FMR                 = 0x19,
         MLX4_OPCODE_LOCAL_INVAL         = 0x1b,
diff --git a/include/linux/mlx4/qp.h b/include/linux/mlx4/qp.h
index 9f29d86e5dc9..7abe64326f72 100644
--- a/include/linux/mlx4/qp.h
+++ b/include/linux/mlx4/qp.h
@@ -285,6 +285,13 @@ struct mlx4_wqe_atomic_seg {
         __be64                  compare;
 };
 
+struct mlx4_wqe_masked_atomic_seg {
+        __be64                  swap_add;
+        __be64                  compare;
+        __be64                  swap_add_mask;
+        __be64                  compare_mask;
+};
+
 struct mlx4_wqe_data_seg {
         __be32                  byte_count;
         __be32                  lkey;
diff --git a/include/linux/mmc/sdio.h b/include/linux/mmc/sdio.h
index 0ebaef577ff5..329a8faa6e37 100644
--- a/include/linux/mmc/sdio.h
+++ b/include/linux/mmc/sdio.h
@@ -94,6 +94,8 @@
 
 #define  SDIO_BUS_WIDTH_1BIT    0x00
 #define  SDIO_BUS_WIDTH_4BIT    0x02
+#define  SDIO_BUS_ECSI          0x20    /* Enable continuous SPI interrupt */
+#define  SDIO_BUS_SCSI          0x40    /* Support continuous SPI interrupt */
 
 #define  SDIO_BUS_ASYNC_INT     0x20
 
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 56fde4364e4c..48c007dae476 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -474,6 +474,32 @@ struct platform_device_id {
                         __attribute__((aligned(sizeof(kernel_ulong_t))));
 };
 
+#define MDIO_MODULE_PREFIX      "mdio:"
+
+#define MDIO_ID_FMT "%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d"
+#define MDIO_ID_ARGS(_id) \
+        (_id)>>31, ((_id)>>30) & 1, ((_id)>>29) & 1, ((_id)>>28) & 1,   \
+        ((_id)>>27) & 1, ((_id)>>26) & 1, ((_id)>>25) & 1, ((_id)>>24) & 1, \
+        ((_id)>>23) & 1, ((_id)>>22) & 1, ((_id)>>21) & 1, ((_id)>>20) & 1, \
+        ((_id)>>19) & 1, ((_id)>>18) & 1, ((_id)>>17) & 1, ((_id)>>16) & 1, \
+        ((_id)>>15) & 1, ((_id)>>14) & 1, ((_id)>>13) & 1, ((_id)>>12) & 1, \
+        ((_id)>>11) & 1, ((_id)>>10) & 1, ((_id)>>9) & 1, ((_id)>>8) & 1, \
+        ((_id)>>7) & 1, ((_id)>>6) & 1, ((_id)>>5) & 1, ((_id)>>4) & 1, \
+        ((_id)>>3) & 1, ((_id)>>2) & 1, ((_id)>>1) & 1, (_id) & 1
+
+/**
+ * struct mdio_device_id - identifies PHY devices on an MDIO/MII bus
+ * @phy_id: The result of
+ *     (mdio_read(&MII_PHYSID1) << 16 | mdio_read(&PHYSID2)) & @phy_id_mask
+ *     for this PHY type
+ * @phy_id_mask: Defines the significant bits of @phy_id.  A value of 0
+ *     is used to terminate an array of struct mdio_device_id.
+ */
+struct mdio_device_id {
+        __u32 phy_id;
+        __u32 phy_id_mask;
+};
+
 struct zorro_device_id {
         __u32 id;                       /* Device ID or ZORRO_WILDCARD */
         kernel_ulong_t driver_data;     /* Data private to the driver */
@@ -483,4 +509,11 @@ struct zorro_device_id {
 
 #define ZORRO_DEVICE_MODALIAS_FMT       "zorro:i%08X"
 
+#define ISAPNP_ANY_ID           0xffff
+struct isapnp_device_id {
+        unsigned short card_vendor, card_device;
+        unsigned short vendor, function;
+        kernel_ulong_t driver_data;     /* data private to the driver */
+};
+
 #endif /* LINUX_MOD_DEVICETABLE_H */
diff --git a/include/linux/mroute.h b/include/linux/mroute.h
index c5f3d53548e2..fa04b246c9ae 100644
--- a/include/linux/mroute.h
+++ b/include/linux/mroute.h
@@ -27,7 +27,8 @@
 #define MRT_DEL_MFC     (MRT_BASE+5)    /* Delete a multicast forwarding entry  */
 #define MRT_VERSION     (MRT_BASE+6)    /* Get the kernel multicast version     */
 #define MRT_ASSERT      (MRT_BASE+7)    /* Activate PIM assert mode             */
-#define MRT_PIM         (MRT_BASE+8)    /* enable PIM code      */
+#define MRT_PIM         (MRT_BASE+8)    /* enable PIM code                      */
+#define MRT_TABLE       (MRT_BASE+9)    /* Specify mroute table ID              */
 
 #define SIOCGETVIFCNT   SIOCPROTOPRIVATE        /* IP protocol privates */
 #define SIOCGETSGCNT    (SIOCPROTOPRIVATE+1)
@@ -191,10 +192,7 @@ struct vif_device {
 #define VIFF_STATIC 0x8000
 
 struct mfc_cache {
-        struct mfc_cache *next;                 /* Next entry on cache line     */
-#ifdef CONFIG_NET_NS
-        struct net *mfc_net;
-#endif
+        struct list_head list;
         __be32 mfc_mcastgrp;                    /* Group the entry belongs to   */
         __be32 mfc_origin;                      /* Source of packet             */
         vifi_t mfc_parent;                      /* Source interface             */
@@ -217,18 +215,6 @@ struct mfc_cache {
         } mfc_un;
 };
 
-static inline
-struct net *mfc_net(const struct mfc_cache *mfc)
-{
-        return read_pnet(&mfc->mfc_net);
-}
-
-static inline
-void mfc_net_set(struct mfc_cache *mfc, struct net *net)
-{
-        write_pnet(&mfc->mfc_net, hold_net(net));
-}
-
 #define MFC_STATIC              1
 #define MFC_NOTIFY              2
 
diff --git a/include/linux/mroute6.h b/include/linux/mroute6.h
index 2caa1a8e525d..6091ab77f388 100644
--- a/include/linux/mroute6.h
+++ b/include/linux/mroute6.h
@@ -24,7 +24,8 @@
 #define MRT6_DEL_MFC    (MRT6_BASE+5)   /* Delete a multicast forwarding entry  */
 #define MRT6_VERSION    (MRT6_BASE+6)   /* Get the kernel multicast version     */
 #define MRT6_ASSERT     (MRT6_BASE+7)   /* Activate PIM assert mode             */
-#define MRT6_PIM        (MRT6_BASE+8)   /* enable PIM code      */
+#define MRT6_PIM        (MRT6_BASE+8)   /* enable PIM code                      */
+#define MRT6_TABLE      (MRT6_BASE+9)   /* Specify mroute table ID              */
 
 #define SIOCGETMIFCNT_IN6       SIOCPROTOPRIVATE        /* IP protocol privates */
 #define SIOCGETSGCNT_IN6        (SIOCPROTOPRIVATE+1)
@@ -182,10 +183,7 @@ struct mif_device {
 #define VIFF_STATIC 0x8000
 
 struct mfc6_cache {
-        struct mfc6_cache *next;                /* Next entry on cache line     */
-#ifdef CONFIG_NET_NS
-        struct net *mfc6_net;
-#endif
+        struct list_head list;
         struct in6_addr mf6c_mcastgrp;                  /* Group the entry belongs to   */
         struct in6_addr mf6c_origin;                    /* Source of packet             */
         mifi_t mf6c_parent;                     /* Source interface             */
@@ -208,18 +206,6 @@ struct mfc6_cache {
         } mfc_un;
 };
 
-static inline
-struct net *mfc6_net(const struct mfc6_cache *mfc)
-{
-        return read_pnet(&mfc->mfc6_net);
-}
-
-static inline
-void mfc6_net_set(struct mfc6_cache *mfc, struct net *net)
-{
-        write_pnet(&mfc->mfc6_net, hold_net(net));
-}
-
 #define MFC_STATIC              1
 #define MFC_NOTIFY              2
 
@@ -244,14 +230,17 @@ extern int ip6mr_get_route(struct net *net, struct sk_buff *skb,
                            struct rtmsg *rtm, int nowait);
 
 #ifdef CONFIG_IPV6_MROUTE
-static inline struct sock *mroute6_socket(struct net *net)
-{
-        return net->ipv6.mroute6_sk;
-}
+extern struct sock *mroute6_socket(struct net *net, struct sk_buff *skb);
 extern int ip6mr_sk_done(struct sock *sk);
 #else
-static inline struct sock *mroute6_socket(struct net *net) { return NULL; }
-static inline int ip6mr_sk_done(struct sock *sk) { return 0; }
+static inline struct sock *mroute6_socket(struct net *net, struct sk_buff *skb)
+{
+        return NULL;
+}
+static inline int ip6mr_sk_done(struct sock *sk)
+{
+        return 0;
+}
 #endif
 #endif
 
diff --git a/include/linux/msm_mdp.h b/include/linux/msm_mdp.h
new file mode 100644
index 000000000000..d11fe0f2f956
--- /dev/null
+++ b/include/linux/msm_mdp.h
@@ -0,0 +1,78 @@
+/* include/linux/msm_mdp.h
+ *
+ * Copyright (C) 2007 Google Incorporated
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#ifndef _MSM_MDP_H_
+#define _MSM_MDP_H_
+
+#include <linux/types.h>
+
+#define MSMFB_IOCTL_MAGIC 'm'
+#define MSMFB_GRP_DISP          _IOW(MSMFB_IOCTL_MAGIC, 1, unsigned int)
+#define MSMFB_BLIT              _IOW(MSMFB_IOCTL_MAGIC, 2, unsigned int)
+
+enum {
+        MDP_RGB_565,            /* RGB 565 planar */
+        MDP_XRGB_8888,          /* RGB 888 padded */
+        MDP_Y_CBCR_H2V2,        /* Y and CbCr, pseudo planar w/ Cb is in MSB */
+        MDP_ARGB_8888,          /* ARGB 888 */
+        MDP_RGB_888,            /* RGB 888 planar */
+        MDP_Y_CRCB_H2V2,        /* Y and CrCb, pseudo planar w/ Cr is in MSB */
+        MDP_YCRYCB_H2V1,        /* YCrYCb interleave */
+        MDP_Y_CRCB_H2V1,        /* Y and CrCb, pseduo planar w/ Cr is in MSB */
+        MDP_Y_CBCR_H2V1,        /* Y and CrCb, pseduo planar w/ Cr is in MSB */
+        MDP_RGBA_8888,          /* ARGB 888 */
+        MDP_BGRA_8888,          /* ABGR 888 */
+        MDP_IMGTYPE_LIMIT       /* Non valid image type after this enum */
+};
+
+enum {
+        PMEM_IMG,
+        FB_IMG,
+};
+
+/* flag values */
+#define MDP_ROT_NOP     0
+#define MDP_FLIP_LR     0x1
+#define MDP_FLIP_UD     0x2
+#define MDP_ROT_90      0x4
+#define MDP_ROT_180     (MDP_FLIP_UD|MDP_FLIP_LR)
+#define MDP_ROT_270     (MDP_ROT_90|MDP_FLIP_UD|MDP_FLIP_LR)
+#define MDP_DITHER      0x8
+#define MDP_BLUR        0x10
+
+#define MDP_TRANSP_NOP  0xffffffff
+#define MDP_ALPHA_NOP   0xff
+
+struct mdp_rect {
+        u32 x, y, w, h;
+};
+
+struct mdp_img {
+        u32 width, height, format, offset;
+        int memory_id;          /* the file descriptor */
+};
+
+struct mdp_blit_req {
+        struct mdp_img src;
+        struct mdp_img dst;
+        struct mdp_rect src_rect;
+        struct mdp_rect dst_rect;
+        u32 alpha, transp_mask, flags;
+};
+
+struct mdp_blit_req_list {
+        u32 count;
+        struct mdp_blit_req req[];
+};
+
+#endif /* _MSM_MDP_H_ */
diff --git a/include/linux/mtd/blktrans.h b/include/linux/mtd/blktrans.h
index 8b4aa0523db7..b481ccd7ff3c 100644
--- a/include/linux/mtd/blktrans.h
+++ b/include/linux/mtd/blktrans.h
@@ -9,6 +9,8 @@
 #define __MTD_TRANS_H__
 
 #include <linux/mutex.h>
+#include <linux/kref.h>
+#include <linux/sysfs.h>
 
 struct hd_geometry;
 struct mtd_info;
@@ -24,11 +26,16 @@ struct mtd_blktrans_dev {
         int devnum;
         unsigned long size;
         int readonly;
-        void *blkcore_priv; /* gendisk in 2.5, devfs_handle in 2.4 */
+        int open;
+        struct kref ref;
+        struct gendisk *disk;
+        struct attribute_group *disk_attributes;
+        struct task_struct *thread;
+        struct request_queue *rq;
+        spinlock_t queue_lock;
+        void *priv;
 };
 
-struct blkcore_priv; /* Differs for 2.4 and 2.5 kernels; private */
-
 struct mtd_blktrans_ops {
         char *name;
         int major;
@@ -60,8 +67,6 @@ struct mtd_blktrans_ops {
         struct list_head devs;
         struct list_head list;
         struct module *owner;
-
-        struct mtd_blkcore_priv *blkcore_priv;
 };
 
 extern int register_mtd_blktrans(struct mtd_blktrans_ops *tr);
diff --git a/include/linux/mtd/cfi.h b/include/linux/mtd/cfi.h
index df89f4275232..574d9ee066f1 100644
--- a/include/linux/mtd/cfi.h
+++ b/include/linux/mtd/cfi.h
@@ -253,6 +253,7 @@ struct cfi_bri_query {
 #define P_ID_MITSUBISHI_STD     0x0100
 #define P_ID_MITSUBISHI_EXT     0x0101
 #define P_ID_SST_PAGE           0x0102
+#define P_ID_SST_OLD            0x0701
 #define P_ID_INTEL_PERFORMANCE  0x0200
 #define P_ID_INTEL_DATA         0x0210
 #define P_ID_RESERVED           0xffff
@@ -297,7 +298,7 @@ static inline uint32_t cfi_build_cmd_addr(uint32_t cmd_ofs,
          * and 32bit devices on 16 bit busses
          * set the low bit of the alternating bit sequence of the address.
          */
-        if (((type * interleave) > bankwidth) && ((uint8_t)cmd_ofs == 0xaa))
+        if (((type * interleave) > bankwidth) && ((cmd_ofs & 0xff) == 0xaa))
                 addr |= (type >> 1)*interleave;
 
         return  addr;
@@ -515,14 +516,25 @@ struct cfi_fixup {
         void* param;
 };
 
-#define CFI_MFR_ANY 0xffff
-#define CFI_ID_ANY  0xffff
-
-#define CFI_MFR_AMD     0x0001
-#define CFI_MFR_INTEL   0x0089
-#define CFI_MFR_ATMEL   0x001F
-#define CFI_MFR_SAMSUNG 0x00EC
-#define CFI_MFR_ST      0x0020 /* STMicroelectronics */
+#define CFI_MFR_ANY             0xFFFF
+#define CFI_ID_ANY              0xFFFF
+#define CFI_MFR_CONTINUATION    0x007F
+
+#define CFI_MFR_AMD             0x0001
+#define CFI_MFR_ATMEL           0x001F
+#define CFI_MFR_EON             0x001C
+#define CFI_MFR_FUJITSU         0x0004
+#define CFI_MFR_HYUNDAI         0x00AD
+#define CFI_MFR_INTEL           0x0089
+#define CFI_MFR_MACRONIX        0x00C2
+#define CFI_MFR_NEC             0x0010
+#define CFI_MFR_PMC             0x009D
+#define CFI_MFR_SAMSUNG         0x00EC
+#define CFI_MFR_SHARP           0x00B0
+#define CFI_MFR_SST             0x00BF
+#define CFI_MFR_ST              0x0020 /* STMicroelectronics */
+#define CFI_MFR_TOSHIBA         0x0098
+#define CFI_MFR_WINBOND         0x00DA
 
 void cfi_fixup(struct mtd_info *mtd, struct cfi_fixup* fixups);
 
diff --git a/include/linux/mtd/flashchip.h b/include/linux/mtd/flashchip.h
index d0bf422ae374..f43e9b49b751 100644
--- a/include/linux/mtd/flashchip.h
+++ b/include/linux/mtd/flashchip.h
@@ -15,6 +15,7 @@
  * has asm/spinlock.h, or 2.4, which has linux/spinlock.h
  */
 #include <linux/sched.h>
+#include <linux/mutex.h>
 
 typedef enum {
         FL_READY,
@@ -74,8 +75,7 @@ struct flchip {
         unsigned int erase_suspended:1;
         unsigned long in_progress_block_addr;
 
-        spinlock_t *mutex;
-        spinlock_t _spinlock; /* We do it like this because sometimes they'll be shared. */
+        struct mutex mutex;
         wait_queue_head_t wq; /* Wait on here when we're waiting for the chip
                              to be ready */
         int word_write_time;
diff --git a/include/linux/mtd/map.h b/include/linux/mtd/map.h
index b981b8772217..de89eca864ce 100644
--- a/include/linux/mtd/map.h
+++ b/include/linux/mtd/map.h
@@ -7,6 +7,7 @@
 #include <linux/types.h>
 #include <linux/list.h>
 #include <linux/string.h>
+#include <linux/bug.h>
 
 #include <linux/mtd/compatmac.h>
 
@@ -386,6 +387,8 @@ static inline map_word inline_map_read(struct map_info *map, unsigned long ofs)
 #endif
         else if (map_bankwidth_is_large(map))
                 memcpy_fromio(r.x, map->virt+ofs, map->bankwidth);
+        else
+                BUG();
 
         return r;
 }
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
index 0f32a9b6ff55..5326435a7571 100644
--- a/include/linux/mtd/mtd.h
+++ b/include/linux/mtd/mtd.h
@@ -20,7 +20,6 @@
 
 #define MTD_CHAR_MAJOR 90
 #define MTD_BLOCK_MAJOR 31
-#define MAX_MTD_DEVICES 32
 
 #define MTD_ERASE_PENDING       0x01
 #define MTD_ERASING             0x02
@@ -61,9 +60,7 @@ struct mtd_erase_region_info {
  * MTD_OOB_PLACE:       oob data are placed at the given offset
  * MTD_OOB_AUTO:        oob data are automatically placed at the free areas
  *                      which are defined by the ecclayout
- * MTD_OOB_RAW:         mode to read raw data+oob in one chunk. The oob data
- *                      is inserted into the data. Thats a raw image of the
- *                      flash contents.
+ * MTD_OOB_RAW:         mode to read oob and data without doing ECC checking
  */
 typedef enum {
         MTD_OOB_PLACE,
@@ -290,8 +287,9 @@ extern int add_mtd_device(struct mtd_info *mtd);
 extern int del_mtd_device (struct mtd_info *mtd);
 
 extern struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num);
+extern int __get_mtd_device(struct mtd_info *mtd);
+extern void __put_mtd_device(struct mtd_info *mtd);
 extern struct mtd_info *get_mtd_device_nm(const char *name);
-
 extern void put_mtd_device(struct mtd_info *mtd);
 
 
diff --git a/include/linux/mtd/mtdram.h b/include/linux/mtd/mtdram.h
index 04fdc07b7353..68891313875d 100644
--- a/include/linux/mtd/mtdram.h
+++ b/include/linux/mtd/mtdram.h
@@ -3,6 +3,6 @@
 
 #include <linux/mtd/mtd.h>
 int mtdram_init_device(struct mtd_info *mtd, void *mapped_address,
-                       unsigned long size, char *name);
+                        unsigned long size, char *name);
 
 #endif /* __MTD_MTDRAM_H__ */
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index ccab9dfc5217..a81b185e23a7 100644
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -25,11 +25,13 @@
 #include <linux/mtd/bbm.h>
 
 struct mtd_info;
+struct nand_flash_dev;
 /* Scan and identify a NAND device */
 extern int nand_scan (struct mtd_info *mtd, int max_chips);
 /* Separate phases of nand_scan(), allowing board driver to intervene
  * and override command or ECC setup according to flash type */
-extern int nand_scan_ident(struct mtd_info *mtd, int max_chips);
+extern int nand_scan_ident(struct mtd_info *mtd, int max_chips,
+                           struct nand_flash_dev *table);
 extern int nand_scan_tail(struct mtd_info *mtd);
 
 /* Free resources held by the NAND device */
@@ -38,6 +40,12 @@ extern void nand_release (struct mtd_info *mtd);
 /* Internal helper for board drivers which need to override command function */
 extern void nand_wait_ready(struct mtd_info *mtd);
 
+/* locks all blockes present in the device */
+extern int nand_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
+
+/* unlocks specified locked blockes */
+extern int nand_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
+
 /* The maximum number of NAND chips in an array */
 #define NAND_MAX_CHIPS          8
 
@@ -45,7 +53,7 @@ extern void nand_wait_ready(struct mtd_info *mtd);
  * is supported now. If you add a chip with bigger oobsize/page
  * adjust this accordingly.
  */
-#define NAND_MAX_OOBSIZE        128
+#define NAND_MAX_OOBSIZE        256
 #define NAND_MAX_PAGESIZE       4096
 
 /*
@@ -82,6 +90,10 @@ extern void nand_wait_ready(struct mtd_info *mtd);
 #define NAND_CMD_ERASE2         0xd0
 #define NAND_CMD_RESET          0xff
 
+#define NAND_CMD_LOCK           0x2a
+#define NAND_CMD_UNLOCK1        0x23
+#define NAND_CMD_UNLOCK2        0x24
+
 /* Extended commands for large page devices */
 #define NAND_CMD_READSTART      0x30
 #define NAND_CMD_RNDOUTSTART    0xE0
@@ -169,6 +181,14 @@ typedef enum {
 #define NAND_NO_READRDY         0x00000100
 /* Chip does not allow subpage writes */
 #define NAND_NO_SUBPAGE_WRITE   0x00000200
+/* Chip stores bad block marker on the last page of the eraseblock */
+#define NAND_BB_LAST_PAGE       0x00000400
+
+/* Device is one of 'new' xD cards that expose fake nand command set */
+#define NAND_BROKEN_XD          0x00000400
+
+/* Device behaves just like nand, but is readonly */
+#define NAND_ROM                0x00000800
 
 /* Options valid for Samsung large page devices */
 #define NAND_SAMSUNG_LP_OPTIONS \
@@ -391,6 +411,7 @@ struct nand_chip {
         int             subpagesize;
         uint8_t         cellinfo;
         int             badblockpos;
+        int             badblockbits;
 
         flstate_t       state;
 
diff --git a/include/linux/mtd/onenand.h b/include/linux/mtd/onenand.h
index 5509eb06b326..c26ff86ad08a 100644
--- a/include/linux/mtd/onenand.h
+++ b/include/linux/mtd/onenand.h
@@ -125,6 +125,9 @@ struct onenand_chip {
         flstate_t               state;
         unsigned char           *page_buf;
         unsigned char           *oob_buf;
+#ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE
+        unsigned char           *verify_buf;
+#endif
 
         int                     subpagesize;
         struct nand_ecclayout   *ecclayout;
@@ -175,10 +178,14 @@ struct onenand_chip {
 #define ONENAND_HAS_CONT_LOCK           (0x0001)
 #define ONENAND_HAS_UNLOCK_ALL          (0x0002)
 #define ONENAND_HAS_2PLANE              (0x0004)
+#define ONENAND_HAS_4KB_PAGE            (0x0008)
 #define ONENAND_SKIP_UNLOCK_CHECK       (0x0100)
 #define ONENAND_PAGEBUF_ALLOC           (0x1000)
 #define ONENAND_OOBBUF_ALLOC            (0x2000)
 
+#define ONENAND_IS_4KB_PAGE(this)                                       \
+        (this->options & ONENAND_HAS_4KB_PAGE)
+
 /*
  * OneNAND Flash Manufacturer ID Codes
  */
@@ -205,6 +212,8 @@ struct mtd_partition;
 
 struct onenand_platform_data {
         void            (*mmcontrol)(struct mtd_info *mtd, int sync_read);
+        int             (*read_bufferram)(struct mtd_info *mtd, int area,
+                        unsigned char *buffer, int offset, size_t count);
         struct mtd_partition *parts;
         unsigned int    nr_parts;
 };
diff --git a/include/linux/mtd/sh_flctl.h b/include/linux/mtd/sh_flctl.h
index ab77609ec337..9cf4c4c79555 100644
--- a/include/linux/mtd/sh_flctl.h
+++ b/include/linux/mtd/sh_flctl.h
@@ -93,8 +93,6 @@
 #define INIT_FL4ECCRESULT_VAL   0x03FF03FF
 #define LOOP_TIMEOUT_MAX        0x00010000
 
-#define mtd_to_flctl(mtd)       container_of(mtd, struct sh_flctl, mtd)
-
 struct sh_flctl {
         struct mtd_info         mtd;
         struct nand_chip        chip;
@@ -125,4 +123,9 @@ struct sh_flctl_platform_data {
         unsigned has_hwecc:1;
 };
 
+static inline struct sh_flctl *mtd_to_flctl(struct mtd_info *mtdinfo)
+{
+        return container_of(mtdinfo, struct sh_flctl, mtd);
+}
+
 #endif  /* __SH_FLCTL_H__ */
diff --git a/include/linux/net.h b/include/linux/net.h
index 4157b5d42bd6..2b4deeeb8646 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -59,6 +59,7 @@ typedef enum {
 #include <linux/wait.h>
 #include <linux/fcntl.h>        /* For O_CLOEXEC and O_NONBLOCK */
 #include <linux/kmemcheck.h>
+#include <linux/rcupdate.h>
 
 struct poll_table_struct;
 struct pipe_inode_info;
@@ -116,6 +117,12 @@ enum sock_shutdown_cmd {
         SHUT_RDWR       = 2,
 };
 
+struct socket_wq {
+        wait_queue_head_t       wait;
+        struct fasync_struct    *fasync_list;
+        struct rcu_head         rcu;
+} ____cacheline_aligned_in_smp;
+
 /**
  *  struct socket - general BSD socket
  *  @state: socket state (%SS_CONNECTED, etc)
@@ -135,11 +142,8 @@ struct socket {
         kmemcheck_bitfield_end(type);
 
         unsigned long           flags;
-        /*
-         * Please keep fasync_list & wait fields in the same cache line
-         */
-        struct fasync_struct    *fasync_list;
-        wait_queue_head_t       wait;
+
+        struct socket_wq        *wq;
 
         struct file             *file;
         struct sock             *sk;
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index fa8b47637997..a1bff6518166 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -31,6 +31,7 @@
 #include <linux/if_link.h>
 
 #ifdef __KERNEL__
+#include <linux/pm_qos_params.h>
 #include <linux/timer.h>
 #include <linux/delay.h>
 #include <linux/mm.h>
@@ -218,34 +219,6 @@ struct neighbour;
 struct neigh_parms;
 struct sk_buff;
 
-struct netif_rx_stats {
-        unsigned total;
-        unsigned dropped;
-        unsigned time_squeeze;
-        unsigned cpu_collision;
-};
-
-DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);
-
-struct dev_addr_list {
-        struct dev_addr_list    *next;
-        u8                      da_addr[MAX_ADDR_LEN];
-        u8                      da_addrlen;
-        u8                      da_synced;
-        int                     da_users;
-        int                     da_gusers;
-};
-
-/*
- *      We tag multicasts with these structures.
- */
-
-#define dev_mc_list     dev_addr_list
-#define dmi_addr        da_addr
-#define dmi_addrlen     da_addrlen
-#define dmi_users       da_users
-#define dmi_gusers      da_gusers
-
 struct netdev_hw_addr {
         struct list_head        list;
         unsigned char           addr[MAX_ADDR_LEN];
@@ -254,8 +227,10 @@ struct netdev_hw_addr {
 #define NETDEV_HW_ADDR_T_SAN            2
 #define NETDEV_HW_ADDR_T_SLAVE          3
 #define NETDEV_HW_ADDR_T_UNICAST        4
+#define NETDEV_HW_ADDR_T_MULTICAST      5
         int                     refcount;
         bool                    synced;
+        bool                    global_use;
         struct rcu_head         rcu_head;
 };
 
@@ -264,16 +239,20 @@ struct netdev_hw_addr_list {
         int                     count;
 };
 
-#define netdev_uc_count(dev) ((dev)->uc.count)
-#define netdev_uc_empty(dev) ((dev)->uc.count == 0)
-#define netdev_for_each_uc_addr(ha, dev) \
-        list_for_each_entry(ha, &dev->uc.list, list)
+#define netdev_hw_addr_list_count(l) ((l)->count)
+#define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0)
+#define netdev_hw_addr_list_for_each(ha, l) \
+        list_for_each_entry(ha, &(l)->list, list)
 
-#define netdev_mc_count(dev) ((dev)->mc_count)
-#define netdev_mc_empty(dev) (netdev_mc_count(dev) == 0)
+#define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc)
+#define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc)
+#define netdev_for_each_uc_addr(ha, dev) \
+        netdev_hw_addr_list_for_each(ha, &(dev)->uc)
 
-#define netdev_for_each_mc_addr(mclist, dev) \
-        for (mclist = dev->mc_list; mclist; mclist = mclist->next)
+#define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc)
+#define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc)
+#define netdev_for_each_mc_addr(ha, dev) \
+        netdev_hw_addr_list_for_each(ha, &(dev)->mc)
 
 struct hh_cache {
         struct hh_cache *hh_next;       /* Next entry                        */
@@ -530,6 +509,85 @@ struct netdev_queue {
         unsigned long           tx_dropped;
 } ____cacheline_aligned_in_smp;
 
+#ifdef CONFIG_RPS
+/*
+ * This structure holds an RPS map which can be of variable length.  The
+ * map is an array of CPUs.
+ */
+struct rps_map {
+        unsigned int len;
+        struct rcu_head rcu;
+        u16 cpus[0];
+};
+#define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + (_num * sizeof(u16)))
+
+/*
+ * The rps_dev_flow structure contains the mapping of a flow to a CPU and the
+ * tail pointer for that CPU's input queue at the time of last enqueue.
+ */
+struct rps_dev_flow {
+        u16 cpu;
+        u16 fill;
+        unsigned int last_qtail;
+};
+
+/*
+ * The rps_dev_flow_table structure contains a table of flow mappings.
+ */
+struct rps_dev_flow_table {
+        unsigned int mask;
+        struct rcu_head rcu;
+        struct work_struct free_work;
+        struct rps_dev_flow flows[0];
+};
+#define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \
+    (_num * sizeof(struct rps_dev_flow)))
+
+/*
+ * The rps_sock_flow_table contains mappings of flows to the last CPU
+ * on which they were processed by the application (set in recvmsg).
+ */
+struct rps_sock_flow_table {
+        unsigned int mask;
+        u16 ents[0];
+};
+#define RPS_SOCK_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_sock_flow_table) + \
+    (_num * sizeof(u16)))
+
+#define RPS_NO_CPU 0xffff
+
+static inline void rps_record_sock_flow(struct rps_sock_flow_table *table,
+                                        u32 hash)
+{
+        if (table && hash) {
+                unsigned int cpu, index = hash & table->mask;
+
+                /* We only give a hint, preemption can change cpu under us */
+                cpu = raw_smp_processor_id();
+
+                if (table->ents[index] != cpu)
+                        table->ents[index] = cpu;
+        }
+}
+
+static inline void rps_reset_sock_flow(struct rps_sock_flow_table *table,
+                                       u32 hash)
+{
+        if (table && hash)
+                table->ents[hash & table->mask] = RPS_NO_CPU;
+}
+
+extern struct rps_sock_flow_table *rps_sock_flow_table;
+
+/* This structure contains an instance of an RX queue. */
+struct netdev_rx_queue {
+        struct rps_map *rps_map;
+        struct rps_dev_flow_table *rps_flow_table;
+        struct kobject kobj;
+        struct netdev_rx_queue *first;
+        atomic_t count;
+} ____cacheline_aligned_in_smp;
+#endif /* CONFIG_RPS */
 
 /*
  * This structure defines the management hooks for network devices.
@@ -629,6 +687,9 @@ struct netdev_queue {
  * int (*ndo_set_vf_tx_rate)(struct net_device *dev, int vf, int rate);
  * int (*ndo_get_vf_config)(struct net_device *dev,
  *                          int vf, struct ifla_vf_info *ivf);
+ * int (*ndo_set_vf_port)(struct net_device *dev, int vf,
+ *                        struct nlattr *port[]);
+ * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb);
  */
 #define HAVE_NET_DEVICE_OPS
 struct net_device_ops {
@@ -667,6 +728,7 @@ struct net_device_ops {
                                                         unsigned short vid);
 #ifdef CONFIG_NET_POLL_CONTROLLER
         void                    (*ndo_poll_controller)(struct net_device *dev);
+        void                    (*ndo_netpoll_cleanup)(struct net_device *dev);
 #endif
         int                     (*ndo_set_vf_mac)(struct net_device *dev,
                                                   int queue, u8 *mac);
@@ -677,6 +739,11 @@ struct net_device_ops {
         int                     (*ndo_get_vf_config)(struct net_device *dev,
                                                      int vf,
                                                      struct ifla_vf_info *ivf);
+        int                     (*ndo_set_vf_port)(struct net_device *dev,
+                                                   int vf,
+                                                   struct nlattr *port[]);
+        int                     (*ndo_get_vf_port)(struct net_device *dev,
+                                                   int vf, struct sk_buff *skb);
 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
         int                     (*ndo_fcoe_enable)(struct net_device *dev);
         int                     (*ndo_fcoe_disable)(struct net_device *dev);
@@ -711,6 +778,9 @@ struct net_device {
          * the interface.
          */
         char                    name[IFNAMSIZ];
+
+        struct pm_qos_request_list *pm_qos_req;
+
         /* device name hash chain */
         struct hlist_node       name_hlist;
         /* snmp alias */
@@ -764,6 +834,7 @@ struct net_device {
 #define NETIF_F_SCTP_CSUM       (1 << 25) /* SCTP checksum offload */
 #define NETIF_F_FCOE_MTU        (1 << 26) /* Supports max FCoE MTU, 2158 bytes*/
 #define NETIF_F_NTUPLE          (1 << 27) /* N-tuple filters supported */
+#define NETIF_F_RXHASH          (1 << 28) /* Receive hashing offload */
 
         /* Segmentation offload features */
 #define NETIF_F_GSO_SHIFT       16
@@ -820,7 +891,7 @@ struct net_device {
         unsigned char           operstate; /* RFC2863 operstate */
         unsigned char           link_mode; /* mapping policy to operstate */
 
-        unsigned                mtu;    /* interface MTU value          */
+        unsigned int            mtu;    /* interface MTU value          */
         unsigned short          type;   /* interface hardware type      */
         unsigned short          hard_header_len;        /* hardware hdr length  */
 
@@ -840,12 +911,10 @@ struct net_device {
         unsigned char           addr_len;       /* hardware address length      */
         unsigned short          dev_id;         /* for shared network cards */
 
-        struct netdev_hw_addr_list      uc;     /* Secondary unicast
-                                                   mac addresses */
-        int                     uc_promisc;
         spinlock_t              addr_list_lock;
-        struct dev_addr_list    *mc_list;       /* Multicast mac addresses      */
-        int                     mc_count;       /* Number of installed mcasts   */
+        struct netdev_hw_addr_list      uc;     /* Unicast mac addresses */
+        struct netdev_hw_addr_list      mc;     /* Multicast mac addresses */
+        int                     uc_promisc;
         unsigned int            promiscuity;
         unsigned int            allmulti;
 
@@ -878,6 +947,15 @@ struct net_device {
 
         unsigned char           broadcast[MAX_ADDR_LEN];        /* hw bcast add */
 
+#ifdef CONFIG_RPS
+        struct kset             *queues_kset;
+
+        struct netdev_rx_queue  *_rx;
+
+        /* Number of RX queues allocated at alloc_netdev_mq() time  */
+        unsigned int            num_rx_queues;
+#endif
+
         struct netdev_queue     rx_queue;
 
         struct netdev_queue     *_tx ____cacheline_aligned_in_smp;
@@ -1306,19 +1384,44 @@ static inline int unregister_gifconf(unsigned int family)
 }
 
 /*
- * Incoming packets are placed on per-cpu queues so that
- * no locking is needed.
+ * Incoming packets are placed on per-cpu queues
  */
 struct softnet_data {
         struct Qdisc            *output_queue;
-        struct sk_buff_head     input_pkt_queue;
+        struct Qdisc            **output_queue_tailp;
         struct list_head        poll_list;
         struct sk_buff          *completion_queue;
-
+        struct sk_buff_head     process_queue;
+
+        /* stats */
+        unsigned int            processed;
+        unsigned int            time_squeeze;
+        unsigned int            cpu_collision;
+        unsigned int            received_rps;
+
+#ifdef CONFIG_RPS
+        struct softnet_data     *rps_ipi_list;
+
+        /* Elements below can be accessed between CPUs for RPS */
+        struct call_single_data csd ____cacheline_aligned_in_smp;
+        struct softnet_data     *rps_ipi_next;
+        unsigned int            cpu;
+        unsigned int            input_queue_head;
+#endif
+        unsigned                dropped;
+        struct sk_buff_head     input_pkt_queue;
         struct napi_struct      backlog;
 };
 
-DECLARE_PER_CPU(struct softnet_data,softnet_data);
+static inline void input_queue_head_add(struct softnet_data *sd,
+                                        unsigned int len)
+{
+#ifdef CONFIG_RPS
+        sd->input_queue_head += len;
+#endif
+}
+
+DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
 
 #define HAVE_NETIF_QUEUE
 
@@ -1945,6 +2048,22 @@ extern struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
 extern int              register_netdev(struct net_device *dev);
 extern void             unregister_netdev(struct net_device *dev);
 
+/* General hardware address lists handling functions */
+extern int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
+                                  struct netdev_hw_addr_list *from_list,
+                                  int addr_len, unsigned char addr_type);
+extern void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
+                                   struct netdev_hw_addr_list *from_list,
+                                   int addr_len, unsigned char addr_type);
+extern int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
+                          struct netdev_hw_addr_list *from_list,
+                          int addr_len);
+extern void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
+                             struct netdev_hw_addr_list *from_list,
+                             int addr_len);
+extern void __hw_addr_flush(struct netdev_hw_addr_list *list);
+extern void __hw_addr_init(struct netdev_hw_addr_list *list);
+
 /* Functions used for device addresses handling */
 extern int dev_addr_add(struct net_device *dev, unsigned char *addr,
                         unsigned char addr_type);
@@ -1956,26 +2075,34 @@ extern int dev_addr_add_multiple(struct net_device *to_dev,
 extern int dev_addr_del_multiple(struct net_device *to_dev,
                                  struct net_device *from_dev,
                                  unsigned char addr_type);
+extern void dev_addr_flush(struct net_device *dev);
+extern int dev_addr_init(struct net_device *dev);
+
+/* Functions used for unicast addresses handling */
+extern int dev_uc_add(struct net_device *dev, unsigned char *addr);
+extern int dev_uc_del(struct net_device *dev, unsigned char *addr);
+extern int dev_uc_sync(struct net_device *to, struct net_device *from);
+extern void dev_uc_unsync(struct net_device *to, struct net_device *from);
+extern void dev_uc_flush(struct net_device *dev);
+extern void dev_uc_init(struct net_device *dev);
+
+/* Functions used for multicast addresses handling */
+extern int dev_mc_add(struct net_device *dev, unsigned char *addr);
+extern int dev_mc_add_global(struct net_device *dev, unsigned char *addr);
+extern int dev_mc_del(struct net_device *dev, unsigned char *addr);
+extern int dev_mc_del_global(struct net_device *dev, unsigned char *addr);
+extern int dev_mc_sync(struct net_device *to, struct net_device *from);
+extern void dev_mc_unsync(struct net_device *to, struct net_device *from);
+extern void dev_mc_flush(struct net_device *dev);
+extern void dev_mc_init(struct net_device *dev);
 
 /* Functions used for secondary unicast and multicast support */
 extern void             dev_set_rx_mode(struct net_device *dev);
 extern void             __dev_set_rx_mode(struct net_device *dev);
-extern int              dev_unicast_delete(struct net_device *dev, void *addr);
-extern int              dev_unicast_add(struct net_device *dev, void *addr);
-extern int              dev_unicast_sync(struct net_device *to, struct net_device *from);
-extern void             dev_unicast_unsync(struct net_device *to, struct net_device *from);
-extern int              dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
-extern int              dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
-extern int              dev_mc_sync(struct net_device *to, struct net_device *from);
-extern void             dev_mc_unsync(struct net_device *to, struct net_device *from);
-extern int              __dev_addr_delete(struct dev_addr_list **list, int *count, void *addr, int alen, int all);
-extern int              __dev_addr_add(struct dev_addr_list **list, int *count, void *addr, int alen, int newonly);
-extern int              __dev_addr_sync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);
-extern void             __dev_addr_unsync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);
 extern int              dev_set_promiscuity(struct net_device *dev, int inc);
 extern int              dev_set_allmulti(struct net_device *dev, int inc);
 extern void             netdev_state_change(struct net_device *dev);
-extern void             netdev_bonding_change(struct net_device *dev,
+extern int              netdev_bonding_change(struct net_device *dev,
                                               unsigned long event);
 extern void             netdev_features_change(struct net_device *dev);
 /* Load a device via the kmod */
@@ -1985,6 +2112,7 @@ extern const struct net_device_stats *dev_get_stats(struct net_device *dev);
 extern void             dev_txq_stats_fold(const struct net_device *dev, struct net_device_stats *stats);
 
 extern int              netdev_max_backlog;
+extern int              netdev_tstamp_prequeue;
 extern int              weight_p;
 extern int              netdev_set_master(struct net_device *dev, struct net_device *master);
 extern int skb_checksum_help(struct sk_buff *skb);
@@ -2045,54 +2173,14 @@ static inline void netif_set_gso_max_size(struct net_device *dev,
         dev->gso_max_size = size;
 }
 
-static inline void skb_bond_set_mac_by_master(struct sk_buff *skb,
-                                              struct net_device *master)
-{
-        if (skb->pkt_type == PACKET_HOST) {
-                u16 *dest = (u16 *) eth_hdr(skb)->h_dest;
+extern int __skb_bond_should_drop(struct sk_buff *skb,
+                                  struct net_device *master);
 
-                memcpy(dest, master->dev_addr, ETH_ALEN);
-        }
-}
-
-/* On bonding slaves other than the currently active slave, suppress
- * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and
- * ARP on active-backup slaves with arp_validate enabled.
- */
 static inline int skb_bond_should_drop(struct sk_buff *skb,
                                        struct net_device *master)
 {
-        if (master) {
-                struct net_device *dev = skb->dev;
-
-                if (master->priv_flags & IFF_MASTER_ARPMON)
-                        dev->last_rx = jiffies;
-
-                if ((master->priv_flags & IFF_MASTER_ALB) && master->br_port) {
-                        /* Do address unmangle. The local destination address
-                         * will be always the one master has. Provides the right
-                         * functionality in a bridge.
-                         */
-                        skb_bond_set_mac_by_master(skb, master);
-                }
-
-                if (dev->priv_flags & IFF_SLAVE_INACTIVE) {
-                        if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
-                            skb->protocol == __cpu_to_be16(ETH_P_ARP))
-                                return 0;
-
-                        if (master->priv_flags & IFF_MASTER_ALB) {
-                                if (skb->pkt_type != PACKET_BROADCAST &&
-                                    skb->pkt_type != PACKET_MULTICAST)
-                                        return 0;
-                        }
-                        if (master->priv_flags & IFF_MASTER_8023AD &&
-                            skb->protocol == __cpu_to_be16(ETH_P_SLOW))
-                                return 0;
-
-                        return 1;
-                }
-        }
+        if (master)
+                return __skb_bond_should_drop(skb, master);
         return 0;
 }
 
diff --git a/include/linux/netfilter/Kbuild b/include/linux/netfilter/Kbuild
index a5a63e41b8af..48767cd16453 100644
--- a/include/linux/netfilter/Kbuild
+++ b/include/linux/netfilter/Kbuild
@@ -16,6 +16,7 @@ header-y += xt_RATEEST.h
 header-y += xt_SECMARK.h
 header-y += xt_TCPMSS.h
 header-y += xt_TCPOPTSTRIP.h
+header-y += xt_TEE.h
 header-y += xt_TPROXY.h
 header-y += xt_comment.h
 header-y += xt_connbytes.h
diff --git a/include/linux/netfilter/nf_conntrack_common.h b/include/linux/netfilter/nf_conntrack_common.h
index c608677dda60..14e6d32002c4 100644
--- a/include/linux/netfilter/nf_conntrack_common.h
+++ b/include/linux/netfilter/nf_conntrack_common.h
@@ -113,6 +113,7 @@ struct ip_conntrack_stat {
         unsigned int expect_new;
         unsigned int expect_create;
         unsigned int expect_delete;
+        unsigned int search_restart;
 };
 
 /* call to create an explicit dependency on nf_conntrack. */
diff --git a/include/linux/netfilter/nf_conntrack_tuple_common.h b/include/linux/netfilter/nf_conntrack_tuple_common.h
index 8e145f0d61cb..2ea22b018a87 100644
--- a/include/linux/netfilter/nf_conntrack_tuple_common.h
+++ b/include/linux/netfilter/nf_conntrack_tuple_common.h
@@ -1,8 +1,7 @@
 #ifndef _NF_CONNTRACK_TUPLE_COMMON_H
 #define _NF_CONNTRACK_TUPLE_COMMON_H
 
-enum ip_conntrack_dir
-{
+enum ip_conntrack_dir {
         IP_CT_DIR_ORIGINAL,
         IP_CT_DIR_REPLY,
         IP_CT_DIR_MAX
diff --git a/include/linux/netfilter/x_tables.h b/include/linux/netfilter/x_tables.h
index 84c7c928e9eb..c2ee5d8550cf 100644
--- a/include/linux/netfilter/x_tables.h
+++ b/include/linux/netfilter/x_tables.h
@@ -1,9 +1,10 @@
 #ifndef _X_TABLES_H
 #define _X_TABLES_H
-
+#include <linux/kernel.h>
 #include <linux/types.h>
 
 #define XT_FUNCTION_MAXNAMELEN 30
+#define XT_EXTENSION_MAXNAMELEN 29
 #define XT_TABLE_MAXNAMELEN 32
 
 struct xt_entry_match {
@@ -12,8 +13,7 @@ struct xt_entry_match {
                         __u16 match_size;
 
                         /* Used by userspace */
-                        char name[XT_FUNCTION_MAXNAMELEN-1];
-
+                        char name[XT_EXTENSION_MAXNAMELEN];
                         __u8 revision;
                 } user;
                 struct {
@@ -36,8 +36,7 @@ struct xt_entry_target {
                         __u16 target_size;
 
                         /* Used by userspace */
-                        char name[XT_FUNCTION_MAXNAMELEN-1];
-
+                        char name[XT_EXTENSION_MAXNAMELEN];
                         __u8 revision;
                 } user;
                 struct {
@@ -70,8 +69,7 @@ struct xt_standard_target {
 /* The argument to IPT_SO_GET_REVISION_*.  Returns highest revision
  * kernel supports, if >= revision. */
 struct xt_get_revision {
-        char name[XT_FUNCTION_MAXNAMELEN-1];
-
+        char name[XT_EXTENSION_MAXNAMELEN];
         __u8 revision;
 };
 
@@ -93,7 +91,7 @@ struct _xt_align {
         __u64 u64;
 };
 
-#define XT_ALIGN(s) ALIGN((s), __alignof__(struct _xt_align))
+#define XT_ALIGN(s) __ALIGN_KERNEL((s), __alignof__(struct _xt_align))
 
 /* Standard return verdict, or do jump. */
 #define XT_STANDARD_TARGET ""
@@ -185,40 +183,53 @@ struct xt_counters_info {
 #include <linux/netdevice.h>
 
 /**
- * struct xt_match_param - parameters for match extensions' match functions
+ * struct xt_action_param - parameters for matches/targets
  *
+ * @match:      the match extension
+ * @target:     the target extension
+ * @matchinfo:  per-match data
+ * @targetinfo: per-target data
  * @in:         input netdevice
  * @out:        output netdevice
- * @match:      struct xt_match through which this function was invoked
- * @matchinfo:  per-match data
  * @fragoff:    packet is a fragment, this is the data offset
  * @thoff:      position of transport header relative to skb->data
  * @hook:       hook number given packet came from
  * @family:     Actual NFPROTO_* through which the function is invoked
  *              (helpful when match->family == NFPROTO_UNSPEC)
+ *
+ * Fields written to by extensions:
+ *
  * @hotdrop:    drop packet if we had inspection problems
+ * Network namespace obtainable using dev_net(in/out)
  */
-struct xt_match_param {
+struct xt_action_param {
+        union {
+                const struct xt_match *match;
+                const struct xt_target *target;
+        };
+        union {
+                const void *matchinfo, *targinfo;
+        };
         const struct net_device *in, *out;
-        const struct xt_match *match;
-        const void *matchinfo;
         int fragoff;
         unsigned int thoff;
         unsigned int hooknum;
         u_int8_t family;
-        bool *hotdrop;
+        bool hotdrop;
 };
 
 /**
  * struct xt_mtchk_param - parameters for match extensions'
  * checkentry functions
  *
+ * @net:        network namespace through which the check was invoked
  * @table:      table the rule is tried to be inserted into
  * @entryinfo:  the family-specific rule data
- *              (struct ipt_ip, ip6t_ip, ebt_entry)
+ *              (struct ipt_ip, ip6t_ip, arpt_arp or (note) ebt_entry)
  * @match:      struct xt_match through which this function was invoked
  * @matchinfo:  per-match data
  * @hook_mask:  via which hooks the new rule is reachable
+ * Other fields as above.
  */
 struct xt_mtchk_param {
         struct net *net;
@@ -230,7 +241,10 @@ struct xt_mtchk_param {
         u_int8_t family;
 };
 
-/* Match destructor parameters */
+/**
+ * struct xt_mdtor_param - match destructor parameters
+ * Fields as above.
+ */
 struct xt_mtdtor_param {
         struct net *net;
         const struct xt_match *match;
@@ -239,23 +253,6 @@ struct xt_mtdtor_param {
 };
 
 /**
- * struct xt_target_param - parameters for target extensions' target functions
- *
- * @hooknum:    hook through which this target was invoked
- * @target:     struct xt_target through which this function was invoked
- * @targinfo:   per-target data
- *
- * Other fields see above.
- */
-struct xt_target_param {
-        const struct net_device *in, *out;
-        const struct xt_target *target;
-        const void *targinfo;
-        unsigned int hooknum;
-        u_int8_t family;
-};
-
-/**
  * struct xt_tgchk_param - parameters for target extensions'
  * checkentry functions
  *
@@ -285,7 +282,7 @@ struct xt_tgdtor_param {
 struct xt_match {
         struct list_head list;
 
-        const char name[XT_FUNCTION_MAXNAMELEN-1];
+        const char name[XT_EXTENSION_MAXNAMELEN];
         u_int8_t revision;
 
         /* Return true or false: return FALSE and set *hotdrop = 1 to
@@ -294,10 +291,10 @@ struct xt_match {
            non-linear skb, using skb_header_pointer and
            skb_ip_make_writable. */
         bool (*match)(const struct sk_buff *skb,
-                      const struct xt_match_param *);
+                      struct xt_action_param *);
 
         /* Called when user tries to insert an entry of this type. */
-        bool (*checkentry)(const struct xt_mtchk_param *);
+        int (*checkentry)(const struct xt_mtchk_param *);
 
         /* Called when entry of this type deleted. */
         void (*destroy)(const struct xt_mtdtor_param *);
@@ -309,9 +306,6 @@ struct xt_match {
         /* Set this to THIS_MODULE if you are a module, otherwise NULL */
         struct module *me;
 
-        /* Free to use by each match */
-        unsigned long data;
-
         const char *table;
         unsigned int matchsize;
 #ifdef CONFIG_COMPAT
@@ -327,19 +321,20 @@ struct xt_match {
 struct xt_target {
         struct list_head list;
 
-        const char name[XT_FUNCTION_MAXNAMELEN-1];
+        const char name[XT_EXTENSION_MAXNAMELEN];
+        u_int8_t revision;
 
         /* Returns verdict. Argument order changed since 2.6.9, as this
            must now handle non-linear skbs, using skb_copy_bits and
            skb_ip_make_writable. */
         unsigned int (*target)(struct sk_buff *skb,
-                               const struct xt_target_param *);
+                               const struct xt_action_param *);
 
         /* Called when user tries to insert an entry of this type:
            hook_mask is a bitmask of hooks from which it can be
            called. */
-        /* Should return true or false. */
-        bool (*checkentry)(const struct xt_tgchk_param *);
+        /* Should return true or false, or an error code (-Exxxx). */
+        int (*checkentry)(const struct xt_tgchk_param *);
 
         /* Called when entry of this type deleted. */
         void (*destroy)(const struct xt_tgdtor_param *);
@@ -360,7 +355,6 @@ struct xt_target {
         unsigned short proto;
 
         unsigned short family;
-        u_int8_t revision;
 };
 
 /* Furniture shopping... */
@@ -398,6 +392,13 @@ struct xt_table_info {
         unsigned int hook_entry[NF_INET_NUMHOOKS];
         unsigned int underflow[NF_INET_NUMHOOKS];
 
+        /*
+         * Number of user chains. Since tables cannot have loops, at most
+         * @stacksize jumps (number of user chains) can possibly be made.
+         */
+        unsigned int stacksize;
+        unsigned int *stackptr;
+        void ***jumpstack;
         /* ipt_entry tables: one per CPU */
         /* Note : this field MUST be the last one, see XT_TABLE_INFO_SZ */
         void *entries[1];
@@ -433,6 +434,8 @@ extern struct xt_table_info *xt_replace_table(struct xt_table *table,
 
 extern struct xt_match *xt_find_match(u8 af, const char *name, u8 revision);
 extern struct xt_target *xt_find_target(u8 af, const char *name, u8 revision);
+extern struct xt_match *xt_request_find_match(u8 af, const char *name,
+                                              u8 revision);
 extern struct xt_target *xt_request_find_target(u8 af, const char *name,
                                                 u8 revision);
 extern int xt_find_revision(u8 af, const char *name, u8 revision,
@@ -598,7 +601,7 @@ struct _compat_xt_align {
         compat_u64 u64;
 };
 
-#define COMPAT_XT_ALIGN(s) ALIGN((s), __alignof__(struct _compat_xt_align))
+#define COMPAT_XT_ALIGN(s) __ALIGN_KERNEL((s), __alignof__(struct _compat_xt_align))
 
 extern void xt_compat_lock(u_int8_t af);
 extern void xt_compat_unlock(u_int8_t af);
diff --git a/include/linux/netfilter/xt_CONNMARK.h b/include/linux/netfilter/xt_CONNMARK.h
index 0a8545866752..2f2e48ec8023 100644
--- a/include/linux/netfilter/xt_CONNMARK.h
+++ b/include/linux/netfilter/xt_CONNMARK.h
@@ -1,26 +1,6 @@
 #ifndef _XT_CONNMARK_H_target
 #define _XT_CONNMARK_H_target
 
-#include <linux/types.h>
-
-/* Copyright (C) 2002,2004 MARA Systems AB <http://www.marasystems.com>
- * by Henrik Nordstrom <hno@marasystems.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- */
-
-enum {
-        XT_CONNMARK_SET = 0,
-        XT_CONNMARK_SAVE,
-        XT_CONNMARK_RESTORE
-};
-
-struct xt_connmark_tginfo1 {
-        __u32 ctmark, ctmask, nfmask;
-        __u8 mode;
-};
+#include <linux/netfilter/xt_connmark.h>
 
 #endif /*_XT_CONNMARK_H_target*/
diff --git a/include/linux/netfilter/xt_MARK.h b/include/linux/netfilter/xt_MARK.h
index bc9561bdef79..41c456deba22 100644
--- a/include/linux/netfilter/xt_MARK.h
+++ b/include/linux/netfilter/xt_MARK.h
@@ -1,10 +1,6 @@
 #ifndef _XT_MARK_H_target
 #define _XT_MARK_H_target
 
-#include <linux/types.h>
-
-struct xt_mark_tginfo2 {
-        __u32 mark, mask;
-};
+#include <linux/netfilter/xt_mark.h>
 
 #endif /*_XT_MARK_H_target */
diff --git a/include/linux/netfilter/xt_TEE.h b/include/linux/netfilter/xt_TEE.h
new file mode 100644
index 000000000000..5c21d5c829af
--- /dev/null
+++ b/include/linux/netfilter/xt_TEE.h
@@ -0,0 +1,12 @@
+#ifndef _XT_TEE_TARGET_H
+#define _XT_TEE_TARGET_H
+
+struct xt_tee_tginfo {
+        union nf_inet_addr gw;
+        char oif[16];
+
+        /* used internally by the kernel */
+        struct xt_tee_priv *priv __attribute__((aligned(8)));
+};
+
+#endif /* _XT_TEE_TARGET_H */
diff --git a/include/linux/netfilter/xt_connmark.h b/include/linux/netfilter/xt_connmark.h
index 619e47cde01a..efc17a8305fb 100644
--- a/include/linux/netfilter/xt_connmark.h
+++ b/include/linux/netfilter/xt_connmark.h
@@ -12,6 +12,17 @@
  * (at your option) any later version.
  */
 
+enum {
+        XT_CONNMARK_SET = 0,
+        XT_CONNMARK_SAVE,
+        XT_CONNMARK_RESTORE
+};
+
+struct xt_connmark_tginfo1 {
+        __u32 ctmark, ctmask, nfmask;
+        __u8 mode;
+};
+
 struct xt_connmark_mtinfo1 {
         __u32 mark, mask;
         __u8 invert;
diff --git a/include/linux/netfilter/xt_mark.h b/include/linux/netfilter/xt_mark.h
index 6607c8f38ea5..ecadc40d5cde 100644
--- a/include/linux/netfilter/xt_mark.h
+++ b/include/linux/netfilter/xt_mark.h
@@ -3,6 +3,10 @@
 
 #include <linux/types.h>
 
+struct xt_mark_tginfo2 {
+        __u32 mark, mask;
+};
+
 struct xt_mark_mtinfo1 {
         __u32 mark, mask;
         __u8 invert;
diff --git a/include/linux/netfilter/xt_recent.h b/include/linux/netfilter/xt_recent.h
index d2c276609925..83318e01425e 100644
--- a/include/linux/netfilter/xt_recent.h
+++ b/include/linux/netfilter/xt_recent.h
@@ -9,6 +9,7 @@ enum {
         XT_RECENT_UPDATE   = 1 << 2,
         XT_RECENT_REMOVE   = 1 << 3,
         XT_RECENT_TTL      = 1 << 4,
+        XT_RECENT_REAP     = 1 << 5,
 
         XT_RECENT_SOURCE   = 0,
         XT_RECENT_DEST     = 1,
@@ -16,6 +17,12 @@ enum {
         XT_RECENT_NAME_LEN = 200,
 };
 
+/* Only allowed with --rcheck and --update */
+#define XT_RECENT_MODIFIERS (XT_RECENT_TTL|XT_RECENT_REAP)
+
+#define XT_RECENT_VALID_FLAGS (XT_RECENT_CHECK|XT_RECENT_SET|XT_RECENT_UPDATE|\
+                               XT_RECENT_REMOVE|XT_RECENT_TTL|XT_RECENT_REAP)
+
 struct xt_recent_mtinfo {
         __u32 seconds;
         __u32 hit_count;
diff --git a/include/linux/netfilter_bridge.h b/include/linux/netfilter_bridge.h
index f8105e54716a..0ddd161f3b06 100644
--- a/include/linux/netfilter_bridge.h
+++ b/include/linux/netfilter_bridge.h
@@ -41,10 +41,10 @@ enum nf_br_hook_priorities {
 
 #define BRNF_PKT_TYPE                   0x01
 #define BRNF_BRIDGED_DNAT               0x02
-#define BRNF_DONT_TAKE_PARENT           0x04
-#define BRNF_BRIDGED                    0x08
-#define BRNF_NF_BRIDGE_PREROUTING       0x10
-
+#define BRNF_BRIDGED                    0x04
+#define BRNF_NF_BRIDGE_PREROUTING       0x08
+#define BRNF_8021Q                      0x10
+#define BRNF_PPPoE                      0x20
 
 /* Only used in br_forward.c */
 extern int nf_bridge_copy_header(struct sk_buff *skb);
@@ -68,6 +68,27 @@ static inline unsigned int nf_bridge_encap_header_len(const struct sk_buff *skb)
         }
 }
 
+static inline unsigned int nf_bridge_mtu_reduction(const struct sk_buff *skb)
+{
+        if (unlikely(skb->nf_bridge->mask & BRNF_PPPoE))
+                return PPPOE_SES_HLEN;
+        return 0;
+}
+
+extern int br_handle_frame_finish(struct sk_buff *skb);
+/* Only used in br_device.c */
+static inline int br_nf_pre_routing_finish_bridge_slow(struct sk_buff *skb)
+{
+        struct nf_bridge_info *nf_bridge = skb->nf_bridge;
+
+        skb_pull(skb, ETH_HLEN);
+        nf_bridge->mask ^= BRNF_BRIDGED_DNAT;
+        skb_copy_to_linear_data_offset(skb, -(ETH_HLEN-ETH_ALEN),
+                                       skb->nf_bridge->data, ETH_HLEN-ETH_ALEN);
+        skb->dev = nf_bridge->physindev;
+        return br_handle_frame_finish(skb);
+}
+
 /* This is called by the IP fragmenting code and it ensures there is
  * enough room for the encapsulating header (if there is one). */
 static inline unsigned int nf_bridge_pad(const struct sk_buff *skb)
diff --git a/include/linux/netfilter_ipv6/ip6_tables.h b/include/linux/netfilter_ipv6/ip6_tables.h
index e5ba03d783c6..18442ff19c07 100644
--- a/include/linux/netfilter_ipv6/ip6_tables.h
+++ b/include/linux/netfilter_ipv6/ip6_tables.h
@@ -316,10 +316,6 @@ extern int ip6t_ext_hdr(u8 nexthdr);
 extern int ipv6_find_hdr(const struct sk_buff *skb, unsigned int *offset,
                          int target, unsigned short *fragoff);
 
-extern int ip6_masked_addrcmp(const struct in6_addr *addr1,
-                              const struct in6_addr *mask,
-                              const struct in6_addr *addr2);
-
 #define IP6T_ALIGN(s) XT_ALIGN(s)
 
 #ifdef CONFIG_COMPAT
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 6eaca5e1e8ca..59d066936ab9 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -188,6 +188,10 @@ extern int netlink_has_listeners(struct sock *sk, unsigned int group);
 extern int netlink_unicast(struct sock *ssk, struct sk_buff *skb, __u32 pid, int nonblock);
 extern int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, __u32 pid,
                              __u32 group, gfp_t allocation);
+extern int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb,
+        __u32 pid, __u32 group, gfp_t allocation,
+        int (*filter)(struct sock *dsk, struct sk_buff *skb, void *data),
+        void *filter_data);
 extern int netlink_set_err(struct sock *ssk, __u32 pid, __u32 group, int code);
 extern int netlink_register_notifier(struct notifier_block *nb);
 extern int netlink_unregister_notifier(struct notifier_block *nb);
diff --git a/include/linux/netpoll.h b/include/linux/netpoll.h
index a765ea898549..e9e231215865 100644
--- a/include/linux/netpoll.h
+++ b/include/linux/netpoll.h
@@ -14,6 +14,7 @@
 
 struct netpoll {
         struct net_device *dev;
+        struct net_device *real_dev;
         char dev_name[IFNAMSIZ];
         const char *name;
         void (*rx_hook)(struct netpoll *, int, char *, int);
@@ -36,8 +37,11 @@ struct netpoll_info {
         struct sk_buff_head txq;
 
         struct delayed_work tx_work;
+
+        struct netpoll *netpoll;
 };
 
+void netpoll_poll_dev(struct net_device *dev);
 void netpoll_poll(struct netpoll *np);
 void netpoll_send_udp(struct netpoll *np, const char *msg, int len);
 void netpoll_print_options(struct netpoll *np);
@@ -47,22 +51,23 @@ int netpoll_trap(void);
 void netpoll_set_trap(int trap);
 void netpoll_cleanup(struct netpoll *np);
 int __netpoll_rx(struct sk_buff *skb);
+void netpoll_send_skb(struct netpoll *np, struct sk_buff *skb);
 
 
 #ifdef CONFIG_NETPOLL
-static inline int netpoll_rx(struct sk_buff *skb)
+static inline bool netpoll_rx(struct sk_buff *skb)
 {
         struct netpoll_info *npinfo = skb->dev->npinfo;
         unsigned long flags;
-        int ret = 0;
+        bool ret = false;
 
         if (!npinfo || (list_empty(&npinfo->rx_np) && !npinfo->rx_flags))
-                return 0;
+                return false;
 
         spin_lock_irqsave(&npinfo->rx_lock, flags);
         /* check rx_flags again with the lock held */
         if (npinfo->rx_flags && __netpoll_rx(skb))
-                ret = 1;
+                ret = true;
         spin_unlock_irqrestore(&npinfo->rx_lock, flags);
 
         return ret;
diff --git a/include/linux/nilfs2_fs.h b/include/linux/nilfs2_fs.h
index 640702e97457..8c2c6116e788 100644
--- a/include/linux/nilfs2_fs.h
+++ b/include/linux/nilfs2_fs.h
@@ -199,16 +199,15 @@ struct nilfs_super_block {
         __le32  s_creator_os;           /* OS */
         __le16  s_def_resuid;           /* Default uid for reserved blocks */
         __le16  s_def_resgid;           /* Default gid for reserved blocks */
-        __le32  s_first_ino;            /* First non-reserved inode */
+        __le32  s_first_ino;            /* First non-reserved inode */
 
-        __le16  s_inode_size;           /* Size of an inode */
+        __le16  s_inode_size;           /* Size of an inode */
         __le16  s_dat_entry_size;       /* Size of a dat entry */
         __le16  s_checkpoint_size;      /* Size of a checkpoint */
         __le16  s_segment_usage_size;   /* Size of a segment usage */
 
         __u8    s_uuid[16];             /* 128-bit uuid for volume */
-        char    s_volume_name[16];      /* volume name */
-        char    s_last_mounted[64];     /* directory where last mounted */
+        char    s_volume_name[80];      /* volume name */
 
         __le32  s_c_interval;           /* Commit interval of segment */
         __le32  s_c_block_max;          /* Threshold of data amount for
@@ -377,6 +376,7 @@ union nilfs_binfo {
  * @ss_nfinfo: number of finfo structures
  * @ss_sumbytes: total size of segment summary in bytes
  * @ss_pad: padding
+ * @ss_cno: checkpoint number
  */
 struct nilfs_segment_summary {
         __le32 ss_datasum;
@@ -391,6 +391,7 @@ struct nilfs_segment_summary {
         __le32 ss_nfinfo;
         __le32 ss_sumbytes;
         __le32 ss_pad;
+        __le64 ss_cno;
         /* array of finfo structures */
 };
 
@@ -437,10 +438,10 @@ struct nilfs_palloc_group_desc {
 
 /**
  * struct nilfs_dat_entry - disk address translation entry
- * @dt_blocknr: block number
- * @dt_start: start checkpoint number
- * @dt_end: end checkpoint number
- * @dt_rsv: reserved for future use
+ * @de_blocknr: block number
+ * @de_start: start checkpoint number
+ * @de_end: end checkpoint number
+ * @de_rsv: reserved for future use
  */
 struct nilfs_dat_entry {
         __le64 de_blocknr;
diff --git a/include/linux/nl80211.h b/include/linux/nl80211.h
index 28ba20fda3e2..b7c77f9712f4 100644
--- a/include/linux/nl80211.h
+++ b/include/linux/nl80211.h
@@ -52,6 +52,8 @@
  *      %NL80211_ATTR_WIPHY_CHANNEL_TYPE, %NL80211_ATTR_WIPHY_RETRY_SHORT,
  *      %NL80211_ATTR_WIPHY_RETRY_LONG, %NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
  *      and/or %NL80211_ATTR_WIPHY_RTS_THRESHOLD.
+ *      However, for setting the channel, see %NL80211_CMD_SET_CHANNEL
+ *      instead, the support here is for backward compatibility only.
  * @NL80211_CMD_NEW_WIPHY: Newly created wiphy, response to get request
  *      or rename notification. Has attributes %NL80211_ATTR_WIPHY and
  *      %NL80211_ATTR_WIPHY_NAME.
@@ -323,6 +325,21 @@
  *      the TX command and %NL80211_ATTR_FRAME includes the contents of the
  *      frame. %NL80211_ATTR_ACK flag is included if the recipient acknowledged
  *      the frame.
+ * @NL80211_CMD_SET_CQM: Connection quality monitor configuration. This command
+ *      is used to configure connection quality monitoring notification trigger
+ *      levels.
+ * @NL80211_CMD_NOTIFY_CQM: Connection quality monitor notification. This
+ *      command is used as an event to indicate the that a trigger level was
+ *      reached.
+ * @NL80211_CMD_SET_CHANNEL: Set the channel (using %NL80211_ATTR_WIPHY_FREQ
+ *      and %NL80211_ATTR_WIPHY_CHANNEL_TYPE) the given interface (identifed
+ *      by %NL80211_ATTR_IFINDEX) shall operate on.
+ *      In case multiple channels are supported by the device, the mechanism
+ *      with which it switches channels is implementation-defined.
+ *      When a monitor interface is given, it can only switch channel while
+ *      no other interfaces are operating to avoid disturbing the operation
+ *      of any other interfaces, and other interfaces will again take
+ *      precedence when they are used.
  *
  * @NL80211_CMD_MAX: highest used command number
  * @__NL80211_CMD_AFTER_LAST: internal use
@@ -419,6 +436,11 @@ enum nl80211_commands {
         NL80211_CMD_SET_POWER_SAVE,
         NL80211_CMD_GET_POWER_SAVE,
 
+        NL80211_CMD_SET_CQM,
+        NL80211_CMD_NOTIFY_CQM,
+
+        NL80211_CMD_SET_CHANNEL,
+
         /* add new commands above here */
 
         /* used to define NL80211_CMD_MAX below */
@@ -691,6 +713,18 @@ enum nl80211_commands {
  * @NL80211_ATTR_ACK: Flag attribute indicating that the frame was
  *      acknowledged by the recipient.
  *
+ * @NL80211_ATTR_CQM: connection quality monitor configuration in a
+ *      nested attribute with %NL80211_ATTR_CQM_* sub-attributes.
+ *
+ * @NL80211_ATTR_LOCAL_STATE_CHANGE: Flag attribute to indicate that a command
+ *      is requesting a local authentication/association state change without
+ *      invoking actual management frame exchange. This can be used with
+ *      NL80211_CMD_AUTHENTICATE, NL80211_CMD_DEAUTHENTICATE,
+ *      NL80211_CMD_DISASSOCIATE.
+ *
+ * @NL80211_ATTR_AP_ISOLATE: (AP mode) Do not forward traffic between stations
+ *      connected to this BSS.
+ *
  * @NL80211_ATTR_MAX: highest attribute number currently defined
  * @__NL80211_ATTR_AFTER_LAST: internal use
  */
@@ -842,6 +876,12 @@ enum nl80211_attrs {
 
         NL80211_ATTR_PS_STATE,
 
+        NL80211_ATTR_CQM,
+
+        NL80211_ATTR_LOCAL_STATE_CHANGE,
+
+        NL80211_ATTR_AP_ISOLATE,
+
         /* add attributes here, update the policy in nl80211.c */
 
         __NL80211_ATTR_AFTER_LAST,
@@ -1583,4 +1623,40 @@ enum nl80211_ps_state {
         NL80211_PS_ENABLED,
 };
 
+/**
+ * enum nl80211_attr_cqm - connection quality monitor attributes
+ * @__NL80211_ATTR_CQM_INVALID: invalid
+ * @NL80211_ATTR_CQM_RSSI_THOLD: RSSI threshold in dBm. This value specifies
+ *      the threshold for the RSSI level at which an event will be sent. Zero
+ *      to disable.
+ * @NL80211_ATTR_CQM_RSSI_HYST: RSSI hysteresis in dBm. This value specifies
+ *      the minimum amount the RSSI level must change after an event before a
+ *      new event may be issued (to reduce effects of RSSI oscillation).
+ * @NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT: RSSI threshold event
+ * @__NL80211_ATTR_CQM_AFTER_LAST: internal
+ * @NL80211_ATTR_CQM_MAX: highest key attribute
+ */
+enum nl80211_attr_cqm {
+        __NL80211_ATTR_CQM_INVALID,
+        NL80211_ATTR_CQM_RSSI_THOLD,
+        NL80211_ATTR_CQM_RSSI_HYST,
+        NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
+
+        /* keep last */
+        __NL80211_ATTR_CQM_AFTER_LAST,
+        NL80211_ATTR_CQM_MAX = __NL80211_ATTR_CQM_AFTER_LAST - 1
+};
+
+/**
+ * enum nl80211_cqm_rssi_threshold_event - RSSI threshold event
+ * @NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW - The RSSI level is lower than the
+ *      configured threshold
+ * @NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH - The RSSI is higher than the
+ *      configured threshold
+ */
+enum nl80211_cqm_rssi_threshold_event {
+        NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW,
+        NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH,
+};
+
 #endif /* __LINUX_NL80211_H */
diff --git a/include/linux/notifier.h b/include/linux/notifier.h
index fee6c2f68075..7c3609622334 100644
--- a/include/linux/notifier.h
+++ b/include/linux/notifier.h
@@ -182,7 +182,10 @@ static inline int notifier_to_errno(int ret)
  *      VC switch chains (for loadable kernel svgalib VC switch helpers) etc...
  */
  
-/* netdevice notifier chain */
+/* netdevice notifier chain. Please remember to update the rtnetlink
+ * notification exclusion list in rtnetlink_event() when adding new
+ * types.
+ */
 #define NETDEV_UP       0x0001  /* For now you can't veto a device up/down */
 #define NETDEV_DOWN     0x0002
 #define NETDEV_REBOOT   0x0003  /* Tell a protocol stack a network interface
@@ -199,10 +202,11 @@ static inline int notifier_to_errno(int ret)
 #define NETDEV_FEAT_CHANGE      0x000B
 #define NETDEV_BONDING_FAILOVER 0x000C
 #define NETDEV_PRE_UP           0x000D
-#define NETDEV_BONDING_OLDTYPE  0x000E
-#define NETDEV_BONDING_NEWTYPE  0x000F
+#define NETDEV_PRE_TYPE_CHANGE  0x000E
+#define NETDEV_POST_TYPE_CHANGE 0x000F
 #define NETDEV_POST_INIT        0x0010
 #define NETDEV_UNREGISTER_BATCH 0x0011
+#define NETDEV_BONDING_DESLAVE  0x0012
 
 #define SYS_DOWN        0x0001  /* Notify of system down */
 #define SYS_RESTART     SYS_DOWN
diff --git a/include/linux/padata.h b/include/linux/padata.h
index 51611da9c498..8d8406246eef 100644
--- a/include/linux/padata.h
+++ b/include/linux/padata.h
@@ -24,7 +24,19 @@
 #include <linux/workqueue.h>
 #include <linux/spinlock.h>
 #include <linux/list.h>
+#include <linux/timer.h>
 
+/**
+ * struct padata_priv -  Embedded to the users data structure.
+ *
+ * @list: List entry, to attach to the padata lists.
+ * @pd: Pointer to the internal control structure.
+ * @cb_cpu: Callback cpu for serializatioon.
+ * @seq_nr: Sequence number of the parallelized data object.
+ * @info: Used to pass information from the parallel to the serial function.
+ * @parallel: Parallel execution function.
+ * @serial: Serial complete function.
+ */
 struct padata_priv {
         struct list_head        list;
         struct parallel_data    *pd;
@@ -35,11 +47,29 @@ struct padata_priv {
         void                    (*serial)(struct padata_priv *padata);
 };
 
+/**
+ * struct padata_list
+ *
+ * @list: List head.
+ * @lock: List lock.
+ */
 struct padata_list {
         struct list_head        list;
         spinlock_t              lock;
 };
 
+/**
+ * struct padata_queue - The percpu padata queues.
+ *
+ * @parallel: List to wait for parallelization.
+ * @reorder: List to wait for reordering after parallel processing.
+ * @serial: List to wait for serialization after reordering.
+ * @pwork: work struct for parallelization.
+ * @swork: work struct for serialization.
+ * @pd: Backpointer to the internal control structure.
+ * @num_obj: Number of objects that are processed by this cpu.
+ * @cpu_index: Index of the cpu.
+ */
 struct padata_queue {
         struct padata_list      parallel;
         struct padata_list      reorder;
@@ -51,6 +81,20 @@ struct padata_queue {
         int                     cpu_index;
 };
 
+/**
+ * struct parallel_data - Internal control structure, covers everything
+ * that depends on the cpumask in use.
+ *
+ * @pinst: padata instance.
+ * @queue: percpu padata queues.
+ * @seq_nr: The sequence number that will be attached to the next object.
+ * @reorder_objects: Number of objects waiting in the reorder queues.
+ * @refcnt: Number of objects holding a reference on this parallel_data.
+ * @max_seq_nr:  Maximal used sequence number.
+ * @cpumask: cpumask in use.
+ * @lock: Reorder lock.
+ * @timer: Reorder timer.
+ */
 struct parallel_data {
         struct padata_instance  *pinst;
         struct padata_queue     *queue;
@@ -60,8 +104,19 @@ struct parallel_data {
         unsigned int            max_seq_nr;
         cpumask_var_t           cpumask;
         spinlock_t              lock;
+        struct timer_list       timer;
 };
 
+/**
+ * struct padata_instance - The overall control structure.
+ *
+ * @cpu_notifier: cpu hotplug notifier.
+ * @wq: The workqueue in use.
+ * @pd: The internal control structure.
+ * @cpumask: User supplied cpumask.
+ * @lock: padata instance lock.
+ * @flags: padata flags.
+ */
 struct padata_instance {
         struct notifier_block   cpu_notifier;
         struct workqueue_struct *wq;
diff --git a/include/linux/pci.h b/include/linux/pci.h
index a788fa12ff31..a327322a33ab 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -334,6 +334,16 @@ struct pci_dev {
 #endif
 };
 
+static inline struct pci_dev *pci_physfn(struct pci_dev *dev)
+{
+#ifdef CONFIG_PCI_IOV
+        if (dev->is_virtfn)
+                dev = dev->physfn;
+#endif
+
+        return dev;
+}
+
 extern struct pci_dev *alloc_pci_dev(void);
 
 #define pci_dev_b(n) list_entry(n, struct pci_dev, bus_list)
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 9f688d243b86..ae66851870be 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -2419,8 +2419,8 @@
 #define PCI_DEVICE_ID_INTEL_82845_HB    0x1a30
 #define PCI_DEVICE_ID_INTEL_IOAT        0x1a38
 #define PCI_DEVICE_ID_INTEL_CPT_SMBUS   0x1c22
-#define PCI_DEVICE_ID_INTEL_CPT_LPC1    0x1c42
-#define PCI_DEVICE_ID_INTEL_CPT_LPC2    0x1c43
+#define PCI_DEVICE_ID_INTEL_CPT_LPC_MIN 0x1c41
+#define PCI_DEVICE_ID_INTEL_CPT_LPC_MAX 0x1c5f
 #define PCI_DEVICE_ID_INTEL_82801AA_0   0x2410
 #define PCI_DEVICE_ID_INTEL_82801AA_1   0x2411
 #define PCI_DEVICE_ID_INTEL_82801AA_3   0x2413
diff --git a/include/linux/pci_regs.h b/include/linux/pci_regs.h
index c8f302991b66..455b9ccdfca7 100644
--- a/include/linux/pci_regs.h
+++ b/include/linux/pci_regs.h
@@ -442,7 +442,10 @@
 #define  PCI_EXP_LNKCTL_LABIE   0x0800  /* Lnk Autonomous Bandwidth Interrupt Enable */
 #define PCI_EXP_LNKSTA          18      /* Link Status */
 #define  PCI_EXP_LNKSTA_CLS     0x000f  /* Current Link Speed */
+#define  PCI_EXP_LNKSTA_CLS_2_5GB 0x01  /* Current Link Speed 2.5GT/s */
+#define  PCI_EXP_LNKSTA_CLS_5_0GB 0x02  /* Current Link Speed 5.0GT/s */
 #define  PCI_EXP_LNKSTA_NLW     0x03f0  /* Nogotiated Link Width */
+#define  PCI_EXP_LNKSTA_NLW_SHIFT 4     /* start of NLW mask in link status */
 #define  PCI_EXP_LNKSTA_LT      0x0800  /* Link Training */
 #define  PCI_EXP_LNKSTA_SLC     0x1000  /* Slot Clock Configuration */
 #define  PCI_EXP_LNKSTA_DLLLA   0x2000  /* Data Link Layer Link Active */
@@ -563,8 +566,7 @@
 #define PCI_ERR_ROOT_FIRST_FATAL        0x00000010      /* First Fatal */
 #define PCI_ERR_ROOT_NONFATAL_RCV       0x00000020      /* Non-Fatal Received */
 #define PCI_ERR_ROOT_FATAL_RCV          0x00000040      /* Fatal Received */
-#define PCI_ERR_ROOT_COR_SRC    52
-#define PCI_ERR_ROOT_SRC        54
+#define PCI_ERR_ROOT_ERR_SRC    52      /* Error Source Identification */
 
 /* Virtual Channel */
 #define PCI_VC_PORT_REG1        4
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 14d7fdf6a90a..987e111f7b11 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -24,6 +24,7 @@
 #include <linux/mii.h>
 #include <linux/timer.h>
 #include <linux/workqueue.h>
+#include <linux/mod_devicetable.h>
 
 #include <asm/atomic.h>
 
@@ -81,6 +82,10 @@ typedef enum {
  */
 #define MII_BUS_ID_SIZE (20 - 3)
 
+/* Or MII_ADDR_C45 into regnum for read/write on mii_bus to enable the 21 bit
+   IEEE 802.3ae clause 45 addressing mode used by 10GIGE phy chips. */
+#define MII_ADDR_C45 (1<<30)
+
 /*
  * The Bus class for PHYs.  Devices which provide access to
  * PHYs should register using this structure
@@ -127,8 +132,8 @@ int mdiobus_register(struct mii_bus *bus);
 void mdiobus_unregister(struct mii_bus *bus);
 void mdiobus_free(struct mii_bus *bus);
 struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr);
-int mdiobus_read(struct mii_bus *bus, int addr, u16 regnum);
-int mdiobus_write(struct mii_bus *bus, int addr, u16 regnum, u16 val);
+int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum);
+int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val);
 
 
 #define PHY_INTERRUPT_DISABLED  0x0
@@ -422,7 +427,7 @@ struct phy_fixup {
  * because the bus read/write functions may wait for an interrupt
  * to conclude the operation.
  */
-static inline int phy_read(struct phy_device *phydev, u16 regnum)
+static inline int phy_read(struct phy_device *phydev, u32 regnum)
 {
         return mdiobus_read(phydev->bus, phydev->addr, regnum);
 }
@@ -437,7 +442,7 @@ static inline int phy_read(struct phy_device *phydev, u16 regnum)
  * because the bus read/write functions may wait for an interrupt
  * to conclude the operation.
  */
-static inline int phy_write(struct phy_device *phydev, u16 regnum, u16 val)
+static inline int phy_write(struct phy_device *phydev, u32 regnum, u16 val)
 {
         return mdiobus_write(phydev->bus, phydev->addr, regnum, val);
 }
diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
index b43a9e039059..16de3933c45e 100644
--- a/include/linux/pipe_fs_i.h
+++ b/include/linux/pipe_fs_i.h
@@ -3,7 +3,7 @@
 
 #define PIPEFS_MAGIC 0x50495045
 
-#define PIPE_BUFFERS (16)
+#define PIPE_DEF_BUFFERS        16
 
 #define PIPE_BUF_FLAG_LRU       0x01    /* page is on the LRU */
 #define PIPE_BUF_FLAG_ATOMIC    0x02    /* was atomically mapped */
@@ -44,17 +44,17 @@ struct pipe_buffer {
  **/
 struct pipe_inode_info {
         wait_queue_head_t wait;
-        unsigned int nrbufs, curbuf;
-        struct page *tmp_page;
+        unsigned int nrbufs, curbuf, buffers;
         unsigned int readers;
         unsigned int writers;
         unsigned int waiting_writers;
         unsigned int r_counter;
         unsigned int w_counter;
+        struct page *tmp_page;
         struct fasync_struct *fasync_readers;
         struct fasync_struct *fasync_writers;
         struct inode *inode;
-        struct pipe_buffer bufs[PIPE_BUFFERS];
+        struct pipe_buffer *bufs;
 };
 
 /*
@@ -139,6 +139,8 @@ void pipe_lock(struct pipe_inode_info *);
 void pipe_unlock(struct pipe_inode_info *);
 void pipe_double_lock(struct pipe_inode_info *, struct pipe_inode_info *);
 
+extern unsigned int pipe_max_pages;
+
 /* Drop the inode semaphore and wait for a pipe event, atomically */
 void pipe_wait(struct pipe_inode_info *pipe);
 
@@ -154,4 +156,7 @@ int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *);
 int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *);
 void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *);
 
+/* for F_SETPIPE_SZ and F_GETPIPE_SZ */
+long pipe_fcntl(struct file *, unsigned int, unsigned long arg);
+
 #endif
diff --git a/include/linux/pm_qos_params.h b/include/linux/pm_qos_params.h
index d74f75ed1e47..8ba440e5eb7f 100644
--- a/include/linux/pm_qos_params.h
+++ b/include/linux/pm_qos_params.h
@@ -14,12 +14,14 @@
 #define PM_QOS_NUM_CLASSES 4
 #define PM_QOS_DEFAULT_VALUE -1
 
-int pm_qos_add_requirement(int qos, char *name, s32 value);
-int pm_qos_update_requirement(int qos, char *name, s32 new_value);
-void pm_qos_remove_requirement(int qos, char *name);
+struct pm_qos_request_list;
 
-int pm_qos_requirement(int qos);
+struct pm_qos_request_list *pm_qos_add_request(int pm_qos_class, s32 value);
+void pm_qos_update_request(struct pm_qos_request_list *pm_qos_req,
+                s32 new_value);
+void pm_qos_remove_request(struct pm_qos_request_list *pm_qos_req);
 
-int pm_qos_add_notifier(int qos, struct notifier_block *notifier);
-int pm_qos_remove_notifier(int qos, struct notifier_block *notifier);
+int pm_qos_request(int pm_qos_class);
+int pm_qos_add_notifier(int pm_qos_class, struct notifier_block *notifier);
+int pm_qos_remove_notifier(int pm_qos_class, struct notifier_block *notifier);
 
diff --git a/include/linux/pm_runtime.h b/include/linux/pm_runtime.h
index b776db737244..6e81888c6222 100644
--- a/include/linux/pm_runtime.h
+++ b/include/linux/pm_runtime.h
@@ -30,6 +30,9 @@ extern void pm_runtime_enable(struct device *dev);
 extern void __pm_runtime_disable(struct device *dev, bool check_resume);
 extern void pm_runtime_allow(struct device *dev);
 extern void pm_runtime_forbid(struct device *dev);
+extern int pm_generic_runtime_idle(struct device *dev);
+extern int pm_generic_runtime_suspend(struct device *dev);
+extern int pm_generic_runtime_resume(struct device *dev);
 
 static inline bool pm_children_suspended(struct device *dev)
 {
@@ -96,6 +99,10 @@ static inline bool device_run_wake(struct device *dev) { return false; }
 static inline void device_set_run_wake(struct device *dev, bool enable) {}
 static inline bool pm_runtime_suspended(struct device *dev) { return false; }
 
+static inline int pm_generic_runtime_idle(struct device *dev) { return 0; }
+static inline int pm_generic_runtime_suspend(struct device *dev) { return 0; }
+static inline int pm_generic_runtime_resume(struct device *dev) { return 0; }
+
 #endif /* !CONFIG_PM_RUNTIME */
 
 static inline int pm_runtime_get(struct device *dev)
diff --git a/include/linux/pm_wakeup.h b/include/linux/pm_wakeup.h
index 0aae7776185e..22d64c18056c 100644
--- a/include/linux/pm_wakeup.h
+++ b/include/linux/pm_wakeup.h
@@ -25,32 +25,34 @@
 # error "please don't include this file directly"
 #endif
 
+#include <linux/types.h>
+
 #ifdef CONFIG_PM
 
 /* changes to device_may_wakeup take effect on the next pm state change.
  * by default, devices should wakeup if they can.
  */
-static inline void device_init_wakeup(struct device *dev, int val)
+static inline void device_init_wakeup(struct device *dev, bool val)
 {
-        dev->power.can_wakeup = dev->power.should_wakeup = !!val;
+        dev->power.can_wakeup = dev->power.should_wakeup = val;
 }
 
-static inline void device_set_wakeup_capable(struct device *dev, int val)
+static inline void device_set_wakeup_capable(struct device *dev, bool capable)
 {
-        dev->power.can_wakeup = !!val;
+        dev->power.can_wakeup = capable;
 }
 
-static inline int device_can_wakeup(struct device *dev)
+static inline bool device_can_wakeup(struct device *dev)
 {
         return dev->power.can_wakeup;
 }
 
-static inline void device_set_wakeup_enable(struct device *dev, int val)
+static inline void device_set_wakeup_enable(struct device *dev, bool enable)
 {
-        dev->power.should_wakeup = !!val;
+        dev->power.should_wakeup = enable;
 }
 
-static inline int device_may_wakeup(struct device *dev)
+static inline bool device_may_wakeup(struct device *dev)
 {
         return dev->power.can_wakeup && dev->power.should_wakeup;
 }
@@ -58,20 +60,28 @@ static inline int device_may_wakeup(struct device *dev)
 #else /* !CONFIG_PM */
 
 /* For some reason the next two routines work even without CONFIG_PM */
-static inline void device_init_wakeup(struct device *dev, int val)
+static inline void device_init_wakeup(struct device *dev, bool val)
 {
-        dev->power.can_wakeup = !!val;
+        dev->power.can_wakeup = val;
 }
 
-static inline void device_set_wakeup_capable(struct device *dev, int val) { }
+static inline void device_set_wakeup_capable(struct device *dev, bool capable)
+{
+}
 
-static inline int device_can_wakeup(struct device *dev)
+static inline bool device_can_wakeup(struct device *dev)
 {
         return dev->power.can_wakeup;
 }
 
-#define device_set_wakeup_enable(dev, val)      do {} while (0)
-#define device_may_wakeup(dev)                  0
+static inline void device_set_wakeup_enable(struct device *dev, bool enable)
+{
+}
+
+static inline bool device_may_wakeup(struct device *dev)
+{
+        return false;
+}
 
 #endif /* !CONFIG_PM */
 
diff --git a/include/linux/ppp_channel.h b/include/linux/ppp_channel.h
index 0d3fa63e90ea..bff98ec1bfed 100644
--- a/include/linux/ppp_channel.h
+++ b/include/linux/ppp_channel.h
@@ -72,6 +72,9 @@ extern int ppp_channel_index(struct ppp_channel *);
 /* Get the unit number associated with a channel, or -1 if none */
 extern int ppp_unit_number(struct ppp_channel *);
 
+/* Get the device name associated with a channel, or NULL if none */
+extern char *ppp_dev_name(struct ppp_channel *);
+
 /*
  * SMP locking notes:
  * The channel code must ensure that when it calls ppp_unregister_channel,
diff --git a/include/linux/quota.h b/include/linux/quota.h
index b462916b2a0a..7126a15467f1 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -174,6 +174,8 @@ enum {
 #include <linux/rwsem.h>
 #include <linux/spinlock.h>
 #include <linux/wait.h>
+#include <linux/percpu.h>
+#include <linux/smp.h>
 
 #include <linux/dqblk_xfs.h>
 #include <linux/dqblk_v1.h>
@@ -238,19 +240,43 @@ static inline int info_dirty(struct mem_dqinfo *info)
         return test_bit(DQF_INFO_DIRTY_B, &info->dqi_flags);
 }
 
+enum {
+        DQST_LOOKUPS,
+        DQST_DROPS,
+        DQST_READS,
+        DQST_WRITES,
+        DQST_CACHE_HITS,
+        DQST_ALLOC_DQUOTS,
+        DQST_FREE_DQUOTS,
+        DQST_SYNCS,
+        _DQST_DQSTAT_LAST
+};
+
 struct dqstats {
-        int lookups;
-        int drops;
-        int reads;
-        int writes;
-        int cache_hits;
-        int allocated_dquots;
-        int free_dquots;
-        int syncs;
+        int stat[_DQST_DQSTAT_LAST];
 };
 
+extern struct dqstats *dqstats_pcpu;
 extern struct dqstats dqstats;
 
+static inline void dqstats_inc(unsigned int type)
+{
+#ifdef CONFIG_SMP
+        per_cpu_ptr(dqstats_pcpu, smp_processor_id())->stat[type]++;
+#else
+        dqstats.stat[type]++;
+#endif
+}
+
+static inline void dqstats_dec(unsigned int type)
+{
+#ifdef CONFIG_SMP
+        per_cpu_ptr(dqstats_pcpu, smp_processor_id())->stat[type]--;
+#else
+        dqstats.stat[type]--;
+#endif
+}
+
 #define DQ_MOD_B        0       /* dquot modified since read */
 #define DQ_BLKS_B       1       /* uid/gid has been warned about blk limit */
 #define DQ_INODES_B     2       /* uid/gid has been warned about inode limit */
@@ -311,12 +337,10 @@ struct quotactl_ops {
         int (*quota_sync)(struct super_block *, int, int);
         int (*get_info)(struct super_block *, int, struct if_dqinfo *);
         int (*set_info)(struct super_block *, int, struct if_dqinfo *);
-        int (*get_dqblk)(struct super_block *, int, qid_t, struct if_dqblk *);
-        int (*set_dqblk)(struct super_block *, int, qid_t, struct if_dqblk *);
+        int (*get_dqblk)(struct super_block *, int, qid_t, struct fs_disk_quota *);
+        int (*set_dqblk)(struct super_block *, int, qid_t, struct fs_disk_quota *);
         int (*get_xstate)(struct super_block *, struct fs_quota_stat *);
         int (*set_xstate)(struct super_block *, unsigned int, int);
-        int (*get_xquota)(struct super_block *, int, qid_t, struct fs_disk_quota *);
-        int (*set_xquota)(struct super_block *, int, qid_t, struct fs_disk_quota *);
 };
 
 struct quota_format_type {
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index e6fa7acce290..370abb1e99cb 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -14,6 +14,14 @@ static inline struct quota_info *sb_dqopt(struct super_block *sb)
         return &sb->s_dquot;
 }
 
+/* i_mutex must being held */
+static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
+{
+        return (ia->ia_valid & ATTR_SIZE && ia->ia_size != inode->i_size) ||
+                (ia->ia_valid & ATTR_UID && ia->ia_uid != inode->i_uid) ||
+                (ia->ia_valid & ATTR_GID && ia->ia_gid != inode->i_gid);
+}
+
 #if defined(CONFIG_QUOTA)
 
 /*
@@ -63,9 +71,12 @@ int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags);
 int vfs_quota_sync(struct super_block *sb, int type, int wait);
 int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
 int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
-int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
-int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
+int vfs_get_dqblk(struct super_block *sb, int type, qid_t id,
+                struct fs_disk_quota *di);
+int vfs_set_dqblk(struct super_block *sb, int type, qid_t id,
+                struct fs_disk_quota *di);
 
+int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
 int dquot_transfer(struct inode *inode, struct iattr *iattr);
 int vfs_dq_quota_on_remount(struct super_block *sb);
 
diff --git a/include/linux/ramfs.h b/include/linux/ramfs.h
index 4e768dda87b0..e7320b5e82fb 100644
--- a/include/linux/ramfs.h
+++ b/include/linux/ramfs.h
@@ -1,7 +1,8 @@
 #ifndef _LINUX_RAMFS_H
 #define _LINUX_RAMFS_H
 
-struct inode *ramfs_get_inode(struct super_block *sb, int mode, dev_t dev);
+struct inode *ramfs_get_inode(struct super_block *sb, const struct inode *dir,
+         int mode, dev_t dev);
 extern int ramfs_get_sb(struct file_system_type *fs_type,
          int flags, const char *dev_name, void *data, struct vfsmount *mnt);
 
@@ -20,4 +21,6 @@ extern const struct file_operations ramfs_file_operations;
 extern const struct vm_operations_struct generic_file_vm_ops;
 extern int __init init_rootfs(void);
 
+int ramfs_fill_super(struct super_block *sb, void *data, int silent);
+
 #endif
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index 2c9b46cff3d7..4ec3b38ce9c5 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -428,5 +428,47 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
                 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; }); \
                 pos = rcu_dereference_raw(pos->next))
 
+/**
+ * hlist_for_each_entry_rcu_bh - iterate over rcu list of given type
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct hlist_node to use as a loop cursor.
+ * @head:       the head for your list.
+ * @member:     the name of the hlist_node within the struct.
+ *
+ * This list-traversal primitive may safely run concurrently with
+ * the _rcu list-mutation primitives such as hlist_add_head_rcu()
+ * as long as the traversal is guarded by rcu_read_lock().
+ */
+#define hlist_for_each_entry_rcu_bh(tpos, pos, head, member)             \
+        for (pos = rcu_dereference_bh((head)->first);                    \
+                pos && ({ prefetch(pos->next); 1; }) &&                  \
+                ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; }); \
+                pos = rcu_dereference_bh(pos->next))
+
+/**
+ * hlist_for_each_entry_continue_rcu - iterate over a hlist continuing after current point
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct hlist_node to use as a loop cursor.
+ * @member:     the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry_continue_rcu(tpos, pos, member)            \
+        for (pos = rcu_dereference((pos)->next);                        \
+             pos && ({ prefetch(pos->next); 1; }) &&                    \
+             ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; });  \
+             pos = rcu_dereference(pos->next))
+
+/**
+ * hlist_for_each_entry_continue_rcu_bh - iterate over a hlist continuing after current point
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct hlist_node to use as a loop cursor.
+ * @member:     the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry_continue_rcu_bh(tpos, pos, member)         \
+        for (pos = rcu_dereference_bh((pos)->next);                     \
+             pos && ({ prefetch(pos->next); 1; }) &&                    \
+             ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; });  \
+             pos = rcu_dereference_bh(pos->next))
+
+
 #endif  /* __KERNEL__ */
 #endif
diff --git a/include/linux/reiserfs_acl.h b/include/linux/reiserfs_acl.h
index b4448853900e..3fd8c4506bbb 100644
--- a/include/linux/reiserfs_acl.h
+++ b/include/linux/reiserfs_acl.h
@@ -53,8 +53,8 @@ int reiserfs_inherit_default_acl(struct reiserfs_transaction_handle *th,
                                  struct inode *dir, struct dentry *dentry,
                                  struct inode *inode);
 int reiserfs_cache_default_acl(struct inode *dir);
-extern struct xattr_handler reiserfs_posix_acl_default_handler;
-extern struct xattr_handler reiserfs_posix_acl_access_handler;
+extern const struct xattr_handler reiserfs_posix_acl_default_handler;
+extern const struct xattr_handler reiserfs_posix_acl_access_handler;
 
 #else
 
diff --git a/include/linux/reiserfs_xattr.h b/include/linux/reiserfs_xattr.h
index 7fa02b4af838..b2cf2089769b 100644
--- a/include/linux/reiserfs_xattr.h
+++ b/include/linux/reiserfs_xattr.h
@@ -58,9 +58,9 @@ int reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *,
                               struct inode *, const char *, const void *,
                               size_t, int);
 
-extern struct xattr_handler reiserfs_xattr_user_handler;
-extern struct xattr_handler reiserfs_xattr_trusted_handler;
-extern struct xattr_handler reiserfs_xattr_security_handler;
+extern const struct xattr_handler reiserfs_xattr_user_handler;
+extern const struct xattr_handler reiserfs_xattr_trusted_handler;
+extern const struct xattr_handler reiserfs_xattr_security_handler;
 #ifdef CONFIG_REISERFS_FS_SECURITY
 int reiserfs_security_init(struct inode *dir, struct inode *inode,
                            struct reiserfs_security_handle *sec);
diff --git a/include/linux/rtc-v3020.h b/include/linux/rtc-v3020.h
index 8ba646e610d9..e55d82cebf80 100644
--- a/include/linux/rtc-v3020.h
+++ b/include/linux/rtc-v3020.h
@@ -15,7 +15,7 @@
 struct v3020_platform_data {
         int leftshift; /* (1<<(leftshift)) & readl() */
 
-        int use_gpio:1;
+        unsigned int use_gpio:1;
         unsigned int gpio_cs;
         unsigned int gpio_wr;
         unsigned int gpio_rd;
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index d1c7c90e9cd4..fbc8cb0d48c3 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -7,6 +7,13 @@
 #include <linux/if_addr.h>
 #include <linux/neighbour.h>
 
+/* rtnetlink families. Values up to 127 are reserved for real address
+ * families, values above 128 may be used arbitrarily.
+ */
+#define RTNL_FAMILY_IPMR                128
+#define RTNL_FAMILY_IP6MR               129
+#define RTNL_FAMILY_MAX                 129
+
 /****
  *              Routing/neighbour discovery messages.
  ****/
diff --git a/include/linux/security.h b/include/linux/security.h
index 3158dd982d27..0c8819170463 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -267,49 +267,16 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      @orig the original mount data copied from userspace.
  *      @copy copied data which will be passed to the security module.
  *      Returns 0 if the copy was successful.
- * @sb_check_sb:
- *      Check permission before the device with superblock @mnt->sb is mounted
- *      on the mount point named by @nd.
- *      @mnt contains the vfsmount for device being mounted.
- *      @path contains the path for the mount point.
- *      Return 0 if permission is granted.
  * @sb_umount:
  *      Check permission before the @mnt file system is unmounted.
  *      @mnt contains the mounted file system.
  *      @flags contains the unmount flags, e.g. MNT_FORCE.
  *      Return 0 if permission is granted.
- * @sb_umount_close:
- *      Close any files in the @mnt mounted filesystem that are held open by
- *      the security module.  This hook is called during an umount operation
- *      prior to checking whether the filesystem is still busy.
- *      @mnt contains the mounted filesystem.
- * @sb_umount_busy:
- *      Handle a failed umount of the @mnt mounted filesystem, e.g.  re-opening
- *      any files that were closed by umount_close.  This hook is called during
- *      an umount operation if the umount fails after a call to the
- *      umount_close hook.
- *      @mnt contains the mounted filesystem.
- * @sb_post_remount:
- *      Update the security module's state when a filesystem is remounted.
- *      This hook is only called if the remount was successful.
- *      @mnt contains the mounted file system.
- *      @flags contains the new filesystem flags.
- *      @data contains the filesystem-specific data.
- * @sb_post_addmount:
- *      Update the security module's state when a filesystem is mounted.
- *      This hook is called any time a mount is successfully grafetd to
- *      the tree.
- *      @mnt contains the mounted filesystem.
- *      @mountpoint contains the path for the mount point.
  * @sb_pivotroot:
  *      Check permission before pivoting the root filesystem.
  *      @old_path contains the path for the new location of the current root (put_old).
  *      @new_path contains the path for the new root (new_root).
  *      Return 0 if permission is granted.
- * @sb_post_pivotroot:
- *      Update module state after a successful pivot.
- *      @old_path contains the path for the old root.
- *      @new_path contains the path for the new root.
  * @sb_set_mnt_opts:
  *      Set the security relevant mount options used for a superblock
  *      @sb the superblock to set security mount options for
@@ -511,12 +478,6 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      @mnt is the vfsmount where the dentry was looked up
  *      @dentry contains the dentry structure for the file.
  *      Return 0 if permission is granted.
- * @inode_delete:
- *      @inode contains the inode structure for deleted inode.
- *      This hook is called when a deleted inode is released (i.e. an inode
- *      with no hard links has its use count drop to zero).  A security module
- *      can use this hook to release any persistent label associated with the
- *      inode.
  * @inode_setxattr:
  *      Check permission before setting the extended attributes
  *      @value identified by @name for @dentry.
@@ -691,10 +652,6 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      @old points to the original credentials.
  *      @gfp indicates the atomicity of any memory allocations.
  *      Prepare a new set of credentials by copying the data from the old set.
- * @cred_commit:
- *      @new points to the new credentials.
- *      @old points to the original credentials.
- *      Install a new set of credentials.
  * @cred_transfer:
  *      @new points to the new credentials.
  *      @old points to the original credentials.
@@ -717,18 +674,6 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      userspace to load a kernel module with the given name.
  *      @kmod_name name of the module requested by the kernel
  *      Return 0 if successful.
- * @task_setuid:
- *      Check permission before setting one or more of the user identity
- *      attributes of the current process.  The @flags parameter indicates
- *      which of the set*uid system calls invoked this hook and how to
- *      interpret the @id0, @id1, and @id2 parameters.  See the LSM_SETID
- *      definitions at the beginning of this file for the @flags values and
- *      their meanings.
- *      @id0 contains a uid.
- *      @id1 contains a uid.
- *      @id2 contains a uid.
- *      @flags contains one of the LSM_SETID_* values.
- *      Return 0 if permission is granted.
  * @task_fix_setuid:
  *      Update the module's state after setting one or more of the user
  *      identity attributes of the current process.  The @flags parameter
@@ -738,18 +683,6 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      @old is the set of credentials that are being replaces
  *      @flags contains one of the LSM_SETID_* values.
  *      Return 0 on success.
- * @task_setgid:
- *      Check permission before setting one or more of the group identity
- *      attributes of the current process.  The @flags parameter indicates
- *      which of the set*gid system calls invoked this hook and how to
- *      interpret the @id0, @id1, and @id2 parameters.  See the LSM_SETID
- *      definitions at the beginning of this file for the @flags values and
- *      their meanings.
- *      @id0 contains a gid.
- *      @id1 contains a gid.
- *      @id2 contains a gid.
- *      @flags contains one of the LSM_SETID_* values.
- *      Return 0 if permission is granted.
  * @task_setpgid:
  *      Check permission before setting the process group identifier of the
  *      process @p to @pgid.
@@ -771,11 +704,6 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      @p contains the task_struct for the process and place is into @secid.
  *      In case of failure, @secid will be set to zero.
  *
- * @task_setgroups:
- *      Check permission before setting the supplementary group set of the
- *      current process.
- *      @group_info contains the new group information.
- *      Return 0 if permission is granted.
  * @task_setnice:
  *      Check permission before setting the nice value of @p to @nice.
  *      @p contains the task_struct of process.
@@ -1139,13 +1067,6 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      Return the length of the string (including terminating NUL) or -ve if
  *      an error.
  *      May also return 0 (and a NULL buffer pointer) if there is no label.
- * @key_session_to_parent:
- *      Forcibly assign the session keyring from a process to its parent
- *      process.
- *      @cred: Pointer to process's credentials
- *      @parent_cred: Pointer to parent process's credentials
- *      @keyring: Proposed new session keyring
- *      Return 0 if permission is granted, -ve error otherwise.
  *
  * Security hooks affecting all System V IPC operations.
  *
@@ -1333,13 +1254,6 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      @cap contains the capability <include/linux/capability.h>.
  *      @audit: Whether to write an audit message or not
  *      Return 0 if the capability is granted for @tsk.
- * @acct:
- *      Check permission before enabling or disabling process accounting.  If
- *      accounting is being enabled, then @file refers to the open file used to
- *      store accounting records.  If accounting is being disabled, then @file
- *      is NULL.
- *      @file contains the file structure for the accounting file (may be NULL).
- *      Return 0 if permission is granted.
  * @sysctl:
  *      Check permission before accessing the @table sysctl variable in the
  *      manner specified by @op.
@@ -1462,7 +1376,6 @@ struct security_operations {
                        const kernel_cap_t *permitted);
         int (*capable) (struct task_struct *tsk, const struct cred *cred,
                         int cap, int audit);
-        int (*acct) (struct file *file);
         int (*sysctl) (struct ctl_table *table, int op);
         int (*quotactl) (int cmds, int type, int id, struct super_block *sb);
         int (*quota_on) (struct dentry *dentry);
@@ -1484,18 +1397,9 @@ struct security_operations {
         int (*sb_statfs) (struct dentry *dentry);
         int (*sb_mount) (char *dev_name, struct path *path,
                          char *type, unsigned long flags, void *data);
-        int (*sb_check_sb) (struct vfsmount *mnt, struct path *path);
         int (*sb_umount) (struct vfsmount *mnt, int flags);
-        void (*sb_umount_close) (struct vfsmount *mnt);
-        void (*sb_umount_busy) (struct vfsmount *mnt);
-        void (*sb_post_remount) (struct vfsmount *mnt,
-                                 unsigned long flags, void *data);
-        void (*sb_post_addmount) (struct vfsmount *mnt,
-                                  struct path *mountpoint);
         int (*sb_pivotroot) (struct path *old_path,
                              struct path *new_path);
-        void (*sb_post_pivotroot) (struct path *old_path,
-                                   struct path *new_path);
         int (*sb_set_mnt_opts) (struct super_block *sb,
                                 struct security_mnt_opts *opts);
         void (*sb_clone_mnt_opts) (const struct super_block *oldsb,
@@ -1544,7 +1448,6 @@ struct security_operations {
         int (*inode_permission) (struct inode *inode, int mask);
         int (*inode_setattr)    (struct dentry *dentry, struct iattr *attr);
         int (*inode_getattr) (struct vfsmount *mnt, struct dentry *dentry);
-        void (*inode_delete) (struct inode *inode);
         int (*inode_setxattr) (struct dentry *dentry, const char *name,
                                const void *value, size_t size, int flags);
         void (*inode_post_setxattr) (struct dentry *dentry, const char *name,
@@ -1585,20 +1488,16 @@ struct security_operations {
         void (*cred_free) (struct cred *cred);
         int (*cred_prepare)(struct cred *new, const struct cred *old,
                             gfp_t gfp);
-        void (*cred_commit)(struct cred *new, const struct cred *old);
         void (*cred_transfer)(struct cred *new, const struct cred *old);
         int (*kernel_act_as)(struct cred *new, u32 secid);
         int (*kernel_create_files_as)(struct cred *new, struct inode *inode);
         int (*kernel_module_request)(char *kmod_name);
-        int (*task_setuid) (uid_t id0, uid_t id1, uid_t id2, int flags);
         int (*task_fix_setuid) (struct cred *new, const struct cred *old,
                                 int flags);
-        int (*task_setgid) (gid_t id0, gid_t id1, gid_t id2, int flags);
         int (*task_setpgid) (struct task_struct *p, pid_t pgid);
         int (*task_getpgid) (struct task_struct *p);
         int (*task_getsid) (struct task_struct *p);
         void (*task_getsecid) (struct task_struct *p, u32 *secid);
-        int (*task_setgroups) (struct group_info *group_info);
         int (*task_setnice) (struct task_struct *p, int nice);
         int (*task_setioprio) (struct task_struct *p, int ioprio);
         int (*task_getioprio) (struct task_struct *p);
@@ -1728,9 +1627,6 @@ struct security_operations {
                                const struct cred *cred,
                                key_perm_t perm);
         int (*key_getsecurity)(struct key *key, char **_buffer);
-        int (*key_session_to_parent)(const struct cred *cred,
-                                     const struct cred *parent_cred,
-                                     struct key *key);
 #endif  /* CONFIG_KEYS */
 
 #ifdef CONFIG_AUDIT
@@ -1761,7 +1657,6 @@ int security_capset(struct cred *new, const struct cred *old,
 int security_capable(int cap);
 int security_real_capable(struct task_struct *tsk, int cap);
 int security_real_capable_noaudit(struct task_struct *tsk, int cap);
-int security_acct(struct file *file);
 int security_sysctl(struct ctl_table *table, int op);
 int security_quotactl(int cmds, int type, int id, struct super_block *sb);
 int security_quota_on(struct dentry *dentry);
@@ -1783,14 +1678,8 @@ int security_sb_show_options(struct seq_file *m, struct super_block *sb);
 int security_sb_statfs(struct dentry *dentry);
 int security_sb_mount(char *dev_name, struct path *path,
                       char *type, unsigned long flags, void *data);
-int security_sb_check_sb(struct vfsmount *mnt, struct path *path);
 int security_sb_umount(struct vfsmount *mnt, int flags);
-void security_sb_umount_close(struct vfsmount *mnt);
-void security_sb_umount_busy(struct vfsmount *mnt);
-void security_sb_post_remount(struct vfsmount *mnt, unsigned long flags, void *data);
-void security_sb_post_addmount(struct vfsmount *mnt, struct path *mountpoint);
 int security_sb_pivotroot(struct path *old_path, struct path *new_path);
-void security_sb_post_pivotroot(struct path *old_path, struct path *new_path);
 int security_sb_set_mnt_opts(struct super_block *sb, struct security_mnt_opts *opts);
 void security_sb_clone_mnt_opts(const struct super_block *oldsb,
                                 struct super_block *newsb);
@@ -1816,7 +1705,6 @@ int security_inode_follow_link(struct dentry *dentry, struct nameidata *nd);
 int security_inode_permission(struct inode *inode, int mask);
 int security_inode_setattr(struct dentry *dentry, struct iattr *attr);
 int security_inode_getattr(struct vfsmount *mnt, struct dentry *dentry);
-void security_inode_delete(struct inode *inode);
 int security_inode_setxattr(struct dentry *dentry, const char *name,
                             const void *value, size_t size, int flags);
 void security_inode_post_setxattr(struct dentry *dentry, const char *name,
@@ -1850,20 +1738,16 @@ int security_task_create(unsigned long clone_flags);
 int security_cred_alloc_blank(struct cred *cred, gfp_t gfp);
 void security_cred_free(struct cred *cred);
 int security_prepare_creds(struct cred *new, const struct cred *old, gfp_t gfp);
-void security_commit_creds(struct cred *new, const struct cred *old);
 void security_transfer_creds(struct cred *new, const struct cred *old);
 int security_kernel_act_as(struct cred *new, u32 secid);
 int security_kernel_create_files_as(struct cred *new, struct inode *inode);
 int security_kernel_module_request(char *kmod_name);
-int security_task_setuid(uid_t id0, uid_t id1, uid_t id2, int flags);
 int security_task_fix_setuid(struct cred *new, const struct cred *old,
                              int flags);
-int security_task_setgid(gid_t id0, gid_t id1, gid_t id2, int flags);
 int security_task_setpgid(struct task_struct *p, pid_t pgid);
 int security_task_getpgid(struct task_struct *p);
 int security_task_getsid(struct task_struct *p);
 void security_task_getsecid(struct task_struct *p, u32 *secid);
-int security_task_setgroups(struct group_info *group_info);
 int security_task_setnice(struct task_struct *p, int nice);
 int security_task_setioprio(struct task_struct *p, int ioprio);
 int security_task_getioprio(struct task_struct *p);
@@ -1990,11 +1874,6 @@ int security_real_capable_noaudit(struct task_struct *tsk, int cap)
         return ret;
 }
 
-static inline int security_acct(struct file *file)
-{
-        return 0;
-}
-
 static inline int security_sysctl(struct ctl_table *table, int op)
 {
         return 0;
@@ -2099,41 +1978,17 @@ static inline int security_sb_mount(char *dev_name, struct path *path,
         return 0;
 }
 
-static inline int security_sb_check_sb(struct vfsmount *mnt,
-                                       struct path *path)
-{
-        return 0;
-}
-
 static inline int security_sb_umount(struct vfsmount *mnt, int flags)
 {
         return 0;
 }
 
-static inline void security_sb_umount_close(struct vfsmount *mnt)
-{ }
-
-static inline void security_sb_umount_busy(struct vfsmount *mnt)
-{ }
-
-static inline void security_sb_post_remount(struct vfsmount *mnt,
-                                             unsigned long flags, void *data)
-{ }
-
-static inline void security_sb_post_addmount(struct vfsmount *mnt,
-                                             struct path *mountpoint)
-{ }
-
 static inline int security_sb_pivotroot(struct path *old_path,
                                         struct path *new_path)
 {
         return 0;
 }
 
-static inline void security_sb_post_pivotroot(struct path *old_path,
-                                              struct path *new_path)
-{ }
-
 static inline int security_sb_set_mnt_opts(struct super_block *sb,
                                            struct security_mnt_opts *opts)
 {
@@ -2249,9 +2104,6 @@ static inline int security_inode_getattr(struct vfsmount *mnt,
         return 0;
 }
 
-static inline void security_inode_delete(struct inode *inode)
-{ }
-
 static inline int security_inode_setxattr(struct dentry *dentry,
                 const char *name, const void *value, size_t size, int flags)
 {
@@ -2398,11 +2250,6 @@ static inline int security_prepare_creds(struct cred *new,
         return 0;
 }
 
-static inline void security_commit_creds(struct cred *new,
-                                         const struct cred *old)
-{
-}
-
 static inline void security_transfer_creds(struct cred *new,
                                            const struct cred *old)
 {
@@ -2424,12 +2271,6 @@ static inline int security_kernel_module_request(char *kmod_name)
         return 0;
 }
 
-static inline int security_task_setuid(uid_t id0, uid_t id1, uid_t id2,
-                                       int flags)
-{
-        return 0;
-}
-
 static inline int security_task_fix_setuid(struct cred *new,
                                            const struct cred *old,
                                            int flags)
@@ -2437,12 +2278,6 @@ static inline int security_task_fix_setuid(struct cred *new,
         return cap_task_fix_setuid(new, old, flags);
 }
 
-static inline int security_task_setgid(gid_t id0, gid_t id1, gid_t id2,
-                                       int flags)
-{
-        return 0;
-}
-
 static inline int security_task_setpgid(struct task_struct *p, pid_t pgid)
 {
         return 0;
@@ -2463,11 +2298,6 @@ static inline void security_task_getsecid(struct task_struct *p, u32 *secid)
         *secid = 0;
 }
 
-static inline int security_task_setgroups(struct group_info *group_info)
-{
-        return 0;
-}
-
 static inline int security_task_setnice(struct task_struct *p, int nice)
 {
         return cap_task_setnice(p, nice);
@@ -3064,9 +2894,6 @@ void security_key_free(struct key *key);
 int security_key_permission(key_ref_t key_ref,
                             const struct cred *cred, key_perm_t perm);
 int security_key_getsecurity(struct key *key, char **_buffer);
-int security_key_session_to_parent(const struct cred *cred,
-                                   const struct cred *parent_cred,
-                                   struct key *key);
 
 #else
 
@@ -3094,13 +2921,6 @@ static inline int security_key_getsecurity(struct key *key, char **_buffer)
         return 0;
 }
 
-static inline int security_key_session_to_parent(const struct cred *cred,
-                                                 const struct cred *parent_cred,
-                                                 struct key *key)
-{
-        return 0;
-}
-
 #endif
 #endif /* CONFIG_KEYS */
 
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 78dd1e7120a9..f10db6e5f3b5 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -182,6 +182,10 @@
 /* Aeroflex Gaisler GRLIB APBUART */
 #define PORT_APBUART    90
 
+/* Altera UARTs */
+#define PORT_ALTERA_JTAGUART    91
+#define PORT_ALTERA_UART        92
+
 #ifdef __KERNEL__
 
 #include <linux/compiler.h>
@@ -246,6 +250,7 @@ struct uart_ops {
 #endif
 };
 
+#define NO_POLL_CHAR            0x00ff0000
 #define UART_CONFIG_TYPE        (1 << 0)
 #define UART_CONFIG_IRQ         (1 << 1)
 
diff --git a/include/linux/serio.h b/include/linux/serio.h
index 64b473066b9a..b5552568178d 100644
--- a/include/linux/serio.h
+++ b/include/linux/serio.h
@@ -196,5 +196,6 @@ static inline void serio_continue_rx(struct serio *serio)
 #define SERIO_TOUCHIT213        0x38
 #define SERIO_W8001     0x39
 #define SERIO_DYNAPRO   0x3a
+#define SERIO_HAMPSHIRE 0x3b
 
 #endif
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 124f90cd5a38..7cdfb4d52847 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -187,7 +187,6 @@ union skb_shared_tx {
  * the end of the header data, ie. at skb->end.
  */
 struct skb_shared_info {
-        atomic_t        dataref;
         unsigned short  nr_frags;
         unsigned short  gso_size;
         /* Warning: this field is not always filled in (UFO)! */
@@ -197,6 +196,12 @@ struct skb_shared_info {
         union skb_shared_tx tx_flags;
         struct sk_buff  *frag_list;
         struct skb_shared_hwtstamps hwtstamps;
+
+        /*
+         * Warning : all fields before dataref are cleared in __alloc_skb()
+         */
+        atomic_t        dataref;
+
         skb_frag_t      frags[MAX_SKB_FRAGS];
         /* Intermediate layers must ensure that destructor_arg
          * remains valid until skb destructor */
@@ -259,7 +264,7 @@ typedef unsigned char *sk_buff_data_t;
  *      @transport_header: Transport layer header
  *      @network_header: Network layer header
  *      @mac_header: Link layer header
- *      @_skb_dst: destination entry
+ *      @_skb_refdst: destination entry (with norefcount bit)
  *      @sp: the security path, used for xfrm
  *      @cb: Control buffer. Free for use by every layer. Put private vars here
  *      @len: Length of actual data
@@ -294,6 +299,7 @@ typedef unsigned char *sk_buff_data_t;
  *      @nfct_reasm: netfilter conntrack re-assembly pointer
  *      @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
  *      @skb_iif: ifindex of device we arrived on
+ *      @rxhash: the packet hash computed on receive
  *      @queue_mapping: Queue mapping for multiqueue devices
  *      @tc_index: Traffic control index
  *      @tc_verd: traffic control verdict
@@ -322,7 +328,7 @@ struct sk_buff {
          */
         char                    cb[48] __aligned(8);
 
-        unsigned long           _skb_dst;
+        unsigned long           _skb_refdst;
 #ifdef CONFIG_XFRM
         struct  sec_path        *sp;
 #endif
@@ -369,6 +375,8 @@ struct sk_buff {
 #endif
 #endif
 
+        __u32                   rxhash;
+
         kmemcheck_bitfield_begin(flags2);
         __u16                   queue_mapping:16;
 #ifdef CONFIG_IPV6_NDISC_NODETYPE
@@ -411,14 +419,64 @@ struct sk_buff {
 
 #include <asm/system.h>
 
+/*
+ * skb might have a dst pointer attached, refcounted or not.
+ * _skb_refdst low order bit is set if refcount was _not_ taken
+ */
+#define SKB_DST_NOREF   1UL
+#define SKB_DST_PTRMASK ~(SKB_DST_NOREF)
+
+/**
+ * skb_dst - returns skb dst_entry
+ * @skb: buffer
+ *
+ * Returns skb dst_entry, regardless of reference taken or not.
+ */
 static inline struct dst_entry *skb_dst(const struct sk_buff *skb)
 {
-        return (struct dst_entry *)skb->_skb_dst;
+        /* If refdst was not refcounted, check we still are in a 
+         * rcu_read_lock section
+         */
+        WARN_ON((skb->_skb_refdst & SKB_DST_NOREF) &&
+                !rcu_read_lock_held() &&
+                !rcu_read_lock_bh_held());
+        return (struct dst_entry *)(skb->_skb_refdst & SKB_DST_PTRMASK);
 }
 
+/**
+ * skb_dst_set - sets skb dst
+ * @skb: buffer
+ * @dst: dst entry
+ *
+ * Sets skb dst, assuming a reference was taken on dst and should
+ * be released by skb_dst_drop()
+ */
 static inline void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst)
 {
-        skb->_skb_dst = (unsigned long)dst;
+        skb->_skb_refdst = (unsigned long)dst;
+}
+
+/**
+ * skb_dst_set_noref - sets skb dst, without a reference
+ * @skb: buffer
+ * @dst: dst entry
+ *
+ * Sets skb dst, assuming a reference was not taken on dst
+ * skb_dst_drop() should not dst_release() this dst
+ */
+static inline void skb_dst_set_noref(struct sk_buff *skb, struct dst_entry *dst)
+{
+        WARN_ON(!rcu_read_lock_held() && !rcu_read_lock_bh_held());
+        skb->_skb_refdst = (unsigned long)dst | SKB_DST_NOREF;
+}
+
+/**
+ * skb_dst_is_noref - Test if skb dst isnt refcounted
+ * @skb: buffer
+ */
+static inline bool skb_dst_is_noref(const struct sk_buff *skb)
+{
+        return (skb->_skb_refdst & SKB_DST_NOREF) && skb_dst(skb);
 }
 
 static inline struct rtable *skb_rtable(const struct sk_buff *skb)
@@ -467,11 +525,6 @@ extern int	       skb_cow_data(struct sk_buff *skb, int tailbits,
                                     struct sk_buff **trailer);
 extern int             skb_pad(struct sk_buff *skb, int pad);
 #define dev_kfree_skb(a)        consume_skb(a)
-#define dev_consume_skb(a)      kfree_skb_clean(a)
-extern void           skb_over_panic(struct sk_buff *skb, int len,
-                                     void *here);
-extern void           skb_under_panic(struct sk_buff *skb, int len,
-                                      void *here);
 
 extern int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
                         int getfrag(void *from, char *to, int offset,
@@ -1130,6 +1183,11 @@ static inline unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len)
         return skb->data += len;
 }
 
+static inline unsigned char *skb_pull_inline(struct sk_buff *skb, unsigned int len)
+{
+        return unlikely(len > skb->len) ? NULL : __skb_pull(skb, len);
+}
+
 extern unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta);
 
 static inline unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len)
@@ -1353,9 +1411,12 @@ static inline int skb_network_offset(const struct sk_buff *skb)
  *
  * Various parts of the networking layer expect at least 32 bytes of
  * headroom, you should not reduce this.
+ * With RPS, we raised NET_SKB_PAD to 64 so that get_rps_cpus() fetches span
+ * a 64 bytes aligned block to fit modern (>= 64 bytes) cache line sizes
+ * NET_IP_ALIGN(2) + ethernet_header(14) + IP_header(20/40) + ports(8)
  */
 #ifndef NET_SKB_PAD
-#define NET_SKB_PAD     32
+#define NET_SKB_PAD     64
 #endif
 
 extern int ___pskb_trim(struct sk_buff *skb, unsigned int len);
diff --git a/include/linux/snmp.h b/include/linux/snmp.h
index 4435d1084755..52797714ade7 100644
--- a/include/linux/snmp.h
+++ b/include/linux/snmp.h
@@ -100,6 +100,7 @@ enum
         ICMP6_MIB_INMSGS,                       /* InMsgs */
         ICMP6_MIB_INERRORS,                     /* InErrors */
         ICMP6_MIB_OUTMSGS,                      /* OutMsgs */
+        ICMP6_MIB_OUTERRORS,                    /* OutErrors */
         __ICMP6_MIB_MAX
 };
 
@@ -227,6 +228,7 @@ enum
         LINUX_MIB_SACKSHIFTFALLBACK,
         LINUX_MIB_TCPBACKLOGDROP,
         LINUX_MIB_TCPMINTTLDROP, /* RFC 5082 */
+        LINUX_MIB_TCPDEFERACCEPTDROP,
         __LINUX_MIB_MAX
 };
 
diff --git a/include/linux/socket.h b/include/linux/socket.h
index 354cc5617f8b..032a19eb61b1 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -189,7 +189,8 @@ struct ucred {
 #define AF_ISDN         34      /* mISDN sockets                */
 #define AF_PHONET       35      /* Phonet sockets               */
 #define AF_IEEE802154   36      /* IEEE802154 sockets           */
-#define AF_MAX          37      /* For now.. */
+#define AF_CAIF         37      /* CAIF sockets                 */
+#define AF_MAX          38      /* For now.. */
 
 /* Protocol families, same as address families. */
 #define PF_UNSPEC       AF_UNSPEC
@@ -229,6 +230,7 @@ struct ucred {
 #define PF_ISDN         AF_ISDN
 #define PF_PHONET       AF_PHONET
 #define PF_IEEE802154   AF_IEEE802154
+#define PF_CAIF         AF_CAIF
 #define PF_MAX          AF_MAX
 
 /* Maximum queue length specifiable by listen.  */
@@ -301,6 +303,7 @@ struct ucred {
 #define SOL_PNPIPE      275
 #define SOL_RDS         276
 #define SOL_IUCV        277
+#define SOL_CAIF        278
 
 /* IPX options */
 #define IPX_TYPE        1
diff --git a/include/linux/spi/wl12xx.h b/include/linux/spi/wl12xx.h
index aed64ed3dc8a..a223ecbc71ef 100644
--- a/include/linux/spi/wl12xx.h
+++ b/include/linux/spi/wl12xx.h
@@ -26,6 +26,8 @@
 
 struct wl12xx_platform_data {
         void (*set_power)(bool enable);
+        /* SDIO only: IRQ number if WLAN_IRQ line is used, 0 for SDIO IRQs */
+        int irq;
         bool use_eeprom;
 };
 
diff --git a/include/linux/splice.h b/include/linux/splice.h
index 18e7c7c0cae6..997c3b4c212b 100644
--- a/include/linux/splice.h
+++ b/include/linux/splice.h
@@ -82,4 +82,11 @@ extern ssize_t splice_to_pipe(struct pipe_inode_info *,
 extern ssize_t splice_direct_to_actor(struct file *, struct splice_desc *,
                                       splice_direct_actor *);
 
+/*
+ * for dynamic pipe sizing
+ */
+extern int splice_grow_spd(struct pipe_inode_info *, struct splice_pipe_desc *);
+extern void splice_shrink_spd(struct pipe_inode_info *,
+                                struct splice_pipe_desc *);
+
 #endif
diff --git a/include/linux/ssb/ssb.h b/include/linux/ssb/ssb.h
index 24f988547361..a2608bff9c78 100644
--- a/include/linux/ssb/ssb.h
+++ b/include/linux/ssb/ssb.h
@@ -305,6 +305,7 @@ struct ssb_bus {
         /* ID information about the Chip. */
         u16 chip_id;
         u16 chip_rev;
+        u16 sprom_offset;
         u16 sprom_size;         /* number of words in sprom */
         u8 chip_package;
 
@@ -394,6 +395,9 @@ extern int ssb_bus_sdiobus_register(struct ssb_bus *bus,
 
 extern void ssb_bus_unregister(struct ssb_bus *bus);
 
+/* Does the device have an SPROM? */
+extern bool ssb_is_sprom_available(struct ssb_bus *bus);
+
 /* Set a fallback SPROM.
  * See kdoc at the function definition for complete documentation. */
 extern int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom);
diff --git a/include/linux/ssb/ssb_driver_chipcommon.h b/include/linux/ssb/ssb_driver_chipcommon.h
index 4e27acf0a92f..2cdf249b4e5f 100644
--- a/include/linux/ssb/ssb_driver_chipcommon.h
+++ b/include/linux/ssb/ssb_driver_chipcommon.h
@@ -53,6 +53,7 @@
 #define  SSB_CHIPCO_CAP_64BIT           0x08000000      /* 64-bit Backplane */
 #define  SSB_CHIPCO_CAP_PMU             0x10000000      /* PMU available (rev >= 20) */
 #define  SSB_CHIPCO_CAP_ECI             0x20000000      /* ECI available (rev >= 20) */
+#define  SSB_CHIPCO_CAP_SPROM           0x40000000      /* SPROM present */
 #define SSB_CHIPCO_CORECTL              0x0008
 #define  SSB_CHIPCO_CORECTL_UARTCLK0    0x00000001      /* Drive UART with internal clock */
 #define  SSB_CHIPCO_CORECTL_SE          0x00000002      /* sync clk out enable (corerev >= 3) */
@@ -385,6 +386,7 @@
 
 
 /** Chip specific Chip-Status register contents. */
+#define SSB_CHIPCO_CHST_4322_SPROM_EXISTS       0x00000040 /* SPROM present */
 #define SSB_CHIPCO_CHST_4325_SPROM_OTP_SEL      0x00000003
 #define SSB_CHIPCO_CHST_4325_DEFCIS_SEL         0 /* OTP is powered up, use def. CIS, no SPROM */
 #define SSB_CHIPCO_CHST_4325_SPROM_SEL          1 /* OTP is powered up, SPROM is present */
@@ -398,6 +400,18 @@
 #define SSB_CHIPCO_CHST_4325_RCAL_VALUE_SHIFT   4
 #define SSB_CHIPCO_CHST_4325_PMUTOP_2B          0x00000200 /* 1 for 2b, 0 for to 2a */
 
+/** Macros to determine SPROM presence based on Chip-Status register. */
+#define SSB_CHIPCO_CHST_4312_SPROM_PRESENT(status) \
+        ((status & SSB_CHIPCO_CHST_4325_SPROM_OTP_SEL) != \
+                SSB_CHIPCO_CHST_4325_OTP_SEL)
+#define SSB_CHIPCO_CHST_4322_SPROM_PRESENT(status) \
+        (status & SSB_CHIPCO_CHST_4322_SPROM_EXISTS)
+#define SSB_CHIPCO_CHST_4325_SPROM_PRESENT(status) \
+        (((status & SSB_CHIPCO_CHST_4325_SPROM_OTP_SEL) != \
+                SSB_CHIPCO_CHST_4325_DEFCIS_SEL) && \
+         ((status & SSB_CHIPCO_CHST_4325_SPROM_OTP_SEL) != \
+                SSB_CHIPCO_CHST_4325_OTP_SEL))
+
 
 
 /** Clockcontrol masks and values **/
@@ -564,6 +578,7 @@ struct ssb_chipcommon_pmu {
 struct ssb_chipcommon {
         struct ssb_device *dev;
         u32 capabilities;
+        u32 status;
         /* Fast Powerup Delay constant */
         u16 fast_pwrup_delay;
         struct ssb_chipcommon_pmu pmu;
diff --git a/include/linux/ssb/ssb_regs.h b/include/linux/ssb/ssb_regs.h
index 9ae9082eaeb4..a6d5225b9275 100644
--- a/include/linux/ssb/ssb_regs.h
+++ b/include/linux/ssb/ssb_regs.h
@@ -170,26 +170,27 @@
 #define SSB_SPROMSIZE_WORDS_R4          220
 #define SSB_SPROMSIZE_BYTES_R123        (SSB_SPROMSIZE_WORDS_R123 * sizeof(u16))
 #define SSB_SPROMSIZE_BYTES_R4          (SSB_SPROMSIZE_WORDS_R4 * sizeof(u16))
-#define SSB_SPROM_BASE                  0x1000
-#define SSB_SPROM_REVISION              0x107E
+#define SSB_SPROM_BASE1                 0x1000
+#define SSB_SPROM_BASE31                0x0800
+#define SSB_SPROM_REVISION              0x007E
 #define  SSB_SPROM_REVISION_REV         0x00FF  /* SPROM Revision number */
 #define  SSB_SPROM_REVISION_CRC         0xFF00  /* SPROM CRC8 value */
 #define  SSB_SPROM_REVISION_CRC_SHIFT   8
 
 /* SPROM Revision 1 */
-#define SSB_SPROM1_SPID                 0x1004  /* Subsystem Product ID for PCI */
-#define SSB_SPROM1_SVID                 0x1006  /* Subsystem Vendor ID for PCI */
-#define SSB_SPROM1_PID                  0x1008  /* Product ID for PCI */
-#define SSB_SPROM1_IL0MAC               0x1048  /* 6 bytes MAC address for 802.11b/g */
-#define SSB_SPROM1_ET0MAC               0x104E  /* 6 bytes MAC address for Ethernet */
-#define SSB_SPROM1_ET1MAC               0x1054  /* 6 bytes MAC address for 802.11a */
-#define SSB_SPROM1_ETHPHY               0x105A  /* Ethernet PHY settings */
+#define SSB_SPROM1_SPID                 0x0004  /* Subsystem Product ID for PCI */
+#define SSB_SPROM1_SVID                 0x0006  /* Subsystem Vendor ID for PCI */
+#define SSB_SPROM1_PID                  0x0008  /* Product ID for PCI */
+#define SSB_SPROM1_IL0MAC               0x0048  /* 6 bytes MAC address for 802.11b/g */
+#define SSB_SPROM1_ET0MAC               0x004E  /* 6 bytes MAC address for Ethernet */
+#define SSB_SPROM1_ET1MAC               0x0054  /* 6 bytes MAC address for 802.11a */
+#define SSB_SPROM1_ETHPHY               0x005A  /* Ethernet PHY settings */
 #define  SSB_SPROM1_ETHPHY_ET0A         0x001F  /* MII Address for enet0 */
 #define  SSB_SPROM1_ETHPHY_ET1A         0x03E0  /* MII Address for enet1 */
 #define  SSB_SPROM1_ETHPHY_ET1A_SHIFT   5
 #define  SSB_SPROM1_ETHPHY_ET0M         (1<<14) /* MDIO for enet0 */
 #define  SSB_SPROM1_ETHPHY_ET1M         (1<<15) /* MDIO for enet1 */
-#define SSB_SPROM1_BINF                 0x105C  /* Board info */
+#define SSB_SPROM1_BINF                 0x005C  /* Board info */
 #define  SSB_SPROM1_BINF_BREV           0x00FF  /* Board Revision */
 #define  SSB_SPROM1_BINF_CCODE          0x0F00  /* Country Code */
 #define  SSB_SPROM1_BINF_CCODE_SHIFT    8
@@ -197,63 +198,63 @@
 #define  SSB_SPROM1_BINF_ANTBG_SHIFT    12
 #define  SSB_SPROM1_BINF_ANTA           0xC000  /* Available A-PHY antennas */
 #define  SSB_SPROM1_BINF_ANTA_SHIFT     14
-#define SSB_SPROM1_PA0B0                0x105E
-#define SSB_SPROM1_PA0B1                0x1060
-#define SSB_SPROM1_PA0B2                0x1062
-#define SSB_SPROM1_GPIOA                0x1064  /* General Purpose IO pins 0 and 1 */
+#define SSB_SPROM1_PA0B0                0x005E
+#define SSB_SPROM1_PA0B1                0x0060
+#define SSB_SPROM1_PA0B2                0x0062
+#define SSB_SPROM1_GPIOA                0x0064  /* General Purpose IO pins 0 and 1 */
 #define  SSB_SPROM1_GPIOA_P0            0x00FF  /* Pin 0 */
 #define  SSB_SPROM1_GPIOA_P1            0xFF00  /* Pin 1 */
 #define  SSB_SPROM1_GPIOA_P1_SHIFT      8
-#define SSB_SPROM1_GPIOB                0x1066  /* General Purpuse IO pins 2 and 3 */
+#define SSB_SPROM1_GPIOB                0x0066  /* General Purpuse IO pins 2 and 3 */
 #define  SSB_SPROM1_GPIOB_P2            0x00FF  /* Pin 2 */
 #define  SSB_SPROM1_GPIOB_P3            0xFF00  /* Pin 3 */
 #define  SSB_SPROM1_GPIOB_P3_SHIFT      8
-#define SSB_SPROM1_MAXPWR               0x1068  /* Power Amplifier Max Power */
+#define SSB_SPROM1_MAXPWR               0x0068  /* Power Amplifier Max Power */
 #define  SSB_SPROM1_MAXPWR_BG           0x00FF  /* B-PHY and G-PHY (in dBm Q5.2) */
 #define  SSB_SPROM1_MAXPWR_A            0xFF00  /* A-PHY (in dBm Q5.2) */
 #define  SSB_SPROM1_MAXPWR_A_SHIFT      8
-#define SSB_SPROM1_PA1B0                0x106A
-#define SSB_SPROM1_PA1B1                0x106C
-#define SSB_SPROM1_PA1B2                0x106E
-#define SSB_SPROM1_ITSSI                0x1070  /* Idle TSSI Target */
+#define SSB_SPROM1_PA1B0                0x006A
+#define SSB_SPROM1_PA1B1                0x006C
+#define SSB_SPROM1_PA1B2                0x006E
+#define SSB_SPROM1_ITSSI                0x0070  /* Idle TSSI Target */
 #define  SSB_SPROM1_ITSSI_BG            0x00FF  /* B-PHY and G-PHY*/
 #define  SSB_SPROM1_ITSSI_A             0xFF00  /* A-PHY */
 #define  SSB_SPROM1_ITSSI_A_SHIFT       8
-#define SSB_SPROM1_BFLLO                0x1072  /* Boardflags (low 16 bits) */
-#define SSB_SPROM1_AGAIN                0x1074  /* Antenna Gain (in dBm Q5.2) */
+#define SSB_SPROM1_BFLLO                0x0072  /* Boardflags (low 16 bits) */
+#define SSB_SPROM1_AGAIN                0x0074  /* Antenna Gain (in dBm Q5.2) */
 #define  SSB_SPROM1_AGAIN_BG            0x00FF  /* B-PHY and G-PHY */
 #define  SSB_SPROM1_AGAIN_BG_SHIFT      0
 #define  SSB_SPROM1_AGAIN_A             0xFF00  /* A-PHY */
 #define  SSB_SPROM1_AGAIN_A_SHIFT       8
 
 /* SPROM Revision 2 (inherits from rev 1) */
-#define SSB_SPROM2_BFLHI                0x1038  /* Boardflags (high 16 bits) */
-#define SSB_SPROM2_MAXP_A               0x103A  /* A-PHY Max Power */
+#define SSB_SPROM2_BFLHI                0x0038  /* Boardflags (high 16 bits) */
+#define SSB_SPROM2_MAXP_A               0x003A  /* A-PHY Max Power */
 #define  SSB_SPROM2_MAXP_A_HI           0x00FF  /* Max Power High */
 #define  SSB_SPROM2_MAXP_A_LO           0xFF00  /* Max Power Low */
 #define  SSB_SPROM2_MAXP_A_LO_SHIFT     8
-#define SSB_SPROM2_PA1LOB0              0x103C  /* A-PHY PowerAmplifier Low Settings */
-#define SSB_SPROM2_PA1LOB1              0x103E  /* A-PHY PowerAmplifier Low Settings */
-#define SSB_SPROM2_PA1LOB2              0x1040  /* A-PHY PowerAmplifier Low Settings */
-#define SSB_SPROM2_PA1HIB0              0x1042  /* A-PHY PowerAmplifier High Settings */
-#define SSB_SPROM2_PA1HIB1              0x1044  /* A-PHY PowerAmplifier High Settings */
-#define SSB_SPROM2_PA1HIB2              0x1046  /* A-PHY PowerAmplifier High Settings */
-#define SSB_SPROM2_OPO                  0x1078  /* OFDM Power Offset from CCK Level */
+#define SSB_SPROM2_PA1LOB0              0x003C  /* A-PHY PowerAmplifier Low Settings */
+#define SSB_SPROM2_PA1LOB1              0x003E  /* A-PHY PowerAmplifier Low Settings */
+#define SSB_SPROM2_PA1LOB2              0x0040  /* A-PHY PowerAmplifier Low Settings */
+#define SSB_SPROM2_PA1HIB0              0x0042  /* A-PHY PowerAmplifier High Settings */
+#define SSB_SPROM2_PA1HIB1              0x0044  /* A-PHY PowerAmplifier High Settings */
+#define SSB_SPROM2_PA1HIB2              0x0046  /* A-PHY PowerAmplifier High Settings */
+#define SSB_SPROM2_OPO                  0x0078  /* OFDM Power Offset from CCK Level */
 #define  SSB_SPROM2_OPO_VALUE           0x00FF
 #define  SSB_SPROM2_OPO_UNUSED          0xFF00
-#define SSB_SPROM2_CCODE                0x107C  /* Two char Country Code */
+#define SSB_SPROM2_CCODE                0x007C  /* Two char Country Code */
 
 /* SPROM Revision 3 (inherits most data from rev 2) */
-#define SSB_SPROM3_IL0MAC               0x104A  /* 6 bytes MAC address for 802.11b/g */
-#define SSB_SPROM3_OFDMAPO              0x102C  /* A-PHY OFDM Mid Power Offset (4 bytes, BigEndian) */
-#define SSB_SPROM3_OFDMALPO             0x1030  /* A-PHY OFDM Low Power Offset (4 bytes, BigEndian) */
-#define SSB_SPROM3_OFDMAHPO             0x1034  /* A-PHY OFDM High Power Offset (4 bytes, BigEndian) */
-#define SSB_SPROM3_GPIOLDC              0x1042  /* GPIO LED Powersave Duty Cycle (4 bytes, BigEndian) */
+#define SSB_SPROM3_OFDMAPO              0x002C  /* A-PHY OFDM Mid Power Offset (4 bytes, BigEndian) */
+#define SSB_SPROM3_OFDMALPO             0x0030  /* A-PHY OFDM Low Power Offset (4 bytes, BigEndian) */
+#define SSB_SPROM3_OFDMAHPO             0x0034  /* A-PHY OFDM High Power Offset (4 bytes, BigEndian) */
+#define SSB_SPROM3_GPIOLDC              0x0042  /* GPIO LED Powersave Duty Cycle (4 bytes, BigEndian) */
 #define  SSB_SPROM3_GPIOLDC_OFF         0x0000FF00      /* Off Count */
 #define  SSB_SPROM3_GPIOLDC_OFF_SHIFT   8
 #define  SSB_SPROM3_GPIOLDC_ON          0x00FF0000      /* On Count */
 #define  SSB_SPROM3_GPIOLDC_ON_SHIFT    16
-#define SSB_SPROM3_CCKPO                0x1078  /* CCK Power Offset */
+#define SSB_SPROM3_IL0MAC               0x004A  /* 6 bytes MAC address for 802.11b/g */
+#define SSB_SPROM3_CCKPO                0x0078  /* CCK Power Offset */
 #define  SSB_SPROM3_CCKPO_1M            0x000F  /* 1M Rate PO */
 #define  SSB_SPROM3_CCKPO_2M            0x00F0  /* 2M Rate PO */
 #define  SSB_SPROM3_CCKPO_2M_SHIFT      4
@@ -264,100 +265,100 @@
 #define  SSB_SPROM3_OFDMGPO             0x107A  /* G-PHY OFDM Power Offset (4 bytes, BigEndian) */
 
 /* SPROM Revision 4 */
-#define SSB_SPROM4_IL0MAC               0x104C  /* 6 byte MAC address for a/b/g/n */
-#define SSB_SPROM4_ETHPHY               0x105A  /* Ethernet PHY settings ?? */
+#define SSB_SPROM4_BFLLO                0x0044  /* Boardflags (low 16 bits) */
+#define SSB_SPROM4_BFLHI                0x0046  /* Board Flags Hi */
+#define SSB_SPROM4_IL0MAC               0x004C  /* 6 byte MAC address for a/b/g/n */
+#define SSB_SPROM4_CCODE                0x0052  /* Country Code (2 bytes) */
+#define SSB_SPROM4_GPIOA                0x0056  /* Gen. Purpose IO # 0 and 1 */
+#define  SSB_SPROM4_GPIOA_P0            0x00FF  /* Pin 0 */
+#define  SSB_SPROM4_GPIOA_P1            0xFF00  /* Pin 1 */
+#define  SSB_SPROM4_GPIOA_P1_SHIFT      8
+#define SSB_SPROM4_GPIOB                0x0058  /* Gen. Purpose IO # 2 and 3 */
+#define  SSB_SPROM4_GPIOB_P2            0x00FF  /* Pin 2 */
+#define  SSB_SPROM4_GPIOB_P3            0xFF00  /* Pin 3 */
+#define  SSB_SPROM4_GPIOB_P3_SHIFT      8
+#define SSB_SPROM4_ETHPHY               0x005A  /* Ethernet PHY settings ?? */
 #define  SSB_SPROM4_ETHPHY_ET0A         0x001F  /* MII Address for enet0 */
 #define  SSB_SPROM4_ETHPHY_ET1A         0x03E0  /* MII Address for enet1 */
 #define  SSB_SPROM4_ETHPHY_ET1A_SHIFT   5
 #define  SSB_SPROM4_ETHPHY_ET0M         (1<<14) /* MDIO for enet0 */
 #define  SSB_SPROM4_ETHPHY_ET1M         (1<<15) /* MDIO for enet1 */
-#define SSB_SPROM4_CCODE                0x1052  /* Country Code (2 bytes) */
-#define SSB_SPROM4_ANTAVAIL             0x105D  /* Antenna available bitfields */
-#define SSB_SPROM4_ANTAVAIL_A           0x00FF  /* A-PHY bitfield */
-#define SSB_SPROM4_ANTAVAIL_A_SHIFT     0
-#define SSB_SPROM4_ANTAVAIL_BG          0xFF00  /* B-PHY and G-PHY bitfield */
-#define SSB_SPROM4_ANTAVAIL_BG_SHIFT    8
-#define SSB_SPROM4_BFLLO                0x1044  /* Boardflags (low 16 bits) */
-#define SSB_SPROM4_AGAIN01              0x105E  /* Antenna Gain (in dBm Q5.2) */
+#define SSB_SPROM4_ANTAVAIL             0x005D  /* Antenna available bitfields */
+#define  SSB_SPROM4_ANTAVAIL_A          0x00FF  /* A-PHY bitfield */
+#define  SSB_SPROM4_ANTAVAIL_A_SHIFT    0
+#define  SSB_SPROM4_ANTAVAIL_BG         0xFF00  /* B-PHY and G-PHY bitfield */
+#define  SSB_SPROM4_ANTAVAIL_BG_SHIFT   8
+#define SSB_SPROM4_AGAIN01              0x005E  /* Antenna Gain (in dBm Q5.2) */
 #define  SSB_SPROM4_AGAIN0              0x00FF  /* Antenna 0 */
 #define  SSB_SPROM4_AGAIN0_SHIFT        0
 #define  SSB_SPROM4_AGAIN1              0xFF00  /* Antenna 1 */
 #define  SSB_SPROM4_AGAIN1_SHIFT        8
-#define SSB_SPROM4_AGAIN23              0x1060
+#define SSB_SPROM4_AGAIN23              0x0060
 #define  SSB_SPROM4_AGAIN2              0x00FF  /* Antenna 2 */
 #define  SSB_SPROM4_AGAIN2_SHIFT        0
 #define  SSB_SPROM4_AGAIN3              0xFF00  /* Antenna 3 */
 #define  SSB_SPROM4_AGAIN3_SHIFT        8
-#define SSB_SPROM4_BFLHI                0x1046  /* Board Flags Hi */
-#define SSB_SPROM4_MAXP_BG              0x1080  /* Max Power BG in path 1 */
+#define SSB_SPROM4_MAXP_BG              0x0080  /* Max Power BG in path 1 */
 #define  SSB_SPROM4_MAXP_BG_MASK        0x00FF  /* Mask for Max Power BG */
 #define  SSB_SPROM4_ITSSI_BG            0xFF00  /* Mask for path 1 itssi_bg */
 #define  SSB_SPROM4_ITSSI_BG_SHIFT      8
-#define SSB_SPROM4_MAXP_A               0x108A  /* Max Power A in path 1 */
+#define SSB_SPROM4_MAXP_A               0x008A  /* Max Power A in path 1 */
 #define  SSB_SPROM4_MAXP_A_MASK         0x00FF  /* Mask for Max Power A */
 #define  SSB_SPROM4_ITSSI_A             0xFF00  /* Mask for path 1 itssi_a */
 #define  SSB_SPROM4_ITSSI_A_SHIFT       8
-#define SSB_SPROM4_GPIOA                0x1056  /* Gen. Purpose IO # 0 and 1 */
-#define  SSB_SPROM4_GPIOA_P0            0x00FF  /* Pin 0 */
-#define  SSB_SPROM4_GPIOA_P1            0xFF00  /* Pin 1 */
-#define  SSB_SPROM4_GPIOA_P1_SHIFT      8
-#define SSB_SPROM4_GPIOB                0x1058  /* Gen. Purpose IO # 2 and 3 */
-#define  SSB_SPROM4_GPIOB_P2            0x00FF  /* Pin 2 */
-#define  SSB_SPROM4_GPIOB_P3            0xFF00  /* Pin 3 */
-#define  SSB_SPROM4_GPIOB_P3_SHIFT      8
-#define SSB_SPROM4_PA0B0                0x1082  /* The paXbY locations are */
-#define SSB_SPROM4_PA0B1                0x1084  /*   only guesses */
-#define SSB_SPROM4_PA0B2                0x1086
-#define SSB_SPROM4_PA1B0                0x108E
-#define SSB_SPROM4_PA1B1                0x1090
-#define SSB_SPROM4_PA1B2                0x1092
+#define SSB_SPROM4_PA0B0                0x0082  /* The paXbY locations are */
+#define SSB_SPROM4_PA0B1                0x0084  /*   only guesses */
+#define SSB_SPROM4_PA0B2                0x0086
+#define SSB_SPROM4_PA1B0                0x008E
+#define SSB_SPROM4_PA1B1                0x0090
+#define SSB_SPROM4_PA1B2                0x0092
 
 /* SPROM Revision 5 (inherits most data from rev 4) */
-#define SSB_SPROM5_BFLLO                0x104A  /* Boardflags (low 16 bits) */
-#define SSB_SPROM5_BFLHI                0x104C  /* Board Flags Hi */
-#define SSB_SPROM5_IL0MAC               0x1052  /* 6 byte MAC address for a/b/g/n */
-#define SSB_SPROM5_CCODE                0x1044  /* Country Code (2 bytes) */
-#define SSB_SPROM5_GPIOA                0x1076  /* Gen. Purpose IO # 0 and 1 */
+#define SSB_SPROM5_CCODE                0x0044  /* Country Code (2 bytes) */
+#define SSB_SPROM5_BFLLO                0x004A  /* Boardflags (low 16 bits) */
+#define SSB_SPROM5_BFLHI                0x004C  /* Board Flags Hi */
+#define SSB_SPROM5_IL0MAC               0x0052  /* 6 byte MAC address for a/b/g/n */
+#define SSB_SPROM5_GPIOA                0x0076  /* Gen. Purpose IO # 0 and 1 */
 #define  SSB_SPROM5_GPIOA_P0            0x00FF  /* Pin 0 */
 #define  SSB_SPROM5_GPIOA_P1            0xFF00  /* Pin 1 */
 #define  SSB_SPROM5_GPIOA_P1_SHIFT      8
-#define SSB_SPROM5_GPIOB                0x1078  /* Gen. Purpose IO # 2 and 3 */
+#define SSB_SPROM5_GPIOB                0x0078  /* Gen. Purpose IO # 2 and 3 */
 #define  SSB_SPROM5_GPIOB_P2            0x00FF  /* Pin 2 */
 #define  SSB_SPROM5_GPIOB_P3            0xFF00  /* Pin 3 */
 #define  SSB_SPROM5_GPIOB_P3_SHIFT      8
 
 /* SPROM Revision 8 */
-#define SSB_SPROM8_BOARDREV             0x1082  /* Board revision */
-#define SSB_SPROM8_BFLLO                0x1084  /* Board flags (bits 0-15) */
-#define SSB_SPROM8_BFLHI                0x1086  /* Board flags (bits 16-31) */
-#define SSB_SPROM8_BFL2LO               0x1088  /* Board flags (bits 32-47) */
-#define SSB_SPROM8_BFL2HI               0x108A  /* Board flags (bits 48-63) */
-#define SSB_SPROM8_IL0MAC               0x108C  /* 6 byte MAC address */
-#define SSB_SPROM8_CCODE                0x1092  /* 2 byte country code */
-#define SSB_SPROM8_ANTAVAIL             0x109C  /* Antenna available bitfields*/
-#define SSB_SPROM8_ANTAVAIL_A           0xFF00  /* A-PHY bitfield */
-#define SSB_SPROM8_ANTAVAIL_A_SHIFT     8
-#define SSB_SPROM8_ANTAVAIL_BG          0x00FF  /* B-PHY and G-PHY bitfield */
-#define SSB_SPROM8_ANTAVAIL_BG_SHIFT    0
-#define SSB_SPROM8_AGAIN01              0x109E  /* Antenna Gain (in dBm Q5.2) */
+#define SSB_SPROM8_BOARDREV             0x0082  /* Board revision */
+#define SSB_SPROM8_BFLLO                0x0084  /* Board flags (bits 0-15) */
+#define SSB_SPROM8_BFLHI                0x0086  /* Board flags (bits 16-31) */
+#define SSB_SPROM8_BFL2LO               0x0088  /* Board flags (bits 32-47) */
+#define SSB_SPROM8_BFL2HI               0x008A  /* Board flags (bits 48-63) */
+#define SSB_SPROM8_IL0MAC               0x008C  /* 6 byte MAC address */
+#define SSB_SPROM8_CCODE                0x0092  /* 2 byte country code */
+#define SSB_SPROM8_GPIOA                0x0096  /*Gen. Purpose IO # 0 and 1 */
+#define  SSB_SPROM8_GPIOA_P0            0x00FF  /* Pin 0 */
+#define  SSB_SPROM8_GPIOA_P1            0xFF00  /* Pin 1 */
+#define  SSB_SPROM8_GPIOA_P1_SHIFT      8
+#define SSB_SPROM8_GPIOB                0x0098  /* Gen. Purpose IO # 2 and 3 */
+#define  SSB_SPROM8_GPIOB_P2            0x00FF  /* Pin 2 */
+#define  SSB_SPROM8_GPIOB_P3            0xFF00  /* Pin 3 */
+#define  SSB_SPROM8_GPIOB_P3_SHIFT      8
+#define SSB_SPROM8_ANTAVAIL             0x009C  /* Antenna available bitfields*/
+#define  SSB_SPROM8_ANTAVAIL_A          0xFF00  /* A-PHY bitfield */
+#define  SSB_SPROM8_ANTAVAIL_A_SHIFT    8
+#define  SSB_SPROM8_ANTAVAIL_BG         0x00FF  /* B-PHY and G-PHY bitfield */
+#define  SSB_SPROM8_ANTAVAIL_BG_SHIFT   0
+#define SSB_SPROM8_AGAIN01              0x009E  /* Antenna Gain (in dBm Q5.2) */
 #define  SSB_SPROM8_AGAIN0              0x00FF  /* Antenna 0 */
 #define  SSB_SPROM8_AGAIN0_SHIFT        0
 #define  SSB_SPROM8_AGAIN1              0xFF00  /* Antenna 1 */
 #define  SSB_SPROM8_AGAIN1_SHIFT        8
-#define SSB_SPROM8_AGAIN23              0x10A0
+#define SSB_SPROM8_AGAIN23              0x00A0
 #define  SSB_SPROM8_AGAIN2              0x00FF  /* Antenna 2 */
 #define  SSB_SPROM8_AGAIN2_SHIFT        0
 #define  SSB_SPROM8_AGAIN3              0xFF00  /* Antenna 3 */
 #define  SSB_SPROM8_AGAIN3_SHIFT        8
-#define SSB_SPROM8_GPIOA                0x1096  /*Gen. Purpose IO # 0 and 1 */
-#define  SSB_SPROM8_GPIOA_P0            0x00FF  /* Pin 0 */
-#define  SSB_SPROM8_GPIOA_P1            0xFF00  /* Pin 1 */
-#define  SSB_SPROM8_GPIOA_P1_SHIFT      8
-#define SSB_SPROM8_GPIOB                0x1098  /* Gen. Purpose IO # 2 and 3 */
-#define  SSB_SPROM8_GPIOB_P2            0x00FF  /* Pin 2 */
-#define  SSB_SPROM8_GPIOB_P3            0xFF00  /* Pin 3 */
-#define  SSB_SPROM8_GPIOB_P3_SHIFT      8
-#define SSB_SPROM8_RSSIPARM2G           0x10A4  /* RSSI params for 2GHz */
+#define SSB_SPROM8_RSSIPARM2G           0x00A4  /* RSSI params for 2GHz */
 #define  SSB_SPROM8_RSSISMF2G           0x000F
 #define  SSB_SPROM8_RSSISMC2G           0x00F0
 #define  SSB_SPROM8_RSSISMC2G_SHIFT     4
@@ -365,7 +366,7 @@
 #define  SSB_SPROM8_RSSISAV2G_SHIFT     8
 #define  SSB_SPROM8_BXA2G               0x1800
 #define  SSB_SPROM8_BXA2G_SHIFT         11
-#define SSB_SPROM8_RSSIPARM5G           0x10A6  /* RSSI params for 5GHz */
+#define SSB_SPROM8_RSSIPARM5G           0x00A6  /* RSSI params for 5GHz */
 #define  SSB_SPROM8_RSSISMF5G           0x000F
 #define  SSB_SPROM8_RSSISMC5G           0x00F0
 #define  SSB_SPROM8_RSSISMC5G_SHIFT     4
@@ -373,47 +374,47 @@
 #define  SSB_SPROM8_RSSISAV5G_SHIFT     8
 #define  SSB_SPROM8_BXA5G               0x1800
 #define  SSB_SPROM8_BXA5G_SHIFT         11
-#define SSB_SPROM8_TRI25G               0x10A8  /* TX isolation 2.4&5.3GHz */
+#define SSB_SPROM8_TRI25G               0x00A8  /* TX isolation 2.4&5.3GHz */
 #define  SSB_SPROM8_TRI2G               0x00FF  /* TX isolation 2.4GHz */
 #define  SSB_SPROM8_TRI5G               0xFF00  /* TX isolation 5.3GHz */
 #define  SSB_SPROM8_TRI5G_SHIFT         8
-#define SSB_SPROM8_TRI5GHL              0x10AA  /* TX isolation 5.2/5.8GHz */
+#define SSB_SPROM8_TRI5GHL              0x00AA  /* TX isolation 5.2/5.8GHz */
 #define  SSB_SPROM8_TRI5GL              0x00FF  /* TX isolation 5.2GHz */
 #define  SSB_SPROM8_TRI5GH              0xFF00  /* TX isolation 5.8GHz */
 #define  SSB_SPROM8_TRI5GH_SHIFT        8
-#define SSB_SPROM8_RXPO                 0x10AC  /* RX power offsets */
+#define SSB_SPROM8_RXPO                 0x00AC  /* RX power offsets */
 #define  SSB_SPROM8_RXPO2G              0x00FF  /* 2GHz RX power offset */
 #define  SSB_SPROM8_RXPO5G              0xFF00  /* 5GHz RX power offset */
 #define  SSB_SPROM8_RXPO5G_SHIFT        8
-#define SSB_SPROM8_MAXP_BG              0x10C0  /* Max Power 2GHz in path 1 */
+#define SSB_SPROM8_MAXP_BG              0x00C0  /* Max Power 2GHz in path 1 */
 #define  SSB_SPROM8_MAXP_BG_MASK        0x00FF  /* Mask for Max Power 2GHz */
 #define  SSB_SPROM8_ITSSI_BG            0xFF00  /* Mask for path 1 itssi_bg */
 #define  SSB_SPROM8_ITSSI_BG_SHIFT      8
-#define SSB_SPROM8_PA0B0                0x10C2  /* 2GHz power amp settings */
-#define SSB_SPROM8_PA0B1                0x10C4
-#define SSB_SPROM8_PA0B2                0x10C6
-#define SSB_SPROM8_MAXP_A               0x10C8  /* Max Power 5.3GHz */
+#define SSB_SPROM8_PA0B0                0x00C2  /* 2GHz power amp settings */
+#define SSB_SPROM8_PA0B1                0x00C4
+#define SSB_SPROM8_PA0B2                0x00C6
+#define SSB_SPROM8_MAXP_A               0x00C8  /* Max Power 5.3GHz */
 #define  SSB_SPROM8_MAXP_A_MASK         0x00FF  /* Mask for Max Power 5.3GHz */
 #define  SSB_SPROM8_ITSSI_A             0xFF00  /* Mask for path 1 itssi_a */
 #define  SSB_SPROM8_ITSSI_A_SHIFT       8
-#define SSB_SPROM8_MAXP_AHL             0x10CA  /* Max Power 5.2/5.8GHz */
+#define SSB_SPROM8_MAXP_AHL             0x00CA  /* Max Power 5.2/5.8GHz */
 #define  SSB_SPROM8_MAXP_AH_MASK        0x00FF  /* Mask for Max Power 5.8GHz */
 #define  SSB_SPROM8_MAXP_AL_MASK        0xFF00  /* Mask for Max Power 5.2GHz */
 #define  SSB_SPROM8_MAXP_AL_SHIFT       8
-#define SSB_SPROM8_PA1B0                0x10CC  /* 5.3GHz power amp settings */
-#define SSB_SPROM8_PA1B1                0x10CE
-#define SSB_SPROM8_PA1B2                0x10D0
-#define SSB_SPROM8_PA1LOB0              0x10D2  /* 5.2GHz power amp settings */
-#define SSB_SPROM8_PA1LOB1              0x10D4
-#define SSB_SPROM8_PA1LOB2              0x10D6
-#define SSB_SPROM8_PA1HIB0              0x10D8  /* 5.8GHz power amp settings */
-#define SSB_SPROM8_PA1HIB1              0x10DA
-#define SSB_SPROM8_PA1HIB2              0x10DC
-#define SSB_SPROM8_CCK2GPO              0x1140  /* CCK power offset */
-#define SSB_SPROM8_OFDM2GPO             0x1142  /* 2.4GHz OFDM power offset */
-#define SSB_SPROM8_OFDM5GPO             0x1146  /* 5.3GHz OFDM power offset */
-#define SSB_SPROM8_OFDM5GLPO            0x114A  /* 5.2GHz OFDM power offset */
-#define SSB_SPROM8_OFDM5GHPO            0x114E  /* 5.8GHz OFDM power offset */
+#define SSB_SPROM8_PA1B0                0x00CC  /* 5.3GHz power amp settings */
+#define SSB_SPROM8_PA1B1                0x00CE
+#define SSB_SPROM8_PA1B2                0x00D0
+#define SSB_SPROM8_PA1LOB0              0x00D2  /* 5.2GHz power amp settings */
+#define SSB_SPROM8_PA1LOB1              0x00D4
+#define SSB_SPROM8_PA1LOB2              0x00D6
+#define SSB_SPROM8_PA1HIB0              0x00D8  /* 5.8GHz power amp settings */
+#define SSB_SPROM8_PA1HIB1              0x00DA
+#define SSB_SPROM8_PA1HIB2              0x00DC
+#define SSB_SPROM8_CCK2GPO              0x0140  /* CCK power offset */
+#define SSB_SPROM8_OFDM2GPO             0x0142  /* 2.4GHz OFDM power offset */
+#define SSB_SPROM8_OFDM5GPO             0x0146  /* 5.3GHz OFDM power offset */
+#define SSB_SPROM8_OFDM5GLPO            0x014A  /* 5.2GHz OFDM power offset */
+#define SSB_SPROM8_OFDM5GHPO            0x014E  /* 5.8GHz OFDM power offset */
 
 /* Values for SSB_SPROM1_BINF_CCODE */
 enum {
diff --git a/include/linux/stmmac.h b/include/linux/stmmac.h
index 32bfd1a8a48d..632ff7c03280 100644
--- a/include/linux/stmmac.h
+++ b/include/linux/stmmac.h
@@ -33,6 +33,7 @@ struct plat_stmmacenet_data {
         int bus_id;
         int pbl;
         int has_gmac;
+        int enh_desc;
         void (*fix_mac_speed)(void *priv, unsigned int speed);
         void (*bus_setup)(unsigned long ioaddr);
 #ifdef CONFIG_STM_DRIVERS
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 1f59d9340c4d..ec2b7a42b45f 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -146,6 +146,7 @@ enum {
         SWP_DISCARDING  = (1 << 3),     /* now discarding a free cluster */
         SWP_SOLIDSTATE  = (1 << 4),     /* blkdev seeks are cheap */
         SWP_CONTINUED   = (1 << 5),     /* swap_map has count continuation */
+        SWP_BLKDEV      = (1 << 6),     /* its a block device */
                                         /* add others here before... */
         SWP_SCANNING    = (1 << 8),     /* refcount in scan_swap_map */
 };
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index f66014c90c9f..7bb5cb64f3b8 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -980,6 +980,8 @@ extern int proc_doulongvec_minmax(struct ctl_table *, int,
                                   void __user *, size_t *, loff_t *);
 extern int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int,
                                       void __user *, size_t *, loff_t *);
+extern int proc_do_large_bitmap(struct ctl_table *, int,
+                                void __user *, size_t *, loff_t *);
 
 /*
  * Register a set of sysctl names by calling register_sysctl_table
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h
index f0496b3d1811..f2694eb4dd3d 100644
--- a/include/linux/sysfs.h
+++ b/include/linux/sysfs.h
@@ -20,6 +20,7 @@
 
 struct kobject;
 struct module;
+enum kobj_ns_type;
 
 /* FIXME
  * The *owner field is no longer used.
@@ -86,17 +87,18 @@ struct attribute_group {
 
 #define attr_name(_attr) (_attr).attr.name
 
+struct file;
 struct vm_area_struct;
 
 struct bin_attribute {
         struct attribute        attr;
         size_t                  size;
         void                    *private;
-        ssize_t (*read)(struct kobject *, struct bin_attribute *,
+        ssize_t (*read)(struct file *, struct kobject *, struct bin_attribute *,
                         char *, loff_t, size_t);
-        ssize_t (*write)(struct kobject *, struct bin_attribute *,
+        ssize_t (*write)(struct file *,struct kobject *, struct bin_attribute *,
                          char *, loff_t, size_t);
-        int (*mmap)(struct kobject *, struct bin_attribute *attr,
+        int (*mmap)(struct file *, struct kobject *, struct bin_attribute *attr,
                     struct vm_area_struct *vma);
 };
 
@@ -154,6 +156,9 @@ void sysfs_remove_link(struct kobject *kobj, const char *name);
 int sysfs_rename_link(struct kobject *kobj, struct kobject *target,
                         const char *old_name, const char *new_name);
 
+void sysfs_delete_link(struct kobject *dir, struct kobject *targ,
+                        const char *name);
+
 int __must_check sysfs_create_group(struct kobject *kobj,
                                     const struct attribute_group *grp);
 int sysfs_update_group(struct kobject *kobj,
@@ -168,10 +173,15 @@ void sysfs_remove_file_from_group(struct kobject *kobj,
 void sysfs_notify(struct kobject *kobj, const char *dir, const char *attr);
 void sysfs_notify_dirent(struct sysfs_dirent *sd);
 struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
+                                      const void *ns,
                                       const unsigned char *name);
 struct sysfs_dirent *sysfs_get(struct sysfs_dirent *sd);
 void sysfs_put(struct sysfs_dirent *sd);
 void sysfs_printk_last_file(void);
+
+/* Called to clear a ns tag when it is no longer valid */
+void sysfs_exit_ns(enum kobj_ns_type type, const void *tag);
+
 int __must_check sysfs_init(void);
 
 #else /* CONFIG_SYSFS */
@@ -264,6 +274,11 @@ static inline int sysfs_rename_link(struct kobject *k, struct kobject *t,
         return 0;
 }
 
+static inline void sysfs_delete_link(struct kobject *k, struct kobject *t,
+                                     const char *name)
+{
+}
+
 static inline int sysfs_create_group(struct kobject *kobj,
                                      const struct attribute_group *grp)
 {
@@ -301,6 +316,7 @@ static inline void sysfs_notify_dirent(struct sysfs_dirent *sd)
 }
 static inline
 struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
+                                      const void *ns,
                                       const unsigned char *name)
 {
         return NULL;
@@ -313,6 +329,10 @@ static inline void sysfs_put(struct sysfs_dirent *sd)
 {
 }
 
+static inline void sysfs_exit_ns(int type, const void *tag)
+{
+}
+
 static inline int __must_check sysfs_init(void)
 {
         return 0;
diff --git a/include/linux/sysrq.h b/include/linux/sysrq.h
index 99adcdc0d3ca..4496322e28dd 100644
--- a/include/linux/sysrq.h
+++ b/include/linux/sysrq.h
@@ -39,41 +39,34 @@ struct sysrq_key_op {
 
 #ifdef CONFIG_MAGIC_SYSRQ
 
-extern int sysrq_on(void);
-
-/*
- * Do not use this one directly:
- */
-extern int __sysrq_enabled;
-
 /* Generic SysRq interface -- you may call it from any device driver, supplying
  * ASCII code of the key, pointer to registers and kbd/tty structs (if they
  * are available -- else NULL's).
  */
 
 void handle_sysrq(int key, struct tty_struct *tty);
-void __handle_sysrq(int key, struct tty_struct *tty, int check_mask);
 int register_sysrq_key(int key, struct sysrq_key_op *op);
 int unregister_sysrq_key(int key, struct sysrq_key_op *op);
 struct sysrq_key_op *__sysrq_get_key_op(int key);
 
+int sysrq_toggle_support(int enable_mask);
+
 #else
 
-static inline int sysrq_on(void)
+static inline void handle_sysrq(int key, struct tty_struct *tty)
 {
-        return 0;
 }
-static inline int __reterr(void)
+
+static inline int register_sysrq_key(int key, struct sysrq_key_op *op)
 {
         return -EINVAL;
 }
-static inline void handle_sysrq(int key, struct tty_struct *tty)
+
+static inline int unregister_sysrq_key(int key, struct sysrq_key_op *op)
 {
+        return -EINVAL;
 }
 
-#define register_sysrq_key(ig,nore) __reterr()
-#define unregister_sysrq_key(ig,nore) __reterr()
-
 #endif
 
 #endif /* _LINUX_SYSRQ_H */
diff --git a/include/linux/tboot.h b/include/linux/tboot.h
index bf2a0c748878..1dba6ee55203 100644
--- a/include/linux/tboot.h
+++ b/include/linux/tboot.h
@@ -150,6 +150,7 @@ extern int tboot_force_iommu(void);
 
 #else
 
+#define tboot_enabled()                 0
 #define tboot_probe()                   do { } while (0)
 #define tboot_shutdown(shutdown_type)   do { } while (0)
 #define tboot_sleep(sleep_state, pm1a_control, pm1b_control)    \
diff --git a/include/linux/tca6416_keypad.h b/include/linux/tca6416_keypad.h
new file mode 100644
index 000000000000..7bd266f3525c
--- /dev/null
+++ b/include/linux/tca6416_keypad.h
@@ -0,0 +1,34 @@
+/*
+ * tca6416 keypad platform support
+ *
+ * Copyright (C) 2010 Texas Instruments
+ *
+ * Author: Sriramakrishnan <srk@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _TCA6416_KEYS_H
+#define _TCA6416_KEYS_H
+
+#include <linux/types.h>
+
+struct tca6416_button {
+        /* Configuration parameters */
+        int code;               /* input event code (KEY_*, SW_*) */
+        int active_low;
+        int type;               /* input event type (EV_KEY, EV_SW) */
+};
+
+struct tca6416_keys_platform_data {
+        struct tca6416_button *buttons;
+        int nbuttons;
+        unsigned int rep:1;     /* enable input subsystem auto repeat */
+        uint16_t pinmask;
+        uint16_t invert;
+        int irq_is_gpio;
+        int use_polling;        /* use polling if Interrupt is not connected*/
+};
+#endif
diff --git a/include/linux/timb_dma.h b/include/linux/timb_dma.h
new file mode 100644
index 000000000000..bb043e970b96
--- /dev/null
+++ b/include/linux/timb_dma.h
@@ -0,0 +1,55 @@
+/*
+ * timb_dma.h timberdale FPGA DMA driver defines
+ * Copyright (c) 2010 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA DMA engine
+ */
+
+#ifndef _LINUX_TIMB_DMA_H
+#define _LINUX_TIMB_DMA_H
+
+/**
+ * struct timb_dma_platform_data_channel - Description of each individual
+ *      DMA channel for the timberdale DMA driver
+ * @rx:                 true if this channel handles data in the direction to
+ *      the CPU.
+ * @bytes_per_line:     Number of bytes per line, this is specific for channels
+ *      handling video data. For other channels this shall be left to 0.
+ * @descriptors:        Number of descriptors to allocate for this channel.
+ * @descriptor_elements: Number of elements in each descriptor.
+ *
+ */
+struct timb_dma_platform_data_channel {
+        bool rx;
+        unsigned int bytes_per_line;
+        unsigned int descriptors;
+        unsigned int descriptor_elements;
+};
+
+/**
+ * struct timb_dma_platform_data - Platform data of the timberdale DMA driver
+ * @nr_channels:        Number of defined channels in the channels array.
+ * @channels:           Definition of the each channel.
+ *
+ */
+struct timb_dma_platform_data {
+        unsigned nr_channels;
+        struct timb_dma_platform_data_channel channels[32];
+};
+
+#endif
diff --git a/include/linux/tipc.h b/include/linux/tipc.h
index 3d92396639de..181c8d0e6f73 100644
--- a/include/linux/tipc.h
+++ b/include/linux/tipc.h
@@ -107,7 +107,7 @@ static inline unsigned int tipc_node(__u32 addr)
  * Message importance levels
  */
 
-#define TIPC_LOW_IMPORTANCE             0  /* default */
+#define TIPC_LOW_IMPORTANCE             0
 #define TIPC_MEDIUM_IMPORTANCE          1
 #define TIPC_HIGH_IMPORTANCE            2
 #define TIPC_CRITICAL_IMPORTANCE        3
@@ -127,23 +127,17 @@ static inline unsigned int tipc_node(__u32 addr)
  * TIPC topology subscription service definitions
  */
 
-#define TIPC_SUB_PORTS          0x01    /* filter for port availability */
-#define TIPC_SUB_SERVICE        0x02    /* filter for service availability */
-#define TIPC_SUB_CANCEL         0x04    /* cancel a subscription */
-#if 0
-/* The following filter options are not currently implemented */
-#define TIPC_SUB_NO_BIND_EVTS   0x04    /* filter out "publish" events */
-#define TIPC_SUB_NO_UNBIND_EVTS 0x08    /* filter out "withdraw" events */
-#define TIPC_SUB_SINGLE_EVT     0x10    /* expire after first event */
-#endif
+#define TIPC_SUB_SERVICE        0x00    /* Filter for service availability    */
+#define TIPC_SUB_PORTS          0x01    /* Filter for port availability  */
+#define TIPC_SUB_CANCEL         0x04    /* Cancel a subscription         */
 
 #define TIPC_WAIT_FOREVER       ~0      /* timeout for permanent subscription */
 
 struct tipc_subscr {
-        struct tipc_name_seq seq;       /* name sequence of interest */
-        __u32 timeout;                  /* subscription duration (in ms) */
-        __u32 filter;                   /* bitmask of filter options */
-        char usr_handle[8];             /* available for subscriber use */
+        struct tipc_name_seq seq;       /* NBO. Name sequence of interest */
+        __u32 timeout;                  /* NBO. Subscription duration (in ms) */
+        __u32 filter;                   /* NBO. Bitmask of filter options */
+        char usr_handle[8];             /* Opaque. Available for subscriber use */
 };
 
 #define TIPC_PUBLISHED          1       /* publication event */
@@ -151,11 +145,11 @@ struct tipc_subscr {
 #define TIPC_SUBSCR_TIMEOUT     3       /* subscription timeout event */
 
 struct tipc_event {
-        __u32 event;                    /* event type */
-        __u32 found_lower;              /* matching name seq instances */
-        __u32 found_upper;              /*    "      "    "     "      */
-        struct tipc_portid port;        /* associated port */
-        struct tipc_subscr s;           /* associated subscription */
+        __u32 event;                    /* NBO. Event type, as defined above */
+        __u32 found_lower;              /* NBO. Matching name seq instances  */
+        __u32 found_upper;              /*  "      "       "   "    "        */
+        struct tipc_portid port;        /* NBO. Associated port              */
+        struct tipc_subscr s;           /* Original, associated subscription */
 };
 
 /*
@@ -188,7 +182,7 @@ struct sockaddr_tipc {
                 struct tipc_name_seq nameseq;
                 struct {
                         struct tipc_name name;
-                        __u32 domain; /* 0: own zone */
+                        __u32 domain;
                 } name;
         } addr;
 };
@@ -206,7 +200,7 @@ struct sockaddr_tipc {
  */
 
 #define TIPC_IMPORTANCE         127     /* Default: TIPC_LOW_IMPORTANCE */
-#define TIPC_SRC_DROPPABLE      128     /* Default: 0 (resend congested msg) */
+#define TIPC_SRC_DROPPABLE      128     /* Default: based on socket type */
 #define TIPC_DEST_DROPPABLE     129     /* Default: based on socket type */
 #define TIPC_CONN_TIMEOUT       130     /* Default: 8000 (ms)  */
 #define TIPC_NODE_RECVQ_DEPTH   131     /* Default: none (read only) */
diff --git a/include/linux/tipc_config.h b/include/linux/tipc_config.h
index 2bc6fa4adeb5..9cde86c32412 100644
--- a/include/linux/tipc_config.h
+++ b/include/linux/tipc_config.h
@@ -74,6 +74,7 @@
 #define  TIPC_CMD_SHOW_NAME_TABLE   0x0005    /* tx name_tbl_query, rx ultra_string */
 #define  TIPC_CMD_SHOW_PORTS        0x0006    /* tx none, rx ultra_string */
 #define  TIPC_CMD_SHOW_LINK_STATS   0x000B    /* tx link_name, rx ultra_string */
+#define  TIPC_CMD_SHOW_STATS        0x000F    /* tx unsigned, rx ultra_string */
 
 #if 0
 #define  TIPC_CMD_SHOW_PORT_STATS   0x0008    /* tx port_ref, rx ultra_string */
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 4409967db0c4..931078b73226 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -23,7 +23,7 @@
  */
 #define NR_UNIX98_PTY_DEFAULT   4096      /* Default maximum for Unix98 ptys */
 #define NR_UNIX98_PTY_MAX       (1 << MINORBITS) /* Absolute limit */
-#define NR_LDISCS               20
+#define NR_LDISCS               30
 
 /* line disciplines */
 #define N_TTY           0
@@ -46,8 +46,9 @@
 #define N_GIGASET_M101  16      /* Siemens Gigaset M101 serial DECT adapter */
 #define N_SLCAN         17      /* Serial / USB serial CAN Adaptors */
 #define N_PPS           18      /* Pulse per Second */
-
 #define N_V253          19      /* Codec control over voice modem */
+#define N_CAIF          20      /* CAIF protocol for talking to modems */
+#define N_GSM0710       21      /* GSM 0710 Mux */
 
 /*
  * This character is the same as _POSIX_VDISABLE: it cannot be used as
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 739f1fd1cc15..d5922a877994 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -45,27 +45,14 @@ struct wusb_dev;
 
 struct ep_device;
 
-/* For SS devices */
-/**
- * struct usb_host_ss_ep_comp - Valid for SuperSpeed devices only
- * @desc: endpoint companion descriptor, wMaxPacketSize in native byteorder
- * @extra: descriptors following this endpoint companion descriptor
- * @extralen: how many bytes of "extra" are valid
- */
-struct usb_host_ss_ep_comp {
-        struct usb_ss_ep_comp_descriptor        desc;
-        unsigned char                           *extra;   /* Extra descriptors */
-        int                                     extralen;
-};
-
 /**
  * struct usb_host_endpoint - host-side endpoint descriptor and queue
  * @desc: descriptor for this endpoint, wMaxPacketSize in native byteorder
+ * @ss_ep_comp: SuperSpeed companion descriptor for this endpoint
  * @urb_list: urbs queued to this endpoint; maintained by usbcore
  * @hcpriv: for use by HCD; typically holds hardware dma queue head (QH)
  *      with one or more transfer descriptors (TDs) per urb
  * @ep_dev: ep_device for sysfs info
- * @ss_ep_comp: companion descriptor information for this endpoint
  * @extra: descriptors following this endpoint in the configuration
  * @extralen: how many bytes of "extra" are valid
  * @enabled: URBs may be submitted to this endpoint
@@ -74,11 +61,11 @@ struct usb_host_ss_ep_comp {
  * descriptor within an active interface in a given USB configuration.
  */
 struct usb_host_endpoint {
-        struct usb_endpoint_descriptor  desc;
+        struct usb_endpoint_descriptor          desc;
+        struct usb_ss_ep_comp_descriptor        ss_ep_comp;
         struct list_head                urb_list;
         void                            *hcpriv;
-        struct ep_device                *ep_dev;        /* For sysfs info */
-        struct usb_host_ss_ep_comp      *ss_ep_comp;    /* For SS devices */
+        struct ep_device                *ep_dev;        /* For sysfs info */
 
         unsigned char *extra;   /* Extra descriptors */
         int extralen;
@@ -109,8 +96,8 @@ enum usb_interface_condition {
 /**
  * struct usb_interface - what usb device drivers talk to
  * @altsetting: array of interface structures, one for each alternate
- *      setting that may be selected.  Each one includes a set of
- *      endpoint configurations.  They will be in no particular order.
+ *      setting that may be selected.  Each one includes a set of
+ *      endpoint configurations.  They will be in no particular order.
  * @cur_altsetting: the current altsetting.
  * @num_altsetting: number of altsettings defined.
  * @intf_assoc: interface association descriptor
@@ -197,8 +184,6 @@ struct usb_interface {
         struct work_struct reset_ws;    /* for resets in atomic context */
 };
 #define to_usb_interface(d) container_of(d, struct usb_interface, dev)
-#define interface_to_usbdev(intf) \
-        container_of(intf->dev.parent, struct usb_device, dev)
 
 static inline void *usb_get_intfdata(struct usb_interface *intf)
 {
@@ -215,7 +200,7 @@ void usb_put_intf(struct usb_interface *intf);
 
 /* this maximum is arbitrary */
 #define USB_MAXINTERFACES       32
-#define USB_MAXIADS             USB_MAXINTERFACES/2
+#define USB_MAXIADS             (USB_MAXINTERFACES/2)
 
 /**
  * struct usb_interface_cache - long-term representation of a device interface
@@ -425,7 +410,6 @@ struct usb_tt;
  * @connect_time: time device was first connected
  * @do_remote_wakeup:  remote wakeup should be enabled
  * @reset_resume: needs reset instead of resume
- * @autosuspend_disabled: autosuspend disabled by the user
  * @wusb_dev: if this is a Wireless USB device, link to the WUSB
  *      specific data for the device.
  * @slot_id: Slot ID assigned by xHCI
@@ -436,7 +420,7 @@ struct usb_tt;
  */
 struct usb_device {
         int             devnum;
-        char            devpath [16];
+        char            devpath[16];
         u32             route;
         enum usb_device_state   state;
         enum usb_device_speed   speed;
@@ -469,7 +453,7 @@ struct usb_device {
         unsigned persist_enabled:1;
         unsigned have_langid:1;
         unsigned authorized:1;
-        unsigned authenticated:1;
+        unsigned authenticated:1;
         unsigned wusb:1;
         int string_langid;
 
@@ -501,13 +485,17 @@ struct usb_device {
 
         unsigned do_remote_wakeup:1;
         unsigned reset_resume:1;
-        unsigned autosuspend_disabled:1;
 #endif
         struct wusb_dev *wusb_dev;
         int slot_id;
 };
 #define to_usb_device(d) container_of(d, struct usb_device, dev)
 
+static inline struct usb_device *interface_to_usbdev(struct usb_interface *intf)
+{
+        return to_usb_device(intf->dev.parent);
+}
+
 extern struct usb_device *usb_get_dev(struct usb_device *dev);
 extern void usb_put_dev(struct usb_device *dev);
 
@@ -522,12 +510,11 @@ extern int usb_lock_device_for_reset(struct usb_device *udev,
 extern int usb_reset_device(struct usb_device *dev);
 extern void usb_queue_reset_device(struct usb_interface *dev);
 
-extern struct usb_device *usb_find_device(u16 vendor_id, u16 product_id);
 
 /* USB autosuspend and autoresume */
 #ifdef CONFIG_USB_SUSPEND
-extern int usb_enable_autosuspend(struct usb_device *udev);
-extern int usb_disable_autosuspend(struct usb_device *udev);
+extern void usb_enable_autosuspend(struct usb_device *udev);
+extern void usb_disable_autosuspend(struct usb_device *udev);
 
 extern int usb_autopm_get_interface(struct usb_interface *intf);
 extern void usb_autopm_put_interface(struct usb_interface *intf);
@@ -572,6 +559,16 @@ static inline void usb_mark_last_busy(struct usb_device *udev)
 /* for drivers using iso endpoints */
 extern int usb_get_current_frame_number(struct usb_device *usb_dev);
 
+/* Sets up a group of bulk endpoints to support multiple stream IDs. */
+extern int usb_alloc_streams(struct usb_interface *interface,
+                struct usb_host_endpoint **eps, unsigned int num_eps,
+                unsigned int num_streams, gfp_t mem_flags);
+
+/* Reverts a group of bulk endpoints back to not using stream IDs. */
+extern void usb_free_streams(struct usb_interface *interface,
+                struct usb_host_endpoint **eps, unsigned int num_eps,
+                gfp_t mem_flags);
+
 /* used these for multi-interface device registration */
 extern int usb_driver_claim_interface(struct usb_driver *driver,
                         struct usb_interface *iface, void *priv);
@@ -667,7 +664,7 @@ static inline int usb_make_path(struct usb_device *dev, char *buf, size_t size)
  * This macro is used to create a struct usb_device_id that matches a
  * specific device.
  */
-#define USB_DEVICE(vend,prod) \
+#define USB_DEVICE(vend, prod) \
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE, \
         .idVendor = (vend), \
         .idProduct = (prod)
@@ -958,17 +955,25 @@ extern int usb_disabled(void);
 #define URB_ISO_ASAP            0x0002  /* iso-only, urb->start_frame
                                          * ignored */
 #define URB_NO_TRANSFER_DMA_MAP 0x0004  /* urb->transfer_dma valid on submit */
-#define URB_NO_SETUP_DMA_MAP    0x0008  /* urb->setup_dma valid on submit */
 #define URB_NO_FSBR             0x0020  /* UHCI-specific */
 #define URB_ZERO_PACKET         0x0040  /* Finish bulk OUT with short packet */
 #define URB_NO_INTERRUPT        0x0080  /* HINT: no non-error interrupt
                                          * needed */
 #define URB_FREE_BUFFER         0x0100  /* Free transfer buffer with the URB */
 
+/* The following flags are used internally by usbcore and HCDs */
 #define URB_DIR_IN              0x0200  /* Transfer from device to host */
 #define URB_DIR_OUT             0
 #define URB_DIR_MASK            URB_DIR_IN
 
+#define URB_DMA_MAP_SINGLE      0x00010000      /* Non-scatter-gather mapping */
+#define URB_DMA_MAP_PAGE        0x00020000      /* HCD-unsupported S-G */
+#define URB_DMA_MAP_SG          0x00040000      /* HCD-supported S-G */
+#define URB_MAP_LOCAL           0x00080000      /* HCD-local-memory mapping */
+#define URB_SETUP_MAP_SINGLE    0x00100000      /* Setup packet DMA mapped */
+#define URB_SETUP_MAP_LOCAL     0x00200000      /* HCD-local setup packet */
+#define URB_DMA_SG_COMBINED     0x00400000      /* S-G entries were combined */
+
 struct usb_iso_packet_descriptor {
         unsigned int offset;
         unsigned int length;            /* expected length */
@@ -1045,12 +1050,8 @@ typedef void (*usb_complete_t)(struct urb *);
  * @setup_packet: Only used for control transfers, this points to eight bytes
  *      of setup data.  Control transfers always start by sending this data
  *      to the device.  Then transfer_buffer is read or written, if needed.
- * @setup_dma: For control transfers with URB_NO_SETUP_DMA_MAP set, the
- *      device driver has provided this DMA address for the setup packet.
- *      The host controller driver should use this in preference to
- *      setup_packet, but the HCD may chose to ignore the address if it must
- *      copy the setup packet into internal structures.  Therefore, setup_packet
- *      must always point to a valid buffer.
+ * @setup_dma: DMA pointer for the setup packet.  The caller must not use
+ *      this field; setup_packet must point to a valid buffer.
  * @start_frame: Returns the initial frame for isochronous transfers.
  * @number_of_packets: Lists the number of ISO transfer buffers.
  * @interval: Specifies the polling interval for interrupt or isochronous
@@ -1082,13 +1083,14 @@ typedef void (*usb_complete_t)(struct urb *);
  * bounce buffer or talking to an IOMMU),
  * although they're cheap on commodity x86 and ppc hardware.
  *
- * Alternatively, drivers may pass the URB_NO_xxx_DMA_MAP transfer flags,
- * which tell the host controller driver that no such mapping is needed since
+ * Alternatively, drivers may pass the URB_NO_TRANSFER_DMA_MAP transfer flag,
+ * which tells the host controller driver that no such mapping is needed for
+ * the transfer_buffer since
  * the device driver is DMA-aware.  For example, a device driver might
  * allocate a DMA buffer with usb_alloc_coherent() or call usb_buffer_map().
- * When these transfer flags are provided, host controller drivers will
- * attempt to use the dma addresses found in the transfer_dma and/or
- * setup_dma fields rather than determining a dma address themselves.
+ * When this transfer flag is provided, host controller drivers will
+ * attempt to use the dma address found in the transfer_dma
+ * field rather than determining a dma address themselves.
  *
  * Note that transfer_buffer must still be set if the controller
  * does not support DMA (as indicated by bus.uses_dma) and when talking
@@ -1111,11 +1113,9 @@ typedef void (*usb_complete_t)(struct urb *);
  * should always terminate with a short packet, even if it means adding an
  * extra zero length packet.
  *
- * Control URBs must provide a setup_packet.  The setup_packet and
- * transfer_buffer may each be mapped for DMA or not, independently of
- * the other.  The transfer_flags bits URB_NO_TRANSFER_DMA_MAP and
- * URB_NO_SETUP_DMA_MAP indicate which buffers have already been mapped.
- * URB_NO_SETUP_DMA_MAP is ignored for non-control URBs.
+ * Control URBs must provide a valid pointer in the setup_packet field.
+ * Unlike the transfer_buffer, the setup_packet may not be mapped for DMA
+ * beforehand.
  *
  * Interrupt URBs must provide an interval, saying how often (in milliseconds
  * or, for highspeed devices, 125 microsecond units)
@@ -1186,14 +1186,15 @@ struct urb {
                                          * current owner */
         struct list_head anchor_list;   /* the URB may be anchored */
         struct usb_anchor *anchor;
-        struct usb_device *dev;         /* (in) pointer to associated device */
+        struct usb_device *dev;         /* (in) pointer to associated device */
         struct usb_host_endpoint *ep;   /* (internal) pointer to endpoint */
         unsigned int pipe;              /* (in) pipe information */
+        unsigned int stream_id;         /* (in) stream ID */
         int status;                     /* (return) non-ISO status */
         unsigned int transfer_flags;    /* (in) URB_SHORT_NOT_OK | ...*/
         void *transfer_buffer;          /* (in) associated data buffer */
         dma_addr_t transfer_dma;        /* (in) dma addr for transfer_buffer */
-        struct usb_sg_request *sg;      /* (in) scatter gather buffer list */
+        struct scatterlist *sg;         /* (in) scatter gather buffer list */
         int num_sgs;                    /* (in) number of entries in the sg list */
         u32 transfer_buffer_length;     /* (in) data buffer length */
         u32 actual_length;              /* (return) actual transfer length */
@@ -1371,18 +1372,6 @@ void *usb_alloc_coherent(struct usb_device *dev, size_t size,
 void usb_free_coherent(struct usb_device *dev, size_t size,
         void *addr, dma_addr_t dma);
 
-/* Compatible macros while we switch over */
-static inline void *usb_buffer_alloc(struct usb_device *dev, size_t size,
-                                     gfp_t mem_flags, dma_addr_t *dma)
-{
-        return usb_alloc_coherent(dev, size, mem_flags, dma);
-}
-static inline void usb_buffer_free(struct usb_device *dev, size_t size,
-                                   void *addr, dma_addr_t dma)
-{
-        return usb_free_coherent(dev, size, addr, dma);
-}
-
 #if 0
 struct urb *usb_buffer_map(struct urb *urb);
 void usb_buffer_dmasync(struct urb *urb);
@@ -1467,8 +1456,6 @@ struct usb_sg_request {
 
         struct usb_device       *dev;
         int                     pipe;
-        struct scatterlist      *sg;
-        int                     nents;
 
         int                     entries;
         struct urb              **urbs;
@@ -1536,23 +1523,31 @@ static inline unsigned int __create_pipe(struct usb_device *dev,
 }
 
 /* Create various pipes... */
-#define usb_sndctrlpipe(dev,endpoint)   \
+#define usb_sndctrlpipe(dev, endpoint)  \
         ((PIPE_CONTROL << 30) | __create_pipe(dev, endpoint))
-#define usb_rcvctrlpipe(dev,endpoint)   \
+#define usb_rcvctrlpipe(dev, endpoint)  \
         ((PIPE_CONTROL << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
-#define usb_sndisocpipe(dev,endpoint)   \
+#define usb_sndisocpipe(dev, endpoint)  \
         ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev, endpoint))
-#define usb_rcvisocpipe(dev,endpoint)   \
+#define usb_rcvisocpipe(dev, endpoint)  \
         ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
-#define usb_sndbulkpipe(dev,endpoint)   \
+#define usb_sndbulkpipe(dev, endpoint)  \
         ((PIPE_BULK << 30) | __create_pipe(dev, endpoint))
-#define usb_rcvbulkpipe(dev,endpoint)   \
+#define usb_rcvbulkpipe(dev, endpoint)  \
         ((PIPE_BULK << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
-#define usb_sndintpipe(dev,endpoint)    \
+#define usb_sndintpipe(dev, endpoint)   \
         ((PIPE_INTERRUPT << 30) | __create_pipe(dev, endpoint))
-#define usb_rcvintpipe(dev,endpoint)    \
+#define usb_rcvintpipe(dev, endpoint)   \
         ((PIPE_INTERRUPT << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
 
+static inline struct usb_host_endpoint *
+usb_pipe_endpoint(struct usb_device *dev, unsigned int pipe)
+{
+        struct usb_host_endpoint **eps;
+        eps = usb_pipein(pipe) ? dev->ep_in : dev->ep_out;
+        return eps[usb_pipeendpoint(pipe)];
+}
+
 /*-------------------------------------------------------------------------*/
 
 static inline __u16
diff --git a/include/linux/usb/Kbuild b/include/linux/usb/Kbuild
index 29fd73b0bffc..51410e0200cf 100644
--- a/include/linux/usb/Kbuild
+++ b/include/linux/usb/Kbuild
@@ -1,6 +1,7 @@
 header-y += audio.h
 header-y += cdc.h
 header-y += ch9.h
+header-y += ch11.h
 header-y += gadgetfs.h
 header-y += midi.h
 header-y += g_printer.h
diff --git a/include/linux/usb/atmel_usba_udc.h b/include/linux/usb/atmel_usba_udc.h
index baf41c8616e9..ba99af275a31 100644
--- a/include/linux/usb/atmel_usba_udc.h
+++ b/include/linux/usb/atmel_usba_udc.h
@@ -15,7 +15,7 @@ struct usba_ep_data {
 
 struct usba_platform_data {
         int                     vbus_pin;
-        int                     vbus_pin_inverted;
+        int                     vbus_pin_inverted;
         int                     num_ep;
         struct usba_ep_data     ep[0];
 };
diff --git a/include/linux/usb/audio-v2.h b/include/linux/usb/audio-v2.h
new file mode 100644
index 000000000000..2389f93a28b5
--- /dev/null
+++ b/include/linux/usb/audio-v2.h
@@ -0,0 +1,378 @@
+/*
+ * Copyright (c) 2010 Daniel Mack <daniel@caiaq.de>
+ *
+ * This software is distributed under the terms of the GNU General Public
+ * License ("GPL") version 2, as published by the Free Software Foundation.
+ *
+ * This file holds USB constants and structures defined
+ * by the USB Device Class Definition for Audio Devices in version 2.0.
+ * Comments below reference relevant sections of the documents contained
+ * in http://www.usb.org/developers/devclass_docs/Audio2.0_final.zip
+ */
+
+#ifndef __LINUX_USB_AUDIO_V2_H
+#define __LINUX_USB_AUDIO_V2_H
+
+#include <linux/types.h>
+
+/* v1.0 and v2.0 of this standard have many things in common. For the rest
+ * of the definitions, please refer to audio.h */
+
+/* 4.7.2.1 Clock Source Descriptor */
+
+struct uac_clock_source_descriptor {
+        __u8 bLength;
+        __u8 bDescriptorType;
+        __u8 bDescriptorSubtype;
+        __u8 bClockID;
+        __u8 bmAttributes;
+        __u8 bmControls;
+        __u8 bAssocTerminal;
+        __u8 iClockSource;
+} __attribute__((packed));
+
+/* 4.7.2.2 Clock Source Descriptor */
+
+struct uac_clock_selector_descriptor {
+        __u8 bLength;
+        __u8 bDescriptorType;
+        __u8 bDescriptorSubtype;
+        __u8 bClockID;
+        __u8 bNrInPins;
+        __u8 bmControls;
+        __u8 baCSourceID[];
+} __attribute__((packed));
+
+/* 4.7.2.4 Input terminal descriptor */
+
+struct uac2_input_terminal_descriptor {
+        __u8 bLength;
+        __u8 bDescriptorType;
+        __u8 bDescriptorSubtype;
+        __u8 bTerminalID;
+        __u16 wTerminalType;
+        __u8 bAssocTerminal;
+        __u8 bCSourceID;
+        __u8 bNrChannels;
+        __u32 bmChannelConfig;
+        __u8 iChannelNames;
+        __u16 bmControls;
+        __u8 iTerminal;
+} __attribute__((packed));
+
+/* 4.7.2.5 Output terminal descriptor */
+
+struct uac2_output_terminal_descriptor {
+        __u8 bLength;
+        __u8 bDescriptorType;
+        __u8 bDescriptorSubtype;
+        __u8 bTerminalID;
+        __u16 wTerminalType;
+        __u8 bAssocTerminal;
+        __u8 bSourceID;
+        __u8 bCSourceID;
+        __u16 bmControls;
+        __u8 iTerminal;
+} __attribute__((packed));
+
+
+
+/* 4.7.2.8 Feature Unit Descriptor */
+
+struct uac2_feature_unit_descriptor {
+        __u8 bLength;
+        __u8 bDescriptorType;
+        __u8 bDescriptorSubtype;
+        __u8 bUnitID;
+        __u8 bSourceID;
+        /* bmaControls is actually u32,
+         * but u8 is needed for the hybrid parser */
+        __u8 bmaControls[0]; /* variable length */
+} __attribute__((packed));
+
+/* 4.9.2 Class-Specific AS Interface Descriptor */
+
+struct uac_as_header_descriptor_v2 {
+        __u8 bLength;
+        __u8 bDescriptorType;
+        __u8 bDescriptorSubtype;
+        __u8 bTerminalLink;
+        __u8 bmControls;
+        __u8 bFormatType;
+        __u32 bmFormats;
+        __u8 bNrChannels;
+        __u32 bmChannelConfig;
+        __u8 iChannelNames;
+} __attribute__((packed));
+
+/* 6.1 Interrupt Data Message */
+
+#define UAC2_INTERRUPT_DATA_MSG_VENDOR  (1 << 0)
+#define UAC2_INTERRUPT_DATA_MSG_EP      (1 << 1)
+
+struct uac2_interrupt_data_msg {
+        __u8 bInfo;
+        __u8 bAttribute;
+        __le16 wValue;
+        __le16 wIndex;
+} __attribute__((packed));
+
+/* A.7 Audio Function Category Codes */
+#define UAC2_FUNCTION_SUBCLASS_UNDEFINED        0x00
+#define UAC2_FUNCTION_DESKTOP_SPEAKER           0x01
+#define UAC2_FUNCTION_HOME_THEATER              0x02
+#define UAC2_FUNCTION_MICROPHONE                0x03
+#define UAC2_FUNCTION_HEADSET                   0x04
+#define UAC2_FUNCTION_TELEPHONE                 0x05
+#define UAC2_FUNCTION_CONVERTER                 0x06
+#define UAC2_FUNCTION_SOUND_RECORDER            0x07
+#define UAC2_FUNCTION_IO_BOX                    0x08
+#define UAC2_FUNCTION_MUSICAL_INSTRUMENT        0x09
+#define UAC2_FUNCTION_PRO_AUDIO                 0x0a
+#define UAC2_FUNCTION_AUDIO_VIDEO               0x0b
+#define UAC2_FUNCTION_CONTROL_PANEL             0x0c
+#define UAC2_FUNCTION_OTHER                     0xff
+
+/* A.9 Audio Class-Specific AC Interface Descriptor Subtypes */
+/* see audio.h for the rest, which is identical to v1 */
+#define UAC2_EFFECT_UNIT                        0x07
+#define UAC2_PROCESSING_UNIT_V2         0x08
+#define UAC2_EXTENSION_UNIT_V2          0x09
+#define UAC2_CLOCK_SOURCE               0x0a
+#define UAC2_CLOCK_SELECTOR             0x0b
+#define UAC2_CLOCK_MULTIPLIER           0x0c
+#define UAC2_SAMPLE_RATE_CONVERTER      0x0d
+
+/* A.10 Audio Class-Specific AS Interface Descriptor Subtypes */
+/* see audio.h for the rest, which is identical to v1 */
+#define UAC2_ENCODER                    0x03
+#define UAC2_DECODER                    0x04
+
+/* A.11 Effect Unit Effect Types */
+#define UAC2_EFFECT_UNDEFINED           0x00
+#define UAC2_EFFECT_PARAM_EQ            0x01
+#define UAC2_EFFECT_REVERB              0x02
+#define UAC2_EFFECT_MOD_DELAY           0x03
+#define UAC2_EFFECT_DYN_RANGE_COMP      0x04
+
+/* A.12 Processing Unit Process Types */
+#define UAC2_PROCESS_UNDEFINED          0x00
+#define UAC2_PROCESS_UP_DOWNMIX         0x01
+#define UAC2_PROCESS_DOLBY_PROLOCIC     0x02
+#define UAC2_PROCESS_STEREO_EXTENDER    0x03
+
+/* A.14 Audio Class-Specific Request Codes */
+#define UAC2_CS_CUR                     0x01
+#define UAC2_CS_RANGE                   0x02
+#define UAC2_CS_MEM                     0x03
+
+/* A.15 Encoder Type Codes */
+#define UAC2_ENCODER_UNDEFINED          0x00
+#define UAC2_ENCODER_OTHER              0x01
+#define UAC2_ENCODER_MPEG               0x02
+#define UAC2_ENCODER_AC3                0x03
+#define UAC2_ENCODER_WMA                0x04
+#define UAC2_ENCODER_DTS                0x05
+
+/* A.16 Decoder Type Codes */
+#define UAC2_DECODER_UNDEFINED          0x00
+#define UAC2_DECODER_OTHER              0x01
+#define UAC2_DECODER_MPEG               0x02
+#define UAC2_DECODER_AC3                0x03
+#define UAC2_DECODER_WMA                0x04
+#define UAC2_DECODER_DTS                0x05
+
+/* A.17.1 Clock Source Control Selectors */
+#define UAC2_CS_UNDEFINED               0x00
+#define UAC2_CS_CONTROL_SAM_FREQ        0x01
+#define UAC2_CS_CONTROL_CLOCK_VALID     0x02
+
+/* A.17.2 Clock Selector Control Selectors */
+#define UAC2_CX_UNDEFINED               0x00
+#define UAC2_CX_CLOCK_SELECTOR          0x01
+
+/* A.17.3 Clock Multiplier Control Selectors */
+#define UAC2_CM_UNDEFINED               0x00
+#define UAC2_CM_NUMERATOR               0x01
+#define UAC2_CM_DENOMINTATOR            0x02
+
+/* A.17.4 Terminal Control Selectors */
+#define UAC2_TE_UNDEFINED               0x00
+#define UAC2_TE_COPY_PROTECT            0x01
+#define UAC2_TE_CONNECTOR               0x02
+#define UAC2_TE_OVERLOAD                0x03
+#define UAC2_TE_CLUSTER                 0x04
+#define UAC2_TE_UNDERFLOW               0x05
+#define UAC2_TE_OVERFLOW                0x06
+#define UAC2_TE_LATENCY                 0x07
+
+/* A.17.5 Mixer Control Selectors */
+#define UAC2_MU_UNDEFINED               0x00
+#define UAC2_MU_MIXER                   0x01
+#define UAC2_MU_CLUSTER                 0x02
+#define UAC2_MU_UNDERFLOW               0x03
+#define UAC2_MU_OVERFLOW                0x04
+#define UAC2_MU_LATENCY                 0x05
+
+/* A.17.6 Selector Control Selectors */
+#define UAC2_SU_UNDEFINED               0x00
+#define UAC2_SU_SELECTOR                0x01
+#define UAC2_SU_LATENCY                 0x02
+
+/* A.17.7 Feature Unit Control Selectors */
+/* see audio.h for the rest, which is identical to v1 */
+#define UAC2_FU_INPUT_GAIN              0x0b
+#define UAC2_FU_INPUT_GAIN_PAD          0x0c
+#define UAC2_FU_PHASE_INVERTER          0x0d
+#define UAC2_FU_UNDERFLOW               0x0e
+#define UAC2_FU_OVERFLOW                0x0f
+#define UAC2_FU_LATENCY                 0x10
+
+/* A.17.8.1 Parametric Equalizer Section Effect Unit Control Selectors */
+#define UAC2_PE_UNDEFINED               0x00
+#define UAC2_PE_ENABLE                  0x01
+#define UAC2_PE_CENTERFREQ              0x02
+#define UAC2_PE_QFACTOR                 0x03
+#define UAC2_PE_GAIN                    0x04
+#define UAC2_PE_UNDERFLOW               0x05
+#define UAC2_PE_OVERFLOW                0x06
+#define UAC2_PE_LATENCY                 0x07
+
+/* A.17.8.2 Reverberation Effect Unit Control Selectors */
+#define UAC2_RV_UNDEFINED               0x00
+#define UAC2_RV_ENABLE                  0x01
+#define UAC2_RV_TYPE                    0x02
+#define UAC2_RV_LEVEL                   0x03
+#define UAC2_RV_TIME                    0x04
+#define UAC2_RV_FEEDBACK                0x05
+#define UAC2_RV_PREDELAY                0x06
+#define UAC2_RV_DENSITY                 0x07
+#define UAC2_RV_HIFREQ_ROLLOFF          0x08
+#define UAC2_RV_UNDERFLOW               0x09
+#define UAC2_RV_OVERFLOW                0x0a
+#define UAC2_RV_LATENCY                 0x0b
+
+/* A.17.8.3 Modulation Delay Effect Control Selectors */
+#define UAC2_MD_UNDEFINED               0x00
+#define UAC2_MD_ENABLE                  0x01
+#define UAC2_MD_BALANCE                 0x02
+#define UAC2_MD_RATE                    0x03
+#define UAC2_MD_DEPTH                   0x04
+#define UAC2_MD_TIME                    0x05
+#define UAC2_MD_FEEDBACK                0x06
+#define UAC2_MD_UNDERFLOW               0x07
+#define UAC2_MD_OVERFLOW                0x08
+#define UAC2_MD_LATENCY                 0x09
+
+/* A.17.8.4 Dynamic Range Compressor Effect Unit Control Selectors */
+#define UAC2_DR_UNDEFINED               0x00
+#define UAC2_DR_ENABLE                  0x01
+#define UAC2_DR_COMPRESSION_RATE        0x02
+#define UAC2_DR_MAXAMPL                 0x03
+#define UAC2_DR_THRESHOLD               0x04
+#define UAC2_DR_ATTACK_TIME             0x05
+#define UAC2_DR_RELEASE_TIME            0x06
+#define UAC2_DR_UNDEFLOW                0x07
+#define UAC2_DR_OVERFLOW                0x08
+#define UAC2_DR_LATENCY                 0x09
+
+/* A.17.9.1 Up/Down-mix Processing Unit Control Selectors */
+#define UAC2_UD_UNDEFINED               0x00
+#define UAC2_UD_ENABLE                  0x01
+#define UAC2_UD_MODE_SELECT             0x02
+#define UAC2_UD_CLUSTER                 0x03
+#define UAC2_UD_UNDERFLOW               0x04
+#define UAC2_UD_OVERFLOW                0x05
+#define UAC2_UD_LATENCY                 0x06
+
+/* A.17.9.2 Dolby Prologic[tm] Processing Unit Control Selectors */
+#define UAC2_DP_UNDEFINED               0x00
+#define UAC2_DP_ENABLE                  0x01
+#define UAC2_DP_MODE_SELECT             0x02
+#define UAC2_DP_CLUSTER                 0x03
+#define UAC2_DP_UNDERFFLOW              0x04
+#define UAC2_DP_OVERFLOW                0x05
+#define UAC2_DP_LATENCY                 0x06
+
+/* A.17.9.3 Stereo Expander Processing Unit Control Selectors */
+#define UAC2_ST_EXT_UNDEFINED           0x00
+#define UAC2_ST_EXT_ENABLE              0x01
+#define UAC2_ST_EXT_WIDTH               0x02
+#define UAC2_ST_EXT_UNDEFLOW            0x03
+#define UAC2_ST_EXT_OVERFLOW            0x04
+#define UAC2_ST_EXT_LATENCY             0x05
+
+/* A.17.10 Extension Unit Control Selectors */
+#define UAC2_XU_UNDEFINED               0x00
+#define UAC2_XU_ENABLE                  0x01
+#define UAC2_XU_CLUSTER                 0x02
+#define UAC2_XU_UNDERFLOW               0x03
+#define UAC2_XU_OVERFLOW                0x04
+#define UAC2_XU_LATENCY                 0x05
+
+/* A.17.11 AudioStreaming Interface Control Selectors */
+#define UAC2_AS_UNDEFINED               0x00
+#define UAC2_AS_ACT_ALT_SETTING         0x01
+#define UAC2_AS_VAL_ALT_SETTINGS        0x02
+#define UAC2_AS_AUDIO_DATA_FORMAT       0x03
+
+/* A.17.12 Encoder Control Selectors */
+#define UAC2_EN_UNDEFINED               0x00
+#define UAC2_EN_BIT_RATE                0x01
+#define UAC2_EN_QUALITY                 0x02
+#define UAC2_EN_VBR                     0x03
+#define UAC2_EN_TYPE                    0x04
+#define UAC2_EN_UNDERFLOW               0x05
+#define UAC2_EN_OVERFLOW                0x06
+#define UAC2_EN_ENCODER_ERROR           0x07
+#define UAC2_EN_PARAM1                  0x08
+#define UAC2_EN_PARAM2                  0x09
+#define UAC2_EN_PARAM3                  0x0a
+#define UAC2_EN_PARAM4                  0x0b
+#define UAC2_EN_PARAM5                  0x0c
+#define UAC2_EN_PARAM6                  0x0d
+#define UAC2_EN_PARAM7                  0x0e
+#define UAC2_EN_PARAM8                  0x0f
+
+/* A.17.13.1 MPEG Decoder Control Selectors */
+#define UAC2_MPEG_UNDEFINED             0x00
+#define UAC2_MPEG_DUAL_CHANNEL          0x01
+#define UAC2_MPEG_SECOND_STEREO         0x02
+#define UAC2_MPEG_MULTILINGUAL          0x03
+#define UAC2_MPEG_DYN_RANGE             0x04
+#define UAC2_MPEG_SCALING               0x05
+#define UAC2_MPEG_HILO_SCALING          0x06
+#define UAC2_MPEG_UNDERFLOW             0x07
+#define UAC2_MPEG_OVERFLOW              0x08
+#define UAC2_MPEG_DECODER_ERROR         0x09
+
+/* A17.13.2 AC3 Decoder Control Selectors */
+#define UAC2_AC3_UNDEFINED              0x00
+#define UAC2_AC3_MODE                   0x01
+#define UAC2_AC3_DYN_RANGE              0x02
+#define UAC2_AC3_SCALING                0x03
+#define UAC2_AC3_HILO_SCALING           0x04
+#define UAC2_AC3_UNDERFLOW              0x05
+#define UAC2_AC3_OVERFLOW               0x06
+#define UAC2_AC3_DECODER_ERROR          0x07
+
+/* A17.13.3 WMA Decoder Control Selectors */
+#define UAC2_WMA_UNDEFINED              0x00
+#define UAC2_WMA_UNDERFLOW              0x01
+#define UAC2_WMA_OVERFLOW               0x02
+#define UAC2_WMA_DECODER_ERROR          0x03
+
+/* A17.13.4 DTS Decoder Control Selectors */
+#define UAC2_DTS_UNDEFINED              0x00
+#define UAC2_DTS_UNDERFLOW              0x01
+#define UAC2_DTS_OVERFLOW               0x02
+#define UAC2_DTS_DECODER_ERROR          0x03
+
+/* A17.14 Endpoint Control Selectors */
+#define UAC2_EP_CS_UNDEFINED            0x00
+#define UAC2_EP_CS_PITCH                0x01
+#define UAC2_EP_CS_DATA_OVERRUN         0x02
+#define UAC2_EP_CS_DATA_UNDERRUN        0x03
+
+#endif /* __LINUX_USB_AUDIO_V2_H */
+
diff --git a/include/linux/usb/audio.h b/include/linux/usb/audio.h
index 4d3e450e2b03..5d646c388752 100644
--- a/include/linux/usb/audio.h
+++ b/include/linux/usb/audio.h
@@ -13,6 +13,9 @@
  * Comments below reference relevant sections of that document:
  *
  * http://www.usb.org/developers/devclass_docs/audio10.pdf
+ *
+ * Types and defines in this file are either specific to version 1.0 of
+ * this standard or common for newer versions.
  */
 
 #ifndef __LINUX_USB_AUDIO_H
@@ -20,14 +23,15 @@
 
 #include <linux/types.h>
 
+/* bInterfaceProtocol values to denote the version of the standard used */
+#define UAC_VERSION_1                   0x00
+#define UAC_VERSION_2                   0x20
+
 /* A.2 Audio Interface Subclass Codes */
 #define USB_SUBCLASS_AUDIOCONTROL       0x01
 #define USB_SUBCLASS_AUDIOSTREAMING     0x02
 #define USB_SUBCLASS_MIDISTREAMING      0x03
 
-#define UAC_VERSION_1                   0x00
-#define UAC_VERSION_2                   0x20
-
 /* A.5 Audio Class-Specific AC Interface Descriptor Subtypes */
 #define UAC_HEADER                      0x01
 #define UAC_INPUT_TERMINAL              0x02
@@ -38,15 +42,6 @@
 #define UAC_PROCESSING_UNIT_V1          0x07
 #define UAC_EXTENSION_UNIT_V1           0x08
 
-/* UAC v2.0 types */
-#define UAC_EFFECT_UNIT                 0x07
-#define UAC_PROCESSING_UNIT_V2          0x08
-#define UAC_EXTENSION_UNIT_V2           0x09
-#define UAC_CLOCK_SOURCE                0x0a
-#define UAC_CLOCK_SELECTOR              0x0b
-#define UAC_CLOCK_MULTIPLIER            0x0c
-#define UAC_SAMPLE_RATE_CONVERTER       0x0d
-
 /* A.6 Audio Class-Specific AS Interface Descriptor Subtypes */
 #define UAC_AS_GENERAL                  0x01
 #define UAC_FORMAT_TYPE                 0x02
@@ -78,10 +73,6 @@
 
 #define UAC_GET_STAT                    0xff
 
-/* Audio class v2.0 handles all the parameter calls differently */
-#define UAC2_CS_CUR                     0x01
-#define UAC2_CS_RANGE                   0x02
-
 /* MIDI - A.1 MS Class-Specific Interface Descriptor Subtypes */
 #define UAC_MS_HEADER                   0x01
 #define UAC_MIDI_IN_JACK                0x02
@@ -110,7 +101,7 @@ struct uac_ac_header_descriptor_v1 {
 #define UAC_DT_AC_HEADER_SIZE(n)        (8 + (n))
 
 /* As above, but more useful for defining your own descriptors: */
-#define DECLARE_UAC_AC_HEADER_DESCRIPTOR(n)                     \
+#define DECLARE_UAC_AC_HEADER_DESCRIPTOR(n)                     \
 struct uac_ac_header_descriptor_v1_##n {                        \
         __u8  bLength;                                          \
         __u8  bDescriptorType;                                  \
@@ -178,7 +169,7 @@ struct uac_output_terminal_descriptor_v1 {
 #define UAC_DT_FEATURE_UNIT_SIZE(ch)            (7 + ((ch) + 1) * 2)
 
 /* As above, but more useful for defining your own descriptors: */
-#define DECLARE_UAC_FEATURE_UNIT_DESCRIPTOR(ch)                 \
+#define DECLARE_UAC_FEATURE_UNIT_DESCRIPTOR(ch)                 \
 struct uac_feature_unit_descriptor_##ch {                       \
         __u8  bLength;                                          \
         __u8  bDescriptorType;                                  \
@@ -190,6 +181,156 @@ struct uac_feature_unit_descriptor_##ch {			\
         __u8  iFeature;                                         \
 } __attribute__ ((packed))
 
+/* 4.3.2.3 Mixer Unit Descriptor */
+struct uac_mixer_unit_descriptor {
+        __u8 bLength;
+        __u8 bDescriptorType;
+        __u8 bDescriptorSubtype;
+        __u8 bUnitID;
+        __u8 bNrInPins;
+        __u8 baSourceID[];
+} __attribute__ ((packed));
+
+static inline __u8 uac_mixer_unit_bNrChannels(struct uac_mixer_unit_descriptor *desc)
+{
+        return desc->baSourceID[desc->bNrInPins];
+}
+
+static inline __u32 uac_mixer_unit_wChannelConfig(struct uac_mixer_unit_descriptor *desc,
+                                                  int protocol)
+{
+        if (protocol == UAC_VERSION_1)
+                return (desc->baSourceID[desc->bNrInPins + 2] << 8) |
+                        desc->baSourceID[desc->bNrInPins + 1];
+        else
+                return  (desc->baSourceID[desc->bNrInPins + 4] << 24) |
+                        (desc->baSourceID[desc->bNrInPins + 3] << 16) |
+                        (desc->baSourceID[desc->bNrInPins + 2] << 8)  |
+                        (desc->baSourceID[desc->bNrInPins + 1]);
+}
+
+static inline __u8 uac_mixer_unit_iChannelNames(struct uac_mixer_unit_descriptor *desc,
+                                                int protocol)
+{
+        return (protocol == UAC_VERSION_1) ?
+                desc->baSourceID[desc->bNrInPins + 3] :
+                desc->baSourceID[desc->bNrInPins + 5];
+}
+
+static inline __u8 *uac_mixer_unit_bmControls(struct uac_mixer_unit_descriptor *desc,
+                                              int protocol)
+{
+        return (protocol == UAC_VERSION_1) ?
+                &desc->baSourceID[desc->bNrInPins + 4] :
+                &desc->baSourceID[desc->bNrInPins + 6];
+}
+
+static inline __u8 uac_mixer_unit_iMixer(struct uac_mixer_unit_descriptor *desc)
+{
+        __u8 *raw = (__u8 *) desc;
+        return raw[desc->bLength - 1];
+}
+
+/* 4.3.2.4 Selector Unit Descriptor */
+struct uac_selector_unit_descriptor {
+        __u8 bLength;
+        __u8 bDescriptorType;
+        __u8 bDescriptorSubtype;
+        __u8 bUintID;
+        __u8 bNrInPins;
+        __u8 baSourceID[];
+} __attribute__ ((packed));
+
+static inline __u8 uac_selector_unit_iSelector(struct uac_selector_unit_descriptor *desc)
+{
+        __u8 *raw = (__u8 *) desc;
+        return raw[9 + desc->bLength - 1];
+}
+
+/* 4.3.2.5 Feature Unit Descriptor */
+struct uac_feature_unit_descriptor {
+        __u8 bLength;
+        __u8 bDescriptorType;
+        __u8 bDescriptorSubtype;
+        __u8 bUnitID;
+        __u8 bSourceID;
+        __u8 bControlSize;
+        __u8 bmaControls[0]; /* variable length */
+} __attribute__((packed));
+
+static inline __u8 uac_feature_unit_iFeature(struct uac_feature_unit_descriptor *desc)
+{
+        __u8 *raw = (__u8 *) desc;
+        return raw[desc->bLength - 1];
+}
+
+/* 4.3.2.6 Processing Unit Descriptors */
+struct uac_processing_unit_descriptor {
+        __u8 bLength;
+        __u8 bDescriptorType;
+        __u8 bDescriptorSubtype;
+        __u8 bUnitID;
+        __u16 wProcessType;
+        __u8 bNrInPins;
+        __u8 baSourceID[];
+} __attribute__ ((packed));
+
+static inline __u8 uac_processing_unit_bNrChannels(struct uac_processing_unit_descriptor *desc)
+{
+        return desc->baSourceID[desc->bNrInPins];
+}
+
+static inline __u32 uac_processing_unit_wChannelConfig(struct uac_processing_unit_descriptor *desc,
+                                                       int protocol)
+{
+        if (protocol == UAC_VERSION_1)
+                return (desc->baSourceID[desc->bNrInPins + 2] << 8) |
+                        desc->baSourceID[desc->bNrInPins + 1];
+        else
+                return  (desc->baSourceID[desc->bNrInPins + 4] << 24) |
+                        (desc->baSourceID[desc->bNrInPins + 3] << 16) |
+                        (desc->baSourceID[desc->bNrInPins + 2] << 8)  |
+                        (desc->baSourceID[desc->bNrInPins + 1]);
+}
+
+static inline __u8 uac_processing_unit_iChannelNames(struct uac_processing_unit_descriptor *desc,
+                                                     int protocol)
+{
+        return (protocol == UAC_VERSION_1) ?
+                desc->baSourceID[desc->bNrInPins + 3] :
+                desc->baSourceID[desc->bNrInPins + 5];
+}
+
+static inline __u8 uac_processing_unit_bControlSize(struct uac_processing_unit_descriptor *desc,
+                                                    int protocol)
+{
+        return (protocol == UAC_VERSION_1) ?
+                desc->baSourceID[desc->bNrInPins + 4] :
+                desc->baSourceID[desc->bNrInPins + 6];
+}
+
+static inline __u8 *uac_processing_unit_bmControls(struct uac_processing_unit_descriptor *desc,
+                                                   int protocol)
+{
+        return (protocol == UAC_VERSION_1) ?
+                &desc->baSourceID[desc->bNrInPins + 5] :
+                &desc->baSourceID[desc->bNrInPins + 7];
+}
+
+static inline __u8 uac_processing_unit_iProcessing(struct uac_processing_unit_descriptor *desc,
+                                                   int protocol)
+{
+        __u8 control_size = uac_processing_unit_bControlSize(desc, protocol);
+        return desc->baSourceID[desc->bNrInPins + control_size];
+}
+
+static inline __u8 *uac_processing_unit_specific(struct uac_processing_unit_descriptor *desc,
+                                                 int protocol)
+{
+        __u8 control_size = uac_processing_unit_bControlSize(desc, protocol);
+        return &desc->baSourceID[desc->bNrInPins + control_size + 1];
+}
+
 /* 4.5.2 Class-Specific AS Interface Descriptor */
 struct uac_as_header_descriptor_v1 {
         __u8  bLength;                  /* in bytes: 7 */
@@ -200,19 +341,6 @@ struct uac_as_header_descriptor_v1 {
         __le16 wFormatTag;              /* The Audio Data Format */
 } __attribute__ ((packed));
 
-struct uac_as_header_descriptor_v2 {
-        __u8 bLength;
-        __u8 bDescriptorType;
-        __u8 bDescriptorSubtype;
-        __u8 bTerminalLink;
-        __u8 bmControls;
-        __u8 bFormatType;
-        __u32 bmFormats;
-        __u8 bNrChannels;
-        __u32 bmChannelConfig;
-        __u8 iChannelNames;
-} __attribute__((packed));
-
 #define UAC_DT_AS_HEADER_SIZE           7
 
 /* Formats - A.1.1 Audio Data Format Type I Codes */
@@ -250,7 +378,7 @@ struct uac_format_type_i_discrete_descriptor {
         __u8  tSamFreq[][3];
 } __attribute__ ((packed));
 
-#define DECLARE_UAC_FORMAT_TYPE_I_DISCRETE_DESC(n)              \
+#define DECLARE_UAC_FORMAT_TYPE_I_DISCRETE_DESC(n)              \
 struct uac_format_type_i_discrete_descriptor_##n {              \
         __u8  bLength;                                          \
         __u8  bDescriptorType;                                  \
@@ -277,7 +405,6 @@ struct uac_format_type_i_ext_descriptor {
         __u8 bSideBandProtocol;
 } __attribute__((packed));
 
-
 /* Formats - Audio Data Format Type I Codes */
 
 #define UAC_FORMAT_TYPE_II_MPEG 0x1001
@@ -329,38 +456,15 @@ struct uac_iso_endpoint_descriptor {
         __u8  bmAttributes;
         __u8  bLockDelayUnits;
         __le16 wLockDelay;
-};
+} __attribute__((packed));
 #define UAC_ISO_ENDPOINT_DESC_SIZE      7
 
 #define UAC_EP_CS_ATTR_SAMPLE_RATE      0x01
 #define UAC_EP_CS_ATTR_PITCH_CONTROL    0x02
 #define UAC_EP_CS_ATTR_FILL_MAX         0x80
 
-/* Audio class v2.0: CLOCK_SOURCE descriptor */
-
-struct uac_clock_source_descriptor {
-        __u8 bLength;
-        __u8 bDescriptorType;
-        __u8 bDescriptorSubtype;
-        __u8 bClockID;
-        __u8 bmAttributes;
-        __u8 bmControls;
-        __u8 bAssocTerminal;
-        __u8 iClockSource;
-} __attribute__((packed));
-
 /* A.10.2 Feature Unit Control Selectors */
 
-struct uac_feature_unit_descriptor {
-        __u8 bLength;
-        __u8 bDescriptorType;
-        __u8 bDescriptorSubtype;
-        __u8 bUnitID;
-        __u8 bSourceID;
-        __u8 bControlSize;
-        __u8 controls[0]; /* variable length */
-} __attribute__((packed));
-
 #define UAC_FU_CONTROL_UNDEFINED        0x00
 #define UAC_MUTE_CONTROL                0x01
 #define UAC_VOLUME_CONTROL              0x02
@@ -384,6 +488,21 @@ struct uac_feature_unit_descriptor {
 #define UAC_FU_BASS_BOOST       (1 << (UAC_BASS_BOOST_CONTROL - 1))
 #define UAC_FU_LOUDNESS         (1 << (UAC_LOUDNESS_CONTROL - 1))
 
+/* status word format (3.7.1.1) */
+
+#define UAC1_STATUS_TYPE_ORIG_MASK              0x0f
+#define UAC1_STATUS_TYPE_ORIG_AUDIO_CONTROL_IF  0x0
+#define UAC1_STATUS_TYPE_ORIG_AUDIO_STREAM_IF   0x1
+#define UAC1_STATUS_TYPE_ORIG_AUDIO_STREAM_EP   0x2
+
+#define UAC1_STATUS_TYPE_IRQ_PENDING            (1 << 7)
+#define UAC1_STATUS_TYPE_MEM_CHANGED            (1 << 6)
+
+struct uac1_status_word {
+        __u8 bStatusType;
+        __u8 bOriginator;
+} __attribute__((packed));
+
 #ifdef __KERNEL__
 
 struct usb_audio_control {
diff --git a/include/linux/usb/cdc.h b/include/linux/usb/cdc.h
index c24124a42ce5..c117a68d04a7 100644
--- a/include/linux/usb/cdc.h
+++ b/include/linux/usb/cdc.h
@@ -18,6 +18,7 @@
 #define USB_CDC_SUBCLASS_MDLM                   0x0a
 #define USB_CDC_SUBCLASS_OBEX                   0x0b
 #define USB_CDC_SUBCLASS_EEM                    0x0c
+#define USB_CDC_SUBCLASS_NCM                    0x0d
 
 #define USB_CDC_PROTO_NONE                      0
 
@@ -49,6 +50,7 @@
 #define USB_CDC_MDLM_DETAIL_TYPE        0x13    /* mdlm_detail_desc */
 #define USB_CDC_DMM_TYPE                0x14
 #define USB_CDC_OBEX_TYPE               0x15
+#define USB_CDC_NCM_TYPE                0x1a
 
 /* "Header Functional Descriptor" from CDC spec  5.2.3.1 */
 struct usb_cdc_header_desc {
@@ -174,6 +176,15 @@ struct usb_cdc_obex_desc {
         __le16  bcdVersion;
 } __attribute__ ((packed));
 
+/* "NCM Control Model Functional Descriptor" */
+struct usb_cdc_ncm_desc {
+        __u8    bLength;
+        __u8    bDescriptorType;
+        __u8    bDescriptorSubType;
+
+        __le16  bcdNcmVersion;
+        __u8    bmNetworkCapabilities;
+} __attribute__ ((packed));
 /*-------------------------------------------------------------------------*/
 
 /*
@@ -197,6 +208,17 @@ struct usb_cdc_obex_desc {
 #define USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER  0x42
 #define USB_CDC_SET_ETHERNET_PACKET_FILTER      0x43
 #define USB_CDC_GET_ETHERNET_STATISTIC          0x44
+#define USB_CDC_GET_NTB_PARAMETERS              0x80
+#define USB_CDC_GET_NET_ADDRESS                 0x81
+#define USB_CDC_SET_NET_ADDRESS                 0x82
+#define USB_CDC_GET_NTB_FORMAT                  0x83
+#define USB_CDC_SET_NTB_FORMAT                  0x84
+#define USB_CDC_GET_NTB_INPUT_SIZE              0x85
+#define USB_CDC_SET_NTB_INPUT_SIZE              0x86
+#define USB_CDC_GET_MAX_DATAGRAM_SIZE           0x87
+#define USB_CDC_SET_MAX_DATAGRAM_SIZE           0x88
+#define USB_CDC_GET_CRC_MODE                    0x89
+#define USB_CDC_SET_CRC_MODE                    0x8a
 
 /* Line Coding Structure from CDC spec 6.2.13 */
 struct usb_cdc_line_coding {
@@ -247,4 +269,76 @@ struct usb_cdc_notification {
         __le16  wLength;
 } __attribute__ ((packed));
 
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Class Specific structures and constants
+ *
+ * CDC NCM parameter structure, CDC NCM subclass 6.2.1
+ *
+ */
+
+struct usb_cdc_ncm_ntb_parameter {
+        __le16  wLength;
+        __le16  bmNtbFormatSupported;
+        __le32  dwNtbInMaxSize;
+        __le16  wNdpInDivisor;
+        __le16  wNdpInPayloadRemainder;
+        __le16  wNdpInAlignment;
+        __le16  wPadding1;
+        __le32  dwNtbOutMaxSize;
+        __le16  wNdpOutDivisor;
+        __le16  wNdpOutPayloadRemainder;
+        __le16  wNdpOutAlignment;
+        __le16  wPadding2;
+} __attribute__ ((packed));
+
+/*
+ * CDC NCM transfer headers, CDC NCM subclass 3.2
+ */
+
+#define NCM_NTH16_SIGN          0x484D434E /* NCMH */
+#define NCM_NTH32_SIGN          0x686D636E /* ncmh */
+
+struct usb_cdc_ncm_nth16 {
+        __le32  dwSignature;
+        __le16  wHeaderLength;
+        __le16  wSequence;
+        __le16  wBlockLength;
+        __le16  wFpIndex;
+} __attribute__ ((packed));
+
+struct usb_cdc_ncm_nth32 {
+        __le32  dwSignature;
+        __le16  wHeaderLength;
+        __le16  wSequence;
+        __le32  dwBlockLength;
+        __le32  dwFpIndex;
+} __attribute__ ((packed));
+
+/*
+ * CDC NCM datagram pointers, CDC NCM subclass 3.3
+ */
+
+#define NCM_NDP16_CRC_SIGN      0x314D434E /* NCM1 */
+#define NCM_NDP16_NOCRC_SIGN    0x304D434E /* NCM0 */
+#define NCM_NDP32_CRC_SIGN      0x316D636E /* ncm1 */
+#define NCM_NDP32_NOCRC_SIGN    0x306D636E /* ncm0 */
+
+struct usb_cdc_ncm_ndp16 {
+        __le32  dwSignature;
+        __le16  wLength;
+        __le16  wNextFpIndex;
+        __u8    data[0];
+} __attribute__ ((packed));
+
+struct usb_cdc_ncm_ndp32 {
+        __le32  dwSignature;
+        __le16  wLength;
+        __le16  wReserved6;
+        __le32  dwNextFpIndex;
+        __le32  dwReserved12;
+        __u8    data[0];
+} __attribute__ ((packed));
+
 #endif /* __LINUX_USB_CDC_H */
diff --git a/include/linux/usb/ch11.h b/include/linux/usb/ch11.h
new file mode 100644
index 000000000000..119194c85d10
--- /dev/null
+++ b/include/linux/usb/ch11.h
@@ -0,0 +1,167 @@
+/*
+ * This file holds Hub protocol constants and data structures that are
+ * defined in chapter 11 (Hub Specification) of the USB 2.0 specification.
+ *
+ * It is used/shared between the USB core, the HCDs and couple of other USB
+ * drivers.
+ */
+
+#ifndef __LINUX_CH11_H
+#define __LINUX_CH11_H
+
+#include <linux/types.h>        /* __u8 etc */
+
+/*
+ * Hub request types
+ */
+
+#define USB_RT_HUB      (USB_TYPE_CLASS | USB_RECIP_DEVICE)
+#define USB_RT_PORT     (USB_TYPE_CLASS | USB_RECIP_OTHER)
+
+/*
+ * Hub class requests
+ * See USB 2.0 spec Table 11-16
+ */
+#define HUB_CLEAR_TT_BUFFER     8
+#define HUB_RESET_TT            9
+#define HUB_GET_TT_STATE        10
+#define HUB_STOP_TT             11
+
+/*
+ * Hub Class feature numbers
+ * See USB 2.0 spec Table 11-17
+ */
+#define C_HUB_LOCAL_POWER       0
+#define C_HUB_OVER_CURRENT      1
+
+/*
+ * Port feature numbers
+ * See USB 2.0 spec Table 11-17
+ */
+#define USB_PORT_FEAT_CONNECTION        0
+#define USB_PORT_FEAT_ENABLE            1
+#define USB_PORT_FEAT_SUSPEND           2       /* L2 suspend */
+#define USB_PORT_FEAT_OVER_CURRENT      3
+#define USB_PORT_FEAT_RESET             4
+#define USB_PORT_FEAT_L1                5       /* L1 suspend */
+#define USB_PORT_FEAT_POWER             8
+#define USB_PORT_FEAT_LOWSPEED          9       /* Should never be used */
+#define USB_PORT_FEAT_C_CONNECTION      16
+#define USB_PORT_FEAT_C_ENABLE          17
+#define USB_PORT_FEAT_C_SUSPEND         18
+#define USB_PORT_FEAT_C_OVER_CURRENT    19
+#define USB_PORT_FEAT_C_RESET           20
+#define USB_PORT_FEAT_TEST              21
+#define USB_PORT_FEAT_INDICATOR         22
+#define USB_PORT_FEAT_C_PORT_L1         23
+
+/*
+ * Hub Status and Hub Change results
+ * See USB 2.0 spec Table 11-19 and Table 11-20
+ */
+struct usb_port_status {
+        __le16 wPortStatus;
+        __le16 wPortChange;
+} __attribute__ ((packed));
+
+/*
+ * wPortStatus bit field
+ * See USB 2.0 spec Table 11-21
+ */
+#define USB_PORT_STAT_CONNECTION        0x0001
+#define USB_PORT_STAT_ENABLE            0x0002
+#define USB_PORT_STAT_SUSPEND           0x0004
+#define USB_PORT_STAT_OVERCURRENT       0x0008
+#define USB_PORT_STAT_RESET             0x0010
+#define USB_PORT_STAT_L1                0x0020
+/* bits 6 to 7 are reserved */
+#define USB_PORT_STAT_POWER             0x0100
+#define USB_PORT_STAT_LOW_SPEED         0x0200
+#define USB_PORT_STAT_HIGH_SPEED        0x0400
+#define USB_PORT_STAT_TEST              0x0800
+#define USB_PORT_STAT_INDICATOR         0x1000
+/* bits 13 to 15 are reserved */
+#define USB_PORT_STAT_SUPER_SPEED       0x8000  /* Linux-internal */
+
+/*
+ * wPortChange bit field
+ * See USB 2.0 spec Table 11-22
+ * Bits 0 to 4 shown, bits 5 to 15 are reserved
+ */
+#define USB_PORT_STAT_C_CONNECTION      0x0001
+#define USB_PORT_STAT_C_ENABLE          0x0002
+#define USB_PORT_STAT_C_SUSPEND         0x0004
+#define USB_PORT_STAT_C_OVERCURRENT     0x0008
+#define USB_PORT_STAT_C_RESET           0x0010
+#define USB_PORT_STAT_C_L1              0x0020
+
+/*
+ * wHubCharacteristics (masks)
+ * See USB 2.0 spec Table 11-13, offset 3
+ */
+#define HUB_CHAR_LPSM           0x0003 /* D1 .. D0 */
+#define HUB_CHAR_COMPOUND       0x0004 /* D2       */
+#define HUB_CHAR_OCPM           0x0018 /* D4 .. D3 */
+#define HUB_CHAR_TTTT           0x0060 /* D6 .. D5 */
+#define HUB_CHAR_PORTIND        0x0080 /* D7       */
+
+struct usb_hub_status {
+        __le16 wHubStatus;
+        __le16 wHubChange;
+} __attribute__ ((packed));
+
+/*
+ * Hub Status & Hub Change bit masks
+ * See USB 2.0 spec Table 11-19 and Table 11-20
+ * Bits 0 and 1 for wHubStatus and wHubChange
+ * Bits 2 to 15 are reserved for both
+ */
+#define HUB_STATUS_LOCAL_POWER  0x0001
+#define HUB_STATUS_OVERCURRENT  0x0002
+#define HUB_CHANGE_LOCAL_POWER  0x0001
+#define HUB_CHANGE_OVERCURRENT  0x0002
+
+
+/*
+ * Hub descriptor
+ * See USB 2.0 spec Table 11-13
+ */
+
+#define USB_DT_HUB                      (USB_TYPE_CLASS | 0x09)
+#define USB_DT_HUB_NONVAR_SIZE          7
+
+struct usb_hub_descriptor {
+        __u8  bDescLength;
+        __u8  bDescriptorType;
+        __u8  bNbrPorts;
+        __le16 wHubCharacteristics;
+        __u8  bPwrOn2PwrGood;
+        __u8  bHubContrCurrent;
+                /* add 1 bit for hub status change; round to bytes */
+        __u8  DeviceRemovable[(USB_MAXCHILDREN + 1 + 7) / 8];
+        __u8  PortPwrCtrlMask[(USB_MAXCHILDREN + 1 + 7) / 8];
+} __attribute__ ((packed));
+
+
+/* port indicator status selectors, tables 11-7 and 11-25 */
+#define HUB_LED_AUTO    0
+#define HUB_LED_AMBER   1
+#define HUB_LED_GREEN   2
+#define HUB_LED_OFF     3
+
+enum hub_led_mode {
+        INDICATOR_AUTO = 0,
+        INDICATOR_CYCLE,
+        /* software blinks for attention:  software, hardware, reserved */
+        INDICATOR_GREEN_BLINK, INDICATOR_GREEN_BLINK_OFF,
+        INDICATOR_AMBER_BLINK, INDICATOR_AMBER_BLINK_OFF,
+        INDICATOR_ALT_BLINK, INDICATOR_ALT_BLINK_OFF
+} __attribute__ ((packed));
+
+/* Transaction Translator Think Times, in bits */
+#define HUB_TTTT_8_BITS         0x00
+#define HUB_TTTT_16_BITS        0x20
+#define HUB_TTTT_24_BITS        0x40
+#define HUB_TTTT_32_BITS        0x60
+
+#endif /* __LINUX_CH11_H */
diff --git a/include/linux/usb/ch9.h b/include/linux/usb/ch9.h
index e58369ff8168..da2ed77d3e8d 100644
--- a/include/linux/usb/ch9.h
+++ b/include/linux/usb/ch9.h
@@ -191,6 +191,8 @@ struct usb_ctrlrequest {
 #define USB_DT_WIRE_ADAPTER             0x21
 #define USB_DT_RPIPE                    0x22
 #define USB_DT_CS_RADIO_CONTROL         0x23
+/* From the T10 UAS specification */
+#define USB_DT_PIPE_USAGE               0x24
 /* From the USB 3.0 spec */
 #define USB_DT_SS_ENDPOINT_COMP         0x30
 
@@ -475,7 +477,7 @@ static inline int usb_endpoint_xfer_isoc(
 static inline int usb_endpoint_is_bulk_in(
                                 const struct usb_endpoint_descriptor *epd)
 {
-        return (usb_endpoint_xfer_bulk(epd) && usb_endpoint_dir_in(epd));
+        return usb_endpoint_xfer_bulk(epd) && usb_endpoint_dir_in(epd);
 }
 
 /**
@@ -488,7 +490,7 @@ static inline int usb_endpoint_is_bulk_in(
 static inline int usb_endpoint_is_bulk_out(
                                 const struct usb_endpoint_descriptor *epd)
 {
-        return (usb_endpoint_xfer_bulk(epd) && usb_endpoint_dir_out(epd));
+        return usb_endpoint_xfer_bulk(epd) && usb_endpoint_dir_out(epd);
 }
 
 /**
@@ -501,7 +503,7 @@ static inline int usb_endpoint_is_bulk_out(
 static inline int usb_endpoint_is_int_in(
                                 const struct usb_endpoint_descriptor *epd)
 {
-        return (usb_endpoint_xfer_int(epd) && usb_endpoint_dir_in(epd));
+        return usb_endpoint_xfer_int(epd) && usb_endpoint_dir_in(epd);
 }
 
 /**
@@ -514,7 +516,7 @@ static inline int usb_endpoint_is_int_in(
 static inline int usb_endpoint_is_int_out(
                                 const struct usb_endpoint_descriptor *epd)
 {
-        return (usb_endpoint_xfer_int(epd) && usb_endpoint_dir_out(epd));
+        return usb_endpoint_xfer_int(epd) && usb_endpoint_dir_out(epd);
 }
 
 /**
@@ -527,7 +529,7 @@ static inline int usb_endpoint_is_int_out(
 static inline int usb_endpoint_is_isoc_in(
                                 const struct usb_endpoint_descriptor *epd)
 {
-        return (usb_endpoint_xfer_isoc(epd) && usb_endpoint_dir_in(epd));
+        return usb_endpoint_xfer_isoc(epd) && usb_endpoint_dir_in(epd);
 }
 
 /**
@@ -540,7 +542,7 @@ static inline int usb_endpoint_is_isoc_in(
 static inline int usb_endpoint_is_isoc_out(
                                 const struct usb_endpoint_descriptor *epd)
 {
-        return (usb_endpoint_xfer_isoc(epd) && usb_endpoint_dir_out(epd));
+        return usb_endpoint_xfer_isoc(epd) && usb_endpoint_dir_out(epd);
 }
 
 /*-------------------------------------------------------------------------*/
@@ -556,6 +558,8 @@ struct usb_ss_ep_comp_descriptor {
 } __attribute__ ((packed));
 
 #define USB_DT_SS_EP_COMP_SIZE          6
+/* Bits 4:0 of bmAttributes if this is a bulk endpoint */
+#define USB_SS_MAX_STREAMS(p)           (1 << (p & 0x1f))
 
 /*-------------------------------------------------------------------------*/
 
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
index 738ea1a691cb..139353efad34 100644
--- a/include/linux/usb/composite.h
+++ b/include/linux/usb/composite.h
@@ -326,6 +326,7 @@ struct usb_composite_dev {
 
         /* private: */
         /* internals */
+        unsigned int                    suspended:1;
         struct usb_device_descriptor    desc;
         struct list_head                configs;
         struct usb_composite_driver     *driver;
diff --git a/include/linux/usb/ehci_def.h b/include/linux/usb/ehci_def.h
index af4b86f3aca3..80287af2a738 100644
--- a/include/linux/usb/ehci_def.h
+++ b/include/linux/usb/ehci_def.h
@@ -45,7 +45,7 @@ struct ehci_caps {
 #define HCC_CANPARK(p)          ((p)&(1 << 2))  /* true: can park on async qh */
 #define HCC_PGM_FRAMELISTLEN(p) ((p)&(1 << 1))  /* true: periodic_size changes*/
 #define HCC_64BIT_ADDR(p)       ((p)&(1))       /* true: can use 64-bit addr */
-        u8              portroute [8];   /* nibbles for routing - offset 0xC */
+        u8              portroute[8];    /* nibbles for routing - offset 0xC */
 } __attribute__ ((packed));
 
 
@@ -92,14 +92,14 @@ struct ehci_regs {
         /* ASYNCLISTADDR: offset 0x18 */
         u32             async_next;     /* address of next async queue head */
 
-        u32             reserved [9];
+        u32             reserved[9];
 
         /* CONFIGFLAG: offset 0x40 */
         u32             configured_flag;
 #define FLAG_CF         (1<<0)          /* true: we'll support "high speed" */
 
         /* PORTSC: offset 0x44 */
-        u32             port_status [0];        /* up to N_PORTS */
+        u32             port_status[0]; /* up to N_PORTS */
 /* 31:23 reserved */
 #define PORT_WKOC_E     (1<<22)         /* wake on overcurrent (enable) */
 #define PORT_WKDISC_E   (1<<21)         /* wake on disconnect (enable) */
diff --git a/include/linux/usb/functionfs.h b/include/linux/usb/functionfs.h
new file mode 100644
index 000000000000..a34a2a043b21
--- /dev/null
+++ b/include/linux/usb/functionfs.h
@@ -0,0 +1,199 @@
+#ifndef __LINUX_FUNCTIONFS_H__
+#define __LINUX_FUNCTIONFS_H__ 1
+
+
+#include <linux/types.h>
+#include <linux/ioctl.h>
+
+#include <linux/usb/ch9.h>
+
+
+enum {
+        FUNCTIONFS_DESCRIPTORS_MAGIC = 1,
+        FUNCTIONFS_STRINGS_MAGIC     = 2
+};
+
+
+#ifndef __KERNEL__
+
+/* Descriptor of an non-audio endpoint */
+struct usb_endpoint_descriptor_no_audio {
+        __u8  bLength;
+        __u8  bDescriptorType;
+
+        __u8  bEndpointAddress;
+        __u8  bmAttributes;
+        __le16 wMaxPacketSize;
+        __u8  bInterval;
+} __attribute__((packed));
+
+
+/*
+ * All numbers must be in little endian order.
+ */
+
+struct usb_functionfs_descs_head {
+        __le32 magic;
+        __le32 length;
+        __le32 fs_count;
+        __le32 hs_count;
+} __attribute__((packed));
+
+/*
+ * Descriptors format:
+ *
+ * | off | name      | type         | description                          |
+ * |-----+-----------+--------------+--------------------------------------|
+ * |   0 | magic     | LE32         | FUNCTIONFS_{FS,HS}_DESCRIPTORS_MAGIC |
+ * |   4 | lenght    | LE32         | length of the whole data chunk       |
+ * |   8 | fs_count  | LE32         | number of full-speed descriptors     |
+ * |  12 | hs_count  | LE32         | number of high-speed descriptors     |
+ * |  16 | fs_descrs | Descriptor[] | list of full-speed descriptors       |
+ * |     | hs_descrs | Descriptor[] | list of high-speed descriptors       |
+ *
+ * descs are just valid USB descriptors and have the following format:
+ *
+ * | off | name            | type | description              |
+ * |-----+-----------------+------+--------------------------|
+ * |   0 | bLength         | U8   | length of the descriptor |
+ * |   1 | bDescriptorType | U8   | descriptor type          |
+ * |   2 | payload         |      | descriptor's payload     |
+ */
+
+struct usb_functionfs_strings_head {
+        __le32 magic;
+        __le32 length;
+        __le32 str_count;
+        __le32 lang_count;
+} __attribute__((packed));
+
+/*
+ * Strings format:
+ *
+ * | off | name       | type                  | description                |
+ * |-----+------------+-----------------------+----------------------------|
+ * |   0 | magic      | LE32                  | FUNCTIONFS_STRINGS_MAGIC   |
+ * |   4 | length     | LE32                  | length of the data chunk   |
+ * |   8 | str_count  | LE32                  | number of strings          |
+ * |  12 | lang_count | LE32                  | number of languages        |
+ * |  16 | stringtab  | StringTab[lang_count] | table of strings per lang  |
+ *
+ * For each language there is one stringtab entry (ie. there are lang_count
+ * stringtab entires).  Each StringTab has following format:
+ *
+ * | off | name    | type              | description                        |
+ * |-----+---------+-------------------+------------------------------------|
+ * |   0 | lang    | LE16              | language code                      |
+ * |   2 | strings | String[str_count] | array of strings in given language |
+ *
+ * For each string ther is one strings entry (ie. there are str_count
+ * string entries).  Each String is a NUL terminated string encoded in
+ * UTF-8.
+ */
+
+#endif
+
+
+/*
+ * Events are delivered on the ep0 file descriptor, when the user mode driver
+ * reads from this file descriptor after writing the descriptors.  Don't
+ * stop polling this descriptor.
+ */
+
+enum usb_functionfs_event_type {
+        FUNCTIONFS_BIND,
+        FUNCTIONFS_UNBIND,
+
+        FUNCTIONFS_ENABLE,
+        FUNCTIONFS_DISABLE,
+
+        FUNCTIONFS_SETUP,
+
+        FUNCTIONFS_SUSPEND,
+        FUNCTIONFS_RESUME
+};
+
+/* NOTE:  this structure must stay the same size and layout on
+ * both 32-bit and 64-bit kernels.
+ */
+struct usb_functionfs_event {
+        union {
+                /* SETUP: packet; DATA phase i/o precedes next event
+                 *(setup.bmRequestType & USB_DIR_IN) flags direction */
+                struct usb_ctrlrequest  setup;
+        } __attribute__((packed)) u;
+
+        /* enum usb_functionfs_event_type */
+        __u8                            type;
+        __u8                            _pad[3];
+} __attribute__((packed));
+
+
+/* Endpoint ioctls */
+/* The same as in gadgetfs */
+
+/* IN transfers may be reported to the gadget driver as complete
+ *      when the fifo is loaded, before the host reads the data;
+ * OUT transfers may be reported to the host's "client" driver as
+ *      complete when they're sitting in the FIFO unread.
+ * THIS returns how many bytes are "unclaimed" in the endpoint fifo
+ * (needed for precise fault handling, when the hardware allows it)
+ */
+#define FUNCTIONFS_FIFO_STATUS  _IO('g', 1)
+
+/* discards any unclaimed data in the fifo. */
+#define FUNCTIONFS_FIFO_FLUSH   _IO('g', 2)
+
+/* resets endpoint halt+toggle; used to implement set_interface.
+ * some hardware (like pxa2xx) can't support this.
+ */
+#define FUNCTIONFS_CLEAR_HALT   _IO('g', 3)
+
+/* Specific for functionfs */
+
+/*
+ * Returns reverse mapping of an interface.  Called on EP0.  If there
+ * is no such interface returns -EDOM.  If function is not active
+ * returns -ENODEV.
+ */
+#define FUNCTIONFS_INTERFACE_REVMAP     _IO('g', 128)
+
+/*
+ * Returns real bEndpointAddress of an endpoint.  If function is not
+ * active returns -ENODEV.
+ */
+#define FUNCTIONFS_ENDPOINT_REVMAP      _IO('g', 129)
+
+
+#ifdef __KERNEL__
+
+struct ffs_data;
+struct usb_composite_dev;
+struct usb_configuration;
+
+
+static int  functionfs_init(void) __attribute__((warn_unused_result));
+static void functionfs_cleanup(void);
+
+static int functionfs_bind(struct ffs_data *ffs, struct usb_composite_dev *cdev)
+        __attribute__((warn_unused_result, nonnull));
+static void functionfs_unbind(struct ffs_data *ffs)
+        __attribute__((nonnull));
+
+static int functionfs_add(struct usb_composite_dev *cdev,
+                          struct usb_configuration *c,
+                          struct ffs_data *ffs)
+        __attribute__((warn_unused_result, nonnull));
+
+
+static int functionfs_ready_callback(struct ffs_data *ffs)
+        __attribute__((warn_unused_result, nonnull));
+static void functionfs_closed_callback(struct ffs_data *ffs)
+        __attribute__((nonnull));
+static int functionfs_check_dev_callback(const char *dev_name)
+        __attribute__((warn_unused_result, nonnull));
+
+
+#endif
+
+#endif
diff --git a/include/linux/usb/g_hid.h b/include/linux/usb/g_hid.h
new file mode 100644
index 000000000000..50f5745df28c
--- /dev/null
+++ b/include/linux/usb/g_hid.h
@@ -0,0 +1,32 @@
+/*
+ * g_hid.h -- Header file for USB HID gadget driver
+ *
+ * Copyright (C) 2010 Fabien Chouteau <fabien.chouteau@barco.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __LINUX_USB_G_HID_H
+#define __LINUX_USB_G_HID_H
+
+struct hidg_func_descriptor {
+        unsigned char           subclass;
+        unsigned char           protocol;
+        unsigned short          report_length;
+        unsigned short          report_desc_length;
+        unsigned char           report_desc[];
+};
+
+#endif /* __LINUX_USB_G_HID_H */
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index f4b7ca516cdd..d3ef42d7d2f0 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -494,9 +494,13 @@ static inline void set_gadget_data(struct usb_gadget *gadget, void *data)
         { dev_set_drvdata(&gadget->dev, data); }
 static inline void *get_gadget_data(struct usb_gadget *gadget)
         { return dev_get_drvdata(&gadget->dev); }
+static inline struct usb_gadget *dev_to_usb_gadget(struct device *dev)
+{
+        return container_of(dev, struct usb_gadget, dev);
+}
 
 /* iterates the non-control endpoints; 'tmp' is a struct usb_ep pointer */
-#define gadget_for_each_ep(tmp,gadget) \
+#define gadget_for_each_ep(tmp, gadget) \
         list_for_each_entry(tmp, &(gadget)->ep_list, ep_list)
 
 
diff --git a/include/linux/usb/gadgetfs.h b/include/linux/usb/gadgetfs.h
index 612102e4d75e..0bb12e0d4f8f 100644
--- a/include/linux/usb/gadgetfs.h
+++ b/include/linux/usb/gadgetfs.h
@@ -19,7 +19,7 @@
 #define __LINUX_USB_GADGETFS_H
 
 #include <linux/types.h>
-#include <asm/ioctl.h>
+#include <linux/ioctl.h>
 
 #include <linux/usb/ch9.h>
 
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
new file mode 100644
index 000000000000..2e3a4ea1a3da
--- /dev/null
+++ b/include/linux/usb/hcd.h
@@ -0,0 +1,625 @@
+/*
+ * Copyright (c) 2001-2002 by David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __USB_CORE_HCD_H
+#define __USB_CORE_HCD_H
+
+#ifdef __KERNEL__
+
+#include <linux/rwsem.h>
+
+#define MAX_TOPO_LEVEL          6
+
+/* This file contains declarations of usbcore internals that are mostly
+ * used or exposed by Host Controller Drivers.
+ */
+
+/*
+ * USB Packet IDs (PIDs)
+ */
+#define USB_PID_EXT                     0xf0    /* USB 2.0 LPM ECN */
+#define USB_PID_OUT                     0xe1
+#define USB_PID_ACK                     0xd2
+#define USB_PID_DATA0                   0xc3
+#define USB_PID_PING                    0xb4    /* USB 2.0 */
+#define USB_PID_SOF                     0xa5
+#define USB_PID_NYET                    0x96    /* USB 2.0 */
+#define USB_PID_DATA2                   0x87    /* USB 2.0 */
+#define USB_PID_SPLIT                   0x78    /* USB 2.0 */
+#define USB_PID_IN                      0x69
+#define USB_PID_NAK                     0x5a
+#define USB_PID_DATA1                   0x4b
+#define USB_PID_PREAMBLE                0x3c    /* Token mode */
+#define USB_PID_ERR                     0x3c    /* USB 2.0: handshake mode */
+#define USB_PID_SETUP                   0x2d
+#define USB_PID_STALL                   0x1e
+#define USB_PID_MDATA                   0x0f    /* USB 2.0 */
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * USB Host Controller Driver (usb_hcd) framework
+ *
+ * Since "struct usb_bus" is so thin, you can't share much code in it.
+ * This framework is a layer over that, and should be more sharable.
+ *
+ * @authorized_default: Specifies if new devices are authorized to
+ *                      connect by default or they require explicit
+ *                      user space authorization; this bit is settable
+ *                      through /sys/class/usb_host/X/authorized_default.
+ *                      For the rest is RO, so we don't lock to r/w it.
+ */
+
+/*-------------------------------------------------------------------------*/
+
+struct usb_hcd {
+
+        /*
+         * housekeeping
+         */
+        struct usb_bus          self;           /* hcd is-a bus */
+        struct kref             kref;           /* reference counter */
+
+        const char              *product_desc;  /* product/vendor string */
+        char                    irq_descr[24];  /* driver + bus # */
+
+        struct timer_list       rh_timer;       /* drives root-hub polling */
+        struct urb              *status_urb;    /* the current status urb */
+#ifdef CONFIG_USB_SUSPEND
+        struct work_struct      wakeup_work;    /* for remote wakeup */
+#endif
+
+        /*
+         * hardware info/state
+         */
+        const struct hc_driver  *driver;        /* hw-specific hooks */
+
+        /* Flags that need to be manipulated atomically */
+        unsigned long           flags;
+#define HCD_FLAG_HW_ACCESSIBLE  0x00000001
+#define HCD_FLAG_SAW_IRQ        0x00000002
+
+        unsigned                rh_registered:1;/* is root hub registered? */
+
+        /* The next flag is a stopgap, to be removed when all the HCDs
+         * support the new root-hub polling mechanism. */
+        unsigned                uses_new_polling:1;
+        unsigned                poll_rh:1;      /* poll for rh status? */
+        unsigned                poll_pending:1; /* status has changed? */
+        unsigned                wireless:1;     /* Wireless USB HCD */
+        unsigned                authorized_default:1;
+        unsigned                has_tt:1;       /* Integrated TT in root hub */
+
+        int                     irq;            /* irq allocated */
+        void __iomem            *regs;          /* device memory/io */
+        u64                     rsrc_start;     /* memory/io resource start */
+        u64                     rsrc_len;       /* memory/io resource length */
+        unsigned                power_budget;   /* in mA, 0 = no limit */
+
+        /* bandwidth_mutex should be taken before adding or removing
+         * any new bus bandwidth constraints:
+         *   1. Before adding a configuration for a new device.
+         *   2. Before removing the configuration to put the device into
+         *      the addressed state.
+         *   3. Before selecting a different configuration.
+         *   4. Before selecting an alternate interface setting.
+         *
+         * bandwidth_mutex should be dropped after a successful control message
+         * to the device, or resetting the bandwidth after a failed attempt.
+         */
+        struct mutex            bandwidth_mutex;
+
+
+#define HCD_BUFFER_POOLS        4
+        struct dma_pool         *pool[HCD_BUFFER_POOLS];
+
+        int                     state;
+#       define  __ACTIVE                0x01
+#       define  __SUSPEND               0x04
+#       define  __TRANSIENT             0x80
+
+#       define  HC_STATE_HALT           0
+#       define  HC_STATE_RUNNING        (__ACTIVE)
+#       define  HC_STATE_QUIESCING      (__SUSPEND|__TRANSIENT|__ACTIVE)
+#       define  HC_STATE_RESUMING       (__SUSPEND|__TRANSIENT)
+#       define  HC_STATE_SUSPENDED      (__SUSPEND)
+
+#define HC_IS_RUNNING(state) ((state) & __ACTIVE)
+#define HC_IS_SUSPENDED(state) ((state) & __SUSPEND)
+
+        /* more shared queuing code would be good; it should support
+         * smarter scheduling, handle transaction translators, etc;
+         * input size of periodic table to an interrupt scheduler.
+         * (ohci 32, uhci 1024, ehci 256/512/1024).
+         */
+
+        /* The HC driver's private data is stored at the end of
+         * this structure.
+         */
+        unsigned long hcd_priv[0]
+                        __attribute__ ((aligned(sizeof(unsigned long))));
+};
+
+/* 2.4 does this a bit differently ... */
+static inline struct usb_bus *hcd_to_bus(struct usb_hcd *hcd)
+{
+        return &hcd->self;
+}
+
+static inline struct usb_hcd *bus_to_hcd(struct usb_bus *bus)
+{
+        return container_of(bus, struct usb_hcd, self);
+}
+
+struct hcd_timeout {    /* timeouts we allocate */
+        struct list_head        timeout_list;
+        struct timer_list       timer;
+};
+
+/*-------------------------------------------------------------------------*/
+
+
+struct hc_driver {
+        const char      *description;   /* "ehci-hcd" etc */
+        const char      *product_desc;  /* product/vendor string */
+        size_t          hcd_priv_size;  /* size of private data */
+
+        /* irq handler */
+        irqreturn_t     (*irq) (struct usb_hcd *hcd);
+
+        int     flags;
+#define HCD_MEMORY      0x0001          /* HC regs use memory (else I/O) */
+#define HCD_LOCAL_MEM   0x0002          /* HC needs local memory */
+#define HCD_USB11       0x0010          /* USB 1.1 */
+#define HCD_USB2        0x0020          /* USB 2.0 */
+#define HCD_USB3        0x0040          /* USB 3.0 */
+#define HCD_MASK        0x0070
+
+        /* called to init HCD and root hub */
+        int     (*reset) (struct usb_hcd *hcd);
+        int     (*start) (struct usb_hcd *hcd);
+
+        /* NOTE:  these suspend/resume calls relate to the HC as
+         * a whole, not just the root hub; they're for PCI bus glue.
+         */
+        /* called after suspending the hub, before entering D3 etc */
+        int     (*pci_suspend)(struct usb_hcd *hcd);
+
+        /* called after entering D0 (etc), before resuming the hub */
+        int     (*pci_resume)(struct usb_hcd *hcd, bool hibernated);
+
+        /* cleanly make HCD stop writing memory and doing I/O */
+        void    (*stop) (struct usb_hcd *hcd);
+
+        /* shutdown HCD */
+        void    (*shutdown) (struct usb_hcd *hcd);
+
+        /* return current frame number */
+        int     (*get_frame_number) (struct usb_hcd *hcd);
+
+        /* manage i/o requests, device state */
+        int     (*urb_enqueue)(struct usb_hcd *hcd,
+                                struct urb *urb, gfp_t mem_flags);
+        int     (*urb_dequeue)(struct usb_hcd *hcd,
+                                struct urb *urb, int status);
+
+        /* hw synch, freeing endpoint resources that urb_dequeue can't */
+        void    (*endpoint_disable)(struct usb_hcd *hcd,
+                        struct usb_host_endpoint *ep);
+
+        /* (optional) reset any endpoint state such as sequence number
+           and current window */
+        void    (*endpoint_reset)(struct usb_hcd *hcd,
+                        struct usb_host_endpoint *ep);
+
+        /* root hub support */
+        int     (*hub_status_data) (struct usb_hcd *hcd, char *buf);
+        int     (*hub_control) (struct usb_hcd *hcd,
+                                u16 typeReq, u16 wValue, u16 wIndex,
+                                char *buf, u16 wLength);
+        int     (*bus_suspend)(struct usb_hcd *);
+        int     (*bus_resume)(struct usb_hcd *);
+        int     (*start_port_reset)(struct usb_hcd *, unsigned port_num);
+
+                /* force handover of high-speed port to full-speed companion */
+        void    (*relinquish_port)(struct usb_hcd *, int);
+                /* has a port been handed over to a companion? */
+        int     (*port_handed_over)(struct usb_hcd *, int);
+
+                /* CLEAR_TT_BUFFER completion callback */
+        void    (*clear_tt_buffer_complete)(struct usb_hcd *,
+                                struct usb_host_endpoint *);
+
+        /* xHCI specific functions */
+                /* Called by usb_alloc_dev to alloc HC device structures */
+        int     (*alloc_dev)(struct usb_hcd *, struct usb_device *);
+                /* Called by usb_disconnect to free HC device structures */
+        void    (*free_dev)(struct usb_hcd *, struct usb_device *);
+        /* Change a group of bulk endpoints to support multiple stream IDs */
+        int     (*alloc_streams)(struct usb_hcd *hcd, struct usb_device *udev,
+                struct usb_host_endpoint **eps, unsigned int num_eps,
+                unsigned int num_streams, gfp_t mem_flags);
+        /* Reverts a group of bulk endpoints back to not using stream IDs.
+         * Can fail if we run out of memory.
+         */
+        int     (*free_streams)(struct usb_hcd *hcd, struct usb_device *udev,
+                struct usb_host_endpoint **eps, unsigned int num_eps,
+                gfp_t mem_flags);
+
+        /* Bandwidth computation functions */
+        /* Note that add_endpoint() can only be called once per endpoint before
+         * check_bandwidth() or reset_bandwidth() must be called.
+         * drop_endpoint() can only be called once per endpoint also.
+         * A call to xhci_drop_endpoint() followed by a call to
+         * xhci_add_endpoint() will add the endpoint to the schedule with
+         * possibly new parameters denoted by a different endpoint descriptor
+         * in usb_host_endpoint.  A call to xhci_add_endpoint() followed by a
+         * call to xhci_drop_endpoint() is not allowed.
+         */
+                /* Allocate endpoint resources and add them to a new schedule */
+        int     (*add_endpoint)(struct usb_hcd *, struct usb_device *,
+                                struct usb_host_endpoint *);
+                /* Drop an endpoint from a new schedule */
+        int     (*drop_endpoint)(struct usb_hcd *, struct usb_device *,
+                                 struct usb_host_endpoint *);
+                /* Check that a new hardware configuration, set using
+                 * endpoint_enable and endpoint_disable, does not exceed bus
+                 * bandwidth.  This must be called before any set configuration
+                 * or set interface requests are sent to the device.
+                 */
+        int     (*check_bandwidth)(struct usb_hcd *, struct usb_device *);
+                /* Reset the device schedule to the last known good schedule,
+                 * which was set from a previous successful call to
+                 * check_bandwidth().  This reverts any add_endpoint() and
+                 * drop_endpoint() calls since that last successful call.
+                 * Used for when a check_bandwidth() call fails due to resource
+                 * or bandwidth constraints.
+                 */
+        void    (*reset_bandwidth)(struct usb_hcd *, struct usb_device *);
+                /* Returns the hardware-chosen device address */
+        int     (*address_device)(struct usb_hcd *, struct usb_device *udev);
+                /* Notifies the HCD after a hub descriptor is fetched.
+                 * Will block.
+                 */
+        int     (*update_hub_device)(struct usb_hcd *, struct usb_device *hdev,
+                        struct usb_tt *tt, gfp_t mem_flags);
+        int     (*reset_device)(struct usb_hcd *, struct usb_device *);
+};
+
+extern int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb);
+extern int usb_hcd_check_unlink_urb(struct usb_hcd *hcd, struct urb *urb,
+                int status);
+extern void usb_hcd_unlink_urb_from_ep(struct usb_hcd *hcd, struct urb *urb);
+
+extern int usb_hcd_submit_urb(struct urb *urb, gfp_t mem_flags);
+extern int usb_hcd_unlink_urb(struct urb *urb, int status);
+extern void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb,
+                int status);
+extern void usb_hcd_flush_endpoint(struct usb_device *udev,
+                struct usb_host_endpoint *ep);
+extern void usb_hcd_disable_endpoint(struct usb_device *udev,
+                struct usb_host_endpoint *ep);
+extern void usb_hcd_reset_endpoint(struct usb_device *udev,
+                struct usb_host_endpoint *ep);
+extern void usb_hcd_synchronize_unlinks(struct usb_device *udev);
+extern int usb_hcd_alloc_bandwidth(struct usb_device *udev,
+                struct usb_host_config *new_config,
+                struct usb_host_interface *old_alt,
+                struct usb_host_interface *new_alt);
+extern int usb_hcd_get_frame_number(struct usb_device *udev);
+
+extern struct usb_hcd *usb_create_hcd(const struct hc_driver *driver,
+                struct device *dev, const char *bus_name);
+extern struct usb_hcd *usb_get_hcd(struct usb_hcd *hcd);
+extern void usb_put_hcd(struct usb_hcd *hcd);
+extern int usb_add_hcd(struct usb_hcd *hcd,
+                unsigned int irqnum, unsigned long irqflags);
+extern void usb_remove_hcd(struct usb_hcd *hcd);
+
+struct platform_device;
+extern void usb_hcd_platform_shutdown(struct platform_device *dev);
+
+#ifdef CONFIG_PCI
+struct pci_dev;
+struct pci_device_id;
+extern int usb_hcd_pci_probe(struct pci_dev *dev,
+                                const struct pci_device_id *id);
+extern void usb_hcd_pci_remove(struct pci_dev *dev);
+extern void usb_hcd_pci_shutdown(struct pci_dev *dev);
+
+#ifdef CONFIG_PM_SLEEP
+extern const struct dev_pm_ops usb_hcd_pci_pm_ops;
+#endif
+#endif /* CONFIG_PCI */
+
+/* pci-ish (pdev null is ok) buffer alloc/mapping support */
+int hcd_buffer_create(struct usb_hcd *hcd);
+void hcd_buffer_destroy(struct usb_hcd *hcd);
+
+void *hcd_buffer_alloc(struct usb_bus *bus, size_t size,
+        gfp_t mem_flags, dma_addr_t *dma);
+void hcd_buffer_free(struct usb_bus *bus, size_t size,
+        void *addr, dma_addr_t dma);
+
+/* generic bus glue, needed for host controllers that don't use PCI */
+extern irqreturn_t usb_hcd_irq(int irq, void *__hcd);
+
+extern void usb_hc_died(struct usb_hcd *hcd);
+extern void usb_hcd_poll_rh_status(struct usb_hcd *hcd);
+
+/* The D0/D1 toggle bits ... USE WITH CAUTION (they're almost hcd-internal) */
+#define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> (ep)) & 1)
+#define usb_dotoggle(dev, ep, out)  ((dev)->toggle[out] ^= (1 << (ep)))
+#define usb_settoggle(dev, ep, out, bit) \
+                ((dev)->toggle[out] = ((dev)->toggle[out] & ~(1 << (ep))) | \
+                 ((bit) << (ep)))
+
+/* -------------------------------------------------------------------------- */
+
+/* Enumeration is only for the hub driver, or HCD virtual root hubs */
+extern struct usb_device *usb_alloc_dev(struct usb_device *parent,
+                                        struct usb_bus *, unsigned port);
+extern int usb_new_device(struct usb_device *dev);
+extern void usb_disconnect(struct usb_device **);
+
+extern int usb_get_configuration(struct usb_device *dev);
+extern void usb_destroy_configuration(struct usb_device *dev);
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * HCD Root Hub support
+ */
+
+#include <linux/usb/ch11.h>
+
+/*
+ * As of USB 2.0, full/low speed devices are segregated into trees.
+ * One type grows from USB 1.1 host controllers (OHCI, UHCI etc).
+ * The other type grows from high speed hubs when they connect to
+ * full/low speed devices using "Transaction Translators" (TTs).
+ *
+ * TTs should only be known to the hub driver, and high speed bus
+ * drivers (only EHCI for now).  They affect periodic scheduling and
+ * sometimes control/bulk error recovery.
+ */
+
+struct usb_device;
+
+struct usb_tt {
+        struct usb_device       *hub;   /* upstream highspeed hub */
+        int                     multi;  /* true means one TT per port */
+        unsigned                think_time;     /* think time in ns */
+
+        /* for control/bulk error recovery (CLEAR_TT_BUFFER) */
+        spinlock_t              lock;
+        struct list_head        clear_list;     /* of usb_tt_clear */
+        struct work_struct      clear_work;
+};
+
+struct usb_tt_clear {
+        struct list_head        clear_list;
+        unsigned                tt;
+        u16                     devinfo;
+        struct usb_hcd          *hcd;
+        struct usb_host_endpoint        *ep;
+};
+
+extern int usb_hub_clear_tt_buffer(struct urb *urb);
+extern void usb_ep0_reinit(struct usb_device *);
+
+/* (shifted) direction/type/recipient from the USB 2.0 spec, table 9.2 */
+#define DeviceRequest \
+        ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE)<<8)
+#define DeviceOutRequest \
+        ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_DEVICE)<<8)
+
+#define InterfaceRequest \
+        ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)
+
+#define EndpointRequest \
+        ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)
+#define EndpointOutRequest \
+        ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)
+
+/* class requests from the USB 2.0 hub spec, table 11-15 */
+/* GetBusState and SetHubDescriptor are optional, omitted */
+#define ClearHubFeature         (0x2000 | USB_REQ_CLEAR_FEATURE)
+#define ClearPortFeature        (0x2300 | USB_REQ_CLEAR_FEATURE)
+#define GetHubDescriptor        (0xa000 | USB_REQ_GET_DESCRIPTOR)
+#define GetHubStatus            (0xa000 | USB_REQ_GET_STATUS)
+#define GetPortStatus           (0xa300 | USB_REQ_GET_STATUS)
+#define SetHubFeature           (0x2000 | USB_REQ_SET_FEATURE)
+#define SetPortFeature          (0x2300 | USB_REQ_SET_FEATURE)
+
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Generic bandwidth allocation constants/support
+ */
+#define FRAME_TIME_USECS        1000L
+#define BitTime(bytecount) (7 * 8 * bytecount / 6) /* with integer truncation */
+                /* Trying not to use worst-case bit-stuffing
+                 * of (7/6 * 8 * bytecount) = 9.33 * bytecount */
+                /* bytecount = data payload byte count */
+
+#define NS_TO_US(ns)    ((ns + 500L) / 1000L)
+                        /* convert & round nanoseconds to microseconds */
+
+
+/*
+ * Full/low speed bandwidth allocation constants/support.
+ */
+#define BW_HOST_DELAY   1000L           /* nanoseconds */
+#define BW_HUB_LS_SETUP 333L            /* nanoseconds */
+                        /* 4 full-speed bit times (est.) */
+
+#define FRAME_TIME_BITS                 12000L  /* frame = 1 millisecond */
+#define FRAME_TIME_MAX_BITS_ALLOC       (90L * FRAME_TIME_BITS / 100L)
+#define FRAME_TIME_MAX_USECS_ALLOC      (90L * FRAME_TIME_USECS / 100L)
+
+/*
+ * Ceiling [nano/micro]seconds (typical) for that many bytes at high speed
+ * ISO is a bit less, no ACK ... from USB 2.0 spec, 5.11.3 (and needed
+ * to preallocate bandwidth)
+ */
+#define USB2_HOST_DELAY 5       /* nsec, guess */
+#define HS_NSECS(bytes) (((55 * 8 * 2083) \
+        + (2083UL * (3 + BitTime(bytes))))/1000 \
+        + USB2_HOST_DELAY)
+#define HS_NSECS_ISO(bytes) (((38 * 8 * 2083) \
+        + (2083UL * (3 + BitTime(bytes))))/1000 \
+        + USB2_HOST_DELAY)
+#define HS_USECS(bytes)         NS_TO_US(HS_NSECS(bytes))
+#define HS_USECS_ISO(bytes)     NS_TO_US(HS_NSECS_ISO(bytes))
+
+extern long usb_calc_bus_time(int speed, int is_input,
+                        int isoc, int bytecount);
+
+/*-------------------------------------------------------------------------*/
+
+extern void usb_set_device_state(struct usb_device *udev,
+                enum usb_device_state new_state);
+
+/*-------------------------------------------------------------------------*/
+
+/* exported only within usbcore */
+
+extern struct list_head usb_bus_list;
+extern struct mutex usb_bus_list_lock;
+extern wait_queue_head_t usb_kill_urb_queue;
+
+extern int usb_find_interface_driver(struct usb_device *dev,
+        struct usb_interface *interface);
+
+#define usb_endpoint_out(ep_dir)        (!((ep_dir) & USB_DIR_IN))
+
+#ifdef CONFIG_PM
+extern void usb_root_hub_lost_power(struct usb_device *rhdev);
+extern int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg);
+extern int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg);
+#endif /* CONFIG_PM */
+
+#ifdef CONFIG_USB_SUSPEND
+extern void usb_hcd_resume_root_hub(struct usb_hcd *hcd);
+#else
+static inline void usb_hcd_resume_root_hub(struct usb_hcd *hcd)
+{
+        return;
+}
+#endif /* CONFIG_USB_SUSPEND */
+
+
+/*
+ * USB device fs stuff
+ */
+
+#ifdef CONFIG_USB_DEVICEFS
+
+/*
+ * these are expected to be called from the USB core/hub thread
+ * with the kernel lock held
+ */
+extern void usbfs_update_special(void);
+extern int usbfs_init(void);
+extern void usbfs_cleanup(void);
+
+#else /* CONFIG_USB_DEVICEFS */
+
+static inline void usbfs_update_special(void) {}
+static inline int usbfs_init(void) { return 0; }
+static inline void usbfs_cleanup(void) { }
+
+#endif /* CONFIG_USB_DEVICEFS */
+
+/*-------------------------------------------------------------------------*/
+
+#if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
+
+struct usb_mon_operations {
+        void (*urb_submit)(struct usb_bus *bus, struct urb *urb);
+        void (*urb_submit_error)(struct usb_bus *bus, struct urb *urb, int err);
+        void (*urb_complete)(struct usb_bus *bus, struct urb *urb, int status);
+        /* void (*urb_unlink)(struct usb_bus *bus, struct urb *urb); */
+};
+
+extern struct usb_mon_operations *mon_ops;
+
+static inline void usbmon_urb_submit(struct usb_bus *bus, struct urb *urb)
+{
+        if (bus->monitored)
+                (*mon_ops->urb_submit)(bus, urb);
+}
+
+static inline void usbmon_urb_submit_error(struct usb_bus *bus, struct urb *urb,
+    int error)
+{
+        if (bus->monitored)
+                (*mon_ops->urb_submit_error)(bus, urb, error);
+}
+
+static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb,
+                int status)
+{
+        if (bus->monitored)
+                (*mon_ops->urb_complete)(bus, urb, status);
+}
+
+int usb_mon_register(struct usb_mon_operations *ops);
+void usb_mon_deregister(void);
+
+#else
+
+static inline void usbmon_urb_submit(struct usb_bus *bus, struct urb *urb) {}
+static inline void usbmon_urb_submit_error(struct usb_bus *bus, struct urb *urb,
+    int error) {}
+static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb,
+                int status) {}
+
+#endif /* CONFIG_USB_MON || CONFIG_USB_MON_MODULE */
+
+/*-------------------------------------------------------------------------*/
+
+/* hub.h ... DeviceRemovable in 2.4.2-ac11, gone in 2.4.10 */
+/* bleech -- resurfaced in 2.4.11 or 2.4.12 */
+#define bitmap  DeviceRemovable
+
+
+/*-------------------------------------------------------------------------*/
+
+/* random stuff */
+
+#define RUN_CONTEXT (in_irq() ? "in_irq" \
+                : (in_interrupt() ? "in_interrupt" : "can sleep"))
+
+
+/* This rwsem is for use only by the hub driver and ehci-hcd.
+ * Nobody else should touch it.
+ */
+extern struct rw_semaphore ehci_cf_port_reset_rwsem;
+
+/* Keep track of which host controller drivers are loaded */
+#define USB_UHCI_LOADED         0
+#define USB_OHCI_LOADED         1
+#define USB_EHCI_LOADED         2
+extern unsigned long usb_hcds_loaded;
+
+#endif /* __KERNEL__ */
+
+#endif /* __USB_CORE_HCD_H */
diff --git a/include/linux/usb/langwell_udc.h b/include/linux/usb/langwell_udc.h
index c949178a6530..2d2d1bbad9d2 100644
--- a/include/linux/usb/langwell_udc.h
+++ b/include/linux/usb/langwell_udc.h
@@ -181,7 +181,7 @@ struct langwell_op_regs {
 #define PORTS_PIC       (BIT(15) | BIT(14))     /* port indicator control */
 #define PORTS_PO        BIT(13) /* port owner */
 #define PORTS_PP        BIT(12) /* port power */
-#define PORTS_LS        (BIT(11) | BIT(10))     /* line status */
+#define PORTS_LS        (BIT(11) | BIT(10))     /* line status */
 #define PORTS_SLP       BIT(9)  /* suspend using L1 */
 #define PORTS_PR        BIT(8)  /* port reset */
 #define PORTS_SUSP      BIT(7)  /* suspend */
diff --git a/include/linux/usb/musb.h b/include/linux/usb/musb.h
index 7acef0234c0e..ee2dd1d506ed 100644
--- a/include/linux/usb/musb.h
+++ b/include/linux/usb/musb.h
@@ -22,12 +22,47 @@ enum musb_mode {
 
 struct clk;
 
+enum musb_fifo_style {
+        FIFO_RXTX,
+        FIFO_TX,
+        FIFO_RX
+} __attribute__ ((packed));
+
+enum musb_buf_mode {
+        BUF_SINGLE,
+        BUF_DOUBLE
+} __attribute__ ((packed));
+
+struct musb_fifo_cfg {
+        u8                      hw_ep_num;
+        enum musb_fifo_style    style;
+        enum musb_buf_mode      mode;
+        u16                     maxpacket;
+};
+
+#define MUSB_EP_FIFO(ep, st, m, pkt)            \
+{                                               \
+        .hw_ep_num      = ep,                   \
+        .style          = st,                   \
+        .mode           = m,                    \
+        .maxpacket      = pkt,                  \
+}
+
+#define MUSB_EP_FIFO_SINGLE(ep, st, pkt)        \
+        MUSB_EP_FIFO(ep, st, BUF_SINGLE, pkt)
+
+#define MUSB_EP_FIFO_DOUBLE(ep, st, pkt)        \
+        MUSB_EP_FIFO(ep, st, BUF_DOUBLE, pkt)
+
 struct musb_hdrc_eps_bits {
         const char      name[16];
         u8              bits;
 };
 
 struct musb_hdrc_config {
+        struct musb_fifo_cfg    *fifo_cfg;      /* board fifo configuration */
+        unsigned                fifo_cfg_size;  /* size of the fifo configuration */
+
         /* MUSB configuration-specific details */
         unsigned        multipoint:1;   /* multipoint device */
         unsigned        dyn_fifo:1 __deprecated; /* supports dynamic fifo sizing */
@@ -51,8 +86,9 @@ struct musb_hdrc_config {
 
         struct musb_hdrc_eps_bits *eps_bits __deprecated;
 #ifdef CONFIG_BLACKFIN
-        /* A GPIO controlling VRSEL in Blackfin */
-        unsigned int    gpio_vrsel;
+        /* A GPIO controlling VRSEL in Blackfin */
+        unsigned int    gpio_vrsel;
+        unsigned int    gpio_vrsel_active;
 #endif
 
 };
diff --git a/include/linux/usb/ncm.h b/include/linux/usb/ncm.h
new file mode 100644
index 000000000000..006d1064c8b2
--- /dev/null
+++ b/include/linux/usb/ncm.h
@@ -0,0 +1,114 @@
+/*
+ * USB CDC NCM auxiliary definitions
+ */
+
+#ifndef __LINUX_USB_NCM_H
+#define __LINUX_USB_NCM_H
+
+#include <linux/types.h>
+#include <linux/usb/cdc.h>
+#include <asm/unaligned.h>
+
+#define NCM_NTB_MIN_IN_SIZE             2048
+#define NCM_NTB_MIN_OUT_SIZE            2048
+
+#define NCM_CONTROL_TIMEOUT             (5 * 1000)
+
+/* bmNetworkCapabilities */
+
+#define NCM_NCAP_ETH_FILTER     (1 << 0)
+#define NCM_NCAP_NET_ADDRESS    (1 << 1)
+#define NCM_NCAP_ENCAP_COMM     (1 << 2)
+#define NCM_NCAP_MAX_DGRAM      (1 << 3)
+#define NCM_NCAP_CRC_MODE       (1 << 4)
+
+/*
+ * Here are options for NCM Datagram Pointer table (NDP) parser.
+ * There are 2 different formats: NDP16 and NDP32 in the spec (ch. 3),
+ * in NDP16 offsets and sizes fields are 1 16bit word wide,
+ * in NDP32 -- 2 16bit words wide. Also signatures are different.
+ * To make the parser code the same, put the differences in the structure,
+ * and switch pointers to the structures when the format is changed.
+ */
+
+struct ndp_parser_opts {
+        u32             nth_sign;
+        u32             ndp_sign;
+        unsigned        nth_size;
+        unsigned        ndp_size;
+        unsigned        ndplen_align;
+        /* sizes in u16 units */
+        unsigned        dgram_item_len; /* index or length */
+        unsigned        block_length;
+        unsigned        fp_index;
+        unsigned        reserved1;
+        unsigned        reserved2;
+        unsigned        next_fp_index;
+};
+
+#define INIT_NDP16_OPTS {                                       \
+                .nth_sign = NCM_NTH16_SIGN,                     \
+                .ndp_sign = NCM_NDP16_NOCRC_SIGN,               \
+                .nth_size = sizeof(struct usb_cdc_ncm_nth16),   \
+                .ndp_size = sizeof(struct usb_cdc_ncm_ndp16),   \
+                .ndplen_align = 4,                              \
+                .dgram_item_len = 1,                            \
+                .block_length = 1,                              \
+                .fp_index = 1,                                  \
+                .reserved1 = 0,                                 \
+                .reserved2 = 0,                                 \
+                .next_fp_index = 1,                             \
+        }
+
+
+#define INIT_NDP32_OPTS {                                       \
+                .nth_sign = NCM_NTH32_SIGN,                     \
+                .ndp_sign = NCM_NDP32_NOCRC_SIGN,               \
+                .nth_size = sizeof(struct usb_cdc_ncm_nth32),   \
+                .ndp_size = sizeof(struct usb_cdc_ncm_ndp32),   \
+                .ndplen_align = 8,                              \
+                .dgram_item_len = 2,                            \
+                .block_length = 2,                              \
+                .fp_index = 2,                                  \
+                .reserved1 = 1,                                 \
+                .reserved2 = 2,                                 \
+                .next_fp_index = 2,                             \
+        }
+
+static inline void put_ncm(__le16 **p, unsigned size, unsigned val)
+{
+        switch (size) {
+        case 1:
+                put_unaligned_le16((u16)val, *p);
+                break;
+        case 2:
+                put_unaligned_le32((u32)val, *p);
+
+                break;
+        default:
+                BUG();
+        }
+
+        *p += size;
+}
+
+static inline unsigned get_ncm(__le16 **p, unsigned size)
+{
+        unsigned tmp;
+
+        switch (size) {
+        case 1:
+                tmp = get_unaligned_le16(*p);
+                break;
+        case 2:
+                tmp = get_unaligned_le32(*p);
+                break;
+        default:
+                BUG();
+        }
+
+        *p += size;
+        return tmp;
+}
+
+#endif /* __LINUX_USB_NCM_H */
diff --git a/include/linux/usb/net2280.h b/include/linux/usb/net2280.h
index 96ca549a778d..148b8fa5b1a2 100644
--- a/include/linux/usb/net2280.h
+++ b/include/linux/usb/net2280.h
@@ -353,7 +353,7 @@ struct net2280_dma_regs {	/* [11.7] */
 #define     DMA_TRANSACTION_DONE_INTERRUPT                      24
 #define     DMA_ABORT                                           1
 #define     DMA_START                                           0
-        u32             _unused0 [2];
+        u32             _unused0[2];
         /* offset 0x0190, 0x01b0, 0x01d0, 0x01f0, */
         u32             dmacount;
 #define     VALID_BIT                                           31
@@ -374,7 +374,7 @@ struct net2280_dep_regs {	/* [11.8] */
         u32             dep_cfg;
         /* offset 0x0204, 0x0214, 0x224, 0x234, 0x244 */
         u32             dep_rsp;
-        u32             _unused [2];
+        u32             _unused[2];
 } __attribute__ ((packed));
 
 /* configurable endpoint registers, BAR0 + 0x0300 ... array of seven structs
@@ -437,7 +437,7 @@ struct net2280_ep_regs {	/* [11.9] */
         /* offset 0x0310, 0x0330, 0x0350, 0x0370, 0x0390, 0x03b0, 0x03d0 */
         u32             ep_avail;
         u32             ep_data;
-        u32             _unused0 [2];
+        u32             _unused0[2];
 } __attribute__ ((packed));
 
 #endif /* __LINUX_USB_NET2280_H */
diff --git a/include/linux/usb/quirks.h b/include/linux/usb/quirks.h
index 0a555dd131fc..16b7f3347545 100644
--- a/include/linux/usb/quirks.h
+++ b/include/linux/usb/quirks.h
@@ -22,4 +22,8 @@
 /*device will morph if reset, don't use reset for handling errors */
 #define USB_QUIRK_RESET_MORPHS          0x00000010
 
+/* device has more interface descriptions than the bNumInterfaces count,
+   and can't handle talking to these interfaces */
+#define USB_QUIRK_HONOR_BNUMINTERFACES  0x00000020
+
 #endif /* __LINUX_USB_QUIRKS_H */
diff --git a/include/linux/usb/rndis_host.h b/include/linux/usb/rndis_host.h
index 1ef1ebc2b04f..05ef52861988 100644
--- a/include/linux/usb/rndis_host.h
+++ b/include/linux/usb/rndis_host.h
@@ -34,10 +34,10 @@
 struct rndis_msg_hdr {
         __le32  msg_type;                       /* RNDIS_MSG_* */
         __le32  msg_len;
-        // followed by data that varies between messages
+        /* followed by data that varies between messages */
         __le32  request_id;
         __le32  status;
-        // ... and more
+        /* ... and more */
 } __attribute__ ((packed));
 
 /* MS-Windows uses this strange size, but RNDIS spec says 1024 minimum */
@@ -92,67 +92,67 @@ struct rndis_msg_hdr {
 
 struct rndis_data_hdr {
         __le32  msg_type;               /* RNDIS_MSG_PACKET */
-        __le32  msg_len;                // rndis_data_hdr + data_len + pad
-        __le32  data_offset;            // 36 -- right after header
-        __le32  data_len;               // ... real packet size
+        __le32  msg_len;                /* rndis_data_hdr + data_len + pad */
+        __le32  data_offset;            /* 36 -- right after header */
+        __le32  data_len;               /* ... real packet size */
 
-        __le32  oob_data_offset;        // zero
-        __le32  oob_data_len;           // zero
-        __le32  num_oob;                // zero
-        __le32  packet_data_offset;     // zero
+        __le32  oob_data_offset;        /* zero */
+        __le32  oob_data_len;           /* zero */
+        __le32  num_oob;                /* zero */
+        __le32  packet_data_offset;     /* zero */
 
-        __le32  packet_data_len;        // zero
-        __le32  vc_handle;              // zero
-        __le32  reserved;               // zero
+        __le32  packet_data_len;        /* zero */
+        __le32  vc_handle;              /* zero */
+        __le32  reserved;               /* zero */
 } __attribute__ ((packed));
 
 struct rndis_init {             /* OUT */
-        // header and:
+        /* header and: */
         __le32  msg_type;                       /* RNDIS_MSG_INIT */
-        __le32  msg_len;                        // 24
+        __le32  msg_len;                        /* 24 */
         __le32  request_id;
-        __le32  major_version;                  // of rndis (1.0)
+        __le32  major_version;                  /* of rndis (1.0) */
         __le32  minor_version;
         __le32  max_transfer_size;
 } __attribute__ ((packed));
 
 struct rndis_init_c {           /* IN */
-        // header and:
+        /* header and: */
         __le32  msg_type;                       /* RNDIS_MSG_INIT_C */
         __le32  msg_len;
         __le32  request_id;
         __le32  status;
-        __le32  major_version;                  // of rndis (1.0)
+        __le32  major_version;                  /* of rndis (1.0) */
         __le32  minor_version;
         __le32  device_flags;
-        __le32  medium;                         // zero == 802.3
+        __le32  medium;                         /* zero == 802.3 */
         __le32  max_packets_per_message;
         __le32  max_transfer_size;
-        __le32  packet_alignment;               // max 7; (1<<n) bytes
-        __le32  af_list_offset;                 // zero
-        __le32  af_list_size;                   // zero
+        __le32  packet_alignment;               /* max 7; (1<<n) bytes */
+        __le32  af_list_offset;                 /* zero */
+        __le32  af_list_size;                   /* zero */
 } __attribute__ ((packed));
 
 struct rndis_halt {             /* OUT (no reply) */
-        // header and:
+        /* header and: */
         __le32  msg_type;                       /* RNDIS_MSG_HALT */
         __le32  msg_len;
         __le32  request_id;
 } __attribute__ ((packed));
 
 struct rndis_query {            /* OUT */
-        // header and:
+        /* header and: */
         __le32  msg_type;                       /* RNDIS_MSG_QUERY */
         __le32  msg_len;
         __le32  request_id;
         __le32  oid;
         __le32  len;
         __le32  offset;
-/*?*/   __le32  handle;                         // zero
+/*?*/   __le32  handle;                         /* zero */
 } __attribute__ ((packed));
 
 struct rndis_query_c {          /* IN */
-        // header and:
+        /* header and: */
         __le32  msg_type;                       /* RNDIS_MSG_QUERY_C */
         __le32  msg_len;
         __le32  request_id;
@@ -162,18 +162,18 @@ struct rndis_query_c {		/* IN */
 } __attribute__ ((packed));
 
 struct rndis_set {              /* OUT */
-        // header and:
+        /* header and: */
         __le32  msg_type;                       /* RNDIS_MSG_SET */
         __le32  msg_len;
         __le32  request_id;
         __le32  oid;
         __le32  len;
         __le32  offset;
-/*?*/   __le32  handle;                         // zero
+/*?*/   __le32  handle;                         /* zero */
 } __attribute__ ((packed));
 
 struct rndis_set_c {            /* IN */
-        // header and:
+        /* header and: */
         __le32  msg_type;                       /* RNDIS_MSG_SET_C */
         __le32  msg_len;
         __le32  request_id;
@@ -181,14 +181,14 @@ struct rndis_set_c {		/* IN */
 } __attribute__ ((packed));
 
 struct rndis_reset {            /* IN */
-        // header and:
+        /* header and: */
         __le32  msg_type;                       /* RNDIS_MSG_RESET */
         __le32  msg_len;
         __le32  reserved;
 } __attribute__ ((packed));
 
 struct rndis_reset_c {          /* OUT */
-        // header and:
+        /* header and: */
         __le32  msg_type;                       /* RNDIS_MSG_RESET_C */
         __le32  msg_len;
         __le32  status;
@@ -196,7 +196,7 @@ struct rndis_reset_c {		/* OUT */
 } __attribute__ ((packed));
 
 struct rndis_indicate {         /* IN (unrequested) */
-        // header and:
+        /* header and: */
         __le32  msg_type;                       /* RNDIS_MSG_INDICATE */
         __le32  msg_len;
         __le32  status;
@@ -208,14 +208,14 @@ struct rndis_indicate {		/* IN (unrequested) */
 } __attribute__ ((packed));
 
 struct rndis_keepalive {        /* OUT (optionally IN) */
-        // header and:
+        /* header and: */
         __le32  msg_type;                       /* RNDIS_MSG_KEEPALIVE */
         __le32  msg_len;
         __le32  request_id;
 } __attribute__ ((packed));
 
 struct rndis_keepalive_c {      /* IN (optionally OUT) */
-        // header and:
+        /* header and: */
         __le32  msg_type;                       /* RNDIS_MSG_KEEPALIVE_C */
         __le32  msg_len;
         __le32  request_id;
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index 0a458b861933..84a4c44c208b 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -35,6 +35,9 @@ enum port_dev_state {
         PORT_UNREGISTERING,
 };
 
+/* USB serial flags */
+#define USB_SERIAL_WRITE_BUSY   0
+
 /**
  * usb_serial_port: structure for the specific ports of a device.
  * @serial: pointer back to the struct usb_serial owner of this port.
@@ -49,7 +52,7 @@ enum port_dev_state {
  * @interrupt_out_size: the size of the interrupt_out_buffer, in bytes.
  * @interrupt_out_urb: pointer to the interrupt out struct urb for this port.
  * @interrupt_out_endpointAddress: endpoint address for the interrupt out pipe
- *      for this port.
+ *      for this port.
  * @bulk_in_buffer: pointer to the bulk in buffer for this port.
  * @bulk_in_size: the size of the bulk_in_buffer, in bytes.
  * @read_urb: pointer to the bulk in struct urb for this port.
@@ -60,13 +63,17 @@ enum port_dev_state {
  * @write_urb: pointer to the bulk out struct urb for this port.
  * @write_fifo: kfifo used to buffer outgoing data
  * @write_urb_busy: port`s writing status
+ * @bulk_out_buffers: pointers to the bulk out buffers for this port
+ * @write_urbs: pointers to the bulk out urbs for this port
+ * @write_urbs_free: status bitmap the for bulk out urbs
+ * @tx_bytes: number of bytes currently in host stack queues
  * @bulk_out_endpointAddress: endpoint address for the bulk out pipe for this
  *      port.
+ * @flags: usb serial port flags
  * @write_wait: a wait_queue_head_t used by the port.
  * @work: work queue entry for the line discipline waking up.
  * @throttled: nonzero if the read urb is inactive to throttle the device
  * @throttle_req: nonzero if the tty wants to throttle us
- * @console: attached usb serial console
  * @dev: pointer to the serial device
  *
  * This structure is used by the usb-serial core and drivers for the specific
@@ -97,16 +104,19 @@ struct usb_serial_port {
         struct urb              *write_urb;
         struct kfifo            write_fifo;
         int                     write_urb_busy;
+
+        unsigned char           *bulk_out_buffers[2];
+        struct urb              *write_urbs[2];
+        unsigned long           write_urbs_free;
         __u8                    bulk_out_endpointAddress;
 
-        int                     tx_bytes_flight;
-        int                     urbs_in_flight;
+        int                     tx_bytes;
 
+        unsigned long           flags;
         wait_queue_head_t       write_wait;
         struct work_struct      work;
         char                    throttled;
         char                    throttle_req;
-        char                    console;
         unsigned long           sysrq; /* sysrq timeout */
         struct device           dev;
         enum port_dev_state     dev_state;
@@ -181,6 +191,8 @@ static inline void usb_set_serial_data(struct usb_serial *serial, void *data)
  * @id_table: pointer to a list of usb_device_id structures that define all
  *      of the devices this structure can support.
  * @num_ports: the number of different ports this device will have.
+ * @bulk_in_size: bytes to allocate for bulk-in buffer (0 = end-point size)
+ * @bulk_out_size: bytes to allocate for bulk-out buffer (0 = end-point size)
  * @calc_num_ports: pointer to a function to determine how many ports this
  *      device has dynamically.  It will be called after the probe()
  *      callback is called, but before attach()
@@ -223,7 +235,9 @@ struct usb_serial_driver {
         struct device_driver    driver;
         struct usb_driver       *usb_driver;
         struct usb_dynids       dynids;
-        int                     max_in_flight_urbs;
+
+        size_t                  bulk_in_size;
+        size_t                  bulk_out_size;
 
         int (*probe)(struct usb_serial *serial, const struct usb_device_id *id);
         int (*attach)(struct usb_serial *serial);
@@ -269,6 +283,11 @@ struct usb_serial_driver {
         void (*write_int_callback)(struct urb *urb);
         void (*read_bulk_callback)(struct urb *urb);
         void (*write_bulk_callback)(struct urb *urb);
+        /* Called by the generic read bulk callback */
+        void (*process_read_urb)(struct urb *urb);
+        /* Called by the generic write implementation */
+        int (*prepare_write_buffer)(struct usb_serial_port *port,
+                                                void *dest, size_t size);
 };
 #define to_usb_serial_driver(d) \
         container_of(d, struct usb_serial_driver, driver)
@@ -318,8 +337,11 @@ extern void usb_serial_generic_disconnect(struct usb_serial *serial);
 extern void usb_serial_generic_release(struct usb_serial *serial);
 extern int usb_serial_generic_register(int debug);
 extern void usb_serial_generic_deregister(void);
-extern void usb_serial_generic_resubmit_read_urb(struct usb_serial_port *port,
+extern int usb_serial_generic_submit_read_urb(struct usb_serial_port *port,
                                                  gfp_t mem_flags);
+extern void usb_serial_generic_process_read_urb(struct urb *urb);
+extern int usb_serial_generic_prepare_write_buffer(struct usb_serial_port *port,
+                                                void *dest, size_t size);
 extern int usb_serial_handle_sysrq_char(struct tty_struct *tty,
                                         struct usb_serial_port *port,
                                         unsigned int ch);
diff --git a/include/linux/usb/ulpi.h b/include/linux/usb/ulpi.h
index 20675c6ebc4d..2369d07c3c87 100644
--- a/include/linux/usb/ulpi.h
+++ b/include/linux/usb/ulpi.h
@@ -1,6 +1,146 @@
+/*
+ * ulpi.h -- ULPI defines and function prorotypes
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ *
+ * This software is distributed under the terms of the GNU General
+ * Public License ("GPL") as published by the Free Software Foundation,
+ * version 2 of that License.
+ */
+
 #ifndef __LINUX_USB_ULPI_H
 #define __LINUX_USB_ULPI_H
 
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Macros for Set and Clear
+ * See ULPI 1.1 specification to find the registers with Set and Clear offsets
+ */
+#define ULPI_SET(a)                             (a + 1)
+#define ULPI_CLR(a)                             (a + 2)
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Register Map
+ */
+#define ULPI_VENDOR_ID_LOW                      0x00
+#define ULPI_VENDOR_ID_HIGH                     0x01
+#define ULPI_PRODUCT_ID_LOW                     0x02
+#define ULPI_PRODUCT_ID_HIGH                    0x03
+#define ULPI_FUNC_CTRL                          0x04
+#define ULPI_IFC_CTRL                           0x07
+#define ULPI_OTG_CTRL                           0x0a
+#define ULPI_USB_INT_EN_RISE                    0x0d
+#define ULPI_USB_INT_EN_FALL                    0x10
+#define ULPI_USB_INT_STS                        0x13
+#define ULPI_USB_INT_LATCH                      0x14
+#define ULPI_DEBUG                              0x15
+#define ULPI_SCRATCH                            0x16
+/* Optional Carkit Registers */
+#define ULPI_CARCIT_CTRL                        0x19
+#define ULPI_CARCIT_INT_DELAY                   0x1c
+#define ULPI_CARCIT_INT_EN                      0x1d
+#define ULPI_CARCIT_INT_STS                     0x20
+#define ULPI_CARCIT_INT_LATCH                   0x21
+#define ULPI_CARCIT_PLS_CTRL                    0x22
+/* Other Optional Registers */
+#define ULPI_TX_POS_WIDTH                       0x25
+#define ULPI_TX_NEG_WIDTH                       0x26
+#define ULPI_POLARITY_RECOVERY                  0x27
+/* Access Extended Register Set */
+#define ULPI_ACCESS_EXTENDED                    0x2f
+/* Vendor Specific */
+#define ULPI_VENDOR_SPECIFIC                    0x30
+/* Extended Registers */
+#define ULPI_EXT_VENDOR_SPECIFIC                0x80
+
+/*-------------------------------------------------------------------------*/
+
+/* Function Control */
+#define ULPI_FUNC_CTRL_XCVRSEL                  (1 << 0)
+#define  ULPI_FUNC_CTRL_XCVRSEL_MASK            (3 << 0)
+#define  ULPI_FUNC_CTRL_HIGH_SPEED              (0 << 0)
+#define  ULPI_FUNC_CTRL_FULL_SPEED              (1 << 0)
+#define  ULPI_FUNC_CTRL_LOW_SPEED               (2 << 0)
+#define  ULPI_FUNC_CTRL_FS4LS                   (3 << 0)
+#define ULPI_FUNC_CTRL_TERMSELECT               (1 << 2)
+#define ULPI_FUNC_CTRL_OPMODE                   (1 << 3)
+#define  ULPI_FUNC_CTRL_OPMODE_MASK             (3 << 3)
+#define  ULPI_FUNC_CTRL_OPMODE_NORMAL           (0 << 3)
+#define  ULPI_FUNC_CTRL_OPMODE_NONDRIVING       (1 << 3)
+#define  ULPI_FUNC_CTRL_OPMODE_DISABLE_NRZI     (2 << 3)
+#define  ULPI_FUNC_CTRL_OPMODE_NOSYNC_NOEOP     (3 << 3)
+#define ULPI_FUNC_CTRL_RESET                    (1 << 5)
+#define ULPI_FUNC_CTRL_SUSPENDM                 (1 << 6)
+
+/* Interface Control */
+#define ULPI_IFC_CTRL_6_PIN_SERIAL_MODE         (1 << 0)
+#define ULPI_IFC_CTRL_3_PIN_SERIAL_MODE         (1 << 1)
+#define ULPI_IFC_CTRL_CARKITMODE                (1 << 2)
+#define ULPI_IFC_CTRL_CLOCKSUSPENDM             (1 << 3)
+#define ULPI_IFC_CTRL_AUTORESUME                (1 << 4)
+#define ULPI_IFC_CTRL_EXTERNAL_VBUS             (1 << 5)
+#define ULPI_IFC_CTRL_PASSTHRU                  (1 << 6)
+#define ULPI_IFC_CTRL_PROTECT_IFC_DISABLE       (1 << 7)
+
+/* OTG Control */
+#define ULPI_OTG_CTRL_ID_PULLUP                 (1 << 0)
+#define ULPI_OTG_CTRL_DP_PULLDOWN               (1 << 1)
+#define ULPI_OTG_CTRL_DM_PULLDOWN               (1 << 2)
+#define ULPI_OTG_CTRL_DISCHRGVBUS               (1 << 3)
+#define ULPI_OTG_CTRL_CHRGVBUS                  (1 << 4)
+#define ULPI_OTG_CTRL_DRVVBUS                   (1 << 5)
+#define ULPI_OTG_CTRL_DRVVBUS_EXT               (1 << 6)
+#define ULPI_OTG_CTRL_EXTVBUSIND                (1 << 7)
+
+/* USB Interrupt Enable Rising,
+ * USB Interrupt Enable Falling,
+ * USB Interrupt Status and
+ * USB Interrupt Latch
+ */
+#define ULPI_INT_HOST_DISCONNECT                (1 << 0)
+#define ULPI_INT_VBUS_VALID                     (1 << 1)
+#define ULPI_INT_SESS_VALID                     (1 << 2)
+#define ULPI_INT_SESS_END                       (1 << 3)
+#define ULPI_INT_IDGRD                          (1 << 4)
+
+/* Debug */
+#define ULPI_DEBUG_LINESTATE0                   (1 << 0)
+#define ULPI_DEBUG_LINESTATE1                   (1 << 1)
+
+/* Carkit Control */
+#define ULPI_CARKIT_CTRL_CARKITPWR              (1 << 0)
+#define ULPI_CARKIT_CTRL_IDGNDDRV               (1 << 1)
+#define ULPI_CARKIT_CTRL_TXDEN                  (1 << 2)
+#define ULPI_CARKIT_CTRL_RXDEN                  (1 << 3)
+#define ULPI_CARKIT_CTRL_SPKLEFTEN              (1 << 4)
+#define ULPI_CARKIT_CTRL_SPKRIGHTEN             (1 << 5)
+#define ULPI_CARKIT_CTRL_MICEN                  (1 << 6)
+
+/* Carkit Interrupt Enable */
+#define ULPI_CARKIT_INT_EN_IDFLOAT_RISE         (1 << 0)
+#define ULPI_CARKIT_INT_EN_IDFLOAT_FALL         (1 << 1)
+#define ULPI_CARKIT_INT_EN_CARINTDET            (1 << 2)
+#define ULPI_CARKIT_INT_EN_DP_RISE              (1 << 3)
+#define ULPI_CARKIT_INT_EN_DP_FALL              (1 << 4)
+
+/* Carkit Interrupt Status and
+ * Carkit Interrupt Latch
+ */
+#define ULPI_CARKIT_INT_IDFLOAT                 (1 << 0)
+#define ULPI_CARKIT_INT_CARINTDET               (1 << 1)
+#define ULPI_CARKIT_INT_DP                      (1 << 2)
+
+/* Carkit Pulse Control*/
+#define ULPI_CARKIT_PLS_CTRL_TXPLSEN            (1 << 0)
+#define ULPI_CARKIT_PLS_CTRL_RXPLSEN            (1 << 1)
+#define ULPI_CARKIT_PLS_CTRL_SPKRLEFT_BIASEN    (1 << 2)
+#define ULPI_CARKIT_PLS_CTRL_SPKRRIGHT_BIASEN   (1 << 3)
+
+/*-------------------------------------------------------------------------*/
+
 struct otg_transceiver *otg_ulpi_create(struct otg_io_access_ops *ops,
                                         unsigned int flags);
 
diff --git a/include/linux/usb/usbnet.h b/include/linux/usb/usbnet.h
index df1e83dd9a54..7ae27a473818 100644
--- a/include/linux/usb/usbnet.h
+++ b/include/linux/usb/usbnet.h
@@ -43,7 +43,7 @@ struct usbnet {
         /* protocol/interface state */
         struct net_device       *net;
         int                     msg_enable;
-        unsigned long           data [5];
+        unsigned long           data[5];
         u32                     xid;
         u32                     hard_mtu;       /* count any extra framing */
         size_t                  rx_urb_size;    /* size for rx urbs */
@@ -148,8 +148,8 @@ struct driver_info {
  * much everything except custom framing and chip-specific stuff.
  */
 extern int usbnet_probe(struct usb_interface *, const struct usb_device_id *);
-extern int usbnet_suspend (struct usb_interface *, pm_message_t );
-extern int usbnet_resume (struct usb_interface *);
+extern int usbnet_suspend(struct usb_interface *, pm_message_t);
+extern int usbnet_resume(struct usb_interface *);
 extern void usbnet_disconnect(struct usb_interface *);
 
 
@@ -165,8 +165,8 @@ struct cdc_state {
         struct usb_interface            *data;
 };
 
-extern int usbnet_generic_cdc_bind (struct usbnet *, struct usb_interface *);
-extern void usbnet_cdc_unbind (struct usbnet *, struct usb_interface *);
+extern int usbnet_generic_cdc_bind(struct usbnet *, struct usb_interface *);
+extern void usbnet_cdc_unbind(struct usbnet *, struct usb_interface *);
 
 /* CDC and RNDIS support the same host-chosen packet filters for IN transfers */
 #define DEFAULT_FILTER  (USB_CDC_PACKET_TYPE_BROADCAST \
@@ -189,29 +189,31 @@ struct skb_data {	/* skb->cb is one of these */
         size_t                  length;
 };
 
-extern int usbnet_open (struct net_device *net);
-extern int usbnet_stop (struct net_device *net);
-extern netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,
-                                      struct net_device *net);
-extern void usbnet_tx_timeout (struct net_device *net);
-extern int usbnet_change_mtu (struct net_device *net, int new_mtu);
+extern int usbnet_open(struct net_device *net);
+extern int usbnet_stop(struct net_device *net);
+extern netdev_tx_t usbnet_start_xmit(struct sk_buff *skb,
+                                     struct net_device *net);
+extern void usbnet_tx_timeout(struct net_device *net);
+extern int usbnet_change_mtu(struct net_device *net, int new_mtu);
 
 extern int usbnet_get_endpoints(struct usbnet *, struct usb_interface *);
 extern int usbnet_get_ethernet_addr(struct usbnet *, int);
-extern void usbnet_defer_kevent (struct usbnet *, int);
-extern void usbnet_skb_return (struct usbnet *, struct sk_buff *);
+extern void usbnet_defer_kevent(struct usbnet *, int);
+extern void usbnet_skb_return(struct usbnet *, struct sk_buff *);
 extern void usbnet_unlink_rx_urbs(struct usbnet *);
 
 extern void usbnet_pause_rx(struct usbnet *);
 extern void usbnet_resume_rx(struct usbnet *);
 extern void usbnet_purge_paused_rxq(struct usbnet *);
 
-extern int usbnet_get_settings (struct net_device *net, struct ethtool_cmd *cmd);
-extern int usbnet_set_settings (struct net_device *net, struct ethtool_cmd *cmd);
-extern u32 usbnet_get_link (struct net_device *net);
-extern u32 usbnet_get_msglevel (struct net_device *);
-extern void usbnet_set_msglevel (struct net_device *, u32);
-extern void usbnet_get_drvinfo (struct net_device *, struct ethtool_drvinfo *);
+extern int usbnet_get_settings(struct net_device *net,
+                               struct ethtool_cmd *cmd);
+extern int usbnet_set_settings(struct net_device *net,
+                               struct ethtool_cmd *cmd);
+extern u32 usbnet_get_link(struct net_device *net);
+extern u32 usbnet_get_msglevel(struct net_device *);
+extern void usbnet_set_msglevel(struct net_device *, u32);
+extern void usbnet_get_drvinfo(struct net_device *, struct ethtool_drvinfo *);
 extern int usbnet_nway_reset(struct net_device *net);
 
 #endif /* __LINUX_USB_USBNET_H */
diff --git a/include/linux/usb/wusb-wa.h b/include/linux/usb/wusb-wa.h
index fb7c359bdfba..f9dec37f617b 100644
--- a/include/linux/usb/wusb-wa.h
+++ b/include/linux/usb/wusb-wa.h
@@ -87,7 +87,7 @@ enum rpipe_crs {
  * FIXME: explain rpipes
  */
 struct usb_rpipe_descriptor {
-        u8      bLength;
+        u8      bLength;
         u8      bDescriptorType;
         __le16  wRPipeIndex;
         __le16  wRequests;
diff --git a/include/linux/via-core.h b/include/linux/via-core.h
new file mode 100644
index 000000000000..7ffb521e1a7a
--- /dev/null
+++ b/include/linux/via-core.h
@@ -0,0 +1,219 @@
+/*
+ * Copyright 1998-2009 VIA Technologies, Inc. All Rights Reserved.
+ * Copyright 2001-2008 S3 Graphics, Inc. All Rights Reserved.
+ * Copyright 2009-2010 Jonathan Corbet <corbet@lwn.net>
+ * Copyright 2010 Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation;
+ * either version 2, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTIES OR REPRESENTATIONS; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE.See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc.,
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __VIA_CORE_H__
+#define __VIA_CORE_H__
+#include <linux/types.h>
+#include <linux/io.h>
+#include <linux/spinlock.h>
+#include <linux/pci.h>
+
+/*
+ * A description of each known serial I2C/GPIO port.
+ */
+enum via_port_type {
+        VIA_PORT_NONE = 0,
+        VIA_PORT_I2C,
+        VIA_PORT_GPIO,
+};
+
+enum via_port_mode {
+        VIA_MODE_OFF = 0,
+        VIA_MODE_I2C,           /* Used as I2C port */
+        VIA_MODE_GPIO,  /* Two GPIO ports */
+};
+
+enum viafb_i2c_adap {
+        VIA_PORT_26 = 0,
+        VIA_PORT_31,
+        VIA_PORT_25,
+        VIA_PORT_2C,
+        VIA_PORT_3D,
+};
+#define VIAFB_NUM_PORTS 5
+
+struct via_port_cfg {
+        enum via_port_type      type;
+        enum via_port_mode      mode;
+        u16                     io_port;
+        u8                      ioport_index;
+};
+
+/*
+ * This is the global viafb "device" containing stuff needed by
+ * all subdevs.
+ */
+struct viafb_dev {
+        struct pci_dev *pdev;
+        int chip_type;
+        struct via_port_cfg *port_cfg;
+        /*
+         * Spinlock for access to device registers.  Not yet
+         * globally used.
+         */
+        spinlock_t reg_lock;
+        /*
+         * The framebuffer MMIO region.  Little, if anything, touches
+         * this memory directly, and certainly nothing outside of the
+         * framebuffer device itself.  We *do* have to be able to allocate
+         * chunks of this memory for other devices, though.
+         */
+        unsigned long fbmem_start;
+        long fbmem_len;
+        void __iomem *fbmem;
+#if defined(CONFIG_FB_VIA_CAMERA) || defined(CONFIG_FB_VIA_CAMERA_MODULE)
+        long camera_fbmem_offset;
+        long camera_fbmem_size;
+#endif
+        /*
+         * The MMIO region for device registers.
+         */
+        unsigned long engine_start;
+        unsigned long engine_len;
+        void __iomem *engine_mmio;
+
+};
+
+/*
+ * Interrupt management.
+ */
+
+void viafb_irq_enable(u32 mask);
+void viafb_irq_disable(u32 mask);
+
+/*
+ * The global interrupt control register and its bits.
+ */
+#define VDE_INTERRUPT   0x200   /* Video interrupt flags/masks */
+#define   VDE_I_DVISENSE  0x00000001  /* DVI sense int status */
+#define   VDE_I_VBLANK    0x00000002  /* Vertical blank status */
+#define   VDE_I_MCCFI     0x00000004  /* MCE compl. frame int status */
+#define   VDE_I_VSYNC     0x00000008  /* VGA VSYNC int status */
+#define   VDE_I_DMA0DDONE 0x00000010  /* DMA 0 descr done */
+#define   VDE_I_DMA0TDONE 0x00000020  /* DMA 0 transfer done */
+#define   VDE_I_DMA1DDONE 0x00000040  /* DMA 1 descr done */
+#define   VDE_I_DMA1TDONE 0x00000080  /* DMA 1 transfer done */
+#define   VDE_I_C1AV      0x00000100  /* Cap Eng 1 act vid end */
+#define   VDE_I_HQV0      0x00000200  /* First HQV engine */
+#define   VDE_I_HQV1      0x00000400  /* Second HQV engine */
+#define   VDE_I_HQV1EN    0x00000800  /* Second HQV engine enable */
+#define   VDE_I_C0AV      0x00001000  /* Cap Eng 0 act vid end */
+#define   VDE_I_C0VBI     0x00002000  /* Cap Eng 0 VBI end */
+#define   VDE_I_C1VBI     0x00004000  /* Cap Eng 1 VBI end */
+#define   VDE_I_VSYNC2    0x00008000  /* Sec. Disp. VSYNC */
+#define   VDE_I_DVISNSEN  0x00010000  /* DVI sense enable */
+#define   VDE_I_VSYNC2EN  0x00020000  /* Sec Disp VSYNC enable */
+#define   VDE_I_MCCFIEN   0x00040000  /* MC comp frame int mask enable */
+#define   VDE_I_VSYNCEN   0x00080000  /* VSYNC enable */
+#define   VDE_I_DMA0DDEN  0x00100000  /* DMA 0 descr done enable */
+#define   VDE_I_DMA0TDEN  0x00200000  /* DMA 0 trans done enable */
+#define   VDE_I_DMA1DDEN  0x00400000  /* DMA 1 descr done enable */
+#define   VDE_I_DMA1TDEN  0x00800000  /* DMA 1 trans done enable */
+#define   VDE_I_C1AVEN    0x01000000  /* cap 1 act vid end enable */
+#define   VDE_I_HQV0EN    0x02000000  /* First hqv engine enable */
+#define   VDE_I_C1VBIEN   0x04000000  /* Cap 1 VBI end enable */
+#define   VDE_I_LVDSSI    0x08000000  /* LVDS sense interrupt */
+#define   VDE_I_C0AVEN    0x10000000  /* Cap 0 act vid end enable */
+#define   VDE_I_C0VBIEN   0x20000000  /* Cap 0 VBI end enable */
+#define   VDE_I_LVDSSIEN  0x40000000  /* LVDS Sense enable */
+#define   VDE_I_ENABLE    0x80000000  /* Global interrupt enable */
+
+/*
+ * DMA management.
+ */
+int viafb_request_dma(void);
+void viafb_release_dma(void);
+/* void viafb_dma_copy_out(unsigned int offset, dma_addr_t paddr, int len); */
+int viafb_dma_copy_out_sg(unsigned int offset, struct scatterlist *sg, int nsg);
+
+/*
+ * DMA Controller registers.
+ */
+#define VDMA_MR0        0xe00           /* Mod reg 0 */
+#define   VDMA_MR_CHAIN   0x01          /* Chaining mode */
+#define   VDMA_MR_TDIE    0x02          /* Transfer done int enable */
+#define VDMA_CSR0       0xe04           /* Control/status */
+#define   VDMA_C_ENABLE   0x01            /* DMA Enable */
+#define   VDMA_C_START    0x02            /* Start a transfer */
+#define   VDMA_C_ABORT    0x04            /* Abort a transfer */
+#define   VDMA_C_DONE     0x08            /* Transfer is done */
+#define VDMA_MARL0      0xe20           /* Mem addr low */
+#define VDMA_MARH0      0xe24           /* Mem addr high */
+#define VDMA_DAR0       0xe28           /* Device address */
+#define VDMA_DQWCR0     0xe2c           /* Count (16-byte) */
+#define VDMA_TMR0       0xe30           /* Tile mode reg */
+#define VDMA_DPRL0      0xe34           /* Not sure */
+#define   VDMA_DPR_IN     0x08          /* Inbound transfer to FB */
+#define VDMA_DPRH0      0xe38
+#define VDMA_PMR0       (0xe00 + 0x134) /* Pitch mode */
+
+/*
+ * Useful stuff that probably belongs somewhere global.
+ */
+#define VGA_WIDTH       640
+#define VGA_HEIGHT      480
+
+/*
+ * Indexed port operations.  Note that these are all multi-op
+ * functions; every invocation will be racy if you're not holding
+ * reg_lock.
+ */
+
+#define VIAStatus   0x3DA  /* Non-indexed port */
+#define VIACR       0x3D4
+#define VIASR       0x3C4
+#define VIAGR       0x3CE
+#define VIAAR       0x3C0
+
+static inline u8 via_read_reg(u16 port, u8 index)
+{
+        outb(index, port);
+        return inb(port + 1);
+}
+
+static inline void via_write_reg(u16 port, u8 index, u8 data)
+{
+        outb(index, port);
+        outb(data, port + 1);
+}
+
+static inline void via_write_reg_mask(u16 port, u8 index, u8 data, u8 mask)
+{
+        u8 old;
+
+        outb(index, port);
+        old = inb(port + 1);
+        outb((data & mask) | (old & ~mask), port + 1);
+}
+
+#define VIA_MISC_REG_READ       0x03CC
+#define VIA_MISC_REG_WRITE      0x03C2
+
+static inline void via_write_misc_reg_mask(u8 data, u8 mask)
+{
+        u8 old = inb(VIA_MISC_REG_READ);
+        outb((data & mask) | (old & ~mask), VIA_MISC_REG_WRITE);
+}
+
+
+#endif /* __VIA_CORE_H__ */
diff --git a/include/linux/via-gpio.h b/include/linux/via-gpio.h
new file mode 100644
index 000000000000..8281aea3dd6d
--- /dev/null
+++ b/include/linux/via-gpio.h
@@ -0,0 +1,14 @@
+/*
+ * Support for viafb GPIO ports.
+ *
+ * Copyright 2009 Jonathan Corbet <corbet@lwn.net>
+ * Distributable under version 2 of the GNU General Public License.
+ */
+
+#ifndef __VIA_GPIO_H__
+#define __VIA_GPIO_H__
+
+extern int viafb_gpio_lookup(const char *name);
+extern int viafb_gpio_init(void);
+extern void viafb_gpio_exit(void);
+#endif
diff --git a/include/linux/via_i2c.h b/include/linux/via_i2c.h
new file mode 100644
index 000000000000..44532e468c05
--- /dev/null
+++ b/include/linux/via_i2c.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright 1998-2009 VIA Technologies, Inc. All Rights Reserved.
+ * Copyright 2001-2008 S3 Graphics, Inc. All Rights Reserved.
+
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation;
+ * either version 2, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTIES OR REPRESENTATIONS; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE.See the GNU General Public License
+ * for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc.,
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+#ifndef __VIA_I2C_H__
+#define __VIA_I2C_H__
+
+#include <linux/i2c.h>
+#include <linux/i2c-algo-bit.h>
+
+struct via_i2c_stuff {
+        u16 i2c_port;                   /* GPIO or I2C port */
+        u16 is_active;                  /* Being used as I2C? */
+        struct i2c_adapter adapter;
+        struct i2c_algo_bit_data algo;
+};
+
+
+int viafb_i2c_readbyte(u8 adap, u8 slave_addr, u8 index, u8 *pdata);
+int viafb_i2c_writebyte(u8 adap, u8 slave_addr, u8 index, u8 data);
+int viafb_i2c_readbytes(u8 adap, u8 slave_addr, u8 index, u8 *buff, int buff_len);
+struct i2c_adapter *viafb_find_i2c_adapter(enum viafb_i2c_adap which);
+
+extern int viafb_i2c_init(void);
+extern void viafb_i2c_exit(void);
+#endif /* __VIA_I2C_H__ */
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 3793d168b44d..047f7e6edb86 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -160,16 +160,6 @@ enum v4l2_buf_type {
         V4L2_BUF_TYPE_PRIVATE              = 0x80,
 };
 
-enum v4l2_ctrl_type {
-        V4L2_CTRL_TYPE_INTEGER       = 1,
-        V4L2_CTRL_TYPE_BOOLEAN       = 2,
-        V4L2_CTRL_TYPE_MENU          = 3,
-        V4L2_CTRL_TYPE_BUTTON        = 4,
-        V4L2_CTRL_TYPE_INTEGER64     = 5,
-        V4L2_CTRL_TYPE_CTRL_CLASS    = 6,
-        V4L2_CTRL_TYPE_STRING        = 7,
-};
-
 enum v4l2_tuner_type {
         V4L2_TUNER_RADIO             = 1,
         V4L2_TUNER_ANALOG_TV         = 2,
@@ -294,6 +284,8 @@ struct v4l2_pix_format {
 
 /* Grey formats */
 #define V4L2_PIX_FMT_GREY    v4l2_fourcc('G', 'R', 'E', 'Y') /*  8  Greyscale     */
+#define V4L2_PIX_FMT_Y4      v4l2_fourcc('Y', '0', '4', ' ') /*  4  Greyscale     */
+#define V4L2_PIX_FMT_Y6      v4l2_fourcc('Y', '0', '6', ' ') /*  6  Greyscale     */
 #define V4L2_PIX_FMT_Y10     v4l2_fourcc('Y', '1', '0', ' ') /* 10  Greyscale     */
 #define V4L2_PIX_FMT_Y16     v4l2_fourcc('Y', '1', '6', ' ') /* 16  Greyscale     */
 
@@ -369,6 +361,7 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_OV511    v4l2_fourcc('O', '5', '1', '1') /* ov511 JPEG */
 #define V4L2_PIX_FMT_OV518    v4l2_fourcc('O', '5', '1', '8') /* ov518 JPEG */
 #define V4L2_PIX_FMT_STV0680  v4l2_fourcc('S', '6', '8', '0') /* stv0680 bayer */
+#define V4L2_PIX_FMT_TM6000   v4l2_fourcc('T', 'M', '6', '0') /* tm5600/tm60x0 */
 
 /*
  *      F O R M A T   E N U M E R A T I O N
@@ -549,6 +542,8 @@ struct v4l2_buffer {
 #define V4L2_BUF_FLAG_KEYFRAME  0x0008  /* Image is a keyframe (I-frame) */
 #define V4L2_BUF_FLAG_PFRAME    0x0010  /* Image is a P-frame */
 #define V4L2_BUF_FLAG_BFRAME    0x0020  /* Image is a B-frame */
+/* Buffer is ready, but the data contained within is corrupted. */
+#define V4L2_BUF_FLAG_ERROR     0x0040
 #define V4L2_BUF_FLAG_TIMECODE  0x0100  /* timecode field is valid */
 #define V4L2_BUF_FLAG_INPUT     0x0200  /* input field is valid */
 
@@ -939,6 +934,16 @@ struct v4l2_ext_controls {
 #define V4L2_CTRL_ID2CLASS(id)    ((id) & 0x0fff0000UL)
 #define V4L2_CTRL_DRIVER_PRIV(id) (((id) & 0xffff) >= 0x1000)
 
+enum v4l2_ctrl_type {
+        V4L2_CTRL_TYPE_INTEGER       = 1,
+        V4L2_CTRL_TYPE_BOOLEAN       = 2,
+        V4L2_CTRL_TYPE_MENU          = 3,
+        V4L2_CTRL_TYPE_BUTTON        = 4,
+        V4L2_CTRL_TYPE_INTEGER64     = 5,
+        V4L2_CTRL_TYPE_CTRL_CLASS    = 6,
+        V4L2_CTRL_TYPE_STRING        = 7,
+};
+
 /*  Used in the VIDIOC_QUERYCTRL ioctl for querying controls */
 struct v4l2_queryctrl {
         __u32                id;
@@ -1023,14 +1028,24 @@ enum v4l2_colorfx {
         V4L2_COLORFX_NONE       = 0,
         V4L2_COLORFX_BW         = 1,
         V4L2_COLORFX_SEPIA      = 2,
+        V4L2_COLORFX_NEGATIVE = 3,
+        V4L2_COLORFX_EMBOSS = 4,
+        V4L2_COLORFX_SKETCH = 5,
+        V4L2_COLORFX_SKY_BLUE = 6,
+        V4L2_COLORFX_GRASS_GREEN = 7,
+        V4L2_COLORFX_SKIN_WHITEN = 8,
+        V4L2_COLORFX_VIVID = 9,
 };
 #define V4L2_CID_AUTOBRIGHTNESS                 (V4L2_CID_BASE+32)
 #define V4L2_CID_BAND_STOP_FILTER               (V4L2_CID_BASE+33)
 
 #define V4L2_CID_ROTATE                         (V4L2_CID_BASE+34)
 #define V4L2_CID_BG_COLOR                       (V4L2_CID_BASE+35)
+
+#define V4L2_CID_CHROMA_GAIN                    (V4L2_CID_BASE+36)
+
 /* last CID + 1 */
-#define V4L2_CID_LASTP1                         (V4L2_CID_BASE+36)
+#define V4L2_CID_LASTP1                         (V4L2_CID_BASE+37)
 
 /*  MPEG-class control IDs defined by V4L2 */
 #define V4L2_CID_MPEG_BASE                      (V4L2_CTRL_CLASS_MPEG | 0x900)
@@ -1276,6 +1291,9 @@ enum  v4l2_exposure_auto_type {
 
 #define V4L2_CID_PRIVACY                        (V4L2_CID_CAMERA_CLASS_BASE+16)
 
+#define V4L2_CID_IRIS_ABSOLUTE                  (V4L2_CID_CAMERA_CLASS_BASE+17)
+#define V4L2_CID_IRIS_RELATIVE                  (V4L2_CID_CAMERA_CLASS_BASE+18)
+
 /* FM Modulator class control IDs */
 #define V4L2_CID_FM_TX_CLASS_BASE               (V4L2_CTRL_CLASS_FM_TX | 0x900)
 #define V4L2_CID_FM_TX_CLASS                    (V4L2_CTRL_CLASS_FM_TX | 1)
@@ -1621,6 +1639,38 @@ struct v4l2_streamparm {
 };
 
 /*
+ *      E V E N T S
+ */
+
+#define V4L2_EVENT_ALL                          0
+#define V4L2_EVENT_VSYNC                        1
+#define V4L2_EVENT_EOS                          2
+#define V4L2_EVENT_PRIVATE_START                0x08000000
+
+/* Payload for V4L2_EVENT_VSYNC */
+struct v4l2_event_vsync {
+        /* Can be V4L2_FIELD_ANY, _NONE, _TOP or _BOTTOM */
+        __u8 field;
+} __attribute__ ((packed));
+
+struct v4l2_event {
+        __u32                           type;
+        union {
+                struct v4l2_event_vsync vsync;
+                __u8                    data[64];
+        } u;
+        __u32                           pending;
+        __u32                           sequence;
+        struct timespec                 timestamp;
+        __u32                           reserved[9];
+};
+
+struct v4l2_event_subscription {
+        __u32                           type;
+        __u32                           reserved[7];
+};
+
+/*
  *      A D V A N C E D   D E B U G G I N G
  *
  *      NOTE: EXPERIMENTAL API, NEVER RELY ON THIS IN APPLICATIONS!
@@ -1742,6 +1792,9 @@ struct v4l2_dbg_chip_ident {
 #define VIDIOC_QUERY_DV_PRESET  _IOR('V',  86, struct v4l2_dv_preset)
 #define VIDIOC_S_DV_TIMINGS     _IOWR('V', 87, struct v4l2_dv_timings)
 #define VIDIOC_G_DV_TIMINGS     _IOWR('V', 88, struct v4l2_dv_timings)
+#define VIDIOC_DQEVENT           _IOR('V', 89, struct v4l2_event)
+#define VIDIOC_SUBSCRIBE_EVENT   _IOW('V', 90, struct v4l2_event_subscription)
+#define VIDIOC_UNSUBSCRIBE_EVENT _IOW('V', 91, struct v4l2_event_subscription)
 
 /* Reminder: when adding new ioctls please add support for them to
    drivers/media/video/v4l2-compat-ioctl32.c as well! */
diff --git a/include/linux/virtio.h b/include/linux/virtio.h
index 40d1709bdbf4..aff5b4f74041 100644
--- a/include/linux/virtio.h
+++ b/include/linux/virtio.h
@@ -7,6 +7,7 @@
 #include <linux/spinlock.h>
 #include <linux/device.h>
 #include <linux/mod_devicetable.h>
+#include <linux/gfp.h>
 
 /**
  * virtqueue - a queue to register buffers for sending or receiving.
@@ -14,7 +15,6 @@
  * @callback: the function to call when buffers are consumed (can be NULL).
  * @name: the name of this virtqueue (mainly for debugging)
  * @vdev: the virtio device this queue was created for.
- * @vq_ops: the operations for this virtqueue (see below).
  * @priv: a pointer for the virtqueue implementation to use.
  */
 struct virtqueue {
@@ -22,60 +22,71 @@ struct virtqueue {
         void (*callback)(struct virtqueue *vq);
         const char *name;
         struct virtio_device *vdev;
-        struct virtqueue_ops *vq_ops;
         void *priv;
 };
 
 /**
- * virtqueue_ops - operations for virtqueue abstraction layer
- * @add_buf: expose buffer to other end
+ * operations for virtqueue
+ * virtqueue_add_buf: expose buffer to other end
  *      vq: the struct virtqueue we're talking about.
  *      sg: the description of the buffer(s).
  *      out_num: the number of sg readable by other side
  *      in_num: the number of sg which are writable (after readable ones)
  *      data: the token identifying the buffer.
+ *      gfp: how to do memory allocations (if necessary).
  *      Returns remaining capacity of queue (sg segments) or a negative error.
- * @kick: update after add_buf
+ * virtqueue_kick: update after add_buf
  *      vq: the struct virtqueue
  *      After one or more add_buf calls, invoke this to kick the other side.
- * @get_buf: get the next used buffer
+ * virtqueue_get_buf: get the next used buffer
  *      vq: the struct virtqueue we're talking about.
  *      len: the length written into the buffer
  *      Returns NULL or the "data" token handed to add_buf.
- * @disable_cb: disable callbacks
+ * virtqueue_disable_cb: disable callbacks
  *      vq: the struct virtqueue we're talking about.
  *      Note that this is not necessarily synchronous, hence unreliable and only
  *      useful as an optimization.
- * @enable_cb: restart callbacks after disable_cb.
+ * virtqueue_enable_cb: restart callbacks after disable_cb.
  *      vq: the struct virtqueue we're talking about.
  *      This re-enables callbacks; it returns "false" if there are pending
  *      buffers in the queue, to detect a possible race between the driver
  *      checking for more work, and enabling callbacks.
- * @detach_unused_buf: detach first unused buffer
+ * virtqueue_detach_unused_buf: detach first unused buffer
  *      vq: the struct virtqueue we're talking about.
  *      Returns NULL or the "data" token handed to add_buf
  *
  * Locking rules are straightforward: the driver is responsible for
  * locking.  No two operations may be invoked simultaneously, with the exception
- * of @disable_cb.
+ * of virtqueue_disable_cb.
  *
  * All operations can be called in any context.
  */
-struct virtqueue_ops {
-        int (*add_buf)(struct virtqueue *vq,
-                       struct scatterlist sg[],
-                       unsigned int out_num,
-                       unsigned int in_num,
-                       void *data);
 
-        void (*kick)(struct virtqueue *vq);
+int virtqueue_add_buf_gfp(struct virtqueue *vq,
+                          struct scatterlist sg[],
+                          unsigned int out_num,
+                          unsigned int in_num,
+                          void *data,
+                          gfp_t gfp);
 
-        void *(*get_buf)(struct virtqueue *vq, unsigned int *len);
+static inline int virtqueue_add_buf(struct virtqueue *vq,
+                                    struct scatterlist sg[],
+                                    unsigned int out_num,
+                                    unsigned int in_num,
+                                    void *data)
+{
+        return virtqueue_add_buf_gfp(vq, sg, out_num, in_num, data, GFP_ATOMIC);
+}
 
-        void (*disable_cb)(struct virtqueue *vq);
-        bool (*enable_cb)(struct virtqueue *vq);
-        void *(*detach_unused_buf)(struct virtqueue *vq);
-};
+void virtqueue_kick(struct virtqueue *vq);
+
+void *virtqueue_get_buf(struct virtqueue *vq, unsigned int *len);
+
+void virtqueue_disable_cb(struct virtqueue *vq);
+
+bool virtqueue_enable_cb(struct virtqueue *vq);
+
+void *virtqueue_detach_unused_buf(struct virtqueue *vq);
 
 /**
  * virtio_device - representation of a device using virtio
diff --git a/include/linux/virtio_blk.h b/include/linux/virtio_blk.h
index e52029e98919..167720d695ed 100644
--- a/include/linux/virtio_blk.h
+++ b/include/linux/virtio_blk.h
@@ -17,6 +17,8 @@
 #define VIRTIO_BLK_F_FLUSH      9       /* Cache flush command support */
 #define VIRTIO_BLK_F_TOPOLOGY   10      /* Topology information is available */
 
+#define VIRTIO_BLK_ID_BYTES     20      /* ID string length */
+
 struct virtio_blk_config {
         /* The capacity (in 512-byte sectors). */
         __u64 capacity;
@@ -67,6 +69,9 @@ struct virtio_blk_config {
 /* Cache flush command */
 #define VIRTIO_BLK_T_FLUSH      4
 
+/* Get device ID command */
+#define VIRTIO_BLK_T_GET_ID    8
+
 /* Barrier before this op. */
 #define VIRTIO_BLK_T_BARRIER    0x80000000
 
diff --git a/include/linux/virtio_console.h b/include/linux/virtio_console.h
index 92228a8fbcbc..a85064db8f94 100644
--- a/include/linux/virtio_console.h
+++ b/include/linux/virtio_console.h
@@ -12,14 +12,39 @@
 
 /* Feature bits */
 #define VIRTIO_CONSOLE_F_SIZE   0       /* Does host provide console size? */
+#define VIRTIO_CONSOLE_F_MULTIPORT 1    /* Does host provide multiple ports? */
+
+#define VIRTIO_CONSOLE_BAD_ID           (~(u32)0)
 
 struct virtio_console_config {
         /* colums of the screens */
         __u16 cols;
         /* rows of the screens */
         __u16 rows;
+        /* max. number of ports this device can hold */
+        __u32 max_nr_ports;
 } __attribute__((packed));
 
+/*
+ * A message that's passed between the Host and the Guest for a
+ * particular port.
+ */
+struct virtio_console_control {
+        __u32 id;               /* Port number */
+        __u16 event;            /* The kind of control event (see below) */
+        __u16 value;            /* Extra information for the key */
+};
+
+/* Some events for control messages */
+#define VIRTIO_CONSOLE_DEVICE_READY     0
+#define VIRTIO_CONSOLE_PORT_ADD         1
+#define VIRTIO_CONSOLE_PORT_REMOVE      2
+#define VIRTIO_CONSOLE_PORT_READY       3
+#define VIRTIO_CONSOLE_CONSOLE_PORT     4
+#define VIRTIO_CONSOLE_RESIZE           5
+#define VIRTIO_CONSOLE_PORT_OPEN        6
+#define VIRTIO_CONSOLE_PORT_NAME        7
+
 #ifdef __KERNEL__
 int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int));
 #endif /* __KERNEL__ */
diff --git a/include/linux/wait.h b/include/linux/wait.h
index 76d96d035ea0..0836ccc57121 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -376,6 +376,155 @@ do {									\
         __ret;                                                          \
 })
 
+
+#define __wait_event_interruptible_locked(wq, condition, exclusive, irq) \
+({                                                                      \
+        int __ret = 0;                                                  \
+        DEFINE_WAIT(__wait);                                            \
+        if (exclusive)                                                  \
+                __wait.flags |= WQ_FLAG_EXCLUSIVE;                      \
+        do {                                                            \
+                if (likely(list_empty(&__wait.task_list)))              \
+                        __add_wait_queue_tail(&(wq), &__wait);          \
+                set_current_state(TASK_INTERRUPTIBLE);                  \
+                if (signal_pending(current)) {                          \
+                        __ret = -ERESTARTSYS;                           \
+                        break;                                          \
+                }                                                       \
+                if (irq)                                                \
+                        spin_unlock_irq(&(wq).lock);                    \
+                else                                                    \
+                        spin_unlock(&(wq).lock);                        \
+                schedule();                                             \
+                if (irq)                                                \
+                        spin_lock_irq(&(wq).lock);                      \
+                else                                                    \
+                        spin_lock(&(wq).lock);                          \
+        } while (!(condition));                                         \
+        __remove_wait_queue(&(wq), &__wait);                            \
+        __set_current_state(TASK_RUNNING);                              \
+        __ret;                                                          \
+})
+
+
+/**
+ * wait_event_interruptible_locked - sleep until a condition gets true
+ * @wq: the waitqueue to wait on
+ * @condition: a C expression for the event to wait for
+ *
+ * The process is put to sleep (TASK_INTERRUPTIBLE) until the
+ * @condition evaluates to true or a signal is received.
+ * The @condition is checked each time the waitqueue @wq is woken up.
+ *
+ * It must be called with wq.lock being held.  This spinlock is
+ * unlocked while sleeping but @condition testing is done while lock
+ * is held and when this macro exits the lock is held.
+ *
+ * The lock is locked/unlocked using spin_lock()/spin_unlock()
+ * functions which must match the way they are locked/unlocked outside
+ * of this macro.
+ *
+ * wake_up_locked() has to be called after changing any variable that could
+ * change the result of the wait condition.
+ *
+ * The function will return -ERESTARTSYS if it was interrupted by a
+ * signal and 0 if @condition evaluated to true.
+ */
+#define wait_event_interruptible_locked(wq, condition)                  \
+        ((condition)                                                    \
+         ? 0 : __wait_event_interruptible_locked(wq, condition, 0, 0))
+
+/**
+ * wait_event_interruptible_locked_irq - sleep until a condition gets true
+ * @wq: the waitqueue to wait on
+ * @condition: a C expression for the event to wait for
+ *
+ * The process is put to sleep (TASK_INTERRUPTIBLE) until the
+ * @condition evaluates to true or a signal is received.
+ * The @condition is checked each time the waitqueue @wq is woken up.
+ *
+ * It must be called with wq.lock being held.  This spinlock is
+ * unlocked while sleeping but @condition testing is done while lock
+ * is held and when this macro exits the lock is held.
+ *
+ * The lock is locked/unlocked using spin_lock_irq()/spin_unlock_irq()
+ * functions which must match the way they are locked/unlocked outside
+ * of this macro.
+ *
+ * wake_up_locked() has to be called after changing any variable that could
+ * change the result of the wait condition.
+ *
+ * The function will return -ERESTARTSYS if it was interrupted by a
+ * signal and 0 if @condition evaluated to true.
+ */
+#define wait_event_interruptible_locked_irq(wq, condition)              \
+        ((condition)                                                    \
+         ? 0 : __wait_event_interruptible_locked(wq, condition, 0, 1))
+
+/**
+ * wait_event_interruptible_exclusive_locked - sleep exclusively until a condition gets true
+ * @wq: the waitqueue to wait on
+ * @condition: a C expression for the event to wait for
+ *
+ * The process is put to sleep (TASK_INTERRUPTIBLE) until the
+ * @condition evaluates to true or a signal is received.
+ * The @condition is checked each time the waitqueue @wq is woken up.
+ *
+ * It must be called with wq.lock being held.  This spinlock is
+ * unlocked while sleeping but @condition testing is done while lock
+ * is held and when this macro exits the lock is held.
+ *
+ * The lock is locked/unlocked using spin_lock()/spin_unlock()
+ * functions which must match the way they are locked/unlocked outside
+ * of this macro.
+ *
+ * The process is put on the wait queue with an WQ_FLAG_EXCLUSIVE flag
+ * set thus when other process waits process on the list if this
+ * process is awaken further processes are not considered.
+ *
+ * wake_up_locked() has to be called after changing any variable that could
+ * change the result of the wait condition.
+ *
+ * The function will return -ERESTARTSYS if it was interrupted by a
+ * signal and 0 if @condition evaluated to true.
+ */
+#define wait_event_interruptible_exclusive_locked(wq, condition)        \
+        ((condition)                                                    \
+         ? 0 : __wait_event_interruptible_locked(wq, condition, 1, 0))
+
+/**
+ * wait_event_interruptible_exclusive_locked_irq - sleep until a condition gets true
+ * @wq: the waitqueue to wait on
+ * @condition: a C expression for the event to wait for
+ *
+ * The process is put to sleep (TASK_INTERRUPTIBLE) until the
+ * @condition evaluates to true or a signal is received.
+ * The @condition is checked each time the waitqueue @wq is woken up.
+ *
+ * It must be called with wq.lock being held.  This spinlock is
+ * unlocked while sleeping but @condition testing is done while lock
+ * is held and when this macro exits the lock is held.
+ *
+ * The lock is locked/unlocked using spin_lock_irq()/spin_unlock_irq()
+ * functions which must match the way they are locked/unlocked outside
+ * of this macro.
+ *
+ * The process is put on the wait queue with an WQ_FLAG_EXCLUSIVE flag
+ * set thus when other process waits process on the list if this
+ * process is awaken further processes are not considered.
+ *
+ * wake_up_locked() has to be called after changing any variable that could
+ * change the result of the wait condition.
+ *
+ * The function will return -ERESTARTSYS if it was interrupted by a
+ * signal and 0 if @condition evaluated to true.
+ */
+#define wait_event_interruptible_exclusive_locked_irq(wq, condition)    \
+        ((condition)                                                    \
+         ? 0 : __wait_event_interruptible_locked(wq, condition, 1, 1))
+
+
+
 #define __wait_event_killable(wq, condition, ret)                       \
 do {                                                                    \
         DEFINE_WAIT(__wait);                                            \
diff --git a/include/linux/wireless.h b/include/linux/wireless.h
index 5b4c6c772a9b..e6827eedf18b 100644
--- a/include/linux/wireless.h
+++ b/include/linux/wireless.h
@@ -346,6 +346,8 @@
 #define SIOCIWFIRST     0x8B00
 #define SIOCIWLAST      SIOCIWLASTPRIV          /* 0x8BFF */
 #define IW_IOCTL_IDX(cmd)       ((cmd) - SIOCIWFIRST)
+#define IW_HANDLER(id, func)                    \
+        [IW_IOCTL_IDX(id)] = func
 
 /* Odd : get (world access), even : set (root access) */
 #define IW_IS_SET(cmd)  (!((cmd) & 0x1))
@@ -648,7 +650,7 @@
  * 32 bit bitmasks. Note : 32 bits = 0x20 = 2^5. */
 #define IW_EVENT_CAPA_BASE(cmd)         ((cmd >= SIOCIWFIRSTPRIV) ? \
                                          (cmd - SIOCIWFIRSTPRIV + 0x60) : \
-                                         (cmd - SIOCSIWCOMMIT))
+                                         (cmd - SIOCIWFIRST))
 #define IW_EVENT_CAPA_INDEX(cmd)        (IW_EVENT_CAPA_BASE(cmd) >> 5)
 #define IW_EVENT_CAPA_MASK(cmd)         (1 << (IW_EVENT_CAPA_BASE(cmd) & 0x1F))
 /* Event capability constants - event autogenerated by the kernel
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 36520ded3e06..cc97d6caf2b3 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -65,6 +65,15 @@ struct writeback_control {
          * so we use a single control to update them
          */
         unsigned no_nrwrite_index_update:1;
+
+        /*
+         * For WB_SYNC_ALL, the sb must always be pinned. For WB_SYNC_NONE,
+         * the writeback code will pin the sb for the caller. However,
+         * for eg umount, the caller does WB_SYNC_NONE but already has
+         * the sb pinned. If the below is set, caller already has the
+         * sb pinned.
+         */
+        unsigned sb_pinned:1;
 };
 
 /*
@@ -73,6 +82,7 @@ struct writeback_control {
 struct bdi_writeback;
 int inode_wait(void *);
 void writeback_inodes_sb(struct super_block *);
+void writeback_inodes_sb_locked(struct super_block *);
 int writeback_inodes_sb_if_idle(struct super_block *);
 void sync_inodes_sb(struct super_block *);
 void writeback_inodes_wbc(struct writeback_control *wbc);
@@ -96,8 +106,14 @@ static inline void inode_sync_wait(struct inode *inode)
 /*
  * mm/page-writeback.c
  */
-void laptop_io_completion(void);
+#ifdef CONFIG_BLOCK
+void laptop_io_completion(struct backing_dev_info *info);
 void laptop_sync_completion(void);
+void laptop_mode_sync(struct work_struct *work);
+void laptop_mode_timer_fn(unsigned long data);
+#else
+static inline void laptop_sync_completion(void) { }
+#endif
 void throttle_vm_writeout(gfp_t gfp_mask);
 
 /* These are exported to sysctl. */
diff --git a/include/linux/xattr.h b/include/linux/xattr.h
index fb9b7e6e1e2d..0cfa1e9c4cc1 100644
--- a/include/linux/xattr.h
+++ b/include/linux/xattr.h
@@ -37,7 +37,7 @@ struct inode;
 struct dentry;
 
 struct xattr_handler {
-        char *prefix;
+        const char *prefix;
         int flags;      /* fs private flags passed back to the handlers */
         size_t (*list)(struct dentry *dentry, char *list, size_t list_size,
                        const char *name, size_t name_len, int handler_flags);