Merge branch 'master' of /home/davem/src/GIT/linux-2.6/

43 files changed, 427 insertions, 101 deletions

diff --git a/include/linux/cciss_ioctl.h b/include/linux/cciss_ioctl.h
index cb57c30081a8..eb130b4d8e72 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 519248d8b2b6..d9bac7f97282 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/clockchips.h b/include/linux/clockchips.h
index 3a1dbba4d3ae..0cf725bdd2a1 100644
--- a/include/linux/clockchips.h
+++ b/include/linux/clockchips.h
@@ -77,10 +77,10 @@ enum clock_event_nofitiers {
 struct clock_event_device {
         const char              *name;
         unsigned int            features;
-        unsigned long           max_delta_ns;
-        unsigned long           min_delta_ns;
-        unsigned long           mult;
-        int                     shift;
+        u64                     max_delta_ns;
+        u64                     min_delta_ns;
+        u32                     mult;
+        u32                     shift;
         int                     rating;
         int                     irq;
         const struct cpumask    *cpumask;
@@ -116,8 +116,8 @@ static inline unsigned long div_sc(unsigned long ticks, unsigned long nsec,
 }
 
 /* Clock event layer functions */
-extern unsigned long clockevent_delta2ns(unsigned long latch,
-                                         struct clock_event_device *evt);
+extern u64 clockevent_delta2ns(unsigned long latch,
+                               struct clock_event_device *evt);
 extern void clockevents_register_device(struct clock_event_device *dev);
 
 extern void clockevents_exchange_device(struct clock_event_device *old,
@@ -130,6 +130,13 @@ extern int clockevents_program_event(struct clock_event_device *dev,
 
 extern void clockevents_handle_noop(struct clock_event_device *dev);
 
+static inline void
+clockevents_calc_mult_shift(struct clock_event_device *ce, u32 freq, u32 minsec)
+{
+        return clocks_calc_mult_shift(&ce->mult, &ce->shift, NSEC_PER_SEC,
+                                      freq, minsec);
+}
+
 #ifdef CONFIG_GENERIC_CLOCKEVENTS
 extern void clockevents_notify(unsigned long reason, void *arg);
 #else
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index 83d2fbd81b93..8a4a130cc196 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -151,6 +151,7 @@ extern u64 timecounter_cyc2time(struct timecounter *tc,
  *                      subtraction of non 64 bit counters
  * @mult:               cycle to nanosecond multiplier
  * @shift:              cycle to nanosecond divisor (power of two)
+ * @max_idle_ns:        max idle time permitted by the clocksource (nsecs)
  * @flags:              flags describing special properties
  * @vread:              vsyscall based read
  * @resume:             resume function for the clocksource, if necessary
@@ -168,6 +169,7 @@ struct clocksource {
         cycle_t mask;
         u32 mult;
         u32 shift;
+        u64 max_idle_ns;
         unsigned long flags;
         cycle_t (*vread)(void);
         void (*resume)(void);
@@ -279,11 +281,23 @@ extern void clocksource_resume(void);
 extern struct clocksource * __init __weak clocksource_default_clock(void);
 extern void clocksource_mark_unstable(struct clocksource *cs);
 
+extern void
+clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 minsec);
+
+static inline void
+clocksource_calc_mult_shift(struct clocksource *cs, u32 freq, u32 minsec)
+{
+        return clocks_calc_mult_shift(&cs->mult, &cs->shift, freq,
+                                      NSEC_PER_SEC, minsec);
+}
+
 #ifdef CONFIG_GENERIC_TIME_VSYSCALL
-extern void update_vsyscall(struct timespec *ts, struct clocksource *c);
+extern void
+update_vsyscall(struct timespec *ts, struct clocksource *c, u32 mult);
 extern void update_vsyscall_tz(void);
 #else
-static inline void update_vsyscall(struct timespec *ts, struct clocksource *c)
+static inline void
+update_vsyscall(struct timespec *ts, struct clocksource *c, u32 mult)
 {
 }
 
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index fd929889e8dc..24d2e30f1b46 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -250,29 +250,6 @@ struct cipher_alg {
         void (*cia_decrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
 };
 
-struct digest_alg {
-        unsigned int dia_digestsize;
-        void (*dia_init)(struct crypto_tfm *tfm);
-        void (*dia_update)(struct crypto_tfm *tfm, const u8 *data,
-                           unsigned int len);
-        void (*dia_final)(struct crypto_tfm *tfm, u8 *out);
-        int (*dia_setkey)(struct crypto_tfm *tfm, const u8 *key,
-                          unsigned int keylen);
-};
-
-struct hash_alg {
-        int (*init)(struct hash_desc *desc);
-        int (*update)(struct hash_desc *desc, struct scatterlist *sg,
-                      unsigned int nbytes);
-        int (*final)(struct hash_desc *desc, u8 *out);
-        int (*digest)(struct hash_desc *desc, struct scatterlist *sg,
-                      unsigned int nbytes, u8 *out);
-        int (*setkey)(struct crypto_hash *tfm, const u8 *key,
-                      unsigned int keylen);
-
-        unsigned int digestsize;
-};
-
 struct compress_alg {
         int (*coa_compress)(struct crypto_tfm *tfm, const u8 *src,
                             unsigned int slen, u8 *dst, unsigned int *dlen);
@@ -293,8 +270,6 @@ struct rng_alg {
 #define cra_aead        cra_u.aead
 #define cra_blkcipher   cra_u.blkcipher
 #define cra_cipher      cra_u.cipher
-#define cra_digest      cra_u.digest
-#define cra_hash        cra_u.hash
 #define cra_compress    cra_u.compress
 #define cra_rng         cra_u.rng
 
@@ -320,8 +295,6 @@ struct crypto_alg {
                 struct aead_alg aead;
                 struct blkcipher_alg blkcipher;
                 struct cipher_alg cipher;
-                struct digest_alg digest;
-                struct hash_alg hash;
                 struct compress_alg compress;
                 struct rng_alg rng;
         } cra_u;
diff --git a/include/linux/dm-log-userspace.h b/include/linux/dm-log-userspace.h
index 8a1f972c0fe9..0c3c3a2110c4 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/dmar.h b/include/linux/dmar.h
index 5de4c9e5856d..d7cecc90ed34 100644
--- a/include/linux/dmar.h
+++ b/include/linux/dmar.h
@@ -126,7 +126,9 @@ extern int free_irte(int irq);
 extern int irq_remapped(int irq);
 extern struct intel_iommu *map_dev_to_ir(struct pci_dev *dev);
 extern struct intel_iommu *map_ioapic_to_ir(int apic);
+extern struct intel_iommu *map_hpet_to_ir(u8 id);
 extern int set_ioapic_sid(struct irte *irte, int apic);
+extern int set_hpet_sid(struct irte *irte, u8 id);
 extern int set_msi_sid(struct irte *irte, struct pci_dev *dev);
 #else
 static inline int alloc_irte(struct intel_iommu *iommu, int irq, u16 count)
@@ -158,10 +160,18 @@ static inline struct intel_iommu *map_ioapic_to_ir(int apic)
 {
         return NULL;
 }
+static inline struct intel_iommu *map_hpet_to_ir(unsigned int hpet_id)
+{
+        return NULL;
+}
 static inline int set_ioapic_sid(struct irte *irte, int apic)
 {
         return 0;
 }
+static inline int set_hpet_sid(struct irte *irte, u8 id)
+{
+        return -1;
+}
 static inline int set_msi_sid(struct irte *irte, struct pci_dev *dev)
 {
         return 0;
diff --git a/include/linux/fb.h b/include/linux/fb.h
index de9c722e7b90..369767bd873e 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/hid.h b/include/linux/hid.h
index 10f628416740..87093652dda8 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/hpet.h b/include/linux/hpet.h
index 79f63a27bcef..219ca4f6bea6 100644
--- a/include/linux/hpet.h
+++ b/include/linux/hpet.h
@@ -126,4 +126,6 @@ struct hpet_info {
 #define HPET_DPI        _IO('h', 0x05)  /* disable periodic */
 #define HPET_IRQFREQ    _IOW('h', 0x6, unsigned long)   /* IRQFREQ usec */
 
+#define MAX_HPET_TBS    8               /* maximum hpet timer blocks */
+
 #endif                          /* !__HPET__ */
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index ff037f0b1b4e..9bace4b9f4fe 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -446,7 +446,7 @@ extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf,
 
 static inline void timer_stats_account_hrtimer(struct hrtimer *timer)
 {
-        if (likely(!timer->start_site))
+        if (likely(!timer_stats_active))
                 return;
         timer_stats_update_stats(timer, timer->start_pid, timer->start_site,
                                  timer->function, timer->start_comm, 0);
@@ -457,8 +457,6 @@ extern void __timer_stats_hrtimer_set_start_info(struct hrtimer *timer,
 
 static inline void timer_stats_hrtimer_set_start_info(struct hrtimer *timer)
 {
-        if (likely(!timer_stats_active))
-                return;
         __timer_stats_hrtimer_set_start_info(timer, __builtin_return_address(0));
 }
 
diff --git a/include/linux/hw_random.h b/include/linux/hw_random.h
index 7244456e7e65..9bede7633f74 100644
--- a/include/linux/hw_random.h
+++ b/include/linux/hw_random.h
@@ -22,10 +22,12 @@
  * @cleanup:            Cleanup callback (can be NULL).
  * @data_present:       Callback to determine if data is available
  *                      on the RNG. If NULL, it is assumed that
- *                      there is always data available.
+ *                      there is always data available.  *OBSOLETE*
  * @data_read:          Read data from the RNG device.
  *                      Returns the number of lower random bytes in "data".
- *                      Must not be NULL.
+ *                      Must not be NULL.    *OSOLETE*
+ * @read:               New API. drivers can fill up to max bytes of data
+ *                      into the buffer. The buffer is aligned for any type.
  * @priv:               Private data, for use by the RNG driver.
  */
 struct hwrng {
@@ -34,6 +36,7 @@ struct hwrng {
         void (*cleanup)(struct hwrng *rng);
         int (*data_present)(struct hwrng *rng, int wait);
         int (*data_read)(struct hwrng *rng, u32 *data);
+        int (*read)(struct hwrng *rng, void *data, size_t max, bool wait);
         unsigned long priv;
 
         /* internal. */
diff --git a/include/linux/ide.h b/include/linux/ide.h
index e4135d6e0556..0ec612959042 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/in6.h b/include/linux/in6.h
index dfa29168e6ab..bd55c6e46b2e 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 597a0077b3c5..5e3dddf8f562 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 84b501ab0d8f..7be8a6537b57 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 b3cd42d50e16..3bd018baae20 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 000000000000..c211b5cf08e6
--- /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 000000000000..52db62064c6e
--- /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 ae9653dbcd78..a287cfc0b1a6 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/libata.h b/include/linux/libata.h
index a5b3dc71e819..6a9c4ddd3d95 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 e5124ceea769..3402042ddc31 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 000000000000..3bcd7163485c
--- /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 6913b71d9ab2..b31bd9e9bca3 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/pci_ids.h b/include/linux/pci_ids.h
index cabf074b4324..eae1f864c934 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
diff --git a/include/linux/pktcdvd.h b/include/linux/pktcdvd.h
index d745f5b6c7b0..76e5053e1fac 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/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index dd31e7bae35c..a05b4a20768d 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 dab68bbed675..52c83b6a758a 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/screen_info.h b/include/linux/screen_info.h
index 1ee2c05142f6..899fbb487c94 100644
--- a/include/linux/screen_info.h
+++ b/include/linux/screen_info.h
@@ -14,7 +14,8 @@ struct screen_info {
         __u16 orig_video_page;  /* 0x04 */
         __u8  orig_video_mode;  /* 0x06 */
         __u8  orig_video_cols;  /* 0x07 */
-        __u16 unused2;          /* 0x08 */
+        __u8  flags;            /* 0x08 */
+        __u8  unused2;          /* 0x09 */
         __u16 orig_video_ega_bx;/* 0x0a */
         __u16 unused3;          /* 0x0c */
         __u8  orig_video_lines; /* 0x0e */
@@ -65,6 +66,8 @@ struct screen_info {
 
 #define VIDEO_TYPE_EFI          0x70    /* EFI graphic mode             */
 
+#define VIDEO_FLAGS_NOCURSOR    (1 << 0) /* The video mode has no cursor set */
+
 #ifdef __KERNEL__
 extern struct screen_info screen_info;
 
diff --git a/include/linux/serial_reg.h b/include/linux/serial_reg.h
index 850db2e80510..cf9327c051ad 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 a640bc2afe76..e2f3044d4a4a 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 68e212ff9dde..4ef246f14654 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 000000000000..07c08af9f8f6
--- /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/spi_bitbang.h b/include/linux/spi/spi_bitbang.h
index eed4254bd503..3274c507b8a9 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/sysctl.h b/include/linux/sysctl.h
index 56af3ca75e24..877ba039e6a4 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/tick.h b/include/linux/tick.h
index 0482229c07db..d2ae79e21be3 100644
--- a/include/linux/tick.h
+++ b/include/linux/tick.h
@@ -43,6 +43,7 @@ enum tick_nohz_mode {
  * @idle_exittime:      Time when the idle state was left
  * @idle_sleeptime:     Sum of the time slept in idle with sched tick stopped
  * @sleep_length:       Duration of the current idle sleep
+ * @do_timer_lst:       CPU was the last one doing do_timer before going idle
  */
 struct tick_sched {
         struct hrtimer                  sched_timer;
@@ -64,6 +65,7 @@ struct tick_sched {
         unsigned long                   last_jiffies;
         unsigned long                   next_jiffies;
         ktime_t                         idle_expires;
+        int                             do_timer_last;
 };
 
 extern void __init tick_init(void);
@@ -98,6 +100,9 @@ extern int tick_check_oneshot_change(int allow_nohz);
 extern struct tick_sched *tick_get_tick_sched(int cpu);
 extern void tick_check_idle(int cpu);
 extern int tick_oneshot_mode_active(void);
+#  ifndef arch_needs_cpu
+#   define arch_needs_cpu(cpu) (0)
+#  endif
 # else
 static inline void tick_clock_notify(void) { }
 static inline int tick_check_oneshot_change(int allow_nohz) { return 0; }
diff --git a/include/linux/time.h b/include/linux/time.h
index fe04e5ef6a59..6e026e45a179 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -148,6 +148,7 @@ extern void monotonic_to_bootbased(struct timespec *ts);
 
 extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
 extern int timekeeping_valid_for_hres(void);
+extern u64 timekeeping_max_deferment(void);
 extern void update_wall_time(void);
 extern void update_xtime_cache(u64 nsec);
 extern void timekeeping_leap_insert(int leapsecond);
diff --git a/include/linux/timex.h b/include/linux/timex.h
index e6967d10d9e5..94f8faecdcbc 100644
--- a/include/linux/timex.h
+++ b/include/linux/timex.h
@@ -115,13 +115,16 @@ struct timex {
 #define ADJ_OFFSET_SS_READ      0xa001  /* read-only adjtime */
 #endif
 
-/* xntp 3.4 compatibility names */
+/* NTP userland likes the MOD_ prefix better */
 #define MOD_OFFSET      ADJ_OFFSET
 #define MOD_FREQUENCY   ADJ_FREQUENCY
 #define MOD_MAXERROR    ADJ_MAXERROR
 #define MOD_ESTERROR    ADJ_ESTERROR
 #define MOD_STATUS      ADJ_STATUS
 #define MOD_TIMECONST   ADJ_TIMECONST
+#define MOD_TAI ADJ_TAI
+#define MOD_MICRO       ADJ_MICRO
+#define MOD_NANO        ADJ_NANO
 
 
 /*
@@ -261,11 +264,7 @@ static inline int ntp_synced(void)
 
 #define NTP_SCALE_SHIFT         32
 
-#ifdef CONFIG_NO_HZ
-#define NTP_INTERVAL_FREQ  (2)
-#else
 #define NTP_INTERVAL_FREQ  (HZ)
-#endif
 #define NTP_INTERVAL_LENGTH (NSEC_PER_SEC/NTP_INTERVAL_FREQ)
 
 /* Returns how long ticks are at present, in ns / 2^NTP_SCALE_SHIFT. */
diff --git a/include/linux/ucb1400.h b/include/linux/ucb1400.h
index adb44066680c..1b4790911052 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/wusb.h b/include/linux/usb/wusb.h
index 429c631d2aad..63ebdcc5dda6 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/videodev2.h b/include/linux/videodev2.h
index b59e78c57161..32b92298fd79 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/vt_kern.h b/include/linux/vt_kern.h
index c0c4e1103a73..7f56db4a79f0 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -110,6 +110,7 @@ extern char con_buf[CON_BUF_SIZE];
 extern struct mutex con_buf_mtx;
 extern char vt_dont_switch;
 extern int default_utf8;
+extern int global_cursor_default;
 
 struct vt_spawn_console {
         spinlock_t lock;
@@ -130,4 +131,6 @@ struct vt_notifier_param {
 extern int register_vt_notifier(struct notifier_block *nb);
 extern int unregister_vt_notifier(struct notifier_block *nb);
 
+extern void hide_boot_cursor(bool hide);
+
 #endif /* _VT_KERN_H */
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index cf24c20de9e4..9466e860d8c2 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