73 files changed, 2614 insertions, 942 deletions

diff --git a/include/asm-generic/dma-mapping-broken.h b/include/asm-generic/dma-mapping-broken.h
index 82cd0cb1c3fe..ccf7b4f34a3c 100644
--- a/include/asm-generic/dma-mapping-broken.h
+++ b/include/asm-generic/dma-mapping-broken.h
@@ -72,9 +72,6 @@ dma_set_mask(struct device *dev, u64 mask);
 extern int
 dma_get_cache_alignment(void);
 
-extern int
-dma_is_consistent(struct device *dev, dma_addr_t dma_handle);
-
 extern void
 dma_cache_sync(struct device *dev, void *vaddr, size_t size,
                enum dma_data_direction direction);
diff --git a/include/asm-generic/fcntl.h b/include/asm-generic/fcntl.h
index e3cbc38bdcc2..a70b2d2bfc14 100644
--- a/include/asm-generic/fcntl.h
+++ b/include/asm-generic/fcntl.h
@@ -11,6 +11,10 @@
  * -Eric Paris
  */
 
+/*
+ * When introducing new O_* bits, please check its uniqueness in fcntl_init().
+ */
+
 #define O_ACCMODE       00000003
 #define O_RDONLY        00000000
 #define O_WRONLY        00000001
diff --git a/include/asm-generic/ioctls.h b/include/asm-generic/ioctls.h
index a799e20a769e..8554cb6a81b9 100644
--- a/include/asm-generic/ioctls.h
+++ b/include/asm-generic/ioctls.h
@@ -69,6 +69,7 @@
 #define TCSETX          0x5433
 #define TCSETXF         0x5434
 #define TCSETXW         0x5435
+#define TIOCSIG         _IOW('T', 0x36, int)  /* pty: generate signal */
 
 #define FIONCLEX        0x5450
 #define FIOCLEX         0x5451
@@ -87,12 +88,10 @@
 #define TIOCGICOUNT     0x545D  /* read serial port inline interrupt counts */
 
 /*
- * some architectures define FIOQSIZE as 0x545E, which is used for
- * TIOCGHAYESESP on others
+ * Some arches already define FIOQSIZE due to a historical
+ * conflict with a Hayes modem-specific ioctl value.
  */
 #ifndef FIOQSIZE
-# define TIOCGHAYESESP  0x545E  /* Get Hayes ESP configuration */
-# define TIOCSHAYESESP  0x545F  /* Set Hayes ESP configuration */
 # define FIOQSIZE       0x5460
 #endif
 
@@ -104,6 +103,7 @@
 #define TIOCPKT_START            8
 #define TIOCPKT_NOSTOP          16
 #define TIOCPKT_DOSTOP          32
+#define TIOCPKT_IOCTL           64
 
 #define TIOCSER_TEMT    0x01    /* Transmitter physically empty */
 
diff --git a/include/asm-generic/termbits.h b/include/asm-generic/termbits.h
index 1c9773d48cb0..232b4781aef3 100644
--- a/include/asm-generic/termbits.h
+++ b/include/asm-generic/termbits.h
@@ -178,6 +178,7 @@ struct ktermios {
 #define FLUSHO  0010000
 #define PENDIN  0040000
 #define IEXTEN  0100000
+#define EXTPROC 0200000
 
 /* tcflow() and TCXONC use these */
 #define TCOOFF          0
diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index 2547daf2aef2..9d65d4d0bd9c 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -39,6 +39,7 @@ header-y += ax25.h
 header-y += b1lli.h
 header-y += baycom.h
 header-y += bfs_fs.h
+header-y += blk_types.h
 header-y += blkpg.h
 header-y += bpqether.h
 header-y += bsg.h
diff --git a/include/linux/audit.h b/include/linux/audit.h
index f391d45c8aea..e24afabc548f 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -544,7 +544,7 @@ extern int audit_signals;
 #define audit_putname(n) do { ; } while (0)
 #define __audit_inode(n,d) do { ; } while (0)
 #define __audit_inode_child(i,p) do { ; } while (0)
-#define audit_inode(n,d) do { ; } while (0)
+#define audit_inode(n,d) do { (void)(d); } while (0)
 #define audit_inode_child(i,p) do { ; } while (0)
 #define audit_core_dumps(i) do { ; } while (0)
 #define auditsc_get_stamp(c,t,s) (0)
diff --git a/include/linux/auto_fs.h b/include/linux/auto_fs.h
index 7b09c8348fd3..da64e15004b6 100644
--- a/include/linux/auto_fs.h
+++ b/include/linux/auto_fs.h
@@ -79,6 +79,7 @@ struct autofs_packet_expire {
 #define AUTOFS_IOC_FAIL       _IO(0x93,0x61)
 #define AUTOFS_IOC_CATATONIC  _IO(0x93,0x62)
 #define AUTOFS_IOC_PROTOVER   _IOR(0x93,0x63,int)
+#define AUTOFS_IOC_SETTIMEOUT32 _IOWR(0x93,0x64,compat_ulong_t)
 #define AUTOFS_IOC_SETTIMEOUT _IOWR(0x93,0x64,unsigned long)
 #define AUTOFS_IOC_EXPIRE     _IOR(0x93,0x65,struct autofs_packet_expire)
 
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index e9aec0d099df..7628219e5386 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -45,22 +45,21 @@ enum bdi_stat_item {
 #define BDI_STAT_BATCH (8*(1+ilog2(nr_cpu_ids)))
 
 struct bdi_writeback {
-        struct list_head list;                  /* hangs off the bdi */
-
-        struct backing_dev_info *bdi;           /* our parent bdi */
+        struct backing_dev_info *bdi;   /* our parent bdi */
         unsigned int nr;
 
-        unsigned long last_old_flush;           /* last old data flush */
+        unsigned long last_old_flush;   /* last old data flush */
+        unsigned long last_active;      /* last time bdi thread was active */
 
-        struct task_struct      *task;          /* writeback task */
-        struct list_head        b_dirty;        /* dirty inodes */
-        struct list_head        b_io;           /* parked for writeback */
-        struct list_head        b_more_io;      /* parked for more writeback */
+        struct task_struct *task;       /* writeback thread */
+        struct timer_list wakeup_timer; /* used for delayed bdi thread wakeup */
+        struct list_head b_dirty;       /* dirty inodes */
+        struct list_head b_io;          /* parked for writeback */
+        struct list_head b_more_io;     /* parked for more writeback */
 };
 
 struct backing_dev_info {
         struct list_head bdi_list;
-        struct rcu_head rcu_head;
         unsigned long ra_pages; /* max readahead in PAGE_CACHE_SIZE units */
         unsigned long state;    /* Always use atomic bitops on this */
         unsigned int capabilities; /* Device capabilities */
@@ -80,8 +79,7 @@ struct backing_dev_info {
         unsigned int max_ratio, max_prop_frac;
 
         struct bdi_writeback wb;  /* default writeback info for this bdi */
-        spinlock_t wb_lock;       /* protects update side of wb_list */
-        struct list_head wb_list; /* the flusher threads hanging off this bdi */
+        spinlock_t wb_lock;       /* protects work_list */
 
         struct list_head work_list;
 
@@ -105,9 +103,10 @@ 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, long nr_pages);
 void bdi_start_background_writeback(struct backing_dev_info *bdi);
-int bdi_writeback_task(struct bdi_writeback *wb);
+int bdi_writeback_thread(void *data);
 int bdi_has_dirty_io(struct backing_dev_info *bdi);
 void bdi_arm_supers_timer(void);
+void bdi_wakeup_thread_delayed(struct backing_dev_info *bdi);
 
 extern spinlock_t bdi_lock;
 extern struct list_head bdi_list;
diff --git a/include/linux/bio.h b/include/linux/bio.h
index 7fc5606e6ea5..5274103434ad 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -9,7 +9,7 @@
  *
  * 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.
  *
@@ -28,6 +28,9 @@
 
 #include <asm/io.h>
 
+/* struct bio, bio_vec and BIO_* flags are defined in blk_types.h */
+#include <linux/blk_types.h>
+
 #define BIO_DEBUG
 
 #ifdef BIO_DEBUG
@@ -41,154 +44,6 @@
 #define BIO_MAX_SECTORS         (BIO_MAX_SIZE >> 9)
 
 /*
- * was unsigned short, but we might as well be ready for > 64kB I/O pages
- */
-struct bio_vec {
-        struct page     *bv_page;
-        unsigned int    bv_len;
-        unsigned int    bv_offset;
-};
-
-struct bio_set;
-struct bio;
-struct bio_integrity_payload;
-typedef void (bio_end_io_t) (struct bio *, int);
-typedef void (bio_destructor_t) (struct bio *);
-
-/*
- * main unit of I/O for the block layer and lower layers (ie drivers and
- * stacking drivers)
- */
-struct bio {
-        sector_t                bi_sector;      /* device address in 512 byte
-                                                   sectors */
-        struct bio              *bi_next;       /* request queue link */
-        struct block_device     *bi_bdev;
-        unsigned long           bi_flags;       /* status, command, etc */
-        unsigned long           bi_rw;          /* bottom bits READ/WRITE,
-                                                 * top bits priority
-                                                 */
-
-        unsigned short          bi_vcnt;        /* how many bio_vec's */
-        unsigned short          bi_idx;         /* current index into bvl_vec */
-
-        /* Number of segments in this BIO after
-         * physical address coalescing is performed.
-         */
-        unsigned int            bi_phys_segments;
-
-        unsigned int            bi_size;        /* residual I/O count */
-
-        /*
-         * To keep track of the max segment size, we account for the
-         * sizes of the first and last mergeable segments in this bio.
-         */
-        unsigned int            bi_seg_front_size;
-        unsigned int            bi_seg_back_size;
-
-        unsigned int            bi_max_vecs;    /* max bvl_vecs we can hold */
-
-        unsigned int            bi_comp_cpu;    /* completion CPU */
-
-        atomic_t                bi_cnt;         /* pin count */
-
-        struct bio_vec          *bi_io_vec;     /* the actual vec list */
-
-        bio_end_io_t            *bi_end_io;
-
-        void                    *bi_private;
-#if defined(CONFIG_BLK_DEV_INTEGRITY)
-        struct bio_integrity_payload *bi_integrity;  /* data integrity */
-#endif
-
-        bio_destructor_t        *bi_destructor; /* destructor */
-
-        /*
-         * We can inline a number of vecs at the end of the bio, to avoid
-         * double allocations for a small number of bio_vecs. This member
-         * MUST obviously be kept at the very end of the bio.
-         */
-        struct bio_vec          bi_inline_vecs[0];
-};
-
-/*
- * bio flags
- */
-#define BIO_UPTODATE    0       /* ok after I/O completion */
-#define BIO_RW_BLOCK    1       /* RW_AHEAD set, and read/write would block */
-#define BIO_EOF         2       /* out-out-bounds error */
-#define BIO_SEG_VALID   3       /* bi_phys_segments valid */
-#define BIO_CLONED      4       /* doesn't own data */
-#define BIO_BOUNCED     5       /* bio is a bounce bio */
-#define BIO_USER_MAPPED 6       /* contains user pages */
-#define BIO_EOPNOTSUPP  7       /* not supported */
-#define BIO_CPU_AFFINE  8       /* complete bio on same CPU as submitted */
-#define BIO_NULL_MAPPED 9       /* contains invalid user pages */
-#define BIO_FS_INTEGRITY 10     /* fs owns integrity data, not block layer */
-#define BIO_QUIET       11      /* Make BIO Quiet */
-#define bio_flagged(bio, flag)  ((bio)->bi_flags & (1 << (flag)))
-
-/*
- * top 4 bits of bio flags indicate the pool this bio came from
- */
-#define BIO_POOL_BITS           (4)
-#define BIO_POOL_NONE           ((1UL << BIO_POOL_BITS) - 1)
-#define BIO_POOL_OFFSET         (BITS_PER_LONG - BIO_POOL_BITS)
-#define BIO_POOL_MASK           (1UL << BIO_POOL_OFFSET)
-#define BIO_POOL_IDX(bio)       ((bio)->bi_flags >> BIO_POOL_OFFSET)    
-
-/*
- * bio bi_rw flags
- *
- * bit 0 -- data direction
- *      If not set, bio is a read from device. If set, it's a write to device.
- * bit 1 -- fail fast device errors
- * bit 2 -- fail fast transport errors
- * bit 3 -- fail fast driver errors
- * bit 4 -- rw-ahead when set
- * bit 5 -- barrier
- *      Insert a serialization point in the IO queue, forcing previously
- *      submitted IO to be completed before this one is issued.
- * bit 6 -- synchronous I/O hint.
- * bit 7 -- Unplug the device immediately after submitting this bio.
- * bit 8 -- metadata request
- *      Used for tracing to differentiate metadata and data IO. May also
- *      get some preferential treatment in the IO scheduler
- * bit 9 -- discard sectors
- *      Informs the lower level device that this range of sectors is no longer
- *      used by the file system and may thus be freed by the device. Used
- *      for flash based storage.
- *      Don't want driver retries for any fast fail whatever the reason.
- * bit 10 -- Tell the IO scheduler not to wait for more requests after this
-        one has been submitted, even if it is a SYNC request.
- */
-enum bio_rw_flags {
-        BIO_RW,
-        BIO_RW_FAILFAST_DEV,
-        BIO_RW_FAILFAST_TRANSPORT,
-        BIO_RW_FAILFAST_DRIVER,
-        /* above flags must match REQ_* */
-        BIO_RW_AHEAD,
-        BIO_RW_BARRIER,
-        BIO_RW_SYNCIO,
-        BIO_RW_UNPLUG,
-        BIO_RW_META,
-        BIO_RW_DISCARD,
-        BIO_RW_NOIDLE,
-};
-
-/*
- * First four bits must match between bio->bi_rw and rq->cmd_flags, make
- * that explicit here.
- */
-#define BIO_RW_RQ_MASK          0xf
-
-static inline bool bio_rw_flagged(struct bio *bio, enum bio_rw_flags flag)
-{
-        return (bio->bi_rw & (1 << flag)) != 0;
-}
-
-/*
  * upper 16 bits of bi_rw define the io priority of this bio
  */
 #define BIO_PRIO_SHIFT  (8 * sizeof(unsigned long) - IOPRIO_BITS)
@@ -211,7 +66,10 @@ static inline bool bio_rw_flagged(struct bio *bio, enum bio_rw_flags flag)
 #define bio_offset(bio)         bio_iovec((bio))->bv_offset
 #define bio_segments(bio)       ((bio)->bi_vcnt - (bio)->bi_idx)
 #define bio_sectors(bio)        ((bio)->bi_size >> 9)
-#define bio_empty_barrier(bio)  (bio_rw_flagged(bio, BIO_RW_BARRIER) && !bio_has_data(bio) && !bio_rw_flagged(bio, BIO_RW_DISCARD))
+#define bio_empty_barrier(bio) \
+        ((bio->bi_rw & REQ_HARDBARRIER) && \
+         !bio_has_data(bio) && \
+         !(bio->bi_rw & REQ_DISCARD))
 
 static inline unsigned int bio_cur_bytes(struct bio *bio)
 {
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
new file mode 100644
index 000000000000..53691774d34e
--- /dev/null
+++ b/include/linux/blk_types.h
@@ -0,0 +1,194 @@
+/*
+ * Block data types and constants.  Directly include this file only to
+ * break include dependency loop.
+ */
+#ifndef __LINUX_BLK_TYPES_H
+#define __LINUX_BLK_TYPES_H
+
+#ifdef CONFIG_BLOCK
+
+#include <linux/types.h>
+
+struct bio_set;
+struct bio;
+struct bio_integrity_payload;
+struct page;
+struct block_device;
+typedef void (bio_end_io_t) (struct bio *, int);
+typedef void (bio_destructor_t) (struct bio *);
+
+/*
+ * was unsigned short, but we might as well be ready for > 64kB I/O pages
+ */
+struct bio_vec {
+        struct page     *bv_page;
+        unsigned int    bv_len;
+        unsigned int    bv_offset;
+};
+
+/*
+ * main unit of I/O for the block layer and lower layers (ie drivers and
+ * stacking drivers)
+ */
+struct bio {
+        sector_t                bi_sector;      /* device address in 512 byte
+                                                   sectors */
+        struct bio              *bi_next;       /* request queue link */
+        struct block_device     *bi_bdev;
+        unsigned long           bi_flags;       /* status, command, etc */
+        unsigned long           bi_rw;          /* bottom bits READ/WRITE,
+                                                 * top bits priority
+                                                 */
+
+        unsigned short          bi_vcnt;        /* how many bio_vec's */
+        unsigned short          bi_idx;         /* current index into bvl_vec */
+
+        /* Number of segments in this BIO after
+         * physical address coalescing is performed.
+         */
+        unsigned int            bi_phys_segments;
+
+        unsigned int            bi_size;        /* residual I/O count */
+
+        /*
+         * To keep track of the max segment size, we account for the
+         * sizes of the first and last mergeable segments in this bio.
+         */
+        unsigned int            bi_seg_front_size;
+        unsigned int            bi_seg_back_size;
+
+        unsigned int            bi_max_vecs;    /* max bvl_vecs we can hold */
+
+        unsigned int            bi_comp_cpu;    /* completion CPU */
+
+        atomic_t                bi_cnt;         /* pin count */
+
+        struct bio_vec          *bi_io_vec;     /* the actual vec list */
+
+        bio_end_io_t            *bi_end_io;
+
+        void                    *bi_private;
+#if defined(CONFIG_BLK_DEV_INTEGRITY)
+        struct bio_integrity_payload *bi_integrity;  /* data integrity */
+#endif
+
+        bio_destructor_t        *bi_destructor; /* destructor */
+
+        /*
+         * We can inline a number of vecs at the end of the bio, to avoid
+         * double allocations for a small number of bio_vecs. This member
+         * MUST obviously be kept at the very end of the bio.
+         */
+        struct bio_vec          bi_inline_vecs[0];
+};
+
+/*
+ * bio flags
+ */
+#define BIO_UPTODATE    0       /* ok after I/O completion */
+#define BIO_RW_BLOCK    1       /* RW_AHEAD set, and read/write would block */
+#define BIO_EOF         2       /* out-out-bounds error */
+#define BIO_SEG_VALID   3       /* bi_phys_segments valid */
+#define BIO_CLONED      4       /* doesn't own data */
+#define BIO_BOUNCED     5       /* bio is a bounce bio */
+#define BIO_USER_MAPPED 6       /* contains user pages */
+#define BIO_EOPNOTSUPP  7       /* not supported */
+#define BIO_CPU_AFFINE  8       /* complete bio on same CPU as submitted */
+#define BIO_NULL_MAPPED 9       /* contains invalid user pages */
+#define BIO_FS_INTEGRITY 10     /* fs owns integrity data, not block layer */
+#define BIO_QUIET       11      /* Make BIO Quiet */
+#define bio_flagged(bio, flag)  ((bio)->bi_flags & (1 << (flag)))
+
+/*
+ * top 4 bits of bio flags indicate the pool this bio came from
+ */
+#define BIO_POOL_BITS           (4)
+#define BIO_POOL_NONE           ((1UL << BIO_POOL_BITS) - 1)
+#define BIO_POOL_OFFSET         (BITS_PER_LONG - BIO_POOL_BITS)
+#define BIO_POOL_MASK           (1UL << BIO_POOL_OFFSET)
+#define BIO_POOL_IDX(bio)       ((bio)->bi_flags >> BIO_POOL_OFFSET)
+
+#endif /* CONFIG_BLOCK */
+
+/*
+ * Request flags.  For use in the cmd_flags field of struct request, and in
+ * bi_rw of struct bio.  Note that some flags are only valid in either one.
+ */
+enum rq_flag_bits {
+        /* common flags */
+        __REQ_WRITE,            /* not set, read. set, write */
+        __REQ_FAILFAST_DEV,     /* no driver retries of device errors */
+        __REQ_FAILFAST_TRANSPORT, /* no driver retries of transport errors */
+        __REQ_FAILFAST_DRIVER,  /* no driver retries of driver errors */
+
+        __REQ_HARDBARRIER,      /* may not be passed by drive either */
+        __REQ_SYNC,             /* request is sync (sync write or read) */
+        __REQ_META,             /* metadata io request */
+        __REQ_DISCARD,          /* request to discard sectors */
+        __REQ_NOIDLE,           /* don't anticipate more IO after this one */
+
+        /* bio only flags */
+        __REQ_UNPLUG,           /* unplug the immediately after submission */
+        __REQ_RAHEAD,           /* read ahead, can fail anytime */
+
+        /* request only flags */
+        __REQ_SORTED,           /* elevator knows about this request */
+        __REQ_SOFTBARRIER,      /* may not be passed by ioscheduler */
+        __REQ_FUA,              /* forced unit access */
+        __REQ_NOMERGE,          /* don't touch this for merging */
+        __REQ_STARTED,          /* drive already may have started this one */
+        __REQ_DONTPREP,         /* don't call prep for this one */
+        __REQ_QUEUED,           /* uses queueing */
+        __REQ_ELVPRIV,          /* elevator private data attached */
+        __REQ_FAILED,           /* set if the request failed */
+        __REQ_QUIET,            /* don't worry about errors */
+        __REQ_PREEMPT,          /* set for "ide_preempt" requests */
+        __REQ_ORDERED_COLOR,    /* is before or after barrier */
+        __REQ_ALLOCED,          /* request came from our alloc pool */
+        __REQ_COPY_USER,        /* contains copies of user pages */
+        __REQ_INTEGRITY,        /* integrity metadata has been remapped */
+        __REQ_FLUSH,            /* request for cache flush */
+        __REQ_IO_STAT,          /* account I/O stat */
+        __REQ_MIXED_MERGE,      /* merge of different types, fail separately */
+        __REQ_NR_BITS,          /* stops here */
+};
+
+#define REQ_WRITE               (1 << __REQ_WRITE)
+#define REQ_FAILFAST_DEV        (1 << __REQ_FAILFAST_DEV)
+#define REQ_FAILFAST_TRANSPORT  (1 << __REQ_FAILFAST_TRANSPORT)
+#define REQ_FAILFAST_DRIVER     (1 << __REQ_FAILFAST_DRIVER)
+#define REQ_HARDBARRIER         (1 << __REQ_HARDBARRIER)
+#define REQ_SYNC                (1 << __REQ_SYNC)
+#define REQ_META                (1 << __REQ_META)
+#define REQ_DISCARD             (1 << __REQ_DISCARD)
+#define REQ_NOIDLE              (1 << __REQ_NOIDLE)
+
+#define REQ_FAILFAST_MASK \
+        (REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER)
+#define REQ_COMMON_MASK \
+        (REQ_WRITE | REQ_FAILFAST_MASK | REQ_HARDBARRIER | REQ_SYNC | \
+         REQ_META| REQ_DISCARD | REQ_NOIDLE)
+
+#define REQ_UNPLUG              (1 << __REQ_UNPLUG)
+#define REQ_RAHEAD              (1 << __REQ_RAHEAD)
+
+#define REQ_SORTED              (1 << __REQ_SORTED)
+#define REQ_SOFTBARRIER         (1 << __REQ_SOFTBARRIER)
+#define REQ_FUA                 (1 << __REQ_FUA)
+#define REQ_NOMERGE             (1 << __REQ_NOMERGE)
+#define REQ_STARTED             (1 << __REQ_STARTED)
+#define REQ_DONTPREP            (1 << __REQ_DONTPREP)
+#define REQ_QUEUED              (1 << __REQ_QUEUED)
+#define REQ_ELVPRIV             (1 << __REQ_ELVPRIV)
+#define REQ_FAILED              (1 << __REQ_FAILED)
+#define REQ_QUIET               (1 << __REQ_QUIET)
+#define REQ_PREEMPT             (1 << __REQ_PREEMPT)
+#define REQ_ORDERED_COLOR       (1 << __REQ_ORDERED_COLOR)
+#define REQ_ALLOCED             (1 << __REQ_ALLOCED)
+#define REQ_COPY_USER           (1 << __REQ_COPY_USER)
+#define REQ_INTEGRITY           (1 << __REQ_INTEGRITY)
+#define REQ_FLUSH               (1 << __REQ_FLUSH)
+#define REQ_IO_STAT             (1 << __REQ_IO_STAT)
+#define REQ_MIXED_MERGE         (1 << __REQ_MIXED_MERGE)
+
+#endif /* __LINUX_BLK_TYPES_H */
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 09a840264d6f..89c855c5655c 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -60,7 +60,6 @@ enum rq_cmd_type_bits {
         REQ_TYPE_PM_RESUME,             /* resume request */
         REQ_TYPE_PM_SHUTDOWN,           /* shutdown request */
         REQ_TYPE_SPECIAL,               /* driver defined type */
-        REQ_TYPE_LINUX_BLOCK,           /* generic block layer message */
         /*
          * for ATA/ATAPI devices. this really doesn't belong here, ide should
          * use REQ_TYPE_SPECIAL and use rq->cmd[0] with the range of driver
@@ -70,84 +69,6 @@ enum rq_cmd_type_bits {
         REQ_TYPE_ATA_PC,
 };
 
-/*
- * For request of type REQ_TYPE_LINUX_BLOCK, rq->cmd[0] is the opcode being
- * sent down (similar to how REQ_TYPE_BLOCK_PC means that ->cmd[] holds a
- * SCSI cdb.
- *
- * 0x00 -> 0x3f are driver private, to be used for whatever purpose they need,
- * typically to differentiate REQ_TYPE_SPECIAL requests.
- *
- */
-enum {
-        REQ_LB_OP_EJECT = 0x40,         /* eject request */
-        REQ_LB_OP_FLUSH = 0x41,         /* flush request */
-};
-
-/*
- * request type modified bits. first four bits match BIO_RW* bits, important
- */
-enum rq_flag_bits {
-        __REQ_RW,               /* not set, read. set, write */
-        __REQ_FAILFAST_DEV,     /* no driver retries of device errors */
-        __REQ_FAILFAST_TRANSPORT, /* no driver retries of transport errors */
-        __REQ_FAILFAST_DRIVER,  /* no driver retries of driver errors */
-        /* above flags must match BIO_RW_* */
-        __REQ_DISCARD,          /* request to discard sectors */
-        __REQ_SORTED,           /* elevator knows about this request */
-        __REQ_SOFTBARRIER,      /* may not be passed by ioscheduler */
-        __REQ_HARDBARRIER,      /* may not be passed by drive either */
-        __REQ_FUA,              /* forced unit access */
-        __REQ_NOMERGE,          /* don't touch this for merging */
-        __REQ_STARTED,          /* drive already may have started this one */
-        __REQ_DONTPREP,         /* don't call prep for this one */
-        __REQ_QUEUED,           /* uses queueing */
-        __REQ_ELVPRIV,          /* elevator private data attached */
-        __REQ_FAILED,           /* set if the request failed */
-        __REQ_QUIET,            /* don't worry about errors */
-        __REQ_PREEMPT,          /* set for "ide_preempt" requests */
-        __REQ_ORDERED_COLOR,    /* is before or after barrier */
-        __REQ_RW_SYNC,          /* request is sync (sync write or read) */
-        __REQ_ALLOCED,          /* request came from our alloc pool */
-        __REQ_RW_META,          /* metadata io request */
-        __REQ_COPY_USER,        /* contains copies of user pages */
-        __REQ_INTEGRITY,        /* integrity metadata has been remapped */
-        __REQ_NOIDLE,           /* Don't anticipate more IO after this one */
-        __REQ_IO_STAT,          /* account I/O stat */
-        __REQ_MIXED_MERGE,      /* merge of different types, fail separately */
-        __REQ_NR_BITS,          /* stops here */
-};
-
-#define REQ_RW          (1 << __REQ_RW)
-#define REQ_FAILFAST_DEV        (1 << __REQ_FAILFAST_DEV)
-#define REQ_FAILFAST_TRANSPORT  (1 << __REQ_FAILFAST_TRANSPORT)
-#define REQ_FAILFAST_DRIVER     (1 << __REQ_FAILFAST_DRIVER)
-#define REQ_DISCARD     (1 << __REQ_DISCARD)
-#define REQ_SORTED      (1 << __REQ_SORTED)
-#define REQ_SOFTBARRIER (1 << __REQ_SOFTBARRIER)
-#define REQ_HARDBARRIER (1 << __REQ_HARDBARRIER)
-#define REQ_FUA         (1 << __REQ_FUA)
-#define REQ_NOMERGE     (1 << __REQ_NOMERGE)
-#define REQ_STARTED     (1 << __REQ_STARTED)
-#define REQ_DONTPREP    (1 << __REQ_DONTPREP)
-#define REQ_QUEUED      (1 << __REQ_QUEUED)
-#define REQ_ELVPRIV     (1 << __REQ_ELVPRIV)
-#define REQ_FAILED      (1 << __REQ_FAILED)
-#define REQ_QUIET       (1 << __REQ_QUIET)
-#define REQ_PREEMPT     (1 << __REQ_PREEMPT)
-#define REQ_ORDERED_COLOR       (1 << __REQ_ORDERED_COLOR)
-#define REQ_RW_SYNC     (1 << __REQ_RW_SYNC)
-#define REQ_ALLOCED     (1 << __REQ_ALLOCED)
-#define REQ_RW_META     (1 << __REQ_RW_META)
-#define REQ_COPY_USER   (1 << __REQ_COPY_USER)
-#define REQ_INTEGRITY   (1 << __REQ_INTEGRITY)
-#define REQ_NOIDLE      (1 << __REQ_NOIDLE)
-#define REQ_IO_STAT     (1 << __REQ_IO_STAT)
-#define REQ_MIXED_MERGE (1 << __REQ_MIXED_MERGE)
-
-#define REQ_FAILFAST_MASK       (REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | \
-                                 REQ_FAILFAST_DRIVER)
-
 #define BLK_MAX_CDB     16
 
 /*
@@ -264,6 +185,7 @@ struct request_pm_state
 typedef void (request_fn_proc) (struct request_queue *q);
 typedef int (make_request_fn) (struct request_queue *q, struct bio *bio);
 typedef int (prep_rq_fn) (struct request_queue *, struct request *);
+typedef void (unprep_rq_fn) (struct request_queue *, struct request *);
 typedef void (unplug_fn) (struct request_queue *);
 
 struct bio_vec;
@@ -275,7 +197,6 @@ struct bvec_merge_data {
 };
 typedef int (merge_bvec_fn) (struct request_queue *, struct bvec_merge_data *,
                              struct bio_vec *);
-typedef void (prepare_flush_fn) (struct request_queue *, struct request *);
 typedef void (softirq_done_fn)(struct request *);
 typedef int (dma_drain_needed_fn)(struct request *);
 typedef int (lld_busy_fn) (struct request_queue *q);
@@ -346,9 +267,9 @@ struct request_queue
         request_fn_proc         *request_fn;
         make_request_fn         *make_request_fn;
         prep_rq_fn              *prep_rq_fn;
+        unprep_rq_fn            *unprep_rq_fn;
         unplug_fn               *unplug_fn;
         merge_bvec_fn           *merge_bvec_fn;
-        prepare_flush_fn        *prepare_flush_fn;
         softirq_done_fn         *softirq_done_fn;
         rq_timed_out_fn         *rq_timed_out_fn;
         dma_drain_needed_fn     *dma_drain_needed;
@@ -467,11 +388,13 @@ struct request_queue
 #define QUEUE_FLAG_IO_STAT     15       /* do IO stats */
 #define QUEUE_FLAG_DISCARD     16       /* supports DISCARD */
 #define QUEUE_FLAG_NOXMERGES   17       /* No extended merges */
+#define QUEUE_FLAG_ADD_RANDOM  18       /* Contributes to random pool */
 
 #define QUEUE_FLAG_DEFAULT      ((1 << QUEUE_FLAG_IO_STAT) |            \
                                  (1 << QUEUE_FLAG_CLUSTER) |            \
                                  (1 << QUEUE_FLAG_STACKABLE)    |       \
-                                 (1 << QUEUE_FLAG_SAME_COMP))
+                                 (1 << QUEUE_FLAG_SAME_COMP)    |       \
+                                 (1 << QUEUE_FLAG_ADD_RANDOM))
 
 static inline int queue_is_locked(struct request_queue *q)
 {
@@ -596,38 +519,26 @@ enum {
         test_bit(QUEUE_FLAG_NOXMERGES, &(q)->queue_flags)
 #define blk_queue_nonrot(q)     test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
 #define blk_queue_io_stat(q)    test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags)
+#define blk_queue_add_random(q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags)
 #define blk_queue_flushing(q)   ((q)->ordseq)
 #define blk_queue_stackable(q)  \
         test_bit(QUEUE_FLAG_STACKABLE, &(q)->queue_flags)
 #define blk_queue_discard(q)    test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags)
 
-#define blk_fs_request(rq)      ((rq)->cmd_type == REQ_TYPE_FS)
-#define blk_pc_request(rq)      ((rq)->cmd_type == REQ_TYPE_BLOCK_PC)
-#define blk_special_request(rq) ((rq)->cmd_type == REQ_TYPE_SPECIAL)
-#define blk_sense_request(rq)   ((rq)->cmd_type == REQ_TYPE_SENSE)
-
-#define blk_failfast_dev(rq)    ((rq)->cmd_flags & REQ_FAILFAST_DEV)
-#define blk_failfast_transport(rq) ((rq)->cmd_flags & REQ_FAILFAST_TRANSPORT)
-#define blk_failfast_driver(rq) ((rq)->cmd_flags & REQ_FAILFAST_DRIVER)
-#define blk_noretry_request(rq) (blk_failfast_dev(rq) ||        \
-                                 blk_failfast_transport(rq) ||  \
-                                 blk_failfast_driver(rq))
-#define blk_rq_started(rq)      ((rq)->cmd_flags & REQ_STARTED)
-#define blk_rq_io_stat(rq)      ((rq)->cmd_flags & REQ_IO_STAT)
-#define blk_rq_quiet(rq)        ((rq)->cmd_flags & REQ_QUIET)
-
-#define blk_account_rq(rq)      (blk_rq_started(rq) && (blk_fs_request(rq) || blk_discard_rq(rq))) 
-
-#define blk_pm_suspend_request(rq)      ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND)
-#define blk_pm_resume_request(rq)       ((rq)->cmd_type == REQ_TYPE_PM_RESUME)
+#define blk_noretry_request(rq) \
+        ((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \
+                             REQ_FAILFAST_DRIVER))
+
+#define blk_account_rq(rq) \
+        (((rq)->cmd_flags & REQ_STARTED) && \
+         ((rq)->cmd_type == REQ_TYPE_FS || \
+          ((rq)->cmd_flags & REQ_DISCARD)))
+
 #define blk_pm_request(rq)      \
-        (blk_pm_suspend_request(rq) || blk_pm_resume_request(rq))
+        ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND || \
+         (rq)->cmd_type == REQ_TYPE_PM_RESUME)
 
 #define blk_rq_cpu_valid(rq)    ((rq)->cpu != -1)
-#define blk_sorted_rq(rq)       ((rq)->cmd_flags & REQ_SORTED)
-#define blk_barrier_rq(rq)      ((rq)->cmd_flags & REQ_HARDBARRIER)
-#define blk_fua_rq(rq)          ((rq)->cmd_flags & REQ_FUA)
-#define blk_discard_rq(rq)      ((rq)->cmd_flags & REQ_DISCARD)
 #define blk_bidi_rq(rq)         ((rq)->next_rq != NULL)
 /* rq->queuelist of dequeued request must be list_empty() */
 #define blk_queued_rq(rq)       (!list_empty(&(rq)->queuelist))
@@ -641,7 +552,7 @@ enum {
  */
 static inline bool rw_is_sync(unsigned int rw_flags)
 {
-        return !(rw_flags & REQ_RW) || (rw_flags & REQ_RW_SYNC);
+        return !(rw_flags & REQ_WRITE) || (rw_flags & REQ_SYNC);
 }
 
 static inline bool rq_is_sync(struct request *rq)
@@ -649,9 +560,6 @@ static inline bool rq_is_sync(struct request *rq)
         return rw_is_sync(rq->cmd_flags);
 }
 
-#define rq_is_meta(rq)          ((rq)->cmd_flags & REQ_RW_META)
-#define rq_noidle(rq)           ((rq)->cmd_flags & REQ_NOIDLE)
-
 static inline int blk_queue_full(struct request_queue *q, int sync)
 {
         if (sync)
@@ -684,7 +592,8 @@ static inline void blk_clear_queue_full(struct request_queue *q, int sync)
         (REQ_NOMERGE | REQ_STARTED | REQ_HARDBARRIER | REQ_SOFTBARRIER)
 #define rq_mergeable(rq)        \
         (!((rq)->cmd_flags & RQ_NOMERGE_FLAGS) && \
-         (blk_discard_rq(rq) || blk_fs_request((rq))))
+         (((rq)->cmd_flags & REQ_DISCARD) || \
+          (rq)->cmd_type == REQ_TYPE_FS))
 
 /*
  * q->prep_rq_fn return values
@@ -709,7 +618,7 @@ extern unsigned long blk_max_low_pfn, blk_max_pfn;
 #define BLK_BOUNCE_HIGH         -1ULL
 #endif
 #define BLK_BOUNCE_ANY          (-1ULL)
-#define BLK_BOUNCE_ISA          (ISA_DMA_THRESHOLD)
+#define BLK_BOUNCE_ISA          (DMA_BIT_MASK(24))
 
 /*
  * default timeout for SG_IO if none specified
@@ -781,6 +690,8 @@ extern struct request *blk_make_request(struct request_queue *, struct bio *,
                                         gfp_t);
 extern void blk_insert_request(struct request_queue *, struct request *, int, void *);
 extern void blk_requeue_request(struct request_queue *, struct request *);
+extern void blk_add_request_payload(struct request *rq, struct page *page,
+                unsigned int len);
 extern int blk_rq_check_limits(struct request_queue *q, struct request *rq);
 extern int blk_lld_busy(struct request_queue *q);
 extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
@@ -915,6 +826,7 @@ extern void blk_complete_request(struct request *);
 extern void __blk_complete_request(struct request *);
 extern void blk_abort_request(struct request *);
 extern void blk_abort_queue(struct request_queue *);
+extern void blk_unprep_request(struct request *);
 
 /*
  * Access functions for manipulating queue properties
@@ -959,6 +871,7 @@ extern int blk_queue_dma_drain(struct request_queue *q,
 extern void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn);
 extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
 extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
+extern void blk_queue_unprep_rq(struct request_queue *, unprep_rq_fn *ufn);
 extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *);
 extern void blk_queue_dma_alignment(struct request_queue *, int);
 extern void blk_queue_update_dma_alignment(struct request_queue *, int);
@@ -966,7 +879,7 @@ extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
 extern void blk_queue_rq_timed_out(struct request_queue *, rq_timed_out_fn *);
 extern void blk_queue_rq_timeout(struct request_queue *, unsigned int);
 extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
-extern int blk_queue_ordered(struct request_queue *, unsigned, prepare_flush_fn *);
+extern int blk_queue_ordered(struct request_queue *, unsigned);
 extern bool blk_do_ordered(struct request_queue *, struct request **);
 extern unsigned blk_ordered_cur_seq(struct request_queue *);
 extern unsigned blk_ordered_req_seq(struct request *);
@@ -1020,7 +933,7 @@ static inline int sb_issue_discard(struct super_block *sb,
 {
         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,
+        return blkdev_issue_discard(sb->s_bdev, block, nr_blocks, GFP_NOFS,
                                    BLKDEV_IFL_WAIT | BLKDEV_IFL_BARRIER);
 }
 
@@ -1333,7 +1246,6 @@ static inline int blk_integrity_rq(struct request *rq)
 struct block_device_operations {
         int (*open) (struct block_device *, fmode_t);
         int (*release) (struct gendisk *, fmode_t);
-        int (*locked_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
         int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
         int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
         int (*direct_access) (struct block_device *, sector_t,
diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
index 416bf62d6d46..3395cf7130f5 100644
--- a/include/linux/blktrace_api.h
+++ b/include/linux/blktrace_api.h
@@ -5,6 +5,7 @@
 #ifdef __KERNEL__
 #include <linux/blkdev.h>
 #include <linux/relay.h>
+#include <linux/compat.h>
 #endif
 
 /*
@@ -220,11 +221,26 @@ static inline int blk_trace_init_sysfs(struct device *dev)
 
 #endif /* CONFIG_BLK_DEV_IO_TRACE */
 
+#ifdef CONFIG_COMPAT
+
+struct compat_blk_user_trace_setup {
+        char name[32];
+        u16 act_mask;
+        u32 buf_size;
+        u32 buf_nr;
+        compat_u64 start_lba;
+        compat_u64 end_lba;
+        u32 pid;
+};
+#define BLKTRACESETUP32 _IOWR(0x12, 115, struct compat_blk_user_trace_setup)
+
+#endif
+
 #if defined(CONFIG_EVENT_TRACING) && defined(CONFIG_BLOCK)
 
 static inline int blk_cmd_buf_len(struct request *rq)
 {
-        return blk_pc_request(rq) ? rq->cmd_len * 3 : 1;
+        return (rq->cmd_type == REQ_TYPE_BLOCK_PC) ? rq->cmd_len * 3 : 1;
 }
 
 extern void blk_dump_cmd(char *buf, struct request *rq);
diff --git a/include/linux/coda_psdev.h b/include/linux/coda_psdev.h
index 8859e2ede9fe..284b520934a0 100644
--- a/include/linux/coda_psdev.h
+++ b/include/linux/coda_psdev.h
@@ -86,9 +86,9 @@ struct upc_req {
         wait_queue_head_t   uc_sleep;   /* process' wait queue */
 };
 
-#define REQ_ASYNC  0x1
-#define REQ_READ   0x2
-#define REQ_WRITE  0x4
-#define REQ_ABORT  0x8
+#define CODA_REQ_ASYNC  0x1
+#define CODA_REQ_READ   0x2
+#define CODA_REQ_WRITE  0x4
+#define CODA_REQ_ABORT  0x8
 
 #endif
diff --git a/include/linux/console_struct.h b/include/linux/console_struct.h
index 38fe59dc89ae..7f0c32908568 100644
--- a/include/linux/console_struct.h
+++ b/include/linux/console_struct.h
@@ -21,6 +21,8 @@ struct vt_struct;
 #define NPAR 16
 
 struct vc_data {
+        struct tty_port port;                   /* Upper level data */
+
         unsigned short  vc_num;                 /* Console number */
         unsigned int    vc_cols;                /* [#] Console size */
         unsigned int    vc_rows;
@@ -56,7 +58,6 @@ struct vc_data {
         /* VT terminal data */
         unsigned int    vc_state;               /* Escape sequence parser state */
         unsigned int    vc_npar,vc_par[NPAR];   /* Parameters of current escape sequence */
-        struct tty_struct *vc_tty;              /* TTY we are attached to */
         /* data for manual vt switching */
         struct vt_mode  vt_mode;
         struct pid      *vt_pid;
@@ -105,6 +106,7 @@ struct vc_data {
         struct vc_data **vc_display_fg;         /* [!] Ptr to var holding fg console for this display */
         unsigned long   vc_uni_pagedir;
         unsigned long   *vc_uni_pagedir_loc;  /* [!] Location of uni_pagedir variable for this console */
+        bool vc_panic_force_write; /* when oops/panic this VC can accept forced output/blanking */
         /* additional information is in vt_kern.h */
 };
 
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index 89b7e1a605b8..e0670a512056 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -142,6 +142,14 @@ static inline int dma_set_seg_boundary(struct device *dev, unsigned long mask)
                 return -EIO;
 }
 
+static inline int dma_get_cache_alignment(void)
+{
+#ifdef ARCH_DMA_MINALIGN
+        return ARCH_DMA_MINALIGN;
+#endif
+        return 1;
+}
+
 /* flags for the coherent memory api */
 #define DMA_MEMORY_MAP                  0x01
 #define DMA_MEMORY_IO                   0x02
diff --git a/include/linux/drbd.h b/include/linux/drbd.h
index b8d2516668aa..479ee3a1d901 100644
--- a/include/linux/drbd.h
+++ b/include/linux/drbd.h
@@ -53,7 +53,7 @@
 
 
 extern const char *drbd_buildtag(void);
-#define REL_VERSION "8.3.8"
+#define REL_VERSION "8.3.8.1"
 #define API_VERSION 88
 #define PRO_VERSION_MIN 86
 #define PRO_VERSION_MAX 94
diff --git a/include/linux/drbd_nl.h b/include/linux/drbd_nl.h
index ce77a746fc9d..5f042810a56c 100644
--- a/include/linux/drbd_nl.h
+++ b/include/linux/drbd_nl.h
@@ -78,10 +78,11 @@ 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_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)
+ * feature will be reimplemented differently with 8.3.9 */
         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/fb.h b/include/linux/fb.h
index 0c5659c41b01..f0268deca658 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -825,6 +825,10 @@ struct fb_tile_ops {
  */
 #define FBINFO_BE_MATH  0x100000
 
+/* report to the VT layer that this fb driver can accept forced console
+   output like oopses */
+#define FBINFO_CAN_FORCE_OUTPUT     0x200000
+
 struct fb_info {
         int node;
         int flags;
diff --git a/include/linux/fs.h b/include/linux/fs.h
index a8ccf85b8691..267d02630517 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -8,6 +8,7 @@
 
 #include <linux/limits.h>
 #include <linux/ioctl.h>
+#include <linux/blk_types.h>
 
 /*
  * It's silly to have NR_OPEN bigger than NR_FILE, but you can change
@@ -92,7 +93,7 @@ struct inodes_stat_t {
 #define FMODE_RANDOM            ((__force fmode_t)0x1000)
 
 /* File was opened by fanotify and shouldn't generate fanotify events */
-#define FMODE_NONOTIFY          ((__force fmode_t)16777216) /* 0x1000000 */
+#define FMODE_NONOTIFY          ((__force fmode_t)0x1000000)
 
 /*
  * The below are the various read and write types that we support. Some of
@@ -121,7 +122,7 @@ struct inodes_stat_t {
  *                      immediately wait on this read without caring about
  *                      unplugging.
  * READA                Used for read-ahead operations. Lower priority, and the
- *                       block layer could (in theory) choose to ignore this
+ *                      block layer could (in theory) choose to ignore this
  *                      request if it runs into resource problems.
  * WRITE                A normal async write. Device will be plugged.
  * SWRITE               Like WRITE, but a special case for ll_rw_block() that
@@ -140,7 +141,7 @@ struct inodes_stat_t {
  * SWRITE_SYNC
  * SWRITE_SYNC_PLUG     Like WRITE_SYNC/WRITE_SYNC_PLUG, but locks the buffer.
  *                      See SWRITE.
- * WRITE_BARRIER        Like WRITE, but tells the block layer that all
+ * WRITE_BARRIER        Like WRITE_SYNC, but tells the block layer that all
  *                      previously submitted writes must be safely on storage
  *                      before this one is started. Also guarantees that when
  *                      this write is complete, it itself is also safely on
@@ -148,29 +149,31 @@ struct inodes_stat_t {
  *                      of this IO.
  *
  */
-#define RW_MASK         1
-#define RWA_MASK        2
-#define READ 0
-#define WRITE 1
-#define READA 2         /* read-ahead  - don't block if no resources */
-#define SWRITE 3        /* for ll_rw_block() - wait for buffer lock */
-#define READ_SYNC       (READ | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG))
-#define READ_META       (READ | (1 << BIO_RW_META))
-#define WRITE_SYNC_PLUG (WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))
-#define WRITE_SYNC      (WRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))
-#define WRITE_ODIRECT_PLUG      (WRITE | (1 << BIO_RW_SYNCIO))
-#define WRITE_META      (WRITE | (1 << BIO_RW_META))
-#define SWRITE_SYNC_PLUG        \
-                        (SWRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))
-#define SWRITE_SYNC     (SWRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))
-#define WRITE_BARRIER   (WRITE | (1 << BIO_RW_BARRIER))
+#define RW_MASK                 REQ_WRITE
+#define RWA_MASK                REQ_RAHEAD
+
+#define READ                    0
+#define WRITE                   RW_MASK
+#define READA                   RWA_MASK
+#define SWRITE                  (WRITE | READA)
+
+#define READ_SYNC               (READ | REQ_SYNC | REQ_UNPLUG)
+#define READ_META               (READ | REQ_META)
+#define WRITE_SYNC_PLUG         (WRITE | REQ_SYNC | REQ_NOIDLE)
+#define WRITE_SYNC              (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_UNPLUG)
+#define WRITE_ODIRECT_PLUG      (WRITE | REQ_SYNC)
+#define WRITE_META              (WRITE | REQ_META)
+#define WRITE_BARRIER           (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_UNPLUG | \
+                                 REQ_HARDBARRIER)
+#define SWRITE_SYNC_PLUG        (SWRITE | REQ_SYNC | REQ_NOIDLE)
+#define SWRITE_SYNC             (SWRITE | REQ_SYNC | REQ_NOIDLE | REQ_UNPLUG)
 
 /*
  * These aren't really reads or writes, they pass down information about
  * parts of device that are now unused by the file system.
  */
-#define DISCARD_NOBARRIER (WRITE | (1 << BIO_RW_DISCARD))
-#define DISCARD_BARRIER (DISCARD_NOBARRIER | (1 << BIO_RW_BARRIER))
+#define DISCARD_NOBARRIER       (WRITE | REQ_DISCARD)
+#define DISCARD_BARRIER         (WRITE | REQ_DISCARD | REQ_HARDBARRIER)
 
 #define SEL_IN          1
 #define SEL_OUT         2
@@ -2196,7 +2199,6 @@ static inline void insert_inode_hash(struct inode *inode) {
 extern void file_move(struct file *f, struct list_head *list);
 extern void file_kill(struct file *f);
 #ifdef CONFIG_BLOCK
-struct bio;
 extern void submit_bio(int, struct bio *);
 extern int bdev_read_only(struct block_device *);
 #endif
@@ -2263,7 +2265,6 @@ static inline int xip_truncate_page(struct address_space *mapping, loff_t from)
 #endif
 
 #ifdef CONFIG_BLOCK
-struct bio;
 typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode,
                             loff_t file_offset);
 
diff --git a/include/linux/gpio_keys.h b/include/linux/gpio_keys.h
index cd0b3f30f48e..ce73a30113b4 100644
--- a/include/linux/gpio_keys.h
+++ b/include/linux/gpio_keys.h
@@ -17,6 +17,8 @@ struct gpio_keys_platform_data {
         struct gpio_keys_button *buttons;
         int nbuttons;
         unsigned int rep:1;             /* enable input subsystem auto repeat */
+        int (*enable)(struct device *dev);
+        void (*disable)(struct device *dev);
 };
 
 #endif
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 21067b418536..38dd4025aa4e 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -108,6 +108,7 @@ extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client,
  * @shutdown: Callback for device shutdown
  * @suspend: Callback for device suspend
  * @resume: Callback for device resume
+ * @alert: Alert callback, for example for the SMBus alert protocol
  * @command: Callback for bus-wide signaling (optional)
  * @driver: Device driver model driver
  * @id_table: List of I2C devices supported by this driver
@@ -233,6 +234,7 @@ static inline void i2c_set_clientdata(struct i2c_client *dev, void *data)
  * @addr: stored in i2c_client.addr
  * @platform_data: stored in i2c_client.dev.platform_data
  * @archdata: copied into i2c_client.dev.archdata
+ * @of_node: pointer to OpenFirmware device node
  * @irq: stored in i2c_client.irq
  *
  * I2C doesn't actually support hardware probing, although controllers and
diff --git a/include/linux/i2c/sx150x.h b/include/linux/i2c/sx150x.h
new file mode 100644
index 000000000000..ee3049cb9ba5
--- /dev/null
+++ b/include/linux/i2c/sx150x.h
@@ -0,0 +1,78 @@
+/*
+ * Driver for the Semtech SX150x I2C GPIO Expanders
+ *
+ * Copyright (c) 2010, Code Aurora Forum. 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 version 2 and
+ * only 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., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+#ifndef __LINUX_I2C_SX150X_H
+#define __LINUX_I2C_SX150X_H
+
+/**
+ * struct sx150x_platform_data - config data for SX150x driver
+ * @gpio_base: The index number of the first GPIO assigned to this
+ *             GPIO expander.  The expander will create a block of
+ *             consecutively numbered gpios beginning at the given base,
+ *             with the size of the block depending on the model of the
+ *             expander chip.
+ * @oscio_is_gpo: If set to true, the driver will configure OSCIO as a GPO
+ *                instead of as an oscillator, increasing the size of the
+ *                GP(I)O pool created by this expander by one.  The
+ *                output-only GPO pin will be added at the end of the block.
+ * @io_pullup_ena: A bit-mask which enables or disables the pull-up resistor
+ *                 for each IO line in the expander.  Setting the bit at
+ *                 position n will enable the pull-up for the IO at
+ *                 the corresponding offset.  For chips with fewer than
+ *                 16 IO pins, high-end bits are ignored.
+ * @io_pulldn_ena: A bit-mask which enables-or disables the pull-down
+ *                 resistor for each IO line in the expander. Setting the
+ *                 bit at position n will enable the pull-down for the IO at
+ *                 the corresponding offset.  For chips with fewer than
+ *                 16 IO pins, high-end bits are ignored.
+ * @io_open_drain_ena: A bit-mask which enables-or disables open-drain
+ *                     operation for each IO line in the expander. Setting the
+ *                     bit at position n enables open-drain operation for
+ *                     the IO at the corresponding offset.  Clearing the bit
+ *                     enables regular push-pull operation for that IO.
+ *                     For chips with fewer than 16 IO pins, high-end bits
+ *                     are ignored.
+ * @io_polarity: A bit-mask which enables polarity inversion for each IO line
+ *               in the expander.  Setting the bit at position n inverts
+ *               the polarity of that IO line, while clearing it results
+ *               in normal polarity. For chips with fewer than 16 IO pins,
+ *               high-end bits are ignored.
+ * @irq_summary: The 'summary IRQ' line to which the GPIO expander's INT line
+ *               is connected, via which it reports interrupt events
+ *               across all GPIO lines.  This must be a real,
+ *               pre-existing IRQ line.
+ *               Setting this value < 0 disables the irq_chip functionality
+ *               of the driver.
+ * @irq_base: The first 'virtual IRQ' line at which our block of GPIO-based
+ *            IRQ lines will appear.  Similarly to gpio_base, the expander
+ *            will create a block of irqs beginning at this number.
+ *            This value is ignored if irq_summary is < 0.
+ */
+struct sx150x_platform_data {
+        unsigned gpio_base;
+        bool     oscio_is_gpo;
+        u16      io_pullup_ena;
+        u16      io_pulldn_ena;
+        u16      io_open_drain_ena;
+        u16      io_polarity;
+        int      irq_summary;
+        unsigned irq_base;
+};
+
+#endif /* __LINUX_I2C_SX150X_H */
diff --git a/include/linux/input.h b/include/linux/input.h
index 339d043ccb53..896a92227bc4 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -776,6 +776,7 @@ struct input_absinfo {
 #define REP_DELAY               0x00
 #define REP_PERIOD              0x01
 #define REP_MAX                 0x01
+#define REP_CNT                 (REP_MAX+1)
 
 /*
  * Sounds
@@ -1099,21 +1100,18 @@ struct input_mt_slot {
  * @repeat_key: stores key code of the last key pressed; used to implement
  *      software autorepeat
  * @timer: timer for software autorepeat
- * @abs: current values for reports from absolute axes
  * @rep: current values for autorepeat parameters (delay, rate)
  * @mt: pointer to array of struct input_mt_slot holding current values
  *      of tracked contacts
  * @mtsize: number of MT slots the device uses
  * @slot: MT slot currently being transmitted
+ * @absinfo: array of &struct absinfo elements holding information
+ *      about absolute axes (current value, min, max, flat, fuzz,
+ *      resolution)
  * @key: reflects current state of device's keys/buttons
  * @led: reflects current state of device's LEDs
  * @snd: reflects current state of sound effects
  * @sw: reflects current state of device's switches
- * @absmax: maximum values for events coming from absolute axes
- * @absmin: minimum values for events coming from absolute axes
- * @absfuzz: describes noisiness for axes
- * @absflat: size of the center flat position (used by joydev)
- * @absres: resolution used for events coming form absolute axes
  * @open: this method is called when the very first user calls
  *      input_open_device(). The driver must prepare the device
  *      to start generating events (start polling thread,
@@ -1180,24 +1178,19 @@ struct input_dev {
         unsigned int repeat_key;
         struct timer_list timer;
 
-        int abs[ABS_CNT];
-        int rep[REP_MAX + 1];
+        int rep[REP_CNT];
 
         struct input_mt_slot *mt;
         int mtsize;
         int slot;
 
+        struct input_absinfo *absinfo;
+
         unsigned long key[BITS_TO_LONGS(KEY_CNT)];
         unsigned long led[BITS_TO_LONGS(LED_CNT)];
         unsigned long snd[BITS_TO_LONGS(SND_CNT)];
         unsigned long sw[BITS_TO_LONGS(SW_CNT)];
 
-        int absmax[ABS_CNT];
-        int absmin[ABS_CNT];
-        int absfuzz[ABS_CNT];
-        int absflat[ABS_CNT];
-        int absres[ABS_CNT];
-
         int (*open)(struct input_dev *dev);
         void (*close)(struct input_dev *dev);
         int (*flush)(struct input_dev *dev, struct file *file);
@@ -1459,16 +1452,32 @@ static inline void input_set_events_per_packet(struct input_dev *dev, int n_even
         dev->hint_events_per_packet = n_events;
 }
 
-static inline void input_set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat)
-{
-        dev->absmin[axis] = min;
-        dev->absmax[axis] = max;
-        dev->absfuzz[axis] = fuzz;
-        dev->absflat[axis] = flat;
-
-        dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);
+void input_alloc_absinfo(struct input_dev *dev);
+void input_set_abs_params(struct input_dev *dev, unsigned int axis,
+                          int min, int max, int fuzz, int flat);
+
+#define INPUT_GENERATE_ABS_ACCESSORS(_suffix, _item)                    \
+static inline int input_abs_get_##_suffix(struct input_dev *dev,        \
+                                          unsigned int axis)            \
+{                                                                       \
+        return dev->absinfo ? dev->absinfo[axis]._item : 0;             \
+}                                                                       \
+                                                                        \
+static inline void input_abs_set_##_suffix(struct input_dev *dev,       \
+                                           unsigned int axis, int val)  \
+{                                                                       \
+        input_alloc_absinfo(dev);                                       \
+        if (dev->absinfo)                                               \
+                dev->absinfo[axis]._item = val;                         \
 }
 
+INPUT_GENERATE_ABS_ACCESSORS(val, value)
+INPUT_GENERATE_ABS_ACCESSORS(min, minimum)
+INPUT_GENERATE_ABS_ACCESSORS(max, maximum)
+INPUT_GENERATE_ABS_ACCESSORS(fuzz, fuzz)
+INPUT_GENERATE_ABS_ACCESSORS(flat, flat)
+INPUT_GENERATE_ABS_ACCESSORS(res, resolution)
+
 int input_get_keycode(struct input_dev *dev,
                       unsigned int scancode, unsigned int *keycode);
 int input_set_keycode(struct input_dev *dev,
diff --git a/include/linux/istallion.h b/include/linux/istallion.h
index 7faca98c7d14..ad700a60c158 100644
--- a/include/linux/istallion.h
+++ b/include/linux/istallion.h
@@ -86,7 +86,7 @@ struct stlibrd {
         unsigned long   magic;
         unsigned int    brdnr;
         unsigned int    brdtype;
-        unsigned int    state;
+        unsigned long   state;
         unsigned int    nrpanels;
         unsigned int    nrports;
         unsigned int    nrdevs;
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 5b57236dfbd0..d848cb854655 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -177,11 +177,12 @@ struct va_format {
 };
 
 extern struct atomic_notifier_head panic_notifier_list;
-extern long (*panic_blink)(long time);
+extern long (*panic_blink)(int state);
 NORET_TYPE void panic(const char * fmt, ...)
         __attribute__ ((NORET_AND format (printf, 1, 2))) __cold;
 extern void oops_enter(void);
 extern void oops_exit(void);
+void print_oops_end_marker(void);
 extern int oops_may_print(void);
 NORET_TYPE void do_exit(long error_code)
         ATTRIB_NORET;
diff --git a/include/linux/kfifo.h b/include/linux/kfifo.h
index 9fad0527344f..311f8753d713 100644
--- a/include/linux/kfifo.h
+++ b/include/linux/kfifo.h
@@ -1,8 +1,7 @@
 /*
- * A generic kernel FIFO implementation.
+ * A generic kernel FIFO implementation
  *
- * Copyright (C) 2009 Stefani Seibold <stefani@seibold.net>
- * Copyright (C) 2004 Stelian Pop <stelian@popies.net>
+ * Copyright (C) 2009/2010 Stefani Seibold <stefani@seibold.net>
  *
  * 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
@@ -20,8 +19,11 @@
  *
  */
 
+#ifndef _LINUX_KFIFO_H
+#define _LINUX_KFIFO_H
+
 /*
- * Howto porting drivers to the new generic fifo API:
+ * How to porting drivers to the new generic FIFO API:
  *
  * - Modify the declaration of the "struct kfifo *" object into a
  *   in-place "struct kfifo" object
@@ -30,586 +32,813 @@
  *   passed as the first argument to this functions
  * - Replace the use of __kfifo_put into kfifo_in and __kfifo_get
  *   into kfifo_out
- * - Replace the use of kfifo_put into kfifo_in_locked and kfifo_get
- *   into kfifo_out_locked
+ * - Replace the use of kfifo_put into kfifo_in_spinlocked and kfifo_get
+ *   into kfifo_out_spinlocked
  *   Note: the spinlock pointer formerly passed to kfifo_init/kfifo_alloc
- *   must be passed now to the kfifo_in_locked and kfifo_out_locked
- *   as the last parameter.
- * - All formerly name __kfifo_* functions has been renamed into kfifo_*
+ *   must be passed now to the kfifo_in_spinlocked and kfifo_out_spinlocked
+ *   as the last parameter
+ * - The formerly __kfifo_* functions are renamed into kfifo_*
  */
 
-#ifndef _LINUX_KFIFO_H
-#define _LINUX_KFIFO_H
+/*
+ * Note about locking : There is no locking required until only * one reader
+ * and one writer is using the fifo and no kfifo_reset() will be * called
+ *  kfifo_reset_out() can be safely used, until it will be only called
+ * in the reader thread.
+ *  For multiple writer and one reader there is only a need to lock the writer.
+ * And vice versa for only one writer and multiple reader there is only a need
+ * to lock the reader.
+ */
 
 #include <linux/kernel.h>
 #include <linux/spinlock.h>
-
-struct kfifo {
-        unsigned char *buffer;  /* the buffer holding the data */
-        unsigned int size;      /* the size of the allocated buffer */
-        unsigned int in;        /* data is added at offset (in % size) */
-        unsigned int out;       /* data is extracted from off. (out % size) */
+#include <linux/stddef.h>
+#include <linux/scatterlist.h>
+
+struct __kfifo {
+        unsigned int    in;
+        unsigned int    out;
+        unsigned int    mask;
+        unsigned int    esize;
+        void            *data;
 };
 
-/*
- * Macros for declaration and initialization of the kfifo datatype
- */
-
-/* helper macro */
-#define __kfifo_initializer(s, b) \
-        (struct kfifo) { \
-                .size   = s, \
-                .in     = 0, \
-                .out    = 0, \
-                .buffer = b \
+#define __STRUCT_KFIFO_COMMON(datatype, recsize, ptrtype) \
+        union { \
+                struct __kfifo  kfifo; \
+                datatype        *type; \
+                char            (*rectype)[recsize]; \
+                ptrtype         *ptr; \
+                const ptrtype   *ptr_const; \
         }
 
-/**
- * DECLARE_KFIFO - macro to declare a kfifo and the associated buffer
- * @name: name of the declared kfifo datatype
- * @size: size of the fifo buffer. Must be a power of two.
- *
- * Note1: the macro can be used inside struct or union declaration
- * Note2: the macro creates two objects:
- *  A kfifo object with the given name and a buffer for the kfifo
- *  object named name##kfifo_buffer
- */
-#define DECLARE_KFIFO(name, size) \
-union { \
-        struct kfifo name; \
-        unsigned char name##kfifo_buffer[size + sizeof(struct kfifo)]; \
+#define __STRUCT_KFIFO(type, size, recsize, ptrtype) \
+{ \
+        __STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \
+        type            buf[((size < 2) || (size & (size - 1))) ? -1 : size]; \
 }
 
-/**
- * INIT_KFIFO - Initialize a kfifo declared by DECLARE_KFIFO
- * @name: name of the declared kfifo datatype
+#define STRUCT_KFIFO(type, size) \
+        struct __STRUCT_KFIFO(type, size, 0, type)
+
+#define __STRUCT_KFIFO_PTR(type, recsize, ptrtype) \
+{ \
+        __STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \
+        type            buf[0]; \
+}
+
+#define STRUCT_KFIFO_PTR(type) \
+        struct __STRUCT_KFIFO_PTR(type, 0, type)
+
+/*
+ * define compatibility "struct kfifo" for dynamic allocated fifos
  */
-#define INIT_KFIFO(name) \
-        name = __kfifo_initializer(sizeof(name##kfifo_buffer) - \
-                                sizeof(struct kfifo), \
-                                name##kfifo_buffer + sizeof(struct kfifo))
+struct kfifo __STRUCT_KFIFO_PTR(unsigned char, 0, void);
 
-/**
- * DEFINE_KFIFO - macro to define and initialize a kfifo
- * @name: name of the declared kfifo datatype
- * @size: size of the fifo buffer. Must be a power of two.
- *
- * Note1: the macro can be used for global and local kfifo data type variables
- * Note2: the macro creates two objects:
- *  A kfifo object with the given name and a buffer for the kfifo
- *  object named name##kfifo_buffer
+#define STRUCT_KFIFO_REC_1(size) \
+        struct __STRUCT_KFIFO(unsigned char, size, 1, void)
+
+#define STRUCT_KFIFO_REC_2(size) \
+        struct __STRUCT_KFIFO(unsigned char, size, 2, void)
+
+/*
+ * define kfifo_rec types
  */
-#define DEFINE_KFIFO(name, size) \
-        unsigned char name##kfifo_buffer[size]; \
-        struct kfifo name = __kfifo_initializer(size, name##kfifo_buffer)
+struct kfifo_rec_ptr_1 __STRUCT_KFIFO_PTR(unsigned char, 1, void);
+struct kfifo_rec_ptr_2 __STRUCT_KFIFO_PTR(unsigned char, 2, void);
 
-extern void kfifo_init(struct kfifo *fifo, void *buffer,
-                        unsigned int size);
-extern __must_check int kfifo_alloc(struct kfifo *fifo, unsigned int size,
-                        gfp_t gfp_mask);
-extern void kfifo_free(struct kfifo *fifo);
-extern unsigned int kfifo_in(struct kfifo *fifo,
-                                const void *from, unsigned int len);
-extern __must_check unsigned int kfifo_out(struct kfifo *fifo,
-                                void *to, unsigned int len);
-extern __must_check unsigned int kfifo_out_peek(struct kfifo *fifo,
-                                void *to, unsigned int len, unsigned offset);
+/*
+ * helper macro to distinguish between real in place fifo where the fifo
+ * array is a part of the structure and the fifo type where the array is
+ * outside of the fifo structure.
+ */
+#define __is_kfifo_ptr(fifo)    (sizeof(*fifo) == sizeof(struct __kfifo))
 
 /**
- * kfifo_initialized - Check if kfifo is initialized.
- * @fifo: fifo to check
- * Return %true if FIFO is initialized, otherwise %false.
- * Assumes the fifo was 0 before.
+ * DECLARE_KFIFO_PTR - macro to declare a fifo pointer object
+ * @fifo: name of the declared fifo
+ * @type: type of the fifo elements
  */
-static inline bool kfifo_initialized(struct kfifo *fifo)
-{
-        return fifo->buffer != NULL;
-}
+#define DECLARE_KFIFO_PTR(fifo, type)   STRUCT_KFIFO_PTR(type) fifo
 
 /**
- * kfifo_reset - removes the entire FIFO contents
- * @fifo: the fifo to be emptied.
+ * DECLARE_KFIFO - macro to declare a fifo object
+ * @fifo: name of the declared fifo
+ * @type: type of the fifo elements
+ * @size: the number of elements in the fifo, this must be a power of 2
  */
-static inline void kfifo_reset(struct kfifo *fifo)
-{
-        fifo->in = fifo->out = 0;
-}
+#define DECLARE_KFIFO(fifo, type, size) STRUCT_KFIFO(type, size) fifo
 
 /**
- * kfifo_reset_out - skip FIFO contents
- * @fifo: the fifo to be emptied.
- */
-static inline void kfifo_reset_out(struct kfifo *fifo)
-{
-        smp_mb();
-        fifo->out = fifo->in;
-}
+ * INIT_KFIFO - Initialize a fifo declared by DECLARE_KFIFO
+ * @fifo: name of the declared fifo datatype
+ */
+#define INIT_KFIFO(fifo) \
+(void)({ \
+        typeof(&(fifo)) __tmp = &(fifo); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        __kfifo->in = 0; \
+        __kfifo->out = 0; \
+        __kfifo->mask = __is_kfifo_ptr(__tmp) ? 0 : ARRAY_SIZE(__tmp->buf) - 1;\
+        __kfifo->esize = sizeof(*__tmp->buf); \
+        __kfifo->data = __is_kfifo_ptr(__tmp) ?  NULL : __tmp->buf; \
+})
 
 /**
- * kfifo_size - returns the size of the fifo in bytes
- * @fifo: the fifo to be used.
- */
-static inline __must_check unsigned int kfifo_size(struct kfifo *fifo)
+ * DEFINE_KFIFO - macro to define and initialize a fifo
+ * @fifo: name of the declared fifo datatype
+ * @type: type of the fifo elements
+ * @size: the number of elements in the fifo, this must be a power of 2
+ *
+ * Note: the macro can be used for global and local fifo data type variables.
+ */
+#define DEFINE_KFIFO(fifo, type, size) \
+        DECLARE_KFIFO(fifo, type, size) = \
+        (typeof(fifo)) { \
+                { \
+                        { \
+                        .in     = 0, \
+                        .out    = 0, \
+                        .mask   = __is_kfifo_ptr(&(fifo)) ? \
+                                  0 : \
+                                  ARRAY_SIZE((fifo).buf) - 1, \
+                        .esize  = sizeof(*(fifo).buf), \
+                        .data   = __is_kfifo_ptr(&(fifo)) ? \
+                                NULL : \
+                                (fifo).buf, \
+                        } \
+                } \
+        }
+
+
+static inline unsigned int __must_check
+__kfifo_must_check_helper(unsigned int val)
 {
-        return fifo->size;
+        return val;
 }
 
 /**
- * kfifo_len - returns the number of used bytes in the FIFO
- * @fifo: the fifo to be used.
+ * kfifo_initialized - Check if the fifo is initialized
+ * @fifo: address of the fifo to check
+ *
+ * Return %true if fifo is initialized, otherwise %false.
+ * Assumes the fifo was 0 before.
  */
-static inline unsigned int kfifo_len(struct kfifo *fifo)
-{
-        register unsigned int   out;
-
-        out = fifo->out;
-        smp_rmb();
-        return fifo->in - out;
-}
+#define kfifo_initialized(fifo) ((fifo)->kfifo.mask)
 
 /**
- * kfifo_is_empty - returns true if the fifo is empty
- * @fifo: the fifo to be used.
+ * kfifo_esize - returns the size of the element managed by the fifo
+ * @fifo: address of the fifo to be used
  */
-static inline __must_check int kfifo_is_empty(struct kfifo *fifo)
-{
-        return fifo->in == fifo->out;
-}
+#define kfifo_esize(fifo)       ((fifo)->kfifo.esize)
 
 /**
- * kfifo_is_full - returns true if the fifo is full
- * @fifo: the fifo to be used.
+ * kfifo_recsize - returns the size of the record length field
+ * @fifo: address of the fifo to be used
  */
-static inline __must_check int kfifo_is_full(struct kfifo *fifo)
-{
-        return kfifo_len(fifo) == kfifo_size(fifo);
-}
+#define kfifo_recsize(fifo)     (sizeof(*(fifo)->rectype))
 
 /**
- * kfifo_avail - returns the number of bytes available in the FIFO
- * @fifo: the fifo to be used.
+ * kfifo_size - returns the size of the fifo in elements
+ * @fifo: address of the fifo to be used
  */
-static inline __must_check unsigned int kfifo_avail(struct kfifo *fifo)
-{
-        return kfifo_size(fifo) - kfifo_len(fifo);
-}
+#define kfifo_size(fifo)        ((fifo)->kfifo.mask + 1)
 
 /**
- * kfifo_in_locked - puts some data into the FIFO using a spinlock for locking
- * @fifo: the fifo to be used.
- * @from: the data to be added.
- * @n: the length of the data to be added.
- * @lock: pointer to the spinlock to use for locking.
+ * kfifo_reset - removes the entire fifo content
+ * @fifo: address of the fifo to be used
  *
- * 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.
+ * Note: usage of kfifo_reset() is dangerous. It should be only called when the
+ * fifo is exclusived locked or when it is secured that no other thread is
+ * accessing the fifo.
  */
-static inline unsigned int kfifo_in_locked(struct kfifo *fifo,
-                const void *from, unsigned int n, spinlock_t *lock)
-{
-        unsigned long flags;
-        unsigned int ret;
-
-        spin_lock_irqsave(lock, flags);
-
-        ret = kfifo_in(fifo, from, n);
-
-        spin_unlock_irqrestore(lock, flags);
-
-        return ret;
-}
+#define kfifo_reset(fifo) \
+(void)({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        __tmp->kfifo.in = __tmp->kfifo.out = 0; \
+})
 
 /**
- * kfifo_out_locked - gets some data from the FIFO using a spinlock for locking
- * @fifo: the fifo to be used.
- * @to: where the data must be copied.
- * @n: the size of the destination buffer.
- * @lock: pointer to the spinlock to use for locking.
+ * kfifo_reset_out - skip fifo content
+ * @fifo: address of the fifo to be used
  *
- * 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,
-        void *to, unsigned int n, spinlock_t *lock)
-{
-        unsigned long flags;
-        unsigned int ret;
-
-        spin_lock_irqsave(lock, flags);
-
-        ret = kfifo_out(fifo, to, n);
-
-        spin_unlock_irqrestore(lock, flags);
-
-        return ret;
-}
-
-extern void kfifo_skip(struct kfifo *fifo, unsigned int len);
-
-extern __must_check int kfifo_from_user(struct kfifo *fifo,
-        const void __user *from, unsigned int n, unsigned *lenout);
-
-extern __must_check int kfifo_to_user(struct kfifo *fifo,
-        void __user *to, unsigned int n, unsigned *lenout);
-
-/*
- * __kfifo_add_out internal helper function for updating the out offset
+ * Note: The usage of kfifo_reset_out() is safe until it will be only called
+ * from the reader thread and there is only one concurrent reader. Otherwise
+ * it is dangerous and must be handled in the same way as kfifo_reset().
  */
-static inline void __kfifo_add_out(struct kfifo *fifo,
-                                unsigned int off)
-{
-        smp_mb();
-        fifo->out += off;
-}
+#define kfifo_reset_out(fifo)   \
+(void)({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        __tmp->kfifo.out = __tmp->kfifo.in; \
+})
 
-/*
- * __kfifo_add_in internal helper function for updating the in offset
+/**
+ * kfifo_len - returns the number of used elements in the fifo
+ * @fifo: address of the fifo to be used
  */
-static inline void __kfifo_add_in(struct kfifo *fifo,
-                                unsigned int off)
-{
-        smp_wmb();
-        fifo->in += off;
-}
+#define kfifo_len(fifo) \
+({ \
+        typeof(fifo + 1) __tmpl = (fifo); \
+        __tmpl->kfifo.in - __tmpl->kfifo.out; \
+})
 
-/*
- * __kfifo_off internal helper function for calculating the index of a
- * given offeset
+/**
+ * kfifo_is_empty - returns true if the fifo is empty
+ * @fifo: address of the fifo to be used
  */
-static inline unsigned int __kfifo_off(struct kfifo *fifo, unsigned int off)
-{
-        return off & (fifo->size - 1);
-}
+#define kfifo_is_empty(fifo) \
+({ \
+        typeof(fifo + 1) __tmpq = (fifo); \
+        __tmpq->kfifo.in == __tmpq->kfifo.out; \
+})
 
-/*
- * __kfifo_peek_n internal helper function for determinate the length of
- * the next record in the fifo
+/**
+ * kfifo_is_full - returns true if the fifo is full
+ * @fifo: address of the fifo to be used
  */
-static inline unsigned int __kfifo_peek_n(struct kfifo *fifo,
-                                unsigned int recsize)
-{
-#define __KFIFO_GET(fifo, off, shift) \
-        ((fifo)->buffer[__kfifo_off((fifo), (fifo)->out+(off))] << (shift))
+#define kfifo_is_full(fifo) \
+({ \
+        typeof(fifo + 1) __tmpq = (fifo); \
+        kfifo_len(__tmpq) > __tmpq->kfifo.mask; \
+})
 
-        unsigned int l;
+/**
+ * kfifo_avail - returns the number of unused elements in the fifo
+ * @fifo: address of the fifo to be used
+ */
+#define kfifo_avail(fifo) \
+__kfifo_must_check_helper( \
+({ \
+        typeof(fifo + 1) __tmpq = (fifo); \
+        const size_t __recsize = sizeof(*__tmpq->rectype); \
+        unsigned int __avail = kfifo_size(__tmpq) - kfifo_len(__tmpq); \
+        (__recsize) ? ((__avail <= __recsize) ? 0 : \
+        __kfifo_max_r(__avail - __recsize, __recsize)) : \
+        __avail; \
+}) \
+)
 
-        l = __KFIFO_GET(fifo, 0, 0);
+/**
+ * kfifo_skip - skip output data
+ * @fifo: address of the fifo to be used
+ */
+#define kfifo_skip(fifo) \
+(void)({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        const size_t __recsize = sizeof(*__tmp->rectype); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        if (__recsize) \
+                __kfifo_skip_r(__kfifo, __recsize); \
+        else \
+                __kfifo->out++; \
+})
 
-        if (--recsize)
-                l |= __KFIFO_GET(fifo, 1, 8);
+/**
+ * kfifo_peek_len - gets the size of the next fifo record
+ * @fifo: address of the fifo to be used
+ *
+ * This function returns the size of the next fifo record in number of bytes.
+ */
+#define kfifo_peek_len(fifo) \
+__kfifo_must_check_helper( \
+({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        const size_t __recsize = sizeof(*__tmp->rectype); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        (!__recsize) ? kfifo_len(__tmp) * sizeof(*__tmp->type) : \
+        __kfifo_len_r(__kfifo, __recsize); \
+}) \
+)
 
-        return l;
-#undef  __KFIFO_GET
-}
+/**
+ * kfifo_alloc - dynamically allocates a new fifo buffer
+ * @fifo: pointer to the fifo
+ * @size: the number of elements in the fifo, this must be a power of 2
+ * @gfp_mask: get_free_pages mask, passed to kmalloc()
+ *
+ * This macro dynamically allocates a new fifo buffer.
+ *
+ * The numer of elements will be rounded-up to a power of 2.
+ * The fifo will be release with kfifo_free().
+ * Return 0 if no error, otherwise an error code.
+ */
+#define kfifo_alloc(fifo, size, gfp_mask) \
+__kfifo_must_check_helper( \
+({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        __is_kfifo_ptr(__tmp) ? \
+        __kfifo_alloc(__kfifo, size, sizeof(*__tmp->type), gfp_mask) : \
+        -EINVAL; \
+}) \
+)
 
-/*
- * __kfifo_poke_n internal helper function for storing the length of
- * the next record into the fifo
+/**
+ * kfifo_free - frees the fifo
+ * @fifo: the fifo to be freed
  */
-static inline void __kfifo_poke_n(struct kfifo *fifo,
-                        unsigned int recsize, unsigned int n)
-{
-#define __KFIFO_PUT(fifo, off, val, shift) \
-                ( \
-                (fifo)->buffer[__kfifo_off((fifo), (fifo)->in+(off))] = \
-                (unsigned char)((val) >> (shift)) \
-                )
+#define kfifo_free(fifo) \
+({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        if (__is_kfifo_ptr(__tmp)) \
+                __kfifo_free(__kfifo); \
+})
 
-        __KFIFO_PUT(fifo, 0, n, 0);
+/**
+ * kfifo_init - initialize a fifo using a preallocated buffer
+ * @fifo: the fifo to assign the buffer
+ * @buffer: the preallocated buffer to be used
+ * @size: the size of the internal buffer, this have to be a power of 2
+ *
+ * This macro initialize a fifo using a preallocated buffer.
+ *
+ * The numer of elements will be rounded-up to a power of 2.
+ * Return 0 if no error, otherwise an error code.
+ */
+#define kfifo_init(fifo, buffer, size) \
+({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        __is_kfifo_ptr(__tmp) ? \
+        __kfifo_init(__kfifo, buffer, size, sizeof(*__tmp->type)) : \
+        -EINVAL; \
+})
 
-        if (--recsize)
-                __KFIFO_PUT(fifo, 1, n, 8);
-#undef  __KFIFO_PUT
-}
+/**
+ * kfifo_put - put data into the fifo
+ * @fifo: address of the fifo to be used
+ * @val: the data to be added
+ *
+ * This macro copies the given value into the fifo.
+ * It returns 0 if the fifo was full. Otherwise it returns the number
+ * processed elements.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macro.
+ */
+#define kfifo_put(fifo, val) \
+({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        typeof(val + 1) __val = (val); \
+        unsigned int __ret; \
+        const size_t __recsize = sizeof(*__tmp->rectype); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        if (0) { \
+                typeof(__tmp->ptr_const) __dummy __attribute__ ((unused)); \
+                __dummy = (typeof(__val))NULL; \
+        } \
+        if (__recsize) \
+                __ret = __kfifo_in_r(__kfifo, __val, sizeof(*__val), \
+                        __recsize); \
+        else { \
+                __ret = !kfifo_is_full(__tmp); \
+                if (__ret) { \
+                        (__is_kfifo_ptr(__tmp) ? \
+                        ((typeof(__tmp->type))__kfifo->data) : \
+                        (__tmp->buf) \
+                        )[__kfifo->in & __tmp->kfifo.mask] = \
+                                *(typeof(__tmp->type))__val; \
+                        smp_wmb(); \
+                        __kfifo->in++; \
+                } \
+        } \
+        __ret; \
+})
 
-/*
- * __kfifo_in_... internal functions for put date into the fifo
- * do not call it directly, use kfifo_in_rec() instead
- */
-extern unsigned int __kfifo_in_n(struct kfifo *fifo,
-        const void *from, unsigned int n, unsigned int recsize);
+/**
+ * kfifo_get - get data from the fifo
+ * @fifo: address of the fifo to be used
+ * @val: the var where to store the data to be added
+ *
+ * This macro reads the data from the fifo.
+ * It returns 0 if the fifo was empty. Otherwise it returns the number
+ * processed elements.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macro.
+ */
+#define kfifo_get(fifo, val) \
+__kfifo_must_check_helper( \
+({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        typeof(val + 1) __val = (val); \
+        unsigned int __ret; \
+        const size_t __recsize = sizeof(*__tmp->rectype); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        if (0) \
+                __val = (typeof(__tmp->ptr))0; \
+        if (__recsize) \
+                __ret = __kfifo_out_r(__kfifo, __val, sizeof(*__val), \
+                        __recsize); \
+        else { \
+                __ret = !kfifo_is_empty(__tmp); \
+                if (__ret) { \
+                        *(typeof(__tmp->type))__val = \
+                                (__is_kfifo_ptr(__tmp) ? \
+                                ((typeof(__tmp->type))__kfifo->data) : \
+                                (__tmp->buf) \
+                                )[__kfifo->out & __tmp->kfifo.mask]; \
+                        smp_wmb(); \
+                        __kfifo->out++; \
+                } \
+        } \
+        __ret; \
+}) \
+)
 
-extern unsigned int __kfifo_in_generic(struct kfifo *fifo,
-        const void *from, unsigned int n, unsigned int recsize);
+/**
+ * kfifo_peek - get data from the fifo without removing
+ * @fifo: address of the fifo to be used
+ * @val: the var where to store the data to be added
+ *
+ * This reads the data from the fifo without removing it from the fifo.
+ * It returns 0 if the fifo was empty. Otherwise it returns the number
+ * processed elements.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macro.
+ */
+#define kfifo_peek(fifo, val) \
+__kfifo_must_check_helper( \
+({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        typeof(val + 1) __val = (val); \
+        unsigned int __ret; \
+        const size_t __recsize = sizeof(*__tmp->rectype); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        if (0) \
+                __val = (typeof(__tmp->ptr))NULL; \
+        if (__recsize) \
+                __ret = __kfifo_out_peek_r(__kfifo, __val, sizeof(*__val), \
+                        __recsize); \
+        else { \
+                __ret = !kfifo_is_empty(__tmp); \
+                if (__ret) { \
+                        *(typeof(__tmp->type))__val = \
+                                (__is_kfifo_ptr(__tmp) ? \
+                                ((typeof(__tmp->type))__kfifo->data) : \
+                                (__tmp->buf) \
+                                )[__kfifo->out & __tmp->kfifo.mask]; \
+                        smp_wmb(); \
+                } \
+        } \
+        __ret; \
+}) \
+)
 
-static inline unsigned int __kfifo_in_rec(struct kfifo *fifo,
-        const void *from, unsigned int n, unsigned int recsize)
-{
-        unsigned int ret;
+/**
+ * kfifo_in - put data into the fifo
+ * @fifo: address of the fifo to be used
+ * @buf: the data to be added
+ * @n: number of elements to be added
+ *
+ * This macro copies the given buffer into the fifo and returns the
+ * number of copied elements.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macro.
+ */
+#define kfifo_in(fifo, buf, n) \
+({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        typeof(buf + 1) __buf = (buf); \
+        unsigned long __n = (n); \
+        const size_t __recsize = sizeof(*__tmp->rectype); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        if (0) { \
+                typeof(__tmp->ptr_const) __dummy __attribute__ ((unused)); \
+                __dummy = (typeof(__buf))NULL; \
+        } \
+        (__recsize) ?\
+        __kfifo_in_r(__kfifo, __buf, __n, __recsize) : \
+        __kfifo_in(__kfifo, __buf, __n); \
+})
 
-        ret = __kfifo_in_n(fifo, from, n, recsize);
+/**
+ * kfifo_in_spinlocked - put data into the fifo using a spinlock for locking
+ * @fifo: address of the fifo to be used
+ * @buf: the data to be added
+ * @n: number of elements to be added
+ * @lock: pointer to the spinlock to use for locking
+ *
+ * This macro copies the given values buffer into the fifo and returns the
+ * number of copied elements.
+ */
+#define kfifo_in_spinlocked(fifo, buf, n, lock) \
+({ \
+        unsigned long __flags; \
+        unsigned int __ret; \
+        spin_lock_irqsave(lock, __flags); \
+        __ret = kfifo_in(fifo, buf, n); \
+        spin_unlock_irqrestore(lock, __flags); \
+        __ret; \
+})
+
+/* alias for kfifo_in_spinlocked, will be removed in a future release */
+#define kfifo_in_locked(fifo, buf, n, lock) \
+                kfifo_in_spinlocked(fifo, buf, n, lock)
 
-        if (likely(ret == 0)) {
-                if (recsize)
-                        __kfifo_poke_n(fifo, recsize, n);
-                __kfifo_add_in(fifo, n + recsize);
-        }
-        return ret;
-}
+/**
+ * kfifo_out - get data from the fifo
+ * @fifo: address of the fifo to be used
+ * @buf: pointer to the storage buffer
+ * @n: max. number of elements to get
+ *
+ * This macro get some data from the fifo and return the numbers of elements
+ * copied.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macro.
+ */
+#define kfifo_out(fifo, buf, n) \
+__kfifo_must_check_helper( \
+({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        typeof(buf + 1) __buf = (buf); \
+        unsigned long __n = (n); \
+        const size_t __recsize = sizeof(*__tmp->rectype); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        if (0) { \
+                typeof(__tmp->ptr) __dummy = NULL; \
+                __buf = __dummy; \
+        } \
+        (__recsize) ?\
+        __kfifo_out_r(__kfifo, __buf, __n, __recsize) : \
+        __kfifo_out(__kfifo, __buf, __n); \
+}) \
+)
+
+/**
+ * kfifo_out_spinlocked - get data from the fifo using a spinlock for locking
+ * @fifo: address of the fifo to be used
+ * @buf: pointer to the storage buffer
+ * @n: max. number of elements to get
+ * @lock: pointer to the spinlock to use for locking
+ *
+ * This macro get the data from the fifo and return the numbers of elements
+ * copied.
+ */
+#define kfifo_out_spinlocked(fifo, buf, n, lock) \
+__kfifo_must_check_helper( \
+({ \
+        unsigned long __flags; \
+        unsigned int __ret; \
+        spin_lock_irqsave(lock, __flags); \
+        __ret = kfifo_out(fifo, buf, n); \
+        spin_unlock_irqrestore(lock, __flags); \
+        __ret; \
+}) \
+)
+
+/* alias for kfifo_out_spinlocked, will be removed in a future release */
+#define kfifo_out_locked(fifo, buf, n, lock) \
+                kfifo_out_spinlocked(fifo, buf, n, lock)
 
 /**
- * kfifo_in_rec - puts some record data into the FIFO
- * @fifo: the fifo to be used.
- * @from: the data to be added.
- * @n: the length of the data to be added.
- * @recsize: size of record field
+ * kfifo_from_user - puts some data from user space into the fifo
+ * @fifo: address of the fifo to be used
+ * @from: pointer to the data to be added
+ * @len: the length of the data to be added
+ * @copied: pointer to output variable to store the number of copied bytes
  *
- * This function copies @n bytes from the @from into the FIFO and returns
- * the number of bytes which cannot be copied.
- * A returned value greater than the @n value means that the record doesn't
- * fit into the buffer.
+ * This macro copies at most @len bytes from the @from into the
+ * fifo, depending of the available space and returns -EFAULT/0.
  *
  * Note that with only one concurrent reader and one concurrent
- * writer, you don't need extra locking to use these functions.
- */
-static inline __must_check unsigned int kfifo_in_rec(struct kfifo *fifo,
-        void *from, unsigned int n, unsigned int recsize)
-{
-        if (!__builtin_constant_p(recsize))
-                return __kfifo_in_generic(fifo, from, n, recsize);
-        return __kfifo_in_rec(fifo, from, n, recsize);
-}
+ * writer, you don't need extra locking to use these macro.
+ */
+#define kfifo_from_user(fifo, from, len, copied) \
+__kfifo_must_check_helper( \
+({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        const void __user *__from = (from); \
+        unsigned int __len = (len); \
+        unsigned int *__copied = (copied); \
+        const size_t __recsize = sizeof(*__tmp->rectype); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        (__recsize) ? \
+        __kfifo_from_user_r(__kfifo, __from, __len,  __copied, __recsize) : \
+        __kfifo_from_user(__kfifo, __from, __len, __copied); \
+}) \
+)
 
-/*
- * __kfifo_out_... internal functions for get date from the fifo
- * do not call it directly, use kfifo_out_rec() instead
- */
-extern unsigned int __kfifo_out_n(struct kfifo *fifo,
-        void *to, unsigned int reclen, unsigned int recsize);
+/**
+ * kfifo_to_user - copies data from the fifo into user space
+ * @fifo: address of the fifo to be used
+ * @to: where the data must be copied
+ * @len: the size of the destination buffer
+ * @copied: pointer to output variable to store the number of copied bytes
+ *
+ * This macro copies at most @len bytes from the fifo into the
+ * @to buffer and returns -EFAULT/0.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macro.
+ */
+#define kfifo_to_user(fifo, to, len, copied) \
+__kfifo_must_check_helper( \
+({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        void __user *__to = (to); \
+        unsigned int __len = (len); \
+        unsigned int *__copied = (copied); \
+        const size_t __recsize = sizeof(*__tmp->rectype); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        (__recsize) ? \
+        __kfifo_to_user_r(__kfifo, __to, __len, __copied, __recsize) : \
+        __kfifo_to_user(__kfifo, __to, __len, __copied); \
+}) \
+)
+
+/**
+ * kfifo_dma_in_prepare - setup a scatterlist for DMA input
+ * @fifo: address of the fifo to be used
+ * @sgl: pointer to the scatterlist array
+ * @nents: number of entries in the scatterlist array
+ * @len: number of elements to transfer
+ *
+ * This macro fills a scatterlist for DMA input.
+ * It returns the number entries in the scatterlist array.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macros.
+ */
+#define kfifo_dma_in_prepare(fifo, sgl, nents, len) \
+({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        struct scatterlist *__sgl = (sgl); \
+        int __nents = (nents); \
+        unsigned int __len = (len); \
+        const size_t __recsize = sizeof(*__tmp->rectype); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        (__recsize) ? \
+        __kfifo_dma_in_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \
+        __kfifo_dma_in_prepare(__kfifo, __sgl, __nents, __len); \
+})
 
-extern unsigned int __kfifo_out_generic(struct kfifo *fifo,
-        void *to, unsigned int n,
-        unsigned int recsize, unsigned int *total);
+/**
+ * kfifo_dma_in_finish - finish a DMA IN operation
+ * @fifo: address of the fifo to be used
+ * @len: number of bytes to received
+ *
+ * This macro finish a DMA IN operation. The in counter will be updated by
+ * the len parameter. No error checking will be done.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macros.
+ */
+#define kfifo_dma_in_finish(fifo, len) \
+(void)({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        unsigned int __len = (len); \
+        const size_t __recsize = sizeof(*__tmp->rectype); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        if (__recsize) \
+                __kfifo_dma_in_finish_r(__kfifo, __len, __recsize); \
+        else \
+                __kfifo->in += __len / sizeof(*__tmp->type); \
+})
 
-static inline unsigned int __kfifo_out_rec(struct kfifo *fifo,
-        void *to, unsigned int n, unsigned int recsize,
-        unsigned int *total)
-{
-        unsigned int l;
-
-        if (!recsize) {
-                l = n;
-                if (total)
-                        *total = l;
-        } else {
-                l = __kfifo_peek_n(fifo, recsize);
-                if (total)
-                        *total = l;
-                if (n < l)
-                        return l;
-        }
+/**
+ * kfifo_dma_out_prepare - setup a scatterlist for DMA output
+ * @fifo: address of the fifo to be used
+ * @sgl: pointer to the scatterlist array
+ * @nents: number of entries in the scatterlist array
+ * @len: number of elements to transfer
+ *
+ * This macro fills a scatterlist for DMA output which at most @len bytes
+ * to transfer.
+ * It returns the number entries in the scatterlist array.
+ * A zero means there is no space available and the scatterlist is not filled.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macros.
+ */
+#define kfifo_dma_out_prepare(fifo, sgl, nents, len) \
+({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        struct scatterlist *__sgl = (sgl); \
+        int __nents = (nents); \
+        unsigned int __len = (len); \
+        const size_t __recsize = sizeof(*__tmp->rectype); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        (__recsize) ? \
+        __kfifo_dma_out_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \
+        __kfifo_dma_out_prepare(__kfifo, __sgl, __nents, __len); \
+})
 
-        return __kfifo_out_n(fifo, to, l, recsize);
-}
+/**
+ * kfifo_dma_out_finish - finish a DMA OUT operation
+ * @fifo: address of the fifo to be used
+ * @len: number of bytes transferd
+ *
+ * This macro finish a DMA OUT operation. The out counter will be updated by
+ * the len parameter. No error checking will be done.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macros.
+ */
+#define kfifo_dma_out_finish(fifo, len) \
+(void)({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        unsigned int __len = (len); \
+        const size_t __recsize = sizeof(*__tmp->rectype); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        if (__recsize) \
+                __kfifo_dma_out_finish_r(__kfifo, __recsize); \
+        else \
+                __kfifo->out += __len / sizeof(*__tmp->type); \
+})
 
 /**
- * kfifo_out_rec - gets some record data from the FIFO
- * @fifo: the fifo to be used.
- * @to: where the data must be copied.
- * @n: the size of the destination buffer.
- * @recsize: size of record field
- * @total: pointer where the total number of to copied bytes should stored
+ * kfifo_out_peek - gets some data from the fifo
+ * @fifo: address of the fifo to be used
+ * @buf: pointer to the storage buffer
+ * @n: max. number of elements to get
  *
- * This function copies at most @n bytes from the FIFO to @to and returns the
- * number of bytes which cannot be copied.
- * A returned value greater than the @n value means that the record doesn't
- * fit into the @to buffer.
+ * This macro get the data from the fifo and return the numbers of elements
+ * copied. The data is not removed from the fifo.
  *
  * Note that with only one concurrent reader and one concurrent
- * writer, you don't need extra locking to use these functions.
+ * writer, you don't need extra locking to use these macro.
  */
-static inline __must_check unsigned int kfifo_out_rec(struct kfifo *fifo,
-        void *to, unsigned int n, unsigned int recsize,
-        unsigned int *total)
+#define kfifo_out_peek(fifo, buf, n) \
+__kfifo_must_check_helper( \
+({ \
+        typeof(fifo + 1) __tmp = (fifo); \
+        typeof(buf + 1) __buf = (buf); \
+        unsigned long __n = (n); \
+        const size_t __recsize = sizeof(*__tmp->rectype); \
+        struct __kfifo *__kfifo = &__tmp->kfifo; \
+        if (0) { \
+                typeof(__tmp->ptr) __dummy __attribute__ ((unused)) = NULL; \
+                __buf = __dummy; \
+        } \
+        (__recsize) ? \
+        __kfifo_out_peek_r(__kfifo, __buf, __n, __recsize) : \
+        __kfifo_out_peek(__kfifo, __buf, __n); \
+}) \
+)
 
-{
-        if (!__builtin_constant_p(recsize))
-                return __kfifo_out_generic(fifo, to, n, recsize, total);
-        return __kfifo_out_rec(fifo, to, n, recsize, total);
-}
+extern int __kfifo_alloc(struct __kfifo *fifo, unsigned int size,
+        size_t esize, gfp_t gfp_mask);
 
-/*
- * __kfifo_from_user_... internal functions for transfer from user space into
- * the fifo. do not call it directly, use kfifo_from_user_rec() instead
- */
-extern unsigned int __kfifo_from_user_n(struct kfifo *fifo,
-        const void __user *from, unsigned int n, unsigned int recsize);
+extern void __kfifo_free(struct __kfifo *fifo);
 
-extern unsigned int __kfifo_from_user_generic(struct kfifo *fifo,
-        const void __user *from, unsigned int n, unsigned int recsize);
+extern int __kfifo_init(struct __kfifo *fifo, void *buffer,
+        unsigned int size, size_t esize);
 
-static inline unsigned int __kfifo_from_user_rec(struct kfifo *fifo,
-        const void __user *from, unsigned int n, unsigned int recsize)
-{
-        unsigned int ret;
+extern unsigned int __kfifo_in(struct __kfifo *fifo,
+        const void *buf, unsigned int len);
 
-        ret = __kfifo_from_user_n(fifo, from, n, recsize);
+extern unsigned int __kfifo_out(struct __kfifo *fifo,
+        void *buf, unsigned int len);
 
-        if (likely(ret == 0)) {
-                if (recsize)
-                        __kfifo_poke_n(fifo, recsize, n);
-                __kfifo_add_in(fifo, n + recsize);
-        }
-        return ret;
-}
+extern int __kfifo_from_user(struct __kfifo *fifo,
+        const void __user *from, unsigned long len, unsigned int *copied);
 
-/**
- * kfifo_from_user_rec - puts some data from user space into the FIFO
- * @fifo: the fifo to be used.
- * @from: pointer to the data to be added.
- * @n: the length of the data to be added.
- * @recsize: size of record field
- *
- * This function copies @n bytes from the @from into the
- * FIFO and returns the number of bytes which cannot be copied.
- *
- * If the returned value is equal or less the @n value, the copy_from_user()
- * functions has failed. Otherwise the record doesn't fit into the buffer.
- *
- * Note that with only one concurrent reader and one concurrent
- * writer, you don't need extra locking to use these functions.
- */
-static inline __must_check unsigned int kfifo_from_user_rec(struct kfifo *fifo,
-        const void __user *from, unsigned int n, unsigned int recsize)
-{
-        if (!__builtin_constant_p(recsize))
-                return __kfifo_from_user_generic(fifo, from, n, recsize);
-        return __kfifo_from_user_rec(fifo, from, n, recsize);
-}
+extern int __kfifo_to_user(struct __kfifo *fifo,
+        void __user *to, unsigned long len, unsigned int *copied);
 
-/*
- * __kfifo_to_user_... internal functions for transfer fifo data into user space
- * do not call it directly, use kfifo_to_user_rec() instead
- */
-extern unsigned int __kfifo_to_user_n(struct kfifo *fifo,
-        void __user *to, unsigned int n, unsigned int reclen,
-        unsigned int recsize);
+extern unsigned int __kfifo_dma_in_prepare(struct __kfifo *fifo,
+        struct scatterlist *sgl, int nents, unsigned int len);
 
-extern unsigned int __kfifo_to_user_generic(struct kfifo *fifo,
-        void __user *to, unsigned int n, unsigned int recsize,
-        unsigned int *total);
+extern unsigned int __kfifo_dma_out_prepare(struct __kfifo *fifo,
+        struct scatterlist *sgl, int nents, unsigned int len);
 
-static inline unsigned int __kfifo_to_user_rec(struct kfifo *fifo,
-        void __user *to, unsigned int n,
-        unsigned int recsize, unsigned int *total)
-{
-        unsigned int l;
-
-        if (!recsize) {
-                l = n;
-                if (total)
-                        *total = l;
-        } else {
-                l = __kfifo_peek_n(fifo, recsize);
-                if (total)
-                        *total = l;
-                if (n < l)
-                        return l;
-        }
+extern unsigned int __kfifo_out_peek(struct __kfifo *fifo,
+        void *buf, unsigned int len);
 
-        return __kfifo_to_user_n(fifo, to, n, l, recsize);
-}
+extern unsigned int __kfifo_in_r(struct __kfifo *fifo,
+        const void *buf, unsigned int len, size_t recsize);
 
-/**
- * kfifo_to_user_rec - gets data from the FIFO and write it to user space
- * @fifo: the fifo to be used.
- * @to: where the data must be copied.
- * @n: the size of the destination buffer.
- * @recsize: size of record field
- * @total: pointer where the total number of to copied bytes should stored
- *
- * This function copies at most @n bytes from the FIFO to the @to.
- * In case of an error, the function returns the number of bytes which cannot
- * be copied.
- * If the returned value is equal or less the @n value, the copy_to_user()
- * functions has failed. Otherwise the record doesn't fit into the @to buffer.
- *
- * Note that with only one concurrent reader and one concurrent
- * writer, you don't need extra locking to use these functions.
- */
-static inline __must_check unsigned int kfifo_to_user_rec(struct kfifo *fifo,
-                void __user *to, unsigned int n, unsigned int recsize,
-                unsigned int *total)
-{
-        if (!__builtin_constant_p(recsize))
-                return __kfifo_to_user_generic(fifo, to, n, recsize, total);
-        return __kfifo_to_user_rec(fifo, to, n, recsize, total);
-}
+extern unsigned int __kfifo_out_r(struct __kfifo *fifo,
+        void *buf, unsigned int len, size_t recsize);
 
-/*
- * __kfifo_peek_... internal functions for peek into the next fifo record
- * do not call it directly, use kfifo_peek_rec() instead
- */
-extern unsigned int __kfifo_peek_generic(struct kfifo *fifo,
-                                unsigned int recsize);
+extern int __kfifo_from_user_r(struct __kfifo *fifo,
+        const void __user *from, unsigned long len, unsigned int *copied,
+        size_t recsize);
 
-/**
- * kfifo_peek_rec - gets the size of the next FIFO record data
- * @fifo: the fifo to be used.
- * @recsize: size of record field
- *
- * This function returns the size of the next FIFO record in number of bytes
- */
-static inline __must_check unsigned int kfifo_peek_rec(struct kfifo *fifo,
-        unsigned int recsize)
-{
-        if (!__builtin_constant_p(recsize))
-                return __kfifo_peek_generic(fifo, recsize);
-        if (!recsize)
-                return kfifo_len(fifo);
-        return __kfifo_peek_n(fifo, recsize);
-}
+extern int __kfifo_to_user_r(struct __kfifo *fifo, void __user *to,
+        unsigned long len, unsigned int *copied, size_t recsize);
 
-/*
- * __kfifo_skip_... internal functions for skip the next fifo record
- * do not call it directly, use kfifo_skip_rec() instead
- */
-extern void __kfifo_skip_generic(struct kfifo *fifo, unsigned int recsize);
+extern unsigned int __kfifo_dma_in_prepare_r(struct __kfifo *fifo,
+        struct scatterlist *sgl, int nents, unsigned int len, size_t recsize);
 
-static inline void __kfifo_skip_rec(struct kfifo *fifo,
-        unsigned int recsize)
-{
-        unsigned int l;
+extern void __kfifo_dma_in_finish_r(struct __kfifo *fifo,
+        unsigned int len, size_t recsize);
 
-        if (recsize) {
-                l = __kfifo_peek_n(fifo, recsize);
+extern unsigned int __kfifo_dma_out_prepare_r(struct __kfifo *fifo,
+        struct scatterlist *sgl, int nents, unsigned int len, size_t recsize);
 
-                if (l + recsize <= kfifo_len(fifo)) {
-                        __kfifo_add_out(fifo, l + recsize);
-                        return;
-                }
-        }
-        kfifo_reset_out(fifo);
-}
+extern void __kfifo_dma_out_finish_r(struct __kfifo *fifo, size_t recsize);
 
-/**
- * kfifo_skip_rec - skip the next fifo out record
- * @fifo: the fifo to be used.
- * @recsize: size of record field
- *
- * This function skips the next FIFO record
- */
-static inline void kfifo_skip_rec(struct kfifo *fifo,
-        unsigned int recsize)
-{
-        if (!__builtin_constant_p(recsize))
-                __kfifo_skip_generic(fifo, recsize);
-        else
-                __kfifo_skip_rec(fifo, recsize);
-}
+extern unsigned int __kfifo_len_r(struct __kfifo *fifo, size_t recsize);
 
-/**
- * kfifo_avail_rec - returns the number of bytes available in a record FIFO
- * @fifo: the fifo to be used.
- * @recsize: size of record field
- */
-static inline __must_check unsigned int kfifo_avail_rec(struct kfifo *fifo,
-        unsigned int recsize)
-{
-        unsigned int l = kfifo_size(fifo) - kfifo_len(fifo);
+extern unsigned int __kfifo_out_peek_r(struct __kfifo *fifo,
+        void *buf, unsigned int len, size_t recsize);
 
-        return (l > recsize) ? l - recsize : 0;
-}
+extern unsigned int __kfifo_max_r(unsigned int len, size_t recsize);
 
 #endif
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 73564cac38c7..159a0762aeaf 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -123,8 +123,7 @@ static inline bool mem_cgroup_disabled(void)
 
 void mem_cgroup_update_file_mapped(struct page *page, int val);
 unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
-                                                gfp_t gfp_mask, int nid,
-                                                int zid);
+                                                gfp_t gfp_mask);
 u64 mem_cgroup_get_limit(struct mem_cgroup *mem);
 
 #else /* CONFIG_CGROUP_MEM_RES_CTLR */
@@ -301,7 +300,7 @@ static inline void mem_cgroup_update_file_mapped(struct page *page,
 
 static inline
 unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
-                                            gfp_t gfp_mask, int nid, int zid)
+                                            gfp_t gfp_mask)
 {
         return 0;
 }
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index d02d2c6e0cfe..4d893eaf8174 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -24,6 +24,7 @@ struct mmc_cid {
 };
 
 struct mmc_csd {
+        unsigned char           structure;
         unsigned char           mmca_vsn;
         unsigned short          cmdclass;
         unsigned short          tacc_clks;
@@ -92,6 +93,7 @@ struct mmc_card {
 #define MMC_TYPE_MMC            0               /* MMC card */
 #define MMC_TYPE_SD             1               /* SD card */
 #define MMC_TYPE_SDIO           2               /* SDIO card */
+#define MMC_TYPE_SD_COMBO       3               /* SD combo (IO+mem) card */
         unsigned int            state;          /* (our) card state */
 #define MMC_STATE_PRESENT       (1<<0)          /* present in sysfs */
 #define MMC_STATE_READONLY      (1<<1)          /* card is read-only */
@@ -101,6 +103,8 @@ struct mmc_card {
 #define MMC_QUIRK_LENIENT_FN0   (1<<0)          /* allow SDIO FN0 writes outside of the VS CCCR range */
 #define MMC_QUIRK_BLKSZ_FOR_BYTE_MODE (1<<1)    /* use func->cur_blksize */
                                                 /* for byte mode */
+#define MMC_QUIRK_NONSTD_SDIO   (1<<2)          /* non-standard SDIO card attached */
+                                                /* (missing CIA registers) */
 
         u32                     raw_cid[4];     /* raw card CID */
         u32                     raw_csd[4];     /* raw card CSD */
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index f65913c9f5a4..513ff0376b09 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -124,6 +124,7 @@ struct mmc_host {
         unsigned int            f_min;
         unsigned int            f_max;
         u32                     ocr_avail;
+        struct notifier_block   pm_notify;
 
 #define MMC_VDD_165_195         0x00000080      /* VDD voltage 1.65 - 1.95 */
 #define MMC_VDD_20_21           0x00000100      /* VDD voltage 2.0 ~ 2.1 */
@@ -183,6 +184,7 @@ struct mmc_host {
 
         /* Only used with MMC_CAP_DISABLE */
         int                     enabled;        /* host is enabled */
+        int                     rescan_disable; /* disable card detection */
         int                     nesting_cnt;    /* "enable" nesting count */
         int                     en_dis_recurs;  /* detect recursion */
         unsigned int            disable_delay;  /* disable delay in msecs */
@@ -257,6 +259,7 @@ int mmc_card_can_sleep(struct mmc_host *host);
 int mmc_host_enable(struct mmc_host *host);
 int mmc_host_disable(struct mmc_host *host);
 int mmc_host_lazy_disable(struct mmc_host *host);
+int mmc_pm_notify(struct notifier_block *notify_block, unsigned long, void *);
 
 static inline void mmc_set_disable_delay(struct mmc_host *host,
                                          unsigned int disable_delay)
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index 8a49cbf0376d..52ce98866287 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -254,6 +254,7 @@ struct _mmc_csd {
 #define EXT_CSD_BUS_WIDTH       183     /* R/W */
 #define EXT_CSD_HS_TIMING       185     /* R/W */
 #define EXT_CSD_CARD_TYPE       196     /* RO */
+#define EXT_CSD_STRUCTURE       194     /* RO */
 #define EXT_CSD_REV             192     /* RO */
 #define EXT_CSD_SEC_CNT         212     /* RO, 4 bytes */
 #define EXT_CSD_S_A_TIMEOUT     217
diff --git a/include/linux/oom.h b/include/linux/oom.h
index f209b683e118..5e3aa8311c5e 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -66,6 +66,8 @@ static inline void oom_killer_enable(void)
 extern unsigned long badness(struct task_struct *p, struct mem_cgroup *mem,
                       const nodemask_t *nodemask, unsigned long uptime);
 
+extern struct task_struct *find_lock_task_mm(struct task_struct *p);
+
 /* sysctls */
 extern int sysctl_oom_dump_tasks;
 extern int sysctl_oom_kill_allocating_task;
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index c81eec4d3c35..f6a3b2d36cad 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -2372,6 +2372,9 @@
 #define PCI_VENDOR_ID_AKS               0x416c
 #define PCI_DEVICE_ID_AKS_ALADDINCARD   0x0100
 
+#define PCI_VENDOR_ID_ACCESSIO          0x494f
+#define PCI_DEVICE_ID_ACCESSIO_WDG_CSM  0x22c0
+
 #define PCI_VENDOR_ID_S3                0x5333
 #define PCI_DEVICE_ID_S3_TRIO           0x8811
 #define PCI_DEVICE_ID_S3_868            0x8880
diff --git a/include/linux/serial.h b/include/linux/serial.h
index c8613c3ff9d3..1ebc694a6d52 100644
--- a/include/linux/serial.h
+++ b/include/linux/serial.h
@@ -77,7 +77,8 @@ struct serial_struct {
 #define PORT_16654      11
 #define PORT_16850      12
 #define PORT_RSA        13      /* RSA-DV II/S card */
-#define PORT_MAX        13
+#define PORT_U6_16550A  14
+#define PORT_MAX        14
 
 #define SERIAL_IO_PORT  0
 #define SERIAL_IO_HUB6  1
@@ -151,7 +152,7 @@ struct serial_uart_config {
 #define ASYNC_BUGGY_UART        (1U << ASYNCB_BUGGY_UART)
 #define ASYNC_AUTOPROBE         (1U << ASYNCB_AUTOPROBE)
 
-#define ASYNC_FLAGS             ((1U << ASYNCB_LAST_USER) - 1)
+#define ASYNC_FLAGS             ((1U << (ASYNCB_LAST_USER + 1)) - 1)
 #define ASYNC_USR_MASK          (ASYNC_SPD_HI|ASYNC_SPD_VHI| \
                 ASYNC_CALLOUT_NOHUP|ASYNC_SPD_SHI|ASYNC_LOW_LATENCY)
 #define ASYNC_SPD_CUST          (ASYNC_SPD_HI|ASYNC_SPD_VHI)
@@ -210,8 +211,10 @@ struct serial_rs485 {
 #define SER_RS485_ENABLED               (1 << 0)
 #define SER_RS485_RTS_ON_SEND           (1 << 1)
 #define SER_RS485_RTS_AFTER_SEND        (1 << 2)
+#define SER_RS485_RTS_BEFORE_SEND       (1 << 3)
         __u32   delay_rts_before_send;  /* Milliseconds */
-        __u32   padding[6];             /* Memory is cheap, new structs
+        __u32   delay_rts_after_send;   /* Milliseconds */
+        __u32   padding[5];             /* Memory is cheap, new structs
                                            are a royal PITA .. */
 };
 
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index fb46aba11fb5..7638deaaba65 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -32,6 +32,9 @@ struct plat_serial8250_port {
         unsigned int    type;           /* If UPF_FIXED_TYPE */
         unsigned int    (*serial_in)(struct uart_port *, int);
         void            (*serial_out)(struct uart_port *, int, int);
+        void            (*set_termios)(struct uart_port *,
+                                       struct ktermios *new,
+                                       struct ktermios *old);
 };
 
 /*
@@ -71,5 +74,7 @@ extern int early_serial_setup(struct uart_port *port);
 extern int serial8250_find_port(struct uart_port *p);
 extern int serial8250_find_port_for_earlycon(void);
 extern int setup_early_serial8250_console(char *cmdline);
+extern void serial8250_do_set_termios(struct uart_port *port,
+                struct ktermios *termios, struct ktermios *old);
 
 #endif
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index f10db6e5f3b5..3c2ad99fed34 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -186,6 +186,15 @@
 #define PORT_ALTERA_JTAGUART    91
 #define PORT_ALTERA_UART        92
 
+/* SH-SCI */
+#define PORT_SCIFB      93
+
+/* MAX3107 */
+#define PORT_MAX3107    94
+
+/* High Speed UART for Medfield */
+#define PORT_MFD        95
+
 #ifdef __KERNEL__
 
 #include <linux/compiler.h>
@@ -220,7 +229,7 @@ struct uart_ops {
         void            (*flush_buffer)(struct uart_port *);
         void            (*set_termios)(struct uart_port *, struct ktermios *new,
                                        struct ktermios *old);
-        void            (*set_ldisc)(struct uart_port *);
+        void            (*set_ldisc)(struct uart_port *, int new);
         void            (*pm)(struct uart_port *, unsigned int state,
                               unsigned int oldstate);
         int             (*set_wake)(struct uart_port *, unsigned int state);
@@ -276,6 +285,9 @@ struct uart_port {
         unsigned char __iomem   *membase;               /* read/write[bwl] */
         unsigned int            (*serial_in)(struct uart_port *, int);
         void                    (*serial_out)(struct uart_port *, int, int);
+        void                    (*set_termios)(struct uart_port *,
+                                               struct ktermios *new,
+                                               struct ktermios *old);
         unsigned int            irq;                    /* irq number */
         unsigned long           irqflags;               /* irq flags  */
         unsigned int            uartclk;                /* base uart clock */
diff --git a/include/linux/serial_mfd.h b/include/linux/serial_mfd.h
new file mode 100644
index 000000000000..2b071e0b034d
--- /dev/null
+++ b/include/linux/serial_mfd.h
@@ -0,0 +1,47 @@
+#ifndef _SERIAL_MFD_H_
+#define _SERIAL_MFD_H_
+
+/* HW register offset definition */
+#define UART_FOR        0x08
+#define UART_PS         0x0C
+#define UART_MUL        0x0D
+#define UART_DIV        0x0E
+
+#define HSU_GBL_IEN     0x0
+#define HSU_GBL_IST     0x4
+
+#define HSU_GBL_INT_BIT_PORT0   0x0
+#define HSU_GBL_INT_BIT_PORT1   0x1
+#define HSU_GBL_INT_BIT_PORT2   0x2
+#define HSU_GBL_INT_BIT_IRI     0x3
+#define HSU_GBL_INT_BIT_HDLC    0x4
+#define HSU_GBL_INT_BIT_DMA     0x5
+
+#define HSU_GBL_ISR     0x8
+#define HSU_GBL_DMASR   0x400
+#define HSU_GBL_DMAISR  0x404
+
+#define HSU_PORT_REG_OFFSET     0x80
+#define HSU_PORT0_REG_OFFSET    0x80
+#define HSU_PORT1_REG_OFFSET    0x100
+#define HSU_PORT2_REG_OFFSET    0x180
+#define HSU_PORT_REG_LENGTH     0x80
+
+#define HSU_DMA_CHANS_REG_OFFSET        0x500
+#define HSU_DMA_CHANS_REG_LENGTH        0x40
+
+#define HSU_CH_SR               0x0     /* channel status reg */
+#define HSU_CH_CR               0x4     /* control reg */
+#define HSU_CH_DCR              0x8     /* descriptor control reg */
+#define HSU_CH_BSR              0x10    /* max fifo buffer size reg */
+#define HSU_CH_MOTSR            0x14    /* minimum ocp transfer size */
+#define HSU_CH_D0SAR            0x20    /* desc 0 start addr */
+#define HSU_CH_D0TSR            0x24    /* desc 0 transfer size */
+#define HSU_CH_D1SAR            0x28
+#define HSU_CH_D1TSR            0x2C
+#define HSU_CH_D2SAR            0x30
+#define HSU_CH_D2TSR            0x34
+#define HSU_CH_D3SAR            0x38
+#define HSU_CH_D3TSR            0x3C
+
+#endif
diff --git a/include/linux/serial_reg.h b/include/linux/serial_reg.h
index cf9327c051ad..c7a0ce11cd47 100644
--- a/include/linux/serial_reg.h
+++ b/include/linux/serial_reg.h
@@ -221,8 +221,24 @@
 #define UART_FCR_PXAR16 0x80    /* receive FIFO threshold = 16 */
 #define UART_FCR_PXAR32 0xc0    /* receive FIFO threshold = 32 */
 
+/*
+ * Intel MID on-chip HSU (High Speed UART) defined bits
+ */
+#define UART_FCR_HSU_64_1B      0x00    /* receive FIFO treshold = 1 */
+#define UART_FCR_HSU_64_16B     0x40    /* receive FIFO treshold = 16 */
+#define UART_FCR_HSU_64_32B     0x80    /* receive FIFO treshold = 32 */
+#define UART_FCR_HSU_64_56B     0xc0    /* receive FIFO treshold = 56 */
+
+#define UART_FCR_HSU_16_1B      0x00    /* receive FIFO treshold = 1 */
+#define UART_FCR_HSU_16_4B      0x40    /* receive FIFO treshold = 4 */
+#define UART_FCR_HSU_16_8B      0x80    /* receive FIFO treshold = 8 */
+#define UART_FCR_HSU_16_14B     0xc0    /* receive FIFO treshold = 14 */
 
+#define UART_FCR_HSU_64B_FIFO   0x20    /* chose 64 bytes FIFO */
+#define UART_FCR_HSU_16B_FIFO   0x00    /* chose 16 bytes FIFO */
 
+#define UART_FCR_HALF_EMPT_TXI  0x00    /* trigger TX_EMPT IRQ for half empty */
+#define UART_FCR_FULL_EMPT_TXI  0x08    /* trigger TX_EMPT IRQ for full empty */
 
 /*
  * These register definitions are for the 16C950
diff --git a/include/linux/sh_clk.h b/include/linux/sh_clk.h
index 1636d1e2a5f1..875ce50719a9 100644
--- a/include/linux/sh_clk.h
+++ b/include/linux/sh_clk.h
@@ -25,6 +25,10 @@ struct clk {
         int                     id;
 
         struct clk              *parent;
+        struct clk              **parent_table; /* list of parents to */
+        unsigned short          parent_num;     /* choose between */
+        unsigned char           src_shift;      /* source clock field in the */
+        unsigned char           src_width;      /* configuration register */
         struct clk_ops          *ops;
 
         struct list_head        children;
@@ -138,13 +142,22 @@ int sh_clk_div4_enable_register(struct clk *clks, int nr,
 int sh_clk_div4_reparent_register(struct clk *clks, int nr,
                          struct clk_div4_table *table);
 
-#define SH_CLK_DIV6(_parent, _reg, _flags)      \
-{                                               \
-        .parent = _parent,                      \
-        .enable_reg = (void __iomem *)_reg,     \
-        .flags = _flags,                        \
+#define SH_CLK_DIV6_EXT(_parent, _reg, _flags, _parents,        \
+                        _num_parents, _src_shift, _src_width)   \
+{                                                               \
+        .parent = _parent,                                      \
+        .enable_reg = (void __iomem *)_reg,                     \
+        .flags = _flags,                                        \
+        .parent_table = _parents,                               \
+        .parent_num = _num_parents,                             \
+        .src_shift = _src_shift,                                \
+        .src_width = _src_width,                                \
 }
 
+#define SH_CLK_DIV6(_parent, _reg, _flags)                      \
+        SH_CLK_DIV6_EXT(_parent, _reg, _flags, NULL, 0, 0, 0)
+
 int sh_clk_div6_register(struct clk *clks, int nr);
+int sh_clk_div6_reparent_register(struct clk *clks, int nr);
 
 #endif /* __SH_CLOCK_H */
diff --git a/include/linux/slab_def.h b/include/linux/slab_def.h
index 1acfa73ce2ac..791a502f6906 100644
--- a/include/linux/slab_def.h
+++ b/include/linux/slab_def.h
@@ -17,7 +17,6 @@
 
 #include <trace/events/kmem.h>
 
-#ifndef ARCH_KMALLOC_MINALIGN
 /*
  * Enforce a minimum alignment for the kmalloc caches.
  * Usually, the kmalloc caches are cache_line_size() aligned, except when
@@ -27,6 +26,9 @@
  * ARCH_KMALLOC_MINALIGN allows that.
  * Note that increasing this value may disable some debug features.
  */
+#ifdef ARCH_DMA_MINALIGN
+#define ARCH_KMALLOC_MINALIGN ARCH_DMA_MINALIGN
+#else
 #define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
 #endif
 
diff --git a/include/linux/slob_def.h b/include/linux/slob_def.h
index 62667f72c2ef..4382db09df4f 100644
--- a/include/linux/slob_def.h
+++ b/include/linux/slob_def.h
@@ -1,7 +1,9 @@
 #ifndef __LINUX_SLOB_DEF_H
 #define __LINUX_SLOB_DEF_H
 
-#ifndef ARCH_KMALLOC_MINALIGN
+#ifdef ARCH_DMA_MINALIGN
+#define ARCH_KMALLOC_MINALIGN ARCH_DMA_MINALIGN
+#else
 #define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long)
 #endif
 
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index 6447a723ecb1..6d14409c4d9a 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -106,15 +106,17 @@ struct kmem_cache {
 /*
  * Kmalloc subsystem.
  */
-#if defined(ARCH_KMALLOC_MINALIGN) && ARCH_KMALLOC_MINALIGN > 8
-#define KMALLOC_MIN_SIZE ARCH_KMALLOC_MINALIGN
+#if defined(ARCH_DMA_MINALIGN) && ARCH_DMA_MINALIGN > 8
+#define KMALLOC_MIN_SIZE ARCH_DMA_MINALIGN
 #else
 #define KMALLOC_MIN_SIZE 8
 #endif
 
 #define KMALLOC_SHIFT_LOW ilog2(KMALLOC_MIN_SIZE)
 
-#ifndef ARCH_KMALLOC_MINALIGN
+#ifdef ARCH_DMA_MINALIGN
+#define ARCH_KMALLOC_MINALIGN ARCH_DMA_MINALIGN
+#else
 #define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
 #endif
 
diff --git a/include/linux/spi/max7301.h b/include/linux/spi/max7301.h
index 34af0a3477bf..bcaa2f762cc1 100644
--- a/include/linux/spi/max7301.h
+++ b/include/linux/spi/max7301.h
@@ -11,6 +11,7 @@ struct max7301 {
         struct mutex    lock;
         u8              port_config[8]; /* field 0 is unused */
         u32             out_level;      /* cached output levels */
+        u32             input_pullup_active;
         struct gpio_chip chip;
         struct device *dev;
         int (*write)(struct device *dev, unsigned int reg, unsigned int val);
@@ -20,6 +21,13 @@ struct max7301 {
 struct max7301_platform_data {
         /* number assigned to the first GPIO */
         unsigned        base;
+        /*
+         * bitmask controlling the pullup configuration,
+         *
+         * _note_ the 4 lowest bits are unused, because the first 4
+         * ports of the controller are not used, too.
+         */
+        u32             input_pullup_active;
 };
 
 extern int __max730x_remove(struct device *dev);
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 91c9d3fc8513..2fee51a11b73 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -244,8 +244,7 @@ extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
 extern unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
                                                 gfp_t gfp_mask, bool noswap,
                                                 unsigned int swappiness,
-                                                struct zone *zone,
-                                                int nid);
+                                                struct zone *zone);
 extern int __isolate_lru_page(struct page *page, int mode, int file);
 extern unsigned long shrink_all_memory(unsigned long nr_pages);
 extern int vm_swappiness;
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 7802a243ee13..1437da3ddc62 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -13,6 +13,7 @@
 #include <linux/tty_driver.h>
 #include <linux/tty_ldisc.h>
 #include <linux/mutex.h>
+#include <linux/smp_lock.h>
 
 #include <asm/system.h>
 
@@ -179,6 +180,7 @@ struct tty_bufhead {
 #define L_FLUSHO(tty)   _L_FLAG((tty), FLUSHO)
 #define L_PENDIN(tty)   _L_FLAG((tty), PENDIN)
 #define L_IEXTEN(tty)   _L_FLAG((tty), IEXTEN)
+#define L_EXTPROC(tty)  _L_FLAG((tty), EXTPROC)
 
 struct device;
 struct signal_struct;
@@ -415,6 +417,7 @@ extern int is_ignored(int sig);
 extern int tty_signal(int sig, struct tty_struct *tty);
 extern void tty_hangup(struct tty_struct *tty);
 extern void tty_vhangup(struct tty_struct *tty);
+extern void tty_vhangup_locked(struct tty_struct *tty);
 extern void tty_vhangup_self(void);
 extern void tty_unhangup(struct file *filp);
 extern int tty_hung_up_p(struct file *filp);
@@ -575,5 +578,54 @@ extern int vt_ioctl(struct tty_struct *tty, struct file *file,
 extern long vt_compat_ioctl(struct tty_struct *tty, struct file * file,
                      unsigned int cmd, unsigned long arg);
 
+/* tty_mutex.c */
+/* functions for preparation of BKL removal */
+extern void __lockfunc tty_lock(void) __acquires(tty_lock);
+extern void __lockfunc tty_unlock(void) __releases(tty_lock);
+extern struct task_struct *__big_tty_mutex_owner;
+#define tty_locked()            (current == __big_tty_mutex_owner)
+
+/*
+ * wait_event_interruptible_tty -- wait for a condition with the tty lock held
+ *
+ * The condition we are waiting for might take a long time to
+ * become true, or might depend on another thread taking the
+ * BTM. In either case, we need to drop the BTM to guarantee
+ * forward progress. This is a leftover from the conversion
+ * from the BKL and should eventually get removed as the BTM
+ * falls out of use.
+ *
+ * Do not use in new code.
+ */
+#define wait_event_interruptible_tty(wq, condition)                     \
+({                                                                      \
+        int __ret = 0;                                                  \
+        if (!(condition)) {                                             \
+                __wait_event_interruptible_tty(wq, condition, __ret);   \
+        }                                                               \
+        __ret;                                                          \
+})
+
+#define __wait_event_interruptible_tty(wq, condition, ret)              \
+do {                                                                    \
+        DEFINE_WAIT(__wait);                                            \
+                                                                        \
+        for (;;) {                                                      \
+                prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE);      \
+                if (condition)                                          \
+                        break;                                          \
+                if (!signal_pending(current)) {                         \
+                        tty_unlock();                                   \
+                        schedule();                                     \
+                        tty_lock();                                     \
+                        continue;                                       \
+                }                                                       \
+                ret = -ERESTARTSYS;                                     \
+                break;                                                  \
+        }                                                               \
+        finish_wait(&wq, &__wait);                                      \
+} while (0)
+
+
 #endif /* __KERNEL__ */
 #endif
diff --git a/include/linux/usb.h b/include/linux/usb.h
index d5922a877994..35fe6ab222bb 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -127,6 +127,8 @@ enum usb_interface_condition {
  *      queued reset so that usb_cancel_queued_reset() doesn't try to
  *      remove from the workqueue when running inside the worker
  *      thread. See __usb_queue_reset_device().
+ * @resetting_device: USB core reset the device, so use alt setting 0 as
+ *      current; needs bandwidth alloc after reset.
  *
  * USB device drivers attach to interfaces on a physical device.  Each
  * interface encapsulates a single high level function, such as feeding
@@ -843,7 +845,7 @@ struct usb_driver {
 
         void (*disconnect) (struct usb_interface *intf);
 
-        int (*ioctl) (struct usb_interface *intf, unsigned int code,
+        int (*unlocked_ioctl) (struct usb_interface *intf, unsigned int code,
                         void *buf);
 
         int (*suspend) (struct usb_interface *intf, pm_message_t message);
@@ -1015,6 +1017,7 @@ typedef void (*usb_complete_t)(struct urb *);
  *      is a different endpoint (and pipe) from "out" endpoint two.
  *      The current configuration controls the existence, type, and
  *      maximum packet size of any given endpoint.
+ * @stream_id: the endpoint's stream ID for bulk streams
  * @dev: Identifies the USB device to perform the request.
  * @status: This is read in non-iso completion functions to get the
  *      status of the particular request.  ISO requests only use it
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
index 139353efad34..890bc1472190 100644
--- a/include/linux/usb/composite.h
+++ b/include/linux/usb/composite.h
@@ -276,6 +276,8 @@ struct usb_composite_driver {
         int                     (*bind)(struct usb_composite_dev *);
         int                     (*unbind)(struct usb_composite_dev *);
 
+        void                    (*disconnect)(struct usb_composite_dev *);
+
         /* global suspend hooks */
         void                    (*suspend)(struct usb_composite_dev *);
         void                    (*resume)(struct usb_composite_dev *);
@@ -342,6 +344,10 @@ struct usb_composite_dev {
 };
 
 extern int usb_string_id(struct usb_composite_dev *c);
+extern int usb_string_ids_tab(struct usb_composite_dev *c,
+                              struct usb_string *str);
+extern int usb_string_ids_n(struct usb_composite_dev *c, unsigned n);
+
 
 /* messaging utils */
 #define DBG(d, fmt, args...) \
diff --git a/include/linux/usb/ehci_def.h b/include/linux/usb/ehci_def.h
index 80287af2a738..2e262cb15425 100644
--- a/include/linux/usb/ehci_def.h
+++ b/include/linux/usb/ehci_def.h
@@ -39,6 +39,12 @@ struct ehci_caps {
 #define HCS_N_PORTS(p)          (((p)>>0)&0xf)  /* bits 3:0, ports on HC */
 
         u32             hcc_params;      /* HCCPARAMS - offset 0x8 */
+/* EHCI 1.1 addendum */
+#define HCC_32FRAME_PERIODIC_LIST(p)    ((p)&(1 << 19))
+#define HCC_PER_PORT_CHANGE_EVENT(p)    ((p)&(1 << 18))
+#define HCC_LPM(p)                      ((p)&(1 << 17))
+#define HCC_HW_PREFETCH(p)              ((p)&(1 << 16))
+
 #define HCC_EXT_CAPS(p)         (((p)>>8)&0xff) /* for pci extended caps */
 #define HCC_ISOC_CACHE(p)       ((p)&(1 << 7))  /* true: can cache isoc frame */
 #define HCC_ISOC_THRES(p)       (((p)>>4)&0x7)  /* bits 6:4, uframes cached */
@@ -54,6 +60,13 @@ struct ehci_regs {
 
         /* USBCMD: offset 0x00 */
         u32             command;
+
+/* EHCI 1.1 addendum */
+#define CMD_HIRD        (0xf<<24)       /* host initiated resume duration */
+#define CMD_PPCEE       (1<<15)         /* per port change event enable */
+#define CMD_FSP         (1<<14)         /* fully synchronized prefetch */
+#define CMD_ASPE        (1<<13)         /* async schedule prefetch enable */
+#define CMD_PSPE        (1<<12)         /* periodic schedule prefetch enable */
 /* 23:16 is r/w intr rate, in microframes; default "8" == 1/msec */
 #define CMD_PARK        (1<<11)         /* enable "park" on async qh */
 #define CMD_PARK_CNT(c) (((c)>>8)&3)    /* how many transfers to park for */
@@ -67,6 +80,7 @@ struct ehci_regs {
 
         /* USBSTS: offset 0x04 */
         u32             status;
+#define STS_PPCE_MASK   (0xff<<16)      /* Per-Port change event 1-16 */
 #define STS_ASS         (1<<15)         /* Async Schedule Status */
 #define STS_PSS         (1<<14)         /* Periodic Schedule Status */
 #define STS_RECL        (1<<13)         /* Reclamation */
@@ -100,6 +114,14 @@ struct ehci_regs {
 
         /* PORTSC: offset 0x44 */
         u32             port_status[0]; /* up to N_PORTS */
+/* EHCI 1.1 addendum */
+#define PORTSC_SUSPEND_STS_ACK 0
+#define PORTSC_SUSPEND_STS_NYET 1
+#define PORTSC_SUSPEND_STS_STALL 2
+#define PORTSC_SUSPEND_STS_ERR 3
+
+#define PORT_DEV_ADDR   (0x7f<<25)              /* device address */
+#define PORT_SSTS       (0x3<<23)               /* suspend status */
 /* 31:23 reserved */
 #define PORT_WKOC_E     (1<<22)         /* wake on overcurrent (enable) */
 #define PORT_WKDISC_E   (1<<21)         /* wake on disconnect (enable) */
@@ -115,6 +137,7 @@ struct ehci_regs {
 #define PORT_USB11(x) (((x)&(3<<10)) == (1<<10))        /* USB 1.1 device */
 /* 11:10 for detecting lowspeed devices (reset vs release ownership) */
 /* 9 reserved */
+#define PORT_LPM        (1<<9)          /* LPM transaction */
 #define PORT_RESET      (1<<8)          /* reset port */
 #define PORT_SUSPEND    (1<<7)          /* suspend port */
 #define PORT_RESUME     (1<<6)          /* resume it */
diff --git a/include/linux/usb/functionfs.h b/include/linux/usb/functionfs.h
index a34a2a043b21..6f649c13193b 100644
--- a/include/linux/usb/functionfs.h
+++ b/include/linux/usb/functionfs.h
@@ -180,9 +180,9 @@ static int functionfs_bind(struct ffs_data *ffs, struct usb_composite_dev *cdev)
 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)
+static int functionfs_bind_config(struct usb_composite_dev *cdev,
+                                  struct usb_configuration *c,
+                                  struct ffs_data *ffs)
         __attribute__((warn_unused_result, nonnull));
 
 
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index 2e3a4ea1a3da..3b571f1ffbb3 100644
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -89,18 +89,33 @@ struct usb_hcd {
          */
         const struct hc_driver  *driver;        /* hw-specific hooks */
 
-        /* Flags that need to be manipulated atomically */
+        /* Flags that need to be manipulated atomically because they can
+         * change while the host controller is running.  Always use
+         * set_bit() or clear_bit() to change their values.
+         */
         unsigned long           flags;
-#define HCD_FLAG_HW_ACCESSIBLE  0x00000001
-#define HCD_FLAG_SAW_IRQ        0x00000002
+#define HCD_FLAG_HW_ACCESSIBLE          0       /* at full power */
+#define HCD_FLAG_SAW_IRQ                1
+#define HCD_FLAG_POLL_RH                2       /* poll for rh status? */
+#define HCD_FLAG_POLL_PENDING           3       /* status has changed? */
+#define HCD_FLAG_WAKEUP_PENDING         4       /* root hub is resuming? */
+
+        /* The flags can be tested using these macros; they are likely to
+         * be slightly faster than test_bit().
+         */
+#define HCD_HW_ACCESSIBLE(hcd)  ((hcd)->flags & (1U << HCD_FLAG_HW_ACCESSIBLE))
+#define HCD_SAW_IRQ(hcd)        ((hcd)->flags & (1U << HCD_FLAG_SAW_IRQ))
+#define HCD_POLL_RH(hcd)        ((hcd)->flags & (1U << HCD_FLAG_POLL_RH))
+#define HCD_POLL_PENDING(hcd)   ((hcd)->flags & (1U << HCD_FLAG_POLL_PENDING))
+#define HCD_WAKEUP_PENDING(hcd) ((hcd)->flags & (1U << HCD_FLAG_WAKEUP_PENDING))
 
+        /* Flags that get set only during HCD registration or removal. */
         unsigned                rh_registered:1;/* is root hub registered? */
+        unsigned                rh_pollable:1;  /* may we poll the root hub? */
 
         /* 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 */
@@ -198,7 +213,7 @@ struct hc_driver {
          * 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);
+        int     (*pci_suspend)(struct usb_hcd *hcd, bool do_wakeup);
 
         /* called after entering D0 (etc), before resuming the hub */
         int     (*pci_resume)(struct usb_hcd *hcd, bool hibernated);
@@ -299,6 +314,10 @@ struct hc_driver {
         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 *);
+                /* Notifies the HCD after a device is connected and its
+                 * address is set
+                 */
+        int     (*update_device)(struct usb_hcd *, struct usb_device *);
 };
 
 extern int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb);
diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h
index f8302d036a76..545cba73ccaf 100644
--- a/include/linux/usb/otg.h
+++ b/include/linux/usb/otg.h
@@ -43,13 +43,6 @@ enum usb_xceiv_events {
         USB_EVENT_ENUMERATED,   /* gadget driver enumerated */
 };
 
-#define USB_OTG_PULLUP_ID               (1 << 0)
-#define USB_OTG_PULLDOWN_DP             (1 << 1)
-#define USB_OTG_PULLDOWN_DM             (1 << 2)
-#define USB_OTG_EXT_VBUS_INDICATOR      (1 << 3)
-#define USB_OTG_DRV_VBUS                (1 << 4)
-#define USB_OTG_DRV_VBUS_EXT            (1 << 5)
-
 struct otg_transceiver;
 
 /* for transceivers connected thru an ULPI interface, the user must
@@ -146,10 +139,10 @@ static inline int otg_io_read(struct otg_transceiver *otg, u32 reg)
         return -EINVAL;
 }
 
-static inline int otg_io_write(struct otg_transceiver *otg, u32 reg, u32 val)
+static inline int otg_io_write(struct otg_transceiver *otg, u32 val, u32 reg)
 {
         if (otg->io_ops && otg->io_ops->write)
-                return otg->io_ops->write(otg, reg, val);
+                return otg->io_ops->write(otg, val, reg);
 
         return -EINVAL;
 }
diff --git a/include/linux/usb/quirks.h b/include/linux/usb/quirks.h
index 16b7f3347545..3e93de7ecbc3 100644
--- a/include/linux/usb/quirks.h
+++ b/include/linux/usb/quirks.h
@@ -26,4 +26,8 @@
    and can't handle talking to these interfaces */
 #define USB_QUIRK_HONOR_BNUMINTERFACES  0x00000020
 
+/* device needs a pause during initialization, after we read the device
+   descriptor */
+#define USB_QUIRK_DELAY_INIT            0x00000040
+
 #endif /* __LINUX_USB_QUIRKS_H */
diff --git a/include/linux/usb/ulpi.h b/include/linux/usb/ulpi.h
index 2369d07c3c87..82b1507f4735 100644
--- a/include/linux/usb/ulpi.h
+++ b/include/linux/usb/ulpi.h
@@ -11,6 +11,42 @@
 #ifndef __LINUX_USB_ULPI_H
 #define __LINUX_USB_ULPI_H
 
+#include <linux/usb/otg.h>
+/*-------------------------------------------------------------------------*/
+
+/*
+ * ULPI Flags
+ */
+#define ULPI_OTG_ID_PULLUP              (1 << 0)
+#define ULPI_OTG_DP_PULLDOWN_DIS        (1 << 1)
+#define ULPI_OTG_DM_PULLDOWN_DIS        (1 << 2)
+#define ULPI_OTG_DISCHRGVBUS            (1 << 3)
+#define ULPI_OTG_CHRGVBUS               (1 << 4)
+#define ULPI_OTG_DRVVBUS                (1 << 5)
+#define ULPI_OTG_DRVVBUS_EXT            (1 << 6)
+#define ULPI_OTG_EXTVBUSIND             (1 << 7)
+
+#define ULPI_IC_6PIN_SERIAL             (1 << 8)
+#define ULPI_IC_3PIN_SERIAL             (1 << 9)
+#define ULPI_IC_CARKIT                  (1 << 10)
+#define ULPI_IC_CLKSUSPM                (1 << 11)
+#define ULPI_IC_AUTORESUME              (1 << 12)
+#define ULPI_IC_EXTVBUS_INDINV          (1 << 13)
+#define ULPI_IC_IND_PASSTHRU            (1 << 14)
+#define ULPI_IC_PROTECT_DIS             (1 << 15)
+
+#define ULPI_FC_HS                      (1 << 16)
+#define ULPI_FC_FS                      (1 << 17)
+#define ULPI_FC_LS                      (1 << 18)
+#define ULPI_FC_FS4LS                   (1 << 19)
+#define ULPI_FC_TERMSEL                 (1 << 20)
+#define ULPI_FC_OP_NORM                 (1 << 21)
+#define ULPI_FC_OP_NODRV                (1 << 22)
+#define ULPI_FC_OP_DIS_NRZI             (1 << 23)
+#define ULPI_FC_OP_NSYNC_NEOP           (1 << 24)
+#define ULPI_FC_RST                     (1 << 25)
+#define ULPI_FC_SUSPM                   (1 << 26)
+
 /*-------------------------------------------------------------------------*/
 
 /*
@@ -58,6 +94,10 @@
 
 /*-------------------------------------------------------------------------*/
 
+/*
+ * Register Bits
+ */
+
 /* Function Control */
 #define ULPI_FUNC_CTRL_XCVRSEL                  (1 << 0)
 #define  ULPI_FUNC_CTRL_XCVRSEL_MASK            (3 << 0)
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 047f7e6edb86..61490c6dcdbd 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -277,6 +277,7 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_RGB565  v4l2_fourcc('R', 'G', 'B', 'P') /* 16  RGB-5-6-5     */
 #define V4L2_PIX_FMT_RGB555X v4l2_fourcc('R', 'G', 'B', 'Q') /* 16  RGB-5-5-5 BE  */
 #define V4L2_PIX_FMT_RGB565X v4l2_fourcc('R', 'G', 'B', 'R') /* 16  RGB-5-6-5 BE  */
+#define V4L2_PIX_FMT_BGR666  v4l2_fourcc('B', 'G', 'R', 'H') /* 18  BGR-6-6-6     */
 #define V4L2_PIX_FMT_BGR24   v4l2_fourcc('B', 'G', 'R', '3') /* 24  BGR-8-8-8     */
 #define V4L2_PIX_FMT_RGB24   v4l2_fourcc('R', 'G', 'B', '3') /* 24  RGB-8-8-8     */
 #define V4L2_PIX_FMT_BGR32   v4l2_fourcc('B', 'G', 'R', '4') /* 32  BGR-8-8-8-8   */
diff --git a/include/linux/virtio_9p.h b/include/linux/virtio_9p.h
index 395c38a47adb..1faa80d92f05 100644
--- a/include/linux/virtio_9p.h
+++ b/include/linux/virtio_9p.h
@@ -2,6 +2,7 @@
 #define _LINUX_VIRTIO_9P_H
 /* This header is BSD licensed so anyone can use the definitions to implement
  * compatible drivers/servers. */
+#include <linux/types.h>
 #include <linux/virtio_ids.h>
 #include <linux/virtio_config.h>
 #include <linux/types.h>
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
index 7f56db4a79f0..6625cc1ab758 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -76,17 +76,52 @@ int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc);
 #define vc_translate(vc, c) ((vc)->vc_translate[(c) |                   \
                                         ((vc)->vc_toggle_meta ? 0x80 : 0)])
 #else
-#define con_set_trans_old(arg) (0)
-#define con_get_trans_old(arg) (-EINVAL)
-#define con_set_trans_new(arg) (0)
-#define con_get_trans_new(arg) (-EINVAL)
-#define con_clear_unimap(vc, ui) (0)
-#define con_set_unimap(vc, ct, list) (0)
-#define con_set_default_unimap(vc) (0)
-#define con_copy_unimap(d, s) (0)
-#define con_get_unimap(vc, ct, uct, list) (-EINVAL)
-#define con_free_unimap(vc) do { ; } while (0)
-#define con_protect_unimap(vc, rdonly) do { ; } while (0)
+static inline int con_set_trans_old(unsigned char __user *table)
+{
+        return 0;
+}
+static inline int con_get_trans_old(unsigned char __user *table)
+{
+        return -EINVAL;
+}
+static inline int con_set_trans_new(unsigned short __user *table)
+{
+        return 0;
+}
+static inline int con_get_trans_new(unsigned short __user *table)
+{
+        return -EINVAL;
+}
+static inline int con_clear_unimap(struct vc_data *vc, struct unimapinit *ui)
+{
+        return 0;
+}
+static inline
+int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list)
+{
+        return 0;
+}
+static inline
+int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct,
+                   struct unipair __user *list)
+{
+        return -EINVAL;
+}
+static inline int con_set_default_unimap(struct vc_data *vc)
+{
+        return 0;
+}
+static inline void con_free_unimap(struct vc_data *vc)
+{
+}
+static inline void con_protect_unimap(struct vc_data *vc, int rdonly)
+{
+}
+static inline
+int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc)
+{
+        return 0;
+}
 
 #define vc_translate(vc, c) (c)
 #endif
@@ -100,6 +135,13 @@ extern int unbind_con_driver(const struct consw *csw, int first, int last,
                              int deflt);
 int vty_init(const struct file_operations *console_fops);
 
+static inline bool vt_force_oops_output(struct vc_data *vc)
+{
+        if (oops_in_progress && vc->vc_panic_force_write)
+                return true;
+        return false;
+}
+
 /*
  * vc_screen.c shares this temporary buffer with the console write code so that
  * we can easily avoid touching user space while holding the console spinlock.
diff --git a/include/linux/wm97xx_batt.h b/include/linux/wm97xx_batt.h
deleted file mode 100644
index a1d6419c2ff8..000000000000
--- a/include/linux/wm97xx_batt.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef _LINUX_WM97XX_BAT_H
-#define _LINUX_WM97XX_BAT_H
-
-#include <linux/wm97xx.h>
-
-#warning This file will be removed soon, use wm97xx.h instead!
-
-#define wm97xx_batt_info wm97xx_batt_pdata
-
-#ifdef CONFIG_BATTERY_WM97XX
-void wm97xx_bat_set_pdata(struct wm97xx_batt_info *data);
-#else
-static inline void wm97xx_bat_set_pdata(struct wm97xx_batt_info *data) {}
-#endif
-
-#endif
diff --git a/include/media/cx2341x.h b/include/media/cx2341x.h
index 9ebe8558b9b6..8d08ebfe20b7 100644
--- a/include/media/cx2341x.h
+++ b/include/media/cx2341x.h
@@ -19,6 +19,8 @@
 #ifndef CX2341X_H
 #define CX2341X_H
 
+#include <media/v4l2-ctrls.h>
+
 enum cx2341x_port {
         CX2341X_PORT_MEMORY    = 0,
         CX2341X_PORT_STREAMING = 1,
@@ -99,6 +101,101 @@ int cx2341x_ext_ctrls(struct cx2341x_mpeg_params *params, int busy,
 void cx2341x_fill_defaults(struct cx2341x_mpeg_params *p);
 void cx2341x_log_status(const struct cx2341x_mpeg_params *p, const char *prefix);
 
+struct cx2341x_handler;
+
+struct cx2341x_handler_ops {
+        /* needed for the video clock freq */
+        int (*s_audio_sampling_freq)(struct cx2341x_handler *hdl, u32 val);
+        /* needed for dualwatch */
+        int (*s_audio_mode)(struct cx2341x_handler *hdl, u32 val);
+        /* needed for setting up the video resolution */
+        int (*s_video_encoding)(struct cx2341x_handler *hdl, u32 val);
+        /* needed for setting up the sliced vbi insertion data structures */
+        int (*s_stream_vbi_fmt)(struct cx2341x_handler *hdl, u32 val);
+};
+
+struct cx2341x_handler {
+        u32 capabilities;
+        enum cx2341x_port port;
+        u16 width;
+        u16 height;
+        u16 is_50hz;
+        u32 audio_properties;
+
+        struct v4l2_ctrl_handler hdl;
+        void *priv;
+        cx2341x_mbox_func func;
+        const struct cx2341x_handler_ops *ops;
+
+        struct v4l2_ctrl *stream_vbi_fmt;
+
+        struct {
+                /* audio cluster */
+                struct v4l2_ctrl *audio_sampling_freq;
+                struct v4l2_ctrl *audio_encoding;
+                struct v4l2_ctrl *audio_l2_bitrate;
+                struct v4l2_ctrl *audio_mode;
+                struct v4l2_ctrl *audio_mode_extension;
+                struct v4l2_ctrl *audio_emphasis;
+                struct v4l2_ctrl *audio_crc;
+                struct v4l2_ctrl *audio_ac3_bitrate;
+        };
+
+        struct {
+                /* video gop cluster */
+                struct v4l2_ctrl *video_b_frames;
+                struct v4l2_ctrl *video_gop_size;
+        };
+
+        struct {
+                /* stream type cluster */
+                struct v4l2_ctrl *stream_type;
+                struct v4l2_ctrl *video_encoding;
+                struct v4l2_ctrl *video_bitrate_mode;
+                struct v4l2_ctrl *video_bitrate;
+                struct v4l2_ctrl *video_bitrate_peak;
+        };
+
+        struct {
+                /* video mute cluster */
+                struct v4l2_ctrl *video_mute;
+                struct v4l2_ctrl *video_mute_yuv;
+        };
+
+        struct {
+                /* video filter mode cluster */
+                struct v4l2_ctrl *video_spatial_filter_mode;
+                struct v4l2_ctrl *video_temporal_filter_mode;
+                struct v4l2_ctrl *video_median_filter_type;
+        };
+
+        struct {
+                /* video filter type cluster */
+                struct v4l2_ctrl *video_luma_spatial_filter_type;
+                struct v4l2_ctrl *video_chroma_spatial_filter_type;
+        };
+
+        struct  {
+                /* video filter cluster */
+                struct v4l2_ctrl *video_spatial_filter;
+                struct v4l2_ctrl *video_temporal_filter;
+        };
+
+        struct {
+                /* video median cluster */
+                struct v4l2_ctrl *video_luma_median_filter_top;
+                struct v4l2_ctrl *video_luma_median_filter_bottom;
+                struct v4l2_ctrl *video_chroma_median_filter_top;
+                struct v4l2_ctrl *video_chroma_median_filter_bottom;
+        };
+};
+
+int cx2341x_handler_init(struct cx2341x_handler *cxhdl,
+                         unsigned nr_of_controls_hint);
+void cx2341x_handler_set_50hz(struct cx2341x_handler *cxhdl, int is_50hz);
+int cx2341x_handler_setup(struct cx2341x_handler *cxhdl);
+void cx2341x_handler_set_busy(struct cx2341x_handler *cxhdl, int busy);
+
 /* Firmware names */
 #define CX2341X_FIRM_ENC_FILENAME "v4l-cx2341x-enc.fw"
 /* Decoder firmware for the cx23415 only */
diff --git a/include/media/cx25840.h b/include/media/cx25840.h
index 0b0cb1776796..46d1a141208e 100644
--- a/include/media/cx25840.h
+++ b/include/media/cx25840.h
@@ -97,4 +97,91 @@ enum cx25840_audio_input {
         CX25840_AUDIO8,
 };
 
+enum cx25840_io_pin {
+        CX25840_PIN_DVALID_PRGM0 = 0,
+        CX25840_PIN_FIELD_PRGM1,
+        CX25840_PIN_HRESET_PRGM2,
+        CX25840_PIN_VRESET_HCTL_PRGM3,
+        CX25840_PIN_IRQ_N_PRGM4,
+        CX25840_PIN_IR_TX_PRGM6,
+        CX25840_PIN_IR_RX_PRGM5,
+        CX25840_PIN_GPIO0_PRGM8,
+        CX25840_PIN_GPIO1_PRGM9,
+        CX25840_PIN_SA_SDIN,            /* Alternate GP Input only */
+        CX25840_PIN_SA_SDOUT,           /* Alternate GP Input only */
+        CX25840_PIN_PLL_CLK_PRGM7,
+        CX25840_PIN_CHIP_SEL_VIPCLK,    /* Output only */
+};
+
+enum cx25840_io_pad {
+        /* Output pads */
+        CX25840_PAD_DEFAULT = 0,
+        CX25840_PAD_ACTIVE,
+        CX25840_PAD_VACTIVE,
+        CX25840_PAD_CBFLAG,
+        CX25840_PAD_VID_DATA_EXT0,
+        CX25840_PAD_VID_DATA_EXT1,
+        CX25840_PAD_GPO0,
+        CX25840_PAD_GPO1,
+        CX25840_PAD_GPO2,
+        CX25840_PAD_GPO3,
+        CX25840_PAD_IRQ_N,
+        CX25840_PAD_AC_SYNC,
+        CX25840_PAD_AC_SDOUT,
+        CX25840_PAD_PLL_CLK,
+        CX25840_PAD_VRESET,
+        CX25840_PAD_RESERVED,
+        /* Pads for PLL_CLK output only */
+        CX25840_PAD_XTI_X5_DLL,
+        CX25840_PAD_AUX_PLL,
+        CX25840_PAD_VID_PLL,
+        CX25840_PAD_XTI,
+        /* Input Pads */
+        CX25840_PAD_GPI0,
+        CX25840_PAD_GPI1,
+        CX25840_PAD_GPI2,
+        CX25840_PAD_GPI3,
+};
+
+enum cx25840_io_pin_strength {
+        CX25840_PIN_DRIVE_MEDIUM = 0,
+        CX25840_PIN_DRIVE_SLOW,
+        CX25840_PIN_DRIVE_FAST,
+};
+
+enum cx23885_io_pin {
+        CX23885_PIN_IR_RX_GPIO19,
+        CX23885_PIN_IR_TX_GPIO20,
+        CX23885_PIN_I2S_SDAT_GPIO21,
+        CX23885_PIN_I2S_WCLK_GPIO22,
+        CX23885_PIN_I2S_BCLK_GPIO23,
+        CX23885_PIN_IRQ_N_GPIO16,
+};
+
+enum cx23885_io_pad {
+        CX23885_PAD_IR_RX,
+        CX23885_PAD_GPIO19,
+        CX23885_PAD_IR_TX,
+        CX23885_PAD_GPIO20,
+        CX23885_PAD_I2S_SDAT,
+        CX23885_PAD_GPIO21,
+        CX23885_PAD_I2S_WCLK,
+        CX23885_PAD_GPIO22,
+        CX23885_PAD_I2S_BCLK,
+        CX23885_PAD_GPIO23,
+        CX23885_PAD_IRQ_N,
+        CX23885_PAD_GPIO16,
+};
+
+/* pvr150_workaround activates a workaround for a hardware bug that is
+   present in Hauppauge PVR-150 (and possibly PVR-500) cards that have
+   certain NTSC tuners (tveeprom tuner model numbers 85, 99 and 112). The
+   audio autodetect fails on some channels for these models and the workaround
+   is to select the audio standard explicitly. Many thanks to Hauppauge for
+   providing this information.
+   This platform data only needs to be supplied by the ivtv driver. */
+struct cx25840_platform_data {
+        int pvr150_workaround;
+};
+
 #endif
diff --git a/include/media/ir-core.h b/include/media/ir-core.h
index 513e60dd1010..eb7fddf8f607 100644
--- a/include/media/ir-core.h
+++ b/include/media/ir-core.h
@@ -41,6 +41,11 @@ enum rc_driver_type {
  *      anything with it. Yet, as the same keycode table can be used with other
  *      devices, a mask is provided to allow its usage. Drivers should generally
  *      leave this field in blank
+ * @timeout: optional time after which device stops sending data
+ * @min_timeout: minimum timeout supported by device
+ * @max_timeout: maximum timeout supported by device
+ * @rx_resolution : resolution (in ns) of input sampler
+ * @tx_resolution: resolution (in ns) of output sampler
  * @priv: driver-specific data, to be used on the callbacks
  * @change_protocol: allow changing the protocol used on hardware decoders
  * @open: callback to allow drivers to enable polling/irq when IR input device
@@ -49,19 +54,36 @@ enum rc_driver_type {
  *      is opened.
  * @s_tx_mask: set transmitter mask (for devices with multiple tx outputs)
  * @s_tx_carrier: set transmit carrier frequency
+ * @s_tx_duty_cycle: set transmit duty cycle (0% - 100%)
+ * @s_rx_carrier: inform driver about carrier it is expected to handle
  * @tx_ir: transmit IR
+ * @s_idle: optional: enable/disable hardware idle mode, upon which,
+        device doesn't interrupt host until it sees IR pulses
+ * @s_learning_mode: enable wide band receiver used for learning
  */
 struct ir_dev_props {
         enum rc_driver_type     driver_type;
         unsigned long           allowed_protos;
         u32                     scanmask;
+
+        u32                     timeout;
+        u32                     min_timeout;
+        u32                     max_timeout;
+
+        u32                     rx_resolution;
+        u32                     tx_resolution;
+
         void                    *priv;
         int                     (*change_protocol)(void *priv, u64 ir_type);
         int                     (*open)(void *priv);
         void                    (*close)(void *priv);
         int                     (*s_tx_mask)(void *priv, u32 mask);
         int                     (*s_tx_carrier)(void *priv, u32 carrier);
+        int                     (*s_tx_duty_cycle)(void *priv, u32 duty_cycle);
+        int                     (*s_rx_carrier_range)(void *priv, u32 min, u32 max);
         int                     (*tx_ir)(void *priv, int *txbuf, u32 n);
+        void                    (*s_idle)(void *priv, int enable);
+        int                     (*s_learning_mode)(void *priv, int enable);
 };
 
 struct ir_input_dev {
@@ -69,9 +91,10 @@ struct ir_input_dev {
         char                            *driver_name;   /* Name of the driver module */
         struct ir_scancode_table        rc_tab;         /* scan/key table */
         unsigned long                   devno;          /* device number */
-        const struct ir_dev_props       *props;         /* Device properties */
+        struct ir_dev_props             *props;         /* Device properties */
         struct ir_raw_event_ctrl        *raw;           /* for raw pulse/space events */
         struct input_dev                *input_dev;     /* the input device associated with this device */
+        bool                            idle;
 
         /* key info - needed by IR keycode handlers */
         spinlock_t                      keylock;        /* protects the below members */
@@ -95,12 +118,12 @@ enum raw_event_type {
 /* From ir-keytable.c */
 int __ir_input_register(struct input_dev *dev,
                       const struct ir_scancode_table *ir_codes,
-                      const struct ir_dev_props *props,
+                      struct ir_dev_props *props,
                       const char *driver_name);
 
 static inline int ir_input_register(struct input_dev *dev,
                       const char *map_name,
-                      const struct ir_dev_props *props,
+                      struct ir_dev_props *props,
                       const char *driver_name) {
         struct ir_scancode_table *ir_codes;
         struct ir_input_dev *ir_dev;
@@ -110,8 +133,12 @@ static inline int ir_input_register(struct input_dev *dev,
                 return -EINVAL;
 
         ir_codes = get_rc_map(map_name);
-        if (!ir_codes)
-                return -EINVAL;
+        if (!ir_codes) {
+                ir_codes = get_rc_map(RC_MAP_EMPTY);
+
+                if (!ir_codes)
+                        return -EINVAL;
+        }
 
         rc = __ir_input_register(dev, ir_codes, props, driver_name);
         if (rc < 0)
@@ -144,6 +171,10 @@ struct ir_raw_event {
 void ir_raw_event_handle(struct input_dev *input_dev);
 int ir_raw_event_store(struct input_dev *input_dev, struct ir_raw_event *ev);
 int ir_raw_event_store_edge(struct input_dev *input_dev, enum raw_event_type type);
+int ir_raw_event_store_with_filter(struct input_dev *input_dev,
+                                struct ir_raw_event *ev);
+void ir_raw_event_set_idle(struct input_dev *input_dev, int idle);
+
 static inline void ir_raw_event_reset(struct input_dev *input_dev)
 {
         struct ir_raw_event ev = { .pulse = false, .duration = 0 };
diff --git a/include/media/lirc.h b/include/media/lirc.h
index 42c467c50519..6678a169fd9e 100644
--- a/include/media/lirc.h
+++ b/include/media/lirc.h
@@ -77,6 +77,7 @@
 #define LIRC_CAN_SET_REC_FILTER           0x08000000
 
 #define LIRC_CAN_MEASURE_CARRIER          0x02000000
+#define LIRC_CAN_USE_WIDEBAND_RECEIVER    0x04000000
 
 #define LIRC_CAN_SEND(x) ((x)&LIRC_CAN_SEND_MASK)
 #define LIRC_CAN_REC(x) ((x)&LIRC_CAN_REC_MASK)
@@ -145,7 +146,7 @@
  * if enabled from the next key press on the driver will send
  * LIRC_MODE2_FREQUENCY packets
  */
-#define LIRC_SET_MEASURE_CARRIER_MODE  _IOW('i', 0x0000001d, __u32)
+#define LIRC_SET_MEASURE_CARRIER_MODE   _IOW('i', 0x0000001d, __u32)
 
 /*
  * to set a range use
@@ -162,4 +163,6 @@
 #define LIRC_SETUP_START               _IO('i', 0x00000021)
 #define LIRC_SETUP_END                 _IO('i', 0x00000022)
 
+#define LIRC_SET_WIDEBAND_RECEIVER     _IOW('i', 0x00000023, __u32)
+
 #endif
diff --git a/include/media/rc-map.h b/include/media/rc-map.h
index 9569d0863f8b..a9c041d49662 100644
--- a/include/media/rc-map.h
+++ b/include/media/rc-map.h
@@ -114,6 +114,7 @@ void rc_map_init(void);
 #define RC_MAP_PURPLETV                  "rc-purpletv"
 #define RC_MAP_PV951                     "rc-pv951"
 #define RC_MAP_RC5_HAUPPAUGE_NEW         "rc-rc5-hauppauge-new"
+#define RC_MAP_RC5_STREAMZAP             "rc-rc5-streamzap"
 #define RC_MAP_RC5_TV                    "rc-rc5-tv"
 #define RC_MAP_RC6_MCE                   "rc-rc6-mce"
 #define RC_MAP_REAL_AUDIO_220_32_KEYS    "rc-real-audio-220-32-keys"
diff --git a/include/media/v4l2-ctrls.h b/include/media/v4l2-ctrls.h
new file mode 100644
index 000000000000..9b7bea928a88
--- /dev/null
+++ b/include/media/v4l2-ctrls.h
@@ -0,0 +1,460 @@
+/*
+    V4L2 controls support header.
+
+    Copyright (C) 2010  Hans Verkuil <hverkuil@xs4all.nl>
+
+    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 _V4L2_CTRLS_H
+#define _V4L2_CTRLS_H
+
+#include <linux/list.h>
+#include <linux/device.h>
+
+/* forward references */
+struct v4l2_ctrl_handler;
+struct v4l2_ctrl;
+struct video_device;
+struct v4l2_subdev;
+
+/** struct v4l2_ctrl_ops - The control operations that the driver has to provide.
+  * @g_volatile_ctrl: Get a new value for this control. Generally only relevant
+  *             for volatile (and usually read-only) controls such as a control
+  *             that returns the current signal strength which changes
+  *             continuously.
+  *             If not set, then the currently cached value will be returned.
+  * @try_ctrl:  Test whether the control's value is valid. Only relevant when
+  *             the usual min/max/step checks are not sufficient.
+  * @s_ctrl:    Actually set the new control value. s_ctrl is compulsory. The
+  *             ctrl->handler->lock is held when these ops are called, so no
+  *             one else can access controls owned by that handler.
+  */
+struct v4l2_ctrl_ops {
+        int (*g_volatile_ctrl)(struct v4l2_ctrl *ctrl);
+        int (*try_ctrl)(struct v4l2_ctrl *ctrl);
+        int (*s_ctrl)(struct v4l2_ctrl *ctrl);
+};
+
+/** struct v4l2_ctrl - The control structure.
+  * @node:      The list node.
+  * @handler:   The handler that owns the control.
+  * @cluster:   Point to start of cluster array.
+  * @ncontrols: Number of controls in cluster array.
+  * @has_new:   Internal flag: set when there is a valid new value.
+  * @done:      Internal flag: set for each processed control.
+  * @is_private: If set, then this control is private to its handler and it
+  *             will not be added to any other handlers. Drivers can set
+  *             this flag.
+  * @is_volatile: If set, then this control is volatile. This means that the
+  *             control's current value cannot be cached and needs to be
+  *             retrieved through the g_volatile_ctrl op. Drivers can set
+  *             this flag.
+  * @ops:       The control ops.
+  * @id:        The control ID.
+  * @name:      The control name.
+  * @type:      The control type.
+  * @minimum:   The control's minimum value.
+  * @maximum:   The control's maximum value.
+  * @default_value: The control's default value.
+  * @step:      The control's step value for non-menu controls.
+  * @menu_skip_mask: The control's skip mask for menu controls. This makes it
+  *             easy to skip menu items that are not valid. If bit X is set,
+  *             then menu item X is skipped. Of course, this only works for
+  *             menus with <= 32 menu items. There are no menus that come
+  *             close to that number, so this is OK. Should we ever need more,
+  *             then this will have to be extended to a u64 or a bit array.
+  * @qmenu:     A const char * array for all menu items. Array entries that are
+  *             empty strings ("") correspond to non-existing menu items (this
+  *             is in addition to the menu_skip_mask above). The last entry
+  *             must be NULL.
+  * @flags:     The control's flags.
+  * @cur:       The control's current value.
+  * @val:       The control's new s32 value.
+  * @val64:     The control's new s64 value.
+  * @string:    The control's new string value.
+  * @priv:      The control's private pointer. For use by the driver. It is
+  *             untouched by the control framework. Note that this pointer is
+  *             not freed when the control is deleted. Should this be needed
+  *             then a new internal bitfield can be added to tell the framework
+  *             to free this pointer.
+  */
+struct v4l2_ctrl {
+        /* Administrative fields */
+        struct list_head node;
+        struct v4l2_ctrl_handler *handler;
+        struct v4l2_ctrl **cluster;
+        unsigned ncontrols;
+        unsigned int has_new:1;
+        unsigned int done:1;
+
+        unsigned int is_private:1;
+        unsigned int is_volatile:1;
+
+        const struct v4l2_ctrl_ops *ops;
+        u32 id;
+        const char *name;
+        enum v4l2_ctrl_type type;
+        s32 minimum, maximum, default_value;
+        union {
+                u32 step;
+                u32 menu_skip_mask;
+        };
+        const char **qmenu;
+        unsigned long flags;
+        union {
+                s32 val;
+                s64 val64;
+                char *string;
+        } cur;
+        union {
+                s32 val;
+                s64 val64;
+                char *string;
+        };
+        void *priv;
+};
+
+/** struct v4l2_ctrl_ref - The control reference.
+  * @node:      List node for the sorted list.
+  * @next:      Single-link list node for the hash.
+  * @ctrl:      The actual control information.
+  *
+  * Each control handler has a list of these refs. The list_head is used to
+  * keep a sorted-by-control-ID list of all controls, while the next pointer
+  * is used to link the control in the hash's bucket.
+  */
+struct v4l2_ctrl_ref {
+        struct list_head node;
+        struct v4l2_ctrl_ref *next;
+        struct v4l2_ctrl *ctrl;
+};
+
+/** struct v4l2_ctrl_handler - The control handler keeps track of all the
+  * controls: both the controls owned by the handler and those inherited
+  * from other handlers.
+  * @lock:      Lock to control access to this handler and its controls.
+  * @ctrls:     The list of controls owned by this handler.
+  * @ctrl_refs: The list of control references.
+  * @cached:    The last found control reference. It is common that the same
+  *             control is needed multiple times, so this is a simple
+  *             optimization.
+  * @buckets:   Buckets for the hashing. Allows for quick control lookup.
+  * @nr_of_buckets: Total number of buckets in the array.
+  * @error:     The error code of the first failed control addition.
+  */
+struct v4l2_ctrl_handler {
+        struct mutex lock;
+        struct list_head ctrls;
+        struct list_head ctrl_refs;
+        struct v4l2_ctrl_ref *cached;
+        struct v4l2_ctrl_ref **buckets;
+        u16 nr_of_buckets;
+        int error;
+};
+
+/** struct v4l2_ctrl_config - Control configuration structure.
+  * @ops:       The control ops.
+  * @id:        The control ID.
+  * @name:      The control name.
+  * @type:      The control type.
+  * @min:       The control's minimum value.
+  * @max:       The control's maximum value.
+  * @step:      The control's step value for non-menu controls.
+  * @def:       The control's default value.
+  * @flags:     The control's flags.
+  * @menu_skip_mask: The control's skip mask for menu controls. This makes it
+  *             easy to skip menu items that are not valid. If bit X is set,
+  *             then menu item X is skipped. Of course, this only works for
+  *             menus with <= 32 menu items. There are no menus that come
+  *             close to that number, so this is OK. Should we ever need more,
+  *             then this will have to be extended to a u64 or a bit array.
+  * @qmenu:     A const char * array for all menu items. Array entries that are
+  *             empty strings ("") correspond to non-existing menu items (this
+  *             is in addition to the menu_skip_mask above). The last entry
+  *             must be NULL.
+  * @is_private: If set, then this control is private to its handler and it
+  *             will not be added to any other handlers.
+  * @is_volatile: If set, then this control is volatile. This means that the
+  *             control's current value cannot be cached and needs to be
+  *             retrieved through the g_volatile_ctrl op.
+  */
+struct v4l2_ctrl_config {
+        const struct v4l2_ctrl_ops *ops;
+        u32 id;
+        const char *name;
+        enum v4l2_ctrl_type type;
+        s32 min;
+        s32 max;
+        u32 step;
+        s32 def;
+        u32 flags;
+        u32 menu_skip_mask;
+        const char **qmenu;
+        unsigned int is_private:1;
+        unsigned int is_volatile:1;
+};
+
+/** v4l2_ctrl_fill() - Fill in the control fields based on the control ID.
+  *
+  * This works for all standard V4L2 controls.
+  * For non-standard controls it will only fill in the given arguments
+  * and @name will be NULL.
+  *
+  * This function will overwrite the contents of @name, @type and @flags.
+  * The contents of @min, @max, @step and @def may be modified depending on
+  * the type.
+  *
+  * Do not use in drivers! It is used internally for backwards compatibility
+  * control handling only. Once all drivers are converted to use the new
+  * control framework this function will no longer be exported.
+  */
+void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
+                    s32 *min, s32 *max, s32 *step, s32 *def, u32 *flags);
+
+
+/** v4l2_ctrl_handler_init() - Initialize the control handler.
+  * @hdl:       The control handler.
+  * @nr_of_controls_hint: A hint of how many controls this handler is
+  *             expected to refer to. This is the total number, so including
+  *             any inherited controls. It doesn't have to be precise, but if
+  *             it is way off, then you either waste memory (too many buckets
+  *             are allocated) or the control lookup becomes slower (not enough
+  *             buckets are allocated, so there are more slow list lookups).
+  *             It will always work, though.
+  *
+  * Returns an error if the buckets could not be allocated. This error will
+  * also be stored in @hdl->error.
+  */
+int v4l2_ctrl_handler_init(struct v4l2_ctrl_handler *hdl,
+                           unsigned nr_of_controls_hint);
+
+/** v4l2_ctrl_handler_free() - Free all controls owned by the handler and free
+  * the control list.
+  * @hdl:       The control handler.
+  *
+  * Does nothing if @hdl == NULL.
+  */
+void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl);
+
+/** v4l2_ctrl_handler_setup() - Call the s_ctrl op for all controls belonging
+  * to the handler to initialize the hardware to the current control values.
+  * @hdl:       The control handler.
+  *
+  * Button controls will be skipped, as are read-only controls.
+  *
+  * If @hdl == NULL, then this just returns 0.
+  */
+int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl);
+
+/** v4l2_ctrl_handler_log_status() - Log all controls owned by the handler.
+  * @hdl:       The control handler.
+  * @prefix:    The prefix to use when logging the control values. If the
+  *             prefix does not end with a space, then ": " will be added
+  *             after the prefix. If @prefix == NULL, then no prefix will be
+  *             used.
+  *
+  * For use with VIDIOC_LOG_STATUS.
+  *
+  * Does nothing if @hdl == NULL.
+  */
+void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
+                                  const char *prefix);
+
+/** v4l2_ctrl_new_custom() - Allocate and initialize a new custom V4L2
+  * control.
+  * @hdl:       The control handler.
+  * @cfg:       The control's configuration data.
+  * @priv:      The control's driver-specific private data.
+  *
+  * If the &v4l2_ctrl struct could not be allocated then NULL is returned
+  * and @hdl->error is set to the error code (if it wasn't set already).
+  */
+struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
+                        const struct v4l2_ctrl_config *cfg, void *priv);
+
+/** v4l2_ctrl_new_std() - Allocate and initialize a new standard V4L2 non-menu control.
+  * @hdl:       The control handler.
+  * @ops:       The control ops.
+  * @id:        The control ID.
+  * @min:       The control's minimum value.
+  * @max:       The control's maximum value.
+  * @step:      The control's step value
+  * @def:       The control's default value.
+  *
+  * If the &v4l2_ctrl struct could not be allocated, or the control
+  * ID is not known, then NULL is returned and @hdl->error is set to the
+  * appropriate error code (if it wasn't set already).
+  *
+  * If @id refers to a menu control, then this function will return NULL.
+  *
+  * Use v4l2_ctrl_new_std_menu() when adding menu controls.
+  */
+struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
+                        const struct v4l2_ctrl_ops *ops,
+                        u32 id, s32 min, s32 max, u32 step, s32 def);
+
+/** v4l2_ctrl_new_std_menu() - Allocate and initialize a new standard V4L2 menu control.
+  * @hdl:       The control handler.
+  * @ops:       The control ops.
+  * @id:        The control ID.
+  * @max:       The control's maximum value.
+  * @mask:      The control's skip mask for menu controls. This makes it
+  *             easy to skip menu items that are not valid. If bit X is set,
+  *             then menu item X is skipped. Of course, this only works for
+  *             menus with <= 32 menu items. There are no menus that come
+  *             close to that number, so this is OK. Should we ever need more,
+  *             then this will have to be extended to a u64 or a bit array.
+  * @def:       The control's default value.
+  *
+  * Same as v4l2_ctrl_new_std(), but @min is set to 0 and the @mask value
+  * determines which menu items are to be skipped.
+  *
+  * If @id refers to a non-menu control, then this function will return NULL.
+  */
+struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
+                        const struct v4l2_ctrl_ops *ops,
+                        u32 id, s32 max, s32 mask, s32 def);
+
+/** v4l2_ctrl_add_ctrl() - Add a control from another handler to this handler.
+  * @hdl:       The control handler.
+  * @ctrl:      The control to add.
+  *
+  * It will return NULL if it was unable to add the control reference.
+  * If the control already belonged to the handler, then it will do
+  * nothing and just return @ctrl.
+  */
+struct v4l2_ctrl *v4l2_ctrl_add_ctrl(struct v4l2_ctrl_handler *hdl,
+                                          struct v4l2_ctrl *ctrl);
+
+/** v4l2_ctrl_add_handler() - Add all controls from handler @add to
+  * handler @hdl.
+  * @hdl:       The control handler.
+  * @add:       The control handler whose controls you want to add to
+  *             the @hdl control handler.
+  *
+  * Does nothing if either of the two is a NULL pointer.
+  * In case of an error @hdl->error will be set to the error code (if it
+  * wasn't set already).
+  */
+int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
+                          struct v4l2_ctrl_handler *add);
+
+
+/** v4l2_ctrl_cluster() - Mark all controls in the cluster as belonging to that cluster.
+  * @ncontrols: The number of controls in this cluster.
+  * @controls:  The cluster control array of size @ncontrols.
+  */
+void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls);
+
+
+/** v4l2_ctrl_find() - Find a control with the given ID.
+  * @hdl:       The control handler.
+  * @id:        The control ID to find.
+  *
+  * If @hdl == NULL this will return NULL as well. Will lock the handler so
+  * do not use from inside &v4l2_ctrl_ops.
+  */
+struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id);
+
+/** v4l2_ctrl_activate() - Make the control active or inactive.
+  * @ctrl:      The control to (de)activate.
+  * @active:    True if the control should become active.
+  *
+  * This sets or clears the V4L2_CTRL_FLAG_INACTIVE flag atomically.
+  * Does nothing if @ctrl == NULL.
+  * This will usually be called from within the s_ctrl op.
+  *
+  * This function can be called regardless of whether the control handler
+  * is locked or not.
+  */
+void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active);
+
+/** v4l2_ctrl_grab() - Mark the control as grabbed or not grabbed.
+  * @ctrl:      The control to (de)activate.
+  * @grabbed:   True if the control should become grabbed.
+  *
+  * This sets or clears the V4L2_CTRL_FLAG_GRABBED flag atomically.
+  * Does nothing if @ctrl == NULL.
+  * This will usually be called when starting or stopping streaming in the
+  * driver.
+  *
+  * This function can be called regardless of whether the control handler
+  * is locked or not.
+  */
+void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed);
+
+/** v4l2_ctrl_lock() - Helper function to lock the handler
+  * associated with the control.
+  * @ctrl:      The control to lock.
+  */
+static inline void v4l2_ctrl_lock(struct v4l2_ctrl *ctrl)
+{
+        mutex_lock(&ctrl->handler->lock);
+}
+
+/** v4l2_ctrl_lock() - Helper function to unlock the handler
+  * associated with the control.
+  * @ctrl:      The control to unlock.
+  */
+static inline void v4l2_ctrl_unlock(struct v4l2_ctrl *ctrl)
+{
+        mutex_unlock(&ctrl->handler->lock);
+}
+
+/** v4l2_ctrl_g_ctrl() - Helper function to get the control's value from within a driver.
+  * @ctrl:      The control.
+  *
+  * This returns the control's value safely by going through the control
+  * framework. This function will lock the control's handler, so it cannot be
+  * used from within the &v4l2_ctrl_ops functions.
+  *
+  * This function is for integer type controls only.
+  */
+s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl);
+
+/** v4l2_ctrl_s_ctrl() - Helper function to set the control's value from within a driver.
+  * @ctrl:      The control.
+  * @val:       The new value.
+  *
+  * This set the control's new value safely by going through the control
+  * framework. This function will lock the control's handler, so it cannot be
+  * used from within the &v4l2_ctrl_ops functions.
+  *
+  * This function is for integer type controls only.
+  */
+int v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val);
+
+
+/* Helpers for ioctl_ops. If hdl == NULL then they will all return -EINVAL. */
+int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc);
+int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm);
+int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *ctrl);
+int v4l2_s_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *ctrl);
+int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *c);
+int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *c);
+int v4l2_s_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *c);
+
+/* Helpers for subdevices. If the associated ctrl_handler == NULL then they
+   will all return -EINVAL. */
+int v4l2_subdev_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc);
+int v4l2_subdev_querymenu(struct v4l2_subdev *sd, struct v4l2_querymenu *qm);
+int v4l2_subdev_g_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs);
+int v4l2_subdev_try_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs);
+int v4l2_subdev_s_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs);
+int v4l2_subdev_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
+int v4l2_subdev_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
+
+#endif
diff --git a/include/media/v4l2-dev.h b/include/media/v4l2-dev.h
index bebe44b03e0f..1efcacbed01a 100644
--- a/include/media/v4l2-dev.h
+++ b/include/media/v4l2-dev.h
@@ -27,6 +27,7 @@
 struct v4l2_ioctl_callbacks;
 struct video_device;
 struct v4l2_device;
+struct v4l2_ctrl_handler;
 
 /* Flag to mark the video_device struct as registered.
    Drivers can clear this flag if they want to block all future
@@ -67,6 +68,9 @@ struct video_device
         struct device *parent;          /* device parent */
         struct v4l2_device *v4l2_dev;   /* v4l2_device parent */
 
+        /* Control handler associated with this device node. May be NULL. */
+        struct v4l2_ctrl_handler *ctrl_handler;
+
         /* device info */
         char name[32];
         int vfl_type;
diff --git a/include/media/v4l2-device.h b/include/media/v4l2-device.h
index 5d5d550e63ad..8bcbd7a0271c 100644
--- a/include/media/v4l2-device.h
+++ b/include/media/v4l2-device.h
@@ -32,6 +32,8 @@
 
 #define V4L2_DEVICE_NAME_SIZE (20 + 16)
 
+struct v4l2_ctrl_handler;
+
 struct v4l2_device {
         /* dev->driver_data points to this struct.
            Note: dev might be NULL if there is no parent device
@@ -47,6 +49,8 @@ struct v4l2_device {
         /* notify callback called by some sub-devices. */
         void (*notify)(struct v4l2_subdev *sd,
                         unsigned int notification, void *arg);
+        /* The control handler. May be NULL. */
+        struct v4l2_ctrl_handler *ctrl_handler;
 };
 
 /* Initialize v4l2_dev and make dev->driver_data point to v4l2_dev.
diff --git a/include/media/v4l2-subdev.h b/include/media/v4l2-subdev.h
index 02c6f4d11ed3..4a97d7341a94 100644
--- a/include/media/v4l2-subdev.h
+++ b/include/media/v4l2-subdev.h
@@ -35,6 +35,7 @@
 #define V4L2_SUBDEV_IR_TX_FIFO_SERVICE_REQ      0x00000001
 
 struct v4l2_device;
+struct v4l2_ctrl_handler;
 struct v4l2_subdev;
 struct tuner_setup;
 
@@ -90,10 +91,31 @@ struct v4l2_decode_vbi_line {
    not yet implemented) since ops provide proper type-checking.
  */
 
+/* Subdevice external IO pin configuration */
+#define V4L2_SUBDEV_IO_PIN_DISABLE      (1 << 0) /* ENABLE assumed */
+#define V4L2_SUBDEV_IO_PIN_OUTPUT       (1 << 1)
+#define V4L2_SUBDEV_IO_PIN_INPUT        (1 << 2)
+#define V4L2_SUBDEV_IO_PIN_SET_VALUE    (1 << 3) /* Set output value */
+#define V4L2_SUBDEV_IO_PIN_ACTIVE_LOW   (1 << 4) /* ACTIVE HIGH assumed */
+
+struct v4l2_subdev_io_pin_config {
+        u32 flags;      /* V4L2_SUBDEV_IO_PIN_* flags for this pin's config */
+        u8 pin;         /* Chip external IO pin to configure */
+        u8 function;    /* Internal signal pad/function to route to IO pin */
+        u8 value;       /* Initial value for pin - e.g. GPIO output value */
+        u8 strength;    /* Pin drive strength */
+};
+
 /* s_config: if set, then it is always called by the v4l2_i2c_new_subdev*
         functions after the v4l2_subdev was registered. It is used to pass
         platform data to the subdev which can be used during initialization.
 
+   s_io_pin_config: configure one or more chip I/O pins for chips that
+        multiplex different internal signal pads out to IO pins.  This function
+        takes a pointer to an array of 'n' pin configuration entries, one for
+        each pin being configured.  This function could be called at times
+        other than just subdevice initialization.
+
    init: initialize the sensor registors to some sort of reasonable default
         values. Do not use for new drivers and should be removed in existing
         drivers.
@@ -110,11 +132,18 @@ struct v4l2_decode_vbi_line {
 
    s_power: puts subdevice in power saving mode (on == 0) or normal operation
         mode (on == 1).
+
+   interrupt_service_routine: Called by the bridge chip's interrupt service
+        handler, when an interrupt status has be raised due to this subdev,
+        so that this subdev can handle the details.  It may schedule work to be
+        performed later.  It must not sleep.  *Called from an IRQ context*.
  */
 struct v4l2_subdev_core_ops {
         int (*g_chip_ident)(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip);
         int (*log_status)(struct v4l2_subdev *sd);
         int (*s_config)(struct v4l2_subdev *sd, int irq, void *platform_data);
+        int (*s_io_pin_config)(struct v4l2_subdev *sd, size_t n,
+                                      struct v4l2_subdev_io_pin_config *pincfg);
         int (*init)(struct v4l2_subdev *sd, u32 val);
         int (*load_fw)(struct v4l2_subdev *sd);
         int (*reset)(struct v4l2_subdev *sd, u32 val);
@@ -133,6 +162,8 @@ struct v4l2_subdev_core_ops {
         int (*s_register)(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg);
 #endif
         int (*s_power)(struct v4l2_subdev *sd, int on);
+        int (*interrupt_service_routine)(struct v4l2_subdev *sd,
+                                                u32 status, bool *handled);
 };
 
 /* s_mode: switch the tuner to a specific tuner mode. Replacement of s_radio.
@@ -307,11 +338,6 @@ struct v4l2_subdev_sensor_ops {
 };
 
 /*
-   interrupt_service_routine: Called by the bridge chip's interrupt service
-        handler, when an IR interrupt status has be raised due to this subdev,
-        so that this subdev can handle the details.  It may schedule work to be
-        performed later.  It must not sleep.  *Called from an IRQ context*.
-
    [rt]x_g_parameters: Get the current operating parameters and state of the
         the IR receiver or transmitter.
 
@@ -335,14 +361,9 @@ struct v4l2_subdev_sensor_ops {
  */
 
 enum v4l2_subdev_ir_mode {
-        V4L2_SUBDEV_IR_MODE_PULSE_WIDTH, /* space & mark widths in nanosecs */
+        V4L2_SUBDEV_IR_MODE_PULSE_WIDTH, /* uses struct ir_raw_event records */
 };
 
-/* Data format of data read or written for V4L2_SUBDEV_IR_MODE_PULSE_WIDTH */
-#define V4L2_SUBDEV_IR_PULSE_MAX_WIDTH_NS       0x7fffffff
-#define V4L2_SUBDEV_IR_PULSE_LEVEL_MASK         0x80000000
-#define V4L2_SUBDEV_IR_PULSE_RX_SEQ_END         0xffffffff
-
 struct v4l2_subdev_ir_parameters {
         /* Either Rx or Tx */
         unsigned int bytes_per_data_element; /* of data in read or write call */
@@ -356,7 +377,10 @@ struct v4l2_subdev_ir_parameters {
         u32 max_pulse_width;       /* ns,      valid only for baseband signal */
         unsigned int carrier_freq; /* Hz,      valid only for modulated signal*/
         unsigned int duty_cycle;   /* percent, valid only for modulated signal*/
-        bool invert;               /* logically invert sense of mark/space */
+        bool invert_level;         /* invert signal level */
+
+        /* Tx only */
+        bool invert_carrier_sense; /* Send 0/space as a carrier burst */
 
         /* Rx only */
         u32 noise_filter_min_width;       /* ns, min time of a valid pulse */
@@ -366,10 +390,6 @@ struct v4l2_subdev_ir_parameters {
 };
 
 struct v4l2_subdev_ir_ops {
-        /* Common to receiver and transmitter */
-        int (*interrupt_service_routine)(struct v4l2_subdev *sd,
-                                                u32 status, bool *handled);
-
         /* Receiver */
         int (*rx_read)(struct v4l2_subdev *sd, u8 *buf, size_t count,
                                 ssize_t *num);
@@ -415,6 +435,8 @@ struct v4l2_subdev {
         u32 flags;
         struct v4l2_device *v4l2_dev;
         const struct v4l2_subdev_ops *ops;
+        /* The control handler of this subdev. May be NULL. */
+        struct v4l2_ctrl_handler *ctrl_handler;
         /* name must be unique */
         char name[V4L2_SUBDEV_NAME_SIZE];
         /* can be used to group similar subdevs, value is driver-specific */
diff --git a/include/scsi/scsi.h b/include/scsi/scsi.h
index 9ae5c613131b..8fcb6e0e9e72 100644
--- a/include/scsi/scsi.h
+++ b/include/scsi/scsi.h
@@ -151,10 +151,10 @@ struct scsi_cmnd;
 
 /* defined in T10 SCSI Primary Commands-2 (SPC2) */
 struct scsi_varlen_cdb_hdr {
-        u8 opcode;        /* opcode always == VARIABLE_LENGTH_CMD */
-        u8 control;
-        u8 misc[5];
-        u8 additional_cdb_length;         /* total cdb length - 8 */
+        __u8 opcode;        /* opcode always == VARIABLE_LENGTH_CMD */
+        __u8 control;
+        __u8 misc[5];
+        __u8 additional_cdb_length;         /* total cdb length - 8 */
         __be16 service_action;
         /* service specific data follows */
 };
diff --git a/include/scsi/scsi_netlink.h b/include/scsi/scsi_netlink.h
index 536752c40d41..58ce8fe44783 100644
--- a/include/scsi/scsi_netlink.h
+++ b/include/scsi/scsi_netlink.h
@@ -105,8 +105,8 @@ struct scsi_nl_host_vendor_msg {
  *    PCI :  ID data is the 16 bit PCI Registered Vendor ID
  */
 #define SCSI_NL_VID_TYPE_SHIFT          56
-#define SCSI_NL_VID_TYPE_MASK           ((u64)0xFF << SCSI_NL_VID_TYPE_SHIFT)
-#define SCSI_NL_VID_TYPE_PCI            ((u64)0x01 << SCSI_NL_VID_TYPE_SHIFT)
+#define SCSI_NL_VID_TYPE_MASK           ((__u64)0xFF << SCSI_NL_VID_TYPE_SHIFT)
+#define SCSI_NL_VID_TYPE_PCI            ((__u64)0x01 << SCSI_NL_VID_TYPE_SHIFT)
 #define SCSI_NL_VID_ID_MASK             (~ SCSI_NL_VID_TYPE_MASK)
 
 
diff --git a/include/trace/events/block.h b/include/trace/events/block.h
index d870a918559c..d8ce278515c3 100644
--- a/include/trace/events/block.h
+++ b/include/trace/events/block.h
@@ -25,8 +25,10 @@ DECLARE_EVENT_CLASS(block_rq_with_error,
 
         TP_fast_assign(
                 __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
-                __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
-                __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
+                __entry->sector    = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                        0 : blk_rq_pos(rq);
+                __entry->nr_sector = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                        0 : blk_rq_sectors(rq);
                 __entry->errors    = rq->errors;
 
                 blk_fill_rwbs_rq(__entry->rwbs, rq);
@@ -109,9 +111,12 @@ DECLARE_EVENT_CLASS(block_rq,
 
         TP_fast_assign(
                 __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
-                __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
-                __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
-                __entry->bytes     = blk_pc_request(rq) ? blk_rq_bytes(rq) : 0;
+                __entry->sector    = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                        0 : blk_rq_pos(rq);
+                __entry->nr_sector = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                        0 : blk_rq_sectors(rq);
+                __entry->bytes     = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                        blk_rq_bytes(rq) : 0;
 
                 blk_fill_rwbs_rq(__entry->rwbs, rq);
                 blk_dump_cmd(__get_str(cmd), rq);
diff --git a/include/trace/events/writeback.h b/include/trace/events/writeback.h
new file mode 100644
index 000000000000..f345f66ae9d1
--- /dev/null
+++ b/include/trace/events/writeback.h
@@ -0,0 +1,159 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM writeback
+
+#if !defined(_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_WRITEBACK_H
+
+#include <linux/backing-dev.h>
+#include <linux/device.h>
+#include <linux/writeback.h>
+
+struct wb_writeback_work;
+
+DECLARE_EVENT_CLASS(writeback_work_class,
+        TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
+        TP_ARGS(bdi, work),
+        TP_STRUCT__entry(
+                __array(char, name, 32)
+                __field(long, nr_pages)
+                __field(dev_t, sb_dev)
+                __field(int, sync_mode)
+                __field(int, for_kupdate)
+                __field(int, range_cyclic)
+                __field(int, for_background)
+        ),
+        TP_fast_assign(
+                strncpy(__entry->name, dev_name(bdi->dev), 32);
+                __entry->nr_pages = work->nr_pages;
+                __entry->sb_dev = work->sb ? work->sb->s_dev : 0;
+                __entry->sync_mode = work->sync_mode;
+                __entry->for_kupdate = work->for_kupdate;
+                __entry->range_cyclic = work->range_cyclic;
+                __entry->for_background = work->for_background;
+        ),
+        TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
+                  "kupdate=%d range_cyclic=%d background=%d",
+                  __entry->name,
+                  MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
+                  __entry->nr_pages,
+                  __entry->sync_mode,
+                  __entry->for_kupdate,
+                  __entry->range_cyclic,
+                  __entry->for_background
+        )
+);
+#define DEFINE_WRITEBACK_WORK_EVENT(name) \
+DEFINE_EVENT(writeback_work_class, name, \
+        TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work), \
+        TP_ARGS(bdi, work))
+DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread);
+DEFINE_WRITEBACK_WORK_EVENT(writeback_queue);
+DEFINE_WRITEBACK_WORK_EVENT(writeback_exec);
+
+TRACE_EVENT(writeback_pages_written,
+        TP_PROTO(long pages_written),
+        TP_ARGS(pages_written),
+        TP_STRUCT__entry(
+                __field(long,           pages)
+        ),
+        TP_fast_assign(
+                __entry->pages          = pages_written;
+        ),
+        TP_printk("%ld", __entry->pages)
+);
+
+DECLARE_EVENT_CLASS(writeback_class,
+        TP_PROTO(struct backing_dev_info *bdi),
+        TP_ARGS(bdi),
+        TP_STRUCT__entry(
+                __array(char, name, 32)
+        ),
+        TP_fast_assign(
+                strncpy(__entry->name, dev_name(bdi->dev), 32);
+        ),
+        TP_printk("bdi %s",
+                  __entry->name
+        )
+);
+#define DEFINE_WRITEBACK_EVENT(name) \
+DEFINE_EVENT(writeback_class, name, \
+        TP_PROTO(struct backing_dev_info *bdi), \
+        TP_ARGS(bdi))
+
+DEFINE_WRITEBACK_EVENT(writeback_nowork);
+DEFINE_WRITEBACK_EVENT(writeback_wake_thread);
+DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread);
+DEFINE_WRITEBACK_EVENT(writeback_bdi_register);
+DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister);
+DEFINE_WRITEBACK_EVENT(writeback_thread_start);
+DEFINE_WRITEBACK_EVENT(writeback_thread_stop);
+
+DECLARE_EVENT_CLASS(wbc_class,
+        TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
+        TP_ARGS(wbc, bdi),
+        TP_STRUCT__entry(
+                __array(char, name, 32)
+                __field(long, nr_to_write)
+                __field(long, pages_skipped)
+                __field(int, sync_mode)
+                __field(int, nonblocking)
+                __field(int, encountered_congestion)
+                __field(int, for_kupdate)
+                __field(int, for_background)
+                __field(int, for_reclaim)
+                __field(int, range_cyclic)
+                __field(int, more_io)
+                __field(unsigned long, older_than_this)
+                __field(long, range_start)
+                __field(long, range_end)
+        ),
+
+        TP_fast_assign(
+                strncpy(__entry->name, dev_name(bdi->dev), 32);
+                __entry->nr_to_write    = wbc->nr_to_write;
+                __entry->pages_skipped  = wbc->pages_skipped;
+                __entry->sync_mode      = wbc->sync_mode;
+                __entry->for_kupdate    = wbc->for_kupdate;
+                __entry->for_background = wbc->for_background;
+                __entry->for_reclaim    = wbc->for_reclaim;
+                __entry->range_cyclic   = wbc->range_cyclic;
+                __entry->more_io        = wbc->more_io;
+                __entry->older_than_this = wbc->older_than_this ?
+                                                *wbc->older_than_this : 0;
+                __entry->range_start    = (long)wbc->range_start;
+                __entry->range_end      = (long)wbc->range_end;
+        ),
+
+        TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
+                "bgrd=%d reclm=%d cyclic=%d more=%d older=0x%lx "
+                "start=0x%lx end=0x%lx",
+                __entry->name,
+                __entry->nr_to_write,
+                __entry->pages_skipped,
+                __entry->sync_mode,
+                __entry->for_kupdate,
+                __entry->for_background,
+                __entry->for_reclaim,
+                __entry->range_cyclic,
+                __entry->more_io,
+                __entry->older_than_this,
+                __entry->range_start,
+                __entry->range_end)
+)
+
+#define DEFINE_WBC_EVENT(name) \
+DEFINE_EVENT(wbc_class, name, \
+        TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
+        TP_ARGS(wbc, bdi))
+DEFINE_WBC_EVENT(wbc_writeback_start);
+DEFINE_WBC_EVENT(wbc_writeback_written);
+DEFINE_WBC_EVENT(wbc_writeback_wait);
+DEFINE_WBC_EVENT(wbc_balance_dirty_start);
+DEFINE_WBC_EVENT(wbc_balance_dirty_written);
+DEFINE_WBC_EVENT(wbc_balance_dirty_wait);
+DEFINE_WBC_EVENT(wbc_writepage);
+
+#endif /* _TRACE_WRITEBACK_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/video/mipi_display.h b/include/video/mipi_display.h
new file mode 100644
index 000000000000..ddcc8ca7316b
--- /dev/null
+++ b/include/video/mipi_display.h
@@ -0,0 +1,130 @@
+/*
+ * Defines for Mobile Industry Processor Interface (MIPI(R))
+ * Display Working Group standards: DSI, DCS, DBI, DPI
+ *
+ * Copyright (C) 2010 Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ * Copyright (C) 2006 Nokia Corporation
+ * Author: Imre Deak <imre.deak@nokia.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 MIPI_DISPLAY_H
+#define MIPI_DISPLAY_H
+
+/* MIPI DSI Processor-to-Peripheral transaction types */
+enum {
+        MIPI_DSI_V_SYNC_START                           = 0x01,
+        MIPI_DSI_V_SYNC_END                             = 0x11,
+        MIPI_DSI_H_SYNC_START                           = 0x21,
+        MIPI_DSI_H_SYNC_END                             = 0x31,
+
+        MIPI_DSI_COLOR_MODE_OFF                         = 0x02,
+        MIPI_DSI_COLOR_MODE_ON                          = 0x12,
+        MIPI_DSI_SHUTDOWN_PERIPHERAL                    = 0x22,
+        MIPI_DSI_TURN_ON_PERIPHERAL                     = 0x32,
+
+        MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM            = 0x03,
+        MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM            = 0x13,
+        MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM            = 0x23,
+
+        MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM           = 0x04,
+        MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM           = 0x14,
+        MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM           = 0x24,
+
+        MIPI_DSI_DCS_SHORT_WRITE                        = 0x05,
+        MIPI_DSI_DCS_SHORT_WRITE_PARAM                  = 0x15,
+
+        MIPI_DSI_DCS_READ                               = 0x06,
+
+        MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE         = 0x37,
+
+        MIPI_DSI_END_OF_TRANSMISSION                    = 0x08,
+
+        MIPI_DSI_NULL_PACKET                            = 0x09,
+        MIPI_DSI_BLANKING_PACKET                        = 0x19,
+        MIPI_DSI_GENERIC_LONG_WRITE                     = 0x29,
+        MIPI_DSI_DCS_LONG_WRITE                         = 0x39,
+
+        MIPI_DSI_LOOSELY_PACKED_PIXEL_STREAM_YCBCR20    = 0x0c,
+        MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR24            = 0x1c,
+        MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR16            = 0x2c,
+
+        MIPI_DSI_PACKED_PIXEL_STREAM_30                 = 0x0d,
+        MIPI_DSI_PACKED_PIXEL_STREAM_36                 = 0x1d,
+        MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR12            = 0x3d,
+
+        MIPI_DSI_PACKED_PIXEL_STREAM_16                 = 0x0e,
+        MIPI_DSI_PACKED_PIXEL_STREAM_18                 = 0x1e,
+        MIPI_DSI_PIXEL_STREAM_3BYTE_18                  = 0x2e,
+        MIPI_DSI_PACKED_PIXEL_STREAM_24                 = 0x3e,
+};
+
+/* MIPI DSI Peripheral-to-Processor transaction types */
+enum {
+        MIPI_DSI_RX_ACKNOWLEDGE_AND_ERROR_REPORT        = 0x02,
+        MIPI_DSI_RX_END_OF_TRANSMISSION                 = 0x08,
+        MIPI_DSI_RX_GENERIC_SHORT_READ_RESPONSE_1BYTE   = 0x11,
+        MIPI_DSI_RX_GENERIC_SHORT_READ_RESPONSE_2BYTE   = 0x12,
+        MIPI_DSI_RX_GENERIC_LONG_READ_RESPONSE          = 0x1a,
+        MIPI_DSI_RX_DCS_LONG_READ_RESPONSE              = 0x1c,
+        MIPI_DSI_RX_DCS_SHORT_READ_RESPONSE_1BYTE       = 0x21,
+        MIPI_DSI_RX_DCS_SHORT_READ_RESPONSE_2BYTE       = 0x22,
+};
+
+/* MIPI DCS commands */
+enum {
+        MIPI_DCS_NOP                    = 0x00,
+        MIPI_DCS_SOFT_RESET             = 0x01,
+        MIPI_DCS_GET_DISPLAY_ID         = 0x04,
+        MIPI_DCS_GET_RED_CHANNEL        = 0x06,
+        MIPI_DCS_GET_GREEN_CHANNEL      = 0x07,
+        MIPI_DCS_GET_BLUE_CHANNEL       = 0x08,
+        MIPI_DCS_GET_DISPLAY_STATUS     = 0x09,
+        MIPI_DCS_GET_POWER_MODE         = 0x0A,
+        MIPI_DCS_GET_ADDRESS_MODE       = 0x0B,
+        MIPI_DCS_GET_PIXEL_FORMAT       = 0x0C,
+        MIPI_DCS_GET_DISPLAY_MODE       = 0x0D,
+        MIPI_DCS_GET_SIGNAL_MODE        = 0x0E,
+        MIPI_DCS_GET_DIAGNOSTIC_RESULT  = 0x0F,
+        MIPI_DCS_ENTER_SLEEP_MODE       = 0x10,
+        MIPI_DCS_EXIT_SLEEP_MODE        = 0x11,
+        MIPI_DCS_ENTER_PARTIAL_MODE     = 0x12,
+        MIPI_DCS_ENTER_NORMAL_MODE      = 0x13,
+        MIPI_DCS_EXIT_INVERT_MODE       = 0x20,
+        MIPI_DCS_ENTER_INVERT_MODE      = 0x21,
+        MIPI_DCS_SET_GAMMA_CURVE        = 0x26,
+        MIPI_DCS_SET_DISPLAY_OFF        = 0x28,
+        MIPI_DCS_SET_DISPLAY_ON         = 0x29,
+        MIPI_DCS_SET_COLUMN_ADDRESS     = 0x2A,
+        MIPI_DCS_SET_PAGE_ADDRESS       = 0x2B,
+        MIPI_DCS_WRITE_MEMORY_START     = 0x2C,
+        MIPI_DCS_WRITE_LUT              = 0x2D,
+        MIPI_DCS_READ_MEMORY_START      = 0x2E,
+        MIPI_DCS_SET_PARTIAL_AREA       = 0x30,
+        MIPI_DCS_SET_SCROLL_AREA        = 0x33,
+        MIPI_DCS_SET_TEAR_OFF           = 0x34,
+        MIPI_DCS_SET_TEAR_ON            = 0x35,
+        MIPI_DCS_SET_ADDRESS_MODE       = 0x36,
+        MIPI_DCS_SET_SCROLL_START       = 0x37,
+        MIPI_DCS_EXIT_IDLE_MODE         = 0x38,
+        MIPI_DCS_ENTER_IDLE_MODE        = 0x39,
+        MIPI_DCS_SET_PIXEL_FORMAT       = 0x3A,
+        MIPI_DCS_WRITE_MEMORY_CONTINUE  = 0x3C,
+        MIPI_DCS_READ_MEMORY_CONTINUE   = 0x3E,
+        MIPI_DCS_SET_TEAR_SCANLINE      = 0x44,
+        MIPI_DCS_GET_SCANLINE           = 0x45,
+        MIPI_DCS_READ_DDB_START         = 0xA1,
+        MIPI_DCS_READ_DDB_CONTINUE      = 0xA8,
+};
+
+/* MIPI DCS pixel formats */
+#define MIPI_DCS_PIXEL_FMT_24BIT        7
+#define MIPI_DCS_PIXEL_FMT_18BIT        6
+#define MIPI_DCS_PIXEL_FMT_16BIT        5
+#define MIPI_DCS_PIXEL_FMT_12BIT        3
+#define MIPI_DCS_PIXEL_FMT_8BIT         2
+#define MIPI_DCS_PIXEL_FMT_3BIT         1
+
+#endif
diff --git a/include/video/sh_mipi_dsi.h b/include/video/sh_mipi_dsi.h
new file mode 100644
index 000000000000..18bca08f9f59
--- /dev/null
+++ b/include/video/sh_mipi_dsi.h
@@ -0,0 +1,35 @@
+/*
+ * Public SH-mobile MIPI DSI header
+ *
+ * Copyright (C) 2010 Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ *
+ * 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 VIDEO_SH_MIPI_DSI_H
+#define VIDEO_SH_MIPI_DSI_H
+
+enum sh_mipi_dsi_data_fmt {
+        MIPI_RGB888,
+        MIPI_RGB565,
+        MIPI_RGB666_LP,
+        MIPI_RGB666,
+        MIPI_BGR888,
+        MIPI_BGR565,
+        MIPI_BGR666_LP,
+        MIPI_BGR666,
+        MIPI_YUYV,
+        MIPI_UYVY,
+        MIPI_YUV420_L,
+        MIPI_YUV420,
+};
+
+struct sh_mobile_lcdc_chan_cfg;
+
+struct sh_mipi_dsi_info {
+        enum sh_mipi_dsi_data_fmt       data_format;
+        struct sh_mobile_lcdc_chan_cfg  *lcd_chan;
+};
+
+#endif
diff --git a/include/video/sh_mobile_hdmi.h b/include/video/sh_mobile_hdmi.h
new file mode 100644
index 000000000000..577cf18cce89
--- /dev/null
+++ b/include/video/sh_mobile_hdmi.h
@@ -0,0 +1,22 @@
+/*
+ * SH-Mobile High-Definition Multimedia Interface (HDMI)
+ *
+ * Copyright (C) 2010, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ *
+ * 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 SH_MOBILE_HDMI_H
+#define SH_MOBILE_HDMI_H
+
+struct sh_mobile_lcdc_chan_cfg;
+struct device;
+
+struct sh_mobile_hdmi_info {
+        struct sh_mobile_lcdc_chan_cfg  *lcd_chan;
+        struct device                   *lcd_dev;
+};
+
+#endif
diff --git a/include/video/sh_mobile_lcdc.h b/include/video/sh_mobile_lcdc.h
index 288205457713..55d700e8566e 100644
--- a/include/video/sh_mobile_lcdc.h
+++ b/include/video/sh_mobile_lcdc.h
@@ -3,24 +3,27 @@
 
 #include <linux/fb.h>
 
-enum { RGB8,   /* 24bpp, 8:8:8 */
-       RGB9,   /* 18bpp, 9:9 */
-       RGB12A, /* 24bpp, 12:12 */
-       RGB12B, /* 12bpp */
-       RGB16,  /* 16bpp */
-       RGB18,  /* 18bpp */
-       RGB24,  /* 24bpp */
-       SYS8A,  /* 24bpp, 8:8:8 */
-       SYS8B,  /* 18bpp, 8:8:2 */
-       SYS8C,  /* 18bpp, 2:8:8 */
-       SYS8D,  /* 16bpp, 8:8 */
-       SYS9,   /* 18bpp, 9:9 */
-       SYS12,  /* 24bpp, 12:12 */
-       SYS16A, /* 16bpp */
-       SYS16B, /* 18bpp, 16:2 */
-       SYS16C, /* 18bpp, 2:16 */
-       SYS18,  /* 18bpp */
-       SYS24 };/* 24bpp */
+enum {
+        RGB8,   /* 24bpp, 8:8:8 */
+        RGB9,   /* 18bpp, 9:9 */
+        RGB12A, /* 24bpp, 12:12 */
+        RGB12B, /* 12bpp */
+        RGB16,  /* 16bpp */
+        RGB18,  /* 18bpp */
+        RGB24,  /* 24bpp */
+        YUV422, /* 16bpp */
+        SYS8A,  /* 24bpp, 8:8:8 */
+        SYS8B,  /* 18bpp, 8:8:2 */
+        SYS8C,  /* 18bpp, 2:8:8 */
+        SYS8D,  /* 16bpp, 8:8 */
+        SYS9,   /* 18bpp, 9:9 */
+        SYS12,  /* 24bpp, 12:12 */
+        SYS16A, /* 16bpp */
+        SYS16B, /* 18bpp, 16:2 */
+        SYS16C, /* 18bpp, 2:16 */
+        SYS18,  /* 18bpp */
+        SYS24,  /* 24bpp */
+};
 
 enum { LCDC_CHAN_DISABLED = 0,
        LCDC_CHAN_MAINLCD,
@@ -52,7 +55,7 @@ struct sh_mobile_lcdc_board_cfg {
                          struct sh_mobile_lcdc_sys_bus_ops *sys_ops);
         void (*start_transfer)(void *board_data, void *sys_ops_handle,
                                struct sh_mobile_lcdc_sys_bus_ops *sys_ops);
-        void (*display_on)(void *board_data);
+        void (*display_on)(void *board_data, struct fb_info *info);
         void (*display_off)(void *board_data);
 };