Merge branch 'linus' into core/rcu

Merge reason: Backmerge latest upstream to queue up dependent fix in the
              scheduler.

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

68 files changed, 1550 insertions, 470 deletions

diff --git a/include/acpi/acpi_bus.h b/include/acpi/acpi_bus.h
index 3cd9ccdcbd8f..54508ccea023 100644
--- a/include/acpi/acpi_bus.h
+++ b/include/acpi/acpi_bus.h
@@ -242,6 +242,8 @@ struct acpi_device_perf {
 struct acpi_device_wakeup_flags {
         u8 valid:1;             /* Can successfully enable wakeup? */
         u8 run_wake:1;          /* Run-Wake GPE devices */
+        u8 always_enabled:1;    /* Run-wake devices that are always enabled */
+        u8 notifier_present:1;  /* Wake-up notify handler has been installed */
 };
 
 struct acpi_device_wakeup_state {
@@ -256,6 +258,7 @@ struct acpi_device_wakeup {
         struct acpi_device_wakeup_state state;
         struct acpi_device_wakeup_flags flags;
         int prepare_count;
+        int run_wake_count;
 };
 
 /* Device */
@@ -386,6 +389,9 @@ acpi_handle acpi_get_pci_rootbridge_handle(unsigned int, unsigned int);
 struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle);
 #define DEVICE_ACPI_HANDLE(dev) ((acpi_handle)((dev)->archdata.acpi_handle))
 
+int acpi_enable_wakeup_device_power(struct acpi_device *dev, int state);
+int acpi_disable_wakeup_device_power(struct acpi_device *dev);
+
 #ifdef CONFIG_PM_SLEEP
 int acpi_pm_device_sleep_state(struct device *, int *);
 int acpi_pm_device_sleep_wake(struct device *, bool);
diff --git a/include/acpi/acpi_drivers.h b/include/acpi/acpi_drivers.h
index f4906f6568d4..3a4767c01c5f 100644
--- a/include/acpi/acpi_drivers.h
+++ b/include/acpi/acpi_drivers.h
@@ -104,6 +104,7 @@ int acpi_pci_bind_root(struct acpi_device *device);
 
 struct pci_bus *pci_acpi_scan_root(struct acpi_device *device, int domain,
                                    int bus);
+void pci_acpi_crs_quirks(void);
 
 /* --------------------------------------------------------------------------
                                     Processor
diff --git a/include/acpi/acpixf.h b/include/acpi/acpixf.h
index 86e9735a96bd..3988f93b9c66 100644
--- a/include/acpi/acpixf.h
+++ b/include/acpi/acpixf.h
@@ -281,11 +281,11 @@ acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status);
 /*
  * GPE Interfaces
  */
-acpi_status acpi_set_gpe_type(acpi_handle gpe_device, u32 gpe_number, u8 type);
+acpi_status acpi_set_gpe(acpi_handle gpe_device, u32 gpe_number, u8 action);
 
-acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number);
+acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number, u8 type);
 
-acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number);
+acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u8 type);
 
 acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags);
 
diff --git a/include/acpi/actypes.h b/include/acpi/actypes.h
index 153f12dc3373..73af40863371 100644
--- a/include/acpi/actypes.h
+++ b/include/acpi/actypes.h
@@ -668,15 +668,16 @@ typedef u32 acpi_event_status;
 
 /*
  * GPE info flags - Per GPE
- * +-+-+-+---+---+-+
- * |7|6|5|4:3|2:1|0|
- * +-+-+-+---+---+-+
- *  | | |  |   |  |
- *  | | |  |   |  +--- Interrupt type: Edge or Level Triggered
- *  | | |  |   +--- Type: Wake-only, Runtime-only, or wake/runtime
+ * +-+-+-+---+-+-+-+
+ * |7|6|5|4:3|2|1|0|
+ * +-+-+-+---+-+-+-+
+ *  | | |  |  | | |
+ *  | | |  |  | | +--- Interrupt type: Edge or Level Triggered
+ *  | | |  |  | +--- GPE can wake the system
+ *  | | |  |  +--- Unused
  *  | | |  +--- Type of dispatch -- to method, handler, or none
- *  | | +--- Enabled for runtime?
- *  | +--- Enabled for wake?
+ *  | | +--- Unused
+ *  | +--- Unused
  *  +--- Unused
  */
 #define ACPI_GPE_XRUPT_TYPE_MASK        (u8) 0x01
@@ -687,22 +688,13 @@ typedef u32 acpi_event_status;
 #define ACPI_GPE_TYPE_WAKE_RUN          (u8) 0x06
 #define ACPI_GPE_TYPE_WAKE              (u8) 0x02
 #define ACPI_GPE_TYPE_RUNTIME           (u8) 0x04       /* Default */
+#define ACPI_GPE_CAN_WAKE               (u8) 0x02
 
 #define ACPI_GPE_DISPATCH_MASK          (u8) 0x18
 #define ACPI_GPE_DISPATCH_HANDLER       (u8) 0x08
 #define ACPI_GPE_DISPATCH_METHOD        (u8) 0x10
 #define ACPI_GPE_DISPATCH_NOT_USED      (u8) 0x00       /* Default */
 
-#define ACPI_GPE_RUN_ENABLE_MASK        (u8) 0x20
-#define ACPI_GPE_RUN_ENABLED            (u8) 0x20
-#define ACPI_GPE_RUN_DISABLED           (u8) 0x00       /* Default */
-
-#define ACPI_GPE_WAKE_ENABLE_MASK       (u8) 0x40
-#define ACPI_GPE_WAKE_ENABLED           (u8) 0x40
-#define ACPI_GPE_WAKE_DISABLED          (u8) 0x00       /* Default */
-
-#define ACPI_GPE_ENABLE_MASK            (u8) 0x60       /* Both run/wake */
-
 /*
  * Flags for GPE and Lock interfaces
  */
diff --git a/include/crypto/md5.h b/include/crypto/md5.h
new file mode 100644
index 000000000000..65f299b08b0d
--- /dev/null
+++ b/include/crypto/md5.h
@@ -0,0 +1,17 @@
+#ifndef _CRYPTO_MD5_H
+#define _CRYPTO_MD5_H
+
+#include <linux/types.h>
+
+#define MD5_DIGEST_SIZE         16
+#define MD5_HMAC_BLOCK_SIZE     64
+#define MD5_BLOCK_WORDS         16
+#define MD5_HASH_WORDS          4
+
+struct md5_state {
+        u32 hash[MD5_HASH_WORDS];
+        u32 block[MD5_BLOCK_WORDS];
+        u64 byte_count;
+};
+
+#endif
diff --git a/include/crypto/pcrypt.h b/include/crypto/pcrypt.h
new file mode 100644
index 000000000000..d7d8bd8c6edc
--- /dev/null
+++ b/include/crypto/pcrypt.h
@@ -0,0 +1,51 @@
+/*
+ * pcrypt - Parallel crypto engine.
+ *
+ * Copyright (C) 2009 secunet Security Networks AG
+ * Copyright (C) 2009 Steffen Klassert <steffen.klassert@secunet.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef _CRYPTO_PCRYPT_H
+#define _CRYPTO_PCRYPT_H
+
+#include <linux/crypto.h>
+#include <linux/kernel.h>
+#include <linux/padata.h>
+
+struct pcrypt_request {
+        struct padata_priv      padata;
+        void                    *data;
+        void                    *__ctx[] CRYPTO_MINALIGN_ATTR;
+};
+
+static inline void *pcrypt_request_ctx(struct pcrypt_request *req)
+{
+        return req->__ctx;
+}
+
+static inline
+struct padata_priv *pcrypt_request_padata(struct pcrypt_request *req)
+{
+        return &req->padata;
+}
+
+static inline
+struct pcrypt_request *pcrypt_padata_request(struct padata_priv *padata)
+{
+        return container_of(padata, struct pcrypt_request, padata);
+}
+
+#endif
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index c05a29cb9bb2..25b8b2f33ae9 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -25,7 +25,7 @@
 static __inline__ int get_bitmask_order(unsigned int count)
 {
         int order;
-        
+
         order = fls(count);
         return order;   /* We could be slightly more clever with -1 here... */
 }
@@ -33,7 +33,7 @@ static __inline__ int get_bitmask_order(unsigned int count)
 static __inline__ int get_count_order(unsigned int count)
 {
         int order;
-        
+
         order = fls(count) - 1;
         if (count & (count - 1))
                 order++;
@@ -45,6 +45,31 @@ static inline unsigned long hweight_long(unsigned long w)
         return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
 }
 
+/*
+ * Clearly slow versions of the hweightN() functions, their benefit is
+ * of course compile time evaluation of constant arguments.
+ */
+#define HWEIGHT8(w)                                     \
+      ( BUILD_BUG_ON_ZERO(!__builtin_constant_p(w)) +   \
+        (!!((w) & (1ULL << 0))) +                       \
+        (!!((w) & (1ULL << 1))) +                       \
+        (!!((w) & (1ULL << 2))) +                       \
+        (!!((w) & (1ULL << 3))) +                       \
+        (!!((w) & (1ULL << 4))) +                       \
+        (!!((w) & (1ULL << 5))) +                       \
+        (!!((w) & (1ULL << 6))) +                       \
+        (!!((w) & (1ULL << 7))) )
+
+#define HWEIGHT16(w) (HWEIGHT8(w)  + HWEIGHT8((w) >> 8))
+#define HWEIGHT32(w) (HWEIGHT16(w) + HWEIGHT16((w) >> 16))
+#define HWEIGHT64(w) (HWEIGHT32(w) + HWEIGHT32((w) >> 32))
+
+/*
+ * Type invariant version that simply casts things to the
+ * largest type.
+ */
+#define HWEIGHT(w)   HWEIGHT64((u64)(w))
+
 /**
  * rol32 - rotate a 32-bit value left
  * @word: value to rotate
diff --git a/include/linux/device.h b/include/linux/device.h
index a62799f2ab00..b30527db3ac0 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -472,6 +472,23 @@ static inline int device_is_registered(struct device *dev)
         return dev->kobj.state_in_sysfs;
 }
 
+static inline void device_enable_async_suspend(struct device *dev)
+{
+        if (dev->power.status == DPM_ON)
+                dev->power.async_suspend = true;
+}
+
+static inline void device_disable_async_suspend(struct device *dev)
+{
+        if (dev->power.status == DPM_ON)
+                dev->power.async_suspend = false;
+}
+
+static inline bool device_async_suspend_enabled(struct device *dev)
+{
+        return !!dev->power.async_suspend;
+}
+
 void driver_init(void);
 
 /*
diff --git a/include/linux/elf.h b/include/linux/elf.h
index 0cc4d55151b7..ad990c5f63f6 100644
--- a/include/linux/elf.h
+++ b/include/linux/elf.h
@@ -349,7 +349,11 @@ typedef struct elf64_shdr {
 #define ELF_OSABI ELFOSABI_NONE
 #endif
 
-/* Notes used in ET_CORE */
+/*
+ * Notes used in ET_CORE. Architectures export some of the arch register sets
+ * using the corresponding note types via the PTRACE_GETREGSET and
+ * PTRACE_SETREGSET requests.
+ */
 #define NT_PRSTATUS     1
 #define NT_PRFPREG      2
 #define NT_PRPSINFO     3
@@ -361,7 +365,13 @@ typedef struct elf64_shdr {
 #define NT_PPC_VSX      0x102           /* PowerPC VSX registers */
 #define NT_386_TLS      0x200           /* i386 TLS slots (struct user_desc) */
 #define NT_386_IOPERM   0x201           /* x86 io permission bitmap (1=deny) */
+#define NT_X86_XSTATE   0x202           /* x86 extended state using xsave */
 #define NT_S390_HIGH_GPRS       0x300   /* s390 upper register halves */
+#define NT_S390_TIMER   0x301           /* s390 timer register */
+#define NT_S390_TODCMP  0x302           /* s390 TOD clock comparator register */
+#define NT_S390_TODPREG 0x303           /* s390 TOD programmable register */
+#define NT_S390_CTRS    0x304           /* s390 control registers */
+#define NT_S390_PREFIX  0x305           /* s390 prefix register */
 
 
 /* Note header in a PT_NOTE section */
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 0b4f97d24d7f..01e6adea07ec 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -134,6 +134,8 @@ extern void
 unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
 extern void unregister_ftrace_function_probe_all(char *glob);
 
+extern int ftrace_text_reserved(void *start, void *end);
+
 enum {
         FTRACE_FL_FREE          = (1 << 0),
         FTRACE_FL_FAILED        = (1 << 1),
@@ -141,7 +143,6 @@ enum {
         FTRACE_FL_ENABLED       = (1 << 3),
         FTRACE_FL_NOTRACE       = (1 << 4),
         FTRACE_FL_CONVERTED     = (1 << 5),
-        FTRACE_FL_FROZEN        = (1 << 6),
 };
 
 struct dyn_ftrace {
@@ -250,6 +251,10 @@ static inline int unregister_ftrace_command(char *cmd_name)
 {
         return -EINVAL;
 }
+static inline int ftrace_text_reserved(void *start, void *end)
+{
+        return 0;
+}
 #endif /* CONFIG_DYNAMIC_FTRACE */
 
 /* totally disable ftrace - can not re-enable after this */
@@ -511,4 +516,10 @@ static inline void trace_hw_branch_oops(void) {}
 
 #endif /* CONFIG_HW_BRANCH_TRACER */
 
+#ifdef CONFIG_FTRACE_SYSCALLS
+
+unsigned long arch_syscall_addr(int nr);
+
+#endif /* CONFIG_FTRACE_SYSCALLS */
+
 #endif /* _LINUX_FTRACE_H */
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index 2233c98d80df..6b7c444ab8f6 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -5,6 +5,7 @@
 #include <linux/trace_seq.h>
 #include <linux/percpu.h>
 #include <linux/hardirq.h>
+#include <linux/perf_event.h>
 
 struct trace_array;
 struct tracer;
@@ -121,9 +122,8 @@ struct ftrace_event_call {
         int                     (*regfunc)(struct ftrace_event_call *);
         void                    (*unregfunc)(struct ftrace_event_call *);
         int                     id;
+        const char              *print_fmt;
         int                     (*raw_init)(struct ftrace_event_call *);
-        int                     (*show_format)(struct ftrace_event_call *,
-                                               struct trace_seq *);
         int                     (*define_fields)(struct ftrace_event_call *);
         struct list_head        fields;
         int                     filter_active;
@@ -138,9 +138,6 @@ struct ftrace_event_call {
 
 #define FTRACE_MAX_PROFILE_SIZE 2048
 
-extern char *perf_trace_buf;
-extern char *perf_trace_buf_nmi;
-
 #define MAX_FILTER_PRED         32
 #define MAX_FILTER_STR_VAL      256     /* Should handle KSYM_SYMBOL_LEN */
 
@@ -188,13 +185,27 @@ do {									\
                 __trace_printk(ip, fmt, ##args);                        \
 } while (0)
 
-#ifdef CONFIG_EVENT_PROFILE
+#ifdef CONFIG_PERF_EVENTS
 struct perf_event;
 extern int ftrace_profile_enable(int event_id);
 extern void ftrace_profile_disable(int event_id);
 extern int ftrace_profile_set_filter(struct perf_event *event, int event_id,
                                      char *filter_str);
 extern void ftrace_profile_free_filter(struct perf_event *event);
+extern void *
+ftrace_perf_buf_prepare(int size, unsigned short type, int *rctxp,
+                         unsigned long *irq_flags);
+
+static inline void
+ftrace_perf_buf_submit(void *raw_data, int size, int rctx, u64 addr,
+                       u64 count, unsigned long irq_flags)
+{
+        struct trace_entry *entry = raw_data;
+
+        perf_tp_event(entry->type, addr, count, raw_data, size);
+        perf_swevent_put_recursion_context(rctx);
+        local_irq_restore(irq_flags);
+}
 #endif
 
 #endif /* _LINUX_FTRACE_EVENT_H */
diff --git a/include/linux/hid.h b/include/linux/hid.h
index 87093652dda8..b1344ec4b7fc 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -501,7 +501,7 @@ struct hid_device {							/* device report descriptor */
         void (*hiddev_report_event) (struct hid_device *, struct hid_report *);
 
         /* handler for raw output data, used by hidraw */
-        int (*hid_output_raw_report) (struct hid_device *, __u8 *, size_t);
+        int (*hid_output_raw_report) (struct hid_device *, __u8 *, size_t, unsigned char);
 
         /* debugging support via debugfs */
         unsigned short debug;
@@ -663,7 +663,7 @@ struct hid_ll_driver {
 
 /* Applications from HID Usage Tables 4/8/99 Version 1.1 */
 /* We ignore a few input applications that are not widely used */
-#define IS_INPUT_APPLICATION(a) (((a >= 0x00010000) && (a <= 0x00010008)) || (a == 0x00010080) || (a == 0x000c0001) || (a == 0x000d0002))
+#define IS_INPUT_APPLICATION(a) (((a >= 0x00010000) && (a <= 0x00010008)) || (a == 0x00010080) || (a == 0x000c0001) || ((a >= 0x000d0002) && (a <= 0x000d0006)))
 
 /* HID core API */
 
@@ -690,6 +690,7 @@ int hid_input_report(struct hid_device *, int type, u8 *, int, int);
 int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field);
 void hid_output_report(struct hid_report *report, __u8 *data);
 struct hid_device *hid_allocate_device(void);
+struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id);
 int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size);
 int hid_check_keys_pressed(struct hid_device *hid);
 int hid_connect(struct hid_device *hid, unsigned int connect_mask);
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index ab2cc20e21a5..74152c08ad07 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -17,6 +17,12 @@ static inline void flush_anon_page(struct vm_area_struct *vma, struct page *page
 static inline void flush_kernel_dcache_page(struct page *page)
 {
 }
+static inline void flush_kernel_vmap_range(void *vaddr, int size)
+{
+}
+static inline void invalidate_kernel_vmap_range(void *vaddr, int size)
+{
+}
 #endif
 
 #include <asm/kmap_types.h>
diff --git a/include/linux/input.h b/include/linux/input.h
index 663208afb64c..f44ee9114401 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -598,6 +598,48 @@ struct input_absinfo {
 
 #define KEY_CAMERA_FOCUS        0x210
 
+#define BTN_TRIGGER_HAPPY               0x2c0
+#define BTN_TRIGGER_HAPPY1              0x2c0
+#define BTN_TRIGGER_HAPPY2              0x2c1
+#define BTN_TRIGGER_HAPPY3              0x2c2
+#define BTN_TRIGGER_HAPPY4              0x2c3
+#define BTN_TRIGGER_HAPPY5              0x2c4
+#define BTN_TRIGGER_HAPPY6              0x2c5
+#define BTN_TRIGGER_HAPPY7              0x2c6
+#define BTN_TRIGGER_HAPPY8              0x2c7
+#define BTN_TRIGGER_HAPPY9              0x2c8
+#define BTN_TRIGGER_HAPPY10             0x2c9
+#define BTN_TRIGGER_HAPPY11             0x2ca
+#define BTN_TRIGGER_HAPPY12             0x2cb
+#define BTN_TRIGGER_HAPPY13             0x2cc
+#define BTN_TRIGGER_HAPPY14             0x2cd
+#define BTN_TRIGGER_HAPPY15             0x2ce
+#define BTN_TRIGGER_HAPPY16             0x2cf
+#define BTN_TRIGGER_HAPPY17             0x2d0
+#define BTN_TRIGGER_HAPPY18             0x2d1
+#define BTN_TRIGGER_HAPPY19             0x2d2
+#define BTN_TRIGGER_HAPPY20             0x2d3
+#define BTN_TRIGGER_HAPPY21             0x2d4
+#define BTN_TRIGGER_HAPPY22             0x2d5
+#define BTN_TRIGGER_HAPPY23             0x2d6
+#define BTN_TRIGGER_HAPPY24             0x2d7
+#define BTN_TRIGGER_HAPPY25             0x2d8
+#define BTN_TRIGGER_HAPPY26             0x2d9
+#define BTN_TRIGGER_HAPPY27             0x2da
+#define BTN_TRIGGER_HAPPY28             0x2db
+#define BTN_TRIGGER_HAPPY29             0x2dc
+#define BTN_TRIGGER_HAPPY30             0x2dd
+#define BTN_TRIGGER_HAPPY31             0x2de
+#define BTN_TRIGGER_HAPPY32             0x2df
+#define BTN_TRIGGER_HAPPY33             0x2e0
+#define BTN_TRIGGER_HAPPY34             0x2e1
+#define BTN_TRIGGER_HAPPY35             0x2e2
+#define BTN_TRIGGER_HAPPY36             0x2e3
+#define BTN_TRIGGER_HAPPY37             0x2e4
+#define BTN_TRIGGER_HAPPY38             0x2e5
+#define BTN_TRIGGER_HAPPY39             0x2e6
+#define BTN_TRIGGER_HAPPY40             0x2e7
+
 /* We avoid low common keys in module aliases so they don't get huge. */
 #define KEY_MIN_INTERESTING     KEY_MUTE
 #define KEY_MAX                 0x2ff
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index 7129504e053d..dda98410d588 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -112,6 +112,7 @@ extern struct resource iomem_resource;
 
 extern int request_resource(struct resource *root, struct resource *new);
 extern int release_resource(struct resource *new);
+void release_child_resources(struct resource *new);
 extern void reserve_region_with_split(struct resource *root,
                              resource_size_t start, resource_size_t end,
                              const char *name);
@@ -120,8 +121,10 @@ extern void insert_resource_expand_to_fit(struct resource *root, struct resource
 extern int allocate_resource(struct resource *root, struct resource *new,
                              resource_size_t size, resource_size_t min,
                              resource_size_t max, resource_size_t align,
-                             void (*alignf)(void *, struct resource *,
-                                            resource_size_t, resource_size_t),
+                             resource_size_t (*alignf)(void *,
+                                                       const struct resource *,
+                                                       resource_size_t,
+                                                       resource_size_t),
                              void *alignf_data);
 int adjust_resource(struct resource *res, resource_size_t start,
                     resource_size_t size);
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 328bca609b9b..1221d2331a6d 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -124,7 +124,7 @@ extern int _cond_resched(void);
 #endif
 
 #ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
-  void __might_sleep(char *file, int line, int preempt_offset);
+  void __might_sleep(const char *file, int line, int preempt_offset);
 /**
  * might_sleep - annotation for functions that can sleep
  *
@@ -138,7 +138,8 @@ extern int _cond_resched(void);
 # define might_sleep() \
         do { __might_sleep(__FILE__, __LINE__, 0); might_resched(); } while (0)
 #else
-  static inline void __might_sleep(char *file, int line, int preempt_offset) { }
+  static inline void __might_sleep(const char *file, int line,
+                                   int preempt_offset) { }
 # define might_sleep() do { might_resched(); } while (0)
 #endif
 
diff --git a/include/linux/list.h b/include/linux/list.h
index 969f6e92d089..5d9c6558e8ab 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -206,6 +206,20 @@ static inline int list_empty_careful(const struct list_head *head)
 }
 
 /**
+ * list_rotate_left - rotate the list to the left
+ * @head: the head of the list
+ */
+static inline void list_rotate_left(struct list_head *head)
+{
+        struct list_head *first;
+
+        if (!list_empty(head)) {
+                first = head->next;
+                list_move_tail(first, head);
+        }
+}
+
+/**
  * list_is_singular - tests whether a list has just one entry.
  * @head: the list to test.
  */
diff --git a/include/linux/lmb.h b/include/linux/lmb.h
index ef82b8fcbddb..f3d14333ebed 100644
--- a/include/linux/lmb.h
+++ b/include/linux/lmb.h
@@ -42,6 +42,7 @@ extern void __init lmb_init(void);
 extern void __init lmb_analyze(void);
 extern long lmb_add(u64 base, u64 size);
 extern long lmb_remove(u64 base, u64 size);
+extern long __init lmb_free(u64 base, u64 size);
 extern long __init lmb_reserve(u64 base, u64 size);
 extern u64 __init lmb_alloc_nid(u64 size, u64 align, int nid,
                                 u64 (*nid_range)(u64, u64, int *));
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 60c467bfbabd..8b2fa8593c61 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -265,6 +265,8 @@ static inline int get_page_unless_zero(struct page *page)
         return atomic_inc_not_zero(&page->_count);
 }
 
+extern int page_is_ram(unsigned long pfn);
+
 /* Support for virtually mapped pages */
 struct page *vmalloc_to_page(const void *addr);
 unsigned long vmalloc_to_pfn(const void *addr);
diff --git a/include/linux/mtd/sh_flctl.h b/include/linux/mtd/sh_flctl.h
index e77c1cea404d..ab77609ec337 100644
--- a/include/linux/mtd/sh_flctl.h
+++ b/include/linux/mtd/sh_flctl.h
@@ -51,6 +51,8 @@
 #define _4ECCCNTEN      (0x1 << 24)
 #define _4ECCEN         (0x1 << 23)
 #define _4ECCCORRECT    (0x1 << 22)
+#define SHBUSSEL        (0x1 << 20)
+#define SEL_16BIT       (0x1 << 19)
 #define SNAND_E         (0x1 << 18)     /* SNAND (0=512 1=2048)*/
 #define QTSEL_E         (0x1 << 17)
 #define ENDIAN          (0x1 << 16)     /* 1 = little endian */
@@ -96,6 +98,7 @@
 struct sh_flctl {
         struct mtd_info         mtd;
         struct nand_chip        chip;
+        struct platform_device  *pdev;
         void __iomem            *reg;
 
         uint8_t done_buff[2048 + 64];   /* max size 2048 + 64 */
diff --git a/include/linux/of.h b/include/linux/of.h
index e7facd8fbce8..f6d9cbc39c9c 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -19,6 +19,11 @@
 #include <linux/bitops.h>
 #include <linux/kref.h>
 #include <linux/mod_devicetable.h>
+#include <linux/spinlock.h>
+
+#include <asm/byteorder.h>
+
+#ifdef CONFIG_OF
 
 typedef u32 phandle;
 typedef u32 ihandle;
@@ -39,10 +44,7 @@ struct of_irq_controller;
 struct device_node {
         const char *name;
         const char *type;
-        phandle node;
-#if !defined(CONFIG_SPARC)
-        phandle linux_phandle;
-#endif
+        phandle phandle;
         char    *full_name;
 
         struct  property *properties;
@@ -63,6 +65,11 @@ struct device_node {
 #endif
 };
 
+/* Pointer for first entry in chain of all nodes. */
+extern struct device_node *allnodes;
+extern struct device_node *of_chosen;
+extern rwlock_t devtree_lock;
+
 static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
 {
         return test_bit(flag, &n->_flags);
@@ -73,12 +80,6 @@ static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
         set_bit(flag, &n->_flags);
 }
 
-static inline void
-set_node_proc_entry(struct device_node *dn, struct proc_dir_entry *de)
-{
-        dn->pde = de;
-}
-
 extern struct device_node *of_find_all_nodes(struct device_node *prev);
 
 #if defined(CONFIG_SPARC)
@@ -101,26 +102,36 @@ extern void of_node_put(struct device_node *node);
  */
 
 /* Helper to read a big number; size is in cells (not bytes) */
-static inline u64 of_read_number(const u32 *cell, int size)
+static inline u64 of_read_number(const __be32 *cell, int size)
 {
         u64 r = 0;
         while (size--)
-                r = (r << 32) | *(cell++);
+                r = (r << 32) | be32_to_cpu(*(cell++));
         return r;
 }
 
 /* Like of_read_number, but we want an unsigned long result */
-#ifdef CONFIG_PPC32
-static inline unsigned long of_read_ulong(const u32 *cell, int size)
+static inline unsigned long of_read_ulong(const __be32 *cell, int size)
 {
-        return cell[size-1];
+        /* toss away upper bits if unsigned long is smaller than u64 */
+        return of_read_number(cell, size);
 }
-#else
-#define of_read_ulong(cell, size)       of_read_number(cell, size)
-#endif
 
 #include <asm/prom.h>
 
+/* Default #address and #size cells.  Allow arch asm/prom.h to override */
+#if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT)
+#define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1
+#define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1
+#endif
+
+/* Default string compare functions, Allow arch asm/prom.h to override */
+#if !defined(of_compat_cmp)
+#define of_compat_cmp(s1, s2, l)        strncasecmp((s1), (s2), (l))
+#define of_prop_cmp(s1, s2)             strcmp((s1), (s2))
+#define of_node_cmp(s1, s2)             strcasecmp((s1), (s2))
+#endif
+
 /* flag descriptions */
 #define OF_DYNAMIC      1 /* node and properties were allocated via kmalloc */
 #define OF_DETACHED     2 /* node has been detached from the device tree */
@@ -187,4 +198,19 @@ extern int of_parse_phandles_with_args(struct device_node *np,
         const char *list_name, const char *cells_name, int index,
         struct device_node **out_node, const void **out_args);
 
+extern int of_machine_is_compatible(const char *compat);
+
+extern int prom_add_property(struct device_node* np, struct property* prop);
+extern int prom_remove_property(struct device_node *np, struct property *prop);
+extern int prom_update_property(struct device_node *np,
+                                struct property *newprop,
+                                struct property *oldprop);
+
+#if defined(CONFIG_OF_DYNAMIC)
+/* For updating the device tree at runtime */
+extern void of_attach_node(struct device_node *);
+extern void of_detach_node(struct device_node *);
+#endif
+
+#endif /* CONFIG_OF */
 #endif /* _LINUX_OF_H */
diff --git a/include/linux/of_fdt.h b/include/linux/of_fdt.h
index 41d432b13553..a1ca92ccb0ff 100644
--- a/include/linux/of_fdt.h
+++ b/include/linux/of_fdt.h
@@ -42,45 +42,62 @@
  * ends when size is 0
  */
 struct boot_param_header {
-        u32     magic;                  /* magic word OF_DT_HEADER */
-        u32     totalsize;              /* total size of DT block */
-        u32     off_dt_struct;          /* offset to structure */
-        u32     off_dt_strings;         /* offset to strings */
-        u32     off_mem_rsvmap;         /* offset to memory reserve map */
-        u32     version;                /* format version */
-        u32     last_comp_version;      /* last compatible version */
+        __be32  magic;                  /* magic word OF_DT_HEADER */
+        __be32  totalsize;              /* total size of DT block */
+        __be32  off_dt_struct;          /* offset to structure */
+        __be32  off_dt_strings;         /* offset to strings */
+        __be32  off_mem_rsvmap;         /* offset to memory reserve map */
+        __be32  version;                /* format version */
+        __be32  last_comp_version;      /* last compatible version */
         /* version 2 fields below */
-        u32     boot_cpuid_phys;        /* Physical CPU id we're booting on */
+        __be32  boot_cpuid_phys;        /* Physical CPU id we're booting on */
         /* version 3 fields below */
-        u32     dt_strings_size;        /* size of the DT strings block */
+        __be32  dt_strings_size;        /* size of the DT strings block */
         /* version 17 fields below */
-        u32     dt_struct_size;         /* size of the DT structure block */
+        __be32  dt_struct_size;         /* size of the DT structure block */
 };
 
+/* TBD: Temporary export of fdt globals - remove when code fully merged */
+extern int __initdata dt_root_addr_cells;
+extern int __initdata dt_root_size_cells;
+extern struct boot_param_header *initial_boot_params;
+
 /* For scanning the flat device-tree at boot time */
-extern int __init of_scan_flat_dt(int (*it)(unsigned long node,
-                                            const char *uname, int depth,
-                                            void *data),
-                                  void *data);
-extern void __init *of_get_flat_dt_prop(unsigned long node, const char *name,
-                                        unsigned long *size);
-extern int __init of_flat_dt_is_compatible(unsigned long node,
-                                           const char *name);
-extern unsigned long __init of_get_flat_dt_root(void);
+extern char *find_flat_dt_string(u32 offset);
+extern int of_scan_flat_dt(int (*it)(unsigned long node, const char *uname,
+                                     int depth, void *data),
+                           void *data);
+extern void *of_get_flat_dt_prop(unsigned long node, const char *name,
+                                 unsigned long *size);
+extern int of_flat_dt_is_compatible(unsigned long node, const char *name);
+extern unsigned long of_get_flat_dt_root(void);
+extern void early_init_dt_scan_chosen_arch(unsigned long node);
+extern int early_init_dt_scan_chosen(unsigned long node, const char *uname,
+                                     int depth, void *data);
+extern void early_init_dt_check_for_initrd(unsigned long node);
+extern int early_init_dt_scan_memory(unsigned long node, const char *uname,
+                                     int depth, void *data);
+extern void early_init_dt_add_memory_arch(u64 base, u64 size);
+extern u64 early_init_dt_alloc_memory_arch(u64 size, u64 align);
+extern u64 dt_mem_next_cell(int s, __be32 **cellp);
+
+/*
+ * If BLK_DEV_INITRD, the fdt early init code will call this function,
+ * to be provided by the arch code. start and end are specified as
+ * physical addresses.
+ */
+#ifdef CONFIG_BLK_DEV_INITRD
+extern void early_init_dt_setup_initrd_arch(unsigned long start,
+                                            unsigned long end);
+#endif
+
+/* Early flat tree scan hooks */
+extern int early_init_dt_scan_root(unsigned long node, const char *uname,
+                                   int depth, void *data);
 
 /* Other Prototypes */
-extern void finish_device_tree(void);
 extern void unflatten_device_tree(void);
 extern void early_init_devtree(void *);
-extern int machine_is_compatible(const char *compat);
-extern void print_properties(struct device_node *node);
-extern int prom_n_intr_cells(struct device_node* np);
-extern void prom_get_irq_senses(unsigned char *senses, int off, int max);
-extern int prom_add_property(struct device_node* np, struct property* prop);
-extern int prom_remove_property(struct device_node *np, struct property *prop);
-extern int prom_update_property(struct device_node *np,
-                                struct property *newprop,
-                                struct property *oldprop);
 
 #endif /* __ASSEMBLY__ */
 #endif /* _LINUX_OF_FDT_H */
diff --git a/include/linux/padata.h b/include/linux/padata.h
new file mode 100644
index 000000000000..51611da9c498
--- /dev/null
+++ b/include/linux/padata.h
@@ -0,0 +1,88 @@
+/*
+ * padata.h - header for the padata parallelization interface
+ *
+ * Copyright (C) 2008, 2009 secunet Security Networks AG
+ * Copyright (C) 2008, 2009 Steffen Klassert <steffen.klassert@secunet.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef PADATA_H
+#define PADATA_H
+
+#include <linux/workqueue.h>
+#include <linux/spinlock.h>
+#include <linux/list.h>
+
+struct padata_priv {
+        struct list_head        list;
+        struct parallel_data    *pd;
+        int                     cb_cpu;
+        int                     seq_nr;
+        int                     info;
+        void                    (*parallel)(struct padata_priv *padata);
+        void                    (*serial)(struct padata_priv *padata);
+};
+
+struct padata_list {
+        struct list_head        list;
+        spinlock_t              lock;
+};
+
+struct padata_queue {
+        struct padata_list      parallel;
+        struct padata_list      reorder;
+        struct padata_list      serial;
+        struct work_struct      pwork;
+        struct work_struct      swork;
+        struct parallel_data    *pd;
+        atomic_t                num_obj;
+        int                     cpu_index;
+};
+
+struct parallel_data {
+        struct padata_instance  *pinst;
+        struct padata_queue     *queue;
+        atomic_t                seq_nr;
+        atomic_t                reorder_objects;
+        atomic_t                refcnt;
+        unsigned int            max_seq_nr;
+        cpumask_var_t           cpumask;
+        spinlock_t              lock;
+};
+
+struct padata_instance {
+        struct notifier_block   cpu_notifier;
+        struct workqueue_struct *wq;
+        struct parallel_data    *pd;
+        cpumask_var_t           cpumask;
+        struct mutex            lock;
+        u8                      flags;
+#define PADATA_INIT             1
+#define PADATA_RESET            2
+};
+
+extern struct padata_instance *padata_alloc(const struct cpumask *cpumask,
+                                            struct workqueue_struct *wq);
+extern void padata_free(struct padata_instance *pinst);
+extern int padata_do_parallel(struct padata_instance *pinst,
+                              struct padata_priv *padata, int cb_cpu);
+extern void padata_do_serial(struct padata_priv *padata);
+extern int padata_set_cpumask(struct padata_instance *pinst,
+                              cpumask_var_t cpumask);
+extern int padata_add_cpu(struct padata_instance *pinst, int cpu);
+extern int padata_remove_cpu(struct padata_instance *pinst, int cpu);
+extern void padata_start(struct padata_instance *pinst);
+extern void padata_stop(struct padata_instance *pinst);
+#endif
diff --git a/include/linux/pci-acpi.h b/include/linux/pci-acpi.h
index 93a7c08f869d..c8b6473c5f42 100644
--- a/include/linux/pci-acpi.h
+++ b/include/linux/pci-acpi.h
@@ -11,6 +11,13 @@
 #include <linux/acpi.h>
 
 #ifdef CONFIG_ACPI
+extern acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev,
+                                                 struct pci_bus *pci_bus);
+extern acpi_status pci_acpi_remove_bus_pm_notifier(struct acpi_device *dev);
+extern acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev,
+                                             struct pci_dev *pci_dev);
+extern acpi_status pci_acpi_remove_pm_notifier(struct acpi_device *dev);
+
 static inline acpi_handle acpi_find_root_bridge_handle(struct pci_dev *pdev)
 {
         struct pci_bus *pbus = pdev->bus;
diff --git a/include/linux/pci.h b/include/linux/pci.h
index c1968f464c38..25813738c71a 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -187,6 +187,33 @@ enum pci_bus_flags {
         PCI_BUS_FLAGS_NO_MMRBC = (__force pci_bus_flags_t) 2,
 };
 
+/* Based on the PCI Hotplug Spec, but some values are made up by us */
+enum pci_bus_speed {
+        PCI_SPEED_33MHz                 = 0x00,
+        PCI_SPEED_66MHz                 = 0x01,
+        PCI_SPEED_66MHz_PCIX            = 0x02,
+        PCI_SPEED_100MHz_PCIX           = 0x03,
+        PCI_SPEED_133MHz_PCIX           = 0x04,
+        PCI_SPEED_66MHz_PCIX_ECC        = 0x05,
+        PCI_SPEED_100MHz_PCIX_ECC       = 0x06,
+        PCI_SPEED_133MHz_PCIX_ECC       = 0x07,
+        PCI_SPEED_66MHz_PCIX_266        = 0x09,
+        PCI_SPEED_100MHz_PCIX_266       = 0x0a,
+        PCI_SPEED_133MHz_PCIX_266       = 0x0b,
+        AGP_UNKNOWN                     = 0x0c,
+        AGP_1X                          = 0x0d,
+        AGP_2X                          = 0x0e,
+        AGP_4X                          = 0x0f,
+        AGP_8X                          = 0x10,
+        PCI_SPEED_66MHz_PCIX_533        = 0x11,
+        PCI_SPEED_100MHz_PCIX_533       = 0x12,
+        PCI_SPEED_133MHz_PCIX_533       = 0x13,
+        PCIE_SPEED_2_5GT                = 0x14,
+        PCIE_SPEED_5_0GT                = 0x15,
+        PCIE_SPEED_8_0GT                = 0x16,
+        PCI_SPEED_UNKNOWN               = 0xff,
+};
+
 struct pci_cap_saved_state {
         struct hlist_node next;
         char cap_nr;
@@ -239,6 +266,7 @@ struct pci_dev {
                                            configuration space */
         unsigned int    pme_support:5;  /* Bitmask of states from which PME#
                                            can be generated */
+        unsigned int    pme_interrupt:1;
         unsigned int    d1_support:1;   /* Low power state D1 is supported */
         unsigned int    d2_support:1;   /* Low power state D2 is supported */
         unsigned int    no_d1d2:1;      /* Only allow D0 and D3 */
@@ -275,7 +303,8 @@ struct pci_dev {
         unsigned int    msix_enabled:1;
         unsigned int    ari_enabled:1;  /* ARI forwarding */
         unsigned int    is_managed:1;
-        unsigned int    is_pcie:1;
+        unsigned int    is_pcie:1;      /* Obsolete. Will be removed.
+                                           Use pci_is_pcie() instead */
         unsigned int    needs_freset:1; /* Dev requires fundamental reset */
         unsigned int    state_saved:1;
         unsigned int    is_physfn:1;
@@ -335,9 +364,26 @@ static inline void pci_add_saved_cap(struct pci_dev *pci_dev,
         hlist_add_head(&new_cap->next, &pci_dev->saved_cap_space);
 }
 
-#ifndef PCI_BUS_NUM_RESOURCES
-#define PCI_BUS_NUM_RESOURCES   16
-#endif
+/*
+ * The first PCI_BRIDGE_RESOURCE_NUM PCI bus resources (those that correspond
+ * to P2P or CardBus bridge windows) go in a table.  Additional ones (for
+ * buses below host bridges or subtractive decode bridges) go in the list.
+ * Use pci_bus_for_each_resource() to iterate through all the resources.
+ */
+
+/*
+ * PCI_SUBTRACTIVE_DECODE means the bridge forwards the window implicitly
+ * and there's no way to program the bridge with the details of the window.
+ * This does not apply to ACPI _CRS windows, even with the _DEC subtractive-
+ * decode bit set, because they are explicit and can be programmed with _SRS.
+ */
+#define PCI_SUBTRACTIVE_DECODE  0x1
+
+struct pci_bus_resource {
+        struct list_head list;
+        struct resource *res;
+        unsigned int flags;
+};
 
 #define PCI_REGION_FLAG_MASK    0x0fU   /* These bits of resource flags tell us the PCI region flags */
 
@@ -348,8 +394,8 @@ struct pci_bus {
         struct list_head devices;       /* list of devices on this bus */
         struct pci_dev  *self;          /* bridge device as seen by parent */
         struct list_head slots;         /* list of slots on this bus */
-        struct resource *resource[PCI_BUS_NUM_RESOURCES];
-                                        /* address space routed to this bus */
+        struct resource *resource[PCI_BRIDGE_RESOURCE_NUM];
+        struct list_head resources;     /* address space routed to this bus */
 
         struct pci_ops  *ops;           /* configuration access functions */
         void            *sysdata;       /* hook for sys-specific extension */
@@ -359,6 +405,8 @@ struct pci_bus {
         unsigned char   primary;        /* number of primary bridge */
         unsigned char   secondary;      /* number of secondary bridge */
         unsigned char   subordinate;    /* max number of subordinate buses */
+        unsigned char   max_bus_speed;  /* enum pci_bus_speed */
+        unsigned char   cur_bus_speed;  /* enum pci_bus_speed */
 
         char            name[48];
 
@@ -563,7 +611,8 @@ int __must_check pcibios_enable_device(struct pci_dev *, int mask);
 char *pcibios_setup(char *str);
 
 /* Used only when drivers/pci/setup.c is used */
-void pcibios_align_resource(void *, struct resource *, resource_size_t,
+resource_size_t pcibios_align_resource(void *, const struct resource *,
+                                resource_size_t,
                                 resource_size_t);
 void pcibios_update_irq(struct pci_dev *, int irq);
 
@@ -589,6 +638,7 @@ struct pci_bus *pci_create_bus(struct device *parent, int bus,
                                struct pci_ops *ops, void *sysdata);
 struct pci_bus *pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev,
                                 int busnr);
+void pcie_update_link_speed(struct pci_bus *bus, u16 link_status);
 struct pci_slot *pci_create_slot(struct pci_bus *parent, int slot_nr,
                                  const char *name,
                                  struct hotplug_slot *hotplug);
@@ -615,12 +665,6 @@ extern void pci_sort_breadthfirst(void);
 
 /* Generic PCI functions exported to card drivers */
 
-#ifdef CONFIG_PCI_LEGACY
-struct pci_dev __deprecated *pci_find_device(unsigned int vendor,
-                                             unsigned int device,
-                                             struct pci_dev *from);
-#endif /* CONFIG_PCI_LEGACY */
-
 enum pci_lost_interrupt_reason {
         PCI_LOST_IRQ_NO_INFORMATION = 0,
         PCI_LOST_IRQ_DISABLE_MSI,
@@ -750,11 +794,19 @@ int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
 pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
 bool pci_pme_capable(struct pci_dev *dev, pci_power_t state);
 void pci_pme_active(struct pci_dev *dev, bool enable);
-int pci_enable_wake(struct pci_dev *dev, pci_power_t state, bool enable);
+int __pci_enable_wake(struct pci_dev *dev, pci_power_t state,
+                      bool runtime, bool enable);
 int pci_wake_from_d3(struct pci_dev *dev, bool enable);
 pci_power_t pci_target_state(struct pci_dev *dev);
 int pci_prepare_to_sleep(struct pci_dev *dev);
 int pci_back_from_sleep(struct pci_dev *dev);
+bool pci_dev_run_wake(struct pci_dev *dev);
+
+static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state,
+                                  bool enable)
+{
+        return __pci_enable_wake(dev, state, false, enable);
+}
 
 /* For use by arch with custom probe code */
 void set_pcie_port_type(struct pci_dev *pdev);
@@ -776,6 +828,7 @@ void pci_bus_assign_resources(const struct pci_bus *bus);
 void pci_bus_size_bridges(struct pci_bus *bus);
 int pci_claim_resource(struct pci_dev *, int);
 void pci_assign_unassigned_resources(void);
+void pci_assign_unassigned_bridge_resources(struct pci_dev *bridge);
 void pdev_enable_device(struct pci_dev *);
 void pdev_sort_resources(struct pci_dev *, struct resource_list *);
 int pci_enable_resources(struct pci_dev *, int mask);
@@ -793,12 +846,23 @@ int pci_request_selected_regions_exclusive(struct pci_dev *, int, const char *);
 void pci_release_selected_regions(struct pci_dev *, int);
 
 /* drivers/pci/bus.c */
+void pci_bus_add_resource(struct pci_bus *bus, struct resource *res, unsigned int flags);
+struct resource *pci_bus_resource_n(const struct pci_bus *bus, int n);
+void pci_bus_remove_resources(struct pci_bus *bus);
+
+#define pci_bus_for_each_resource(bus, res, i)                          \
+        for (i = 0;                                                     \
+            (res = pci_bus_resource_n(bus, i)) || i < PCI_BRIDGE_RESOURCE_NUM; \
+             i++)
+
 int __must_check pci_bus_alloc_resource(struct pci_bus *bus,
                         struct resource *res, resource_size_t size,
                         resource_size_t align, resource_size_t min,
                         unsigned int type_mask,
-                        void (*alignf)(void *, struct resource *,
-                                resource_size_t, resource_size_t),
+                        resource_size_t (*alignf)(void *,
+                                                  const struct resource *,
+                                                  resource_size_t,
+                                                  resource_size_t),
                         void *alignf_data);
 void pci_enable_bridges(struct pci_bus *bus);
 
@@ -959,6 +1023,11 @@ static inline int pci_proc_domain(struct pci_bus *bus)
 }
 #endif /* CONFIG_PCI_DOMAINS */
 
+/* some architectures require additional setup to direct VGA traffic */
+typedef int (*arch_set_vga_state_t)(struct pci_dev *pdev, bool decode,
+                      unsigned int command_bits, bool change_bridge);
+extern void pci_register_set_vga_state(arch_set_vga_state_t func);
+
 #else /* CONFIG_PCI is not enabled */
 
 /*
@@ -977,13 +1046,6 @@ static inline int pci_proc_domain(struct pci_bus *bus)
 _PCI_NOP_ALL(read, *)
 _PCI_NOP_ALL(write,)
 
-static inline struct pci_dev *pci_find_device(unsigned int vendor,
-                                              unsigned int device,
-                                              struct pci_dev *from)
-{
-        return NULL;
-}
-
 static inline struct pci_dev *pci_get_device(unsigned int vendor,
                                              unsigned int device,
                                              struct pci_dev *from)
@@ -1241,8 +1303,12 @@ enum pci_fixup_pass {
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend,                   \
                         suspend##vendor##device##hook, vendor, device, hook)
 
-
+#ifdef CONFIG_PCI_QUIRKS
 void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev);
+#else
+static inline void pci_fixup_device(enum pci_fixup_pass pass,
+                                    struct pci_dev *dev) {}
+#endif
 
 void __iomem *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen);
 void pcim_iounmap(struct pci_dev *pdev, void __iomem *addr);
diff --git a/include/linux/pci_hotplug.h b/include/linux/pci_hotplug.h
index 652ba797696d..5d09cbafa7db 100644
--- a/include/linux/pci_hotplug.h
+++ b/include/linux/pci_hotplug.h
@@ -28,26 +28,6 @@
 #ifndef _PCI_HOTPLUG_H
 #define _PCI_HOTPLUG_H
 
-
-/* These values come from the PCI Hotplug Spec */
-enum pci_bus_speed {
-        PCI_SPEED_33MHz                 = 0x00,
-        PCI_SPEED_66MHz                 = 0x01,
-        PCI_SPEED_66MHz_PCIX            = 0x02,
-        PCI_SPEED_100MHz_PCIX           = 0x03,
-        PCI_SPEED_133MHz_PCIX           = 0x04,
-        PCI_SPEED_66MHz_PCIX_ECC        = 0x05,
-        PCI_SPEED_100MHz_PCIX_ECC       = 0x06,
-        PCI_SPEED_133MHz_PCIX_ECC       = 0x07,
-        PCI_SPEED_66MHz_PCIX_266        = 0x09,
-        PCI_SPEED_100MHz_PCIX_266       = 0x0a,
-        PCI_SPEED_133MHz_PCIX_266       = 0x0b,
-        PCI_SPEED_66MHz_PCIX_533        = 0x11,
-        PCI_SPEED_100MHz_PCIX_533       = 0x12,
-        PCI_SPEED_133MHz_PCIX_533       = 0x13,
-        PCI_SPEED_UNKNOWN               = 0xff,
-};
-
 /* These values come from the PCI Express Spec */
 enum pcie_link_width {
         PCIE_LNK_WIDTH_RESRV    = 0x00,
@@ -61,12 +41,6 @@ enum pcie_link_width {
         PCIE_LNK_WIDTH_UNKNOWN  = 0xFF,
 };
 
-enum pcie_link_speed {
-        PCIE_2_5GB              = 0x14,
-        PCIE_5_0GB              = 0x15,
-        PCIE_LNK_SPEED_UNKNOWN  = 0xFF,
-};
-
 /**
  * struct hotplug_slot_ops -the callbacks that the hotplug pci core can use
  * @owner: The module owner of this structure
@@ -89,12 +63,6 @@ enum pcie_link_speed {
  * @get_adapter_status: Called to get see if an adapter is present in the slot or not.
  *      If this field is NULL, the value passed in the struct hotplug_slot_info
  *      will be used when this value is requested by a user.
- * @get_max_bus_speed: Called to get the max bus speed for a slot.
- *      If this field is NULL, the value passed in the struct hotplug_slot_info
- *      will be used when this value is requested by a user.
- * @get_cur_bus_speed: Called to get the current bus speed for a slot.
- *      If this field is NULL, the value passed in the struct hotplug_slot_info
- *      will be used when this value is requested by a user.
  *
  * The table of function pointers that is passed to the hotplug pci core by a
  * hotplug pci driver.  These functions are called by the hotplug pci core when
@@ -112,17 +80,14 @@ struct hotplug_slot_ops {
         int (*get_attention_status)     (struct hotplug_slot *slot, u8 *value);
         int (*get_latch_status)         (struct hotplug_slot *slot, u8 *value);
         int (*get_adapter_status)       (struct hotplug_slot *slot, u8 *value);
-        int (*get_max_bus_speed)        (struct hotplug_slot *slot, enum pci_bus_speed *value);
-        int (*get_cur_bus_speed)        (struct hotplug_slot *slot, enum pci_bus_speed *value);
 };
 
 /**
  * struct hotplug_slot_info - used to notify the hotplug pci core of the state of the slot
- * @power: if power is enabled or not (1/0)
+ * @power_status: if power is enabled or not (1/0)
  * @attention_status: if the attention light is enabled or not (1/0)
  * @latch_status: if the latch (if any) is open or closed (1/0)
- * @adapter_present: if there is a pci board present in the slot or not (1/0)
- * @address: (domain << 16 | bus << 8 | dev)
+ * @adapter_status: if there is a pci board present in the slot or not (1/0)
  *
  * Used to notify the hotplug pci core of the status of a specific slot.
  */
@@ -131,8 +96,6 @@ struct hotplug_slot_info {
         u8      attention_status;
         u8      latch_status;
         u8      adapter_status;
-        enum pci_bus_speed      max_bus_speed;
-        enum pci_bus_speed      cur_bus_speed;
 };
 
 /**
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index cca8a044e2b6..0be824320580 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -2417,6 +2417,9 @@
 #define PCI_DEVICE_ID_INTEL_82840_HB    0x1a21
 #define PCI_DEVICE_ID_INTEL_82845_HB    0x1a30
 #define PCI_DEVICE_ID_INTEL_IOAT        0x1a38
+#define PCI_DEVICE_ID_INTEL_CPT_SMBUS   0x1c22
+#define PCI_DEVICE_ID_INTEL_CPT_LPC1    0x1c42
+#define PCI_DEVICE_ID_INTEL_CPT_LPC2    0x1c43
 #define PCI_DEVICE_ID_INTEL_82801AA_0   0x2410
 #define PCI_DEVICE_ID_INTEL_82801AA_1   0x2411
 #define PCI_DEVICE_ID_INTEL_82801AA_3   0x2413
diff --git a/include/linux/percpu_counter.h b/include/linux/percpu_counter.h
index a7684a513994..794662b2be5d 100644
--- a/include/linux/percpu_counter.h
+++ b/include/linux/percpu_counter.h
@@ -98,9 +98,6 @@ static inline void percpu_counter_set(struct percpu_counter *fbc, s64 amount)
         fbc->count = amount;
 }
 
-#define __percpu_counter_add(fbc, amount, batch) \
-        percpu_counter_add(fbc, amount)
-
 static inline void
 percpu_counter_add(struct percpu_counter *fbc, s64 amount)
 {
@@ -109,6 +106,12 @@ percpu_counter_add(struct percpu_counter *fbc, s64 amount)
         preempt_enable();
 }
 
+static inline void
+__percpu_counter_add(struct percpu_counter *fbc, s64 amount, s32 batch)
+{
+        percpu_counter_add(fbc, amount);
+}
+
 static inline s64 percpu_counter_read(struct percpu_counter *fbc)
 {
         return fbc->count;
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index a177698d95e2..7b18b4fd5df7 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -288,7 +288,7 @@ struct perf_event_mmap_page {
 };
 
 #define PERF_RECORD_MISC_CPUMODE_MASK           (3 << 0)
-#define PERF_RECORD_MISC_CPUMODE_UNKNOWN                (0 << 0)
+#define PERF_RECORD_MISC_CPUMODE_UNKNOWN        (0 << 0)
 #define PERF_RECORD_MISC_KERNEL                 (1 << 0)
 #define PERF_RECORD_MISC_USER                   (2 << 0)
 #define PERF_RECORD_MISC_HYPERVISOR             (3 << 0)
@@ -354,8 +354,8 @@ enum perf_event_type {
          *      u64                             stream_id;
          * };
          */
-        PERF_RECORD_THROTTLE            = 5,
-        PERF_RECORD_UNTHROTTLE          = 6,
+        PERF_RECORD_THROTTLE                    = 5,
+        PERF_RECORD_UNTHROTTLE                  = 6,
 
         /*
          * struct {
@@ -369,10 +369,10 @@ enum perf_event_type {
 
         /*
          * struct {
-         *      struct perf_event_header        header;
-         *      u32                             pid, tid;
+         *      struct perf_event_header        header;
+         *      u32                             pid, tid;
          *
-         *      struct read_format              values;
+         *      struct read_format              values;
          * };
          */
         PERF_RECORD_READ                        = 8,
@@ -410,7 +410,7 @@ enum perf_event_type {
          *        char                  data[size];}&& PERF_SAMPLE_RAW
          * };
          */
-        PERF_RECORD_SAMPLE              = 9,
+        PERF_RECORD_SAMPLE                      = 9,
 
         PERF_RECORD_MAX,                        /* non-ABI */
 };
@@ -476,9 +476,11 @@ struct hw_perf_event {
         union {
                 struct { /* hardware */
                         u64             config;
+                        u64             last_tag;
                         unsigned long   config_base;
                         unsigned long   event_base;
                         int             idx;
+                        int             last_cpu;
                 };
                 struct { /* software */
                         s64             remaining;
@@ -496,9 +498,8 @@ struct hw_perf_event {
         atomic64_t                      period_left;
         u64                             interrupts;
 
-        u64                             freq_count;
-        u64                             freq_interrupts;
-        u64                             freq_stamp;
+        u64                             freq_time_stamp;
+        u64                             freq_count_stamp;
 #endif
 };
 
@@ -510,6 +511,8 @@ struct perf_event;
 struct pmu {
         int (*enable)                   (struct perf_event *event);
         void (*disable)                 (struct perf_event *event);
+        int (*start)                    (struct perf_event *event);
+        void (*stop)                    (struct perf_event *event);
         void (*read)                    (struct perf_event *event);
         void (*unthrottle)              (struct perf_event *event);
 };
@@ -563,6 +566,10 @@ typedef void (*perf_overflow_handler_t)(struct perf_event *, int,
                                         struct perf_sample_data *,
                                         struct pt_regs *regs);
 
+enum perf_group_flag {
+        PERF_GROUP_SOFTWARE = 0x1,
+};
+
 /**
  * struct perf_event - performance event kernel representation:
  */
@@ -572,6 +579,7 @@ struct perf_event {
         struct list_head                event_entry;
         struct list_head                sibling_list;
         int                             nr_siblings;
+        int                             group_flags;
         struct perf_event               *group_leader;
         struct perf_event               *output;
         const struct pmu                *pmu;
@@ -656,7 +664,7 @@ struct perf_event {
 
         perf_overflow_handler_t         overflow_handler;
 
-#ifdef CONFIG_EVENT_PROFILE
+#ifdef CONFIG_EVENT_TRACING
         struct event_filter             *filter;
 #endif
 
@@ -681,7 +689,8 @@ struct perf_event_context {
          */
         struct mutex                    mutex;
 
-        struct list_head                group_list;
+        struct list_head                pinned_groups;
+        struct list_head                flexible_groups;
         struct list_head                event_list;
         int                             nr_events;
         int                             nr_active;
@@ -744,10 +753,9 @@ extern int perf_max_events;
 
 extern const struct pmu *hw_perf_event_init(struct perf_event *event);
 
-extern void perf_event_task_sched_in(struct task_struct *task, int cpu);
-extern void perf_event_task_sched_out(struct task_struct *task,
-                                        struct task_struct *next, int cpu);
-extern void perf_event_task_tick(struct task_struct *task, int cpu);
+extern void perf_event_task_sched_in(struct task_struct *task);
+extern void perf_event_task_sched_out(struct task_struct *task, struct task_struct *next);
+extern void perf_event_task_tick(struct task_struct *task);
 extern int perf_event_init_task(struct task_struct *child);
 extern void perf_event_exit_task(struct task_struct *child);
 extern void perf_event_free_task(struct task_struct *task);
@@ -762,7 +770,7 @@ extern int perf_event_task_disable(void);
 extern int perf_event_task_enable(void);
 extern int hw_perf_group_sched_in(struct perf_event *group_leader,
                struct perf_cpu_context *cpuctx,
-               struct perf_event_context *ctx, int cpu);
+               struct perf_event_context *ctx);
 extern void perf_event_update_userpage(struct perf_event *event);
 extern int perf_event_release_kernel(struct perf_event *event);
 extern struct perf_event *
@@ -851,8 +859,7 @@ extern int sysctl_perf_event_mlock;
 extern int sysctl_perf_event_sample_rate;
 
 extern void perf_event_init(void);
-extern void perf_tp_event(int event_id, u64 addr, u64 count,
-                                 void *record, int entry_size);
+extern void perf_tp_event(int event_id, u64 addr, u64 count, void *record, int entry_size);
 extern void perf_bp_event(struct perf_event *event, void *data);
 
 #ifndef perf_misc_flags
@@ -873,12 +880,12 @@ 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)             { }
+perf_event_task_sched_in(struct task_struct *task)                      { }
 static inline void
 perf_event_task_sched_out(struct task_struct *task,
-                            struct task_struct *next, int cpu)          { }
+                            struct task_struct *next)                   { }
 static inline void
-perf_event_task_tick(struct task_struct *task, int cpu)                 { }
+perf_event_task_tick(struct task_struct *task)                          { }
 static inline int perf_event_init_task(struct task_struct *child)       { return 0; }
 static inline void perf_event_exit_task(struct task_struct *child)      { }
 static inline void perf_event_free_task(struct task_struct *task)       { }
@@ -893,13 +900,13 @@ static inline void
 perf_sw_event(u32 event_id, u64 nr, int nmi,
                      struct pt_regs *regs, u64 addr)                    { }
 static inline void
-perf_bp_event(struct perf_event *event, void *data)             { }
+perf_bp_event(struct perf_event *event, void *data)                     { }
 
 static inline void perf_event_mmap(struct vm_area_struct *vma)          { }
 static inline void perf_event_comm(struct task_struct *tsk)             { }
 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 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)         { }
diff --git a/include/linux/pfkeyv2.h b/include/linux/pfkeyv2.h
index 228b0b6306b0..0b80c806631f 100644
--- a/include/linux/pfkeyv2.h
+++ b/include/linux/pfkeyv2.h
@@ -315,6 +315,7 @@ struct sadb_x_kmaddress {
 #define SADB_X_EALG_AES_GCM_ICV12       19
 #define SADB_X_EALG_AES_GCM_ICV16       20
 #define SADB_X_EALG_CAMELLIACBC         22
+#define SADB_X_EALG_NULL_AES_GMAC       23
 #define SADB_EALG_MAX                   253 /* last EALG */
 /* private allocations should use 249-255 (RFC2407) */
 #define SADB_X_EALG_SERPENTCBC  252     /* draft-ietf-ipsec-ciph-aes-cbc-00 */
diff --git a/include/linux/plist.h b/include/linux/plist.h
index 8227f717c70f..6898985e7b38 100644
--- a/include/linux/plist.h
+++ b/include/linux/plist.h
@@ -45,7 +45,7 @@
  * the insertion of new nodes. There are no nodes with duplicate
  * priorites on the list.
  *
- * The nodes on the node_list is ordered by priority and can contain
+ * The nodes on the node_list are ordered by priority and can contain
  * entries which have the same priority. Those entries are ordered
  * FIFO
  *
@@ -265,7 +265,7 @@ static inline int plist_node_empty(const struct plist_node *node)
  *
  * Assumes the plist is _not_ empty.
  */
-static inline struct plist_node* plist_first(const struct plist_head *head)
+static inline struct plist_node *plist_first(const struct plist_head *head)
 {
         return list_entry(head->node_list.next,
                           struct plist_node, plist.node_list);
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 198b8f9fe05e..e80df06ad22a 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -26,6 +26,7 @@
 #include <linux/spinlock.h>
 #include <linux/wait.h>
 #include <linux/timer.h>
+#include <linux/completion.h>
 
 /*
  * Callbacks for platform drivers to implement.
@@ -412,9 +413,11 @@ struct dev_pm_info {
         pm_message_t            power_state;
         unsigned int            can_wakeup:1;
         unsigned int            should_wakeup:1;
+        unsigned                async_suspend:1;
         enum dpm_state          status;         /* Owned by the PM core */
 #ifdef CONFIG_PM_SLEEP
         struct list_head        entry;
+        struct completion       completion;
 #endif
 #ifdef CONFIG_PM_RUNTIME
         struct timer_list       suspend_timer;
@@ -430,6 +433,7 @@ struct dev_pm_info {
         unsigned int            request_pending:1;
         unsigned int            deferred_resume:1;
         unsigned int            run_wake:1;
+        unsigned int            runtime_auto:1;
         enum rpm_request        request;
         enum rpm_status         runtime_status;
         int                     runtime_error;
@@ -508,6 +512,7 @@ extern void __suspend_report_result(const char *function, void *fn, int ret);
                 __suspend_report_result(__func__, fn, ret);             \
         } while (0)
 
+extern void device_pm_wait_for_dev(struct device *sub, struct device *dev);
 #else /* !CONFIG_PM_SLEEP */
 
 #define device_pm_lock() do {} while (0)
@@ -520,6 +525,7 @@ static inline int dpm_suspend_start(pm_message_t state)
 
 #define suspend_report_result(fn, ret)          do {} while (0)
 
+static inline void device_pm_wait_for_dev(struct device *a, struct device *b) {}
 #endif /* !CONFIG_PM_SLEEP */
 
 /* How to reorder dpm_list after device_move() */
diff --git a/include/linux/pm_runtime.h b/include/linux/pm_runtime.h
index 370ce0a6fe4a..7d773aac5314 100644
--- a/include/linux/pm_runtime.h
+++ b/include/linux/pm_runtime.h
@@ -28,6 +28,8 @@ extern int __pm_runtime_set_status(struct device *dev, unsigned int status);
 extern int pm_runtime_barrier(struct device *dev);
 extern void pm_runtime_enable(struct device *dev);
 extern void __pm_runtime_disable(struct device *dev, bool check_resume);
+extern void pm_runtime_allow(struct device *dev);
+extern void pm_runtime_forbid(struct device *dev);
 
 static inline bool pm_children_suspended(struct device *dev)
 {
@@ -78,6 +80,8 @@ static inline int __pm_runtime_set_status(struct device *dev,
 static inline int pm_runtime_barrier(struct device *dev) { return 0; }
 static inline void pm_runtime_enable(struct device *dev) {}
 static inline void __pm_runtime_disable(struct device *dev, bool c) {}
+static inline void pm_runtime_allow(struct device *dev) {}
+static inline void pm_runtime_forbid(struct device *dev) {}
 
 static inline bool pm_children_suspended(struct device *dev) { return false; }
 static inline void pm_suspend_ignore_children(struct device *dev, bool en) {}
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index 56f2d63a5cbb..c5eab89da51e 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -27,6 +27,26 @@
 #define PTRACE_GETSIGINFO       0x4202
 #define PTRACE_SETSIGINFO       0x4203
 
+/*
+ * Generic ptrace interface that exports the architecture specific regsets
+ * using the corresponding NT_* types (which are also used in the core dump).
+ * Please note that the NT_PRSTATUS note type in a core dump contains a full
+ * 'struct elf_prstatus'. But the user_regset for NT_PRSTATUS contains just the
+ * elf_gregset_t that is the pr_reg field of 'struct elf_prstatus'. For all the
+ * other user_regset flavors, the user_regset layout and the ELF core dump note
+ * payload are exactly the same layout.
+ *
+ * This interface usage is as follows:
+ *      struct iovec iov = { buf, len};
+ *
+ *      ret = ptrace(PTRACE_GETREGSET/PTRACE_SETREGSET, pid, NT_XXX_TYPE, &iov);
+ *
+ * On the successful completion, iov.len will be updated by the kernel,
+ * specifying how much the kernel has written/read to/from the user's iov.buf.
+ */
+#define PTRACE_GETREGSET        0x4204
+#define PTRACE_SETREGSET        0x4205
+
 /* options set using PTRACE_SETOPTIONS */
 #define PTRACE_O_TRACESYSGOOD   0x00000001
 #define PTRACE_O_TRACEFORK      0x00000002
diff --git a/include/linux/raid_class.h b/include/linux/raid_class.h
index 6b537f1ac96c..31e1ff69efc8 100644
--- a/include/linux/raid_class.h
+++ b/include/linux/raid_class.h
@@ -32,6 +32,7 @@ enum raid_level {
         RAID_LEVEL_0,
         RAID_LEVEL_1,
         RAID_LEVEL_10,
+        RAID_LEVEL_1E,
         RAID_LEVEL_3,
         RAID_LEVEL_4,
         RAID_LEVEL_5,
diff --git a/include/linux/resume-trace.h b/include/linux/resume-trace.h
index c9ba2fdf807d..bc8c3881c729 100644
--- a/include/linux/resume-trace.h
+++ b/include/linux/resume-trace.h
@@ -6,6 +6,11 @@
 
 extern int pm_trace_enabled;
 
+static inline int pm_trace_is_enabled(void)
+{
+       return pm_trace_enabled;
+}
+
 struct device;
 extern void set_trace_device(struct device *);
 extern void generate_resume_trace(const void *tracedata, unsigned int user);
@@ -17,6 +22,8 @@ extern void generate_resume_trace(const void *tracedata, unsigned int user);
 
 #else
 
+static inline int pm_trace_is_enabled(void) { return 0; }
+
 #define TRACE_DEVICE(dev) do { } while (0)
 #define TRACE_RESUME(dev) do { } while (0)
 
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 78efe7c485ac..0eef87b58ea5 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -740,14 +740,6 @@ struct user_struct {
         uid_t uid;
         struct user_namespace *user_ns;
 
-#ifdef CONFIG_USER_SCHED
-        struct task_group *tg;
-#ifdef CONFIG_SYSFS
-        struct kobject kobj;
-        struct delayed_work work;
-#endif
-#endif
-
 #ifdef CONFIG_PERF_EVENTS
         atomic_long_t locked_vm;
 #endif
@@ -878,7 +870,10 @@ static inline int sd_balance_for_mc_power(void)
         if (sched_smt_power_savings)
                 return SD_POWERSAVINGS_BALANCE;
 
-        return SD_PREFER_SIBLING;
+        if (!sched_mc_power_savings)
+                return SD_PREFER_SIBLING;
+
+        return 0;
 }
 
 static inline int sd_balance_for_package_power(void)
@@ -1084,7 +1079,8 @@ struct sched_domain;
 struct sched_class {
         const struct sched_class *next;
 
-        void (*enqueue_task) (struct rq *rq, struct task_struct *p, int wakeup);
+        void (*enqueue_task) (struct rq *rq, struct task_struct *p, int wakeup,
+                              bool head);
         void (*dequeue_task) (struct rq *rq, struct task_struct *p, int sleep);
         void (*yield_task) (struct rq *rq);
 
@@ -1096,14 +1092,6 @@ struct sched_class {
 #ifdef CONFIG_SMP
         int  (*select_task_rq)(struct task_struct *p, int sd_flag, int flags);
 
-        unsigned long (*load_balance) (struct rq *this_rq, int this_cpu,
-                        struct rq *busiest, unsigned long max_load_move,
-                        struct sched_domain *sd, enum cpu_idle_type idle,
-                        int *all_pinned, int *this_best_prio);
-
-        int (*move_one_task) (struct rq *this_rq, int this_cpu,
-                              struct rq *busiest, struct sched_domain *sd,
-                              enum cpu_idle_type idle);
         void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
         void (*post_schedule) (struct rq *this_rq);
         void (*task_waking) (struct rq *this_rq, struct task_struct *task);
@@ -2517,13 +2505,9 @@ extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
 
 extern void normalize_rt_tasks(void);
 
-#ifdef CONFIG_GROUP_SCHED
+#ifdef CONFIG_CGROUP_SCHED
 
 extern struct task_group init_task_group;
-#ifdef CONFIG_USER_SCHED
-extern struct task_group root_task_group;
-extern void set_tg_uid(struct user_struct *user);
-#endif
 
 extern struct task_group *sched_create_group(struct task_group *parent);
 extern void sched_destroy_group(struct task_group *tg);
diff --git a/include/linux/sh_intc.h b/include/linux/sh_intc.h
index 4ef246f14654..51d288d8ac88 100644
--- a/include/linux/sh_intc.h
+++ b/include/linux/sh_intc.h
@@ -45,7 +45,7 @@ struct intc_sense_reg {
 #define INTC_SMP(stride, nr)
 #endif
 
-struct intc_desc {
+struct intc_hw_desc {
         struct intc_vect *vectors;
         unsigned int nr_vectors;
         struct intc_group *groups;
@@ -56,29 +56,40 @@ struct intc_desc {
         unsigned int nr_prio_regs;
         struct intc_sense_reg *sense_regs;
         unsigned int nr_sense_regs;
-        char *name;
         struct intc_mask_reg *ack_regs;
         unsigned int nr_ack_regs;
 };
 
 #define _INTC_ARRAY(a) a, sizeof(a)/sizeof(*a)
+#define INTC_HW_DESC(vectors, groups, mask_regs,        \
+                     prio_regs, sense_regs, ack_regs)   \
+{                                                       \
+        _INTC_ARRAY(vectors), _INTC_ARRAY(groups),      \
+        _INTC_ARRAY(mask_regs), _INTC_ARRAY(prio_regs), \
+        _INTC_ARRAY(sense_regs), _INTC_ARRAY(ack_regs), \
+}
+
+struct intc_desc {
+        char *name;
+        intc_enum force_enable;
+        intc_enum force_disable;
+        struct intc_hw_desc hw;
+};
+
 #define DECLARE_INTC_DESC(symbol, chipname, vectors, groups,            \
         mask_regs, prio_regs, sense_regs)                               \
 struct intc_desc symbol __initdata = {                                  \
-        _INTC_ARRAY(vectors), _INTC_ARRAY(groups),                      \
-        _INTC_ARRAY(mask_regs), _INTC_ARRAY(prio_regs),                 \
-        _INTC_ARRAY(sense_regs),                                        \
-        chipname,                                                       \
+        .name = chipname,                                               \
+        .hw = INTC_HW_DESC(vectors, groups, mask_regs,                  \
+                           prio_regs, sense_regs, NULL),                \
 }
 
 #define DECLARE_INTC_DESC_ACK(symbol, chipname, vectors, groups,        \
         mask_regs, prio_regs, sense_regs, ack_regs)                     \
 struct intc_desc symbol __initdata = {                                  \
-        _INTC_ARRAY(vectors), _INTC_ARRAY(groups),                      \
-        _INTC_ARRAY(mask_regs), _INTC_ARRAY(prio_regs),                 \
-        _INTC_ARRAY(sense_regs),                                        \
-        chipname,                                                       \
-        _INTC_ARRAY(ack_regs),                                          \
+        .name = chipname,                                               \
+        .hw = INTC_HW_DESC(vectors, groups, mask_regs,                  \
+                           prio_regs, sense_regs, ack_regs),            \
 }
 
 void __init register_intc_controller(struct intc_desc *desc);
diff --git a/include/linux/spi/dw_spi.h b/include/linux/spi/dw_spi.h
index 51b3e771a9a3..cc813f95a2f2 100644
--- a/include/linux/spi/dw_spi.h
+++ b/include/linux/spi/dw_spi.h
@@ -90,6 +90,7 @@ struct dw_spi {
         unsigned long           paddr;
         u32                     iolen;
         int                     irq;
+        u32                     fifo_len;       /* depth of the FIFO buffer */
         u32                     max_freq;       /* max bus freq supported */
 
         u16                     bus_num;
@@ -171,6 +172,10 @@ static inline void spi_chip_sel(struct dw_spi *dws, u16 cs)
 {
         if (cs > dws->num_cs)
                 return;
+
+        if (dws->cs_control)
+                dws->cs_control(1);
+
         dw_writel(dws, ser, 1 << cs);
 }
 
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 207466a49f3d..8126f239edf0 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -99,7 +99,7 @@ struct perf_event_attr;
 #define __SC_TEST5(t5, a5, ...) __SC_TEST(t5); __SC_TEST4(__VA_ARGS__)
 #define __SC_TEST6(t6, a6, ...) __SC_TEST(t6); __SC_TEST5(__VA_ARGS__)
 
-#ifdef CONFIG_EVENT_PROFILE
+#ifdef CONFIG_PERF_EVENTS
 
 #define TRACE_SYS_ENTER_PROFILE_INIT(sname)                                    \
         .profile_enable = prof_sysenter_enable,                                \
@@ -113,7 +113,7 @@ struct perf_event_attr;
 #define TRACE_SYS_ENTER_PROFILE_INIT(sname)
 #define TRACE_SYS_EXIT_PROFILE(sname)
 #define TRACE_SYS_EXIT_PROFILE_INIT(sname)
-#endif
+#endif /* CONFIG_PERF_EVENTS */
 
 #ifdef CONFIG_FTRACE_SYSCALLS
 #define __SC_STR_ADECL1(t, a)           #a
@@ -132,7 +132,8 @@ struct perf_event_attr;
 
 #define SYSCALL_TRACE_ENTER_EVENT(sname)                                \
         static const struct syscall_metadata __syscall_meta_##sname;    \
-        static struct ftrace_event_call event_enter_##sname;            \
+        static struct ftrace_event_call                                 \
+        __attribute__((__aligned__(4))) event_enter_##sname;            \
         static struct trace_event enter_syscall_print_##sname = {       \
                 .trace                  = print_syscall_enter,          \
         };                                                              \
@@ -143,8 +144,7 @@ struct perf_event_attr;
                 .name                   = "sys_enter"#sname,            \
                 .system                 = "syscalls",                   \
                 .event                  = &enter_syscall_print_##sname, \
-                .raw_init               = trace_event_raw_init,         \
-                .show_format            = syscall_enter_format,         \
+                .raw_init               = init_syscall_trace,           \
                 .define_fields          = syscall_enter_define_fields,  \
                 .regfunc                = reg_event_syscall_enter,      \
                 .unregfunc              = unreg_event_syscall_enter,    \
@@ -154,7 +154,8 @@ struct perf_event_attr;
 
 #define SYSCALL_TRACE_EXIT_EVENT(sname)                                 \
         static const struct syscall_metadata __syscall_meta_##sname;    \
-        static struct ftrace_event_call event_exit_##sname;             \
+        static struct ftrace_event_call                                 \
+        __attribute__((__aligned__(4))) event_exit_##sname;             \
         static struct trace_event exit_syscall_print_##sname = {        \
                 .trace                  = print_syscall_exit,           \
         };                                                              \
@@ -165,8 +166,7 @@ struct perf_event_attr;
                 .name                   = "sys_exit"#sname,             \
                 .system                 = "syscalls",                   \
                 .event                  = &exit_syscall_print_##sname,  \
-                .raw_init               = trace_event_raw_init,         \
-                .show_format            = syscall_exit_format,          \
+                .raw_init               = init_syscall_trace,           \
                 .define_fields          = syscall_exit_define_fields,   \
                 .regfunc                = reg_event_syscall_exit,       \
                 .unregfunc              = unreg_event_syscall_exit,     \
diff --git a/include/linux/usb.h b/include/linux/usb.h
index d7ace1b80f09..332eaea61021 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -339,6 +339,7 @@ struct usb_bus {
 
         struct usb_devmap devmap;       /* device address allocation map */
         struct usb_device *root_hub;    /* Root hub */
+        struct usb_bus *hs_companion;   /* Companion EHCI bus, if any */
         struct list_head bus_list;      /* list of busses */
 
         int bandwidth_allocated;        /* on this bus: how much of the time
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index d4962a782b8a..3793d168b44d 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -350,6 +350,7 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_MPEG     v4l2_fourcc('M', 'P', 'E', 'G') /* MPEG-1/2/4    */
 
 /*  Vendor-specific formats   */
+#define V4L2_PIX_FMT_CPIA1    v4l2_fourcc('C', 'P', 'I', 'A') /* cpia1 YUV */
 #define V4L2_PIX_FMT_WNVA     v4l2_fourcc('W', 'N', 'V', 'A') /* Winnov hw compress */
 #define V4L2_PIX_FMT_SN9C10X  v4l2_fourcc('S', '9', '1', '0') /* SN9C10x compression */
 #define V4L2_PIX_FMT_SN9C20X_I420 v4l2_fourcc('S', '9', '2', '0') /* SN9C20x YUV 4:2:0 */
@@ -362,6 +363,7 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_SPCA561  v4l2_fourcc('S', '5', '6', '1') /* compressed GBRG bayer */
 #define V4L2_PIX_FMT_PAC207   v4l2_fourcc('P', '2', '0', '7') /* compressed BGGR bayer */
 #define V4L2_PIX_FMT_MR97310A v4l2_fourcc('M', '3', '1', '0') /* compressed BGGR bayer */
+#define V4L2_PIX_FMT_SN9C2028 v4l2_fourcc('S', 'O', 'N', 'X') /* compressed GBRG bayer */
 #define V4L2_PIX_FMT_SQ905C   v4l2_fourcc('9', '0', '5', 'C') /* compressed RGGB bayer */
 #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 */
diff --git a/include/linux/virtio.h b/include/linux/virtio.h
index 057a2e010758..f508c651e53d 100644
--- a/include/linux/virtio.h
+++ b/include/linux/virtio.h
@@ -51,6 +51,9 @@ struct virtqueue {
  *      This re-enables callbacks; it returns "false" if there are pending
  *      buffers in the queue, to detect a possible race between the driver
  *      checking for more work, and enabling callbacks.
+ * @detach_unused_buf: detach first unused buffer
+ *      vq: the struct virtqueue we're talking about.
+ *      Returns NULL or the "data" token handed to add_buf
  *
  * Locking rules are straightforward: the driver is responsible for
  * locking.  No two operations may be invoked simultaneously, with the exception
@@ -71,6 +74,7 @@ struct virtqueue_ops {
 
         void (*disable_cb)(struct virtqueue *vq);
         bool (*enable_cb)(struct virtqueue *vq);
+        void *(*detach_unused_buf)(struct virtqueue *vq);
 };
 
 /**
diff --git a/include/linux/virtio_balloon.h b/include/linux/virtio_balloon.h
index 1418f048cb34..a50ecd1b81a2 100644
--- a/include/linux/virtio_balloon.h
+++ b/include/linux/virtio_balloon.h
@@ -7,6 +7,7 @@
 
 /* The feature bitmap for virtio balloon */
 #define VIRTIO_BALLOON_F_MUST_TELL_HOST 0 /* Tell before reclaiming pages */
+#define VIRTIO_BALLOON_F_STATS_VQ       1 /* Memory Stats virtqueue */
 
 /* Size of a PFN in the balloon interface. */
 #define VIRTIO_BALLOON_PFN_SHIFT 12
@@ -18,4 +19,18 @@ struct virtio_balloon_config
         /* Number of pages we've actually got in balloon. */
         __le32 actual;
 };
+
+#define VIRTIO_BALLOON_S_SWAP_IN  0   /* Amount of memory swapped in */
+#define VIRTIO_BALLOON_S_SWAP_OUT 1   /* Amount of memory swapped out */
+#define VIRTIO_BALLOON_S_MAJFLT   2   /* Number of major faults */
+#define VIRTIO_BALLOON_S_MINFLT   3   /* Number of minor faults */
+#define VIRTIO_BALLOON_S_MEMFREE  4   /* Total amount of free memory */
+#define VIRTIO_BALLOON_S_MEMTOT   5   /* Total amount of memory */
+#define VIRTIO_BALLOON_S_NR       6
+
+struct virtio_balloon_stat {
+        u16 tag;
+        u64 val;
+} __attribute__((packed));
+
 #endif /* _LINUX_VIRTIO_BALLOON_H */
diff --git a/include/linux/virtio_blk.h b/include/linux/virtio_blk.h
index fd294c56d571..e52029e98919 100644
--- a/include/linux/virtio_blk.h
+++ b/include/linux/virtio_blk.h
@@ -15,6 +15,7 @@
 #define VIRTIO_BLK_F_BLK_SIZE   6       /* Block size of disk is available*/
 #define VIRTIO_BLK_F_SCSI       7       /* Supports scsi command passthru */
 #define VIRTIO_BLK_F_FLUSH      9       /* Cache flush command support */
+#define VIRTIO_BLK_F_TOPOLOGY   10      /* Topology information is available */
 
 struct virtio_blk_config {
         /* The capacity (in 512-byte sectors). */
@@ -29,8 +30,20 @@ struct virtio_blk_config {
                 __u8 heads;
                 __u8 sectors;
         } geometry;
+
         /* block size of device (if VIRTIO_BLK_F_BLK_SIZE) */
         __u32 blk_size;
+
+        /* the next 4 entries are guarded by VIRTIO_BLK_F_TOPOLOGY  */
+        /* exponent for physical block per logical block. */
+        __u8 physical_block_exp;
+        /* alignment offset in logical blocks. */
+        __u8 alignment_offset;
+        /* minimum I/O size without performance penalty in logical blocks. */
+        __u16 min_io_size;
+        /* optimal sustained I/O size in logical blocks. */
+        __u32 opt_io_size;
+
 } __attribute__((packed));
 
 /*
diff --git a/include/linux/virtio_console.h b/include/linux/virtio_console.h
index fe885174cc1f..ae4f039515b4 100644
--- a/include/linux/virtio_console.h
+++ b/include/linux/virtio_console.h
@@ -3,19 +3,45 @@
 #include <linux/types.h>
 #include <linux/virtio_ids.h>
 #include <linux/virtio_config.h>
-/* This header, excluding the #ifdef __KERNEL__ part, is BSD licensed so
- * anyone can use the definitions to implement compatible drivers/servers. */
+/*
+ * This header, excluding the #ifdef __KERNEL__ part, is BSD licensed so
+ * anyone can use the definitions to implement compatible drivers/servers.
+ *
+ * Copyright (C) Red Hat, Inc., 2009, 2010
+ */
 
 /* Feature bits */
 #define VIRTIO_CONSOLE_F_SIZE   0       /* Does host provide console size? */
+#define VIRTIO_CONSOLE_F_MULTIPORT 1    /* Does host provide multiple ports? */
 
 struct virtio_console_config {
         /* colums of the screens */
         __u16 cols;
         /* rows of the screens */
         __u16 rows;
+        /* max. number of ports this device can hold */
+        __u32 max_nr_ports;
+        /* number of ports added so far */
+        __u32 nr_ports;
 } __attribute__((packed));
 
+/*
+ * A message that's passed between the Host and the Guest for a
+ * particular port.
+ */
+struct virtio_console_control {
+        __u32 id;               /* Port number */
+        __u16 event;            /* The kind of control event (see below) */
+        __u16 value;            /* Extra information for the key */
+};
+
+/* Some events for control messages */
+#define VIRTIO_CONSOLE_PORT_READY       0
+#define VIRTIO_CONSOLE_CONSOLE_PORT     1
+#define VIRTIO_CONSOLE_RESIZE           2
+#define VIRTIO_CONSOLE_PORT_OPEN        3
+#define VIRTIO_CONSOLE_PORT_NAME        4
+#define VIRTIO_CONSOLE_PORT_REMOVE      5
 
 #ifdef __KERNEL__
 int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int));
diff --git a/include/media/davinci/isif.h b/include/media/davinci/isif.h
new file mode 100644
index 000000000000..b0b74ad618cc
--- /dev/null
+++ b/include/media/davinci/isif.h
@@ -0,0 +1,531 @@
+/*
+ * Copyright (C) 2008-2009 Texas Instruments Inc
+ *
+ * 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
+ *
+ * isif header file
+ */
+#ifndef _ISIF_H
+#define _ISIF_H
+
+#include <media/davinci/ccdc_types.h>
+#include <media/davinci/vpfe_types.h>
+
+/* isif float type S8Q8/U8Q8 */
+struct isif_float_8 {
+        /* 8 bit integer part */
+        __u8 integer;
+        /* 8 bit decimal part */
+        __u8 decimal;
+};
+
+/* isif float type U16Q16/S16Q16 */
+struct isif_float_16 {
+        /* 16 bit integer part */
+        __u16 integer;
+        /* 16 bit decimal part */
+        __u16 decimal;
+};
+
+/************************************************************************
+ *   Vertical Defect Correction parameters
+ ***********************************************************************/
+/* Defect Correction (DFC) table entry */
+struct isif_vdfc_entry {
+        /* vertical position of defect */
+        __u16 pos_vert;
+        /* horizontal position of defect */
+        __u16 pos_horz;
+        /*
+         * Defect level of Vertical line defect position. This is subtracted
+         * from the data at the defect position
+         */
+        __u8 level_at_pos;
+        /*
+         * Defect level of the pixels upper than the vertical line defect.
+         * This is subtracted from the data
+         */
+        __u8 level_up_pixels;
+        /*
+         * Defect level of the pixels lower than the vertical line defect.
+         * This is subtracted from the data
+         */
+        __u8 level_low_pixels;
+};
+
+#define ISIF_VDFC_TABLE_SIZE            8
+struct isif_dfc {
+        /* enable vertical defect correction */
+        __u8 en;
+        /* Defect level subtraction. Just fed through if saturating */
+#define ISIF_VDFC_NORMAL                0
+        /*
+         * Defect level subtraction. Horizontal interpolation ((i-2)+(i+2))/2
+         * if data saturating
+         */
+#define ISIF_VDFC_HORZ_INTERPOL_IF_SAT  1
+        /* Horizontal interpolation (((i-2)+(i+2))/2) */
+#define ISIF_VDFC_HORZ_INTERPOL         2
+        /* one of the vertical defect correction modes above */
+        __u8 corr_mode;
+        /* 0 - whole line corrected, 1 - not pixels upper than the defect */
+        __u8 corr_whole_line;
+#define ISIF_VDFC_NO_SHIFT              0
+#define ISIF_VDFC_SHIFT_1               1
+#define ISIF_VDFC_SHIFT_2               2
+#define ISIF_VDFC_SHIFT_3               3
+#define ISIF_VDFC_SHIFT_4               4
+        /*
+         * defect level shift value. level_at_pos, level_upper_pos,
+         * and level_lower_pos can be shifted up by this value. Choose
+         * one of the values above
+         */
+        __u8 def_level_shift;
+        /* defect saturation level */
+        __u16 def_sat_level;
+        /* number of vertical defects. Max is ISIF_VDFC_TABLE_SIZE */
+        __u16 num_vdefects;
+        /* VDFC table ptr */
+        struct isif_vdfc_entry table[ISIF_VDFC_TABLE_SIZE];
+};
+
+struct isif_horz_bclamp {
+
+        /* Horizontal clamp disabled. Only vertical clamp value is subtracted */
+#define ISIF_HORZ_BC_DISABLE            0
+        /*
+         * Horizontal clamp value is calculated and subtracted from image data
+         * along with vertical clamp value
+         */
+#define ISIF_HORZ_BC_CLAMP_CALC_ENABLED 1
+        /*
+         * Horizontal clamp value calculated from previous image is subtracted
+         * from image data along with vertical clamp value.
+         */
+#define ISIF_HORZ_BC_CLAMP_NOT_UPDATED  2
+        /* horizontal clamp mode. One of the values above */
+        __u8 mode;
+        /*
+         * pixel value limit enable.
+         *  0 - limit disabled
+         *  1 - pixel value limited to 1023
+         */
+        __u8 clamp_pix_limit;
+        /* Select Most left window for bc calculation */
+#define ISIF_SEL_MOST_LEFT_WIN          0
+        /* Select Most right window for bc calculation */
+#define ISIF_SEL_MOST_RIGHT_WIN         1
+        /* Select most left or right window for clamp val calculation */
+        __u8 base_win_sel_calc;
+        /* Window count per color for calculation. range 1-32 */
+        __u8 win_count_calc;
+        /* Window start position - horizontal for calculation. 0 - 8191 */
+        __u16 win_start_h_calc;
+        /* Window start position - vertical for calculation 0 - 8191 */
+        __u16 win_start_v_calc;
+#define ISIF_HORZ_BC_SZ_H_2PIXELS       0
+#define ISIF_HORZ_BC_SZ_H_4PIXELS       1
+#define ISIF_HORZ_BC_SZ_H_8PIXELS       2
+#define ISIF_HORZ_BC_SZ_H_16PIXELS      3
+        /* Width of the sample window in pixels for calculation */
+        __u8 win_h_sz_calc;
+#define ISIF_HORZ_BC_SZ_V_32PIXELS      0
+#define ISIF_HORZ_BC_SZ_V_64PIXELS      1
+#define ISIF_HORZ_BC_SZ_V_128PIXELS     2
+#define ISIF_HORZ_BC_SZ_V_256PIXELS     3
+        /* Height of the sample window in pixels for calculation */
+        __u8 win_v_sz_calc;
+};
+
+/************************************************************************
+ *  Black Clamp parameters
+ ***********************************************************************/
+struct isif_vert_bclamp {
+        /* Reset value used is the clamp value calculated */
+#define ISIF_VERT_BC_USE_HORZ_CLAMP_VAL         0
+        /* Reset value used is reset_clamp_val configured */
+#define ISIF_VERT_BC_USE_CONFIG_CLAMP_VAL       1
+        /* No update, previous image value is used */
+#define ISIF_VERT_BC_NO_UPDATE                  2
+        /*
+         * Reset value selector for vertical clamp calculation. Use one of
+         * the above values
+         */
+        __u8 reset_val_sel;
+        /* U8Q8. Line average coefficient used in vertical clamp calculation */
+        __u8 line_ave_coef;
+        /* Height of the optical black region for calculation */
+        __u16 ob_v_sz_calc;
+        /* Optical black region start position - horizontal. 0 - 8191 */
+        __u16 ob_start_h;
+        /* Optical black region start position - vertical 0 - 8191 */
+        __u16 ob_start_v;
+};
+
+struct isif_black_clamp {
+        /*
+         * This offset value is added irrespective of the clamp enable status.
+         * S13
+         */
+        __u16 dc_offset;
+        /*
+         * Enable black/digital clamp value to be subtracted from the image data
+         */
+        __u8 en;
+        /*
+         * black clamp mode. same/separate clamp for 4 colors
+         * 0 - disable - same clamp value for all colors
+         * 1 - clamp value calculated separately for all colors
+         */
+        __u8 bc_mode_color;
+        /* Vrtical start position for bc subtraction */
+        __u16 vert_start_sub;
+        /* Black clamp for horizontal direction */
+        struct isif_horz_bclamp horz;
+        /* Black clamp for vertical direction */
+        struct isif_vert_bclamp vert;
+};
+
+/*************************************************************************
+** Color Space Convertion (CSC)
+*************************************************************************/
+#define ISIF_CSC_NUM_COEFF      16
+struct isif_color_space_conv {
+        /* Enable color space conversion */
+        __u8 en;
+        /*
+         * csc coeffient table. S8Q5, M00 at index 0, M01 at index 1, and
+         * so forth
+         */
+        struct isif_float_8 coeff[ISIF_CSC_NUM_COEFF];
+};
+
+
+/*************************************************************************
+**  Black  Compensation parameters
+*************************************************************************/
+struct isif_black_comp {
+        /* Comp for Red */
+        __s8 r_comp;
+        /* Comp for Gr */
+        __s8 gr_comp;
+        /* Comp for Blue */
+        __s8 b_comp;
+        /* Comp for Gb */
+        __s8 gb_comp;
+};
+
+/*************************************************************************
+**  Gain parameters
+*************************************************************************/
+struct isif_gain {
+        /* Gain for Red or ye */
+        struct isif_float_16 r_ye;
+        /* Gain for Gr or cy */
+        struct isif_float_16 gr_cy;
+        /* Gain for Gb or g */
+        struct isif_float_16 gb_g;
+        /* Gain for Blue or mg */
+        struct isif_float_16 b_mg;
+};
+
+#define ISIF_LINEAR_TAB_SIZE    192
+/*************************************************************************
+**  Linearization parameters
+*************************************************************************/
+struct isif_linearize {
+        /* Enable or Disable linearization of data */
+        __u8 en;
+        /* Shift value applied */
+        __u8 corr_shft;
+        /* scale factor applied U11Q10 */
+        struct isif_float_16 scale_fact;
+        /* Size of the linear table */
+        __u16 table[ISIF_LINEAR_TAB_SIZE];
+};
+
+/* Color patterns */
+#define ISIF_RED        0
+#define ISIF_GREEN_RED  1
+#define ISIF_GREEN_BLUE 2
+#define ISIF_BLUE       3
+struct isif_col_pat {
+        __u8 olop;
+        __u8 olep;
+        __u8 elop;
+        __u8 elep;
+};
+
+/*************************************************************************
+**  Data formatter parameters
+*************************************************************************/
+struct isif_fmtplen {
+        /*
+         * number of program entries for SET0, range 1 - 16
+         * when fmtmode is ISIF_SPLIT, 1 - 8 when fmtmode is
+         * ISIF_COMBINE
+         */
+        __u16 plen0;
+        /*
+         * number of program entries for SET1, range 1 - 16
+         * when fmtmode is ISIF_SPLIT, 1 - 8 when fmtmode is
+         * ISIF_COMBINE
+         */
+        __u16 plen1;
+        /**
+         * number of program entries for SET2, range 1 - 16
+         * when fmtmode is ISIF_SPLIT, 1 - 8 when fmtmode is
+         * ISIF_COMBINE
+         */
+        __u16 plen2;
+        /**
+         * number of program entries for SET3, range 1 - 16
+         * when fmtmode is ISIF_SPLIT, 1 - 8 when fmtmode is
+         * ISIF_COMBINE
+         */
+        __u16 plen3;
+};
+
+struct isif_fmt_cfg {
+#define ISIF_SPLIT              0
+#define ISIF_COMBINE            1
+        /* Split or combine or line alternate */
+        __u8 fmtmode;
+        /* enable or disable line alternating mode */
+        __u8 ln_alter_en;
+#define ISIF_1LINE              0
+#define ISIF_2LINES             1
+#define ISIF_3LINES             2
+#define ISIF_4LINES             3
+        /* Split/combine line number */
+        __u8 lnum;
+        /* Address increment Range 1 - 16 */
+        __u8 addrinc;
+};
+
+struct isif_fmt_addr_ptr {
+        /* Initial address */
+        __u32 init_addr;
+        /* output line number */
+#define ISIF_1STLINE            0
+#define ISIF_2NDLINE            1
+#define ISIF_3RDLINE            2
+#define ISIF_4THLINE            3
+        __u8 out_line;
+};
+
+struct isif_fmtpgm_ap {
+        /* program address pointer */
+        __u8 pgm_aptr;
+        /* program address increment or decrement */
+        __u8 pgmupdt;
+};
+
+struct isif_data_formatter {
+        /* Enable/Disable data formatter */
+        __u8 en;
+        /* data formatter configuration */
+        struct isif_fmt_cfg cfg;
+        /* Formatter program entries length */
+        struct isif_fmtplen plen;
+        /* first pixel in a line fed to formatter */
+        __u16 fmtrlen;
+        /* HD interval for output line. Only valid when split line */
+        __u16 fmthcnt;
+        /* formatter address pointers */
+        struct isif_fmt_addr_ptr fmtaddr_ptr[16];
+        /* program enable/disable */
+        __u8 pgm_en[32];
+        /* program address pointers */
+        struct isif_fmtpgm_ap fmtpgm_ap[32];
+};
+
+struct isif_df_csc {
+        /* Color Space Conversion confguration, 0 - csc, 1 - df */
+        __u8 df_or_csc;
+        /* csc configuration valid if df_or_csc is 0 */
+        struct isif_color_space_conv csc;
+        /* data formatter configuration valid if df_or_csc is 1 */
+        struct isif_data_formatter df;
+        /* start pixel in a line at the input */
+        __u32 start_pix;
+        /* number of pixels in input line */
+        __u32 num_pixels;
+        /* start line at the input */
+        __u32 start_line;
+        /* number of lines at the input */
+        __u32 num_lines;
+};
+
+struct isif_gain_offsets_adj {
+        /* Gain adjustment per color */
+        struct isif_gain gain;
+        /* Offset adjustment */
+        __u16 offset;
+        /* Enable or Disable Gain adjustment for SDRAM data */
+        __u8 gain_sdram_en;
+        /* Enable or Disable Gain adjustment for IPIPE data */
+        __u8 gain_ipipe_en;
+        /* Enable or Disable Gain adjustment for H3A data */
+        __u8 gain_h3a_en;
+        /* Enable or Disable Gain adjustment for SDRAM data */
+        __u8 offset_sdram_en;
+        /* Enable or Disable Gain adjustment for IPIPE data */
+        __u8 offset_ipipe_en;
+        /* Enable or Disable Gain adjustment for H3A data */
+        __u8 offset_h3a_en;
+};
+
+struct isif_cul {
+        /* Horizontal Cull pattern for odd lines */
+        __u8 hcpat_odd;
+        /* Horizontal Cull pattern for even lines */
+        __u8 hcpat_even;
+        /* Vertical Cull pattern */
+        __u8 vcpat;
+        /* Enable or disable lpf. Apply when cull is enabled */
+        __u8 en_lpf;
+};
+
+struct isif_compress {
+#define ISIF_ALAW               0
+#define ISIF_DPCM               1
+#define ISIF_NO_COMPRESSION     2
+        /* Compression Algorithm used */
+        __u8 alg;
+        /* Choose Predictor1 for DPCM compression */
+#define ISIF_DPCM_PRED1         0
+        /* Choose Predictor2 for DPCM compression */
+#define ISIF_DPCM_PRED2         1
+        /* Predictor for DPCM compression */
+        __u8 pred;
+};
+
+/* all the stuff in this struct will be provided by userland */
+struct isif_config_params_raw {
+        /* Linearization parameters for image sensor data input */
+        struct isif_linearize linearize;
+        /* Data formatter or CSC */
+        struct isif_df_csc df_csc;
+        /* Defect Pixel Correction (DFC) confguration */
+        struct isif_dfc dfc;
+        /* Black/Digital Clamp configuration */
+        struct isif_black_clamp bclamp;
+        /* Gain, offset adjustments */
+        struct isif_gain_offsets_adj gain_offset;
+        /* Culling */
+        struct isif_cul culling;
+        /* A-Law and DPCM compression options */
+        struct isif_compress compress;
+        /* horizontal offset for Gain/LSC/DFC */
+        __u16 horz_offset;
+        /* vertical offset for Gain/LSC/DFC */
+        __u16 vert_offset;
+        /* color pattern for field 0 */
+        struct isif_col_pat col_pat_field0;
+        /* color pattern for field 1 */
+        struct isif_col_pat col_pat_field1;
+#define ISIF_NO_SHIFT           0
+#define ISIF_1BIT_SHIFT         1
+#define ISIF_2BIT_SHIFT         2
+#define ISIF_3BIT_SHIFT         3
+#define ISIF_4BIT_SHIFT         4
+#define ISIF_5BIT_SHIFT         5
+#define ISIF_6BIT_SHIFT         6
+        /* Data shift applied before storing to SDRAM */
+        __u8 data_shift;
+        /* enable input test pattern generation */
+        __u8 test_pat_gen;
+};
+
+#ifdef __KERNEL__
+struct isif_ycbcr_config {
+        /* isif pixel format */
+        enum ccdc_pixfmt pix_fmt;
+        /* isif frame format */
+        enum ccdc_frmfmt frm_fmt;
+        /* ISIF crop window */
+        struct v4l2_rect win;
+        /* field polarity */
+        enum vpfe_pin_pol fid_pol;
+        /* interface VD polarity */
+        enum vpfe_pin_pol vd_pol;
+        /* interface HD polarity */
+        enum vpfe_pin_pol hd_pol;
+        /* isif pix order. Only used for ycbcr capture */
+        enum ccdc_pixorder pix_order;
+        /* isif buffer type. Only used for ycbcr capture */
+        enum ccdc_buftype buf_type;
+};
+
+/* MSB of image data connected to sensor port */
+enum isif_data_msb {
+        ISIF_BIT_MSB_15,
+        ISIF_BIT_MSB_14,
+        ISIF_BIT_MSB_13,
+        ISIF_BIT_MSB_12,
+        ISIF_BIT_MSB_11,
+        ISIF_BIT_MSB_10,
+        ISIF_BIT_MSB_9,
+        ISIF_BIT_MSB_8,
+        ISIF_BIT_MSB_7
+};
+
+enum isif_cfa_pattern {
+        ISIF_CFA_PAT_MOSAIC,
+        ISIF_CFA_PAT_STRIPE
+};
+
+struct isif_params_raw {
+        /* isif pixel format */
+        enum ccdc_pixfmt pix_fmt;
+        /* isif frame format */
+        enum ccdc_frmfmt frm_fmt;
+        /* video window */
+        struct v4l2_rect win;
+        /* field polarity */
+        enum vpfe_pin_pol fid_pol;
+        /* interface VD polarity */
+        enum vpfe_pin_pol vd_pol;
+        /* interface HD polarity */
+        enum vpfe_pin_pol hd_pol;
+        /* buffer type. Applicable for interlaced mode */
+        enum ccdc_buftype buf_type;
+        /* Gain values */
+        struct isif_gain gain;
+        /* cfa pattern */
+        enum isif_cfa_pattern cfa_pat;
+        /* Data MSB position */
+        enum isif_data_msb data_msb;
+        /* Enable horizontal flip */
+        unsigned char horz_flip_en;
+        /* Enable image invert vertically */
+        unsigned char image_invert_en;
+
+        /* all the userland defined stuff*/
+        struct isif_config_params_raw config_params;
+};
+
+enum isif_data_pack {
+        ISIF_PACK_16BIT,
+        ISIF_PACK_12BIT,
+        ISIF_PACK_8BIT
+};
+
+#define ISIF_WIN_NTSC                           {0, 0, 720, 480}
+#define ISIF_WIN_VGA                            {0, 0, 640, 480}
+
+#endif
+#endif
diff --git a/include/media/davinci/vpss.h b/include/media/davinci/vpss.h
index fcdff745fae2..c59cc029c74a 100644
--- a/include/media/davinci/vpss.h
+++ b/include/media/davinci/vpss.h
@@ -29,7 +29,19 @@
 /* selector for ccdc input selection on DM355 */
 enum vpss_ccdc_source_sel {
         VPSS_CCDCIN,
-        VPSS_HSSIIN
+        VPSS_HSSIIN,
+        VPSS_PGLPBK,    /* for DM365 only */
+        VPSS_CCDCPG     /* for DM365 only */
+};
+
+struct vpss_sync_pol {
+        unsigned int ccdpg_hdpol:1;
+        unsigned int ccdpg_vdpol:1;
+};
+
+struct vpss_pg_frame_size {
+        short hlpfr;
+        short pplen;
 };
 
 /* Used for enable/diable VPSS Clock */
@@ -47,12 +59,38 @@ enum vpss_clock_sel {
          */
         VPSS_VENC_CLOCK_SEL,
         VPSS_VPBE_CLOCK,
+        /* DM365 only clocks */
+        VPSS_IPIPEIF_CLOCK,
+        VPSS_RSZ_CLOCK,
+        VPSS_BL_CLOCK,
+        /*
+         * When using VPSS_PCLK_INTERNAL in vpss_enable_clock() api
+         * following applies:-
+         * en = 0 disable internal PCLK
+         * en = 1 enables internal PCLK
+         */
+        VPSS_PCLK_INTERNAL,
+        /*
+         * When using VPSS_PSYNC_CLOCK_SEL in vpss_enable_clock() api
+         * following applies:-
+         * en = 0 enables MMR clock
+         * en = 1 enables VPSS clock
+         */
+        VPSS_PSYNC_CLOCK_SEL,
+        VPSS_LDC_CLOCK_SEL,
+        VPSS_OSD_CLOCK_SEL,
+        VPSS_FDIF_CLOCK,
+        VPSS_LDC_CLOCK
 };
 
 /* select input to ccdc on dm355 */
 int vpss_select_ccdc_source(enum vpss_ccdc_source_sel src_sel);
 /* enable/disable a vpss clock, 0 - success, -1 - failure */
 int vpss_enable_clock(enum vpss_clock_sel clock_sel, int en);
+/* set sync polarity, only for DM365*/
+void dm365_vpss_set_sync_pol(struct vpss_sync_pol);
+/* set the PG_FRAME_SIZE register, only for DM365 */
+void dm365_vpss_set_pg_frame_size(struct vpss_pg_frame_size);
 
 /* wbl reset for dm644x */
 enum vpss_wbl_sel {
@@ -65,5 +103,6 @@ enum vpss_wbl_sel {
         VPSS_PCR_PREV_WBL_0,
         VPSS_PCR_CCDC_WBL_O,
 };
+/* clear wbl overflow flag for DM6446 */
 int vpss_clear_wbl_overflow(enum vpss_wbl_sel wbl_sel);
 #endif
diff --git a/include/media/ir-common.h b/include/media/ir-common.h
index 2c6af24b905e..c66298062d39 100644
--- a/include/media/ir-common.h
+++ b/include/media/ir-common.h
@@ -35,7 +35,7 @@
 
 struct ir_input_state {
         /* configuration */
-        int                ir_type;
+        u64      ir_type;
 
         /* key info */
         u32                ir_key;      /* ir scancode */
@@ -84,7 +84,7 @@ struct card_ir {
 /* Routines from ir-functions.c */
 
 int ir_input_init(struct input_dev *dev, struct ir_input_state *ir,
-                   int ir_type);
+                   const u64 ir_type);
 void ir_input_nokey(struct input_dev *dev, struct ir_input_state *ir);
 void ir_input_keydown(struct input_dev *dev, struct ir_input_state *ir,
                       u32 ir_key);
@@ -162,4 +162,6 @@ extern struct ir_scancode_table ir_codes_terratec_cinergy_xs_table;
 extern struct ir_scancode_table ir_codes_videomate_s350_table;
 extern struct ir_scancode_table ir_codes_gadmei_rm008z_table;
 extern struct ir_scancode_table ir_codes_nec_terratec_cinergy_xs_table;
+extern struct ir_scancode_table ir_codes_winfast_usbii_deluxe_table;
+extern struct ir_scancode_table ir_codes_kworld_315u_table;
 #endif
diff --git a/include/media/ir-core.h b/include/media/ir-core.h
index 299d201e1339..61c223bc3953 100644
--- a/include/media/ir-core.h
+++ b/include/media/ir-core.h
@@ -21,13 +21,11 @@ extern int ir_core_debug;
 #define IR_dprintk(level, fmt, arg...)  if (ir_core_debug >= level) \
         printk(KERN_DEBUG "%s: " fmt , __func__, ## arg)
 
-enum ir_type {
-        IR_TYPE_UNKNOWN = 0,
-        IR_TYPE_RC5     = 1,
-        IR_TYPE_PD      = 2,             /* Pulse distance encoded IR */
-        IR_TYPE_NEC     = 3,
-        IR_TYPE_OTHER   = 99,
-};
+#define IR_TYPE_UNKNOWN 0
+#define IR_TYPE_RC5     (1  << 0)       /* Philips RC5 protocol */
+#define IR_TYPE_PD      (1  << 1)       /* Pulse distance encoded IR */
+#define IR_TYPE_NEC     (1  << 2)
+#define IR_TYPE_OTHER   (((u64)1) << 63l)
 
 struct ir_scancode {
         u16     scancode;
@@ -37,26 +35,40 @@ struct ir_scancode {
 struct ir_scancode_table {
         struct ir_scancode      *scan;
         int                     size;
-        enum                    ir_type ir_type;
+        u64             ir_type;
         spinlock_t              lock;
 };
 
+struct ir_dev_props {
+        unsigned long allowed_protos;
+        void            *priv;
+        int (*change_protocol)(void *priv, u64 ir_type);
+};
+
+
 struct ir_input_dev {
-        struct input_dev                *dev;
-        struct ir_scancode_table        rc_tab;
+        struct input_dev                *dev;           /* Input device*/
+        struct ir_scancode_table        rc_tab;         /* scan/key table */
+        unsigned long                   devno;          /* device number */
+        struct attribute_group          attr;           /* IR attributes */
+        struct device                   *class_dev;     /* virtual class dev */
+        const struct ir_dev_props       *props;         /* Device properties */
 };
+#define to_ir_input_dev(_attr) container_of(_attr, struct ir_input_dev, attr)
 
 /* Routines from ir-keytable.c */
 
 u32 ir_g_keycode_from_table(struct input_dev *input_dev,
                             u32 scancode);
 
-int ir_set_keycode_table(struct input_dev *input_dev,
-                         struct ir_scancode_table *rc_tab);
-
-int ir_roundup_tablesize(int n_elems);
 int ir_input_register(struct input_dev *dev,
-                      struct ir_scancode_table *ir_codes);
+                      const struct ir_scancode_table *ir_codes,
+                      const struct ir_dev_props *props);
 void ir_input_unregister(struct input_dev *input_dev);
 
+/* Routines from ir-sysfs.c */
+
+int ir_register_class(struct input_dev *input_dev);
+void ir_unregister_class(struct input_dev *input_dev);
+
 #endif
diff --git a/include/media/ir-kbd-i2c.h b/include/media/ir-kbd-i2c.h
index aaf65e8b1a40..9142936603cc 100644
--- a/include/media/ir-kbd-i2c.h
+++ b/include/media/ir-kbd-i2c.h
@@ -36,7 +36,7 @@ enum ir_kbd_get_key_fn {
 struct IR_i2c_init_data {
         struct ir_scancode_table *ir_codes;
         const char             *name;
-        int                    type; /* IR_TYPE_RC5, IR_TYPE_PD, etc */
+        u64          type; /* IR_TYPE_RC5, IR_TYPE_PD, etc */
         /*
          * Specify either a function pointer or a value indicating one of
          * ir_kbd_i2c's internal get_key functions
diff --git a/include/media/ov772x.h b/include/media/ov772x.h
index 14c77efd6a85..548bf1155c83 100644
--- a/include/media/ov772x.h
+++ b/include/media/ov772x.h
@@ -15,8 +15,9 @@
 #include <media/soc_camera.h>
 
 /* for flags */
-#define OV772X_FLAG_VFLIP     0x00000001 /* Vertical flip image */
-#define OV772X_FLAG_HFLIP     0x00000002 /* Horizontal flip image */
+#define OV772X_FLAG_VFLIP       (1 << 0) /* Vertical flip image */
+#define OV772X_FLAG_HFLIP       (1 << 1) /* Horizontal flip image */
+#define OV772X_FLAG_8BIT        (1 << 2) /* default 10 bit */
 
 /*
  * for Edge ctrl
@@ -53,9 +54,8 @@ struct ov772x_edge_ctrl {
  * ov772x camera info
  */
 struct ov772x_camera_info {
-        unsigned long          buswidth;
-        unsigned long          flags;
-        struct ov772x_edge_ctrl edgectrl;
+        unsigned long           flags;
+        struct ov772x_edge_ctrl edgectrl;
 };
 
 #endif /* __OV772X_H__ */
diff --git a/include/media/saa7146_vv.h b/include/media/saa7146_vv.h
index 4aeff96ff7d8..b9da1f5591e7 100644
--- a/include/media/saa7146_vv.h
+++ b/include/media/saa7146_vv.h
@@ -188,6 +188,7 @@ void saa7146_buffer_timeout(unsigned long data);
 void saa7146_dma_free(struct saa7146_dev* dev,struct videobuf_queue *q,
                                                 struct saa7146_buf *buf);
 
+int saa7146_vv_devinit(struct saa7146_dev *dev);
 int saa7146_vv_init(struct saa7146_dev* dev, struct saa7146_ext_vv *ext_vv);
 int saa7146_vv_release(struct saa7146_dev* dev);
 
diff --git a/include/media/soc_camera.h b/include/media/soc_camera.h
index dcc5b86bcb6c..9d69f01b6fa2 100644
--- a/include/media/soc_camera.h
+++ b/include/media/soc_camera.h
@@ -81,6 +81,8 @@ struct soc_camera_host_ops {
         int (*set_bus_param)(struct soc_camera_device *, __u32);
         int (*get_ctrl)(struct soc_camera_device *, struct v4l2_control *);
         int (*set_ctrl)(struct soc_camera_device *, struct v4l2_control *);
+        int (*get_parm)(struct soc_camera_device *, struct v4l2_streamparm *);
+        int (*set_parm)(struct soc_camera_device *, struct v4l2_streamparm *);
         unsigned int (*poll)(struct file *, poll_table *);
         const struct v4l2_queryctrl *controls;
         int num_controls;
diff --git a/include/media/timb_radio.h b/include/media/timb_radio.h
new file mode 100644
index 000000000000..fcd32a3696ba
--- /dev/null
+++ b/include/media/timb_radio.h
@@ -0,0 +1,36 @@
+/*
+ * timb_radio.h Platform struct for the Timberdale radio driver
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _TIMB_RADIO_
+#define _TIMB_RADIO_ 1
+
+#include <linux/i2c.h>
+
+struct timb_radio_platform_data {
+        int i2c_adapter; /* I2C adapter where the tuner and dsp are attached */
+        struct {
+                const char *module_name;
+                struct i2c_board_info *info;
+        } tuner;
+        struct {
+                const char *module_name;
+                struct i2c_board_info *info;
+        } dsp;
+};
+
+#endif
diff --git a/include/media/tuner.h b/include/media/tuner.h
index 4d5b53ff17db..5505c5360ca3 100644
--- a/include/media/tuner.h
+++ b/include/media/tuner.h
@@ -129,6 +129,7 @@
 #define TUNER_PARTSNIC_PTI_5NF05        81
 #define TUNER_PHILIPS_CU1216L           82
 #define TUNER_NXP_TDA18271              83
+#define TUNER_SONY_BTF_PXN01Z           84
 
 /* tv card specific */
 #define TDA9887_PRESENT                 (1<<0)
diff --git a/include/media/tvp7002.h b/include/media/tvp7002.h
new file mode 100644
index 000000000000..ee4353459ef5
--- /dev/null
+++ b/include/media/tvp7002.h
@@ -0,0 +1,56 @@
+/* Texas Instruments Triple 8-/10-BIT 165-/110-MSPS Video and Graphics
+ * Digitizer with Horizontal PLL registers
+ *
+ * Copyright (C) 2009 Texas Instruments Inc
+ * Author: Santiago Nunez-Corrales <santiago.nunez@ridgerun.com>
+ *
+ * This code is partially based upon the TVP5150 driver
+ * written by Mauro Carvalho Chehab (mchehab@infradead.org),
+ * the TVP514x driver written by Vaibhav Hiremath <hvaibhav@ti.com>
+ * and the TVP7002 driver in the TI LSP 2.10.00.14
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef _TVP7002_H_
+#define _TVP7002_H_
+
+/* Platform-dependent data
+ *
+ * clk_polarity:
+ *                      0 -> data clocked out on rising edge of DATACLK signal
+ *                      1 -> data clocked out on falling edge of DATACLK signal
+ * hs_polarity:
+ *                      0 -> active low HSYNC output
+ *                      1 -> active high HSYNC output
+ * sog_polarity:
+ *                      0 -> normal operation
+ *                      1 -> operation with polarity inverted
+ * vs_polarity:
+ *                      0 -> active low VSYNC output
+ *                      1 -> active high VSYNC output
+ * fid_polarity:
+ *                      0 -> the field ID output is set to logic 1 for an odd
+ *                           field (field 1) and set to logic 0 for an even
+ *                           field (field 0).
+ *                      1 -> operation with polarity inverted.
+ */
+struct tvp7002_config {
+        u8 clk_polarity;
+        u8 hs_polarity;
+        u8 vs_polarity;
+        u8 fid_polarity;
+        u8 sog_polarity;
+};
+#endif
diff --git a/include/media/tw9910.h b/include/media/tw9910.h
index 5e2895a05e6b..90bcf1fa5421 100644
--- a/include/media/tw9910.h
+++ b/include/media/tw9910.h
@@ -30,8 +30,8 @@ enum tw9910_mpout_pin {
 };
 
 struct tw9910_video_info {
-        unsigned long          buswidth;
-        enum tw9910_mpout_pin  mpout;
+        unsigned long           buswidth;
+        enum tw9910_mpout_pin   mpout;
 };
 
 
diff --git a/include/media/v4l2-chip-ident.h b/include/media/v4l2-chip-ident.h
index 6cc107d198a0..56abf21dd786 100644
--- a/include/media/v4l2-chip-ident.h
+++ b/include/media/v4l2-chip-ident.h
@@ -39,6 +39,7 @@ enum {
 
         /* module saa7115: reserved range 101-149 */
         V4L2_IDENT_SAA7111 = 101,
+        V4L2_IDENT_SAA7111A = 102,
         V4L2_IDENT_SAA7113 = 103,
         V4L2_IDENT_SAA7114 = 104,
         V4L2_IDENT_SAA7115 = 105,
@@ -134,6 +135,9 @@ enum {
         /* modules tef6862: just ident 6862 */
         V4L2_IDENT_TEF6862 = 6862,
 
+        /* module tvp7002: just ident 7002 */
+        V4L2_IDENT_TVP7002 = 7002,
+
         /* module adv7170: just ident 7170 */
         V4L2_IDENT_ADV7170 = 7170,
 
@@ -155,6 +159,9 @@ enum {
         /* module adv7343: just ident 7343 */
         V4L2_IDENT_ADV7343 = 7343,
 
+        /* module saa7706h: just ident 7706 */
+        V4L2_IDENT_SAA7706H = 7706,
+
         /* module wm8739: just ident 8739 */
         V4L2_IDENT_WM8739 = 8739,
 
diff --git a/include/media/v4l2-subdev.h b/include/media/v4l2-subdev.h
index 9ba99cd39ee7..2bcdca0a57fc 100644
--- a/include/media/v4l2-subdev.h
+++ b/include/media/v4l2-subdev.h
@@ -180,6 +180,7 @@ struct v4l2_subdev_audio_ops {
         int (*s_clock_freq)(struct v4l2_subdev *sd, u32 freq);
         int (*s_i2s_clock_freq)(struct v4l2_subdev *sd, u32 freq);
         int (*s_routing)(struct v4l2_subdev *sd, u32 input, u32 output, u32 config);
+        int (*s_stream)(struct v4l2_subdev *sd, int enable);
 };
 
 /*
diff --git a/include/pcmcia/ds.h b/include/pcmcia/ds.h
index ee148573c114..d57847f2f6c1 100644
--- a/include/pcmcia/ds.h
+++ b/include/pcmcia/ds.h
@@ -40,7 +40,7 @@ struct net_device;
  * Documentation/pcmcia/driver.txt for details.
 */
 struct pcmcia_dynids {
-        spinlock_t              lock;
+        struct mutex            lock;
         struct list_head        list;
 };
 
diff --git a/include/pcmcia/ss.h b/include/pcmcia/ss.h
index cbfba885eb85..32896a773910 100644
--- a/include/pcmcia/ss.h
+++ b/include/pcmcia/ss.h
@@ -134,9 +134,9 @@ struct pccard_operations {
 
 struct pcmcia_socket {
         struct module                   *owner;
-        spinlock_t                      lock;
         socket_state_t                  socket;
         u_int                           state;
+        u_int                           suspended_state;        /* state before suspend */
         u_short                         functions;
         u_short                         lock_count;
         pccard_mem_map                  cis_mem;
@@ -200,9 +200,14 @@ struct pcmcia_socket {
         struct task_struct              *thread;
         struct completion               thread_done;
         unsigned int                    thread_events;
-        /* protects socket h/w state */
+        unsigned int                    sysfs_events;
+
+        /* For the non-trivial interaction between these locks,
+         * see Documentation/pcmcia/locking.txt */
         struct mutex                    skt_mutex;
-        /* protects thread_events */
+        struct mutex                    ops_mutex;
+
+        /* protects thread_events and sysfs_events */
         spinlock_t                      thread_lock;
 
         /* pcmcia (16-bit) */
@@ -225,30 +230,19 @@ struct pcmcia_socket {
                 u8                      busy:1;
                 /* pcmcia module is being unloaded */
                 u8                      dead:1;
-                /* a multifunction-device add event is pending */
-                u8                      device_add_pending:1;
-                /* the pending event adds a mfc (1) or pfc (0) */
-                u8                      mfc_pfc:1;
+                /* the PCMCIA card consists of two pseudo devices */
+                u8                      has_pfc:1;
 
-                u8                      reserved:3;
+                u8                      reserved:4;
         } pcmcia_state;
 
 
-        /* for adding further pseudo-multifunction devices */
-        struct work_struct              device_add;
-
 #ifdef CONFIG_PCMCIA_IOCTL
         struct user_info_t              *user;
         wait_queue_head_t               queue;
 #endif /* CONFIG_PCMCIA_IOCTL */
 #endif /* CONFIG_PCMCIA */
 
-        /* cardbus (32-bit) */
-#ifdef CONFIG_CARDBUS
-        struct resource                 *cb_cis_res;
-        void __iomem                    *cb_cis_virt;
-#endif /* CONFIG_CARDBUS */
-
         /* socket device */
         struct device                   dev;
         /* data internal to the socket driver */
@@ -263,13 +257,25 @@ struct pcmcia_socket {
  * - pccard_static_ops          iomem and ioport areas are assigned statically
  * - pccard_iodyn_ops           iomem areas is assigned statically, ioport
  *                              areas dynamically
+ *                              If this option is selected, use
+ *                              "select PCCARD_IODYN" in Kconfig.
  * - pccard_nonstatic_ops       iomem and ioport areas are assigned dynamically.
  *                              If this option is selected, use
  *                              "select PCCARD_NONSTATIC" in Kconfig.
+ *
  */
 extern struct pccard_resource_ops pccard_static_ops;
+#if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE)
 extern struct pccard_resource_ops pccard_iodyn_ops;
 extern struct pccard_resource_ops pccard_nonstatic_ops;
+#else
+/* If PCMCIA is not used, but only CARDBUS, these functions are not used
+ * at all. Therefore, do not use the large (240K!) rsrc_nonstatic module
+ */
+#define pccard_iodyn_ops pccard_static_ops
+#define pccard_nonstatic_ops pccard_static_ops
+#endif
+
 
 /* socket drivers are expected to use these callbacks in their .drv struct */
 extern int pcmcia_socket_dev_suspend(struct device *dev);
diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h
index 7c4449900c24..d80b6dbed1ca 100644
--- a/include/scsi/scsi_device.h
+++ b/include/scsi/scsi_device.h
@@ -348,7 +348,8 @@ extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp,
                             struct scsi_sense_hdr *);
 extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout,
                                 int retries, struct scsi_sense_hdr *sshdr);
-extern unsigned char *scsi_get_vpd_page(struct scsi_device *, u8 page);
+extern int scsi_get_vpd_page(struct scsi_device *, u8 page, unsigned char *buf,
+                             int buf_len);
 extern int scsi_device_set_state(struct scsi_device *sdev,
                                  enum scsi_device_state state);
 extern struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,
diff --git a/include/scsi/scsi_transport_sas.h b/include/scsi/scsi_transport_sas.h
index 61ad3594aad6..ffeebc34a4f7 100644
--- a/include/scsi/scsi_transport_sas.h
+++ b/include/scsi/scsi_transport_sas.h
@@ -107,6 +107,8 @@ struct sas_end_device {
         struct sas_rphy         rphy;
         /* flags */
         unsigned                ready_led_meaning:1;
+        unsigned                tlr_supported:1;
+        unsigned                tlr_enabled:1;
         /* parameters */
         u16                     I_T_nexus_loss_timeout;
         u16                     initiator_response_timeout;
@@ -181,6 +183,11 @@ extern int sas_phy_add(struct sas_phy *);
 extern void sas_phy_delete(struct sas_phy *);
 extern int scsi_is_sas_phy(const struct device *);
 
+unsigned int sas_tlr_supported(struct scsi_device *);
+unsigned int sas_is_tlr_enabled(struct scsi_device *);
+void sas_disable_tlr(struct scsi_device *);
+void sas_enable_tlr(struct scsi_device *);
+
 extern struct sas_rphy *sas_end_device_alloc(struct sas_port *);
 extern struct sas_rphy *sas_expander_alloc(struct sas_port *, enum sas_device_type);
 void sas_rphy_free(struct sas_rphy *);
diff --git a/include/trace/events/lock.h b/include/trace/events/lock.h
index a870ba125aa8..5c1dcfc16c60 100644
--- a/include/trace/events/lock.h
+++ b/include/trace/events/lock.h
@@ -20,14 +20,17 @@ TRACE_EVENT(lock_acquire,
         TP_STRUCT__entry(
                 __field(unsigned int, flags)
                 __string(name, lock->name)
+                __field(void *, lockdep_addr)
         ),
 
         TP_fast_assign(
                 __entry->flags = (trylock ? 1 : 0) | (read ? 2 : 0);
                 __assign_str(name, lock->name);
+                __entry->lockdep_addr = lock;
         ),
 
-        TP_printk("%s%s%s", (__entry->flags & 1) ? "try " : "",
+        TP_printk("%p %s%s%s", __entry->lockdep_addr,
+                  (__entry->flags & 1) ? "try " : "",
                   (__entry->flags & 2) ? "read " : "",
                   __get_str(name))
 );
@@ -40,13 +43,16 @@ TRACE_EVENT(lock_release,
 
         TP_STRUCT__entry(
                 __string(name, lock->name)
+                __field(void *, lockdep_addr)
         ),
 
         TP_fast_assign(
                 __assign_str(name, lock->name);
+                __entry->lockdep_addr = lock;
         ),
 
-        TP_printk("%s", __get_str(name))
+        TP_printk("%p %s",
+                  __entry->lockdep_addr, __get_str(name))
 );
 
 #ifdef CONFIG_LOCK_STAT
@@ -59,13 +65,16 @@ TRACE_EVENT(lock_contended,
 
         TP_STRUCT__entry(
                 __string(name, lock->name)
+                __field(void *, lockdep_addr)
         ),
 
         TP_fast_assign(
                 __assign_str(name, lock->name);
+                __entry->lockdep_addr = lock;
         ),
 
-        TP_printk("%s", __get_str(name))
+        TP_printk("%p %s",
+                  __entry->lockdep_addr, __get_str(name))
 );
 
 TRACE_EVENT(lock_acquired,
@@ -75,16 +84,18 @@ TRACE_EVENT(lock_acquired,
 
         TP_STRUCT__entry(
                 __string(name, lock->name)
-                __field(unsigned long, wait_usec)
-                __field(unsigned long, wait_nsec_rem)
+                __field(s64, wait_nsec)
+                __field(void *, lockdep_addr)
         ),
+
         TP_fast_assign(
                 __assign_str(name, lock->name);
-                __entry->wait_nsec_rem = do_div(waittime, NSEC_PER_USEC);
-                __entry->wait_usec = (unsigned long) waittime;
+                __entry->wait_nsec = waittime;
+                __entry->lockdep_addr = lock;
         ),
-        TP_printk("%s (%lu.%03lu us)", __get_str(name), __entry->wait_usec,
-                                       __entry->wait_nsec_rem)
+        TP_printk("%p %s (%llu ns)", __entry->lockdep_addr,
+                  __get_str(name),
+                  __entry->wait_nsec)
 );
 
 #endif
diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
index c6fe03e902ca..0804cd594803 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -65,7 +65,8 @@
         };
 #undef DEFINE_EVENT
 #define DEFINE_EVENT(template, name, proto, args)       \
-        static struct ftrace_event_call event_##name
+        static struct ftrace_event_call                 \
+        __attribute__((__aligned__(4))) event_##name
 
 #undef DEFINE_EVENT_PRINT
 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
@@ -131,130 +132,6 @@
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
 /*
- * Setup the showing format of trace point.
- *
- * int
- * ftrace_format_##call(struct trace_seq *s)
- * {
- *      struct ftrace_raw_##call field;
- *      int ret;
- *
- *      ret = trace_seq_printf(s, #type " " #item ";"
- *                             " offset:%u; size:%u;\n",
- *                             offsetof(struct ftrace_raw_##call, item),
- *                             sizeof(field.type));
- *
- * }
- */
-
-#undef TP_STRUCT__entry
-#define TP_STRUCT__entry(args...) args
-
-#undef __field
-#define __field(type, item)                                     \
-        ret = trace_seq_printf(s, "\tfield:" #type " " #item ";\t"      \
-                               "offset:%u;\tsize:%u;\tsigned:%u;\n",    \
-                               (unsigned int)offsetof(typeof(field), item), \
-                               (unsigned int)sizeof(field.item),        \
-                               (unsigned int)is_signed_type(type));     \
-        if (!ret)                                                       \
-                return 0;
-
-#undef __field_ext
-#define __field_ext(type, item, filter_type)    __field(type, item)
-
-#undef __array
-#define __array(type, item, len)                                                \
-        ret = trace_seq_printf(s, "\tfield:" #type " " #item "[" #len "];\t"    \
-                               "offset:%u;\tsize:%u;\tsigned:%u;\n",    \
-                               (unsigned int)offsetof(typeof(field), item), \
-                               (unsigned int)sizeof(field.item),        \
-                               (unsigned int)is_signed_type(type));     \
-        if (!ret)                                                       \
-                return 0;
-
-#undef __dynamic_array
-#define __dynamic_array(type, item, len)                                       \
-        ret = trace_seq_printf(s, "\tfield:__data_loc " #type "[] " #item ";\t"\
-                               "offset:%u;\tsize:%u;\tsigned:%u;\n",           \
-                               (unsigned int)offsetof(typeof(field),           \
-                                        __data_loc_##item),                    \
-                               (unsigned int)sizeof(field.__data_loc_##item), \
-                               (unsigned int)is_signed_type(type));     \
-        if (!ret)                                                              \
-                return 0;
-
-#undef __string
-#define __string(item, src) __dynamic_array(char, item, -1)
-
-#undef __entry
-#define __entry REC
-
-#undef __print_symbolic
-#undef __get_dynamic_array
-#undef __get_str
-
-#undef TP_printk
-#define TP_printk(fmt, args...) "\"%s\", %s\n", fmt, __stringify(args)
-
-#undef TP_fast_assign
-#define TP_fast_assign(args...) args
-
-#undef TP_perf_assign
-#define TP_perf_assign(args...)
-
-#undef DECLARE_EVENT_CLASS
-#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, func, print)    \
-static int                                                              \
-ftrace_format_setup_##call(struct ftrace_event_call *unused,            \
-                           struct trace_seq *s)                         \
-{                                                                       \
-        struct ftrace_raw_##call field __attribute__((unused));         \
-        int ret = 0;                                                    \
-                                                                        \
-        tstruct;                                                        \
-                                                                        \
-        return ret;                                                     \
-}                                                                       \
-                                                                        \
-static int                                                              \
-ftrace_format_##call(struct ftrace_event_call *unused,                  \
-                     struct trace_seq *s)                               \
-{                                                                       \
-        int ret = 0;                                                    \
-                                                                        \
-        ret = ftrace_format_setup_##call(unused, s);                    \
-        if (!ret)                                                       \
-                return ret;                                             \
-                                                                        \
-        ret = trace_seq_printf(s, "\nprint fmt: " print);               \
-                                                                        \
-        return ret;                                                     \
-}
-
-#undef DEFINE_EVENT
-#define DEFINE_EVENT(template, name, proto, args)
-
-#undef DEFINE_EVENT_PRINT
-#define DEFINE_EVENT_PRINT(template, name, proto, args, print)          \
-static int                                                              \
-ftrace_format_##name(struct ftrace_event_call *unused,                  \
-                      struct trace_seq *s)                              \
-{                                                                       \
-        int ret = 0;                                                    \
-                                                                        \
-        ret = ftrace_format_setup_##template(unused, s);                \
-        if (!ret)                                                       \
-                return ret;                                             \
-                                                                        \
-        trace_seq_printf(s, "\nprint fmt: " print);                     \
-                                                                        \
-        return ret;                                                     \
-}
-
-#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
-
-/*
  * Stage 3 of the trace events.
  *
  * Override the macros in <trace/trace_events.h> to include the following:
@@ -323,7 +200,7 @@ ftrace_format_##name(struct ftrace_event_call *unused,			\
 
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
-static enum print_line_t                                                \
+static notrace enum print_line_t                                        \
 ftrace_raw_output_id_##call(int event_id, const char *name,             \
                             struct trace_iterator *iter, int flags)     \
 {                                                                       \
@@ -356,7 +233,7 @@ ftrace_raw_output_id_##call(int event_id, const char *name,		\
 
 #undef DEFINE_EVENT
 #define DEFINE_EVENT(template, name, proto, args)                       \
-static enum print_line_t                                                \
+static notrace enum print_line_t                                        \
 ftrace_raw_output_##name(struct trace_iterator *iter, int flags)        \
 {                                                                       \
         return ftrace_raw_output_id_##template(event_##name.id,         \
@@ -365,7 +242,7 @@ ftrace_raw_output_##name(struct trace_iterator *iter, int flags)	\
 
 #undef DEFINE_EVENT_PRINT
 #define DEFINE_EVENT_PRINT(template, call, proto, args, print)          \
-static enum print_line_t                                                \
+static notrace enum print_line_t                                        \
 ftrace_raw_output_##call(struct trace_iterator *iter, int flags)        \
 {                                                                       \
         struct trace_seq *s = &iter->seq;                               \
@@ -431,7 +308,7 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags)	\
 
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, func, print)    \
-static int                                                              \
+static int notrace                                                      \
 ftrace_define_fields_##call(struct ftrace_event_call *event_call)       \
 {                                                                       \
         struct ftrace_raw_##call field;                                 \
@@ -479,7 +356,7 @@ ftrace_define_fields_##call(struct ftrace_event_call *event_call)	\
 
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
-static inline int ftrace_get_offsets_##call(                            \
+static inline notrace int ftrace_get_offsets_##call(                    \
         struct ftrace_data_offsets_##call *__data_offsets, proto)       \
 {                                                                       \
         int __data_size = 0;                                            \
@@ -499,7 +376,7 @@ static inline int ftrace_get_offsets_##call(				\
 
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
-#ifdef CONFIG_EVENT_PROFILE
+#ifdef CONFIG_PERF_EVENTS
 
 /*
  * Generate the functions needed for tracepoint perf_event support.
@@ -526,12 +403,14 @@ static inline int ftrace_get_offsets_##call(				\
                                                                         \
 static void ftrace_profile_##name(proto);                               \
                                                                         \
-static int ftrace_profile_enable_##name(struct ftrace_event_call *unused)\
+static notrace int                                                      \
+ftrace_profile_enable_##name(struct ftrace_event_call *unused)          \
 {                                                                       \
         return register_trace_##name(ftrace_profile_##name);            \
 }                                                                       \
                                                                         \
-static void ftrace_profile_disable_##name(struct ftrace_event_call *unused)\
+static notrace void                                                     \
+ftrace_profile_disable_##name(struct ftrace_event_call *unused)         \
 {                                                                       \
         unregister_trace_##name(ftrace_profile_##name);                 \
 }
@@ -542,7 +421,7 @@ static void ftrace_profile_disable_##name(struct ftrace_event_call *unused)\
 
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
-#endif
+#endif /* CONFIG_PERF_EVENTS */
 
 /*
  * Stage 4 of the trace events.
@@ -622,12 +501,11 @@ static void ftrace_profile_disable_##name(struct ftrace_event_call *unused)\
  *      .raw_init               = trace_event_raw_init,
  *      .regfunc                = ftrace_reg_event_<call>,
  *      .unregfunc              = ftrace_unreg_event_<call>,
- *      .show_format            = ftrace_format_<call>,
  * }
  *
  */
 
-#ifdef CONFIG_EVENT_PROFILE
+#ifdef CONFIG_PERF_EVENTS
 
 #define _TRACE_PROFILE_INIT(call)                                       \
         .profile_enable = ftrace_profile_enable_##call,                 \
@@ -635,7 +513,7 @@ static void ftrace_profile_disable_##name(struct ftrace_event_call *unused)\
 
 #else
 #define _TRACE_PROFILE_INIT(call)
-#endif
+#endif /* CONFIG_PERF_EVENTS */
 
 #undef __entry
 #define __entry entry
@@ -657,10 +535,17 @@ static void ftrace_profile_disable_##name(struct ftrace_event_call *unused)\
 #define __assign_str(dst, src)                                          \
         strcpy(__get_str(dst), src);
 
+#undef TP_fast_assign
+#define TP_fast_assign(args...) args
+
+#undef TP_perf_assign
+#define TP_perf_assign(args...)
+
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
                                                                         \
-static void ftrace_raw_event_id_##call(struct ftrace_event_call *event_call, \
+static notrace void                                                     \
+ftrace_raw_event_id_##call(struct ftrace_event_call *event_call,        \
                                        proto)                           \
 {                                                                       \
         struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
@@ -697,17 +582,19 @@ static void ftrace_raw_event_id_##call(struct ftrace_event_call *event_call, \
 #undef DEFINE_EVENT
 #define DEFINE_EVENT(template, call, proto, args)                       \
                                                                         \
-static void ftrace_raw_event_##call(proto)                              \
+static notrace void ftrace_raw_event_##call(proto)                      \
 {                                                                       \
         ftrace_raw_event_id_##template(&event_##call, args);            \
 }                                                                       \
                                                                         \
-static int ftrace_raw_reg_event_##call(struct ftrace_event_call *unused)\
+static notrace int                                                      \
+ftrace_raw_reg_event_##call(struct ftrace_event_call *unused)           \
 {                                                                       \
         return register_trace_##call(ftrace_raw_event_##call);          \
 }                                                                       \
                                                                         \
-static void ftrace_raw_unreg_event_##call(struct ftrace_event_call *unused)\
+static notrace void                                                     \
+ftrace_raw_unreg_event_##call(struct ftrace_event_call *unused)         \
 {                                                                       \
         unregister_trace_##call(ftrace_raw_event_##call);               \
 }                                                                       \
@@ -722,8 +609,20 @@ static struct trace_event ftrace_event_type_##call = {			\
 
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
+#undef __entry
+#define __entry REC
+
+#undef __print_flags
+#undef __print_symbolic
+#undef __get_dynamic_array
+#undef __get_str
+
+#undef TP_printk
+#define TP_printk(fmt, args...) "\"" fmt "\", "  __stringify(args)
+
 #undef DECLARE_EVENT_CLASS
-#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)
+#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
+static const char print_fmt_##call[] = print;
 
 #undef DEFINE_EVENT
 #define DEFINE_EVENT(template, call, proto, args)                       \
@@ -737,7 +636,7 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
         .raw_init               = trace_event_raw_init,                 \
         .regfunc                = ftrace_raw_reg_event_##call,          \
         .unregfunc              = ftrace_raw_unreg_event_##call,        \
-        .show_format            = ftrace_format_##template,             \
+        .print_fmt              = print_fmt_##template,                 \
         .define_fields          = ftrace_define_fields_##template,      \
         _TRACE_PROFILE_INIT(call)                                       \
 }
@@ -745,6 +644,8 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 #undef DEFINE_EVENT_PRINT
 #define DEFINE_EVENT_PRINT(template, call, proto, args, print)          \
                                                                         \
+static const char print_fmt_##call[] = print;                           \
+                                                                        \
 static struct ftrace_event_call __used                                  \
 __attribute__((__aligned__(4)))                                         \
 __attribute__((section("_ftrace_events"))) event_##call = {             \
@@ -754,7 +655,7 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
         .raw_init               = trace_event_raw_init,                 \
         .regfunc                = ftrace_raw_reg_event_##call,          \
         .unregfunc              = ftrace_raw_unreg_event_##call,        \
-        .show_format            = ftrace_format_##call,                 \
+        .print_fmt              = print_fmt_##call,                     \
         .define_fields          = ftrace_define_fields_##template,      \
         _TRACE_PROFILE_INIT(call)                                       \
 }
@@ -835,7 +736,17 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
  * }
  */
 
-#ifdef CONFIG_EVENT_PROFILE
+#ifdef CONFIG_PERF_EVENTS
+
+#undef __entry
+#define __entry entry
+
+#undef __get_dynamic_array
+#define __get_dynamic_array(field)      \
+                ((void *)__entry + (__entry->__data_loc_##field & 0xffff))
+
+#undef __get_str
+#define __get_str(field) (char *)__get_dynamic_array(field)
 
 #undef __perf_addr
 #define __perf_addr(a) __addr = (a)
@@ -845,27 +756,17 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
-static void                                                             \
+static notrace void                                                     \
 ftrace_profile_templ_##call(struct ftrace_event_call *event_call,       \
                             proto)                                      \
 {                                                                       \
         struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
-        extern int perf_swevent_get_recursion_context(void);            \
-        extern void perf_swevent_put_recursion_context(int rctx);       \
-        extern void perf_tp_event(int, u64, u64, void *, int);          \
         struct ftrace_raw_##call *entry;                                \
         u64 __addr = 0, __count = 1;                                    \
         unsigned long irq_flags;                                        \
-        struct trace_entry *ent;                                        \
         int __entry_size;                                               \
         int __data_size;                                                \
-        char *trace_buf;                                                \
-        char *raw_data;                                                 \
-        int __cpu;                                                      \
         int rctx;                                                       \
-        int pc;                                                         \
-                                                                        \
-        pc = preempt_count();                                           \
                                                                         \
         __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
         __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),\
@@ -875,47 +776,21 @@ ftrace_profile_templ_##call(struct ftrace_event_call *event_call,	\
         if (WARN_ONCE(__entry_size > FTRACE_MAX_PROFILE_SIZE,           \
                       "profile buffer not large enough"))               \
                 return;                                                 \
-                                                                        \
-        local_irq_save(irq_flags);                                      \
-                                                                        \
-        rctx = perf_swevent_get_recursion_context();                    \
-        if (rctx < 0)                                                   \
-                goto end_recursion;                                     \
-                                                                        \
-        __cpu = smp_processor_id();                                     \
-                                                                        \
-        if (in_nmi())                                                   \
-                trace_buf = rcu_dereference(perf_trace_buf_nmi);        \
-        else                                                            \
-                trace_buf = rcu_dereference(perf_trace_buf);            \
-                                                                        \
-        if (!trace_buf)                                                 \
-                goto end;                                               \
-                                                                        \
-        raw_data = per_cpu_ptr(trace_buf, __cpu);                       \
-                                                                        \
-        *(u64 *)(&raw_data[__entry_size - sizeof(u64)]) = 0ULL;         \
-        entry = (struct ftrace_raw_##call *)raw_data;                   \
-        ent = &entry->ent;                                              \
-        tracing_generic_entry_update(ent, irq_flags, pc);               \
-        ent->type = event_call->id;                                     \
-                                                                        \
+        entry = (struct ftrace_raw_##call *)ftrace_perf_buf_prepare(    \
+                __entry_size, event_call->id, &rctx, &irq_flags);       \
+        if (!entry)                                                     \
+                return;                                                 \
         tstruct                                                         \
                                                                         \
         { assign; }                                                     \
                                                                         \
-        perf_tp_event(event_call->id, __addr, __count, entry,           \
-                             __entry_size);                             \
-                                                                        \
-end:                                                                    \
-        perf_swevent_put_recursion_context(rctx);                       \
-end_recursion:                                                          \
-        local_irq_restore(irq_flags);                                   \
+        ftrace_perf_buf_submit(entry, __entry_size, rctx, __addr,       \
+                               __count, irq_flags);                     \
 }
 
 #undef DEFINE_EVENT
 #define DEFINE_EVENT(template, call, proto, args)               \
-static void ftrace_profile_##call(proto)                        \
+static notrace void ftrace_profile_##call(proto)                \
 {                                                               \
         struct ftrace_event_call *event_call = &event_##call;   \
                                                                 \
@@ -927,7 +802,7 @@ static void ftrace_profile_##call(proto)			\
         DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
 
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
-#endif /* CONFIG_EVENT_PROFILE */
+#endif /* CONFIG_PERF_EVENTS */
 
 #undef _TRACE_PROFILE_INIT
 
diff --git a/include/trace/syscall.h b/include/trace/syscall.h
index 961fda3556bb..0387100752f0 100644
--- a/include/trace/syscall.h
+++ b/include/trace/syscall.h
@@ -34,10 +34,6 @@ struct syscall_metadata {
 extern unsigned long arch_syscall_addr(int nr);
 extern int init_syscall_trace(struct ftrace_event_call *call);
 
-extern int syscall_enter_format(struct ftrace_event_call *call,
-                                struct trace_seq *s);
-extern int syscall_exit_format(struct ftrace_event_call *call,
-                                struct trace_seq *s);
 extern int syscall_enter_define_fields(struct ftrace_event_call *call);
 extern int syscall_exit_define_fields(struct ftrace_event_call *call);
 extern int reg_event_syscall_enter(struct ftrace_event_call *call);
@@ -49,12 +45,12 @@ ftrace_format_syscall(struct ftrace_event_call *call, struct trace_seq *s);
 enum print_line_t print_syscall_enter(struct trace_iterator *iter, int flags);
 enum print_line_t print_syscall_exit(struct trace_iterator *iter, int flags);
 #endif
-#ifdef CONFIG_EVENT_PROFILE
+
+#ifdef CONFIG_PERF_EVENTS
 int prof_sysenter_enable(struct ftrace_event_call *call);
 void prof_sysenter_disable(struct ftrace_event_call *call);
 int prof_sysexit_enable(struct ftrace_event_call *call);
 void prof_sysexit_disable(struct ftrace_event_call *call);
-
 #endif
 
 #endif /* _TRACE_SYSCALL_H */
diff --git a/include/video/sh_mobile_lcdc.h b/include/video/sh_mobile_lcdc.h
index 288205457713..2cc893fc1f85 100644
--- a/include/video/sh_mobile_lcdc.h
+++ b/include/video/sh_mobile_lcdc.h
@@ -34,6 +34,8 @@ enum { LCDC_CLK_BUS, LCDC_CLK_PERIPHERAL, LCDC_CLK_EXTERNAL };
 #define LCDC_FLAGS_HSCNT (1 << 3) /* Disable HSYNC during VBLANK */
 #define LCDC_FLAGS_DWCNT (1 << 4) /* Disable dotclock during blanking */
 
+#define FBIO_WAITFORVSYNC _IOW('F', 0x20, __u32)
+
 struct sh_mobile_lcdc_sys_bus_cfg {
         unsigned long ldmt2r;
         unsigned long ldmt3r;