102 files changed, 2966 insertions, 984 deletions
diff --git a/include/acpi/acpi_bus.h b/include/acpi/acpi_bus.h
index 0d9f984a60a1..16c3c441256e 100644
--- a/include/acpi/acpi_bus.h
+++ b/include/acpi/acpi_bus.h
@@ -316,7 +316,7 @@ struct acpi_bus_event {
        u32 data;
 };
-extern struct subsystem acpi_subsys;
+extern struct kset acpi_subsys;
 /*
 * External Functions
diff --git a/include/asm-alpha/scatterlist.h b/include/asm-alpha/scatterlist.h
index 6afb8bd3aaf9..917365405e83 100644
--- a/include/asm-alpha/scatterlist.h
+++ b/include/asm-alpha/scatterlist.h
@@ -2,6 +2,7 @@
 #define _ALPHA_SCATTERLIST_H
 #include <asm/page.h>
+#include <asm/types.h>
  
 struct scatterlist {
        struct page *page;
diff --git a/include/asm-arm/arch-imx/mmc.h b/include/asm-arm/arch-imx/mmc.h
index 1937151665c7..84c726934ace 100644
--- a/include/asm-arm/arch-imx/mmc.h
+++ b/include/asm-arm/arch-imx/mmc.h
@@ -1,7 +1,7 @@
 #ifndef ASMARM_ARCH_MMC_H
 #define ASMARM_ARCH_MMC_H
-#include <linux/mmc/protocol.h>
+#include <linux/mmc/host.h>
 struct imxmmc_platform_data {
        int (*card_present)(void);
diff --git a/include/asm-arm/arch-ixp4xx/dma.h b/include/asm-arm/arch-ixp4xx/dma.h
index 789f7f53c357..2c7f5327d80f 100644
--- a/include/asm-arm/arch-ixp4xx/dma.h
+++ b/include/asm-arm/arch-ixp4xx/dma.h
@@ -12,7 +12,6 @@
 #define __ASM_ARCH_DMA_H
 #include <linux/device.h>
-#include <linux/pci.h>
 #include <asm/page.h>
 #include <asm/sizes.h>
 #include <asm/hardware.h>
diff --git a/include/asm-arm/arch-pxa/mmc.h b/include/asm-arm/arch-pxa/mmc.h
index a38a28c4bbd8..ef4f570381d1 100644
--- a/include/asm-arm/arch-pxa/mmc.h
+++ b/include/asm-arm/arch-pxa/mmc.h
@@ -1,7 +1,7 @@
 #ifndef ASMARM_ARCH_MMC_H
 #define ASMARM_ARCH_MMC_H
-#include <linux/mmc/protocol.h>
+#include <linux/mmc/host.h>
 #include <linux/interrupt.h>
 struct device;
diff --git a/include/asm-arm/arch-pxa/pxa27x_keyboard.h b/include/asm-arm/arch-pxa/pxa27x_keyboard.h
new file mode 100644
index 000000000000..3aaff923b2ca
--- /dev/null
+++ b/include/asm-arm/arch-pxa/pxa27x_keyboard.h
@@ -0,0 +1,13 @@
+#define PXAKBD_MAXROW           8
+#define PXAKBD_MAXCOL           8
+struct pxa27x_keyboard_platform_data {
+        int nr_rows, nr_cols;
+        int keycodes[PXAKBD_MAXROW][PXAKBD_MAXCOL];
+        int gpio_modes[PXAKBD_MAXROW + PXAKBD_MAXCOL];
+#ifdef CONFIG_PM
+        u32 reg_kpc;
+        u32 reg_kprec;
+#endif
+};
diff --git a/include/asm-arm/mach/mmc.h b/include/asm-arm/mach/mmc.h
index 1b3555d4b41e..eb91145c00c4 100644
--- a/include/asm-arm/mach/mmc.h
+++ b/include/asm-arm/mach/mmc.h
@@ -4,7 +4,7 @@
 #ifndef ASMARM_MACH_MMC_H
 #define ASMARM_MACH_MMC_H
-#include <linux/mmc/protocol.h>
+#include <linux/mmc/host.h>
 struct mmc_platform_data {
        unsigned int ocr_mask;                  /* available voltages */
diff --git a/include/asm-avr32/scatterlist.h b/include/asm-avr32/scatterlist.h
index bfe7d753423c..c6d5ce3b3a25 100644
--- a/include/asm-avr32/scatterlist.h
+++ b/include/asm-avr32/scatterlist.h
@@ -1,6 +1,8 @@
 #ifndef __ASM_AVR32_SCATTERLIST_H
 #define __ASM_AVR32_SCATTERLIST_H
+#include <asm/types.h>
 struct scatterlist {
    struct page         *page;
    unsigned int        offset;
diff --git a/include/asm-frv/scatterlist.h b/include/asm-frv/scatterlist.h
index fb38fd329a5f..8e827fa853f1 100644
--- a/include/asm-frv/scatterlist.h
+++ b/include/asm-frv/scatterlist.h
@@ -1,6 +1,8 @@
 #ifndef _ASM_SCATTERLIST_H
 #define _ASM_SCATTERLIST_H
+#include <asm/types.h>
 /*
 * Drivers must set either ->address or (preferred) ->page and ->offset
 * to indicate where data must be transferred to/from.
diff --git a/include/asm-h8300/scatterlist.h b/include/asm-h8300/scatterlist.h
index 7627f0cd1a2f..985fdf54eaca 100644
--- a/include/asm-h8300/scatterlist.h
+++ b/include/asm-h8300/scatterlist.h
@@ -1,6 +1,8 @@
 #ifndef _H8300_SCATTERLIST_H
 #define _H8300_SCATTERLIST_H
+#include <asm/types.h>
 struct scatterlist {
        struct page     *page;
        unsigned int    offset;
diff --git a/include/asm-i386/agp.h b/include/asm-i386/agp.h
index 9075083bab76..6af173dbf123 100644
--- a/include/asm-i386/agp.h
+++ b/include/asm-i386/agp.h
@@ -12,8 +12,10 @@
 * data corruption on some CPUs.
 */
-int map_page_into_agp(struct page *page);
+/* Caller's responsibility to call global_flush_tlb() for
-int unmap_page_from_agp(struct page *page);
+ * performance reasons */
+#define map_page_into_agp(page) change_page_attr(page, 1, PAGE_KERNEL_NOCACHE)
+#define unmap_page_from_agp(page) change_page_attr(page, 1, PAGE_KERNEL)
 #define flush_agp_mappings() global_flush_tlb()
 /* Could use CLFLUSH here if the cpu supports it. But then it would
diff --git a/include/asm-i386/scatterlist.h b/include/asm-i386/scatterlist.h
index 55d6c953a76e..d7e45a8f1aae 100644
--- a/include/asm-i386/scatterlist.h
+++ b/include/asm-i386/scatterlist.h
@@ -1,6 +1,8 @@
 #ifndef _I386_SCATTERLIST_H
 #define _I386_SCATTERLIST_H
+#include <asm/types.h>
 struct scatterlist {
    struct page         *page;
    unsigned int        offset;
diff --git a/include/asm-i386/voyager.h b/include/asm-i386/voyager.h
index 5b27838905b2..91a9932937ab 100644
--- a/include/asm-i386/voyager.h
+++ b/include/asm-i386/voyager.h
@@ -487,15 +487,11 @@ extern struct voyager_qic_cpi *voyager_quad_cpi_addr[NR_CPUS];
 extern struct voyager_SUS *voyager_SUS;
 /* variables exported always */
+extern struct task_struct *voyager_thread;
 extern int voyager_level;
-extern int kvoyagerd_running;
-extern struct semaphore kvoyagerd_sem;
 extern struct voyager_status voyager_status;
 /* functions exported by the voyager and voyager_smp modules */
 extern int voyager_cat_readb(__u8 module, __u8 asic, int reg);
 extern void voyager_cat_init(void);
 extern void voyager_detect(struct voyager_bios_info *);
diff --git a/include/asm-ia64/scatterlist.h b/include/asm-ia64/scatterlist.h
index 9dbea8844d5e..a452ea24205a 100644
--- a/include/asm-ia64/scatterlist.h
+++ b/include/asm-ia64/scatterlist.h
@@ -6,6 +6,8 @@
 *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
 */
+#include <asm/types.h>
 struct scatterlist {
        struct page *page;
        unsigned int offset;
diff --git a/include/asm-m32r/scatterlist.h b/include/asm-m32r/scatterlist.h
index c2de96cb69ed..352415ff5eb9 100644
--- a/include/asm-m32r/scatterlist.h
+++ b/include/asm-m32r/scatterlist.h
@@ -1,6 +1,8 @@
 #ifndef _ASM_M32R_SCATTERLIST_H
 #define _ASM_M32R_SCATTERLIST_H
+#include <asm/types.h>
 struct scatterlist {
    char *  address;    /* Location data is to be transferred to, NULL for
                         * highmem page */
diff --git a/include/asm-m68k/adb.h b/include/asm-m68k/adb.h
deleted file mode 100644
index 9176b55185bb..000000000000
--- a/include/asm-m68k/adb.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Definitions for talking to ADB and CUDA.  The CUDA is a microcontroller
- * which controls the ADB, system power, RTC, and various other things on
- * later Macintoshes
- *
- * Copyright (C) 1996 Paul Mackerras.
- */
-/* First byte sent to or received from CUDA */
-#define ADB_PACKET      0
-#define CUDA_PACKET     1
-#define ERROR_PACKET    2
-#define TIMER_PACKET    3
-#define POWER_PACKET    4
-#define MACIIC_PACKET   5
-/* ADB commands (2nd byte) */
-#define ADB_BUSRESET            0
-#define ADB_FLUSH(id)           (1 + ((id) << 4))
-#define ADB_WRITEREG(id, reg)   (8 + (reg) + ((id) << 4))
-#define ADB_READREG(id, reg)    (0xc + (reg) + ((id) << 4))
-/* ADB default device IDs (upper 4 bits of 2nd byte) */
-#define ADB_DONGLE      1       /* "software execution control" devices */
-#define ADB_KEYBOARD    2
-#define ADB_MOUSE       3
-#define ADB_TABLET      4
-#define ADB_MODEM       5
-#define ADB_MISC        7       /* maybe a monitor */
-/* CUDA commands (2nd byte) */
-#define CUDA_WARM_START         0
-#define CUDA_AUTOPOLL           1
-#define CUDA_GET_6805_ADDR      2
-#define CUDA_GET_TIME           3
-#define CUDA_GET_PRAM           7
-#define CUDA_SET_6805_ADDR      8
-#define CUDA_SET_TIME           9
-#define CUDA_POWERDOWN          0xa
-#define CUDA_POWERUP_TIME       0xb
-#define CUDA_SET_PRAM           0xc
-#define CUDA_MS_RESET           0xd
-#define CUDA_SEND_DFAC          0xe
-#define CUDA_RESET_SYSTEM       0x11
-#define CUDA_SET_IPL            0x12
-#define CUDA_SET_AUTO_RATE      0x14
-#define CUDA_GET_AUTO_RATE      0x16
-#define CUDA_SET_DEVICE_LIST    0x19
-#define CUDA_GET_DEVICE_LIST    0x1a
-#define CUDA_GET_SET_IIC        0x22
-#ifdef __KERNEL__
-struct adb_request {
-    unsigned char data[16];
-    int nbytes;
-    unsigned char reply[16];
-    int reply_len;
-    unsigned char reply_expected;
-    unsigned char sent;
-    unsigned char got_reply;
-    void (*done)(struct adb_request *);
-    void *arg;
-    struct adb_request *next;
-};
-void via_adb_init(void);
-int adb_request(struct adb_request *req,
-                 void (*done)(struct adb_request *), int nbytes, ...);
-int adb_send_request(struct adb_request *req);
-void adb_poll(void);
-int adb_register(int default_id,
-                 void (*handler)(unsigned char *, int, struct pt_regs *));
-#endif  /* __KERNEL */
diff --git a/include/asm-m68k/atarikb.h b/include/asm-m68k/atarikb.h
index 18926058fde7..546e7da5804f 100644
--- a/include/asm-m68k/atarikb.h
+++ b/include/asm-m68k/atarikb.h
@@ -36,5 +36,11 @@ void ikbd_joystick_disable(void);
 extern void (*atari_MIDI_interrupt_hook) (void);
 /* Hook for mouse driver */
 extern void (*atari_mouse_interrupt_hook) (char *);
+/* Hook for keyboard inputdev  driver */
+extern void (*atari_input_keyboard_interrupt_hook) (unsigned char, char);
+/* Hook for mouse inputdev  driver */
+extern void (*atari_input_mouse_interrupt_hook) (char *);
+int atari_keyb_init(void);
 #endif /* _LINUX_ATARIKB_H */
diff --git a/include/asm-m68knommu/scatterlist.h b/include/asm-m68knommu/scatterlist.h
index 2085d6ff8782..4da79d3d3f34 100644
--- a/include/asm-m68knommu/scatterlist.h
+++ b/include/asm-m68knommu/scatterlist.h
@@ -2,6 +2,7 @@
 #define _M68KNOMMU_SCATTERLIST_H
 #include <linux/mm.h>
+#include <asm/types.h>
 struct scatterlist {
        struct page     *page;
diff --git a/include/asm-mips/scatterlist.h b/include/asm-mips/scatterlist.h
index 22634706e9d5..7af104c95b20 100644
--- a/include/asm-mips/scatterlist.h
+++ b/include/asm-mips/scatterlist.h
@@ -1,6 +1,8 @@
 #ifndef __ASM_SCATTERLIST_H
 #define __ASM_SCATTERLIST_H
+#include <asm/types.h>
 struct scatterlist {
        struct page *   page;
        unsigned int    offset;
diff --git a/include/asm-parisc/scatterlist.h b/include/asm-parisc/scatterlist.h
index 236c1d0fba33..e7211c748446 100644
--- a/include/asm-parisc/scatterlist.h
+++ b/include/asm-parisc/scatterlist.h
@@ -2,6 +2,7 @@
 #define _ASM_PARISC_SCATTERLIST_H
 #include <asm/page.h>
+#include <asm/types.h>
 struct scatterlist {
        struct page *page;
diff --git a/include/asm-powerpc/ps3av.h b/include/asm-powerpc/ps3av.h
index 43e90ea96136..9efc40f1c778 100644
--- a/include/asm-powerpc/ps3av.h
+++ b/include/asm-powerpc/ps3av.h
@@ -18,8 +18,6 @@
 #ifndef _ASM_POWERPC_PS3AV_H_
 #define _ASM_POWERPC_PS3AV_H_
-#include <linux/mutex.h>
 /** command for ioctl() **/
 #define PS3AV_VERSION 0x205     /* version of ps3av command */
@@ -643,24 +641,6 @@ struct ps3av_pkt_avb_param {
        u8 buf[PS3AV_PKT_AVB_PARAM_MAX_BUF_SIZE];
 };
-struct ps3av {
-        int available;
-        struct semaphore sem;
-        struct semaphore ping;
-        struct semaphore pong;
-        struct mutex mutex;
-        int open_count;
-        struct ps3_vuart_port_device *dev;
-        int region;
-        struct ps3av_pkt_av_get_hw_conf av_hw_conf;
-        u32 av_port[PS3AV_AV_PORT_MAX + PS3AV_OPT_PORT_MAX];
-        u32 opt_port[PS3AV_OPT_PORT_MAX];
-        u32 head[PS3AV_HEAD_MAX];
-        u32 audio_port;
-        int ps3av_mode;
-        int ps3av_mode_old;
-};
 /** command status **/
 #define PS3AV_STATUS_SUCCESS                    0x0000  /* success */
@@ -718,6 +698,7 @@ static inline void ps3av_cmd_av_monitor_info_dump(const struct ps3av_pkt_av_get_
 extern int ps3av_cmd_video_get_monitor_info(struct ps3av_pkt_av_get_monitor_info *,
                                            u32);
+struct ps3_vuart_port_device;
 extern int ps3av_vuart_write(struct ps3_vuart_port_device *dev,
                             const void *buf, unsigned long size);
 extern int ps3av_vuart_read(struct ps3_vuart_port_device *dev, void *buf,
@@ -725,6 +706,7 @@ extern int ps3av_vuart_read(struct ps3_vuart_port_device *dev, void *buf,
 extern int ps3av_set_video_mode(u32, int);
 extern int ps3av_set_audio_mode(u32, u32, u32, u32, u32);
+extern int ps3av_get_auto_mode(int);
 extern int ps3av_set_mode(u32, int);
 extern int ps3av_get_mode(void);
 extern int ps3av_get_scanmode(int);
diff --git a/include/asm-s390/ccwdev.h b/include/asm-s390/ccwdev.h
index cfc81533b9ba..6795ecefd15b 100644
--- a/include/asm-s390/ccwdev.h
+++ b/include/asm-s390/ccwdev.h
@@ -164,9 +164,9 @@ extern int ccw_device_resume(struct ccw_device *);
 extern int ccw_device_halt(struct ccw_device *, unsigned long);
 extern int ccw_device_clear(struct ccw_device *, unsigned long);
-extern int read_dev_chars(struct ccw_device *cdev, void **buffer, int length);
+extern int __deprecated read_dev_chars(struct ccw_device *cdev, void **buffer, int length);
-extern int read_conf_data(struct ccw_device *cdev, void **buffer, int *length);
+extern int __deprecated read_conf_data(struct ccw_device *cdev, void **buffer, int *length);
-extern int read_conf_data_lpm(struct ccw_device *cdev, void **buffer,
+extern int __deprecated read_conf_data_lpm(struct ccw_device *cdev, void **buffer,
                              int *length, __u8 lpm);
 extern int ccw_device_set_online(struct ccw_device *cdev);
diff --git a/include/asm-s390/elf.h b/include/asm-s390/elf.h
index c0d629d61d3e..91d06325cc79 100644
--- a/include/asm-s390/elf.h
+++ b/include/asm-s390/elf.h
@@ -188,7 +188,8 @@ static inline int dump_task_fpu(struct task_struct *tsk, elf_fpregset_t *fpregs)
 /* This yields a mask that user programs can use to figure out what
   instruction set this CPU supports. */
-#define ELF_HWCAP (0)
+extern unsigned long elf_hwcap;
+#define ELF_HWCAP (elf_hwcap)
 /* This yields a string that ld.so will use to load implementation
   specific libraries for optimization.  This is more specific in
@@ -197,7 +198,9 @@ static inline int dump_task_fpu(struct task_struct *tsk, elf_fpregset_t *fpregs)
   For the moment, we have only optimizations for the Intel generations,
   but that could change... */
-#define ELF_PLATFORM (NULL)
+#define ELF_PLATFORM_SIZE 8
+extern char elf_platform[];
+#define ELF_PLATFORM (elf_platform)
 #ifndef __s390x__
 #define SET_PERSONALITY(ex, ibcs2) set_personality((ibcs2)?PER_SVR4:PER_LINUX)
diff --git a/include/asm-s390/kdebug.h b/include/asm-s390/kdebug.h
index 1b50f89819a4..d2d7ad276148 100644
--- a/include/asm-s390/kdebug.h
+++ b/include/asm-s390/kdebug.h
@@ -22,8 +22,21 @@ struct die_args {
 */
 extern int register_die_notifier(struct notifier_block *);
 extern int unregister_die_notifier(struct notifier_block *);
-extern int register_page_fault_notifier(struct notifier_block *);
-extern int unregister_page_fault_notifier(struct notifier_block *);
+/*
+ * These are only here because kprobes.c wants them to implement a
+ * blatant layering violation. Will hopefully go away soon once all
+ * architectures are updated.
+ */
+static inline int register_page_fault_notifier(struct notifier_block *nb)
+{
+        return 0;
+}
+static inline int unregister_page_fault_notifier(struct notifier_block *nb)
+{
+        return 0;
+}
 extern struct atomic_notifier_head s390die_chain;
 enum die_val {
@@ -39,7 +52,6 @@ enum die_val {
        DIE_GPF,
        DIE_CALL,
        DIE_NMI_IPI,
-        DIE_PAGE_FAULT,
 };
 static inline int notify_die(enum die_val val, const char *str,
diff --git a/include/asm-s390/kprobes.h b/include/asm-s390/kprobes.h
index b847ff0ec3fa..830fe4c4eea6 100644
--- a/include/asm-s390/kprobes.h
+++ b/include/asm-s390/kprobes.h
@@ -97,18 +97,10 @@ void kretprobe_trampoline(void);
 int  is_prohibited_opcode(kprobe_opcode_t *instruction);
 void get_instruction_type(struct arch_specific_insn *ainsn);
+int kprobe_fault_handler(struct pt_regs *regs, int trapnr);
+int kprobe_exceptions_notify(struct notifier_block *self,
+        unsigned long val, void *data);
 #define flush_insn_slot(p)      do { } while (0)
 #endif  /* _ASM_S390_KPROBES_H */
-#ifdef CONFIG_KPROBES
-extern int kprobe_exceptions_notify(struct notifier_block *self,
-                                        unsigned long val, void *data);
-#else   /* !CONFIG_KPROBES */
-static inline int kprobe_exceptions_notify(struct notifier_block *self,
-                                                unsigned long val, void *data)
-{
-        return 0;
-}
-#endif
diff --git a/include/asm-s390/lowcore.h b/include/asm-s390/lowcore.h
index ffc9788a21a7..801a6fd35b5b 100644
--- a/include/asm-s390/lowcore.h
+++ b/include/asm-s390/lowcore.h
@@ -229,17 +229,19 @@ struct _lowcore
        __u16        subchannel_nr;            /* 0x0ba */
        __u32        io_int_parm;              /* 0x0bc */
        __u32        io_int_word;              /* 0x0c0 */
-        __u8         pad3[0xD4-0xC4];          /* 0x0c4 */
+        __u8         pad3[0xc8-0xc4];          /* 0x0c4 */
+        __u32        stfl_fac_list;            /* 0x0c8 */
+        __u8         pad4[0xd4-0xcc];          /* 0x0cc */
        __u32        extended_save_area_addr;  /* 0x0d4 */
        __u32        cpu_timer_save_area[2];   /* 0x0d8 */
        __u32        clock_comp_save_area[2];  /* 0x0e0 */
        __u32        mcck_interruption_code[2]; /* 0x0e8 */
-        __u8         pad4[0xf4-0xf0];          /* 0x0f0 */
+        __u8         pad5[0xf4-0xf0];          /* 0x0f0 */
        __u32        external_damage_code;     /* 0x0f4 */
        __u32        failing_storage_address;  /* 0x0f8 */
-        __u8         pad5[0x100-0xfc];         /* 0x0fc */
+        __u8         pad6[0x100-0xfc];         /* 0x0fc */
        __u32        st_status_fixed_logout[4];/* 0x100 */
-        __u8         pad6[0x120-0x110];        /* 0x110 */
+        __u8         pad7[0x120-0x110];        /* 0x110 */
        __u32        access_regs_save_area[16];/* 0x120 */
        __u32        floating_pt_save_area[8]; /* 0x160 */
        __u32        gpregs_save_area[16];     /* 0x180 */
diff --git a/include/asm-sh/scatterlist.h b/include/asm-sh/scatterlist.h
index d19e7cd3b023..b9ae53c38365 100644
--- a/include/asm-sh/scatterlist.h
+++ b/include/asm-sh/scatterlist.h
@@ -1,6 +1,8 @@
 #ifndef __ASM_SH_SCATTERLIST_H
 #define __ASM_SH_SCATTERLIST_H
+#include <asm/types.h>
 struct scatterlist {
    struct page * page; /* Location for highmem page, if any */
    unsigned int offset;/* for highmem, page offset */
diff --git a/include/asm-sh64/scatterlist.h b/include/asm-sh64/scatterlist.h
index 5d8fa32d2e9d..1c723f2d7a95 100644
--- a/include/asm-sh64/scatterlist.h
+++ b/include/asm-sh64/scatterlist.h
@@ -11,6 +11,8 @@
 #ifndef __ASM_SH64_SCATTERLIST_H
 #define __ASM_SH64_SCATTERLIST_H
+#include <asm/types.h>
 struct scatterlist {
    struct page * page; /* Location for highmem page, if any */
    unsigned int offset;/* for highmem, page offset */
diff --git a/include/asm-sparc64/scatterlist.h b/include/asm-sparc64/scatterlist.h
index ec4f3c63fe98..048fdb40e81d 100644
--- a/include/asm-sparc64/scatterlist.h
+++ b/include/asm-sparc64/scatterlist.h
@@ -3,6 +3,7 @@
 #define _SPARC64_SCATTERLIST_H
 #include <asm/page.h>
+#include <asm/types.h>
 struct scatterlist {
        struct page     *page;
diff --git a/include/asm-v850/scatterlist.h b/include/asm-v850/scatterlist.h
index af1cba69a526..56f402920db9 100644
--- a/include/asm-v850/scatterlist.h
+++ b/include/asm-v850/scatterlist.h
@@ -14,6 +14,8 @@
 #ifndef __V850_SCATTERLIST_H__
 #define __V850_SCATTERLIST_H__
+#include <asm/types.h>
 struct scatterlist {
        struct page     *page;
        unsigned        offset;
diff --git a/include/asm-x86_64/agp.h b/include/asm-x86_64/agp.h
index 06c52ee9c06b..de338666f3f9 100644
--- a/include/asm-x86_64/agp.h
+++ b/include/asm-x86_64/agp.h
@@ -10,8 +10,10 @@
 * with different cachability attributes for the same page.
 */
-int map_page_into_agp(struct page *page);
+/* Caller's responsibility to call global_flush_tlb() for
-int unmap_page_from_agp(struct page *page);
+ * performance reasons */
+#define map_page_into_agp(page) change_page_attr(page, 1, PAGE_KERNEL_NOCACHE)
+#define unmap_page_from_agp(page) change_page_attr(page, 1, PAGE_KERNEL)
 #define flush_agp_mappings() global_flush_tlb()
 /* Could use CLFLUSH here if the cpu supports it. But then it would
diff --git a/include/asm-x86_64/scatterlist.h b/include/asm-x86_64/scatterlist.h
index 49d89f8129cd..eaf7ada27e14 100644
--- a/include/asm-x86_64/scatterlist.h
+++ b/include/asm-x86_64/scatterlist.h
@@ -1,6 +1,8 @@
 #ifndef _X8664_SCATTERLIST_H
 #define _X8664_SCATTERLIST_H
+#include <asm/types.h>
 struct scatterlist {
    struct page         *page;
    unsigned int        offset;
diff --git a/include/asm-xtensa/scatterlist.h b/include/asm-xtensa/scatterlist.h
index 38a2b9acd658..ca337a294290 100644
--- a/include/asm-xtensa/scatterlist.h
+++ b/include/asm-xtensa/scatterlist.h
@@ -11,6 +11,8 @@
 #ifndef _XTENSA_SCATTERLIST_H
 #define _XTENSA_SCATTERLIST_H
+#include <asm/types.h>
 struct scatterlist {
        struct page     *page;
        unsigned int    offset;
diff --git a/include/crypto/algapi.h b/include/crypto/algapi.h
index 4e05e93ff681..b2b1e6efd812 100644
--- a/include/crypto/algapi.h
+++ b/include/crypto/algapi.h
@@ -13,8 +13,11 @@
 #define _CRYPTO_ALGAPI_H
 #include <linux/crypto.h>
+#include <linux/list.h>
+#include <linux/kernel.h>
 struct module;
+struct rtattr;
 struct seq_file;
 struct crypto_type {
@@ -38,7 +41,7 @@ struct crypto_template {
        struct hlist_head instances;
        struct module *module;
-        struct crypto_instance *(*alloc)(void *param, unsigned int len);
+        struct crypto_instance *(*alloc)(struct rtattr **tb);
        void (*free)(struct crypto_instance *inst);
        char name[CRYPTO_MAX_ALG_NAME];
@@ -48,6 +51,15 @@ struct crypto_spawn {
        struct list_head list;
        struct crypto_alg *alg;
        struct crypto_instance *inst;
+        u32 mask;
+};
+struct crypto_queue {
+        struct list_head list;
+        struct list_head *backlog;
+        unsigned int qlen;
+        unsigned int max_qlen;
 };
 struct scatter_walk {
@@ -81,6 +93,7 @@ struct blkcipher_walk {
        int flags;
 };
+extern const struct crypto_type crypto_ablkcipher_type;
 extern const struct crypto_type crypto_blkcipher_type;
 extern const struct crypto_type crypto_hash_type;
@@ -91,16 +104,23 @@ void crypto_unregister_template(struct crypto_template *tmpl);
 struct crypto_template *crypto_lookup_template(const char *name);
 int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg,
-                      struct crypto_instance *inst);
+                      struct crypto_instance *inst, u32 mask);
 void crypto_drop_spawn(struct crypto_spawn *spawn);
 struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type,
                                    u32 mask);
-struct crypto_alg *crypto_get_attr_alg(void *param, unsigned int len,
+struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb);
-                                       u32 type, u32 mask);
+int crypto_check_attr_type(struct rtattr **tb, u32 type);
+struct crypto_alg *crypto_get_attr_alg(struct rtattr **tb, u32 type, u32 mask);
 struct crypto_instance *crypto_alloc_instance(const char *name,
                                              struct crypto_alg *alg);
+void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen);
+int crypto_enqueue_request(struct crypto_queue *queue,
+                           struct crypto_async_request *request);
+struct crypto_async_request *crypto_dequeue_request(struct crypto_queue *queue);
+int crypto_tfm_in_queue(struct crypto_queue *queue, struct crypto_tfm *tfm);
 int blkcipher_walk_done(struct blkcipher_desc *desc,
                        struct blkcipher_walk *walk, int err);
 int blkcipher_walk_virt(struct blkcipher_desc *desc,
@@ -118,11 +138,37 @@ static inline void *crypto_tfm_ctx_aligned(struct crypto_tfm *tfm)
        return (void *)ALIGN(addr, align);
 }
+static inline struct crypto_instance *crypto_tfm_alg_instance(
+        struct crypto_tfm *tfm)
+{
+        return container_of(tfm->__crt_alg, struct crypto_instance, alg);
+}
 static inline void *crypto_instance_ctx(struct crypto_instance *inst)
 {
        return inst->__ctx;
 }
+static inline struct ablkcipher_alg *crypto_ablkcipher_alg(
+        struct crypto_ablkcipher *tfm)
+{
+        return &crypto_ablkcipher_tfm(tfm)->__crt_alg->cra_ablkcipher;
+}
+static inline void *crypto_ablkcipher_ctx(struct crypto_ablkcipher *tfm)
+{
+        return crypto_tfm_ctx(&tfm->base);
+}
+static inline struct crypto_blkcipher *crypto_spawn_blkcipher(
+        struct crypto_spawn *spawn)
+{
+        u32 type = CRYPTO_ALG_TYPE_BLKCIPHER;
+        u32 mask = CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC;
+        return __crypto_blkcipher_cast(crypto_spawn_tfm(spawn, type, mask));
+}
 static inline void *crypto_blkcipher_ctx(struct crypto_blkcipher *tfm)
 {
        return crypto_tfm_ctx(&tfm->base);
@@ -170,5 +216,35 @@ static inline void blkcipher_walk_init(struct blkcipher_walk *walk,
        walk->total = nbytes;
 }
+static inline struct crypto_async_request *crypto_get_backlog(
+        struct crypto_queue *queue)
+{
+        return queue->backlog == &queue->list ? NULL :
+               container_of(queue->backlog, struct crypto_async_request, list);
+}
+static inline int ablkcipher_enqueue_request(struct ablkcipher_alg *alg,
+                                             struct ablkcipher_request *request)
+{
+        return crypto_enqueue_request(alg->queue, &request->base);
+}
+static inline struct ablkcipher_request *ablkcipher_dequeue_request(
+        struct ablkcipher_alg *alg)
+{
+        return ablkcipher_request_cast(crypto_dequeue_request(alg->queue));
+}
+static inline void *ablkcipher_request_ctx(struct ablkcipher_request *req)
+{
+        return req->__ctx;
+}
+static inline int ablkcipher_tfm_in_queue(struct crypto_ablkcipher *tfm)
+{
+        return crypto_tfm_in_queue(crypto_ablkcipher_alg(tfm)->queue,
+                                   crypto_ablkcipher_tfm(tfm));
+}
 #endif  /* _CRYPTO_ALGAPI_H */
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index cb9b2ec8849c..963051a967d6 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -265,7 +265,6 @@ struct freq_attr {
 /*********************************************************************
 *                        CPUFREQ 2.6. INTERFACE                     *
 *********************************************************************/
-int cpufreq_set_policy(struct cpufreq_policy *policy);
 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
 int cpufreq_update_policy(unsigned int cpu);
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index 779aa78ee643..0de7e2ace822 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -56,6 +56,7 @@
 #define CRYPTO_TFM_REQ_WEAK_KEY         0x00000100
 #define CRYPTO_TFM_REQ_MAY_SLEEP        0x00000200
+#define CRYPTO_TFM_REQ_MAY_BACKLOG      0x00000400
 #define CRYPTO_TFM_RES_WEAK_KEY         0x00100000
 #define CRYPTO_TFM_RES_BAD_KEY_LEN      0x00200000
 #define CRYPTO_TFM_RES_BAD_KEY_SCHED    0x00400000
@@ -88,11 +89,38 @@
 #endif
 struct scatterlist;
+struct crypto_ablkcipher;
+struct crypto_async_request;
 struct crypto_blkcipher;
 struct crypto_hash;
+struct crypto_queue;
 struct crypto_tfm;
 struct crypto_type;
+typedef void (*crypto_completion_t)(struct crypto_async_request *req, int err);
+struct crypto_async_request {
+        struct list_head list;
+        crypto_completion_t complete;
+        void *data;
+        struct crypto_tfm *tfm;
+        u32 flags;
+};
+struct ablkcipher_request {
+        struct crypto_async_request base;
+        unsigned int nbytes;
+        void *info;
+        struct scatterlist *src;
+        struct scatterlist *dst;
+        void *__ctx[] CRYPTO_MINALIGN_ATTR;
+};
 struct blkcipher_desc {
        struct crypto_blkcipher *tfm;
        void *info;
@@ -116,6 +144,19 @@ struct hash_desc {
 * Algorithms: modular crypto algorithm implementations, managed
 * via crypto_register_alg() and crypto_unregister_alg().
 */
+struct ablkcipher_alg {
+        int (*setkey)(struct crypto_ablkcipher *tfm, const u8 *key,
+                      unsigned int keylen);
+        int (*encrypt)(struct ablkcipher_request *req);
+        int (*decrypt)(struct ablkcipher_request *req);
+        struct crypto_queue *queue;
+        unsigned int min_keysize;
+        unsigned int max_keysize;
+        unsigned int ivsize;
+};
 struct blkcipher_alg {
        int (*setkey)(struct crypto_tfm *tfm, const u8 *key,
                      unsigned int keylen);
@@ -170,6 +211,7 @@ struct compress_alg {
                              unsigned int slen, u8 *dst, unsigned int *dlen);
 };
+#define cra_ablkcipher  cra_u.ablkcipher
 #define cra_blkcipher   cra_u.blkcipher
 #define cra_cipher      cra_u.cipher
 #define cra_digest      cra_u.digest
@@ -194,6 +236,7 @@ struct crypto_alg {
        const struct crypto_type *cra_type;
        union {
+                struct ablkcipher_alg ablkcipher;
                struct blkcipher_alg blkcipher;
                struct cipher_alg cipher;
                struct digest_alg digest;
@@ -232,6 +275,15 @@ static inline int crypto_has_alg(const char *name, u32 type, u32 mask)
 * crypto_free_*(), as well as the various helpers below.
 */
+struct ablkcipher_tfm {
+        int (*setkey)(struct crypto_ablkcipher *tfm, const u8 *key,
+                      unsigned int keylen);
+        int (*encrypt)(struct ablkcipher_request *req);
+        int (*decrypt)(struct ablkcipher_request *req);
+        unsigned int ivsize;
+        unsigned int reqsize;
+};
 struct blkcipher_tfm {
        void *iv;
        int (*setkey)(struct crypto_tfm *tfm, const u8 *key,
@@ -290,6 +342,7 @@ struct compress_tfm {
                              u8 *dst, unsigned int *dlen);
 };
+#define crt_ablkcipher  crt_u.ablkcipher
 #define crt_blkcipher   crt_u.blkcipher
 #define crt_cipher      crt_u.cipher
 #define crt_hash        crt_u.hash
@@ -300,6 +353,7 @@ struct crypto_tfm {
        u32 crt_flags;
        
        union {
+                struct ablkcipher_tfm ablkcipher;
                struct blkcipher_tfm blkcipher;
                struct cipher_tfm cipher;
                struct hash_tfm hash;
@@ -311,6 +365,10 @@ struct crypto_tfm {
        void *__crt_ctx[] CRYPTO_MINALIGN_ATTR;
 };
+struct crypto_ablkcipher {
+        struct crypto_tfm base;
+};
 struct crypto_blkcipher {
        struct crypto_tfm base;
 };
@@ -330,12 +388,21 @@ struct crypto_hash {
 enum {
        CRYPTOA_UNSPEC,
        CRYPTOA_ALG,
+        CRYPTOA_TYPE,
+        __CRYPTOA_MAX,
 };
+#define CRYPTOA_MAX (__CRYPTOA_MAX - 1)
 struct crypto_attr_alg {
        char name[CRYPTO_MAX_ALG_NAME];
 };
+struct crypto_attr_type {
+        u32 type;
+        u32 mask;
+};
 /* 
 * Transform user interface.
 */
@@ -411,6 +478,167 @@ static inline unsigned int crypto_tfm_ctx_alignment(void)
 /*
 * API wrappers.
 */
+static inline struct crypto_ablkcipher *__crypto_ablkcipher_cast(
+        struct crypto_tfm *tfm)
+{
+        return (struct crypto_ablkcipher *)tfm;
+}
+static inline struct crypto_ablkcipher *crypto_alloc_ablkcipher(
+        const char *alg_name, u32 type, u32 mask)
+{
+        type &= ~CRYPTO_ALG_TYPE_MASK;
+        type |= CRYPTO_ALG_TYPE_BLKCIPHER;
+        mask |= CRYPTO_ALG_TYPE_MASK;
+        return __crypto_ablkcipher_cast(
+                crypto_alloc_base(alg_name, type, mask));
+}
+static inline struct crypto_tfm *crypto_ablkcipher_tfm(
+        struct crypto_ablkcipher *tfm)
+{
+        return &tfm->base;
+}
+static inline void crypto_free_ablkcipher(struct crypto_ablkcipher *tfm)
+{
+        crypto_free_tfm(crypto_ablkcipher_tfm(tfm));
+}
+static inline int crypto_has_ablkcipher(const char *alg_name, u32 type,
+                                        u32 mask)
+{
+        type &= ~CRYPTO_ALG_TYPE_MASK;
+        type |= CRYPTO_ALG_TYPE_BLKCIPHER;
+        mask |= CRYPTO_ALG_TYPE_MASK;
+        return crypto_has_alg(alg_name, type, mask);
+}
+static inline struct ablkcipher_tfm *crypto_ablkcipher_crt(
+        struct crypto_ablkcipher *tfm)
+{
+        return &crypto_ablkcipher_tfm(tfm)->crt_ablkcipher;
+}
+static inline unsigned int crypto_ablkcipher_ivsize(
+        struct crypto_ablkcipher *tfm)
+{
+        return crypto_ablkcipher_crt(tfm)->ivsize;
+}
+static inline unsigned int crypto_ablkcipher_blocksize(
+        struct crypto_ablkcipher *tfm)
+{
+        return crypto_tfm_alg_blocksize(crypto_ablkcipher_tfm(tfm));
+}
+static inline unsigned int crypto_ablkcipher_alignmask(
+        struct crypto_ablkcipher *tfm)
+{
+        return crypto_tfm_alg_alignmask(crypto_ablkcipher_tfm(tfm));
+}
+static inline u32 crypto_ablkcipher_get_flags(struct crypto_ablkcipher *tfm)
+{
+        return crypto_tfm_get_flags(crypto_ablkcipher_tfm(tfm));
+}
+static inline void crypto_ablkcipher_set_flags(struct crypto_ablkcipher *tfm,
+                                               u32 flags)
+{
+        crypto_tfm_set_flags(crypto_ablkcipher_tfm(tfm), flags);
+}
+static inline void crypto_ablkcipher_clear_flags(struct crypto_ablkcipher *tfm,
+                                                 u32 flags)
+{
+        crypto_tfm_clear_flags(crypto_ablkcipher_tfm(tfm), flags);
+}
+static inline int crypto_ablkcipher_setkey(struct crypto_ablkcipher *tfm,
+                                           const u8 *key, unsigned int keylen)
+{
+        return crypto_ablkcipher_crt(tfm)->setkey(tfm, key, keylen);
+}
+static inline struct crypto_ablkcipher *crypto_ablkcipher_reqtfm(
+        struct ablkcipher_request *req)
+{
+        return __crypto_ablkcipher_cast(req->base.tfm);
+}
+static inline int crypto_ablkcipher_encrypt(struct ablkcipher_request *req)
+{
+        struct ablkcipher_tfm *crt =
+                crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
+        return crt->encrypt(req);
+}
+static inline int crypto_ablkcipher_decrypt(struct ablkcipher_request *req)
+{
+        struct ablkcipher_tfm *crt =
+                crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
+        return crt->decrypt(req);
+}
+static inline int crypto_ablkcipher_reqsize(struct crypto_ablkcipher *tfm)
+{
+        return crypto_ablkcipher_crt(tfm)->reqsize;
+}
+static inline void ablkcipher_request_set_tfm(
+        struct ablkcipher_request *req, struct crypto_ablkcipher *tfm)
+{
+        req->base.tfm = crypto_ablkcipher_tfm(tfm);
+}
+static inline struct ablkcipher_request *ablkcipher_request_cast(
+        struct crypto_async_request *req)
+{
+        return container_of(req, struct ablkcipher_request, base);
+}
+static inline struct ablkcipher_request *ablkcipher_request_alloc(
+        struct crypto_ablkcipher *tfm, gfp_t gfp)
+{
+        struct ablkcipher_request *req;
+        req = kmalloc(sizeof(struct ablkcipher_request) +
+                      crypto_ablkcipher_reqsize(tfm), gfp);
+        if (likely(req))
+                ablkcipher_request_set_tfm(req, tfm);
+        return req;
+}
+static inline void ablkcipher_request_free(struct ablkcipher_request *req)
+{
+        kfree(req);
+}
+static inline void ablkcipher_request_set_callback(
+        struct ablkcipher_request *req,
+        u32 flags, crypto_completion_t complete, void *data)
+{
+        req->base.complete = complete;
+        req->base.data = data;
+        req->base.flags = flags;
+}
+static inline void ablkcipher_request_set_crypt(
+        struct ablkcipher_request *req,
+        struct scatterlist *src, struct scatterlist *dst,
+        unsigned int nbytes, void *iv)
+{
+        req->src = src;
+        req->dst = dst;
+        req->nbytes = nbytes;
+        req->info = iv;
+}
 static inline struct crypto_blkcipher *__crypto_blkcipher_cast(
        struct crypto_tfm *tfm)
 {
@@ -427,9 +655,9 @@ static inline struct crypto_blkcipher *crypto_blkcipher_cast(
 static inline struct crypto_blkcipher *crypto_alloc_blkcipher(
        const char *alg_name, u32 type, u32 mask)
 {
-        type &= ~CRYPTO_ALG_TYPE_MASK;
+        type &= ~(CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC);
        type |= CRYPTO_ALG_TYPE_BLKCIPHER;
-        mask |= CRYPTO_ALG_TYPE_MASK;
+        mask |= CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC;
        return __crypto_blkcipher_cast(crypto_alloc_base(alg_name, type, mask));
 }
@@ -447,9 +675,9 @@ static inline void crypto_free_blkcipher(struct crypto_blkcipher *tfm)
 static inline int crypto_has_blkcipher(const char *alg_name, u32 type, u32 mask)
 {
-        type &= ~CRYPTO_ALG_TYPE_MASK;
+        type &= ~(CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC);
        type |= CRYPTO_ALG_TYPE_BLKCIPHER;
-        mask |= CRYPTO_ALG_TYPE_MASK;
+        mask |= CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC;
        return crypto_has_alg(alg_name, type, mask);
 }
diff --git a/include/linux/device.h b/include/linux/device.h
index a0cd2ced31a9..6579068134d1 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -53,7 +53,7 @@ struct bus_type {
        const char              * name;
        struct module           * owner;
-        struct subsystem        subsys;
+        struct kset             subsys;
        struct kset             drivers;
        struct kset             devices;
        struct klist            klist_devices;
@@ -80,7 +80,6 @@ struct bus_type {
        int (*resume)(struct device * dev);
        unsigned int drivers_autoprobe:1;
-        unsigned int multithread_probe:1;
 };
 extern int __must_check bus_register(struct bus_type * bus);
@@ -179,7 +178,7 @@ struct class {
        const char              * name;
        struct module           * owner;
-        struct subsystem        subsys;
+        struct kset             subsys;
        struct list_head        children;
        struct list_head        devices;
        struct list_head        interfaces;
@@ -559,8 +558,8 @@ extern void device_shutdown(void);
 /* drivers/base/firmware.c */
-extern int __must_check firmware_register(struct subsystem *);
+extern int __must_check firmware_register(struct kset *);
-extern void firmware_unregister(struct subsystem *);
+extern void firmware_unregister(struct kset *);
 /* debugging and troubleshooting/diagnostic helpers. */
 extern const char *dev_driver_string(struct device *dev);
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index c6310aef5ab0..f2d248f8cc92 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -434,6 +434,7 @@ struct ethtool_ops {
 #define SUPPORTED_10000baseT_Full       (1 << 12)
 #define SUPPORTED_Pause                 (1 << 13)
 #define SUPPORTED_Asym_Pause            (1 << 14)
+#define SUPPORTED_2500baseX_Full        (1 << 15)
 /* Indicates what features are advertised by the interface. */
 #define ADVERTISED_10baseT_Half         (1 << 0)
@@ -451,6 +452,7 @@ struct ethtool_ops {
 #define ADVERTISED_10000baseT_Full      (1 << 12)
 #define ADVERTISED_Pause                (1 << 13)
 #define ADVERTISED_Asym_Pause           (1 << 14)
+#define ADVERTISED_2500baseX_Full       (1 << 15)
 /* The following are all involved in forcing a particular link
 * mode for the device for setting things.  When getting the
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 095a9c9a64fb..7c0077f06e24 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1416,7 +1416,7 @@ extern void mnt_set_mountpoint(struct vfsmount *, struct dentry *,
 extern int vfs_statfs(struct dentry *, struct kstatfs *);
 /* /sys/fs */
-extern struct subsystem fs_subsys;
+extern struct kset fs_subsys;
 #define FLOCK_VERIFY_READ  1
 #define FLOCK_VERIFY_WRITE 2
diff --git a/include/linux/gpio_keys.h b/include/linux/gpio_keys.h
index 2b217c7b9312..265d17830a0f 100644
--- a/include/linux/gpio_keys.h
+++ b/include/linux/gpio_keys.h
@@ -3,10 +3,11 @@
 struct gpio_keys_button {
        /* Configuration parameters */
-        int keycode;
+        int code;               /* input event code (KEY_*, SW_*) */
        int gpio;
        int active_low;
        char *desc;
+        int type;               /* input event type (EV_KEY, EV_SW) */
 };
 struct gpio_keys_platform_data {
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index bca8e2dfa355..a515eb0afdfb 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -44,8 +44,13 @@ static inline void *kmap(struct page *page)
 #define kunmap(page) do { (void) (page); } while (0)
-#define kmap_atomic(page, idx) \
+#include <asm/kmap_types.h>
-        ({ pagefault_disable(); page_address(page); })
+static inline void *kmap_atomic(struct page *page, enum km_type idx)
+{
+        pagefault_disable();
+        return page_address(page);
+}
 #define kmap_atomic_prot(page, idx, prot)       kmap_atomic(page, idx)
 #define kunmap_atomic(addr, idx)        do { pagefault_enable(); } while (0)
diff --git a/include/linux/hp_sdc.h b/include/linux/hp_sdc.h
index debd71515312..9db3d454887f 100644
--- a/include/linux/hp_sdc.h
+++ b/include/linux/hp_sdc.h
@@ -71,6 +71,7 @@ typedef struct {
          struct semaphore *semaphore;  /* Semaphore to sleep on. */
        } act;
 } hp_sdc_transaction;
+int __hp_sdc_enqueue_transaction(hp_sdc_transaction *this);
 int hp_sdc_enqueue_transaction(hp_sdc_transaction *this);
 int hp_sdc_dequeue_transaction(hp_sdc_transaction *this);
diff --git a/include/linux/i2c-algo-bit.h b/include/linux/i2c-algo-bit.h
index 937da70cb4c4..9ee0f800592f 100644
--- a/include/linux/i2c-algo-bit.h
+++ b/include/linux/i2c-algo-bit.h
@@ -38,11 +38,14 @@ struct i2c_algo_bit_data {
        int  (*getscl) (void *data);
        /* local settings */
-        int udelay;             /* half-clock-cycle time in microsecs */
+        int udelay;             /* half clock cycle time in us,
-                                /* i.e. clock is (500 / udelay) KHz */
+                                   minimum 2 us for fast-mode I2C,
+                                   minimum 5 us for standard-mode I2C and SMBus,
+                                   maximum 50 us for SMBus */
        int timeout;            /* in jiffies */
 };
 int i2c_bit_add_bus(struct i2c_adapter *);
+int i2c_bit_add_numbered_bus(struct i2c_adapter *);
 #endif /* _LINUX_I2C_ALGO_BIT_H */
diff --git a/include/linux/i2c-gpio.h b/include/linux/i2c-gpio.h
new file mode 100644
index 000000000000..c1bcb1f1d73b
--- /dev/null
+++ b/include/linux/i2c-gpio.h
@@ -0,0 +1,38 @@
+/*
+ * i2c-gpio interface to platform code
+ *
+ * Copyright (C) 2007 Atmel 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.
+ */
+#ifndef _LINUX_I2C_GPIO_H
+#define _LINUX_I2C_GPIO_H
+/**
+ * struct i2c_gpio_platform_data - Platform-dependent data for i2c-gpio
+ * @sda_pin: GPIO pin ID to use for SDA
+ * @scl_pin: GPIO pin ID to use for SCL
+ * @udelay: signal toggle delay. SCL frequency is (500 / udelay) kHz
+ * @timeout: clock stretching timeout in jiffies. If the slave keeps
+ *      SCL low for longer than this, the transfer will time out.
+ * @sda_is_open_drain: SDA is configured as open drain, i.e. the pin
+ *      isn't actively driven high when setting the output value high.
+ *      gpio_get_value() must return the actual pin state even if the
+ *      pin is configured as an output.
+ * @scl_is_open_drain: SCL is set up as open drain. Same requirements
+ *      as for sda_is_open_drain apply.
+ * @scl_is_output_only: SCL output drivers cannot be turned off.
+ */
+struct i2c_gpio_platform_data {
+        unsigned int    sda_pin;
+        unsigned int    scl_pin;
+        int             udelay;
+        int             timeout;
+        unsigned int    sda_is_open_drain:1;
+        unsigned int    scl_is_open_drain:1;
+        unsigned int    scl_is_output_only:1;
+};
+#endif /* _LINUX_I2C_GPIO_H */
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
index 9c21dc793d7b..0e8da684ce68 100644
--- a/include/linux/i2c-id.h
+++ b/include/linux/i2c-id.h
@@ -258,8 +258,9 @@
 /* --- MCP107 adapter */
 #define I2C_HW_MPC107           0x0d0000
-/* --- Marvell mv64xxx i2c adapter */
+/* --- Embedded adapters */
 #define I2C_HW_MV64XXX          0x190000
+#define I2C_HW_BLACKFIN         0x190001 /* ADI Blackfin I2C TWI driver */
 /* --- Miscellaneous adapters */
 #define I2C_HW_SAA7146          0x060000 /* SAA7146 video decoder bus */
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 9428092017e3..cae7d618030c 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -35,11 +35,6 @@
 #include <linux/sched.h>        /* for completion */
 #include <linux/mutex.h>
-/* --- For i2c-isa ---------------------------------------------------- */
-extern void i2c_adapter_dev_release(struct device *dev);
-extern struct device_driver i2c_adapter_driver;
-extern struct class i2c_adapter_class;
 extern struct bus_type i2c_bus_type;
 /* --- General options ------------------------------------------------ */
@@ -87,6 +82,9 @@ extern s32 i2c_smbus_write_byte_data(struct i2c_client * client,
 extern s32 i2c_smbus_read_word_data(struct i2c_client * client, u8 command);
 extern s32 i2c_smbus_write_word_data(struct i2c_client * client,
                                     u8 command, u16 value);
+/* Returns the number of read bytes */
+extern s32 i2c_smbus_read_block_data(struct i2c_client *client,
+                                     u8 command, u8 *values);
 extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
                                      u8 command, u8 length,
                                      const u8 *values);
@@ -114,7 +112,7 @@ struct i2c_driver {
         * can be used by the driver to test if the bus meets its conditions
         * & seek for the presence of the chip(s) it supports. If found, it
         * registers the client(s) that are on the bus to the i2c admin. via
-         * i2c_attach_client.
+         * i2c_attach_client.  (LEGACY I2C DRIVERS ONLY)
         */
        int (*attach_adapter)(struct i2c_adapter *);
        int (*detach_adapter)(struct i2c_adapter *);
@@ -122,10 +120,17 @@ struct i2c_driver {
        /* tells the driver that a client is about to be deleted & gives it
         * the chance to remove its private data. Also, if the client struct
         * has been dynamically allocated by the driver in the function above,
-         * it must be freed here.
+         * it must be freed here.  (LEGACY I2C DRIVERS ONLY)
         */
        int (*detach_client)(struct i2c_client *);
+        /* Standard driver model interfaces, for "new style" i2c drivers.
+         * With the driver model, device enumeration is NEVER done by drivers;
+         * it's done by infrastructure.  (NEW STYLE DRIVERS ONLY)
+         */
+        int (*probe)(struct i2c_client *);
+        int (*remove)(struct i2c_client *);
        /* driver model interfaces that don't relate to enumeration  */
        void (*shutdown)(struct i2c_client *);
        int (*suspend)(struct i2c_client *, pm_message_t mesg);
@@ -141,25 +146,34 @@ struct i2c_driver {
 };
 #define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)
-#define I2C_NAME_SIZE   50
+#define I2C_NAME_SIZE   20
-/*
+/**
- * i2c_client identifies a single device (i.e. chip) that is connected to an
+ * struct i2c_client - represent an I2C slave device
- * i2c bus. The behaviour is defined by the routines of the driver. This
+ * @addr: Address used on the I2C bus connected to the parent adapter.
- * function is mainly used for lookup & other admin. functions.
+ * @name: Indicates the type of the device, usually a chip name that's
+ *      generic enough to hide second-sourcing and compatible revisions.
+ * @dev: Driver model device node for the slave.
+ * @driver_name: Identifies new-style driver used with this device; also
+ *      used as the module name for hotplug/coldplug modprobe support.
+ *
+ * An i2c_client identifies a single device (i.e. chip) connected to an
+ * i2c bus. The behaviour is defined by the routines of the driver.
 */
 struct i2c_client {
-        unsigned int flags;             /* div., see below              */
+        unsigned short flags;           /* div., see below              */
        unsigned short addr;            /* chip address - NOTE: 7bit    */
                                        /* addresses are stored in the  */
                                        /* _LOWER_ 7 bits               */
+        char name[I2C_NAME_SIZE];
        struct i2c_adapter *adapter;    /* the adapter we sit on        */
        struct i2c_driver *driver;      /* and our access routines      */
        int usage_count;                /* How many accesses currently  */
                                        /* to the client                */
        struct device dev;              /* the device structure         */
+        int irq;                        /* irq issued by device (or -1) */
+        char driver_name[KOBJ_NAME_LEN];
        struct list_head list;
-        char name[I2C_NAME_SIZE];
        struct completion released;
 };
 #define to_i2c_client(d) container_of(d, struct i2c_client, dev)
@@ -179,6 +193,76 @@ static inline void i2c_set_clientdata (struct i2c_client *dev, void *data)
        dev_set_drvdata (&dev->dev, data);
 }
+/**
+ * struct i2c_board_info - template for device creation
+ * @driver_name: identifies the driver to be bound to the device
+ * @type: optional chip type information, to initialize i2c_client.name
+ * @flags: to initialize i2c_client.flags
+ * @addr: stored in i2c_client.addr
+ * @platform_data: stored in i2c_client.dev.platform_data
+ * @irq: stored in i2c_client.irq
+ * I2C doesn't actually support hardware probing, although controllers and
+ * devices may be able to use I2C_SMBUS_QUICK to tell whether or not there's
+ * a device at a given address.  Drivers commonly need more information than
+ * that, such as chip type, configuration, associated IRQ, and so on.
+ *
+ * i2c_board_info is used to build tables of information listing I2C devices
+ * that are present.  This information is used to grow the driver model tree
+ * for "new style" I2C drivers.  For mainboards this is done statically using
+ * i2c_register_board_info(), where @bus_num represents an adapter that isn't
+ * yet available.  For add-on boards, i2c_new_device() does this dynamically
+ * with the adapter already known.
+ */
+struct i2c_board_info {
+        char            driver_name[KOBJ_NAME_LEN];
+        char            type[I2C_NAME_SIZE];
+        unsigned short  flags;
+        unsigned short  addr;
+        void            *platform_data;
+        int             irq;
+};
+/**
+ * I2C_BOARD_INFO - macro used to list an i2c device and its driver
+ * @driver: identifies the driver to use with the device
+ * @dev_addr: the device's address on the bus.
+ *
+ * This macro initializes essential fields of a struct i2c_board_info,
+ * declaring what has been provided on a particular board.  Optional
+ * fields (such as the chip type, its associated irq, or device-specific
+ * platform_data) are provided using conventional syntax.
+ */
+#define I2C_BOARD_INFO(driver,dev_addr) \
+        .driver_name = (driver), .addr = (dev_addr)
+/* Add-on boards should register/unregister their devices; e.g. a board
+ * with integrated I2C, a config eeprom, sensors, and a codec that's
+ * used in conjunction with the primary hardware.
+ */
+extern struct i2c_client *
+i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info);
+/* If you don't know the exact address of an I2C device, use this variant
+ * instead, which can probe for device presence in a list of possible
+ * addresses.
+ */
+extern struct i2c_client *
+i2c_new_probed_device(struct i2c_adapter *adap,
+                      struct i2c_board_info *info,
+                      unsigned short const *addr_list);
+extern void i2c_unregister_device(struct i2c_client *);
+/* Mainboard arch_initcall() code should register all its I2C devices.
+ * This is done at arch_initcall time, before declaring any i2c adapters.
+ * Modules for add-on boards must use other calls.
+ */
+extern int
+i2c_register_board_info(int busnum, struct i2c_board_info const *info, unsigned n);
 /*
 * The following structs are for those who like to implement new bus drivers:
 * i2c_algorithm is the interface to a class of hardware solutions which can
@@ -228,17 +312,14 @@ struct i2c_adapter {
        int timeout;
        int retries;
        struct device dev;              /* the adapter device */
-        struct class_device class_dev;  /* the class device */
        int nr;
        struct list_head clients;
        struct list_head list;
-        char name[I2C_NAME_SIZE];
+        char name[48];
        struct completion dev_released;
-        struct completion class_dev_released;
 };
-#define dev_to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
+#define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
-#define class_dev_to_i2c_adapter(d) container_of(d, struct i2c_adapter, class_dev)
 static inline void *i2c_get_adapdata (struct i2c_adapter *dev)
 {
@@ -290,9 +371,10 @@ struct i2c_client_address_data {
 */
 extern int i2c_add_adapter(struct i2c_adapter *);
 extern int i2c_del_adapter(struct i2c_adapter *);
+extern int i2c_add_numbered_adapter(struct i2c_adapter *);
 extern int i2c_register_driver(struct module *, struct i2c_driver *);
-extern int i2c_del_driver(struct i2c_driver *);
+extern void i2c_del_driver(struct i2c_driver *);
 static inline int i2c_add_driver(struct i2c_driver *driver)
 {
@@ -365,6 +447,7 @@ struct i2c_msg {
 #define I2C_M_REV_DIR_ADDR      0x2000
 #define I2C_M_IGNORE_NAK        0x1000
 #define I2C_M_NO_RD_ACK         0x0800
+#define I2C_M_RECV_LEN          0x0400 /* length will be first received byte */
        __u16 len;              /* msg length                           */
        __u8 *buf;              /* pointer to msg data                  */
 };
diff --git a/include/linux/ide.h b/include/linux/ide.h
index d3bbc7188b6a..418dfb5adadd 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -613,7 +613,6 @@ typedef struct ide_drive_s {
        u8      quirk_list;     /* considered quirky, set for a specific host */
        u8      init_speed;     /* transfer rate set at boot */
-        u8      pio_speed;      /* unused by core, used by some drivers for fallback from DMA */
        u8      current_speed;  /* current transfer rate set */
        u8      desired_speed;  /* desired transfer rate set */
        u8      dn;             /* now wide spread use */
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
new file mode 100644
index 000000000000..ecd61e8438a5
--- /dev/null
+++ b/include/linux/ieee80211.h
@@ -0,0 +1,342 @@
+/*
+ * IEEE 802.11 defines
+ *
+ * Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
+ * <jkmaline@cc.hut.fi>
+ * Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.fi>
+ * Copyright (c) 2005, Devicescape Software, Inc.
+ * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef IEEE80211_H
+#define IEEE80211_H
+#include <linux/types.h>
+#define FCS_LEN 4
+#define IEEE80211_FCTL_VERS             0x0003
+#define IEEE80211_FCTL_FTYPE            0x000c
+#define IEEE80211_FCTL_STYPE            0x00f0
+#define IEEE80211_FCTL_TODS             0x0100
+#define IEEE80211_FCTL_FROMDS           0x0200
+#define IEEE80211_FCTL_MOREFRAGS        0x0400
+#define IEEE80211_FCTL_RETRY            0x0800
+#define IEEE80211_FCTL_PM               0x1000
+#define IEEE80211_FCTL_MOREDATA         0x2000
+#define IEEE80211_FCTL_PROTECTED        0x4000
+#define IEEE80211_FCTL_ORDER            0x8000
+#define IEEE80211_SCTL_FRAG             0x000F
+#define IEEE80211_SCTL_SEQ              0xFFF0
+#define IEEE80211_FTYPE_MGMT            0x0000
+#define IEEE80211_FTYPE_CTL             0x0004
+#define IEEE80211_FTYPE_DATA            0x0008
+/* management */
+#define IEEE80211_STYPE_ASSOC_REQ       0x0000
+#define IEEE80211_STYPE_ASSOC_RESP      0x0010
+#define IEEE80211_STYPE_REASSOC_REQ     0x0020
+#define IEEE80211_STYPE_REASSOC_RESP    0x0030
+#define IEEE80211_STYPE_PROBE_REQ       0x0040
+#define IEEE80211_STYPE_PROBE_RESP      0x0050
+#define IEEE80211_STYPE_BEACON          0x0080
+#define IEEE80211_STYPE_ATIM            0x0090
+#define IEEE80211_STYPE_DISASSOC        0x00A0
+#define IEEE80211_STYPE_AUTH            0x00B0
+#define IEEE80211_STYPE_DEAUTH          0x00C0
+#define IEEE80211_STYPE_ACTION          0x00D0
+/* control */
+#define IEEE80211_STYPE_PSPOLL          0x00A0
+#define IEEE80211_STYPE_RTS             0x00B0
+#define IEEE80211_STYPE_CTS             0x00C0
+#define IEEE80211_STYPE_ACK             0x00D0
+#define IEEE80211_STYPE_CFEND           0x00E0
+#define IEEE80211_STYPE_CFENDACK        0x00F0
+/* data */
+#define IEEE80211_STYPE_DATA                    0x0000
+#define IEEE80211_STYPE_DATA_CFACK              0x0010
+#define IEEE80211_STYPE_DATA_CFPOLL             0x0020
+#define IEEE80211_STYPE_DATA_CFACKPOLL          0x0030
+#define IEEE80211_STYPE_NULLFUNC                0x0040
+#define IEEE80211_STYPE_CFACK                   0x0050
+#define IEEE80211_STYPE_CFPOLL                  0x0060
+#define IEEE80211_STYPE_CFACKPOLL               0x0070
+#define IEEE80211_STYPE_QOS_DATA                0x0080
+#define IEEE80211_STYPE_QOS_DATA_CFACK          0x0090
+#define IEEE80211_STYPE_QOS_DATA_CFPOLL         0x00A0
+#define IEEE80211_STYPE_QOS_DATA_CFACKPOLL      0x00B0
+#define IEEE80211_STYPE_QOS_NULLFUNC            0x00C0
+#define IEEE80211_STYPE_QOS_CFACK               0x00D0
+#define IEEE80211_STYPE_QOS_CFPOLL              0x00E0
+#define IEEE80211_STYPE_QOS_CFACKPOLL           0x00F0
+/* miscellaneous IEEE 802.11 constants */
+#define IEEE80211_MAX_FRAG_THRESHOLD    2346
+#define IEEE80211_MAX_RTS_THRESHOLD     2347
+#define IEEE80211_MAX_AID               2007
+#define IEEE80211_MAX_TIM_LEN           251
+#define IEEE80211_MAX_DATA_LEN          2304
+/* Maximum size for the MA-UNITDATA primitive, 802.11 standard section
+   6.2.1.1.2.
+   The figure in section 7.1.2 suggests a body size of up to 2312
+   bytes is allowed, which is a bit confusing, I suspect this
+   represents the 2304 bytes of real data, plus a possible 8 bytes of
+   WEP IV and ICV. (this interpretation suggested by Ramiro Barreiro) */
+#define IEEE80211_MAX_SSID_LEN          32
+struct ieee80211_hdr {
+        __le16 frame_control;
+        __le16 duration_id;
+        u8 addr1[6];
+        u8 addr2[6];
+        u8 addr3[6];
+        __le16 seq_ctrl;
+        u8 addr4[6];
+} __attribute__ ((packed));
+struct ieee80211_mgmt {
+        __le16 frame_control;
+        __le16 duration;
+        u8 da[6];
+        u8 sa[6];
+        u8 bssid[6];
+        __le16 seq_ctrl;
+        union {
+                struct {
+                        __le16 auth_alg;
+                        __le16 auth_transaction;
+                        __le16 status_code;
+                        /* possibly followed by Challenge text */
+                        u8 variable[0];
+                } __attribute__ ((packed)) auth;
+                struct {
+                        __le16 reason_code;
+                } __attribute__ ((packed)) deauth;
+                struct {
+                        __le16 capab_info;
+                        __le16 listen_interval;
+                        /* followed by SSID and Supported rates */
+                        u8 variable[0];
+                } __attribute__ ((packed)) assoc_req;
+                struct {
+                        __le16 capab_info;
+                        __le16 status_code;
+                        __le16 aid;
+                        /* followed by Supported rates */
+                        u8 variable[0];
+                } __attribute__ ((packed)) assoc_resp, reassoc_resp;
+                struct {
+                        __le16 capab_info;
+                        __le16 listen_interval;
+                        u8 current_ap[6];
+                        /* followed by SSID and Supported rates */
+                        u8 variable[0];
+                } __attribute__ ((packed)) reassoc_req;
+                struct {
+                        __le16 reason_code;
+                } __attribute__ ((packed)) disassoc;
+                struct {
+                        __le64 timestamp;
+                        __le16 beacon_int;
+                        __le16 capab_info;
+                        /* followed by some of SSID, Supported rates,
+                         * FH Params, DS Params, CF Params, IBSS Params, TIM */
+                        u8 variable[0];
+                } __attribute__ ((packed)) beacon;
+                struct {
+                        /* only variable items: SSID, Supported rates */
+                        u8 variable[0];
+                } __attribute__ ((packed)) probe_req;
+                struct {
+                        __le64 timestamp;
+                        __le16 beacon_int;
+                        __le16 capab_info;
+                        /* followed by some of SSID, Supported rates,
+                         * FH Params, DS Params, CF Params, IBSS Params */
+                        u8 variable[0];
+                } __attribute__ ((packed)) probe_resp;
+                struct {
+                        u8 category;
+                        union {
+                                struct {
+                                        u8 action_code;
+                                        u8 dialog_token;
+                                        u8 status_code;
+                                        u8 variable[0];
+                                } __attribute__ ((packed)) wme_action;
+                                struct{
+                                        u8 action_code;
+                                        u8 element_id;
+                                        u8 length;
+                                        u8 switch_mode;
+                                        u8 new_chan;
+                                        u8 switch_count;
+                                } __attribute__((packed)) chan_switch;
+                        } u;
+                } __attribute__ ((packed)) action;
+        } u;
+} __attribute__ ((packed));
+/* Control frames */
+struct ieee80211_rts {
+        __le16 frame_control;
+        __le16 duration;
+        u8 ra[6];
+        u8 ta[6];
+} __attribute__ ((packed));
+struct ieee80211_cts {
+        __le16 frame_control;
+        __le16 duration;
+        u8 ra[6];
+} __attribute__ ((packed));
+/* Authentication algorithms */
+#define WLAN_AUTH_OPEN 0
+#define WLAN_AUTH_SHARED_KEY 1
+#define WLAN_AUTH_FAST_BSS_TRANSITION 2
+#define WLAN_AUTH_LEAP 128
+#define WLAN_AUTH_CHALLENGE_LEN 128
+#define WLAN_CAPABILITY_ESS             (1<<0)
+#define WLAN_CAPABILITY_IBSS            (1<<1)
+#define WLAN_CAPABILITY_CF_POLLABLE     (1<<2)
+#define WLAN_CAPABILITY_CF_POLL_REQUEST (1<<3)
+#define WLAN_CAPABILITY_PRIVACY         (1<<4)
+#define WLAN_CAPABILITY_SHORT_PREAMBLE  (1<<5)
+#define WLAN_CAPABILITY_PBCC            (1<<6)
+#define WLAN_CAPABILITY_CHANNEL_AGILITY (1<<7)
+/* 802.11h */
+#define WLAN_CAPABILITY_SPECTRUM_MGMT   (1<<8)
+#define WLAN_CAPABILITY_QOS             (1<<9)
+#define WLAN_CAPABILITY_SHORT_SLOT_TIME (1<<10)
+#define WLAN_CAPABILITY_DSSS_OFDM       (1<<13)
+/* Status codes */
+enum ieee80211_statuscode {
+        WLAN_STATUS_SUCCESS = 0,
+        WLAN_STATUS_UNSPECIFIED_FAILURE = 1,
+        WLAN_STATUS_CAPS_UNSUPPORTED = 10,
+        WLAN_STATUS_REASSOC_NO_ASSOC = 11,
+        WLAN_STATUS_ASSOC_DENIED_UNSPEC = 12,
+        WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG = 13,
+        WLAN_STATUS_UNKNOWN_AUTH_TRANSACTION = 14,
+        WLAN_STATUS_CHALLENGE_FAIL = 15,
+        WLAN_STATUS_AUTH_TIMEOUT = 16,
+        WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA = 17,
+        WLAN_STATUS_ASSOC_DENIED_RATES = 18,
+        /* 802.11b */
+        WLAN_STATUS_ASSOC_DENIED_NOSHORTPREAMBLE = 19,
+        WLAN_STATUS_ASSOC_DENIED_NOPBCC = 20,
+        WLAN_STATUS_ASSOC_DENIED_NOAGILITY = 21,
+        /* 802.11h */
+        WLAN_STATUS_ASSOC_DENIED_NOSPECTRUM = 22,
+        WLAN_STATUS_ASSOC_REJECTED_BAD_POWER = 23,
+        WLAN_STATUS_ASSOC_REJECTED_BAD_SUPP_CHAN = 24,
+        /* 802.11g */
+        WLAN_STATUS_ASSOC_DENIED_NOSHORTTIME = 25,
+        WLAN_STATUS_ASSOC_DENIED_NODSSSOFDM = 26,
+        /* 802.11i */
+        WLAN_STATUS_INVALID_IE = 40,
+        WLAN_STATUS_INVALID_GROUP_CIPHER = 41,
+        WLAN_STATUS_INVALID_PAIRWISE_CIPHER = 42,
+        WLAN_STATUS_INVALID_AKMP = 43,
+        WLAN_STATUS_UNSUPP_RSN_VERSION = 44,
+        WLAN_STATUS_INVALID_RSN_IE_CAP = 45,
+        WLAN_STATUS_CIPHER_SUITE_REJECTED = 46,
+};
+/* Reason codes */
+enum ieee80211_reasoncode {
+        WLAN_REASON_UNSPECIFIED = 1,
+        WLAN_REASON_PREV_AUTH_NOT_VALID = 2,
+        WLAN_REASON_DEAUTH_LEAVING = 3,
+        WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY = 4,
+        WLAN_REASON_DISASSOC_AP_BUSY = 5,
+        WLAN_REASON_CLASS2_FRAME_FROM_NONAUTH_STA = 6,
+        WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA = 7,
+        WLAN_REASON_DISASSOC_STA_HAS_LEFT = 8,
+        WLAN_REASON_STA_REQ_ASSOC_WITHOUT_AUTH = 9,
+        /* 802.11h */
+        WLAN_REASON_DISASSOC_BAD_POWER = 10,
+        WLAN_REASON_DISASSOC_BAD_SUPP_CHAN = 11,
+        /* 802.11i */
+        WLAN_REASON_INVALID_IE = 13,
+        WLAN_REASON_MIC_FAILURE = 14,
+        WLAN_REASON_4WAY_HANDSHAKE_TIMEOUT = 15,
+        WLAN_REASON_GROUP_KEY_HANDSHAKE_TIMEOUT = 16,
+        WLAN_REASON_IE_DIFFERENT = 17,
+        WLAN_REASON_INVALID_GROUP_CIPHER = 18,
+        WLAN_REASON_INVALID_PAIRWISE_CIPHER = 19,
+        WLAN_REASON_INVALID_AKMP = 20,
+        WLAN_REASON_UNSUPP_RSN_VERSION = 21,
+        WLAN_REASON_INVALID_RSN_IE_CAP = 22,
+        WLAN_REASON_IEEE8021X_FAILED = 23,
+        WLAN_REASON_CIPHER_SUITE_REJECTED = 24,
+};
+/* Information Element IDs */
+enum ieee80211_eid {
+        WLAN_EID_SSID = 0,
+        WLAN_EID_SUPP_RATES = 1,
+        WLAN_EID_FH_PARAMS = 2,
+        WLAN_EID_DS_PARAMS = 3,
+        WLAN_EID_CF_PARAMS = 4,
+        WLAN_EID_TIM = 5,
+        WLAN_EID_IBSS_PARAMS = 6,
+        WLAN_EID_CHALLENGE = 16,
+        /* 802.11d */
+        WLAN_EID_COUNTRY = 7,
+        WLAN_EID_HP_PARAMS = 8,
+        WLAN_EID_HP_TABLE = 9,
+        WLAN_EID_REQUEST = 10,
+        /* 802.11h */
+        WLAN_EID_PWR_CONSTRAINT = 32,
+        WLAN_EID_PWR_CAPABILITY = 33,
+        WLAN_EID_TPC_REQUEST = 34,
+        WLAN_EID_TPC_REPORT = 35,
+        WLAN_EID_SUPPORTED_CHANNELS = 36,
+        WLAN_EID_CHANNEL_SWITCH = 37,
+        WLAN_EID_MEASURE_REQUEST = 38,
+        WLAN_EID_MEASURE_REPORT = 39,
+        WLAN_EID_QUIET = 40,
+        WLAN_EID_IBSS_DFS = 41,
+        /* 802.11g */
+        WLAN_EID_ERP_INFO = 42,
+        WLAN_EID_EXT_SUPP_RATES = 50,
+        /* 802.11i */
+        WLAN_EID_RSN = 48,
+        WLAN_EID_WPA = 221,
+        WLAN_EID_GENERIC = 221,
+        WLAN_EID_VENDOR_SPECIFIC = 221,
+        WLAN_EID_QOS_PARAMETER = 222
+};
+/* cipher suite selectors */
+#define WLAN_CIPHER_SUITE_USE_GROUP     0x000FAC00
+#define WLAN_CIPHER_SUITE_WEP40         0x000FAC01
+#define WLAN_CIPHER_SUITE_TKIP          0x000FAC02
+/* reserved:                            0x000FAC03 */
+#define WLAN_CIPHER_SUITE_CCMP          0x000FAC04
+#define WLAN_CIPHER_SUITE_WEP104        0x000FAC05
+#define WLAN_MAX_KEY_LEN                32
+#endif /* IEEE80211_H */
diff --git a/include/linux/input-polldev.h b/include/linux/input-polldev.h
new file mode 100644
index 000000000000..597a0077b3c5
--- /dev/null
+++ b/include/linux/input-polldev.h
@@ -0,0 +1,46 @@
+#ifndef _INPUT_POLLDEV_H
+#define _INPUT_POLLDEV_H
+/*
+ * Copyright (c) 2007 Dmitry Torokhov
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ */
+#include <linux/input.h>
+#include <linux/workqueue.h>
+/**
+ * struct input_polled_dev - simple polled input device
+ * @private: private driver data
+ * @flush: driver-supplied method that flushes device's state upon
+ *      opening (optional)
+ * @poll: driver-supplied method that polls the device and posts
+ *      input events (mandatory).
+ * @poll_interval: specifies how often the poll() method shoudl be called.
+ * @input: input device structire associated with the polled device.
+ *      Must be properly initialized by the driver (id, name, phys, bits).
+ *
+ * Polled input device provides a skeleton for supporting simple input
+ * devices that do not raise interrupts but have to be periodically
+ * scanned or polled to detect changes in their state.
+ */
+struct input_polled_dev {
+        void *private;
+        void (*flush)(struct input_polled_dev *dev);
+        void (*poll)(struct input_polled_dev *dev);
+        unsigned int poll_interval; /* msec */
+        struct input_dev *input;
+        struct delayed_work work;
+};
+struct input_polled_dev *input_allocate_polled_device(void);
+void input_free_polled_device(struct input_polled_dev *dev);
+int input_register_polled_device(struct input_polled_dev *dev);
+void input_unregister_polled_device(struct input_polled_dev *dev);
+#endif
diff --git a/include/linux/input.h b/include/linux/input.h
index bde65c8a3519..439954d09752 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -506,6 +506,7 @@ struct input_absinfo {
 #define KEY_VOICEMAIL           0x1ac
 #define KEY_ADDRESSBOOK         0x1ad
 #define KEY_MESSENGER           0x1ae
+#define KEY_DISPLAYTOGGLE       0x1af   /* Turn display (LCD) on and off */
 #define KEY_DEL_EOL             0x1c0
 #define KEY_DEL_EOS             0x1c1
@@ -676,6 +677,7 @@ struct input_absinfo {
 #define BUS_I2C                 0x18
 #define BUS_HOST                0x19
 #define BUS_GSC                 0x1A
+#define BUS_ATARI               0x1B
 /*
 * Values describing the status of a force-feedback effect
@@ -913,33 +915,6 @@ struct ff_effect {
 #define BIT(x)  (1UL<<((x)%BITS_PER_LONG))
 #define LONG(x) ((x)/BITS_PER_LONG)
-#define INPUT_KEYCODE(dev, scancode) ((dev->keycodesize == 1) ? ((u8*)dev->keycode)[scancode] : \
-        ((dev->keycodesize == 2) ? ((u16*)dev->keycode)[scancode] : (((u32*)dev->keycode)[scancode])))
-#define SET_INPUT_KEYCODE(dev, scancode, val)                   \
-                ({      unsigned __old;                         \
-                switch (dev->keycodesize) {                     \
-                        case 1: {                               \
-                                u8 *k = (u8 *)dev->keycode;     \
-                                __old = k[scancode];            \
-                                k[scancode] = val;              \
-                                break;                          \
-                        }                                       \
-                        case 2: {                               \
-                                u16 *k = (u16 *)dev->keycode;   \
-                                __old = k[scancode];            \
-                                k[scancode] = val;              \
-                                break;                          \
-                        }                                       \
-                        default: {                              \
-                                u32 *k = (u32 *)dev->keycode;   \
-                                __old = k[scancode];            \
-                                k[scancode] = val;              \
-                                break;                          \
-                        }                                       \
-                }                                               \
-                __old; })
 struct input_dev {
        void *private;
@@ -962,6 +937,8 @@ struct input_dev {
        unsigned int keycodemax;
        unsigned int keycodesize;
        void *keycode;
+        int (*setkeycode)(struct input_dev *dev, int scancode, int keycode);
+        int (*getkeycode)(struct input_dev *dev, int scancode, int *keycode);
        struct ff_device *ff;
@@ -996,6 +973,9 @@ struct input_dev {
        unsigned int users;
        struct class_device cdev;
+        union {                 /* temporarily so while we switching to struct device */
+                struct device *parent;
+        } dev;
        struct list_head        h_list;
        struct list_head        node;
@@ -1074,7 +1054,7 @@ struct input_handler {
        void *private;
        void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
-        struct input_handle* (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
+        int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
        void (*disconnect)(struct input_handle *handle);
        void (*start)(struct input_handle *handle);
@@ -1104,7 +1084,7 @@ struct input_handle {
 };
 #define to_dev(n) container_of(n,struct input_dev,node)
-#define to_handler(n) container_of(n,struct input_handler,node);
+#define to_handler(n) container_of(n,struct input_handler,node)
 #define to_handle(n) container_of(n,struct input_handle,d_node)
 #define to_handle_h(n) container_of(n,struct input_handle,h_node)
@@ -1121,12 +1101,25 @@ static inline void input_put_device(struct input_dev *dev)
        class_device_put(&dev->cdev);
 }
+static inline void *input_get_drvdata(struct input_dev *dev)
+{
+        return dev->private;
+}
+static inline void input_set_drvdata(struct input_dev *dev, void *data)
+{
+        dev->private = data;
+}
 int input_register_device(struct input_dev *);
 void input_unregister_device(struct input_dev *);
 int input_register_handler(struct input_handler *);
 void input_unregister_handler(struct input_handler *);
+int input_register_handle(struct input_handle *);
+void input_unregister_handle(struct input_handle *);
 int input_grab_device(struct input_handle *);
 void input_release_device(struct input_handle *);
@@ -1168,6 +1161,8 @@ static inline void input_sync(struct input_dev *dev)
        input_event(dev, EV_SYN, SYN_REPORT, 0);
 }
+void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code);
 static inline void input_set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat)
 {
        dev->absmin[axis] = min;
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 838cf5a5bd7f..0319f665dd3f 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -185,10 +185,14 @@ static inline int disable_irq_wake(unsigned int irq)
 * validator need to define the methods below in their asm/irq.h
 * files, under an #ifdef CONFIG_LOCKDEP section.
 */
-# ifndef CONFIG_LOCKDEP
+#ifndef CONFIG_LOCKDEP
 #  define disable_irq_nosync_lockdep(irq)       disable_irq_nosync(irq)
+#  define disable_irq_nosync_lockdep_irqsave(irq, flags) \
+                                                disable_irq_nosync(irq)
 #  define disable_irq_lockdep(irq)              disable_irq(irq)
 #  define enable_irq_lockdep(irq)               enable_irq(irq)
+#  define enable_irq_lockdep_irqrestore(irq, flags) \
+                                                enable_irq(irq)
 # endif
 #endif /* CONFIG_GENERIC_HARDIRQS */
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
index eb0e63ef297f..c288e41ba331 100644
--- a/include/linux/kobject.h
+++ b/include/linux/kobject.h
@@ -124,7 +124,6 @@ struct kset_uevent_ops {
 };
 struct kset {
-        struct subsystem        * subsys;
        struct kobj_type        * ktype;
        struct list_head        list;
        spinlock_t              list_lock;
@@ -171,32 +170,23 @@ extern struct kobject * kset_find_obj(struct kset *, const char *);
 #define set_kset_name(str)      .kset = { .kobj = { .name = str } }
-struct subsystem {
-        struct kset             kset;
-};
 #define decl_subsys(_name,_type,_uevent_ops) \
-struct subsystem _name##_subsys = { \
+struct kset _name##_subsys = { \
-        .kset = { \
+        .kobj = { .name = __stringify(_name) }, \
-                .kobj = { .name = __stringify(_name) }, \
+        .ktype = _type, \
-                .ktype = _type, \
+        .uevent_ops =_uevent_ops, \
-                .uevent_ops =_uevent_ops, \
-        } \
 }
 #define decl_subsys_name(_varname,_name,_type,_uevent_ops) \
-struct subsystem _varname##_subsys = { \
+struct kset _varname##_subsys = { \
-        .kset = { \
+        .kobj = { .name = __stringify(_name) }, \
-                .kobj = { .name = __stringify(_name) }, \
+        .ktype = _type, \
-                .ktype = _type, \
+        .uevent_ops =_uevent_ops, \
-                .uevent_ops =_uevent_ops, \
-        } \
 }
 /* The global /sys/kernel/ subsystem for people to chain off of */
-extern struct subsystem kernel_subsys;
+extern struct kset kernel_subsys;
 /* The global /sys/hypervisor/ subsystem  */
-extern struct subsystem hypervisor_subsys;
+extern struct kset hypervisor_subsys;
 /**
 * Helpers for setting the kset of registered objects.
@@ -214,7 +204,7 @@ extern struct subsystem hypervisor_subsys;
 */
 #define kobj_set_kset_s(obj,subsys) \
-        (obj)->kobj.kset = &(subsys).kset
+        (obj)->kobj.kset = &(subsys)
 /**
 *      kset_set_kset_s(obj,subsys) - set kset for embedded kset.
@@ -228,7 +218,7 @@ extern struct subsystem hypervisor_subsys;
 */
 #define kset_set_kset_s(obj,subsys) \
-        (obj)->kset.kobj.kset = &(subsys).kset
+        (obj)->kset.kobj.kset = &(subsys)
 /**
 *      subsys_set_kset(obj,subsys) - set kset for subsystem
@@ -241,29 +231,31 @@ extern struct subsystem hypervisor_subsys;
 */
 #define subsys_set_kset(obj,_subsys) \
-        (obj)->subsys.kset.kobj.kset = &(_subsys).kset
+        (obj)->subsys.kobj.kset = &(_subsys)
-extern void subsystem_init(struct subsystem *);
+extern void subsystem_init(struct kset *);
-extern int __must_check subsystem_register(struct subsystem *);
+extern int __must_check subsystem_register(struct kset *);
-extern void subsystem_unregister(struct subsystem *);
+extern void subsystem_unregister(struct kset *);
-static inline struct subsystem * subsys_get(struct subsystem * s)
+static inline struct kset *subsys_get(struct kset *s)
 {
-        return s ? container_of(kset_get(&s->kset),struct subsystem,kset) : NULL;
+        if (s)
+                return kset_get(s);
+        return NULL;
 }
-static inline void subsys_put(struct subsystem * s)
+static inline void subsys_put(struct kset *s)
 {
-        kset_put(&s->kset);
+        kset_put(s);
 }
 struct subsys_attribute {
        struct attribute attr;
-        ssize_t (*show)(struct subsystem *, char *);
+        ssize_t (*show)(struct kset *, char *);
-        ssize_t (*store)(struct subsystem *, const char *, size_t); 
+        ssize_t (*store)(struct kset *, const char *, size_t);
 };
-extern int __must_check subsys_create_file(struct subsystem * ,
+extern int __must_check subsys_create_file(struct kset *,
                                        struct subsys_attribute *);
 #if defined(CONFIG_HOTPLUG)
diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
index ac25b5649c59..f6a81e0b1b93 100644
--- a/include/linux/lockd/lockd.h
+++ b/include/linux/lockd/lockd.h
@@ -88,7 +88,7 @@ struct nlm_wait;
 /*
 * Memory chunk for NLM client RPC request.
 */
-#define NLMCLNT_OHSIZE          (sizeof(utsname()->nodename)+10)
+#define NLMCLNT_OHSIZE          ((__NEW_UTS_LEN) + 10u)
 struct nlm_rqst {
        unsigned int            a_flags;        /* initial RPC task flags */
        struct nlm_host *       a_host;         /* host handle */
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index e45712acfac5..badf702fcff4 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -10,7 +10,7 @@
 #ifndef LINUX_MMC_CARD_H
 #define LINUX_MMC_CARD_H
-#include <linux/mmc/mmc.h>
+#include <linux/mmc/core.h>
 struct mmc_cid {
        unsigned int            manfid;
@@ -41,6 +41,7 @@ struct mmc_csd {
 struct mmc_ext_csd {
        unsigned int            hs_max_dtr;
+        unsigned int            sectors;
 };
 struct sd_scr {
@@ -60,18 +61,17 @@ struct mmc_host;
 * MMC device
 */
 struct mmc_card {
-        struct list_head        node;           /* node in hosts devices list */
        struct mmc_host         *host;          /* the host this device belongs to */
        struct device           dev;            /* the device */
        unsigned int            rca;            /* relative card address of device */
+        unsigned int            type;           /* card type */
+#define MMC_TYPE_MMC            0               /* MMC card */
+#define MMC_TYPE_SD             1               /* SD card */
        unsigned int            state;          /* (our) card state */
 #define MMC_STATE_PRESENT       (1<<0)          /* present in sysfs */
-#define MMC_STATE_DEAD          (1<<1)          /* device no longer in stack */
+#define MMC_STATE_READONLY      (1<<1)          /* card is read-only */
-#define MMC_STATE_BAD           (1<<2)          /* unrecognised device */
+#define MMC_STATE_HIGHSPEED     (1<<2)          /* card is in high speed mode */
-#define MMC_STATE_SDCARD        (1<<3)          /* is an SD card */
+#define MMC_STATE_BLOCKADDR     (1<<3)          /* card uses block-addressing */
-#define MMC_STATE_READONLY      (1<<4)          /* card is read-only */
-#define MMC_STATE_HIGHSPEED     (1<<5)          /* card is in high speed mode */
-#define MMC_STATE_BLOCKADDR     (1<<6)          /* card uses block-addressing */
        u32                     raw_cid[4];     /* raw card CID */
        u32                     raw_csd[4];     /* raw card CSD */
        u32                     raw_scr[2];     /* raw card SCR */
@@ -82,18 +82,15 @@ struct mmc_card {
        struct sd_switch_caps   sw_caps;        /* switch (CMD6) caps */
 };
+#define mmc_card_mmc(c)         ((c)->type == MMC_TYPE_MMC)
+#define mmc_card_sd(c)          ((c)->type == MMC_TYPE_SD)
 #define mmc_card_present(c)     ((c)->state & MMC_STATE_PRESENT)
-#define mmc_card_dead(c)        ((c)->state & MMC_STATE_DEAD)
-#define mmc_card_bad(c)         ((c)->state & MMC_STATE_BAD)
-#define mmc_card_sd(c)          ((c)->state & MMC_STATE_SDCARD)
 #define mmc_card_readonly(c)    ((c)->state & MMC_STATE_READONLY)
 #define mmc_card_highspeed(c)   ((c)->state & MMC_STATE_HIGHSPEED)
 #define mmc_card_blockaddr(c)   ((c)->state & MMC_STATE_BLOCKADDR)
 #define mmc_card_set_present(c) ((c)->state |= MMC_STATE_PRESENT)
-#define mmc_card_set_dead(c)    ((c)->state |= MMC_STATE_DEAD)
-#define mmc_card_set_bad(c)     ((c)->state |= MMC_STATE_BAD)
-#define mmc_card_set_sd(c)      ((c)->state |= MMC_STATE_SDCARD)
 #define mmc_card_set_readonly(c) ((c)->state |= MMC_STATE_READONLY)
 #define mmc_card_set_highspeed(c) ((c)->state |= MMC_STATE_HIGHSPEED)
 #define mmc_card_set_blockaddr(c) ((c)->state |= MMC_STATE_BLOCKADDR)
@@ -119,11 +116,4 @@ struct mmc_driver {
 extern int mmc_register_driver(struct mmc_driver *);
 extern void mmc_unregister_driver(struct mmc_driver *);
-static inline int mmc_card_claim_host(struct mmc_card *card)
-{
-        return __mmc_claim_host(card->host, card);
-}
-#define mmc_card_release_host(c)        mmc_release_host((c)->host)
 #endif
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
new file mode 100644
index 000000000000..04bbe12fae8d
--- /dev/null
+++ b/include/linux/mmc/core.h
@@ -0,0 +1,112 @@
+/*
+ *  linux/include/linux/mmc/core.h
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef LINUX_MMC_CORE_H
+#define LINUX_MMC_CORE_H
+#include <linux/interrupt.h>
+#include <linux/device.h>
+struct request;
+struct mmc_data;
+struct mmc_request;
+struct mmc_command {
+        u32                     opcode;
+        u32                     arg;
+        u32                     resp[4];
+        unsigned int            flags;          /* expected response type */
+#define MMC_RSP_PRESENT (1 << 0)
+#define MMC_RSP_136     (1 << 1)                /* 136 bit response */
+#define MMC_RSP_CRC     (1 << 2)                /* expect valid crc */
+#define MMC_RSP_BUSY    (1 << 3)                /* card may send busy */
+#define MMC_RSP_OPCODE  (1 << 4)                /* response contains opcode */
+#define MMC_CMD_MASK    (3 << 5)                /* command type */
+#define MMC_CMD_AC      (0 << 5)
+#define MMC_CMD_ADTC    (1 << 5)
+#define MMC_CMD_BC      (2 << 5)
+#define MMC_CMD_BCR     (3 << 5)
+/*
+ * These are the response types, and correspond to valid bit
+ * patterns of the above flags.  One additional valid pattern
+ * is all zeros, which means we don't expect a response.
+ */
+#define MMC_RSP_NONE    (0)
+#define MMC_RSP_R1      (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE)
+#define MMC_RSP_R1B     (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE|MMC_RSP_BUSY)
+#define MMC_RSP_R2      (MMC_RSP_PRESENT|MMC_RSP_136|MMC_RSP_CRC)
+#define MMC_RSP_R3      (MMC_RSP_PRESENT)
+#define MMC_RSP_R6      (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE)
+#define MMC_RSP_R7      (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE)
+#define mmc_resp_type(cmd)      ((cmd)->flags & (MMC_RSP_PRESENT|MMC_RSP_136|MMC_RSP_CRC|MMC_RSP_BUSY|MMC_RSP_OPCODE))
+/*
+ * These are the command types.
+ */
+#define mmc_cmd_type(cmd)       ((cmd)->flags & MMC_CMD_MASK)
+        unsigned int            retries;        /* max number of retries */
+        unsigned int            error;          /* command error */
+#define MMC_ERR_NONE    0
+#define MMC_ERR_TIMEOUT 1
+#define MMC_ERR_BADCRC  2
+#define MMC_ERR_FIFO    3
+#define MMC_ERR_FAILED  4
+#define MMC_ERR_INVALID 5
+        struct mmc_data         *data;          /* data segment associated with cmd */
+        struct mmc_request      *mrq;           /* associated request */
+};
+struct mmc_data {
+        unsigned int            timeout_ns;     /* data timeout (in ns, max 80ms) */
+        unsigned int            timeout_clks;   /* data timeout (in clocks) */
+        unsigned int            blksz;          /* data block size */
+        unsigned int            blocks;         /* number of blocks */
+        unsigned int            error;          /* data error */
+        unsigned int            flags;
+#define MMC_DATA_WRITE  (1 << 8)
+#define MMC_DATA_READ   (1 << 9)
+#define MMC_DATA_STREAM (1 << 10)
+#define MMC_DATA_MULTI  (1 << 11)
+        unsigned int            bytes_xfered;
+        struct mmc_command      *stop;          /* stop command */
+        struct mmc_request      *mrq;           /* associated request */
+        unsigned int            sg_len;         /* size of scatter list */
+        struct scatterlist      *sg;            /* I/O scatter list */
+};
+struct mmc_request {
+        struct mmc_command      *cmd;
+        struct mmc_data         *data;
+        struct mmc_command      *stop;
+        void                    *done_data;     /* completion data */
+        void                    (*done)(struct mmc_request *);/* completion function */
+};
+struct mmc_host;
+struct mmc_card;
+extern int mmc_wait_for_req(struct mmc_host *, struct mmc_request *);
+extern int mmc_wait_for_cmd(struct mmc_host *, struct mmc_command *, int);
+extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
+        struct mmc_command *, int);
+extern void mmc_set_data_timeout(struct mmc_data *, const struct mmc_card *, int);
+extern void mmc_claim_host(struct mmc_host *host);
+extern void mmc_release_host(struct mmc_host *host);
+#endif
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index bfcef8a1ad8b..b1350dfd3e91 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -10,36 +10,13 @@
 #ifndef LINUX_MMC_HOST_H
 #define LINUX_MMC_HOST_H
-#include <linux/mmc/mmc.h>
+#include <linux/mmc/core.h>
 struct mmc_ios {
        unsigned int    clock;                  /* clock rate */
        unsigned short  vdd;
-#define MMC_VDD_150     0
+/* vdd stores the bit number of the selected voltage range from below. */
-#define MMC_VDD_155     1
-#define MMC_VDD_160     2
-#define MMC_VDD_165     3
-#define MMC_VDD_170     4
-#define MMC_VDD_180     5
-#define MMC_VDD_190     6
-#define MMC_VDD_200     7
-#define MMC_VDD_210     8
-#define MMC_VDD_220     9
-#define MMC_VDD_230     10
-#define MMC_VDD_240     11
-#define MMC_VDD_250     12
-#define MMC_VDD_260     13
-#define MMC_VDD_270     14
-#define MMC_VDD_280     15
-#define MMC_VDD_290     16
-#define MMC_VDD_300     17
-#define MMC_VDD_310     18
-#define MMC_VDD_320     19
-#define MMC_VDD_330     20
-#define MMC_VDD_340     21
-#define MMC_VDD_350     22
-#define MMC_VDD_360     23
        unsigned char   bus_mode;               /* command output mode */
@@ -88,6 +65,24 @@ struct mmc_host {
        unsigned int            f_max;
        u32                     ocr_avail;
+#define MMC_VDD_165_195         0x00000080      /* VDD voltage 1.65 - 1.95 */
+#define MMC_VDD_20_21           0x00000100      /* VDD voltage 2.0 ~ 2.1 */
+#define MMC_VDD_21_22           0x00000200      /* VDD voltage 2.1 ~ 2.2 */
+#define MMC_VDD_22_23           0x00000400      /* VDD voltage 2.2 ~ 2.3 */
+#define MMC_VDD_23_24           0x00000800      /* VDD voltage 2.3 ~ 2.4 */
+#define MMC_VDD_24_25           0x00001000      /* VDD voltage 2.4 ~ 2.5 */
+#define MMC_VDD_25_26           0x00002000      /* VDD voltage 2.5 ~ 2.6 */
+#define MMC_VDD_26_27           0x00004000      /* VDD voltage 2.6 ~ 2.7 */
+#define MMC_VDD_27_28           0x00008000      /* VDD voltage 2.7 ~ 2.8 */
+#define MMC_VDD_28_29           0x00010000      /* VDD voltage 2.8 ~ 2.9 */
+#define MMC_VDD_29_30           0x00020000      /* VDD voltage 2.9 ~ 3.0 */
+#define MMC_VDD_30_31           0x00040000      /* VDD voltage 3.0 ~ 3.1 */
+#define MMC_VDD_31_32           0x00080000      /* VDD voltage 3.1 ~ 3.2 */
+#define MMC_VDD_32_33           0x00100000      /* VDD voltage 3.2 ~ 3.3 */
+#define MMC_VDD_33_34           0x00200000      /* VDD voltage 3.3 ~ 3.4 */
+#define MMC_VDD_34_35           0x00400000      /* VDD voltage 3.4 ~ 3.5 */
+#define MMC_VDD_35_36           0x00800000      /* VDD voltage 3.5 ~ 3.6 */
        unsigned long           caps;           /* Host capabilities */
 #define MMC_CAP_4_BIT_DATA      (1 << 0)        /* Can the host do 4 bit transfers */
@@ -106,6 +101,8 @@ struct mmc_host {
        unsigned int            max_blk_count;  /* maximum number of blocks in one req */
        /* private data */
+        spinlock_t              lock;           /* lock for claim and bus ops */
        struct mmc_ios          ios;            /* current io bus settings */
        u32                     ocr;            /* the current OCR setting */
@@ -113,15 +110,19 @@ struct mmc_host {
 #define MMC_MODE_MMC            0
 #define MMC_MODE_SD             1
-        struct list_head        cards;          /* devices attached to this host */
+        struct mmc_card         *card;          /* device attached to this host */
        wait_queue_head_t       wq;
-        spinlock_t              lock;           /* claimed lock */
        unsigned int            claimed:1;      /* host exclusively claimed */
-        struct mmc_card         *card_selected; /* the selected MMC card */
        struct delayed_work     detect;
+#ifdef CONFIG_MMC_DEBUG
+        unsigned int            removed:1;      /* host is being removed */
+#endif
+        const struct mmc_bus_ops *bus_ops;      /* current bus driver */
+        unsigned int            bus_refs;       /* reference counter */
+        unsigned int            bus_dead:1;     /* bus has been released */
        unsigned long           private[0] ____cacheline_aligned;
 };
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index cdc54be804f1..e3ed9b95040e 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -1,119 +1,257 @@
 /*
- *  linux/include/linux/mmc/mmc.h
+ * Header for MultiMediaCard (MMC)
 *
- * This program is free software; you can redistribute it and/or modify
+ * Copyright 2002 Hewlett-Packard Company
- * it under the terms of the GNU General Public License version 2 as
+ *
- * published by the Free Software Foundation.
+ * Use consistent with the GNU GPL is permitted,
+ * provided that this copyright notice is
+ * preserved in its entirety in all copies and derived works.
+ *
+ * HEWLETT-PACKARD COMPANY MAKES NO WARRANTIES, EXPRESSED OR IMPLIED,
+ * AS TO THE USEFULNESS OR CORRECTNESS OF THIS CODE OR ITS
+ * FITNESS FOR ANY PARTICULAR PURPOSE.
+ *
+ * Many thanks to Alessandro Rubini and Jonathan Corbet!
+ *
+ * Based strongly on code by:
+ *
+ * Author: Yong-iL Joh <tolkien@mizi.com>
+ * Date  : $Date: 2002/06/18 12:37:30 $
+ *
+ * Author:  Andrew Christian
+ *          15 May 2002
 */
-#ifndef MMC_H
-#define MMC_H
+#ifndef MMC_MMC_H
+#define MMC_MMC_H
-#include <linux/list.h>
-#include <linux/interrupt.h>
+/* Standard MMC commands (4.1)           type  argument     response */
-#include <linux/device.h>
+   /* class 1 */
+#define MMC_GO_IDLE_STATE         0   /* bc                          */
-struct request;
+#define MMC_SEND_OP_COND          1   /* bcr  [31:0] OCR         R3  */
-struct mmc_data;
+#define MMC_ALL_SEND_CID          2   /* bcr                     R2  */
-struct mmc_request;
+#define MMC_SET_RELATIVE_ADDR     3   /* ac   [31:16] RCA        R1  */
+#define MMC_SET_DSR               4   /* bc   [31:16] RCA            */
-struct mmc_command {
+#define MMC_SWITCH                6   /* ac   [31:0] See below   R1b */
-        u32                     opcode;
+#define MMC_SELECT_CARD           7   /* ac   [31:16] RCA        R1  */
-        u32                     arg;
+#define MMC_SEND_EXT_CSD          8   /* adtc                    R1  */
-        u32                     resp[4];
+#define MMC_SEND_CSD              9   /* ac   [31:16] RCA        R2  */
-        unsigned int            flags;          /* expected response type */
+#define MMC_SEND_CID             10   /* ac   [31:16] RCA        R2  */
-#define MMC_RSP_PRESENT (1 << 0)
+#define MMC_READ_DAT_UNTIL_STOP  11   /* adtc [31:0] dadr        R1  */
-#define MMC_RSP_136     (1 << 1)                /* 136 bit response */
+#define MMC_STOP_TRANSMISSION    12   /* ac                      R1b */
-#define MMC_RSP_CRC     (1 << 2)                /* expect valid crc */
+#define MMC_SEND_STATUS          13   /* ac   [31:16] RCA        R1  */
-#define MMC_RSP_BUSY    (1 << 3)                /* card may send busy */
+#define MMC_GO_INACTIVE_STATE    15   /* ac   [31:16] RCA            */
-#define MMC_RSP_OPCODE  (1 << 4)                /* response contains opcode */
-#define MMC_CMD_MASK    (3 << 5)                /* command type */
+  /* class 2 */
-#define MMC_CMD_AC      (0 << 5)
+#define MMC_SET_BLOCKLEN         16   /* ac   [31:0] block len   R1  */
-#define MMC_CMD_ADTC    (1 << 5)
+#define MMC_READ_SINGLE_BLOCK    17   /* adtc [31:0] data addr   R1  */
-#define MMC_CMD_BC      (2 << 5)
+#define MMC_READ_MULTIPLE_BLOCK  18   /* adtc [31:0] data addr   R1  */
-#define MMC_CMD_BCR     (3 << 5)
+  /* class 3 */
+#define MMC_WRITE_DAT_UNTIL_STOP 20   /* adtc [31:0] data addr   R1  */
+  /* class 4 */
+#define MMC_SET_BLOCK_COUNT      23   /* adtc [31:0] data addr   R1  */
+#define MMC_WRITE_BLOCK          24   /* adtc [31:0] data addr   R1  */
+#define MMC_WRITE_MULTIPLE_BLOCK 25   /* adtc                    R1  */
+#define MMC_PROGRAM_CID          26   /* adtc                    R1  */
+#define MMC_PROGRAM_CSD          27   /* adtc                    R1  */
+  /* class 6 */
+#define MMC_SET_WRITE_PROT       28   /* ac   [31:0] data addr   R1b */
+#define MMC_CLR_WRITE_PROT       29   /* ac   [31:0] data addr   R1b */
+#define MMC_SEND_WRITE_PROT      30   /* adtc [31:0] wpdata addr R1  */
+  /* class 5 */
+#define MMC_ERASE_GROUP_START    35   /* ac   [31:0] data addr   R1  */
+#define MMC_ERASE_GROUP_END      36   /* ac   [31:0] data addr   R1  */
+#define MMC_ERASE                38   /* ac                      R1b */
+  /* class 9 */
+#define MMC_FAST_IO              39   /* ac   <Complex>          R4  */
+#define MMC_GO_IRQ_STATE         40   /* bcr                     R5  */
+  /* class 7 */
+#define MMC_LOCK_UNLOCK          42   /* adtc                    R1b */
+  /* class 8 */
+#define MMC_APP_CMD              55   /* ac   [31:16] RCA        R1  */
+#define MMC_GEN_CMD              56   /* adtc [0] RD/WR          R1  */
 /*
- * These are the response types, and correspond to valid bit
+ * MMC_SWITCH argument format:
- * patterns of the above flags.  One additional valid pattern
+ *
- * is all zeros, which means we don't expect a response.
+ *      [31:26] Always 0
+ *      [25:24] Access Mode
+ *      [23:16] Location of target Byte in EXT_CSD
+ *      [15:08] Value Byte
+ *      [07:03] Always 0
+ *      [02:00] Command Set
 */
-#define MMC_RSP_NONE    (0)
-#define MMC_RSP_R1      (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE)
-#define MMC_RSP_R1B     (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE|MMC_RSP_BUSY)
-#define MMC_RSP_R2      (MMC_RSP_PRESENT|MMC_RSP_136|MMC_RSP_CRC)
-#define MMC_RSP_R3      (MMC_RSP_PRESENT)
-#define MMC_RSP_R6      (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE)
-#define MMC_RSP_R7      (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE)
-#define mmc_resp_type(cmd)      ((cmd)->flags & (MMC_RSP_PRESENT|MMC_RSP_136|MMC_RSP_CRC|MMC_RSP_BUSY|MMC_RSP_OPCODE))
 /*
- * These are the command types.
+  MMC status in R1
+  Type
+        e : error bit
+        s : status bit
+        r : detected and set for the actual command response
+        x : detected and set during command execution. the host must poll
+            the card by sending status command in order to read these bits.
+  Clear condition
+        a : according to the card state
+        b : always related to the previous command. Reception of
+            a valid command will clear it (with a delay of one command)
+        c : clear by read
 */
-#define mmc_cmd_type(cmd)       ((cmd)->flags & MMC_CMD_MASK)
-        unsigned int            retries;        /* max number of retries */
+#define R1_OUT_OF_RANGE         (1 << 31)       /* er, c */
-        unsigned int            error;          /* command error */
+#define R1_ADDRESS_ERROR        (1 << 30)       /* erx, c */
+#define R1_BLOCK_LEN_ERROR      (1 << 29)       /* er, c */
+#define R1_ERASE_SEQ_ERROR      (1 << 28)       /* er, c */
+#define R1_ERASE_PARAM          (1 << 27)       /* ex, c */
+#define R1_WP_VIOLATION         (1 << 26)       /* erx, c */
+#define R1_CARD_IS_LOCKED       (1 << 25)       /* sx, a */
+#define R1_LOCK_UNLOCK_FAILED   (1 << 24)       /* erx, c */
+#define R1_COM_CRC_ERROR        (1 << 23)       /* er, b */
+#define R1_ILLEGAL_COMMAND      (1 << 22)       /* er, b */
+#define R1_CARD_ECC_FAILED      (1 << 21)       /* ex, c */
+#define R1_CC_ERROR             (1 << 20)       /* erx, c */
+#define R1_ERROR                (1 << 19)       /* erx, c */
+#define R1_UNDERRUN             (1 << 18)       /* ex, c */
+#define R1_OVERRUN              (1 << 17)       /* ex, c */
+#define R1_CID_CSD_OVERWRITE    (1 << 16)       /* erx, c, CID/CSD overwrite */
+#define R1_WP_ERASE_SKIP        (1 << 15)       /* sx, c */
+#define R1_CARD_ECC_DISABLED    (1 << 14)       /* sx, a */
+#define R1_ERASE_RESET          (1 << 13)       /* sr, c */
+#define R1_STATUS(x)            (x & 0xFFFFE000)
+#define R1_CURRENT_STATE(x)     ((x & 0x00001E00) >> 9) /* sx, b (4 bits) */
+#define R1_READY_FOR_DATA       (1 << 8)        /* sx, a */
+#define R1_APP_CMD              (1 << 5)        /* sr, c */
-#define MMC_ERR_NONE    0
+/* These are unpacked versions of the actual responses */
-#define MMC_ERR_TIMEOUT 1
-#define MMC_ERR_BADCRC  2
-#define MMC_ERR_FIFO    3
-#define MMC_ERR_FAILED  4
-#define MMC_ERR_INVALID 5
-        struct mmc_data         *data;          /* data segment associated with cmd */
+struct _mmc_csd {
-        struct mmc_request      *mrq;           /* associated request */
+        u8  csd_structure;
+        u8  spec_vers;
+        u8  taac;
+        u8  nsac;
+        u8  tran_speed;
+        u16 ccc;
+        u8  read_bl_len;
+        u8  read_bl_partial;
+        u8  write_blk_misalign;
+        u8  read_blk_misalign;
+        u8  dsr_imp;
+        u16 c_size;
+        u8  vdd_r_curr_min;
+        u8  vdd_r_curr_max;
+        u8  vdd_w_curr_min;
+        u8  vdd_w_curr_max;
+        u8  c_size_mult;
+        union {
+                struct { /* MMC system specification version 3.1 */
+                        u8  erase_grp_size;
+                        u8  erase_grp_mult;
+                } v31;
+                struct { /* MMC system specification version 2.2 */
+                        u8  sector_size;
+                        u8  erase_grp_size;
+                } v22;
+        } erase;
+        u8  wp_grp_size;
+        u8  wp_grp_enable;
+        u8  default_ecc;
+        u8  r2w_factor;
+        u8  write_bl_len;
+        u8  write_bl_partial;
+        u8  file_format_grp;
+        u8  copy;
+        u8  perm_write_protect;
+        u8  tmp_write_protect;
+        u8  file_format;
+        u8  ecc;
 };
-struct mmc_data {
+/*
-        unsigned int            timeout_ns;     /* data timeout (in ns, max 80ms) */
+ * OCR bits are mostly in host.h
-        unsigned int            timeout_clks;   /* data timeout (in clocks) */
+ */
-        unsigned int            blksz;          /* data block size */
+#define MMC_CARD_BUSY   0x80000000      /* Card Power up status bit */
-        unsigned int            blocks;         /* number of blocks */
-        unsigned int            error;          /* data error */
-        unsigned int            flags;
-#define MMC_DATA_WRITE  (1 << 8)
+/*
-#define MMC_DATA_READ   (1 << 9)
+ * Card Command Classes (CCC)
-#define MMC_DATA_STREAM (1 << 10)
+ */
-#define MMC_DATA_MULTI  (1 << 11)
+#define CCC_BASIC               (1<<0)  /* (0) Basic protocol functions */
+                                        /* (CMD0,1,2,3,4,7,9,10,12,13,15) */
+#define CCC_STREAM_READ         (1<<1)  /* (1) Stream read commands */
+                                        /* (CMD11) */
+#define CCC_BLOCK_READ          (1<<2)  /* (2) Block read commands */
+                                        /* (CMD16,17,18) */
+#define CCC_STREAM_WRITE        (1<<3)  /* (3) Stream write commands */
+                                        /* (CMD20) */
+#define CCC_BLOCK_WRITE         (1<<4)  /* (4) Block write commands */
+                                        /* (CMD16,24,25,26,27) */
+#define CCC_ERASE               (1<<5)  /* (5) Ability to erase blocks */
+                                        /* (CMD32,33,34,35,36,37,38,39) */
+#define CCC_WRITE_PROT          (1<<6)  /* (6) Able to write protect blocks */
+                                        /* (CMD28,29,30) */
+#define CCC_LOCK_CARD           (1<<7)  /* (7) Able to lock down card */
+                                        /* (CMD16,CMD42) */
+#define CCC_APP_SPEC            (1<<8)  /* (8) Application specific */
+                                        /* (CMD55,56,57,ACMD*) */
+#define CCC_IO_MODE             (1<<9)  /* (9) I/O mode */
+                                        /* (CMD5,39,40,52,53) */
+#define CCC_SWITCH              (1<<10) /* (10) High speed switch */
+                                        /* (CMD6,34,35,36,37,50) */
+                                        /* (11) Reserved */
+                                        /* (CMD?) */
-        unsigned int            bytes_xfered;
+/*
+ * CSD field definitions
+ */
-        struct mmc_command      *stop;          /* stop command */
+#define CSD_STRUCT_VER_1_0  0           /* Valid for system specification 1.0 - 1.2 */
-        struct mmc_request      *mrq;           /* associated request */
+#define CSD_STRUCT_VER_1_1  1           /* Valid for system specification 1.4 - 2.2 */
+#define CSD_STRUCT_VER_1_2  2           /* Valid for system specification 3.1 - 3.2 - 3.31 - 4.0 - 4.1 */
+#define CSD_STRUCT_EXT_CSD  3           /* Version is coded in CSD_STRUCTURE in EXT_CSD */
-        unsigned int            sg_len;         /* size of scatter list */
+#define CSD_SPEC_VER_0      0           /* Implements system specification 1.0 - 1.2 */
-        struct scatterlist      *sg;            /* I/O scatter list */
+#define CSD_SPEC_VER_1      1           /* Implements system specification 1.4 */
-};
+#define CSD_SPEC_VER_2      2           /* Implements system specification 2.0 - 2.2 */
+#define CSD_SPEC_VER_3      3           /* Implements system specification 3.1 - 3.2 - 3.31 */
+#define CSD_SPEC_VER_4      4           /* Implements system specification 4.0 - 4.1 */
-struct mmc_request {
+/*
-        struct mmc_command      *cmd;
+ * EXT_CSD fields
-        struct mmc_data         *data;
+ */
-        struct mmc_command      *stop;
-        void                    *done_data;     /* completion data */
+#define EXT_CSD_BUS_WIDTH       183     /* R/W */
-        void                    (*done)(struct mmc_request *);/* completion function */
+#define EXT_CSD_HS_TIMING       185     /* R/W */
-};
+#define EXT_CSD_CARD_TYPE       196     /* RO */
+#define EXT_CSD_SEC_CNT         212     /* RO, 4 bytes */
+/*
+ * EXT_CSD field definitions
+ */
-struct mmc_host;
+#define EXT_CSD_CMD_SET_NORMAL          (1<<0)
-struct mmc_card;
+#define EXT_CSD_CMD_SET_SECURE          (1<<1)
+#define EXT_CSD_CMD_SET_CPSECURE        (1<<2)
-extern int mmc_wait_for_req(struct mmc_host *, struct mmc_request *);
+#define EXT_CSD_CARD_TYPE_26    (1<<0)  /* Card can run at 26MHz */
-extern int mmc_wait_for_cmd(struct mmc_host *, struct mmc_command *, int);
+#define EXT_CSD_CARD_TYPE_52    (1<<1)  /* Card can run at 52MHz */
-extern int mmc_wait_for_app_cmd(struct mmc_host *, unsigned int,
-        struct mmc_command *, int);
-extern void mmc_set_data_timeout(struct mmc_data *, const struct mmc_card *, int);
+#define EXT_CSD_BUS_WIDTH_1     0       /* Card is in 1 bit mode */
+#define EXT_CSD_BUS_WIDTH_4     1       /* Card is in 4 bit mode */
+#define EXT_CSD_BUS_WIDTH_8     2       /* Card is in 8 bit mode */
-extern int __mmc_claim_host(struct mmc_host *host, struct mmc_card *card);
+/*
+ * MMC_SWITCH access modes
+ */
-static inline void mmc_claim_host(struct mmc_host *host)
+#define MMC_SWITCH_MODE_CMD_SET         0x00    /* Change the command set */
-{
+#define MMC_SWITCH_MODE_SET_BITS        0x01    /* Set bits which are 1 in value */
-        __mmc_claim_host(host, (struct mmc_card *)-1);
+#define MMC_SWITCH_MODE_CLEAR_BITS      0x02    /* Clear bits which are 1 in value */
-}
+#define MMC_SWITCH_MODE_WRITE_BYTE      0x03    /* Set target to value */
-extern void mmc_release_host(struct mmc_host *host);
+#endif  /* MMC_MMC_PROTOCOL_H */
-#endif
diff --git a/include/linux/mmc/protocol.h b/include/linux/mmc/protocol.h
deleted file mode 100644
index c90b6768329d..000000000000
--- a/include/linux/mmc/protocol.h
+++ /dev/null
@@ -1,327 +0,0 @@
-/*
- * Header for MultiMediaCard (MMC)
- *
- * Copyright 2002 Hewlett-Packard Company
- *
- * Use consistent with the GNU GPL is permitted,
- * provided that this copyright notice is
- * preserved in its entirety in all copies and derived works.
- *
- * HEWLETT-PACKARD COMPANY MAKES NO WARRANTIES, EXPRESSED OR IMPLIED,
- * AS TO THE USEFULNESS OR CORRECTNESS OF THIS CODE OR ITS
- * FITNESS FOR ANY PARTICULAR PURPOSE.
- *
- * Many thanks to Alessandro Rubini and Jonathan Corbet!
- *
- * Based strongly on code by:
- *
- * Author: Yong-iL Joh <tolkien@mizi.com>
- * Date  : $Date: 2002/06/18 12:37:30 $
- *
- * Author:  Andrew Christian
- *          15 May 2002
- */
-#ifndef MMC_MMC_PROTOCOL_H
-#define MMC_MMC_PROTOCOL_H
-/* Standard MMC commands (4.1)           type  argument     response */
-   /* class 1 */
-#define MMC_GO_IDLE_STATE         0   /* bc                          */
-#define MMC_SEND_OP_COND          1   /* bcr  [31:0] OCR         R3  */
-#define MMC_ALL_SEND_CID          2   /* bcr                     R2  */
-#define MMC_SET_RELATIVE_ADDR     3   /* ac   [31:16] RCA        R1  */
-#define MMC_SET_DSR               4   /* bc   [31:16] RCA            */
-#define MMC_SWITCH                6   /* ac   [31:0] See below   R1b */
-#define MMC_SELECT_CARD           7   /* ac   [31:16] RCA        R1  */
-#define MMC_SEND_EXT_CSD          8   /* adtc                    R1  */
-#define MMC_SEND_CSD              9   /* ac   [31:16] RCA        R2  */
-#define MMC_SEND_CID             10   /* ac   [31:16] RCA        R2  */
-#define MMC_READ_DAT_UNTIL_STOP  11   /* adtc [31:0] dadr        R1  */
-#define MMC_STOP_TRANSMISSION    12   /* ac                      R1b */
-#define MMC_SEND_STATUS          13   /* ac   [31:16] RCA        R1  */
-#define MMC_GO_INACTIVE_STATE    15   /* ac   [31:16] RCA            */
-  /* class 2 */
-#define MMC_SET_BLOCKLEN         16   /* ac   [31:0] block len   R1  */
-#define MMC_READ_SINGLE_BLOCK    17   /* adtc [31:0] data addr   R1  */
-#define MMC_READ_MULTIPLE_BLOCK  18   /* adtc [31:0] data addr   R1  */
-  /* class 3 */
-#define MMC_WRITE_DAT_UNTIL_STOP 20   /* adtc [31:0] data addr   R1  */
-  /* class 4 */
-#define MMC_SET_BLOCK_COUNT      23   /* adtc [31:0] data addr   R1  */
-#define MMC_WRITE_BLOCK          24   /* adtc [31:0] data addr   R1  */
-#define MMC_WRITE_MULTIPLE_BLOCK 25   /* adtc                    R1  */
-#define MMC_PROGRAM_CID          26   /* adtc                    R1  */
-#define MMC_PROGRAM_CSD          27   /* adtc                    R1  */
-  /* class 6 */
-#define MMC_SET_WRITE_PROT       28   /* ac   [31:0] data addr   R1b */
-#define MMC_CLR_WRITE_PROT       29   /* ac   [31:0] data addr   R1b */
-#define MMC_SEND_WRITE_PROT      30   /* adtc [31:0] wpdata addr R1  */
-  /* class 5 */
-#define MMC_ERASE_GROUP_START    35   /* ac   [31:0] data addr   R1  */
-#define MMC_ERASE_GROUP_END      36   /* ac   [31:0] data addr   R1  */
-#define MMC_ERASE                38   /* ac                      R1b */
-  /* class 9 */
-#define MMC_FAST_IO              39   /* ac   <Complex>          R4  */
-#define MMC_GO_IRQ_STATE         40   /* bcr                     R5  */
-  /* class 7 */
-#define MMC_LOCK_UNLOCK          42   /* adtc                    R1b */
-  /* class 8 */
-#define MMC_APP_CMD              55   /* ac   [31:16] RCA        R1  */
-#define MMC_GEN_CMD              56   /* adtc [0] RD/WR          R1  */
-/* SD commands                           type  argument     response */
-  /* class 0 */
-/* This is basically the same command as for MMC with some quirks. */
-#define SD_SEND_RELATIVE_ADDR     3   /* bcr                     R6  */
-#define SD_SEND_IF_COND           8   /* bcr  [11:0] See below   R7  */
-  /* class 10 */
-#define SD_SWITCH                 6   /* adtc [31:0] See below   R1  */
-  /* Application commands */
-#define SD_APP_SET_BUS_WIDTH      6   /* ac   [1:0] bus width    R1  */
-#define SD_APP_SEND_NUM_WR_BLKS  22   /* adtc                    R1  */
-#define SD_APP_OP_COND           41   /* bcr  [31:0] OCR         R3  */
-#define SD_APP_SEND_SCR          51   /* adtc                    R1  */
-/*
- * MMC_SWITCH argument format:
- *
- *      [31:26] Always 0
- *      [25:24] Access Mode
- *      [23:16] Location of target Byte in EXT_CSD
- *      [15:08] Value Byte
- *      [07:03] Always 0
- *      [02:00] Command Set
- */
-/*
- * SD_SWITCH argument format:
- *
- *      [31] Check (0) or switch (1)
- *      [30:24] Reserved (0)
- *      [23:20] Function group 6
- *      [19:16] Function group 5
- *      [15:12] Function group 4
- *      [11:8] Function group 3
- *      [7:4] Function group 2
- *      [3:0] Function group 1
- */
-/*
- * SD_SEND_IF_COND argument format:
- *
- *      [31:12] Reserved (0)
- *      [11:8] Host Voltage Supply Flags
- *      [7:0] Check Pattern (0xAA)
- */
-/*
-  MMC status in R1
-  Type
-        e : error bit
-        s : status bit
-        r : detected and set for the actual command response
-        x : detected and set during command execution. the host must poll
-            the card by sending status command in order to read these bits.
-  Clear condition
-        a : according to the card state
-        b : always related to the previous command. Reception of
-            a valid command will clear it (with a delay of one command)
-        c : clear by read
- */
-#define R1_OUT_OF_RANGE         (1 << 31)       /* er, c */
-#define R1_ADDRESS_ERROR        (1 << 30)       /* erx, c */
-#define R1_BLOCK_LEN_ERROR      (1 << 29)       /* er, c */
-#define R1_ERASE_SEQ_ERROR      (1 << 28)       /* er, c */
-#define R1_ERASE_PARAM          (1 << 27)       /* ex, c */
-#define R1_WP_VIOLATION         (1 << 26)       /* erx, c */
-#define R1_CARD_IS_LOCKED       (1 << 25)       /* sx, a */
-#define R1_LOCK_UNLOCK_FAILED   (1 << 24)       /* erx, c */
-#define R1_COM_CRC_ERROR        (1 << 23)       /* er, b */
-#define R1_ILLEGAL_COMMAND      (1 << 22)       /* er, b */
-#define R1_CARD_ECC_FAILED      (1 << 21)       /* ex, c */
-#define R1_CC_ERROR             (1 << 20)       /* erx, c */
-#define R1_ERROR                (1 << 19)       /* erx, c */
-#define R1_UNDERRUN             (1 << 18)       /* ex, c */
-#define R1_OVERRUN              (1 << 17)       /* ex, c */
-#define R1_CID_CSD_OVERWRITE    (1 << 16)       /* erx, c, CID/CSD overwrite */
-#define R1_WP_ERASE_SKIP        (1 << 15)       /* sx, c */
-#define R1_CARD_ECC_DISABLED    (1 << 14)       /* sx, a */
-#define R1_ERASE_RESET          (1 << 13)       /* sr, c */
-#define R1_STATUS(x)            (x & 0xFFFFE000)
-#define R1_CURRENT_STATE(x)     ((x & 0x00001E00) >> 9) /* sx, b (4 bits) */
-#define R1_READY_FOR_DATA       (1 << 8)        /* sx, a */
-#define R1_APP_CMD              (1 << 5)        /* sr, c */
-/* These are unpacked versions of the actual responses */
-struct _mmc_csd {
-        u8  csd_structure;
-        u8  spec_vers;
-        u8  taac;
-        u8  nsac;
-        u8  tran_speed;
-        u16 ccc;
-        u8  read_bl_len;
-        u8  read_bl_partial;
-        u8  write_blk_misalign;
-        u8  read_blk_misalign;
-        u8  dsr_imp;
-        u16 c_size;
-        u8  vdd_r_curr_min;
-        u8  vdd_r_curr_max;
-        u8  vdd_w_curr_min;
-        u8  vdd_w_curr_max;
-        u8  c_size_mult;
-        union {
-                struct { /* MMC system specification version 3.1 */
-                        u8  erase_grp_size;
-                        u8  erase_grp_mult;
-                } v31;
-                struct { /* MMC system specification version 2.2 */
-                        u8  sector_size;
-                        u8  erase_grp_size;
-                } v22;
-        } erase;
-        u8  wp_grp_size;
-        u8  wp_grp_enable;
-        u8  default_ecc;
-        u8  r2w_factor;
-        u8  write_bl_len;
-        u8  write_bl_partial;
-        u8  file_format_grp;
-        u8  copy;
-        u8  perm_write_protect;
-        u8  tmp_write_protect;
-        u8  file_format;
-        u8  ecc;
-};
-#define MMC_VDD_145_150 0x00000001      /* VDD voltage 1.45 - 1.50 */
-#define MMC_VDD_150_155 0x00000002      /* VDD voltage 1.50 - 1.55 */
-#define MMC_VDD_155_160 0x00000004      /* VDD voltage 1.55 - 1.60 */
-#define MMC_VDD_160_165 0x00000008      /* VDD voltage 1.60 - 1.65 */
-#define MMC_VDD_165_170 0x00000010      /* VDD voltage 1.65 - 1.70 */
-#define MMC_VDD_17_18   0x00000020      /* VDD voltage 1.7 - 1.8 */
-#define MMC_VDD_18_19   0x00000040      /* VDD voltage 1.8 - 1.9 */
-#define MMC_VDD_19_20   0x00000080      /* VDD voltage 1.9 - 2.0 */
-#define MMC_VDD_20_21   0x00000100      /* VDD voltage 2.0 ~ 2.1 */
-#define MMC_VDD_21_22   0x00000200      /* VDD voltage 2.1 ~ 2.2 */
-#define MMC_VDD_22_23   0x00000400      /* VDD voltage 2.2 ~ 2.3 */
-#define MMC_VDD_23_24   0x00000800      /* VDD voltage 2.3 ~ 2.4 */
-#define MMC_VDD_24_25   0x00001000      /* VDD voltage 2.4 ~ 2.5 */
-#define MMC_VDD_25_26   0x00002000      /* VDD voltage 2.5 ~ 2.6 */
-#define MMC_VDD_26_27   0x00004000      /* VDD voltage 2.6 ~ 2.7 */
-#define MMC_VDD_27_28   0x00008000      /* VDD voltage 2.7 ~ 2.8 */
-#define MMC_VDD_28_29   0x00010000      /* VDD voltage 2.8 ~ 2.9 */
-#define MMC_VDD_29_30   0x00020000      /* VDD voltage 2.9 ~ 3.0 */
-#define MMC_VDD_30_31   0x00040000      /* VDD voltage 3.0 ~ 3.1 */
-#define MMC_VDD_31_32   0x00080000      /* VDD voltage 3.1 ~ 3.2 */
-#define MMC_VDD_32_33   0x00100000      /* VDD voltage 3.2 ~ 3.3 */
-#define MMC_VDD_33_34   0x00200000      /* VDD voltage 3.3 ~ 3.4 */
-#define MMC_VDD_34_35   0x00400000      /* VDD voltage 3.4 ~ 3.5 */
-#define MMC_VDD_35_36   0x00800000      /* VDD voltage 3.5 ~ 3.6 */
-#define MMC_CARD_BUSY   0x80000000      /* Card Power up status bit */
-/*
- * Card Command Classes (CCC)
- */
-#define CCC_BASIC               (1<<0)  /* (0) Basic protocol functions */
-                                        /* (CMD0,1,2,3,4,7,9,10,12,13,15) */
-#define CCC_STREAM_READ         (1<<1)  /* (1) Stream read commands */
-                                        /* (CMD11) */
-#define CCC_BLOCK_READ          (1<<2)  /* (2) Block read commands */
-                                        /* (CMD16,17,18) */
-#define CCC_STREAM_WRITE        (1<<3)  /* (3) Stream write commands */
-                                        /* (CMD20) */
-#define CCC_BLOCK_WRITE         (1<<4)  /* (4) Block write commands */
-                                        /* (CMD16,24,25,26,27) */
-#define CCC_ERASE               (1<<5)  /* (5) Ability to erase blocks */
-                                        /* (CMD32,33,34,35,36,37,38,39) */
-#define CCC_WRITE_PROT          (1<<6)  /* (6) Able to write protect blocks */
-                                        /* (CMD28,29,30) */
-#define CCC_LOCK_CARD           (1<<7)  /* (7) Able to lock down card */
-                                        /* (CMD16,CMD42) */
-#define CCC_APP_SPEC            (1<<8)  /* (8) Application specific */
-                                        /* (CMD55,56,57,ACMD*) */
-#define CCC_IO_MODE             (1<<9)  /* (9) I/O mode */
-                                        /* (CMD5,39,40,52,53) */
-#define CCC_SWITCH              (1<<10) /* (10) High speed switch */
-                                        /* (CMD6,34,35,36,37,50) */
-                                        /* (11) Reserved */
-                                        /* (CMD?) */
-/*
- * CSD field definitions
- */
-#define CSD_STRUCT_VER_1_0  0           /* Valid for system specification 1.0 - 1.2 */
-#define CSD_STRUCT_VER_1_1  1           /* Valid for system specification 1.4 - 2.2 */
-#define CSD_STRUCT_VER_1_2  2           /* Valid for system specification 3.1 - 3.2 - 3.31 - 4.0 - 4.1 */
-#define CSD_STRUCT_EXT_CSD  3           /* Version is coded in CSD_STRUCTURE in EXT_CSD */
-#define CSD_SPEC_VER_0      0           /* Implements system specification 1.0 - 1.2 */
-#define CSD_SPEC_VER_1      1           /* Implements system specification 1.4 */
-#define CSD_SPEC_VER_2      2           /* Implements system specification 2.0 - 2.2 */
-#define CSD_SPEC_VER_3      3           /* Implements system specification 3.1 - 3.2 - 3.31 */
-#define CSD_SPEC_VER_4      4           /* Implements system specification 4.0 - 4.1 */
-/*
- * EXT_CSD fields
- */
-#define EXT_CSD_BUS_WIDTH       183     /* R/W */
-#define EXT_CSD_HS_TIMING       185     /* R/W */
-#define EXT_CSD_CARD_TYPE       196     /* RO */
-/*
- * EXT_CSD field definitions
- */
-#define EXT_CSD_CMD_SET_NORMAL          (1<<0)
-#define EXT_CSD_CMD_SET_SECURE          (1<<1)
-#define EXT_CSD_CMD_SET_CPSECURE        (1<<2)
-#define EXT_CSD_CARD_TYPE_26    (1<<0)  /* Card can run at 26MHz */
-#define EXT_CSD_CARD_TYPE_52    (1<<1)  /* Card can run at 52MHz */
-#define EXT_CSD_BUS_WIDTH_1     0       /* Card is in 1 bit mode */
-#define EXT_CSD_BUS_WIDTH_4     1       /* Card is in 4 bit mode */
-#define EXT_CSD_BUS_WIDTH_8     2       /* Card is in 8 bit mode */
-/*
- * MMC_SWITCH access modes
- */
-#define MMC_SWITCH_MODE_CMD_SET         0x00    /* Change the command set */
-#define MMC_SWITCH_MODE_SET_BITS        0x01    /* Set bits which are 1 in value */
-#define MMC_SWITCH_MODE_CLEAR_BITS      0x02    /* Clear bits which are 1 in value */
-#define MMC_SWITCH_MODE_WRITE_BYTE      0x03    /* Set target to value */
-/*
- * SCR field definitions
- */
-#define SCR_SPEC_VER_0      0           /* Implements system specification 1.0 - 1.01 */
-#define SCR_SPEC_VER_1      1           /* Implements system specification 1.10 */
-#define SCR_SPEC_VER_2      2           /* Implements system specification 2.00 */
-/*
- * SD bus widths
- */
-#define SD_BUS_WIDTH_1      0
-#define SD_BUS_WIDTH_4      2
-#endif  /* MMC_MMC_PROTOCOL_H */
diff --git a/include/linux/mmc/sd.h b/include/linux/mmc/sd.h
new file mode 100644
index 000000000000..f310062cffb4
--- /dev/null
+++ b/include/linux/mmc/sd.h
@@ -0,0 +1,83 @@
+/*
+ *  include/linux/mmc/sd.h
+ *
+ *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ */
+#ifndef MMC_SD_H
+#define MMC_SD_H
+/* SD commands                           type  argument     response */
+  /* class 0 */
+/* This is basically the same command as for MMC with some quirks. */
+#define SD_SEND_RELATIVE_ADDR     3   /* bcr                     R6  */
+#define SD_SEND_IF_COND           8   /* bcr  [11:0] See below   R7  */
+  /* class 10 */
+#define SD_SWITCH                 6   /* adtc [31:0] See below   R1  */
+  /* Application commands */
+#define SD_APP_SET_BUS_WIDTH      6   /* ac   [1:0] bus width    R1  */
+#define SD_APP_SEND_NUM_WR_BLKS  22   /* adtc                    R1  */
+#define SD_APP_OP_COND           41   /* bcr  [31:0] OCR         R3  */
+#define SD_APP_SEND_SCR          51   /* adtc                    R1  */
+/*
+ * SD_SWITCH argument format:
+ *
+ *      [31] Check (0) or switch (1)
+ *      [30:24] Reserved (0)
+ *      [23:20] Function group 6
+ *      [19:16] Function group 5
+ *      [15:12] Function group 4
+ *      [11:8] Function group 3
+ *      [7:4] Function group 2
+ *      [3:0] Function group 1
+ */
+/*
+ * SD_SEND_IF_COND argument format:
+ *
+ *      [31:12] Reserved (0)
+ *      [11:8] Host Voltage Supply Flags
+ *      [7:0] Check Pattern (0xAA)
+ */
+/*
+ * SCR field definitions
+ */
+#define SCR_SPEC_VER_0          0       /* Implements system specification 1.0 - 1.01 */
+#define SCR_SPEC_VER_1          1       /* Implements system specification 1.10 */
+#define SCR_SPEC_VER_2          2       /* Implements system specification 2.00 */
+/*
+ * SD bus widths
+ */
+#define SD_BUS_WIDTH_1          0
+#define SD_BUS_WIDTH_4          2
+/*
+ * SD_SWITCH mode
+ */
+#define SD_SWITCH_CHECK         0
+#define SD_SWITCH_SET           1
+/*
+ * SD_SWITCH function groups
+ */
+#define SD_SWITCH_GRP_ACCESS    0
+/*
+ * SD_SWITCH access modes
+ */
+#define SD_SWITCH_ACCESS_DEF    0
+#define SD_SWITCH_ACCESS_HS     1
+#endif
diff --git a/include/linux/module.h b/include/linux/module.h
index 95679eb8571e..f0b0faf42d5d 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -568,7 +568,7 @@ struct device_driver;
 #ifdef CONFIG_SYSFS
 struct module;
-extern struct subsystem module_subsys;
+extern struct kset module_subsys;
 int mod_sysfs_init(struct module *mod);
 int mod_sysfs_setup(struct module *mod,
diff --git a/include/linux/msi.h b/include/linux/msi.h
index e38fe6822cb4..94bb46d82efd 100644
--- a/include/linux/msi.h
+++ b/include/linux/msi.h
@@ -1,6 +1,8 @@
 #ifndef LINUX_MSI_H
 #define LINUX_MSI_H
+#include <linux/list.h>
 struct msi_msg {
        u32     address_lo;     /* low 32 bits of msi message address */
        u32     address_hi;     /* high 32 bits of msi message address */
@@ -24,10 +26,8 @@ struct msi_desc {
                unsigned default_irq;   /* default pre-assigned irq       */
        }msi_attrib;
-        struct {
+        unsigned int irq;
-                __u16   head;
+        struct list_head list;
-                __u16   tail;
-        }link;
        void __iomem *mask_base;
        struct pci_dev *dev;
@@ -41,6 +41,9 @@ struct msi_desc {
 */
 int arch_setup_msi_irq(struct pci_dev *dev, struct msi_desc *desc);
 void arch_teardown_msi_irq(unsigned int irq);
+extern int arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type);
+extern void arch_teardown_msi_irqs(struct pci_dev *dev);
+extern int arch_msi_check_device(struct pci_dev* dev, int nvec, int type);
 #endif /* LINUX_MSI_H */
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index ac0c92b1e002..30446222b396 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -304,7 +304,7 @@ struct net_device
        unsigned long           state;
-        struct net_device       *next;
+        struct list_head        dev_list;
        
        /* The device initialization function. Called only once. */
        int                     (*init)(struct net_device *dev);
@@ -575,13 +575,36 @@ struct packet_type {
 #include <linux/notifier.h>
 extern struct net_device                loopback_dev;           /* The loopback */
-extern struct net_device                *dev_base;              /* All devices */
+extern struct list_head                 dev_base_head;          /* All devices */
 extern rwlock_t                         dev_base_lock;          /* Device list lock */
+#define for_each_netdev(d)              \
+                list_for_each_entry(d, &dev_base_head, dev_list)
+#define for_each_netdev_safe(d, n)      \
+                list_for_each_entry_safe(d, n, &dev_base_head, dev_list)
+#define for_each_netdev_continue(d)             \
+                list_for_each_entry_continue(d, &dev_base_head, dev_list)
+#define net_device_entry(lh)    list_entry(lh, struct net_device, dev_list)
+static inline struct net_device *next_net_device(struct net_device *dev)
+{
+        struct list_head *lh;
+        lh = dev->dev_list.next;
+        return lh == &dev_base_head ? NULL : net_device_entry(lh);
+}
+static inline struct net_device *first_net_device(void)
+{
+        return list_empty(&dev_base_head) ? NULL :
+                net_device_entry(dev_base_head.next);
+}
 extern int                      netdev_boot_setup_check(struct net_device *dev);
 extern unsigned long            netdev_boot_base(const char *prefix, int unit);
 extern struct net_device    *dev_getbyhwaddr(unsigned short type, char *hwaddr);
 extern struct net_device *dev_getfirstbyhwtype(unsigned short type);
+extern struct net_device *__dev_getfirstbyhwtype(unsigned short type);
 extern void             dev_add_pack(struct packet_type *pt);
 extern void             dev_remove_pack(struct packet_type *pt);
 extern void             __dev_remove_pack(struct packet_type *pt);
diff --git a/include/linux/netfilter/nf_conntrack_proto_gre.h b/include/linux/netfilter/nf_conntrack_proto_gre.h
index 4e6bbce04ff8..535e4219d2bb 100644
--- a/include/linux/netfilter/nf_conntrack_proto_gre.h
+++ b/include/linux/netfilter/nf_conntrack_proto_gre.h
@@ -87,24 +87,6 @@ int nf_ct_gre_keymap_add(struct nf_conn *ct, enum ip_conntrack_dir dir,
 /* delete keymap entries */
 void nf_ct_gre_keymap_destroy(struct nf_conn *ct);
-/* get pointer to gre key, if present */
-static inline __be32 *gre_key(struct gre_hdr *greh)
-{
-        if (!greh->key)
-                return NULL;
-        if (greh->csum || greh->routing)
-                return (__be32 *)(greh+sizeof(*greh)+4);
-        return (__be32 *)(greh+sizeof(*greh));
-}
-/* get pointer ot gre csum, if present */
-static inline __sum16 *gre_csum(struct gre_hdr *greh)
-{
-        if (!greh->csum)
-                return NULL;
-        return (__sum16 *)(greh+sizeof(*greh));
-}
 extern void nf_ct_gre_keymap_flush(void);
 extern void nf_nat_need_gre(void);
diff --git a/include/linux/netfilter_bridge.h b/include/linux/netfilter_bridge.h
index 19060030bac9..533ee351a273 100644
--- a/include/linux/netfilter_bridge.h
+++ b/include/linux/netfilter_bridge.h
@@ -55,18 +55,25 @@ static inline int nf_bridge_maybe_copy_header(struct sk_buff *skb)
        return 0;
 }
+static inline unsigned int nf_bridge_encap_header_len(const struct sk_buff *skb)
+{
+        switch (skb->protocol) {
+        case __constant_htons(ETH_P_8021Q):
+                return VLAN_HLEN;
+        case __constant_htons(ETH_P_PPP_SES):
+                return PPPOE_SES_HLEN;
+        default:
+                return 0;
+        }
+}
 /* This is called by the IP fragmenting code and it ensures there is
 * enough room for the encapsulating header (if there is one). */
-static inline int nf_bridge_pad(const struct sk_buff *skb)
+static inline unsigned int nf_bridge_pad(const struct sk_buff *skb)
 {
-        int padding = 0;
+        if (skb->nf_bridge)
+                return nf_bridge_encap_header_len(skb);
-        if (skb->nf_bridge && skb->protocol == htons(ETH_P_8021Q))
+        return 0;
-                padding = VLAN_HLEN;
-        else if (skb->nf_bridge && skb->protocol == htons(ETH_P_PPP_SES))
-                padding = PPPOE_SES_HLEN;
-        return padding;
 }
 struct bridge_skb_cb {
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index f41688f56632..2e23353c28a5 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -31,7 +31,7 @@ struct sockaddr_nl
 {
        sa_family_t     nl_family;      /* AF_NETLINK   */
        unsigned short  nl_pad;         /* zero         */
-        __u32           nl_pid;         /* process pid  */
+        __u32           nl_pid;         /* port ID      */
        __u32           nl_groups;      /* multicast groups mask */
 };
@@ -41,7 +41,7 @@ struct nlmsghdr
        __u16           nlmsg_type;     /* Message content */
        __u16           nlmsg_flags;    /* Additional flags */
        __u32           nlmsg_seq;      /* Sequence number */
-        __u32           nlmsg_pid;      /* Sending process PID */
+        __u32           nlmsg_pid;      /* Sending process port ID */
 };
 /* Flags values */
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index e9ae0c6e2c62..0543439a97af 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -455,7 +455,7 @@ nfs_have_writebacks(struct inode *inode)
 /*
 * Allocate nfs_write_data structures
 */
-extern struct nfs_write_data *nfs_writedata_alloc(size_t len);
+extern struct nfs_write_data *nfs_writedata_alloc(unsigned int npages);
 /*
 * linux/fs/nfs/read.c
@@ -469,7 +469,7 @@ extern void nfs_readdata_release(void *data);
 /*
 * Allocate nfs_read_data structures
 */
-extern struct nfs_read_data *nfs_readdata_alloc(size_t len);
+extern struct nfs_read_data *nfs_readdata_alloc(unsigned int npages);
 /*
 * linux/fs/nfs3proc.c
diff --git a/include/linux/nfs_mount.h b/include/linux/nfs_mount.h
index 659c75438454..cc8b9c59acb8 100644
--- a/include/linux/nfs_mount.h
+++ b/include/linux/nfs_mount.h
@@ -61,6 +61,7 @@ struct nfs_mount_data {
 #define NFS_MOUNT_NOACL         0x0800  /* 4 */
 #define NFS_MOUNT_STRICTLOCK    0x1000  /* reserved for NFSv4 */
 #define NFS_MOUNT_SECFLAVOUR    0x2000  /* 5 */
+#define NFS_MOUNT_NORDIRPLUS    0x4000  /* 5 */
 #define NFS_MOUNT_FLAGMASK      0xFFFF
 #endif
diff --git a/include/linux/nfs_page.h b/include/linux/nfs_page.h
index 16b0266b14fd..41afab6b5f09 100644
--- a/include/linux/nfs_page.h
+++ b/include/linux/nfs_page.h
@@ -21,8 +21,7 @@
 /*
 * Valid flags for the radix tree
 */
-#define NFS_PAGE_TAG_DIRTY      0
+#define NFS_PAGE_TAG_WRITEBACK  0
-#define NFS_PAGE_TAG_WRITEBACK  1
 /*
 * Valid flags for a dirty buffer
@@ -39,7 +38,7 @@ struct nfs_page {
        struct page             *wb_page;       /* page to read in/write out */
        struct nfs_open_context *wb_context;    /* File state context info */
        atomic_t                wb_complete;    /* i/os we're waiting for */
-        unsigned long           wb_index;       /* Offset >> PAGE_CACHE_SHIFT */
+        pgoff_t                 wb_index;       /* Offset >> PAGE_CACHE_SHIFT */
        unsigned int            wb_offset,      /* Offset & ~PAGE_CACHE_MASK */
                                wb_pgbase,      /* Start of page data */
                                wb_bytes;       /* Length of request */
@@ -48,6 +47,19 @@ struct nfs_page {
        struct nfs_writeverf    wb_verf;        /* Commit cookie */
 };
+struct nfs_pageio_descriptor {
+        struct list_head        pg_list;
+        unsigned long           pg_bytes_written;
+        size_t                  pg_count;
+        size_t                  pg_bsize;
+        unsigned int            pg_base;
+        struct inode            *pg_inode;
+        int                     (*pg_doio)(struct inode *, struct list_head *, unsigned int, size_t, int);
+        int                     pg_ioflags;
+        int                     pg_error;
+};
 #define NFS_WBACK_BUSY(req)     (test_bit(PG_BUSY,&(req)->wb_flags))
 extern  struct nfs_page *nfs_create_request(struct nfs_open_context *ctx,
@@ -59,13 +71,16 @@ extern	void nfs_clear_request(struct nfs_page *req);
 extern  void nfs_release_request(struct nfs_page *req);
-extern  long nfs_scan_dirty(struct address_space *mapping,
-                                struct writeback_control *wbc,
-                                struct list_head *dst);
 extern  int nfs_scan_list(struct nfs_inode *nfsi, struct list_head *head, struct list_head *dst,
-                          unsigned long idx_start, unsigned int npages);
+                          pgoff_t idx_start, unsigned int npages);
-extern  int nfs_coalesce_requests(struct list_head *, struct list_head *,
+extern  void nfs_pageio_init(struct nfs_pageio_descriptor *desc,
-                                  unsigned int);
+                             struct inode *inode,
+                             int (*doio)(struct inode *, struct list_head *, unsigned int, size_t, int),
+                             size_t bsize,
+                             int how);
+extern  int nfs_pageio_add_request(struct nfs_pageio_descriptor *,
+                                   struct nfs_page *);
+extern  void nfs_pageio_complete(struct nfs_pageio_descriptor *desc);
 extern  int nfs_wait_on_request(struct nfs_page *);
 extern  void nfs_unlock_request(struct nfs_page *req);
 extern  int nfs_set_page_writeback_locked(struct nfs_page *req);
diff --git a/include/linux/nubus.h b/include/linux/nubus.h
index 870e66a96286..cdb3e9b8db54 100644
--- a/include/linux/nubus.h
+++ b/include/linux/nubus.h
@@ -28,18 +28,18 @@ enum nubus_category {
 };
 enum nubus_type_network {
-        NUBUS_TYPE_ETHERNET      = 0x0001,
+        NUBUS_TYPE_ETHERNET      = 0x0001,
-        NUBUS_TYPE_RS232         = 0x0002
+        NUBUS_TYPE_RS232         = 0x0002
 };
 enum nubus_type_display {
-        NUBUS_TYPE_VIDEO         = 0x0001
+        NUBUS_TYPE_VIDEO         = 0x0001
 };
 enum nubus_type_cpu {
-        NUBUS_TYPE_68020         = 0x0003,
+        NUBUS_TYPE_68020         = 0x0003,
-        NUBUS_TYPE_68030         = 0x0004,
+        NUBUS_TYPE_68030         = 0x0004,
-        NUBUS_TYPE_68040         = 0x0005
+        NUBUS_TYPE_68040         = 0x0005
 };
 /* Known <Cat,Type,SW,HW> tuples: (according to TattleTech and Slots)
@@ -56,6 +56,7 @@ enum nubus_type_cpu {
 *
 *  SONIC comm-slot/on-board and DuoDock Ethernet: <4,1,1,272>
 *  SONIC LC-PDS Ethernet (Dayna, but like Apple 16-bit, sort of): <4,1,1,271>
+ *  Apple SONIC LC-PDS Ethernet ("Apple Ethernet LC Twisted-Pair Card"): <4,1,0,281>
 *  Sonic Systems Ethernet A-Series Card: <4,1,268,256>
 *  Asante MacCon NuBus-A: <4,1,260,256> (alpha-1.0,1.1 revision)
 *   ROM on the above card: <2,1,0,0>
@@ -80,24 +81,26 @@ enum nubus_type_cpu {
 /* Add known DrSW values here */
 enum nubus_drsw {
        /* NUBUS_CAT_DISPLAY */
-        NUBUS_DRSW_APPLE        = 0x0001,
+        NUBUS_DRSW_APPLE        = 0x0001,
-        NUBUS_DRSW_APPLE_HIRES  = 0x0013, /* MacII HiRes card driver */
+        NUBUS_DRSW_APPLE_HIRES  = 0x0013, /* MacII HiRes card driver */
        
        /* NUBUS_CAT_NETWORK */
-        NUBUS_DRSW_CABLETRON    = 0x0001,
+        NUBUS_DRSW_3COM         = 0x0000,
-        NUBUS_DRSW_SONIC_LC     = 0x0001,
+        NUBUS_DRSW_CABLETRON    = 0x0001,
-        NUBUS_DRSW_KINETICS     = 0x0103,
+        NUBUS_DRSW_SONIC_LC     = 0x0001,
-        NUBUS_DRSW_ASANTE       = 0x0104,
+        NUBUS_DRSW_KINETICS     = 0x0103,
-        NUBUS_DRSW_DAYNA        = 0x010b,
+        NUBUS_DRSW_ASANTE       = 0x0104,
-        NUBUS_DRSW_FARALLON     = 0x010c,
+        NUBUS_DRSW_TECHWORKS    = 0x0109,
-        NUBUS_DRSW_APPLE_SN     = 0x010f,
+        NUBUS_DRSW_DAYNA        = 0x010b,
-        NUBUS_DRSW_DAYNA2       = 0x0115,
+        NUBUS_DRSW_FARALLON     = 0x010c,
+        NUBUS_DRSW_APPLE_SN     = 0x010f,
+        NUBUS_DRSW_DAYNA2       = 0x0115,
        NUBUS_DRSW_FOCUS        = 0x011a,
        NUBUS_DRSW_ASANTE_CS    = 0x011d, /* use asante SMC9194 driver */
-        NUBUS_DRSW_DAYNA_LC     = 0x011e,
+        NUBUS_DRSW_DAYNA_LC     = 0x011e,
        /* NUBUS_CAT_CPU */
-        NUBUS_DRSW_NONE         = 0x0000,
+        NUBUS_DRSW_NONE         = 0x0000,
 };
 /* DrHW: Uniquely identifies the hardware interface to a board (or at
@@ -107,27 +110,48 @@ enum nubus_drsw {
 /* Add known DrHW values here */
 enum nubus_drhw {
        /* NUBUS_CAT_DISPLAY */
-        NUBUS_DRHW_APPLE_TFB    = 0x0001, /* Toby frame buffer card */
+        NUBUS_DRHW_APPLE_TFB      = 0x0001, /* Toby frame buffer card */
-        NUBUS_DRHW_APPLE_HRVC   = 0x0013, /* Mac II High Res Video card */
+        NUBUS_DRHW_APPLE_WVC      = 0x0006, /* Apple Workstation Video Card */
-        NUBUS_DRHW_APPLE_RBV1   = 0x0018, /* IIci RBV video */
+        NUBUS_DRHW_SIGMA_CLRMAX   = 0x0007, /* Sigma Design ColorMax */
-        NUBUS_DRHW_APPLE_MDC    = 0x0019, /* Macintosh Display Card */
+        NUBUS_DRHW_APPLE_SE30     = 0x0009, /* Apple SE/30 video */
-        NUBUS_DRHW_APPLE_SONORA = 0x0022, /* Sonora built-in video */
+        NUBUS_DRHW_APPLE_HRVC     = 0x0013, /* Mac II High-Res Video Card */
-        NUBUS_DRHW_APPLE_JET    = 0x0029, /* Jet framebuffer (DuoDock) */
+        NUBUS_DRHW_APPLE_PVC      = 0x0017, /* Mac II Portrait Video Card */
+        NUBUS_DRHW_APPLE_RBV1     = 0x0018, /* IIci RBV video */
+        NUBUS_DRHW_APPLE_MDC      = 0x0019, /* Macintosh Display Card */
+        NUBUS_DRHW_APPLE_SONORA   = 0x0022, /* Sonora built-in video */
+        NUBUS_DRHW_APPLE_24AC     = 0x002b, /* Mac 24AC Video Card */
        NUBUS_DRHW_APPLE_VALKYRIE = 0x002e,
-        NUBUS_DRHW_THUNDER24    = 0x02cb, /* SuperMac Thunder/24 */
+        NUBUS_DRHW_APPLE_JET      = 0x0029, /* Jet framebuffer (DuoDock) */
+        NUBUS_DRHW_SMAC_GFX       = 0x0105, /* SuperMac GFX */
+        NUBUS_DRHW_RASTER_CB264   = 0x013B, /* RasterOps ColorBoard 264 */
+        NUBUS_DRHW_MICRON_XCEED   = 0x0146, /* Micron Exceed color */
+        NUBUS_DRHW_RDIUS_GSC      = 0x0153, /* Radius GS/C */
+        NUBUS_DRHW_SMAC_SPEC8     = 0x017B, /* SuperMac Spectrum/8 */
+        NUBUS_DRHW_SMAC_SPEC24    = 0x017C, /* SuperMac Spectrum/24 */
+        NUBUS_DRHW_RASTER_CB364   = 0x026F, /* RasterOps ColorBoard 364 */
+        NUBUS_DRHW_RDIUS_DCGX     = 0x027C, /* Radius DirectColor/GX */
+        NUBUS_DRHW_RDIUS_PC8      = 0x0291, /* Radius PrecisionColor 8 */
+        NUBUS_DRHW_LAPIS_PCS8     = 0x0292, /* Lapis ProColorServer 8 */
+        NUBUS_DRHW_RASTER_24LXI   = 0x02A0, /* RasterOps 8/24 XLi */
+        NUBUS_DRHW_RASTER_PBPGT   = 0x02A5, /* RasterOps PaintBoard Prism GT */
+        NUBUS_DRHW_EMACH_FSX      = 0x02AE, /* E-Machines Futura SX */
+        NUBUS_DRHW_SMAC_THUND24   = 0x02CB, /* SuperMac Thunder/24 */
+        NUBUS_DRHW_RDIUS_PC24XP   = 0x0406, /* Radius PrecisionColor 24Xp */
+        NUBUS_DRHW_RDIUS_PC24X    = 0x040A, /* Radius PrecisionColor 24X */
+        NUBUS_DRHW_RDIUS_PC8XJ    = 0x040B, /* Radius PrecisionColor 8XJ */
        
        /* NUBUS_CAT_NETWORK */
-        NUBUS_DRHW_INTERLAN     = 0x0100,
+        NUBUS_DRHW_INTERLAN       = 0x0100,
-        NUBUS_DRHW_SMC9194      = 0x0101,
+        NUBUS_DRHW_SMC9194        = 0x0101,
-        NUBUS_DRHW_KINETICS     = 0x0106,
+        NUBUS_DRHW_KINETICS       = 0x0106,
-        NUBUS_DRHW_CABLETRON    = 0x0109,
+        NUBUS_DRHW_CABLETRON      = 0x0109,
-        NUBUS_DRHW_ASANTE_LC    = 0x010f,
+        NUBUS_DRHW_ASANTE_LC      = 0x010f,
-        NUBUS_DRHW_SONIC        = 0x0110,
+        NUBUS_DRHW_SONIC          = 0x0110,
-        NUBUS_DRHW_SONIC_NB     = 0x0118,
+        NUBUS_DRHW_TECHWORKS      = 0x0112,
-        NUBUS_DRHW_SONIC_LC     = 0x0119,
+        NUBUS_DRHW_APPLE_SONIC_NB = 0x0118,
-        
+        NUBUS_DRHW_APPLE_SONIC_LC = 0x0119,
-        /* NUBUS_CAT_COMMUNICATIONS */
+        NUBUS_DRHW_FOCUS          = 0x011c,
-        NUBUS_DRHW_DOVEFAX      = 0x0100,
+        NUBUS_DRHW_SONNET         = 0x011d,
 };
 /* Resource IDs: These are the identifiers for the various weird and
@@ -153,17 +177,17 @@ enum nubus_res_id {
 /* Category-specific resources. */
 enum nubus_board_res_id {
-        NUBUS_RESID_BOARDID      = 0x0020,
+        NUBUS_RESID_BOARDID      = 0x0020,
        NUBUS_RESID_PRAMINITDATA = 0x0021,
-        NUBUS_RESID_PRIMARYINIT  = 0x0022,
+        NUBUS_RESID_PRIMARYINIT  = 0x0022,
        NUBUS_RESID_TIMEOUTCONST = 0x0023,
-        NUBUS_RESID_VENDORINFO   = 0x0024,
+        NUBUS_RESID_VENDORINFO   = 0x0024,
-        NUBUS_RESID_BOARDFLAGS   = 0x0025,
+        NUBUS_RESID_BOARDFLAGS   = 0x0025,
-        NUBUS_RESID_SECONDINIT   = 0x0026,
+        NUBUS_RESID_SECONDINIT   = 0x0026,
        /* Not sure why Apple put these next two in here */
-        NUBUS_RESID_VIDNAMES     = 0x0041,
+        NUBUS_RESID_VIDNAMES     = 0x0041,
-        NUBUS_RESID_VIDMODES     = 0x007e
+        NUBUS_RESID_VIDMODES     = 0x007e
 };
 /* Fields within the vendor info directory */
@@ -185,13 +209,13 @@ enum nubus_cpu_res_id {
 };
 enum nubus_display_res_id {
-        NUBUS_RESID_GAMMADIR    = 0x0040,
+        NUBUS_RESID_GAMMADIR    = 0x0040,
-        NUBUS_RESID_FIRSTMODE   = 0x0080,
+        NUBUS_RESID_FIRSTMODE   = 0x0080,
-        NUBUS_RESID_SECONDMODE  = 0x0081,
+        NUBUS_RESID_SECONDMODE  = 0x0081,
-        NUBUS_RESID_THIRDMODE   = 0x0082,
+        NUBUS_RESID_THIRDMODE   = 0x0082,
-        NUBUS_RESID_FOURTHMODE  = 0x0083,
+        NUBUS_RESID_FOURTHMODE  = 0x0083,
-        NUBUS_RESID_FIFTHMODE   = 0x0084,
+        NUBUS_RESID_FIFTHMODE   = 0x0084,
-        NUBUS_RESID_SIXTHMODE   = 0x0085
+        NUBUS_RESID_SIXTHMODE   = 0x0085
 };
 struct nubus_dir
@@ -214,7 +238,7 @@ struct nubus_board {
        struct nubus_board* next;
        struct nubus_dev* first_dev;
        
-        /* Only 9-E actually exist, though 0-8 are also theoretically
+        /* Only 9-E actually exist, though 0-8 are also theoretically
           possible, and 0 is a special case which represents the
           motherboard and onboard peripherals (Ethernet, video) */
        int slot;
diff --git a/include/linux/parser.h b/include/linux/parser.h
index fa3332861a09..26b2bdfcaf06 100644
--- a/include/linux/parser.h
+++ b/include/linux/parser.h
@@ -11,7 +11,7 @@
 /* associates an integer enumerator with a pattern string. */
 struct match_token {
        int token;
-        char *pattern;
+        const char *pattern;
 };
 typedef struct match_token match_table_t[];
@@ -29,5 +29,5 @@ int match_token(char *, match_table_t table, substring_t args[]);
 int match_int(substring_t *, int *result);
 int match_octal(substring_t *, int *result);
 int match_hex(substring_t *, int *result);
-void match_strcpy(char *, substring_t *);
+void match_strcpy(char *, const substring_t *);
-char *match_strdup(substring_t *);
+char *match_strdup(const substring_t *);
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 972491089ac9..fbf3766dac1e 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -96,6 +96,19 @@ enum pci_channel_state {
        pci_channel_io_perm_failure = (__force pci_channel_state_t) 3,
 };
+typedef unsigned int __bitwise pcie_reset_state_t;
+enum pcie_reset_state {
+        /* Reset is NOT asserted (Use to deassert reset) */
+        pcie_deassert_reset = (__force pcie_reset_state_t) 1,
+        /* Use #PERST to reset PCI-E device */
+        pcie_warm_reset = (__force pcie_reset_state_t) 2,
+        /* Use PCI-E Hot Reset to reset device */
+        pcie_hot_reset = (__force pcie_reset_state_t) 3
+};
 typedef unsigned short __bitwise pci_bus_flags_t;
 enum pci_bus_flags {
        PCI_BUS_FLAGS_NO_MSI = (__force pci_bus_flags_t) 1,
@@ -176,10 +189,12 @@ struct pci_dev {
        int rom_attr_enabled;           /* has display of the rom attribute been enabled? */
        struct bin_attribute *res_attr[DEVICE_COUNT_RESOURCE]; /* sysfs file for resources */
 #ifdef CONFIG_PCI_MSI
-        unsigned int first_msi_irq;
+        struct list_head msi_list;
 #endif
 };
+extern struct pci_dev *alloc_pci_dev(void);
 #define pci_dev_g(n) list_entry(n, struct pci_dev, global_list)
 #define pci_dev_b(n) list_entry(n, struct pci_dev, bus_list)
 #define to_pci_dev(n) container_of(n, struct pci_dev, dev)
@@ -392,12 +407,6 @@ struct pci_driver {
        .vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
        .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
-/*
- * pci_module_init is obsolete, this stays here till we fix up all usages of it
- * in the tree.
- */
-#define pci_module_init pci_register_driver
 /**
 * PCI_VDEVICE - macro used to describe a specific pci device in short form
 * @vend: the vendor name
@@ -532,6 +541,7 @@ static inline int pci_is_managed(struct pci_dev *pdev)
 void pci_disable_device(struct pci_dev *dev);
 void pci_set_master(struct pci_dev *dev);
+int pci_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state);
 #define HAVE_PCI_SET_MWI
 int __must_check pci_set_mwi(struct pci_dev *dev);
 void pci_clear_mwi(struct pci_dev *dev);
@@ -730,6 +740,9 @@ static inline int pci_set_power_state(struct pci_dev *dev, pci_power_t state) {
 static inline pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state) { return PCI_D0; }
 static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state, int enable) { return 0; }
+static inline int pci_request_regions(struct pci_dev *dev, const char *res_name) { return -EIO; }
+static inline void pci_release_regions(struct pci_dev *dev) { }
 #define pci_dma_burst_advice(pdev, strat, strategy_parameter) do { } while (0)
 static inline void pci_block_user_cfg_access(struct pci_dev *dev) { }
diff --git a/include/linux/pci_hotplug.h b/include/linux/pci_hotplug.h
index a675a05c4091..ab4cb6ecd47c 100644
--- a/include/linux/pci_hotplug.h
+++ b/include/linux/pci_hotplug.h
@@ -174,7 +174,7 @@ extern int pci_hp_register		(struct hotplug_slot *slot);
 extern int pci_hp_deregister            (struct hotplug_slot *slot);
 extern int __must_check pci_hp_change_slot_info (struct hotplug_slot *slot,
                                                 struct hotplug_slot_info *info);
-extern struct subsystem pci_hotplug_slots_subsys;
+extern struct kset pci_hotplug_slots_subsys;
 /* PCI Setting Record (Type 0) */
 struct hpp_type0 {
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 1b0ddbb8a804..ae849f0d4430 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1213,11 +1213,13 @@
 #define PCI_DEVICE_ID_NVIDIA_NVENET_16              0x03E5
 #define PCI_DEVICE_ID_NVIDIA_NVENET_17              0x03E6
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA      0x03E7
+#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SMBUS     0x03EB
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_IDE       0x03EC
 #define PCI_DEVICE_ID_NVIDIA_NVENET_18              0x03EE
 #define PCI_DEVICE_ID_NVIDIA_NVENET_19              0x03EF
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA2     0x03F6
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA3     0x03F7
+#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP65_SMBUS     0x0446
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP65_IDE       0x0448
 #define PCI_DEVICE_ID_NVIDIA_NVENET_20              0x0450
 #define PCI_DEVICE_ID_NVIDIA_NVENET_21              0x0451
@@ -1924,6 +1926,7 @@
 #define PCI_DEVICE_ID_TIGON3_5752       0x1600
 #define PCI_DEVICE_ID_TIGON3_5752M      0x1601
 #define PCI_DEVICE_ID_NX2_5709          0x1639
+#define PCI_DEVICE_ID_NX2_5709S         0x163a
 #define PCI_DEVICE_ID_TIGON3_5700       0x1644
 #define PCI_DEVICE_ID_TIGON3_5701       0x1645
 #define PCI_DEVICE_ID_TIGON3_5702       0x1646
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 253a2b9be9d6..e7367c74e1bb 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -197,7 +197,7 @@ typedef unsigned char *sk_buff_data_t;
 *      @tstamp: Time we arrived
 *      @dev: Device we arrived on/are leaving by
 *      @iif: ifindex of device we arrived on
- *      @h: Transport layer header
+ *      @transport_header: Transport layer header
 *      @network_header: Network layer header
 *      @mac_header: Link layer header
 *      @dst: destination entry
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index c7a78eef2b4f..66611423c8ee 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -84,7 +84,8 @@ struct rpc_procinfo {
        u32                     p_proc;         /* RPC procedure number */
        kxdrproc_t              p_encode;       /* XDR encode function */
        kxdrproc_t              p_decode;       /* XDR decode function */
-        unsigned int            p_bufsiz;       /* req. buffer size */
+        unsigned int            p_arglen;       /* argument hdr length (u32) */
+        unsigned int            p_replen;       /* reply hdr length (u32) */
        unsigned int            p_count;        /* call count */
        unsigned int            p_timer;        /* Which RTT timer to use */
        u32                     p_statidx;      /* Which procedure to account */
@@ -121,8 +122,8 @@ struct rpc_clnt *rpc_clone_client(struct rpc_clnt *);
 int             rpc_shutdown_client(struct rpc_clnt *);
 int             rpc_destroy_client(struct rpc_clnt *);
 void            rpc_release_client(struct rpc_clnt *);
-void            rpc_getport(struct rpc_task *);
+int             rpcb_register(u32, u32, int, unsigned short, int *);
-int             rpc_register(u32, u32, int, unsigned short, int *);
+void            rpcb_getport(struct rpc_task *);
 void            rpc_call_setup(struct rpc_task *, struct rpc_message *, int);
@@ -144,7 +145,7 @@ char *		rpc_peeraddr2str(struct rpc_clnt *, enum rpc_display_format_t);
 /*
 * Helper function for NFSroot support
 */
-int             rpc_getport_external(struct sockaddr_in *, __u32, __u32, int);
+int             rpcb_getport_external(struct sockaddr_in *, __u32, __u32, int);
 #endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_CLNT_H */
diff --git a/include/linux/sunrpc/debug.h b/include/linux/sunrpc/debug.h
index b7c7307ceec6..3912cf16361e 100644
--- a/include/linux/sunrpc/debug.h
+++ b/include/linux/sunrpc/debug.h
@@ -17,7 +17,7 @@
 #define RPCDBG_DEBUG            0x0004
 #define RPCDBG_NFS              0x0008
 #define RPCDBG_AUTH             0x0010
-#define RPCDBG_PMAP             0x0020
+#define RPCDBG_BIND             0x0020
 #define RPCDBG_SCHED            0x0040
 #define RPCDBG_TRANS            0x0080
 #define RPCDBG_SVCSOCK          0x0100
diff --git a/include/linux/sunrpc/msg_prot.h b/include/linux/sunrpc/msg_prot.h
index 606cb2165232..784d4c3ef651 100644
--- a/include/linux/sunrpc/msg_prot.h
+++ b/include/linux/sunrpc/msg_prot.h
@@ -78,10 +78,6 @@ enum rpc_auth_stat {
        RPCSEC_GSS_CTXPROBLEM = 14
 };
-#define RPC_PMAP_PROGRAM        100000
-#define RPC_PMAP_VERSION        2
-#define RPC_PMAP_PORT           111
 #define RPC_MAXNETNAMELEN       256
 /*
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index 3069ecca0129..2047fb202a13 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -264,7 +264,7 @@ struct rpc_task *rpc_wake_up_next(struct rpc_wait_queue *);
 void            rpc_wake_up_status(struct rpc_wait_queue *, int);
 void            rpc_delay(struct rpc_task *, unsigned long);
 void *          rpc_malloc(struct rpc_task *, size_t);
-void            rpc_free(struct rpc_task *);
+void            rpc_free(void *);
 int             rpciod_up(void);
 void            rpciod_down(void);
 int             __rpc_wait_for_completion_task(struct rpc_task *task, int (*)(void *));
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index f780e72fc417..fa89ce6ce076 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -84,7 +84,9 @@ struct rpc_rqst {
        struct list_head        rq_list;
        __u32 *                 rq_buffer;      /* XDR encode buffer */
-        size_t                  rq_bufsize;
+        size_t                  rq_bufsize,
+                                rq_callsize,
+                                rq_rcvsize;
        struct xdr_buf          rq_private_buf;         /* The receive buffer
                                                         * used in the softirq.
@@ -112,7 +114,7 @@ struct rpc_xprt_ops {
        void            (*set_port)(struct rpc_xprt *xprt, unsigned short port);
        void            (*connect)(struct rpc_task *task);
        void *          (*buf_alloc)(struct rpc_task *task, size_t size);
-        void            (*buf_free)(struct rpc_task *task);
+        void            (*buf_free)(void *buffer);
        int             (*send_request)(struct rpc_task *task);
        void            (*set_retrans_timeout)(struct rpc_task *task);
        void            (*timer)(struct rpc_task *task);
@@ -150,6 +152,7 @@ struct rpc_xprt {
        unsigned long           state;          /* transport state */
        unsigned char           shutdown   : 1, /* being shut down */
                                resvport   : 1; /* use a reserved port */
+        unsigned int            bind_index;     /* bind function index */
        /*
         * Connection of transports
diff --git a/include/linux/tifm.h b/include/linux/tifm.h
index 3deb0a6c1370..2a196982601f 100644
--- a/include/linux/tifm.h
+++ b/include/linux/tifm.h
@@ -14,16 +14,16 @@
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
-#include <linux/wait.h>
 #include <linux/delay.h>
 #include <linux/pci.h>
-#include <linux/kthread.h>
+#include <linux/workqueue.h>
 /* Host registers (relative to pci base address): */
 enum {
        FM_SET_INTERRUPT_ENABLE   = 0x008,
        FM_CLEAR_INTERRUPT_ENABLE = 0x00c,
-        FM_INTERRUPT_STATUS       = 0x014 };
+        FM_INTERRUPT_STATUS       = 0x014
+};
 /* Socket registers (relative to socket base address): */
 enum {
@@ -58,14 +58,8 @@ enum {
        SOCK_MS_DATA                   = 0x188,
        SOCK_MS_STATUS                 = 0x18c,
        SOCK_MS_SYSTEM                 = 0x190,
-        SOCK_FIFO_ACCESS               = 0x200 };
+        SOCK_FIFO_ACCESS               = 0x200
+};
-#define TIFM_IRQ_ENABLE           0x80000000
-#define TIFM_IRQ_SOCKMASK(x)      (x)
-#define TIFM_IRQ_CARDMASK(x)      ((x) << 8)
-#define TIFM_IRQ_FIFOMASK(x)      ((x) << 16)
-#define TIFM_IRQ_SETALL           0xffffffff
 #define TIFM_CTRL_LED             0x00000040
 #define TIFM_CTRL_FAST_CLK        0x00000100
@@ -73,63 +67,76 @@ enum {
 #define TIFM_SOCK_STATE_OCCUPIED  0x00000008
 #define TIFM_SOCK_STATE_POWERED   0x00000080
-#define TIFM_FIFO_ENABLE          0x00000001 /* Meaning of this constant is unverified */
+#define TIFM_FIFO_ENABLE          0x00000001
+#define TIFM_FIFO_READY           0x00000001
 #define TIFM_FIFO_INT_SETALL      0x0000ffff
-#define TIFM_FIFO_INTMASK         0x00000005 /* Meaning of this constant is unverified */
+#define TIFM_FIFO_INTMASK         0x00000005
+#define TIFM_DMA_RESET            0x00000002
+#define TIFM_DMA_TX               0x00008000
+#define TIFM_DMA_EN               0x00000001
+#define TIFM_DMA_TSIZE            0x0000007f
-#define TIFM_DMA_RESET            0x00000002 /* Meaning of this constant is unverified */
+#define TIFM_TYPE_XD 1
-#define TIFM_DMA_TX               0x00008000 /* Meaning of this constant is unverified */
+#define TIFM_TYPE_MS 2
-#define TIFM_DMA_EN               0x00000001 /* Meaning of this constant is unverified */
+#define TIFM_TYPE_SD 3
-typedef enum {FM_NULL = 0, FM_XD = 0x01, FM_MS = 0x02, FM_SD = 0x03} tifm_media_id;
+struct tifm_device_id {
+        unsigned char type;
+};
 struct tifm_driver;
 struct tifm_dev {
-        char __iomem            *addr;
+        char __iomem  *addr;
-        spinlock_t              lock;
+        spinlock_t    lock;
-        tifm_media_id           media_id;
+        unsigned char type;
-        unsigned int            socket_id;
+        unsigned int  socket_id;
-        void                    (*signal_irq)(struct tifm_dev *sock,
+        void          (*card_event)(struct tifm_dev *sock);
-                                              unsigned int sock_irq_status);
+        void          (*data_event)(struct tifm_dev *sock);
-        struct tifm_driver      *drv;
+        struct device dev;
-        struct device           dev;
 };
 struct tifm_driver {
-        tifm_media_id        *id_table;
+        struct tifm_device_id *id_table;
-        int                  (*probe)(struct tifm_dev *dev);
+        int                   (*probe)(struct tifm_dev *dev);
-        void                 (*remove)(struct tifm_dev *dev);
+        void                  (*remove)(struct tifm_dev *dev);
-        int                  (*suspend)(struct tifm_dev *dev,
+        int                   (*suspend)(struct tifm_dev *dev,
-                                        pm_message_t state);
+                                         pm_message_t state);
-        int                  (*resume)(struct tifm_dev *dev);
+        int                   (*resume)(struct tifm_dev *dev);
-        struct device_driver driver;
+        struct device_driver  driver;
 };
 struct tifm_adapter {
-        char __iomem            *addr;
+        char __iomem        *addr;
-        spinlock_t              lock;
+        spinlock_t          lock;
-        unsigned int            irq_status;
+        unsigned int        irq_status;
-        unsigned int            socket_change_set;
+        unsigned int        socket_change_set;
-        wait_queue_head_t       change_set_notify;
+        unsigned int        id;
-        unsigned int            id;
+        unsigned int        num_sockets;
-        unsigned int            num_sockets;
+        struct completion   *finish_me;
-        struct tifm_dev         **sockets;
-        struct task_struct      *media_switcher;
+        struct work_struct  media_switcher;
-        struct class_device     cdev;
+        struct class_device cdev;
-        struct device           *dev;
+        void                (*eject)(struct tifm_adapter *fm,
-        void                    (*eject)(struct tifm_adapter *fm, struct tifm_dev *sock);
+                                     struct tifm_dev *sock);
+        struct tifm_dev     *sockets[0];
 };
-struct tifm_adapter *tifm_alloc_adapter(void);
+struct tifm_adapter *tifm_alloc_adapter(unsigned int num_sockets,
-void tifm_free_device(struct device *dev);
+                                        struct device *dev);
-void tifm_free_adapter(struct tifm_adapter *fm);
+int tifm_add_adapter(struct tifm_adapter *fm);
-int tifm_add_adapter(struct tifm_adapter *fm, int (*mediathreadfn)(void *data));
 void tifm_remove_adapter(struct tifm_adapter *fm);
-struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm);
+void tifm_free_adapter(struct tifm_adapter *fm);
+void tifm_free_device(struct device *dev);
+struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm, unsigned int id,
+                                   unsigned char type);
 int tifm_register_driver(struct tifm_driver *drv);
 void tifm_unregister_driver(struct tifm_driver *drv);
 void tifm_eject(struct tifm_dev *sock);
@@ -137,11 +144,11 @@ int tifm_map_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents,
                int direction);
 void tifm_unmap_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents,
                   int direction);
+void tifm_queue_work(struct work_struct *work);
 static inline void *tifm_get_drvdata(struct tifm_dev *dev)
 {
-        return dev_get_drvdata(&dev->dev);
+        return dev_get_drvdata(&dev->dev);
 }
 static inline void tifm_set_drvdata(struct tifm_dev *dev, void *data)
@@ -149,8 +156,4 @@ static inline void tifm_set_drvdata(struct tifm_dev *dev, void *data)
        dev_set_drvdata(&dev->dev, data);
 }
-struct tifm_device_id {
-        tifm_media_id media_id;
-};
 #endif
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 0c78f7f4a976..daa6c125f66e 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -59,6 +59,8 @@ struct writeback_control {
        unsigned for_reclaim:1;         /* Invoked from the page allocator */
        unsigned for_writepages:1;      /* This is a writepages() call */
        unsigned range_cyclic:1;        /* range_start is cyclic */
+        void *fs_private;               /* For use by ->writepages() */
 };
 /*
diff --git a/include/linux/xfrm.h b/include/linux/xfrm.h
index a5d53e0fe152..b58adc52448d 100644
--- a/include/linux/xfrm.h
+++ b/include/linux/xfrm.h
@@ -243,17 +243,6 @@ enum xfrm_ae_ftype_t {
 #define XFRM_AE_MAX (__XFRM_AE_MAX - 1)
 };
-/* SAD Table filter flags  */
-enum xfrm_sad_ftype_t {
-        XFRM_SAD_UNSPEC,
-        XFRM_SAD_HMASK=1,
-        XFRM_SAD_HMAX=2,
-        XFRM_SAD_CNT=4,
-        __XFRM_SAD_MAX
-#define XFRM_SAD_MAX (__XFRM_SAD_MAX - 1)
-};
 struct xfrm_userpolicy_type {
        __u8            type;
        __u16           reserved1;
@@ -287,44 +276,41 @@ enum xfrm_attr_type_t {
 enum xfrm_sadattr_type_t {
        XFRMA_SAD_UNSPEC,
-        XFRMA_SADHMASK,
+        XFRMA_SAD_CNT,
-        XFRMA_SADHMAX,
+        XFRMA_SAD_HINFO,
-        XFRMA_SADCNT,
        __XFRMA_SAD_MAX
 #define XFRMA_SAD_MAX (__XFRMA_SAD_MAX - 1)
 };
-/* SPD Table filter flags  */
+struct xfrmu_sadhinfo {
-enum xfrm_spd_ftype_t {
+        __u32 sadhcnt; /* current hash bkts */
-        XFRM_SPD_UNSPEC,
+        __u32 sadhmcnt; /* max allowed hash bkts */
-        XFRM_SPD_HMASK=1,
-        XFRM_SPD_HMAX=2,
-        XFRM_SPD_ICNT=4,
-        XFRM_SPD_OCNT=8,
-        XFRM_SPD_FCNT=16,
-        XFRM_SPD_ISCNT=32,
-        XFRM_SPD_OSCNT=64,
-        XFRM_SPD_FSCNT=128,
-        __XFRM_SPD_MAX
-#define XFRM_SPD_MAX (__XFRM_SPD_MAX - 1)
 };
 enum xfrm_spdattr_type_t {
        XFRMA_SPD_UNSPEC,
-        XFRMA_SPDHMASK,
+        XFRMA_SPD_INFO,
-        XFRMA_SPDHMAX,
+        XFRMA_SPD_HINFO,
-        XFRMA_SPDICNT,
-        XFRMA_SPDOCNT,
-        XFRMA_SPDFCNT,
-        XFRMA_SPDISCNT,
-        XFRMA_SPDOSCNT,
-        XFRMA_SPDFSCNT,
        __XFRMA_SPD_MAX
 #define XFRMA_SPD_MAX (__XFRMA_SPD_MAX - 1)
 };
+struct xfrmu_spdinfo {
+        __u32 incnt;
+        __u32 outcnt;
+        __u32 fwdcnt;
+        __u32 inscnt;
+        __u32 outscnt;
+        __u32 fwdscnt;
+};
+struct xfrmu_spdhinfo {
+        __u32 spdhcnt;
+        __u32 spdhmcnt;
+};
 struct xfrm_usersa_info {
        struct xfrm_selector            sel;
        struct xfrm_id                  id;
diff --git a/include/media/ovcamchip.h b/include/media/ovcamchip.h
index 0f43451f8bb3..05b9569ef1c8 100644
--- a/include/media/ovcamchip.h
+++ b/include/media/ovcamchip.h
@@ -16,7 +16,6 @@
 #include <linux/videodev.h>
 #include <media/v4l2-common.h>
-#include <linux/i2c.h>
 /* --------------------------------- */
 /*           ENUMERATIONS            */
diff --git a/include/media/tuner.h b/include/media/tuner.h
index a41ac41113ac..6dcf3c45707d 100644
--- a/include/media/tuner.h
+++ b/include/media/tuner.h
@@ -23,6 +23,7 @@
 #define _TUNER_H
 #include <linux/videodev2.h>
+#include <linux/i2c.h>
 #include <media/tuner-types.h>
 extern int tuner_debug;
diff --git a/include/net/ipv6.h b/include/net/ipv6.h
index f70afef9c3cc..4fa5dfe886c4 100644
--- a/include/net/ipv6.h
+++ b/include/net/ipv6.h
@@ -204,9 +204,9 @@ struct ip6_flowlabel
 {
        struct ip6_flowlabel    *next;
        __be32                  label;
+        atomic_t                users;
        struct in6_addr         dst;
        struct ipv6_txoptions   *opt;
-        atomic_t                users;
        unsigned long           linger;
        u8                      share;
        u32                     owner;
@@ -291,7 +291,7 @@ static inline int ipv6_addr_src_scope(const struct in6_addr *addr)
 static inline int ipv6_addr_cmp(const struct in6_addr *a1, const struct in6_addr *a2)
 {
-        return memcmp((const void *) a1, (const void *) a2, sizeof(struct in6_addr));
+        return memcmp(a1, a2, sizeof(struct in6_addr));
 }
 static inline int
@@ -308,7 +308,7 @@ ipv6_masked_addr_cmp(const struct in6_addr *a1, const struct in6_addr *m,
 static inline void ipv6_addr_copy(struct in6_addr *a1, const struct in6_addr *a2)
 {
-        memcpy((void *) a1, (const void *) a2, sizeof(struct in6_addr));
+        memcpy(a1, a2, sizeof(struct in6_addr));
 }
 static inline void ipv6_addr_prefix(struct in6_addr *pfx, 
@@ -319,16 +319,12 @@ static inline void ipv6_addr_prefix(struct in6_addr *pfx,
        int o = plen >> 3,
            b = plen & 0x7;
+        memset(pfx->s6_addr, 0, sizeof(pfx->s6_addr));
        memcpy(pfx->s6_addr, addr, o);
-        if (b != 0) {
+        if (b != 0)
                pfx->s6_addr[o] = addr->s6_addr[o] & (0xff00 >> b);
-                o++;
-        }
-        if (o < 16)
-                memset(pfx->s6_addr + o, 0, 16 - o);
 }
-#ifndef __HAVE_ARCH_ADDR_SET
 static inline void ipv6_addr_set(struct in6_addr *addr, 
                                     __be32 w1, __be32 w2,
                                     __be32 w3, __be32 w4)
@@ -338,7 +334,6 @@ static inline void ipv6_addr_set(struct in6_addr *addr,
        addr->s6_addr32[2] = w3;
        addr->s6_addr32[3] = w4;
 }
-#endif
 static inline int ipv6_addr_equal(const struct in6_addr *a1,
                                  const struct in6_addr *a2)
diff --git a/include/net/iucv/af_iucv.h b/include/net/iucv/af_iucv.h
index 04d1abb72d25..f9bd11be1891 100644
--- a/include/net/iucv/af_iucv.h
+++ b/include/net/iucv/af_iucv.h
@@ -28,6 +28,7 @@ enum {
        IUCV_LISTEN,
        IUCV_SEVERED,
        IUCV_DISCONN,
+        IUCV_CLOSING,
        IUCV_CLOSED
 };
@@ -62,6 +63,7 @@ struct iucv_sock {
        struct sock             *parent;
        struct iucv_path        *path;
        struct sk_buff_head     send_skb_q;
+        struct sk_buff_head     backlog_skb_q;
        unsigned int            send_tag;
 };
diff --git a/include/net/mac80211.h b/include/net/mac80211.h
new file mode 100644
index 000000000000..a7f122b79948
--- /dev/null
+++ b/include/net/mac80211.h
@@ -0,0 +1,1045 @@
+/*
+ * Low-level hardware driver -- IEEE 802.11 driver (80211.o) interface
+ * Copyright 2002-2005, Devicescape Software, Inc.
+ * Copyright 2006-2007  Jiri Benc <jbenc@suse.cz>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef MAC80211_H
+#define MAC80211_H
+#include <linux/kernel.h>
+#include <linux/if_ether.h>
+#include <linux/skbuff.h>
+#include <linux/wireless.h>
+#include <linux/device.h>
+#include <linux/ieee80211.h>
+#include <net/wireless.h>
+#include <net/cfg80211.h>
+/* Note! Only ieee80211_tx_status_irqsafe() and ieee80211_rx_irqsafe() can be
+ * called in hardware interrupt context. The low-level driver must not call any
+ * other functions in hardware interrupt context. If there is a need for such
+ * call, the low-level driver should first ACK the interrupt and perform the
+ * IEEE 802.11 code call after this, e.g., from a scheduled tasklet (in
+ * software interrupt context).
+ */
+/*
+ * Frame format used when passing frame between low-level hardware drivers
+ * and IEEE 802.11 driver the same as used in the wireless media, i.e.,
+ * buffers start with IEEE 802.11 header and include the same octets that
+ * are sent over air.
+ *
+ * If hardware uses IEEE 802.3 headers (and perform 802.3 <-> 802.11
+ * conversion in firmware), upper layer 802.11 code needs to be changed to
+ * support this.
+ *
+ * If the receive frame format is not the same as the real frame sent
+ * on the wireless media (e.g., due to padding etc.), upper layer 802.11 code
+ * could be updated to provide support for such format assuming this would
+ * optimize the performance, e.g., by removing need to re-allocation and
+ * copying of the data.
+ */
+#define IEEE80211_CHAN_W_SCAN 0x00000001
+#define IEEE80211_CHAN_W_ACTIVE_SCAN 0x00000002
+#define IEEE80211_CHAN_W_IBSS 0x00000004
+/* Channel information structure. Low-level driver is expected to fill in chan,
+ * freq, and val fields. Other fields will be filled in by 80211.o based on
+ * hostapd information and low-level driver does not need to use them. The
+ * limits for each channel will be provided in 'struct ieee80211_conf' when
+ * configuring the low-level driver with hw->config callback. If a device has
+ * a default regulatory domain, IEEE80211_HW_DEFAULT_REG_DOMAIN_CONFIGURED
+ * can be set to let the driver configure all fields */
+struct ieee80211_channel {
+        short chan; /* channel number (IEEE 802.11) */
+        short freq; /* frequency in MHz */
+        int val; /* hw specific value for the channel */
+        int flag; /* flag for hostapd use (IEEE80211_CHAN_*) */
+        unsigned char power_level;
+        unsigned char antenna_max;
+};
+#define IEEE80211_RATE_ERP 0x00000001
+#define IEEE80211_RATE_BASIC 0x00000002
+#define IEEE80211_RATE_PREAMBLE2 0x00000004
+#define IEEE80211_RATE_SUPPORTED 0x00000010
+#define IEEE80211_RATE_OFDM 0x00000020
+#define IEEE80211_RATE_CCK 0x00000040
+#define IEEE80211_RATE_TURBO 0x00000080
+#define IEEE80211_RATE_MANDATORY 0x00000100
+#define IEEE80211_RATE_CCK_2 (IEEE80211_RATE_CCK | IEEE80211_RATE_PREAMBLE2)
+#define IEEE80211_RATE_MODULATION(f) \
+        (f & (IEEE80211_RATE_CCK | IEEE80211_RATE_OFDM))
+/* Low-level driver should set PREAMBLE2, OFDM, CCK, and TURBO flags.
+ * BASIC, SUPPORTED, ERP, and MANDATORY flags are set in 80211.o based on the
+ * configuration. */
+struct ieee80211_rate {
+        int rate; /* rate in 100 kbps */
+        int val; /* hw specific value for the rate */
+        int flags; /* IEEE80211_RATE_ flags */
+        int val2; /* hw specific value for the rate when using short preamble
+                   * (only when IEEE80211_RATE_PREAMBLE2 flag is set, i.e., for
+                   * 2, 5.5, and 11 Mbps) */
+        signed char min_rssi_ack;
+        unsigned char min_rssi_ack_delta;
+        /* following fields are set by 80211.o and need not be filled by the
+         * low-level driver */
+        int rate_inv; /* inverse of the rate (LCM(all rates) / rate) for
+                       * optimizing channel utilization estimates */
+};
+/* 802.11g is backwards-compatible with 802.11b, so a wlan card can
+ * actually be both in 11b and 11g modes at the same time. */
+enum {
+        MODE_IEEE80211A, /* IEEE 802.11a */
+        MODE_IEEE80211B, /* IEEE 802.11b only */
+        MODE_ATHEROS_TURBO, /* Atheros Turbo mode (2x.11a at 5 GHz) */
+        MODE_IEEE80211G, /* IEEE 802.11g (and 802.11b compatibility) */
+        MODE_ATHEROS_TURBOG, /* Atheros Turbo mode (2x.11g at 2.4 GHz) */
+        /* keep last */
+        NUM_IEEE80211_MODES
+};
+struct ieee80211_hw_mode {
+        int mode; /* MODE_IEEE80211... */
+        int num_channels; /* Number of channels (below) */
+        struct ieee80211_channel *channels; /* Array of supported channels */
+        int num_rates; /* Number of rates (below) */
+        struct ieee80211_rate *rates; /* Array of supported rates */
+        struct list_head list; /* Internal, don't touch */
+};
+struct ieee80211_tx_queue_params {
+        int aifs; /* 0 .. 255; -1 = use default */
+        int cw_min; /* 2^n-1: 1, 3, 7, .. , 1023; 0 = use default */
+        int cw_max; /* 2^n-1: 1, 3, 7, .. , 1023; 0 = use default */
+        int burst_time; /* maximum burst time in 0.1 ms (i.e., 10 = 1 ms);
+                         * 0 = disabled */
+};
+struct ieee80211_tx_queue_stats_data {
+        unsigned int len; /* num packets in queue */
+        unsigned int limit; /* queue len (soft) limit */
+        unsigned int count; /* total num frames sent */
+};
+enum {
+        IEEE80211_TX_QUEUE_DATA0,
+        IEEE80211_TX_QUEUE_DATA1,
+        IEEE80211_TX_QUEUE_DATA2,
+        IEEE80211_TX_QUEUE_DATA3,
+        IEEE80211_TX_QUEUE_DATA4,
+        IEEE80211_TX_QUEUE_SVP,
+        NUM_TX_DATA_QUEUES,
+/* due to stupidity in the sub-ioctl userspace interface, the items in
+ * this struct need to have fixed values. As soon as it is removed, we can
+ * fix these entries. */
+        IEEE80211_TX_QUEUE_AFTER_BEACON = 6,
+        IEEE80211_TX_QUEUE_BEACON = 7
+};
+struct ieee80211_tx_queue_stats {
+        struct ieee80211_tx_queue_stats_data data[NUM_TX_DATA_QUEUES];
+};
+struct ieee80211_low_level_stats {
+        unsigned int dot11ACKFailureCount;
+        unsigned int dot11RTSFailureCount;
+        unsigned int dot11FCSErrorCount;
+        unsigned int dot11RTSSuccessCount;
+};
+/* Transmit control fields. This data structure is passed to low-level driver
+ * with each TX frame. The low-level driver is responsible for configuring
+ * the hardware to use given values (depending on what is supported). */
+#define HW_KEY_IDX_INVALID -1
+struct ieee80211_tx_control {
+        int tx_rate; /* Transmit rate, given as the hw specific value for the
+                      * rate (from struct ieee80211_rate) */
+        int rts_cts_rate; /* Transmit rate for RTS/CTS frame, given as the hw
+                           * specific value for the rate (from
+                           * struct ieee80211_rate) */
+#define IEEE80211_TXCTL_REQ_TX_STATUS   (1<<0)/* request TX status callback for
+                                                * this frame */
+#define IEEE80211_TXCTL_DO_NOT_ENCRYPT  (1<<1) /* send this frame without
+                                                * encryption; e.g., for EAPOL
+                                                * frames */
+#define IEEE80211_TXCTL_USE_RTS_CTS     (1<<2) /* use RTS-CTS before sending
+                                                * frame */
+#define IEEE80211_TXCTL_USE_CTS_PROTECT (1<<3) /* use CTS protection for the
+                                                * frame (e.g., for combined
+                                                * 802.11g / 802.11b networks) */
+#define IEEE80211_TXCTL_NO_ACK          (1<<4) /* tell the low level not to
+                                                * wait for an ack */
+#define IEEE80211_TXCTL_RATE_CTRL_PROBE (1<<5)
+#define IEEE80211_TXCTL_CLEAR_DST_MASK  (1<<6)
+#define IEEE80211_TXCTL_REQUEUE         (1<<7)
+#define IEEE80211_TXCTL_FIRST_FRAGMENT  (1<<8) /* this is a first fragment of
+                                                * the frame */
+#define IEEE80211_TXCTL_TKIP_NEW_PHASE1_KEY (1<<9)
+        u32 flags;                             /* tx control flags defined
+                                                * above */
+        u8 retry_limit;         /* 1 = only first attempt, 2 = one retry, .. */
+        u8 power_level;         /* per-packet transmit power level, in dBm */
+        u8 antenna_sel_tx;      /* 0 = default/diversity, 1 = Ant0, 2 = Ant1 */
+        s8 key_idx;             /* -1 = do not encrypt, >= 0 keyidx from
+                                 * hw->set_key() */
+        u8 icv_len;             /* length of the ICV/MIC field in octets */
+        u8 iv_len;              /* length of the IV field in octets */
+        u8 tkip_key[16];        /* generated phase2/phase1 key for hw TKIP */
+        u8 queue;               /* hardware queue to use for this frame;
+                                 * 0 = highest, hw->queues-1 = lowest */
+        u8 sw_retry_attempt;    /* number of times hw has tried to
+                                 * transmit frame (not incl. hw retries) */
+        struct ieee80211_rate *rate;            /* internal 80211.o rate */
+        struct ieee80211_rate *rts_rate;        /* internal 80211.o rate
+                                                 * for RTS/CTS */
+        int alt_retry_rate; /* retry rate for the last retries, given as the
+                             * hw specific value for the rate (from
+                             * struct ieee80211_rate). To be used to limit
+                             * packet dropping when probing higher rates, if hw
+                             * supports multiple retry rates. -1 = not used */
+        int type;       /* internal */
+        int ifindex;    /* internal */
+};
+/* Receive status. The low-level driver should provide this information
+ * (the subset supported by hardware) to the 802.11 code with each received
+ * frame. */
+struct ieee80211_rx_status {
+        u64 mactime;
+        int freq; /* receive frequency in Mhz */
+        int channel;
+        int phymode;
+        int ssi;
+        int signal; /* used as qual in statistics reporting */
+        int noise;
+        int antenna;
+        int rate;
+#define RX_FLAG_MMIC_ERROR      (1<<0)
+#define RX_FLAG_DECRYPTED       (1<<1)
+#define RX_FLAG_RADIOTAP        (1<<2)
+        int flag;
+};
+/* Transmit status. The low-level driver should provide this information
+ * (the subset supported by hardware) to the 802.11 code for each transmit
+ * frame. */
+struct ieee80211_tx_status {
+        /* copied ieee80211_tx_control structure */
+        struct ieee80211_tx_control control;
+#define IEEE80211_TX_STATUS_TX_FILTERED (1<<0)
+#define IEEE80211_TX_STATUS_ACK         (1<<1) /* whether the TX frame was ACKed */
+        u32 flags;              /* tx staus flags defined above */
+        int ack_signal; /* measured signal strength of the ACK frame */
+        int excessive_retries;
+        int retry_count;
+        int queue_length;      /* information about TX queue */
+        int queue_number;
+};
+/**
+ * struct ieee80211_conf - configuration of the device
+ *
+ * This struct indicates how the driver shall configure the hardware.
+ *
+ * @radio_enabled: when zero, driver is required to switch off the radio.
+ */
+struct ieee80211_conf {
+        int channel;                    /* IEEE 802.11 channel number */
+        int freq;                       /* MHz */
+        int channel_val;                /* hw specific value for the channel */
+        int phymode;                    /* MODE_IEEE80211A, .. */
+        struct ieee80211_channel *chan;
+        struct ieee80211_hw_mode *mode;
+        unsigned int regulatory_domain;
+        int radio_enabled;
+        int beacon_int;
+#define IEEE80211_CONF_SHORT_SLOT_TIME  (1<<0) /* use IEEE 802.11g Short Slot
+                                                * Time */
+#define IEEE80211_CONF_SSID_HIDDEN      (1<<1) /* do not broadcast the ssid */
+#define IEEE80211_CONF_RADIOTAP         (1<<2) /* use radiotap if supported
+                                                  check this bit at RX time */
+        u32 flags;                      /* configuration flags defined above */
+        u8 power_level;                 /* transmit power limit for current
+                                         * regulatory domain; in dBm */
+        u8 antenna_max;                 /* maximum antenna gain */
+        short tx_power_reduction; /* in 0.1 dBm */
+        /* 0 = default/diversity, 1 = Ant0, 2 = Ant1 */
+        u8 antenna_sel_tx;
+        u8 antenna_sel_rx;
+        int antenna_def;
+        int antenna_mode;
+        /* Following five fields are used for IEEE 802.11H */
+        unsigned int radar_detect;
+        unsigned int spect_mgmt;
+        /* All following fields are currently unused. */
+        unsigned int quiet_duration; /* duration of quiet period */
+        unsigned int quiet_offset; /* how far into the beacon is the quiet
+                                    * period */
+        unsigned int quiet_period;
+        u8 radar_firpwr_threshold;
+        u8 radar_rssi_threshold;
+        u8 pulse_height_threshold;
+        u8 pulse_rssi_threshold;
+        u8 pulse_inband_threshold;
+};
+/**
+ * enum ieee80211_if_types - types of 802.11 network interfaces
+ *
+ * @IEEE80211_IF_TYPE_AP: interface in AP mode.
+ * @IEEE80211_IF_TYPE_MGMT: special interface for communication with hostap
+ *      daemon. Drivers should never see this type.
+ * @IEEE80211_IF_TYPE_STA: interface in STA (client) mode.
+ * @IEEE80211_IF_TYPE_IBSS: interface in IBSS (ad-hoc) mode.
+ * @IEEE80211_IF_TYPE_MNTR: interface in monitor (rfmon) mode.
+ * @IEEE80211_IF_TYPE_WDS: interface in WDS mode.
+ * @IEEE80211_IF_TYPE_VLAN: not used.
+ */
+enum ieee80211_if_types {
+        IEEE80211_IF_TYPE_AP = 0x00000000,
+        IEEE80211_IF_TYPE_MGMT = 0x00000001,
+        IEEE80211_IF_TYPE_STA = 0x00000002,
+        IEEE80211_IF_TYPE_IBSS = 0x00000003,
+        IEEE80211_IF_TYPE_MNTR = 0x00000004,
+        IEEE80211_IF_TYPE_WDS = 0x5A580211,
+        IEEE80211_IF_TYPE_VLAN = 0x00080211,
+};
+/**
+ * struct ieee80211_if_init_conf - initial configuration of an interface
+ *
+ * @if_id: internal interface ID. This number has no particular meaning to
+ *      drivers and the only allowed usage is to pass it to
+ *      ieee80211_beacon_get() and ieee80211_get_buffered_bc() functions.
+ *      This field is not valid for monitor interfaces
+ *      (interfaces of %IEEE80211_IF_TYPE_MNTR type).
+ * @type: one of &enum ieee80211_if_types constants. Determines the type of
+ *      added/removed interface.
+ * @mac_addr: pointer to MAC address of the interface. This pointer is valid
+ *      until the interface is removed (i.e. it cannot be used after
+ *      remove_interface() callback was called for this interface).
+ *
+ * This structure is used in add_interface() and remove_interface()
+ * callbacks of &struct ieee80211_hw.
+ */
+struct ieee80211_if_init_conf {
+        int if_id;
+        int type;
+        void *mac_addr;
+};
+/**
+ * struct ieee80211_if_conf - configuration of an interface
+ *
+ * @type: type of the interface. This is always the same as was specified in
+ *      &struct ieee80211_if_init_conf. The type of an interface never changes
+ *      during the life of the interface; this field is present only for
+ *      convenience.
+ * @bssid: BSSID of the network we are associated to/creating.
+ * @ssid: used (together with @ssid_len) by drivers for hardware that
+ *      generate beacons independently. The pointer is valid only during the
+ *      config_interface() call, so copy the value somewhere if you need
+ *      it.
+ * @ssid_len: length of the @ssid field.
+ * @generic_elem: used (together with @generic_elem_len) by drivers for
+ *      hardware that generate beacons independently. The pointer is valid
+ *      only during the config_interface() call, so copy the value somewhere
+ *      if you need it.
+ * @generic_elem_len: length of the generic element.
+ * @beacon: beacon template. Valid only if @host_gen_beacon_template in
+ *      &struct ieee80211_hw is set. The driver is responsible of freeing
+ *      the sk_buff.
+ * @beacon_control: tx_control for the beacon template, this field is only
+ *      valid when the @beacon field was set.
+ *
+ * This structure is passed to the config_interface() callback of
+ * &struct ieee80211_hw.
+ */
+struct ieee80211_if_conf {
+        int type;
+        u8 *bssid;
+        u8 *ssid;
+        size_t ssid_len;
+        u8 *generic_elem;
+        size_t generic_elem_len;
+        struct sk_buff *beacon;
+        struct ieee80211_tx_control *beacon_control;
+};
+typedef enum { ALG_NONE, ALG_WEP, ALG_TKIP, ALG_CCMP, ALG_NULL }
+ieee80211_key_alg;
+struct ieee80211_key_conf {
+        int hw_key_idx;                 /* filled + used by low-level driver */
+        ieee80211_key_alg alg;
+        int keylen;
+#define IEEE80211_KEY_FORCE_SW_ENCRYPT (1<<0) /* to be cleared by low-level
+                                                 driver */
+#define IEEE80211_KEY_DEFAULT_TX_KEY   (1<<1) /* This key is the new default TX
+                                                 key (used only for broadcast
+                                                 keys). */
+#define IEEE80211_KEY_DEFAULT_WEP_ONLY (1<<2) /* static WEP is the only
+                                                 configured security policy;
+                                                 this allows some low-level
+                                                 drivers to determine when
+                                                 hwaccel can be used */
+        u32 flags; /* key configuration flags defined above */
+        s8 keyidx;                      /* WEP key index */
+        u8 key[0];
+};
+#define IEEE80211_SEQ_COUNTER_RX        0
+#define IEEE80211_SEQ_COUNTER_TX        1
+typedef enum {
+        SET_KEY, DISABLE_KEY, REMOVE_ALL_KEYS,
+} set_key_cmd;
+/* This is driver-visible part of the per-hw state the stack keeps. */
+struct ieee80211_hw {
+        /* points to the cfg80211 wiphy for this piece. Note
+         * that you must fill in the perm_addr and dev fields
+         * of this structure, use the macros provided below. */
+        struct wiphy *wiphy;
+        /* assigned by mac80211, don't write */
+        struct ieee80211_conf conf;
+        /* Single thread workqueue available for driver use
+         * Allocated by mac80211 on registration */
+        struct workqueue_struct *workqueue;
+        /* Pointer to the private area that was
+         * allocated with this struct for you. */
+        void *priv;
+        /* The rest is information about your hardware */
+        /* TODO: frame_type 802.11/802.3, sw_encryption requirements */
+        /* Some wireless LAN chipsets generate beacons in the hardware/firmware
+         * and others rely on host generated beacons. This option is used to
+         * configure the upper layer IEEE 802.11 module to generate beacons.
+         * The low-level driver can use ieee80211_beacon_get() to fetch the
+         * next beacon frame. */
+#define IEEE80211_HW_HOST_GEN_BEACON (1<<0)
+        /* The device needs to be supplied with a beacon template only. */
+#define IEEE80211_HW_HOST_GEN_BEACON_TEMPLATE (1<<1)
+        /* Some devices handle decryption internally and do not
+         * indicate whether the frame was encrypted (unencrypted frames
+         * will be dropped by the hardware, unless specifically allowed
+         * through) */
+#define IEEE80211_HW_DEVICE_HIDES_WEP (1<<2)
+        /* Whether RX frames passed to ieee80211_rx() include FCS in the end */
+#define IEEE80211_HW_RX_INCLUDES_FCS (1<<3)
+        /* Some wireless LAN chipsets buffer broadcast/multicast frames for
+         * power saving stations in the hardware/firmware and others rely on
+         * the host system for such buffering. This option is used to
+         * configure the IEEE 802.11 upper layer to buffer broadcast/multicast
+         * frames when there are power saving stations so that low-level driver
+         * can fetch them with ieee80211_get_buffered_bc(). */
+#define IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING (1<<4)
+#define IEEE80211_HW_WEP_INCLUDE_IV (1<<5)
+        /* will data nullfunc frames get proper TX status callback */
+#define IEEE80211_HW_DATA_NULLFUNC_ACK (1<<6)
+        /* Force software encryption for TKIP packets if WMM is enabled. */
+#define IEEE80211_HW_NO_TKIP_WMM_HWACCEL (1<<7)
+        /* Some devices handle Michael MIC internally and do not include MIC in
+         * the received packets passed up. device_strips_mic must be set
+         * for such devices. The 'encryption' frame control bit is expected to
+         * be still set in the IEEE 802.11 header with this option unlike with
+         * the device_hides_wep configuration option.
+         */
+#define IEEE80211_HW_DEVICE_STRIPS_MIC (1<<8)
+        /* Device is capable of performing full monitor mode even during
+         * normal operation. */
+#define IEEE80211_HW_MONITOR_DURING_OPER (1<<9)
+        /* Device does not need BSSID filter set to broadcast in order to
+         * receive all probe responses while scanning */
+#define IEEE80211_HW_NO_PROBE_FILTERING (1<<10)
+        /* Channels are already configured to the default regulatory domain
+         * specified in the device's EEPROM */
+#define IEEE80211_HW_DEFAULT_REG_DOMAIN_CONFIGURED (1<<11)
+        /* calculate Michael MIC for an MSDU when doing hwcrypto */
+#define IEEE80211_HW_TKIP_INCLUDE_MMIC (1<<12)
+        /* Do TKIP phase1 key mixing in stack to support cards only do
+         * phase2 key mixing when doing hwcrypto */
+#define IEEE80211_HW_TKIP_REQ_PHASE1_KEY (1<<13)
+        /* Do TKIP phase1 and phase2 key mixing in stack and send the generated
+         * per-packet RC4 key with each TX frame when doing hwcrypto */
+#define IEEE80211_HW_TKIP_REQ_PHASE2_KEY (1<<14)
+        u32 flags;                      /* hardware flags defined above */
+        /* Set to the size of a needed device specific skb headroom for TX skbs. */
+        unsigned int extra_tx_headroom;
+        /* This is the time in us to change channels
+         */
+        int channel_change_time;
+        /* Maximum values for various statistics.
+         * Leave at 0 to indicate no support. Use negative numbers for dBm. */
+        s8 max_rssi;
+        s8 max_signal;
+        s8 max_noise;
+        /* Number of available hardware TX queues for data packets.
+         * WMM requires at least four queues. */
+        int queues;
+};
+static inline void SET_IEEE80211_DEV(struct ieee80211_hw *hw, struct device *dev)
+{
+        set_wiphy_dev(hw->wiphy, dev);
+}
+static inline void SET_IEEE80211_PERM_ADDR(struct ieee80211_hw *hw, u8 *addr)
+{
+        memcpy(hw->wiphy->perm_addr, addr, ETH_ALEN);
+}
+/* Configuration block used by the low-level driver to tell the 802.11 code
+ * about supported hardware features and to pass function pointers to callback
+ * functions. */
+struct ieee80211_ops {
+        /* Handler that 802.11 module calls for each transmitted frame.
+         * skb contains the buffer starting from the IEEE 802.11 header.
+         * The low-level driver should send the frame out based on
+         * configuration in the TX control data.
+         * Must be atomic. */
+        int (*tx)(struct ieee80211_hw *hw, struct sk_buff *skb,
+                  struct ieee80211_tx_control *control);
+        /* Handler for performing hardware reset. */
+        int (*reset)(struct ieee80211_hw *hw);
+        /* Handler that is called when any netdevice attached to the hardware
+         * device is set UP for the first time. This can be used, e.g., to
+         * enable interrupts and beacon sending. */
+        int (*open)(struct ieee80211_hw *hw);
+        /* Handler that is called when the last netdevice attached to the
+         * hardware device is set DOWN. This can be used, e.g., to disable
+         * interrupts and beacon sending. */
+        int (*stop)(struct ieee80211_hw *hw);
+        /* Handler for asking a driver if a new interface can be added (or,
+         * more exactly, set UP). If the handler returns zero, the interface
+         * is added. Driver should perform any initialization it needs prior
+         * to returning zero. By returning non-zero addition of the interface
+         * is inhibited. Unless monitor_during_oper is set, it is guaranteed
+         * that monitor interfaces and normal interfaces are mutually
+         * exclusive. The open() handler is called after add_interface()
+         * if this is the first device added. At least one of the open()
+         * open() and add_interface() callbacks has to be assigned. If
+         * add_interface() is NULL, one STA interface is permitted only. */
+        int (*add_interface)(struct ieee80211_hw *hw,
+                             struct ieee80211_if_init_conf *conf);
+        /* Notify a driver that an interface is going down. The stop() handler
+         * is called prior to this if this is a last interface. */
+        void (*remove_interface)(struct ieee80211_hw *hw,
+                                 struct ieee80211_if_init_conf *conf);
+        /* Handler for configuration requests. IEEE 802.11 code calls this
+         * function to change hardware configuration, e.g., channel. */
+        int (*config)(struct ieee80211_hw *hw, struct ieee80211_conf *conf);
+        /* Handler for configuration requests related to interfaces (e.g.
+         * BSSID). */
+        int (*config_interface)(struct ieee80211_hw *hw,
+                                int if_id, struct ieee80211_if_conf *conf);
+        /* ieee80211 drivers do not have access to the &struct net_device
+         * that is (are) connected with their device. Hence (and because
+         * we need to combine the multicast lists and flags for multiple
+         * virtual interfaces), they cannot assign set_multicast_list.
+         * The parameters here replace dev->flags and dev->mc_count,
+         * dev->mc_list is replaced by calling ieee80211_get_mc_list_item.
+         * Must be atomic. */
+        void (*set_multicast_list)(struct ieee80211_hw *hw,
+                                   unsigned short flags, int mc_count);
+        /* Set TIM bit handler. If the hardware/firmware takes care of beacon
+         * generation, IEEE 802.11 code uses this function to tell the
+         * low-level to set (or clear if set==0) TIM bit for the given aid. If
+         * host system is used to generate beacons, this handler is not used
+         * and low-level driver should set it to NULL.
+         * Must be atomic. */
+        int (*set_tim)(struct ieee80211_hw *hw, int aid, int set);
+        /* Set encryption key. IEEE 802.11 module calls this function to set
+         * encryption keys. addr is ff:ff:ff:ff:ff:ff for default keys and
+         * station hwaddr for individual keys. aid of the station is given
+         * to help low-level driver in selecting which key->hw_key_idx to use
+         * for this key. TX control data will use the hw_key_idx selected by
+         * the low-level driver.
+         * Must be atomic. */
+        int (*set_key)(struct ieee80211_hw *hw, set_key_cmd cmd,
+                       u8 *addr, struct ieee80211_key_conf *key, int aid);
+        /* Set TX key index for default/broadcast keys. This is needed in cases
+         * where wlan card is doing full WEP/TKIP encapsulation (wep_include_iv
+         * is not set), in other cases, this function pointer can be set to
+         * NULL since the IEEE 802. 11 module takes care of selecting the key
+         * index for each TX frame. */
+        int (*set_key_idx)(struct ieee80211_hw *hw, int idx);
+        /* Enable/disable IEEE 802.1X. This item requests wlan card to pass
+         * unencrypted EAPOL-Key frames even when encryption is configured.
+         * If the wlan card does not require such a configuration, this
+         * function pointer can be set to NULL. */
+        int (*set_ieee8021x)(struct ieee80211_hw *hw, int use_ieee8021x);
+        /* Set port authorization state (IEEE 802.1X PAE) to be authorized
+         * (authorized=1) or unauthorized (authorized=0). This function can be
+         * used if the wlan hardware or low-level driver implements PAE.
+         * 80211.o module will anyway filter frames based on authorization
+         * state, so this function pointer can be NULL if low-level driver does
+         * not require event notification about port state changes.
+         * Currently unused. */
+        int (*set_port_auth)(struct ieee80211_hw *hw, u8 *addr,
+                             int authorized);
+        /* Ask the hardware to service the scan request, no need to start
+         * the scan state machine in stack. */
+        int (*hw_scan)(struct ieee80211_hw *hw, u8 *ssid, size_t len);
+        /* return low-level statistics */
+        int (*get_stats)(struct ieee80211_hw *hw,
+                         struct ieee80211_low_level_stats *stats);
+        /* For devices that generate their own beacons and probe response
+         * or association responses this updates the state of privacy_invoked
+         * returns 0 for success or an error number */
+        int (*set_privacy_invoked)(struct ieee80211_hw *hw,
+                                   int privacy_invoked);
+        /* For devices that have internal sequence counters, allow 802.11
+         * code to access the current value of a counter */
+        int (*get_sequence_counter)(struct ieee80211_hw *hw,
+                                    u8* addr, u8 keyidx, u8 txrx,
+                                    u32* iv32, u16* iv16);
+        /* Configuration of RTS threshold (if device needs it) */
+        int (*set_rts_threshold)(struct ieee80211_hw *hw, u32 value);
+        /* Configuration of fragmentation threshold.
+         * Assign this if the device does fragmentation by itself,
+         * if this method is assigned then the stack will not do
+         * fragmentation. */
+        int (*set_frag_threshold)(struct ieee80211_hw *hw, u32 value);
+        /* Configuration of retry limits (if device needs it) */
+        int (*set_retry_limit)(struct ieee80211_hw *hw,
+                               u32 short_retry, u32 long_retr);
+        /* Number of STAs in STA table notification (NULL = disabled).
+         * Must be atomic. */
+        void (*sta_table_notification)(struct ieee80211_hw *hw,
+                                       int num_sta);
+        /* Configure TX queue parameters (EDCF (aifs, cw_min, cw_max),
+         * bursting) for a hardware TX queue.
+         * queue = IEEE80211_TX_QUEUE_*.
+         * Must be atomic. */
+        int (*conf_tx)(struct ieee80211_hw *hw, int queue,
+                       const struct ieee80211_tx_queue_params *params);
+        /* Get statistics of the current TX queue status. This is used to get
+         * number of currently queued packets (queue length), maximum queue
+         * size (limit), and total number of packets sent using each TX queue
+         * (count).
+         * Currently unused. */
+        int (*get_tx_stats)(struct ieee80211_hw *hw,
+                            struct ieee80211_tx_queue_stats *stats);
+        /* Get the current TSF timer value from firmware/hardware. Currently,
+         * this is only used for IBSS mode debugging and, as such, is not a
+         * required function.
+         * Must be atomic. */
+        u64 (*get_tsf)(struct ieee80211_hw *hw);
+        /* Reset the TSF timer and allow firmware/hardware to synchronize with
+         * other STAs in the IBSS. This is only used in IBSS mode. This
+         * function is optional if the firmware/hardware takes full care of
+         * TSF synchronization. */
+        void (*reset_tsf)(struct ieee80211_hw *hw);
+        /* Setup beacon data for IBSS beacons. Unlike access point (Master),
+         * IBSS uses a fixed beacon frame which is configured using this
+         * function. This handler is required only for IBSS mode. */
+        int (*beacon_update)(struct ieee80211_hw *hw,
+                             struct sk_buff *skb,
+                             struct ieee80211_tx_control *control);
+        /* Determine whether the last IBSS beacon was sent by us. This is
+         * needed only for IBSS mode and the result of this function is used to
+         * determine whether to reply to Probe Requests. */
+        int (*tx_last_beacon)(struct ieee80211_hw *hw);
+};
+/* Allocate a new hardware device. This must be called once for each
+ * hardware device. The returned pointer must be used to refer to this
+ * device when calling other functions. 802.11 code allocates a private data
+ * area for the low-level driver. The size of this area is given as
+ * priv_data_len.
+ */
+struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
+                                        const struct ieee80211_ops *ops);
+/* Register hardware device to the IEEE 802.11 code and kernel. Low-level
+ * drivers must call this function before using any other IEEE 802.11
+ * function except ieee80211_register_hwmode. */
+int ieee80211_register_hw(struct ieee80211_hw *hw);
+/* driver can use this and ieee80211_get_rx_led_name to get the
+ * name of the registered LEDs after ieee80211_register_hw
+ * was called.
+ * This is useful to set the default trigger on the LED class
+ * device that your driver should export for each LED the device
+ * has, that way the default behaviour will be as expected but
+ * the user can still change it/turn off the LED etc.
+ */
+#ifdef CONFIG_MAC80211_LEDS
+extern char *__ieee80211_get_tx_led_name(struct ieee80211_hw *hw);
+extern char *__ieee80211_get_rx_led_name(struct ieee80211_hw *hw);
+#endif
+static inline char *ieee80211_get_tx_led_name(struct ieee80211_hw *hw)
+{
+#ifdef CONFIG_MAC80211_LEDS
+        return __ieee80211_get_tx_led_name(hw);
+#else
+        return NULL;
+#endif
+}
+static inline char *ieee80211_get_rx_led_name(struct ieee80211_hw *hw)
+{
+#ifdef CONFIG_MAC80211_LEDS
+        return __ieee80211_get_rx_led_name(hw);
+#else
+        return NULL;
+#endif
+}
+/* Register a new hardware PHYMODE capability to the stack. */
+int ieee80211_register_hwmode(struct ieee80211_hw *hw,
+                              struct ieee80211_hw_mode *mode);
+/* Unregister a hardware device. This function instructs 802.11 code to free
+ * allocated resources and unregister netdevices from the kernel. */
+void ieee80211_unregister_hw(struct ieee80211_hw *hw);
+/* Free everything that was allocated including private data of a driver. */
+void ieee80211_free_hw(struct ieee80211_hw *hw);
+/* Receive frame callback function. The low-level driver uses this function to
+ * send received frames to the IEEE 802.11 code. Receive buffer (skb) must
+ * start with IEEE 802.11 header. */
+void __ieee80211_rx(struct ieee80211_hw *hw, struct sk_buff *skb,
+                    struct ieee80211_rx_status *status);
+void ieee80211_rx_irqsafe(struct ieee80211_hw *hw,
+                          struct sk_buff *skb,
+                          struct ieee80211_rx_status *status);
+/* Transmit status callback function. The low-level driver must call this
+ * function to report transmit status for all the TX frames that had
+ * req_tx_status set in the transmit control fields. In addition, this should
+ * be called at least for all unicast frames to provide information for TX rate
+ * control algorithm. In order to maintain all statistics, this function is
+ * recommended to be called after each frame, including multicast/broadcast, is
+ * sent. */
+void ieee80211_tx_status(struct ieee80211_hw *hw,
+                         struct sk_buff *skb,
+                         struct ieee80211_tx_status *status);
+void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
+                                 struct sk_buff *skb,
+                                 struct ieee80211_tx_status *status);
+/**
+ * ieee80211_beacon_get - beacon generation function
+ * @hw: pointer obtained from ieee80211_alloc_hw().
+ * @if_id: interface ID from &struct ieee80211_if_init_conf.
+ * @control: will be filled with information needed to send this beacon.
+ *
+ * If the beacon frames are generated by the host system (i.e., not in
+ * hardware/firmware), the low-level driver uses this function to receive
+ * the next beacon frame from the 802.11 code. The low-level is responsible
+ * for calling this function before beacon data is needed (e.g., based on
+ * hardware interrupt). Returned skb is used only once and low-level driver
+ * is responsible of freeing it.
+ */
+struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw,
+                                     int if_id,
+                                     struct ieee80211_tx_control *control);
+/**
+ * ieee80211_rts_get - RTS frame generation function
+ * @hw: pointer obtained from ieee80211_alloc_hw().
+ * @frame: pointer to the frame that is going to be protected by the RTS.
+ * @frame_len: the frame length (in octets).
+ * @frame_txctl: &struct ieee80211_tx_control of the frame.
+ * @rts: The buffer where to store the RTS frame.
+ *
+ * If the RTS frames are generated by the host system (i.e., not in
+ * hardware/firmware), the low-level driver uses this function to receive
+ * the next RTS frame from the 802.11 code. The low-level is responsible
+ * for calling this function before and RTS frame is needed.
+ */
+void ieee80211_rts_get(struct ieee80211_hw *hw,
+                       const void *frame, size_t frame_len,
+                       const struct ieee80211_tx_control *frame_txctl,
+                       struct ieee80211_rts *rts);
+/**
+ * ieee80211_rts_duration - Get the duration field for an RTS frame
+ * @hw: pointer obtained from ieee80211_alloc_hw().
+ * @frame_len: the length of the frame that is going to be protected by the RTS.
+ * @frame_txctl: &struct ieee80211_tx_control of the frame.
+ *
+ * If the RTS is generated in firmware, but the host system must provide
+ * the duration field, the low-level driver uses this function to receive
+ * the duration field value in little-endian byteorder.
+ */
+__le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
+                              size_t frame_len,
+                              const struct ieee80211_tx_control *frame_txctl);
+/**
+ * ieee80211_ctstoself_get - CTS-to-self frame generation function
+ * @hw: pointer obtained from ieee80211_alloc_hw().
+ * @frame: pointer to the frame that is going to be protected by the CTS-to-self.
+ * @frame_len: the frame length (in octets).
+ * @frame_txctl: &struct ieee80211_tx_control of the frame.
+ * @cts: The buffer where to store the CTS-to-self frame.
+ *
+ * If the CTS-to-self frames are generated by the host system (i.e., not in
+ * hardware/firmware), the low-level driver uses this function to receive
+ * the next CTS-to-self frame from the 802.11 code. The low-level is responsible
+ * for calling this function before and CTS-to-self frame is needed.
+ */
+void ieee80211_ctstoself_get(struct ieee80211_hw *hw,
+                             const void *frame, size_t frame_len,
+                             const struct ieee80211_tx_control *frame_txctl,
+                             struct ieee80211_cts *cts);
+/**
+ * ieee80211_ctstoself_duration - Get the duration field for a CTS-to-self frame
+ * @hw: pointer obtained from ieee80211_alloc_hw().
+ * @frame_len: the length of the frame that is going to be protected by the CTS-to-self.
+ * @frame_txctl: &struct ieee80211_tx_control of the frame.
+ *
+ * If the CTS-to-self is generated in firmware, but the host system must provide
+ * the duration field, the low-level driver uses this function to receive
+ * the duration field value in little-endian byteorder.
+ */
+__le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
+                                    size_t frame_len,
+                                    const struct ieee80211_tx_control *frame_txctl);
+/**
+ * ieee80211_generic_frame_duration - Calculate the duration field for a frame
+ * @hw: pointer obtained from ieee80211_alloc_hw().
+ * @frame_len: the length of the frame.
+ * @rate: the rate (in 100kbps) at which the frame is going to be transmitted.
+ *
+ * Calculate the duration field of some generic frame, given its
+ * length and transmission rate (in 100kbps).
+ */
+__le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
+                                        size_t frame_len,
+                                        int rate);
+/**
+ * ieee80211_get_buffered_bc - accessing buffered broadcast and multicast frames
+ * @hw: pointer as obtained from ieee80211_alloc_hw().
+ * @if_id: interface ID from &struct ieee80211_if_init_conf.
+ * @control: will be filled with information needed to send returned frame.
+ *
+ * Function for accessing buffered broadcast and multicast frames. If
+ * hardware/firmware does not implement buffering of broadcast/multicast
+ * frames when power saving is used, 802.11 code buffers them in the host
+ * memory. The low-level driver uses this function to fetch next buffered
+ * frame. In most cases, this is used when generating beacon frame. This
+ * function returns a pointer to the next buffered skb or NULL if no more
+ * buffered frames are available.
+ *
+ * Note: buffered frames are returned only after DTIM beacon frame was
+ * generated with ieee80211_beacon_get() and the low-level driver must thus
+ * call ieee80211_beacon_get() first. ieee80211_get_buffered_bc() returns
+ * NULL if the previous generated beacon was not DTIM, so the low-level driver
+ * does not need to check for DTIM beacons separately and should be able to
+ * use common code for all beacons.
+ */
+struct sk_buff *
+ieee80211_get_buffered_bc(struct ieee80211_hw *hw, int if_id,
+                          struct ieee80211_tx_control *control);
+/* Low level drivers that have their own MLME and MAC indicate
+ * the aid for an associating station with this call */
+int ieee80211_set_aid_for_sta(struct ieee80211_hw *hw,
+                              u8 *peer_address, u16 aid);
+/* Given an sk_buff with a raw 802.11 header at the data pointer this function
+ * returns the 802.11 header length in bytes (not including encryption
+ * headers). If the data in the sk_buff is too short to contain a valid 802.11
+ * header the function returns 0.
+ */
+int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb);
+/* Like ieee80211_get_hdrlen_from_skb() but takes a FC in CPU order. */
+int ieee80211_get_hdrlen(u16 fc);
+/**
+ * ieee80211_wake_queue - wake specific queue
+ * @hw: pointer as obtained from ieee80211_alloc_hw().
+ * @queue: queue number (counted from zero).
+ *
+ * Drivers should use this function instead of netif_wake_queue.
+ */
+void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue);
+/**
+ * ieee80211_stop_queue - stop specific queue
+ * @hw: pointer as obtained from ieee80211_alloc_hw().
+ * @queue: queue number (counted from zero).
+ *
+ * Drivers should use this function instead of netif_stop_queue.
+ */
+void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue);
+/**
+ * ieee80211_start_queues - start all queues
+ * @hw: pointer to as obtained from ieee80211_alloc_hw().
+ *
+ * Drivers should use this function instead of netif_start_queue.
+ */
+void ieee80211_start_queues(struct ieee80211_hw *hw);
+/**
+ * ieee80211_stop_queues - stop all queues
+ * @hw: pointer as obtained from ieee80211_alloc_hw().
+ *
+ * Drivers should use this function instead of netif_stop_queue.
+ */
+void ieee80211_stop_queues(struct ieee80211_hw *hw);
+/**
+ * ieee80211_wake_queues - wake all queues
+ * @hw: pointer as obtained from ieee80211_alloc_hw().
+ *
+ * Drivers should use this function instead of netif_wake_queue.
+ */
+void ieee80211_wake_queues(struct ieee80211_hw *hw);
+/**
+ * ieee80211_get_mc_list_item - iteration over items in multicast list
+ * @hw: pointer as obtained from ieee80211_alloc_hw().
+ * @prev: value returned by previous call to ieee80211_get_mc_list_item() or
+ *      NULL to start a new iteration.
+ * @ptr: pointer to buffer of void * type for internal usage of
+ *      ieee80211_get_mc_list_item().
+ *
+ * Iterates over items in multicast list of given device. To get the first
+ * item, pass NULL in @prev and in *@ptr. In subsequent calls, pass the
+ * value returned by previous call in @prev. Don't alter *@ptr during
+ * iteration. When there are no more items, NULL is returned.
+ */
+struct dev_mc_list *
+ieee80211_get_mc_list_item(struct ieee80211_hw *hw,
+                           struct dev_mc_list *prev,
+                           void **ptr);
+/* called by driver to notify scan status completed */
+void ieee80211_scan_completed(struct ieee80211_hw *hw);
+/* Function to indicate Radar Detection. The low level driver must call this
+ * function to indicate the presence of radar in the current channel.
+ * Additionally the radar type also could be sent */
+int  ieee80211_radar_status(struct ieee80211_hw *hw, int channel,
+                            int radar, int radar_type);
+/* return a pointer to the source address (SA) */
+static inline u8 *ieee80211_get_SA(struct ieee80211_hdr *hdr)
+{
+        u8 *raw = (u8 *) hdr;
+        u8 tofrom = (*(raw+1)) & 3; /* get the TODS and FROMDS bits */
+        switch (tofrom) {
+                case 2:
+                        return hdr->addr3;
+                case 3:
+                        return hdr->addr4;
+        }
+        return hdr->addr2;
+}
+/* return a pointer to the destination address (DA) */
+static inline u8 *ieee80211_get_DA(struct ieee80211_hdr *hdr)
+{
+        u8 *raw = (u8 *) hdr;
+        u8 to_ds = (*(raw+1)) & 1; /* get the TODS bit */
+        if (to_ds)
+                return hdr->addr3;
+        return hdr->addr1;
+}
+static inline int ieee80211_get_morefrag(struct ieee80211_hdr *hdr)
+{
+        return (le16_to_cpu(hdr->frame_control) &
+                IEEE80211_FCTL_MOREFRAGS) != 0;
+}
+#define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
+#define MAC_ARG(x) ((u8*)(x))[0], ((u8*)(x))[1], ((u8*)(x))[2], \
+                   ((u8*)(x))[3], ((u8*)(x))[4], ((u8*)(x))[5]
+#endif /* MAC80211_H */
diff --git a/include/net/sctp/command.h b/include/net/sctp/command.h
index 6114c4f54b0a..f56c8d695a82 100644
--- a/include/net/sctp/command.h
+++ b/include/net/sctp/command.h
@@ -100,6 +100,8 @@ typedef enum {
        SCTP_CMD_T3_RTX_TIMERS_STOP, /* Stops T3-rtx pending timers */
        SCTP_CMD_FORCE_PRIM_RETRAN,  /* Forces retrans. over primary path. */
        SCTP_CMD_SET_SK_ERR,     /* Set sk_err */
+        SCTP_CMD_ASSOC_CHANGE,   /* generate and send assoc_change event */
+        SCTP_CMD_ADAPTATION_IND, /* generate and send adaptation event */
        SCTP_CMD_LAST
 } sctp_verb_t;
diff --git a/include/net/sctp/sctp.h b/include/net/sctp/sctp.h
index 28af68059521..dda72bf5b9b4 100644
--- a/include/net/sctp/sctp.h
+++ b/include/net/sctp/sctp.h
@@ -378,11 +378,15 @@ static inline int sctp_sysctl_jiffies_ms(ctl_table *table, int __user *name, int
 int sctp_v6_init(void);
 void sctp_v6_exit(void);
+int sctp_v6_add_protocol(void);
+void sctp_v6_del_protocol(void);
 #else /* #ifdef defined(CONFIG_IPV6) */
 static inline int sctp_v6_init(void) { return 0; }
 static inline void sctp_v6_exit(void) { return; }
+static inline int sctp_v6_add_protocol(void) { return 0; }
+static inline void sctp_v6_del_protocol(void) { return; }
 #endif /* #if defined(CONFIG_IPV6) */
diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h
index 7b4fff93ba7f..5e81984b8478 100644
--- a/include/net/sctp/structs.h
+++ b/include/net/sctp/structs.h
@@ -1857,6 +1857,7 @@ int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *,
 int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *,
                                         struct sctp_cookie*,
                                         gfp_t gfp);
+int sctp_assoc_set_id(struct sctp_association *, gfp_t);
 int sctp_cmp_addr_exact(const union sctp_addr *ss1,
                        const union sctp_addr *ss2);
diff --git a/include/net/tcp.h b/include/net/tcp.h
index ef8f9d4dae85..e22b4f0305a3 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -736,7 +736,8 @@ static inline __u32 tcp_current_ssthresh(const struct sock *sk)
 static inline void tcp_sync_left_out(struct tcp_sock *tp)
 {
-        BUG_ON(tp->sacked_out + tp->lost_out > tp->packets_out);
+        BUG_ON(tp->rx_opt.sack_ok &&
+               (tp->sacked_out + tp->lost_out > tp->packets_out));
        tp->left_out = tp->sacked_out + tp->lost_out;
 }
diff --git a/include/net/xfrm.h b/include/net/xfrm.h
index 66c2d3eec03c..39ef925d39dd 100644
--- a/include/net/xfrm.h
+++ b/include/net/xfrm.h
@@ -416,25 +416,6 @@ struct xfrm_audit
        u32     secid;
 };
-/* SAD metadata, add more later */
-struct xfrm_sadinfo
-{
-        u32 sadhcnt; /* current hash bkts */
-        u32 sadhmcnt; /* max allowed hash bkts */
-        u32 sadcnt; /* current running count */
-};
-struct xfrm_spdinfo
-{
-        u32 incnt;
-        u32 outcnt;
-        u32 fwdcnt;
-        u32 inscnt;
-        u32 outscnt;
-        u32 fwdscnt;
-        u32 spdhcnt;
-        u32 spdhmcnt;
-};
 #ifdef CONFIG_AUDITSYSCALL
 extern void xfrm_audit_log(uid_t auid, u32 secid, int type, int result,
                    struct xfrm_policy *xp, struct xfrm_state *x);
@@ -964,11 +945,29 @@ static inline int xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **s
        return -ENOSYS;
 }
 #endif
+struct xfrmk_sadinfo {
+        u32 sadhcnt; /* current hash bkts */
+        u32 sadhmcnt; /* max allowed hash bkts */
+        u32 sadcnt; /* current running count */
+};
+struct xfrmk_spdinfo {
+        u32 incnt;
+        u32 outcnt;
+        u32 fwdcnt;
+        u32 inscnt;
+        u32 outscnt;
+        u32 fwdscnt;
+        u32 spdhcnt;
+        u32 spdhmcnt;
+};
 extern struct xfrm_state *xfrm_find_acq_byseq(u32 seq);
 extern int xfrm_state_delete(struct xfrm_state *x);
 extern void xfrm_state_flush(u8 proto, struct xfrm_audit *audit_info);
-extern void xfrm_sad_getinfo(struct xfrm_sadinfo *si);
+extern void xfrm_sad_getinfo(struct xfrmk_sadinfo *si);
-extern void xfrm_spd_getinfo(struct xfrm_spdinfo *si);
+extern void xfrm_spd_getinfo(struct xfrmk_spdinfo *si);
 extern int xfrm_replay_check(struct xfrm_state *x, __be32 seq);
 extern void xfrm_replay_advance(struct xfrm_state *x, __be32 seq);
 extern void xfrm_replay_notify(struct xfrm_state *x, int event);
diff --git a/include/rdma/ib_mad.h b/include/rdma/ib_mad.h
index 585d28e960dd..739fa4d0e539 100644
--- a/include/rdma/ib_mad.h
+++ b/include/rdma/ib_mad.h
@@ -39,8 +39,6 @@
 #if !defined( IB_MAD_H )
 #define IB_MAD_H
-#include <linux/pci.h>
 #include <rdma/ib_verbs.h>
 /* Management base version */
diff --git a/include/scsi/iscsi_proto.h b/include/scsi/iscsi_proto.h
index 4a44278ed768..8d1e4e8026fe 100644
--- a/include/scsi/iscsi_proto.h
+++ b/include/scsi/iscsi_proto.h
@@ -588,7 +588,17 @@ struct iscsi_reject {
 #define VALUE_MAXLEN            255
 #define TARGET_NAME_MAXLEN      VALUE_MAXLEN
-#define DEFAULT_MAX_RECV_DATA_SEGMENT_LENGTH    8192
+#define ISCSI_DEF_MAX_RECV_SEG_LEN              8192
+#define ISCSI_MIN_MAX_RECV_SEG_LEN              512
+#define ISCSI_MAX_MAX_RECV_SEG_LEN              16777215
+#define ISCSI_DEF_FIRST_BURST_LEN               65536
+#define ISCSI_MIN_FIRST_BURST_LEN               512
+#define ISCSI_MAX_FIRST_BURST_LEN               16777215
+#define ISCSI_DEF_MAX_BURST_LEN                 262144
+#define ISCSI_MIN_MAX_BURST_LEN                 512
+#define ISCSI_MAX_MAX_BURST_LEN                 16777215
 /************************* RFC 3720 End *****************************/
diff --git a/include/scsi/scsi.h b/include/scsi/scsi.h
index 5c0e9791441c..9f8f80ab0c8b 100644
--- a/include/scsi/scsi.h
+++ b/include/scsi/scsi.h
@@ -203,6 +203,7 @@ static inline int scsi_status_is_good(int status)
 /*
 *  DEVICE TYPES
+ *  Please keep them in 0x%02x format for $MODALIAS to work
 */
 #define TYPE_DISK           0x00
diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h
index d6948d0e8cdb..a2e0c1032491 100644
--- a/include/scsi/scsi_cmnd.h
+++ b/include/scsi/scsi_cmnd.h
@@ -73,9 +73,6 @@ struct scsi_cmnd {
        unsigned short use_sg;  /* Number of pieces of scatter-gather */
        unsigned short sglist_len;      /* size of malloc'd scatter-gather list */
-        /* offset in cmd we are at (for multi-transfer tgt cmds) */
-        unsigned offset;
        unsigned underflow;     /* Return error if less than
                                   this amount is transferred */
diff --git a/include/scsi/scsi_dbg.h b/include/scsi/scsi_dbg.h
index 3bbbfbe8cbfc..5a43a4cd96c6 100644
--- a/include/scsi/scsi_dbg.h
+++ b/include/scsi/scsi_dbg.h
@@ -5,14 +5,16 @@ struct scsi_cmnd;
 struct scsi_sense_hdr;
 extern void scsi_print_command(struct scsi_cmnd *);
-extern void scsi_print_sense_hdr(const char *, struct scsi_sense_hdr *);
 extern void __scsi_print_command(unsigned char *);
-extern void scsi_print_sense(const char *, struct scsi_cmnd *);
+extern void scsi_show_extd_sense(unsigned char, unsigned char);
+extern void scsi_show_sense_hdr(struct scsi_sense_hdr *);
+extern void scsi_print_sense_hdr(const char *, struct scsi_sense_hdr *);
+extern void scsi_print_sense(char *, struct scsi_cmnd *);
 extern void __scsi_print_sense(const char *name,
                               const unsigned char *sense_buffer,
                               int sense_len);
-extern void scsi_print_driverbyte(int);
+extern void scsi_show_result(int);
-extern void scsi_print_hostbyte(int);
+extern void scsi_print_result(struct scsi_cmnd *);
 extern void scsi_print_status(unsigned char);
 extern const char *scsi_sense_key_string(unsigned char);
 extern const char *scsi_extd_sense_format(unsigned char, unsigned char);
diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h
index 9dd37e2f5a84..2f3c5b8b1d6a 100644
--- a/include/scsi/scsi_device.h
+++ b/include/scsi/scsi_device.h
@@ -5,6 +5,7 @@
 #include <linux/list.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
+#include <linux/blkdev.h>
 #include <asm/atomic.h>
 struct request_queue;
@@ -119,6 +120,7 @@ struct scsi_device {
        unsigned use_192_bytes_for_3f:1; /* ask for 192 bytes from page 0x3f */
        unsigned no_start_on_add:1;     /* do not issue start on add */
        unsigned allow_restart:1; /* issue START_UNIT in error handler */
+        unsigned manage_start_stop:1;   /* Let HLD (sd) manage start/stop */
        unsigned no_uld_attach:1; /* disable connecting to upper level drivers */
        unsigned select_no_atn:1;
        unsigned fix_capacity:1;        /* READ_CAPACITY is too high by 1 */
@@ -154,8 +156,11 @@ struct scsi_device {
 #define sdev_printk(prefix, sdev, fmt, a...)    \
        dev_printk(prefix, &(sdev)->sdev_gendev, fmt, ##a)
-#define scmd_printk(prefix, scmd, fmt, a...)    \
+#define scmd_printk(prefix, scmd, fmt, a...)                            \
-        dev_printk(prefix, &(scmd)->device->sdev_gendev, fmt, ##a)
+        (scmd)->request->rq_disk ?                                      \
+        sdev_printk(prefix, (scmd)->device, "[%s] " fmt,                \
+                    (scmd)->request->rq_disk->disk_name, ##a) :         \
+        sdev_printk(prefix, (scmd)->device, fmt, ##a)
 enum scsi_target_state {
        STARGET_RUNNING = 1,
@@ -353,4 +358,9 @@ static inline int scsi_device_qas(struct scsi_device *sdev)
                return 0;
        return sdev->inquiry[56] & 0x02;
 }
+#define MODULE_ALIAS_SCSI_DEVICE(type) \
+        MODULE_ALIAS("scsi:t-" __stringify(type) "*")
+#define SCSI_DEVICE_MODALIAS_FMT "scsi:t-0x%02x"
 #endif /* _SCSI_SCSI_DEVICE_H */
diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
index 7f1f411d07af..68f461b7a835 100644
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -129,6 +129,11 @@ struct scsi_host_template {
         * the LLD. When the driver is finished processing the command
         * the done callback is invoked.
         *
+         * This is called to inform the LLD to transfer
+         * cmd->request_bufflen bytes. The cmd->use_sg speciefies the
+         * number of scatterlist entried in the command and
+         * cmd->request_buffer contains the scatterlist.
+         *
         * return values: see queuecommand
         *
         * If the LLD accepts the cmd, it should set the result to an
@@ -139,20 +144,6 @@ struct scsi_host_template {
        /* TODO: rename */
        int (* transfer_response)(struct scsi_cmnd *,
                                  void (*done)(struct scsi_cmnd *));
-        /*
-         * This is called to inform the LLD to transfer cmd->request_bufflen
-         * bytes of the cmd at cmd->offset in the cmd. The cmd->use_sg
-         * speciefies the number of scatterlist entried in the command
-         * and cmd->request_buffer contains the scatterlist.
-         *
-         * If the command cannot be processed in one transfer_data call
-         * becuase a scatterlist within the LLD's limits cannot be
-         * created then transfer_data will be called multiple times.
-         * It is initially called from process context, and later
-         * calls are from the interrup context.
-         */
-        int (* transfer_data)(struct scsi_cmnd *,
-                              void (*done)(struct scsi_cmnd *));
        /* Used as callback for the completion of task management request. */
        int (* tsk_mgmt_response)(u64 mid, int result);
@@ -335,6 +326,19 @@ struct scsi_host_template {
        int (*proc_info)(struct Scsi_Host *, char *, char **, off_t, int, int);
        /*
+         * This is an optional routine that allows the transport to become
+         * involved when a scsi io timer fires. The return value tells the
+         * timer routine how to finish the io timeout handling:
+         * EH_HANDLED:          I fixed the error, please complete the command
+         * EH_RESET_TIMER:      I need more time, reset the timer and
+         *                      begin counting again
+         * EH_NOT_HANDLED       Begin normal error recovery
+         *
+         * Status: OPTIONAL
+         */
+        enum scsi_eh_timer_return (* eh_timed_out)(struct scsi_cmnd *);
+        /*
         * suspend support
         */
        int (*resume)(struct scsi_device *);
diff --git a/include/scsi/scsi_tgt_if.h b/include/scsi/scsi_tgt_if.h
index 07d6e77ae895..4cf9dff29a2f 100644
--- a/include/scsi/scsi_tgt_if.h
+++ b/include/scsi/scsi_tgt_if.h
@@ -45,11 +45,13 @@ struct tgt_event {
                /* user-> kernel */
                struct {
                        int host_no;
-                        uint32_t len;
                        int result;
+                        aligned_u64 tag;
                        aligned_u64 uaddr;
+                        aligned_u64 sense_uaddr;
+                        uint32_t len;
+                        uint32_t sense_len;
                        uint8_t rw;
-                        aligned_u64 tag;
                } cmd_rsp;
                struct {
                        int host_no;
diff --git a/include/scsi/scsi_transport_fc.h b/include/scsi/scsi_transport_fc.h
index 798f7c7ee426..1e797308640a 100644
--- a/include/scsi/scsi_transport_fc.h
+++ b/include/scsi/scsi_transport_fc.h
@@ -108,6 +108,8 @@ enum fc_port_state {
 #define FC_PORTSPEED_2GBIT              2
 #define FC_PORTSPEED_4GBIT              4
 #define FC_PORTSPEED_10GBIT             8
+#define FC_PORTSPEED_8GBIT              0x10
+#define FC_PORTSPEED_16GBIT             0x20
 #define FC_PORTSPEED_NOT_NEGOTIATED     (1 << 15) /* Speed not established */
 /*
diff --git a/include/scsi/sd.h b/include/scsi/sd.h
new file mode 100644
index 000000000000..5261488e1108
--- /dev/null
+++ b/include/scsi/sd.h
@@ -0,0 +1,72 @@
+#ifndef _SCSI_DISK_H
+#define _SCSI_DISK_H
+/*
+ * More than enough for everybody ;)  The huge number of majors
+ * is a leftover from 16bit dev_t days, we don't really need that
+ * much numberspace.
+ */
+#define SD_MAJORS       16
+/*
+ * This is limited by the naming scheme enforced in sd_probe,
+ * add another character to it if you really need more disks.
+ */
+#define SD_MAX_DISKS    (((26 * 26) + 26 + 1) * 26)
+/*
+ * Time out in seconds for disks and Magneto-opticals (which are slower).
+ */
+#define SD_TIMEOUT              (30 * HZ)
+#define SD_MOD_TIMEOUT          (75 * HZ)
+/*
+ * Number of allowed retries
+ */
+#define SD_MAX_RETRIES          5
+#define SD_PASSTHROUGH_RETRIES  1
+/*
+ * Size of the initial data buffer for mode and read capacity data
+ */
+#define SD_BUF_SIZE             512
+struct scsi_disk {
+        struct scsi_driver *driver;     /* always &sd_template */
+        struct scsi_device *device;
+        struct class_device cdev;
+        struct gendisk  *disk;
+        unsigned int    openers;        /* protected by BKL for now, yuck */
+        sector_t        capacity;       /* size in 512-byte sectors */
+        u32             index;
+        u8              media_present;
+        u8              write_prot;
+        unsigned        WCE : 1;        /* state of disk WCE bit */
+        unsigned        RCD : 1;        /* state of disk RCD bit, unused */
+        unsigned        DPOFUA : 1;     /* state of disk DPOFUA bit */
+};
+#define to_scsi_disk(obj) container_of(obj,struct scsi_disk,cdev)
+static int  sd_revalidate_disk(struct gendisk *disk);
+static void sd_rw_intr(struct scsi_cmnd * SCpnt);
+static int  sd_probe(struct device *);
+static int  sd_remove(struct device *);
+static void sd_shutdown(struct device *dev);
+static int sd_suspend(struct device *dev, pm_message_t state);
+static int sd_resume(struct device *dev);
+static void sd_rescan(struct device *);
+static int  sd_init_command(struct scsi_cmnd *);
+static int  sd_issue_flush(struct device *, sector_t *);
+static void sd_prepare_flush(request_queue_t *, struct request *);
+static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
+static void scsi_disk_release(struct class_device *cdev);
+static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
+static void sd_print_result(struct scsi_disk *, int);
+#define sd_printk(prefix, sdsk, fmt, a...)                              \
+        (sdsk)->disk ?                                                  \
+        sdev_printk(prefix, (sdsk)->device, "[%s] " fmt,                \
+                    (sdsk)->disk->disk_name, ##a) :                     \
+        sdev_printk(prefix, (sdsk)->device, fmt, ##a)
+#endif /* _SCSI_DISK_H */