Merge branch 'linus' into tracing/urgent

Conflicts:
	kernel/trace/trace_kprobe.c

Merge reason: resolve the conflict.

Signed-off-by: Ingo Molnar <mingo@elte.hu>

68 files changed, 1007 insertions, 341 deletions

diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index 5a5385749e1..f72914db2a1 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -214,7 +214,6 @@ unifdef-y += futex.h
 unifdef-y += fs.h
 unifdef-y += gameport.h
 unifdef-y += generic_serial.h
-unifdef-y += hayesesp.h
 unifdef-y += hdlcdrv.h
 unifdef-y += hdlc.h
 unifdef-y += hdreg.h
diff --git a/include/linux/cciss_ioctl.h b/include/linux/cciss_ioctl.h
index cb57c30081a..eb130b4d8e7 100644
--- a/include/linux/cciss_ioctl.h
+++ b/include/linux/cciss_ioctl.h
@@ -39,7 +39,7 @@ typedef __u32 DriverVer_type;
 #ifndef CCISS_CMD_H
 // This defines are duplicated in cciss_cmd.h in the driver directory 
 
-//general boundary defintions
+//general boundary definitions
 #define SENSEINFOBYTES          32//note that this value may vary between host implementations
 
 //Command Status value
diff --git a/include/linux/chio.h b/include/linux/chio.h
index 519248d8b2b..d9bac7f9728 100644
--- a/include/linux/chio.h
+++ b/include/linux/chio.h
@@ -21,7 +21,7 @@
  *    query vendor-specific element types
  *
  *    accessing elements works by specifing type and unit of the element.
- *    for eample, storage elements are addressed with type = CHET_ST and
+ *    for example, storage elements are addressed with type = CHET_ST and
  *    unit = 0 .. cp_nslots-1
  *
  */
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index 47536197ffd..e287863ac05 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -43,6 +43,8 @@ extern int sched_create_sysfs_power_savings_entries(struct sysdev_class *cls);
 
 #ifdef CONFIG_HOTPLUG_CPU
 extern void unregister_cpu(struct cpu *cpu);
+extern ssize_t arch_cpu_probe(const char *, size_t);
+extern ssize_t arch_cpu_release(const char *, size_t);
 #endif
 struct notifier_block;
 
@@ -115,6 +117,19 @@ extern void put_online_cpus(void);
 #define unregister_hotcpu_notifier(nb)  unregister_cpu_notifier(nb)
 int cpu_down(unsigned int cpu);
 
+#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
+extern void cpu_hotplug_driver_lock(void);
+extern void cpu_hotplug_driver_unlock(void);
+#else
+static inline void cpu_hotplug_driver_lock(void)
+{
+}
+
+static inline void cpu_hotplug_driver_unlock(void)
+{
+}
+#endif
+
 #else           /* CONFIG_HOTPLUG_CPU */
 
 #define get_online_cpus()       do { } while (0)
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 79a2340d83c..4de02b10007 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -232,6 +232,7 @@ struct cpufreq_driver {
         /* optional */
         unsigned int (*getavg)  (struct cpufreq_policy *policy,
                                  unsigned int cpu);
+        int     (*bios_limit)   (int cpu, unsigned int *limit);
 
         int     (*exit)         (struct cpufreq_policy *policy);
         int     (*suspend)      (struct cpufreq_policy *policy, pm_message_t pmsg);
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index 789cf5f920c..d77b54733c5 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -84,6 +84,7 @@ extern const struct cpumask *const cpu_active_mask;
 #define num_online_cpus()       cpumask_weight(cpu_online_mask)
 #define num_possible_cpus()     cpumask_weight(cpu_possible_mask)
 #define num_present_cpus()      cpumask_weight(cpu_present_mask)
+#define num_active_cpus()       cpumask_weight(cpu_active_mask)
 #define cpu_online(cpu)         cpumask_test_cpu((cpu), cpu_online_mask)
 #define cpu_possible(cpu)       cpumask_test_cpu((cpu), cpu_possible_mask)
 #define cpu_present(cpu)        cpumask_test_cpu((cpu), cpu_present_mask)
@@ -92,6 +93,7 @@ extern const struct cpumask *const cpu_active_mask;
 #define num_online_cpus()       1
 #define num_possible_cpus()     1
 #define num_present_cpus()      1
+#define num_active_cpus()       1
 #define cpu_online(cpu)         ((cpu) == 0)
 #define cpu_possible(cpu)       ((cpu) == 0)
 #define cpu_present(cpu)        ((cpu) == 0)
diff --git a/include/linux/device.h b/include/linux/device.h
index 2ea3e492181..2a73d9bcbc9 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -558,7 +558,7 @@ extern void wait_for_device_probe(void);
 #ifdef CONFIG_DEVTMPFS
 extern int devtmpfs_create_node(struct device *dev);
 extern int devtmpfs_delete_node(struct device *dev);
-extern int devtmpfs_mount(const char *mountpoint);
+extern int devtmpfs_mount(const char *mntdir);
 #else
 static inline int devtmpfs_create_node(struct device *dev) { return 0; }
 static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
diff --git a/include/linux/dm-log-userspace.h b/include/linux/dm-log-userspace.h
index 8a1f972c0fe..0c3c3a2110c 100644
--- a/include/linux/dm-log-userspace.h
+++ b/include/linux/dm-log-userspace.h
@@ -363,7 +363,7 @@
  * various request types above.  The remaining 24-bits are currently
  * set to zero and are reserved for future use and compatibility concerns.
  *
- * User-space should always use DM_ULOG_REQUEST_TYPE to aquire the
+ * User-space should always use DM_ULOG_REQUEST_TYPE to acquire the
  * request type from the 'request_type' field to maintain forward compatibility.
  */
 #define DM_ULOG_REQUEST_MASK 0xFF
diff --git a/include/linux/ext2_fs.h b/include/linux/ext2_fs.h
index 121720d74e1..2dfa7076e8b 100644
--- a/include/linux/ext2_fs.h
+++ b/include/linux/ext2_fs.h
@@ -565,14 +565,14 @@ struct ext2_dir_entry_2 {
  * other bits are reserved for now.
  */
 enum {
-        EXT2_FT_UNKNOWN,
-        EXT2_FT_REG_FILE,
-        EXT2_FT_DIR,
-        EXT2_FT_CHRDEV,
-        EXT2_FT_BLKDEV,
-        EXT2_FT_FIFO,
-        EXT2_FT_SOCK,
-        EXT2_FT_SYMLINK,
+        EXT2_FT_UNKNOWN         = 0,
+        EXT2_FT_REG_FILE        = 1,
+        EXT2_FT_DIR             = 2,
+        EXT2_FT_CHRDEV          = 3,
+        EXT2_FT_BLKDEV          = 4,
+        EXT2_FT_FIFO            = 5,
+        EXT2_FT_SOCK            = 6,
+        EXT2_FT_SYMLINK         = 7,
         EXT2_FT_MAX
 };
 
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index 7499b366779..6b049030fbe 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -918,6 +918,8 @@ extern void ext3_abort (struct super_block *, const char *, const char *, ...)
         __attribute__ ((format (printf, 3, 4)));
 extern void ext3_warning (struct super_block *, const char *, const char *, ...)
         __attribute__ ((format (printf, 3, 4)));
+extern void ext3_msg(struct super_block *, const char *, const char *, ...)
+        __attribute__ ((format (printf, 3, 4)));
 extern void ext3_update_dynamic_rev (struct super_block *sb);
 
 #define ext3_std_error(sb, errno)                               \
diff --git a/include/linux/fb.h b/include/linux/fb.h
index de9c722e7b9..369767bd873 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -763,6 +763,7 @@ struct fb_tile_ops {
          *  takes over; acceleration engine should be in a quiescent state */
 
 /* hints */
+#define FBINFO_VIRTFB           0x0004 /* FB is System RAM, not device. */
 #define FBINFO_PARTIAL_PAN_OK   0x0040 /* otw use pan only for double-buffering */
 #define FBINFO_READS_FAST       0x0080 /* soft-copy faster than rendering */
 
diff --git a/include/linux/firmware.h b/include/linux/firmware.h
index d3154462843..043811f0d27 100644
--- a/include/linux/firmware.h
+++ b/include/linux/firmware.h
@@ -4,6 +4,7 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/compiler.h>
+#include <linux/gfp.h>
 
 #define FW_ACTION_NOHOTPLUG 0
 #define FW_ACTION_HOTPLUG 1
@@ -38,7 +39,7 @@ int request_firmware(const struct firmware **fw, const char *name,
                      struct device *device);
 int request_firmware_nowait(
         struct module *module, int uevent,
-        const char *name, struct device *device, void *context,
+        const char *name, struct device *device, gfp_t gfp, void *context,
         void (*cont)(const struct firmware *fw, void *context));
 
 void release_firmware(const struct firmware *fw);
@@ -51,7 +52,7 @@ static inline int request_firmware(const struct firmware **fw,
 }
 static inline int request_firmware_nowait(
         struct module *module, int uevent,
-        const char *name, struct device *device, void *context,
+        const char *name, struct device *device, gfp_t gfp, void *context,
         void (*cont)(const struct firmware *fw, void *context))
 {
         return -EINVAL;
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 891f7d642e5..a057f48eb15 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2091,8 +2091,6 @@ extern int filemap_fdatawait_range(struct address_space *, loff_t lstart,
 extern int filemap_write_and_wait(struct address_space *mapping);
 extern int filemap_write_and_wait_range(struct address_space *mapping,
                                         loff_t lstart, loff_t lend);
-extern int wait_on_page_writeback_range(struct address_space *mapping,
-                                pgoff_t start, pgoff_t end);
 extern int __filemap_fdatawrite_range(struct address_space *mapping,
                                 loff_t start, loff_t end, int sync_mode);
 extern int filemap_fdatawrite_range(struct address_space *mapping,
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
index 43fc95d822d..28e33fea510 100644
--- a/include/linux/fsl_devices.h
+++ b/include/linux/fsl_devices.h
@@ -74,7 +74,12 @@ struct spi_device;
 struct fsl_spi_platform_data {
         u32     initial_spmode; /* initial SPMODE value */
         s16     bus_num;
-        bool    qe_mode;
+        unsigned int flags;
+#define SPI_QE_CPU_MODE         (1 << 0) /* QE CPU ("PIO") mode */
+#define SPI_CPM_MODE            (1 << 1) /* CPM/QE ("DMA") mode */
+#define SPI_CPM1                (1 << 2) /* SPI unit is in CPM1 block */
+#define SPI_CPM2                (1 << 3) /* SPI unit is in CPM2 block */
+#define SPI_QE                  (1 << 4) /* SPI unit is in QE block */
         /* board specific information */
         u16     max_chipselect;
         void    (*cs_control)(struct spi_device *spi, bool on);
@@ -90,6 +95,10 @@ struct mpc8xx_pcmcia_ops {
  * lead to a deep sleep (i.e. power removed from the core,
  * instead of just the clock).
  */
+#if defined(CONFIG_PPC_83xx) && defined(CONFIG_SUSPEND)
 int fsl_deep_sleep(void);
+#else
+static inline int fsl_deep_sleep(void) { return 0; }
+#endif
 
 #endif /* _FSL_DEVICE_H_ */
diff --git a/include/linux/gigaset_dev.h b/include/linux/gigaset_dev.h
index 5dc4a316ca3..258ba82937e 100644
--- a/include/linux/gigaset_dev.h
+++ b/include/linux/gigaset_dev.h
@@ -16,15 +16,23 @@
 
 #include <linux/ioctl.h>
 
+/* The magic IOCTL value for this interface. */
 #define GIGASET_IOCTL 0x47
 
-#define GIGVER_DRIVER 0
-#define GIGVER_COMPAT 1
-#define GIGVER_FWBASE 2
+/* enable/disable device control via character device (lock out ISDN subsys) */
+#define GIGASET_REDIR    _IOWR(GIGASET_IOCTL, 0, int)
 
-#define GIGASET_REDIR    _IOWR (GIGASET_IOCTL, 0, int)
-#define GIGASET_CONFIG   _IOWR (GIGASET_IOCTL, 1, int)
-#define GIGASET_BRKCHARS _IOW  (GIGASET_IOCTL, 2, unsigned char[6]) //FIXME [6] okay?
-#define GIGASET_VERSION  _IOWR (GIGASET_IOCTL, 3, unsigned[4])
+/* enable adapter configuration mode (M10x only) */
+#define GIGASET_CONFIG   _IOWR(GIGASET_IOCTL, 1, int)
+
+/* set break characters (M105 only) */
+#define GIGASET_BRKCHARS _IOW(GIGASET_IOCTL, 2, unsigned char[6])
+
+/* get version information selected by arg[0] */
+#define GIGASET_VERSION  _IOWR(GIGASET_IOCTL, 3, unsigned[4])
+/* values for GIGASET_VERSION arg[0] */
+#define GIGVER_DRIVER 0         /* get driver version */
+#define GIGVER_COMPAT 1         /* get interface compatibility version */
+#define GIGVER_FWBASE 2         /* get base station firmware version */
 
 #endif
diff --git a/include/linux/hayesesp.h b/include/linux/hayesesp.h
deleted file mode 100644
index 92b08cfe4a7..00000000000
--- a/include/linux/hayesesp.h
+++ /dev/null
@@ -1,114 +0,0 @@
-#ifndef HAYESESP_H
-#define HAYESESP_H
-
-struct hayes_esp_config {
-        short flow_on;
-        short flow_off;
-        short rx_trigger;
-        short tx_trigger;
-        short pio_threshold;
-        unsigned char rx_timeout;
-        char dma_channel;
-};
-
-#ifdef __KERNEL__
-
-#define ESP_DMA_CHANNEL   0
-#define ESP_RX_TRIGGER    768
-#define ESP_TX_TRIGGER    768
-#define ESP_FLOW_OFF      1016
-#define ESP_FLOW_ON       944
-#define ESP_RX_TMOUT      128
-#define ESP_PIO_THRESHOLD 32
-
-#define ESP_IN_MAJOR    57      /* major dev # for dial in */
-#define ESP_OUT_MAJOR   58      /* major dev # for dial out */
-#define ESPC_SCALE      3
-#define UART_ESI_BASE   0x00
-#define UART_ESI_SID    0x01
-#define UART_ESI_RX     0x02
-#define UART_ESI_TX     0x02
-#define UART_ESI_CMD1   0x04
-#define UART_ESI_CMD2   0x05
-#define UART_ESI_STAT1  0x04
-#define UART_ESI_STAT2  0x05
-#define UART_ESI_RWS    0x07
-
-#define UART_IER_DMA_TMOUT      0x80
-#define UART_IER_DMA_TC         0x08
-
-#define ESI_SET_IRQ             0x04
-#define ESI_SET_DMA_TMOUT       0x05
-#define ESI_SET_SRV_MASK        0x06
-#define ESI_SET_ERR_MASK        0x07
-#define ESI_SET_FLOW_CNTL       0x08
-#define ESI_SET_FLOW_CHARS      0x09
-#define ESI_SET_FLOW_LVL        0x0a
-#define ESI_SET_TRIGGER         0x0b
-#define ESI_SET_RX_TIMEOUT      0x0c
-#define ESI_SET_FLOW_TMOUT      0x0d
-#define ESI_WRITE_UART          0x0e
-#define ESI_READ_UART           0x0f
-#define ESI_SET_MODE            0x10
-#define ESI_GET_ERR_STAT        0x12
-#define ESI_GET_UART_STAT       0x13
-#define ESI_GET_RX_AVAIL        0x14
-#define ESI_GET_TX_AVAIL        0x15
-#define ESI_START_DMA_RX        0x16
-#define ESI_START_DMA_TX        0x17
-#define ESI_ISSUE_BREAK         0x1a
-#define ESI_FLUSH_RX            0x1b
-#define ESI_FLUSH_TX            0x1c
-#define ESI_SET_BAUD            0x1d
-#define ESI_SET_ENH_IRQ         0x1f
-#define ESI_SET_REINTR          0x20
-#define ESI_SET_PRESCALAR       0x23
-#define ESI_NO_COMMAND          0xff
-
-#define ESP_STAT_RX_TIMEOUT     0x01
-#define ESP_STAT_DMA_RX         0x02
-#define ESP_STAT_DMA_TX         0x04
-#define ESP_STAT_NEVER_DMA      0x08
-#define ESP_STAT_USE_PIO        0x10
-
-#define ESP_MAGIC               0x53ee
-#define ESP_XMIT_SIZE           4096
-
-struct esp_struct {
-        int                     magic;
-        struct tty_port         port;
-        spinlock_t              lock;
-        int                     io_port;
-        int                     irq;
-        int                     read_status_mask;
-        int                     ignore_status_mask;
-        int                     timeout;
-        int                     stat_flags;
-        int                     custom_divisor;
-        int                     close_delay;
-        unsigned short          closing_wait;
-        unsigned short          closing_wait2;
-        int                     IER;    /* Interrupt Enable Register */
-        int                     MCR;    /* Modem control register */
-        unsigned long           last_active;
-        int                     line;
-        unsigned char           *xmit_buf;
-        int                     xmit_head;
-        int                     xmit_tail;
-        int                     xmit_cnt;
-        wait_queue_head_t       break_wait;
-        struct async_icount     icount; /* kernel counters for the 4 input interrupts */
-        struct hayes_esp_config config; /* port configuration */
-        struct esp_struct       *next_port; /* For the linked list */
-};
-
-struct esp_pio_buffer {
-        unsigned char data[1024];
-        struct esp_pio_buffer *next;
-};
-
-#endif /* __KERNEL__ */
-
-
-#endif /* ESP_H */
-
diff --git a/include/linux/hid.h b/include/linux/hid.h
index 10f62841674..87093652dda 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -312,6 +312,7 @@ struct hid_item {
 #define HID_QUIRK_MULTI_INPUT                   0x00000040
 #define HID_QUIRK_SKIP_OUTPUT_REPORTS           0x00010000
 #define HID_QUIRK_FULLSPEED_INTERVAL            0x10000000
+#define HID_QUIRK_NO_INIT_REPORTS               0x20000000
 
 /*
  * This is the global environment of the parser. This information is
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 9bace4b9f4f..af634e95871 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -162,10 +162,11 @@ struct hrtimer_clock_base {
  * @expires_next:       absolute time of the next event which was scheduled
  *                      via clock_set_next_event()
  * @hres_active:        State of high resolution mode
- * @check_clocks:       Indictator, when set evaluate time source and clock
- *                      event devices whether high resolution mode can be
- *                      activated.
- * @nr_events:          Total number of timer interrupt events
+ * @hang_detected:      The last hrtimer interrupt detected a hang
+ * @nr_events:          Total number of hrtimer interrupt events
+ * @nr_retries:         Total number of hrtimer interrupt retries
+ * @nr_hangs:           Total number of hrtimer interrupt hangs
+ * @max_hang_time:      Maximum time spent in hrtimer_interrupt
  */
 struct hrtimer_cpu_base {
         spinlock_t                      lock;
@@ -173,7 +174,11 @@ struct hrtimer_cpu_base {
 #ifdef CONFIG_HIGH_RES_TIMERS
         ktime_t                         expires_next;
         int                             hres_active;
+        int                             hang_detected;
         unsigned long                   nr_events;
+        unsigned long                   nr_retries;
+        unsigned long                   nr_hangs;
+        ktime_t                         max_hang_time;
 #endif
 };
 
@@ -435,47 +440,4 @@ extern u64 ktime_divns(const ktime_t kt, s64 div);
 /* Show pending timers: */
 extern void sysrq_timer_list_show(void);
 
-/*
- * Timer-statistics info:
- */
-#ifdef CONFIG_TIMER_STATS
-
-extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf,
-                                     void *timerf, char *comm,
-                                     unsigned int timer_flag);
-
-static inline void timer_stats_account_hrtimer(struct hrtimer *timer)
-{
-        if (likely(!timer_stats_active))
-                return;
-        timer_stats_update_stats(timer, timer->start_pid, timer->start_site,
-                                 timer->function, timer->start_comm, 0);
-}
-
-extern void __timer_stats_hrtimer_set_start_info(struct hrtimer *timer,
-                                                 void *addr);
-
-static inline void timer_stats_hrtimer_set_start_info(struct hrtimer *timer)
-{
-        __timer_stats_hrtimer_set_start_info(timer, __builtin_return_address(0));
-}
-
-static inline void timer_stats_hrtimer_clear_start_info(struct hrtimer *timer)
-{
-        timer->start_site = NULL;
-}
-#else
-static inline void timer_stats_account_hrtimer(struct hrtimer *timer)
-{
-}
-
-static inline void timer_stats_hrtimer_set_start_info(struct hrtimer *timer)
-{
-}
-
-static inline void timer_stats_hrtimer_clear_start_info(struct hrtimer *timer)
-{
-}
-#endif
-
 #endif
diff --git a/include/linux/hw_breakpoint.h b/include/linux/hw_breakpoint.h
index a03daed08c5..69f07a9f127 100644
--- a/include/linux/hw_breakpoint.h
+++ b/include/linux/hw_breakpoint.h
@@ -20,19 +20,18 @@ enum {
 
 #ifdef CONFIG_HAVE_HW_BREAKPOINT
 
-/* As it's for in-kernel or ptrace use, we want it to be pinned */
-#define DEFINE_BREAKPOINT_ATTR(name)    \
-struct perf_event_attr name = {         \
-        .type = PERF_TYPE_BREAKPOINT,   \
-        .size = sizeof(name),           \
-        .pinned = 1,                    \
-};
-
 static inline void hw_breakpoint_init(struct perf_event_attr *attr)
 {
+        memset(attr, 0, sizeof(*attr));
+
         attr->type = PERF_TYPE_BREAKPOINT;
         attr->size = sizeof(*attr);
+        /*
+         * As it's for in-kernel or ptrace use, we want it to be pinned
+         * and to call its callback every hits.
+         */
         attr->pinned = 1;
+        attr->sample_period = 1;
 }
 
 static inline unsigned long hw_breakpoint_addr(struct perf_event *bp)
@@ -52,27 +51,24 @@ static inline int hw_breakpoint_len(struct perf_event *bp)
 
 extern struct perf_event *
 register_user_hw_breakpoint(struct perf_event_attr *attr,
-                            perf_callback_t triggered,
+                            perf_overflow_handler_t triggered,
                             struct task_struct *tsk);
 
 /* FIXME: only change from the attr, and don't unregister */
-extern struct perf_event *
-modify_user_hw_breakpoint(struct perf_event *bp,
-                          struct perf_event_attr *attr,
-                          perf_callback_t triggered,
-                          struct task_struct *tsk);
+extern int
+modify_user_hw_breakpoint(struct perf_event *bp, struct perf_event_attr *attr);
 
 /*
  * Kernel breakpoints are not associated with any particular thread.
  */
 extern struct perf_event *
 register_wide_hw_breakpoint_cpu(struct perf_event_attr *attr,
-                                perf_callback_t triggered,
+                                perf_overflow_handler_t triggered,
                                 int cpu);
 
 extern struct perf_event **
 register_wide_hw_breakpoint(struct perf_event_attr *attr,
-                            perf_callback_t triggered);
+                            perf_overflow_handler_t triggered);
 
 extern int register_perf_hw_breakpoint(struct perf_event *bp);
 extern int __register_perf_hw_breakpoint(struct perf_event *bp);
@@ -93,20 +89,18 @@ static inline struct arch_hw_breakpoint *counter_arch_bp(struct perf_event *bp)
 
 static inline struct perf_event *
 register_user_hw_breakpoint(struct perf_event_attr *attr,
-                            perf_callback_t triggered,
+                            perf_overflow_handler_t triggered,
                             struct task_struct *tsk)    { return NULL; }
-static inline struct perf_event *
+static inline int
 modify_user_hw_breakpoint(struct perf_event *bp,
-                          struct perf_event_attr *attr,
-                          perf_callback_t triggered,
-                          struct task_struct *tsk)      { return NULL; }
+                          struct perf_event_attr *attr) { return NULL; }
 static inline struct perf_event *
 register_wide_hw_breakpoint_cpu(struct perf_event_attr *attr,
-                                perf_callback_t triggered,
+                                perf_overflow_handler_t  triggered,
                                 int cpu)                { return NULL; }
 static inline struct perf_event **
 register_wide_hw_breakpoint(struct perf_event_attr *attr,
-                            perf_callback_t triggered)  { return NULL; }
+                            perf_overflow_handler_t triggered)  { return NULL; }
 static inline int
 register_perf_hw_breakpoint(struct perf_event *bp)      { return -ENOSYS; }
 static inline int
diff --git a/include/linux/ide.h b/include/linux/ide.h
index e4135d6e055..0ec61295904 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -125,8 +125,8 @@ struct ide_io_ports {
  * Timeouts for various operations:
  */
 enum {
-        /* spec allows up to 20ms */
-        WAIT_DRQ        = HZ / 10,      /* 100ms */
+        /* spec allows up to 20ms, but CF cards and SSD drives need more */
+        WAIT_DRQ        = 1 * HZ,       /* 1s */
         /* some laptops are very slow */
         WAIT_READY      = 5 * HZ,       /* 5s */
         /* should be less than 3ms (?), if all ATAPI CD is closed at boot */
diff --git a/include/linux/if_ether.h b/include/linux/if_ether.h
index 005e1525ab8..299b4121f91 100644
--- a/include/linux/if_ether.h
+++ b/include/linux/if_ether.h
@@ -137,8 +137,6 @@ extern struct ctl_table ether_table[];
 extern ssize_t sysfs_format_mac(char *buf, const unsigned char *addr, int len);
 
 #define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
-#define MAC_BUF_SIZE    18
-#define DECLARE_MAC_BUF(var) char var[MAC_BUF_SIZE]
 
 #endif
 
diff --git a/include/linux/in6.h b/include/linux/in6.h
index dfa29168e6a..bd55c6e46b2 100644
--- a/include/linux/in6.h
+++ b/include/linux/in6.h
@@ -110,7 +110,7 @@ struct in6_flowlabel_req {
 #define IPV6_FLOWINFO_FLOWLABEL         0x000fffff
 #define IPV6_FLOWINFO_PRIORITY          0x0ff00000
 
-/* These defintions are obsolete */
+/* These definitions are obsolete */
 #define IPV6_PRIORITY_UNCHARACTERIZED   0x0000
 #define IPV6_PRIORITY_FILLER            0x0100
 #define IPV6_PRIORITY_UNATTENDED        0x0200
diff --git a/include/linux/input-polldev.h b/include/linux/input-polldev.h
index 597a0077b3c..5e3dddf8f56 100644
--- a/include/linux/input-polldev.h
+++ b/include/linux/input-polldev.h
@@ -14,12 +14,19 @@
 
 /**
  * struct input_polled_dev - simple polled input device
- * @private: private driver data
- * @flush: driver-supplied method that flushes device's state upon
- *      opening (optional)
+ * @private: private driver data.
+ * @open: driver-supplied method that prepares device for polling
+ *      (enabled the device and maybe flushes device state).
+ * @close: driver-supplied method that is called when device is no
+ *      longer being polled. Used to put device into low power mode.
  * @poll: driver-supplied method that polls the device and posts
  *      input events (mandatory).
- * @poll_interval: specifies how often the poll() method shoudl be called.
+ * @poll_interval: specifies how often the poll() method should be called.
+ *      Defaults to 500 msec unless overriden when registering the device.
+ * @poll_interval_max: specifies upper bound for the poll interval.
+ *      Defaults to the initial value of @poll_interval.
+ * @poll_interval_min: specifies lower bound for the poll interval.
+ *      Defaults to 0.
  * @input: input device structire associated with the polled device.
  *      Must be properly initialized by the driver (id, name, phys, bits).
  *
@@ -30,11 +37,16 @@
 struct input_polled_dev {
         void *private;
 
-        void (*flush)(struct input_polled_dev *dev);
+        void (*open)(struct input_polled_dev *dev);
+        void (*close)(struct input_polled_dev *dev);
         void (*poll)(struct input_polled_dev *dev);
         unsigned int poll_interval; /* msec */
+        unsigned int poll_interval_max; /* msec */
+        unsigned int poll_interval_min; /* msec */
 
         struct input_dev *input;
+
+/* private: */
         struct delayed_work work;
 };
 
diff --git a/include/linux/input.h b/include/linux/input.h
index 84b501ab0d8..7be8a6537b5 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -895,7 +895,7 @@ struct ff_periodic_effect {
         struct ff_envelope envelope;
 
         __u32 custom_len;
-        __s16 *custom_data;
+        __s16 __user *custom_data;
 };
 
 /**
@@ -1021,9 +1021,12 @@ struct ff_effect {
  * @keycodesize: size of elements in keycode table
  * @keycode: map of scancodes to keycodes for this device
  * @setkeycode: optional method to alter current keymap, used to implement
- *      sparse keymaps. If not supplied default mechanism will be used
+ *      sparse keymaps. If not supplied default mechanism will be used.
+ *      The method is being called while holding event_lock and thus must
+ *      not sleep
  * @getkeycode: optional method to retrieve current keymap. If not supplied
- *      default mechanism will be used
+ *      default mechanism will be used. The method is being called while
+ *      holding event_lock and thus must not sleep
  * @ff: force feedback structure associated with the device if device
  *      supports force feedback effects
  * @repeat_key: stores key code of the last key pressed; used to implement
@@ -1040,6 +1043,7 @@ struct ff_effect {
  * @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,
@@ -1294,6 +1298,9 @@ void input_unregister_device(struct input_dev *);
 int __must_check input_register_handler(struct input_handler *);
 void input_unregister_handler(struct input_handler *);
 
+int input_handler_for_each_handle(struct input_handler *, void *data,
+                                  int (*fn)(struct input_handle *, void *));
+
 int input_register_handle(struct input_handle *);
 void input_unregister_handle(struct input_handle *);
 
diff --git a/include/linux/input/matrix_keypad.h b/include/linux/input/matrix_keypad.h
index b3cd42d50e1..3bd018baae2 100644
--- a/include/linux/input/matrix_keypad.h
+++ b/include/linux/input/matrix_keypad.h
@@ -41,6 +41,9 @@ struct matrix_keymap_data {
  * @col_scan_delay_us: delay, measured in microseconds, that is
  *      needed before we can keypad after activating column gpio
  * @debounce_ms: debounce interval in milliseconds
+ * @active_low: gpio polarity
+ * @wakeup: controls whether the device should be set up as wakeup
+ *      source
  *
  * This structure represents platform-specific data that use used by
  * matrix_keypad driver to perform proper initialization.
diff --git a/include/linux/input/sh_keysc.h b/include/linux/input/sh_keysc.h
new file mode 100644
index 00000000000..c211b5cf08e
--- /dev/null
+++ b/include/linux/input/sh_keysc.h
@@ -0,0 +1,14 @@
+#ifndef __SH_KEYSC_H__
+#define __SH_KEYSC_H__
+
+#define SH_KEYSC_MAXKEYS 30
+
+struct sh_keysc_info {
+        enum { SH_KEYSC_MODE_1, SH_KEYSC_MODE_2, SH_KEYSC_MODE_3 } mode;
+        int scan_timing; /* 0 -> 7, see KYCR1, SCN[2:0] */
+        int delay;
+        int kycr2_delay;
+        int keycodes[SH_KEYSC_MAXKEYS];
+};
+
+#endif /* __SH_KEYSC_H__ */
diff --git a/include/linux/input/sparse-keymap.h b/include/linux/input/sparse-keymap.h
new file mode 100644
index 00000000000..52db62064c6
--- /dev/null
+++ b/include/linux/input/sparse-keymap.h
@@ -0,0 +1,62 @@
+#ifndef _SPARSE_KEYMAP_H
+#define _SPARSE_KEYMAP_H
+
+/*
+ * Copyright (c) 2009 Dmitry Torokhov
+ *
+ * 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.
+ */
+
+#define KE_END          0       /* Indicates end of keymap */
+#define KE_KEY          1       /* Ordinary key/button */
+#define KE_SW           2       /* Switch (predetermined value) */
+#define KE_VSW          3       /* Switch (value supplied at runtime) */
+#define KE_IGNORE       4       /* Known entry that should be ignored */
+#define KE_LAST         KE_IGNORE
+
+/**
+ * struct key_entry - keymap entry for use in sparse keymap
+ * @type: Type of the key entry (KE_KEY, KE_SW, KE_VSW, KE_END);
+ *      drivers are allowed to extend the list with their own
+ *      private definitions.
+ * @code: Device-specific data identifying the button/switch
+ * @keycode: KEY_* code assigned to a key/button
+ * @sw.code: SW_* code assigned to a switch
+ * @sw.value: Value that should be sent in an input even when KE_SW
+ *      switch is toggled. KE_VSW switches ignore this field and
+ *      expect driver to supply value for the event.
+ *
+ * This structure defines an entry in a sparse keymap used by some
+ * input devices for which traditional table-based approach is not
+ * suitable.
+ */
+struct key_entry {
+        int type;               /* See KE_* above */
+        u32 code;
+        union {
+                u16 keycode;            /* For KE_KEY */
+                struct {                /* For KE_SW, KE_VSW */
+                        u8 code;
+                        u8 value;       /* For KE_SW, ignored by KE_VSW */
+                } sw;
+        };
+};
+
+struct key_entry *sparse_keymap_entry_from_scancode(struct input_dev *dev,
+                                                    unsigned int code);
+struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev,
+                                                   unsigned int code);
+int sparse_keymap_setup(struct input_dev *dev,
+                        const struct key_entry *keymap,
+                        int (*setup)(struct input_dev *, struct key_entry *));
+void sparse_keymap_free(struct input_dev *dev);
+
+void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke,
+                                unsigned int value, bool autorelease);
+
+bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code,
+                                unsigned int value, bool autorelease);
+
+#endif /* _SPARSE_KEYMAP_H */
diff --git a/include/linux/irq.h b/include/linux/irq.h
index ae9653dbcd7..a287cfc0b1a 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -282,7 +282,7 @@ extern irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action);
 
 /*
  * Built-in IRQ handlers for various IRQ types,
- * callable via desc->chip->handle_irq()
+ * callable via desc->handle_irq()
  */
 extern void handle_level_irq(unsigned int irq, struct irq_desc *desc);
 extern void handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc);
diff --git a/include/linux/isicom.h b/include/linux/isicom.h
index bbd42197298..b92e0565063 100644
--- a/include/linux/isicom.h
+++ b/include/linux/isicom.h
@@ -67,6 +67,7 @@
 
 #define         FIRMWARE_LOADED         0x0001
 #define         BOARD_ACTIVE            0x0002
+#define         BOARD_INIT              0x0004
 
         /* isi_port status bitmap  */
 
diff --git a/include/linux/kvm.h b/include/linux/kvm.h
index 2d241da0723..a24de0b1858 100644
--- a/include/linux/kvm.h
+++ b/include/linux/kvm.h
@@ -496,6 +496,7 @@ struct kvm_ioeventfd {
 #define KVM_CAP_VCPU_EVENTS 41
 #endif
 #define KVM_CAP_S390_PSW 42
+#define KVM_CAP_PPC_SEGSTATE 43
 
 #ifdef KVM_CAP_IRQ_ROUTING
 
diff --git a/include/linux/libata.h b/include/linux/libata.h
index a5b3dc71e81..6a9c4ddd3d9 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -1024,7 +1024,7 @@ extern int ata_std_bios_param(struct scsi_device *sdev,
 extern int ata_scsi_slave_config(struct scsi_device *sdev);
 extern void ata_scsi_slave_destroy(struct scsi_device *sdev);
 extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
-                                       int queue_depth);
+                                       int queue_depth, int reason);
 extern struct ata_device *ata_dev_pair(struct ata_device *adev);
 extern int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);
 
diff --git a/include/linux/mfd/ezx-pcap.h b/include/linux/mfd/ezx-pcap.h
index e5124ceea76..3402042ddc3 100644
--- a/include/linux/mfd/ezx-pcap.h
+++ b/include/linux/mfd/ezx-pcap.h
@@ -45,7 +45,7 @@ void pcap_set_ts_bits(struct pcap_chip *, u32);
 #define PCAP_CLEAR_INTERRUPT_REGISTER   0x01ffffff
 #define PCAP_MASK_ALL_INTERRUPT         0x01ffffff
 
-/* registers acessible by both pcap ports */
+/* registers accessible by both pcap ports */
 #define PCAP_REG_ISR            0x0     /* Interrupt Status */
 #define PCAP_REG_MSR            0x1     /* Interrupt Mask */
 #define PCAP_REG_PSTAT          0x2     /* Processor Status */
@@ -67,7 +67,7 @@ void pcap_set_ts_bits(struct pcap_chip *, u32);
 #define PCAP_REG_VENDOR_TEST1   0x1e
 #define PCAP_REG_VENDOR_TEST2   0x1f
 
-/* registers acessible by pcap port 1 only (a1200, e2 & e6) */
+/* registers accessible by pcap port 1 only (a1200, e2 & e6) */
 #define PCAP_REG_INT_SEL        0x3     /* Interrupt Select */
 #define PCAP_REG_SWCTRL         0x4     /* Switching Regulator Control */
 #define PCAP_REG_VREG1          0x5     /* Regulator Bank 1 Control */
diff --git a/include/linux/mfd/sh_mobile_sdhi.h b/include/linux/mfd/sh_mobile_sdhi.h
new file mode 100644
index 00000000000..3bcd7163485
--- /dev/null
+++ b/include/linux/mfd/sh_mobile_sdhi.h
@@ -0,0 +1,8 @@
+#ifndef __SH_MOBILE_SDHI_H__
+#define __SH_MOBILE_SDHI_H__
+
+struct sh_mobile_sdhi_info {
+        void (*set_pwr)(struct platform_device *pdev, int state);
+};
+
+#endif /* __SH_MOBILE_SDHI_H__ */
diff --git a/include/linux/mtd/ubi.h b/include/linux/mtd/ubi.h
index 6913b71d9ab..b31bd9e9bca 100644
--- a/include/linux/mtd/ubi.h
+++ b/include/linux/mtd/ubi.h
@@ -174,6 +174,8 @@ void ubi_get_volume_info(struct ubi_volume_desc *desc,
 struct ubi_volume_desc *ubi_open_volume(int ubi_num, int vol_id, int mode);
 struct ubi_volume_desc *ubi_open_volume_nm(int ubi_num, const char *name,
                                            int mode);
+struct ubi_volume_desc *ubi_open_volume_path(const char *pathname, int mode);
+
 int ubi_register_volume_notifier(struct notifier_block *nb,
                                  int ignore_existing);
 int ubi_unregister_volume_notifier(struct notifier_block *nb);
diff --git a/include/linux/namei.h b/include/linux/namei.h
index ec0f607b364..02894675028 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -76,7 +76,6 @@ extern struct file *nameidata_to_filp(struct nameidata *nd, int flags);
 extern void release_open_intent(struct nameidata *);
 
 extern struct dentry *lookup_one_len(const char *, struct dentry *, int);
-extern struct dentry *lookup_one_noperm(const char *, struct dentry *);
 
 extern int follow_down(struct path *);
 extern int follow_up(struct path *);
diff --git a/include/linux/nilfs2_fs.h b/include/linux/nilfs2_fs.h
index ce520402e84..3fe02cf8b65 100644
--- a/include/linux/nilfs2_fs.h
+++ b/include/linux/nilfs2_fs.h
@@ -151,6 +151,8 @@ struct nilfs_super_root {
 #define NILFS_MOUNT_BARRIER             0x1000  /* Use block barriers */
 #define NILFS_MOUNT_STRICT_ORDER        0x2000  /* Apply strict in-order
                                                    semantics also for data */
+#define NILFS_MOUNT_NORECOVERY          0x4000  /* Disable write access during
+                                                   mount-time recovery */
 
 
 /**
@@ -403,6 +405,28 @@ struct nilfs_segment_summary {
 #define NILFS_SS_GC     0x0010  /* segment written for cleaner operation */
 
 /**
+ * struct nilfs_btree_node - B-tree node
+ * @bn_flags: flags
+ * @bn_level: level
+ * @bn_nchildren: number of children
+ * @bn_pad: padding
+ */
+struct nilfs_btree_node {
+        __u8 bn_flags;
+        __u8 bn_level;
+        __le16 bn_nchildren;
+        __le32 bn_pad;
+};
+
+/* flags */
+#define NILFS_BTREE_NODE_ROOT   0x01
+
+/* level */
+#define NILFS_BTREE_LEVEL_DATA          0
+#define NILFS_BTREE_LEVEL_NODE_MIN      (NILFS_BTREE_LEVEL_DATA + 1)
+#define NILFS_BTREE_LEVEL_MAX           14
+
+/**
  * struct nilfs_palloc_group_desc - block group descriptor
  * @pg_nfrees: number of free entries in block group
  */
diff --git a/include/linux/omapfb.h b/include/linux/omapfb.h
new file mode 100644
index 00000000000..f46c40ac6d4
--- /dev/null
+++ b/include/linux/omapfb.h
@@ -0,0 +1,251 @@
+/*
+ * File: include/linux/omapfb.h
+ *
+ * Framebuffer driver for TI OMAP boards
+ *
+ * Copyright (C) 2004 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 as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#ifndef __LINUX_OMAPFB_H__
+#define __LINUX_OMAPFB_H__
+
+#include <linux/fb.h>
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+/* IOCTL commands. */
+
+#define OMAP_IOW(num, dtype)    _IOW('O', num, dtype)
+#define OMAP_IOR(num, dtype)    _IOR('O', num, dtype)
+#define OMAP_IOWR(num, dtype)   _IOWR('O', num, dtype)
+#define OMAP_IO(num)            _IO('O', num)
+
+#define OMAPFB_MIRROR           OMAP_IOW(31, int)
+#define OMAPFB_SYNC_GFX         OMAP_IO(37)
+#define OMAPFB_VSYNC            OMAP_IO(38)
+#define OMAPFB_SET_UPDATE_MODE  OMAP_IOW(40, int)
+#define OMAPFB_GET_CAPS         OMAP_IOR(42, struct omapfb_caps)
+#define OMAPFB_GET_UPDATE_MODE  OMAP_IOW(43, int)
+#define OMAPFB_LCD_TEST         OMAP_IOW(45, int)
+#define OMAPFB_CTRL_TEST        OMAP_IOW(46, int)
+#define OMAPFB_UPDATE_WINDOW_OLD OMAP_IOW(47, struct omapfb_update_window_old)
+#define OMAPFB_SET_COLOR_KEY    OMAP_IOW(50, struct omapfb_color_key)
+#define OMAPFB_GET_COLOR_KEY    OMAP_IOW(51, struct omapfb_color_key)
+#define OMAPFB_SETUP_PLANE      OMAP_IOW(52, struct omapfb_plane_info)
+#define OMAPFB_QUERY_PLANE      OMAP_IOW(53, struct omapfb_plane_info)
+#define OMAPFB_UPDATE_WINDOW    OMAP_IOW(54, struct omapfb_update_window)
+#define OMAPFB_SETUP_MEM        OMAP_IOW(55, struct omapfb_mem_info)
+#define OMAPFB_QUERY_MEM        OMAP_IOW(56, struct omapfb_mem_info)
+#define OMAPFB_WAITFORVSYNC     OMAP_IO(57)
+#define OMAPFB_MEMORY_READ      OMAP_IOR(58, struct omapfb_memory_read)
+#define OMAPFB_GET_OVERLAY_COLORMODE OMAP_IOR(59, struct omapfb_ovl_colormode)
+#define OMAPFB_WAITFORGO        OMAP_IO(60)
+#define OMAPFB_GET_VRAM_INFO    OMAP_IOR(61, struct omapfb_vram_info)
+#define OMAPFB_SET_TEARSYNC     OMAP_IOW(62, struct omapfb_tearsync_info)
+
+#define OMAPFB_CAPS_GENERIC_MASK        0x00000fff
+#define OMAPFB_CAPS_LCDC_MASK           0x00fff000
+#define OMAPFB_CAPS_PANEL_MASK          0xff000000
+
+#define OMAPFB_CAPS_MANUAL_UPDATE       0x00001000
+#define OMAPFB_CAPS_TEARSYNC            0x00002000
+#define OMAPFB_CAPS_PLANE_RELOCATE_MEM  0x00004000
+#define OMAPFB_CAPS_PLANE_SCALE         0x00008000
+#define OMAPFB_CAPS_WINDOW_PIXEL_DOUBLE 0x00010000
+#define OMAPFB_CAPS_WINDOW_SCALE        0x00020000
+#define OMAPFB_CAPS_WINDOW_OVERLAY      0x00040000
+#define OMAPFB_CAPS_WINDOW_ROTATE       0x00080000
+#define OMAPFB_CAPS_SET_BACKLIGHT       0x01000000
+
+/* Values from DSP must map to lower 16-bits */
+#define OMAPFB_FORMAT_MASK              0x00ff
+#define OMAPFB_FORMAT_FLAG_DOUBLE       0x0100
+#define OMAPFB_FORMAT_FLAG_TEARSYNC     0x0200
+#define OMAPFB_FORMAT_FLAG_FORCE_VSYNC  0x0400
+#define OMAPFB_FORMAT_FLAG_ENABLE_OVERLAY       0x0800
+#define OMAPFB_FORMAT_FLAG_DISABLE_OVERLAY      0x1000
+
+#define OMAPFB_MEMTYPE_SDRAM            0
+#define OMAPFB_MEMTYPE_SRAM             1
+#define OMAPFB_MEMTYPE_MAX              1
+
+enum omapfb_color_format {
+        OMAPFB_COLOR_RGB565 = 0,
+        OMAPFB_COLOR_YUV422,
+        OMAPFB_COLOR_YUV420,
+        OMAPFB_COLOR_CLUT_8BPP,
+        OMAPFB_COLOR_CLUT_4BPP,
+        OMAPFB_COLOR_CLUT_2BPP,
+        OMAPFB_COLOR_CLUT_1BPP,
+        OMAPFB_COLOR_RGB444,
+        OMAPFB_COLOR_YUY422,
+
+        OMAPFB_COLOR_ARGB16,
+        OMAPFB_COLOR_RGB24U,    /* RGB24, 32-bit container */
+        OMAPFB_COLOR_RGB24P,    /* RGB24, 24-bit container */
+        OMAPFB_COLOR_ARGB32,
+        OMAPFB_COLOR_RGBA32,
+        OMAPFB_COLOR_RGBX32,
+};
+
+struct omapfb_update_window {
+        __u32 x, y;
+        __u32 width, height;
+        __u32 format;
+        __u32 out_x, out_y;
+        __u32 out_width, out_height;
+        __u32 reserved[8];
+};
+
+struct omapfb_update_window_old {
+        __u32 x, y;
+        __u32 width, height;
+        __u32 format;
+};
+
+enum omapfb_plane {
+        OMAPFB_PLANE_GFX = 0,
+        OMAPFB_PLANE_VID1,
+        OMAPFB_PLANE_VID2,
+};
+
+enum omapfb_channel_out {
+        OMAPFB_CHANNEL_OUT_LCD = 0,
+        OMAPFB_CHANNEL_OUT_DIGIT,
+};
+
+struct omapfb_plane_info {
+        __u32 pos_x;
+        __u32 pos_y;
+        __u8  enabled;
+        __u8  channel_out;
+        __u8  mirror;
+        __u8  reserved1;
+        __u32 out_width;
+        __u32 out_height;
+        __u32 reserved2[12];
+};
+
+struct omapfb_mem_info {
+        __u32 size;
+        __u8  type;
+        __u8  reserved[3];
+};
+
+struct omapfb_caps {
+        __u32 ctrl;
+        __u32 plane_color;
+        __u32 wnd_color;
+};
+
+enum omapfb_color_key_type {
+        OMAPFB_COLOR_KEY_DISABLED = 0,
+        OMAPFB_COLOR_KEY_GFX_DST,
+        OMAPFB_COLOR_KEY_VID_SRC,
+};
+
+struct omapfb_color_key {
+        __u8  channel_out;
+        __u32 background;
+        __u32 trans_key;
+        __u8  key_type;
+};
+
+enum omapfb_update_mode {
+        OMAPFB_UPDATE_DISABLED = 0,
+        OMAPFB_AUTO_UPDATE,
+        OMAPFB_MANUAL_UPDATE
+};
+
+struct omapfb_memory_read {
+        __u16 x;
+        __u16 y;
+        __u16 w;
+        __u16 h;
+        size_t buffer_size;
+        void __user *buffer;
+};
+
+struct omapfb_ovl_colormode {
+        __u8 overlay_idx;
+        __u8 mode_idx;
+        __u32 bits_per_pixel;
+        __u32 nonstd;
+        struct fb_bitfield red;
+        struct fb_bitfield green;
+        struct fb_bitfield blue;
+        struct fb_bitfield transp;
+};
+
+struct omapfb_vram_info {
+        __u32 total;
+        __u32 free;
+        __u32 largest_free_block;
+        __u32 reserved[5];
+};
+
+struct omapfb_tearsync_info {
+        __u8 enabled;
+        __u8 reserved1[3];
+        __u16 line;
+        __u16 reserved2;
+};
+
+#ifdef __KERNEL__
+
+#include <plat/board.h>
+
+#ifdef CONFIG_ARCH_OMAP1
+#define OMAPFB_PLANE_NUM                1
+#else
+#define OMAPFB_PLANE_NUM                3
+#endif
+
+struct omapfb_mem_region {
+        u32             paddr;
+        void __iomem    *vaddr;
+        unsigned long   size;
+        u8              type;           /* OMAPFB_PLANE_MEM_* */
+        enum omapfb_color_format format;/* OMAPFB_COLOR_* */
+        unsigned        format_used:1;  /* Must be set when format is set.
+                                         * Needed b/c of the badly chosen 0
+                                         * base for OMAPFB_COLOR_* values
+                                         */
+        unsigned        alloc:1;        /* allocated by the driver */
+        unsigned        map:1;          /* kernel mapped by the driver */
+};
+
+struct omapfb_mem_desc {
+        int                             region_cnt;
+        struct omapfb_mem_region        region[OMAPFB_PLANE_NUM];
+};
+
+struct omapfb_platform_data {
+        struct omap_lcd_config          lcd;
+        struct omapfb_mem_desc          mem_desc;
+        void                            *ctrl_platform_data;
+};
+
+/* in arch/arm/plat-omap/fb.c */
+extern void omapfb_set_platform_data(struct omapfb_platform_data *data);
+extern void omapfb_set_ctrl_platform_data(void *pdata);
+extern void omapfb_reserve_sdram(void);
+
+#endif
+
+#endif /* __OMAPFB_H */
diff --git a/include/linux/pci.h b/include/linux/pci.h
index f5c7cd343e5..04771b9c331 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -218,6 +218,7 @@ struct pci_dev {
         unsigned int    class;          /* 3 bytes: (base,sub,prog-if) */
         u8              revision;       /* PCI revision, low byte of class word */
         u8              hdr_type;       /* PCI header type (`multi' flag masked out) */
+        u8              pcie_cap;       /* PCI-E capability offset */
         u8              pcie_type;      /* PCI-E device/port type */
         u8              rom_base_reg;   /* which config register controls the ROM */
         u8              pin;            /* which interrupt pin this device uses */
@@ -280,6 +281,7 @@ struct pci_dev {
         unsigned int    is_virtfn:1;
         unsigned int    reset_fn:1;
         unsigned int    is_hotplug_bridge:1;
+        unsigned int    aer_firmware_first:1;
         pci_dev_flags_t dev_flags;
         atomic_t        enable_cnt;     /* pci_enable_device has been called */
 
@@ -635,7 +637,13 @@ struct pci_dev *pci_get_subsys(unsigned int vendor, unsigned int device,
                                 unsigned int ss_vendor, unsigned int ss_device,
                                 struct pci_dev *from);
 struct pci_dev *pci_get_slot(struct pci_bus *bus, unsigned int devfn);
-struct pci_dev *pci_get_bus_and_slot(unsigned int bus, unsigned int devfn);
+struct pci_dev *pci_get_domain_bus_and_slot(int domain, unsigned int bus,
+                                            unsigned int devfn);
+static inline struct pci_dev *pci_get_bus_and_slot(unsigned int bus,
+                                                   unsigned int devfn)
+{
+        return pci_get_domain_bus_and_slot(0, bus, devfn);
+}
 struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from);
 int pci_dev_present(const struct pci_device_id *ids);
 
@@ -701,6 +709,7 @@ void pci_disable_device(struct pci_dev *dev);
 void pci_set_master(struct pci_dev *dev);
 void pci_clear_master(struct pci_dev *dev);
 int pci_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state);
+int pci_set_cacheline_size(struct pci_dev *dev);
 #define HAVE_PCI_SET_MWI
 int __must_check pci_set_mwi(struct pci_dev *dev);
 int pci_try_set_mwi(struct pci_dev *dev);
@@ -1246,6 +1255,8 @@ extern int pci_pci_problems;
 
 extern unsigned long pci_cardbus_io_size;
 extern unsigned long pci_cardbus_mem_size;
+extern u8 pci_dfl_cache_line_size;
+extern u8 pci_cache_line_size;
 
 extern unsigned long pci_hotplug_io_size;
 extern unsigned long pci_hotplug_mem_size;
@@ -1290,5 +1301,34 @@ extern void pci_hp_create_module_link(struct pci_slot *pci_slot);
 extern void pci_hp_remove_module_link(struct pci_slot *pci_slot);
 #endif
 
+/**
+ * pci_pcie_cap - get the saved PCIe capability offset
+ * @dev: PCI device
+ *
+ * PCIe capability offset is calculated at PCI device initialization
+ * time and saved in the data structure. This function returns saved
+ * PCIe capability offset. Using this instead of pci_find_capability()
+ * reduces unnecessary search in the PCI configuration space. If you
+ * need to calculate PCIe capability offset from raw device for some
+ * reasons, please use pci_find_capability() instead.
+ */
+static inline int pci_pcie_cap(struct pci_dev *dev)
+{
+        return dev->pcie_cap;
+}
+
+/**
+ * pci_is_pcie - check if the PCI device is PCI Express capable
+ * @dev: PCI device
+ *
+ * Retrun true if the PCI device is PCI Express capable, false otherwise.
+ */
+static inline bool pci_is_pcie(struct pci_dev *dev)
+{
+        return !!pci_pcie_cap(dev);
+}
+
+void pci_request_acs(void);
+
 #endif /* __KERNEL__ */
 #endif /* LINUX_PCI_H */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index cabf074b432..cca8a044e2b 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1587,6 +1587,8 @@
 #define PCI_VENDOR_ID_COMPEX            0x11f6
 #define PCI_DEVICE_ID_COMPEX_ENET100VG4 0x0112
 
+#define PCI_VENDOR_ID_PMC_Sierra        0x11f8
+
 #define PCI_VENDOR_ID_RP                0x11fe
 #define PCI_DEVICE_ID_RP32INTF          0x0001
 #define PCI_DEVICE_ID_RP8INTF           0x0002
@@ -2293,6 +2295,20 @@
 #define PCI_DEVICE_ID_MPC8536           0x0051
 #define PCI_DEVICE_ID_P2020E            0x0070
 #define PCI_DEVICE_ID_P2020             0x0071
+#define PCI_DEVICE_ID_P2010E            0x0078
+#define PCI_DEVICE_ID_P2010             0x0079
+#define PCI_DEVICE_ID_P1020E            0x0100
+#define PCI_DEVICE_ID_P1020             0x0101
+#define PCI_DEVICE_ID_P1011E            0x0108
+#define PCI_DEVICE_ID_P1011             0x0109
+#define PCI_DEVICE_ID_P1022E            0x0110
+#define PCI_DEVICE_ID_P1022             0x0111
+#define PCI_DEVICE_ID_P1013E            0x0118
+#define PCI_DEVICE_ID_P1013             0x0119
+#define PCI_DEVICE_ID_P4080E            0x0400
+#define PCI_DEVICE_ID_P4080             0x0401
+#define PCI_DEVICE_ID_P4040E            0x0408
+#define PCI_DEVICE_ID_P4040             0x0409
 #define PCI_DEVICE_ID_MPC8641           0x7010
 #define PCI_DEVICE_ID_MPC8641D          0x7011
 #define PCI_DEVICE_ID_MPC8610           0x7018
diff --git a/include/linux/pci_regs.h b/include/linux/pci_regs.h
index dd0bed4f1cf..9f2ad0aa3c3 100644
--- a/include/linux/pci_regs.h
+++ b/include/linux/pci_regs.h
@@ -365,6 +365,11 @@
 #define  PCI_X_STATUS_266MHZ    0x40000000      /* 266 MHz capable */
 #define  PCI_X_STATUS_533MHZ    0x80000000      /* 533 MHz capable */
 
+/* PCI Bridge Subsystem ID registers */
+
+#define PCI_SSVID_VENDOR_ID     4       /* PCI-Bridge subsystem vendor id register */
+#define PCI_SSVID_DEVICE_ID     6       /* PCI-Bridge subsystem device id register */
+
 /* PCI Express capability registers */
 
 #define PCI_EXP_FLAGS           2       /* Capabilities register */
@@ -502,6 +507,7 @@
 #define PCI_EXT_CAP_ID_VC       2
 #define PCI_EXT_CAP_ID_DSN      3
 #define PCI_EXT_CAP_ID_PWR      4
+#define PCI_EXT_CAP_ID_ACS      13
 #define PCI_EXT_CAP_ID_ARI      14
 #define PCI_EXT_CAP_ID_ATS      15
 #define PCI_EXT_CAP_ID_SRIOV    16
@@ -662,4 +668,16 @@
 #define  PCI_SRIOV_VFM_MO       0x2     /* Active.MigrateOut */
 #define  PCI_SRIOV_VFM_AV       0x3     /* Active.Available */
 
+/* Access Control Service */
+#define PCI_ACS_CAP             0x04    /* ACS Capability Register */
+#define  PCI_ACS_SV             0x01    /* Source Validation */
+#define  PCI_ACS_TB             0x02    /* Translation Blocking */
+#define  PCI_ACS_RR             0x04    /* P2P Request Redirect */
+#define  PCI_ACS_CR             0x08    /* P2P Completion Redirect */
+#define  PCI_ACS_UF             0x10    /* Upstream Forwarding */
+#define  PCI_ACS_EC             0x20    /* P2P Egress Control */
+#define  PCI_ACS_DT             0x40    /* Direct Translated P2P */
+#define PCI_ACS_CTRL            0x06    /* ACS Control Register */
+#define PCI_ACS_EGRESS_CTL_V    0x08    /* ACS Egress Control Vector */
+
 #endif /* LINUX_PCI_REGS_H */
diff --git a/include/linux/pcieport_if.h b/include/linux/pcieport_if.h
index b4c79545330..6775532b92a 100644
--- a/include/linux/pcieport_if.h
+++ b/include/linux/pcieport_if.h
@@ -10,10 +10,7 @@
 #define _PCIEPORT_IF_H_
 
 /* Port Type */
-#define PCIE_RC_PORT                    4       /* Root port of RC */
-#define PCIE_SW_UPSTREAM_PORT           5       /* Upstream port of Switch */
-#define PCIE_SW_DOWNSTREAM_PORT         6       /* Downstream port of Switch */
-#define PCIE_ANY_PORT                   7
+#define PCIE_ANY_PORT                   (~0)
 
 /* Service Type */
 #define PCIE_PORT_SERVICE_PME_SHIFT     0       /* Power Management Event */
@@ -25,17 +22,6 @@
 #define PCIE_PORT_SERVICE_VC_SHIFT      3       /* Virtual Channel */
 #define PCIE_PORT_SERVICE_VC            (1 << PCIE_PORT_SERVICE_VC_SHIFT)
 
-/* Root/Upstream/Downstream Port's Interrupt Mode */
-#define PCIE_PORT_NO_IRQ                (-1)
-#define PCIE_PORT_INTx_MODE             0
-#define PCIE_PORT_MSI_MODE              1
-#define PCIE_PORT_MSIX_MODE             2
-
-struct pcie_port_data {
-        int port_type;          /* Type of the port */
-        int port_irq_mode;      /* [0:INTx | 1:MSI | 2:MSI-X] */
-};
-
 struct pcie_device {
         int             irq;        /* Service IRQ/MSI/MSI-X Vector */
         struct pci_dev *port;       /* Root/Upstream/Downstream Port */
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index 43adbd7f001..64a53f74c9a 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -18,10 +18,6 @@
 #include <linux/ioctl.h>
 #include <asm/byteorder.h>
 
-#ifdef CONFIG_HAVE_HW_BREAKPOINT
-#include <asm/hw_breakpoint.h>
-#endif
-
 /*
  * User-space ABI bits:
  */
@@ -215,12 +211,12 @@ struct perf_event_attr {
                 __u32           wakeup_watermark; /* bytes before wakeup   */
         };
 
-        union {
-                struct { /* Hardware breakpoint info */
-                        __u64           bp_addr;
-                        __u32           bp_type;
-                        __u32           bp_len;
-                };
+        struct { /* Hardware breakpoint info */
+                __u64           bp_addr;
+                __u32           bp_type;
+                __u32           bp_len;
+                __u64           __bp_reserved_1;
+                __u64           __bp_reserved_2;
         };
 
         __u32                   __reserved_2;
@@ -451,6 +447,10 @@ enum perf_callchain_context {
 # include <asm/perf_event.h>
 #endif
 
+#ifdef CONFIG_HAVE_HW_BREAKPOINT
+#include <asm/hw_breakpoint.h>
+#endif
+
 #include <linux/list.h>
 #include <linux/mutex.h>
 #include <linux/rculist.h>
@@ -565,10 +565,12 @@ struct perf_pending_entry {
         void (*func)(struct perf_pending_entry *);
 };
 
-typedef void (*perf_callback_t)(struct perf_event *, void *);
-
 struct perf_sample_data;
 
+typedef void (*perf_overflow_handler_t)(struct perf_event *, int,
+                                        struct perf_sample_data *,
+                                        struct pt_regs *regs);
+
 /**
  * struct perf_event - performance event kernel representation:
  */
@@ -660,18 +662,12 @@ struct perf_event {
         struct pid_namespace            *ns;
         u64                             id;
 
-        void (*overflow_handler)(struct perf_event *event,
-                        int nmi, struct perf_sample_data *data,
-                        struct pt_regs *regs);
+        perf_overflow_handler_t         overflow_handler;
 
 #ifdef CONFIG_EVENT_PROFILE
         struct event_filter             *filter;
 #endif
 
-        perf_callback_t                 callback;
-
-        perf_callback_t                 event_callback;
-
 #endif /* CONFIG_PERF_EVENTS */
 };
 
@@ -781,7 +777,7 @@ extern struct perf_event *
 perf_event_create_kernel_counter(struct perf_event_attr *attr,
                                 int cpu,
                                 pid_t pid,
-                                perf_callback_t callback);
+                                perf_overflow_handler_t callback);
 extern u64 perf_event_read_value(struct perf_event *event,
                                  u64 *enabled, u64 *running);
 
@@ -876,6 +872,8 @@ extern void perf_output_copy(struct perf_output_handle *handle,
                              const void *buf, unsigned int len);
 extern int perf_swevent_get_recursion_context(void);
 extern void perf_swevent_put_recursion_context(int rctx);
+extern void perf_event_enable(struct perf_event *event);
+extern void perf_event_disable(struct perf_event *event);
 #else
 static inline void
 perf_event_task_sched_in(struct task_struct *task, int cpu)             { }
@@ -906,7 +904,8 @@ static inline void perf_event_fork(struct task_struct *tsk)		{ }
 static inline void perf_event_init(void)                                { }
 static inline int  perf_swevent_get_recursion_context(void)  { return -1; }
 static inline void perf_swevent_put_recursion_context(int rctx)         { }
-
+static inline void perf_event_enable(struct perf_event *event)          { }
+static inline void perf_event_disable(struct perf_event *event)         { }
 #endif
 
 #define perf_output_put(handle, x) \
diff --git a/include/linux/pktcdvd.h b/include/linux/pktcdvd.h
index d745f5b6c7b..76e5053e1fa 100644
--- a/include/linux/pktcdvd.h
+++ b/include/linux/pktcdvd.h
@@ -30,7 +30,7 @@
 
 /*
  * use drive write caching -- we need deferred error handling to be
- * able to sucessfully recover with this option (drive will return good
+ * able to successfully recover with this option (drive will return good
  * status as soon as the cdb is validated).
  */
 #if defined(CONFIG_CDROM_PKTCDVD_WCACHE)
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index 3c6675c2444..71ff887ca44 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -83,6 +83,8 @@ struct early_platform_driver {
         struct platform_driver *pdrv;
         struct list_head list;
         int requested_id;
+        char *buffer;
+        int bufsize;
 };
 
 #define EARLY_PLATFORM_ID_UNSET -2
@@ -102,21 +104,29 @@ extern int early_platform_driver_probe(char *class_str,
                                        int nr_probe, int user_only);
 extern void early_platform_cleanup(void);
 
+#define early_platform_init(class_string, platdrv)              \
+        early_platform_init_buffer(class_string, platdrv, NULL, 0)
 
 #ifndef MODULE
-#define early_platform_init(class_string, platform_driver)              \
+#define early_platform_init_buffer(class_string, platdrv, buf, bufsiz)  \
 static __initdata struct early_platform_driver early_driver = {         \
         .class_str = class_string,                                      \
-        .pdrv = platform_driver,                                        \
+        .buffer = buf,                                                  \
+        .bufsize = bufsiz,                                              \
+        .pdrv = platdrv,                                                \
         .requested_id = EARLY_PLATFORM_ID_UNSET,                        \
 };                                                                      \
-static int __init early_platform_driver_setup_func(char *buf)           \
+static int __init early_platform_driver_setup_func(char *buffer)        \
 {                                                                       \
-        return early_platform_driver_register(&early_driver, buf);      \
+        return early_platform_driver_register(&early_driver, buffer);   \
 }                                                                       \
 early_param(class_string, early_platform_driver_setup_func)
 #else /* MODULE */
-#define early_platform_init(class_string, platform_driver)
+#define early_platform_init_buffer(class_string, platdrv, buf, bufsiz)  \
+static inline char *early_platform_driver_setup_func(void)              \
+{                                                                       \
+        return bufsiz ? buf : NULL;                                     \
+}
 #endif /* MODULE */
 
 #endif /* _PLATFORM_DEVICE_H_ */
diff --git a/include/linux/quota.h b/include/linux/quota.h
index ce9a9b2e5cd..e70e6219424 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -73,6 +73,8 @@
 /* Quota format type IDs */
 #define QFMT_VFS_OLD 1
 #define QFMT_VFS_V0 2
+#define QFMT_OCFS2 3
+#define QFMT_VFS_V1 4
 
 /* Size of block in which space limits are passed through the quota
  * interface */
@@ -334,7 +336,7 @@ struct quotactl_ops {
 
 struct quota_format_type {
         int qf_fmt_id;  /* Quota format id */
-        struct quota_format_ops *qf_ops;        /* Operations of format */
+        const struct quota_format_ops *qf_ops;  /* Operations of format */
         struct module *qf_owner;                /* Module implementing quota format */
         struct quota_format_type *qf_next;
 };
@@ -394,7 +396,7 @@ struct quota_info {
         struct rw_semaphore dqptr_sem;          /* serialize ops using quota_info struct, pointers from inode to dquots */
         struct inode *files[MAXQUOTAS];         /* inodes of quotafiles */
         struct mem_dqinfo info[MAXQUOTAS];      /* Information for each quota type */
-        struct quota_format_ops *ops[MAXQUOTAS];        /* Operations for each type */
+        const struct quota_format_ops *ops[MAXQUOTAS];  /* Operations for each type */
 };
 
 int register_quota_format(struct quota_format_type *fmt);
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index dd31e7bae35..a05b4a20768 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -52,11 +52,63 @@
 #define REISERFS_IOC32_GETVERSION       FS_IOC32_GETVERSION
 #define REISERFS_IOC32_SETVERSION       FS_IOC32_SETVERSION
 
-/* Locking primitives */
-/* Right now we are still falling back to (un)lock_kernel, but eventually that
-   would evolve into real per-fs locks */
-#define reiserfs_write_lock( sb ) lock_kernel()
-#define reiserfs_write_unlock( sb ) unlock_kernel()
+/*
+ * Locking primitives. The write lock is a per superblock
+ * special mutex that has properties close to the Big Kernel Lock
+ * which was used in the previous locking scheme.
+ */
+void reiserfs_write_lock(struct super_block *s);
+void reiserfs_write_unlock(struct super_block *s);
+int reiserfs_write_lock_once(struct super_block *s);
+void reiserfs_write_unlock_once(struct super_block *s, int lock_depth);
+
+/*
+ * Several mutexes depend on the write lock.
+ * However sometimes we want to relax the write lock while we hold
+ * these mutexes, according to the release/reacquire on schedule()
+ * properties of the Bkl that were used.
+ * Reiserfs performances and locking were based on this scheme.
+ * Now that the write lock is a mutex and not the bkl anymore, doing so
+ * may result in a deadlock:
+ *
+ * A acquire write_lock
+ * A acquire j_commit_mutex
+ * A release write_lock and wait for something
+ * B acquire write_lock
+ * B can't acquire j_commit_mutex and sleep
+ * A can't acquire write lock anymore
+ * deadlock
+ *
+ * What we do here is avoiding such deadlock by playing the same game
+ * than the Bkl: if we can't acquire a mutex that depends on the write lock,
+ * we release the write lock, wait a bit and then retry.
+ *
+ * The mutexes concerned by this hack are:
+ * - The commit mutex of a journal list
+ * - The flush mutex
+ * - The journal lock
+ * - The inode mutex
+ */
+static inline void reiserfs_mutex_lock_safe(struct mutex *m,
+                               struct super_block *s)
+{
+        reiserfs_write_unlock(s);
+        mutex_lock(m);
+        reiserfs_write_lock(s);
+}
+
+/*
+ * When we schedule, we usually want to also release the write lock,
+ * according to the previous bkl based locking scheme of reiserfs.
+ */
+static inline void reiserfs_cond_resched(struct super_block *s)
+{
+        if (need_resched()) {
+                reiserfs_write_unlock(s);
+                schedule();
+                reiserfs_write_lock(s);
+        }
+}
 
 struct fid;
 
@@ -1329,7 +1381,11 @@ static inline loff_t max_reiserfs_offset(struct inode *inode)
 #define get_generation(s) atomic_read (&fs_generation(s))
 #define FILESYSTEM_CHANGED_TB(tb)  (get_generation((tb)->tb_sb) != (tb)->fs_gen)
 #define __fs_changed(gen,s) (gen != get_generation (s))
-#define fs_changed(gen,s) ({cond_resched(); __fs_changed(gen, s);})
+#define fs_changed(gen,s)               \
+({                                      \
+        reiserfs_cond_resched(s);       \
+        __fs_changed(gen, s);           \
+})
 
 /***************************************************************************/
 /*                  FIXATE NODES                                           */
@@ -2258,8 +2314,7 @@ __u32 r5_hash(const signed char *msg, int len);
 #define SPARE_SPACE 500
 
 /* prototypes from ioctl.c */
-int reiserfs_ioctl(struct inode *inode, struct file *filp,
-                   unsigned int cmd, unsigned long arg);
+long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
 long reiserfs_compat_ioctl(struct file *filp,
                    unsigned int cmd, unsigned long arg);
 int reiserfs_unpack(struct inode *inode, struct file *filp);
diff --git a/include/linux/reiserfs_fs_sb.h b/include/linux/reiserfs_fs_sb.h
index dab68bbed67..52c83b6a758 100644
--- a/include/linux/reiserfs_fs_sb.h
+++ b/include/linux/reiserfs_fs_sb.h
@@ -7,6 +7,8 @@
 #ifdef __KERNEL__
 #include <linux/workqueue.h>
 #include <linux/rwsem.h>
+#include <linux/mutex.h>
+#include <linux/sched.h>
 #endif
 
 typedef enum {
@@ -355,6 +357,13 @@ struct reiserfs_sb_info {
         struct reiserfs_journal *s_journal;     /* pointer to journal information */
         unsigned short s_mount_state;   /* reiserfs state (valid, invalid) */
 
+        /* Serialize writers access, replace the old bkl */
+        struct mutex lock;
+        /* Owner of the lock (can be recursive) */
+        struct task_struct *lock_owner;
+        /* Depth of the lock, start from -1 like the bkl */
+        int lock_depth;
+
         /* Comment? -Hans */
         void (*end_io_handler) (struct buffer_head *, int);
         hashf_t s_hash_function;        /* pointer to function which is used
@@ -408,6 +417,17 @@ struct reiserfs_sb_info {
         char *s_qf_names[MAXQUOTAS];
         int s_jquota_fmt;
 #endif
+#ifdef CONFIG_REISERFS_CHECK
+
+        struct tree_balance *cur_tb;    /*
+                                         * Detects whether more than one
+                                         * copy of tb exists per superblock
+                                         * as a means of checking whether
+                                         * do_balance is executing concurrently
+                                         * against another tree reader/writer
+                                         * on a same mount point.
+                                         */
+#endif
 };
 
 /* Definitions of reiserfs on-disk properties: */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 89115ec7d43..294eb2f8014 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1102,7 +1102,7 @@ struct sched_class {
 
         void (*set_curr_task) (struct rq *rq);
         void (*task_tick) (struct rq *rq, struct task_struct *p, int queued);
-        void (*task_new) (struct rq *rq, struct task_struct *p);
+        void (*task_fork) (struct task_struct *p);
 
         void (*switched_from) (struct rq *this_rq, struct task_struct *task,
                                int running);
@@ -1111,7 +1111,8 @@ struct sched_class {
         void (*prio_changed) (struct rq *this_rq, struct task_struct *task,
                              int oldprio, int running);
 
-        unsigned int (*get_rr_interval) (struct task_struct *task);
+        unsigned int (*get_rr_interval) (struct rq *rq,
+                                         struct task_struct *task);
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
         void (*moved_group) (struct task_struct *p);
@@ -1151,8 +1152,6 @@ struct sched_entity {
         u64                     start_runtime;
         u64                     avg_wakeup;
 
-        u64                     avg_running;
-
 #ifdef CONFIG_SCHEDSTATS
         u64                     wait_start;
         u64                     wait_max;
@@ -1175,7 +1174,6 @@ struct sched_entity {
         u64                     nr_failed_migrations_running;
         u64                     nr_failed_migrations_hot;
         u64                     nr_forced_migrations;
-        u64                     nr_forced2_migrations;
 
         u64                     nr_wakeups;
         u64                     nr_wakeups_sync;
@@ -1840,7 +1838,8 @@ static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
 extern int sched_clock_stable;
 #endif
 
-extern unsigned long long sched_clock(void);
+/* ftrace calls sched_clock() directly */
+extern unsigned long long notrace sched_clock(void);
 
 extern void sched_clock_init(void);
 extern u64 sched_clock_cpu(int cpu);
@@ -1903,14 +1902,22 @@ extern unsigned int sysctl_sched_wakeup_granularity;
 extern unsigned int sysctl_sched_shares_ratelimit;
 extern unsigned int sysctl_sched_shares_thresh;
 extern unsigned int sysctl_sched_child_runs_first;
+
+enum sched_tunable_scaling {
+        SCHED_TUNABLESCALING_NONE,
+        SCHED_TUNABLESCALING_LOG,
+        SCHED_TUNABLESCALING_LINEAR,
+        SCHED_TUNABLESCALING_END,
+};
+extern enum sched_tunable_scaling sysctl_sched_tunable_scaling;
+
 #ifdef CONFIG_SCHED_DEBUG
-extern unsigned int sysctl_sched_features;
 extern unsigned int sysctl_sched_migration_cost;
 extern unsigned int sysctl_sched_nr_migrate;
 extern unsigned int sysctl_sched_time_avg;
 extern unsigned int sysctl_timer_migration;
 
-int sched_nr_latency_handler(struct ctl_table *table, int write,
+int sched_proc_update_handler(struct ctl_table *table, int write,
                 void __user *buffer, size_t *length,
                 loff_t *ppos);
 #endif
diff --git a/include/linux/serial_reg.h b/include/linux/serial_reg.h
index 850db2e8051..cf9327c051a 100644
--- a/include/linux/serial_reg.h
+++ b/include/linux/serial_reg.h
@@ -216,10 +216,10 @@
 
 #define UART_IIR_TOD    0x08    /* Character Timeout Indication Detected */
 
-#define UART_FCR_PXAR1  0x00    /* receive FIFO treshold = 1 */
-#define UART_FCR_PXAR8  0x40    /* receive FIFO treshold = 8 */
-#define UART_FCR_PXAR16 0x80    /* receive FIFO treshold = 16 */
-#define UART_FCR_PXAR32 0xc0    /* receive FIFO treshold = 32 */
+#define UART_FCR_PXAR1  0x00    /* receive FIFO threshold = 1 */
+#define UART_FCR_PXAR8  0x40    /* receive FIFO threshold = 8 */
+#define UART_FCR_PXAR16 0x80    /* receive FIFO threshold = 16 */
+#define UART_FCR_PXAR32 0xc0    /* receive FIFO threshold = 32 */
 
 
 
diff --git a/include/linux/serio.h b/include/linux/serio.h
index a640bc2afe7..e2f3044d4a4 100644
--- a/include/linux/serio.h
+++ b/include/linux/serio.h
@@ -215,5 +215,6 @@ static inline void serio_unpin_driver(struct serio *serio)
 #define SERIO_INEXIO    0x37
 #define SERIO_TOUCHIT213        0x38
 #define SERIO_W8001     0x39
+#define SERIO_DYNAPRO   0x3a
 
 #endif
diff --git a/include/linux/sh_intc.h b/include/linux/sh_intc.h
index 68e212ff9dd..4ef246f1465 100644
--- a/include/linux/sh_intc.h
+++ b/include/linux/sh_intc.h
@@ -57,10 +57,8 @@ struct intc_desc {
         struct intc_sense_reg *sense_regs;
         unsigned int nr_sense_regs;
         char *name;
-#if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
         struct intc_mask_reg *ack_regs;
         unsigned int nr_ack_regs;
-#endif
 };
 
 #define _INTC_ARRAY(a) a, sizeof(a)/sizeof(*a)
@@ -73,7 +71,6 @@ struct intc_desc symbol __initdata = {					\
         chipname,                                                       \
 }
 
-#if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
 #define DECLARE_INTC_DESC_ACK(symbol, chipname, vectors, groups,        \
         mask_regs, prio_regs, sense_regs, ack_regs)                     \
 struct intc_desc symbol __initdata = {                                  \
@@ -83,9 +80,11 @@ struct intc_desc symbol __initdata = {					\
         chipname,                                                       \
         _INTC_ARRAY(ack_regs),                                          \
 }
-#endif
 
 void __init register_intc_controller(struct intc_desc *desc);
 int intc_set_priority(unsigned int irq, unsigned int prio);
 
+int reserve_irq_vector(unsigned int irq);
+void reserve_irq_legacy(void);
+
 #endif /* __SH_INTC_H */
diff --git a/include/linux/sh_pfc.h b/include/linux/sh_pfc.h
new file mode 100644
index 00000000000..07c08af9f8f
--- /dev/null
+++ b/include/linux/sh_pfc.h
@@ -0,0 +1,96 @@
+/*
+ * SuperH Pin Function Controller Support
+ *
+ * Copyright (c) 2008 Magnus Damm
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ */
+
+#ifndef __SH_PFC_H
+#define __SH_PFC_H
+
+#include <asm-generic/gpio.h>
+
+typedef unsigned short pinmux_enum_t;
+typedef unsigned short pinmux_flag_t;
+
+#define PINMUX_TYPE_NONE            0
+#define PINMUX_TYPE_FUNCTION        1
+#define PINMUX_TYPE_GPIO            2
+#define PINMUX_TYPE_OUTPUT          3
+#define PINMUX_TYPE_INPUT           4
+#define PINMUX_TYPE_INPUT_PULLUP    5
+#define PINMUX_TYPE_INPUT_PULLDOWN  6
+
+#define PINMUX_FLAG_TYPE            (0x7)
+#define PINMUX_FLAG_WANT_PULLUP     (1 << 3)
+#define PINMUX_FLAG_WANT_PULLDOWN   (1 << 4)
+
+#define PINMUX_FLAG_DBIT_SHIFT      5
+#define PINMUX_FLAG_DBIT            (0x1f << PINMUX_FLAG_DBIT_SHIFT)
+#define PINMUX_FLAG_DREG_SHIFT      10
+#define PINMUX_FLAG_DREG            (0x3f << PINMUX_FLAG_DREG_SHIFT)
+
+struct pinmux_gpio {
+        pinmux_enum_t enum_id;
+        pinmux_flag_t flags;
+};
+
+#define PINMUX_GPIO(gpio, data_or_mark) [gpio] = { data_or_mark }
+#define PINMUX_DATA(data_or_mark, ids...) data_or_mark, ids, 0
+
+struct pinmux_cfg_reg {
+        unsigned long reg, reg_width, field_width;
+        unsigned long *cnt;
+        pinmux_enum_t *enum_ids;
+};
+
+#define PINMUX_CFG_REG(name, r, r_width, f_width) \
+        .reg = r, .reg_width = r_width, .field_width = f_width,         \
+        .cnt = (unsigned long [r_width / f_width]) {}, \
+        .enum_ids = (pinmux_enum_t [(r_width / f_width) * (1 << f_width)]) \
+
+struct pinmux_data_reg {
+        unsigned long reg, reg_width, reg_shadow;
+        pinmux_enum_t *enum_ids;
+};
+
+#define PINMUX_DATA_REG(name, r, r_width) \
+        .reg = r, .reg_width = r_width, \
+        .enum_ids = (pinmux_enum_t [r_width]) \
+
+struct pinmux_range {
+        pinmux_enum_t begin;
+        pinmux_enum_t end;
+        pinmux_enum_t force;
+};
+
+struct pinmux_info {
+        char *name;
+        pinmux_enum_t reserved_id;
+        struct pinmux_range data;
+        struct pinmux_range input;
+        struct pinmux_range input_pd;
+        struct pinmux_range input_pu;
+        struct pinmux_range output;
+        struct pinmux_range mark;
+        struct pinmux_range function;
+
+        unsigned first_gpio, last_gpio;
+
+        struct pinmux_gpio *gpios;
+        struct pinmux_cfg_reg *cfg_regs;
+        struct pinmux_data_reg *data_regs;
+
+        pinmux_enum_t *gpio_data;
+        unsigned int gpio_data_size;
+
+        unsigned long *gpio_in_use;
+        struct gpio_chip chip;
+};
+
+int register_pinmux(struct pinmux_info *pip);
+
+#endif /* __SH_PFC_H */
diff --git a/include/linux/spi/mpc52xx_spi.h b/include/linux/spi/mpc52xx_spi.h
new file mode 100644
index 00000000000..d1004cf0924
--- /dev/null
+++ b/include/linux/spi/mpc52xx_spi.h
@@ -0,0 +1,10 @@
+
+#ifndef INCLUDE_MPC5200_SPI_H
+#define INCLUDE_MPC5200_SPI_H
+
+extern void mpc52xx_spi_set_premessage_hook(struct spi_master *master,
+                                            void (*hook)(struct spi_message *m,
+                                                         void *context),
+                                            void *hook_context);
+
+#endif
diff --git a/include/linux/spi/spi_bitbang.h b/include/linux/spi/spi_bitbang.h
index eed4254bd50..3274c507b8a 100644
--- a/include/linux/spi/spi_bitbang.h
+++ b/include/linux/spi/spi_bitbang.h
@@ -15,7 +15,7 @@
  * Some hardware works well with requests at spi_transfer scope:
  *
  *   -  Drivers leveraging smarter hardware, with fifos or DMA; or for half
- *      duplex (MicroWire) controllers.  Provide chipslect() and txrx_bufs(),
+ *      duplex (MicroWire) controllers.  Provide chipselect() and txrx_bufs(),
  *      and custom setup()/cleanup() methods.
  */
 
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 72d69860d90..65793e90d6f 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -832,4 +832,8 @@ int kernel_execve(const char *filename, char *const argv[], char *const envp[]);
 asmlinkage long sys_perf_event_open(
                 struct perf_event_attr __user *attr_uptr,
                 pid_t pid, int cpu, int group_fd, unsigned long flags);
+
+asmlinkage long sys_mmap_pgoff(unsigned long addr, unsigned long len,
+                        unsigned long prot, unsigned long flags,
+                        unsigned long fd, unsigned long pgoff);
 #endif
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index 56af3ca75e2..877ba039e6a 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -89,8 +89,8 @@ enum
         KERN_VERSION=4,         /* string: compile time info */
         KERN_SECUREMASK=5,      /* struct: maximum rights mask */
         KERN_PROF=6,            /* table: profiling information */
-        KERN_NODENAME=7,
-        KERN_DOMAINNAME=8,
+        KERN_NODENAME=7,        /* string: hostname */
+        KERN_DOMAINNAME=8,      /* string: domainname */
 
         KERN_PANIC=15,          /* int: panic timeout */
         KERN_REALROOTDEV=16,    /* real root device to mount after initrd */
@@ -102,8 +102,8 @@ enum
         KERN_PPC_HTABRECLAIM=25, /* turn htab reclaimation on/off on PPC */
         KERN_PPC_ZEROPAGED=26,  /* turn idle page zeroing on/off on PPC */
         KERN_PPC_POWERSAVE_NAP=27, /* use nap mode for power saving */
-        KERN_MODPROBE=28,
-        KERN_SG_BIG_BUFF=29,
+        KERN_MODPROBE=28,       /* string: modprobe path */
+        KERN_SG_BIG_BUFF=29,    /* int: sg driver reserved buffer size */
         KERN_ACCT=30,           /* BSD process accounting parameters */
         KERN_PPC_L2CR=31,       /* l2cr register on PPC */
 
@@ -150,7 +150,7 @@ enum
         KERN_ACPI_VIDEO_FLAGS=71, /* int: flags for setting up video after ACPI sleep */
         KERN_IA64_UNALIGNED=72, /* int: ia64 unaligned userland trap enable */
         KERN_COMPAT_LOG=73,     /* int: print compat layer  messages */
-        KERN_MAX_LOCK_DEPTH=74,
+        KERN_MAX_LOCK_DEPTH=74, /* int: rtmutex's maximum lock depth */
         KERN_NMI_WATCHDOG=75, /* int: enable/disable nmi watchdog */
         KERN_PANIC_ON_NMI=76, /* int: whether we will panic on an unrecovered */
 };
diff --git a/include/linux/tty.h b/include/linux/tty.h
index f0f43d08d8b..405a9035fe4 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -190,9 +190,17 @@ struct tty_port_operations {
         /* Control the DTR line */
         void (*dtr_rts)(struct tty_port *port, int raise);
         /* Called when the last close completes or a hangup finishes
-           IFF the port was initialized. Do not use to free resources */
+           IFF the port was initialized. Do not use to free resources. Called
+           under the port mutex to serialize against activate/shutdowns */
         void (*shutdown)(struct tty_port *port);
         void (*drop)(struct tty_port *port);
+        /* Called under the port mutex from tty_port_open, serialized using
+           the port mutex */
+        /* FIXME: long term getting the tty argument *out* of this would be
+           good for consoles */
+        int (*activate)(struct tty_port *port, struct tty_struct *tty);
+        /* Called on the final put of a port */
+        void (*destruct)(struct tty_port *port);
 };
         
 struct tty_port {
@@ -206,12 +214,14 @@ struct tty_port {
         wait_queue_head_t       delta_msr_wait; /* Modem status change */
         unsigned long           flags;          /* TTY flags ASY_*/
         struct mutex            mutex;          /* Locking */
+        struct mutex            buf_mutex;      /* Buffer alloc lock */
         unsigned char           *xmit_buf;      /* Optional buffer */
         unsigned int            close_delay;    /* Close port delay */
         unsigned int            closing_wait;   /* Delay for output */
         int                     drain_delay;    /* Set to zero if no pure time
                                                    based drain is needed else
                                                    set to size of fifo */
+        struct kref             kref;           /* Ref counter */
 };
 
 /*
@@ -439,7 +449,7 @@ extern void initialize_tty_struct(struct tty_struct *tty,
                 struct tty_driver *driver, int idx);
 extern struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,
                                                                 int first_ok);
-extern void tty_release_dev(struct file *filp);
+extern int tty_release(struct inode *inode, struct file *filp);
 extern int tty_init_termios(struct tty_struct *tty);
 
 extern struct tty_struct *tty_pair_get_tty(struct tty_struct *tty);
@@ -454,6 +464,15 @@ extern int tty_write_lock(struct tty_struct *tty, int ndelay);
 extern void tty_port_init(struct tty_port *port);
 extern int tty_port_alloc_xmit_buf(struct tty_port *port);
 extern void tty_port_free_xmit_buf(struct tty_port *port);
+extern void tty_port_put(struct tty_port *port);
+
+extern inline struct tty_port *tty_port_get(struct tty_port *port)
+{
+        if (port)
+                kref_get(&port->kref);
+        return port;
+}
+
 extern struct tty_struct *tty_port_tty_get(struct tty_port *port);
 extern void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty);
 extern int tty_port_carrier_raised(struct tty_port *port);
@@ -467,6 +486,8 @@ extern int tty_port_close_start(struct tty_port *port,
 extern void tty_port_close_end(struct tty_port *port, struct tty_struct *tty);
 extern void tty_port_close(struct tty_port *port,
                                 struct tty_struct *tty, struct file *filp);
+extern int tty_port_open(struct tty_port *port,
+                                struct tty_struct *tty, struct file *filp);
 extern inline int tty_port_users(struct tty_port *port)
 {
         return port->count + port->blocked_open;
diff --git a/include/linux/ucb1400.h b/include/linux/ucb1400.h
index adb44066680..1b479091105 100644
--- a/include/linux/ucb1400.h
+++ b/include/linux/ucb1400.h
@@ -110,6 +110,10 @@ struct ucb1400 {
         struct platform_device  *ucb1400_gpio;
 };
 
+struct ucb1400_pdata {
+        int     irq;
+};
+
 static inline u16 ucb1400_reg_read(struct snd_ac97 *ac97, u16 reg)
 {
         return ac97->bus->ops->read(ac97, reg);
diff --git a/include/linux/usb.h b/include/linux/usb.h
index a34fa89f147..e101a2d04d7 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -331,6 +331,7 @@ struct usb_bus {
         u8 otg_port;                    /* 0, or number of OTG/HNP port */
         unsigned is_b_host:1;           /* true during some HNP roleswitches */
         unsigned b_hnp_enable:1;        /* OTG: did A-Host enable HNP? */
+        unsigned sg_tablesize;          /* 0 or largest number of sg list entries */
 
         int devnum_next;                /* Next open device number in
                                          * round-robin allocation */
@@ -428,11 +429,9 @@ struct usb_tt;
  * @last_busy: time of last use
  * @autosuspend_delay: in jiffies
  * @connect_time: time device was first connected
- * @auto_pm: autosuspend/resume in progress
  * @do_remote_wakeup:  remote wakeup should be enabled
  * @reset_resume: needs reset instead of resume
  * @autosuspend_disabled: autosuspend disabled by the user
- * @autoresume_disabled: autoresume disabled by the user
  * @skip_sys_resume: skip the next system resume
  * @wusb_dev: if this is a Wireless USB device, link to the WUSB
  *      specific data for the device.
@@ -513,11 +512,9 @@ struct usb_device {
         int autosuspend_delay;
         unsigned long connect_time;
 
-        unsigned auto_pm:1;
         unsigned do_remote_wakeup:1;
         unsigned reset_resume:1;
         unsigned autosuspend_disabled:1;
-        unsigned autoresume_disabled:1;
         unsigned skip_sys_resume:1;
 #endif
         struct wusb_dev *wusb_dev;
@@ -543,22 +540,20 @@ extern struct usb_device *usb_find_device(u16 vendor_id, u16 product_id);
 
 /* USB autosuspend and autoresume */
 #ifdef CONFIG_USB_SUSPEND
-extern int usb_autopm_set_interface(struct usb_interface *intf);
 extern int usb_autopm_get_interface(struct usb_interface *intf);
 extern void usb_autopm_put_interface(struct usb_interface *intf);
 extern int usb_autopm_get_interface_async(struct usb_interface *intf);
 extern void usb_autopm_put_interface_async(struct usb_interface *intf);
 
-static inline void usb_autopm_enable(struct usb_interface *intf)
+static inline void usb_autopm_get_interface_no_resume(
+                struct usb_interface *intf)
 {
-        atomic_set(&intf->pm_usage_cnt, 0);
-        usb_autopm_set_interface(intf);
+        atomic_inc(&intf->pm_usage_cnt);
 }
-
-static inline void usb_autopm_disable(struct usb_interface *intf)
+static inline void usb_autopm_put_interface_no_suspend(
+                struct usb_interface *intf)
 {
-        atomic_set(&intf->pm_usage_cnt, 1);
-        usb_autopm_set_interface(intf);
+        atomic_dec(&intf->pm_usage_cnt);
 }
 
 static inline void usb_mark_last_busy(struct usb_device *udev)
@@ -568,12 +563,8 @@ static inline void usb_mark_last_busy(struct usb_device *udev)
 
 #else
 
-static inline int usb_autopm_set_interface(struct usb_interface *intf)
-{ return 0; }
-
 static inline int usb_autopm_get_interface(struct usb_interface *intf)
 { return 0; }
-
 static inline int usb_autopm_get_interface_async(struct usb_interface *intf)
 { return 0; }
 
@@ -581,9 +572,11 @@ static inline void usb_autopm_put_interface(struct usb_interface *intf)
 { }
 static inline void usb_autopm_put_interface_async(struct usb_interface *intf)
 { }
-static inline void usb_autopm_enable(struct usb_interface *intf)
+static inline void usb_autopm_get_interface_no_resume(
+                struct usb_interface *intf)
 { }
-static inline void usb_autopm_disable(struct usb_interface *intf)
+static inline void usb_autopm_put_interface_no_suspend(
+                struct usb_interface *intf)
 { }
 static inline void usb_mark_last_busy(struct usb_device *udev)
 { }
@@ -626,6 +619,10 @@ extern struct usb_interface *usb_ifnum_to_if(const struct usb_device *dev,
                 unsigned ifnum);
 extern struct usb_host_interface *usb_altnum_to_altsetting(
                 const struct usb_interface *intf, unsigned int altnum);
+extern struct usb_host_interface *usb_find_alt_setting(
+                struct usb_host_config *config,
+                unsigned int iface_num,
+                unsigned int alt_num);
 
 
 /**
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
index 4f6bb3d2160..738ea1a691c 100644
--- a/include/linux/usb/composite.h
+++ b/include/linux/usb/composite.h
@@ -127,6 +127,7 @@ struct usb_function {
         /* private: */
         /* internals */
         struct list_head                list;
+        DECLARE_BITMAP(endpoints, 32);
 };
 
 int usb_add_function(struct usb_configuration *, struct usb_function *);
diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h
index 2443c0e7a80..52bb917641f 100644
--- a/include/linux/usb/otg.h
+++ b/include/linux/usb/otg.h
@@ -33,6 +33,23 @@ enum usb_otg_state {
         OTG_STATE_A_VBUS_ERR,
 };
 
+#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
+ * provide access ops
+ */
+struct otg_io_access_ops {
+        int (*read)(struct otg_transceiver *otg, u32 reg);
+        int (*write)(struct otg_transceiver *otg, u32 val, u32 reg);
+};
+
 /*
  * the otg driver needs to interact with both device side and host side
  * usb controllers.  it decides which controller is active at a given
@@ -42,6 +59,7 @@ enum usb_otg_state {
 struct otg_transceiver {
         struct device           *dev;
         const char              *label;
+        unsigned int             flags;
 
         u8                      default_a;
         enum usb_otg_state      state;
@@ -49,10 +67,17 @@ struct otg_transceiver {
         struct usb_bus          *host;
         struct usb_gadget       *gadget;
 
+        struct otg_io_access_ops        *io_ops;
+        void __iomem                    *io_priv;
+
         /* to pass extra port status to the root hub */
         u16                     port_status;
         u16                     port_change;
 
+        /* initialize/shutdown the OTG controller */
+        int     (*init)(struct otg_transceiver *otg);
+        void    (*shutdown)(struct otg_transceiver *otg);
+
         /* bind/unbind the host controller */
         int     (*set_host)(struct otg_transceiver *otg,
                                 struct usb_bus *host);
@@ -65,6 +90,10 @@ struct otg_transceiver {
         int     (*set_power)(struct otg_transceiver *otg,
                                 unsigned mA);
 
+        /* effective for A-peripheral, ignored for B devices */
+        int     (*set_vbus)(struct otg_transceiver *otg,
+                                bool enabled);
+
         /* for non-OTG B devices: set transceiver into suspend mode */
         int     (*set_suspend)(struct otg_transceiver *otg,
                                 int suspend);
@@ -85,6 +114,38 @@ extern int otg_set_transceiver(struct otg_transceiver *);
 extern void usb_nop_xceiv_register(void);
 extern void usb_nop_xceiv_unregister(void);
 
+/* helpers for direct access thru low-level io interface */
+static inline int otg_io_read(struct otg_transceiver *otg, u32 reg)
+{
+        if (otg->io_ops && otg->io_ops->read)
+                return otg->io_ops->read(otg, reg);
+
+        return -EINVAL;
+}
+
+static inline int otg_io_write(struct otg_transceiver *otg, u32 reg, u32 val)
+{
+        if (otg->io_ops && otg->io_ops->write)
+                return otg->io_ops->write(otg, reg, val);
+
+        return -EINVAL;
+}
+
+static inline int
+otg_init(struct otg_transceiver *otg)
+{
+        if (otg->init)
+                return otg->init(otg);
+
+        return 0;
+}
+
+static inline void
+otg_shutdown(struct otg_transceiver *otg)
+{
+        if (otg->shutdown)
+                otg->shutdown(otg);
+}
 
 /* for usb host and peripheral controller drivers */
 extern struct otg_transceiver *otg_get_transceiver(void);
@@ -97,6 +158,12 @@ otg_start_hnp(struct otg_transceiver *otg)
         return otg->start_hnp(otg);
 }
 
+/* Context: can sleep */
+static inline int
+otg_set_vbus(struct otg_transceiver *otg, bool enabled)
+{
+        return otg->set_vbus(otg, enabled);
+}
 
 /* for HCDs */
 static inline int
@@ -105,7 +172,6 @@ otg_set_host(struct otg_transceiver *otg, struct usb_bus *host)
         return otg->set_host(otg, host);
 }
 
-
 /* for usb peripheral controller drivers */
 
 /* Context: can sleep */
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index ce911ebf91e..acf6e457c04 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -39,8 +39,6 @@ enum port_dev_state {
  * @serial: pointer back to the struct usb_serial owner of this port.
  * @port: pointer to the corresponding tty_port for this port.
  * @lock: spinlock to grab when updating portions of this structure.
- * @mutex: mutex used to synchronize serial_open() and serial_close()
- *      access for this port.
  * @number: the number of the port (the minor number).
  * @interrupt_in_buffer: pointer to the interrupt in buffer for this port.
  * @interrupt_in_urb: pointer to the interrupt in struct urb for this port.
@@ -77,7 +75,6 @@ struct usb_serial_port {
         struct usb_serial       *serial;
         struct tty_port         port;
         spinlock_t              lock;
-        struct mutex            mutex;
         unsigned char           number;
 
         unsigned char           *interrupt_in_buffer;
diff --git a/include/linux/usb/ulpi.h b/include/linux/usb/ulpi.h
new file mode 100644
index 00000000000..20675c6ebc4
--- /dev/null
+++ b/include/linux/usb/ulpi.h
@@ -0,0 +1,7 @@
+#ifndef __LINUX_USB_ULPI_H
+#define __LINUX_USB_ULPI_H
+
+struct otg_transceiver *otg_ulpi_create(struct otg_io_access_ops *ops,
+                                        unsigned int flags);
+
+#endif /* __LINUX_USB_ULPI_H */
diff --git a/include/linux/usb/wusb.h b/include/linux/usb/wusb.h
index 429c631d2aa..63ebdcc5dda 100644
--- a/include/linux/usb/wusb.h
+++ b/include/linux/usb/wusb.h
@@ -74,7 +74,7 @@ enum {
  * WUSB defines that CHIDs, CDIDs and CKs are a 16 byte string of
  * data. In order to avoid confusion and enforce types, we wrap it.
  *
- * Make it packed, as we use it in some hw defintions.
+ * Make it packed, as we use it in some hw definitions.
  */
 struct wusb_ckhdid {
         u8 data[16];
diff --git a/include/linux/usb_usual.h b/include/linux/usb_usual.h
index 3d15fb9bc11..a4b947e470a 100644
--- a/include/linux/usb_usual.h
+++ b/include/linux/usb_usual.h
@@ -56,7 +56,9 @@
         US_FLAG(SANE_SENSE,     0x00008000)                     \
                 /* Sane Sense (> 18 bytes) */                   \
         US_FLAG(CAPACITY_OK,    0x00010000)                     \
-                /* READ CAPACITY response is correct */
+                /* READ CAPACITY response is correct */         \
+        US_FLAG(BAD_SENSE,      0x00020000)                     \
+                /* Bad Sense (never more than 18 bytes) */
 
 #define US_FLAG(name, value)    US_FL_##name = value ,
 enum { US_DO_ALL_FLAGS };
diff --git a/include/linux/usbdevice_fs.h b/include/linux/usbdevice_fs.h
index b2a7d8ba6ee..15591d2ea40 100644
--- a/include/linux/usbdevice_fs.h
+++ b/include/linux/usbdevice_fs.h
@@ -128,6 +128,29 @@ struct usbdevfs_hub_portinfo {
 #ifdef __KERNEL__
 #ifdef CONFIG_COMPAT
 #include <linux/compat.h>
+
+struct usbdevfs_ctrltransfer32 {
+        u8 bRequestType;
+        u8 bRequest;
+        u16 wValue;
+        u16 wIndex;
+        u16 wLength;
+        u32 timeout;  /* in milliseconds */
+        compat_caddr_t data;
+};
+
+struct usbdevfs_bulktransfer32 {
+        compat_uint_t ep;
+        compat_uint_t len;
+        compat_uint_t timeout; /* in milliseconds */
+        compat_caddr_t data;
+};
+
+struct usbdevfs_disconnectsignal32 {
+        compat_int_t signr;
+        compat_caddr_t context;
+};
+
 struct usbdevfs_urb32 {
         unsigned char type;
         unsigned char endpoint;
@@ -153,7 +176,9 @@ struct usbdevfs_ioctl32 {
 #endif /* __KERNEL__ */
 
 #define USBDEVFS_CONTROL           _IOWR('U', 0, struct usbdevfs_ctrltransfer)
+#define USBDEVFS_CONTROL32           _IOWR('U', 0, struct usbdevfs_ctrltransfer32)
 #define USBDEVFS_BULK              _IOWR('U', 2, struct usbdevfs_bulktransfer)
+#define USBDEVFS_BULK32              _IOWR('U', 2, struct usbdevfs_bulktransfer32)
 #define USBDEVFS_RESETEP           _IOR('U', 3, unsigned int)
 #define USBDEVFS_SETINTERFACE      _IOR('U', 4, struct usbdevfs_setinterface)
 #define USBDEVFS_SETCONFIGURATION  _IOR('U', 5, unsigned int)
@@ -166,6 +191,7 @@ struct usbdevfs_ioctl32 {
 #define USBDEVFS_REAPURBNDELAY     _IOW('U', 13, void *)
 #define USBDEVFS_REAPURBNDELAY32   _IOW('U', 13, __u32)
 #define USBDEVFS_DISCSIGNAL        _IOR('U', 14, struct usbdevfs_disconnectsignal)
+#define USBDEVFS_DISCSIGNAL32      _IOR('U', 14, struct usbdevfs_disconnectsignal32)
 #define USBDEVFS_CLAIMINTERFACE    _IOR('U', 15, unsigned int)
 #define USBDEVFS_RELEASEINTERFACE  _IOR('U', 16, unsigned int)
 #define USBDEVFS_CONNECTINFO       _IOW('U', 17, struct usbdevfs_connectinfo)
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index b59e78c5716..32b92298fd7 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -361,6 +361,7 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_PJPG     v4l2_fourcc('P', 'J', 'P', 'G') /* Pixart 73xx JPEG */
 #define V4L2_PIX_FMT_OV511    v4l2_fourcc('O', '5', '1', '1') /* ov511 JPEG */
 #define V4L2_PIX_FMT_OV518    v4l2_fourcc('O', '5', '1', '8') /* ov518 JPEG */
+#define V4L2_PIX_FMT_STV0680  v4l2_fourcc('S', '6', '8', '0') /* stv0680 bayer */
 
 /*
  *      F O R M A T   E N U M E R A T I O N
@@ -490,7 +491,7 @@ struct v4l2_jpegcompression {
                                  * you do, leave them untouched.
                                  * Inluding less markers will make the
                                  * resulting code smaller, but there will
-                                 * be fewer aplications which can read it.
+                                 * be fewer applications which can read it.
                                  * The presence of the APP and COM marker
                                  * is influenced by APP_len and COM_len
                                  * ONLY, not by this property! */
@@ -563,6 +564,7 @@ struct v4l2_framebuffer {
 #define V4L2_FBUF_CAP_LOCAL_ALPHA       0x0010
 #define V4L2_FBUF_CAP_GLOBAL_ALPHA      0x0020
 #define V4L2_FBUF_CAP_LOCAL_INV_ALPHA   0x0040
+#define V4L2_FBUF_CAP_SRC_CHROMAKEY     0x0080
 /*  Flags for the 'flags' field. */
 #define V4L2_FBUF_FLAG_PRIMARY          0x0001
 #define V4L2_FBUF_FLAG_OVERLAY          0x0002
@@ -570,6 +572,7 @@ struct v4l2_framebuffer {
 #define V4L2_FBUF_FLAG_LOCAL_ALPHA      0x0008
 #define V4L2_FBUF_FLAG_GLOBAL_ALPHA     0x0010
 #define V4L2_FBUF_FLAG_LOCAL_INV_ALPHA  0x0020
+#define V4L2_FBUF_FLAG_SRC_CHROMAKEY    0x0040
 
 struct v4l2_clip {
         struct v4l2_rect        c;
@@ -912,8 +915,10 @@ enum v4l2_colorfx {
 #define V4L2_CID_AUTOBRIGHTNESS                 (V4L2_CID_BASE+32)
 #define V4L2_CID_BAND_STOP_FILTER               (V4L2_CID_BASE+33)
 
+#define V4L2_CID_ROTATE                         (V4L2_CID_BASE+34)
+#define V4L2_CID_BG_COLOR                       (V4L2_CID_BASE+35)
 /* last CID + 1 */
-#define V4L2_CID_LASTP1                         (V4L2_CID_BASE+34)
+#define V4L2_CID_LASTP1                         (V4L2_CID_BASE+36)
 
 /*  MPEG-class control IDs defined by V4L2 */
 #define V4L2_CID_MPEG_BASE                      (V4L2_CTRL_CLASS_MPEG | 0x900)
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index cf24c20de9e..9466e860d8c 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -25,6 +25,7 @@ typedef void (*work_func_t)(struct work_struct *work);
 struct work_struct {
         atomic_long_t data;
 #define WORK_STRUCT_PENDING 0           /* T if work item pending execution */
+#define WORK_STRUCT_STATIC  1           /* static initializer (debugobjects) */
 #define WORK_STRUCT_FLAG_MASK (3UL)
 #define WORK_STRUCT_WQ_DATA_MASK (~WORK_STRUCT_FLAG_MASK)
         struct list_head entry;
@@ -35,6 +36,7 @@ struct work_struct {
 };
 
 #define WORK_DATA_INIT()        ATOMIC_LONG_INIT(0)
+#define WORK_DATA_STATIC_INIT() ATOMIC_LONG_INIT(2)
 
 struct delayed_work {
         struct work_struct work;
@@ -63,7 +65,7 @@ struct execute_work {
 #endif
 
 #define __WORK_INITIALIZER(n, f) {                              \
-        .data = WORK_DATA_INIT(),                               \
+        .data = WORK_DATA_STATIC_INIT(),                        \
         .entry  = { &(n).entry, &(n).entry },                   \
         .func = (f),                                            \
         __WORK_INIT_LOCKDEP_MAP(#n, &(n))                       \
@@ -91,6 +93,14 @@ struct execute_work {
 #define PREPARE_DELAYED_WORK(_work, _func)                      \
         PREPARE_WORK(&(_work)->work, (_func))
 
+#ifdef CONFIG_DEBUG_OBJECTS_WORK
+extern void __init_work(struct work_struct *work, int onstack);
+extern void destroy_work_on_stack(struct work_struct *work);
+#else
+static inline void __init_work(struct work_struct *work, int onstack) { }
+static inline void destroy_work_on_stack(struct work_struct *work) { }
+#endif
+
 /*
  * initialize all of a work item in one go
  *
@@ -99,24 +109,36 @@ struct execute_work {
  * to generate better code.
  */
 #ifdef CONFIG_LOCKDEP
-#define INIT_WORK(_work, _func)                                         \
+#define __INIT_WORK(_work, _func, _onstack)                             \
         do {                                                            \
                 static struct lock_class_key __key;                     \
                                                                         \
+                __init_work((_work), _onstack);                         \
                 (_work)->data = (atomic_long_t) WORK_DATA_INIT();       \
                 lockdep_init_map(&(_work)->lockdep_map, #_work, &__key, 0);\
                 INIT_LIST_HEAD(&(_work)->entry);                        \
                 PREPARE_WORK((_work), (_func));                         \
         } while (0)
 #else
-#define INIT_WORK(_work, _func)                                         \
+#define __INIT_WORK(_work, _func, _onstack)                             \
         do {                                                            \
+                __init_work((_work), _onstack);                         \
                 (_work)->data = (atomic_long_t) WORK_DATA_INIT();       \
                 INIT_LIST_HEAD(&(_work)->entry);                        \
                 PREPARE_WORK((_work), (_func));                         \
         } while (0)
 #endif
 
+#define INIT_WORK(_work, _func)                                 \
+        do {                                                    \
+                __INIT_WORK((_work), (_func), 0);               \
+        } while (0)
+
+#define INIT_WORK_ON_STACK(_work, _func)                        \
+        do {                                                    \
+                __INIT_WORK((_work), (_func), 1);               \
+        } while (0)
+
 #define INIT_DELAYED_WORK(_work, _func)                         \
         do {                                                    \
                 INIT_WORK(&(_work)->work, (_func));             \
@@ -125,22 +147,16 @@ struct execute_work {
 
 #define INIT_DELAYED_WORK_ON_STACK(_work, _func)                \
         do {                                                    \
-                INIT_WORK(&(_work)->work, (_func));             \
+                INIT_WORK_ON_STACK(&(_work)->work, (_func));    \
                 init_timer_on_stack(&(_work)->timer);           \
         } while (0)
 
-#define INIT_DELAYED_WORK_DEFERRABLE(_work, _func)                      \
+#define INIT_DELAYED_WORK_DEFERRABLE(_work, _func)              \
         do {                                                    \
                 INIT_WORK(&(_work)->work, (_func));             \
                 init_timer_deferrable(&(_work)->timer);         \
         } while (0)
 
-#define INIT_DELAYED_WORK_ON_STACK(_work, _func)                \
-        do {                                                    \
-                INIT_WORK(&(_work)->work, (_func));             \
-                init_timer_on_stack(&(_work)->timer);           \
-        } while (0)
-
 /**
  * work_pending - Find out whether a work item is currently pending
  * @work: The work item in question