244 files changed, 6931 insertions, 2679 deletions

diff --git a/include/linux/acct.h b/include/linux/acct.h
index 1993a3691768..9a66401073fc 100644
--- a/include/linux/acct.h
+++ b/include/linux/acct.h
@@ -16,6 +16,8 @@
 #define _LINUX_ACCT_H
 
 #include <linux/types.h>
+#include <linux/jiffies.h>
+
 #include <asm/param.h>
 #include <asm/byteorder.h>
 
@@ -117,12 +119,15 @@ struct acct_v3
 #include <linux/config.h>
 
 #ifdef CONFIG_BSD_PROCESS_ACCT
+struct vfsmount;
 struct super_block;
+extern void acct_auto_close_mnt(struct vfsmount *m);
 extern void acct_auto_close(struct super_block *sb);
 extern void acct_process(long exitcode);
 extern void acct_update_integrals(struct task_struct *tsk);
 extern void acct_clear_integrals(struct task_struct *tsk);
 #else
+#define acct_auto_close_mnt(x)  do { } while (0)
 #define acct_auto_close(x)      do { } while (0)
 #define acct_process(x)         do { } while (0)
 #define acct_update_integrals(x)                do { } while (0)
@@ -162,13 +167,13 @@ typedef struct acct acct_t;
 #ifdef __KERNEL__
 /*
  * Yet another set of HZ to *HZ helper functions.
- * See <linux/times.h> for the original.
+ * See <linux/jiffies.h> for the original.
  */
 
 static inline u32 jiffies_to_AHZ(unsigned long x)
 {
 #if (TICK_NSEC % (NSEC_PER_SEC / AHZ)) == 0
-        return x / (HZ / USER_HZ);
+        return x / (HZ / AHZ);
 #else
         u64 tmp = (u64)x * TICK_NSEC;
         do_div(tmp, (NSEC_PER_SEC / AHZ));
diff --git a/include/linux/aio.h b/include/linux/aio.h
index a4d5af907f90..49fd37629ee4 100644
--- a/include/linux/aio.h
+++ b/include/linux/aio.h
@@ -24,7 +24,12 @@ struct kioctx;
 #define KIOCB_SYNC_KEY          (~0U)
 
 /* ki_flags bits */
-#define KIF_LOCKED              0
+/*
+ * This may be used for cancel/retry serialization in the future, but
+ * for now it's unused and we probably don't want modules to even
+ * think they can use it.
+ */
+/* #define KIF_LOCKED           0 */
 #define KIF_KICKED              1
 #define KIF_CANCELLED           2
 
@@ -43,6 +48,40 @@ struct kioctx;
 #define kiocbIsKicked(iocb)     test_bit(KIF_KICKED, &(iocb)->ki_flags)
 #define kiocbIsCancelled(iocb)  test_bit(KIF_CANCELLED, &(iocb)->ki_flags)
 
+/* is there a better place to document function pointer methods? */
+/**
+ * ki_retry     -       iocb forward progress callback
+ * @kiocb:      The kiocb struct to advance by performing an operation.
+ *
+ * This callback is called when the AIO core wants a given AIO operation
+ * to make forward progress.  The kiocb argument describes the operation
+ * that is to be performed.  As the operation proceeds, perhaps partially,
+ * ki_retry is expected to update the kiocb with progress made.  Typically
+ * ki_retry is set in the AIO core and it itself calls file_operations
+ * helpers.
+ *
+ * ki_retry's return value determines when the AIO operation is completed
+ * and an event is generated in the AIO event ring.  Except the special
+ * return values described below, the value that is returned from ki_retry
+ * is transferred directly into the completion ring as the operation's
+ * resulting status.  Once this has happened ki_retry *MUST NOT* reference
+ * the kiocb pointer again.
+ *
+ * If ki_retry returns -EIOCBQUEUED it has made a promise that aio_complete()
+ * will be called on the kiocb pointer in the future.  The AIO core will
+ * not ask the method again -- ki_retry must ensure forward progress.
+ * aio_complete() must be called once and only once in the future, multiple
+ * calls may result in undefined behaviour.
+ *
+ * If ki_retry returns -EIOCBRETRY it has made a promise that kick_iocb()
+ * will be called on the kiocb pointer in the future.  This may happen
+ * through generic helpers that associate kiocb->ki_wait with a wait
+ * queue head that ki_retry uses via current->io_wait.  It can also happen
+ * with custom tracking and manual calls to kick_iocb(), though that is
+ * discouraged.  In either case, kick_iocb() must be called once and only
+ * once.  ki_retry must ensure forward progress, the AIO core will wait
+ * indefinitely for kick_iocb() to be called.
+ */
 struct kiocb {
         struct list_head        ki_run_list;
         long                    ki_flags;
@@ -85,7 +124,7 @@ struct kiocb {
                 (x)->ki_users = 1;                      \
                 (x)->ki_key = KIOCB_SYNC_KEY;           \
                 (x)->ki_filp = (filp);                  \
-                (x)->ki_ctx = &tsk->active_mm->default_kioctx;  \
+                (x)->ki_ctx = NULL;                     \
                 (x)->ki_cancel = NULL;                  \
                 (x)->ki_dtor = NULL;                    \
                 (x)->ki_obj.tsk = tsk;                  \
@@ -144,6 +183,7 @@ struct kioctx {
         struct list_head        active_reqs;    /* used for cancellation */
         struct list_head        run_list;       /* used for kicked reqs */
 
+        /* sys_io_setup currently limits this to an unsigned int */
         unsigned                max_reqs;
 
         struct aio_ring_info    ring_info;
@@ -170,8 +210,15 @@ struct kioctx *lookup_ioctx(unsigned long ctx_id);
 int FASTCALL(io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
                                   struct iocb *iocb));
 
-#define get_ioctx(kioctx)       do { if (unlikely(atomic_read(&(kioctx)->users) <= 0)) BUG(); atomic_inc(&(kioctx)->users); } while (0)
-#define put_ioctx(kioctx)       do { if (unlikely(atomic_dec_and_test(&(kioctx)->users))) __put_ioctx(kioctx); else if (unlikely(atomic_read(&(kioctx)->users) < 0)) BUG(); } while (0)
+#define get_ioctx(kioctx) do {                                          \
+        BUG_ON(unlikely(atomic_read(&(kioctx)->users) <= 0));           \
+        atomic_inc(&(kioctx)->users);                                   \
+} while (0)
+#define put_ioctx(kioctx) do {                                          \
+        BUG_ON(unlikely(atomic_read(&(kioctx)->users) <= 0));           \
+        if (unlikely(atomic_dec_and_test(&(kioctx)->users)))            \
+                __put_ioctx(kioctx);                                    \
+} while (0)
 
 #define in_aio() !is_sync_wait(current->io_wait)
 /* may be used for debugging */
@@ -195,7 +242,7 @@ static inline struct kiocb *list_kiocb(struct list_head *h)
 }
 
 /* for sysctl: */
-extern atomic_t aio_nr;
-extern unsigned aio_max_nr;
+extern unsigned long aio_nr;
+extern unsigned long aio_max_nr;
 
 #endif /* __LINUX__AIO_H */
diff --git a/include/linux/ata.h b/include/linux/ata.h
index a5b74efab067..d2873b732bb1 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -42,13 +42,18 @@ enum {
         ATA_SECT_SIZE           = 512,
 
         ATA_ID_WORDS            = 256,
-        ATA_ID_PROD_OFS         = 27,
-        ATA_ID_FW_REV_OFS       = 23,
         ATA_ID_SERNO_OFS        = 10,
-        ATA_ID_MAJOR_VER        = 80,
-        ATA_ID_PIO_MODES        = 64,
+        ATA_ID_FW_REV_OFS       = 23,
+        ATA_ID_PROD_OFS         = 27,
+        ATA_ID_OLD_PIO_MODES    = 51,
+        ATA_ID_FIELD_VALID      = 53,
         ATA_ID_MWDMA_MODES      = 63,
+        ATA_ID_PIO_MODES        = 64,
+        ATA_ID_EIDE_DMA_MIN     = 65,
+        ATA_ID_EIDE_PIO         = 67,
+        ATA_ID_EIDE_PIO_IORDY   = 68,
         ATA_ID_UDMA_MODES       = 88,
+        ATA_ID_MAJOR_VER        = 80,
         ATA_ID_PIO4             = (1 << 1),
 
         ATA_PCI_CTL_OFS         = 2,
@@ -128,10 +133,15 @@ enum {
         ATA_CMD_PIO_READ_EXT    = 0x24,
         ATA_CMD_PIO_WRITE       = 0x30,
         ATA_CMD_PIO_WRITE_EXT   = 0x34,
+        ATA_CMD_READ_MULTI      = 0xC4,
+        ATA_CMD_READ_MULTI_EXT  = 0x29,
+        ATA_CMD_WRITE_MULTI     = 0xC5,
+        ATA_CMD_WRITE_MULTI_EXT = 0x39,
         ATA_CMD_SET_FEATURES    = 0xEF,
         ATA_CMD_PACKET          = 0xA0,
         ATA_CMD_VERIFY          = 0x40,
         ATA_CMD_VERIFY_EXT      = 0x42,
+        ATA_CMD_INIT_DEV_PARAMS = 0x91,
 
         /* SETFEATURES stuff */
         SETFEATURES_XFER        = 0x03,
@@ -146,14 +156,14 @@ enum {
         XFER_MW_DMA_2           = 0x22,
         XFER_MW_DMA_1           = 0x21,
         XFER_MW_DMA_0           = 0x20,
+        XFER_SW_DMA_2           = 0x12,
+        XFER_SW_DMA_1           = 0x11,
+        XFER_SW_DMA_0           = 0x10,
         XFER_PIO_4              = 0x0C,
         XFER_PIO_3              = 0x0B,
         XFER_PIO_2              = 0x0A,
         XFER_PIO_1              = 0x09,
         XFER_PIO_0              = 0x08,
-        XFER_SW_DMA_2           = 0x12,
-        XFER_SW_DMA_1           = 0x11,
-        XFER_SW_DMA_0           = 0x10,
         XFER_PIO_SLOW           = 0x00,
 
         /* ATAPI stuff */
@@ -181,6 +191,7 @@ enum {
         ATA_TFLAG_ISADDR        = (1 << 1), /* enable r/w to nsect/lba regs */
         ATA_TFLAG_DEVICE        = (1 << 2), /* enable r/w to device reg */
         ATA_TFLAG_WRITE         = (1 << 3), /* data dir: host->dev==1 (write) */
+        ATA_TFLAG_LBA           = (1 << 4), /* enable LBA */
 };
 
 enum ata_tf_protocols {
@@ -250,7 +261,19 @@ struct ata_taskfile {
           ((u64) (id)[(n) + 1] << 16) | \
           ((u64) (id)[(n) + 0]) )
 
-static inline int atapi_cdb_len(u16 *dev_id)
+static inline int ata_id_current_chs_valid(const u16 *id)
+{
+        /* For ATA-1 devices, if the INITIALIZE DEVICE PARAMETERS command 
+           has not been issued to the device then the values of 
+           id[54] to id[56] are vendor specific. */
+        return (id[53] & 0x01) && /* Current translation valid */
+                id[54] &&  /* cylinders in current translation */
+                id[55] &&  /* heads in current translation */
+                id[55] <= 16 &&
+                id[56];    /* sectors in current translation */
+}
+
+static inline int atapi_cdb_len(const u16 *dev_id)
 {
         u16 tmp = dev_id[0] & 0x3;
         switch (tmp) {
@@ -260,7 +283,7 @@ static inline int atapi_cdb_len(u16 *dev_id)
         }
 }
 
-static inline int is_atapi_taskfile(struct ata_taskfile *tf)
+static inline int is_atapi_taskfile(const struct ata_taskfile *tf)
 {
         return (tf->protocol == ATA_PROT_ATAPI) ||
                (tf->protocol == ATA_PROT_ATAPI_NODATA) ||
diff --git a/include/linux/atmdev.h b/include/linux/atmdev.h
index 9f374cfa1b05..b203ea82a0a8 100644
--- a/include/linux/atmdev.h
+++ b/include/linux/atmdev.h
@@ -7,7 +7,6 @@
 #define LINUX_ATMDEV_H
 
 
-#include <linux/config.h>
 #include <linux/atmapi.h>
 #include <linux/atm.h>
 #include <linux/atmioc.h>
@@ -76,6 +75,13 @@ struct atm_dev_stats {
                                         /* set interface ESI */
 #define ATM_SETESIF     _IOW('a',ATMIOC_ITF+13,struct atmif_sioc)
                                         /* force interface ESI */
+#define ATM_ADDLECSADDR _IOW('a', ATMIOC_ITF+14, struct atmif_sioc)
+                                        /* register a LECS address */
+#define ATM_DELLECSADDR _IOW('a', ATMIOC_ITF+15, struct atmif_sioc)
+                                        /* unregister a LECS address */
+#define ATM_GETLECSADDR _IOW('a', ATMIOC_ITF+16, struct atmif_sioc)
+                                        /* retrieve LECS address(es) */
+
 #define ATM_GETSTAT     _IOW('a',ATMIOC_SARCOM+0,struct atmif_sioc)
                                         /* get AAL layer statistics */
 #define ATM_GETSTATZ    _IOW('a',ATMIOC_SARCOM+1,struct atmif_sioc)
@@ -203,6 +209,7 @@ struct atm_cirange {
 
 #ifdef __KERNEL__
 
+#include <linux/config.h>
 #include <linux/wait.h> /* wait_queue_head_t */
 #include <linux/time.h> /* struct timeval */
 #include <linux/net.h>
@@ -267,7 +274,7 @@ enum {
 
 
 enum {
-        ATM_DF_CLOSE,           /* close device when last VCC is closed */
+        ATM_DF_REMOVED,         /* device was removed from atm_devs list */
 };
 
 
@@ -328,6 +335,8 @@ struct atm_dev_addr {
         struct list_head entry;         /* next address */
 };
 
+enum atm_addr_type_t { ATM_ADDR_LOCAL, ATM_ADDR_LECS };
+
 struct atm_dev {
         const struct atmdev_ops *ops;   /* device operations; NULL if unused */
         const struct atmphy_ops *phy;   /* PHY operations, may be undefined */
@@ -338,6 +347,7 @@ struct atm_dev {
         void            *phy_data;      /* private PHY date */
         unsigned long   flags;          /* device flags (ATM_DF_*) */
         struct list_head local;         /* local ATM addresses */
+        struct list_head lecs;          /* LECS ATM addresses learned via ILMI */
         unsigned char   esi[ESI_LEN];   /* ESI ("MAC" addr) */
         struct atm_cirange ci_range;    /* VPI/VCI range */
         struct k_atm_dev_stats stats;   /* statistics */
@@ -405,7 +415,6 @@ struct atm_dev *atm_dev_register(const char *type,const struct atmdev_ops *ops,
     int number,unsigned long *flags); /* number == -1: pick first available */
 struct atm_dev *atm_dev_lookup(int number);
 void atm_dev_deregister(struct atm_dev *dev);
-void shutdown_atm_dev(struct atm_dev *dev);
 void vcc_insert_socket(struct sock *sk);
 
 
@@ -447,18 +456,19 @@ static inline void atm_dev_hold(struct atm_dev *dev)
 
 static inline void atm_dev_put(struct atm_dev *dev)
 {
-        atomic_dec(&dev->refcnt);
-
-        if ((atomic_read(&dev->refcnt) == 1) &&
-            test_bit(ATM_DF_CLOSE,&dev->flags))
-                shutdown_atm_dev(dev);
+        if (atomic_dec_and_test(&dev->refcnt)) {
+                BUG_ON(!test_bit(ATM_DF_REMOVED, &dev->flags));
+                if (dev->ops->dev_close)
+                        dev->ops->dev_close(dev);
+                kfree(dev);
+        }
 }
 
 
 int atm_charge(struct atm_vcc *vcc,int truesize);
 struct sk_buff *atm_alloc_charge(struct atm_vcc *vcc,int pdu_size,
-    int gfp_flags);
-int atm_pcr_goal(struct atm_trafprm *tp);
+    gfp_t gfp_flags);
+int atm_pcr_goal(const struct atm_trafprm *tp);
 
 void vcc_release_async(struct atm_vcc *vcc, int reply);
 
diff --git a/include/linux/audit.h b/include/linux/audit.h
index b2a2509bd7ea..da3c01955f3d 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -260,11 +260,11 @@ extern int audit_filter_user(struct netlink_skb_parms *cb, int type);
 #ifdef CONFIG_AUDIT
 /* These are defined in audit.c */
                                 /* Public API */
-extern void                 audit_log(struct audit_context *ctx, int gfp_mask,
+extern void                 audit_log(struct audit_context *ctx, gfp_t gfp_mask,
                                       int type, const char *fmt, ...)
                                       __attribute__((format(printf,4,5)));
 
-extern struct audit_buffer *audit_log_start(struct audit_context *ctx, int gfp_mask, int type);
+extern struct audit_buffer *audit_log_start(struct audit_context *ctx, gfp_t gfp_mask, int type);
 extern void                 audit_log_format(struct audit_buffer *ab,
                                              const char *fmt, ...)
                             __attribute__((format(printf,2,3)));
diff --git a/include/linux/bfs_fs.h b/include/linux/bfs_fs.h
index c1237aa92e38..8ed6dfdcd783 100644
--- a/include/linux/bfs_fs.h
+++ b/include/linux/bfs_fs.h
@@ -20,19 +20,19 @@
 
 /* BFS inode layout on disk */
 struct bfs_inode {
-        __u16 i_ino;
+        __le16 i_ino;
         __u16 i_unused;
-        __u32 i_sblock;
-        __u32 i_eblock;
-        __u32 i_eoffset;
-        __u32 i_vtype;
-        __u32 i_mode;
-        __s32 i_uid;
-        __s32 i_gid;
-        __u32 i_nlink;
-        __u32 i_atime;
-        __u32 i_mtime;
-        __u32 i_ctime;
+        __le32 i_sblock;
+        __le32 i_eblock;
+        __le32 i_eoffset;
+        __le32 i_vtype;
+        __le32 i_mode;
+        __le32 i_uid;
+        __le32 i_gid;
+        __le32 i_nlink;
+        __le32 i_atime;
+        __le32 i_mtime;
+        __le32 i_ctime;
         __u32 i_padding[4];
 };
 
@@ -41,17 +41,17 @@ struct bfs_inode {
 #define BFS_DIRS_PER_BLOCK      32
 
 struct bfs_dirent {
-        __u16 ino;
+        __le16 ino;
         char name[BFS_NAMELEN];
 };
 
 /* BFS superblock layout on disk */
 struct bfs_super_block {
-        __u32 s_magic;
-        __u32 s_start;
-        __u32 s_end;
-        __s32 s_from;
-        __s32 s_to;
+        __le32 s_magic;
+        __le32 s_start;
+        __le32 s_end;
+        __le32 s_from;
+        __le32 s_to;
         __s32 s_bfrom;
         __s32 s_bto;
         char  s_fsname[6];
@@ -66,15 +66,15 @@ struct bfs_super_block {
 #define BFS_INO2OFF(ino) \
         ((__u32)(((ino) - BFS_ROOT_INO) * sizeof(struct bfs_inode)) + BFS_BSIZE)
 #define BFS_NZFILESIZE(ip) \
-        ((cpu_to_le32((ip)->i_eoffset) + 1) -  cpu_to_le32((ip)->i_sblock) * BFS_BSIZE)
+        ((le32_to_cpu((ip)->i_eoffset) + 1) -  le32_to_cpu((ip)->i_sblock) * BFS_BSIZE)
 
 #define BFS_FILESIZE(ip) \
         ((ip)->i_sblock == 0 ? 0 : BFS_NZFILESIZE(ip))
 
 #define BFS_FILEBLOCKS(ip) \
-        ((ip)->i_sblock == 0 ? 0 : (cpu_to_le32((ip)->i_eblock) + 1) -  cpu_to_le32((ip)->i_sblock))
+        ((ip)->i_sblock == 0 ? 0 : (le32_to_cpu((ip)->i_eblock) + 1) -  le32_to_cpu((ip)->i_sblock))
 #define BFS_UNCLEAN(bfs_sb, sb) \
-        ((cpu_to_le32(bfs_sb->s_from) != -1) && (cpu_to_le32(bfs_sb->s_to) != -1) && !(sb->s_flags & MS_RDONLY))
+        ((le32_to_cpu(bfs_sb->s_from) != -1) && (le32_to_cpu(bfs_sb->s_to) != -1) && !(sb->s_flags & MS_RDONLY))
 
 
 #endif  /* _LINUX_BFS_FS_H */
diff --git a/include/linux/bio.h b/include/linux/bio.h
index 6e1c79c8b6bf..685fd3720df5 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -276,8 +276,8 @@ extern void bio_pair_release(struct bio_pair *dbio);
 extern struct bio_set *bioset_create(int, int, int);
 extern void bioset_free(struct bio_set *);
 
-extern struct bio *bio_alloc(unsigned int __nocast, int);
-extern struct bio *bio_alloc_bioset(unsigned int __nocast, int, struct bio_set *);
+extern struct bio *bio_alloc(gfp_t, int);
+extern struct bio *bio_alloc_bioset(gfp_t, int, struct bio_set *);
 extern void bio_put(struct bio *);
 extern void bio_free(struct bio *, struct bio_set *);
 
@@ -287,7 +287,7 @@ extern int bio_phys_segments(struct request_queue *, struct bio *);
 extern int bio_hw_segments(struct request_queue *, struct bio *);
 
 extern void __bio_clone(struct bio *, struct bio *);
-extern struct bio *bio_clone(struct bio *, unsigned int __nocast);
+extern struct bio *bio_clone(struct bio *, gfp_t);
 
 extern void bio_init(struct bio *);
 
@@ -301,7 +301,7 @@ extern struct bio *bio_map_user_iov(struct request_queue *,
                                     struct sg_iovec *, int, int);
 extern void bio_unmap_user(struct bio *);
 extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int,
-                                unsigned int);
+                                gfp_t);
 extern void bio_set_pages_dirty(struct bio *bio);
 extern void bio_check_pages_dirty(struct bio *bio);
 extern struct bio *bio_copy_user(struct request_queue *, unsigned long, unsigned int, int);
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index 86dd5502b05c..7d8ff97b3e92 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -40,6 +40,8 @@
  * bitmap_weight(src, nbits)                    Hamming Weight: number set bits
  * bitmap_shift_right(dst, src, n, nbits)       *dst = *src >> n
  * bitmap_shift_left(dst, src, n, nbits)        *dst = *src << n
+ * bitmap_remap(dst, src, old, new, nbits)      *dst = map(old, new)(src)
+ * bitmap_bitremap(oldbit, old, new, nbits)     newbit = map(old, new)(oldbit)
  * bitmap_scnprintf(buf, len, src, nbits)       Print bitmap src to buf
  * bitmap_parse(ubuf, ulen, dst, nbits)         Parse bitmap dst from user buf
  * bitmap_scnlistprintf(buf, len, src, nbits)   Print bitmap src as list to buf
@@ -104,6 +106,10 @@ extern int bitmap_scnlistprintf(char *buf, unsigned int len,
                         const unsigned long *src, int nbits);
 extern int bitmap_parselist(const char *buf, unsigned long *maskp,
                         int nmaskbits);
+extern void bitmap_remap(unsigned long *dst, const unsigned long *src,
+                const unsigned long *old, const unsigned long *new, int bits);
+extern int bitmap_bitremap(int oldbit,
+                const unsigned long *old, const unsigned long *new, int bits);
 extern int bitmap_find_free_region(unsigned long *bitmap, int bits, int order);
 extern void bitmap_release_region(unsigned long *bitmap, int pos, int order);
 extern int bitmap_allocate_region(unsigned long *bitmap, int pos, int order);
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index cb3c3ef50f50..38c2fb7ebe09 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -84,6 +84,16 @@ static __inline__ int get_bitmask_order(unsigned int count)
         return order;   /* We could be slightly more clever with -1 here... */
 }
 
+static __inline__ int get_count_order(unsigned int count)
+{
+        int order;
+        
+        order = fls(count) - 1;
+        if (count & (count - 1))
+                order++;
+        return order;
+}
+
 /*
  * hweightN: returns the hamming weight (i.e. the number
  * of bits set) of a N-bit word
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index efdc9b5bc05c..a33a31e71bbc 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -96,8 +96,8 @@ struct io_context {
 
 void put_io_context(struct io_context *ioc);
 void exit_io_context(void);
-struct io_context *current_io_context(int gfp_flags);
-struct io_context *get_io_context(int gfp_flags);
+struct io_context *current_io_context(gfp_t gfp_flags);
+struct io_context *get_io_context(gfp_t gfp_flags);
 void copy_io_context(struct io_context **pdst, struct io_context **psrc);
 void swap_io_context(struct io_context **ioc1, struct io_context **ioc2);
 
@@ -107,9 +107,9 @@ typedef void (rq_end_io_fn)(struct request *);
 struct request_list {
         int count[2];
         int starved[2];
+        int elvpriv;
         mempool_t *rq_pool;
         wait_queue_head_t wait[2];
-        wait_queue_head_t drain;
 };
 
 #define BLK_MAX_CDB     16
@@ -203,6 +203,7 @@ struct request {
 enum rq_flag_bits {
         __REQ_RW,               /* not set, read. set, write */
         __REQ_FAILFAST,         /* no low level driver retries */
+        __REQ_SORTED,           /* elevator knows about this request */
         __REQ_SOFTBARRIER,      /* may not be passed by ioscheduler */
         __REQ_HARDBARRIER,      /* may not be passed by drive either */
         __REQ_CMD,              /* is a regular fs rw request */
@@ -210,6 +211,7 @@ enum rq_flag_bits {
         __REQ_STARTED,          /* drive already may have started this one */
         __REQ_DONTPREP,         /* don't call prep for this one */
         __REQ_QUEUED,           /* uses queueing */
+        __REQ_ELVPRIV,          /* elevator private data attached */
         /*
          * for ATA/ATAPI devices
          */
@@ -235,6 +237,7 @@ enum rq_flag_bits {
 
 #define REQ_RW          (1 << __REQ_RW)
 #define REQ_FAILFAST    (1 << __REQ_FAILFAST)
+#define REQ_SORTED      (1 << __REQ_SORTED)
 #define REQ_SOFTBARRIER (1 << __REQ_SOFTBARRIER)
 #define REQ_HARDBARRIER (1 << __REQ_HARDBARRIER)
 #define REQ_CMD         (1 << __REQ_CMD)
@@ -242,6 +245,7 @@ enum rq_flag_bits {
 #define REQ_STARTED     (1 << __REQ_STARTED)
 #define REQ_DONTPREP    (1 << __REQ_DONTPREP)
 #define REQ_QUEUED      (1 << __REQ_QUEUED)
+#define REQ_ELVPRIV     (1 << __REQ_ELVPRIV)
 #define REQ_PC          (1 << __REQ_PC)
 #define REQ_BLOCK_PC    (1 << __REQ_BLOCK_PC)
 #define REQ_SENSE       (1 << __REQ_SENSE)
@@ -333,6 +337,12 @@ struct request_queue
         end_flush_fn            *end_flush_fn;
 
         /*
+         * Dispatch queue sorting
+         */
+        sector_t                end_sector;
+        struct request          *boundary_rq;
+
+        /*
          * Auto-unplugging state
          */
         struct timer_list       unplug_timer;
@@ -354,7 +364,7 @@ struct request_queue
          * queue needs bounce pages for pages above this limit
          */
         unsigned long           bounce_pfn;
-        unsigned int            bounce_gfp;
+        gfp_t                   bounce_gfp;
 
         /*
          * various queue flags, see QUEUE_* below
@@ -396,6 +406,7 @@ struct request_queue
 
         atomic_t                refcnt;
 
+        unsigned int            nr_sorted;
         unsigned int            in_flight;
 
         /*
@@ -405,8 +416,6 @@ struct request_queue
         unsigned int            sg_reserved_size;
         int                     node;
 
-        struct list_head        drain_list;
-
         /*
          * reserved for flush operations
          */
@@ -434,7 +443,7 @@ enum {
 #define QUEUE_FLAG_DEAD         5       /* queue being torn down */
 #define QUEUE_FLAG_REENTER      6       /* Re-entrancy avoidance */
 #define QUEUE_FLAG_PLUGGED      7       /* queue is plugged */
-#define QUEUE_FLAG_DRAIN        8       /* draining queue for sched switch */
+#define QUEUE_FLAG_ELVSWITCH    8       /* don't use elevator, just do FIFO */
 #define QUEUE_FLAG_FLUSH        9       /* doing barrier flush sequence */
 
 #define blk_queue_plugged(q)    test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags)
@@ -454,6 +463,7 @@ enum {
 #define blk_pm_request(rq)      \
         ((rq)->flags & (REQ_PM_SUSPEND | REQ_PM_RESUME))
 
+#define blk_sorted_rq(rq)       ((rq)->flags & REQ_SORTED)
 #define blk_barrier_rq(rq)      ((rq)->flags & REQ_HARDBARRIER)
 #define blk_barrier_preflush(rq)        ((rq)->flags & REQ_BAR_PREFLUSH)
 #define blk_barrier_postflush(rq)       ((rq)->flags & REQ_BAR_POSTFLUSH)
@@ -550,7 +560,7 @@ extern void generic_make_request(struct bio *bio);
 extern void blk_put_request(struct request *);
 extern void blk_end_sync_rq(struct request *rq);
 extern void blk_attempt_remerge(request_queue_t *, struct request *);
-extern struct request *blk_get_request(request_queue_t *, int, int);
+extern struct request *blk_get_request(request_queue_t *, int, gfp_t);
 extern void blk_insert_request(request_queue_t *, struct request *, int, void *);
 extern void blk_requeue_request(request_queue_t *, struct request *);
 extern void blk_plug_device(request_queue_t *);
@@ -565,7 +575,7 @@ extern void blk_run_queue(request_queue_t *);
 extern void blk_queue_activity_fn(request_queue_t *, activity_fn *, void *);
 extern int blk_rq_map_user(request_queue_t *, struct request *, void __user *, unsigned int);
 extern int blk_rq_unmap_user(struct bio *, unsigned int);
-extern int blk_rq_map_kern(request_queue_t *, struct request *, void *, unsigned int, unsigned int);
+extern int blk_rq_map_kern(request_queue_t *, struct request *, void *, unsigned int, gfp_t);
 extern int blk_rq_map_user_iov(request_queue_t *, struct request *, struct sg_iovec *, int);
 extern int blk_execute_rq(request_queue_t *, struct gendisk *,
                           struct request *, int);
@@ -611,12 +621,22 @@ extern void end_request(struct request *req, int uptodate);
 
 static inline void blkdev_dequeue_request(struct request *req)
 {
-        BUG_ON(list_empty(&req->queuelist));
+        elv_dequeue_request(req->q, req);
+}
 
-        list_del_init(&req->queuelist);
+/*
+ * This should be in elevator.h, but that requires pulling in rq and q
+ */
+static inline void elv_dispatch_add_tail(struct request_queue *q,
+                                         struct request *rq)
+{
+        if (q->last_merge == rq)
+                q->last_merge = NULL;
+        q->nr_sorted--;
 
-        if (req->rl)
-                elv_remove_request(req->q, req);
+        q->end_sector = rq_end_sector(rq);
+        q->boundary_rq = rq;
+        list_add_tail(&rq->queuelist, &q->queue_head);
 }
 
 /*
@@ -650,12 +670,10 @@ extern void blk_dump_rq_flags(struct request *, char *);
 extern void generic_unplug_device(request_queue_t *);
 extern void __generic_unplug_device(request_queue_t *);
 extern long nr_blockdev_pages(void);
-extern void blk_wait_queue_drained(request_queue_t *, int);
-extern void blk_finish_queue_drain(request_queue_t *);
 
 int blk_get_queue(request_queue_t *);
-request_queue_t *blk_alloc_queue(int gfp_mask);
-request_queue_t *blk_alloc_queue_node(int,int);
+request_queue_t *blk_alloc_queue(gfp_t);
+request_queue_t *blk_alloc_queue_node(gfp_t, int);
 #define blk_put_queue(q) blk_cleanup_queue((q))
 
 /*
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index 82bd8842d11c..3b03b0b868dd 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -43,7 +43,7 @@ typedef struct bootmem_data {
 extern unsigned long __init bootmem_bootmap_pages (unsigned long);
 extern unsigned long __init init_bootmem (unsigned long addr, unsigned long memend);
 extern void __init free_bootmem (unsigned long addr, unsigned long size);
-extern void * __init __alloc_bootmem (unsigned long size, unsigned long align, unsigned long goal);
+extern void * __init __alloc_bootmem_limit (unsigned long size, unsigned long align, unsigned long goal, unsigned long limit);
 #ifndef CONFIG_HAVE_ARCH_BOOTMEM_NODE
 extern void __init reserve_bootmem (unsigned long addr, unsigned long size);
 #define alloc_bootmem(x) \
@@ -54,6 +54,16 @@ extern void __init reserve_bootmem (unsigned long addr, unsigned long size);
         __alloc_bootmem((x), PAGE_SIZE, __pa(MAX_DMA_ADDRESS))
 #define alloc_bootmem_low_pages(x) \
         __alloc_bootmem((x), PAGE_SIZE, 0)
+
+#define alloc_bootmem_limit(x, limit)                                           \
+        __alloc_bootmem_limit((x), SMP_CACHE_BYTES, __pa(MAX_DMA_ADDRESS), (limit))
+#define alloc_bootmem_low_limit(x, limit)                       \
+        __alloc_bootmem_limit((x), SMP_CACHE_BYTES, 0, (limit))
+#define alloc_bootmem_pages_limit(x, limit)                                     \
+        __alloc_bootmem_limit((x), PAGE_SIZE, __pa(MAX_DMA_ADDRESS), (limit))
+#define alloc_bootmem_low_pages_limit(x, limit)         \
+        __alloc_bootmem_limit((x), PAGE_SIZE, 0, (limit))
+
 #endif /* !CONFIG_HAVE_ARCH_BOOTMEM_NODE */
 extern unsigned long __init free_all_bootmem (void);
 
@@ -61,7 +71,7 @@ extern unsigned long __init init_bootmem_node (pg_data_t *pgdat, unsigned long f
 extern void __init reserve_bootmem_node (pg_data_t *pgdat, unsigned long physaddr, unsigned long size);
 extern void __init free_bootmem_node (pg_data_t *pgdat, unsigned long addr, unsigned long size);
 extern unsigned long __init free_all_bootmem_node (pg_data_t *pgdat);
-extern void * __init __alloc_bootmem_node (pg_data_t *pgdat, unsigned long size, unsigned long align, unsigned long goal);
+extern void * __init __alloc_bootmem_node_limit (pg_data_t *pgdat, unsigned long size, unsigned long align, unsigned long goal, unsigned long limit);
 #ifndef CONFIG_HAVE_ARCH_BOOTMEM_NODE
 #define alloc_bootmem_node(pgdat, x) \
         __alloc_bootmem_node((pgdat), (x), SMP_CACHE_BYTES, __pa(MAX_DMA_ADDRESS))
@@ -69,6 +79,14 @@ extern void * __init __alloc_bootmem_node (pg_data_t *pgdat, unsigned long size,
         __alloc_bootmem_node((pgdat), (x), PAGE_SIZE, __pa(MAX_DMA_ADDRESS))
 #define alloc_bootmem_low_pages_node(pgdat, x) \
         __alloc_bootmem_node((pgdat), (x), PAGE_SIZE, 0)
+
+#define alloc_bootmem_node_limit(pgdat, x, limit)                               \
+        __alloc_bootmem_node_limit((pgdat), (x), SMP_CACHE_BYTES, __pa(MAX_DMA_ADDRESS), (limit))
+#define alloc_bootmem_pages_node_limit(pgdat, x, limit)                         \
+        __alloc_bootmem_node_limit((pgdat), (x), PAGE_SIZE, __pa(MAX_DMA_ADDRESS), (limit))
+#define alloc_bootmem_low_pages_node_limit(pgdat, x, limit)             \
+        __alloc_bootmem_node_limit((pgdat), (x), PAGE_SIZE, 0, (limit))
+
 #endif /* !CONFIG_HAVE_ARCH_BOOTMEM_NODE */
 
 #ifdef CONFIG_HAVE_ARCH_ALLOC_REMAP
@@ -105,5 +123,15 @@ extern void *__init alloc_large_system_hash(const char *tablename,
 #endif
 extern int __initdata hashdist;         /* Distribute hashes across NUMA nodes? */
 
+static inline void *__alloc_bootmem (unsigned long size, unsigned long align, unsigned long goal)
+{
+        return __alloc_bootmem_limit(size, align, goal, 0);
+}
+
+static inline void *__alloc_bootmem_node (pg_data_t *pgdat, unsigned long size, unsigned long align,
+                                     unsigned long goal)
+{
+        return __alloc_bootmem_node_limit(pgdat, size, align, goal, 0);
+}
 
 #endif /* _LINUX_BOOTMEM_H */
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 90828493791f..1db061bb6b08 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -126,8 +126,8 @@ BUFFER_FNS(Eopnotsupp, eopnotsupp)
 /* If we *know* page->private refers to buffer_heads */
 #define page_buffers(page)                                      \
         ({                                                      \
-                BUG_ON(!PagePrivate(page));             \
-                ((struct buffer_head *)(page)->private);        \
+                BUG_ON(!PagePrivate(page));                     \
+                ((struct buffer_head *)page_private(page));     \
         })
 #define page_has_buffers(page)  PagePrivate(page)
 
@@ -172,7 +172,7 @@ void __brelse(struct buffer_head *);
 void __bforget(struct buffer_head *);
 void __breadahead(struct block_device *, sector_t block, int size);
 struct buffer_head *__bread(struct block_device *, sector_t block, int size);
-struct buffer_head *alloc_buffer_head(unsigned int __nocast gfp_flags);
+struct buffer_head *alloc_buffer_head(gfp_t gfp_flags);
 void free_buffer_head(struct buffer_head * bh);
 void FASTCALL(unlock_buffer(struct buffer_head *bh));
 void FASTCALL(__lock_buffer(struct buffer_head *bh));
@@ -188,8 +188,9 @@ extern int buffer_heads_over_limit;
  * Generic address_space_operations implementations for buffer_head-backed
  * address_spaces.
  */
-int try_to_release_page(struct page * page, int gfp_mask);
+int try_to_release_page(struct page * page, gfp_t gfp_mask);
 int block_invalidatepage(struct page *page, unsigned long offset);
+int do_invalidatepage(struct page *page, unsigned long offset);
 int block_write_full_page(struct page *page, get_block_t *get_block,
                                 struct writeback_control *wbc);
 int block_read_full_page(struct page*, get_block_t*);
@@ -219,7 +220,7 @@ static inline void attach_page_buffers(struct page *page,
 {
         page_cache_get(page);
         SetPagePrivate(page);
-        page->private = (unsigned long)head;
+        set_page_private(page, (unsigned long)head);
 }
 
 static inline void get_bh(struct buffer_head *bh)
diff --git a/include/linux/cciss_ioctl.h b/include/linux/cciss_ioctl.h
index 424d5e622b43..6e27f42e3a57 100644
--- a/include/linux/cciss_ioctl.h
+++ b/include/linux/cciss_ioctl.h
@@ -10,8 +10,8 @@
 typedef struct _cciss_pci_info_struct
 {
         unsigned char   bus;
-        unsigned short  domain;
         unsigned char   dev_fn;
+        unsigned short  domain;
         __u32           board_id;
 } cciss_pci_info_struct; 
 
diff --git a/include/linux/cm4000_cs.h b/include/linux/cm4000_cs.h
new file mode 100644
index 000000000000..605ebe24bb2e
--- /dev/null
+++ b/include/linux/cm4000_cs.h
@@ -0,0 +1,66 @@
+#ifndef _CM4000_H_
+#define _CM4000_H_
+
+#define MAX_ATR                 33
+
+#define CM4000_MAX_DEV          4
+
+/* those two structures are passed via ioctl() from/to userspace.  They are
+ * used by existing userspace programs, so I kepth the awkward "bIFSD" naming
+ * not to break compilation of userspace apps. -HW */
+
+typedef struct atreq {
+        int32_t atr_len;
+        unsigned char atr[64];
+        int32_t power_act;
+        unsigned char bIFSD;
+        unsigned char bIFSC;
+} atreq_t;
+
+
+/* what is particularly stupid in the original driver is the arch-dependant
+ * member sizes. This leads to CONFIG_COMPAT breakage, since 32bit userspace
+ * will lay out the structure members differently than the 64bit kernel.
+ *
+ * I've changed "ptsreq.protocol" from "unsigned long" to "u_int32_t".
+ * On 32bit this will make no difference.  With 64bit kernels, it will make
+ * 32bit apps work, too.
+ */
+
+typedef struct ptsreq {
+        u_int32_t protocol; /*T=0: 2^0, T=1:  2^1*/
+        unsigned char flags;
+        unsigned char pts1;
+        unsigned char pts2;
+        unsigned char pts3;
+} ptsreq_t;
+
+#define CM_IOC_MAGIC            'c'
+#define CM_IOC_MAXNR            255
+
+#define CM_IOCGSTATUS           _IOR (CM_IOC_MAGIC, 0, unsigned char *)
+#define CM_IOCGATR              _IOWR(CM_IOC_MAGIC, 1, atreq_t *)
+#define CM_IOCSPTS              _IOW (CM_IOC_MAGIC, 2, ptsreq_t *)
+#define CM_IOCSRDR              _IO  (CM_IOC_MAGIC, 3)
+#define CM_IOCARDOFF            _IO  (CM_IOC_MAGIC, 4)
+
+#define CM_IOSDBGLVL            _IOW(CM_IOC_MAGIC, 250, int*)
+
+/* card and device states */
+#define CM_CARD_INSERTED                0x01
+#define CM_CARD_POWERED                 0x02
+#define CM_ATR_PRESENT                  0x04
+#define CM_ATR_VALID                    0x08
+#define CM_STATE_VALID                  0x0f
+/* extra info only from CM4000 */
+#define CM_NO_READER                    0x10
+#define CM_BAD_CARD                     0x20
+
+
+#ifdef __KERNEL__
+
+#define DEVICE_NAME             "cmm"
+#define MODULE_NAME             "cm4000_cs"
+
+#endif  /* __KERNEL__ */
+#endif  /* _CM4000_H_ */
diff --git a/include/linux/cn_proc.h b/include/linux/cn_proc.h
new file mode 100644
index 000000000000..c948f678e04e
--- /dev/null
+++ b/include/linux/cn_proc.h
@@ -0,0 +1,127 @@
+/*
+ * cn_proc.h - process events connector
+ *
+ * Copyright (C) Matt Helsley, IBM Corp. 2005
+ * Based on cn_fork.h by Nguyen Anh Quynh and Guillaume Thouvenin
+ * Original copyright notice follows:
+ * Copyright (C) 2005 Nguyen Anh Quynh <aquynh@gmail.com>
+ * Copyright (C) 2005 Guillaume Thouvenin <guillaume.thouvenin@bull.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef CN_PROC_H
+#define CN_PROC_H
+
+#include <linux/types.h>
+#include <linux/connector.h>
+
+/*
+ * Userspace sends this enum to register with the kernel that it is listening
+ * for events on the connector.
+ */
+enum proc_cn_mcast_op {
+        PROC_CN_MCAST_LISTEN = 1,
+        PROC_CN_MCAST_IGNORE = 2
+};
+
+/*
+ * From the user's point of view, the process
+ * ID is the thread group ID and thread ID is the internal
+ * kernel "pid". So, fields are assigned as follow:
+ *
+ *  In user space     -  In  kernel space
+ *
+ * parent process ID  =  parent->tgid
+ * parent thread  ID  =  parent->pid
+ * child  process ID  =  child->tgid
+ * child  thread  ID  =  child->pid
+ */
+
+struct proc_event {
+        enum what {
+                /* Use successive bits so the enums can be used to record
+                 * sets of events as well
+                 */
+                PROC_EVENT_NONE = 0x00000000,
+                PROC_EVENT_FORK = 0x00000001,
+                PROC_EVENT_EXEC = 0x00000002,
+                PROC_EVENT_UID  = 0x00000004,
+                PROC_EVENT_GID  = 0x00000040,
+                /* "next" should be 0x00000400 */
+                /* "last" is the last process event: exit */
+                PROC_EVENT_EXIT = 0x80000000
+        } what;
+        __u32 cpu;
+        union { /* must be last field of proc_event struct */
+                struct {
+                        __u32 err;
+                } ack;
+
+                struct fork_proc_event {
+                        pid_t parent_pid;
+                        pid_t parent_tgid;
+                        pid_t child_pid;
+                        pid_t child_tgid;
+                } fork;
+
+                struct exec_proc_event {
+                        pid_t process_pid;
+                        pid_t process_tgid;
+                } exec;
+
+                struct id_proc_event {
+                        pid_t process_pid;
+                        pid_t process_tgid;
+                        union {
+                                __u32 ruid; /* task uid */
+                                __u32 rgid; /* task gid */
+                        } r;
+                        union {
+                                __u32 euid;
+                                __u32 egid;
+                        } e;
+                } id;
+
+                struct exit_proc_event {
+                        pid_t process_pid;
+                        pid_t process_tgid;
+                        __u32 exit_code, exit_signal;
+                } exit;
+        } event_data;
+};
+
+#ifdef __KERNEL__
+#ifdef CONFIG_PROC_EVENTS
+void proc_fork_connector(struct task_struct *task);
+void proc_exec_connector(struct task_struct *task);
+void proc_id_connector(struct task_struct *task, int which_id);
+void proc_exit_connector(struct task_struct *task);
+#else
+static inline void proc_fork_connector(struct task_struct *task)
+{}
+
+static inline void proc_exec_connector(struct task_struct *task)
+{}
+
+static inline void proc_id_connector(struct task_struct *task,
+                                     int which_id)
+{}
+
+static inline void proc_exit_connector(struct task_struct *task)
+{}
+#endif  /* CONFIG_PROC_EVENTS */
+#endif  /* __KERNEL__ */
+#endif  /* CN_PROC_H */
diff --git a/include/linux/compat_ioctl.h b/include/linux/compat_ioctl.h
index ecb0d39c0798..119f9d064cc6 100644
--- a/include/linux/compat_ioctl.h
+++ b/include/linux/compat_ioctl.h
@@ -10,6 +10,10 @@
 #define ULONG_IOCTL(cmd)  HANDLE_IOCTL((cmd),(ioctl_trans_handler_t)sys_ioctl)
 #endif
 
+
+COMPATIBLE_IOCTL(0x4B50)   /* KDGHWCLK - not in the kernel, but don't complain */
+COMPATIBLE_IOCTL(0x4B51)   /* KDSHWCLK - not in the kernel, but don't complain */
+
 /* Big T */
 COMPATIBLE_IOCTL(TCGETA)
 COMPATIBLE_IOCTL(TCSETA)
@@ -52,13 +56,6 @@ ULONG_IOCTL(TIOCSCTTY)
 COMPATIBLE_IOCTL(TIOCGPTN)
 COMPATIBLE_IOCTL(TIOCSPTLCK)
 COMPATIBLE_IOCTL(TIOCSERGETLSR)
-/* Big F */
-COMPATIBLE_IOCTL(FBIOBLANK)
-COMPATIBLE_IOCTL(FBIOGET_VSCREENINFO)
-COMPATIBLE_IOCTL(FBIOPUT_VSCREENINFO)
-COMPATIBLE_IOCTL(FBIOPAN_DISPLAY)
-COMPATIBLE_IOCTL(FBIOGET_CON2FBMAP)
-COMPATIBLE_IOCTL(FBIOPUT_CON2FBMAP)
 /* Little f */
 COMPATIBLE_IOCTL(FIOCLEX)
 COMPATIBLE_IOCTL(FIONCLEX)
@@ -81,6 +78,8 @@ COMPATIBLE_IOCTL(HDIO_DRIVE_CMD)
 COMPATIBLE_IOCTL(HDIO_DRIVE_TASK)
 COMPATIBLE_IOCTL(HDIO_SET_PIO_MODE)
 COMPATIBLE_IOCTL(HDIO_SET_NICE)
+COMPATIBLE_IOCTL(HDIO_SET_KEEPSETTINGS)
+COMPATIBLE_IOCTL(HDIO_SCAN_HWIF)
 /* 0x02 -- Floppy ioctls */
 COMPATIBLE_IOCTL(FDMSGON)
 COMPATIBLE_IOCTL(FDMSGOFF)
@@ -99,6 +98,7 @@ COMPATIBLE_IOCTL(FDTWADDLE)
 COMPATIBLE_IOCTL(FDFMTTRK)
 COMPATIBLE_IOCTL(FDRAWCMD)
 /* 0x12 */
+COMPATIBLE_IOCTL(BLKRASET)
 COMPATIBLE_IOCTL(BLKROSET)
 COMPATIBLE_IOCTL(BLKROGET)
 COMPATIBLE_IOCTL(BLKRRPART)
@@ -259,9 +259,18 @@ COMPATIBLE_IOCTL(RTC_RD_TIME)
 COMPATIBLE_IOCTL(RTC_SET_TIME)
 COMPATIBLE_IOCTL(RTC_WKALM_SET)
 COMPATIBLE_IOCTL(RTC_WKALM_RD)
+/*
+ * These two are only for the sbus rtc driver, but
+ * hwclock tries them on every rtc device first when
+ * running on sparc.  On other architectures the entries
+ * are useless but harmless.
+ */
+COMPATIBLE_IOCTL(_IOR('p', 20, int[7])) /* RTCGET */
+COMPATIBLE_IOCTL(_IOW('p', 21, int[7])) /* RTCSET */
 /* Little m */
 COMPATIBLE_IOCTL(MTIOCTOP)
 /* Socket level stuff */
+COMPATIBLE_IOCTL(FIOQSIZE)
 COMPATIBLE_IOCTL(FIOSETOWN)
 COMPATIBLE_IOCTL(SIOCSPGRP)
 COMPATIBLE_IOCTL(FIOGETOWN)
@@ -786,3 +795,70 @@ COMPATIBLE_IOCTL(HIDIOCGFLAG)
 COMPATIBLE_IOCTL(HIDIOCSFLAG)
 COMPATIBLE_IOCTL(HIDIOCGCOLLECTIONINDEX)
 COMPATIBLE_IOCTL(HIDIOCGCOLLECTIONINFO)
+/* dvb */
+COMPATIBLE_IOCTL(AUDIO_STOP)
+COMPATIBLE_IOCTL(AUDIO_PLAY)
+COMPATIBLE_IOCTL(AUDIO_PAUSE)
+COMPATIBLE_IOCTL(AUDIO_CONTINUE)
+COMPATIBLE_IOCTL(AUDIO_SELECT_SOURCE)
+COMPATIBLE_IOCTL(AUDIO_SET_MUTE)
+COMPATIBLE_IOCTL(AUDIO_SET_AV_SYNC)
+COMPATIBLE_IOCTL(AUDIO_SET_BYPASS_MODE)
+COMPATIBLE_IOCTL(AUDIO_CHANNEL_SELECT)
+COMPATIBLE_IOCTL(AUDIO_GET_STATUS)
+COMPATIBLE_IOCTL(AUDIO_GET_CAPABILITIES)
+COMPATIBLE_IOCTL(AUDIO_CLEAR_BUFFER)
+COMPATIBLE_IOCTL(AUDIO_SET_ID)
+COMPATIBLE_IOCTL(AUDIO_SET_MIXER)
+COMPATIBLE_IOCTL(AUDIO_SET_STREAMTYPE)
+COMPATIBLE_IOCTL(AUDIO_SET_EXT_ID)
+COMPATIBLE_IOCTL(AUDIO_SET_ATTRIBUTES)
+COMPATIBLE_IOCTL(AUDIO_SET_KARAOKE)
+COMPATIBLE_IOCTL(DMX_START)
+COMPATIBLE_IOCTL(DMX_STOP)
+COMPATIBLE_IOCTL(DMX_SET_FILTER)
+COMPATIBLE_IOCTL(DMX_SET_PES_FILTER)
+COMPATIBLE_IOCTL(DMX_SET_BUFFER_SIZE)
+COMPATIBLE_IOCTL(DMX_GET_PES_PIDS)
+COMPATIBLE_IOCTL(DMX_GET_CAPS)
+COMPATIBLE_IOCTL(DMX_SET_SOURCE)
+COMPATIBLE_IOCTL(DMX_GET_STC)
+COMPATIBLE_IOCTL(FE_GET_INFO)
+COMPATIBLE_IOCTL(FE_DISEQC_RESET_OVERLOAD)
+COMPATIBLE_IOCTL(FE_DISEQC_SEND_MASTER_CMD)
+COMPATIBLE_IOCTL(FE_DISEQC_RECV_SLAVE_REPLY)
+COMPATIBLE_IOCTL(FE_DISEQC_SEND_BURST)
+COMPATIBLE_IOCTL(FE_SET_TONE)
+COMPATIBLE_IOCTL(FE_SET_VOLTAGE)
+COMPATIBLE_IOCTL(FE_ENABLE_HIGH_LNB_VOLTAGE)
+COMPATIBLE_IOCTL(FE_READ_STATUS)
+COMPATIBLE_IOCTL(FE_READ_BER)
+COMPATIBLE_IOCTL(FE_READ_SIGNAL_STRENGTH)
+COMPATIBLE_IOCTL(FE_READ_SNR)
+COMPATIBLE_IOCTL(FE_READ_UNCORRECTED_BLOCKS)
+COMPATIBLE_IOCTL(FE_SET_FRONTEND)
+COMPATIBLE_IOCTL(FE_GET_FRONTEND)
+COMPATIBLE_IOCTL(FE_GET_EVENT)
+COMPATIBLE_IOCTL(FE_DISHNETWORK_SEND_LEGACY_CMD)
+COMPATIBLE_IOCTL(VIDEO_STOP)
+COMPATIBLE_IOCTL(VIDEO_PLAY)
+COMPATIBLE_IOCTL(VIDEO_FREEZE)
+COMPATIBLE_IOCTL(VIDEO_CONTINUE)
+COMPATIBLE_IOCTL(VIDEO_SELECT_SOURCE)
+COMPATIBLE_IOCTL(VIDEO_SET_BLANK)
+COMPATIBLE_IOCTL(VIDEO_GET_STATUS)
+COMPATIBLE_IOCTL(VIDEO_SET_DISPLAY_FORMAT)
+COMPATIBLE_IOCTL(VIDEO_FAST_FORWARD)
+COMPATIBLE_IOCTL(VIDEO_SLOWMOTION)
+COMPATIBLE_IOCTL(VIDEO_GET_CAPABILITIES)
+COMPATIBLE_IOCTL(VIDEO_CLEAR_BUFFER)
+COMPATIBLE_IOCTL(VIDEO_SET_ID)
+COMPATIBLE_IOCTL(VIDEO_SET_STREAMTYPE)
+COMPATIBLE_IOCTL(VIDEO_SET_FORMAT)
+COMPATIBLE_IOCTL(VIDEO_SET_SYSTEM)
+COMPATIBLE_IOCTL(VIDEO_SET_HIGHLIGHT)
+COMPATIBLE_IOCTL(VIDEO_SET_SPU)
+COMPATIBLE_IOCTL(VIDEO_GET_NAVI)
+COMPATIBLE_IOCTL(VIDEO_SET_ATTRIBUTES)
+COMPATIBLE_IOCTL(VIDEO_GET_SIZE)
+COMPATIBLE_IOCTL(VIDEO_GET_FRAME_RATE)
diff --git a/include/linux/config.h b/include/linux/config.h
index 9d1c14f7ad6d..a91f5e55b525 100644
--- a/include/linux/config.h
+++ b/include/linux/config.h
@@ -1,6 +1,8 @@
 #ifndef _LINUX_CONFIG_H
 #define _LINUX_CONFIG_H
-
+/* This file is no longer in use and kept only for backward compatibility.
+ * autoconf.h is now included via -imacros on the commandline
+ */
 #include <linux/autoconf.h>
 
 #endif
diff --git a/include/linux/connector.h b/include/linux/connector.h
index 96de26301f84..ad1a22c1c42e 100644
--- a/include/linux/connector.h
+++ b/include/linux/connector.h
@@ -27,6 +27,14 @@
 #define CN_IDX_CONNECTOR                0xffffffff
 #define CN_VAL_CONNECTOR                0xffffffff
 
+/*
+ * Process Events connector unique ids -- used for message routing
+ */
+#define CN_IDX_PROC                     0x1
+#define CN_VAL_PROC                     0x1
+#define CN_IDX_CIFS                     0x2
+#define CN_VAL_CIFS                     0x1
+
 #define CN_NETLINK_USERS                1
 
 /*
@@ -104,12 +112,19 @@ struct cn_queue_dev {
         struct sock *nls;
 };
 
-struct cn_callback {
+struct cn_callback_id {
         unsigned char name[CN_CBQ_NAMELEN];
-
         struct cb_id id;
+};
+
+struct cn_callback_data {
+        void (*destruct_data) (void *);
+        void *ddata;
+        
+        void *callback_priv;
         void (*callback) (void *);
-        void *priv;
+
+        void *free;
 };
 
 struct cn_callback_entry {
@@ -118,8 +133,8 @@ struct cn_callback_entry {
         struct work_struct work;
         struct cn_queue_dev *pdev;
 
-        void (*destruct_data) (void *);
-        void *ddata;
+        struct cn_callback_id id;
+        struct cn_callback_data data;
 
         int seq, group;
         struct sock *nls;
@@ -142,9 +157,9 @@ struct cn_dev {
 
 int cn_add_callback(struct cb_id *, char *, void (*callback) (void *));
 void cn_del_callback(struct cb_id *);
-int cn_netlink_send(struct cn_msg *, u32, int);
+int cn_netlink_send(struct cn_msg *, u32, gfp_t);
 
-int cn_queue_add_callback(struct cn_queue_dev *dev, struct cn_callback *cb);
+int cn_queue_add_callback(struct cn_queue_dev *dev, char *name, struct cb_id *id, void (*callback)(void *));
 void cn_queue_del_callback(struct cn_queue_dev *dev, struct cb_id *id);
 
 struct cn_queue_dev *cn_queue_alloc_dev(char *name, struct sock *);
@@ -152,6 +167,8 @@ void cn_queue_free_dev(struct cn_queue_dev *dev);
 
 int cn_cb_equal(struct cb_id *, struct cb_id *);
 
+void cn_queue_wrapper(void *data);
+
 extern int cn_already_initialized;
 
 #endif                          /* __KERNEL__ */
diff --git a/include/linux/console_struct.h b/include/linux/console_struct.h
index 725be90ef55e..f8e5587a0f92 100644
--- a/include/linux/console_struct.h
+++ b/include/linux/console_struct.h
@@ -9,6 +9,8 @@
  * to achieve effects such as fast scrolling by changing the origin.
  */
 
+#include <linux/vt.h>
+
 struct vt_struct;
 
 #define NPAR 16
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index 86980c68234a..0ed1d4853c69 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -32,6 +32,7 @@ struct cpu {
 };
 
 extern int register_cpu(struct cpu *, int, struct node *);
+extern struct sys_device *get_cpu_sysdev(int cpu);
 #ifdef CONFIG_HOTPLUG_CPU
 extern void unregister_cpu(struct cpu *, struct node *);
 #endif
@@ -41,6 +42,7 @@ struct notifier_block;
 /* Need to know about CPUs going up/down? */
 extern int register_cpu_notifier(struct notifier_block *nb);
 extern void unregister_cpu_notifier(struct notifier_block *nb);
+extern int current_in_cpu_hotplug(void);
 
 int cpu_up(unsigned int cpu);
 
@@ -53,16 +55,19 @@ static inline int register_cpu_notifier(struct notifier_block *nb)
 static inline void unregister_cpu_notifier(struct notifier_block *nb)
 {
 }
+static inline int current_in_cpu_hotplug(void)
+{
+        return 0;
+}
 
 #endif /* CONFIG_SMP */
 extern struct sysdev_class cpu_sysdev_class;
 
 #ifdef CONFIG_HOTPLUG_CPU
 /* Stop CPUs going up and down. */
-extern struct semaphore cpucontrol;
-#define lock_cpu_hotplug()      down(&cpucontrol)
-#define unlock_cpu_hotplug()    up(&cpucontrol)
-#define lock_cpu_hotplug_interruptible() down_interruptible(&cpucontrol)
+extern void lock_cpu_hotplug(void);
+extern void unlock_cpu_hotplug(void);
+extern int lock_cpu_hotplug_interruptible(void);
 #define hotcpu_notifier(fn, pri) {                              \
         static struct notifier_block fn##_nb =                  \
                 { .notifier_call = fn, .priority = pri };       \
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index ff7f80f48df1..d068176b7ad7 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -23,6 +23,7 @@
 #include <linux/completion.h>
 #include <linux/workqueue.h>
 #include <linux/cpumask.h>
+#include <asm/div64.h>
 
 #define CPUFREQ_NAME_LEN 16
 
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index b15826f6e3a2..13e9f4a3ab26 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -12,6 +12,8 @@
  * see bitmap_scnprintf() and bitmap_parse() in lib/bitmap.c.
  * For details of cpulist_scnprintf() and cpulist_parse(), see
  * bitmap_scnlistprintf() and bitmap_parselist(), also in bitmap.c.
+ * For details of cpu_remap(), see bitmap_bitremap in lib/bitmap.c
+ * For details of cpus_remap(), see bitmap_remap in lib/bitmap.c.
  *
  * The available cpumask operations are:
  *
@@ -50,6 +52,8 @@
  * int cpumask_parse(ubuf, ulen, mask)  Parse ascii string as cpumask
  * int cpulist_scnprintf(buf, len, mask) Format cpumask as list for printing
  * int cpulist_parse(buf, map)          Parse ascii string as cpulist
+ * int cpu_remap(oldbit, old, new)      newbit = map(old, new)(oldbit)
+ * int cpus_remap(dst, src, old, new)   *dst = map(old, new)(src)
  *
  * for_each_cpu_mask(cpu, mask)         for-loop cpu over mask
  *
@@ -294,6 +298,22 @@ static inline int __cpulist_parse(const char *buf, cpumask_t *dstp, int nbits)
         return bitmap_parselist(buf, dstp->bits, nbits);
 }
 
+#define cpu_remap(oldbit, old, new) \
+                __cpu_remap((oldbit), &(old), &(new), NR_CPUS)
+static inline int __cpu_remap(int oldbit,
+                const cpumask_t *oldp, const cpumask_t *newp, int nbits)
+{
+        return bitmap_bitremap(oldbit, oldp->bits, newp->bits, nbits);
+}
+
+#define cpus_remap(dst, src, old, new) \
+                __cpus_remap(&(dst), &(src), &(old), &(new), NR_CPUS)
+static inline void __cpus_remap(cpumask_t *dstp, const cpumask_t *srcp,
+                const cpumask_t *oldp, const cpumask_t *newp, int nbits)
+{
+        bitmap_remap(dstp->bits, srcp->bits, oldp->bits, newp->bits, nbits);
+}
+
 #if NR_CPUS > 1
 #define for_each_cpu_mask(cpu, mask)            \
         for ((cpu) = first_cpu(mask);           \
@@ -392,4 +412,14 @@ extern cpumask_t cpu_present_map;
 #define for_each_online_cpu(cpu)  for_each_cpu_mask((cpu), cpu_online_map)
 #define for_each_present_cpu(cpu) for_each_cpu_mask((cpu), cpu_present_map)
 
+/* Find the highest possible smp_processor_id() */
+#define highest_possible_processor_id() \
+({ \
+        unsigned int cpu, highest = 0; \
+        for_each_cpu_mask(cpu, cpu_possible_map) \
+                highest = cpu; \
+        highest; \
+})
+
+
 #endif /* __LINUX_CPUMASK_H */
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index 24062a1dbf61..6e2deef96b34 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -23,7 +23,7 @@ void cpuset_init_current_mems_allowed(void);
 void cpuset_update_current_mems_allowed(void);
 void cpuset_restrict_to_mems_allowed(unsigned long *nodes);
 int cpuset_zonelist_valid_mems_allowed(struct zonelist *zl);
-extern int cpuset_zone_allowed(struct zone *z, unsigned int __nocast gfp_mask);
+extern int cpuset_zone_allowed(struct zone *z, gfp_t gfp_mask);
 extern int cpuset_excl_nodes_overlap(const struct task_struct *p);
 extern struct file_operations proc_cpuset_operations;
 extern char *cpuset_task_status_allowed(struct task_struct *task, char *buffer);
@@ -49,8 +49,7 @@ static inline int cpuset_zonelist_valid_mems_allowed(struct zonelist *zl)
         return 1;
 }
 
-static inline int cpuset_zone_allowed(struct zone *z,
-                                        unsigned int __nocast gfp_mask)
+static inline int cpuset_zone_allowed(struct zone *z, gfp_t gfp_mask)
 {
         return 1;
 }
diff --git a/include/linux/cyclomx.h b/include/linux/cyclomx.h
index 04fa7dff079c..300d704bdb9a 100644
--- a/include/linux/cyclomx.h
+++ b/include/linux/cyclomx.h
@@ -37,8 +37,6 @@
 #include <linux/cycx_x25.h>
 #endif
 
-#define is_digit(ch) (((ch)>=(unsigned)'0'&&(ch)<=(unsigned)'9')?1:0)
-
 /* Adapter Data Space.
  * This structure is needed because we handle multiple cards, otherwise
  * static data would do it.
diff --git a/include/linux/cycx_drv.h b/include/linux/cycx_drv.h
index 6621df86a748..12fe6b0bfcff 100644
--- a/include/linux/cycx_drv.h
+++ b/include/linux/cycx_drv.h
@@ -60,6 +60,5 @@ extern int cycx_peek(struct cycx_hw *hw, u32 addr, void *buf, u32 len);
 extern int cycx_poke(struct cycx_hw *hw, u32 addr, void *buf, u32 len);
 extern int cycx_exec(void __iomem *addr);
 
-extern void cycx_inten(struct cycx_hw *hw);
 extern void cycx_intr(struct cycx_hw *hw);
 #endif  /* _CYCX_DRV_H */
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index ab04b4f9b0db..46a2ba617595 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -329,6 +329,7 @@ static inline int d_mountpoint(struct dentry *dentry)
 }
 
 extern struct vfsmount *lookup_mnt(struct vfsmount *, struct dentry *);
+extern struct vfsmount *__lookup_mnt(struct vfsmount *, struct dentry *, int);
 extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
 
 extern int sysctl_vfs_cache_pressure;
diff --git a/include/linux/device.h b/include/linux/device.h
index 06e5d42f2c7b..17cbc6db67b4 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -28,19 +28,6 @@
 #define BUS_ID_SIZE             KOBJ_NAME_LEN
 
 
-enum {
-        SUSPEND_NOTIFY,
-        SUSPEND_SAVE_STATE,
-        SUSPEND_DISABLE,
-        SUSPEND_POWER_DOWN,
-};
-
-enum {
-        RESUME_POWER_ON,
-        RESUME_RESTORE_STATE,
-        RESUME_ENABLE,
-};
-
 struct device;
 struct device_driver;
 struct class;
@@ -115,8 +102,8 @@ struct device_driver {
         int     (*probe)        (struct device * dev);
         int     (*remove)       (struct device * dev);
         void    (*shutdown)     (struct device * dev);
-        int     (*suspend)      (struct device * dev, pm_message_t state, u32 level);
-        int     (*resume)       (struct device * dev, u32 level);
+        int     (*suspend)      (struct device * dev, pm_message_t state);
+        int     (*resume)       (struct device * dev);
 };
 
 
@@ -190,7 +177,43 @@ struct class_attribute class_attr_##_name = __ATTR(_name,_mode,_show,_store)
 extern int class_create_file(struct class *, const struct class_attribute *);
 extern void class_remove_file(struct class *, const struct class_attribute *);
 
+struct class_device_attribute {
+        struct attribute        attr;
+        ssize_t (*show)(struct class_device *, char * buf);
+        ssize_t (*store)(struct class_device *, const char * buf, size_t count);
+};
+
+#define CLASS_DEVICE_ATTR(_name,_mode,_show,_store)             \
+struct class_device_attribute class_device_attr_##_name =       \
+        __ATTR(_name,_mode,_show,_store)
 
+extern int class_device_create_file(struct class_device *,
+                                    const struct class_device_attribute *);
+
+/**
+ * struct class_device - class devices
+ * @class: pointer to the parent class for this class device.  This is required.
+ * @devt: for internal use by the driver core only.
+ * @node: for internal use by the driver core only.
+ * @kobj: for internal use by the driver core only.
+ * @devt_attr: for internal use by the driver core only.
+ * @dev: if set, a symlink to the struct device is created in the sysfs
+ * directory for this struct class device.
+ * @class_data: pointer to whatever you want to store here for this struct
+ * class_device.  Use class_get_devdata() and class_set_devdata() to get and
+ * set this pointer.
+ * @parent: pointer to a struct class_device that is the parent of this struct
+ * class_device.  If NULL, this class_device will show up at the root of the
+ * struct class in sysfs (which is probably what you want to have happen.)
+ * @release: pointer to a release function for this struct class_device.  If
+ * set, this will be called instead of the class specific release function.
+ * Only use this if you want to override the default release function, like
+ * when you are nesting class_device structures.
+ * @hotplug: pointer to a hotplug function for this struct class_device.  If
+ * set, this will be called instead of the class specific hotplug function.
+ * Only use this if you want to override the default hotplug function, like
+ * when you are nesting class_device structures.
+ */
 struct class_device {
         struct list_head        node;
 
@@ -198,9 +221,14 @@ struct class_device {
         struct class            * class;        /* required */
         dev_t                   devt;           /* dev_t, creates the sysfs "dev" */
         struct class_device_attribute *devt_attr;
+        struct class_device_attribute uevent_attr;
         struct device           * dev;          /* not necessary, but nice to have */
         void                    * class_data;   /* class-specific data */
+        struct class_device     *parent;        /* parent of this child device, if there is one */
 
+        void    (*release)(struct class_device *dev);
+        int     (*hotplug)(struct class_device *dev, char **envp,
+                           int num_envp, char *buffer, int buffer_size);
         char    class_id[BUS_ID_SIZE];  /* unique to this class */
 };
 
@@ -228,18 +256,6 @@ extern int class_device_rename(struct class_device *, char *);
 extern struct class_device * class_device_get(struct class_device *);
 extern void class_device_put(struct class_device *);
 
-struct class_device_attribute {
-        struct attribute        attr;
-        ssize_t (*show)(struct class_device *, char * buf);
-        ssize_t (*store)(struct class_device *, const char * buf, size_t count);
-};
-
-#define CLASS_DEVICE_ATTR(_name,_mode,_show,_store)             \
-struct class_device_attribute class_device_attr_##_name =       \
-        __ATTR(_name,_mode,_show,_store)
-
-extern int class_device_create_file(struct class_device *, 
-                                    const struct class_device_attribute *);
 extern void class_device_remove_file(struct class_device *, 
                                      const struct class_device_attribute *);
 extern int class_device_create_bin_file(struct class_device *,
@@ -251,8 +267,8 @@ struct class_interface {
         struct list_head        node;
         struct class            *class;
 
-        int (*add)      (struct class_device *);
-        void (*remove)  (struct class_device *);
+        int (*add)      (struct class_device *, struct class_interface *);
+        void (*remove)  (struct class_device *, struct class_interface *);
 };
 
 extern int class_interface_register(struct class_interface *);
@@ -260,12 +276,29 @@ extern void class_interface_unregister(struct class_interface *);
 
 extern struct class *class_create(struct module *owner, char *name);
 extern void class_destroy(struct class *cls);
-extern struct class_device *class_device_create(struct class *cls, dev_t devt,
-                                                struct device *device, char *fmt, ...)
-                                        __attribute__((format(printf,4,5)));
+extern struct class_device *class_device_create(struct class *cls,
+                                                struct class_device *parent,
+                                                dev_t devt,
+                                                struct device *device,
+                                                char *fmt, ...)
+                                        __attribute__((format(printf,5,6)));
 extern void class_device_destroy(struct class *cls, dev_t devt);
 
 
+/* interface for exporting device attributes */
+struct device_attribute {
+        struct attribute        attr;
+        ssize_t (*show)(struct device *dev, struct device_attribute *attr,
+                        char *buf);
+        ssize_t (*store)(struct device *dev, struct device_attribute *attr,
+                         const char *buf, size_t count);
+};
+
+#define DEVICE_ATTR(_name,_mode,_show,_store) \
+struct device_attribute dev_attr_##_name = __ATTR(_name,_mode,_show,_store)
+
+extern int device_create_file(struct device *device, struct device_attribute * entry);
+extern void device_remove_file(struct device * dev, struct device_attribute * attr);
 struct device {
         struct klist            klist_children;
         struct klist_node       knode_parent;           /* node in sibling list */
@@ -275,6 +308,7 @@ struct device {
 
         struct kobject kobj;
         char    bus_id[BUS_ID_SIZE];    /* position on parent bus */
+        struct device_attribute uevent_attr;
 
         struct semaphore        sem;    /* semaphore to synchronize calls to
                                          * its driver.
@@ -317,6 +351,11 @@ dev_set_drvdata (struct device *dev, void *data)
         dev->driver_data = data;
 }
 
+static inline int device_is_registered(struct device *dev)
+{
+        return klist_node_attached(&dev->knode_bus);
+}
+
 /*
  * High level routines for use by the bus drivers
  */
@@ -338,23 +377,6 @@ extern int  device_attach(struct device * dev);
 extern void driver_attach(struct device_driver * drv);
 
 
-/* driverfs interface for exporting device attributes */
-
-struct device_attribute {
-        struct attribute        attr;
-        ssize_t (*show)(struct device *dev, struct device_attribute *attr,
-                        char *buf);
-        ssize_t (*store)(struct device *dev, struct device_attribute *attr,
-                         const char *buf, size_t count);
-};
-
-#define DEVICE_ATTR(_name,_mode,_show,_store) \
-struct device_attribute dev_attr_##_name = __ATTR(_name,_mode,_show,_store)
-
-
-extern int device_create_file(struct device *device, struct device_attribute * entry);
-extern void device_remove_file(struct device * dev, struct device_attribute * attr);
-
 /*
  * Platform "fixup" functions - allow the platform to have their say
  * about devices and actions that the general device layer doesn't
@@ -374,32 +396,6 @@ extern struct device * get_device(struct device * dev);
 extern void put_device(struct device * dev);
 
 
-/* drivers/base/platform.c */
-
-struct platform_device {
-        const char      * name;
-        u32             id;
-        struct device   dev;
-        u32             num_resources;
-        struct resource * resource;
-};
-
-#define to_platform_device(x) container_of((x), struct platform_device, dev)
-
-extern int platform_device_register(struct platform_device *);
-extern void platform_device_unregister(struct platform_device *);
-
-extern struct bus_type platform_bus_type;
-extern struct device platform_bus;
-
-extern struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);
-extern int platform_get_irq(struct platform_device *, unsigned int);
-extern struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, char *);
-extern int platform_get_irq_byname(struct platform_device *, char *);
-extern int platform_add_devices(struct platform_device **, int);
-
-extern struct platform_device *platform_device_register_simple(char *, unsigned int, struct resource *, unsigned int);
-
 /* drivers/base/power.c */
 extern void device_shutdown(void);
 
diff --git a/include/linux/dmapool.h b/include/linux/dmapool.h
index 4932ee5c77f0..76f12f46db7f 100644
--- a/include/linux/dmapool.h
+++ b/include/linux/dmapool.h
@@ -19,7 +19,7 @@ struct dma_pool *dma_pool_create(const char *name, struct device *dev,
 
 void dma_pool_destroy(struct dma_pool *pool);
 
-void *dma_pool_alloc(struct dma_pool *pool, unsigned int __nocast mem_flags,
+void *dma_pool_alloc(struct dma_pool *pool, gfp_t mem_flags,
                      dma_addr_t *handle);
 
 void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t addr);
diff --git a/include/linux/dmi.h b/include/linux/dmi.h
index a415f1d93e9a..05f4132622fc 100644
--- a/include/linux/dmi.h
+++ b/include/linux/dmi.h
@@ -60,7 +60,7 @@ struct dmi_device {
         void *device_data;      /* Type specific data */
 };
 
-#if defined(CONFIG_X86) && !defined(CONFIG_X86_64)
+#if defined(CONFIG_X86_32)
 
 extern int dmi_check_system(struct dmi_system_id *list);
 extern char * dmi_get_system_info(int field);
diff --git a/include/linux/dqblk_xfs.h b/include/linux/dqblk_xfs.h
index cb31719ee192..2fda1b2aabd9 100644
--- a/include/linux/dqblk_xfs.h
+++ b/include/linux/dqblk_xfs.h
@@ -1,22 +1,18 @@
 /*
  * Copyright (c) 1995-2001,2004 Silicon Graphics, Inc.  All Rights Reserved.
  *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2.1 of the GNU Lesser General Public License
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
  * as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
- * USA
- *
- * Contact information: Silicon Graphics, Inc., 1500 Crittenden Lane,
- * Mountain View, CA 94043, USA, or: http://www.sgi.com
+ * You should have received a copy of the GNU Lesset General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef _LINUX_DQBLK_XFS_H
 #define _LINUX_DQBLK_XFS_H
@@ -32,7 +28,8 @@
 
 #define XQM_USRQUOTA    0       /* system call user quota type */
 #define XQM_GRPQUOTA    1       /* system call group quota type */
-#define XQM_MAXQUOTAS   2
+#define XQM_PRJQUOTA    2       /* system call project quota type */
+#define XQM_MAXQUOTAS   3
 
 #define Q_XQUOTAON      XQM_CMD(1)      /* enable accounting/enforcement */
 #define Q_XQUOTAOFF     XQM_CMD(2)      /* disable accounting/enforcement */
@@ -40,6 +37,7 @@
 #define Q_XSETQLIM      XQM_CMD(4)      /* set disk limits */
 #define Q_XGETQSTAT     XQM_CMD(5)      /* get quota subsystem status */
 #define Q_XQUOTARM      XQM_CMD(6)      /* free disk space used by dquots */
+#define Q_XQUOTASYNC    XQM_CMD(7)      /* delalloc flush, updates dquots */
 
 /*
  * fs_disk_quota structure:
diff --git a/include/linux/ds17287rtc.h b/include/linux/ds17287rtc.h
new file mode 100644
index 000000000000..c281ba42e28f
--- /dev/null
+++ b/include/linux/ds17287rtc.h
@@ -0,0 +1,67 @@
+/*
+ * ds17287rtc.h - register definitions for the ds1728[57] RTC / CMOS RAM
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * (C) 2003 Guido Guenther <agx@sigxcpu.org>
+ */
+#ifndef __LINUX_DS17287RTC_H
+#define __LINUX_DS17287RTC_H
+
+#include <linux/rtc.h>                  /* get the user-level API */
+#include <linux/spinlock.h>             /* spinlock_t */
+#include <linux/mc146818rtc.h>
+
+/* Register A */
+#define DS_REGA_DV2     0x40            /* countdown chain */
+#define DS_REGA_DV1     0x20            /* oscillator enable */
+#define DS_REGA_DV0     0x10            /* bank select */
+
+/* bank 1 registers */
+#define DS_B1_MODEL     0x40            /* model number byte */
+#define DS_B1_SN1       0x41            /* serial number byte 1 */
+#define DS_B1_SN2       0x42            /* serial number byte 2 */
+#define DS_B1_SN3       0x43            /* serial number byte 3 */
+#define DS_B1_SN4       0x44            /* serial number byte 4 */
+#define DS_B1_SN5       0x45            /* serial number byte 5 */
+#define DS_B1_SN6       0x46            /* serial number byte 6 */
+#define DS_B1_CRC       0x47            /* CRC byte */
+#define DS_B1_CENTURY   0x48            /* Century byte */
+#define DS_B1_DALARM    0x49            /* date alarm */
+#define DS_B1_XCTRL4A   0x4a            /* extendec control register 4a */
+#define DS_B1_XCTRL4B   0x4b            /* extendec control register 4b */
+#define DS_B1_RTCADDR2  0x4e            /* rtc address 2 */
+#define DS_B1_RTCADDR3  0x4f            /* rtc address 3 */
+#define DS_B1_RAMLSB    0x50            /* extended ram LSB */
+#define DS_B1_RAMMSB    0x51            /* extended ram MSB */
+#define DS_B1_RAMDPORT  0x53            /* extended ram data port */
+
+/* register details */
+/* extended control register 4a */
+#define DS_XCTRL4A_VRT2 0x80            /* valid ram and time */
+#define DS_XCTRL4A_INCR 0x40            /* increment progress status */
+#define DS_XCTRL4A_BME  0x20            /* burst mode enable */
+#define DS_XCTRL4A_PAB  0x08            /* power active bar ctrl */
+#define DS_XCTRL4A_RF   0x04            /* ram clear flag */
+#define DS_XCTRL4A_WF   0x02            /* wake up alarm flag */
+#define DS_XCTRL4A_KF   0x01            /* kickstart flag */
+
+/* interrupt causes */
+#define DS_XCTRL4A_IFS  (DS_XCTRL4A_RF|DS_XCTRL4A_WF|DS_XCTRL4A_KF)
+
+/* extended control register 4b */
+#define DS_XCTRL4B_ABE  0x80            /* auxiliary battery enable */
+#define DS_XCTRL4B_E32K 0x40            /* enable 32.768 kHz Output */
+#define DS_XCTRL4B_CS   0x20            /* crystal select */
+#define DS_XCTRL4B_RCE  0x10            /* ram clear enable */
+#define DS_XCTRL4B_PRS  0x08            /* PAB resec select */
+#define DS_XCTRL4B_RIE  0x04            /* ram clear interrupt enable */
+#define DS_XCTRL4B_WFE  0x02            /* wake up alarm interrupt enable */
+#define DS_XCTRL4B_KFE  0x01            /* kickstart interrupt enable */
+
+/* interrupt enable bits */
+#define DS_XCTRL4B_IFES (DS_XCTRL4B_RIE|DS_XCTRL4B_WFE|DS_XCTRL4B_KFE)
+
+#endif /* __LINUX_DS17287RTC_H */
diff --git a/include/linux/ds1742rtc.h b/include/linux/ds1742rtc.h
new file mode 100644
index 000000000000..a83cdd1cafc9
--- /dev/null
+++ b/include/linux/ds1742rtc.h
@@ -0,0 +1,53 @@
+/*
+ * ds1742rtc.h - register definitions for the Real-Time-Clock / CMOS RAM
+ *
+ * Copyright (C) 1999-2001 Toshiba Corporation
+ * Copyright (C) 2003 Ralf Baechle (ralf@linux-mips.org)
+ *
+ * Permission is hereby granted to copy, modify and redistribute this code
+ * in terms of the GNU Library General Public License, Version 2 or later,
+ * at your option.
+ */
+#ifndef __LINUX_DS1742RTC_H
+#define __LINUX_DS1742RTC_H
+
+#include <asm/ds1742.h>
+
+#define RTC_BRAM_SIZE           0x800
+#define RTC_OFFSET              0x7f8
+
+/*
+ * Register summary
+ */
+#define RTC_CONTROL             (RTC_OFFSET + 0)
+#define RTC_CENTURY             (RTC_OFFSET + 0)
+#define RTC_SECONDS             (RTC_OFFSET + 1)
+#define RTC_MINUTES             (RTC_OFFSET + 2)
+#define RTC_HOURS               (RTC_OFFSET + 3)
+#define RTC_DAY                 (RTC_OFFSET + 4)
+#define RTC_DATE                (RTC_OFFSET + 5)
+#define RTC_MONTH               (RTC_OFFSET + 6)
+#define RTC_YEAR                (RTC_OFFSET + 7)
+
+#define RTC_CENTURY_MASK        0x3f
+#define RTC_SECONDS_MASK        0x7f
+#define RTC_DAY_MASK            0x07
+
+/*
+ * Bits in the Control/Century register
+ */
+#define RTC_WRITE               0x80
+#define RTC_READ                0x40
+
+/*
+ * Bits in the Seconds register
+ */
+#define RTC_STOP                0x80
+
+/*
+ * Bits in the Day register
+ */
+#define RTC_BATT_FLAG           0x80
+#define RTC_FREQ_TEST           0x40
+
+#endif /* __LINUX_DS1742RTC_H */
diff --git a/include/linux/eeprom.h b/include/linux/eeprom.h
deleted file mode 100644
index 38afd9da1dfe..000000000000
--- a/include/linux/eeprom.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/* credit winbond-840.c
- */
-#include <asm/io.h>
-struct eeprom_ops {
-        void    (*set_cs)(void *ee);
-        void    (*clear_cs)(void *ee);
-};
-
-#define EEPOL_EEDI      0x01
-#define EEPOL_EEDO      0x02
-#define EEPOL_EECLK     0x04
-#define EEPOL_EESEL     0x08
-
-struct eeprom {
-        void *dev;
-        struct eeprom_ops *ops;
-
-        void __iomem *  addr;
-
-        unsigned        ee_addr_bits;
-
-        unsigned        eesel;
-        unsigned        eeclk;
-        unsigned        eedo;
-        unsigned        eedi;
-        unsigned        polarity;
-        unsigned        ee_state;
-
-        spinlock_t      *lock;
-        u32             *cache;
-};
-
-
-u8   eeprom_readb(struct eeprom *ee, unsigned address);
-void eeprom_read(struct eeprom *ee, unsigned address, u8 *bytes,
-                unsigned count);
-void eeprom_writeb(struct eeprom *ee, unsigned address, u8 data);
-void eeprom_write(struct eeprom *ee, unsigned address, u8 *bytes,
-                unsigned count);
-
-/* The EEPROM commands include the alway-set leading bit. */
-enum EEPROM_Cmds {
-        EE_WriteCmd=(5 << 6), EE_ReadCmd=(6 << 6), EE_EraseCmd=(7 << 6),
-};
-
-void setup_ee_mem_bitbanger(struct eeprom *ee, void __iomem *memaddr, int eesel_bit, int eeclk_bit, int eedo_bit, int eedi_bit, unsigned polarity)
-{
-        ee->addr = memaddr;
-        ee->eesel = 1 << eesel_bit;
-        ee->eeclk = 1 << eeclk_bit;
-        ee->eedo = 1 << eedo_bit;
-        ee->eedi = 1 << eedi_bit;
-
-        ee->polarity = polarity;
-
-        *ee->cache = readl(ee->addr);
-}
-
-/* foo. put this in a .c file */
-static inline void eeprom_update(struct eeprom *ee, u32 mask, int pol)
-{
-        unsigned long flags;
-        u32 data;
-
-        spin_lock_irqsave(ee->lock, flags);
-        data = *ee->cache;
-
-        data &= ~mask;
-        if (pol)
-                data |= mask;
-
-        *ee->cache = data;
-//printk("update: %08x\n", data);
-        writel(data, ee->addr);
-        spin_unlock_irqrestore(ee->lock, flags);
-}
-
-void eeprom_clk_lo(struct eeprom *ee)
-{
-        int pol = !!(ee->polarity & EEPOL_EECLK);
-
-        eeprom_update(ee, ee->eeclk, pol);
-        udelay(2);
-}
-
-void eeprom_clk_hi(struct eeprom *ee)
-{
-        int pol = !!(ee->polarity & EEPOL_EECLK);
-
-        eeprom_update(ee, ee->eeclk, !pol);
-        udelay(2);
-}
-
-void eeprom_send_addr(struct eeprom *ee, unsigned address)
-{
-        int pol = !!(ee->polarity & EEPOL_EEDI);
-        unsigned i;
-        address |= 6 << 6;
-
-        /* Shift the read command bits out. */
-        for (i=0; i<11; i++) {
-                eeprom_update(ee, ee->eedi, ((address >> 10) & 1) ^ pol);
-                address <<= 1;
-                eeprom_clk_hi(ee);
-                eeprom_clk_lo(ee);
-        }
-        eeprom_update(ee, ee->eedi, pol);
-}
-
-u16   eeprom_readw(struct eeprom *ee, unsigned address)
-{
-        unsigned i;
-        u16     res = 0;
-
-        eeprom_clk_lo(ee);
-        eeprom_update(ee, ee->eesel, 1 ^ !!(ee->polarity & EEPOL_EESEL));
-        eeprom_send_addr(ee, address);
-
-        for (i=0; i<16; i++) {
-                u32 data;
-                eeprom_clk_hi(ee);
-                res <<= 1;
-                data = readl(ee->addr);
-//printk("eeprom_readw: %08x\n", data);
-                res |= !!(data & ee->eedo) ^ !!(ee->polarity & EEPOL_EEDO);
-                eeprom_clk_lo(ee);
-        }
-        eeprom_update(ee, ee->eesel, 0 ^ !!(ee->polarity & EEPOL_EESEL));
-
-        return res;
-}
-
-
-void eeprom_writeb(struct eeprom *ee, unsigned address, u8 data)
-{
-}
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index ea6bbc2d7407..a74c27e460ba 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -8,18 +8,17 @@ typedef void (elevator_merge_req_fn) (request_queue_t *, struct request *, struc
 
 typedef void (elevator_merged_fn) (request_queue_t *, struct request *);
 
-typedef struct request *(elevator_next_req_fn) (request_queue_t *);
+typedef int (elevator_dispatch_fn) (request_queue_t *, int);
 
-typedef void (elevator_add_req_fn) (request_queue_t *, struct request *, int);
+typedef void (elevator_add_req_fn) (request_queue_t *, struct request *);
 typedef int (elevator_queue_empty_fn) (request_queue_t *);
-typedef void (elevator_remove_req_fn) (request_queue_t *, struct request *);
-typedef void (elevator_requeue_req_fn) (request_queue_t *, struct request *);
 typedef struct request *(elevator_request_list_fn) (request_queue_t *, struct request *);
 typedef void (elevator_completed_req_fn) (request_queue_t *, struct request *);
 typedef int (elevator_may_queue_fn) (request_queue_t *, int, struct bio *);
 
-typedef int (elevator_set_req_fn) (request_queue_t *, struct request *, struct bio *, int);
+typedef int (elevator_set_req_fn) (request_queue_t *, struct request *, struct bio *, gfp_t);
 typedef void (elevator_put_req_fn) (request_queue_t *, struct request *);
+typedef void (elevator_activate_req_fn) (request_queue_t *, struct request *);
 typedef void (elevator_deactivate_req_fn) (request_queue_t *, struct request *);
 
 typedef int (elevator_init_fn) (request_queue_t *, elevator_t *);
@@ -31,10 +30,9 @@ struct elevator_ops
         elevator_merged_fn *elevator_merged_fn;
         elevator_merge_req_fn *elevator_merge_req_fn;
 
-        elevator_next_req_fn *elevator_next_req_fn;
+        elevator_dispatch_fn *elevator_dispatch_fn;
         elevator_add_req_fn *elevator_add_req_fn;
-        elevator_remove_req_fn *elevator_remove_req_fn;
-        elevator_requeue_req_fn *elevator_requeue_req_fn;
+        elevator_activate_req_fn *elevator_activate_req_fn;
         elevator_deactivate_req_fn *elevator_deactivate_req_fn;
 
         elevator_queue_empty_fn *elevator_queue_empty_fn;
@@ -81,15 +79,15 @@ struct elevator_queue
 /*
  * block elevator interface
  */
+extern void elv_dispatch_sort(request_queue_t *, struct request *);
 extern void elv_add_request(request_queue_t *, struct request *, int, int);
 extern void __elv_add_request(request_queue_t *, struct request *, int, int);
 extern int elv_merge(request_queue_t *, struct request **, struct bio *);
 extern void elv_merge_requests(request_queue_t *, struct request *,
                                struct request *);
 extern void elv_merged_request(request_queue_t *, struct request *);
-extern void elv_remove_request(request_queue_t *, struct request *);
+extern void elv_dequeue_request(request_queue_t *, struct request *);
 extern void elv_requeue_request(request_queue_t *, struct request *);
-extern void elv_deactivate_request(request_queue_t *, struct request *);
 extern int elv_queue_empty(request_queue_t *);
 extern struct request *elv_next_request(struct request_queue *q);
 extern struct request *elv_former_request(request_queue_t *, struct request *);
@@ -98,7 +96,7 @@ extern int elv_register_queue(request_queue_t *q);
 extern void elv_unregister_queue(request_queue_t *q);
 extern int elv_may_queue(request_queue_t *, int, struct bio *);
 extern void elv_completed_request(request_queue_t *, struct request *);
-extern int elv_set_request(request_queue_t *, struct request *, struct bio *, int);
+extern int elv_set_request(request_queue_t *, struct request *, struct bio *, gfp_t);
 extern void elv_put_request(request_queue_t *, struct request *);
 
 /*
@@ -142,4 +140,6 @@ enum {
         ELV_MQUEUE_MUST,
 };
 
+#define rq_end_sector(rq)       ((rq)->sector + (rq)->nr_sectors)
+
 #endif
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index 4522c7186bf3..5f49a30eb6f2 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -48,8 +48,10 @@ static inline void eth_copy_and_sum (struct sk_buff *dest,
 }
 
 /**
- * is_zero_ether_addr - Determine if give Ethernet address is all
- * zeros.
+ * is_zero_ether_addr - Determine if give Ethernet address is all zeros.
+ * @addr: Pointer to a six-byte array containing the Ethernet address
+ *
+ * Return true if the address is all zeroes.
  */
 static inline int is_zero_ether_addr(const u8 *addr)
 {
@@ -57,9 +59,7 @@ static inline int is_zero_ether_addr(const u8 *addr)
 }
 
 /**
- * is_multicast_ether_addr - Determine if the given Ethernet address is a
- * multicast address.
- *
+ * is_multicast_ether_addr - Determine if the Ethernet address is a multicast.
  * @addr: Pointer to a six-byte array containing the Ethernet address
  *
  * Return true if the address is a multicast address.
@@ -69,10 +69,15 @@ static inline int is_multicast_ether_addr(const u8 *addr)
         return ((addr[0] != 0xff) && (0x01 & addr[0]));
 }
 
+/**
+ * is_broadcast_ether_addr - Determine if the Ethernet address is broadcast
+ * @addr: Pointer to a six-byte array containing the Ethernet address
+ *
+ * Return true if the address is the broadcast address.
+ */
 static inline int is_broadcast_ether_addr(const u8 *addr)
 {
-        return ((addr[0] == 0xff) && (addr[1] == 0xff) && (addr[2] == 0xff) &&  
-                (addr[3] == 0xff) && (addr[4] == 0xff) && (addr[5] == 0xff));
+        return (addr[0] & addr[1] & addr[2] & addr[3] & addr[4] & addr[5]) == 0xff;
 }
 
 /**
@@ -104,6 +109,22 @@ static inline void random_ether_addr(u8 *addr)
         addr [0] &= 0xfe;       /* clear multicast bit */
         addr [0] |= 0x02;       /* set local assignment bit (IEEE802) */
 }
+
+/**
+ * compare_ether_addr - Compare two Ethernet addresses
+ * @addr1: Pointer to a six-byte array containing the Ethernet address
+ * @addr2: Pointer other six-byte array containing the Ethernet address
+ *
+ * Compare two ethernet addresses, returns 0 if equal
+ */
+static inline unsigned compare_ether_addr(const u8 *addr1, const u8 *addr2)
+{
+        const u16 *a = (const u16 *) addr1;
+        const u16 *b = (const u16 *) addr2;
+
+        BUILD_BUG_ON(ETH_ALEN != 6);
+        return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2])) != 0;
+}
 #endif  /* __KERNEL__ */
 
 #endif  /* _LINUX_ETHERDEVICE_H */
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index ed1440ea4c91..93535f093216 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -269,6 +269,8 @@ u32 ethtool_op_get_tso(struct net_device *dev);
 int ethtool_op_set_tso(struct net_device *dev, u32 data);
 int ethtool_op_get_perm_addr(struct net_device *dev, 
                              struct ethtool_perm_addr *addr, u8 *data);
+u32 ethtool_op_get_ufo(struct net_device *dev);
+int ethtool_op_set_ufo(struct net_device *dev, u32 data);
 
 /**
  * &ethtool_ops - Alter and report network device settings
@@ -298,6 +300,8 @@ int ethtool_op_get_perm_addr(struct net_device *dev,
  * set_sg: Turn scatter-gather on or off
  * get_tso: Report whether TCP segmentation offload is enabled
  * set_tso: Turn TCP segmentation offload on or off
+ * get_ufo: Report whether UDP fragmentation offload is enabled
+ * set_ufo: Turn UDP fragmentation offload on or off
  * self_test: Run specified self-tests
  * get_strings: Return a set of strings that describe the requested objects 
  * phys_id: Identify the device
@@ -364,6 +368,8 @@ struct ethtool_ops {
         int     (*get_perm_addr)(struct net_device *, struct ethtool_perm_addr *, u8 *);
         int     (*begin)(struct net_device *);
         void    (*complete)(struct net_device *);
+        u32     (*get_ufo)(struct net_device *);
+        int     (*set_ufo)(struct net_device *, u32);
 };
 
 /* CMDs currently supported */
@@ -400,6 +406,8 @@ struct ethtool_ops {
 #define ETHTOOL_GTSO            0x0000001e /* Get TSO enable (ethtool_value) */
 #define ETHTOOL_STSO            0x0000001f /* Set TSO enable (ethtool_value) */
 #define ETHTOOL_GPERMADDR       0x00000020 /* Get permanent hardware address */
+#define ETHTOOL_GUFO            0x00000021 /* Get UFO enable (ethtool_value) */
+#define ETHTOOL_SUFO            0x00000022 /* Set UFO enable (ethtool_value) */
 
 /* compatibility with older code */
 #define SPARC_ETH_GSET          ETHTOOL_GSET
@@ -445,10 +453,11 @@ struct ethtool_ops {
  * it was foced up into this mode or autonegotiated.
  */
 
-/* The forced speed, 10Mb, 100Mb, gigabit, 10GbE. */
+/* The forced speed, 10Mb, 100Mb, gigabit, 2.5Gb, 10GbE. */
 #define SPEED_10                10
 #define SPEED_100               100
 #define SPEED_1000              1000
+#define SPEED_2500              2500
 #define SPEED_10000             10000
 
 /* Duplex, half or full. */
diff --git a/include/linux/fb.h b/include/linux/fb.h
index c698055266d0..04a58f33ec53 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -201,6 +201,14 @@ struct fb_bitfield {
 #define FB_VMODE_SMOOTH_XPAN    512     /* smooth xpan possible (internally used) */
 #define FB_VMODE_CONUPDATE      512     /* don't update x/yoffset       */
 
+/*
+ * Display rotation support
+ */
+#define FB_ROTATE_UR      0
+#define FB_ROTATE_CW      1
+#define FB_ROTATE_UD      2
+#define FB_ROTATE_CCW     3
+
 #define PICOS2KHZ(a) (1000000000UL/(a))
 #define KHZ2PICOS(a) (1000000000UL/(a))
 
@@ -489,9 +497,9 @@ struct fb_cursor_user {
 #define FB_EVENT_MODE_DELETE            0x04
 /*      A driver registered itself */
 #define FB_EVENT_FB_REGISTERED          0x05
-/*      get console to framebuffer mapping */
+/*      CONSOLE-SPECIFIC: get console to framebuffer mapping */
 #define FB_EVENT_GET_CONSOLE_MAP        0x06
-/*      set console to framebuffer mapping */
+/*      CONSOLE-SPECIFIC: set console to framebuffer mapping */
 #define FB_EVENT_SET_CONSOLE_MAP        0x07
 /*      A display blank is requested       */
 #define FB_EVENT_BLANK                  0x08
@@ -500,6 +508,12 @@ struct fb_cursor_user {
 /*      The resolution of the passed in fb_info about to change and
         all vc's should be changed         */
 #define FB_EVENT_MODE_CHANGE_ALL        0x0A
+/*      CONSOLE-SPECIFIC: set console rotation */
+#define FB_EVENT_SET_CON_ROTATE         0x0B
+/*      CONSOLE-SPECIFIC: get console rotation */
+#define FB_EVENT_GET_CON_ROTATE         0x0C
+/*      CONSOLE-SPECIFIC: rotate all consoles */
+#define FB_EVENT_SET_CON_ROTATE_ALL     0x0D
 
 struct fb_event {
         struct fb_info *info;
@@ -810,7 +824,6 @@ struct fb_info {
 extern int fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var); 
 extern int fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var); 
 extern int fb_blank(struct fb_info *info, int blank);
-extern int soft_cursor(struct fb_info *info, struct fb_cursor *cursor);
 extern void cfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect); 
 extern void cfb_copyarea(struct fb_info *info, const struct fb_copyarea *area); 
 extern void cfb_imageblit(struct fb_info *info, const struct fb_image *image);
@@ -818,8 +831,8 @@ extern void cfb_imageblit(struct fb_info *info, const struct fb_image *image);
 /* drivers/video/fbmem.c */
 extern int register_framebuffer(struct fb_info *fb_info);
 extern int unregister_framebuffer(struct fb_info *fb_info);
-extern int fb_prepare_logo(struct fb_info *fb_info);
-extern int fb_show_logo(struct fb_info *fb_info);
+extern int fb_prepare_logo(struct fb_info *fb_info, int rotate);
+extern int fb_show_logo(struct fb_info *fb_info, int rotate);
 extern char* fb_get_buffer_offset(struct fb_info *info, struct fb_pixmap *buf, u32 size);
 extern void fb_pad_unaligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 idx,
                                 u32 height, u32 shift_high, u32 shift_low, u32 mod);
@@ -829,6 +842,7 @@ extern int fb_get_color_depth(struct fb_var_screeninfo *var,
                               struct fb_fix_screeninfo *fix);
 extern int fb_get_options(char *name, char **option);
 extern int fb_new_modelist(struct fb_info *info);
+extern int fb_con_duit(struct fb_info *info, int event, void *data);
 
 extern struct fb_info *registered_fb[FB_MAX];
 extern int num_registered_fb;
@@ -898,11 +912,13 @@ extern struct fb_videomode *fb_match_mode(struct fb_var_screeninfo *var,
                                           struct list_head *head);
 extern struct fb_videomode *fb_find_best_mode(struct fb_var_screeninfo *var,
                                               struct list_head *head);
-extern struct fb_videomode *fb_find_nearest_mode(struct fb_var_screeninfo *var,
+extern struct fb_videomode *fb_find_nearest_mode(struct fb_videomode *mode,
                                                  struct list_head *head);
 extern void fb_destroy_modelist(struct list_head *head);
 extern void fb_videomode_to_modelist(struct fb_videomode *modedb, int num,
                                      struct list_head *head);
+extern struct fb_videomode *fb_find_best_display(struct fb_monspecs *specs,
+                                                 struct list_head *head);
 
 /* drivers/video/fbcmap.c */
 extern int fb_alloc_cmap(struct fb_cmap *cmap, int len, int transp);
diff --git a/include/linux/file.h b/include/linux/file.h
index f5bbd4c508b3..418b6101b59a 100644
--- a/include/linux/file.h
+++ b/include/linux/file.h
@@ -33,13 +33,13 @@ struct fdtable {
  * Open file table structure
  */
 struct files_struct {
-        atomic_t count;
-        spinlock_t file_lock;     /* Protects all the below members.  Nests inside tsk->alloc_lock */
+        atomic_t count;
         struct fdtable *fdt;
         struct fdtable fdtab;
-        fd_set close_on_exec_init;
-        fd_set open_fds_init;
-        struct file * fd_array[NR_OPEN_DEFAULT];
+        fd_set close_on_exec_init;
+        fd_set open_fds_init;
+        struct file * fd_array[NR_OPEN_DEFAULT];
+        spinlock_t file_lock;     /* Protects concurrent writers.  Nests inside tsk->alloc_lock */
 };
 
 #define files_fdtable(files) (rcu_dereference((files)->fdt))
@@ -59,9 +59,9 @@ extern void FASTCALL(set_close_on_exec(unsigned int fd, int flag));
 extern void put_filp(struct file *);
 extern int get_unused_fd(void);
 extern void FASTCALL(put_unused_fd(unsigned int fd));
-struct kmem_cache_s;
-extern void filp_ctor(void * objp, struct kmem_cache_s *cachep, unsigned long cflags);
-extern void filp_dtor(void * objp, struct kmem_cache_s *cachep, unsigned long dflags);
+struct kmem_cache;
+extern void filp_ctor(void * objp, struct kmem_cache *cachep, unsigned long cflags);
+extern void filp_dtor(void * objp, struct kmem_cache *cachep, unsigned long dflags);
 
 extern struct file ** alloc_fd_array(int);
 extern void free_fd_array(struct file **, int);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index e0b77c5af9a0..cc35b6ac778d 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -104,6 +104,10 @@ extern int dir_notify_enable;
 #define MS_MOVE         8192
 #define MS_REC          16384
 #define MS_VERBOSE      32768
+#define MS_UNBINDABLE   (1<<17) /* change to unbindable */
+#define MS_PRIVATE      (1<<18) /* change to private */
+#define MS_SLAVE        (1<<19) /* change to slave */
+#define MS_SHARED       (1<<20) /* change to shared */
 #define MS_POSIXACL     (1<<16) /* VFS does not apply the umask */
 #define MS_ACTIVE       (1<<30)
 #define MS_NOUSER       (1<<31)
@@ -264,6 +268,7 @@ typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 #define ATTR_ATTR_FLAG  1024
 #define ATTR_KILL_SUID  2048
 #define ATTR_KILL_SGID  4096
+#define ATTR_FILE       8192
 
 /*
  * This is the Inode Attributes structure, used for notify_change().  It
@@ -283,6 +288,13 @@ struct iattr {
         struct timespec ia_atime;
         struct timespec ia_mtime;
         struct timespec ia_ctime;
+
+        /*
+         * Not an attribute, but an auxilary info for filesystems wanting to
+         * implement an ftruncate() like method.  NOTE: filesystem should
+         * check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
+         */
+        struct file     *ia_file;
 };
 
 /*
@@ -320,7 +332,7 @@ struct address_space_operations {
         /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
         sector_t (*bmap)(struct address_space *, sector_t);
         int (*invalidatepage) (struct page *, unsigned long);
-        int (*releasepage) (struct page *, int);
+        int (*releasepage) (struct page *, gfp_t);
         ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
                         loff_t offset, unsigned long nr_segs);
         struct page* (*get_xip_page)(struct address_space *, sector_t,
@@ -574,7 +586,14 @@ struct file_ra_state {
 #define RA_FLAG_INCACHE 0x02    /* file is already in cache */
 
 struct file {
-        struct list_head        f_list;
+        /*
+         * fu_list becomes invalid after file_free is called and queued via
+         * fu_rcuhead for RCU freeing
+         */
+        union {
+                struct list_head        fu_list;
+                struct rcu_head         fu_rcuhead;
+        } f_u;
         struct dentry           *f_dentry;
         struct vfsmount         *f_vfsmnt;
         struct file_operations  *f_op;
@@ -598,7 +617,6 @@ struct file {
         spinlock_t              f_ep_lock;
 #endif /* #ifdef CONFIG_EPOLL */
         struct address_space    *f_mapping;
-        struct rcu_head         f_rcuhead;
 };
 extern spinlock_t files_lock;
 #define file_list_lock() spin_lock(&files_lock);
@@ -856,6 +874,7 @@ static inline void unlock_super(struct super_block * sb)
 /*
  * VFS helper functions..
  */
+extern int vfs_permission(struct nameidata *, int);
 extern int vfs_create(struct inode *, struct dentry *, int, struct nameidata *);
 extern int vfs_mkdir(struct inode *, struct dentry *, int);
 extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
@@ -871,6 +890,11 @@ extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct de
 extern void dentry_unhash(struct dentry *dentry);
 
 /*
+ * VFS file helper functions.
+ */
+extern int file_permission(struct file *, int);
+
+/*
  * File types
  *
  * NOTE! These match bits 12..15 of stat.st_mode
@@ -1082,6 +1106,8 @@ int sync_inode(struct inode *inode, struct writeback_control *wbc);
  * @get_name:       find the name for a given inode in a given directory
  * @get_parent:     find the parent of a given directory
  * @get_dentry:     find a dentry for the inode given a file handle sub-fragment
+ * @find_exported_dentry:
+ *      set by the exporting module to a standard helper function.
  *
  * Description:
  *    The export_operations structure provides a means for nfsd to communicate
@@ -1233,7 +1259,12 @@ extern int unregister_filesystem(struct file_system_type *);
 extern struct vfsmount *kern_mount(struct file_system_type *);
 extern int may_umount_tree(struct vfsmount *);
 extern int may_umount(struct vfsmount *);
+extern void umount_tree(struct vfsmount *, int, struct list_head *);
+extern void release_mounts(struct list_head *);
 extern long do_mount(char *, char *, char *, unsigned long, void *);
+extern struct vfsmount *copy_tree(struct vfsmount *, struct dentry *, int);
+extern void mnt_set_mountpoint(struct vfsmount *, struct dentry *,
+                                  struct vfsmount *);
 
 extern int vfs_statfs(struct super_block *, struct kstatfs *);
 
@@ -1282,7 +1313,7 @@ static inline int break_lease(struct inode *inode, unsigned int mode)
 
 /* fs/open.c */
 
-extern int do_truncate(struct dentry *, loff_t start);
+extern int do_truncate(struct dentry *, loff_t start, struct file *filp);
 extern long do_sys_open(const char __user *filename, int flags, int mode);
 extern struct file *filp_open(const char *, int, int);
 extern struct file * dentry_open(struct dentry *, struct vfsmount *, int);
diff --git a/include/linux/fs_enet_pd.h b/include/linux/fs_enet_pd.h
new file mode 100644
index 000000000000..783c476b8674
--- /dev/null
+++ b/include/linux/fs_enet_pd.h
@@ -0,0 +1,135 @@
+/*
+ * Platform information definitions for the
+ * universal Freescale Ethernet driver.
+ *
+ * Copyright (c) 2003 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ *
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+#ifndef FS_ENET_PD_H
+#define FS_ENET_PD_H
+
+#include <asm/types.h>
+
+#define FS_ENET_NAME    "fs_enet"
+
+enum fs_id {
+        fsid_fec1,
+        fsid_fec2,
+        fsid_fcc1,
+        fsid_fcc2,
+        fsid_fcc3,
+        fsid_scc1,
+        fsid_scc2,
+        fsid_scc3,
+        fsid_scc4,
+};
+
+#define FS_MAX_INDEX    9
+
+static inline int fs_get_fec_index(enum fs_id id)
+{
+        if (id >= fsid_fec1 && id <= fsid_fec2)
+                return id - fsid_fec1;
+        return -1;
+}
+
+static inline int fs_get_fcc_index(enum fs_id id)
+{
+        if (id >= fsid_fcc1 && id <= fsid_fcc3)
+                return id - fsid_fcc1;
+        return -1;
+}
+
+static inline int fs_get_scc_index(enum fs_id id)
+{
+        if (id >= fsid_scc1 && id <= fsid_scc4)
+                return id - fsid_scc1;
+        return -1;
+}
+
+enum fs_mii_method {
+        fsmii_fixed,
+        fsmii_fec,
+        fsmii_bitbang,
+};
+
+enum fs_ioport {
+        fsiop_porta,
+        fsiop_portb,
+        fsiop_portc,
+        fsiop_portd,
+        fsiop_porte,
+};
+
+struct fs_mii_bus_info {
+        int method;             /* mii method                  */
+        int id;                 /* the id of the mii_bus       */
+        int disable_aneg;       /* if the controller needs to negothiate speed & duplex */
+        int lpa;                /* the default board-specific vallues will be applied otherwise */
+
+        union {
+                struct {
+                        int duplex;
+                        int speed;
+                } fixed;
+
+                struct {
+                        /* nothing */
+                } fec;
+                
+                struct {
+                        /* nothing */
+                } scc;
+
+                struct {
+                        int mdio_port;  /* port & bit for MDIO */
+                        int mdio_bit;
+                        int mdc_port;   /* port & bit for MDC  */
+                        int mdc_bit;
+                        int delay;      /* delay in us         */
+                } bitbang;
+        } i;
+};
+
+struct fs_platform_info {
+        
+        void(*init_ioports)(void);
+        /* device specific information */
+        int fs_no;              /* controller index            */
+
+        u32 cp_page;            /* CPM page */
+        u32 cp_block;           /* CPM sblock */
+        
+        u32 clk_trx;            /* some stuff for pins & mux configuration*/
+        u32 clk_route;
+        u32 clk_mask;
+        
+        u32 mem_offset;
+        u32 dpram_offset;
+        u32 fcc_regs_c;
+        
+        u32 device_flags;
+
+        int phy_addr;           /* the phy address (-1 no phy) */
+        int phy_irq;            /* the phy irq (if it exists)  */
+
+        const struct fs_mii_bus_info *bus_info;
+
+        int rx_ring, tx_ring;   /* number of buffers on rx     */
+        __u8 macaddr[6];        /* mac address                 */
+        int rx_copybreak;       /* limit we copy small frames  */
+        int use_napi;           /* use NAPI                    */
+        int napi_weight;        /* NAPI weight                 */
+
+        int use_rmii;           /* use RMII mode               */
+};
+
+#endif
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
index 70f54af87b9f..934aa9bda481 100644
--- a/include/linux/fsl_devices.h
+++ b/include/linux/fsl_devices.h
@@ -4,7 +4,7 @@
  * Definitions for any platform device related flags or structures for
  * Freescale processor devices
  *
- * Maintainer: Kumar Gala (kumar.gala@freescale.com)
+ * Maintainer: Kumar Gala <galak@kernel.crashing.org>
  *
  * Copyright 2004 Freescale Semiconductor, Inc
  *
@@ -47,16 +47,21 @@
 struct gianfar_platform_data {
         /* device specific information */
         u32 device_flags;
-        u32 phy_reg_addr;
 
         /* board specific information */
         u32 board_flags;
-        u32 phy_flags;
-        u32 phyid;
-        u32 interruptPHY;
+        const char *bus_id;
         u8 mac_addr[6];
 };
 
+struct gianfar_mdio_data {
+        /* device specific information */
+        u32 paddr;
+
+        /* board specific information */
+        int irq[32];
+};
+
 /* Flags related to gianfar device features */
 #define FSL_GIANFAR_DEV_HAS_GIGABIT             0x00000001
 #define FSL_GIANFAR_DEV_HAS_COALESCE            0x00000002
diff --git a/include/linux/fuse.h b/include/linux/fuse.h
index acbeb96a3353..b76b558b03d4 100644
--- a/include/linux/fuse.h
+++ b/include/linux/fuse.h
@@ -14,7 +14,7 @@
 #define FUSE_KERNEL_VERSION 7
 
 /** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 2
+#define FUSE_KERNEL_MINOR_VERSION 3
 
 /** The node ID of the root inode */
 #define FUSE_ROOT_ID 1
@@ -61,7 +61,7 @@ struct fuse_kstatfs {
 #define FATTR_SIZE      (1 << 3)
 #define FATTR_ATIME     (1 << 4)
 #define FATTR_MTIME     (1 << 5)
-#define FATTR_CTIME     (1 << 6)
+#define FATTR_FH        (1 << 6)
 
 /**
  * Flags returned by the OPEN request
@@ -100,7 +100,9 @@ enum fuse_opcode {
         FUSE_OPENDIR       = 27,
         FUSE_READDIR       = 28,
         FUSE_RELEASEDIR    = 29,
-        FUSE_FSYNCDIR      = 30
+        FUSE_FSYNCDIR      = 30,
+        FUSE_ACCESS        = 34,
+        FUSE_CREATE        = 35
 };
 
 /* Conservative buffer size for the client */
@@ -153,12 +155,25 @@ struct fuse_link_in {
 struct fuse_setattr_in {
         __u32   valid;
         __u32   padding;
-        struct fuse_attr attr;
+        __u64   fh;
+        __u64   size;
+        __u64   unused1;
+        __u64   atime;
+        __u64   mtime;
+        __u64   unused2;
+        __u32   atimensec;
+        __u32   mtimensec;
+        __u32   unused3;
+        __u32   mode;
+        __u32   unused4;
+        __u32   uid;
+        __u32   gid;
+        __u32   unused5;
 };
 
 struct fuse_open_in {
         __u32   flags;
-        __u32   padding;
+        __u32   mode;
 };
 
 struct fuse_open_out {
@@ -223,6 +238,11 @@ struct fuse_getxattr_out {
         __u32   padding;
 };
 
+struct fuse_access_in {
+        __u32   mask;
+        __u32   padding;
+};
+
 struct fuse_init_in_out {
         __u32   major;
         __u32   minor;
diff --git a/include/linux/gameport.h b/include/linux/gameport.h
index cd623eccdbea..2401dea2b867 100644
--- a/include/linux/gameport.h
+++ b/include/linux/gameport.h
@@ -12,6 +12,7 @@
 #include <asm/io.h>
 #include <linux/list.h>
 #include <linux/device.h>
+#include <linux/timer.h>
 
 struct gameport {
 
diff --git a/include/linux/genetlink.h b/include/linux/genetlink.h
new file mode 100644
index 000000000000..84f12a41dc01
--- /dev/null
+++ b/include/linux/genetlink.h
@@ -0,0 +1,51 @@
+#ifndef __LINUX_GENERIC_NETLINK_H
+#define __LINUX_GENERIC_NETLINK_H
+
+#include <linux/netlink.h>
+
+#define GENL_NAMSIZ     16      /* length of family name */
+
+#define GENL_MIN_ID     NLMSG_MIN_TYPE
+#define GENL_MAX_ID     1023
+
+struct genlmsghdr {
+        __u8    cmd;
+        __u8    version;
+        __u16   reserved;
+};
+
+#define GENL_HDRLEN     NLMSG_ALIGN(sizeof(struct genlmsghdr))
+
+/*
+ * List of reserved static generic netlink identifiers:
+ */
+#define GENL_ID_GENERATE        0
+#define GENL_ID_CTRL            NLMSG_MIN_TYPE
+
+/**************************************************************************
+ * Controller
+ **************************************************************************/
+
+enum {
+        CTRL_CMD_UNSPEC,
+        CTRL_CMD_NEWFAMILY,
+        CTRL_CMD_DELFAMILY,
+        CTRL_CMD_GETFAMILY,
+        CTRL_CMD_NEWOPS,
+        CTRL_CMD_DELOPS,
+        CTRL_CMD_GETOPS,
+        __CTRL_CMD_MAX,
+};
+
+#define CTRL_CMD_MAX (__CTRL_CMD_MAX - 1)
+
+enum {
+        CTRL_ATTR_UNSPEC,
+        CTRL_ATTR_FAMILY_ID,
+        CTRL_ATTR_FAMILY_NAME,
+        __CTRL_ATTR_MAX,
+};
+
+#define CTRL_ATTR_MAX (__CTRL_ATTR_MAX - 1)
+
+#endif  /* __LINUX_GENERIC_NETLINK_H */
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 01796c41c951..eef5ccdcd731 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -78,7 +78,7 @@ struct hd_struct {
         sector_t start_sect;
         sector_t nr_sects;
         struct kobject kobj;
-        unsigned reads, read_sectors, writes, write_sectors;
+        unsigned ios[2], sectors[2];    /* READs and WRITEs */
         int policy, partno;
 };
 
@@ -89,10 +89,10 @@ struct hd_struct {
 #define GENHD_FL_SUPPRESS_PARTITION_INFO        32
 
 struct disk_stats {
-        unsigned read_sectors, write_sectors;
-        unsigned reads, writes;
-        unsigned read_merges, write_merges;
-        unsigned read_ticks, write_ticks;
+        unsigned sectors[2];            /* READs and WRITEs */
+        unsigned ios[2];
+        unsigned merges[2];
+        unsigned ticks[2];
         unsigned io_ticks;
         unsigned time_in_queue;
 };
@@ -119,7 +119,7 @@ struct gendisk {
         int policy;
 
         atomic_t sync_io;               /* RAID */
-        unsigned long stamp, stamp_idle;
+        unsigned long stamp;
         int in_flight;
 #ifdef  CONFIG_SMP
         struct disk_stats *dkstats;
@@ -132,6 +132,7 @@ struct gendisk {
 struct disk_attribute {
         struct attribute attr;
         ssize_t (*show)(struct gendisk *, char *);
+        ssize_t (*store)(struct gendisk *, const char *, size_t);
 };
 
 /* 
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 4dc990f3b5cc..8b2eab90abb6 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -11,9 +11,16 @@ struct vm_area_struct;
 /*
  * GFP bitmasks..
  */
-/* Zone modifiers in GFP_ZONEMASK (see linux/mmzone.h - low two bits) */
-#define __GFP_DMA       0x01u
-#define __GFP_HIGHMEM   0x02u
+/* Zone modifiers in GFP_ZONEMASK (see linux/mmzone.h - low three bits) */
+#define __GFP_DMA       ((__force gfp_t)0x01u)
+#define __GFP_HIGHMEM   ((__force gfp_t)0x02u)
+#ifdef CONFIG_DMA_IS_DMA32
+#define __GFP_DMA32     ((__force gfp_t)0x01)   /* ZONE_DMA is ZONE_DMA32 */
+#elif BITS_PER_LONG < 64
+#define __GFP_DMA32     ((__force gfp_t)0x00)   /* ZONE_NORMAL is ZONE_DMA32 */
+#else
+#define __GFP_DMA32     ((__force gfp_t)0x04)   /* Has own ZONE_DMA32 */
+#endif
 
 /*
  * Action modifiers - doesn't change the zoning
@@ -26,30 +33,29 @@ struct vm_area_struct;
  *
  * __GFP_NORETRY: The VM implementation must not retry indefinitely.
  */
-#define __GFP_WAIT      0x10u   /* Can wait and reschedule? */
-#define __GFP_HIGH      0x20u   /* Should access emergency pools? */
-#define __GFP_IO        0x40u   /* Can start physical IO? */
-#define __GFP_FS        0x80u   /* Can call down to low-level FS? */
-#define __GFP_COLD      0x100u  /* Cache-cold page required */
-#define __GFP_NOWARN    0x200u  /* Suppress page allocation failure warning */
-#define __GFP_REPEAT    0x400u  /* Retry the allocation.  Might fail */
-#define __GFP_NOFAIL    0x800u  /* Retry for ever.  Cannot fail */
-#define __GFP_NORETRY   0x1000u /* Do not retry.  Might fail */
-#define __GFP_NO_GROW   0x2000u /* Slab internal usage */
-#define __GFP_COMP      0x4000u /* Add compound page metadata */
-#define __GFP_ZERO      0x8000u /* Return zeroed page on success */
-#define __GFP_NOMEMALLOC 0x10000u /* Don't use emergency reserves */
-#define __GFP_NORECLAIM  0x20000u /* No realy zone reclaim during allocation */
-#define __GFP_HARDWALL   0x40000u /* Enforce hardwall cpuset memory allocs */
+#define __GFP_WAIT      ((__force gfp_t)0x10u)  /* Can wait and reschedule? */
+#define __GFP_HIGH      ((__force gfp_t)0x20u)  /* Should access emergency pools? */
+#define __GFP_IO        ((__force gfp_t)0x40u)  /* Can start physical IO? */
+#define __GFP_FS        ((__force gfp_t)0x80u)  /* Can call down to low-level FS? */
+#define __GFP_COLD      ((__force gfp_t)0x100u) /* Cache-cold page required */
+#define __GFP_NOWARN    ((__force gfp_t)0x200u) /* Suppress page allocation failure warning */
+#define __GFP_REPEAT    ((__force gfp_t)0x400u) /* Retry the allocation.  Might fail */
+#define __GFP_NOFAIL    ((__force gfp_t)0x800u) /* Retry for ever.  Cannot fail */
+#define __GFP_NORETRY   ((__force gfp_t)0x1000u)/* Do not retry.  Might fail */
+#define __GFP_NO_GROW   ((__force gfp_t)0x2000u)/* Slab internal usage */
+#define __GFP_COMP      ((__force gfp_t)0x4000u)/* Add compound page metadata */
+#define __GFP_ZERO      ((__force gfp_t)0x8000u)/* Return zeroed page on success */
+#define __GFP_NOMEMALLOC ((__force gfp_t)0x10000u) /* Don't use emergency reserves */
+#define __GFP_HARDWALL   ((__force gfp_t)0x20000u) /* Enforce hardwall cpuset memory allocs */
 
 #define __GFP_BITS_SHIFT 20     /* Room for 20 __GFP_FOO bits */
-#define __GFP_BITS_MASK ((1 << __GFP_BITS_SHIFT) - 1)
+#define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))
 
 /* if you forget to add the bitmask here kernel will crash, period */
 #define GFP_LEVEL_MASK (__GFP_WAIT|__GFP_HIGH|__GFP_IO|__GFP_FS| \
                         __GFP_COLD|__GFP_NOWARN|__GFP_REPEAT| \
                         __GFP_NOFAIL|__GFP_NORETRY|__GFP_NO_GROW|__GFP_COMP| \
-                        __GFP_NOMEMALLOC|__GFP_NORECLAIM|__GFP_HARDWALL)
+                        __GFP_NOMEMALLOC|__GFP_HARDWALL)
 
 #define GFP_ATOMIC      (__GFP_HIGH)
 #define GFP_NOIO        (__GFP_WAIT)
@@ -64,6 +70,16 @@ struct vm_area_struct;
 
 #define GFP_DMA         __GFP_DMA
 
+/* 4GB DMA on some platforms */
+#define GFP_DMA32       __GFP_DMA32
+
+
+static inline int gfp_zone(gfp_t gfp)
+{
+        int zone = GFP_ZONEMASK & (__force int) gfp;
+        BUG_ON(zone >= GFP_ZONETYPES);
+        return zone;
+}
 
 /*
  * There is only one page-allocator function, and two main namespaces to
@@ -85,30 +101,30 @@ static inline void arch_free_page(struct page *page, int order) { }
 #endif
 
 extern struct page *
-FASTCALL(__alloc_pages(unsigned int, unsigned int, struct zonelist *));
+FASTCALL(__alloc_pages(gfp_t, unsigned int, struct zonelist *));
 
-static inline struct page *alloc_pages_node(int nid, unsigned int __nocast gfp_mask,
+static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
                                                 unsigned int order)
 {
         if (unlikely(order >= MAX_ORDER))
                 return NULL;
 
         return __alloc_pages(gfp_mask, order,
-                NODE_DATA(nid)->node_zonelists + (gfp_mask & GFP_ZONEMASK));
+                NODE_DATA(nid)->node_zonelists + gfp_zone(gfp_mask));
 }
 
 #ifdef CONFIG_NUMA
-extern struct page *alloc_pages_current(unsigned int __nocast gfp_mask, unsigned order);
+extern struct page *alloc_pages_current(gfp_t gfp_mask, unsigned order);
 
 static inline struct page *
-alloc_pages(unsigned int __nocast gfp_mask, unsigned int order)
+alloc_pages(gfp_t gfp_mask, unsigned int order)
 {
         if (unlikely(order >= MAX_ORDER))
                 return NULL;
 
         return alloc_pages_current(gfp_mask, order);
 }
-extern struct page *alloc_page_vma(unsigned __nocast gfp_mask,
+extern struct page *alloc_page_vma(gfp_t gfp_mask,
                         struct vm_area_struct *vma, unsigned long addr);
 #else
 #define alloc_pages(gfp_mask, order) \
@@ -117,8 +133,8 @@ extern struct page *alloc_page_vma(unsigned __nocast gfp_mask,
 #endif
 #define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)
 
-extern unsigned long FASTCALL(__get_free_pages(unsigned int __nocast gfp_mask, unsigned int order));
-extern unsigned long FASTCALL(get_zeroed_page(unsigned int __nocast gfp_mask));
+extern unsigned long FASTCALL(__get_free_pages(gfp_t gfp_mask, unsigned int order));
+extern unsigned long FASTCALL(get_zeroed_page(gfp_t gfp_mask));
 
 #define __get_free_page(gfp_mask) \
                 __get_free_pages((gfp_mask),0)
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index 5912874ca83c..71d2b8a723b9 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -90,6 +90,8 @@ extern void synchronize_irq(unsigned int irq);
 #define nmi_enter()             irq_enter()
 #define nmi_exit()              sub_preempt_count(HARDIRQ_OFFSET)
 
+struct task_struct;
+
 #ifndef CONFIG_VIRT_CPU_ACCOUNTING
 static inline void account_user_vtime(struct task_struct *tsk)
 {
diff --git a/include/linux/hdreg.h b/include/linux/hdreg.h
index b5d660089de4..2b54eac738ea 100644
--- a/include/linux/hdreg.h
+++ b/include/linux/hdreg.h
@@ -80,10 +80,12 @@
 /*
  * Define standard taskfile in/out register
  */
-#define IDE_TASKFILE_STD_OUT_FLAGS      0xFE
 #define IDE_TASKFILE_STD_IN_FLAGS       0xFE
-#define IDE_HOB_STD_OUT_FLAGS           0x3C
 #define IDE_HOB_STD_IN_FLAGS            0x3C
+#ifndef __KERNEL__
+#define IDE_TASKFILE_STD_OUT_FLAGS      0xFE
+#define IDE_HOB_STD_OUT_FLAGS           0x3C
+#endif
 
 typedef unsigned char task_ioreg_t;
 typedef unsigned long sata_ioreg_t;
diff --git a/include/linux/hil.h b/include/linux/hil.h
new file mode 100644
index 000000000000..13352d7d0caf
--- /dev/null
+++ b/include/linux/hil.h
@@ -0,0 +1,483 @@
+#ifndef _HIL_H_
+#define _HIL_H_
+
+/*
+ * Hewlett Packard Human Interface Loop (HP-HIL) Protocol -- header.
+ *
+ * Copyright (c) 2001 Brian S. Julin
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL").
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ *
+ * References:
+ * HP-HIL Technical Reference Manual.  Hewlett Packard Product No. 45918A
+ *
+ * A note of thanks to HP for providing and shipping reference materials
+ * free of charge to help in the development of HIL support for Linux.
+ *
+ */
+
+#include <asm/types.h>
+
+/* Physical constants relevant to raw loop/device timing. 
+ */ 
+
+#define HIL_CLOCK               8MHZ
+#define HIL_EK1_CLOCK           30HZ
+#define HIL_EK2_CLOCK           60HZ
+
+#define HIL_TIMEOUT_DEV         5       /* ms */
+#define HIL_TIMEOUT_DEVS        10      /* ms */
+#define HIL_TIMEOUT_NORESP      10      /* ms */
+#define HIL_TIMEOUT_DEVS_DATA   16      /* ms */
+#define HIL_TIMEOUT_SELFTEST    200     /* ms */
+
+
+/* Actual wire line coding.  These will only be useful if someone is 
+ * implementing a software MLC to run HIL devices on a non-parisc machine.
+ */
+
+#define HIL_WIRE_PACKET_LEN     15
+enum hil_wire_bitpos {
+        HIL_WIRE_START          = 0,
+        HIL_WIRE_ADDR2,
+        HIL_WIRE_ADDR1,
+        HIL_WIRE_ADDR0,
+        HIL_WIRE_COMMAND,
+        HIL_WIRE_DATA7,
+        HIL_WIRE_DATA6,
+        HIL_WIRE_DATA5,
+        HIL_WIRE_DATA4,
+        HIL_WIRE_DATA3,
+        HIL_WIRE_DATA2,
+        HIL_WIRE_DATA1,
+        HIL_WIRE_DATA0,
+        HIL_WIRE_PARITY,
+        HIL_WIRE_STOP
+};
+
+/* HP documentation uses these bit positions to refer to commands;
+ * we will call these "packets".
+ */
+enum hil_pkt_bitpos {
+        HIL_PKT_CMD             = 0x00000800,
+        HIL_PKT_ADDR2           = 0x00000400,
+        HIL_PKT_ADDR1           = 0x00000200,
+        HIL_PKT_ADDR0           = 0x00000100,
+        HIL_PKT_ADDR_MASK       = 0x00000700,
+        HIL_PKT_ADDR_SHIFT      = 8,
+        HIL_PKT_DATA7           = 0x00000080,
+        HIL_PKT_DATA6           = 0x00000040,
+        HIL_PKT_DATA5           = 0x00000020,
+        HIL_PKT_DATA4           = 0x00000010,
+        HIL_PKT_DATA3           = 0x00000008,
+        HIL_PKT_DATA2           = 0x00000004,
+        HIL_PKT_DATA1           = 0x00000002,
+        HIL_PKT_DATA0           = 0x00000001,
+        HIL_PKT_DATA_MASK       = 0x000000FF,
+        HIL_PKT_DATA_SHIFT      = 0
+};
+
+/* The HIL MLC also has several error/status/control bits.  We extend the 
+ * "packet" to include these when direct access to the MLC is available,
+ * or emulate them in cases where they are not available. 
+ *
+ * This way the device driver knows that the underlying MLC driver
+ * has had to deal with loop errors.
+ */
+enum hil_error_bitpos {
+        HIL_ERR_OB      = 0x00000800, /* MLC is busy sending an auto-poll, 
+                                         or we have filled up the output 
+                                         buffer and must wait. */
+        HIL_ERR_INT     = 0x00010000, /* A normal interrupt has occurred. */
+        HIL_ERR_NMI     = 0x00020000, /* An NMI has occurred. */
+        HIL_ERR_LERR    = 0x00040000, /* A poll didn't come back. */
+        HIL_ERR_PERR    = 0x01000000, /* There was a Parity Error. */
+        HIL_ERR_FERR    = 0x02000000, /* There was a Framing Error. */
+        HIL_ERR_FOF     = 0x04000000  /* Input FIFO Overflowed. */
+};
+
+enum hil_control_bitpos {
+        HIL_CTRL_TEST   = 0x00010000,
+        HIL_CTRL_IPF    = 0x00040000,
+        HIL_CTRL_APE    = 0x02000000
+};
+
+/* Bits 30,31 are unused, we use them to control write behavior. */
+#define HIL_DO_ALTER_CTRL  0x40000000 /* Write MSW of packet to control 
+                                          before writing LSW to loop */
+#define HIL_CTRL_ONLY      0xc0000000 /* *Only* alter the control registers */
+
+/* This gives us a 32-bit "packet" 
+ */
+typedef u32 hil_packet;
+
+
+/* HIL Loop commands 
+ */
+enum hil_command {
+        HIL_CMD_IFC     = 0x00, /* Interface Clear */
+        HIL_CMD_EPT     = 0x01, /* Enter Pass-Thru Mode */
+        HIL_CMD_ELB     = 0x02, /* Enter Loop-Back Mode */
+        HIL_CMD_IDD     = 0x03, /* Identify and Describe */
+        HIL_CMD_DSR     = 0x04, /* Device Soft Reset */
+        HIL_CMD_PST     = 0x05, /* Perform Self Test */
+        HIL_CMD_RRG     = 0x06, /* Read Register */
+        HIL_CMD_WRG     = 0x07, /* Write Register */
+        HIL_CMD_ACF     = 0x08, /* Auto Configure */
+        HIL_CMDID_ACF   = 0x07, /* Auto Configure bits with incremented ID */
+        HIL_CMD_POL     = 0x10, /* Poll */
+        HIL_CMDCT_POL   = 0x0f, /* Poll command bits with item count  */
+        HIL_CMD_RPL     = 0x20, /* RePoll */
+        HIL_CMDCT_RPL   = 0x0f, /* RePoll command bits with item count */
+        HIL_CMD_RNM     = 0x30, /* Report Name */
+        HIL_CMD_RST     = 0x31, /* Report Status */
+        HIL_CMD_EXD     = 0x32, /* Extended Describe */
+        HIL_CMD_RSC     = 0x33, /* Report Security Code */
+
+        /* 0x34 to 0x3c reserved for future use  */
+
+        HIL_CMD_DKA     = 0x3d, /* Disable Keyswitch Autorepeat */
+        HIL_CMD_EK1     = 0x3e, /* Enable Keyswitch Autorepeat 1 */
+        HIL_CMD_EK2     = 0x3f, /* Enable Keyswitch Autorepeat 2 */
+        HIL_CMD_PR1     = 0x40, /* Prompt1 */  
+        HIL_CMD_PR2     = 0x41, /* Prompt2 */
+        HIL_CMD_PR3     = 0x42, /* Prompt3 */
+        HIL_CMD_PR4     = 0x43, /* Prompt4 */
+        HIL_CMD_PR5     = 0x44, /* Prompt5 */
+        HIL_CMD_PR6     = 0x45, /* Prompt6 */
+        HIL_CMD_PR7     = 0x46, /* Prompt7 */
+        HIL_CMD_PRM     = 0x47, /* Prompt (General Purpose) */
+        HIL_CMD_AK1     = 0x48, /* Acknowlege1 */  
+        HIL_CMD_AK2     = 0x49, /* Acknowlege2 */
+        HIL_CMD_AK3     = 0x4a, /* Acknowlege3 */
+        HIL_CMD_AK4     = 0x4b, /* Acknowlege4 */
+        HIL_CMD_AK5     = 0x4c, /* Acknowlege5 */
+        HIL_CMD_AK6     = 0x4d, /* Acknowlege6 */
+        HIL_CMD_AK7     = 0x4e, /* Acknowlege7 */
+        HIL_CMD_ACK     = 0x4f, /* Acknowlege (General Purpose) */
+
+        /* 0x50 to 0x78 reserved for future use  */
+        /* 0x80 to 0xEF device-specific commands */
+        /* 0xf0 to 0xf9 reserved for future use  */
+
+        HIL_CMD_RIO     = 0xfa, /* Register I/O Error */
+        HIL_CMD_SHR     = 0xfb, /* System Hard Reset */
+        HIL_CMD_TER     = 0xfc, /* Transmission Error */
+        HIL_CMD_CAE     = 0xfd, /* Configuration Address Error */
+        HIL_CMD_DHR     = 0xfe, /* Device Hard Reset */
+
+        /* 0xff is prohibited from use. */
+};
+
+
+/* 
+ * Response "records" to HIL commands
+ */
+
+/* Device ID byte 
+ */
+#define HIL_IDD_DID_TYPE_MASK           0xe0    /* Primary type bits */
+#define HIL_IDD_DID_TYPE_KB_INTEGRAL    0xa0    /* Integral keyboard */
+#define HIL_IDD_DID_TYPE_KB_ITF         0xc0    /* ITD keyboard */
+#define HIL_IDD_DID_TYPE_KB_RSVD        0xe0    /* Reserved keyboard type */
+#define HIL_IDD_DID_TYPE_KB_LANG_MASK   0x1f    /* Keyboard locale bits */
+#define HIL_IDD_DID_KBLANG_USE_ESD      0x00    /* Use ESD Locale instead */
+#define HIL_IDD_DID_TYPE_ABS            0x80    /* Absolute Positioners */
+#define HIL_IDD_DID_ABS_RSVD1_MASK      0xf8    /* Reserved */
+#define HIL_IDD_DID_ABS_RSVD1           0x98
+#define HIL_IDD_DID_ABS_TABLET_MASK     0xf8    /* Tablets and digitizers */
+#define HIL_IDD_DID_ABS_TABLET          0x90
+#define HIL_IDD_DID_ABS_TSCREEN_MASK    0xfc    /* Touch screens */
+#define HIL_IDD_DID_ABS_TSCREEN         0x8c
+#define HIL_IDD_DID_ABS_RSVD2_MASK      0xfc    /* Reserved */
+#define HIL_IDD_DID_ABS_RSVD2           0x88
+#define HIL_IDD_DID_ABS_RSVD3_MASK      0xfc    /* Reserved */
+#define HIL_IDD_DID_ABS_RSVD3           0x80
+#define HIL_IDD_DID_TYPE_REL            0x60    /* Relative Positioners */
+#define HIL_IDD_DID_REL_RSVD1_MASK      0xf0    /* Reserved */
+#define HIL_IDD_DID_REL_RSVD1           0x70
+#define HIL_IDD_DID_REL_RSVD2_MASK      0xfc    /* Reserved */
+#define HIL_IDD_DID_REL_RSVD2           0x6c
+#define HIL_IDD_DID_REL_MOUSE_MASK      0xfc    /* Mouse */
+#define HIL_IDD_DID_REL_MOUSE           0x68
+#define HIL_IDD_DID_REL_QUAD_MASK       0xf8    /* Other Quadrature Devices */
+#define HIL_IDD_DID_REL_QUAD            0x60
+#define HIL_IDD_DID_TYPE_CHAR           0x40    /* Character Entry */
+#define HIL_IDD_DID_CHAR_BARCODE_MASK   0xfc    /* Barcode Reader */
+#define HIL_IDD_DID_CHAR_BARCODE        0x5c
+#define HIL_IDD_DID_CHAR_RSVD1_MASK     0xfc    /* Reserved */
+#define HIL_IDD_DID_CHAR_RSVD1          0x58
+#define HIL_IDD_DID_CHAR_RSVD2_MASK     0xf8    /* Reserved */
+#define HIL_IDD_DID_CHAR_RSVD2          0x50
+#define HIL_IDD_DID_CHAR_RSVD3_MASK     0xf0    /* Reserved */
+#define HIL_IDD_DID_CHAR_RSVD3          0x40
+#define HIL_IDD_DID_TYPE_OTHER          0x20    /* Miscellaneous */
+#define HIL_IDD_DID_OTHER_RSVD1_MASK    0xf0    /* Reserved */
+#define HIL_IDD_DID_OTHER_RSVD1         0x30
+#define HIL_IDD_DID_OTHER_BARCODE_MASK  0xfc    /* Tone Generator */
+#define HIL_IDD_DID_OTHER_BARCODE       0x2c
+#define HIL_IDD_DID_OTHER_RSVD2_MASK    0xfc    /* Reserved */
+#define HIL_IDD_DID_OTHER_RSVD2         0x28
+#define HIL_IDD_DID_OTHER_RSVD3_MASK    0xf8    /* Reserved */
+#define HIL_IDD_DID_OTHER_RSVD3         0x20
+#define HIL_IDD_DID_TYPE_KEYPAD         0x00    /* Vectra Keyboard */
+
+/* IDD record header 
+ */
+#define HIL_IDD_HEADER_AXSET_MASK       0x03    /* Number of axis in a set */
+#define HIL_IDD_HEADER_RSC              0x04    /* Supports RSC command */
+#define HIL_IDD_HEADER_EXD              0x08    /* Supports EXD command */
+#define HIL_IDD_HEADER_IOD              0x10    /* IOD byte to follow */
+#define HIL_IDD_HEADER_16BIT            0x20    /* 16 (vs. 8) bit resolution */
+#define HIL_IDD_HEADER_ABS              0x40    /* Reports Absolute Position */
+#define HIL_IDD_HEADER_2X_AXIS          0x80    /* Two sets of 1-3 axis */
+
+/* I/O Descriptor
+ */
+#define HIL_IDD_IOD_NBUTTON_MASK        0x07    /* Number of buttons */
+#define HIL_IDD_IOD_PROXIMITY           0x08    /* Proximity in/out events */
+#define HIL_IDD_IOD_PROMPT_MASK         0x70    /* Number of prompts/acks */
+#define HIL_IDD_IOD_PROMPT_SHIFT        4
+#define HIL_IDD_IOD_PROMPT              0x80    /* Generic prompt/ack */
+
+#define HIL_IDD_NUM_AXES_PER_SET(header_packet) \
+((header_packet) & HIL_IDD_HEADER_AXSET_MASK)
+
+#define HIL_IDD_NUM_AXSETS(header_packet) \
+(2 - !((header_packet) & HIL_IDD_HEADER_2X_AXIS))
+
+#define HIL_IDD_LEN(header_packet) \
+((4 - !(header_packet & HIL_IDD_HEADER_IOD) -                   \
+  2 * !(HIL_IDD_NUM_AXES_PER_SET(header_packet))) +             \
+  2 * HIL_IDD_NUM_AXES_PER_SET(header_packet) *                 \
+ !!((header_packet) & HIL_IDD_HEADER_ABS))
+
+/* The following HIL_IDD_* macros assume you have an array of 
+ * packets and/or unpacked 8-bit data in the order that they 
+ * were received.
+ */
+
+#define HIL_IDD_AXIS_COUNTS_PER_M(header_ptr) \
+(!(HIL_IDD_NUM_AXSETS(*(header_ptr))) ? -1 :                    \
+(((*(header_ptr + 1) & HIL_PKT_DATA_MASK) +                     \
+  ((*(header_ptr + 2) & HIL_PKT_DATA_MASK)) << 8)               \
+* ((*(header_ptr) & HIL_IDD_HEADER_16BIT) ? 100 : 1)))
+
+#define HIL_IDD_AXIS_MAX(header_ptr, __axnum) \
+((!(*(header_ptr) & HIL_IDD_HEADER_ABS) ||                      \
+  (HIL_IDD_NUM_AXES_PER_SET(*(header_ptr)) <= __axnum)) ? 0 :   \
+ ((HIL_PKT_DATA_MASK & *((header_ptr) + 3 + 2 * __axnum)) +     \
+  ((HIL_PKT_DATA_MASK & *((header_ptr) + 4 + 2 * __axnum)) << 8)))
+
+#define HIL_IDD_IOD(header_ptr) \
+(*(header_ptr + HIL_IDD_LEN((*header_ptr)) - 1))
+
+#define HIL_IDD_HAS_GEN_PROMPT(header_ptr) \
+((*header_ptr & HIL_IDD_HEADER_IOD) &&                          \
+ (HIL_IDD_IOD(header_ptr) & HIL_IDD_IOD_PROMPT))
+
+#define HIL_IDD_HAS_GEN_PROXIMITY(header_ptr) \
+((*header_ptr & HIL_IDD_HEADER_IOD) &&                          \
+ (HIL_IDD_IOD(header_ptr) & HIL_IDD_IOD_PROXIMITY))
+
+#define HIL_IDD_NUM_BUTTONS(header_ptr) \
+((*header_ptr & HIL_IDD_HEADER_IOD) ?                           \
+ (HIL_IDD_IOD(header_ptr) & HIL_IDD_IOD_NBUTTON_MASK) : 0)
+
+#define HIL_IDD_NUM_PROMPTS(header_ptr) \
+((*header_ptr & HIL_IDD_HEADER_IOD) ?                           \
+ ((HIL_IDD_IOD(header_ptr) & HIL_IDD_IOD_NPROMPT_MASK)          \
+  >> HIL_IDD_IOD_PROMPT_SHIFT) : 0)
+
+/* The response to HIL EXD commands -- the "extended describe record" */
+#define HIL_EXD_HEADER_WRG              0x03    /* Supports type2 WRG */
+#define HIL_EXD_HEADER_WRG_TYPE1        0x01    /* Supports type1 WRG */
+#define HIL_EXD_HEADER_WRG_TYPE2        0x02    /* Supports type2 WRG */
+#define HIL_EXD_HEADER_RRG              0x04    /* Supports RRG command */
+#define HIL_EXD_HEADER_RNM              0x10    /* Supports RNM command */
+#define HIL_EXD_HEADER_RST              0x20    /* Supports RST command */
+#define HIL_EXD_HEADER_LOCALE           0x40    /* Contains locale code */
+
+#define HIL_EXD_NUM_RRG(header_ptr) \
+((*header_ptr & HIL_EXD_HEADER_RRG) ? \
+ (*(header_ptr + 1) & HIL_PKT_DATA_MASK) : 0)
+
+#define HIL_EXD_NUM_WWG(header_ptr) \
+((*header_ptr & HIL_EXD_HEADER_WRG) ?                           \
+ (*(header_ptr + 2 - !(*header_ptr & HIL_EXD_HEADER_RRG)) &     \
+    HIL_PKT_DATA_MASK) : 0)
+
+#define HIL_EXD_LEN(header_ptr) \
+(!!(*header_ptr & HIL_EXD_HEADER_RRG) +                         \
+ !!(*header_ptr & HIL_EXD_HEADER_WRG) +                         \
+ !!(*header_ptr & HIL_EXD_HEADER_LOCALE) +                      \
+ 2 * !!(*header_ptr & HIL_EXD_HEADER_WRG_TYPE2) + 1)
+
+#define HIL_EXD_LOCALE(header_ptr) \
+(!(*header_ptr & HIL_EXD_HEADER_LOCALE) ? -1 :                  \
+ (*(header_ptr + HIL_EXD_LEN(header_ptr) - 1) & HIL_PKT_DATA_MASK))
+
+#define HIL_EXD_WRG_TYPE2_LEN(header_ptr) \
+(!(*header_ptr & HIL_EXD_HEADER_WRG_TYPE2) ? -1 :                       \
+ (*(header_ptr + HIL_EXD_LEN(header_ptr) - 2 -                          \
+    !!(*header_ptr & HIL_EXD_HEADER_LOCALE)) & HIL_PKT_DATA_MASK) +     \
+ ((*(header_ptr + HIL_EXD_LEN(header_ptr) - 1 -                         \
+     !!(*header_ptr & HIL_EXD_HEADER_LOCALE)) & HIL_PKT_DATA_MASK) << 8))
+
+/* Device locale codes. */ 
+
+/* Last defined locale code.  Everything above this is "Reserved",
+   and note that this same table applies to the Device ID Byte where 
+   keyboards may have a nationality code which is only 5 bits. */
+#define HIL_LOCALE_MAX 0x1f
+
+/* Map to hopefully useful strings.  I was trying to make these look
+   like locale.aliases strings do; maybe that isn't the right table to
+   emulate.  In either case, I didn't have much to work on. */
+#define HIL_LOCALE_MAP \
+"",                     /* 0x00 Reserved */             \
+"",                     /* 0x01 Reserved */             \
+"",                     /* 0x02 Reserved */             \
+"swiss.french",         /* 0x03 Swiss/French */         \
+"portuguese",           /* 0x04 Portuguese */           \
+"arabic",               /* 0x05 Arabic */               \
+"hebrew",               /* 0x06 Hebrew */               \
+"english.canadian",     /* 0x07 Canadian English */     \
+"turkish",              /* 0x08 Turkish */              \
+"greek",                /* 0x09 Greek */                \
+"thai",                 /* 0x0a Thai (Thailand) */      \
+"italian",              /* 0x0b Italian */              \
+"korean",               /* 0x0c Hangul (Korea) */       \
+"dutch",                /* 0x0d Dutch */                \
+"swedish",              /* 0x0e Swedish */              \
+"german",               /* 0x0f German */               \
+"chinese",              /* 0x10 Chinese-PRC */          \
+"chinese",              /* 0x11 Chinese-ROC */          \
+"swiss.french",         /* 0x12 Swiss/French II */      \
+"spanish",              /* 0x13 Spanish */              \
+"swiss.german",         /* 0x14 Swiss/German II */      \
+"flemish",              /* 0x15 Belgian (Flemish) */    \
+"finnish",              /* 0x16 Finnish */              \
+"english.uk",           /* 0x17 United Kingdom */       \
+"french.canadian",      /* 0x18 French/Canadian */      \
+"swiss.german",         /* 0x19 Swiss/German */         \
+"norwegian",            /* 0x1a Norwegian */            \
+"french",               /* 0x1b French */               \
+"danish",               /* 0x1c Danish */               \
+"japanese",             /* 0x1d Katakana */             \
+"spanish",              /* 0x1e Latin American/Spanish*/\
+"english.us"            /* 0x1f United States */        \
+
+
+/* HIL keycodes */
+#define HIL_KEYCODES_SET1_TBLSIZE 128
+#define HIL_KEYCODES_SET1       \
+   KEY_5,               KEY_RESERVED,   KEY_RIGHTALT,   KEY_LEFTALT,    \
+   KEY_RIGHTSHIFT,      KEY_LEFTSHIFT,  KEY_LEFTCTRL,   KEY_SYSRQ,      \
+   KEY_KP4,             KEY_KP8,        KEY_KP5,        KEY_KP9,        \
+   KEY_KP6,             KEY_KP7,        KEY_KPCOMMA,    KEY_KPENTER,    \
+   KEY_KP1,             KEY_KPSLASH,    KEY_KP2,        KEY_KPPLUS,     \
+   KEY_KP3,             KEY_KPASTERISK, KEY_KP0,        KEY_KPMINUS,    \
+   KEY_B,               KEY_V,          KEY_C,          KEY_X,          \
+   KEY_Z,               KEY_RESERVED,   KEY_RESERVED,   KEY_ESC,        \
+   KEY_6,               KEY_F10,        KEY_3,          KEY_F11,        \
+   KEY_KPDOT,           KEY_F9,         KEY_TAB /*KP*/, KEY_F12,        \
+   KEY_H,               KEY_G,          KEY_F,          KEY_D,          \
+   KEY_S,               KEY_A,          KEY_RESERVED,   KEY_CAPSLOCK,   \
+   KEY_U,               KEY_Y,          KEY_T,          KEY_R,          \
+   KEY_E,               KEY_W,          KEY_Q,          KEY_TAB,        \
+   KEY_7,               KEY_6,          KEY_5,          KEY_4,          \
+   KEY_3,               KEY_2,          KEY_1,          KEY_GRAVE,      \
+   KEY_F13,             KEY_F14,        KEY_F15,        KEY_F16,        \
+   KEY_F17,             KEY_F18,        KEY_F19,        KEY_F20,        \
+   KEY_MENU,            KEY_F4,         KEY_F3,         KEY_F2,         \
+   KEY_F1,              KEY_VOLUMEUP,   KEY_STOP,       KEY_SENDFILE,   \
+   KEY_SYSRQ,           KEY_F5,         KEY_F6,         KEY_F7,         \
+   KEY_F8,              KEY_VOLUMEDOWN, KEY_DEL_EOL,    KEY_DEL_EOS,    \
+   KEY_8,               KEY_9,          KEY_0,          KEY_MINUS,      \
+   KEY_EQUAL,           KEY_BACKSPACE,  KEY_INS_LINE,   KEY_DEL_LINE,   \
+   KEY_I,               KEY_O,          KEY_P,          KEY_LEFTBRACE,  \
+   KEY_RIGHTBRACE,      KEY_BACKSLASH,  KEY_INSERT,     KEY_DELETE,     \
+   KEY_J,               KEY_K,          KEY_L,          KEY_SEMICOLON,  \
+   KEY_APOSTROPHE,      KEY_ENTER,      KEY_HOME,       KEY_PAGEUP,     \
+   KEY_M,               KEY_COMMA,      KEY_DOT,        KEY_SLASH,      \
+   KEY_BACKSLASH,       KEY_SELECT,     KEY_102ND,      KEY_PAGEDOWN,   \
+   KEY_N,               KEY_SPACE,      KEY_NEXT,       KEY_RESERVED,   \
+   KEY_LEFT,            KEY_DOWN,       KEY_UP,         KEY_RIGHT
+
+
+#define HIL_KEYCODES_SET3_TBLSIZE 128
+#define HIL_KEYCODES_SET3       \
+  KEY_RESERVED, KEY_ESC,        KEY_1,          KEY_2,                  \
+  KEY_3,        KEY_4,          KEY_5,          KEY_6,                  \
+  KEY_7,        KEY_8,          KEY_9,          KEY_0,                  \
+  KEY_MINUS,    KEY_EQUAL,      KEY_BACKSPACE,  KEY_TAB,                \
+  KEY_Q,        KEY_W,          KEY_E,          KEY_R,                  \
+  KEY_T,        KEY_Y,          KEY_U,          KEY_I,                  \
+  KEY_O,        KEY_P,          KEY_LEFTBRACE,  KEY_RIGHTBRACE,         \
+  KEY_ENTER,    KEY_LEFTCTRL,   KEY_A,          KEY_S,                  \
+  KEY_D,        KEY_F,          KEY_G,          KEY_H,                  \
+  KEY_J,        KEY_K,          KEY_L,          KEY_SEMICOLON,          \
+  KEY_APOSTROPHE,KEY_GRAVE,     KEY_LEFTSHIFT,  KEY_BACKSLASH,          \
+  KEY_Z,        KEY_X,          KEY_C,          KEY_V,                  \
+  KEY_B,        KEY_N,          KEY_M,          KEY_COMMA,              \
+  KEY_DOT,      KEY_SLASH,      KEY_RIGHTSHIFT, KEY_KPASTERISK,         \
+  KEY_LEFTALT,  KEY_SPACE,      KEY_CAPSLOCK,   KEY_F1,                 \
+  KEY_F2,       KEY_F3,         KEY_F4,         KEY_F5,                 \
+  KEY_F6,       KEY_F7,         KEY_F8,         KEY_F9,                 \
+  KEY_F10,      KEY_NUMLOCK,    KEY_SCROLLLOCK, KEY_KP7,                \
+  KEY_KP8,      KEY_KP9,        KEY_KPMINUS,    KEY_KP4,                \
+  KEY_KP5,      KEY_KP6,        KEY_KPPLUS,     KEY_KP1,                \
+  KEY_KP2,      KEY_KP3,        KEY_KP0,        KEY_KPDOT,              \
+  KEY_SYSRQ,    KEY_RESERVED,   KEY_RESERVED,   KEY_RESERVED,           \
+  KEY_RESERVED, KEY_RESERVED,   KEY_RESERVED,   KEY_RESERVED,           \
+  KEY_RESERVED, KEY_RESERVED,   KEY_RESERVED,   KEY_RESERVED,           \
+  KEY_UP,       KEY_LEFT,       KEY_DOWN,       KEY_RIGHT,              \
+  KEY_HOME,     KEY_PAGEUP,     KEY_END,        KEY_PAGEDOWN,           \
+  KEY_INSERT,   KEY_DELETE,     KEY_102ND,      KEY_RESERVED,           \
+  KEY_RESERVED, KEY_RESERVED,   KEY_RESERVED,   KEY_RESERVED,           \
+  KEY_F1,       KEY_F2,         KEY_F3,         KEY_F4,                 \
+  KEY_F5,       KEY_F6,         KEY_F7,         KEY_F8,                 \
+  KEY_RESERVED, KEY_RESERVED,   KEY_RESERVED,   KEY_RESERVED,           \
+  KEY_RESERVED, KEY_RESERVED,   KEY_RESERVED,   KEY_RESERVED
+
+
+/* Response to POL command, the "poll record header" */
+
+#define HIL_POL_NUM_AXES_MASK   0x03    /* Number of axis reported */
+#define HIL_POL_CTS             0x04    /* Device ready to receive data */
+#define HIL_POL_STATUS_PENDING  0x08    /* Device has status to report */
+#define HIL_POL_CHARTYPE_MASK   0x70    /* Type of character data to follow */
+#define HIL_POL_CHARTYPE_NONE   0x00    /* No character data to follow */
+#define HIL_POL_CHARTYPE_RSVD1  0x10    /* Reserved Set 1 */
+#define HIL_POL_CHARTYPE_ASCII  0x20    /* U.S. ASCII */
+#define HIL_POL_CHARTYPE_BINARY 0x30    /* Binary data */
+#define HIL_POL_CHARTYPE_SET1   0x40    /* Keycode Set 1 */
+#define HIL_POL_CHARTYPE_RSVD2  0x50    /* Reserved Set 2 */
+#define HIL_POL_CHARTYPE_SET2   0x60    /* Keycode Set 2 */
+#define HIL_POL_CHARTYPE_SET3   0x70    /* Keycode Set 3 */
+#define HIL_POL_AXIS_ALT        0x80    /* Data is from axis set 2 */
+
+
+#endif /* _HIL_H_ */
diff --git a/include/linux/hil_mlc.h b/include/linux/hil_mlc.h
new file mode 100644
index 000000000000..8df29ca48a13
--- /dev/null
+++ b/include/linux/hil_mlc.h
@@ -0,0 +1,168 @@
+/*
+ * HP Human Interface Loop Master Link Controller driver.
+ *
+ * Copyright (c) 2001 Brian S. Julin
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL").
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ *
+ * References:
+ * HP-HIL Technical Reference Manual.  Hewlett Packard Product No. 45918A
+ *
+ */
+
+#include <linux/hil.h>
+#include <linux/time.h>
+#include <linux/interrupt.h>
+#include <asm/semaphore.h>
+#include <linux/serio.h>
+#include <linux/list.h>
+
+typedef struct hil_mlc hil_mlc;
+
+/* The HIL has a complicated state engine.
+ * We define the structure of nodes in the state engine here.
+ */
+enum hilse_act {
+        /* HILSE_OUT prepares to receive input if the next node
+         * is an IN or EXPECT, and then sends the given packet.
+         */
+        HILSE_OUT = 0,
+
+        /* HILSE_CTS checks if the loop is busy. */
+        HILSE_CTS,
+
+        /* HILSE_OUT_LAST sends the given command packet to 
+         * the last configured/running device on the loop.
+         */
+        HILSE_OUT_LAST,
+
+        /* HILSE_OUT_DISC sends the given command packet to
+         * the next device past the last configured/running one.
+         */
+        HILSE_OUT_DISC,
+
+        /* HILSE_FUNC runs a callback function with given arguments.
+         * a positive return value causes the "ugly" branch to be taken.
+         */
+        HILSE_FUNC,
+
+        /* HILSE_IN simply expects any non-errored packet to arrive 
+         * within arg usecs.
+         */
+        HILSE_IN                = 0x100,
+
+        /* HILSE_EXPECT expects a particular packet to arrive 
+         * within arg usecs, any other packet is considered an error.
+         */
+        HILSE_EXPECT,
+
+        /* HILSE_EXPECT_LAST as above but dev field should be last 
+         * discovered/operational device.
+         */
+        HILSE_EXPECT_LAST,
+
+        /* HILSE_EXPECT_LAST as above but dev field should be first 
+         * undiscovered/inoperational device.
+         */
+        HILSE_EXPECT_DISC
+};
+
+typedef int     (hilse_func) (hil_mlc *mlc, int arg);
+struct hilse_node {
+        enum hilse_act          act;    /* How to process this node         */
+        union {
+                hilse_func      *func;  /* Function to call if HILSE_FUNC   */
+                hil_packet      packet; /* Packet to send or to compare     */
+        } object;
+        int                     arg;    /* Timeout in usec or parm for func */
+        int                     good;   /* Node to jump to on success       */
+        int                     bad;    /* Node to jump to on error         */
+        int                     ugly;   /* Node to jump to on timeout       */
+};
+
+/* Methods for back-end drivers, e.g. hp_sdc_mlc */
+typedef int     (hil_mlc_cts) (hil_mlc *mlc);
+typedef void    (hil_mlc_out) (hil_mlc *mlc);
+typedef int     (hil_mlc_in)  (hil_mlc *mlc, suseconds_t timeout);
+
+struct hil_mlc_devinfo {
+        uint8_t idd[16];        /* Device ID Byte and Describe Record */
+        uint8_t rsc[16];        /* Security Code Header and Record */
+        uint8_t exd[16];        /* Extended Describe Record */
+        uint8_t rnm[16];        /* Device name as returned by RNM command */
+};
+
+struct hil_mlc_serio_map {
+        hil_mlc *mlc;
+        int di_revmap;
+        int didx;
+};
+
+/* How many (possibly old/detached) devices the we try to keep track of */
+#define HIL_MLC_DEVMEM 16
+
+struct hil_mlc {
+        struct list_head        list;   /* hil_mlc is organized as linked list */
+
+        rwlock_t                lock;
+
+        void *priv; /* Data specific to a particular type of MLC */
+
+        int                     seidx;  /* Current node in state engine */
+        int                     istarted, ostarted;
+
+        hil_mlc_cts             *cts;
+        struct semaphore        csem;   /* Raised when loop idle */
+
+        hil_mlc_out             *out;
+        struct semaphore        osem;   /* Raised when outpacket dispatched */
+        hil_packet              opacket;
+
+        hil_mlc_in              *in;
+        struct semaphore        isem;   /* Raised when a packet arrives */
+        hil_packet              ipacket[16];
+        hil_packet              imatch;
+        int                     icount;
+        struct timeval          instart;
+        suseconds_t             intimeout;
+
+        int                     ddi;    /* Last operational device id */
+        int                     lcv;    /* LCV to throttle loops */
+        struct timeval          lcv_tv; /* Time loop was started */
+
+        int                     di_map[7]; /* Maps below items to live devs */
+        struct hil_mlc_devinfo  di[HIL_MLC_DEVMEM];
+        struct serio            *serio[HIL_MLC_DEVMEM];
+        struct hil_mlc_serio_map serio_map[HIL_MLC_DEVMEM];
+        hil_packet              serio_opacket[HIL_MLC_DEVMEM];
+        int                     serio_oidx[HIL_MLC_DEVMEM];
+        struct hil_mlc_devinfo  di_scratch; /* Temporary area */
+
+        int                     opercnt;
+
+        struct tasklet_struct   *tasklet;
+};
+
+int hil_mlc_register(hil_mlc *mlc);
+int hil_mlc_unregister(hil_mlc *mlc);
diff --git a/include/linux/hp_sdc.h b/include/linux/hp_sdc.h
new file mode 100644
index 000000000000..debd71515312
--- /dev/null
+++ b/include/linux/hp_sdc.h
@@ -0,0 +1,300 @@
+/*
+ * HP i8042 System Device Controller -- header
+ *
+ * Copyright (c) 2001 Brian S. Julin
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL").
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ *
+ * References:
+ * 
+ * HP-HIL Technical Reference Manual.  Hewlett Packard Product No. 45918A
+ *
+ * System Device Controller Microprocessor Firmware Theory of Operation
+ *      for Part Number 1820-4784 Revision B.  Dwg No. A-1820-4784-2
+ *
+ */
+
+#ifndef _LINUX_HP_SDC_H
+#define _LINUX_HP_SDC_H
+
+#include <linux/interrupt.h>
+#include <linux/types.h>
+#include <linux/time.h>
+#include <linux/timer.h>
+#if defined(__hppa__)
+#include <asm/hardware.h>
+#endif
+
+
+/* No 4X status reads take longer than this (in usec).
+ */
+#define HP_SDC_MAX_REG_DELAY 20000
+
+typedef void (hp_sdc_irqhook) (int irq, void *dev_id, 
+                               uint8_t status, uint8_t data);
+
+int hp_sdc_request_timer_irq(hp_sdc_irqhook *callback);
+int hp_sdc_request_hil_irq(hp_sdc_irqhook *callback);
+int hp_sdc_request_cooked_irq(hp_sdc_irqhook *callback);
+int hp_sdc_release_timer_irq(hp_sdc_irqhook *callback);
+int hp_sdc_release_hil_irq(hp_sdc_irqhook *callback);
+int hp_sdc_release_cooked_irq(hp_sdc_irqhook *callback);
+
+typedef struct {
+        int actidx;     /* Start of act.  Acts are atomic WRT I/O to SDC */
+        int idx;        /* Index within the act */
+        int endidx;     /* transaction is over and done if idx == endidx */
+        uint8_t *seq;   /* commands/data for the transaction */
+        union {
+          hp_sdc_irqhook   *irqhook;    /* Callback, isr or tasklet context */
+          struct semaphore *semaphore;  /* Semaphore to sleep on. */
+        } act;
+} hp_sdc_transaction;
+int hp_sdc_enqueue_transaction(hp_sdc_transaction *this);
+int hp_sdc_dequeue_transaction(hp_sdc_transaction *this);
+
+/* The HP_SDC_ACT* values are peculiar to this driver.
+ * Nuance: never HP_SDC_ACT_DATAIN | HP_SDC_ACT_DEALLOC, use another
+ * act to perform the dealloc.
+ */
+#define HP_SDC_ACT_PRECMD       0x01            /* Send a command first */
+#define HP_SDC_ACT_DATAREG      0x02            /* Set data registers */
+#define HP_SDC_ACT_DATAOUT      0x04            /* Send data bytes */
+#define HP_SDC_ACT_POSTCMD      0x08            /* Send command after */
+#define HP_SDC_ACT_DATAIN       0x10            /* Collect data after */
+#define HP_SDC_ACT_DURING       0x1f
+#define HP_SDC_ACT_SEMAPHORE    0x20            /* Raise semaphore after */
+#define HP_SDC_ACT_CALLBACK     0x40            /* Pass data to IRQ handler */
+#define HP_SDC_ACT_DEALLOC      0x80            /* Destroy transaction after */
+#define HP_SDC_ACT_AFTER        0xe0
+#define HP_SDC_ACT_DEAD         0x60            /* Act timed out. */
+
+/* Rest of the flags are straightforward representation of the SDC interface */
+#define HP_SDC_STATUS_IBF       0x02    /* Input buffer full */
+
+#define HP_SDC_STATUS_IRQMASK   0xf0    /* Bits containing "level 1" irq */
+#define HP_SDC_STATUS_PERIODIC  0x10    /* Periodic 10ms timer */
+#define HP_SDC_STATUS_USERTIMER 0x20    /* "Special purpose" timer */
+#define HP_SDC_STATUS_TIMER     0x30    /* Both PERIODIC and USERTIMER */
+#define HP_SDC_STATUS_REG       0x40    /* Data from an i8042 register */
+#define HP_SDC_STATUS_HILCMD    0x50    /* Command from HIL MLC */
+#define HP_SDC_STATUS_HILDATA   0x60    /* Data from HIL MLC */
+#define HP_SDC_STATUS_PUP       0x70    /* Sucessful power-up self test */
+#define HP_SDC_STATUS_KCOOKED   0x80    /* Key from cooked kbd */
+#define HP_SDC_STATUS_KRPG      0xc0    /* Key from Repeat Gen */
+#define HP_SDC_STATUS_KMOD_SUP  0x10    /* Shift key is up */
+#define HP_SDC_STATUS_KMOD_CUP  0x20    /* Control key is up */
+
+#define HP_SDC_NMISTATUS_FHS    0x40    /* NMI is a fast handshake irq */
+
+/* Internal i8042 registers (there are more, but they are not too useful). */
+
+#define HP_SDC_USE              0x02    /* Resource usage (including OB bit) */
+#define HP_SDC_IM               0x04    /* Interrupt mask */
+#define HP_SDC_CFG              0x11    /* Configuration register */
+#define HP_SDC_KBLANGUAGE       0x12    /* Keyboard language */
+
+#define HP_SDC_D0               0x70    /* General purpose data buffer 0 */
+#define HP_SDC_D1               0x71    /* General purpose data buffer 1 */
+#define HP_SDC_D2               0x72    /* General purpose data buffer 2 */
+#define HP_SDC_D3               0x73    /* General purpose data buffer 3 */
+#define HP_SDC_VT1              0x74    /* Timer for voice 1 */
+#define HP_SDC_VT2              0x75    /* Timer for voice 2 */
+#define HP_SDC_VT3              0x76    /* Timer for voice 3 */
+#define HP_SDC_VT4              0x77    /* Timer for voice 4 */
+#define HP_SDC_KBN              0x78    /* Which HIL devs are Nimitz */
+#define HP_SDC_KBC              0x79    /* Which HIL devs are cooked kbds */
+#define HP_SDC_LPS              0x7a    /* i8042's view of HIL status */
+#define HP_SDC_LPC              0x7b    /* i8042's view of HIL "control" */
+#define HP_SDC_RSV              0x7c    /* Reserved "for testing" */
+#define HP_SDC_LPR              0x7d    /* i8042 count of HIL reconfigs */
+#define HP_SDC_XTD              0x7e    /* "Extended Configuration" register */
+#define HP_SDC_STR              0x7f    /* i8042 self-test result */
+
+/* Bitfields for above registers */
+#define HP_SDC_USE_LOOP         0x04    /* Command is currently on the loop. */
+
+#define HP_SDC_IM_MASK          0x1f    /* these bits not part of cmd/status */
+#define HP_SDC_IM_FH            0x10    /* Mask the fast handshake irq */
+#define HP_SDC_IM_PT            0x08    /* Mask the periodic timer irq */
+#define HP_SDC_IM_TIMERS        0x04    /* Mask the MT/DT/CT irq */
+#define HP_SDC_IM_RESET         0x02    /* Mask the reset key irq */
+#define HP_SDC_IM_HIL           0x01    /* Mask the HIL MLC irq */
+
+#define HP_SDC_CFG_ROLLOVER     0x08    /* WTF is "N-key rollover"? */
+#define HP_SDC_CFG_KBD          0x10    /* There is a keyboard */
+#define HP_SDC_CFG_NEW          0x20    /* Supports/uses HIL MLC */
+#define HP_SDC_CFG_KBD_OLD      0x03    /* keyboard code for non-HIL */
+#define HP_SDC_CFG_KBD_NEW      0x07    /* keyboard code from HIL autoconfig */
+#define HP_SDC_CFG_REV          0x40    /* Code revision bit */
+#define HP_SDC_CFG_IDPROM       0x80    /* IDPROM present in kbd (not HIL) */
+
+#define HP_SDC_LPS_NDEV         0x07    /* # devices autoconfigured on HIL */
+#define HP_SDC_LPS_ACSUCC       0x08    /* loop autoconfigured successfully */
+#define HP_SDC_LPS_ACFAIL       0x80    /* last loop autoconfigure failed */
+
+#define HP_SDC_LPC_APE_IPF      0x01    /* HIL MLC APE/IPF (autopoll) set */
+#define HP_SDC_LPC_ARCONERR     0x02    /* i8042 autoreconfigs loop on err */
+#define HP_SDC_LPC_ARCQUIET     0x03    /* i8042 doesn't report autoreconfigs*/
+#define HP_SDC_LPC_COOK         0x10    /* i8042 cooks devices in _KBN */
+#define HP_SDC_LPC_RC           0x80    /* causes autoreconfig */
+
+#define HP_SDC_XTD_REV          0x07    /* contains revision code */
+#define HP_SDC_XTD_REV_STRINGS(val, str) \
+switch (val) {                                          \
+        case 0x1: str = "1820-3712"; break;             \
+        case 0x2: str = "1820-4379"; break;             \
+        case 0x3: str = "1820-4784"; break;             \
+        default: str = "unknown";                       \
+};
+#define HP_SDC_XTD_BEEPER       0x08    /* TI SN76494 beeper available */
+#define HP_SDC_XTD_BBRTC        0x20    /* OKI MSM-58321 BBRTC present */
+
+#define HP_SDC_CMD_LOAD_RT      0x31    /* Load real time (from 8042) */
+#define HP_SDC_CMD_LOAD_FHS     0x36    /* Load the fast handshake timer */
+#define HP_SDC_CMD_LOAD_MT      0x38    /* Load the match timer */
+#define HP_SDC_CMD_LOAD_DT      0x3B    /* Load the delay timer */
+#define HP_SDC_CMD_LOAD_CT      0x3E    /* Load the cycle timer */
+
+#define HP_SDC_CMD_SET_IM       0x40    /* 010xxxxx == set irq mask */
+
+/* The documents provided do not explicitly state that all registers betweem 
+ * 0x01 and 0x1f inclusive can be read by sending their register index as a 
+ * command, but this is implied and appears to be the case.
+ */
+#define HP_SDC_CMD_READ_RAM     0x00    /* Load from i8042 RAM (autoinc) */
+#define HP_SDC_CMD_READ_USE     0x02    /* Undocumented! Load from usage reg */
+#define HP_SDC_CMD_READ_IM      0x04    /* Load current interrupt mask */
+#define HP_SDC_CMD_READ_KCC     0x11    /* Load primary kbd config code */
+#define HP_SDC_CMD_READ_KLC     0x12    /* Load primary kbd language code */
+#define HP_SDC_CMD_READ_T1      0x13    /* Load timer output buffer byte 1 */
+#define HP_SDC_CMD_READ_T2      0x14    /* Load timer output buffer byte 1 */
+#define HP_SDC_CMD_READ_T3      0x15    /* Load timer output buffer byte 1 */
+#define HP_SDC_CMD_READ_T4      0x16    /* Load timer output buffer byte 1 */
+#define HP_SDC_CMD_READ_T5      0x17    /* Load timer output buffer byte 1 */
+#define HP_SDC_CMD_READ_D0      0xf0    /* Load from i8042 RAM location 0x70 */
+#define HP_SDC_CMD_READ_D1      0xf1    /* Load from i8042 RAM location 0x71 */
+#define HP_SDC_CMD_READ_D2      0xf2    /* Load from i8042 RAM location 0x72 */
+#define HP_SDC_CMD_READ_D3      0xf3    /* Load from i8042 RAM location 0x73 */
+#define HP_SDC_CMD_READ_VT1     0xf4    /* Load from i8042 RAM location 0x74 */
+#define HP_SDC_CMD_READ_VT2     0xf5    /* Load from i8042 RAM location 0x75 */
+#define HP_SDC_CMD_READ_VT3     0xf6    /* Load from i8042 RAM location 0x76 */
+#define HP_SDC_CMD_READ_VT4     0xf7    /* Load from i8042 RAM location 0x77 */
+#define HP_SDC_CMD_READ_KBN     0xf8    /* Load from i8042 RAM location 0x78 */
+#define HP_SDC_CMD_READ_KBC     0xf9    /* Load from i8042 RAM location 0x79 */
+#define HP_SDC_CMD_READ_LPS     0xfa    /* Load from i8042 RAM location 0x7a */
+#define HP_SDC_CMD_READ_LPC     0xfb    /* Load from i8042 RAM location 0x7b */
+#define HP_SDC_CMD_READ_RSV     0xfc    /* Load from i8042 RAM location 0x7c */
+#define HP_SDC_CMD_READ_LPR     0xfd    /* Load from i8042 RAM location 0x7d */
+#define HP_SDC_CMD_READ_XTD     0xfe    /* Load from i8042 RAM location 0x7e */
+#define HP_SDC_CMD_READ_STR     0xff    /* Load from i8042 RAM location 0x7f */
+
+#define HP_SDC_CMD_SET_ARD      0xA0    /* Set emulated autorepeat delay */
+#define HP_SDC_CMD_SET_ARR      0xA2    /* Set emulated autorepeat rate */
+#define HP_SDC_CMD_SET_BELL     0xA3    /* Set voice 3 params for "beep" cmd */
+#define HP_SDC_CMD_SET_RPGR     0xA6    /* Set "RPG" irq rate (doesn't work) */
+#define HP_SDC_CMD_SET_RTMS     0xAD    /* Set the RTC time (milliseconds) */
+#define HP_SDC_CMD_SET_RTD      0xAF    /* Set the RTC time (days) */
+#define HP_SDC_CMD_SET_FHS      0xB2    /* Set fast handshake timer */
+#define HP_SDC_CMD_SET_MT       0xB4    /* Set match timer */
+#define HP_SDC_CMD_SET_DT       0xB7    /* Set delay timer */
+#define HP_SDC_CMD_SET_CT       0xBA    /* Set cycle timer */
+#define HP_SDC_CMD_SET_RAMP     0xC1    /* Reset READ_RAM autoinc counter */
+#define HP_SDC_CMD_SET_D0       0xe0    /* Load to i8042 RAM location 0x70 */
+#define HP_SDC_CMD_SET_D1       0xe1    /* Load to i8042 RAM location 0x71 */
+#define HP_SDC_CMD_SET_D2       0xe2    /* Load to i8042 RAM location 0x72 */
+#define HP_SDC_CMD_SET_D3       0xe3    /* Load to i8042 RAM location 0x73 */
+#define HP_SDC_CMD_SET_VT1      0xe4    /* Load to i8042 RAM location 0x74 */
+#define HP_SDC_CMD_SET_VT2      0xe5    /* Load to i8042 RAM location 0x75 */
+#define HP_SDC_CMD_SET_VT3      0xe6    /* Load to i8042 RAM location 0x76 */
+#define HP_SDC_CMD_SET_VT4      0xe7    /* Load to i8042 RAM location 0x77 */
+#define HP_SDC_CMD_SET_KBN      0xe8    /* Load to i8042 RAM location 0x78 */
+#define HP_SDC_CMD_SET_KBC      0xe9    /* Load to i8042 RAM location 0x79 */
+#define HP_SDC_CMD_SET_LPS      0xea    /* Load to i8042 RAM location 0x7a */
+#define HP_SDC_CMD_SET_LPC      0xeb    /* Load to i8042 RAM location 0x7b */
+#define HP_SDC_CMD_SET_RSV      0xec    /* Load to i8042 RAM location 0x7c */
+#define HP_SDC_CMD_SET_LPR      0xed    /* Load to i8042 RAM location 0x7d */
+#define HP_SDC_CMD_SET_XTD      0xee    /* Load to i8042 RAM location 0x7e */
+#define HP_SDC_CMD_SET_STR      0xef    /* Load to i8042 RAM location 0x7f */
+
+#define HP_SDC_CMD_DO_RTCW      0xc2    /* i8042 RAM 0x70 --> RTC */
+#define HP_SDC_CMD_DO_RTCR      0xc3    /* RTC[0x70 0:3] --> irq/status/data */
+#define HP_SDC_CMD_DO_BEEP      0xc4    /* i8042 RAM 0x70-74  --> beeper,VT3 */
+#define HP_SDC_CMD_DO_HIL       0xc5    /* i8042 RAM 0x70-73 --> 
+                                           HIL MLC R0,R1 i8042 HIL watchdog */
+
+/* Values used to (de)mangle input/output to/from the HIL MLC */
+#define HP_SDC_DATA             0x40    /* Data from an 8042 register */
+#define HP_SDC_HIL_CMD          0x50    /* Data from HIL MLC R1/8042 */
+#define HP_SDC_HIL_R1MASK       0x0f    /* Contents of HIL MLC R1 0:3 */
+#define HP_SDC_HIL_AUTO         0x10    /* Set if POL results from i8042 */   
+#define HP_SDC_HIL_ISERR        0x80    /* Has meaning as in next 4 values */
+#define HP_SDC_HIL_RC_DONE      0x80    /* i8042 auto-configured loop */
+#define HP_SDC_HIL_ERR          0x81    /* HIL MLC R2 had a bit set */
+#define HP_SDC_HIL_TO           0x82    /* i8042 HIL watchdog expired */
+#define HP_SDC_HIL_RC           0x84    /* i8042 is auto-configuring loop */
+#define HP_SDC_HIL_DAT          0x60    /* Data from HIL MLC R0 */
+
+
+typedef struct {
+        rwlock_t        ibf_lock;
+        rwlock_t        lock;           /* user/tasklet lock */
+        rwlock_t        rtq_lock;       /* isr/tasklet lock */
+        rwlock_t        hook_lock;      /* isr/user lock for handler add/del */
+
+        unsigned int    irq, nmi;       /* Our IRQ lines */
+        unsigned long   base_io, status_io, data_io; /* Our IO ports */
+
+        uint8_t         im;             /* Interrupt mask */
+        int             set_im;         /* Interrupt mask needs to be set. */
+
+        int             ibf;            /* Last known status of IBF flag */
+        uint8_t         wi;             /* current i8042 write index */
+        uint8_t         r7[4];          /* current i8042[0x70 - 0x74] values */
+        uint8_t         r11, r7e;       /* Values from version/revision regs */
+
+        hp_sdc_irqhook  *timer, *reg, *hil, *pup, *cooked;
+
+#define HP_SDC_QUEUE_LEN 16
+        hp_sdc_transaction *tq[HP_SDC_QUEUE_LEN]; /* All pending read/writes */
+
+        int             rcurr, rqty;    /* Current read transact in process */
+        struct timeval  rtv;            /* Time when current read started */
+        int             wcurr;          /* Current write transact in process */
+
+        int             dev_err;        /* carries status from registration */
+#if defined(__hppa__)
+        struct parisc_device    *dev;
+#elif defined(__mc68000__)
+        void            *dev;
+#else
+#error No support for device registration on this arch yet.
+#endif
+
+        struct timer_list kicker;       /* Keeps below task alive */
+        struct tasklet_struct   task;
+
+} hp_i8042_sdc;
+
+#endif /* _LINUX_HP_SDC_H */
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index e670b0d13fe0..1056717ee501 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -16,7 +16,6 @@ static inline int is_vm_hugetlb_page(struct vm_area_struct *vma)
 int hugetlb_sysctl_handler(struct ctl_table *, int, struct file *, void __user *, size_t *, loff_t *);
 int copy_hugetlb_page_range(struct mm_struct *, struct mm_struct *, struct vm_area_struct *);
 int follow_hugetlb_page(struct mm_struct *, struct vm_area_struct *, struct page **, struct vm_area_struct **, unsigned long *, int *, int);
-void zap_hugepage_range(struct vm_area_struct *, unsigned long, unsigned long);
 void unmap_hugepage_range(struct vm_area_struct *, unsigned long, unsigned long);
 int hugetlb_prefault(struct address_space *, struct vm_area_struct *);
 int hugetlb_report_meminfo(char *);
@@ -25,6 +24,8 @@ int is_hugepage_mem_enough(size_t);
 unsigned long hugetlb_total_pages(void);
 struct page *alloc_huge_page(void);
 void free_huge_page(struct page *);
+int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
+                        unsigned long address, int write_access);
 
 extern unsigned long max_huge_pages;
 extern const unsigned long hugetlb_zero, hugetlb_infinity;
@@ -85,7 +86,6 @@ static inline unsigned long hugetlb_total_pages(void)
 #define follow_huge_addr(mm, addr, write)       ERR_PTR(-EINVAL)
 #define copy_hugetlb_page_range(src, dst, vma)  ({ BUG(); 0; })
 #define hugetlb_prefault(mapping, vma)          ({ BUG(); 0; })
-#define zap_hugepage_range(vma, start, len)     BUG()
 #define unmap_hugepage_range(vma, start, end)   BUG()
 #define is_hugepage_mem_enough(size)            0
 #define hugetlb_report_meminfo(buf)             0
@@ -99,10 +99,11 @@ static inline unsigned long hugetlb_total_pages(void)
                                                 do { } while (0)
 #define alloc_huge_page()                       ({ NULL; })
 #define free_huge_page(p)                       ({ (void)(p); BUG(); })
+#define hugetlb_fault(mm, vma, addr, write)     ({ BUG(); 0; })
 
 #ifndef HPAGE_MASK
-#define HPAGE_MASK      0               /* Keep the compiler happy */
-#define HPAGE_SIZE      0
+#define HPAGE_MASK      PAGE_MASK               /* Keep the compiler happy */
+#define HPAGE_SIZE      PAGE_SIZE
 #endif
 
 #endif /* !CONFIG_HUGETLB_PAGE */
diff --git a/include/linux/i2c-algo-bit.h b/include/linux/i2c-algo-bit.h
index 110904481238..c0e7fab28ce3 100644
--- a/include/linux/i2c-algo-bit.h
+++ b/include/linux/i2c-algo-bit.h
@@ -21,8 +21,6 @@
 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
    Frodo Looijaard <frodol@dds.nl> */
 
-/* $Id: i2c-algo-bit.h,v 1.10 2003/01/21 08:08:16 kmalkki Exp $ */
-
 #ifndef _LINUX_I2C_ALGO_BIT_H
 #define _LINUX_I2C_ALGO_BIT_H
 
@@ -46,8 +44,6 @@ struct i2c_algo_bit_data {
         int timeout;            /* in jiffies */
 };
 
-#define I2C_BIT_ADAP_MAX        16
-
 int i2c_bit_add_bus(struct i2c_adapter *);
 int i2c_bit_del_bus(struct i2c_adapter *);
 
diff --git a/include/linux/i2c-algo-pca.h b/include/linux/i2c-algo-pca.h
index 941b786c5732..226693e0d88b 100644
--- a/include/linux/i2c-algo-pca.h
+++ b/include/linux/i2c-algo-pca.h
@@ -9,8 +9,6 @@ struct i2c_algo_pca_data {
         int  (*wait_for_interrupt)      (struct i2c_algo_pca_data *adap);
 };
 
-#define I2C_PCA_ADAP_MAX        16
-
 int i2c_pca_add_bus(struct i2c_adapter *);
 int i2c_pca_del_bus(struct i2c_adapter *);
 
diff --git a/include/linux/i2c-algo-pcf.h b/include/linux/i2c-algo-pcf.h
index 2a508562255f..18b0adf57a3d 100644
--- a/include/linux/i2c-algo-pcf.h
+++ b/include/linux/i2c-algo-pcf.h
@@ -22,8 +22,6 @@
 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
    Frodo Looijaard <frodol@dds.nl> */
 
-/* $Id: i2c-algo-pcf.h,v 1.8 2003/01/21 08:08:16 kmalkki Exp $ */
-
 #ifndef _LINUX_I2C_ALGO_PCF_H
 #define _LINUX_I2C_ALGO_PCF_H
 
@@ -41,8 +39,6 @@ struct i2c_algo_pcf_data {
         int timeout;
 };
 
-#define I2C_PCF_ADAP_MAX        16
-
 int i2c_pcf_add_bus(struct i2c_adapter *);
 int i2c_pcf_del_bus(struct i2c_adapter *);
 
diff --git a/include/linux/i2c-dev.h b/include/linux/i2c-dev.h
index 541695679762..81c229a0fbca 100644
--- a/include/linux/i2c-dev.h
+++ b/include/linux/i2c-dev.h
@@ -19,8 +19,6 @@
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-/* $Id: i2c-dev.h,v 1.13 2003/01/21 08:08:16 kmalkki Exp $ */
-
 #ifndef _LINUX_I2C_DEV_H
 #define _LINUX_I2C_DEV_H
 
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
index 44f30876a1c9..ef3b5632e63a 100644
--- a/include/linux/i2c-id.h
+++ b/include/linux/i2c-id.h
@@ -27,10 +27,10 @@
  * ---- Driver types -----------------------------------------------------
  *       device id name + number        function description, i2c address(es)
  *
- *  Range 1000-1999 range is defined in sensors/sensors.h 
- *  Range 0x100 - 0x1ff is for V4L2 Common Components 
+ *  Range 1000-1999 range is defined in sensors/sensors.h
+ *  Range 0x100 - 0x1ff is for V4L2 Common Components
  *  Range 0xf000 - 0xffff is reserved for local experimentation, and should
- *        never be used in official drivers 
+ *        never be used in official drivers
  */
 
 #define I2C_DRIVERID_MSP3400     1
@@ -99,7 +99,16 @@
 #define I2C_DRIVERID_MAX6900    63      /* MAX6900 real-time clock      */
 #define I2C_DRIVERID_SAA7114H   64      /* video decoder                */
 #define I2C_DRIVERID_DS1374     65      /* DS1374 real time clock       */
-
+#define I2C_DRIVERID_TDA9874    66      /* TV sound decoder             */
+#define I2C_DRIVERID_SAA6752HS  67      /* MPEG2 encoder                */
+#define I2C_DRIVERID_TVEEPROM   68      /* TV EEPROM                    */
+#define I2C_DRIVERID_WM8775     69      /* wm8775 audio processor       */
+#define I2C_DRIVERID_CS53L32A   70      /* cs53l32a audio processor     */
+#define I2C_DRIVERID_CX25840    71      /* cx2584x video encoder        */
+#define I2C_DRIVERID_SAA7127    72      /* saa7124 video encoder        */
+#define I2C_DRIVERID_SAA711X    73      /* saa711x video encoders       */
+#define I2C_DRIVERID_AKITAIOEXP 74      /* IO Expander on Sharp SL-C1000 */
+#define I2C_DRIVERID_I2C_IR     75      /* I2C InfraRed on Video boards */
 
 #define I2C_DRIVERID_EXP0       0xF0    /* experimental use id's        */
 #define I2C_DRIVERID_EXP1       0xF1
@@ -111,7 +120,7 @@
 #define I2C_DRIVERID_ARP        902    /* SMBus ARP Client              */
 #define I2C_DRIVERID_ALERT      903    /* SMBus Alert Responder Client  */
 
-/* IDs --   Use DRIVERIDs 1000-1999 for sensors. 
+/* IDs --   Use DRIVERIDs 1000-1999 for sensors.
    These were originally in sensors.h in the lm_sensors package */
 #define I2C_DRIVERID_LM78 1002
 #define I2C_DRIVERID_LM75 1003
@@ -164,10 +173,7 @@
 
 /* --- Bit algorithm adapters                                           */
 #define I2C_HW_B_LP             0x010000 /* Parallel port Philips style */
-#define I2C_HW_B_LPC            0x010001 /* Parallel port control reg. */
 #define I2C_HW_B_SER            0x010002 /* Serial line interface */
-#define I2C_HW_B_ELV            0x010003 /* ELV Card */
-#define I2C_HW_B_VELLE          0x010004 /* Vellemann K8000 */
 #define I2C_HW_B_BT848          0x010005 /* BT848 video boards */
 #define I2C_HW_B_WNV            0x010006 /* Winnov Videums */
 #define I2C_HW_B_VIA            0x010007 /* Via vt82c586b */
@@ -193,6 +199,7 @@
 #define I2C_HW_B_NVIDIA         0x01001c /* nvidia framebuffer driver */
 #define I2C_HW_B_SAVAGE         0x01001d /* savage framebuffer driver */
 #define I2C_HW_B_RADEON         0x01001e /* radeon framebuffer driver */
+#define I2C_HW_B_EM28XX         0x01001f /* em28xx video capture cards */
 
 /* --- PCF 8584 based algorithms                                        */
 #define I2C_HW_P_LP             0x020000 /* Parallel port interface */
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 3d49a305bf88..5e19a7ba69b2 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -23,15 +23,15 @@
 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and
    Frodo Looijaard <frodol@dds.nl> */
 
-/* $Id: i2c.h,v 1.68 2003/01/21 08:08:16 kmalkki Exp $ */
-
 #ifndef _LINUX_I2C_H
 #define _LINUX_I2C_H
 
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/i2c-id.h>
+#include <linux/mod_devicetable.h>
 #include <linux/device.h>       /* for struct device */
+#include <linux/sched.h>        /* for completion */
 #include <asm/semaphore.h>
 
 /* --- For i2c-isa ---------------------------------------------------- */
@@ -94,10 +94,10 @@ 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 bytes transferred */
 extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
                                       u8 command, u8 length,
                                       u8 *values);
+/* Returns the number of read bytes */
 extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client * client,
                                          u8 command, u8 *values);
 
@@ -391,10 +391,6 @@ struct i2c_msg {
 #define I2C_FUNC_10BIT_ADDR             0x00000002
 #define I2C_FUNC_PROTOCOL_MANGLING      0x00000004 /* I2C_M_{REV_DIR_ADDR,NOSTART,..} */
 #define I2C_FUNC_SMBUS_HWPEC_CALC       0x00000008 /* SMBus 2.0 */
-#define I2C_FUNC_SMBUS_READ_WORD_DATA_PEC  0x00000800 /* SMBus 2.0 */ 
-#define I2C_FUNC_SMBUS_WRITE_WORD_DATA_PEC 0x00001000 /* SMBus 2.0 */ 
-#define I2C_FUNC_SMBUS_PROC_CALL_PEC    0x00002000 /* SMBus 2.0 */
-#define I2C_FUNC_SMBUS_BLOCK_PROC_CALL_PEC 0x00004000 /* SMBus 2.0 */
 #define I2C_FUNC_SMBUS_BLOCK_PROC_CALL  0x00008000 /* SMBus 2.0 */
 #define I2C_FUNC_SMBUS_QUICK            0x00010000 
 #define I2C_FUNC_SMBUS_READ_BYTE        0x00020000 
@@ -410,8 +406,6 @@ struct i2c_msg {
 #define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK  0x08000000 /* w/ 1-byte reg. addr. */
 #define I2C_FUNC_SMBUS_READ_I2C_BLOCK_2  0x10000000 /* I2C-like block xfer  */
 #define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2 0x20000000 /* w/ 2-byte reg. addr. */
-#define I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC  0x40000000 /* SMBus 2.0 */
-#define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC 0x80000000 /* SMBus 2.0 */
 
 #define I2C_FUNC_SMBUS_BYTE (I2C_FUNC_SMBUS_READ_BYTE | \
                              I2C_FUNC_SMBUS_WRITE_BYTE)
@@ -425,17 +419,6 @@ struct i2c_msg {
                                   I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)
 #define I2C_FUNC_SMBUS_I2C_BLOCK_2 (I2C_FUNC_SMBUS_READ_I2C_BLOCK_2 | \
                                     I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2)
-#define I2C_FUNC_SMBUS_BLOCK_DATA_PEC (I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC | \
-                                       I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC)
-#define I2C_FUNC_SMBUS_WORD_DATA_PEC  (I2C_FUNC_SMBUS_READ_WORD_DATA_PEC | \
-                                       I2C_FUNC_SMBUS_WRITE_WORD_DATA_PEC)
-
-#define I2C_FUNC_SMBUS_READ_BYTE_PEC            I2C_FUNC_SMBUS_READ_BYTE_DATA
-#define I2C_FUNC_SMBUS_WRITE_BYTE_PEC           I2C_FUNC_SMBUS_WRITE_BYTE_DATA
-#define I2C_FUNC_SMBUS_READ_BYTE_DATA_PEC       I2C_FUNC_SMBUS_READ_WORD_DATA
-#define I2C_FUNC_SMBUS_WRITE_BYTE_DATA_PEC      I2C_FUNC_SMBUS_WRITE_WORD_DATA
-#define I2C_FUNC_SMBUS_BYTE_PEC                 I2C_FUNC_SMBUS_BYTE_DATA
-#define I2C_FUNC_SMBUS_BYTE_DATA_PEC            I2C_FUNC_SMBUS_WORD_DATA
 
 #define I2C_FUNC_SMBUS_EMUL (I2C_FUNC_SMBUS_QUICK | \
                              I2C_FUNC_SMBUS_BYTE | \
@@ -443,20 +426,17 @@ struct i2c_msg {
                              I2C_FUNC_SMBUS_WORD_DATA | \
                              I2C_FUNC_SMBUS_PROC_CALL | \
                              I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | \
-                             I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC | \
                              I2C_FUNC_SMBUS_I2C_BLOCK)
 
 /* 
  * Data for SMBus Messages 
  */
 #define I2C_SMBUS_BLOCK_MAX     32      /* As specified in SMBus standard */    
-#define I2C_SMBUS_I2C_BLOCK_MAX 32      /* Not specified but we use same structure */
 union i2c_smbus_data {
         __u8 byte;
         __u16 word;
-        __u8 block[I2C_SMBUS_BLOCK_MAX + 3]; /* block[0] is used for length */
-                          /* one more for read length in block process call */
-                                                    /* and one more for PEC */
+        __u8 block[I2C_SMBUS_BLOCK_MAX + 2]; /* block[0] is used for length */
+                               /* and one more for user-space compatibility */
 };
 
 /* smbus_access read or write markers */
@@ -473,10 +453,6 @@ union i2c_smbus_data {
 #define I2C_SMBUS_BLOCK_DATA        5
 #define I2C_SMBUS_I2C_BLOCK_DATA    6
 #define I2C_SMBUS_BLOCK_PROC_CALL   7           /* SMBus 2.0 */
-#define I2C_SMBUS_BLOCK_DATA_PEC    8           /* SMBus 2.0 */
-#define I2C_SMBUS_PROC_CALL_PEC     9           /* SMBus 2.0 */
-#define I2C_SMBUS_BLOCK_PROC_CALL_PEC  10       /* SMBus 2.0 */
-#define I2C_SMBUS_WORD_DATA_PEC    11           /* SMBus 2.0 */
 
 
 /* ----- commands for the ioctl like i2c_command call:
@@ -506,11 +482,6 @@ union i2c_smbus_data {
 
 #define I2C_SMBUS       0x0720  /* SMBus-level access */
 
-/* ... algo-bit.c recognizes */
-#define I2C_UDELAY      0x0705  /* set delay in microsecs between each  */
-                                /* written byte (except address)        */
-#define I2C_MDELAY      0x0706  /* millisec delay between written bytes */
-
 /* ----- I2C-DEV: char device interface stuff ------------------------- */
 
 #define I2C_MAJOR       89              /* Device major number          */
diff --git a/include/linux/i2o.h b/include/linux/i2o.h
index bdc286ec947c..d79c8a4bc4f8 100644
--- a/include/linux/i2o.h
+++ b/include/linux/i2o.h
@@ -25,10 +25,14 @@
 /* How many different OSM's are we allowing */
 #define I2O_MAX_DRIVERS         8
 
-#include <asm/io.h>
-#include <asm/semaphore.h>      /* Needed for MUTEX init macros */
 #include <linux/pci.h>
 #include <linux/dma-mapping.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>    /* work_struct */
+
+#include <asm/io.h>
+#include <asm/semaphore.h>      /* Needed for MUTEX init macros */
 
 /* message queue empty */
 #define I2O_QUEUE_EMPTY         0xffffffff
@@ -66,8 +70,6 @@ struct i2o_device {
         struct device device;
 
         struct semaphore lock;  /* device lock */
-
-        struct class_device classdev;   /* i2o device class */
 };
 
 /*
@@ -194,7 +196,7 @@ struct i2o_controller {
         struct resource mem_resource;   /* Mem resource allocated to the IOP */
 
         struct device device;
-        struct class_device classdev;   /* I2O controller class */
+        struct class_device *classdev;  /* I2O controller class device */
         struct i2o_device *exec;        /* Executive */
 #if BITS_PER_LONG == 64
         spinlock_t context_list_lock;   /* lock for context_list */
@@ -492,7 +494,7 @@ static inline int i2o_dma_map_sg(struct i2o_controller *c,
  *      Returns 0 on success or -ENOMEM on failure.
  */
 static inline int i2o_dma_alloc(struct device *dev, struct i2o_dma *addr,
-                                size_t len, unsigned int gfp_mask)
+                                size_t len, gfp_t gfp_mask)
 {
         struct pci_dev *pdev = to_pci_dev(dev);
         int dma_64 = 0;
@@ -551,7 +553,7 @@ static inline void i2o_dma_free(struct device *dev, struct i2o_dma *addr)
  *      Returns the 0 on success or negative error code on failure.
  */
 static inline int i2o_dma_realloc(struct device *dev, struct i2o_dma *addr,
-                                  size_t len, unsigned int gfp_mask)
+                                  size_t len, gfp_t gfp_mask)
 {
         i2o_dma_free(dev, addr);
 
diff --git a/include/linux/ibmtr.h b/include/linux/ibmtr.h
index 2ef0b21517fb..1c7a0dd5536a 100644
--- a/include/linux/ibmtr.h
+++ b/include/linux/ibmtr.h
@@ -7,8 +7,8 @@
 /* ported to the Alpha architecture 02/20/96 (just used the HZ macro) */
 
 #define TR_RETRY_INTERVAL       (30*HZ) /* 500 on PC = 5 s */
-#define TR_RST_TIME             (HZ/20) /* 5 on PC = 50 ms */
-#define TR_BUSY_INTERVAL        (HZ/5)  /* 5 on PC = 200 ms */
+#define TR_RST_TIME             (msecs_to_jiffies(50))  /* 5 on PC = 50 ms */
+#define TR_BUSY_INTERVAL        (msecs_to_jiffies(200)) /* 5 on PC = 200 ms */
 #define TR_SPIN_INTERVAL        (3*HZ)  /* 3 seconds before init timeout */
 
 #define TR_ISA 1
diff --git a/include/linux/ide.h b/include/linux/ide.h
index a6dbb51ecd7b..a39c3c59789d 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -218,7 +218,7 @@ typedef enum {	ide_unknown,	ide_generic,	ide_pci,
                 ide_rz1000,     ide_trm290,
                 ide_cmd646,     ide_cy82c693,   ide_4drives,
                 ide_pmac,       ide_etrax100,   ide_acorn,
-                ide_forced
+                ide_au1xxx, ide_forced
 } hwif_chipset_t;
 
 /*
@@ -230,6 +230,7 @@ typedef struct hw_regs_s {
         int             dma;                    /* our dma entry */
         ide_ack_intr_t  *ack_intr;              /* acknowledge interrupt */
         hwif_chipset_t  chipset;
+        struct device   *dev;
 } hw_regs_t;
 
 /*
@@ -266,6 +267,10 @@ static inline void ide_std_init_ports(hw_regs_t *hw,
 
 #include <asm/ide.h>
 
+#ifndef MAX_HWIFS
+#define MAX_HWIFS       CONFIG_IDE_MAX_HWIFS
+#endif
+
 /* needed on alpha, x86/x86_64, ia64, mips, ppc32 and sh */
 #ifndef IDE_ARCH_OBSOLETE_DEFAULTS
 # define ide_default_io_base(index)     (0)
@@ -1084,9 +1089,11 @@ enum {
 
 /*
  * Subdrivers support.
+ *
+ * The gendriver.owner field should be set to the module owner of this driver.
+ * The gendriver.name field should be set to the name of this driver
  */
 typedef struct ide_driver_s {
-        struct module                   *owner;
         const char                      *version;
         u8                              media;
         unsigned supports_dsc_overlap   : 1;
@@ -1194,37 +1201,11 @@ extern u64 ide_get_error_location(ide_drive_t *, char *);
  */
 typedef enum {
         ide_wait,       /* insert rq at end of list, and wait for it */
-        ide_next,       /* insert rq immediately after current request */
         ide_preempt,    /* insert rq in front of current request */
         ide_head_wait,  /* insert rq in front of current request and wait for it */
         ide_end         /* insert rq at end of list, but don't wait for it */
 } ide_action_t;
 
-/*
- * This function issues a special IDE device request
- * onto the request queue.
- *
- * If action is ide_wait, then the rq is queued at the end of the
- * request queue, and the function sleeps until it has been processed.
- * This is for use when invoked from an ioctl handler.
- *
- * If action is ide_preempt, then the rq is queued at the head of
- * the request queue, displacing the currently-being-processed
- * request and this function returns immediately without waiting
- * for the new rq to be completed.  This is VERY DANGEROUS, and is
- * intended for careful use by the ATAPI tape/cdrom driver code.
- *
- * If action is ide_next, then the rq is queued immediately after
- * the currently-being-processed-request (if any), and the function
- * returns without waiting for the new rq to be completed.  As above,
- * This is VERY DANGEROUS, and is intended for careful use by the
- * ATAPI tape/cdrom driver code.
- *
- * If action is ide_end, then the rq is queued at the end of the
- * request queue, and the function returns immediately without waiting
- * for the new rq to be completed. This is again intended for careful
- * use by the ATAPI tape/cdrom driver code.
- */
 extern int ide_do_drive_cmd(ide_drive_t *, struct request *, ide_action_t);
 
 /*
@@ -1324,7 +1305,8 @@ void ide_init_disk(struct gendisk *, ide_drive_t *);
 extern int ideprobe_init(void);
 
 extern void ide_scan_pcibus(int scan_direction) __init;
-extern int ide_pci_register_driver(struct pci_driver *driver);
+extern int __ide_pci_register_driver(struct pci_driver *driver, struct module *owner);
+#define ide_pci_register_driver(d) __ide_pci_register_driver(d, THIS_MODULE)
 extern void ide_pci_unregister_driver(struct pci_driver *driver);
 void ide_pci_setup_ports(struct pci_dev *, struct ide_pci_device_s *, int, ata_index_t *);
 extern void ide_setup_pci_noise (struct pci_dev *dev, struct ide_pci_device_s *d);
diff --git a/include/linux/idr.h b/include/linux/idr.h
index ca3b7e462576..d37c8d808b0f 100644
--- a/include/linux/idr.h
+++ b/include/linux/idr.h
@@ -8,6 +8,10 @@
  * Small id to pointer translation service avoiding fixed sized
  * tables.
  */
+
+#ifndef __IDR_H__
+#define __IDR_H__
+
 #include <linux/types.h>
 #include <linux/bitops.h>
 
@@ -71,8 +75,11 @@ struct idr {
  */
 
 void *idr_find(struct idr *idp, int id);
-int idr_pre_get(struct idr *idp, unsigned gfp_mask);
+int idr_pre_get(struct idr *idp, gfp_t gfp_mask);
 int idr_get_new(struct idr *idp, void *ptr, int *id);
 int idr_get_new_above(struct idr *idp, void *ptr, int starting_id, int *id);
 void idr_remove(struct idr *idp, int id);
+void idr_destroy(struct idr *idp);
 void idr_init(struct idr *idp);
+
+#endif /* __IDR_H__ */
diff --git a/include/linux/if_arp.h b/include/linux/if_arp.h
index 0856548a2a08..a8b1a2071838 100644
--- a/include/linux/if_arp.h
+++ b/include/linux/if_arp.h
@@ -84,6 +84,7 @@
 #define ARPHRD_IEEE802_TR 800           /* Magic type ident for TR      */
 #define ARPHRD_IEEE80211 801            /* IEEE 802.11                  */
 #define ARPHRD_IEEE80211_PRISM 802      /* IEEE 802.11 + Prism2 header  */
+#define ARPHRD_IEEE80211_RADIOTAP 803   /* IEEE 802.11 + radiotap header */
 
 #define ARPHRD_VOID       0xFFFF        /* Void type, nothing is known */
 #define ARPHRD_NONE       0xFFFE        /* zero header length */
diff --git a/include/linux/if_ether.h b/include/linux/if_ether.h
index fc2d4c8225aa..fe26d431de87 100644
--- a/include/linux/if_ether.h
+++ b/include/linux/if_ether.h
@@ -21,6 +21,8 @@
 #ifndef _LINUX_IF_ETHER_H
 #define _LINUX_IF_ETHER_H
 
+#include <linux/types.h>
+
 /*
  *      IEEE 802.3 Ethernet magic constants.  The frame sizes omit the preamble
  *      and FCS/CRC (frame check sequence). 
@@ -100,7 +102,7 @@
 struct ethhdr {
         unsigned char   h_dest[ETH_ALEN];       /* destination eth addr */
         unsigned char   h_source[ETH_ALEN];     /* source ether addr    */
-        unsigned short  h_proto;                /* packet type ID field */
+        __be16          h_proto;                /* packet type ID field */
 } __attribute__((packed));
 
 #ifdef __KERNEL__
@@ -111,7 +113,9 @@ static inline struct ethhdr *eth_hdr(const struct sk_buff *skb)
         return (struct ethhdr *)skb->mac.raw;
 }
 
+#ifdef CONFIG_SYSCTL
 extern struct ctl_table ether_table[];
 #endif
+#endif
 
 #endif  /* _LINUX_IF_ETHER_H */
diff --git a/include/linux/if_ppp.h b/include/linux/if_ppp.h
index 572aff7daa21..768372f07caa 100644
--- a/include/linux/if_ppp.h
+++ b/include/linux/if_ppp.h
@@ -21,7 +21,7 @@
  */
 
 /*
- *  ==FILEVERSION 20000724==
+ *  ==FILEVERSION 20050812==
  *
  *  NOTE TO MAINTAINERS:
  *     If you modify this file at all, please set the above date.
@@ -35,6 +35,8 @@
 #ifndef _IF_PPP_H_
 #define _IF_PPP_H_
 
+#include <linux/compiler.h>
+
 /*
  * Packet sizes
  */
@@ -70,7 +72,8 @@
 #define SC_LOG_RAWIN    0x00080000      /* log all chars received */
 #define SC_LOG_FLUSH    0x00100000      /* log all chars flushed */
 #define SC_SYNC         0x00200000      /* synchronous serial mode */
-#define SC_MASK         0x0f200fff      /* bits that user can change */
+#define SC_MUST_COMP    0x00400000      /* no uncompressed packets may be sent or received */
+#define SC_MASK         0x0f600fff      /* bits that user can change */
 
 /* state bits */
 #define SC_XMIT_BUSY    0x10000000      /* (used by isdn_ppp?) */
diff --git a/include/linux/if_wanpipe_common.h b/include/linux/if_wanpipe_common.h
index f25fec8ee2ca..6e5461d69fdd 100644
--- a/include/linux/if_wanpipe_common.h
+++ b/include/linux/if_wanpipe_common.h
@@ -17,8 +17,6 @@
 #ifndef _WANPIPE_SOCK_DRIVER_COMMON_H
 #define _WANPIPE_SOCK_DRIVER_COMMON_H
 
-#include <linux/version.h>
-
 typedef struct {
         struct net_device *slave;
         atomic_t packet_sent;
diff --git a/include/linux/inetdevice.h b/include/linux/inetdevice.h
index 7e1e15f934f3..fd7af86151b1 100644
--- a/include/linux/inetdevice.h
+++ b/include/linux/inetdevice.h
@@ -142,13 +142,21 @@ static __inline__ int bad_mask(u32 mask, u32 addr)
 
 #define endfor_ifa(in_dev) }
 
+static inline struct in_device *__in_dev_get_rcu(const struct net_device *dev)
+{
+        struct in_device *in_dev = dev->ip_ptr;
+        if (in_dev)
+                in_dev = rcu_dereference(in_dev);
+        return in_dev;
+}
+
 static __inline__ struct in_device *
 in_dev_get(const struct net_device *dev)
 {
         struct in_device *in_dev;
 
         rcu_read_lock();
-        in_dev = dev->ip_ptr;
+        in_dev = __in_dev_get_rcu(dev);
         if (in_dev)
                 atomic_inc(&in_dev->refcnt);
         rcu_read_unlock();
@@ -156,7 +164,7 @@ in_dev_get(const struct net_device *dev)
 }
 
 static __inline__ struct in_device *
-__in_dev_get(const struct net_device *dev)
+__in_dev_get_rtnl(const struct net_device *dev)
 {
         return (struct in_device*)dev->ip_ptr;
 }
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index 68ab5f2ab9cd..dcfd2ecccb5d 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -51,7 +51,6 @@
         .page_table_lock =  SPIN_LOCK_UNLOCKED,                 \
         .mmlist         = LIST_HEAD_INIT(name.mmlist),          \
         .cpu_vm_mask    = CPU_MASK_ALL,                         \
-        .default_kioctx = INIT_KIOCTX(name.default_kioctx, name),       \
 }
 
 #define INIT_SIGNALS(sig) {     \
diff --git a/include/linux/input.h b/include/linux/input.h
index e8c296ff6257..3c5823368ddb 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -12,6 +12,7 @@
 #ifdef __KERNEL__
 #include <linux/time.h>
 #include <linux/list.h>
+#include <linux/device.h>
 #else
 #include <sys/time.h>
 #include <sys/ioctl.h>
@@ -644,6 +645,7 @@ struct input_absinfo {
 #define BUS_ADB                 0x17
 #define BUS_I2C                 0x18
 #define BUS_HOST                0x19
+#define BUS_GSC                 0x1A
 
 /*
  * Values describing the status of an effect
@@ -889,11 +891,15 @@ struct input_dev {
         struct semaphore sem;   /* serializes open and close operations */
         unsigned int users;
 
-        struct device *dev;
+        struct class_device cdev;
+        struct device *dev;     /* will be removed soon */
+
+        int dynalloc;   /* temporarily */
 
         struct list_head        h_list;
         struct list_head        node;
 };
+#define to_input_dev(d) container_of(d, struct input_dev, cdev)
 
 /*
  * Structure for hotplug & device<->driver matching.
@@ -984,7 +990,24 @@ static inline void init_input_dev(struct input_dev *dev)
         INIT_LIST_HEAD(&dev->node);
 }
 
-void input_register_device(struct input_dev *);
+struct input_dev *input_allocate_device(void);
+
+static inline void input_free_device(struct input_dev *dev)
+{
+        kfree(dev);
+}
+
+static inline struct input_dev *input_get_device(struct input_dev *dev)
+{
+        return to_input_dev(class_device_get(&dev->cdev));
+}
+
+static inline void input_put_device(struct input_dev *dev)
+{
+        class_device_put(&dev->cdev);
+}
+
+int input_register_device(struct input_dev *);
 void input_unregister_device(struct input_dev *);
 
 void input_register_handler(struct input_handler *);
@@ -1052,7 +1075,7 @@ static inline void input_set_abs_params(struct input_dev *dev, int axis, int min
         dev->absbit[LONG(axis)] |= BIT(axis);
 }
 
-extern struct class *input_class;
+extern struct class input_class;
 
 #endif
 #endif
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 0a90205184b0..41f150a3d2dd 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -9,6 +9,7 @@
 #include <linux/preempt.h>
 #include <linux/cpumask.h>
 #include <linux/hardirq.h>
+#include <linux/sched.h>
 #include <asm/atomic.h>
 #include <asm/ptrace.h>
 #include <asm/system.h>
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index 18d010bee635..cd6bd001ba4e 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -94,7 +94,7 @@ extern struct resource iomem_resource;
 extern int request_resource(struct resource *root, struct resource *new);
 extern struct resource * ____request_resource(struct resource *root, struct resource *new);
 extern int release_resource(struct resource *new);
-extern int insert_resource(struct resource *parent, struct resource *new);
+extern __deprecated_for_modules int insert_resource(struct resource *parent, struct resource *new);
 extern int allocate_resource(struct resource *root, struct resource *new,
                              unsigned long size,
                              unsigned long min, unsigned long max,
diff --git a/include/linux/ipmi.h b/include/linux/ipmi.h
index 938d55b813a5..d6276e60b3bf 100644
--- a/include/linux/ipmi.h
+++ b/include/linux/ipmi.h
@@ -256,10 +256,7 @@ struct ipmi_recv_msg
 };
 
 /* Allocate and free the receive message. */
-static inline void ipmi_free_recv_msg(struct ipmi_recv_msg *msg)
-{
-        msg->done(msg);
-}
+void ipmi_free_recv_msg(struct ipmi_recv_msg *msg);
 
 struct ipmi_user_hndl
 {
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index bb6f88e14061..e0b922785d98 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -372,8 +372,9 @@ static inline struct raw6_sock *raw6_sk(const struct sock *sk)
 #define inet_v6_ipv6only(__sk)          0
 #endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
 
-#define INET6_MATCH(__sk, __saddr, __daddr, __ports, __dif)        \
-        (((*((__u32 *)&(inet_sk(__sk)->dport))) == (__ports))   && \
+#define INET6_MATCH(__sk, __hash, __saddr, __daddr, __ports, __dif)\
+        (((__sk)->sk_hash == (__hash))                          && \
+         ((*((__u32 *)&(inet_sk(__sk)->dport))) == (__ports))   && \
          ((__sk)->sk_family             == AF_INET6)            && \
          ipv6_addr_equal(&inet6_sk(__sk)->daddr, (__saddr))     && \
          ipv6_addr_equal(&inet6_sk(__sk)->rcv_saddr, (__daddr)) && \
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 69681c3b1f05..c516382fbec2 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -10,6 +10,7 @@
  */
 
 #include <linux/config.h>
+#include <asm/smp.h>            /* cpu_online_map */
 
 #if !defined(CONFIG_ARCH_S390)
 
diff --git a/include/linux/istallion.h b/include/linux/istallion.h
index 5f4ee646c119..1f996621bc9c 100644
--- a/include/linux/istallion.h
+++ b/include/linux/istallion.h
@@ -21,8 +21,6 @@
  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <linux/version.h>
-
 /*****************************************************************************/
 #ifndef _ISTALLION_H
 #define _ISTALLION_H
diff --git a/include/linux/jbd.h b/include/linux/jbd.h
index de097269bd7f..dcde7adfdce5 100644
--- a/include/linux/jbd.h
+++ b/include/linux/jbd.h
@@ -16,8 +16,6 @@
 #ifndef _LINUX_JBD_H
 #define _LINUX_JBD_H
 
-#if defined(CONFIG_JBD) || defined(CONFIG_JBD_MODULE) || !defined(__KERNEL__)
-
 /* Allow this file to be included directly into e2fsprogs */
 #ifndef __KERNEL__
 #include "jfs_compat.h"
@@ -69,7 +67,7 @@ extern int journal_enable_debug;
 #define jbd_debug(f, a...)      /**/
 #endif
 
-extern void * __jbd_kmalloc (const char *where, size_t size, int flags, int retry);
+extern void * __jbd_kmalloc (const char *where, size_t size, gfp_t flags, int retry);
 #define jbd_kmalloc(size, flags) \
         __jbd_kmalloc(__FUNCTION__, (size), (flags), journal_oom_retry)
 #define jbd_rep_kmalloc(size, flags) \
@@ -611,6 +609,9 @@ struct transaction_s
  * @j_revoke: The revoke table - maintains the list of revoked blocks in the
  *     current transaction.
  * @j_revoke_table: alternate revoke tables for j_revoke
+ * @j_wbuf: array of buffer_heads for journal_commit_transaction
+ * @j_wbufsize: maximum number of buffer_heads allowed in j_wbuf, the
+ *      number that will fit in j_blocksize
  * @j_private: An opaque pointer to fs-private information.
  */
 
@@ -890,7 +891,7 @@ extern int	 journal_forget (handle_t *, struct buffer_head *);
 extern void      journal_sync_buffer (struct buffer_head *);
 extern int       journal_invalidatepage(journal_t *,
                                 struct page *, unsigned long);
-extern int       journal_try_to_free_buffers(journal_t *, struct page *, int);
+extern int       journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
 extern int       journal_stop(handle_t *);
 extern int       journal_flush (journal_t *);
 extern void      journal_lock_updates (journal_t *);
@@ -935,7 +936,7 @@ void journal_put_journal_head(struct journal_head *jh);
  */
 extern kmem_cache_t *jbd_handle_cache;
 
-static inline handle_t *jbd_alloc_handle(unsigned int __nocast gfp_flags)
+static inline handle_t *jbd_alloc_handle(gfp_t gfp_flags)
 {
         return kmem_cache_alloc(jbd_handle_cache, gfp_flags);
 }
@@ -1080,19 +1081,4 @@ extern int jbd_blocks_per_page(struct inode *inode);
 
 #endif  /* __KERNEL__ */
 
-#endif  /* CONFIG_JBD || CONFIG_JBD_MODULE || !__KERNEL__ */
-
-/*
- * Compatibility no-ops which allow the kernel to compile without CONFIG_JBD
- * go here.
- */
-
-#if defined(__KERNEL__) && !(defined(CONFIG_JBD) || defined(CONFIG_JBD_MODULE))
-
-#define J_ASSERT(expr)                  do {} while (0)
-#define J_ASSERT_BH(bh, expr)           do {} while (0)
-#define buffer_jbd(bh)                  0
-#define journal_buffer_journal_lru(bh)  0
-
-#endif  /* defined(__KERNEL__) && !defined(CONFIG_JBD) */
 #endif  /* _LINUX_JBD_H */
diff --git a/include/linux/jffs2.h b/include/linux/jffs2.h
index 419fc953ac16..cf792bb3c726 100644
--- a/include/linux/jffs2.h
+++ b/include/linux/jffs2.h
@@ -5,10 +5,10 @@
  *
  * Created by David Woodhouse <dwmw2@infradead.org>
  *
- * For licensing information, see the file 'LICENCE' in the 
+ * For licensing information, see the file 'LICENCE' in the
  * jffs2 directory.
  *
- * $Id: jffs2.h,v 1.34 2004/11/16 20:36:14 dwmw2 Exp $
+ * $Id: jffs2.h,v 1.38 2005/09/26 11:37:23 havasi Exp $
  *
  */
 
@@ -28,6 +28,9 @@
 #define JFFS2_EMPTY_BITMASK 0xffff
 #define JFFS2_DIRTY_BITMASK 0x0000
 
+/* Summary node MAGIC marker */
+#define JFFS2_SUM_MAGIC 0x02851885
+
 /* We only allow a single char for length, and 0xFF is empty flash so
    we don't want it confused with a real length. Hence max 254.
 */
@@ -43,8 +46,6 @@
 #define JFFS2_COMPR_COPY        0x04
 #define JFFS2_COMPR_DYNRUBIN    0x05
 #define JFFS2_COMPR_ZLIB        0x06
-#define JFFS2_COMPR_LZO         0x07
-#define JFFS2_COMPR_LZARI       0x08
 /* Compatibility flags. */
 #define JFFS2_COMPAT_MASK 0xc000      /* What do to if an unknown nodetype is found */
 #define JFFS2_NODE_ACCURATE 0x2000
@@ -62,15 +63,17 @@
 #define JFFS2_NODETYPE_CLEANMARKER (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 3)
 #define JFFS2_NODETYPE_PADDING (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 4)
 
+#define JFFS2_NODETYPE_SUMMARY (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 6)
+
 // Maybe later...
 //#define JFFS2_NODETYPE_CHECKPOINT (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 3)
 //#define JFFS2_NODETYPE_OPTIONS (JFFS2_FEATURE_RWCOMPAT_COPY | JFFS2_NODE_ACCURATE | 4)
 
 
-#define JFFS2_INO_FLAG_PREREAD    1     /* Do read_inode() for this one at 
-                                           mount time, don't wait for it to 
+#define JFFS2_INO_FLAG_PREREAD    1     /* Do read_inode() for this one at
+                                           mount time, don't wait for it to
                                            happen later */
-#define JFFS2_INO_FLAG_USERCOMPR  2     /* User has requested a specific 
+#define JFFS2_INO_FLAG_USERCOMPR  2     /* User has requested a specific
                                            compression type */
 
 
@@ -101,7 +104,7 @@ struct jffs2_unknown_node
 struct jffs2_raw_dirent
 {
         jint16_t magic;
-        jint16_t nodetype;      /* == JFFS_NODETYPE_DIRENT */
+        jint16_t nodetype;      /* == JFFS2_NODETYPE_DIRENT */
         jint32_t totlen;
         jint32_t hdr_crc;
         jint32_t pino;
@@ -117,7 +120,7 @@ struct jffs2_raw_dirent
 } __attribute__((packed));
 
 /* The JFFS2 raw inode structure: Used for storage on physical media.  */
-/* The uid, gid, atime, mtime and ctime members could be longer, but 
+/* The uid, gid, atime, mtime and ctime members could be longer, but
    are left like this for space efficiency. If and when people decide
    they really need them extended, it's simple enough to add support for
    a new type of raw node.
@@ -125,7 +128,7 @@ struct jffs2_raw_dirent
 struct jffs2_raw_inode
 {
         jint16_t magic;      /* A constant magic number.  */
-        jint16_t nodetype;   /* == JFFS_NODETYPE_INODE */
+        jint16_t nodetype;   /* == JFFS2_NODETYPE_INODE */
         jint32_t totlen;     /* Total length of this node (inc data, etc.) */
         jint32_t hdr_crc;
         jint32_t ino;        /* Inode number.  */
@@ -148,9 +151,25 @@ struct jffs2_raw_inode
         uint8_t data[0];
 } __attribute__((packed));
 
-union jffs2_node_union {
+struct jffs2_raw_summary
+{
+        jint16_t magic;
+        jint16_t nodetype;      /* = JFFS2_NODETYPE_SUMMARY */
+        jint32_t totlen;
+        jint32_t hdr_crc;
+        jint32_t sum_num;       /* number of sum entries*/
+        jint32_t cln_mkr;       /* clean marker size, 0 = no cleanmarker */
+        jint32_t padded;        /* sum of the size of padding nodes */
+        jint32_t sum_crc;       /* summary information crc */
+        jint32_t node_crc;      /* node crc */
+        jint32_t sum[0];        /* inode summary info */
+} __attribute__((packed));
+
+union jffs2_node_union
+{
         struct jffs2_raw_inode i;
         struct jffs2_raw_dirent d;
+        struct jffs2_raw_summary s;
         struct jffs2_unknown_node u;
 };
 
diff --git a/include/linux/jffs2_fs_i.h b/include/linux/jffs2_fs_i.h
index 6dbb1cce6646..ef85ab56302b 100644
--- a/include/linux/jffs2_fs_i.h
+++ b/include/linux/jffs2_fs_i.h
@@ -1,4 +1,4 @@
-/* $Id: jffs2_fs_i.h,v 1.17 2004/11/11 23:51:27 dwmw2 Exp $ */
+/* $Id: jffs2_fs_i.h,v 1.19 2005/11/07 11:14:52 gleixner Exp $ */
 
 #ifndef _JFFS2_FS_I
 #define _JFFS2_FS_I
@@ -25,13 +25,16 @@ struct jffs2_inode_info {
         /* There may be one datanode which isn't referenced by any of the
            above fragments, if it contains a metadata update but no actual
            data - or if this is a directory inode */
-        /* This also holds the _only_ dnode for symlinks/device nodes, 
+        /* This also holds the _only_ dnode for symlinks/device nodes,
            etc. */
         struct jffs2_full_dnode *metadata;
 
         /* Directory entries */
         struct jffs2_full_dirent *dents;
 
+        /* The target path if this is the inode of a symlink */
+        unsigned char *target;
+
         /* Some stuff we just have to keep in-core at all times, for each inode. */
         struct jffs2_inode_cache *inocache;
 
diff --git a/include/linux/jffs2_fs_sb.h b/include/linux/jffs2_fs_sb.h
index 1e21546622de..4bcfb5570221 100644
--- a/include/linux/jffs2_fs_sb.h
+++ b/include/linux/jffs2_fs_sb.h
@@ -1,4 +1,4 @@
-/* $Id: jffs2_fs_sb.h,v 1.52 2005/05/19 16:12:17 gleixner Exp $ */
+/* $Id: jffs2_fs_sb.h,v 1.54 2005/09/21 13:37:34 dedekind Exp $ */
 
 #ifndef _JFFS2_FS_SB
 #define _JFFS2_FS_SB
@@ -20,7 +20,7 @@
 struct jffs2_inodirty;
 
 /* A struct for the overall file system control.  Pointers to
-   jffs2_sb_info structs are named `c' in the source code.  
+   jffs2_sb_info structs are named `c' in the source code.
    Nee jffs_control
 */
 struct jffs2_sb_info {
@@ -35,7 +35,7 @@ struct jffs2_sb_info {
         struct completion gc_thread_start; /* GC thread start completion */
         struct completion gc_thread_exit; /* GC thread exit completion port */
 
-        struct semaphore alloc_sem;     /* Used to protect all the following 
+        struct semaphore alloc_sem;     /* Used to protect all the following
                                            fields, and also to protect against
                                            out-of-order writing of nodes. And GC. */
         uint32_t cleanmarker_size;      /* Size of an _inline_ CLEANMARKER
@@ -64,7 +64,7 @@ struct jffs2_sb_info {
         uint32_t nospc_dirty_size;
 
         uint32_t nr_blocks;
-        struct jffs2_eraseblock *blocks;        /* The whole array of blocks. Used for getting blocks 
+        struct jffs2_eraseblock *blocks;        /* The whole array of blocks. Used for getting blocks
                                                  * from the offset (blocks[ofs / sector_size]) */
         struct jffs2_eraseblock *nextblock;     /* The block we're currently filling */
 
@@ -82,25 +82,26 @@ struct jffs2_sb_info {
         struct list_head bad_list;              /* Bad blocks. */
         struct list_head bad_used_list;         /* Bad blocks with valid data in. */
 
-        spinlock_t erase_completion_lock;       /* Protect free_list and erasing_list 
+        spinlock_t erase_completion_lock;       /* Protect free_list and erasing_list
                                                    against erase completion handler */
         wait_queue_head_t erase_wait;           /* For waiting for erases to complete */
 
         wait_queue_head_t inocache_wq;
         struct jffs2_inode_cache **inocache_list;
         spinlock_t inocache_lock;
-        
+
         /* Sem to allow jffs2_garbage_collect_deletion_dirent to
-           drop the erase_completion_lock while it's holding a pointer 
+           drop the erase_completion_lock while it's holding a pointer
            to an obsoleted node. I don't like this. Alternatives welcomed. */
         struct semaphore erase_free_sem;
 
+        uint32_t wbuf_pagesize; /* 0 for NOR and other flashes with no wbuf */
+
 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
         /* Write-behind buffer for NAND flash */
         unsigned char *wbuf;
         uint32_t wbuf_ofs;
         uint32_t wbuf_len;
-        uint32_t wbuf_pagesize;
         struct jffs2_inodirty *wbuf_inodes;
 
         struct rw_semaphore wbuf_sem;   /* Protects the write buffer */
@@ -112,6 +113,8 @@ struct jffs2_sb_info {
         uint32_t fsdata_len;
 #endif
 
+        struct jffs2_summary *summary;          /* Summary information */
+
         /* OS-private pointer for getting back to master superblock info */
         void *os_priv;
 };
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 4367ce4db52a..b1e407a4fbda 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -168,7 +168,7 @@ static inline void console_verbose(void)
 
 extern void bust_spinlocks(int yes);
 extern int oops_in_progress;            /* If set, an oops, panic(), BUG() or die() is in progress */
-extern int panic_timeout;
+extern __deprecated_for_modules int panic_timeout;
 extern int panic_on_oops;
 extern int tainted;
 extern const char *print_tainted(void);
@@ -266,7 +266,6 @@ extern void dump_stack(void);
 
 /**
  * container_of - cast a member of a structure out to the containing structure
- *
  * @ptr:        the pointer to the member.
  * @type:       the type of the container struct this is embedded in.
  * @member:     the name of the member within the struct.
@@ -307,7 +306,7 @@ struct sysinfo {
         char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding: libc5 uses this.. */
 };
 
-/* Force a compilation error if condition is false */
+/* Force a compilation error if condition is true */
 #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
 
 #ifdef CONFIG_SYSCTL
diff --git a/include/linux/kernel_stat.h b/include/linux/kernel_stat.h
index dba27749b428..a484572c302e 100644
--- a/include/linux/kernel_stat.h
+++ b/include/linux/kernel_stat.h
@@ -6,6 +6,7 @@
 #include <linux/smp.h>
 #include <linux/threads.h>
 #include <linux/percpu.h>
+#include <linux/cpumask.h>
 #include <asm/cputime.h>
 
 /*
@@ -43,11 +44,10 @@ extern unsigned long long nr_context_switches(void);
  */
 static inline int kstat_irqs(int irq)
 {
-        int i, sum=0;
+        int cpu, sum = 0;
 
-        for (i = 0; i < NR_CPUS; i++)
-                if (cpu_possible(i))
-                        sum += kstat_cpu(i).irqs[irq];
+        for_each_cpu(cpu)
+                sum += kstat_cpu(cpu).irqs[irq];
 
         return sum;
 }
diff --git a/include/linux/key-ui.h b/include/linux/key-ui.h
index cc326174a808..e8b8a7a5c496 100644
--- a/include/linux/key-ui.h
+++ b/include/linux/key-ui.h
@@ -24,7 +24,8 @@ extern spinlock_t key_serial_lock;
 #define KEY_WRITE       0x04    /* require permission to update / modify */
 #define KEY_SEARCH      0x08    /* require permission to search (keyring) or find (key) */
 #define KEY_LINK        0x10    /* require permission to link */
-#define KEY_ALL         0x1f    /* all the above permissions */
+#define KEY_SETATTR     0x20    /* require permission to change attributes */
+#define KEY_ALL         0x3f    /* all the above permissions */
 
 /*
  * the keyring payload contains a list of the keys to which the keyring is
@@ -38,92 +39,21 @@ struct keyring_list {
         struct key      *keys[0];
 };
 
-
 /*
  * check to see whether permission is granted to use a key in the desired way
  */
-static inline int key_permission(const struct key *key, key_perm_t perm)
-{
-        key_perm_t kperm;
-
-        if (key->uid == current->fsuid)
-                kperm = key->perm >> 16;
-        else if (key->gid != -1 &&
-                 key->perm & KEY_GRP_ALL &&
-                 in_group_p(key->gid)
-                 )
-                kperm = key->perm >> 8;
-        else
-                kperm = key->perm;
-
-        kperm = kperm & perm & KEY_ALL;
-
-        return kperm == perm;
-}
-
-/*
- * check to see whether permission is granted to use a key in at least one of
- * the desired ways
- */
-static inline int key_any_permission(const struct key *key, key_perm_t perm)
-{
-        key_perm_t kperm;
-
-        if (key->uid == current->fsuid)
-                kperm = key->perm >> 16;
-        else if (key->gid != -1 &&
-                 key->perm & KEY_GRP_ALL &&
-                 in_group_p(key->gid)
-                 )
-                kperm = key->perm >> 8;
-        else
-                kperm = key->perm;
+extern int key_task_permission(const key_ref_t key_ref,
+                               struct task_struct *context,
+                               key_perm_t perm);
 
-        kperm = kperm & perm & KEY_ALL;
-
-        return kperm != 0;
-}
-
-static inline int key_task_groups_search(struct task_struct *tsk, gid_t gid)
+static inline int key_permission(const key_ref_t key_ref, key_perm_t perm)
 {
-        int ret;
-
-        task_lock(tsk);
-        ret = groups_search(tsk->group_info, gid);
-        task_unlock(tsk);
-        return ret;
-}
-
-static inline int key_task_permission(const struct key *key,
-                                      struct task_struct *context,
-                                      key_perm_t perm)
-{
-        key_perm_t kperm;
-
-        if (key->uid == context->fsuid) {
-                kperm = key->perm >> 16;
-        }
-        else if (key->gid != -1 &&
-                 key->perm & KEY_GRP_ALL && (
-                         key->gid == context->fsgid ||
-                         key_task_groups_search(context, key->gid)
-                         )
-                 ) {
-                kperm = key->perm >> 8;
-        }
-        else {
-                kperm = key->perm;
-        }
-
-        kperm = kperm & perm & KEY_ALL;
-
-        return kperm == perm;
-
+        return key_task_permission(key_ref, current, perm);
 }
 
-extern struct key *lookup_user_key(struct task_struct *context,
-                                   key_serial_t id, int create, int partial,
-                                   key_perm_t perm);
+extern key_ref_t lookup_user_key(struct task_struct *context,
+                                 key_serial_t id, int create, int partial,
+                                 key_perm_t perm);
 
 extern long join_session_keyring(const char *name);
 
diff --git a/include/linux/key.h b/include/linux/key.h
index 970bbd916cf4..53513a3be53b 100644
--- a/include/linux/key.h
+++ b/include/linux/key.h
@@ -35,26 +35,37 @@ struct key;
 
 #undef KEY_DEBUGGING
 
-#define KEY_USR_VIEW    0x00010000      /* user can view a key's attributes */
-#define KEY_USR_READ    0x00020000      /* user can read key payload / view keyring */
-#define KEY_USR_WRITE   0x00040000      /* user can update key payload / add link to keyring */
-#define KEY_USR_SEARCH  0x00080000      /* user can find a key in search / search a keyring */
-#define KEY_USR_LINK    0x00100000      /* user can create a link to a key/keyring */
-#define KEY_USR_ALL     0x001f0000
+#define KEY_POS_VIEW    0x01000000      /* possessor can view a key's attributes */
+#define KEY_POS_READ    0x02000000      /* possessor can read key payload / view keyring */
+#define KEY_POS_WRITE   0x04000000      /* possessor can update key payload / add link to keyring */
+#define KEY_POS_SEARCH  0x08000000      /* possessor can find a key in search / search a keyring */
+#define KEY_POS_LINK    0x10000000      /* possessor can create a link to a key/keyring */
+#define KEY_POS_SETATTR 0x20000000      /* possessor can set key attributes */
+#define KEY_POS_ALL     0x3f000000
+
+#define KEY_USR_VIEW    0x00010000      /* user permissions... */
+#define KEY_USR_READ    0x00020000
+#define KEY_USR_WRITE   0x00040000
+#define KEY_USR_SEARCH  0x00080000
+#define KEY_USR_LINK    0x00100000
+#define KEY_USR_SETATTR 0x00200000
+#define KEY_USR_ALL     0x003f0000
 
 #define KEY_GRP_VIEW    0x00000100      /* group permissions... */
 #define KEY_GRP_READ    0x00000200
 #define KEY_GRP_WRITE   0x00000400
 #define KEY_GRP_SEARCH  0x00000800
 #define KEY_GRP_LINK    0x00001000
-#define KEY_GRP_ALL     0x00001f00
+#define KEY_GRP_SETATTR 0x00002000
+#define KEY_GRP_ALL     0x00003f00
 
 #define KEY_OTH_VIEW    0x00000001      /* third party permissions... */
 #define KEY_OTH_READ    0x00000002
 #define KEY_OTH_WRITE   0x00000004
 #define KEY_OTH_SEARCH  0x00000008
 #define KEY_OTH_LINK    0x00000010
-#define KEY_OTH_ALL     0x0000001f
+#define KEY_OTH_SETATTR 0x00000020
+#define KEY_OTH_ALL     0x0000003f
 
 struct seq_file;
 struct user_struct;
@@ -67,6 +78,38 @@ struct keyring_name;
 
 /*****************************************************************************/
 /*
+ * key reference with possession attribute handling
+ *
+ * NOTE! key_ref_t is a typedef'd pointer to a type that is not actually
+ * defined. This is because we abuse the bottom bit of the reference to carry a
+ * flag to indicate whether the calling process possesses that key in one of
+ * its keyrings.
+ *
+ * the key_ref_t has been made a separate type so that the compiler can reject
+ * attempts to dereference it without proper conversion.
+ *
+ * the three functions are used to assemble and disassemble references
+ */
+typedef struct __key_reference_with_attributes *key_ref_t;
+
+static inline key_ref_t make_key_ref(const struct key *key,
+                                     unsigned long possession)
+{
+        return (key_ref_t) ((unsigned long) key | possession);
+}
+
+static inline struct key *key_ref_to_ptr(const key_ref_t key_ref)
+{
+        return (struct key *) ((unsigned long) key_ref & ~1UL);
+}
+
+static inline unsigned long is_key_possessed(const key_ref_t key_ref)
+{
+        return (unsigned long) key_ref & 1UL;
+}
+
+/*****************************************************************************/
+/*
  * authentication token / access credential / keyring
  * - types of key include:
  *   - keyrings
@@ -80,6 +123,7 @@ struct key {
         struct key_type         *type;          /* type of key */
         struct rw_semaphore     sem;            /* change vs change sem */
         struct key_user         *user;          /* owner of this key */
+        void                    *security;      /* security data for this key */
         time_t                  expiry;         /* time at which key expires (or 0) */
         uid_t                   uid;
         gid_t                   gid;
@@ -215,20 +259,25 @@ static inline struct key *key_get(struct key *key)
         return key;
 }
 
+static inline void key_ref_put(key_ref_t key_ref)
+{
+        key_put(key_ref_to_ptr(key_ref));
+}
+
 extern struct key *request_key(struct key_type *type,
                                const char *description,
                                const char *callout_info);
 
 extern int key_validate(struct key *key);
 
-extern struct key *key_create_or_update(struct key *keyring,
-                                        const char *type,
-                                        const char *description,
-                                        const void *payload,
-                                        size_t plen,
-                                        int not_in_quota);
+extern key_ref_t key_create_or_update(key_ref_t keyring,
+                                      const char *type,
+                                      const char *description,
+                                      const void *payload,
+                                      size_t plen,
+                                      int not_in_quota);
 
-extern int key_update(struct key *key,
+extern int key_update(key_ref_t key,
                       const void *payload,
                       size_t plen);
 
@@ -243,9 +292,9 @@ extern struct key *keyring_alloc(const char *description, uid_t uid, gid_t gid,
 
 extern int keyring_clear(struct key *keyring);
 
-extern struct key *keyring_search(struct key *keyring,
-                                  struct key_type *type,
-                                  const char *description);
+extern key_ref_t keyring_search(key_ref_t keyring,
+                                struct key_type *type,
+                                const char *description);
 
 extern int keyring_add_key(struct key *keyring,
                            struct key *key);
@@ -285,6 +334,10 @@ extern void key_init(void);
 #define key_serial(k)                   0
 #define key_get(k)                      ({ NULL; })
 #define key_put(k)                      do { } while(0)
+#define key_ref_put(k)                  do { } while(0)
+#define make_key_ref(k)                 ({ NULL; })
+#define key_ref_to_ptr(k)               ({ NULL; })
+#define is_key_possessed(k)             0
 #define alloc_uid_keyring(u)            0
 #define switch_uid_keyring(u)           do { } while(0)
 #define __install_session_keyring(t, k) ({ NULL; })
diff --git a/include/linux/kfifo.h b/include/linux/kfifo.h
index c27cd428d269..48eccd865bd8 100644
--- a/include/linux/kfifo.h
+++ b/include/linux/kfifo.h
@@ -35,8 +35,8 @@ struct kfifo {
 };
 
 extern struct kfifo *kfifo_init(unsigned char *buffer, unsigned int size,
-                                unsigned int __nocast gfp_mask, spinlock_t *lock);
-extern struct kfifo *kfifo_alloc(unsigned int size, unsigned int __nocast gfp_mask,
+                                gfp_t gfp_mask, spinlock_t *lock);
+extern struct kfifo *kfifo_alloc(unsigned int size, gfp_t gfp_mask,
                                  spinlock_t *lock);
 extern void kfifo_free(struct kfifo *fifo);
 extern unsigned int __kfifo_put(struct kfifo *fifo,
diff --git a/include/linux/kobj_map.h b/include/linux/kobj_map.h
index b6cc10bf8dfc..cbe7d8008042 100644
--- a/include/linux/kobj_map.h
+++ b/include/linux/kobj_map.h
@@ -1,5 +1,7 @@
 #ifdef __KERNEL__
 
+#include <asm/semaphore.h>
+
 typedef struct kobject *kobj_probe_t(dev_t, int *, void *);
 struct kobj_map;
 
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
index 3b22304f12fd..7f7403aa4a41 100644
--- a/include/linux/kobject.h
+++ b/include/linux/kobject.h
@@ -65,7 +65,7 @@ extern void kobject_unregister(struct kobject *);
 extern struct kobject * kobject_get(struct kobject *);
 extern void kobject_put(struct kobject *);
 
-extern char * kobject_get_path(struct kobject *, int);
+extern char * kobject_get_path(struct kobject *, gfp_t);
 
 struct kobj_type {
         void (*release)(struct kobject *);
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
index e30afdca7917..e373c4a9de53 100644
--- a/include/linux/kprobes.h
+++ b/include/linux/kprobes.h
@@ -33,6 +33,9 @@
 #include <linux/list.h>
 #include <linux/notifier.h>
 #include <linux/smp.h>
+#include <linux/percpu.h>
+#include <linux/spinlock.h>
+#include <linux/rcupdate.h>
 
 #include <asm/kprobes.h>
 
@@ -106,6 +109,9 @@ struct jprobe {
         kprobe_opcode_t *entry; /* probe handling code to jump to */
 };
 
+DECLARE_PER_CPU(struct kprobe *, current_kprobe);
+DECLARE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
+
 #ifdef ARCH_SUPPORTS_KRETPROBES
 extern void arch_prepare_kretprobe(struct kretprobe *rp, struct pt_regs *regs);
 #else /* ARCH_SUPPORTS_KRETPROBES */
@@ -142,17 +148,7 @@ struct kretprobe_instance {
 };
 
 #ifdef CONFIG_KPROBES
-/* Locks kprobe: irq must be disabled */
-void lock_kprobes(void);
-void unlock_kprobes(void);
-
-/* kprobe running now on this CPU? */
-static inline int kprobe_running(void)
-{
-        extern unsigned int kprobe_cpu;
-        return kprobe_cpu == smp_processor_id();
-}
-
+extern spinlock_t kretprobe_lock;
 extern int arch_prepare_kprobe(struct kprobe *p);
 extern void arch_copy_kprobe(struct kprobe *p);
 extern void arch_arm_kprobe(struct kprobe *p);
@@ -163,10 +159,26 @@ extern void show_registers(struct pt_regs *regs);
 extern kprobe_opcode_t *get_insn_slot(void);
 extern void free_insn_slot(kprobe_opcode_t *slot);
 
-/* Get the kprobe at this addr (if any).  Must have called lock_kprobes */
+/* Get the kprobe at this addr (if any) - called with preemption disabled */
 struct kprobe *get_kprobe(void *addr);
 struct hlist_head * kretprobe_inst_table_head(struct task_struct *tsk);
 
+/* kprobe_running() will just return the current_kprobe on this CPU */
+static inline struct kprobe *kprobe_running(void)
+{
+        return (__get_cpu_var(current_kprobe));
+}
+
+static inline void reset_current_kprobe(void)
+{
+        __get_cpu_var(current_kprobe) = NULL;
+}
+
+static inline struct kprobe_ctlblk *get_kprobe_ctlblk(void)
+{
+        return (&__get_cpu_var(kprobe_ctlblk));
+}
+
 int register_kprobe(struct kprobe *p);
 void unregister_kprobe(struct kprobe *p);
 int setjmp_pre_handler(struct kprobe *, struct pt_regs *);
@@ -183,9 +195,9 @@ void add_rp_inst(struct kretprobe_instance *ri);
 void kprobe_flush_task(struct task_struct *tk);
 void recycle_rp_inst(struct kretprobe_instance *ri);
 #else /* CONFIG_KPROBES */
-static inline int kprobe_running(void)
+static inline struct kprobe *kprobe_running(void)
 {
-        return 0;
+        return NULL;
 }
 static inline int register_kprobe(struct kprobe *p)
 {
diff --git a/include/linux/kthread.h b/include/linux/kthread.h
index 3fa786448db3..ebdd41fd1082 100644
--- a/include/linux/kthread.h
+++ b/include/linux/kthread.h
@@ -70,6 +70,18 @@ void kthread_bind(struct task_struct *k, unsigned int cpu);
 int kthread_stop(struct task_struct *k);
 
 /**
+ * kthread_stop_sem: stop a thread created by kthread_create().
+ * @k: thread created by kthread_create().
+ * @s: semaphore that @k waits on while idle.
+ *
+ * Does essentially the same thing as kthread_stop() above, but wakes
+ * @k by calling up(@s).
+ *
+ * Returns the result of threadfn(), or -EINTR if wake_up_process()
+ * was never called. */
+int kthread_stop_sem(struct task_struct *k, struct semaphore *s);
+
+/**
  * kthread_should_stop: should this kthread return now?
  *
  * When someone calls kthread_stop on your kthread, it will be woken
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 022105c745fc..f2dbb684ce9e 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -29,6 +29,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
+#include <linux/dma-mapping.h>
 #include <asm/io.h>
 #include <linux/ata.h>
 #include <linux/workqueue.h>
@@ -58,6 +59,8 @@
 #define VPRINTK(fmt, args...)
 #endif  /* ATA_DEBUG */
 
+#define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
+
 #ifdef ATA_NDEBUG
 #define assert(expr)
 #else
@@ -91,12 +94,13 @@ enum {
         ATA_SHT_EMULATED        = 1,
         ATA_SHT_CMD_PER_LUN     = 1,
         ATA_SHT_THIS_ID         = -1,
-        ATA_SHT_USE_CLUSTERING  = 0,
+        ATA_SHT_USE_CLUSTERING  = 1,
 
         /* struct ata_device stuff */
         ATA_DFLAG_LBA48         = (1 << 0), /* device supports LBA48 */
         ATA_DFLAG_PIO           = (1 << 1), /* device currently in PIO mode */
         ATA_DFLAG_LOCK_SECTORS  = (1 << 2), /* don't adjust max_sectors */
+        ATA_DFLAG_LBA           = (1 << 3), /* device supports LBA */
 
         ATA_DEV_UNKNOWN         = 0,    /* unknown device */
         ATA_DEV_ATA             = 1,    /* ATA device */
@@ -117,6 +121,7 @@ enum {
         ATA_FLAG_PIO_DMA        = (1 << 8), /* PIO cmds via DMA */
         ATA_FLAG_NOINTR         = (1 << 9), /* FIXME: Remove this once
                                              * proper HSM is in place. */
+        ATA_FLAG_DEBUGMSG       = (1 << 10),
 
         ATA_QCFLAG_ACTIVE       = (1 << 1), /* cmd not yet ack'd to scsi lyer */
         ATA_QCFLAG_SG           = (1 << 3), /* have s/g table? */
@@ -154,17 +159,32 @@ enum {
         ATA_SHIFT_UDMA          = 0,
         ATA_SHIFT_MWDMA         = 8,
         ATA_SHIFT_PIO           = 11,
+
+        /* size of buffer to pad xfers ending on unaligned boundaries */
+        ATA_DMA_PAD_SZ          = 4,
+        ATA_DMA_PAD_BUF_SZ      = ATA_DMA_PAD_SZ * ATA_MAX_QUEUE,
+        
+        /* Masks for port functions */
+        ATA_PORT_PRIMARY        = (1 << 0),
+        ATA_PORT_SECONDARY      = (1 << 1),
 };
 
-enum pio_task_states {
-        PIO_ST_UNKNOWN,
-        PIO_ST_IDLE,
-        PIO_ST_POLL,
-        PIO_ST_TMOUT,
-        PIO_ST,
-        PIO_ST_LAST,
-        PIO_ST_LAST_POLL,
-        PIO_ST_ERR,
+enum hsm_task_states {
+        HSM_ST_UNKNOWN,
+        HSM_ST_IDLE,
+        HSM_ST_POLL,
+        HSM_ST_TMOUT,
+        HSM_ST,
+        HSM_ST_LAST,
+        HSM_ST_LAST_POLL,
+        HSM_ST_ERR,
+};
+
+enum ata_completion_errors {
+        AC_ERR_OTHER            = (1 << 0),
+        AC_ERR_DEV              = (1 << 1),
+        AC_ERR_ATA_BUS          = (1 << 2),
+        AC_ERR_HOST_BUS         = (1 << 3),
 };
 
 /* forward declarations */
@@ -174,7 +194,7 @@ struct ata_port;
 struct ata_queued_cmd;
 
 /* typedefs */
-typedef int (*ata_qc_cb_t) (struct ata_queued_cmd *qc, u8 drv_stat);
+typedef int (*ata_qc_cb_t) (struct ata_queued_cmd *qc, unsigned int err_mask);
 
 struct ata_ioports {
         unsigned long           cmd_addr;
@@ -197,8 +217,8 @@ struct ata_ioports {
 struct ata_probe_ent {
         struct list_head        node;
         struct device           *dev;
-        struct ata_port_operations      *port_ops;
-        Scsi_Host_Template      *sht;
+        const struct ata_port_operations *port_ops;
+        struct scsi_host_template *sht;
         struct ata_ioports      port[ATA_MAX_PORTS];
         unsigned int            n_ports;
         unsigned int            hard_port_no;
@@ -220,7 +240,7 @@ struct ata_host_set {
         void __iomem            *mmio_base;
         unsigned int            n_ports;
         void                    *private_data;
-        struct ata_port_operations *ops;
+        const struct ata_port_operations *ops;
         struct ata_port *       ports[0];
 };
 
@@ -237,9 +257,12 @@ struct ata_queued_cmd {
         unsigned long           flags;          /* ATA_QCFLAG_xxx */
         unsigned int            tag;
         unsigned int            n_elem;
+        unsigned int            orig_n_elem;
 
         int                     dma_dir;
 
+        unsigned int            pad_len;
+
         unsigned int            nsect;
         unsigned int            cursect;
 
@@ -250,9 +273,11 @@ struct ata_queued_cmd {
         unsigned int            cursg_ofs;
 
         struct scatterlist      sgent;
+        struct scatterlist      pad_sgent;
         void                    *buf_virt;
 
-        struct scatterlist      *sg;
+        /* DO NOT iterate over __sg manually, use ata_for_each_sg() */
+        struct scatterlist      *__sg;
 
         ata_qc_cb_t             complete_fn;
 
@@ -278,15 +303,18 @@ struct ata_device {
         u8                      xfer_mode;
         unsigned int            xfer_shift;     /* ATA_SHIFT_xxx */
 
-        /* cache info about current transfer mode */
-        u8                      xfer_protocol;  /* taskfile xfer protocol */
-        u8                      read_cmd;       /* opcode to use on read */
-        u8                      write_cmd;      /* opcode to use on write */
+        unsigned int            multi_count;    /* sectors count for
+                                                   READ/WRITE MULTIPLE */
+
+        /* for CHS addressing */
+        u16                     cylinders;      /* Number of cylinders */
+        u16                     heads;          /* Number of heads */
+        u16                     sectors;        /* Number of sectors per track */
 };
 
 struct ata_port {
         struct Scsi_Host        *host;  /* our co-allocated scsi host */
-        struct ata_port_operations      *ops;
+        const struct ata_port_operations *ops;
         unsigned long           flags;  /* ATA_FLAG_xxx */
         unsigned int            id;     /* unique id req'd by scsi midlyr */
         unsigned int            port_no; /* unique port #; from zero */
@@ -295,6 +323,9 @@ struct ata_port {
         struct ata_prd          *prd;    /* our SG list */
         dma_addr_t              prd_dma; /* and its DMA mapping */
 
+        void                    *pad;   /* array of DMA pad buffers */
+        dma_addr_t              pad_dma;
+
         struct ata_ioports      ioaddr; /* ATA cmd/ctl/dma register blocks */
 
         u8                      ctl;    /* cache of ATA control register */
@@ -319,7 +350,7 @@ struct ata_port {
         struct work_struct      packet_task;
 
         struct work_struct      pio_task;
-        unsigned int            pio_task_state;
+        unsigned int            hsm_task_state;
         unsigned long           pio_task_timeout;
 
         void                    *private_data;
@@ -333,13 +364,12 @@ struct ata_port_operations {
         void (*set_piomode) (struct ata_port *, struct ata_device *);
         void (*set_dmamode) (struct ata_port *, struct ata_device *);
 
-        void (*tf_load) (struct ata_port *ap, struct ata_taskfile *tf);
+        void (*tf_load) (struct ata_port *ap, const struct ata_taskfile *tf);
         void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
 
-        void (*exec_command)(struct ata_port *ap, struct ata_taskfile *tf);
+        void (*exec_command)(struct ata_port *ap, const struct ata_taskfile *tf);
         u8   (*check_status)(struct ata_port *ap);
         u8   (*check_altstatus)(struct ata_port *ap);
-        u8   (*check_err)(struct ata_port *ap);
         void (*dev_select)(struct ata_port *ap, unsigned int device);
 
         void (*phy_reset) (struct ata_port *ap);
@@ -372,14 +402,28 @@ struct ata_port_operations {
 };
 
 struct ata_port_info {
-        Scsi_Host_Template      *sht;
+        struct scsi_host_template       *sht;
         unsigned long           host_flags;
         unsigned long           pio_mask;
         unsigned long           mwdma_mask;
         unsigned long           udma_mask;
-        struct ata_port_operations      *port_ops;
+        const struct ata_port_operations *port_ops;
+        void                    *private_data;
 };
 
+struct ata_timing {
+        unsigned short mode;            /* ATA mode */
+        unsigned short setup;           /* t1 */
+        unsigned short act8b;           /* t2 for 8-bit I/O */
+        unsigned short rec8b;           /* t2i for 8-bit I/O */
+        unsigned short cyc8b;           /* t0 for 8-bit I/O */
+        unsigned short active;          /* t2 or tD */
+        unsigned short recover;         /* t2i or tK */
+        unsigned short cycle;           /* t0 */
+        unsigned short udma;            /* t2CYCTYP/2 */
+};
+
+#define FIT(v,vmin,vmax)        max_t(short,min_t(short,v,vmax),vmin)
 
 extern void ata_port_probe(struct ata_port *);
 extern void __sata_phy_reset(struct ata_port *ap);
@@ -392,26 +436,28 @@ extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_i
                              unsigned int n_ports);
 extern void ata_pci_remove_one (struct pci_dev *pdev);
 #endif /* CONFIG_PCI */
-extern int ata_device_add(struct ata_probe_ent *ent);
-extern int ata_scsi_detect(Scsi_Host_Template *sht);
+extern int ata_device_add(const struct ata_probe_ent *ent);
+extern void ata_host_set_remove(struct ata_host_set *host_set);
+extern int ata_scsi_detect(struct scsi_host_template *sht);
 extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
 extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
 extern int ata_scsi_error(struct Scsi_Host *host);
 extern int ata_scsi_release(struct Scsi_Host *host);
 extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
+extern int ata_ratelimit(void);
+
 /*
  * Default driver ops implementations
  */
-extern void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf);
+extern void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
 extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
-extern void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp);
-extern void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf);
+extern void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp);
+extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
 extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device);
 extern void ata_std_dev_select (struct ata_port *ap, unsigned int device);
 extern u8 ata_check_status(struct ata_port *ap);
 extern u8 ata_altstatus(struct ata_port *ap);
-extern u8 ata_chk_err(struct ata_port *ap);
-extern void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf);
+extern void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf);
 extern int ata_port_start (struct ata_port *ap);
 extern void ata_port_stop (struct ata_port *ap);
 extern void ata_host_stop (struct ata_host_set *host_set);
@@ -422,8 +468,8 @@ extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
                 unsigned int buflen);
 extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
                  unsigned int n_elem);
-extern unsigned int ata_dev_classify(struct ata_taskfile *tf);
-extern void ata_dev_id_string(u16 *id, unsigned char *s,
+extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
+extern void ata_dev_id_string(const u16 *id, unsigned char *s,
                               unsigned int ofs, unsigned int len);
 extern void ata_dev_config(struct ata_port *ap, unsigned int i);
 extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
@@ -431,7 +477,7 @@ extern void ata_bmdma_start (struct ata_queued_cmd *qc);
 extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
 extern u8   ata_bmdma_status(struct ata_port *ap);
 extern void ata_bmdma_irq_clear(struct ata_port *ap);
-extern void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat);
+extern void ata_qc_complete(struct ata_queued_cmd *qc, unsigned int err_mask);
 extern void ata_eng_timeout(struct ata_port *ap);
 extern void ata_scsi_simulate(u16 *id, struct scsi_cmnd *cmd,
                               void (*done)(struct scsi_cmnd *));
@@ -440,6 +486,32 @@ extern int ata_std_bios_param(struct scsi_device *sdev,
                               sector_t capacity, int geom[]);
 extern int ata_scsi_slave_config(struct scsi_device *sdev);
 
+/*
+ * Timing helpers
+ */
+extern int ata_timing_compute(struct ata_device *, unsigned short,
+                              struct ata_timing *, int, int);
+extern void ata_timing_merge(const struct ata_timing *,
+                             const struct ata_timing *, struct ata_timing *,
+                             unsigned int);
+
+enum {
+        ATA_TIMING_SETUP        = (1 << 0),
+        ATA_TIMING_ACT8B        = (1 << 1),
+        ATA_TIMING_REC8B        = (1 << 2),
+        ATA_TIMING_CYC8B        = (1 << 3),
+        ATA_TIMING_8BIT         = ATA_TIMING_ACT8B | ATA_TIMING_REC8B |
+                                  ATA_TIMING_CYC8B,
+        ATA_TIMING_ACTIVE       = (1 << 4),
+        ATA_TIMING_RECOVER      = (1 << 5),
+        ATA_TIMING_CYCLE        = (1 << 6),
+        ATA_TIMING_UDMA         = (1 << 7),
+        ATA_TIMING_ALL          = ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
+                                  ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
+                                  ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
+                                  ATA_TIMING_CYCLE | ATA_TIMING_UDMA,
+};
+
 
 #ifdef CONFIG_PCI
 struct pci_bits {
@@ -451,18 +523,43 @@ struct pci_bits {
 
 extern void ata_pci_host_stop (struct ata_host_set *host_set);
 extern struct ata_probe_ent *
-ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port);
-extern int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits);
+ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int portmask);
+extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
 
 #endif /* CONFIG_PCI */
 
 
+static inline int
+ata_sg_is_last(struct scatterlist *sg, struct ata_queued_cmd *qc)
+{
+        if (sg == &qc->pad_sgent)
+                return 1;
+        if (qc->pad_len)
+                return 0;
+        if (((sg - qc->__sg) + 1) == qc->n_elem)
+                return 1;
+        return 0;
+}
+
+static inline struct scatterlist *
+ata_qc_next_sg(struct scatterlist *sg, struct ata_queued_cmd *qc)
+{
+        if (sg == &qc->pad_sgent)
+                return NULL;
+        if (++sg - qc->__sg < qc->n_elem)
+                return sg;
+        return qc->pad_len ? &qc->pad_sgent : NULL;
+}
+
+#define ata_for_each_sg(sg, qc) \
+        for (sg = qc->__sg; sg; sg = ata_qc_next_sg(sg, qc))
+
 static inline unsigned int ata_tag_valid(unsigned int tag)
 {
         return (tag < ATA_MAX_QUEUE) ? 1 : 0;
 }
 
-static inline unsigned int ata_dev_present(struct ata_device *dev)
+static inline unsigned int ata_dev_present(const struct ata_device *dev)
 {
         return ((dev->class == ATA_DEV_ATA) ||
                 (dev->class == ATA_DEV_ATAPI));
@@ -565,6 +662,17 @@ static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, uns
                 tf->device = ATA_DEVICE_OBS | ATA_DEV1;
 }
 
+static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
+{
+        qc->__sg = NULL;
+        qc->flags = 0;
+        qc->cursect = qc->cursg = qc->cursg_ofs = 0;
+        qc->nsect = 0;
+        qc->nbytes = qc->curbytes = 0;
+
+        ata_tf_init(qc->ap, &qc->tf, qc->dev->devno);
+}
+
 
 /**
  *      ata_irq_on - Enable interrupts on a port.
@@ -661,11 +769,41 @@ static inline unsigned int sata_dev_present(struct ata_port *ap)
         return ((scr_read(ap, SCR_STATUS) & 0xf) == 0x3) ? 1 : 0;
 }
 
-static inline int ata_try_flush_cache(struct ata_device *dev)
+static inline int ata_try_flush_cache(const struct ata_device *dev)
 {
         return ata_id_wcache_enabled(dev->id) ||
                ata_id_has_flush(dev->id) ||
                ata_id_has_flush_ext(dev->id);
 }
 
+static inline unsigned int ac_err_mask(u8 status)
+{
+        if (status & ATA_BUSY)
+                return AC_ERR_ATA_BUS;
+        if (status & (ATA_ERR | ATA_DF))
+                return AC_ERR_DEV;
+        return 0;
+}
+
+static inline unsigned int __ac_err_mask(u8 status)
+{
+        unsigned int mask = ac_err_mask(status);
+        if (mask == 0)
+                return AC_ERR_OTHER;
+        return mask;
+}
+
+static inline int ata_pad_alloc(struct ata_port *ap, struct device *dev)
+{
+        ap->pad_dma = 0;
+        ap->pad = dma_alloc_coherent(dev, ATA_DMA_PAD_BUF_SZ,
+                                     &ap->pad_dma, GFP_KERNEL);
+        return (ap->pad == NULL) ? -ENOMEM : 0;
+}
+
+static inline void ata_pad_free(struct ata_port *ap, struct device *dev)
+{
+        dma_free_coherent(dev, ATA_DMA_PAD_BUF_SZ, ap->pad, ap->pad_dma);
+}
+
 #endif /* __LINUX_LIBATA_H__ */
diff --git a/include/linux/list.h b/include/linux/list.h
index e6ec59682274..fbfca73355a3 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -442,12 +442,14 @@ static inline void list_splice_init(struct list_head *list,
  * as long as the traversal is guarded by rcu_read_lock().
  */
 #define list_for_each_rcu(pos, head) \
-        for (pos = (head)->next; prefetch(pos->next), pos != (head); \
-                pos = rcu_dereference(pos->next))
+        for (pos = (head)->next; \
+                prefetch(rcu_dereference(pos)->next), pos != (head); \
+                pos = pos->next)
 
 #define __list_for_each_rcu(pos, head) \
-        for (pos = (head)->next; pos != (head); \
-                pos = rcu_dereference(pos->next))
+        for (pos = (head)->next; \
+                rcu_dereference(pos) != (head); \
+                pos = pos->next)
 
 /**
  * list_for_each_safe_rcu       -       iterate over an rcu-protected list safe
@@ -461,8 +463,9 @@ static inline void list_splice_init(struct list_head *list,
  * as long as the traversal is guarded by rcu_read_lock().
  */
 #define list_for_each_safe_rcu(pos, n, head) \
-        for (pos = (head)->next, n = pos->next; pos != (head); \
-                pos = rcu_dereference(n), n = pos->next)
+        for (pos = (head)->next; \
+                n = rcu_dereference(pos)->next, pos != (head); \
+                pos = n)
 
 /**
  * list_for_each_entry_rcu      -       iterate over rcu list of given type
@@ -474,11 +477,11 @@ static inline void list_splice_init(struct list_head *list,
  * the _rcu list-mutation primitives such as list_add_rcu()
  * as long as the traversal is guarded by rcu_read_lock().
  */
-#define list_for_each_entry_rcu(pos, head, member)                      \
-        for (pos = list_entry((head)->next, typeof(*pos), member);      \
-             prefetch(pos->member.next), &pos->member != (head);        \
-             pos = rcu_dereference(list_entry(pos->member.next,         \
-                                        typeof(*pos), member)))
+#define list_for_each_entry_rcu(pos, head, member) \
+        for (pos = list_entry((head)->next, typeof(*pos), member); \
+                prefetch(rcu_dereference(pos)->member.next), \
+                        &pos->member != (head); \
+                pos = list_entry(pos->member.next, typeof(*pos), member))
 
 
 /**
@@ -492,8 +495,9 @@ static inline void list_splice_init(struct list_head *list,
  * as long as the traversal is guarded by rcu_read_lock().
  */
 #define list_for_each_continue_rcu(pos, head) \
-        for ((pos) = (pos)->next; prefetch((pos)->next), (pos) != (head); \
-                (pos) = rcu_dereference((pos)->next))
+        for ((pos) = (pos)->next; \
+                prefetch(rcu_dereference((pos))->next), (pos) != (head); \
+                (pos) = (pos)->next)
 
 /*
  * Double linked lists with a single pointer list head.
@@ -597,7 +601,7 @@ static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
  * or hlist_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
- * hlist_for_each_rcu(), used to prevent memory-consistency
+ * hlist_for_each_entry_rcu(), used to prevent memory-consistency
  * problems on Alpha CPUs.  Regardless of the type of CPU, the
  * list-traversal primitive must be guarded by rcu_read_lock().
  */
@@ -646,7 +650,7 @@ static inline void hlist_add_after(struct hlist_node *n,
  * or hlist_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
- * hlist_for_each_rcu(), used to prevent memory-consistency
+ * hlist_for_each_entry_rcu(), used to prevent memory-consistency
  * problems on Alpha CPUs.
  */
 static inline void hlist_add_before_rcu(struct hlist_node *n,
@@ -671,7 +675,7 @@ static inline void hlist_add_before_rcu(struct hlist_node *n,
  * or hlist_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
- * hlist_for_each_rcu(), used to prevent memory-consistency
+ * hlist_for_each_entry_rcu(), used to prevent memory-consistency
  * problems on Alpha CPUs.
  */
 static inline void hlist_add_after_rcu(struct hlist_node *prev,
@@ -695,10 +699,6 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
         for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
              pos = n)
 
-#define hlist_for_each_rcu(pos, head) \
-        for ((pos) = (head)->first; pos && ({ prefetch((pos)->next); 1; }); \
-                (pos) = rcu_dereference((pos)->next))
-
 /**
  * hlist_for_each_entry - iterate over list of given type
  * @tpos:       the type * to use as a loop counter.
@@ -751,7 +751,7 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
 
 /**
  * hlist_for_each_entry_rcu - iterate over rcu list of given type
- * @pos:        the type * to use as a loop counter.
+ * @tpos:       the type * to use as a loop counter.
  * @pos:        the &struct hlist_node to use as a loop counter.
  * @head:       the head for your list.
  * @member:     the name of the hlist_node within the struct.
@@ -762,9 +762,9 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
  */
 #define hlist_for_each_entry_rcu(tpos, pos, head, member)                \
         for (pos = (head)->first;                                        \
-             pos && ({ prefetch(pos->next); 1;}) &&                      \
+             rcu_dereference(pos) && ({ prefetch(pos->next); 1;}) &&     \
                 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
-             pos = rcu_dereference(pos->next))
+             pos = pos->next)
 
 #else
 #warning "don't include kernel headers in userspace"
diff --git a/include/linux/loop.h b/include/linux/loop.h
index 53fa51595443..40f63c9879d2 100644
--- a/include/linux/loop.h
+++ b/include/linux/loop.h
@@ -52,7 +52,7 @@ struct loop_device {
         unsigned        lo_blocksize;
         void            *key_data; 
 
-        int             old_gfp_mask;
+        gfp_t           old_gfp_mask;
 
         spinlock_t              lo_lock;
         struct bio              *lo_bio;
diff --git a/include/linux/mbcache.h b/include/linux/mbcache.h
index 9263d2db2d67..99e044b4efc6 100644
--- a/include/linux/mbcache.h
+++ b/include/linux/mbcache.h
@@ -22,7 +22,7 @@ struct mb_cache_entry {
 };
 
 struct mb_cache_op {
-        int (*free)(struct mb_cache_entry *, int);
+        int (*free)(struct mb_cache_entry *, gfp_t);
 };
 
 /* Functions on caches */
diff --git a/include/linux/memory.h b/include/linux/memory.h
new file mode 100644
index 000000000000..dc4081b6f161
--- /dev/null
+++ b/include/linux/memory.h
@@ -0,0 +1,96 @@
+/*
+ * include/linux/memory.h - generic memory definition
+ *
+ * This is mainly for topological representation. We define the
+ * basic "struct memory_block" here, which can be embedded in per-arch
+ * definitions or NUMA information.
+ *
+ * Basic handling of the devices is done in drivers/base/memory.c
+ * and system devices are handled in drivers/base/sys.c.
+ *
+ * Memory block are exported via sysfs in the class/memory/devices/
+ * directory.
+ *
+ */
+#ifndef _LINUX_MEMORY_H_
+#define _LINUX_MEMORY_H_
+
+#include <linux/sysdev.h>
+#include <linux/node.h>
+#include <linux/compiler.h>
+
+#include <asm/semaphore.h>
+
+struct memory_block {
+        unsigned long phys_index;
+        unsigned long state;
+        /*
+         * This serializes all state change requests.  It isn't
+         * held during creation because the control files are
+         * created long after the critical areas during
+         * initialization.
+         */
+        struct semaphore state_sem;
+        int phys_device;                /* to which fru does this belong? */
+        void *hw;                       /* optional pointer to fw/hw data */
+        int (*phys_callback)(struct memory_block *);
+        struct sys_device sysdev;
+};
+
+/* These states are exposed to userspace as text strings in sysfs */
+#define MEM_ONLINE              (1<<0) /* exposed to userspace */
+#define MEM_GOING_OFFLINE       (1<<1) /* exposed to userspace */
+#define MEM_OFFLINE             (1<<2) /* exposed to userspace */
+
+/*
+ * All of these states are currently kernel-internal for notifying
+ * kernel components and architectures.
+ *
+ * For MEM_MAPPING_INVALID, all notifier chains with priority >0
+ * are called before pfn_to_page() becomes invalid.  The priority=0
+ * entry is reserved for the function that actually makes
+ * pfn_to_page() stop working.  Any notifiers that want to be called
+ * after that should have priority <0.
+ */
+#define MEM_MAPPING_INVALID     (1<<3)
+
+struct notifier_block;
+struct mem_section;
+
+#ifndef CONFIG_MEMORY_HOTPLUG
+static inline int memory_dev_init(void)
+{
+        return 0;
+}
+static inline int register_memory_notifier(struct notifier_block *nb)
+{
+        return 0;
+}
+static inline void unregister_memory_notifier(struct notifier_block *nb)
+{
+}
+#else
+extern int register_memory(struct memory_block *, struct mem_section *section, struct node *);
+extern int register_new_memory(struct mem_section *);
+extern int unregister_memory_section(struct mem_section *);
+extern int memory_dev_init(void);
+extern int register_memory_notifier(struct notifier_block *nb);
+extern void unregister_memory_notifier(struct notifier_block *nb);
+
+#define CONFIG_MEM_BLOCK_SIZE   (PAGES_PER_SECTION<<PAGE_SHIFT)
+
+extern int invalidate_phys_mapping(unsigned long, unsigned long);
+struct notifier_block;
+
+extern int register_memory_notifier(struct notifier_block *nb);
+extern void unregister_memory_notifier(struct notifier_block *nb);
+
+#endif /* CONFIG_MEMORY_HOTPLUG */
+
+#define hotplug_memory_notifier(fn, pri) {                      \
+        static struct notifier_block fn##_mem_nb =              \
+                { .notifier_call = fn, .priority = pri };       \
+        register_memory_notifier(&fn##_mem_nb);                 \
+}
+
+#endif /* _LINUX_MEMORY_H_ */
diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
new file mode 100644
index 000000000000..01f03bc06eff
--- /dev/null
+++ b/include/linux/memory_hotplug.h
@@ -0,0 +1,104 @@
+#ifndef __LINUX_MEMORY_HOTPLUG_H
+#define __LINUX_MEMORY_HOTPLUG_H
+
+#include <linux/mmzone.h>
+#include <linux/spinlock.h>
+#include <linux/mmzone.h>
+#include <linux/notifier.h>
+
+#ifdef CONFIG_MEMORY_HOTPLUG
+/*
+ * pgdat resizing functions
+ */
+static inline
+void pgdat_resize_lock(struct pglist_data *pgdat, unsigned long *flags)
+{
+        spin_lock_irqsave(&pgdat->node_size_lock, *flags);
+}
+static inline
+void pgdat_resize_unlock(struct pglist_data *pgdat, unsigned long *flags)
+{
+        spin_unlock_irqrestore(&pgdat->node_size_lock, *flags);
+}
+static inline
+void pgdat_resize_init(struct pglist_data *pgdat)
+{
+        spin_lock_init(&pgdat->node_size_lock);
+}
+/*
+ * Zone resizing functions
+ */
+static inline unsigned zone_span_seqbegin(struct zone *zone)
+{
+        return read_seqbegin(&zone->span_seqlock);
+}
+static inline int zone_span_seqretry(struct zone *zone, unsigned iv)
+{
+        return read_seqretry(&zone->span_seqlock, iv);
+}
+static inline void zone_span_writelock(struct zone *zone)
+{
+        write_seqlock(&zone->span_seqlock);
+}
+static inline void zone_span_writeunlock(struct zone *zone)
+{
+        write_sequnlock(&zone->span_seqlock);
+}
+static inline void zone_seqlock_init(struct zone *zone)
+{
+        seqlock_init(&zone->span_seqlock);
+}
+extern int zone_grow_free_lists(struct zone *zone, unsigned long new_nr_pages);
+extern int zone_grow_waitqueues(struct zone *zone, unsigned long nr_pages);
+extern int add_one_highpage(struct page *page, int pfn, int bad_ppro);
+/* need some defines for these for archs that don't support it */
+extern void online_page(struct page *page);
+/* VM interface that may be used by firmware interface */
+extern int add_memory(u64 start, u64 size);
+extern int remove_memory(u64 start, u64 size);
+extern int online_pages(unsigned long, unsigned long);
+
+/* reasonably generic interface to expand the physical pages in a zone  */
+extern int __add_pages(struct zone *zone, unsigned long start_pfn,
+        unsigned long nr_pages);
+#else /* ! CONFIG_MEMORY_HOTPLUG */
+/*
+ * Stub functions for when hotplug is off
+ */
+static inline void pgdat_resize_lock(struct pglist_data *p, unsigned long *f) {}
+static inline void pgdat_resize_unlock(struct pglist_data *p, unsigned long *f) {}
+static inline void pgdat_resize_init(struct pglist_data *pgdat) {}
+
+static inline unsigned zone_span_seqbegin(struct zone *zone)
+{
+        return 0;
+}
+static inline int zone_span_seqretry(struct zone *zone, unsigned iv)
+{
+        return 0;
+}
+static inline void zone_span_writelock(struct zone *zone) {}
+static inline void zone_span_writeunlock(struct zone *zone) {}
+static inline void zone_seqlock_init(struct zone *zone) {}
+
+static inline int mhp_notimplemented(const char *func)
+{
+        printk(KERN_WARNING "%s() called, with CONFIG_MEMORY_HOTPLUG disabled\n", func);
+        dump_stack();
+        return -ENOSYS;
+}
+
+static inline int __add_pages(struct zone *zone, unsigned long start_pfn,
+        unsigned long nr_pages)
+{
+        return mhp_notimplemented(__FUNCTION__);
+}
+#endif /* ! CONFIG_MEMORY_HOTPLUG */
+static inline int __remove_pages(struct zone *zone, unsigned long start_pfn,
+        unsigned long nr_pages)
+{
+        printk(KERN_WARNING "%s() called, not yet supported\n", __FUNCTION__);
+        dump_stack();
+        return -ENOSYS;
+}
+#endif /* __LINUX_MEMORY_HOTPLUG_H */
diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h
index 58385ee1c0ac..8b67cf837ca9 100644
--- a/include/linux/mempolicy.h
+++ b/include/linux/mempolicy.h
@@ -27,10 +27,10 @@
 
 #include <linux/config.h>
 #include <linux/mmzone.h>
-#include <linux/bitmap.h>
 #include <linux/slab.h>
 #include <linux/rbtree.h>
 #include <linux/spinlock.h>
+#include <linux/nodemask.h>
 
 struct vm_area_struct;
 
@@ -47,8 +47,7 @@ struct vm_area_struct;
  * Locking policy for interlave:
  * In process context there is no locking because only the process accesses
  * its own state. All vma manipulation is somewhat protected by a down_read on
- * mmap_sem. For allocating in the interleave policy the page_table_lock
- * must be also aquired to protect il_next.
+ * mmap_sem.
  *
  * Freeing policy:
  * When policy is MPOL_BIND v.zonelist is kmalloc'ed and must be kfree'd.
@@ -63,7 +62,7 @@ struct mempolicy {
         union {
                 struct zonelist  *zonelist;     /* bind */
                 short            preferred_node; /* preferred */
-                DECLARE_BITMAP(nodes, MAX_NUMNODES); /* interleave */
+                nodemask_t       nodes;         /* interleave */
                 /* undefined for default */
         } v;
 };
@@ -155,6 +154,7 @@ struct mempolicy *get_vma_policy(struct task_struct *task,
 
 extern void numa_default_policy(void);
 extern void numa_policy_init(void);
+extern void numa_policy_rebind(const nodemask_t *old, const nodemask_t *new);
 extern struct mempolicy default_policy;
 
 #else
@@ -227,6 +227,11 @@ static inline void numa_default_policy(void)
 {
 }
 
+static inline void numa_policy_rebind(const nodemask_t *old,
+                                        const nodemask_t *new)
+{
+}
+
 #endif /* CONFIG_NUMA */
 #endif /* __KERNEL__ */
 
diff --git a/include/linux/mempool.h b/include/linux/mempool.h
index 796220ce47cc..f2427d7394b0 100644
--- a/include/linux/mempool.h
+++ b/include/linux/mempool.h
@@ -6,7 +6,7 @@
 
 #include <linux/wait.h>
 
-typedef void * (mempool_alloc_t)(unsigned int __nocast gfp_mask, void *pool_data);
+typedef void * (mempool_alloc_t)(gfp_t gfp_mask, void *pool_data);
 typedef void (mempool_free_t)(void *element, void *pool_data);
 
 typedef struct mempool_s {
@@ -26,17 +26,16 @@ extern mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn,
 extern mempool_t *mempool_create_node(int min_nr, mempool_alloc_t *alloc_fn,
                         mempool_free_t *free_fn, void *pool_data, int nid);
 
-extern int mempool_resize(mempool_t *pool, int new_min_nr,
-                        unsigned int __nocast gfp_mask);
+extern int mempool_resize(mempool_t *pool, int new_min_nr, gfp_t gfp_mask);
 extern void mempool_destroy(mempool_t *pool);
-extern void * mempool_alloc(mempool_t *pool, unsigned int __nocast gfp_mask);
+extern void * mempool_alloc(mempool_t *pool, gfp_t gfp_mask);
 extern void mempool_free(void *element, mempool_t *pool);
 
 /*
  * A mempool_alloc_t and mempool_free_t that get the memory from
  * a slab that is passed in through pool_data.
  */
-void *mempool_alloc_slab(unsigned int __nocast gfp_mask, void *pool_data);
+void *mempool_alloc_slab(gfp_t gfp_mask, void *pool_data);
 void mempool_free_slab(void *element, void *pool_data);
 
 #endif /* _LINUX_MEMPOOL_H */
diff --git a/include/linux/mii.h b/include/linux/mii.h
index 9b8d0476988a..68f5a0f392dd 100644
--- a/include/linux/mii.h
+++ b/include/linux/mii.h
@@ -158,6 +158,7 @@ extern int mii_link_ok (struct mii_if_info *mii);
 extern int mii_nway_restart (struct mii_if_info *mii);
 extern int mii_ethtool_gset(struct mii_if_info *mii, struct ethtool_cmd *ecmd);
 extern int mii_ethtool_sset(struct mii_if_info *mii, struct ethtool_cmd *ecmd);
+extern int mii_check_gmii_support(struct mii_if_info *mii);
 extern void mii_check_link (struct mii_if_info *mii);
 extern unsigned int mii_check_media (struct mii_if_info *mii,
                                      unsigned int ok_to_print,
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 097b3a3c693d..29f02d8513f6 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -144,7 +144,8 @@ extern unsigned int kobjsize(const void *objp);
 
 #define VM_GROWSDOWN    0x00000100      /* general info on the segment */
 #define VM_GROWSUP      0x00000200
-#define VM_SHM          0x00000400      /* shared memory area, don't swap out */
+#define VM_SHM          0x00000000      /* Means nothing: delete it later */
+#define VM_PFNMAP       0x00000400      /* Page-ranges managed without "struct page", just pure PFN */
 #define VM_DENYWRITE    0x00000800      /* ETXTBSY on write attempts.. */
 
 #define VM_EXECUTABLE   0x00001000
@@ -157,11 +158,12 @@ extern unsigned int kobjsize(const void *objp);
 
 #define VM_DONTCOPY     0x00020000      /* Do not copy this vma on fork */
 #define VM_DONTEXPAND   0x00040000      /* Cannot expand with mremap() */
-#define VM_RESERVED     0x00080000      /* Don't unmap it from swap_out */
+#define VM_RESERVED     0x00080000      /* Count as reserved_vm like IO */
 #define VM_ACCOUNT      0x00100000      /* Is a VM accounted object */
 #define VM_HUGETLB      0x00400000      /* Huge TLB Page VM */
 #define VM_NONLINEAR    0x00800000      /* Is non-linear (remap_file_pages) */
 #define VM_MAPPED_COPY  0x01000000      /* T if mapped copy of data (nommu mmap) */
+#define VM_INCOMPLETE   0x02000000      /* Strange partial PFN mapping marker */
 
 #ifndef VM_STACK_DEFAULT_FLAGS          /* arch can override this */
 #define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS
@@ -206,12 +208,6 @@ struct vm_operations_struct {
 struct mmu_gather;
 struct inode;
 
-#ifdef ARCH_HAS_ATOMIC_UNSIGNED
-typedef unsigned page_flags_t;
-#else
-typedef unsigned long page_flags_t;
-#endif
-
 /*
  * Each physical page in the system has a struct page associated with
  * it to keep track of whatever it is we are using the page for at the
@@ -219,20 +215,25 @@ typedef unsigned long page_flags_t;
  * a page.
  */
 struct page {
-        page_flags_t flags;             /* Atomic flags, some possibly
+        unsigned long flags;            /* Atomic flags, some possibly
                                          * updated asynchronously */
         atomic_t _count;                /* Usage count, see below. */
         atomic_t _mapcount;             /* Count of ptes mapped in mms,
                                          * to show when page is mapped
                                          * & limit reverse map searches.
                                          */
-        unsigned long private;          /* Mapping-private opaque data:
+        union {
+                unsigned long private;  /* Mapping-private opaque data:
                                          * usually used for buffer_heads
                                          * if PagePrivate set; used for
                                          * swp_entry_t if PageSwapCache
                                          * When page is free, this indicates
                                          * order in the buddy system.
                                          */
+#if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
+                spinlock_t ptl;
+#endif
+        } u;
         struct address_space *mapping;  /* If low bit clear, points to
                                          * inode address_space, or NULL.
                                          * If page mapped as anonymous
@@ -260,6 +261,9 @@ struct page {
 #endif /* WANT_PAGE_VIRTUAL */
 };
 
+#define page_private(page)              ((page)->u.private)
+#define set_page_private(page, v)       ((page)->u.private = (v))
+
 /*
  * FIXME: take this include out, include page-flags.h in
  * files which need it (119 of them)
@@ -309,41 +313,22 @@ struct page {
 
 extern void FASTCALL(__page_cache_release(struct page *));
 
-#ifdef CONFIG_HUGETLB_PAGE
-
-static inline int page_count(struct page *p)
+static inline int page_count(struct page *page)
 {
-        if (PageCompound(p))
-                p = (struct page *)p->private;
-        return atomic_read(&(p)->_count) + 1;
+        if (PageCompound(page))
+                page = (struct page *)page_private(page);
+        return atomic_read(&page->_count) + 1;
 }
 
 static inline void get_page(struct page *page)
 {
         if (unlikely(PageCompound(page)))
-                page = (struct page *)page->private;
+                page = (struct page *)page_private(page);
         atomic_inc(&page->_count);
 }
 
 void put_page(struct page *page);
 
-#else           /* CONFIG_HUGETLB_PAGE */
-
-#define page_count(p)           (atomic_read(&(p)->_count) + 1)
-
-static inline void get_page(struct page *page)
-{
-        atomic_inc(&page->_count);
-}
-
-static inline void put_page(struct page *page)
-{
-        if (!PageReserved(page) && put_page_testzero(page))
-                __page_cache_release(page);
-}
-
-#endif          /* CONFIG_HUGETLB_PAGE */
-
 /*
  * Multiple processes may "see" the same page. E.g. for untouched
  * mappings of /dev/null, all processes see the same page full of
@@ -427,7 +412,7 @@ static inline void put_page(struct page *page)
 #endif
 
 /* Page flags: | [SECTION] | [NODE] | ZONE | ... | FLAGS | */
-#define SECTIONS_PGOFF          ((sizeof(page_flags_t)*8) - SECTIONS_WIDTH)
+#define SECTIONS_PGOFF          ((sizeof(unsigned long)*8) - SECTIONS_WIDTH)
 #define NODES_PGOFF             (SECTIONS_PGOFF - NODES_WIDTH)
 #define ZONES_PGOFF             (NODES_PGOFF - ZONES_WIDTH)
 
@@ -587,7 +572,7 @@ static inline int PageAnon(struct page *page)
 static inline pgoff_t page_index(struct page *page)
 {
         if (unlikely(PageSwapCache(page)))
-                return page->private;
+                return page_private(page);
         return page->index;
 }
 
@@ -680,9 +665,10 @@ struct zap_details {
         unsigned long truncate_count;           /* Compare vm_truncate_count */
 };
 
+struct page *vm_normal_page(struct vm_area_struct *, unsigned long, pte_t);
 unsigned long zap_page_range(struct vm_area_struct *vma, unsigned long address,
                 unsigned long size, struct zap_details *);
-unsigned long unmap_vmas(struct mmu_gather **tlb, struct mm_struct *mm,
+unsigned long unmap_vmas(struct mmu_gather **tlb,
                 struct vm_area_struct *start_vma, unsigned long start_addr,
                 unsigned long end_addr, unsigned long *nr_accounted,
                 struct zap_details *);
@@ -704,10 +690,6 @@ static inline void unmap_shared_mapping_range(struct address_space *mapping,
 }
 
 extern int vmtruncate(struct inode * inode, loff_t offset);
-extern pud_t *FASTCALL(__pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address));
-extern pmd_t *FASTCALL(__pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address));
-extern pte_t *FASTCALL(pte_alloc_kernel(struct mm_struct *mm, pmd_t *pmd, unsigned long address));
-extern pte_t *FASTCALL(pte_alloc_map(struct mm_struct *mm, pmd_t *pmd, unsigned long address));
 extern int install_page(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, struct page *page, pgprot_t prot);
 extern int install_file_pte(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, unsigned long pgoff, pgprot_t prot);
 extern int __handle_mm_fault(struct mm_struct *mm,struct vm_area_struct *vma, unsigned long address, int write_access);
@@ -723,6 +705,7 @@ void install_arg_page(struct vm_area_struct *, struct page *, unsigned long);
 
 int get_user_pages(struct task_struct *tsk, struct mm_struct *mm, unsigned long start,
                 int len, int write, int force, struct page **pages, struct vm_area_struct **vmas);
+void print_bad_pte(struct vm_area_struct *, pte_t, unsigned long);
 
 int __set_page_dirty_buffers(struct page *page);
 int __set_page_dirty_nobuffers(struct page *page);
@@ -747,7 +730,7 @@ extern unsigned long do_mremap(unsigned long addr,
  * The callback will be passed nr_to_scan == 0 when the VM is querying the
  * cache size, so a fastpath for that case is appropriate.
  */
-typedef int (*shrinker_t)(int nr_to_scan, unsigned int gfp_mask);
+typedef int (*shrinker_t)(int nr_to_scan, gfp_t gfp_mask);
 
 /*
  * Add an aging callback.  The int is the number of 'seeks' it takes
@@ -759,38 +742,85 @@ struct shrinker;
 extern struct shrinker *set_shrinker(int, shrinker_t);
 extern void remove_shrinker(struct shrinker *shrinker);
 
-/*
- * On a two-level or three-level page table, this ends up being trivial. Thus
- * the inlining and the symmetry break with pte_alloc_map() that does all
- * of this out-of-line.
- */
+extern pte_t *FASTCALL(get_locked_pte(struct mm_struct *mm, unsigned long addr, spinlock_t **ptl));
+
+int __pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address);
+int __pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address);
+int __pte_alloc(struct mm_struct *mm, pmd_t *pmd, unsigned long address);
+int __pte_alloc_kernel(pmd_t *pmd, unsigned long address);
+
 /*
  * The following ifdef needed to get the 4level-fixup.h header to work.
  * Remove it when 4level-fixup.h has been removed.
  */
-#ifdef CONFIG_MMU
-#ifndef __ARCH_HAS_4LEVEL_HACK 
+#if defined(CONFIG_MMU) && !defined(__ARCH_HAS_4LEVEL_HACK)
 static inline pud_t *pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address)
 {
-        if (pgd_none(*pgd))
-                return __pud_alloc(mm, pgd, address);
-        return pud_offset(pgd, address);
+        return (unlikely(pgd_none(*pgd)) && __pud_alloc(mm, pgd, address))?
+                NULL: pud_offset(pgd, address);
 }
 
 static inline pmd_t *pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address)
 {
-        if (pud_none(*pud))
-                return __pmd_alloc(mm, pud, address);
-        return pmd_offset(pud, address);
+        return (unlikely(pud_none(*pud)) && __pmd_alloc(mm, pud, address))?
+                NULL: pmd_offset(pud, address);
 }
-#endif
-#endif /* CONFIG_MMU */
+#endif /* CONFIG_MMU && !__ARCH_HAS_4LEVEL_HACK */
+
+#if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
+/*
+ * We tuck a spinlock to guard each pagetable page into its struct page,
+ * at page->private, with BUILD_BUG_ON to make sure that this will not
+ * overflow into the next struct page (as it might with DEBUG_SPINLOCK).
+ * When freeing, reset page->mapping so free_pages_check won't complain.
+ */
+#define __pte_lockptr(page)     &((page)->u.ptl)
+#define pte_lock_init(_page)    do {                                    \
+        spin_lock_init(__pte_lockptr(_page));                           \
+} while (0)
+#define pte_lock_deinit(page)   ((page)->mapping = NULL)
+#define pte_lockptr(mm, pmd)    ({(void)(mm); __pte_lockptr(pmd_page(*(pmd)));})
+#else
+/*
+ * We use mm->page_table_lock to guard all pagetable pages of the mm.
+ */
+#define pte_lock_init(page)     do {} while (0)
+#define pte_lock_deinit(page)   do {} while (0)
+#define pte_lockptr(mm, pmd)    ({(void)(pmd); &(mm)->page_table_lock;})
+#endif /* NR_CPUS < CONFIG_SPLIT_PTLOCK_CPUS */
+
+#define pte_offset_map_lock(mm, pmd, address, ptlp)     \
+({                                                      \
+        spinlock_t *__ptl = pte_lockptr(mm, pmd);       \
+        pte_t *__pte = pte_offset_map(pmd, address);    \
+        *(ptlp) = __ptl;                                \
+        spin_lock(__ptl);                               \
+        __pte;                                          \
+})
+
+#define pte_unmap_unlock(pte, ptl)      do {            \
+        spin_unlock(ptl);                               \
+        pte_unmap(pte);                                 \
+} while (0)
+
+#define pte_alloc_map(mm, pmd, address)                 \
+        ((unlikely(!pmd_present(*(pmd))) && __pte_alloc(mm, pmd, address))? \
+                NULL: pte_offset_map(pmd, address))
+
+#define pte_alloc_map_lock(mm, pmd, address, ptlp)      \
+        ((unlikely(!pmd_present(*(pmd))) && __pte_alloc(mm, pmd, address))? \
+                NULL: pte_offset_map_lock(mm, pmd, address, ptlp))
+
+#define pte_alloc_kernel(pmd, address)                  \
+        ((unlikely(!pmd_present(*(pmd))) && __pte_alloc_kernel(pmd, address))? \
+                NULL: pte_offset_kernel(pmd, address))
 
 extern void free_area_init(unsigned long * zones_size);
 extern void free_area_init_node(int nid, pg_data_t *pgdat,
         unsigned long * zones_size, unsigned long zone_start_pfn, 
         unsigned long *zholes_size);
 extern void memmap_init_zone(unsigned long, int, unsigned long, unsigned long);
+extern void setup_per_zone_pages_min(void);
 extern void mem_init(void);
 extern void show_mem(void);
 extern void si_meminfo(struct sysinfo * val);
@@ -834,6 +864,7 @@ extern int split_vma(struct mm_struct *,
 extern int insert_vm_struct(struct mm_struct *, struct vm_area_struct *);
 extern void __vma_link_rb(struct mm_struct *, struct vm_area_struct *,
         struct rb_node **, struct rb_node *);
+extern void unlink_file_vma(struct vm_area_struct *);
 extern struct vm_area_struct *copy_vma(struct vm_area_struct **,
         unsigned long addr, unsigned long len, pgoff_t pgoff);
 extern void exit_mmap(struct mm_struct *);
@@ -881,20 +912,23 @@ int write_one_page(struct page *page, int wait);
                                          * turning readahead off */
 
 int do_page_cache_readahead(struct address_space *mapping, struct file *filp,
-                        unsigned long offset, unsigned long nr_to_read);
+                        pgoff_t offset, unsigned long nr_to_read);
 int force_page_cache_readahead(struct address_space *mapping, struct file *filp,
-                        unsigned long offset, unsigned long nr_to_read);
-unsigned long  page_cache_readahead(struct address_space *mapping,
+                        pgoff_t offset, unsigned long nr_to_read);
+unsigned long page_cache_readahead(struct address_space *mapping,
                           struct file_ra_state *ra,
                           struct file *filp,
-                          unsigned long offset,
+                          pgoff_t offset,
                           unsigned long size);
 void handle_ra_miss(struct address_space *mapping, 
                     struct file_ra_state *ra, pgoff_t offset);
 unsigned long max_sane_readahead(unsigned long nr);
 
 /* Do stack extension */
-extern int expand_stack(struct vm_area_struct * vma, unsigned long address);
+extern int expand_stack(struct vm_area_struct *vma, unsigned long address);
+#ifdef CONFIG_IA64
+extern int expand_upwards(struct vm_area_struct *vma, unsigned long address);
+#endif
 
 /* Look up the first VMA which satisfies  addr < vm_end,  NULL if none. */
 extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);
@@ -917,40 +951,29 @@ static inline unsigned long vma_pages(struct vm_area_struct *vma)
         return (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
 }
 
-extern struct vm_area_struct *find_extend_vma(struct mm_struct *mm, unsigned long addr);
+struct vm_area_struct *find_extend_vma(struct mm_struct *, unsigned long addr);
+struct page *vmalloc_to_page(void *addr);
+unsigned long vmalloc_to_pfn(void *addr);
+int remap_pfn_range(struct vm_area_struct *, unsigned long addr,
+                        unsigned long pfn, unsigned long size, pgprot_t);
+int vm_insert_page(struct vm_area_struct *, unsigned long addr, struct page *);
 
-extern struct page * vmalloc_to_page(void *addr);
-extern unsigned long vmalloc_to_pfn(void *addr);
-extern struct page * follow_page(struct mm_struct *mm, unsigned long address,
-                int write);
-extern int check_user_page_readable(struct mm_struct *mm, unsigned long address);
-int remap_pfn_range(struct vm_area_struct *, unsigned long,
-                unsigned long, unsigned long, pgprot_t);
+struct page *follow_page(struct vm_area_struct *, unsigned long address,
+                        unsigned int foll_flags);
+#define FOLL_WRITE      0x01    /* check pte is writable */
+#define FOLL_TOUCH      0x02    /* mark page accessed */
+#define FOLL_GET        0x04    /* do get_page on page */
+#define FOLL_ANON       0x08    /* give ZERO_PAGE if no pgtable */
 
 #ifdef CONFIG_PROC_FS
-void __vm_stat_account(struct mm_struct *, unsigned long, struct file *, long);
+void vm_stat_account(struct mm_struct *, unsigned long, struct file *, long);
 #else
-static inline void __vm_stat_account(struct mm_struct *mm,
+static inline void vm_stat_account(struct mm_struct *mm,
                         unsigned long flags, struct file *file, long pages)
 {
 }
 #endif /* CONFIG_PROC_FS */
 
-static inline void vm_stat_account(struct vm_area_struct *vma)
-{
-        __vm_stat_account(vma->vm_mm, vma->vm_flags, vma->vm_file,
-                                                        vma_pages(vma));
-}
-
-static inline void vm_stat_unaccount(struct vm_area_struct *vma)
-{
-        __vm_stat_account(vma->vm_mm, vma->vm_flags, vma->vm_file,
-                                                        -vma_pages(vma));
-}
-
-/* update per process rss and vm hiwater data */
-extern void update_mem_hiwater(struct task_struct *tsk);
-
 #ifndef CONFIG_DEBUG_PAGEALLOC
 static inline void
 kernel_map_pages(struct page *page, int numpages, int enable)
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index 1ab78e8d6c53..aef6042f8f0b 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -50,7 +50,7 @@ struct mmc_command {
 #define MMC_ERR_INVALID 5
 
         struct mmc_data         *data;          /* data segment associated with cmd */
-        struct mmc_request      *mrq;           /* assoicated request */
+        struct mmc_request      *mrq;           /* associated request */
 };
 
 struct mmc_data {
@@ -68,7 +68,7 @@ struct mmc_data {
         unsigned int            bytes_xfered;
 
         struct mmc_command      *stop;          /* stop command */
-        struct mmc_request      *mrq;           /* assoicated request */
+        struct mmc_request      *mrq;           /* associated request */
 
         unsigned int            sg_len;         /* size of scatter list */
         struct scatterlist      *sg;            /* I/O scatter list */
diff --git a/include/linux/mmc/protocol.h b/include/linux/mmc/protocol.h
index f819cae92266..a14dc306545b 100644
--- a/include/linux/mmc/protocol.h
+++ b/include/linux/mmc/protocol.h
@@ -63,7 +63,7 @@
   /* 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                37   /* ac                      R1b */
+#define MMC_ERASE                38   /* ac                      R1b */
 
   /* class 9 */
 #define MMC_FAST_IO              39   /* ac   <Complex>          R4  */
@@ -74,7 +74,7 @@
 
   /* class 8 */
 #define MMC_APP_CMD              55   /* ac   [31:16] RCA        R1  */
-#define MMC_GEN_CMD              56   /* adtc [0] RD/WR          R1b */
+#define MMC_GEN_CMD              56   /* adtc [0] RD/WR          R1  */
 
 /* SD commands                           type  argument     response */
   /* class 8 */
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 5ed471b58f4f..9f22090df7dd 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -12,6 +12,7 @@
 #include <linux/threads.h>
 #include <linux/numa.h>
 #include <linux/init.h>
+#include <linux/seqlock.h>
 #include <asm/atomic.h>
 
 /* Free memory management - zoned buddy allocator.  */
@@ -70,10 +71,11 @@ struct per_cpu_pageset {
 #endif
 
 #define ZONE_DMA                0
-#define ZONE_NORMAL             1
-#define ZONE_HIGHMEM            2
+#define ZONE_DMA32              1
+#define ZONE_NORMAL             2
+#define ZONE_HIGHMEM            3
 
-#define MAX_NR_ZONES            3       /* Sync this with ZONES_SHIFT */
+#define MAX_NR_ZONES            4       /* Sync this with ZONES_SHIFT */
 #define ZONES_SHIFT             2       /* ceil(log2(MAX_NR_ZONES)) */
 
 
@@ -89,27 +91,18 @@ struct per_cpu_pageset {
  * will be a maximum of 4 (2 ** 2) zonelists, for 3 modifiers there will
  * be 8 (2 ** 3) zonelists.  GFP_ZONETYPES defines the number of possible
  * combinations of zone modifiers in "zone modifier space".
+ *
+ * NOTE! Make sure this matches the zones in <linux/gfp.h>
  */
-#define GFP_ZONEMASK    0x03
-/*
- * As an optimisation any zone modifier bits which are only valid when
- * no other zone modifier bits are set (loners) should be placed in
- * the highest order bits of this field.  This allows us to reduce the
- * extent of the zonelists thus saving space.  For example in the case
- * of three zone modifier bits, we could require up to eight zonelists.
- * If the left most zone modifier is a "loner" then the highest valid
- * zonelist would be four allowing us to allocate only five zonelists.
- * Use the first form when the left most bit is not a "loner", otherwise
- * use the second.
- */
-/* #define GFP_ZONETYPES        (GFP_ZONEMASK + 1) */           /* Non-loner */
-#define GFP_ZONETYPES   ((GFP_ZONEMASK + 1) / 2 + 1)            /* Loner */
+#define GFP_ZONEMASK    0x07
+#define GFP_ZONETYPES   5
 
 /*
  * On machines where it is needed (eg PCs) we divide physical memory
- * into multiple physical zones. On a PC we have 3 zones:
+ * into multiple physical zones. On a PC we have 4 zones:
  *
  * ZONE_DMA       < 16 MB       ISA DMA capable memory
+ * ZONE_DMA32        0 MB       Empty
  * ZONE_NORMAL  16-896 MB       direct mapped by the kernel
  * ZONE_HIGHMEM  > 896 MB       only page cache and user processes
  */
@@ -137,6 +130,10 @@ struct zone {
          * free areas of different sizes
          */
         spinlock_t              lock;
+#ifdef CONFIG_MEMORY_HOTPLUG
+        /* see spanned/present_pages for more description */
+        seqlock_t               span_seqlock;
+#endif
         struct free_area        free_area[MAX_ORDER];
 
 
@@ -220,6 +217,16 @@ struct zone {
         /* zone_start_pfn == zone_start_paddr >> PAGE_SHIFT */
         unsigned long           zone_start_pfn;
 
+        /*
+         * zone_start_pfn, spanned_pages and present_pages are all
+         * protected by span_seqlock.  It is a seqlock because it has
+         * to be read outside of zone->lock, and it is done in the main
+         * allocator path.  But, it is written quite infrequently.
+         *
+         * The lock is declared along with zone->lock because it is
+         * frequently read in proximity to zone->lock.  It's good to
+         * give them a chance of being in the same cacheline.
+         */
         unsigned long           spanned_pages;  /* total size, including holes */
         unsigned long           present_pages;  /* amount of memory (excluding holes) */
 
@@ -273,6 +280,16 @@ typedef struct pglist_data {
         struct page *node_mem_map;
 #endif
         struct bootmem_data *bdata;
+#ifdef CONFIG_MEMORY_HOTPLUG
+        /*
+         * Must be held any time you expect node_start_pfn, node_present_pages
+         * or node_spanned_pages stay constant.  Holding this will also
+         * guarantee that any pfn_valid() stays that way.
+         *
+         * Nests above zone->lock and zone->size_seqlock.
+         */
+        spinlock_t node_size_lock;
+#endif
         unsigned long node_start_pfn;
         unsigned long node_present_pages; /* total number of physical pages */
         unsigned long node_spanned_pages; /* total size of physical page
@@ -293,6 +310,8 @@ typedef struct pglist_data {
 #endif
 #define nid_page_nr(nid, pagenr)        pgdat_page_nr(NODE_DATA(nid),(pagenr))
 
+#include <linux/memory_hotplug.h>
+
 extern struct pglist_data *pgdat_list;
 
 void __get_zone_counts(unsigned long *active, unsigned long *inactive,
@@ -302,7 +321,7 @@ void get_zone_counts(unsigned long *active, unsigned long *inactive,
 void build_all_zonelists(void);
 void wakeup_kswapd(struct zone *zone, int order);
 int zone_watermark_ok(struct zone *z, int order, unsigned long mark,
-                int alloc_type, int can_try_harder, int gfp_high);
+                int classzone_idx, int alloc_flags);
 
 #ifdef CONFIG_HAVE_MEMORY_PRESENT
 void memory_present(int nid, unsigned long start, unsigned long end);
@@ -406,7 +425,9 @@ int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, struct file *,
 
 #include <linux/topology.h>
 /* Returns the number of the current Node. */
+#ifndef numa_node_id
 #define numa_node_id()          (cpu_to_node(raw_smp_processor_id()))
+#endif
 
 #ifndef CONFIG_NEED_MULTIPLE_NODES
 
@@ -426,12 +447,12 @@ extern struct pglist_data contig_page_data;
 #include <asm/sparsemem.h>
 #endif
 
-#if BITS_PER_LONG == 32 || defined(ARCH_HAS_ATOMIC_UNSIGNED)
+#if BITS_PER_LONG == 32
 /*
- * with 32 bit page->flags field, we reserve 8 bits for node/zone info.
- * there are 3 zones (2 bits) and this leaves 8-2=6 bits for nodes.
+ * with 32 bit page->flags field, we reserve 9 bits for node/zone info.
+ * there are 4 zones (3 bits) and this leaves 9-3=6 bits for nodes.
  */
-#define FLAGS_RESERVED          8
+#define FLAGS_RESERVED          9
 
 #elif BITS_PER_LONG == 64
 /*
@@ -509,6 +530,7 @@ static inline struct mem_section *__nr_to_section(unsigned long nr)
                 return NULL;
         return &mem_section[SECTION_NR_TO_ROOT(nr)][nr & SECTION_ROOT_MASK];
 }
+extern int __section_nr(struct mem_section* ms);
 
 /*
  * We use the lower bits of the mem_map pointer to store
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 47da39ba3f03..7b08c11ec4cc 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -183,7 +183,7 @@ struct of_device_id
         char    name[32];
         char    type[32];
         char    compatible[128];
-#if __KERNEL__
+#ifdef __KERNEL__
         void    *data;
 #else
         kernel_ulong_t data;
@@ -209,10 +209,11 @@ struct pcmcia_device_id {
         /* for real multi-function devices */
         __u8            function;
 
-        /* for pseude multi-function devices */
+        /* for pseudo multi-function devices */
         __u8            device_no;
 
-        __u32           prod_id_hash[4];
+        __u32           prod_id_hash[4]
+                __attribute__((aligned(sizeof(__u32))));
 
         /* not matched against in kernelspace*/
 #ifdef __KERNEL__
@@ -243,4 +244,9 @@ struct pcmcia_device_id {
 #define PCMCIA_DEV_ID_MATCH_FAKE_CIS    0x0200
 #define PCMCIA_DEV_ID_MATCH_ANONYMOUS   0x0400
 
+/* I2C */
+struct i2c_device_id {
+        __u16 id;
+};
+
 #endif /* LINUX_MOD_DEVICETABLE_H */
diff --git a/include/linux/module.h b/include/linux/module.h
index f05372b7fe77..84d75f3a8aca 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -554,7 +554,9 @@ static inline void MODULE_PARM_(void) { }
 #ifdef MODULE
 /* DEPRECATED: Do not use. */
 #define MODULE_PARM(var,type)                                               \
-struct obsolete_modparm __parm_##var __attribute__((section("__obsparm"))) = \
+extern struct obsolete_modparm __parm_##var \
+__attribute__((section("__obsparm"))); \
+struct obsolete_modparm __parm_##var = \
 { __stringify(var), type, &MODULE_PARM_ }; \
 __MODULE_PARM_TYPE(var, type);
 #else
diff --git a/include/linux/mount.h b/include/linux/mount.h
index f8f39937e301..dd4e83eba933 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -17,12 +17,14 @@
 #include <linux/spinlock.h>
 #include <asm/atomic.h>
 
-#define MNT_NOSUID      1
-#define MNT_NODEV       2
-#define MNT_NOEXEC      4
+#define MNT_NOSUID      0x01
+#define MNT_NODEV       0x02
+#define MNT_NOEXEC      0x04
+#define MNT_SHARED      0x10    /* if the vfsmount is a shared mount */
+#define MNT_UNBINDABLE  0x20    /* if the vfsmount is a unbindable mount */
+#define MNT_PNODE_MASK  0x30    /* propogation flag mask */
 
-struct vfsmount
-{
+struct vfsmount {
         struct list_head mnt_hash;
         struct vfsmount *mnt_parent;    /* fs we are mounted on */
         struct dentry *mnt_mountpoint;  /* dentry of mountpoint */
@@ -36,7 +38,12 @@ struct vfsmount
         char *mnt_devname;              /* Name of device e.g. /dev/dsk/hda1 */
         struct list_head mnt_list;
         struct list_head mnt_expire;    /* link in fs-specific expiry list */
+        struct list_head mnt_share;     /* circular list of shared mounts */
+        struct list_head mnt_slave_list;/* list of slave mounts */
+        struct list_head mnt_slave;     /* slave list entry */
+        struct vfsmount *mnt_master;    /* slave is on master->mnt_slave_list */
         struct namespace *mnt_namespace; /* containing namespace */
+        int mnt_pinned;
 };
 
 static inline struct vfsmount *mntget(struct vfsmount *mnt)
@@ -46,15 +53,9 @@ static inline struct vfsmount *mntget(struct vfsmount *mnt)
         return mnt;
 }
 
-extern void __mntput(struct vfsmount *mnt);
-
-static inline void mntput_no_expire(struct vfsmount *mnt)
-{
-        if (mnt) {
-                if (atomic_dec_and_test(&mnt->mnt_count))
-                        __mntput(mnt);
-        }
-}
+extern void mntput_no_expire(struct vfsmount *mnt);
+extern void mnt_pin(struct vfsmount *mnt);
+extern void mnt_unpin(struct vfsmount *mnt);
 
 static inline void mntput(struct vfsmount *mnt)
 {
diff --git a/include/linux/msdos_fs.h b/include/linux/msdos_fs.h
index 9a3d27257984..941da5c016a0 100644
--- a/include/linux/msdos_fs.h
+++ b/include/linux/msdos_fs.h
@@ -282,6 +282,17 @@ static inline u8 fat_attr(struct inode *inode)
                 MSDOS_I(inode)->i_attrs;
 }
 
+static inline unsigned char fat_checksum(const __u8 *name)
+{
+        unsigned char s = name[0];
+        s = (s<<7) + (s>>1) + name[1];  s = (s<<7) + (s>>1) + name[2];
+        s = (s<<7) + (s>>1) + name[3];  s = (s<<7) + (s>>1) + name[4];
+        s = (s<<7) + (s>>1) + name[5];  s = (s<<7) + (s>>1) + name[6];
+        s = (s<<7) + (s>>1) + name[7];  s = (s<<7) + (s>>1) + name[8];
+        s = (s<<7) + (s>>1) + name[9];  s = (s<<7) + (s>>1) + name[10];
+        return s;
+}
+
 static inline sector_t fat_clus_to_blknr(struct msdos_sb_info *sbi, int clus)
 {
         return ((sector_t)clus - FAT_START_ENT) * sbi->sec_per_clus
diff --git a/include/linux/mtd/bbm.h b/include/linux/mtd/bbm.h
new file mode 100644
index 000000000000..7a7fbe87fef0
--- /dev/null
+++ b/include/linux/mtd/bbm.h
@@ -0,0 +1,122 @@
+/*
+ *  linux/include/linux/mtd/bbm.h
+ *
+ *  NAND family Bad Block Management (BBM) header file
+ *    - Bad Block Table (BBT) implementation
+ *
+ *  Copyright (c) 2005 Samsung Electronics
+ *  Kyungmin Park <kyungmin.park@samsung.com>
+ *
+ *  Copyright (c) 2000-2005
+ *  Thomas Gleixner <tglx@linuxtronix.de>
+ *
+ */
+#ifndef __LINUX_MTD_BBM_H
+#define __LINUX_MTD_BBM_H
+
+/* The maximum number of NAND chips in an array */
+#define NAND_MAX_CHIPS          8
+
+/**
+ * struct nand_bbt_descr - bad block table descriptor
+ * @param options       options for this descriptor
+ * @param pages         the page(s) where we find the bbt, used with
+ *                      option BBT_ABSPAGE when bbt is searched,
+ *                      then we store the found bbts pages here.
+ *                      Its an array and supports up to 8 chips now
+ * @param offs          offset of the pattern in the oob area of the page
+ * @param veroffs       offset of the bbt version counter in the oob are of the page
+ * @param version       version read from the bbt page during scan
+ * @param len           length of the pattern, if 0 no pattern check is performed
+ * @param maxblocks     maximum number of blocks to search for a bbt. This number of
+ *                      blocks is reserved at the end of the device
+ *                      where the tables are written.
+ * @param reserved_block_code   if non-0, this pattern denotes a reserved
+ *                      (rather than bad) block in the stored bbt
+ * @param pattern       pattern to identify bad block table or factory marked
+ *                      good / bad blocks, can be NULL, if len = 0
+ *
+ * Descriptor for the bad block table marker and the descriptor for the
+ * pattern which identifies good and bad blocks. The assumption is made
+ * that the pattern and the version count are always located in the oob area
+ * of the first block.
+ */
+struct nand_bbt_descr {
+        int options;
+        int pages[NAND_MAX_CHIPS];
+        int offs;
+        int veroffs;
+        uint8_t version[NAND_MAX_CHIPS];
+        int len;
+        int maxblocks;
+        int reserved_block_code;
+        uint8_t *pattern;
+};
+
+/* Options for the bad block table descriptors */
+
+/* The number of bits used per block in the bbt on the device */
+#define NAND_BBT_NRBITS_MSK     0x0000000F
+#define NAND_BBT_1BIT           0x00000001
+#define NAND_BBT_2BIT           0x00000002
+#define NAND_BBT_4BIT           0x00000004
+#define NAND_BBT_8BIT           0x00000008
+/* The bad block table is in the last good block of the device */
+#define NAND_BBT_LASTBLOCK      0x00000010
+/* The bbt is at the given page, else we must scan for the bbt */
+#define NAND_BBT_ABSPAGE        0x00000020
+/* The bbt is at the given page, else we must scan for the bbt */
+#define NAND_BBT_SEARCH         0x00000040
+/* bbt is stored per chip on multichip devices */
+#define NAND_BBT_PERCHIP        0x00000080
+/* bbt has a version counter at offset veroffs */
+#define NAND_BBT_VERSION        0x00000100
+/* Create a bbt if none axists */
+#define NAND_BBT_CREATE         0x00000200
+/* Search good / bad pattern through all pages of a block */
+#define NAND_BBT_SCANALLPAGES   0x00000400
+/* Scan block empty during good / bad block scan */
+#define NAND_BBT_SCANEMPTY      0x00000800
+/* Write bbt if neccecary */
+#define NAND_BBT_WRITE          0x00001000
+/* Read and write back block contents when writing bbt */
+#define NAND_BBT_SAVECONTENT    0x00002000
+/* Search good / bad pattern on the first and the second page */
+#define NAND_BBT_SCAN2NDPAGE    0x00004000
+
+/* The maximum number of blocks to scan for a bbt */
+#define NAND_BBT_SCAN_MAXBLOCKS 4
+
+/*
+ * Constants for oob configuration
+ */
+#define ONENAND_BADBLOCK_POS    0
+
+/**
+ * struct bbt_info - [GENERIC] Bad Block Table data structure
+ * @param bbt_erase_shift       [INTERN] number of address bits in a bbt entry
+ * @param badblockpos           [INTERN] position of the bad block marker in the oob area
+ * @param bbt                   [INTERN] bad block table pointer
+ * @param badblock_pattern      [REPLACEABLE] bad block scan pattern used for initial bad block scan
+ * @param priv                  [OPTIONAL] pointer to private bbm date
+ */
+struct bbm_info {
+        int bbt_erase_shift;
+        int badblockpos;
+        int options;
+
+        uint8_t *bbt;
+
+        int (*isbad_bbt)(struct mtd_info *mtd, loff_t ofs, int allowbbt);
+
+        /* TODO Add more NAND specific fileds */
+        struct nand_bbt_descr *badblock_pattern;
+
+        void *priv;
+};
+
+/* OneNAND BBT interface */
+extern int onenand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd);
+extern int onenand_default_bbt(struct mtd_info *mtd);
+
+#endif  /* __LINUX_MTD_BBM_H */
diff --git a/include/linux/mtd/blktrans.h b/include/linux/mtd/blktrans.h
index 4ebc2e5a16e2..f46afec6fbf8 100644
--- a/include/linux/mtd/blktrans.h
+++ b/include/linux/mtd/blktrans.h
@@ -1,5 +1,5 @@
 /*
- * $Id: blktrans.h,v 1.5 2003/06/23 12:00:08 dwmw2 Exp $
+ * $Id: blktrans.h,v 1.6 2005/11/07 11:14:54 gleixner Exp $
  *
  * (C) 2003 David Woodhouse <dwmw2@infradead.org>
  *
@@ -67,6 +67,6 @@ extern int register_mtd_blktrans(struct mtd_blktrans_ops *tr);
 extern int deregister_mtd_blktrans(struct mtd_blktrans_ops *tr);
 extern int add_mtd_blktrans_dev(struct mtd_blktrans_dev *dev);
 extern int del_mtd_blktrans_dev(struct mtd_blktrans_dev *dev);
-                                 
+
 
 #endif /* __MTD_TRANS_H__ */
diff --git a/include/linux/mtd/cfi.h b/include/linux/mtd/cfi.h
index e6b6a1c66bd5..23a568910341 100644
--- a/include/linux/mtd/cfi.h
+++ b/include/linux/mtd/cfi.h
@@ -1,14 +1,13 @@
 
-/* Common Flash Interface structures 
+/* Common Flash Interface structures
  * See http://support.intel.com/design/flash/technote/index.htm
- * $Id: cfi.h,v 1.54 2005/06/06 23:04:36 tpoynor Exp $
+ * $Id: cfi.h,v 1.57 2005/11/15 23:28:17 tpoynor Exp $
  */
 
 #ifndef __MTD_CFI_H__
 #define __MTD_CFI_H__
 
 #include <linux/config.h>
-#include <linux/version.h>
 #include <linux/delay.h>
 #include <linux/types.h>
 #include <linux/interrupt.h>
@@ -82,8 +81,8 @@ static inline int cfi_interleave_supported(int i)
 }
 
 
-/* NB: these values must represents the number of bytes needed to meet the 
- *     device type (x8, x16, x32).  Eg. a 32 bit device is 4 x 8 bytes. 
+/* NB: these values must represents the number of bytes needed to meet the
+ *     device type (x8, x16, x32).  Eg. a 32 bit device is 4 x 8 bytes.
  *     These numbers are used in calculations.
  */
 #define CFI_DEVICETYPE_X8  (8 / 8)
@@ -173,6 +172,15 @@ struct cfi_intelext_regioninfo {
         struct cfi_intelext_blockinfo BlockTypes[1];
 } __attribute__((packed));
 
+struct cfi_intelext_programming_regioninfo {
+        uint8_t  ProgRegShift;
+        uint8_t  Reserved1;
+        uint8_t  ControlValid;
+        uint8_t  Reserved2;
+        uint8_t  ControlInvalid;
+        uint8_t  Reserved3;
+} __attribute__((packed));
+
 /* Vendor-Specific PRI for AMD/Fujitsu Extended Command Set (0x0002) */
 
 struct cfi_pri_amdstd {
@@ -250,7 +258,7 @@ static inline uint32_t cfi_build_cmd_addr(uint32_t cmd_ofs, int interleave, int
 /*
  * Transforms the CFI command for the given geometry (bus width & interleave).
  * It looks too long to be inline, but in the common case it should almost all
- * get optimised away. 
+ * get optimised away.
  */
 static inline map_word cfi_build_cmd(u_long cmd, struct map_info *map, struct cfi_private *cfi)
 {
@@ -259,7 +267,7 @@ static inline map_word cfi_build_cmd(u_long cmd, struct map_info *map, struct cf
         unsigned long onecmd;
         int i;
 
-        /* We do it this way to give the compiler a fighting chance 
+        /* We do it this way to give the compiler a fighting chance
            of optimising away all the crap for 'bankwidth' larger than
            an unsigned long, in the common case where that support is
            disabled */
@@ -270,7 +278,7 @@ static inline map_word cfi_build_cmd(u_long cmd, struct map_info *map, struct cf
                 wordwidth = map_bankwidth(map);
                 words_per_bus = 1;
         }
-        
+
         chip_mode = map_bankwidth(map) / cfi_interleave(cfi);
         chips_per_word = wordwidth * cfi_interleave(cfi) / map_bankwidth(map);
 
@@ -289,7 +297,7 @@ static inline map_word cfi_build_cmd(u_long cmd, struct map_info *map, struct cf
                 break;
         }
 
-        /* Now replicate it across the size of an unsigned long, or 
+        /* Now replicate it across the size of an unsigned long, or
            just to the bus width as appropriate */
         switch (chips_per_word) {
         default: BUG();
@@ -305,7 +313,7 @@ static inline map_word cfi_build_cmd(u_long cmd, struct map_info *map, struct cf
                 ;
         }
 
-        /* And finally, for the multi-word case, replicate it 
+        /* And finally, for the multi-word case, replicate it
            in all words in the structure */
         for (i=0; i < words_per_bus; i++) {
                 val.x[i] = onecmd;
@@ -316,14 +324,14 @@ static inline map_word cfi_build_cmd(u_long cmd, struct map_info *map, struct cf
 #define CMD(x)  cfi_build_cmd((x), map, cfi)
 
 
-static inline unsigned char cfi_merge_status(map_word val, struct map_info *map, 
+static inline unsigned long cfi_merge_status(map_word val, struct map_info *map,
                                            struct cfi_private *cfi)
 {
         int wordwidth, words_per_bus, chip_mode, chips_per_word;
         unsigned long onestat, res = 0;
         int i;
 
-        /* We do it this way to give the compiler a fighting chance 
+        /* We do it this way to give the compiler a fighting chance
            of optimising away all the crap for 'bankwidth' larger than
            an unsigned long, in the common case where that support is
            disabled */
@@ -334,7 +342,7 @@ static inline unsigned char cfi_merge_status(map_word val, struct map_info *map,
                 wordwidth = map_bankwidth(map);
                 words_per_bus = 1;
         }
-        
+
         chip_mode = map_bankwidth(map) / cfi_interleave(cfi);
         chips_per_word = wordwidth * cfi_interleave(cfi) / map_bankwidth(map);
 
@@ -418,6 +426,22 @@ static inline uint8_t cfi_read_query(struct map_info *map, uint32_t addr)
         }
 }
 
+static inline uint16_t cfi_read_query16(struct map_info *map, uint32_t addr)
+{
+        map_word val = map_read(map, addr);
+
+        if (map_bankwidth_is_1(map)) {
+                return val.x[0] & 0xff;
+        } else if (map_bankwidth_is_2(map)) {
+                return cfi16_to_cpu(val.x[0]);
+        } else {
+                /* No point in a 64-bit byteswap since that would just be
+                   swapping the responses from different chips, and we are
+                   only interested in one chip (a representative sample) */
+                return cfi32_to_cpu(val.x[0]);
+        }
+}
+
 static inline void cfi_udelay(int us)
 {
         if (us >= 1000) {
diff --git a/include/linux/mtd/doc2000.h b/include/linux/mtd/doc2000.h
index 953e64fb8ac5..386a52cf8b1b 100644
--- a/include/linux/mtd/doc2000.h
+++ b/include/linux/mtd/doc2000.h
@@ -1,12 +1,12 @@
-/* 
+/*
  * Linux driver for Disk-On-Chip devices
  *
- * Copyright (C) 1999 Machine Vision Holdings, Inc.   
+ * Copyright (C) 1999 Machine Vision Holdings, Inc.
  * Copyright (C) 2001-2003 David Woodhouse <dwmw2@infradead.org>
  * Copyright (C) 2002-2003 Greg Ungerer <gerg@snapgear.com>
  * Copyright (C) 2002-2003 SnapGear Inc
  *
- * $Id: doc2000.h,v 1.24 2005/01/05 12:40:38 dwmw2 Exp $ 
+ * $Id: doc2000.h,v 1.25 2005/11/07 11:14:54 gleixner Exp $
  *
  * Released under GPL
  */
@@ -75,10 +75,10 @@
 #define DoC_Mplus_CtrlConfirm           0x1076
 #define DoC_Mplus_Power                 0x1fff
 
-/* How to access the device? 
- * On ARM, it'll be mmap'd directly with 32-bit wide accesses. 
+/* How to access the device?
+ * On ARM, it'll be mmap'd directly with 32-bit wide accesses.
  * On PPC, it's mmap'd and 16-bit wide.
- * Others use readb/writeb 
+ * Others use readb/writeb
  */
 #if defined(__arm__)
 #define ReadDOC_(adr, reg)      ((unsigned char)(*(volatile __u32 *)(((unsigned long)adr)+((reg)<<2))))
@@ -172,7 +172,7 @@ struct DiskOnChip {
         unsigned long totlen;
         unsigned char ChipID; /* Type of DiskOnChip */
         int ioreg;
-        
+
         unsigned long mfr; /* Flash IDs - only one type of flash per device */
         unsigned long id;
         int chipshift;
@@ -180,10 +180,10 @@ struct DiskOnChip {
         char pageadrlen;
         char interleave; /* Internal interleaving - Millennium Plus style */
         unsigned long erasesize;
-        
+
         int curfloor;
         int curchip;
-        
+
         int numchips;
         struct Nand *chips;
         struct mtd_info *nextdoc;
diff --git a/include/linux/mtd/flashchip.h b/include/linux/mtd/flashchip.h
index 675776fa3e27..a293a3b78e05 100644
--- a/include/linux/mtd/flashchip.h
+++ b/include/linux/mtd/flashchip.h
@@ -1,12 +1,12 @@
 
-/* 
+/*
  * struct flchip definition
- * 
- * Contains information about the location and state of a given flash device 
+ *
+ * Contains information about the location and state of a given flash device
  *
  * (C) 2000 Red Hat. GPLd.
  *
- * $Id: flashchip.h,v 1.17 2005/03/14 18:27:15 bjd Exp $
+ * $Id: flashchip.h,v 1.18 2005/11/07 11:14:54 gleixner Exp $
  *
  */
 
@@ -15,11 +15,11 @@
 
 /* For spinlocks. sched.h includes spinlock.h from whichever directory it
  * happens to be in - so we don't have to care whether we're on 2.2, which
- * has asm/spinlock.h, or 2.4, which has linux/spinlock.h 
+ * has asm/spinlock.h, or 2.4, which has linux/spinlock.h
  */
 #include <linux/sched.h>
 
-typedef enum { 
+typedef enum {
         FL_READY,
         FL_STATUS,
         FL_CFI_QUERY,
@@ -45,7 +45,7 @@ typedef enum {
 
 
 
-/* NOTE: confusingly, this can be used to refer to more than one chip at a time, 
+/* NOTE: confusingly, this can be used to refer to more than one chip at a time,
    if they're interleaved.  This can even refer to individual partitions on
    the same physical chip when present. */
 
diff --git a/include/linux/mtd/ftl.h b/include/linux/mtd/ftl.h
index 3678459b4535..d99609113307 100644
--- a/include/linux/mtd/ftl.h
+++ b/include/linux/mtd/ftl.h
@@ -1,6 +1,6 @@
 /*
- * $Id: ftl.h,v 1.6 2003/01/24 13:20:04 dwmw2 Exp $
- * 
+ * $Id: ftl.h,v 1.7 2005/11/07 11:14:54 gleixner Exp $
+ *
  * Derived from (and probably identical to):
  * ftl.h 1.7 1999/10/25 20:23:17
  *
@@ -12,7 +12,7 @@
  * Software distributed under the License is distributed on an "AS IS"
  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  * the License for the specific language governing rights and
- * limitations under the License. 
+ * limitations under the License.
  *
  * The initial developer of the original code is David A. Hinds
  * <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
diff --git a/include/linux/mtd/gen_probe.h b/include/linux/mtd/gen_probe.h
index 3d7bdec14f97..256e7342ed1e 100644
--- a/include/linux/mtd/gen_probe.h
+++ b/include/linux/mtd/gen_probe.h
@@ -1,14 +1,14 @@
 /*
  * (C) 2001, 2001 Red Hat, Inc.
  * GPL'd
- * $Id: gen_probe.h,v 1.3 2004/10/20 22:10:33 dwmw2 Exp $
+ * $Id: gen_probe.h,v 1.4 2005/11/07 11:14:54 gleixner Exp $
  */
 
 #ifndef __LINUX_MTD_GEN_PROBE_H__
 #define __LINUX_MTD_GEN_PROBE_H__
 
 #include <linux/mtd/flashchip.h>
-#include <linux/mtd/map.h> 
+#include <linux/mtd/map.h>
 #include <linux/mtd/cfi.h>
 #include <linux/bitops.h>
 
diff --git a/include/linux/mtd/jedec.h b/include/linux/mtd/jedec.h
index 2ba0f700ddbc..9006feb218b9 100644
--- a/include/linux/mtd/jedec.h
+++ b/include/linux/mtd/jedec.h
@@ -1,13 +1,13 @@
 
 /* JEDEC Flash Interface.
- * This is an older type of interface for self programming flash. It is 
+ * This is an older type of interface for self programming flash. It is
  * commonly use in older AMD chips and is obsolete compared with CFI.
  * It is called JEDEC because the JEDEC association distributes the ID codes
  * for the chips.
  *
  * See the AMD flash databook for information on how to operate the interface.
  *
- * $Id: jedec.h,v 1.3 2003/05/21 11:51:01 dwmw2 Exp $
+ * $Id: jedec.h,v 1.4 2005/11/07 11:14:54 gleixner Exp $
  */
 
 #ifndef __LINUX_MTD_JEDEC_H__
@@ -33,16 +33,16 @@ struct jedec_flash_chip
    __u16 jedec;
    unsigned long size;
    unsigned long sectorsize;
-   
+
    // *(__u8*)(base + (adder << addrshift)) = data << datashift
    // Address size = size << addrshift
    unsigned long base;           // Byte 0 of the flash, will be unaligned
    unsigned int datashift;       // Useful for 32bit/16bit accesses
    unsigned int addrshift;
    unsigned long offset;         // linerized start. base==offset for unbanked, uninterleaved flash
-   
+
    __u32 capabilities;
-   
+
    // These markers are filled in by the flash_chip_scan function
    unsigned long start;
    unsigned long length;
@@ -51,16 +51,16 @@ struct jedec_flash_chip
 struct jedec_private
 {
    unsigned long size;         // Total size of all the devices
-   
+
    /* Bank handling. If sum(bank_fill) == size then this is linear flash.
       Otherwise the mapping has holes in it. bank_fill may be used to
-      find the holes, but in the common symetric case 
-      bank_fill[0] == bank_fill[*], thus addresses may be computed 
+      find the holes, but in the common symetric case
+      bank_fill[0] == bank_fill[*], thus addresses may be computed
       mathmatically. bank_fill must be powers of two */
    unsigned is_banked;
    unsigned long bank_fill[MAX_JEDEC_CHIPS];
-   
-   struct jedec_flash_chip chips[MAX_JEDEC_CHIPS];  
+
+   struct jedec_flash_chip chips[MAX_JEDEC_CHIPS];
 };
 
 #endif
diff --git a/include/linux/mtd/map.h b/include/linux/mtd/map.h
index 142963f01d29..fedfbc8a287f 100644
--- a/include/linux/mtd/map.h
+++ b/include/linux/mtd/map.h
@@ -1,6 +1,6 @@
 
 /* Overhauled routines for dealing with different mmap regions of flash */
-/* $Id: map.h,v 1.52 2005/05/25 10:29:41 gleixner Exp $ */
+/* $Id: map.h,v 1.54 2005/11/07 11:14:54 gleixner Exp $ */
 
 #ifndef __LINUX_MTD_MAP_H__
 #define __LINUX_MTD_MAP_H__
@@ -8,7 +8,10 @@
 #include <linux/config.h>
 #include <linux/types.h>
 #include <linux/list.h>
+#include <linux/string.h>
+
 #include <linux/mtd/compatmac.h>
+
 #include <asm/unaligned.h>
 #include <asm/system.h>
 #include <asm/io.h>
@@ -167,14 +170,14 @@ typedef union {
    to a chip probe routine -- either JEDEC or CFI probe or both -- via
    do_map_probe(). If a chip is recognised, the probe code will invoke the
    appropriate chip driver (if present) and return a struct mtd_info.
-   At which point, you fill in the mtd->module with your own module 
+   At which point, you fill in the mtd->module with your own module
    address, and register it with the MTD core code. Or you could partition
    it and register the partitions instead, or keep it for your own private
    use; whatever.
-   
+
    The mtd->priv field will point to the struct map_info, and any further
-   private data required by the chip driver is linked from the 
-   mtd->priv->fldrv_priv field. This allows the map driver to get at 
+   private data required by the chip driver is linked from the
+   mtd->priv->fldrv_priv field. This allows the map driver to get at
    the destructor function map->fldrv_destroy() when it's tired
    of living.
 */
@@ -211,7 +214,7 @@ struct map_info {
            If there is no cache to care about this can be set to NULL. */
         void (*inval_cache)(struct map_info *, unsigned long, ssize_t);
 
-        /* set_vpp() must handle being reentered -- enable, enable, disable 
+        /* set_vpp() must handle being reentered -- enable, enable, disable
            must leave it enabled. */
         void (*set_vpp)(struct map_info *, int);
 
@@ -350,7 +353,7 @@ static inline map_word map_word_ff(struct map_info *map)
 {
         map_word r;
         int i;
-        
+
         if (map_bankwidth(map) < MAP_FF_LIMIT) {
                 int bw = 8 * map_bankwidth(map);
                 r.x[0] = (1 << bw) - 1;
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
index c50c3f3927d9..b6f2fdae65c6 100644
--- a/include/linux/mtd/mtd.h
+++ b/include/linux/mtd/mtd.h
@@ -1,5 +1,5 @@
-/* 
- * $Id: mtd.h,v 1.59 2005/04/11 10:19:02 gleixner Exp $
+/*
+ * $Id: mtd.h,v 1.61 2005/11/07 11:14:54 gleixner Exp $
  *
  * Copyright (C) 1999-2003 David Woodhouse <dwmw2@infradead.org> et al.
  *
@@ -14,7 +14,6 @@
 #endif
 
 #include <linux/config.h>
-#include <linux/version.h>
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/uio.h>
@@ -72,7 +71,17 @@ struct mtd_info {
         u_int32_t oobsize;   // Amount of OOB data per block (e.g. 16)
         u_int32_t ecctype;
         u_int32_t eccsize;
-        
+
+        /*
+         * Reuse some of the above unused fields in the case of NOR flash
+         * with configurable programming regions to avoid modifying the
+         * user visible structure layout/size.  Only valid when the
+         * MTD_PROGRAM_REGIONS flag is set.
+         * (Maybe we should have an union for those?)
+         */
+#define MTD_PROGREGION_SIZE(mtd)  (mtd)->oobblock
+#define MTD_PROGREGION_CTRLMODE_VALID(mtd)  (mtd)->oobsize
+#define MTD_PROGREGION_CTRLMODE_INVALID(mtd)  (mtd)->ecctype
 
         // Kernel-only stuff starts here.
         char *name;
@@ -80,13 +89,13 @@ struct mtd_info {
 
         // oobinfo is a nand_oobinfo structure, which can be set by iotcl (MEMSETOOBINFO)
         struct nand_oobinfo oobinfo;
-        u_int32_t oobavail;  // Number of bytes in OOB area available for fs 
+        u_int32_t oobavail;  // Number of bytes in OOB area available for fs
 
         /* Data for variable erase regions. If numeraseregions is zero,
-         * it means that the whole device has erasesize as given above. 
+         * it means that the whole device has erasesize as given above.
          */
         int numeraseregions;
-        struct mtd_erase_region_info *eraseregions; 
+        struct mtd_erase_region_info *eraseregions;
 
         /* This really shouldn't be here. It can go away in 2.5 */
         u_int32_t bank_size;
@@ -109,10 +118,10 @@ struct mtd_info {
         int (*read_oob) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
         int (*write_oob) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf);
 
-        /* 
-         * Methods to access the protection register area, present in some 
+        /*
+         * Methods to access the protection register area, present in some
          * flash devices. The user data is one time programmable but the
-         * factory data is read only. 
+         * factory data is read only.
          */
         int (*get_fact_prot_info) (struct mtd_info *mtd, struct otp_info *buf, size_t len);
         int (*read_fact_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
@@ -123,14 +132,14 @@ struct mtd_info {
 
         /* kvec-based read/write methods. We need these especially for NAND flash,
            with its limited number of write cycles per erase.
-           NB: The 'count' parameter is the number of _vectors_, each of 
+           NB: The 'count' parameter is the number of _vectors_, each of
            which contains an (ofs, len) tuple.
         */
         int (*readv) (struct mtd_info *mtd, struct kvec *vecs, unsigned long count, loff_t from, size_t *retlen);
-        int (*readv_ecc) (struct mtd_info *mtd, struct kvec *vecs, unsigned long count, loff_t from, 
+        int (*readv_ecc) (struct mtd_info *mtd, struct kvec *vecs, unsigned long count, loff_t from,
                 size_t *retlen, u_char *eccbuf, struct nand_oobinfo *oobsel);
         int (*writev) (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count, loff_t to, size_t *retlen);
-        int (*writev_ecc) (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count, loff_t to, 
+        int (*writev_ecc) (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count, loff_t to,
                 size_t *retlen, u_char *eccbuf, struct nand_oobinfo *oobsel);
 
         /* Sync */
@@ -194,7 +203,7 @@ int default_mtd_readv(struct mtd_info *mtd, struct kvec *vecs,
 #define MTD_WRITEECC(mtd, args...) (*(mtd->write_ecc))(mtd, args)
 #define MTD_READOOB(mtd, args...) (*(mtd->read_oob))(mtd, args)
 #define MTD_WRITEOOB(mtd, args...) (*(mtd->write_oob))(mtd, args)
-#define MTD_SYNC(mtd) do { if (mtd->sync) (*(mtd->sync))(mtd);  } while (0) 
+#define MTD_SYNC(mtd) do { if (mtd->sync) (*(mtd->sync))(mtd);  } while (0)
 
 
 #ifdef CONFIG_MTD_PARTITIONS
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index 9b5b76217584..da5e67b3fc70 100644
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -5,7 +5,7 @@
  *                     Steven J. Hill <sjhill@realitydiluted.com>
  *                     Thomas Gleixner <tglx@linutronix.de>
  *
- * $Id: nand.h,v 1.73 2005/05/31 19:39:17 gleixner Exp $
+ * $Id: nand.h,v 1.74 2005/09/15 13:58:50 vwool Exp $
  *
  * 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
@@ -24,7 +24,7 @@
  *                      bat later if I did something naughty.
  *   10-11-2000 SJH     Added private NAND flash structure for driver
  *   10-24-2000 SJH     Added prototype for 'nand_scan' function
- *   10-29-2001 TG      changed nand_chip structure to support 
+ *   10-29-2001 TG      changed nand_chip structure to support
  *                      hardwarespecific function for accessing control lines
  *   02-21-2002 TG      added support for different read/write adress and
  *                      ready/busy line access function
@@ -36,21 +36,21 @@
  *                      CONFIG_MTD_NAND_ECC_JFFS2 is not set
  *   08-10-2002 TG      extensions to nand_chip structure to support HW-ECC
  *
- *   08-29-2002 tglx    nand_chip structure: data_poi for selecting 
+ *   08-29-2002 tglx    nand_chip structure: data_poi for selecting
  *                      internal / fs-driver buffer
  *                      support for 6byte/512byte hardware ECC
  *                      read_ecc, write_ecc extended for different oob-layout
  *                      oob layout selections: NAND_NONE_OOB, NAND_JFFS2_OOB,
  *                      NAND_YAFFS_OOB
  *  11-25-2002 tglx     Added Manufacturer code FUJITSU, NATIONAL
- *                      Split manufacturer and device ID structures 
+ *                      Split manufacturer and device ID structures
  *
  *  02-08-2004 tglx     added option field to nand structure for chip anomalities
  *  05-25-2004 tglx     added bad block table support, ST-MICRO manufacturer id
  *                      update of nand_chip structure description
- *  01-17-2005 dmarlin  added extended commands for AG-AND device and added option 
+ *  01-17-2005 dmarlin  added extended commands for AG-AND device and added option
  *                      for BBT_AUTO_REFRESH.
- *  01-20-2005 dmarlin  added optional pointer to hardware specific callback for 
+ *  01-20-2005 dmarlin  added optional pointer to hardware specific callback for
  *                      extra error status checks.
  */
 #ifndef __LINUX_MTD_NAND_H
@@ -120,8 +120,8 @@ extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_
 #define NAND_CMD_CACHEDPROG     0x15
 
 /* Extended commands for AG-AND device */
-/* 
- * Note: the command for NAND_CMD_DEPLETE1 is really 0x00 but 
+/*
+ * Note: the command for NAND_CMD_DEPLETE1 is really 0x00 but
  *       there is no way to distinguish that from NAND_CMD_READ0
  *       until the remaining sequence of commands has been completed
  *       so add a high order bit and mask it off in the command.
@@ -145,7 +145,7 @@ extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_
 #define NAND_STATUS_READY       0x40
 #define NAND_STATUS_WP          0x80
 
-/* 
+/*
  * Constants for ECC_MODES
  */
 
@@ -191,12 +191,12 @@ extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_
 #define NAND_CACHEPRG           0x00000008
 /* Chip has copy back function */
 #define NAND_COPYBACK           0x00000010
-/* AND Chip which has 4 banks and a confusing page / block 
+/* AND Chip which has 4 banks and a confusing page / block
  * assignment. See Renesas datasheet for further information */
 #define NAND_IS_AND             0x00000020
 /* Chip has a array of 4 pages which can be read without
  * additional ready /busy waits */
-#define NAND_4PAGE_ARRAY        0x00000040 
+#define NAND_4PAGE_ARRAY        0x00000040
 /* Chip requires that BBT is periodically rewritten to prevent
  * bits from adjacent blocks from 'leaking' in altering data.
  * This happens with the Renesas AG-AND chips, possibly others.  */
@@ -219,8 +219,8 @@ extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_
 /* Use a flash based bad block table. This option is passed to the
  * default bad block table function. */
 #define NAND_USE_FLASH_BBT      0x00010000
-/* The hw ecc generator provides a syndrome instead a ecc value on read 
- * This can only work if we have the ecc bytes directly behind the 
+/* The hw ecc generator provides a syndrome instead a ecc value on read
+ * This can only work if we have the ecc bytes directly behind the
  * data bytes. Applies for DOC and AG-AND Renesas HW Reed Solomon generators */
 #define NAND_HWECC_SYNDROME     0x00020000
 /* This option skips the bbt scan during initialization. */
@@ -244,6 +244,7 @@ typedef enum {
         FL_ERASING,
         FL_SYNCING,
         FL_CACHEDPRG,
+        FL_PM_SUSPENDED,
 } nand_state_t;
 
 /* Keep gcc happy */
@@ -251,7 +252,7 @@ struct nand_chip;
 
 /**
  * struct nand_hw_control - Control structure for hardware controller (e.g ECC generator) shared among independend devices
- * @lock:               protection lock  
+ * @lock:               protection lock
  * @active:             the mtd device which holds the controller currently
  * @wq:                 wait queue to sleep on if a NAND operation is in progress
  *                      used instead of the per chip wait queue when a hw controller is available
@@ -264,8 +265,8 @@ struct nand_hw_control {
 
 /**
  * struct nand_chip - NAND Private Flash Chip Data
- * @IO_ADDR_R:          [BOARDSPECIFIC] address to read the 8 I/O lines of the flash device 
- * @IO_ADDR_W:          [BOARDSPECIFIC] address to write the 8 I/O lines of the flash device 
+ * @IO_ADDR_R:          [BOARDSPECIFIC] address to read the 8 I/O lines of the flash device
+ * @IO_ADDR_W:          [BOARDSPECIFIC] address to write the 8 I/O lines of the flash device
  * @read_byte:          [REPLACEABLE] read one byte from the chip
  * @write_byte:         [REPLACEABLE] write one byte to the chip
  * @read_word:          [REPLACEABLE] read one word from the chip
@@ -288,7 +289,7 @@ struct nand_hw_control {
  *                      be provided if a hardware ECC is available
  * @erase_cmd:          [INTERN] erase command write function, selectable due to AND support
  * @scan_bbt:           [REPLACEABLE] function to scan bad block table
- * @eccmode:            [BOARDSPECIFIC] mode of ecc, see defines 
+ * @eccmode:            [BOARDSPECIFIC] mode of ecc, see defines
  * @eccsize:            [INTERN] databytes used per ecc-calculation
  * @eccbytes:           [INTERN] number of ecc bytes per ecc-calculation step
  * @eccsteps:           [INTERN] number of ecc calculation steps per page
@@ -300,7 +301,7 @@ struct nand_hw_control {
  * @phys_erase_shift:   [INTERN] number of address bits in a physical eraseblock
  * @bbt_erase_shift:    [INTERN] number of address bits in a bbt entry
  * @chip_shift:         [INTERN] number of address bits in one chip
- * @data_buf:           [INTERN] internal buffer for one page + oob 
+ * @data_buf:           [INTERN] internal buffer for one page + oob
  * @oob_buf:            [INTERN] oob buffer for one eraseblock
  * @oobdirty:           [INTERN] indicates that oob_buf must be reinitialized
  * @data_poi:           [INTERN] pointer to a data buffer
@@ -315,22 +316,22 @@ struct nand_hw_control {
  * @bbt:                [INTERN] bad block table pointer
  * @bbt_td:             [REPLACEABLE] bad block table descriptor for flash lookup
  * @bbt_md:             [REPLACEABLE] bad block table mirror descriptor
- * @badblock_pattern:   [REPLACEABLE] bad block scan pattern used for initial bad block scan 
+ * @badblock_pattern:   [REPLACEABLE] bad block scan pattern used for initial bad block scan
  * @controller:         [OPTIONAL] a pointer to a hardware controller structure which is shared among multiple independend devices
  * @priv:               [OPTIONAL] pointer to private chip date
- * @errstat:            [OPTIONAL] hardware specific function to perform additional error status checks 
+ * @errstat:            [OPTIONAL] hardware specific function to perform additional error status checks
  *                      (determine if errors are correctable)
  */
- 
+
 struct nand_chip {
         void  __iomem   *IO_ADDR_R;
         void  __iomem   *IO_ADDR_W;
-        
+
         u_char          (*read_byte)(struct mtd_info *mtd);
         void            (*write_byte)(struct mtd_info *mtd, u_char byte);
         u16             (*read_word)(struct mtd_info *mtd);
         void            (*write_word)(struct mtd_info *mtd, u16 word);
-        
+
         void            (*write_buf)(struct mtd_info *mtd, const u_char *buf, int len);
         void            (*read_buf)(struct mtd_info *mtd, u_char *buf, int len);
         int             (*verify_buf)(struct mtd_info *mtd, const u_char *buf, int len);
@@ -395,7 +396,7 @@ struct nand_chip {
  * @name:       Identify the device type
  * @id:         device ID code
  * @pagesize:   Pagesize in bytes. Either 256 or 512 or 0
- *              If the pagesize is 0, then the real pagesize 
+ *              If the pagesize is 0, then the real pagesize
  *              and the eraseize are determined from the
  *              extended id bytes in the chip
  * @erasesize:  Size of an erase block in the flash device.
@@ -424,7 +425,7 @@ struct nand_manufacturers {
 extern struct nand_flash_dev nand_flash_ids[];
 extern struct nand_manufacturers nand_manuf_ids[];
 
-/** 
+/**
  * struct nand_bbt_descr - bad block table descriptor
  * @options:    options for this descriptor
  * @pages:      the page(s) where we find the bbt, used with option BBT_ABSPAGE
@@ -435,14 +436,14 @@ extern struct nand_manufacturers nand_manuf_ids[];
  * @version:    version read from the bbt page during scan
  * @len:        length of the pattern, if 0 no pattern check is performed
  * @maxblocks:  maximum number of blocks to search for a bbt. This number of
- *              blocks is reserved at the end of the device where the tables are 
+ *              blocks is reserved at the end of the device where the tables are
  *              written.
  * @reserved_block_code: if non-0, this pattern denotes a reserved (rather than
  *              bad) block in the stored bbt
- * @pattern:    pattern to identify bad block table or factory marked good / 
+ * @pattern:    pattern to identify bad block table or factory marked good /
  *              bad blocks, can be NULL, if len = 0
  *
- * Descriptor for the bad block table marker and the descriptor for the 
+ * Descriptor for the bad block table marker and the descriptor for the
  * pattern which identifies good and bad blocks. The assumption is made
  * that the pattern and the version count are always located in the oob area
  * of the first block.
diff --git a/include/linux/mtd/onenand.h b/include/linux/mtd/onenand.h
new file mode 100644
index 000000000000..f1fd4215686a
--- /dev/null
+++ b/include/linux/mtd/onenand.h
@@ -0,0 +1,155 @@
+/*
+ *  linux/include/linux/mtd/onenand.h
+ *
+ *  Copyright (C) 2005 Samsung Electronics
+ *  Kyungmin Park <kyungmin.park@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __LINUX_MTD_ONENAND_H
+#define __LINUX_MTD_ONENAND_H
+
+#include <linux/spinlock.h>
+#include <linux/mtd/onenand_regs.h>
+#include <linux/mtd/bbm.h>
+
+#define MAX_BUFFERRAM           2
+#define MAX_ONENAND_PAGESIZE    (2048 + 64)
+
+/* Scan and identify a OneNAND device */
+extern int onenand_scan(struct mtd_info *mtd, int max_chips);
+/* Free resources held by the OneNAND device */
+extern void onenand_release(struct mtd_info *mtd);
+
+/**
+ * onenand_state_t - chip states
+ * Enumeration for OneNAND flash chip state
+ */
+typedef enum {
+        FL_READY,
+        FL_READING,
+        FL_WRITING,
+        FL_ERASING,
+        FL_SYNCING,
+        FL_UNLOCKING,
+        FL_LOCKING,
+        FL_PM_SUSPENDED,
+} onenand_state_t;
+
+/**
+ * struct onenand_bufferram - OneNAND BufferRAM Data
+ * @param block         block address in BufferRAM
+ * @param page          page address in BufferRAM
+ * @param valid         valid flag
+ */
+struct onenand_bufferram {
+        int block;
+        int page;
+        int valid;
+};
+
+/**
+ * struct onenand_chip - OneNAND Private Flash Chip Data
+ * @param base          [BOARDSPECIFIC] address to access OneNAND
+ * @param chipsize      [INTERN] the size of one chip for multichip arrays
+ * @param device_id     [INTERN] device ID
+ * @param verstion_id   [INTERN] version ID
+ * @param options       [BOARDSPECIFIC] various chip options. They can partly be set to inform onenand_scan about
+ * @param erase_shift   [INTERN] number of address bits in a block
+ * @param page_shift    [INTERN] number of address bits in a page
+ * @param ppb_shift     [INTERN] number of address bits in a pages per block
+ * @param page_mask     [INTERN] a page per block mask
+ * @param bufferam_index        [INTERN] BufferRAM index
+ * @param bufferam      [INTERN] BufferRAM info
+ * @param readw         [REPLACEABLE] hardware specific function for read short
+ * @param writew        [REPLACEABLE] hardware specific function for write short
+ * @param command       [REPLACEABLE] hardware specific function for writing commands to the chip
+ * @param wait          [REPLACEABLE] hardware specific function for wait on ready
+ * @param read_bufferram        [REPLACEABLE] hardware specific function for BufferRAM Area
+ * @param write_bufferram       [REPLACEABLE] hardware specific function for BufferRAM Area
+ * @param read_word     [REPLACEABLE] hardware specific function for read register of OneNAND
+ * @param write_word    [REPLACEABLE] hardware specific function for write register of OneNAND
+ * @param scan_bbt      [REPLACEALBE] hardware specific function for scaning Bad block Table
+ * @param chip_lock     [INTERN] spinlock used to protect access to this structure and the chip
+ * @param wq            [INTERN] wait queue to sleep on if a OneNAND operation is in progress
+ * @param state         [INTERN] the current state of the OneNAND device
+ * @param autooob       [REPLACEABLE] the default (auto)placement scheme
+ * @param bbm           [REPLACEABLE] pointer to Bad Block Management
+ * @param priv          [OPTIONAL] pointer to private chip date
+ */
+struct onenand_chip {
+        void __iomem            *base;
+        unsigned int            chipsize;
+        unsigned int            device_id;
+        unsigned int            density_mask;
+        unsigned int            options;
+
+        unsigned int            erase_shift;
+        unsigned int            page_shift;
+        unsigned int            ppb_shift;      /* Pages per block shift */
+        unsigned int            page_mask;
+
+        unsigned int            bufferram_index;
+        struct onenand_bufferram        bufferram[MAX_BUFFERRAM];
+
+        int (*command)(struct mtd_info *mtd, int cmd, loff_t address, size_t len);
+        int (*wait)(struct mtd_info *mtd, int state);
+        int (*read_bufferram)(struct mtd_info *mtd, int area,
+                        unsigned char *buffer, int offset, size_t count);
+        int (*write_bufferram)(struct mtd_info *mtd, int area,
+                        const unsigned char *buffer, int offset, size_t count);
+        unsigned short (*read_word)(void __iomem *addr);
+        void (*write_word)(unsigned short value, void __iomem *addr);
+        void (*mmcontrol)(struct mtd_info *mtd, int sync_read);
+        int (*block_markbad)(struct mtd_info *mtd, loff_t ofs);
+        int (*scan_bbt)(struct mtd_info *mtd);
+
+        spinlock_t              chip_lock;
+        wait_queue_head_t       wq;
+        onenand_state_t         state;
+
+        struct nand_oobinfo     *autooob;
+
+        void                    *bbm;
+
+        void                    *priv;
+};
+
+/*
+ * Helper macros
+ */
+#define ONENAND_CURRENT_BUFFERRAM(this)         (this->bufferram_index)
+#define ONENAND_NEXT_BUFFERRAM(this)            (this->bufferram_index ^ 1)
+#define ONENAND_SET_NEXT_BUFFERRAM(this)        (this->bufferram_index ^= 1)
+
+#define ONENAND_GET_SYS_CFG1(this)                                      \
+        (this->read_word(this->base + ONENAND_REG_SYS_CFG1))
+#define ONENAND_SET_SYS_CFG1(v, this)                                   \
+        (this->write_word(v, this->base + ONENAND_REG_SYS_CFG1))
+
+/*
+ * Options bits
+ */
+#define ONENAND_CONT_LOCK               (0x0001)
+
+
+/*
+ * OneNAND Flash Manufacturer ID Codes
+ */
+#define ONENAND_MFR_SAMSUNG     0xec
+#define ONENAND_MFR_UNKNOWN     0x00
+
+/**
+ * struct nand_manufacturers - NAND Flash Manufacturer ID Structure
+ * @param name:         Manufacturer name
+ * @param id:           manufacturer ID code of device.
+*/
+struct onenand_manufacturers {
+        int id;
+        char *name;
+};
+
+#endif  /* __LINUX_MTD_ONENAND_H */
diff --git a/include/linux/mtd/onenand_regs.h b/include/linux/mtd/onenand_regs.h
new file mode 100644
index 000000000000..d7832ef8ed63
--- /dev/null
+++ b/include/linux/mtd/onenand_regs.h
@@ -0,0 +1,180 @@
+/*
+ *  linux/include/linux/mtd/onenand_regs.h
+ *
+ *  OneNAND Register header file
+ *
+ *  Copyright (C) 2005 Samsung Electronics
+ *
+ * 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 __ONENAND_REG_H
+#define __ONENAND_REG_H
+
+/* Memory Address Map Translation (Word order) */
+#define ONENAND_MEMORY_MAP(x)           ((x) << 1)
+
+/*
+ * External BufferRAM area
+ */
+#define ONENAND_BOOTRAM                 ONENAND_MEMORY_MAP(0x0000)
+#define ONENAND_DATARAM                 ONENAND_MEMORY_MAP(0x0200)
+#define ONENAND_SPARERAM                ONENAND_MEMORY_MAP(0x8010)
+
+/*
+ * OneNAND Registers
+ */
+#define ONENAND_REG_MANUFACTURER_ID     ONENAND_MEMORY_MAP(0xF000)
+#define ONENAND_REG_DEVICE_ID           ONENAND_MEMORY_MAP(0xF001)
+#define ONENAND_REG_VERSION_ID          ONENAND_MEMORY_MAP(0xF002)
+#define ONENAND_REG_DATA_BUFFER_SIZE    ONENAND_MEMORY_MAP(0xF003)
+#define ONENAND_REG_BOOT_BUFFER_SIZE    ONENAND_MEMORY_MAP(0xF004)
+#define ONENAND_REG_NUM_BUFFERS         ONENAND_MEMORY_MAP(0xF005)
+#define ONENAND_REG_TECHNOLOGY          ONENAND_MEMORY_MAP(0xF006)
+
+#define ONENAND_REG_START_ADDRESS1      ONENAND_MEMORY_MAP(0xF100)
+#define ONENAND_REG_START_ADDRESS2      ONENAND_MEMORY_MAP(0xF101)
+#define ONENAND_REG_START_ADDRESS3      ONENAND_MEMORY_MAP(0xF102)
+#define ONENAND_REG_START_ADDRESS4      ONENAND_MEMORY_MAP(0xF103)
+#define ONENAND_REG_START_ADDRESS5      ONENAND_MEMORY_MAP(0xF104)
+#define ONENAND_REG_START_ADDRESS6      ONENAND_MEMORY_MAP(0xF105)
+#define ONENAND_REG_START_ADDRESS7      ONENAND_MEMORY_MAP(0xF106)
+#define ONENAND_REG_START_ADDRESS8      ONENAND_MEMORY_MAP(0xF107)
+
+#define ONENAND_REG_START_BUFFER        ONENAND_MEMORY_MAP(0xF200)
+#define ONENAND_REG_COMMAND             ONENAND_MEMORY_MAP(0xF220)
+#define ONENAND_REG_SYS_CFG1            ONENAND_MEMORY_MAP(0xF221)
+#define ONENAND_REG_SYS_CFG2            ONENAND_MEMORY_MAP(0xF222)
+#define ONENAND_REG_CTRL_STATUS         ONENAND_MEMORY_MAP(0xF240)
+#define ONENAND_REG_INTERRUPT           ONENAND_MEMORY_MAP(0xF241)
+#define ONENAND_REG_START_BLOCK_ADDRESS ONENAND_MEMORY_MAP(0xF24C)
+#define ONENAND_REG_END_BLOCK_ADDRESS   ONENAND_MEMORY_MAP(0xF24D)
+#define ONENAND_REG_WP_STATUS           ONENAND_MEMORY_MAP(0xF24E)
+
+#define ONENAND_REG_ECC_STATUS          ONENAND_MEMORY_MAP(0xFF00)
+#define ONENAND_REG_ECC_M0              ONENAND_MEMORY_MAP(0xFF01)
+#define ONENAND_REG_ECC_S0              ONENAND_MEMORY_MAP(0xFF02)
+#define ONENAND_REG_ECC_M1              ONENAND_MEMORY_MAP(0xFF03)
+#define ONENAND_REG_ECC_S1              ONENAND_MEMORY_MAP(0xFF04)
+#define ONENAND_REG_ECC_M2              ONENAND_MEMORY_MAP(0xFF05)
+#define ONENAND_REG_ECC_S2              ONENAND_MEMORY_MAP(0xFF06)
+#define ONENAND_REG_ECC_M3              ONENAND_MEMORY_MAP(0xFF07)
+#define ONENAND_REG_ECC_S3              ONENAND_MEMORY_MAP(0xFF08)
+
+/*
+ * Device ID Register F001h (R)
+ */
+#define ONENAND_DEVICE_DENSITY_SHIFT    (4)
+#define ONENAND_DEVICE_IS_DDP           (1 << 3)
+#define ONENAND_DEVICE_IS_DEMUX         (1 << 2)
+#define ONENAND_DEVICE_VCC_MASK         (0x3)
+
+#define ONENAND_DEVICE_DENSITY_512Mb    (0x002)
+
+/*
+ * Version ID Register F002h (R)
+ */
+#define ONENAND_VERSION_PROCESS_SHIFT   (8)
+
+/*
+ * Start Address 1 F100h (R/W)
+ */
+#define ONENAND_DDP_SHIFT               (15)
+
+/*
+ * Start Address 8 F107h (R/W)
+ */
+#define ONENAND_FPA_MASK                (0x3f)
+#define ONENAND_FPA_SHIFT               (2)
+#define ONENAND_FSA_MASK                (0x03)
+
+/*
+ * Start Buffer Register F200h (R/W)
+ */
+#define ONENAND_BSA_MASK                (0x03)
+#define ONENAND_BSA_SHIFT               (8)
+#define ONENAND_BSA_BOOTRAM             (0 << 2)
+#define ONENAND_BSA_DATARAM0            (2 << 2)
+#define ONENAND_BSA_DATARAM1            (3 << 2)
+#define ONENAND_BSC_MASK                (0x03)
+
+/*
+ * Command Register F220h (R/W)
+ */
+#define ONENAND_CMD_READ                (0x00)
+#define ONENAND_CMD_READOOB             (0x13)
+#define ONENAND_CMD_PROG                (0x80)
+#define ONENAND_CMD_PROGOOB             (0x1A)
+#define ONENAND_CMD_UNLOCK              (0x23)
+#define ONENAND_CMD_LOCK                (0x2A)
+#define ONENAND_CMD_LOCK_TIGHT          (0x2C)
+#define ONENAND_CMD_ERASE               (0x94)
+#define ONENAND_CMD_RESET               (0xF0)
+#define ONENAND_CMD_READID              (0x90)
+
+/* NOTE: Those are not *REAL* commands */
+#define ONENAND_CMD_BUFFERRAM           (0x1978)
+
+/*
+ * System Configuration 1 Register F221h (R, R/W)
+ */
+#define ONENAND_SYS_CFG1_SYNC_READ      (1 << 15)
+#define ONENAND_SYS_CFG1_BRL_7          (7 << 12)
+#define ONENAND_SYS_CFG1_BRL_6          (6 << 12)
+#define ONENAND_SYS_CFG1_BRL_5          (5 << 12)
+#define ONENAND_SYS_CFG1_BRL_4          (4 << 12)
+#define ONENAND_SYS_CFG1_BRL_3          (3 << 12)
+#define ONENAND_SYS_CFG1_BRL_10         (2 << 12)
+#define ONENAND_SYS_CFG1_BRL_9          (1 << 12)
+#define ONENAND_SYS_CFG1_BRL_8          (0 << 12)
+#define ONENAND_SYS_CFG1_BRL_SHIFT      (12)
+#define ONENAND_SYS_CFG1_BL_32          (4 << 9)
+#define ONENAND_SYS_CFG1_BL_16          (3 << 9)
+#define ONENAND_SYS_CFG1_BL_8           (2 << 9)
+#define ONENAND_SYS_CFG1_BL_4           (1 << 9)
+#define ONENAND_SYS_CFG1_BL_CONT        (0 << 9)
+#define ONENAND_SYS_CFG1_BL_SHIFT       (9)
+#define ONENAND_SYS_CFG1_NO_ECC         (1 << 8)
+#define ONENAND_SYS_CFG1_RDY            (1 << 7)
+#define ONENAND_SYS_CFG1_INT            (1 << 6)
+#define ONENAND_SYS_CFG1_IOBE           (1 << 5)
+#define ONENAND_SYS_CFG1_RDY_CONF       (1 << 4)
+
+/*
+ * Controller Status Register F240h (R)
+ */
+#define ONENAND_CTRL_ONGO               (1 << 15)
+#define ONENAND_CTRL_LOCK               (1 << 14)
+#define ONENAND_CTRL_LOAD               (1 << 13)
+#define ONENAND_CTRL_PROGRAM            (1 << 12)
+#define ONENAND_CTRL_ERASE              (1 << 11)
+#define ONENAND_CTRL_ERROR              (1 << 10)
+#define ONENAND_CTRL_RSTB               (1 << 7)
+
+/*
+ * Interrupt Status Register F241h (R)
+ */
+#define ONENAND_INT_MASTER              (1 << 15)
+#define ONENAND_INT_READ                (1 << 7)
+#define ONENAND_INT_WRITE               (1 << 6)
+#define ONENAND_INT_ERASE               (1 << 5)
+#define ONENAND_INT_RESET               (1 << 4)
+#define ONENAND_INT_CLEAR               (0 << 0)
+
+/*
+ * NAND Flash Write Protection Status Register F24Eh (R)
+ */
+#define ONENAND_WP_US                   (1 << 2)
+#define ONENAND_WP_LS                   (1 << 1)
+#define ONENAND_WP_LTS                  (1 << 0)
+
+/*
+ * ECC Status Reigser FF00h (R)
+ */
+#define ONENAND_ECC_1BIT                (1 << 0)
+#define ONENAND_ECC_2BIT                (1 << 1)
+#define ONENAND_ECC_2BIT_ALL            (0xAAAA)
+
+#endif  /* __ONENAND_REG_H */
diff --git a/include/linux/mtd/partitions.h b/include/linux/mtd/partitions.h
index 50b2edfc8f11..b03f512d51b9 100644
--- a/include/linux/mtd/partitions.h
+++ b/include/linux/mtd/partitions.h
@@ -5,7 +5,7 @@
  *
  * This code is GPL
  *
- * $Id: partitions.h,v 1.16 2004/11/16 18:34:40 dwmw2 Exp $
+ * $Id: partitions.h,v 1.17 2005/11/07 11:14:55 gleixner Exp $
  */
 
 #ifndef MTD_PARTITIONS_H
@@ -16,25 +16,25 @@
 
 /*
  * Partition definition structure:
- * 
+ *
  * An array of struct partition is passed along with a MTD object to
  * add_mtd_partitions() to create them.
  *
  * For each partition, these fields are available:
  * name: string that will be used to label the partition's MTD device.
- * size: the partition size; if defined as MTDPART_SIZ_FULL, the partition 
+ * size: the partition size; if defined as MTDPART_SIZ_FULL, the partition
  *      will extend to the end of the master MTD device.
- * offset: absolute starting position within the master MTD device; if 
- *      defined as MTDPART_OFS_APPEND, the partition will start where the 
+ * offset: absolute starting position within the master MTD device; if
+ *      defined as MTDPART_OFS_APPEND, the partition will start where the
  *      previous one ended; if MTDPART_OFS_NXTBLK, at the next erase block.
- * mask_flags: contains flags that have to be masked (removed) from the 
+ * mask_flags: contains flags that have to be masked (removed) from the
  *      master MTD flag set for the corresponding MTD partition.
- *      For example, to force a read-only partition, simply adding 
+ *      For example, to force a read-only partition, simply adding
  *      MTD_WRITEABLE to the mask_flags will do the trick.
  *
- * Note: writeable partitions require their size and offset be 
+ * Note: writeable partitions require their size and offset be
  * erasesize aligned (e.g. use MTDPART_OFS_NEXTBLK).
- */ 
+ */
 
 struct mtd_partition {
         char *name;                     /* identifier string */
@@ -66,7 +66,7 @@ struct mtd_part_parser {
 
 extern int register_mtd_parser(struct mtd_part_parser *parser);
 extern int deregister_mtd_parser(struct mtd_part_parser *parser);
-extern int parse_mtd_partitions(struct mtd_info *master, const char **types, 
+extern int parse_mtd_partitions(struct mtd_info *master, const char **types,
                                 struct mtd_partition **pparts, unsigned long origin);
 
 #define put_partition_parser(p) do { module_put((p)->owner); } while(0)
diff --git a/include/linux/mtd/physmap.h b/include/linux/mtd/physmap.h
index 05aa4970677f..c7b8bcdef013 100644
--- a/include/linux/mtd/physmap.h
+++ b/include/linux/mtd/physmap.h
@@ -1,8 +1,8 @@
 /*
- * For boards with physically mapped flash and using 
+ * For boards with physically mapped flash and using
  * drivers/mtd/maps/physmap.c mapping driver.
  *
- * $Id: physmap.h,v 1.3 2004/07/21 00:16:15 jwboyer Exp $
+ * $Id: physmap.h,v 1.4 2005/11/07 11:14:55 gleixner Exp $
  *
  * Copyright (C) 2003 MontaVista Software Inc.
  * Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
@@ -18,7 +18,7 @@
 
 #include <linux/config.h>
 
-#if defined(CONFIG_MTD_PHYSMAP) 
+#if defined(CONFIG_MTD_PHYSMAP)
 
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
@@ -44,12 +44,12 @@ static inline void physmap_configure(unsigned long addr, unsigned long size, int
 #if defined(CONFIG_MTD_PARTITIONS)
 
 /*
- * Machines that wish to do flash partition may want to call this function in 
- * their setup routine.  
+ * Machines that wish to do flash partition may want to call this function in
+ * their setup routine.
  *
  *      physmap_set_partitions(mypartitions, num_parts);
  *
- * Note that one can always override this hard-coded partition with 
+ * Note that one can always override this hard-coded partition with
  * command line partition (you need to enable CONFIG_MTD_CMDLINE_PARTS).
  */
 void physmap_set_partitions(struct mtd_partition *parts, int num_parts);
diff --git a/include/linux/mtd/pmc551.h b/include/linux/mtd/pmc551.h
index 113e3087f68a..a7f6d20ad407 100644
--- a/include/linux/mtd/pmc551.h
+++ b/include/linux/mtd/pmc551.h
@@ -1,5 +1,5 @@
 /*
- * $Id: pmc551.h,v 1.5 2003/01/24 16:49:53 dwmw2 Exp $
+ * $Id: pmc551.h,v 1.6 2005/11/07 11:14:55 gleixner Exp $
  *
  * PMC551 PCI Mezzanine Ram Device
  *
@@ -7,7 +7,7 @@
  *       Mark Ferrell
  *       Copyright 1999,2000 Nortel Networks
  *
- * License: 
+ * License:
  *       As part of this driver was derrived from the slram.c driver it falls
  *       under the same license, which is GNU General Public License v2
  */
@@ -17,7 +17,7 @@
 
 #include <linux/mtd/mtd.h>
 
-#define PMC551_VERSION "$Id: pmc551.h,v 1.5 2003/01/24 16:49:53 dwmw2 Exp $\n"\
+#define PMC551_VERSION "$Id: pmc551.h,v 1.6 2005/11/07 11:14:55 gleixner Exp $\n"\
        "Ramix PMC551 PCI Mezzanine Ram Driver. (C) 1999,2000 Nortel Networks.\n"
 
 /*
@@ -30,7 +30,7 @@ struct mypriv {
         u32    curr_map0;
         u32    asize;
         struct mtd_info *nextpmc551;
-};                       
+};
 
 /*
  * Function Prototypes
@@ -39,7 +39,7 @@ static int pmc551_erase(struct mtd_info *, struct erase_info *);
 static void pmc551_unpoint(struct mtd_info *, u_char *, loff_t, size_t);
 static int pmc551_point (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char **mtdbuf);
 static int pmc551_read(struct mtd_info *, loff_t, size_t, size_t *, u_char *);
-static int pmc551_write(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);        
+static int pmc551_write(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
 
 
 /*
@@ -50,7 +50,7 @@ static int pmc551_write(struct mtd_info *, loff_t, size_t, size_t *, const u_cha
 #endif
 
 #ifndef PCI_DEVICE_ID_V3_SEMI_V370PDC
-#define PCI_DEVICE_ID_V3_SEMI_V370PDC     0x0200  
+#define PCI_DEVICE_ID_V3_SEMI_V370PDC     0x0200
 #endif
 
 
diff --git a/include/linux/mtd/xip.h b/include/linux/mtd/xip.h
index 7b7deef6b180..220d50bb71cd 100644
--- a/include/linux/mtd/xip.h
+++ b/include/linux/mtd/xip.h
@@ -12,7 +12,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * $Id: xip.h,v 1.2 2004/12/01 15:49:10 nico Exp $
+ * $Id: xip.h,v 1.5 2005/11/07 11:14:55 gleixner Exp $
  */
 
 #ifndef __LINUX_MTD_XIP_H__
@@ -23,19 +23,19 @@
 #ifdef CONFIG_MTD_XIP
 
 /*
- * Function that are modifying the flash state away from array mode must
- * obviously not be running from flash.  The __xipram is therefore marking
- * those functions so they get relocated to ram.
- */
-#define __xipram __attribute__ ((__section__ (".data")))
-
-/*
  * We really don't want gcc to guess anything.
  * We absolutely _need_ proper inlining.
  */
 #include <linux/compiler.h>
 
 /*
+ * Function that are modifying the flash state away from array mode must
+ * obviously not be running from flash.  The __xipram is therefore marking
+ * those functions so they get relocated to ram.
+ */
+#define __xipram noinline __attribute__ ((__section__ (".data")))
+
+/*
  * Each architecture has to provide the following macros.  They must access
  * the hardware directly and not rely on any other (XIP) functions since they
  * won't be available when used (flash not in array mode).
@@ -60,9 +60,9 @@
  *              overflowing.
  *
  * xip_iprefetch()
- *  
+ *
  *      Macro to fill instruction prefetch
- *      e.g. a series of nops:  asm volatile (".rep 8; nop; .endr"); 
+ *      e.g. a series of nops:  asm volatile (".rep 8; nop; .endr");
  */
 
 #include <asm/mtd-xip.h>
diff --git a/include/linux/namei.h b/include/linux/namei.h
index 7db67b008cac..455660eafba9 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -8,6 +8,7 @@ struct vfsmount;
 struct open_intent {
         int     flags;
         int     create_mode;
+        struct file *file;
 };
 
 enum { MAX_NESTED_LINKS = 5 };
@@ -65,8 +66,15 @@ extern int FASTCALL(link_path_walk(const char *, struct nameidata *));
 extern void path_release(struct nameidata *);
 extern void path_release_on_umount(struct nameidata *);
 
+extern int __user_path_lookup_open(const char __user *, unsigned lookup_flags, struct nameidata *nd, int open_flags);
+extern int path_lookup_open(const char *, unsigned lookup_flags, struct nameidata *, int open_flags);
+extern struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
+                int (*open)(struct inode *, struct file *));
+extern struct file *nameidata_to_filp(struct nameidata *nd, int flags);
+extern void release_open_intent(struct nameidata *);
+
 extern struct dentry * lookup_one_len(const char *, struct dentry *, int);
-extern struct dentry * lookup_hash(struct qstr *, struct dentry *);
+extern struct dentry * lookup_hash(struct nameidata *);
 
 extern int follow_down(struct vfsmount **, struct dentry **);
 extern int follow_up(struct vfsmount **, struct dentry **);
diff --git a/include/linux/namespace.h b/include/linux/namespace.h
index 0e5a86f13b2f..6731977c4c13 100644
--- a/include/linux/namespace.h
+++ b/include/linux/namespace.h
@@ -9,7 +9,8 @@ struct namespace {
         atomic_t                count;
         struct vfsmount *       root;
         struct list_head        list;
-        struct rw_semaphore     sem;
+        wait_queue_head_t poll;
+        int event;
 };
 
 extern int copy_namespace(int, struct task_struct *);
diff --git a/include/linux/net.h b/include/linux/net.h
index 4e981585a89a..d6a41e6577f6 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -71,6 +71,7 @@ typedef enum {
  * @SOCK_RAW: raw socket
  * @SOCK_RDM: reliably-delivered message
  * @SOCK_SEQPACKET: sequential packet socket
+ * @SOCK_DCCP: Datagram Congestion Control Protocol socket
  * @SOCK_PACKET: linux specific way of getting packets at the dev level.
  *                For writing rarp and other similar things on the user level.
  *
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 7c717907896d..936f8b76114e 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -265,6 +265,8 @@ struct net_device
          * the interface.
          */
         char                    name[IFNAMSIZ];
+        /* device name hash chain */
+        struct hlist_node       name_hlist;
 
         /*
          *      I/O specific fields
@@ -292,6 +294,22 @@ struct net_device
 
         /* ------- Fields preinitialized in Space.c finish here ------- */
 
+        /* Net device features */
+        unsigned long           features;
+#define NETIF_F_SG              1       /* Scatter/gather IO. */
+#define NETIF_F_IP_CSUM         2       /* Can checksum only TCP/UDP over IPv4. */
+#define NETIF_F_NO_CSUM         4       /* Does not require checksum. F.e. loopack. */
+#define NETIF_F_HW_CSUM         8       /* Can checksum all the packets. */
+#define NETIF_F_HIGHDMA         32      /* Can DMA to high memory. */
+#define NETIF_F_FRAGLIST        64      /* Scatter/gather IO. */
+#define NETIF_F_HW_VLAN_TX      128     /* Transmit VLAN hw acceleration */
+#define NETIF_F_HW_VLAN_RX      256     /* Receive VLAN hw acceleration */
+#define NETIF_F_HW_VLAN_FILTER  512     /* Receive filtering on VLAN */
+#define NETIF_F_VLAN_CHALLENGED 1024    /* Device cannot handle VLAN packets */
+#define NETIF_F_TSO             2048    /* Can offload TCP/IP segmentation */
+#define NETIF_F_LLTX            4096    /* LockLess TX */
+#define NETIF_F_UFO             8192    /* Can offload UDP Large Send*/
+
         struct net_device       *next_sched;
 
         /* Interface index. Unique device identifier    */
@@ -316,9 +334,6 @@ struct net_device
          * will (read: may be cleaned up at will).
          */
 
-        /* These may be needed for future network-power-down code. */
-        unsigned long           trans_start;    /* Time (in jiffies) of last Tx */
-        unsigned long           last_rx;        /* Time of last Rx      */
 
         unsigned short          flags;  /* interface flags (a la BSD)   */
         unsigned short          gflags;
@@ -328,15 +343,12 @@ struct net_device
         unsigned                mtu;    /* interface MTU value          */
         unsigned short          type;   /* interface hardware type      */
         unsigned short          hard_header_len;        /* hardware hdr length  */
-        void                    *priv;  /* pointer to private data      */
 
         struct net_device       *master; /* Pointer to master device of a group,
                                           * which this device is member of.
                                           */
 
         /* Interface address info. */
-        unsigned char           broadcast[MAX_ADDR_LEN];        /* hw bcast add */
-        unsigned char           dev_addr[MAX_ADDR_LEN]; /* hw address   */
         unsigned char           perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
         unsigned char           addr_len;       /* hardware address length      */
         unsigned short          dev_id;         /* for shared network cards */
@@ -346,8 +358,6 @@ struct net_device
         int                     promiscuity;
         int                     allmulti;
 
-        int                     watchdog_timeo;
-        struct timer_list       watchdog_timer;
 
         /* Protocol specific pointers */
         
@@ -358,32 +368,62 @@ struct net_device
         void                    *ec_ptr;        /* Econet specific data */
         void                    *ax25_ptr;      /* AX.25 specific data */
 
-        struct list_head        poll_list;      /* Link to poll list    */
+/*
+ * Cache line mostly used on receive path (including eth_type_trans())
+ */
+        struct list_head        poll_list ____cacheline_aligned_in_smp;
+                                        /* Link to poll list    */
+
+        int                     (*poll) (struct net_device *dev, int *quota);
         int                     quota;
         int                     weight;
+        unsigned long           last_rx;        /* Time of last Rx      */
+        /* Interface address info used in eth_type_trans() */
+        unsigned char           dev_addr[MAX_ADDR_LEN]; /* hw address, (before bcast 
+                                                        because most packets are unicast) */
 
+        unsigned char           broadcast[MAX_ADDR_LEN];        /* hw bcast add */
+
+/*
+ * Cache line mostly used on queue transmit path (qdisc)
+ */
+        /* device queue lock */
+        spinlock_t              queue_lock ____cacheline_aligned_in_smp;
         struct Qdisc            *qdisc;
         struct Qdisc            *qdisc_sleeping;
-        struct Qdisc            *qdisc_ingress;
         struct list_head        qdisc_list;
         unsigned long           tx_queue_len;   /* Max frames per queue allowed */
 
         /* ingress path synchronizer */
         spinlock_t              ingress_lock;
+        struct Qdisc            *qdisc_ingress;
+
+/*
+ * One part is mostly used on xmit path (device)
+ */
         /* hard_start_xmit synchronizer */
-        spinlock_t              xmit_lock;
+        spinlock_t              xmit_lock ____cacheline_aligned_in_smp;
         /* cpu id of processor entered to hard_start_xmit or -1,
            if nobody entered there.
          */
         int                     xmit_lock_owner;
-        /* device queue lock */
-        spinlock_t              queue_lock;
+        void                    *priv;  /* pointer to private data      */
+        int                     (*hard_start_xmit) (struct sk_buff *skb,
+                                                    struct net_device *dev);
+        /* These may be needed for future network-power-down code. */
+        unsigned long           trans_start;    /* Time (in jiffies) of last Tx */
+
+        int                     watchdog_timeo; /* used by dev_watchdog() */
+        struct timer_list       watchdog_timer;
+
+/*
+ * refcnt is a very hot point, so align it on SMP
+ */
         /* Number of references to this device */
-        atomic_t                refcnt;
+        atomic_t                refcnt ____cacheline_aligned_in_smp;
+
         /* delayed register/unregister */
         struct list_head        todo_list;
-        /* device name hash chain */
-        struct hlist_node       name_hlist;
         /* device index hash chain */
         struct hlist_node       index_hlist;
 
@@ -396,21 +436,6 @@ struct net_device
                NETREG_RELEASED,         /* called free_netdev */
         } reg_state;
 
-        /* Net device features */
-        unsigned long           features;
-#define NETIF_F_SG              1       /* Scatter/gather IO. */
-#define NETIF_F_IP_CSUM         2       /* Can checksum only TCP/UDP over IPv4. */
-#define NETIF_F_NO_CSUM         4       /* Does not require checksum. F.e. loopack. */
-#define NETIF_F_HW_CSUM         8       /* Can checksum all the packets. */
-#define NETIF_F_HIGHDMA         32      /* Can DMA to high memory. */
-#define NETIF_F_FRAGLIST        64      /* Scatter/gather IO. */
-#define NETIF_F_HW_VLAN_TX      128     /* Transmit VLAN hw acceleration */
-#define NETIF_F_HW_VLAN_RX      256     /* Receive VLAN hw acceleration */
-#define NETIF_F_HW_VLAN_FILTER  512     /* Receive filtering on VLAN */
-#define NETIF_F_VLAN_CHALLENGED 1024    /* Device cannot handle VLAN packets */
-#define NETIF_F_TSO             2048    /* Can offload TCP/IP segmentation */
-#define NETIF_F_LLTX            4096    /* LockLess TX */
-
         /* Called after device is detached from network. */
         void                    (*uninit)(struct net_device *dev);
         /* Called after last user reference disappears. */
@@ -419,10 +444,7 @@ struct net_device
         /* Pointers to interface service routines.      */
         int                     (*open)(struct net_device *dev);
         int                     (*stop)(struct net_device *dev);
-        int                     (*hard_start_xmit) (struct sk_buff *skb,
-                                                    struct net_device *dev);
 #define HAVE_NETDEV_POLL
-        int                     (*poll) (struct net_device *dev, int *quota);
         int                     (*hard_header) (struct sk_buff *skb,
                                                 struct net_device *dev,
                                                 unsigned short type,
@@ -852,11 +874,9 @@ static inline void netif_rx_complete(struct net_device *dev)
 
 static inline void netif_poll_disable(struct net_device *dev)
 {
-        while (test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state)) {
+        while (test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state))
                 /* No hurry. */
-                current->state = TASK_INTERRUPTIBLE;
-                schedule_timeout(1);
-        }
+                schedule_timeout_interruptible(1);
 }
 
 static inline void netif_poll_enable(struct net_device *dev)
@@ -907,6 +927,13 @@ extern int		netdev_max_backlog;
 extern int              weight_p;
 extern int              netdev_set_master(struct net_device *dev, struct net_device *master);
 extern int skb_checksum_help(struct sk_buff *skb, int inward);
+#ifdef CONFIG_BUG
+extern void netdev_rx_csum_fault(struct net_device *dev);
+#else
+static inline void netdev_rx_csum_fault(struct net_device *dev)
+{
+}
+#endif
 /* rx skb timestamps */
 extern void             net_enable_timestamp(void);
 extern void             net_disable_timestamp(void);
diff --git a/include/linux/netfilter/nf_conntrack_common.h b/include/linux/netfilter/nf_conntrack_common.h
new file mode 100644
index 000000000000..6d39b518486b
--- /dev/null
+++ b/include/linux/netfilter/nf_conntrack_common.h
@@ -0,0 +1,159 @@
+#ifndef _NF_CONNTRACK_COMMON_H
+#define _NF_CONNTRACK_COMMON_H
+/* Connection state tracking for netfilter.  This is separated from,
+   but required by, the NAT layer; it can also be used by an iptables
+   extension. */
+enum ip_conntrack_info
+{
+        /* Part of an established connection (either direction). */
+        IP_CT_ESTABLISHED,
+
+        /* Like NEW, but related to an existing connection, or ICMP error
+           (in either direction). */
+        IP_CT_RELATED,
+
+        /* Started a new connection to track (only
+           IP_CT_DIR_ORIGINAL); may be a retransmission. */
+        IP_CT_NEW,
+
+        /* >= this indicates reply direction */
+        IP_CT_IS_REPLY,
+
+        /* Number of distinct IP_CT types (no NEW in reply dirn). */
+        IP_CT_NUMBER = IP_CT_IS_REPLY * 2 - 1
+};
+
+/* Bitset representing status of connection. */
+enum ip_conntrack_status {
+        /* It's an expected connection: bit 0 set.  This bit never changed */
+        IPS_EXPECTED_BIT = 0,
+        IPS_EXPECTED = (1 << IPS_EXPECTED_BIT),
+
+        /* We've seen packets both ways: bit 1 set.  Can be set, not unset. */
+        IPS_SEEN_REPLY_BIT = 1,
+        IPS_SEEN_REPLY = (1 << IPS_SEEN_REPLY_BIT),
+
+        /* Conntrack should never be early-expired. */
+        IPS_ASSURED_BIT = 2,
+        IPS_ASSURED = (1 << IPS_ASSURED_BIT),
+
+        /* Connection is confirmed: originating packet has left box */
+        IPS_CONFIRMED_BIT = 3,
+        IPS_CONFIRMED = (1 << IPS_CONFIRMED_BIT),
+
+        /* Connection needs src nat in orig dir.  This bit never changed. */
+        IPS_SRC_NAT_BIT = 4,
+        IPS_SRC_NAT = (1 << IPS_SRC_NAT_BIT),
+
+        /* Connection needs dst nat in orig dir.  This bit never changed. */
+        IPS_DST_NAT_BIT = 5,
+        IPS_DST_NAT = (1 << IPS_DST_NAT_BIT),
+
+        /* Both together. */
+        IPS_NAT_MASK = (IPS_DST_NAT | IPS_SRC_NAT),
+
+        /* Connection needs TCP sequence adjusted. */
+        IPS_SEQ_ADJUST_BIT = 6,
+        IPS_SEQ_ADJUST = (1 << IPS_SEQ_ADJUST_BIT),
+
+        /* NAT initialization bits. */
+        IPS_SRC_NAT_DONE_BIT = 7,
+        IPS_SRC_NAT_DONE = (1 << IPS_SRC_NAT_DONE_BIT),
+
+        IPS_DST_NAT_DONE_BIT = 8,
+        IPS_DST_NAT_DONE = (1 << IPS_DST_NAT_DONE_BIT),
+
+        /* Both together */
+        IPS_NAT_DONE_MASK = (IPS_DST_NAT_DONE | IPS_SRC_NAT_DONE),
+
+        /* Connection is dying (removed from lists), can not be unset. */
+        IPS_DYING_BIT = 9,
+        IPS_DYING = (1 << IPS_DYING_BIT),
+};
+
+/* Connection tracking event bits */
+enum ip_conntrack_events
+{
+        /* New conntrack */
+        IPCT_NEW_BIT = 0,
+        IPCT_NEW = (1 << IPCT_NEW_BIT),
+
+        /* Expected connection */
+        IPCT_RELATED_BIT = 1,
+        IPCT_RELATED = (1 << IPCT_RELATED_BIT),
+
+        /* Destroyed conntrack */
+        IPCT_DESTROY_BIT = 2,
+        IPCT_DESTROY = (1 << IPCT_DESTROY_BIT),
+
+        /* Timer has been refreshed */
+        IPCT_REFRESH_BIT = 3,
+        IPCT_REFRESH = (1 << IPCT_REFRESH_BIT),
+
+        /* Status has changed */
+        IPCT_STATUS_BIT = 4,
+        IPCT_STATUS = (1 << IPCT_STATUS_BIT),
+
+        /* Update of protocol info */
+        IPCT_PROTOINFO_BIT = 5,
+        IPCT_PROTOINFO = (1 << IPCT_PROTOINFO_BIT),
+
+        /* Volatile protocol info */
+        IPCT_PROTOINFO_VOLATILE_BIT = 6,
+        IPCT_PROTOINFO_VOLATILE = (1 << IPCT_PROTOINFO_VOLATILE_BIT),
+
+        /* New helper for conntrack */
+        IPCT_HELPER_BIT = 7,
+        IPCT_HELPER = (1 << IPCT_HELPER_BIT),
+
+        /* Update of helper info */
+        IPCT_HELPINFO_BIT = 8,
+        IPCT_HELPINFO = (1 << IPCT_HELPINFO_BIT),
+
+        /* Volatile helper info */
+        IPCT_HELPINFO_VOLATILE_BIT = 9,
+        IPCT_HELPINFO_VOLATILE = (1 << IPCT_HELPINFO_VOLATILE_BIT),
+
+        /* NAT info */
+        IPCT_NATINFO_BIT = 10,
+        IPCT_NATINFO = (1 << IPCT_NATINFO_BIT),
+
+        /* Counter highest bit has been set */
+        IPCT_COUNTER_FILLING_BIT = 11,
+        IPCT_COUNTER_FILLING = (1 << IPCT_COUNTER_FILLING_BIT),
+};
+
+enum ip_conntrack_expect_events {
+        IPEXP_NEW_BIT = 0,
+        IPEXP_NEW = (1 << IPEXP_NEW_BIT),
+};
+
+#ifdef __KERNEL__
+struct ip_conntrack_counter
+{
+        u_int32_t packets;
+        u_int32_t bytes;
+};
+
+struct ip_conntrack_stat
+{
+        unsigned int searched;
+        unsigned int found;
+        unsigned int new;
+        unsigned int invalid;
+        unsigned int ignore;
+        unsigned int delete;
+        unsigned int delete_list;
+        unsigned int insert;
+        unsigned int insert_failed;
+        unsigned int drop;
+        unsigned int early_drop;
+        unsigned int error;
+        unsigned int expect_new;
+        unsigned int expect_create;
+        unsigned int expect_delete;
+};
+
+#endif /* __KERNEL__ */
+
+#endif /* _NF_CONNTRACK_COMMON_H */
diff --git a/include/linux/netfilter/nf_conntrack_ftp.h b/include/linux/netfilter/nf_conntrack_ftp.h
new file mode 100644
index 000000000000..ad4a41c9ce93
--- /dev/null
+++ b/include/linux/netfilter/nf_conntrack_ftp.h
@@ -0,0 +1,44 @@
+#ifndef _NF_CONNTRACK_FTP_H
+#define _NF_CONNTRACK_FTP_H
+/* FTP tracking. */
+
+/* This enum is exposed to userspace */
+enum ip_ct_ftp_type
+{
+        /* PORT command from client */
+        IP_CT_FTP_PORT,
+        /* PASV response from server */
+        IP_CT_FTP_PASV,
+        /* EPRT command from client */
+        IP_CT_FTP_EPRT,
+        /* EPSV response from server */
+        IP_CT_FTP_EPSV,
+};
+
+#ifdef __KERNEL__
+
+#define FTP_PORT        21
+
+#define NUM_SEQ_TO_REMEMBER 2
+/* This structure exists only once per master */
+struct ip_ct_ftp_master {
+        /* Valid seq positions for cmd matching after newline */
+        u_int32_t seq_aft_nl[IP_CT_DIR_MAX][NUM_SEQ_TO_REMEMBER];
+        /* 0 means seq_match_aft_nl not set */
+        int seq_aft_nl_num[IP_CT_DIR_MAX];
+};
+
+struct ip_conntrack_expect;
+
+/* For NAT to hook in when we find a packet which describes what other
+ * connection we should expect. */
+extern unsigned int (*ip_nat_ftp_hook)(struct sk_buff **pskb,
+                                       enum ip_conntrack_info ctinfo,
+                                       enum ip_ct_ftp_type type,
+                                       unsigned int matchoff,
+                                       unsigned int matchlen,
+                                       struct ip_conntrack_expect *exp,
+                                       u32 *seq);
+#endif /* __KERNEL__ */
+
+#endif /* _NF_CONNTRACK_FTP_H */
diff --git a/include/linux/netfilter/nf_conntrack_sctp.h b/include/linux/netfilter/nf_conntrack_sctp.h
new file mode 100644
index 000000000000..b8994d9fd1a9
--- /dev/null
+++ b/include/linux/netfilter/nf_conntrack_sctp.h
@@ -0,0 +1,27 @@
+#ifndef _NF_CONNTRACK_SCTP_H
+#define _NF_CONNTRACK_SCTP_H
+/* SCTP tracking. */
+
+#include <linux/netfilter/nf_conntrack_tuple_common.h>
+
+enum sctp_conntrack {
+        SCTP_CONNTRACK_NONE,
+        SCTP_CONNTRACK_CLOSED,
+        SCTP_CONNTRACK_COOKIE_WAIT,
+        SCTP_CONNTRACK_COOKIE_ECHOED,
+        SCTP_CONNTRACK_ESTABLISHED,
+        SCTP_CONNTRACK_SHUTDOWN_SENT,
+        SCTP_CONNTRACK_SHUTDOWN_RECD,
+        SCTP_CONNTRACK_SHUTDOWN_ACK_SENT,
+        SCTP_CONNTRACK_MAX
+};
+
+struct ip_ct_sctp
+{
+        enum sctp_conntrack state;
+
+        u_int32_t vtag[IP_CT_DIR_MAX];
+        u_int32_t ttag[IP_CT_DIR_MAX];
+};
+
+#endif /* _NF_CONNTRACK_SCTP_H */
diff --git a/include/linux/netfilter/nf_conntrack_tcp.h b/include/linux/netfilter/nf_conntrack_tcp.h
new file mode 100644
index 000000000000..b2feeffde384
--- /dev/null
+++ b/include/linux/netfilter/nf_conntrack_tcp.h
@@ -0,0 +1,56 @@
+#ifndef _NF_CONNTRACK_TCP_H
+#define _NF_CONNTRACK_TCP_H
+/* TCP tracking. */
+
+/* This is exposed to userspace (ctnetlink) */
+enum tcp_conntrack {
+        TCP_CONNTRACK_NONE,
+        TCP_CONNTRACK_SYN_SENT,
+        TCP_CONNTRACK_SYN_RECV,
+        TCP_CONNTRACK_ESTABLISHED,
+        TCP_CONNTRACK_FIN_WAIT,
+        TCP_CONNTRACK_CLOSE_WAIT,
+        TCP_CONNTRACK_LAST_ACK,
+        TCP_CONNTRACK_TIME_WAIT,
+        TCP_CONNTRACK_CLOSE,
+        TCP_CONNTRACK_LISTEN,
+        TCP_CONNTRACK_MAX,
+        TCP_CONNTRACK_IGNORE
+};
+
+/* Window scaling is advertised by the sender */
+#define IP_CT_TCP_FLAG_WINDOW_SCALE             0x01
+
+/* SACK is permitted by the sender */
+#define IP_CT_TCP_FLAG_SACK_PERM                0x02
+
+/* This sender sent FIN first */
+#define IP_CT_TCP_FLAG_CLOSE_INIT               0x03
+
+#ifdef __KERNEL__
+
+struct ip_ct_tcp_state {
+        u_int32_t       td_end;         /* max of seq + len */
+        u_int32_t       td_maxend;      /* max of ack + max(win, 1) */
+        u_int32_t       td_maxwin;      /* max(win) */
+        u_int8_t        td_scale;       /* window scale factor */
+        u_int8_t        loose;          /* used when connection picked up from the middle */
+        u_int8_t        flags;          /* per direction options */
+};
+
+struct ip_ct_tcp
+{
+        struct ip_ct_tcp_state seen[2]; /* connection parameters per direction */
+        u_int8_t        state;          /* state of the connection (enum tcp_conntrack) */
+        /* For detecting stale connections */
+        u_int8_t        last_dir;       /* Direction of the last packet (enum ip_conntrack_dir) */
+        u_int8_t        retrans;        /* Number of retransmitted packets */
+        u_int8_t        last_index;     /* Index of the last packet */
+        u_int32_t       last_seq;       /* Last sequence number seen in dir */
+        u_int32_t       last_ack;       /* Last sequence number seen in opposite dir */
+        u_int32_t       last_end;       /* Last seq + len */
+};
+
+#endif /* __KERNEL__ */
+
+#endif /* _NF_CONNTRACK_TCP_H */
diff --git a/include/linux/netfilter/nf_conntrack_tuple_common.h b/include/linux/netfilter/nf_conntrack_tuple_common.h
new file mode 100644
index 000000000000..8e145f0d61cb
--- /dev/null
+++ b/include/linux/netfilter/nf_conntrack_tuple_common.h
@@ -0,0 +1,13 @@
+#ifndef _NF_CONNTRACK_TUPLE_COMMON_H
+#define _NF_CONNTRACK_TUPLE_COMMON_H
+
+enum ip_conntrack_dir
+{
+        IP_CT_DIR_ORIGINAL,
+        IP_CT_DIR_REPLY,
+        IP_CT_DIR_MAX
+};
+
+#define CTINFO2DIR(ctinfo) ((ctinfo) >= IP_CT_IS_REPLY ? IP_CT_DIR_REPLY : IP_CT_DIR_ORIGINAL)
+
+#endif /* _NF_CONNTRACK_TUPLE_COMMON_H */
diff --git a/include/linux/netfilter/nfnetlink.h b/include/linux/netfilter/nfnetlink.h
index 1d5b10ae2399..934a2479f160 100644
--- a/include/linux/netfilter/nfnetlink.h
+++ b/include/linux/netfilter/nfnetlink.h
@@ -41,11 +41,15 @@ enum nfnetlink_groups {
 struct nfattr
 {
         u_int16_t nfa_len;
-        u_int16_t nfa_type;
+        u_int16_t nfa_type;     /* we use 15 bits for the type, and the highest
+                                 * bit to indicate whether the payload is nested */
 } __attribute__ ((packed));
 
-/* FIXME: Shamelessly copy and pasted from rtnetlink.h, it's time
- *        to put this in a generic file */
+/* FIXME: Apart from NFNL_NFA_NESTED shamelessly copy and pasted from
+ * rtnetlink.h, it's time to put this in a generic file */
+
+#define NFNL_NFA_NEST   0x8000
+#define NFA_TYPE(attr)  ((attr)->nfa_type & 0x7fff)
 
 #define NFA_ALIGNTO     4
 #define NFA_ALIGN(len)  (((len) + NFA_ALIGNTO - 1) & ~(NFA_ALIGNTO - 1))
@@ -59,7 +63,7 @@ struct nfattr
 #define NFA_PAYLOAD(nfa) ((int)((nfa)->nfa_len) - NFA_LENGTH(0))
 #define NFA_NEST(skb, type) \
 ({      struct nfattr *__start = (struct nfattr *) (skb)->tail; \
-        NFA_PUT(skb, type, 0, NULL); \
+        NFA_PUT(skb, (NFNL_NFA_NEST | type), 0, NULL); \
         __start;  })
 #define NFA_NEST_END(skb, start) \
 ({      (start)->nfa_len = ((skb)->tail - (unsigned char *) (start)); \
@@ -108,7 +112,6 @@ struct nfnl_callback
 {
         int (*call)(struct sock *nl, struct sk_buff *skb, 
                 struct nlmsghdr *nlh, struct nfattr *cda[], int *errp);
-        kernel_cap_t cap_required; /* capabilities required for this msg */
         u_int16_t attr_count;   /* number of nfattr's */
 };
 
@@ -142,7 +145,7 @@ extern void nfnl_unlock(void);
 extern int nfnetlink_subsys_register(struct nfnetlink_subsystem *n);
 extern int nfnetlink_subsys_unregister(struct nfnetlink_subsystem *n);
 
-extern int nfattr_parse(struct nfattr *tb[], int maxattr, 
+extern void nfattr_parse(struct nfattr *tb[], int maxattr, 
                         struct nfattr *nfa, int len);
 
 #define nfattr_parse_nested(tb, max, nfa) \
@@ -150,11 +153,14 @@ extern int nfattr_parse(struct nfattr *tb[], int maxattr,
 
 #define nfattr_bad_size(tb, max, cta_min)                               \
 ({      int __i, __res = 0;                                             \
-        for (__i=0; __i<max; __i++)                                     \
+        for (__i=0; __i<max; __i++) {                                   \
+                if (!cta_min[__i])                                      \
+                        continue;                                       \
                 if (tb[__i] && NFA_PAYLOAD(tb[__i]) < cta_min[__i]){    \
                         __res = 1;                                      \
                         break;                                          \
                 }                                                       \
+        }                                                               \
         __res;                                                          \
 })
 
diff --git a/include/linux/netfilter/nfnetlink_conntrack.h b/include/linux/netfilter/nfnetlink_conntrack.h
index 5c55751c78e4..116fcaced909 100644
--- a/include/linux/netfilter/nfnetlink_conntrack.h
+++ b/include/linux/netfilter/nfnetlink_conntrack.h
@@ -70,15 +70,24 @@ enum ctattr_l4proto {
 
 enum ctattr_protoinfo {
         CTA_PROTOINFO_UNSPEC,
-        CTA_PROTOINFO_TCP_STATE,
+        CTA_PROTOINFO_TCP,
         __CTA_PROTOINFO_MAX
 };
 #define CTA_PROTOINFO_MAX (__CTA_PROTOINFO_MAX - 1)
 
+enum ctattr_protoinfo_tcp {
+        CTA_PROTOINFO_TCP_UNSPEC,
+        CTA_PROTOINFO_TCP_STATE,
+        __CTA_PROTOINFO_TCP_MAX
+};
+#define CTA_PROTOINFO_TCP_MAX (__CTA_PROTOINFO_TCP_MAX - 1)
+
 enum ctattr_counters {
         CTA_COUNTERS_UNSPEC,
-        CTA_COUNTERS_PACKETS,
-        CTA_COUNTERS_BYTES,
+        CTA_COUNTERS_PACKETS,           /* old 64bit counters */
+        CTA_COUNTERS_BYTES,             /* old 64bit counters */
+        CTA_COUNTERS32_PACKETS,
+        CTA_COUNTERS32_BYTES,
         __CTA_COUNTERS_MAX
 };
 #define CTA_COUNTERS_MAX (__CTA_COUNTERS_MAX - 1)
diff --git a/include/linux/netfilter_arp/arp_tables.h b/include/linux/netfilter_arp/arp_tables.h
index d759a637bded..e98a870a20be 100644
--- a/include/linux/netfilter_arp/arp_tables.h
+++ b/include/linux/netfilter_arp/arp_tables.h
@@ -68,7 +68,8 @@ struct arpt_entry_target
                         u_int16_t target_size;
 
                         /* Used by userspace */
-                        char name[ARPT_FUNCTION_MAXNAMELEN];
+                        char name[ARPT_FUNCTION_MAXNAMELEN-1];
+                        u_int8_t revision;
                 } user;
                 struct {
                         u_int16_t target_size;
@@ -148,7 +149,9 @@ struct arpt_entry
 
 #define ARPT_SO_GET_INFO                (ARPT_BASE_CTL)
 #define ARPT_SO_GET_ENTRIES             (ARPT_BASE_CTL + 1)
-#define ARPT_SO_GET_MAX                 ARPT_SO_GET_ENTRIES
+/* #define ARPT_SO_GET_REVISION_MATCH   (ARPT_BASE_CTL + 2)*/
+#define ARPT_SO_GET_REVISION_TARGET     (ARPT_BASE_CTL + 3)
+#define ARPT_SO_GET_MAX                 ARPT_SO_GET_REVISION_TARGET
 
 /* CONTINUE verdict for targets */
 #define ARPT_CONTINUE 0xFFFFFFFF
@@ -236,6 +239,15 @@ struct arpt_get_entries
         struct arpt_entry entrytable[0];
 };
 
+/* The argument to ARPT_SO_GET_REVISION_*.  Returns highest revision
+ * kernel supports, if >= revision. */
+struct arpt_get_revision
+{
+        char name[ARPT_FUNCTION_MAXNAMELEN-1];
+
+        u_int8_t revision;
+};
+
 /* Standard return verdict, or do jump. */
 #define ARPT_STANDARD_TARGET ""
 /* Error verdict. */
@@ -274,7 +286,9 @@ struct arpt_target
 {
         struct list_head list;
 
-        const char name[ARPT_FUNCTION_MAXNAMELEN];
+        const char name[ARPT_FUNCTION_MAXNAMELEN-1];
+
+        u_int8_t revision;
 
         /* Returns verdict. */
         unsigned int (*target)(struct sk_buff **pskb,
diff --git a/include/linux/netfilter_ipv4/ip_conntrack.h b/include/linux/netfilter_ipv4/ip_conntrack.h
index bace72a76cc4..b3432ab59a17 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack.h
@@ -1,128 +1,7 @@
 #ifndef _IP_CONNTRACK_H
 #define _IP_CONNTRACK_H
-/* Connection state tracking for netfilter.  This is separated from,
-   but required by, the NAT layer; it can also be used by an iptables
-   extension. */
-enum ip_conntrack_info
-{
-        /* Part of an established connection (either direction). */
-        IP_CT_ESTABLISHED,
-
-        /* Like NEW, but related to an existing connection, or ICMP error
-           (in either direction). */
-        IP_CT_RELATED,
-
-        /* Started a new connection to track (only
-           IP_CT_DIR_ORIGINAL); may be a retransmission. */
-        IP_CT_NEW,
-
-        /* >= this indicates reply direction */
-        IP_CT_IS_REPLY,
-
-        /* Number of distinct IP_CT types (no NEW in reply dirn). */
-        IP_CT_NUMBER = IP_CT_IS_REPLY * 2 - 1
-};
-
-/* Bitset representing status of connection. */
-enum ip_conntrack_status {
-        /* It's an expected connection: bit 0 set.  This bit never changed */
-        IPS_EXPECTED_BIT = 0,
-        IPS_EXPECTED = (1 << IPS_EXPECTED_BIT),
-
-        /* We've seen packets both ways: bit 1 set.  Can be set, not unset. */
-        IPS_SEEN_REPLY_BIT = 1,
-        IPS_SEEN_REPLY = (1 << IPS_SEEN_REPLY_BIT),
-
-        /* Conntrack should never be early-expired. */
-        IPS_ASSURED_BIT = 2,
-        IPS_ASSURED = (1 << IPS_ASSURED_BIT),
-
-        /* Connection is confirmed: originating packet has left box */
-        IPS_CONFIRMED_BIT = 3,
-        IPS_CONFIRMED = (1 << IPS_CONFIRMED_BIT),
-
-        /* Connection needs src nat in orig dir.  This bit never changed. */
-        IPS_SRC_NAT_BIT = 4,
-        IPS_SRC_NAT = (1 << IPS_SRC_NAT_BIT),
-
-        /* Connection needs dst nat in orig dir.  This bit never changed. */
-        IPS_DST_NAT_BIT = 5,
-        IPS_DST_NAT = (1 << IPS_DST_NAT_BIT),
-
-        /* Both together. */
-        IPS_NAT_MASK = (IPS_DST_NAT | IPS_SRC_NAT),
-
-        /* Connection needs TCP sequence adjusted. */
-        IPS_SEQ_ADJUST_BIT = 6,
-        IPS_SEQ_ADJUST = (1 << IPS_SEQ_ADJUST_BIT),
-
-        /* NAT initialization bits. */
-        IPS_SRC_NAT_DONE_BIT = 7,
-        IPS_SRC_NAT_DONE = (1 << IPS_SRC_NAT_DONE_BIT),
-
-        IPS_DST_NAT_DONE_BIT = 8,
-        IPS_DST_NAT_DONE = (1 << IPS_DST_NAT_DONE_BIT),
-
-        /* Both together */
-        IPS_NAT_DONE_MASK = (IPS_DST_NAT_DONE | IPS_SRC_NAT_DONE),
-
-        /* Connection is dying (removed from lists), can not be unset. */
-        IPS_DYING_BIT = 9,
-        IPS_DYING = (1 << IPS_DYING_BIT),
-};
-
-/* Connection tracking event bits */
-enum ip_conntrack_events
-{
-        /* New conntrack */
-        IPCT_NEW_BIT = 0,
-        IPCT_NEW = (1 << IPCT_NEW_BIT),
-
-        /* Expected connection */
-        IPCT_RELATED_BIT = 1,
-        IPCT_RELATED = (1 << IPCT_RELATED_BIT),
 
-        /* Destroyed conntrack */
-        IPCT_DESTROY_BIT = 2,
-        IPCT_DESTROY = (1 << IPCT_DESTROY_BIT),
-
-        /* Timer has been refreshed */
-        IPCT_REFRESH_BIT = 3,
-        IPCT_REFRESH = (1 << IPCT_REFRESH_BIT),
-
-        /* Status has changed */
-        IPCT_STATUS_BIT = 4,
-        IPCT_STATUS = (1 << IPCT_STATUS_BIT),
-
-        /* Update of protocol info */
-        IPCT_PROTOINFO_BIT = 5,
-        IPCT_PROTOINFO = (1 << IPCT_PROTOINFO_BIT),
-
-        /* Volatile protocol info */
-        IPCT_PROTOINFO_VOLATILE_BIT = 6,
-        IPCT_PROTOINFO_VOLATILE = (1 << IPCT_PROTOINFO_VOLATILE_BIT),
-
-        /* New helper for conntrack */
-        IPCT_HELPER_BIT = 7,
-        IPCT_HELPER = (1 << IPCT_HELPER_BIT),
-
-        /* Update of helper info */
-        IPCT_HELPINFO_BIT = 8,
-        IPCT_HELPINFO = (1 << IPCT_HELPINFO_BIT),
-
-        /* Volatile helper info */
-        IPCT_HELPINFO_VOLATILE_BIT = 9,
-        IPCT_HELPINFO_VOLATILE = (1 << IPCT_HELPINFO_VOLATILE_BIT),
-
-        /* NAT info */
-        IPCT_NATINFO_BIT = 10,
-        IPCT_NATINFO = (1 << IPCT_NATINFO_BIT),
-};
-
-enum ip_conntrack_expect_events {
-        IPEXP_NEW_BIT = 0,
-        IPEXP_NEW = (1 << IPEXP_NEW_BIT),
-};
+#include <linux/netfilter/nf_conntrack_common.h>
 
 #ifdef __KERNEL__
 #include <linux/config.h>
@@ -190,12 +69,6 @@ do {									\
 #define IP_NF_ASSERT(x)
 #endif
 
-struct ip_conntrack_counter
-{
-        u_int64_t packets;
-        u_int64_t bytes;
-};
-
 struct ip_conntrack_helper;
 
 struct ip_conntrack
@@ -332,11 +205,28 @@ extern void need_ip_conntrack(void);
 extern int invert_tuplepr(struct ip_conntrack_tuple *inverse,
                           const struct ip_conntrack_tuple *orig);
 
+extern void __ip_ct_refresh_acct(struct ip_conntrack *ct,
+                                 enum ip_conntrack_info ctinfo,
+                                 const struct sk_buff *skb,
+                                 unsigned long extra_jiffies,
+                                 int do_acct);
+
+/* Refresh conntrack for this many jiffies and do accounting */
+static inline void ip_ct_refresh_acct(struct ip_conntrack *ct, 
+                                      enum ip_conntrack_info ctinfo,
+                                      const struct sk_buff *skb,
+                                      unsigned long extra_jiffies)
+{
+        __ip_ct_refresh_acct(ct, ctinfo, skb, extra_jiffies, 1);
+}
+
 /* Refresh conntrack for this many jiffies */
-extern void ip_ct_refresh_acct(struct ip_conntrack *ct,
-                               enum ip_conntrack_info ctinfo,
-                               const struct sk_buff *skb,
-                               unsigned long extra_jiffies);
+static inline void ip_ct_refresh(struct ip_conntrack *ct,
+                                 const struct sk_buff *skb,
+                                 unsigned long extra_jiffies)
+{
+        __ip_ct_refresh_acct(ct, 0, skb, extra_jiffies, 0);
+}
 
 /* These are for NAT.  Icky. */
 /* Update TCP window tracking data when NAT mangles the packet */
@@ -405,25 +295,6 @@ static inline int is_dying(struct ip_conntrack *ct)
 
 extern unsigned int ip_conntrack_htable_size;
  
-struct ip_conntrack_stat
-{
-        unsigned int searched;
-        unsigned int found;
-        unsigned int new;
-        unsigned int invalid;
-        unsigned int ignore;
-        unsigned int delete;
-        unsigned int delete_list;
-        unsigned int insert;
-        unsigned int insert_failed;
-        unsigned int drop;
-        unsigned int early_drop;
-        unsigned int error;
-        unsigned int expect_new;
-        unsigned int expect_create;
-        unsigned int expect_delete;
-};
-
 #define CONNTRACK_STAT_INC(count) (__get_cpu_var(ip_conntrack_stat).count++)
 
 #ifdef CONFIG_IP_NF_CONNTRACK_EVENTS
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_ftp.h b/include/linux/netfilter_ipv4/ip_conntrack_ftp.h
index 5f06429b9047..63811934de4d 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack_ftp.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack_ftp.h
@@ -1,43 +1,6 @@
 #ifndef _IP_CONNTRACK_FTP_H
 #define _IP_CONNTRACK_FTP_H
-/* FTP tracking. */
 
-#ifdef __KERNEL__
+#include <linux/netfilter/nf_conntrack_ftp.h>
 
-#define FTP_PORT        21
-
-#endif /* __KERNEL__ */
-
-enum ip_ct_ftp_type
-{
-        /* PORT command from client */
-        IP_CT_FTP_PORT,
-        /* PASV response from server */
-        IP_CT_FTP_PASV,
-        /* EPRT command from client */
-        IP_CT_FTP_EPRT,
-        /* EPSV response from server */
-        IP_CT_FTP_EPSV,
-};
-
-#define NUM_SEQ_TO_REMEMBER 2
-/* This structure exists only once per master */
-struct ip_ct_ftp_master {
-        /* Valid seq positions for cmd matching after newline */
-        u_int32_t seq_aft_nl[IP_CT_DIR_MAX][NUM_SEQ_TO_REMEMBER];
-        /* 0 means seq_match_aft_nl not set */
-        int seq_aft_nl_num[IP_CT_DIR_MAX];
-};
-
-struct ip_conntrack_expect;
-
-/* For NAT to hook in when we find a packet which describes what other
- * connection we should expect. */
-extern unsigned int (*ip_nat_ftp_hook)(struct sk_buff **pskb,
-                                       enum ip_conntrack_info ctinfo,
-                                       enum ip_ct_ftp_type type,
-                                       unsigned int matchoff,
-                                       unsigned int matchlen,
-                                       struct ip_conntrack_expect *exp,
-                                       u32 *seq);
 #endif /* _IP_CONNTRACK_FTP_H */
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_icmp.h b/include/linux/netfilter_ipv4/ip_conntrack_icmp.h
index f1664abbe392..eed5ee3e4744 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack_icmp.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack_icmp.h
@@ -1,11 +1,6 @@
 #ifndef _IP_CONNTRACK_ICMP_H
 #define _IP_CONNTRACK_ICMP_H
-/* ICMP tracking. */
-#include <asm/atomic.h>
 
-struct ip_ct_icmp
-{
-        /* Optimization: when number in == number out, forget immediately. */
-        atomic_t count;
-};
+#include <net/netfilter/ipv4/nf_conntrack_icmp.h>
+
 #endif /* _IP_CONNTRACK_ICMP_H */
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_pptp.h b/include/linux/netfilter_ipv4/ip_conntrack_pptp.h
index 389e3851d52f..816144c75de0 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack_pptp.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack_pptp.h
@@ -60,8 +60,8 @@ struct ip_ct_pptp_expect {
 
 struct pptp_pkt_hdr {
         __u16   packetLength;
-        __u16   packetType;
-        __u32   magicCookie;
+        __be16  packetType;
+        __be32  magicCookie;
 };
 
 /* PptpControlMessageType values */
@@ -93,7 +93,7 @@ struct pptp_pkt_hdr {
 #define PPTP_REMOVE_DEVICE_ERROR        6
 
 struct PptpControlHeader {
-        __u16   messageType;
+        __be16  messageType;
         __u16   reserved;
 };
 
@@ -106,13 +106,13 @@ struct PptpControlHeader {
 #define PPTP_BEARER_CAP_DIGITAL         0x2
 
 struct PptpStartSessionRequest {
-        __u16   protocolVersion;
+        __be16  protocolVersion;
         __u8    reserved1;
         __u8    reserved2;
-        __u32   framingCapability;
-        __u32   bearerCapability;
-        __u16   maxChannels;
-        __u16   firmwareRevision;
+        __be32  framingCapability;
+        __be32  bearerCapability;
+        __be16  maxChannels;
+        __be16  firmwareRevision;
         __u8    hostName[64];
         __u8    vendorString[64];
 };
@@ -125,13 +125,13 @@ struct PptpStartSessionRequest {
 #define PPTP_START_UNKNOWN_PROTOCOL     5
 
 struct PptpStartSessionReply {
-        __u16   protocolVersion;
+        __be16  protocolVersion;
         __u8    resultCode;
         __u8    generalErrorCode;
-        __u32   framingCapability;
-        __u32   bearerCapability;
-        __u16   maxChannels;
-        __u16   firmwareRevision;
+        __be32  framingCapability;
+        __be32  bearerCapability;
+        __be16  maxChannels;
+        __be16  firmwareRevision;
         __u8    hostName[64];
         __u8    vendorString[64];
 };
@@ -155,7 +155,7 @@ struct PptpStopSessionReply {
 };
 
 struct PptpEchoRequest {
-        __u32 identNumber;
+        __be32 identNumber;
 };
 
 /* PptpEchoReplyResultCode */
@@ -163,7 +163,7 @@ struct PptpEchoRequest {
 #define PPTP_ECHO_GENERAL_ERROR         2
 
 struct PptpEchoReply {
-        __u32   identNumber;
+        __be32  identNumber;
         __u8    resultCode;
         __u8    generalErrorCode;
         __u16   reserved;
@@ -180,16 +180,16 @@ struct PptpEchoReply {
 #define PPTP_DONT_CARE_BEARER_TYPE      3
 
 struct PptpOutCallRequest {
-        __u16   callID;
-        __u16   callSerialNumber;
-        __u32   minBPS;
-        __u32   maxBPS;
-        __u32   bearerType;
-        __u32   framingType;
-        __u16   packetWindow;
-        __u16   packetProcDelay;
+        __be16  callID;
+        __be16  callSerialNumber;
+        __be32  minBPS;
+        __be32  maxBPS;
+        __be32  bearerType;
+        __be32  framingType;
+        __be16  packetWindow;
+        __be16  packetProcDelay;
         __u16   reserved1;
-        __u16   phoneNumberLength;
+        __be16  phoneNumberLength;
         __u16   reserved2;
         __u8    phoneNumber[64];
         __u8    subAddress[64];
@@ -205,24 +205,24 @@ struct PptpOutCallRequest {
 #define PPTP_OUTCALL_DONT_ACCEPT        7
 
 struct PptpOutCallReply {
-        __u16   callID;
-        __u16   peersCallID;
+        __be16  callID;
+        __be16  peersCallID;
         __u8    resultCode;
         __u8    generalErrorCode;
-        __u16   causeCode;
-        __u32   connectSpeed;
-        __u16   packetWindow;
-        __u16   packetProcDelay;
-        __u32   physChannelID;
+        __be16  causeCode;
+        __be32  connectSpeed;
+        __be16  packetWindow;
+        __be16  packetProcDelay;
+        __be32  physChannelID;
 };
 
 struct PptpInCallRequest {
-        __u16   callID;
-        __u16   callSerialNumber;
-        __u32   callBearerType;
-        __u32   physChannelID;
-        __u16   dialedNumberLength;
-        __u16   dialingNumberLength;
+        __be16  callID;
+        __be16  callSerialNumber;
+        __be32  callBearerType;
+        __be32  physChannelID;
+        __be16  dialedNumberLength;
+        __be16  dialingNumberLength;
         __u8    dialedNumber[64];
         __u8    dialingNumber[64];
         __u8    subAddress[64];
@@ -234,61 +234,54 @@ struct PptpInCallRequest {
 #define PPTP_INCALL_DONT_ACCEPT         3
 
 struct PptpInCallReply {
-        __u16   callID;
-        __u16   peersCallID;
+        __be16  callID;
+        __be16  peersCallID;
         __u8    resultCode;
         __u8    generalErrorCode;
-        __u16   packetWindow;
-        __u16   packetProcDelay;
+        __be16  packetWindow;
+        __be16  packetProcDelay;
         __u16   reserved;
 };
 
 struct PptpInCallConnected {
-        __u16   peersCallID;
+        __be16  peersCallID;
         __u16   reserved;
-        __u32   connectSpeed;
-        __u16   packetWindow;
-        __u16   packetProcDelay;
-        __u32   callFramingType;
+        __be32  connectSpeed;
+        __be16  packetWindow;
+        __be16  packetProcDelay;
+        __be32  callFramingType;
 };
 
 struct PptpClearCallRequest {
-        __u16   callID;
+        __be16  callID;
         __u16   reserved;
 };
 
 struct PptpCallDisconnectNotify {
-        __u16   callID;
+        __be16  callID;
         __u8    resultCode;
         __u8    generalErrorCode;
-        __u16   causeCode;
+        __be16  causeCode;
         __u16   reserved;
         __u8    callStatistics[128];
 };
 
 struct PptpWanErrorNotify {
-        __u16   peersCallID;
+        __be16  peersCallID;
         __u16   reserved;
-        __u32   crcErrors;
-        __u32   framingErrors;
-        __u32   hardwareOverRuns;
-        __u32   bufferOverRuns;
-        __u32   timeoutErrors;
-        __u32   alignmentErrors;
+        __be32  crcErrors;
+        __be32  framingErrors;
+        __be32  hardwareOverRuns;
+        __be32  bufferOverRuns;
+        __be32  timeoutErrors;
+        __be32  alignmentErrors;
 };
 
 struct PptpSetLinkInfo {
-        __u16   peersCallID;
+        __be16  peersCallID;
         __u16   reserved;
-        __u32   sendAccm;
-        __u32   recvAccm;
-};
-
-
-struct pptp_priv_data {
-        __u16   call_id;
-        __u16   mcall_id;
-        __u16   pcall_id;
+        __be32  sendAccm;
+        __be32  recvAccm;
 };
 
 union pptp_ctrl_union {
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_protocol.h b/include/linux/netfilter_ipv4/ip_conntrack_protocol.h
index b6b99be8632a..2c76b879e3dc 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack_protocol.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack_protocol.h
@@ -52,6 +52,9 @@ struct ip_conntrack_protocol
         int (*to_nfattr)(struct sk_buff *skb, struct nfattr *nfa,
                          const struct ip_conntrack *ct);
 
+        /* convert nfnetlink attributes to protoinfo */
+        int (*from_nfattr)(struct nfattr *tb[], struct ip_conntrack *ct);
+
         int (*tuple_to_nfattr)(struct sk_buff *skb,
                                const struct ip_conntrack_tuple *t);
         int (*nfattr_to_tuple)(struct nfattr *tb[],
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_sctp.h b/include/linux/netfilter_ipv4/ip_conntrack_sctp.h
index 7a8d869321f7..4099a041a32a 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack_sctp.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack_sctp.h
@@ -1,25 +1,6 @@
 #ifndef _IP_CONNTRACK_SCTP_H
 #define _IP_CONNTRACK_SCTP_H
-/* SCTP tracking. */
 
-enum sctp_conntrack {
-        SCTP_CONNTRACK_NONE,
-        SCTP_CONNTRACK_CLOSED,
-        SCTP_CONNTRACK_COOKIE_WAIT,
-        SCTP_CONNTRACK_COOKIE_ECHOED,
-        SCTP_CONNTRACK_ESTABLISHED,
-        SCTP_CONNTRACK_SHUTDOWN_SENT,
-        SCTP_CONNTRACK_SHUTDOWN_RECD,
-        SCTP_CONNTRACK_SHUTDOWN_ACK_SENT,
-        SCTP_CONNTRACK_MAX
-};
-
-struct ip_ct_sctp
-{
-        enum sctp_conntrack state;
-
-        u_int32_t vtag[IP_CT_DIR_MAX];
-        u_int32_t ttag[IP_CT_DIR_MAX];
-};
+#include <linux/netfilter/nf_conntrack_sctp.h>
 
 #endif /* _IP_CONNTRACK_SCTP_H */
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_tcp.h b/include/linux/netfilter_ipv4/ip_conntrack_tcp.h
index 16da044d97a7..876b8fb17e68 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack_tcp.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack_tcp.h
@@ -1,51 +1,6 @@
 #ifndef _IP_CONNTRACK_TCP_H
 #define _IP_CONNTRACK_TCP_H
-/* TCP tracking. */
 
-enum tcp_conntrack {
-        TCP_CONNTRACK_NONE,
-        TCP_CONNTRACK_SYN_SENT,
-        TCP_CONNTRACK_SYN_RECV,
-        TCP_CONNTRACK_ESTABLISHED,
-        TCP_CONNTRACK_FIN_WAIT,
-        TCP_CONNTRACK_CLOSE_WAIT,
-        TCP_CONNTRACK_LAST_ACK,
-        TCP_CONNTRACK_TIME_WAIT,
-        TCP_CONNTRACK_CLOSE,
-        TCP_CONNTRACK_LISTEN,
-        TCP_CONNTRACK_MAX,
-        TCP_CONNTRACK_IGNORE
-};
-
-/* Window scaling is advertised by the sender */
-#define IP_CT_TCP_FLAG_WINDOW_SCALE             0x01
-
-/* SACK is permitted by the sender */
-#define IP_CT_TCP_FLAG_SACK_PERM                0x02
-
-/* This sender sent FIN first */
-#define IP_CT_TCP_FLAG_CLOSE_INIT               0x03
-
-struct ip_ct_tcp_state {
-        u_int32_t       td_end;         /* max of seq + len */
-        u_int32_t       td_maxend;      /* max of ack + max(win, 1) */
-        u_int32_t       td_maxwin;      /* max(win) */
-        u_int8_t        td_scale;       /* window scale factor */
-        u_int8_t        loose;          /* used when connection picked up from the middle */
-        u_int8_t        flags;          /* per direction options */
-};
-
-struct ip_ct_tcp
-{
-        struct ip_ct_tcp_state seen[2]; /* connection parameters per direction */
-        u_int8_t        state;          /* state of the connection (enum tcp_conntrack) */
-        /* For detecting stale connections */
-        u_int8_t        last_dir;       /* Direction of the last packet (enum ip_conntrack_dir) */
-        u_int8_t        retrans;        /* Number of retransmitted packets */
-        u_int8_t        last_index;     /* Index of the last packet */
-        u_int32_t       last_seq;       /* Last sequence number seen in dir */
-        u_int32_t       last_ack;       /* Last sequence number seen in opposite dir */
-        u_int32_t       last_end;       /* Last seq + len */
-};
+#include <linux/netfilter/nf_conntrack_tcp.h>
 
 #endif /* _IP_CONNTRACK_TCP_H */
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_tuple.h b/include/linux/netfilter_ipv4/ip_conntrack_tuple.h
index 14dc0f7b6556..2fdabdb4c0ef 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack_tuple.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack_tuple.h
@@ -1,6 +1,9 @@
 #ifndef _IP_CONNTRACK_TUPLE_H
 #define _IP_CONNTRACK_TUPLE_H
 
+#include <linux/types.h>
+#include <linux/netfilter/nf_conntrack_tuple_common.h>
+
 /* A `tuple' is a structure containing the information to uniquely
   identify a connection.  ie. if two packets have the same tuple, they
   are in the same connection; if not, they are not.
@@ -17,7 +20,7 @@ union ip_conntrack_manip_proto
         u_int16_t all;
 
         struct {
-                u_int16_t port;
+                __be16 port;
         } tcp;
         struct {
                 u_int16_t port;
@@ -29,7 +32,7 @@ union ip_conntrack_manip_proto
                 u_int16_t port;
         } sctp;
         struct {
-                u_int16_t key;  /* key is 32bit, pptp only uses 16 */
+                __be16 key;     /* key is 32bit, pptp only uses 16 */
         } gre;
 };
 
@@ -65,7 +68,7 @@ struct ip_conntrack_tuple
                                 u_int16_t port;
                         } sctp;
                         struct {
-                                u_int16_t key;  /* key is 32bit, 
+                                __be16 key;     /* key is 32bit, 
                                                  * pptp only uses 16 */
                         } gre;
                 } u;
@@ -86,13 +89,6 @@ struct ip_conntrack_tuple
                 (tuple)->dst.u.all = 0;                         \
         } while (0)
 
-enum ip_conntrack_dir
-{
-        IP_CT_DIR_ORIGINAL,
-        IP_CT_DIR_REPLY,
-        IP_CT_DIR_MAX
-};
-
 #ifdef __KERNEL__
 
 #define DUMP_TUPLE(tp)                                          \
@@ -101,8 +97,6 @@ DEBUGP("tuple %p: %u %u.%u.%u.%u:%hu -> %u.%u.%u.%u:%hu\n",	\
        NIPQUAD((tp)->src.ip), ntohs((tp)->src.u.all),           \
        NIPQUAD((tp)->dst.ip), ntohs((tp)->dst.u.all))
 
-#define CTINFO2DIR(ctinfo) ((ctinfo) >= IP_CT_IS_REPLY ? IP_CT_DIR_REPLY : IP_CT_DIR_ORIGINAL)
-
 /* If we're the first tuple, it's the original dir. */
 #define DIRECTION(h) ((enum ip_conntrack_dir)(h)->tuple.dst.dir)
 
diff --git a/include/linux/netfilter_ipv4/ip_nat.h b/include/linux/netfilter_ipv4/ip_nat.h
index e201ec6e9905..41a107de17cf 100644
--- a/include/linux/netfilter_ipv4/ip_nat.h
+++ b/include/linux/netfilter_ipv4/ip_nat.h
@@ -58,10 +58,6 @@ extern rwlock_t ip_nat_lock;
 struct ip_nat_info
 {
         struct list_head bysource;
-
-        /* Helper (NULL if none). */
-        struct ip_nat_helper *helper;
-
         struct ip_nat_seq seq[IP_CT_DIR_MAX];
 };
 
diff --git a/include/linux/netfilter_ipv4/ip_nat_core.h b/include/linux/netfilter_ipv4/ip_nat_core.h
index 3b50eb91f007..30db23f06b03 100644
--- a/include/linux/netfilter_ipv4/ip_nat_core.h
+++ b/include/linux/netfilter_ipv4/ip_nat_core.h
@@ -5,16 +5,14 @@
 
 /* This header used to share core functionality between the standalone
    NAT module, and the compatibility layer's use of NAT for masquerading. */
-extern int ip_nat_init(void);
-extern void ip_nat_cleanup(void);
 
-extern unsigned int nat_packet(struct ip_conntrack *ct,
+extern unsigned int ip_nat_packet(struct ip_conntrack *ct,
                                enum ip_conntrack_info conntrackinfo,
                                unsigned int hooknum,
                                struct sk_buff **pskb);
 
-extern int icmp_reply_translation(struct sk_buff **pskb,
-                                  struct ip_conntrack *ct,
-                                  enum ip_nat_manip_type manip,
-                                  enum ip_conntrack_dir dir);
+extern int ip_nat_icmp_reply_translation(struct sk_buff **pskb,
+                                         struct ip_conntrack *ct,
+                                         enum ip_nat_manip_type manip,
+                                         enum ip_conntrack_dir dir);
 #endif /* _IP_NAT_CORE_H */
diff --git a/include/linux/netfilter_ipv4/ipt_sctp.h b/include/linux/netfilter_ipv4/ipt_sctp.h
index e93a9ec99fc2..80b3dbacd193 100644
--- a/include/linux/netfilter_ipv4/ipt_sctp.h
+++ b/include/linux/netfilter_ipv4/ipt_sctp.h
@@ -7,8 +7,6 @@
 
 #define IPT_SCTP_VALID_FLAGS            0x07
 
-#define ELEMCOUNT(x) (sizeof(x)/sizeof(x[0]))
-
 
 struct ipt_sctp_flag_info {
         u_int8_t chunktype;
@@ -59,21 +57,21 @@ struct ipt_sctp_info {
 #define SCTP_CHUNKMAP_RESET(chunkmap)                           \
         do {                                                    \
                 int i;                                          \
-                for (i = 0; i < ELEMCOUNT(chunkmap); i++)       \
+                for (i = 0; i < ARRAY_SIZE(chunkmap); i++)      \
                         chunkmap[i] = 0;                        \
         } while (0)
 
 #define SCTP_CHUNKMAP_SET_ALL(chunkmap)                         \
         do {                                                    \
                 int i;                                          \
-                for (i = 0; i < ELEMCOUNT(chunkmap); i++)       \
+                for (i = 0; i < ARRAY_SIZE(chunkmap); i++)      \
                         chunkmap[i] = ~0;                       \
         } while (0)
 
 #define SCTP_CHUNKMAP_COPY(destmap, srcmap)                     \
         do {                                                    \
                 int i;                                          \
-                for (i = 0; i < ELEMCOUNT(chunkmap); i++)       \
+                for (i = 0; i < ARRAY_SIZE(chunkmap); i++)      \
                         destmap[i] = srcmap[i];                 \
         } while (0)
 
@@ -81,7 +79,7 @@ struct ipt_sctp_info {
 ({                                                      \
         int i;                                          \
         int flag = 1;                                   \
-        for (i = 0; i < ELEMCOUNT(chunkmap); i++) {     \
+        for (i = 0; i < ARRAY_SIZE(chunkmap); i++) {    \
                 if (chunkmap[i]) {                      \
                         flag = 0;                       \
                         break;                          \
@@ -94,7 +92,7 @@ struct ipt_sctp_info {
 ({                                                      \
         int i;                                          \
         int flag = 1;                                   \
-        for (i = 0; i < ELEMCOUNT(chunkmap); i++) {     \
+        for (i = 0; i < ARRAY_SIZE(chunkmap); i++) {    \
                 if (chunkmap[i] != ~0) {                \
                         flag = 0;                       \
                                 break;                  \
diff --git a/include/linux/netfilter_ipv6.h b/include/linux/netfilter_ipv6.h
index edcc2c6eb5c7..53b2983f6278 100644
--- a/include/linux/netfilter_ipv6.h
+++ b/include/linux/netfilter_ipv6.h
@@ -59,6 +59,7 @@
 
 enum nf_ip6_hook_priorities {
         NF_IP6_PRI_FIRST = INT_MIN,
+        NF_IP6_PRI_CONNTRACK_DEFRAG = -400,
         NF_IP6_PRI_SELINUX_FIRST = -225,
         NF_IP6_PRI_CONNTRACK = -200,
         NF_IP6_PRI_BRIDGE_SABOTAGE_FORWARD = -175,
diff --git a/include/linux/netfilter_ipv6/ip6_tables.h b/include/linux/netfilter_ipv6/ip6_tables.h
index 59f70b34e029..2efc046d9e94 100644
--- a/include/linux/netfilter_ipv6/ip6_tables.h
+++ b/include/linux/netfilter_ipv6/ip6_tables.h
@@ -57,7 +57,8 @@ struct ip6t_entry_match
                         u_int16_t match_size;
 
                         /* Used by userspace */
-                        char name[IP6T_FUNCTION_MAXNAMELEN];
+                        char name[IP6T_FUNCTION_MAXNAMELEN-1];
+                        u_int8_t revision;
                 } user;
                 struct {
                         u_int16_t match_size;
@@ -80,7 +81,8 @@ struct ip6t_entry_target
                         u_int16_t target_size;
 
                         /* Used by userspace */
-                        char name[IP6T_FUNCTION_MAXNAMELEN];
+                        char name[IP6T_FUNCTION_MAXNAMELEN-1];
+                        u_int8_t revision;
                 } user;
                 struct {
                         u_int16_t target_size;
@@ -161,7 +163,9 @@ struct ip6t_entry
 
 #define IP6T_SO_GET_INFO                (IP6T_BASE_CTL)
 #define IP6T_SO_GET_ENTRIES             (IP6T_BASE_CTL + 1)
-#define IP6T_SO_GET_MAX                 IP6T_SO_GET_ENTRIES
+#define IP6T_SO_GET_REVISION_MATCH      (IP6T_BASE_CTL + 2)
+#define IP6T_SO_GET_REVISION_TARGET     (IP6T_BASE_CTL + 3)
+#define IP6T_SO_GET_MAX                 IP6T_SO_GET_REVISION_TARGET
 
 /* CONTINUE verdict for targets */
 #define IP6T_CONTINUE 0xFFFFFFFF
@@ -291,6 +295,15 @@ struct ip6t_get_entries
         struct ip6t_entry entrytable[0];
 };
 
+/* The argument to IP6T_SO_GET_REVISION_*.  Returns highest revision
+ * kernel supports, if >= revision. */
+struct ip6t_get_revision
+{
+        char name[IP6T_FUNCTION_MAXNAMELEN-1];
+
+        u_int8_t revision;
+};
+
 /* Standard return verdict, or do jump. */
 #define IP6T_STANDARD_TARGET ""
 /* Error verdict. */
@@ -352,7 +365,9 @@ struct ip6t_match
 {
         struct list_head list;
 
-        const char name[IP6T_FUNCTION_MAXNAMELEN];
+        const char name[IP6T_FUNCTION_MAXNAMELEN-1];
+
+        u_int8_t revision;
 
         /* Return true or false: return FALSE and set *hotdrop = 1 to
            force immediate packet drop. */
@@ -387,7 +402,9 @@ struct ip6t_target
 {
         struct list_head list;
 
-        const char name[IP6T_FUNCTION_MAXNAMELEN];
+        const char name[IP6T_FUNCTION_MAXNAMELEN-1];
+
+        u_int8_t revision;
 
         /* Returns verdict. Argument order changed since 2.6.9, as this
            must now handle non-linear skbs, using skb_copy_bits and
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index bdebdc564506..6a2ccf78a356 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -71,7 +71,8 @@ struct nlmsghdr
 
 #define NLMSG_ALIGNTO   4
 #define NLMSG_ALIGN(len) ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) )
-#define NLMSG_LENGTH(len) ((len)+NLMSG_ALIGN(sizeof(struct nlmsghdr)))
+#define NLMSG_HDRLEN     ((int) NLMSG_ALIGN(sizeof(struct nlmsghdr)))
+#define NLMSG_LENGTH(len) ((len)+NLMSG_ALIGN(NLMSG_HDRLEN))
 #define NLMSG_SPACE(len) NLMSG_ALIGN(NLMSG_LENGTH(len))
 #define NLMSG_DATA(nlh)  ((void*)(((char*)nlh) + NLMSG_LENGTH(0)))
 #define NLMSG_NEXT(nlh,len)      ((len) -= NLMSG_ALIGN((nlh)->nlmsg_len), \
@@ -86,6 +87,8 @@ struct nlmsghdr
 #define NLMSG_DONE              0x3     /* End of a dump        */
 #define NLMSG_OVERRUN           0x4     /* Data lost            */
 
+#define NLMSG_MIN_TYPE          0x10    /* < 0x10: reserved control messages */
+
 struct nlmsgerr
 {
         int             error;
@@ -108,6 +111,25 @@ enum {
         NETLINK_CONNECTED,
 };
 
+/*
+ *  <------- NLA_HDRLEN ------> <-- NLA_ALIGN(payload)-->
+ * +---------------------+- - -+- - - - - - - - - -+- - -+
+ * |        Header       | Pad |     Payload       | Pad |
+ * |   (struct nlattr)   | ing |                   | ing |
+ * +---------------------+- - -+- - - - - - - - - -+- - -+
+ *  <-------------- nlattr->nla_len -------------->
+ */
+
+struct nlattr
+{
+        __u16           nla_len;
+        __u16           nla_type;
+};
+
+#define NLA_ALIGNTO             4
+#define NLA_ALIGN(len)          (((len) + NLA_ALIGNTO - 1) & ~(NLA_ALIGNTO - 1))
+#define NLA_HDRLEN              ((int) NLA_ALIGN(sizeof(struct nlattr)))
+
 #ifdef __KERNEL__
 
 #include <linux/capability.h>
@@ -131,7 +153,7 @@ extern struct sock *netlink_kernel_create(int unit, unsigned int groups, void (*
 extern void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err);
 extern int netlink_unicast(struct sock *ssk, struct sk_buff *skb, __u32 pid, int nonblock);
 extern int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, __u32 pid,
-                             __u32 group, unsigned int __nocast allocation);
+                             __u32 group, gfp_t allocation);
 extern void netlink_set_err(struct sock *ssk, __u32 pid, __u32 group, int code);
 extern int netlink_register_notifier(struct notifier_block *nb);
 extern int netlink_unregister_notifier(struct notifier_block *nb);
diff --git a/include/linux/netpoll.h b/include/linux/netpoll.h
index 5ade54a78dbb..ca5a8733000f 100644
--- a/include/linux/netpoll.h
+++ b/include/linux/netpoll.h
@@ -86,7 +86,7 @@ static inline void netpoll_poll_unlock(void *have)
 
 #else
 #define netpoll_rx(a) 0
-#define netpoll_poll_lock(a) 0
+#define netpoll_poll_lock(a) NULL
 #define netpoll_poll_unlock(a)
 #endif
 
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 9a6047ff1b25..12787a9b0259 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -41,6 +41,10 @@
 #define NFS_MAX_FILE_IO_BUFFER_SIZE     32768
 #define NFS_DEF_FILE_IO_BUFFER_SIZE     4096
 
+/* Default timeout values */
+#define NFS_MAX_UDP_TIMEOUT     (60*HZ)
+#define NFS_MAX_TCP_TIMEOUT     (600*HZ)
+
 /*
  * superblock magic number for NFS
  */
@@ -137,6 +141,7 @@ struct nfs_inode {
         unsigned long           attrtimeo_timestamp;
         __u64                   change_attr;            /* v4 only */
 
+        unsigned long           last_updated;
         /* "Generation counter" for the attribute cache. This is
          * bumped whenever we update the metadata on the
          * server.
@@ -236,13 +241,17 @@ static inline int nfs_caches_unstable(struct inode *inode)
         return atomic_read(&NFS_I(inode)->data_updates) != 0;
 }
 
+static inline void nfs_mark_for_revalidate(struct inode *inode)
+{
+        spin_lock(&inode->i_lock);
+        NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS;
+        spin_unlock(&inode->i_lock);
+}
+
 static inline void NFS_CACHEINV(struct inode *inode)
 {
-        if (!nfs_caches_unstable(inode)) {
-                spin_lock(&inode->i_lock);
-                NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS;
-                spin_unlock(&inode->i_lock);
-        }
+        if (!nfs_caches_unstable(inode))
+                nfs_mark_for_revalidate(inode);
 }
 
 static inline int nfs_server_capable(struct inode *inode, int cap)
@@ -276,7 +285,7 @@ static inline long nfs_save_change_attribute(struct inode *inode)
 static inline int nfs_verify_change_attribute(struct inode *inode, unsigned long chattr)
 {
         return !nfs_caches_unstable(inode)
-                && chattr == NFS_I(inode)->cache_change_attribute;
+                && time_after_eq(chattr, NFS_I(inode)->cache_change_attribute);
 }
 
 /*
@@ -286,6 +295,7 @@ extern void nfs_zap_caches(struct inode *);
 extern struct inode *nfs_fhget(struct super_block *, struct nfs_fh *,
                                 struct nfs_fattr *);
 extern int nfs_refresh_inode(struct inode *, struct nfs_fattr *);
+extern int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr);
 extern int nfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 extern int nfs_permission(struct inode *, int, struct nameidata *);
 extern int nfs_access_get_cached(struct inode *, struct rpc_cred *, struct nfs_access_entry *);
@@ -306,12 +316,18 @@ extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, st
 extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
 extern void put_nfs_open_context(struct nfs_open_context *ctx);
 extern void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx);
-extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, int mode);
+extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, int mode);
 extern void nfs_file_clear_open_context(struct file *filp);
 
 /* linux/net/ipv4/ipconfig.c: trims ip addr off front of name, too. */
 extern u32 root_nfs_parse_addr(char *name); /*__init*/
 
+static inline void nfs_fattr_init(struct nfs_fattr *fattr)
+{
+        fattr->valid = 0;
+        fattr->time_start = jiffies;
+}
+
 /*
  * linux/fs/nfs/file.c
  */
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index a2bf6914ff1b..40718669b9c8 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -41,7 +41,7 @@ struct nfs_fattr {
         __u32                   bitmap[2];      /* NFSv4 returned attribute bitmap */
         __u64                   change_attr;    /* NFSv4 change attribute */
         __u64                   pre_change_attr;/* pre-op NFSv4 change attribute */
-        unsigned long           timestamp;
+        unsigned long           time_start;
 };
 
 #define NFS_ATTR_WCC            0x0001          /* pre-op WCC data    */
@@ -96,12 +96,13 @@ struct nfs4_change_info {
         u64                     after;
 };
 
+struct nfs_seqid;
 /*
  * Arguments to the open call.
  */
 struct nfs_openargs {
         const struct nfs_fh *   fh;
-        __u32                   seqid;
+        struct nfs_seqid *      seqid;
         int                     open_flags;
         __u64                   clientid;
         __u32                   id;
@@ -123,6 +124,7 @@ struct nfs_openres {
         struct nfs4_change_info cinfo;
         __u32                   rflags;
         struct nfs_fattr *      f_attr;
+        struct nfs_fattr *      dir_attr;
         const struct nfs_server *server;
         int                     delegation_type;
         nfs4_stateid            delegation;
@@ -136,7 +138,7 @@ struct nfs_openres {
 struct nfs_open_confirmargs {
         const struct nfs_fh *   fh;
         nfs4_stateid            stateid;
-        __u32                   seqid;
+        struct nfs_seqid *      seqid;
 };
 
 struct nfs_open_confirmres {
@@ -148,13 +150,16 @@ struct nfs_open_confirmres {
  */
 struct nfs_closeargs {
         struct nfs_fh *         fh;
-        nfs4_stateid            stateid;
-        __u32                   seqid;
+        nfs4_stateid *          stateid;
+        struct nfs_seqid *      seqid;
         int                     open_flags;
+        const u32 *             bitmask;
 };
 
 struct nfs_closeres {
         nfs4_stateid            stateid;
+        struct nfs_fattr *      fattr;
+        const struct nfs_server *server;
 };
 /*
  *  * Arguments to the lock,lockt, and locku call.
@@ -164,30 +169,19 @@ struct nfs_lowner {
         u32                     id;
 };
 
-struct nfs_open_to_lock {
-        __u32                   open_seqid;
-        nfs4_stateid            open_stateid;
-        __u32                   lock_seqid;
-        struct nfs_lowner       lock_owner;
-};
-
-struct nfs_exist_lock {
-        nfs4_stateid            stateid;
-        __u32                   seqid;
-};
-
 struct nfs_lock_opargs {
+        struct nfs_seqid *      lock_seqid;
+        nfs4_stateid *          lock_stateid;
+        struct nfs_seqid *      open_seqid;
+        nfs4_stateid *          open_stateid;
+        struct nfs_lowner       lock_owner;
         __u32                   reclaim;
         __u32                   new_lock_owner;
-        union {
-                struct nfs_open_to_lock *open_lock;
-                struct nfs_exist_lock   *exist_lock;
-        } u;
 };
 
 struct nfs_locku_opargs {
-        __u32                   seqid;
-        nfs4_stateid            stateid;
+        struct nfs_seqid *      seqid;
+        nfs4_stateid *          stateid;
 };
 
 struct nfs_lockargs {
@@ -262,6 +256,7 @@ struct nfs_writeargs {
         enum nfs3_stable_how    stable;
         unsigned int            pgbase;
         struct page **          pages;
+        const u32 *             bitmask;
 };
 
 struct nfs_writeverf {
@@ -273,6 +268,7 @@ struct nfs_writeres {
         struct nfs_fattr *      fattr;
         struct nfs_writeverf *  verf;
         __u32                   count;
+        const struct nfs_server *server;
 };
 
 /*
@@ -550,6 +546,7 @@ struct nfs4_create_res {
         struct nfs_fh *                 fh;
         struct nfs_fattr *              fattr;
         struct nfs4_change_info         dir_cinfo;
+        struct nfs_fattr *              dir_fattr;
 };
 
 struct nfs4_fsinfo_arg {
@@ -571,8 +568,17 @@ struct nfs4_link_arg {
         const struct nfs_fh *           fh;
         const struct nfs_fh *           dir_fh;
         const struct qstr *             name;
+        const u32 *                     bitmask;
+};
+
+struct nfs4_link_res {
+        const struct nfs_server *       server;
+        struct nfs_fattr *              fattr;
+        struct nfs4_change_info         cinfo;
+        struct nfs_fattr *              dir_attr;
 };
 
+
 struct nfs4_lookup_arg {
         const struct nfs_fh *           dir_fh;
         const struct qstr *             name;
@@ -619,6 +625,13 @@ struct nfs4_readlink {
 struct nfs4_remove_arg {
         const struct nfs_fh *           fh;
         const struct qstr *             name;
+        const u32 *                     bitmask;
+};
+
+struct nfs4_remove_res {
+        const struct nfs_server *       server;
+        struct nfs4_change_info         cinfo;
+        struct nfs_fattr *              dir_attr;
 };
 
 struct nfs4_rename_arg {
@@ -626,11 +639,15 @@ struct nfs4_rename_arg {
         const struct nfs_fh *           new_dir;
         const struct qstr *             old_name;
         const struct qstr *             new_name;
+        const u32 *                     bitmask;
 };
 
 struct nfs4_rename_res {
+        const struct nfs_server *       server;
         struct nfs4_change_info         old_cinfo;
+        struct nfs_fattr *              old_fattr;
         struct nfs4_change_info         new_cinfo;
+        struct nfs_fattr *              new_fattr;
 };
 
 struct nfs4_setclientid {
@@ -722,7 +739,7 @@ struct nfs_rpc_ops {
         int     (*write)   (struct nfs_write_data *);
         int     (*commit)  (struct nfs_write_data *);
         int     (*create)  (struct inode *, struct dentry *,
-                            struct iattr *, int);
+                            struct iattr *, int, struct nameidata *);
         int     (*remove)  (struct inode *, struct qstr *);
         int     (*unlink_setup)  (struct rpc_message *,
                             struct dentry *, struct qstr *);
diff --git a/include/linux/nfsd/nfsd.h b/include/linux/nfsd/nfsd.h
index 6d5a24f3fc6d..51c231a1e5a6 100644
--- a/include/linux/nfsd/nfsd.h
+++ b/include/linux/nfsd/nfsd.h
@@ -60,7 +60,7 @@ typedef int (*nfsd_dirop_t)(struct inode *, struct dentry *, int, int);
 extern struct svc_program       nfsd_program;
 extern struct svc_version       nfsd_version2, nfsd_version3,
                                 nfsd_version4;
-
+extern struct svc_serv          *nfsd_serv;
 /*
  * Function prototypes.
  */
diff --git a/include/linux/nfsd/syscall.h b/include/linux/nfsd/syscall.h
index e65c9db6d13f..781efbf94ed3 100644
--- a/include/linux/nfsd/syscall.h
+++ b/include/linux/nfsd/syscall.h
@@ -39,6 +39,21 @@
 #define NFSCTL_GETFD            7       /* get an fh by path (used by mountd) */
 #define NFSCTL_GETFS            8       /* get an fh by path with max FH len */
 
+/*
+ * Macros used to set version
+ */
+#define NFSCTL_VERSET(_cltbits, _v)   ((_cltbits) |=  (1 << (_v)))
+#define NFSCTL_VERUNSET(_cltbits, _v) ((_cltbits) &= ~(1 << (_v)))
+#define NFSCTL_VERISSET(_cltbits, _v) ((_cltbits) & (1 << (_v)))
+
+#if defined(CONFIG_NFSD_V4)
+#define NFSCTL_VERALL   (0x1c /* 0b011100 */)
+#elif defined(CONFIG_NFSD_V3)
+#define NFSCTL_VERALL   (0x0c /* 0b001100 */)
+#else
+#define NFSCTL_VERALL   (0x04 /* 0b000100 */)
+#endif
+
 /* SVC */
 struct nfsctl_svc {
         unsigned short          svc_port;
@@ -120,6 +135,8 @@ extern int		exp_delclient(struct nfsctl_client *ncp);
 extern int              exp_export(struct nfsctl_export *nxp);
 extern int              exp_unexport(struct nfsctl_export *nxp);
 
+extern unsigned int nfsd_versbits;
+
 #endif /* __KERNEL__ */
 
 #endif /* NFSD_SYSCALL_H */
diff --git a/include/linux/nfsd/xdr3.h b/include/linux/nfsd/xdr3.h
index 21e18ce7ca63..3c2a71b43bac 100644
--- a/include/linux/nfsd/xdr3.h
+++ b/include/linux/nfsd/xdr3.h
@@ -42,7 +42,7 @@ struct nfsd3_writeargs {
         __u64                   offset;
         __u32                   count;
         int                     stable;
-        int                     len;
+        __u32                   len;
         struct kvec             vec[RPCSVC_MAXPAGES];
         int                     vlen;
 };
diff --git a/include/linux/nodemask.h b/include/linux/nodemask.h
index e96fe9062500..4726ef7ba8e8 100644
--- a/include/linux/nodemask.h
+++ b/include/linux/nodemask.h
@@ -12,6 +12,8 @@
  * see bitmap_scnprintf() and bitmap_parse() in lib/bitmap.c.
  * For details of nodelist_scnprintf() and nodelist_parse(), see
  * bitmap_scnlistprintf() and bitmap_parselist(), also in bitmap.c.
+ * For details of node_remap(), see bitmap_bitremap in lib/bitmap.c.
+ * For details of nodes_remap(), see bitmap_remap in lib/bitmap.c.
  *
  * The available nodemask operations are:
  *
@@ -52,6 +54,8 @@
  * int nodemask_parse(ubuf, ulen, mask) Parse ascii string as nodemask
  * int nodelist_scnprintf(buf, len, mask) Format nodemask as list for printing
  * int nodelist_parse(buf, map)         Parse ascii string as nodelist
+ * int node_remap(oldbit, old, new)     newbit = map(old, new)(oldbit)
+ * int nodes_remap(dst, src, old, new)  *dst = map(old, new)(dst)
  *
  * for_each_node_mask(node, mask)       for-loop node over mask
  *
@@ -307,6 +311,22 @@ static inline int __nodelist_parse(const char *buf, nodemask_t *dstp, int nbits)
         return bitmap_parselist(buf, dstp->bits, nbits);
 }
 
+#define node_remap(oldbit, old, new) \
+                __node_remap((oldbit), &(old), &(new), MAX_NUMNODES)
+static inline int __node_remap(int oldbit,
+                const nodemask_t *oldp, const nodemask_t *newp, int nbits)
+{
+        return bitmap_bitremap(oldbit, oldp->bits, newp->bits, nbits);
+}
+
+#define nodes_remap(dst, src, old, new) \
+                __nodes_remap(&(dst), &(src), &(old), &(new), MAX_NUMNODES)
+static inline void __nodes_remap(nodemask_t *dstp, const nodemask_t *srcp,
+                const nodemask_t *oldp, const nodemask_t *newp, int nbits)
+{
+        bitmap_remap(dstp->bits, srcp->bits, oldp->bits, newp->bits, nbits);
+}
+
 #if MAX_NUMNODES > 1
 #define for_each_node_mask(node, mask)                  \
         for ((node) = first_node(mask);                 \
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index f34767c5fc79..343083fec258 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -287,11 +287,7 @@ extern void __mod_page_state(unsigned long offset, unsigned long delta);
 #define ClearPageReclaim(page)  clear_bit(PG_reclaim, &(page)->flags)
 #define TestClearPageReclaim(page) test_and_clear_bit(PG_reclaim, &(page)->flags)
 
-#ifdef CONFIG_HUGETLB_PAGE
 #define PageCompound(page)      test_bit(PG_compound, &(page)->flags)
-#else
-#define PageCompound(page)      0
-#endif
 #define SetPageCompound(page)   set_bit(PG_compound, &(page)->flags)
 #define ClearPageCompound(page) clear_bit(PG_compound, &(page)->flags)
 
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index d9a25647a295..ee700c6eb442 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -19,18 +19,19 @@
 #define AS_EIO          (__GFP_BITS_SHIFT + 0)  /* IO error on async write */
 #define AS_ENOSPC       (__GFP_BITS_SHIFT + 1)  /* ENOSPC on async write */
 
-static inline unsigned int __nocast mapping_gfp_mask(struct address_space * mapping)
+static inline gfp_t mapping_gfp_mask(struct address_space * mapping)
 {
-        return mapping->flags & __GFP_BITS_MASK;
+        return (__force gfp_t)mapping->flags & __GFP_BITS_MASK;
 }
 
 /*
  * This is non-atomic.  Only to be used before the mapping is activated.
  * Probably needs a barrier...
  */
-static inline void mapping_set_gfp_mask(struct address_space *m, int mask)
+static inline void mapping_set_gfp_mask(struct address_space *m, gfp_t mask)
 {
-        m->flags = (m->flags & ~__GFP_BITS_MASK) | mask;
+        m->flags = (m->flags & ~(__force unsigned long)__GFP_BITS_MASK) |
+                                (__force unsigned long)mask;
 }
 
 /*
@@ -52,12 +53,12 @@ void release_pages(struct page **pages, int nr, int cold);
 
 static inline struct page *page_cache_alloc(struct address_space *x)
 {
-        return alloc_pages(mapping_gfp_mask(x)|__GFP_NORECLAIM, 0);
+        return alloc_pages(mapping_gfp_mask(x), 0);
 }
 
 static inline struct page *page_cache_alloc_cold(struct address_space *x)
 {
-        return alloc_pages(mapping_gfp_mask(x)|__GFP_COLD|__GFP_NORECLAIM, 0);
+        return alloc_pages(mapping_gfp_mask(x)|__GFP_COLD, 0);
 }
 
 typedef int filler_t(void *, struct page *);
@@ -69,7 +70,7 @@ extern struct page * find_lock_page(struct address_space *mapping,
 extern struct page * find_trylock_page(struct address_space *mapping,
                                 unsigned long index);
 extern struct page * find_or_create_page(struct address_space *mapping,
-                                unsigned long index, unsigned int gfp_mask);
+                                unsigned long index, gfp_t gfp_mask);
 unsigned find_get_pages(struct address_space *mapping, pgoff_t start,
                         unsigned int nr_pages, struct page **pages);
 unsigned find_get_pages_tag(struct address_space *mapping, pgoff_t *index,
@@ -92,9 +93,9 @@ extern int read_cache_pages(struct address_space *mapping,
                 struct list_head *pages, filler_t *filler, void *data);
 
 int add_to_page_cache(struct page *page, struct address_space *mapping,
-                                unsigned long index, int gfp_mask);
+                                unsigned long index, gfp_t gfp_mask);
 int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
-                                unsigned long index, int gfp_mask);
+                                unsigned long index, gfp_t gfp_mask);
 extern void remove_from_page_cache(struct page *page);
 extern void __remove_from_page_cache(struct page *page);
 
diff --git a/include/linux/pci-acpi.h b/include/linux/pci-acpi.h
index 857126a36ecc..4877e35ae202 100644
--- a/include/linux/pci-acpi.h
+++ b/include/linux/pci-acpi.h
@@ -47,14 +47,15 @@
                                 OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL)
 
 #ifdef CONFIG_ACPI
-extern acpi_status pci_osc_control_set(u32 flags);
+extern acpi_status pci_osc_control_set(acpi_handle handle, u32 flags);
 extern acpi_status pci_osc_support_set(u32 flags);
 #else
 #if !defined(acpi_status)
 typedef u32             acpi_status;
 #define AE_ERROR        (acpi_status) (0x0001)
 #endif    
-static inline acpi_status pci_osc_control_set(u32 flags) {return AE_ERROR;}
+static inline acpi_status pci_osc_control_set(acpi_handle handle, u32 flags)
+{return AE_ERROR;}
 static inline acpi_status pci_osc_support_set(u32 flags) {return AE_ERROR;} 
 #endif
 
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 7349058ed778..de690ca73d58 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -132,6 +132,7 @@ struct pci_dev {
         unsigned int    is_enabled:1;   /* pci_enable_device has been called */
         unsigned int    is_busmaster:1; /* device is busmaster */
         unsigned int    no_msi:1;       /* device may not use msi */
+        unsigned int    block_ucfg_access:1;    /* userspace config space access is blocked */
 
         u32             saved_config_space[16]; /* config space saved at suspend time */
         struct bin_attribute *rom_attr; /* attribute descriptor for sysfs ROM entry */
@@ -235,7 +236,6 @@ struct module;
 struct pci_driver {
         struct list_head node;
         char *name;
-        struct module *owner;
         const struct pci_device_id *id_table;   /* must be non-NULL for probe to be called */
         int  (*probe)  (struct pci_dev *dev, const struct pci_device_id *id);   /* New device inserted */
         void (*remove) (struct pci_dev *dev);   /* Device removed (NULL if not a hot-plug capable driver) */
@@ -337,6 +337,7 @@ struct pci_dev *pci_find_device (unsigned int vendor, unsigned int device, const
 struct pci_dev *pci_find_device_reverse (unsigned int vendor, unsigned int device, const struct pci_dev *from);
 struct pci_dev *pci_find_slot (unsigned int bus, unsigned int devfn);
 int pci_find_capability (struct pci_dev *dev, int cap);
+int pci_find_next_capability (struct pci_dev *dev, u8 pos, int cap);
 int pci_find_ext_capability (struct pci_dev *dev, int cap);
 struct pci_bus * pci_find_next_bus(const struct pci_bus *from);
 
@@ -431,8 +432,13 @@ int pci_bus_alloc_resource(struct pci_bus *bus, struct resource *res,
                            void *alignf_data);
 void pci_enable_bridges(struct pci_bus *bus);
 
-/* New-style probing supporting hot-pluggable devices */
-int pci_register_driver(struct pci_driver *);
+/* Proper probing supporting hot-pluggable devices */
+int __pci_register_driver(struct pci_driver *, struct module *);
+static inline int pci_register_driver(struct pci_driver *driver)
+{
+        return __pci_register_driver(driver, THIS_MODULE);
+}
+
 void pci_unregister_driver(struct pci_driver *);
 void pci_remove_behind_bridge(struct pci_dev *);
 struct pci_driver *pci_dev_driver(const struct pci_dev *);
@@ -490,6 +496,9 @@ extern void pci_disable_msix(struct pci_dev *dev);
 extern void msi_remove_pci_irq_vectors(struct pci_dev *dev);
 #endif
 
+extern void pci_block_user_cfg_access(struct pci_dev *dev);
+extern void pci_unblock_user_cfg_access(struct pci_dev *dev);
+
 /*
  * PCI domain support.  Sometimes called PCI segment (eg by ACPI),
  * a PCI domain is defined to be a set of PCI busses which share
@@ -543,9 +552,11 @@ static inline int pci_enable_device(struct pci_dev *dev) { return -EIO; }
 static inline void pci_disable_device(struct pci_dev *dev) { }
 static inline int pci_set_dma_mask(struct pci_dev *dev, u64 mask) { return -EIO; }
 static inline int pci_assign_resource(struct pci_dev *dev, int i) { return -EBUSY;}
+static inline int __pci_register_driver(struct pci_driver *drv, struct module *owner) { return 0;}
 static inline int pci_register_driver(struct pci_driver *drv) { return 0;}
 static inline void pci_unregister_driver(struct pci_driver *drv) { }
 static inline int pci_find_capability (struct pci_dev *dev, int cap) {return 0; }
+static inline int pci_find_next_capability (struct pci_dev *dev, u8 post, int cap) { return 0; }
 static inline int pci_find_ext_capability (struct pci_dev *dev, int cap) {return 0; }
 static inline const struct pci_device_id *pci_match_device(const struct pci_device_id *ids, const struct pci_dev *dev) { return NULL; }
 
@@ -560,6 +571,9 @@ static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state, int en
 
 #define pci_dma_burst_advice(pdev, strat, strategy_parameter) do { } while (0)
 
+static inline void pci_block_user_cfg_access(struct pci_dev *dev) { }
+static inline void pci_unblock_user_cfg_access(struct pci_dev *dev) { }
+
 #endif /* CONFIG_PCI */
 
 /* Include architecture-dependent settings and functions */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index c49d28eca561..1e737e269db9 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -96,6 +96,9 @@
 #define PCI_CLASS_SERIAL_ACCESS         0x0c01
 #define PCI_CLASS_SERIAL_SSA            0x0c02
 #define PCI_CLASS_SERIAL_USB            0x0c03
+#define PCI_CLASS_SERIAL_USB_UHCI       0x0c0300
+#define PCI_CLASS_SERIAL_USB_OHCI       0x0c0310
+#define PCI_CLASS_SERIAL_USB_EHCI       0x0c0320
 #define PCI_CLASS_SERIAL_FIBER          0x0c04
 #define PCI_CLASS_SERIAL_SMBUS          0x0c05
 
@@ -132,9 +135,6 @@
 
 #define PCI_VENDOR_ID_COMPAQ            0x0e11
 #define PCI_DEVICE_ID_COMPAQ_TOKENRING  0x0508
-#define PCI_DEVICE_ID_COMPAQ_1280       0x3033
-#define PCI_DEVICE_ID_COMPAQ_TRIFLEX    0x4000
-#define PCI_DEVICE_ID_COMPAQ_6010       0x6010
 #define PCI_DEVICE_ID_COMPAQ_TACHYON    0xa0fc
 #define PCI_DEVICE_ID_COMPAQ_SMART2P    0xae10
 #define PCI_DEVICE_ID_COMPAQ_NETEL100   0xae32
@@ -185,6 +185,7 @@
 #define PCI_DEVICE_ID_LSI_61C102        0x0901
 #define PCI_DEVICE_ID_LSI_63C815        0x1000
 #define PCI_DEVICE_ID_LSI_SAS1064       0x0050
+#define PCI_DEVICE_ID_LSI_SAS1064R      0x0411
 #define PCI_DEVICE_ID_LSI_SAS1066       0x005E
 #define PCI_DEVICE_ID_LSI_SAS1068       0x0054
 #define PCI_DEVICE_ID_LSI_SAS1064A      0x005C
@@ -273,7 +274,6 @@
 #define PCI_DEVICE_ID_ATI_RAGE128_PP    0x5050
 #define PCI_DEVICE_ID_ATI_RAGE128_PQ    0x5051
 #define PCI_DEVICE_ID_ATI_RAGE128_PR    0x5052
-#define PCI_DEVICE_ID_ATI_RAGE128_TR    0x5452
 #define PCI_DEVICE_ID_ATI_RAGE128_PS    0x5053
 #define PCI_DEVICE_ID_ATI_RAGE128_PT    0x5054
 #define PCI_DEVICE_ID_ATI_RAGE128_PU    0x5055
@@ -281,8 +281,6 @@
 #define PCI_DEVICE_ID_ATI_RAGE128_PW    0x5057
 #define PCI_DEVICE_ID_ATI_RAGE128_PX    0x5058
 /* Rage128 M4 */
-#define PCI_DEVICE_ID_ATI_RADEON_LE     0x4d45
-#define PCI_DEVICE_ID_ATI_RADEON_LF     0x4d46
 /* Radeon R100 */
 #define PCI_DEVICE_ID_ATI_RADEON_QD     0x5144
 #define PCI_DEVICE_ID_ATI_RADEON_QE     0x5145
@@ -303,32 +301,22 @@
 #define PCI_DEVICE_ID_ATI_RADEON_QW     0x5157
 #define PCI_DEVICE_ID_ATI_RADEON_QX     0x5158
 /* Radeon NV-100 */
-#define PCI_DEVICE_ID_ATI_RADEON_N1     0x5159
-#define PCI_DEVICE_ID_ATI_RADEON_N2     0x515a
 /* Radeon RV250 (9000) */
 #define PCI_DEVICE_ID_ATI_RADEON_Id     0x4964
 #define PCI_DEVICE_ID_ATI_RADEON_Ie     0x4965
 #define PCI_DEVICE_ID_ATI_RADEON_If     0x4966
 #define PCI_DEVICE_ID_ATI_RADEON_Ig     0x4967
 /* Radeon RV280 (9200) */
-#define PCI_DEVICE_ID_ATI_RADEON_Y_     0x5960
 #define PCI_DEVICE_ID_ATI_RADEON_Ya     0x5961
 #define PCI_DEVICE_ID_ATI_RADEON_Yd     0x5964
 /* Radeon R300 (9500) */
-#define PCI_DEVICE_ID_ATI_RADEON_AD     0x4144
 /* Radeon R300 (9700) */
 #define PCI_DEVICE_ID_ATI_RADEON_ND     0x4e44
 #define PCI_DEVICE_ID_ATI_RADEON_NE     0x4e45
 #define PCI_DEVICE_ID_ATI_RADEON_NF     0x4e46
 #define PCI_DEVICE_ID_ATI_RADEON_NG     0x4e47
-#define PCI_DEVICE_ID_ATI_RADEON_AE     0x4145
-#define PCI_DEVICE_ID_ATI_RADEON_AF     0x4146
 /* Radeon R350 (9800) */
-#define PCI_DEVICE_ID_ATI_RADEON_NH     0x4e48
-#define PCI_DEVICE_ID_ATI_RADEON_NI     0x4e49
 /* Radeon RV350 (9600) */
-#define PCI_DEVICE_ID_ATI_RADEON_AP     0x4150
-#define PCI_DEVICE_ID_ATI_RADEON_AR     0x4152
 /* Radeon M6 */
 #define PCI_DEVICE_ID_ATI_RADEON_LY     0x4c59
 #define PCI_DEVICE_ID_ATI_RADEON_LZ     0x4c5a
@@ -341,10 +329,6 @@
 #define PCI_DEVICE_ID_ATI_RADEON_Lf     0x4c66
 #define PCI_DEVICE_ID_ATI_RADEON_Lg     0x4c67
 /* Radeon */
-#define PCI_DEVICE_ID_ATI_RADEON_RA     0x5144
-#define PCI_DEVICE_ID_ATI_RADEON_RB     0x5145
-#define PCI_DEVICE_ID_ATI_RADEON_RC     0x5146
-#define PCI_DEVICE_ID_ATI_RADEON_RD     0x5147
 /* RadeonIGP */
 #define PCI_DEVICE_ID_ATI_RS100         0xcab0
 #define PCI_DEVICE_ID_ATI_RS200         0xcab2
@@ -392,6 +376,7 @@
 #define PCI_DEVICE_ID_NS_87560_USB      0x0012
 #define PCI_DEVICE_ID_NS_83815          0x0020
 #define PCI_DEVICE_ID_NS_83820          0x0022
+#define PCI_DEVICE_ID_NS_SATURN         0x0035
 #define PCI_DEVICE_ID_NS_SCx200_BRIDGE  0x0500
 #define PCI_DEVICE_ID_NS_SCx200_SMI     0x0501
 #define PCI_DEVICE_ID_NS_SCx200_IDE     0x0502
@@ -402,6 +387,7 @@
 #define PCI_DEVICE_ID_NS_SC1100_SMI     0x0511
 #define PCI_DEVICE_ID_NS_SC1100_XBUS    0x0515
 #define PCI_DEVICE_ID_NS_87410          0xd001
+#define PCI_DEVICE_ID_NS_CS5535_IDE     0x002d
 
 #define PCI_VENDOR_ID_TSENG             0x100c
 #define PCI_DEVICE_ID_TSENG_W32P_2      0x3202
@@ -444,45 +430,29 @@
 #define PCI_DEVICE_ID_CIRRUS_5465       0x00d6
 #define PCI_DEVICE_ID_CIRRUS_6729       0x1100
 #define PCI_DEVICE_ID_CIRRUS_6832       0x1110
-#define PCI_DEVICE_ID_CIRRUS_7542       0x1200
 #define PCI_DEVICE_ID_CIRRUS_7543       0x1202
-#define PCI_DEVICE_ID_CIRRUS_7541       0x1204
 #define PCI_DEVICE_ID_CIRRUS_4610       0x6001
 #define PCI_DEVICE_ID_CIRRUS_4612       0x6003
 #define PCI_DEVICE_ID_CIRRUS_4615       0x6004
-#define PCI_DEVICE_ID_CIRRUS_4281       0x6005
 
 #define PCI_VENDOR_ID_IBM               0x1014
-#define PCI_DEVICE_ID_IBM_FIRE_CORAL    0x000a
 #define PCI_DEVICE_ID_IBM_TR            0x0018
-#define PCI_DEVICE_ID_IBM_82G2675       0x001d
-#define PCI_DEVICE_ID_IBM_MCA           0x0020
-#define PCI_DEVICE_ID_IBM_82351         0x0022
-#define PCI_DEVICE_ID_IBM_PYTHON        0x002d
-#define PCI_DEVICE_ID_IBM_SERVERAID     0x002e
 #define PCI_DEVICE_ID_IBM_TR_WAKE       0x003e
-#define PCI_DEVICE_ID_IBM_MPIC          0x0046
-#define PCI_DEVICE_ID_IBM_3780IDSP      0x007d
-#define PCI_DEVICE_ID_IBM_CHUKAR        0x0096
 #define PCI_DEVICE_ID_IBM_CPC710_PCI64  0x00fc
-#define PCI_DEVICE_ID_IBM_CPC710_PCI32  0x0105
-#define PCI_DEVICE_ID_IBM_405GP         0x0156
 #define PCI_DEVICE_ID_IBM_SNIPE         0x0180
-#define PCI_DEVICE_ID_IBM_SERVERAIDI960 0x01bd
 #define PCI_DEVICE_ID_IBM_CITRINE               0x028C
 #define PCI_DEVICE_ID_IBM_GEMSTONE              0xB166
-#define PCI_DEVICE_ID_IBM_MPIC_2        0xffff
+#define PCI_DEVICE_ID_IBM_OBSIDIAN              0x02BD
 #define PCI_DEVICE_ID_IBM_ICOM_DEV_ID_1 0x0031
 #define PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2 0x0219
 #define PCI_DEVICE_ID_IBM_ICOM_V2_TWO_PORTS_RVX         0x021A
 #define PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM     0x0251
 #define PCI_DEVICE_ID_IBM_ICOM_FOUR_PORT_MODEL  0x252
 
-#define PCI_VENDOR_ID_COMPEX2           0x101a // pci.ids says "AT&T GIS (NCR)"
+#define PCI_VENDOR_ID_COMPEX2           0x101a /* pci.ids says "AT&T GIS (NCR)" */
 #define PCI_DEVICE_ID_COMPEX2_100VG     0x0005
 
 #define PCI_VENDOR_ID_WD                0x101c
-#define PCI_DEVICE_ID_WD_7197           0x3296
 #define PCI_DEVICE_ID_WD_90C            0xc24a
 
 #define PCI_VENDOR_ID_AMI               0x101e
@@ -499,33 +469,18 @@
 #define PCI_DEVICE_ID_AMD_FE_GATE_7006  0x7006
 #define PCI_DEVICE_ID_AMD_FE_GATE_7007  0x7007
 #define PCI_DEVICE_ID_AMD_FE_GATE_700C  0x700C
-#define PCI_DEVICE_ID_AMD_FE_GATE_700D  0x700D
 #define PCI_DEVICE_ID_AMD_FE_GATE_700E  0x700E
-#define PCI_DEVICE_ID_AMD_FE_GATE_700F  0x700F
-#define PCI_DEVICE_ID_AMD_COBRA_7400    0x7400
 #define PCI_DEVICE_ID_AMD_COBRA_7401    0x7401
-#define PCI_DEVICE_ID_AMD_COBRA_7403    0x7403
-#define PCI_DEVICE_ID_AMD_COBRA_7404    0x7404
-#define PCI_DEVICE_ID_AMD_VIPER_7408    0x7408
 #define PCI_DEVICE_ID_AMD_VIPER_7409    0x7409
 #define PCI_DEVICE_ID_AMD_VIPER_740B    0x740B
-#define PCI_DEVICE_ID_AMD_VIPER_740C    0x740C
 #define PCI_DEVICE_ID_AMD_VIPER_7410    0x7410
 #define PCI_DEVICE_ID_AMD_VIPER_7411    0x7411
 #define PCI_DEVICE_ID_AMD_VIPER_7413    0x7413
-#define PCI_DEVICE_ID_AMD_VIPER_7414    0x7414
-#define PCI_DEVICE_ID_AMD_OPUS_7440     0x7440
-#       define PCI_DEVICE_ID_AMD_VIPER_7440     PCI_DEVICE_ID_AMD_OPUS_7440
+#define PCI_DEVICE_ID_AMD_VIPER_7440    0x7440
 #define PCI_DEVICE_ID_AMD_OPUS_7441     0x7441
-#       define PCI_DEVICE_ID_AMD_VIPER_7441     PCI_DEVICE_ID_AMD_OPUS_7441
 #define PCI_DEVICE_ID_AMD_OPUS_7443     0x7443
-#       define PCI_DEVICE_ID_AMD_VIPER_7443     PCI_DEVICE_ID_AMD_OPUS_7443
+#define PCI_DEVICE_ID_AMD_VIPER_7443    0x7443
 #define PCI_DEVICE_ID_AMD_OPUS_7445     0x7445
-#define PCI_DEVICE_ID_AMD_OPUS_7448     0x7448
-# define        PCI_DEVICE_ID_AMD_VIPER_7448    PCI_DEVICE_ID_AMD_OPUS_7448
-#define PCI_DEVICE_ID_AMD_OPUS_7449     0x7449
-#       define PCI_DEVICE_ID_AMD_VIPER_7449     PCI_DEVICE_ID_AMD_OPUS_7449
-#define PCI_DEVICE_ID_AMD_8111_LAN      0x7462
 #define PCI_DEVICE_ID_AMD_8111_LPC      0x7468
 #define PCI_DEVICE_ID_AMD_8111_IDE      0x7469
 #define PCI_DEVICE_ID_AMD_8111_SMBUS2   0x746a
@@ -534,6 +489,8 @@
 #define PCI_DEVICE_ID_AMD_8151_0        0x7454
 #define PCI_DEVICE_ID_AMD_8131_APIC     0x7450
 
+#define PCI_DEVICE_ID_AMD_CS5536_IDE    0x209A
+
 #define PCI_VENDOR_ID_TRIDENT           0x1023
 #define PCI_DEVICE_ID_TRIDENT_4DWAVE_DX 0x2000
 #define PCI_DEVICE_ID_TRIDENT_4DWAVE_NX 0x2001
@@ -559,12 +516,14 @@
 #define PCI_VENDOR_ID_DELL              0x1028
 #define PCI_DEVICE_ID_DELL_RACIII       0x0008
 #define PCI_DEVICE_ID_DELL_RAC4         0x0012
+#define PCI_DEVICE_ID_DELL_PERC5        0x0015
 
 #define PCI_VENDOR_ID_MATROX            0x102B
 #define PCI_DEVICE_ID_MATROX_MGA_2      0x0518
 #define PCI_DEVICE_ID_MATROX_MIL        0x0519
 #define PCI_DEVICE_ID_MATROX_MYS        0x051A
 #define PCI_DEVICE_ID_MATROX_MIL_2      0x051b
+#define PCI_DEVICE_ID_MATROX_MYS_AGP    0x051e
 #define PCI_DEVICE_ID_MATROX_MIL_2_AGP  0x051f
 #define PCI_DEVICE_ID_MATROX_MGA_IMP    0x0d10
 #define PCI_DEVICE_ID_MATROX_G100_MM    0x1000
@@ -582,7 +541,6 @@
 #define PCI_DEVICE_ID_CT_65550          0x00e0
 #define PCI_DEVICE_ID_CT_65554          0x00e4
 #define PCI_DEVICE_ID_CT_65555          0x00e5
-#define PCI_DEVICE_ID_CT_69000          0x00c0
 
 #define PCI_VENDOR_ID_MIRO              0x1031
 #define PCI_DEVICE_ID_MIRO_36050        0x5601
@@ -636,7 +594,6 @@
 #define PCI_DEVICE_ID_SI_550            0x0550
 #define PCI_DEVICE_ID_SI_540_VGA        0x5300
 #define PCI_DEVICE_ID_SI_550_VGA        0x5315
-#define PCI_DEVICE_ID_SI_601            0x0601
 #define PCI_DEVICE_ID_SI_620            0x0620
 #define PCI_DEVICE_ID_SI_630            0x0630
 #define PCI_DEVICE_ID_SI_633            0x0633
@@ -647,30 +604,23 @@
 #define PCI_DEVICE_ID_SI_648            0x0648
 #define PCI_DEVICE_ID_SI_650            0x0650
 #define PCI_DEVICE_ID_SI_651            0x0651
-#define PCI_DEVICE_ID_SI_652            0x0652
 #define PCI_DEVICE_ID_SI_655            0x0655
 #define PCI_DEVICE_ID_SI_661            0x0661
 #define PCI_DEVICE_ID_SI_730            0x0730
 #define PCI_DEVICE_ID_SI_733            0x0733
 #define PCI_DEVICE_ID_SI_630_VGA        0x6300
-#define PCI_DEVICE_ID_SI_730_VGA        0x7300
 #define PCI_DEVICE_ID_SI_735            0x0735
 #define PCI_DEVICE_ID_SI_740            0x0740
 #define PCI_DEVICE_ID_SI_741            0x0741
 #define PCI_DEVICE_ID_SI_745            0x0745
 #define PCI_DEVICE_ID_SI_746            0x0746
-#define PCI_DEVICE_ID_SI_748            0x0748
-#define PCI_DEVICE_ID_SI_750            0x0750
-#define PCI_DEVICE_ID_SI_751            0x0751
-#define PCI_DEVICE_ID_SI_752            0x0752
 #define PCI_DEVICE_ID_SI_755            0x0755
 #define PCI_DEVICE_ID_SI_760            0x0760
 #define PCI_DEVICE_ID_SI_900            0x0900
 #define PCI_DEVICE_ID_SI_961            0x0961
 #define PCI_DEVICE_ID_SI_962            0x0962
 #define PCI_DEVICE_ID_SI_963            0x0963
-#define PCI_DEVICE_ID_SI_5107           0x5107
-#define PCI_DEVICE_ID_SI_5300           0x5300
+#define PCI_DEVICE_ID_SI_965            0x0965
 #define PCI_DEVICE_ID_SI_5511           0x5511
 #define PCI_DEVICE_ID_SI_5513           0x5513
 #define PCI_DEVICE_ID_SI_5518           0x5518
@@ -682,10 +632,6 @@
 #define PCI_DEVICE_ID_SI_5597           0x5597
 #define PCI_DEVICE_ID_SI_5598           0x5598
 #define PCI_DEVICE_ID_SI_5600           0x5600
-#define PCI_DEVICE_ID_SI_6300           0x6300
-#define PCI_DEVICE_ID_SI_6306           0x6306
-#define PCI_DEVICE_ID_SI_6326           0x6326
-#define PCI_DEVICE_ID_SI_7001           0x7001
 #define PCI_DEVICE_ID_SI_7012           0x7012
 #define PCI_DEVICE_ID_SI_7013           0x7013
 #define PCI_DEVICE_ID_SI_7016           0x7016
@@ -706,23 +652,19 @@
 #define PCI_DEVICE_ID_HP_DIVA_TOSCA1    0x1049
 #define PCI_DEVICE_ID_HP_DIVA_TOSCA2    0x104A
 #define PCI_DEVICE_ID_HP_DIVA_MAESTRO   0x104B
-#define PCI_DEVICE_ID_HP_PCI_LBA        0x1054
-#define PCI_DEVICE_ID_HP_REO_SBA        0x10f0
 #define PCI_DEVICE_ID_HP_REO_IOC        0x10f1
 #define PCI_DEVICE_ID_HP_VISUALIZE_FXE  0x108b
 #define PCI_DEVICE_ID_HP_DIVA_HALFDOME  0x1223
 #define PCI_DEVICE_ID_HP_DIVA_KEYSTONE  0x1226
 #define PCI_DEVICE_ID_HP_DIVA_POWERBAR  0x1227
-#define PCI_DEVICE_ID_HP_ZX1_SBA        0x1229
 #define PCI_DEVICE_ID_HP_ZX1_IOC        0x122a
 #define PCI_DEVICE_ID_HP_PCIX_LBA       0x122e
 #define PCI_DEVICE_ID_HP_SX1000_IOC     0x127c
 #define PCI_DEVICE_ID_HP_DIVA_EVEREST   0x1282
 #define PCI_DEVICE_ID_HP_DIVA_AUX       0x1290
 #define PCI_DEVICE_ID_HP_DIVA_RMP3      0x1301
-#define PCI_DEVICE_ID_HP_CISS           0x3210
+#define PCI_DEVICE_ID_HP_DIVA_HURRICANE 0x132a
 #define PCI_DEVICE_ID_HP_CISSA          0x3220
-#define PCI_DEVICE_ID_HP_CISSB          0x3222
 #define PCI_DEVICE_ID_HP_CISSC          0x3230
 #define PCI_DEVICE_ID_HP_CISSD          0x3238
 #define PCI_DEVICE_ID_HP_ZX2_IOC        0x4031
@@ -730,8 +672,6 @@
 #define PCI_VENDOR_ID_PCTECH            0x1042
 #define PCI_DEVICE_ID_PCTECH_RZ1000     0x1000
 #define PCI_DEVICE_ID_PCTECH_RZ1001     0x1001
-#define PCI_DEVICE_ID_PCTECH_SAMURAI_0  0x3000
-#define PCI_DEVICE_ID_PCTECH_SAMURAI_1  0x3010
 #define PCI_DEVICE_ID_PCTECH_SAMURAI_IDE 0x3020
 
 #define PCI_VENDOR_ID_ASUSTEK           0x1043
@@ -741,24 +681,15 @@
 #define PCI_DEVICE_ID_DPT               0xa400
 
 #define PCI_VENDOR_ID_OPTI              0x1045
-#define PCI_DEVICE_ID_OPTI_92C178       0xc178
-#define PCI_DEVICE_ID_OPTI_82C557       0xc557
 #define PCI_DEVICE_ID_OPTI_82C558       0xc558
 #define PCI_DEVICE_ID_OPTI_82C621       0xc621
 #define PCI_DEVICE_ID_OPTI_82C700       0xc700
-#define PCI_DEVICE_ID_OPTI_82C701       0xc701
-#define PCI_DEVICE_ID_OPTI_82C814       0xc814
-#define PCI_DEVICE_ID_OPTI_82C822       0xc822
-#define PCI_DEVICE_ID_OPTI_82C861       0xc861
 #define PCI_DEVICE_ID_OPTI_82C825       0xd568
 
 #define PCI_VENDOR_ID_ELSA              0x1048
 #define PCI_DEVICE_ID_ELSA_MICROLINK    0x1000
 #define PCI_DEVICE_ID_ELSA_QS3000       0x3000
 
-#define PCI_VENDOR_ID_SGS               0x104a
-#define PCI_DEVICE_ID_SGS_2000          0x0008
-#define PCI_DEVICE_ID_SGS_1764          0x0009
 
 #define PCI_VENDOR_ID_BUSLOGIC                0x104B
 #define PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC 0x0140
@@ -766,9 +697,10 @@
 #define PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT     0x8130
 
 #define PCI_VENDOR_ID_TI                0x104c
-#define PCI_DEVICE_ID_TI_TVP4010        0x3d04
 #define PCI_DEVICE_ID_TI_TVP4020        0x3d07
 #define PCI_DEVICE_ID_TI_4450           0x8011
+#define PCI_DEVICE_ID_TI_XX21_XX11      0x8031
+#define PCI_DEVICE_ID_TI_X515           0x8036
 #define PCI_DEVICE_ID_TI_1130           0xac12
 #define PCI_DEVICE_ID_TI_1031           0xac13
 #define PCI_DEVICE_ID_TI_1131           0xac15
@@ -785,22 +717,23 @@
 #define PCI_DEVICE_ID_TI_4451           0xac42
 #define PCI_DEVICE_ID_TI_4510           0xac44
 #define PCI_DEVICE_ID_TI_4520           0xac46
+#define PCI_DEVICE_ID_TI_7510           0xac47
+#define PCI_DEVICE_ID_TI_7610           0xac48
+#define PCI_DEVICE_ID_TI_7410           0xac49
 #define PCI_DEVICE_ID_TI_1410           0xac50
 #define PCI_DEVICE_ID_TI_1420           0xac51
 #define PCI_DEVICE_ID_TI_1451A          0xac52
 #define PCI_DEVICE_ID_TI_1620           0xac54
 #define PCI_DEVICE_ID_TI_1520           0xac55
 #define PCI_DEVICE_ID_TI_1510           0xac56
+#define PCI_DEVICE_ID_TI_X620           0xac8d
+#define PCI_DEVICE_ID_TI_X420           0xac8e
 
 #define PCI_VENDOR_ID_SONY              0x104d
-#define PCI_DEVICE_ID_SONY_CXD3222      0x8039
 
-#define PCI_VENDOR_ID_OAK               0x104e
-#define PCI_DEVICE_ID_OAK_OTI107        0x0107
 
 /* Winbond have two vendor IDs! See 0x10ad as well */
 #define PCI_VENDOR_ID_WINBOND2          0x1050
-#define PCI_DEVICE_ID_WINBOND2_89C940   0x0940
 #define PCI_DEVICE_ID_WINBOND2_89C940F  0x5a5a
 #define PCI_DEVICE_ID_WINBOND2_6692     0x6692
 
@@ -809,19 +742,15 @@
   
 #define PCI_VENDOR_ID_EFAR              0x1055
 #define PCI_DEVICE_ID_EFAR_SLC90E66_1   0x9130
-#define PCI_DEVICE_ID_EFAR_SLC90E66_0   0x9460
-#define PCI_DEVICE_ID_EFAR_SLC90E66_2   0x9462
 #define PCI_DEVICE_ID_EFAR_SLC90E66_3   0x9463
 
 #define PCI_VENDOR_ID_MOTOROLA          0x1057
-#define PCI_VENDOR_ID_MOTOROLA_OOPS     0x1507
 #define PCI_DEVICE_ID_MOTOROLA_MPC105   0x0001
 #define PCI_DEVICE_ID_MOTOROLA_MPC106   0x0002
 #define PCI_DEVICE_ID_MOTOROLA_MPC107   0x0004
 #define PCI_DEVICE_ID_MOTOROLA_RAVEN    0x4801
 #define PCI_DEVICE_ID_MOTOROLA_FALCON   0x4802
 #define PCI_DEVICE_ID_MOTOROLA_HAWK     0x4803
-#define PCI_DEVICE_ID_MOTOROLA_CPX8216  0x4806
 #define PCI_DEVICE_ID_MOTOROLA_HARRIER  0x480b
 #define PCI_DEVICE_ID_MOTOROLA_MPC5200  0x5803
 
@@ -832,33 +761,19 @@
 #define PCI_DEVICE_ID_PROMISE_20262     0x4d38
 #define PCI_DEVICE_ID_PROMISE_20263     0x0D38
 #define PCI_DEVICE_ID_PROMISE_20268     0x4d68
-#define PCI_DEVICE_ID_PROMISE_20268R    0x6268
 #define PCI_DEVICE_ID_PROMISE_20269     0x4d69
 #define PCI_DEVICE_ID_PROMISE_20270     0x6268
 #define PCI_DEVICE_ID_PROMISE_20271     0x6269
 #define PCI_DEVICE_ID_PROMISE_20275     0x1275
 #define PCI_DEVICE_ID_PROMISE_20276     0x5275
 #define PCI_DEVICE_ID_PROMISE_20277     0x7275
-#define PCI_DEVICE_ID_PROMISE_5300      0x5300
 
-#define PCI_VENDOR_ID_N9                0x105d
-#define PCI_DEVICE_ID_N9_I128           0x2309
-#define PCI_DEVICE_ID_N9_I128_2         0x2339
-#define PCI_DEVICE_ID_N9_I128_T2R       0x493d
 
 #define PCI_VENDOR_ID_UMC               0x1060
 #define PCI_DEVICE_ID_UMC_UM8673F       0x0101
-#define PCI_DEVICE_ID_UMC_UM8891A       0x0891
 #define PCI_DEVICE_ID_UMC_UM8886BF      0x673a
 #define PCI_DEVICE_ID_UMC_UM8886A       0x886a
-#define PCI_DEVICE_ID_UMC_UM8881F       0x8881
-#define PCI_DEVICE_ID_UMC_UM8886F       0x8886
-#define PCI_DEVICE_ID_UMC_UM9017F       0x9017
-#define PCI_DEVICE_ID_UMC_UM8886N       0xe886
-#define PCI_DEVICE_ID_UMC_UM8891N       0xe891
 
-#define PCI_VENDOR_ID_X                 0x1061
-#define PCI_DEVICE_ID_X_AGX016          0x0001
 
 #define PCI_VENDOR_ID_MYLEX             0x1069
 #define PCI_DEVICE_ID_MYLEX_DAC960_P    0x0001
@@ -869,39 +784,32 @@
 #define PCI_DEVICE_ID_MYLEX_DAC960_BA   0xBA56
 #define PCI_DEVICE_ID_MYLEX_DAC960_GEM  0xB166
 
-#define PCI_VENDOR_ID_PICOP             0x1066
-#define PCI_DEVICE_ID_PICOP_PT86C52X    0x0001
-#define PCI_DEVICE_ID_PICOP_PT80C524    0x8002
 
 #define PCI_VENDOR_ID_APPLE             0x106b
 #define PCI_DEVICE_ID_APPLE_BANDIT      0x0001
-#define PCI_DEVICE_ID_APPLE_GC          0x0002
 #define PCI_DEVICE_ID_APPLE_HYDRA       0x000e
 #define PCI_DEVICE_ID_APPLE_UNI_N_FW    0x0018
-#define PCI_DEVICE_ID_APPLE_KL_USB      0x0019
 #define PCI_DEVICE_ID_APPLE_UNI_N_AGP   0x0020
 #define PCI_DEVICE_ID_APPLE_UNI_N_GMAC  0x0021
-#define PCI_DEVICE_ID_APPLE_KEYLARGO    0x0022
 #define PCI_DEVICE_ID_APPLE_UNI_N_GMACP 0x0024
-#define PCI_DEVICE_ID_APPLE_KEYLARGO_P  0x0025
-#define PCI_DEVICE_ID_APPLE_KL_USB_P    0x0026
 #define PCI_DEVICE_ID_APPLE_UNI_N_AGP_P 0x0027
 #define PCI_DEVICE_ID_APPLE_UNI_N_AGP15 0x002d
 #define PCI_DEVICE_ID_APPLE_UNI_N_PCI15 0x002e
-#define PCI_DEVICE_ID_APPLE_UNI_N_FW2   0x0030
 #define PCI_DEVICE_ID_APPLE_UNI_N_GMAC2 0x0032
 #define PCI_DEVICE_ID_APPLE_UNI_N_ATA   0x0033
 #define PCI_DEVICE_ID_APPLE_UNI_N_AGP2  0x0034
 #define PCI_DEVICE_ID_APPLE_IPID_ATA100 0x003b
-#define PCI_DEVICE_ID_APPLE_KEYLARGO_I  0x003e
 #define PCI_DEVICE_ID_APPLE_K2_ATA100   0x0043
 #define PCI_DEVICE_ID_APPLE_U3_AGP      0x004b
 #define PCI_DEVICE_ID_APPLE_K2_GMAC     0x004c
 #define PCI_DEVICE_ID_APPLE_SH_ATA      0x0050
 #define PCI_DEVICE_ID_APPLE_SH_SUNGEM   0x0051
-#define PCI_DEVICE_ID_APPLE_SH_FW       0x0052
 #define PCI_DEVICE_ID_APPLE_U3L_AGP     0x0058
 #define PCI_DEVICE_ID_APPLE_U3H_AGP     0x0059
+#define PCI_DEVICE_ID_APPLE_IPID2_AGP   0x0066
+#define PCI_DEVICE_ID_APPLE_IPID2_ATA   0x0069
+#define PCI_DEVICE_ID_APPLE_IPID2_FW    0x006a
+#define PCI_DEVICE_ID_APPLE_IPID2_GMAC  0x006b
 #define PCI_DEVICE_ID_APPLE_TIGON3      0x1645
 
 #define PCI_VENDOR_ID_YAMAHA            0x1073
@@ -912,12 +820,9 @@
 #define PCI_DEVICE_ID_YAMAHA_744        0x0010
 #define PCI_DEVICE_ID_YAMAHA_754        0x0012
 
-#define PCI_VENDOR_ID_NEXGEN            0x1074
-#define PCI_DEVICE_ID_NEXGEN_82C501     0x4e78
 
 #define PCI_VENDOR_ID_QLOGIC            0x1077
 #define PCI_DEVICE_ID_QLOGIC_ISP1020    0x1020
-#define PCI_DEVICE_ID_QLOGIC_ISP1022    0x1022
 #define PCI_DEVICE_ID_QLOGIC_ISP2100    0x2100
 #define PCI_DEVICE_ID_QLOGIC_ISP2200    0x2200
 #define PCI_DEVICE_ID_QLOGIC_ISP2300    0x2300
@@ -935,32 +840,20 @@
 #define PCI_DEVICE_ID_CYRIX_PCI_MASTER  0x0001
 #define PCI_DEVICE_ID_CYRIX_5520        0x0002
 #define PCI_DEVICE_ID_CYRIX_5530_LEGACY 0x0100
-#define PCI_DEVICE_ID_CYRIX_5530_SMI    0x0101
 #define PCI_DEVICE_ID_CYRIX_5530_IDE    0x0102
 #define PCI_DEVICE_ID_CYRIX_5530_AUDIO  0x0103
 #define PCI_DEVICE_ID_CYRIX_5530_VIDEO  0x0104
 
-#define PCI_VENDOR_ID_LEADTEK           0x107d
-#define PCI_DEVICE_ID_LEADTEK_805       0x0000
 
-#define PCI_VENDOR_ID_INTERPHASE        0x107e
-#define PCI_DEVICE_ID_INTERPHASE_5526   0x0004
-#define PCI_DEVICE_ID_INTERPHASE_55x6   0x0005
-#define PCI_DEVICE_ID_INTERPHASE_5575   0x0008
 
 #define PCI_VENDOR_ID_CONTAQ            0x1080
-#define PCI_DEVICE_ID_CONTAQ_82C599     0x0600
 #define PCI_DEVICE_ID_CONTAQ_82C693     0xc693
 
-#define PCI_VENDOR_ID_FOREX             0x1083
 
 #define PCI_VENDOR_ID_OLICOM            0x108d
-#define PCI_DEVICE_ID_OLICOM_OC3136     0x0001
-#define PCI_DEVICE_ID_OLICOM_OC2315     0x0011
 #define PCI_DEVICE_ID_OLICOM_OC2325     0x0012
 #define PCI_DEVICE_ID_OLICOM_OC2183     0x0013
 #define PCI_DEVICE_ID_OLICOM_OC2326     0x0014
-#define PCI_DEVICE_ID_OLICOM_OC6151     0x0021
 
 #define PCI_VENDOR_ID_SUN               0x108e
 #define PCI_DEVICE_ID_SUN_EBUS          0x1000
@@ -976,51 +869,34 @@
 #define PCI_DEVICE_ID_SUN_SABRE         0xa000
 #define PCI_DEVICE_ID_SUN_HUMMINGBIRD   0xa001
 #define PCI_DEVICE_ID_SUN_TOMATILLO     0xa801
+#define PCI_DEVICE_ID_SUN_CASSINI       0xabba
 
 #define PCI_VENDOR_ID_CMD               0x1095
-#define PCI_DEVICE_ID_CMD_640           0x0640
 #define PCI_DEVICE_ID_CMD_643           0x0643
 #define PCI_DEVICE_ID_CMD_646           0x0646
-#define PCI_DEVICE_ID_CMD_647           0x0647
 #define PCI_DEVICE_ID_CMD_648           0x0648
 #define PCI_DEVICE_ID_CMD_649           0x0649
-#define PCI_DEVICE_ID_CMD_670           0x0670
-#define PCI_DEVICE_ID_CMD_680           0x0680
 
 #define PCI_DEVICE_ID_SII_680           0x0680
 #define PCI_DEVICE_ID_SII_3112          0x3112
 #define PCI_DEVICE_ID_SII_1210SA        0x0240
 
-#define PCI_VENDOR_ID_VISION            0x1098
-#define PCI_DEVICE_ID_VISION_QD8500     0x0001
-#define PCI_DEVICE_ID_VISION_QD8580     0x0002
 
 #define PCI_VENDOR_ID_BROOKTREE         0x109e
-#define PCI_DEVICE_ID_BROOKTREE_848     0x0350
-#define PCI_DEVICE_ID_BROOKTREE_849A    0x0351
-#define PCI_DEVICE_ID_BROOKTREE_878_1   0x036e
 #define PCI_DEVICE_ID_BROOKTREE_878     0x0878
 #define PCI_DEVICE_ID_BROOKTREE_879     0x0879
-#define PCI_DEVICE_ID_BROOKTREE_8474    0x8474
 
-#define PCI_VENDOR_ID_SIERRA            0x10a8
-#define PCI_DEVICE_ID_SIERRA_STB        0x0000
 
 #define PCI_VENDOR_ID_SGI               0x10a9
 #define PCI_DEVICE_ID_SGI_IOC3          0x0003
 #define PCI_DEVICE_ID_SGI_IOC4          0x100a
 #define PCI_VENDOR_ID_SGI_LITHIUM       0x1002
 
-#define PCI_VENDOR_ID_ACC               0x10aa
-#define PCI_DEVICE_ID_ACC_2056          0x0000
 
 #define PCI_VENDOR_ID_WINBOND           0x10ad
-#define PCI_DEVICE_ID_WINBOND_83769     0x0001
 #define PCI_DEVICE_ID_WINBOND_82C105    0x0105
 #define PCI_DEVICE_ID_WINBOND_83C553    0x0565
 
-#define PCI_VENDOR_ID_DATABOOK          0x10b3
-#define PCI_DEVICE_ID_DATABOOK_87144    0xb106
 
 #define PCI_VENDOR_ID_PLX               0x10b5
 #define PCI_DEVICE_ID_PLX_R685          0x1030
@@ -1031,33 +907,19 @@
 #define PCI_DEVICE_ID_PLX_DJINN_ITOO    0x1151
 #define PCI_DEVICE_ID_PLX_R753          0x1152
 #define PCI_DEVICE_ID_PLX_OLITEC        0x1187
-#define PCI_DEVICE_ID_PLX_9030          0x9030
 #define PCI_DEVICE_ID_PLX_9050          0x9050
-#define PCI_DEVICE_ID_PLX_9060          0x9060
-#define PCI_DEVICE_ID_PLX_9060ES        0x906E
-#define PCI_DEVICE_ID_PLX_9060SD        0x906D
 #define PCI_DEVICE_ID_PLX_9080          0x9080
 #define PCI_DEVICE_ID_PLX_GTEK_SERIAL2  0xa001
 
 #define PCI_VENDOR_ID_MADGE             0x10b6
 #define PCI_DEVICE_ID_MADGE_MK2         0x0002
-#define PCI_DEVICE_ID_MADGE_C155S       0x1001
 
 #define PCI_VENDOR_ID_3COM              0x10b7
 #define PCI_DEVICE_ID_3COM_3C985        0x0001
 #define PCI_DEVICE_ID_3COM_3C940        0x1700
 #define PCI_DEVICE_ID_3COM_3C339        0x3390
 #define PCI_DEVICE_ID_3COM_3C359        0x3590
-#define PCI_DEVICE_ID_3COM_3C590        0x5900
-#define PCI_DEVICE_ID_3COM_3C595TX      0x5950
-#define PCI_DEVICE_ID_3COM_3C595T4      0x5951
-#define PCI_DEVICE_ID_3COM_3C595MII     0x5952
 #define PCI_DEVICE_ID_3COM_3C940B       0x80eb
-#define PCI_DEVICE_ID_3COM_3C900TPO     0x9000
-#define PCI_DEVICE_ID_3COM_3C900COMBO   0x9001
-#define PCI_DEVICE_ID_3COM_3C905TX      0x9050
-#define PCI_DEVICE_ID_3COM_3C905T4      0x9051
-#define PCI_DEVICE_ID_3COM_3C905B_TX    0x9055
 #define PCI_DEVICE_ID_3COM_3CR990       0x9900
 #define PCI_DEVICE_ID_3COM_3CR990_TX_95 0x9902
 #define PCI_DEVICE_ID_3COM_3CR990_TX_97 0x9903
@@ -1067,24 +929,11 @@
 #define PCI_DEVICE_ID_3COM_3CR990SVR97  0x9909
 #define PCI_DEVICE_ID_3COM_3CR990SVR    0x990a
 
-#define PCI_VENDOR_ID_SMC               0x10b8
-#define PCI_DEVICE_ID_SMC_EPIC100       0x0005
 
 #define PCI_VENDOR_ID_AL                0x10b9
-#define PCI_DEVICE_ID_AL_M1445          0x1445
-#define PCI_DEVICE_ID_AL_M1449          0x1449
-#define PCI_DEVICE_ID_AL_M1451          0x1451
-#define PCI_DEVICE_ID_AL_M1461          0x1461
-#define PCI_DEVICE_ID_AL_M1489          0x1489
-#define PCI_DEVICE_ID_AL_M1511          0x1511
-#define PCI_DEVICE_ID_AL_M1513          0x1513
-#define PCI_DEVICE_ID_AL_M1521          0x1521
-#define PCI_DEVICE_ID_AL_M1523          0x1523
-#define PCI_DEVICE_ID_AL_M1531          0x1531
 #define PCI_DEVICE_ID_AL_M1533          0x1533
 #define PCI_DEVICE_ID_AL_M1535          0x1535
 #define PCI_DEVICE_ID_AL_M1541          0x1541
-#define PCI_DEVICE_ID_AL_M1543          0x1543
 #define PCI_DEVICE_ID_AL_M1563          0x1563
 #define PCI_DEVICE_ID_AL_M1621          0x1621
 #define PCI_DEVICE_ID_AL_M1631          0x1631
@@ -1097,49 +946,23 @@
 #define PCI_DEVICE_ID_AL_M1681          0x1681
 #define PCI_DEVICE_ID_AL_M1683          0x1683
 #define PCI_DEVICE_ID_AL_M1689          0x1689
-#define PCI_DEVICE_ID_AL_M3307          0x3307
-#define PCI_DEVICE_ID_AL_M4803          0x5215
 #define PCI_DEVICE_ID_AL_M5219          0x5219
 #define PCI_DEVICE_ID_AL_M5228          0x5228
 #define PCI_DEVICE_ID_AL_M5229          0x5229
-#define PCI_DEVICE_ID_AL_M5237          0x5237
-#define PCI_DEVICE_ID_AL_M5243          0x5243
 #define PCI_DEVICE_ID_AL_M5451          0x5451
 #define PCI_DEVICE_ID_AL_M7101          0x7101
 
-#define PCI_VENDOR_ID_MITSUBISHI        0x10ba
 
-#define PCI_VENDOR_ID_SURECOM           0x10bd
-#define PCI_DEVICE_ID_SURECOM_NE34      0x0e34
 
 #define PCI_VENDOR_ID_NEOMAGIC          0x10c8
-#define PCI_DEVICE_ID_NEOMAGIC_MAGICGRAPH_NM2070 0x0001
-#define PCI_DEVICE_ID_NEOMAGIC_MAGICGRAPH_128V 0x0002
-#define PCI_DEVICE_ID_NEOMAGIC_MAGICGRAPH_128ZV 0x0003
-#define PCI_DEVICE_ID_NEOMAGIC_MAGICGRAPH_NM2160 0x0004
-#define PCI_DEVICE_ID_NEOMAGIC_MAGICMEDIA_256AV       0x0005
-#define PCI_DEVICE_ID_NEOMAGIC_MAGICGRAPH_128ZVPLUS   0x0083
 #define PCI_DEVICE_ID_NEOMAGIC_NM256AV_AUDIO 0x8005
 #define PCI_DEVICE_ID_NEOMAGIC_NM256ZX_AUDIO 0x8006
 #define PCI_DEVICE_ID_NEOMAGIC_NM256XL_PLUS_AUDIO 0x8016
 
-#define PCI_VENDOR_ID_ASP               0x10cd
-#define PCI_DEVICE_ID_ASP_ABP940        0x1200
-#define PCI_DEVICE_ID_ASP_ABP940U       0x1300
-#define PCI_DEVICE_ID_ASP_ABP940UW      0x2300
-
-#define PCI_VENDOR_ID_MACRONIX          0x10d9
-#define PCI_DEVICE_ID_MACRONIX_MX98713  0x0512
-#define PCI_DEVICE_ID_MACRONIX_MX987x5  0x0531
 
 #define PCI_VENDOR_ID_TCONRAD           0x10da
 #define PCI_DEVICE_ID_TCONRAD_TOKENRING 0x0508
 
-#define PCI_VENDOR_ID_CERN              0x10dc
-#define PCI_DEVICE_ID_CERN_SPSB_PMC     0x0001
-#define PCI_DEVICE_ID_CERN_SPSB_PCI     0x0002
-#define PCI_DEVICE_ID_CERN_HIPPI_DST    0x0021
-#define PCI_DEVICE_ID_CERN_HIPPI_SRC    0x0022
 
 #define PCI_VENDOR_ID_NVIDIA                    0x10de
 #define PCI_DEVICE_ID_NVIDIA_TNT                0x0020
@@ -1177,6 +1000,10 @@
 #define PCI_DEVICE_ID_NVIDIA_CK8_AUDIO          0x008a
 #define PCI_DEVICE_ID_NVIDIA_NVENET_5           0x008c
 #define PCI_DEVICE_ID_NVIDIA_NFORCE2S_SATA      0x008e
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_7800_GT   0x0090
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_7800_GTX   0x0091
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_GO_7800   0x0098
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_GO_7800_GTX 0x0099
 #define PCI_DEVICE_ID_NVIDIA_ITNT2              0x00A0
 #define PCI_DEVICE_ID_GEFORCE_6800A             0x00c1
 #define PCI_DEVICE_ID_GEFORCE_6800A_LE          0x00c2
@@ -1185,7 +1012,6 @@
 #define PCI_DEVICE_ID_QUADRO_FX_GO1400          0x00cc
 #define PCI_DEVICE_ID_QUADRO_FX_1400            0x00ce
 #define PCI_DEVICE_ID_NVIDIA_NFORCE3            0x00d1
-#define PCI_DEVICE_ID_NVIDIA_MCP3_AUDIO         0x00da
 #define PCI_DEVICE_ID_NVIDIA_NFORCE3_SMBUS      0x00d4
 #define PCI_DEVICE_ID_NVIDIA_NFORCE3_IDE        0x00d5
 #define PCI_DEVICE_ID_NVIDIA_NVENET_3           0x00d6
@@ -1268,10 +1094,10 @@
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA  0x0266
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA2 0x0267
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_IDE   0x036E
-#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA  0x036F
+#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA  0x037E
+#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA2 0x037F
 #define PCI_DEVICE_ID_NVIDIA_NVENET_12          0x0268
 #define PCI_DEVICE_ID_NVIDIA_NVENET_13          0x0269
-#define PCI_DEVICE_ID_NVIDIA_MCP51_AUDIO        0x026B
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4800   0x0280
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4800_8X    0x0281
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4800SE     0x0282
@@ -1322,24 +1148,13 @@
 #define PCI_DEVICE_ID_NVIDIA_NVENET_15              0x0373
 
 #define PCI_VENDOR_ID_IMS               0x10e0
-#define PCI_DEVICE_ID_IMS_8849          0x8849
 #define PCI_DEVICE_ID_IMS_TT128         0x9128
 #define PCI_DEVICE_ID_IMS_TT3D          0x9135
 
-#define PCI_VENDOR_ID_TEKRAM2           0x10e1
-#define PCI_DEVICE_ID_TEKRAM2_690c      0x690c
 
-#define PCI_VENDOR_ID_TUNDRA            0x10e3
-#define PCI_DEVICE_ID_TUNDRA_CA91C042   0x0000
 
-#define PCI_VENDOR_ID_AMCC              0x10e8
-#define PCI_DEVICE_ID_AMCC_MYRINET      0x8043
-#define PCI_DEVICE_ID_AMCC_PARASTATION  0x8062
-#define PCI_DEVICE_ID_AMCC_S5933        0x807d
-#define PCI_DEVICE_ID_AMCC_S5933_HEPC3  0x809c
 
 #define PCI_VENDOR_ID_INTERG            0x10ea
-#define PCI_DEVICE_ID_INTERG_1680       0x1680
 #define PCI_DEVICE_ID_INTERG_1682       0x1682
 #define PCI_DEVICE_ID_INTERG_2000       0x2000
 #define PCI_DEVICE_ID_INTERG_2010       0x2010
@@ -1347,32 +1162,23 @@
 #define PCI_DEVICE_ID_INTERG_5050       0x5050
 
 #define PCI_VENDOR_ID_REALTEK           0x10ec
-#define PCI_DEVICE_ID_REALTEK_8029      0x8029
-#define PCI_DEVICE_ID_REALTEK_8129      0x8129
 #define PCI_DEVICE_ID_REALTEK_8139      0x8139
-#define PCI_DEVICE_ID_REALTEK_8169      0x8169
 
 #define PCI_VENDOR_ID_XILINX            0x10ee
 #define PCI_DEVICE_ID_RME_DIGI96        0x3fc0
 #define PCI_DEVICE_ID_RME_DIGI96_8      0x3fc1
 #define PCI_DEVICE_ID_RME_DIGI96_8_PRO  0x3fc2
 #define PCI_DEVICE_ID_RME_DIGI96_8_PAD_OR_PST 0x3fc3
-#define PCI_DEVICE_ID_XILINX_HAMMERFALL 0x3fc4
 #define PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP 0x3fc5
 #define PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP_MADI 0x3fc6
-#define PCI_DEVICE_ID_TURBOPAM          0x4020
 
-#define PCI_VENDOR_ID_TRUEVISION        0x10fa
-#define PCI_DEVICE_ID_TRUEVISION_T1000  0x000c
 
 #define PCI_VENDOR_ID_INIT              0x1101
-#define PCI_DEVICE_ID_INIT_320P         0x9100
-#define PCI_DEVICE_ID_INIT_360P         0x9500
 
-#define PCI_VENDOR_ID_CREATIVE          0x1102 // duplicate: ECTIVA
+#define PCI_VENDOR_ID_CREATIVE          0x1102 /* duplicate: ECTIVA */
 #define PCI_DEVICE_ID_CREATIVE_EMU10K1  0x0002
 
-#define PCI_VENDOR_ID_ECTIVA            0x1102 // duplicate: CREATIVE
+#define PCI_VENDOR_ID_ECTIVA            0x1102 /* duplicate: CREATIVE */
 #define PCI_DEVICE_ID_ECTIVA_EV1938     0x8938
 
 #define PCI_VENDOR_ID_TTI               0x1103
@@ -1382,7 +1188,7 @@
 #define PCI_DEVICE_ID_TTI_HPT302        0x0006
 #define PCI_DEVICE_ID_TTI_HPT371        0x0007
 #define PCI_DEVICE_ID_TTI_HPT374        0x0008
-#define PCI_DEVICE_ID_TTI_HPT372N       0x0009  // apparently a 372N variant?
+#define PCI_DEVICE_ID_TTI_HPT372N       0x0009  /* apparently a 372N variant? */
 
 #define PCI_VENDOR_ID_VIA               0x1106
 #define PCI_DEVICE_ID_VIA_8763_0        0x0198
@@ -1393,38 +1199,28 @@
 #define PCI_DEVICE_ID_VIA_3269_0        0x0269
 #define PCI_DEVICE_ID_VIA_K8T800PRO_0   0x0282
 #define PCI_DEVICE_ID_VIA_8363_0        0x0305
+#define PCI_DEVICE_ID_VIA_P4M800CE      0x0314
 #define PCI_DEVICE_ID_VIA_8371_0        0x0391
 #define PCI_DEVICE_ID_VIA_8501_0        0x0501
-#define PCI_DEVICE_ID_VIA_82C505        0x0505
 #define PCI_DEVICE_ID_VIA_82C561        0x0561
 #define PCI_DEVICE_ID_VIA_82C586_1      0x0571
 #define PCI_DEVICE_ID_VIA_82C576        0x0576
-#define PCI_DEVICE_ID_VIA_82C585        0x0585
 #define PCI_DEVICE_ID_VIA_82C586_0      0x0586
-#define PCI_DEVICE_ID_VIA_82C595        0x0595
 #define PCI_DEVICE_ID_VIA_82C596        0x0596
 #define PCI_DEVICE_ID_VIA_82C597_0      0x0597
 #define PCI_DEVICE_ID_VIA_82C598_0      0x0598
 #define PCI_DEVICE_ID_VIA_8601_0        0x0601
 #define PCI_DEVICE_ID_VIA_8605_0        0x0605
-#define PCI_DEVICE_ID_VIA_82C680        0x0680
 #define PCI_DEVICE_ID_VIA_82C686        0x0686
 #define PCI_DEVICE_ID_VIA_82C691_0      0x0691
-#define PCI_DEVICE_ID_VIA_82C693        0x0693
-#define PCI_DEVICE_ID_VIA_82C693_1      0x0698
-#define PCI_DEVICE_ID_VIA_82C926        0x0926
 #define PCI_DEVICE_ID_VIA_82C576_1      0x1571
-#define PCI_DEVICE_ID_VIA_82C595_97     0x1595
 #define PCI_DEVICE_ID_VIA_82C586_2      0x3038
 #define PCI_DEVICE_ID_VIA_82C586_3      0x3040
-#define PCI_DEVICE_ID_VIA_6305          0x3044
 #define PCI_DEVICE_ID_VIA_82C596_3      0x3050
 #define PCI_DEVICE_ID_VIA_82C596B_3     0x3051
 #define PCI_DEVICE_ID_VIA_82C686_4      0x3057
 #define PCI_DEVICE_ID_VIA_82C686_5      0x3058
 #define PCI_DEVICE_ID_VIA_8233_5        0x3059
-#define PCI_DEVICE_ID_VIA_8233_7        0x3065
-#define PCI_DEVICE_ID_VIA_82C686_6      0x3068
 #define PCI_DEVICE_ID_VIA_8233_0        0x3074
 #define PCI_DEVICE_ID_VIA_8633_0        0x3091
 #define PCI_DEVICE_ID_VIA_8367_0        0x3099
@@ -1440,40 +1236,26 @@
 #define PCI_DEVICE_ID_VIA_8703_51_0     0x3148
 #define PCI_DEVICE_ID_VIA_8237_SATA     0x3149
 #define PCI_DEVICE_ID_VIA_XN266         0x3156
+#define PCI_DEVICE_ID_VIA_6410          0x3164
 #define PCI_DEVICE_ID_VIA_8754C_0       0x3168
 #define PCI_DEVICE_ID_VIA_8235          0x3177
-#define PCI_DEVICE_ID_VIA_P4N333        0x3178
 #define PCI_DEVICE_ID_VIA_8385_0        0x3188
 #define PCI_DEVICE_ID_VIA_8377_0        0x3189
 #define PCI_DEVICE_ID_VIA_8378_0        0x3205
 #define PCI_DEVICE_ID_VIA_8783_0        0x3208
-#define PCI_DEVICE_ID_VIA_P4M400        0x3209
 #define PCI_DEVICE_ID_VIA_8237          0x3227
 #define PCI_DEVICE_ID_VIA_3296_0        0x0296
-#define PCI_DEVICE_ID_VIA_86C100A       0x6100
 #define PCI_DEVICE_ID_VIA_8231          0x8231
 #define PCI_DEVICE_ID_VIA_8231_4        0x8235
 #define PCI_DEVICE_ID_VIA_8365_1        0x8305
 #define PCI_DEVICE_ID_VIA_8371_1        0x8391
-#define PCI_DEVICE_ID_VIA_8501_1        0x8501
-#define PCI_DEVICE_ID_VIA_82C597_1      0x8597
 #define PCI_DEVICE_ID_VIA_82C598_1      0x8598
-#define PCI_DEVICE_ID_VIA_8601_1        0x8601
-#define PCI_DEVICE_ID_VIA_8505_1        0x8605
-#define PCI_DEVICE_ID_VIA_8633_1        0xB091
-#define PCI_DEVICE_ID_VIA_8367_1        0xB099
-#define PCI_DEVICE_ID_VIA_P4X266_1      0xB101
-#define PCI_DEVICE_ID_VIA_8615_1        0xB103
-#define PCI_DEVICE_ID_VIA_8361_1        0xB112
-#define PCI_DEVICE_ID_VIA_8235_1        0xB168
 #define PCI_DEVICE_ID_VIA_838X_1        0xB188
 #define PCI_DEVICE_ID_VIA_83_87XX_1     0xB198
 
 #define PCI_VENDOR_ID_SIEMENS           0x110A
 #define PCI_DEVICE_ID_SIEMENS_DSCC4     0x2102
 
-#define PCI_VENDOR_ID_SMC2              0x1113
-#define PCI_DEVICE_ID_SMC2_1211TX       0x1211
 
 #define PCI_VENDOR_ID_VORTEX            0x1119
 #define PCI_DEVICE_ID_VORTEX_GDT60x0    0x0000
@@ -1496,18 +1278,6 @@
 #define PCI_DEVICE_ID_VORTEX_GDT6557RP  0x0103
 #define PCI_DEVICE_ID_VORTEX_GDT6x11RP  0x0104
 #define PCI_DEVICE_ID_VORTEX_GDT6x21RP  0x0105
-#define PCI_DEVICE_ID_VORTEX_GDT6x17RP1 0x0110
-#define PCI_DEVICE_ID_VORTEX_GDT6x27RP1 0x0111
-#define PCI_DEVICE_ID_VORTEX_GDT6537RP1 0x0112
-#define PCI_DEVICE_ID_VORTEX_GDT6557RP1 0x0113
-#define PCI_DEVICE_ID_VORTEX_GDT6x11RP1 0x0114
-#define PCI_DEVICE_ID_VORTEX_GDT6x21RP1 0x0115
-#define PCI_DEVICE_ID_VORTEX_GDT6x17RP2 0x0120
-#define PCI_DEVICE_ID_VORTEX_GDT6x27RP2 0x0121
-#define PCI_DEVICE_ID_VORTEX_GDT6537RP2 0x0122
-#define PCI_DEVICE_ID_VORTEX_GDT6557RP2 0x0123
-#define PCI_DEVICE_ID_VORTEX_GDT6x11RP2 0x0124
-#define PCI_DEVICE_ID_VORTEX_GDT6x21RP2 0x0125
 
 #define PCI_VENDOR_ID_EF                0x111a
 #define PCI_DEVICE_ID_EF_ATM_FPGA       0x0000
@@ -1519,21 +1289,15 @@
 #define PCI_DEVICE_ID_IDT_IDT77201      0x0001
 
 #define PCI_VENDOR_ID_FORE              0x1127
-#define PCI_DEVICE_ID_FORE_PCA200PC     0x0210
 #define PCI_DEVICE_ID_FORE_PCA200E      0x0300
 
-#define PCI_VENDOR_ID_IMAGINGTECH       0x112f
-#define PCI_DEVICE_ID_IMAGINGTECH_ICPCI 0x0000
 
 #define PCI_VENDOR_ID_PHILIPS           0x1131
-#define PCI_DEVICE_ID_PHILIPS_SAA7145   0x7145
 #define PCI_DEVICE_ID_PHILIPS_SAA7146   0x7146
 #define PCI_DEVICE_ID_PHILIPS_SAA9730   0x9730
 
 #define PCI_VENDOR_ID_EICON             0x1133
-#define PCI_DEVICE_ID_EICON_DIVA20PRO   0xe001
 #define PCI_DEVICE_ID_EICON_DIVA20      0xe002
-#define PCI_DEVICE_ID_EICON_DIVA20PRO_U 0xe003
 #define PCI_DEVICE_ID_EICON_DIVA20_U    0xe004
 #define PCI_DEVICE_ID_EICON_DIVA201     0xe005
 #define PCI_DEVICE_ID_EICON_DIVA202     0xe00b
@@ -1545,35 +1309,17 @@
 #define PCI_VENDOR_ID_ZIATECH           0x1138
 #define PCI_DEVICE_ID_ZIATECH_5550_HC   0x5550
  
-#define PCI_VENDOR_ID_CYCLONE           0x113c
-#define PCI_DEVICE_ID_CYCLONE_SDK       0x0001
 
-#define PCI_VENDOR_ID_ALLIANCE          0x1142
-#define PCI_DEVICE_ID_ALLIANCE_PROMOTIO 0x3210
-#define PCI_DEVICE_ID_ALLIANCE_PROVIDEO 0x6422
-#define PCI_DEVICE_ID_ALLIANCE_AT24     0x6424
-#define PCI_DEVICE_ID_ALLIANCE_AT3D     0x643d
 
 #define PCI_VENDOR_ID_SYSKONNECT        0x1148
-#define PCI_DEVICE_ID_SYSKONNECT_FP     0x4000
 #define PCI_DEVICE_ID_SYSKONNECT_TR     0x4200
 #define PCI_DEVICE_ID_SYSKONNECT_GE     0x4300
 #define PCI_DEVICE_ID_SYSKONNECT_YU     0x4320
 #define PCI_DEVICE_ID_SYSKONNECT_9DXX   0x4400
 #define PCI_DEVICE_ID_SYSKONNECT_9MXX   0x4500
 
-#define PCI_VENDOR_ID_VMIC              0x114a
-#define PCI_DEVICE_ID_VMIC_VME          0x7587
 
 #define PCI_VENDOR_ID_DIGI              0x114f
-#define PCI_DEVICE_ID_DIGI_EPC          0x0002
-#define PCI_DEVICE_ID_DIGI_RIGHTSWITCH  0x0003
-#define PCI_DEVICE_ID_DIGI_XEM          0x0004
-#define PCI_DEVICE_ID_DIGI_XR           0x0005
-#define PCI_DEVICE_ID_DIGI_CX           0x0006
-#define PCI_DEVICE_ID_DIGI_XRJ          0x0009
-#define PCI_DEVICE_ID_DIGI_EPCJ         0x000a
-#define PCI_DEVICE_ID_DIGI_XR_920       0x0027
 #define PCI_DEVICE_ID_DIGI_DF_M_IOM2_E  0x0070
 #define PCI_DEVICE_ID_DIGI_DF_M_E       0x0071
 #define PCI_DEVICE_ID_DIGI_DF_M_IOM2_A  0x0072
@@ -1583,23 +1329,15 @@
 #define PCI_DEVICE_ID_NEO_2RJ45         0x00CA
 #define PCI_DEVICE_ID_NEO_2RJ45PRI      0x00CB
 
-#define PCI_VENDOR_ID_MUTECH            0x1159
-#define PCI_DEVICE_ID_MUTECH_MV1000     0x0001
 
 #define PCI_VENDOR_ID_XIRCOM            0x115d
-#define PCI_DEVICE_ID_XIRCOM_X3201_ETH  0x0003
 #define PCI_DEVICE_ID_XIRCOM_RBM56G     0x0101
 #define PCI_DEVICE_ID_XIRCOM_X3201_MDM  0x0103
 
-#define PCI_VENDOR_ID_RENDITION         0x1163
-#define PCI_DEVICE_ID_RENDITION_VERITE  0x0001
-#define PCI_DEVICE_ID_RENDITION_VERITE2100 0x2000
 
 #define PCI_VENDOR_ID_SERVERWORKS         0x1166
 #define PCI_DEVICE_ID_SERVERWORKS_HE      0x0008
 #define PCI_DEVICE_ID_SERVERWORKS_LE      0x0009
-#define PCI_DEVICE_ID_SERVERWORKS_CIOB30  0x0010
-#define PCI_DEVICE_ID_SERVERWORKS_CMIC_HE 0x0011
 #define PCI_DEVICE_ID_SERVERWORKS_GCNB_LE 0x0017
 #define PCI_DEVICE_ID_SERVERWORKS_OSB4    0x0200
 #define PCI_DEVICE_ID_SERVERWORKS_CSB5    0x0201
@@ -1609,13 +1347,7 @@
 #define PCI_DEVICE_ID_SERVERWORKS_CSB6IDE 0x0213
 #define PCI_DEVICE_ID_SERVERWORKS_HT1000IDE 0x0214
 #define PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2 0x0217
-#define PCI_DEVICE_ID_SERVERWORKS_OSB4USB 0x0220
-#define PCI_DEVICE_ID_SERVERWORKS_CSB5USB PCI_DEVICE_ID_SERVERWORKS_OSB4USB
-#define PCI_DEVICE_ID_SERVERWORKS_CSB6USB 0x0221
 #define PCI_DEVICE_ID_SERVERWORKS_CSB6LPC 0x0227
-#define PCI_DEVICE_ID_SERVERWORKS_GCLE    0x0225
-#define PCI_DEVICE_ID_SERVERWORKS_GCLE2   0x0227
-#define PCI_DEVICE_ID_SERVERWORKS_CSB5ISA 0x0230
 
 #define PCI_VENDOR_ID_SBE               0x1176
 #define PCI_DEVICE_ID_SBE_WANXL100      0x0301
@@ -1626,17 +1358,12 @@
 #define PCI_DEVICE_ID_TOSHIBA_PICCOLO   0x0102
 #define PCI_DEVICE_ID_TOSHIBA_PICCOLO_1 0x0103
 #define PCI_DEVICE_ID_TOSHIBA_PICCOLO_2 0x0105
-#define PCI_DEVICE_ID_TOSHIBA_601       0x0601
 #define PCI_DEVICE_ID_TOSHIBA_TOPIC95   0x060a
-#define PCI_DEVICE_ID_TOSHIBA_TOPIC95_A 0x0603
-#define PCI_DEVICE_ID_TOSHIBA_TOPIC95_B 0x060a
 #define PCI_DEVICE_ID_TOSHIBA_TOPIC97   0x060f
 #define PCI_DEVICE_ID_TOSHIBA_TOPIC100  0x0617
 
 #define PCI_VENDOR_ID_TOSHIBA_2         0x102f
-#define PCI_DEVICE_ID_TOSHIBA_TX3927    0x000a
 #define PCI_DEVICE_ID_TOSHIBA_TC35815CF 0x0030
-#define PCI_DEVICE_ID_TOSHIBA_TX4927    0x0180
 #define PCI_DEVICE_ID_TOSHIBA_TC86C001_MISC     0x0108
 #define PCI_DEVICE_ID_TOSHIBA_SPIDER_NET 0x01b3
 
@@ -1651,7 +1378,6 @@
 #define PCI_DEVICE_ID_DLINK_DGE510T     0x4c00
 
 #define PCI_VENDOR_ID_ARTOP             0x1191
-#define PCI_DEVICE_ID_ARTOP_ATP8400     0x0004
 #define PCI_DEVICE_ID_ARTOP_ATP850UF    0x0005
 #define PCI_DEVICE_ID_ARTOP_ATP860      0x0006
 #define PCI_DEVICE_ID_ARTOP_ATP860R     0x0007
@@ -1664,16 +1390,11 @@
 #define PCI_DEVICE_ID_ARTOP_AEC7612D    0x8040
 #define PCI_DEVICE_ID_ARTOP_AEC7612SUW  0x8050
 #define PCI_DEVICE_ID_ARTOP_8060        0x8060
-#define PCI_DEVICE_ID_ARTOP_AEC67160    0x8080
-#define PCI_DEVICE_ID_ARTOP_AEC67160_2  0x8081
-#define PCI_DEVICE_ID_ARTOP_AEC67162    0x808a
 
 #define PCI_VENDOR_ID_ZEITNET           0x1193
 #define PCI_DEVICE_ID_ZEITNET_1221      0x0001
 #define PCI_DEVICE_ID_ZEITNET_1225      0x0002
 
-#define PCI_VENDOR_ID_OMEGA             0x119b
-#define PCI_DEVICE_ID_OMEGA_82C092G     0x1221
 
 #define PCI_VENDOR_ID_FUJITSU_ME        0x119e
 #define PCI_DEVICE_ID_FUJITSU_FS155     0x0001
@@ -1683,7 +1404,6 @@
 #define PCI_SUBDEVICE_ID_KEYSPAN_SX2    0x5334
 
 #define PCI_VENDOR_ID_MARVELL           0x11ab
-#define PCI_DEVICE_ID_MARVELL_GT64011   0x4146
 #define PCI_DEVICE_ID_MARVELL_GT64111   0x4146
 #define PCI_DEVICE_ID_MARVELL_GT64260   0x6430
 #define PCI_DEVICE_ID_MARVELL_MV64360   0x6460
@@ -1691,53 +1411,35 @@
 #define PCI_DEVICE_ID_MARVELL_GT96100   0x9652
 #define PCI_DEVICE_ID_MARVELL_GT96100A  0x9653
 
-#define PCI_VENDOR_ID_LITEON            0x11ad
-#define PCI_DEVICE_ID_LITEON_LNE100TX   0x0002
 
 #define PCI_VENDOR_ID_V3                0x11b0
 #define PCI_DEVICE_ID_V3_V960           0x0001
-#define PCI_DEVICE_ID_V3_V350           0x0001
-#define PCI_DEVICE_ID_V3_V961           0x0002
 #define PCI_DEVICE_ID_V3_V351           0x0002
 
-#define PCI_VENDOR_ID_NP                0x11bc
-#define PCI_DEVICE_ID_NP_PCI_FDDI       0x0001
 
 #define PCI_VENDOR_ID_ATT               0x11c1
-#define PCI_DEVICE_ID_ATT_L56XMF        0x0440
 #define PCI_DEVICE_ID_ATT_VENUS_MODEM   0x480
 
-#define PCI_VENDOR_ID_NEC2              0x11c3 /* NEC (2nd) */
 
 #define PCI_VENDOR_ID_SPECIALIX         0x11cb
 #define PCI_DEVICE_ID_SPECIALIX_IO8     0x2000
-#define PCI_DEVICE_ID_SPECIALIX_XIO     0x4000
 #define PCI_DEVICE_ID_SPECIALIX_RIO     0x8000
 #define PCI_SUBDEVICE_ID_SPECIALIX_SPEED4 0xa004
 
-#define PCI_VENDOR_ID_AURAVISION        0x11d1
-#define PCI_DEVICE_ID_AURAVISION_VXP524 0x01f7
 
 #define PCI_VENDOR_ID_ANALOG_DEVICES    0x11d4
 #define PCI_DEVICE_ID_AD1889JS          0x1889
 
-#define PCI_VENDOR_ID_IKON              0x11d5
-#define PCI_DEVICE_ID_IKON_10115        0x0115
-#define PCI_DEVICE_ID_IKON_10117        0x0117
 
-#define PCI_VENDOR_ID_SEGA              0x11db
 #define PCI_DEVICE_ID_SEGA_BBA          0x1234
 
 #define PCI_VENDOR_ID_ZORAN             0x11de
 #define PCI_DEVICE_ID_ZORAN_36057       0x6057
 #define PCI_DEVICE_ID_ZORAN_36120       0x6120
 
-#define PCI_VENDOR_ID_KINETIC           0x11f4
-#define PCI_DEVICE_ID_KINETIC_2915      0x2915
 
 #define PCI_VENDOR_ID_COMPEX            0x11f6
 #define PCI_DEVICE_ID_COMPEX_ENET100VG4 0x0112
-#define PCI_DEVICE_ID_COMPEX_RL2000     0x1401
 
 #define PCI_VENDOR_ID_RP                0x11fe
 #define PCI_DEVICE_ID_RP32INTF          0x0001
@@ -1751,7 +1453,6 @@
 #define PCI_DEVICE_ID_RP16SNI           0x0009  
 #define PCI_DEVICE_ID_RPP4              0x000A
 #define PCI_DEVICE_ID_RPP8              0x000B
-#define PCI_DEVICE_ID_RP8M              0x000C
 #define PCI_DEVICE_ID_RP4M              0x000D
 #define PCI_DEVICE_ID_RP2_232           0x000E
 #define PCI_DEVICE_ID_RP2_422           0x000F
@@ -1779,10 +1480,6 @@
 #define PCI_DEVICE_ID_PC300_TE_M_2      0x0320
 #define PCI_DEVICE_ID_PC300_TE_M_1      0x0321
 
-/* Allied Telesyn */
-#define PCI_VENDOR_ID_AT                0x1259
-#define PCI_SUBDEVICE_ID_AT_2701FX      0x2703
-
 #define PCI_VENDOR_ID_ESSENTIAL         0x120f
 #define PCI_DEVICE_ID_ESSENTIAL_ROADRUNNER      0x0001
 
@@ -1799,10 +1496,7 @@
 #define PCI_DEVICE_ID_3DFX_VOODOO3      0x0005
 #define PCI_DEVICE_ID_3DFX_VOODOO5      0x0009
 
-#define PCI_VENDOR_ID_SIGMADES          0x1236
-#define PCI_DEVICE_ID_SIGMADES_6425     0x6401
 
-#define PCI_VENDOR_ID_CCUBE             0x123f
 
 #define PCI_VENDOR_ID_AVM               0x1244
 #define PCI_DEVICE_ID_AVM_B1            0x0700
@@ -1812,19 +1506,8 @@
 #define PCI_DEVICE_ID_AVM_C2            0x1100
 #define PCI_DEVICE_ID_AVM_T1            0x1200
 
-#define PCI_VENDOR_ID_DIPIX             0x1246
 
 #define PCI_VENDOR_ID_STALLION          0x124d
-#define PCI_DEVICE_ID_STALLION_ECHPCI832 0x0000
-#define PCI_DEVICE_ID_STALLION_ECHPCI864 0x0002
-#define PCI_DEVICE_ID_STALLION_EIOPCI   0x0003
-
-#define PCI_VENDOR_ID_OPTIBASE          0x1255
-#define PCI_DEVICE_ID_OPTIBASE_FORGE    0x1110
-#define PCI_DEVICE_ID_OPTIBASE_FUSION   0x1210
-#define PCI_DEVICE_ID_OPTIBASE_VPLEX    0x2110
-#define PCI_DEVICE_ID_OPTIBASE_VPLEXCC  0x2120
-#define PCI_DEVICE_ID_OPTIBASE_VQUEST   0x2130
 
 /* Allied Telesyn */
 #define PCI_VENDOR_ID_AT                0x1259
@@ -1833,7 +1516,6 @@
 
 #define PCI_VENDOR_ID_ESS               0x125d
 #define PCI_DEVICE_ID_ESS_ESS1968       0x1968
-#define PCI_DEVICE_ID_ESS_AUDIOPCI      0x1969
 #define PCI_DEVICE_ID_ESS_ESS1978       0x1978
 #define PCI_DEVICE_ID_ESS_ALLEGRO_1     0x1988
 #define PCI_DEVICE_ID_ESS_ALLEGRO       0x1989
@@ -1846,11 +1528,7 @@
 
 #define PCI_VENDOR_ID_SATSAGEM          0x1267
 #define PCI_DEVICE_ID_SATSAGEM_NICCY    0x1016
-#define PCI_DEVICE_ID_SATSAGEM_PCR2101  0x5352
-#define PCI_DEVICE_ID_SATSAGEM_TELSATTURBO 0x5a4b
 
-#define PCI_VENDOR_ID_HUGHES            0x1273
-#define PCI_DEVICE_ID_HUGHES_DIRECPC    0x0002
 
 #define PCI_VENDOR_ID_ENSONIQ           0x1274
 #define PCI_DEVICE_ID_ENSONIQ_CT5880    0x5880
@@ -1871,13 +1549,10 @@
 #define PCI_DEVICE_ID_ITE_IT8330G_0     0xe886
 
 /* formerly Platform Tech */
-#define PCI_VENDOR_ID_ESS_OLD           0x1285
 #define PCI_DEVICE_ID_ESS_ESS0100       0x0100
 
 #define PCI_VENDOR_ID_ALTEON            0x12ae
-#define PCI_DEVICE_ID_ALTEON_ACENIC     0x0001
 
-#define PCI_VENDOR_ID_USR               0x12B9
 
 #define PCI_SUBVENDOR_ID_CONNECT_TECH                   0x12c4
 #define PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_232           0x0001
@@ -1892,8 +1567,6 @@
 #define PCI_SUBDEVICE_ID_CONNECT_TECH_BH081101V1        0x000A
 #define PCI_SUBDEVICE_ID_CONNECT_TECH_BH041101V1        0x000B
 
-#define PCI_VENDOR_ID_PICTUREL          0x12c5
-#define PCI_DEVICE_ID_PICTUREL_PCIVST   0x0081
 
 #define PCI_VENDOR_ID_NVIDIA_SGS        0x12d2
 #define PCI_DEVICE_ID_NVIDIA_SGS_RIVA128 0x0018
@@ -1915,8 +1588,6 @@
 #define PCI_VENDOR_ID_ELECTRONICDESIGNGMBH 0x12f8
 #define PCI_DEVICE_ID_LML_33R10         0x8a02
 
-#define PCI_VENDOR_ID_CBOARDS           0x1307
-#define PCI_DEVICE_ID_CBOARDS_DAS1602_16 0x0001
 
 #define PCI_VENDOR_ID_SIIG              0x131f
 #define PCI_SUBVENDOR_ID_SIIG           0x131f
@@ -1960,7 +1631,6 @@
 #define PCI_SUBDEVICE_ID_SIIG_QUARTET_SERIAL    0x2050
 
 #define PCI_VENDOR_ID_RADISYS           0x1331
-#define PCI_DEVICE_ID_RADISYS_ENP2611   0x0030
 
 #define PCI_VENDOR_ID_DOMEX             0x134a
 #define PCI_DEVICE_ID_DOMEX_DMX3191D    0x0001
@@ -1968,8 +1638,6 @@
 #define PCI_VENDOR_ID_QUATECH           0x135C
 #define PCI_DEVICE_ID_QUATECH_QSC100    0x0010
 #define PCI_DEVICE_ID_QUATECH_DSC100    0x0020
-#define PCI_DEVICE_ID_QUATECH_DSC200    0x0030
-#define PCI_DEVICE_ID_QUATECH_QSC200    0x0040
 #define PCI_DEVICE_ID_QUATECH_ESC100D   0x0050
 #define PCI_DEVICE_ID_QUATECH_ESC100M   0x0060
 
@@ -1988,7 +1656,6 @@
 #define PCI_SUBDEVICE_ID_HYPERCOPE_ERGO         0x0106
 #define PCI_SUBDEVICE_ID_HYPERCOPE_METRO        0x0107
 #define PCI_SUBDEVICE_ID_HYPERCOPE_CHAMP2       0x0108
-#define PCI_SUBDEVICE_ID_HYPERCOPE_PLEXUS       0x0109
 
 #define PCI_VENDOR_ID_KAWASAKI          0x136b
 #define PCI_DEVICE_ID_MCHIP_KL5A72002   0xff01
@@ -2002,12 +1669,9 @@
 #define PCI_DEVICE_ID_LMC_SSI           0x0005
 #define PCI_DEVICE_ID_LMC_T1            0x0006
 
-#define PCI_VENDOR_ID_MARIAN            0x1382
-#define PCI_DEVICE_ID_MARIAN_PRODIF_PLUS 0x2048
 
 #define PCI_VENDOR_ID_NETGEAR           0x1385
 #define PCI_DEVICE_ID_NETGEAR_GA620     0x620a
-#define PCI_DEVICE_ID_NETGEAR_GA622     0x622a
 
 #define PCI_VENDOR_ID_APPLICOM          0x1389
 #define PCI_DEVICE_ID_APPLICOM_PCIGENERIC 0x0001
@@ -2030,9 +1694,6 @@
 #define PCI_DEVICE_ID_MOXA_CP134U       0x1340
 #define PCI_DEVICE_ID_MOXA_C168         0x1680
 #define PCI_DEVICE_ID_MOXA_CP168U       0x1681
-#define PCI_DEVICE_ID_MOXA_CP204J       0x2040
-#define PCI_DEVICE_ID_MOXA_C218         0x2180
-#define PCI_DEVICE_ID_MOXA_C320         0x3200
 
 #define PCI_VENDOR_ID_CCD               0x1397
 #define PCI_DEVICE_ID_CCD_2BD0          0x2bd0
@@ -2053,9 +1714,7 @@
 
 #define PCI_VENDOR_ID_MICROGATE         0x13c0
 #define PCI_DEVICE_ID_MICROGATE_USC     0x0010
-#define PCI_DEVICE_ID_MICROGATE_SCC     0x0020
 #define PCI_DEVICE_ID_MICROGATE_SCA     0x0030
-#define PCI_DEVICE_ID_MICROGATE_USC2    0x0210
 
 #define PCI_VENDOR_ID_3WARE             0x13C1
 #define PCI_DEVICE_ID_3WARE_1000        0x1000
@@ -2106,10 +1765,6 @@
 
 #define PCI_VENDOR_ID_SAMSUNG           0x144d
 
-#define PCI_VENDOR_ID_AIRONET           0x14b9
-#define PCI_DEVICE_ID_AIRONET_4800_1    0x0001
-#define PCI_DEVICE_ID_AIRONET_4800      0x4500 // values switched?  see
-#define PCI_DEVICE_ID_AIRONET_4500      0x4800 // drivers/net/aironet4500_card.c
 
 #define PCI_VENDOR_ID_TITAN             0x14D2
 #define PCI_DEVICE_ID_TITAN_010L        0x8001
@@ -2128,8 +1783,6 @@
 #define PCI_DEVICE_ID_PANACOM_QUADMODEM 0x0400
 #define PCI_DEVICE_ID_PANACOM_DUALMODEM 0x0402
 
-#define PCI_VENDOR_ID_SIPACKETS         0x14d9
-#define PCI_DEVICE_ID_SP_HT             0x0010
 
 #define PCI_VENDOR_ID_AFAVLAB           0x14db
 #define PCI_DEVICE_ID_AFAVLAB_P028      0x2180
@@ -2145,6 +1798,7 @@
 #define PCI_DEVICE_ID_TIGON3_5704       0x1648
 #define PCI_DEVICE_ID_TIGON3_5704S_2    0x1649
 #define PCI_DEVICE_ID_NX2_5706          0x164a
+#define PCI_DEVICE_ID_NX2_5708          0x164c
 #define PCI_DEVICE_ID_TIGON3_5702FE     0x164d
 #define PCI_DEVICE_ID_TIGON3_5705       0x1653
 #define PCI_DEVICE_ID_TIGON3_5705_2     0x1654
@@ -2152,11 +1806,13 @@
 #define PCI_DEVICE_ID_TIGON3_5721       0x1659
 #define PCI_DEVICE_ID_TIGON3_5705M      0x165d
 #define PCI_DEVICE_ID_TIGON3_5705M_2    0x165e
+#define PCI_DEVICE_ID_TIGON3_5714       0x1668
 #define PCI_DEVICE_ID_TIGON3_5780       0x166a
 #define PCI_DEVICE_ID_TIGON3_5780S      0x166b
 #define PCI_DEVICE_ID_TIGON3_5705F      0x166e
 #define PCI_DEVICE_ID_TIGON3_5750       0x1676
 #define PCI_DEVICE_ID_TIGON3_5751       0x1677
+#define PCI_DEVICE_ID_TIGON3_5715       0x1678
 #define PCI_DEVICE_ID_TIGON3_5750M      0x167c
 #define PCI_DEVICE_ID_TIGON3_5751M      0x167d
 #define PCI_DEVICE_ID_TIGON3_5751F      0x167e
@@ -2167,6 +1823,7 @@
 #define PCI_DEVICE_ID_TIGON3_5703X      0x16a7
 #define PCI_DEVICE_ID_TIGON3_5704S      0x16a8
 #define PCI_DEVICE_ID_NX2_5706S         0x16aa
+#define PCI_DEVICE_ID_NX2_5708S         0x16ac
 #define PCI_DEVICE_ID_TIGON3_5702A3     0x16c6
 #define PCI_DEVICE_ID_TIGON3_5703A3     0x16c7
 #define PCI_DEVICE_ID_TIGON3_5781       0x16dd
@@ -2186,11 +1843,14 @@
 #define PCI_DEVICE_ID_ENE_1211          0x1211
 #define PCI_DEVICE_ID_ENE_1225          0x1225
 #define PCI_DEVICE_ID_ENE_1410          0x1410
+#define PCI_DEVICE_ID_ENE_710           0x1411
+#define PCI_DEVICE_ID_ENE_712           0x1412
 #define PCI_DEVICE_ID_ENE_1420          0x1420
+#define PCI_DEVICE_ID_ENE_720           0x1421
+#define PCI_DEVICE_ID_ENE_722           0x1422
+
 #define PCI_VENDOR_ID_CHELSIO           0x1425
 
-#define PCI_VENDOR_ID_MIPS              0x153f
-#define PCI_DEVICE_ID_SOC_IT            0x0001
 
 #define PCI_VENDOR_ID_SYBA              0x1592
 #define PCI_DEVICE_ID_SYBA_2P_EPP       0x0782
@@ -2210,15 +1870,7 @@
 #define PCI_DEVICE_ID_MELLANOX_SINAI    0x6274
 
 #define PCI_VENDOR_ID_PDC               0x15e9
-#define PCI_DEVICE_ID_PDC_1841          0x1841
 
-#define PCI_VENDOR_ID_MACROLINK         0x15ed
-#define PCI_DEVICE_ID_MACROLINK_MCCS8   0x1000
-#define PCI_DEVICE_ID_MACROLINK_MCCS    0x1001
-#define PCI_DEVICE_ID_MACROLINK_MCCS8H  0x1002
-#define PCI_DEVICE_ID_MACROLINK_MCCSH   0x1003
-#define PCI_DEVICE_ID_MACROLINK_MCCR8   0x2000
-#define PCI_DEVICE_ID_MACROLINK_MCCR    0x2001
 
 #define PCI_VENDOR_ID_FARSITE           0x1619
 #define PCI_DEVICE_ID_FARSITE_T2P       0x0400
@@ -2236,7 +1888,6 @@
 #define PCI_DEVICE_ID_REVOLUTION        0x0044
 
 #define PCI_VENDOR_ID_LINKSYS           0x1737
-#define PCI_DEVICE_ID_LINKSYS_EG1032    0x1032
 #define PCI_DEVICE_ID_LINKSYS_EG1064    0x1064
 
 #define PCI_VENDOR_ID_ALTIMA            0x173b
@@ -2251,7 +1902,6 @@
 #define PCI_DEVICE_ID_HERC_WIN          0x5732
 #define PCI_DEVICE_ID_HERC_UNI          0x5832
 
-#define PCI_VENDOR_ID_INFINICON         0x1820
 
 #define PCI_VENDOR_ID_SITECOM           0x182d
 #define PCI_DEVICE_ID_SITECOM_DC105V2   0x3069
@@ -2261,8 +1911,6 @@
 #define PCI_VENDOR_ID_TDI               0x192E
 #define PCI_DEVICE_ID_TDI_EHCI          0x0101
 
-#define PCI_VENDOR_ID_SYMPHONY          0x1c1c
-#define PCI_DEVICE_ID_SYMPHONY_101      0x0001
 
 #define PCI_VENDOR_ID_TEKRAM            0x1de1
 #define PCI_DEVICE_ID_TEKRAM_DC290      0xdc29
@@ -2271,70 +1919,33 @@
 #define PCI_DEVICE_ID_HINT_VXPROII_IDE 0x8013
 
 #define PCI_VENDOR_ID_3DLABS            0x3d3d
-#define PCI_DEVICE_ID_3DLABS_300SX      0x0001
-#define PCI_DEVICE_ID_3DLABS_500TX      0x0002
-#define PCI_DEVICE_ID_3DLABS_DELTA      0x0003
-#define PCI_DEVICE_ID_3DLABS_PERMEDIA   0x0004
-#define PCI_DEVICE_ID_3DLABS_MX         0x0006
 #define PCI_DEVICE_ID_3DLABS_PERMEDIA2  0x0007
-#define PCI_DEVICE_ID_3DLABS_GAMMA      0x0008
 #define PCI_DEVICE_ID_3DLABS_PERMEDIA2V 0x0009
 
-#define PCI_VENDOR_ID_AVANCE            0x4005
-#define PCI_DEVICE_ID_AVANCE_ALG2064    0x2064
-#define PCI_DEVICE_ID_AVANCE_2302       0x2302
 
 #define PCI_VENDOR_ID_AKS               0x416c
 #define PCI_DEVICE_ID_AKS_ALADDINCARD   0x0100
-#define PCI_DEVICE_ID_AKS_CPC           0x0200
 
-#define PCI_VENDOR_ID_REDCREEK          0x4916
-#define PCI_DEVICE_ID_RC45              0x1960
 
-#define PCI_VENDOR_ID_NETVIN            0x4a14
-#define PCI_DEVICE_ID_NETVIN_NV5000SC   0x5000
 
 #define PCI_VENDOR_ID_S3                0x5333
-#define PCI_DEVICE_ID_S3_PLATO_PXS      0x0551
-#define PCI_DEVICE_ID_S3_ViRGE          0x5631
 #define PCI_DEVICE_ID_S3_TRIO           0x8811
-#define PCI_DEVICE_ID_S3_AURORA64VP     0x8812
-#define PCI_DEVICE_ID_S3_TRIO64UVP      0x8814
-#define PCI_DEVICE_ID_S3_ViRGE_VX       0x883d
 #define PCI_DEVICE_ID_S3_868            0x8880
-#define PCI_DEVICE_ID_S3_928            0x88b0
-#define PCI_DEVICE_ID_S3_864_1          0x88c0
-#define PCI_DEVICE_ID_S3_864_2          0x88c1
-#define PCI_DEVICE_ID_S3_964_1          0x88d0
-#define PCI_DEVICE_ID_S3_964_2          0x88d1
 #define PCI_DEVICE_ID_S3_968            0x88f0
-#define PCI_DEVICE_ID_S3_TRIO64V2       0x8901
-#define PCI_DEVICE_ID_S3_PLATO_PXG      0x8902
-#define PCI_DEVICE_ID_S3_ViRGE_DXGX     0x8a01
-#define PCI_DEVICE_ID_S3_ViRGE_GX2      0x8a10
 #define PCI_DEVICE_ID_S3_SAVAGE4        0x8a25
-#define PCI_DEVICE_ID_S3_ViRGE_MX       0x8c01
-#define PCI_DEVICE_ID_S3_ViRGE_MXP      0x8c02
-#define PCI_DEVICE_ID_S3_ViRGE_MXPMV    0x8c03
 #define PCI_DEVICE_ID_S3_PROSAVAGE8     0x8d04
 #define PCI_DEVICE_ID_S3_SONICVIBES     0xca00
 
 #define PCI_VENDOR_ID_DUNORD            0x5544
 #define PCI_DEVICE_ID_DUNORD_I3000      0x0001
 
+
 #define PCI_VENDOR_ID_DCI               0x6666
 #define PCI_DEVICE_ID_DCI_PCCOM4        0x0001
 #define PCI_DEVICE_ID_DCI_PCCOM8        0x0002
 
-#define PCI_VENDOR_ID_DUNORD            0x5544
-#define PCI_DEVICE_ID_DUNORD_I3000      0x0001
-
-#define PCI_VENDOR_ID_GENROCO           0x5555
-#define PCI_DEVICE_ID_GENROCO_HFP832    0x0003
-
 #define PCI_VENDOR_ID_INTEL             0x8086
 #define PCI_DEVICE_ID_INTEL_EESSC       0x0008
-#define PCI_DEVICE_ID_INTEL_21145       0x0039
 #define PCI_DEVICE_ID_INTEL_PXHD_0      0x0320
 #define PCI_DEVICE_ID_INTEL_PXHD_1      0x0321
 #define PCI_DEVICE_ID_INTEL_PXH_0       0x0329
@@ -2343,30 +1954,17 @@
 #define PCI_DEVICE_ID_INTEL_82375       0x0482
 #define PCI_DEVICE_ID_INTEL_82424       0x0483
 #define PCI_DEVICE_ID_INTEL_82378       0x0484
-#define PCI_DEVICE_ID_INTEL_82430       0x0486
-#define PCI_DEVICE_ID_INTEL_82434       0x04a3
 #define PCI_DEVICE_ID_INTEL_I960        0x0960
 #define PCI_DEVICE_ID_INTEL_I960RM      0x0962
-#define PCI_DEVICE_ID_INTEL_82562ET     0x1031
-#define PCI_DEVICE_ID_INTEL_82801CAM    0x1038
 #define PCI_DEVICE_ID_INTEL_82815_MC    0x1130
-#define PCI_DEVICE_ID_INTEL_82815_AB    0x1131
 #define PCI_DEVICE_ID_INTEL_82815_CGC   0x1132
-#define PCI_DEVICE_ID_INTEL_82559ER     0x1209
 #define PCI_DEVICE_ID_INTEL_82092AA_0   0x1221
-#define PCI_DEVICE_ID_INTEL_82092AA_1   0x1222
-#define PCI_DEVICE_ID_INTEL_7116        0x1223
 #define PCI_DEVICE_ID_INTEL_7505_0      0x2550  
-#define PCI_DEVICE_ID_INTEL_7505_1      0x2552  
 #define PCI_DEVICE_ID_INTEL_7205_0      0x255d
-#define PCI_DEVICE_ID_INTEL_82596       0x1226
-#define PCI_DEVICE_ID_INTEL_82865       0x1227
-#define PCI_DEVICE_ID_INTEL_82557       0x1229
 #define PCI_DEVICE_ID_INTEL_82437       0x122d
 #define PCI_DEVICE_ID_INTEL_82371FB_0   0x122e
 #define PCI_DEVICE_ID_INTEL_82371FB_1   0x1230
 #define PCI_DEVICE_ID_INTEL_82371MX     0x1234
-#define PCI_DEVICE_ID_INTEL_82437MX     0x1235
 #define PCI_DEVICE_ID_INTEL_82441       0x1237
 #define PCI_DEVICE_ID_INTEL_82380FB     0x124b
 #define PCI_DEVICE_ID_INTEL_82439       0x1250
@@ -2375,83 +1973,53 @@
 #define PCI_DEVICE_ID_INTEL_82845_HB    0x1a30
 #define PCI_DEVICE_ID_INTEL_82801AA_0   0x2410
 #define PCI_DEVICE_ID_INTEL_82801AA_1   0x2411
-#define PCI_DEVICE_ID_INTEL_82801AA_2   0x2412
 #define PCI_DEVICE_ID_INTEL_82801AA_3   0x2413
 #define PCI_DEVICE_ID_INTEL_82801AA_5   0x2415
 #define PCI_DEVICE_ID_INTEL_82801AA_6   0x2416
 #define PCI_DEVICE_ID_INTEL_82801AA_8   0x2418
 #define PCI_DEVICE_ID_INTEL_82801AB_0   0x2420
 #define PCI_DEVICE_ID_INTEL_82801AB_1   0x2421
-#define PCI_DEVICE_ID_INTEL_82801AB_2   0x2422
 #define PCI_DEVICE_ID_INTEL_82801AB_3   0x2423
 #define PCI_DEVICE_ID_INTEL_82801AB_5   0x2425
 #define PCI_DEVICE_ID_INTEL_82801AB_6   0x2426
 #define PCI_DEVICE_ID_INTEL_82801AB_8   0x2428
 #define PCI_DEVICE_ID_INTEL_82801BA_0   0x2440
-#define PCI_DEVICE_ID_INTEL_82801BA_1   0x2442
 #define PCI_DEVICE_ID_INTEL_82801BA_2   0x2443
-#define PCI_DEVICE_ID_INTEL_82801BA_3   0x2444
 #define PCI_DEVICE_ID_INTEL_82801BA_4   0x2445
-#define PCI_DEVICE_ID_INTEL_82801BA_5   0x2446
 #define PCI_DEVICE_ID_INTEL_82801BA_6   0x2448
-#define PCI_DEVICE_ID_INTEL_82801BA_7   0x2449
 #define PCI_DEVICE_ID_INTEL_82801BA_8   0x244a
 #define PCI_DEVICE_ID_INTEL_82801BA_9   0x244b
 #define PCI_DEVICE_ID_INTEL_82801BA_10  0x244c
 #define PCI_DEVICE_ID_INTEL_82801BA_11  0x244e
 #define PCI_DEVICE_ID_INTEL_82801E_0    0x2450
-#define PCI_DEVICE_ID_INTEL_82801E_2    0x2452
-#define PCI_DEVICE_ID_INTEL_82801E_3    0x2453
-#define PCI_DEVICE_ID_INTEL_82801E_9    0x2459
 #define PCI_DEVICE_ID_INTEL_82801E_11   0x245b
-#define PCI_DEVICE_ID_INTEL_82801E_13   0x245d
-#define PCI_DEVICE_ID_INTEL_82801E_14   0x245e
 #define PCI_DEVICE_ID_INTEL_82801CA_0   0x2480
-#define PCI_DEVICE_ID_INTEL_82801CA_2   0x2482
 #define PCI_DEVICE_ID_INTEL_82801CA_3   0x2483
-#define PCI_DEVICE_ID_INTEL_82801CA_4   0x2484
 #define PCI_DEVICE_ID_INTEL_82801CA_5   0x2485
 #define PCI_DEVICE_ID_INTEL_82801CA_6   0x2486
-#define PCI_DEVICE_ID_INTEL_82801CA_7   0x2487
 #define PCI_DEVICE_ID_INTEL_82801CA_10  0x248a
 #define PCI_DEVICE_ID_INTEL_82801CA_11  0x248b
 #define PCI_DEVICE_ID_INTEL_82801CA_12  0x248c
 #define PCI_DEVICE_ID_INTEL_82801DB_0   0x24c0
 #define PCI_DEVICE_ID_INTEL_82801DB_1   0x24c1
-#define PCI_DEVICE_ID_INTEL_82801DB_2   0x24c2
 #define PCI_DEVICE_ID_INTEL_82801DB_3   0x24c3
-#define PCI_DEVICE_ID_INTEL_82801DB_4   0x24c4
 #define PCI_DEVICE_ID_INTEL_82801DB_5   0x24c5
 #define PCI_DEVICE_ID_INTEL_82801DB_6   0x24c6
-#define PCI_DEVICE_ID_INTEL_82801DB_7   0x24c7
 #define PCI_DEVICE_ID_INTEL_82801DB_9   0x24c9
 #define PCI_DEVICE_ID_INTEL_82801DB_10  0x24ca
 #define PCI_DEVICE_ID_INTEL_82801DB_11  0x24cb
 #define PCI_DEVICE_ID_INTEL_82801DB_12  0x24cc
-#define PCI_DEVICE_ID_INTEL_82801DB_13  0x24cd
 #define PCI_DEVICE_ID_INTEL_82801EB_0   0x24d0
 #define PCI_DEVICE_ID_INTEL_82801EB_1   0x24d1
-#define PCI_DEVICE_ID_INTEL_82801EB_2   0x24d2
 #define PCI_DEVICE_ID_INTEL_82801EB_3   0x24d3
-#define PCI_DEVICE_ID_INTEL_82801EB_4   0x24d4
 #define PCI_DEVICE_ID_INTEL_82801EB_5   0x24d5
 #define PCI_DEVICE_ID_INTEL_82801EB_6   0x24d6
-#define PCI_DEVICE_ID_INTEL_82801EB_7   0x24d7
 #define PCI_DEVICE_ID_INTEL_82801EB_11  0x24db
-#define PCI_DEVICE_ID_INTEL_82801EB_13  0x24dd
 #define PCI_DEVICE_ID_INTEL_ESB_1       0x25a1
 #define PCI_DEVICE_ID_INTEL_ESB_2       0x25a2
-#define PCI_DEVICE_ID_INTEL_ESB_3       0x25a3
-#define PCI_DEVICE_ID_INTEL_ESB_31      0x25b0
 #define PCI_DEVICE_ID_INTEL_ESB_4       0x25a4
 #define PCI_DEVICE_ID_INTEL_ESB_5       0x25a6
-#define PCI_DEVICE_ID_INTEL_ESB_6       0x25a7
-#define PCI_DEVICE_ID_INTEL_ESB_7       0x25a9
-#define PCI_DEVICE_ID_INTEL_ESB_8       0x25aa
 #define PCI_DEVICE_ID_INTEL_ESB_9       0x25ab
-#define PCI_DEVICE_ID_INTEL_ESB_11      0x25ac
-#define PCI_DEVICE_ID_INTEL_ESB_12      0x25ad
-#define PCI_DEVICE_ID_INTEL_ESB_13      0x25ae
 #define PCI_DEVICE_ID_INTEL_82820_HB    0x2500
 #define PCI_DEVICE_ID_INTEL_82820_UP_HB 0x2501
 #define PCI_DEVICE_ID_INTEL_82850_HB    0x2530
@@ -2461,7 +2029,6 @@
 #define PCI_DEVICE_ID_INTEL_82865_HB    0x2570
 #define PCI_DEVICE_ID_INTEL_82865_IG    0x2572
 #define PCI_DEVICE_ID_INTEL_82875_HB    0x2578
-#define PCI_DEVICE_ID_INTEL_82875_IG    0x257b
 #define PCI_DEVICE_ID_INTEL_82915G_HB   0x2580
 #define PCI_DEVICE_ID_INTEL_82915G_IG   0x2582
 #define PCI_DEVICE_ID_INTEL_82915GM_HB  0x2590
@@ -2471,80 +2038,23 @@
 #define PCI_DEVICE_ID_INTEL_ICH6_0      0x2640
 #define PCI_DEVICE_ID_INTEL_ICH6_1      0x2641
 #define PCI_DEVICE_ID_INTEL_ICH6_2      0x2642
-#define PCI_DEVICE_ID_INTEL_ICH6_3      0x2651
-#define PCI_DEVICE_ID_INTEL_ICH6_4      0x2652
-#define PCI_DEVICE_ID_INTEL_ICH6_5      0x2653
-#define PCI_DEVICE_ID_INTEL_ICH6_6      0x2658
-#define PCI_DEVICE_ID_INTEL_ICH6_7      0x2659
-#define PCI_DEVICE_ID_INTEL_ICH6_8      0x265a
-#define PCI_DEVICE_ID_INTEL_ICH6_9      0x265b
-#define PCI_DEVICE_ID_INTEL_ICH6_10     0x265c
-#define PCI_DEVICE_ID_INTEL_ICH6_11     0x2660
-#define PCI_DEVICE_ID_INTEL_ICH6_12     0x2662
-#define PCI_DEVICE_ID_INTEL_ICH6_13     0x2664
-#define PCI_DEVICE_ID_INTEL_ICH6_14     0x2666
-#define PCI_DEVICE_ID_INTEL_ICH6_15     0x2668
 #define PCI_DEVICE_ID_INTEL_ICH6_16     0x266a
 #define PCI_DEVICE_ID_INTEL_ICH6_17     0x266d
 #define PCI_DEVICE_ID_INTEL_ICH6_18     0x266e
 #define PCI_DEVICE_ID_INTEL_ICH6_19     0x266f
 #define PCI_DEVICE_ID_INTEL_ESB2_0      0x2670
-#define PCI_DEVICE_ID_INTEL_ESB2_1      0x2680
-#define PCI_DEVICE_ID_INTEL_ESB2_2      0x2681
-#define PCI_DEVICE_ID_INTEL_ESB2_3      0x2682
-#define PCI_DEVICE_ID_INTEL_ESB2_4      0x2683
-#define PCI_DEVICE_ID_INTEL_ESB2_5      0x2688
-#define PCI_DEVICE_ID_INTEL_ESB2_6      0x2689
-#define PCI_DEVICE_ID_INTEL_ESB2_7      0x268a
-#define PCI_DEVICE_ID_INTEL_ESB2_8      0x268b
-#define PCI_DEVICE_ID_INTEL_ESB2_9      0x268c
-#define PCI_DEVICE_ID_INTEL_ESB2_10     0x2690
-#define PCI_DEVICE_ID_INTEL_ESB2_11     0x2692
-#define PCI_DEVICE_ID_INTEL_ESB2_12     0x2694
-#define PCI_DEVICE_ID_INTEL_ESB2_13     0x2696
 #define PCI_DEVICE_ID_INTEL_ESB2_14     0x2698
-#define PCI_DEVICE_ID_INTEL_ESB2_15     0x2699
-#define PCI_DEVICE_ID_INTEL_ESB2_16     0x269a
 #define PCI_DEVICE_ID_INTEL_ESB2_17     0x269b
 #define PCI_DEVICE_ID_INTEL_ESB2_18     0x269e
 #define PCI_DEVICE_ID_INTEL_ICH7_0      0x27b8
 #define PCI_DEVICE_ID_INTEL_ICH7_1      0x27b9
-#define PCI_DEVICE_ID_INTEL_ICH7_2      0x27c0
-#define PCI_DEVICE_ID_INTEL_ICH7_3      0x27c1
 #define PCI_DEVICE_ID_INTEL_ICH7_30     0x27b0
 #define PCI_DEVICE_ID_INTEL_ICH7_31     0x27bd
-#define PCI_DEVICE_ID_INTEL_ICH7_5      0x27c4
-#define PCI_DEVICE_ID_INTEL_ICH7_6      0x27c5
-#define PCI_DEVICE_ID_INTEL_ICH7_7      0x27c8
-#define PCI_DEVICE_ID_INTEL_ICH7_8      0x27c9
-#define PCI_DEVICE_ID_INTEL_ICH7_9      0x27ca
-#define PCI_DEVICE_ID_INTEL_ICH7_10     0x27cb
-#define PCI_DEVICE_ID_INTEL_ICH7_11     0x27cc
-#define PCI_DEVICE_ID_INTEL_ICH7_12     0x27d0
-#define PCI_DEVICE_ID_INTEL_ICH7_13     0x27d2
-#define PCI_DEVICE_ID_INTEL_ICH7_14     0x27d4
-#define PCI_DEVICE_ID_INTEL_ICH7_15     0x27d6
-#define PCI_DEVICE_ID_INTEL_ICH7_16     0x27d8
 #define PCI_DEVICE_ID_INTEL_ICH7_17     0x27da
-#define PCI_DEVICE_ID_INTEL_ICH7_18     0x27dc
 #define PCI_DEVICE_ID_INTEL_ICH7_19     0x27dd
 #define PCI_DEVICE_ID_INTEL_ICH7_20     0x27de
 #define PCI_DEVICE_ID_INTEL_ICH7_21     0x27df
-#define PCI_DEVICE_ID_INTEL_ICH7_22     0x27e0
-#define PCI_DEVICE_ID_INTEL_ICH7_23     0x27e2
 #define PCI_DEVICE_ID_INTEL_82855PM_HB  0x3340
-#define PCI_DEVICE_ID_INTEL_ESB2_19     0x3500
-#define PCI_DEVICE_ID_INTEL_ESB2_20     0x3501
-#define PCI_DEVICE_ID_INTEL_ESB2_21     0x3504
-#define PCI_DEVICE_ID_INTEL_ESB2_22     0x3505
-#define PCI_DEVICE_ID_INTEL_ESB2_23     0x350c
-#define PCI_DEVICE_ID_INTEL_ESB2_24     0x350d
-#define PCI_DEVICE_ID_INTEL_ESB2_25     0x3510
-#define PCI_DEVICE_ID_INTEL_ESB2_26     0x3511
-#define PCI_DEVICE_ID_INTEL_ESB2_27     0x3514
-#define PCI_DEVICE_ID_INTEL_ESB2_28     0x3515
-#define PCI_DEVICE_ID_INTEL_ESB2_29     0x3518
-#define PCI_DEVICE_ID_INTEL_ESB2_30     0x3519
 #define PCI_DEVICE_ID_INTEL_82830_HB    0x3575
 #define PCI_DEVICE_ID_INTEL_82830_CGC   0x3577
 #define PCI_DEVICE_ID_INTEL_82855GM_HB  0x3580
@@ -2558,7 +2068,6 @@
 #define PCI_DEVICE_ID_INTEL_MCH_PC      0x3599
 #define PCI_DEVICE_ID_INTEL_MCH_PC1     0x359a
 #define PCI_DEVICE_ID_INTEL_E7525_MCH   0x359e
-#define PCI_DEVICE_ID_INTEL_80310       0x530d
 #define PCI_DEVICE_ID_INTEL_82371SB_0   0x7000
 #define PCI_DEVICE_ID_INTEL_82371SB_1   0x7010
 #define PCI_DEVICE_ID_INTEL_82371SB_2   0x7020
@@ -2583,22 +2092,15 @@
 #define PCI_DEVICE_ID_INTEL_440MX_6     0x7196
 #define PCI_DEVICE_ID_INTEL_82443MX_0   0x7198
 #define PCI_DEVICE_ID_INTEL_82443MX_1   0x7199
-#define PCI_DEVICE_ID_INTEL_82443MX_2   0x719a
 #define PCI_DEVICE_ID_INTEL_82443MX_3   0x719b
 #define PCI_DEVICE_ID_INTEL_82443GX_0   0x71a0
-#define PCI_DEVICE_ID_INTEL_82443GX_1   0x71a1
 #define PCI_DEVICE_ID_INTEL_82443GX_2   0x71a2
-#define PCI_DEVICE_ID_INTEL_82372FB_0   0x7600
 #define PCI_DEVICE_ID_INTEL_82372FB_1   0x7601
-#define PCI_DEVICE_ID_INTEL_82372FB_2   0x7602
-#define PCI_DEVICE_ID_INTEL_82372FB_3   0x7603
 #define PCI_DEVICE_ID_INTEL_82454GX     0x84c4
-#define PCI_DEVICE_ID_INTEL_82450GX     0x84c5
 #define PCI_DEVICE_ID_INTEL_82451NX     0x84ca
 #define PCI_DEVICE_ID_INTEL_82454NX     0x84cb
 #define PCI_DEVICE_ID_INTEL_84460GX     0x84ea
 #define PCI_DEVICE_ID_INTEL_IXP4XX      0x8500
-#define PCI_DEVICE_ID_INTEL_IXP2400     0x9001
 #define PCI_DEVICE_ID_INTEL_IXP2800     0x9004
 #define PCI_DEVICE_ID_INTEL_S21152BB    0xb152
 
@@ -2611,7 +2113,6 @@
 #define PCI_SUBDEVICE_ID_COMPUTONE_PG6  0x0003
 
 #define PCI_VENDOR_ID_KTI               0x8e2e
-#define PCI_DEVICE_ID_KTI_ET32P2        0x3000
 
 #define PCI_VENDOR_ID_ADAPTEC           0x9004
 #define PCI_DEVICE_ID_ADAPTEC_7810      0x1078
@@ -2619,7 +2120,6 @@
 #define PCI_DEVICE_ID_ADAPTEC_38602     0x3860
 #define PCI_DEVICE_ID_ADAPTEC_7850      0x5078
 #define PCI_DEVICE_ID_ADAPTEC_7855      0x5578
-#define PCI_DEVICE_ID_ADAPTEC_5800      0x5800
 #define PCI_DEVICE_ID_ADAPTEC_3860      0x6038
 #define PCI_DEVICE_ID_ADAPTEC_1480A     0x6075
 #define PCI_DEVICE_ID_ADAPTEC_7860      0x6078
@@ -2639,7 +2139,6 @@
 #define PCI_DEVICE_ID_ADAPTEC_7886      0x8678
 #define PCI_DEVICE_ID_ADAPTEC_7887      0x8778
 #define PCI_DEVICE_ID_ADAPTEC_7888      0x8878
-#define PCI_DEVICE_ID_ADAPTEC_1030      0x8b78
 
 #define PCI_VENDOR_ID_ADAPTEC2          0x9005
 #define PCI_DEVICE_ID_ADAPTEC2_2940U2   0x0010
@@ -2657,10 +2156,9 @@
 #define PCI_DEVICE_ID_ADAPTEC2_7899B    0x00c1
 #define PCI_DEVICE_ID_ADAPTEC2_7899D    0x00c3
 #define PCI_DEVICE_ID_ADAPTEC2_7899P    0x00cf
+#define PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN   0x0500
 #define PCI_DEVICE_ID_ADAPTEC2_SCAMP    0x0503
 
-#define PCI_VENDOR_ID_ATRONICS          0x907f
-#define PCI_DEVICE_ID_ATRONICS_2015     0x2015
 
 #define PCI_VENDOR_ID_HOLTEK            0x9412
 #define PCI_DEVICE_ID_HOLTEK_6565       0x6565
@@ -2679,6 +2177,7 @@
 
 #define PCI_SUBVENDOR_ID_EXSYS          0xd84d
 #define PCI_SUBDEVICE_ID_EXSYS_4014     0x4014
+#define PCI_SUBDEVICE_ID_EXSYS_4055     0x4055
 
 #define PCI_VENDOR_ID_TIGERJET          0xe159
 #define PCI_DEVICE_ID_TIGERJET_300      0x0001
@@ -2692,7 +2191,3 @@
 #define PCI_DEVICE_ID_RME_DIGI32_PRO    0x9897
 #define PCI_DEVICE_ID_RME_DIGI32_8      0x9898
 
-#define PCI_VENDOR_ID_ARK               0xedd8
-#define PCI_DEVICE_ID_ARK_STING         0xa091
-#define PCI_DEVICE_ID_ARK_STINGARK      0xa099
-#define PCI_DEVICE_ID_ARK_2000MT        0xa0a1
diff --git a/include/linux/percpu.h b/include/linux/percpu.h
index 5451eb1e781d..fb8d2d24e4bb 100644
--- a/include/linux/percpu.h
+++ b/include/linux/percpu.h
@@ -38,7 +38,7 @@ extern void free_percpu(const void *);
 
 #else /* CONFIG_SMP */
 
-#define per_cpu_ptr(ptr, cpu) (ptr)
+#define per_cpu_ptr(ptr, cpu) ({ (void)(cpu); (ptr); })
 
 static inline void *__alloc_percpu(size_t size, size_t align)
 {
diff --git a/include/linux/phonedev.h b/include/linux/phonedev.h
index d54049eed0c3..a0e31adf3abe 100644
--- a/include/linux/phonedev.h
+++ b/include/linux/phonedev.h
@@ -2,7 +2,6 @@
 #define __LINUX_PHONEDEV_H
 
 #include <linux/types.h>
-#include <linux/version.h>
 
 #ifdef __KERNEL__
 
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 72cb67b66e0c..92a9696fdebe 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -72,6 +72,9 @@ struct mii_bus {
         /* list of all PHYs on bus */
         struct phy_device *phy_map[PHY_MAX_ADDR];
 
+        /* Phy addresses to be ignored when probing */
+        u32 phy_mask;
+
         /* Pointer to an array of interrupts, each PHY's
          * interrupt at the index matching its address */
         int *irq;
diff --git a/include/linux/pkt_sched.h b/include/linux/pkt_sched.h
index 60ffcb9c5791..e87b233615b3 100644
--- a/include/linux/pkt_sched.h
+++ b/include/linux/pkt_sched.h
@@ -93,6 +93,7 @@ struct tc_fifo_qopt
 /* PRIO section */
 
 #define TCQ_PRIO_BANDS  16
+#define TCQ_MIN_PRIO_BANDS 2
 
 struct tc_prio_qopt
 {
@@ -169,6 +170,7 @@ struct tc_red_qopt
         unsigned char   Scell_log;      /* cell size for idle damping */
         unsigned char   flags;
 #define TC_RED_ECN      1
+#define TC_RED_HARDDROP 2
 };
 
 struct tc_red_xstats
@@ -194,38 +196,34 @@ enum
 
 #define TCA_GRED_MAX (__TCA_GRED_MAX - 1)
 
-#define TCA_SET_OFF TCA_GRED_PARMS
 struct tc_gred_qopt
 {
-       __u32           limit;          /* HARD maximal queue length (bytes)    
-*/
-       __u32           qth_min;        /* Min average length threshold (bytes) 
-*/
-       __u32           qth_max;        /* Max average length threshold (bytes) 
-*/
-       __u32           DP;             /* upto 2^32 DPs */
-       __u32           backlog;        
-       __u32           qave;   
-       __u32           forced; 
-       __u32           early;  
-       __u32           other;  
-       __u32           pdrop;  
-
-       unsigned char   Wlog;           /* log(W)               */
-       unsigned char   Plog;           /* log(P_max/(qth_max-qth_min)) */
-       unsigned char   Scell_log;      /* cell size for idle damping */
-       __u8            prio;            /* prio of this VQ */
-       __u32    packets;
-       __u32    bytesin;
+        __u32           limit;        /* HARD maximal queue length (bytes)    */
+        __u32           qth_min;      /* Min average length threshold (bytes) */
+        __u32           qth_max;      /* Max average length threshold (bytes) */
+        __u32           DP;           /* upto 2^32 DPs */
+        __u32           backlog;
+        __u32           qave;
+        __u32           forced;
+        __u32           early;
+        __u32           other;
+        __u32           pdrop;
+        __u8            Wlog;         /* log(W)               */
+        __u8            Plog;         /* log(P_max/(qth_max-qth_min)) */
+        __u8            Scell_log;    /* cell size for idle damping */
+        __u8            prio;         /* prio of this VQ */
+        __u32           packets;
+        __u32           bytesin;
 };
+
 /* gred setup */
 struct tc_gred_sopt
 {
-       __u32            DPs;
-       __u32            def_DP;
-       __u8             grio;
-       __u8             pad1;
-       __u16            pad2;
+        __u32           DPs;
+        __u32           def_DP;
+        __u8            grio;
+        __u8            flags;
+        __u16           pad1;
 };
 
 /* HTB section */
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
new file mode 100644
index 000000000000..17e336f40b47
--- /dev/null
+++ b/include/linux/platform_device.h
@@ -0,0 +1,61 @@
+/*
+ * platform_device.h - generic, centralized driver model
+ *
+ * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
+ *
+ * This file is released under the GPLv2
+ *
+ * See Documentation/driver-model/ for more information.
+ */
+
+#ifndef _PLATFORM_DEVICE_H_
+#define _PLATFORM_DEVICE_H_
+
+#include <linux/device.h>
+
+struct platform_device {
+        const char      * name;
+        u32             id;
+        struct device   dev;
+        u32             num_resources;
+        struct resource * resource;
+};
+
+#define to_platform_device(x) container_of((x), struct platform_device, dev)
+
+extern int platform_device_register(struct platform_device *);
+extern void platform_device_unregister(struct platform_device *);
+
+extern struct bus_type platform_bus_type;
+extern struct device platform_bus;
+
+extern struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);
+extern int platform_get_irq(struct platform_device *, unsigned int);
+extern struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, char *);
+extern int platform_get_irq_byname(struct platform_device *, char *);
+extern int platform_add_devices(struct platform_device **, int);
+
+extern struct platform_device *platform_device_register_simple(char *, unsigned int, struct resource *, unsigned int);
+
+extern struct platform_device *platform_device_alloc(const char *name, unsigned int id);
+extern int platform_device_add_resources(struct platform_device *pdev, struct resource *res, unsigned int num);
+extern int platform_device_add_data(struct platform_device *pdev, void *data, size_t size);
+extern int platform_device_add(struct platform_device *pdev);
+extern void platform_device_put(struct platform_device *pdev);
+
+struct platform_driver {
+        int (*probe)(struct platform_device *);
+        int (*remove)(struct platform_device *);
+        void (*shutdown)(struct platform_device *);
+        int (*suspend)(struct platform_device *, pm_message_t state);
+        int (*resume)(struct platform_device *);
+        struct device_driver driver;
+};
+
+extern int platform_driver_register(struct platform_driver *);
+extern void platform_driver_unregister(struct platform_driver *);
+
+#define platform_get_drvdata(_dev)      dev_get_drvdata(&(_dev)->dev)
+#define platform_set_drvdata(_dev,data) dev_set_drvdata(&(_dev)->dev, (data))
+
+#endif /* _PLATFORM_DEVICE_H_ */
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 5cfb07648eca..5be87ba3b7ac 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -94,55 +94,6 @@ struct pm_dev
         struct list_head entry;
 };
 
-#ifdef CONFIG_PM
-
-extern int pm_active;
-
-#define PM_IS_ACTIVE() (pm_active != 0)
-
-/*
- * Register a device with power management
- */
-struct pm_dev __deprecated *
-pm_register(pm_dev_t type, unsigned long id, pm_callback callback);
-
-/*
- * Unregister a device with power management
- */
-void __deprecated pm_unregister(struct pm_dev *dev);
-
-/*
- * Unregister all devices with matching callback
- */
-void __deprecated pm_unregister_all(pm_callback callback);
-
-/*
- * Send a request to all devices
- */
-int __deprecated pm_send_all(pm_request_t rqst, void *data);
-
-#else /* CONFIG_PM */
-
-#define PM_IS_ACTIVE() 0
-
-static inline struct pm_dev *pm_register(pm_dev_t type,
-                                         unsigned long id,
-                                         pm_callback callback)
-{
-        return NULL;
-}
-
-static inline void pm_unregister(struct pm_dev *dev) {}
-
-static inline void pm_unregister_all(pm_callback callback) {}
-
-static inline int pm_send_all(pm_request_t rqst, void *data)
-{
-        return 0;
-}
-
-#endif /* CONFIG_PM */
-
 /* Functions above this comment are list-based old-style power
  * managment. Please avoid using them.  */
 
@@ -170,6 +121,7 @@ typedef int __bitwise suspend_disk_method_t;
 
 struct pm_ops {
         suspend_disk_method_t pm_disk_mode;
+        int (*valid)(suspend_state_t state);
         int (*prepare)(suspend_state_t state);
         int (*enter)(suspend_state_t state);
         int (*finish)(suspend_state_t state);
@@ -219,10 +171,11 @@ typedef struct pm_message {
 
 struct dev_pm_info {
         pm_message_t            power_state;
+        unsigned                can_wakeup:1;
 #ifdef  CONFIG_PM
+        unsigned                should_wakeup:1;
         pm_message_t            prev_state;
         void                    * saved_state;
-        atomic_t                pm_users;
         struct device           * pm_parent;
         struct list_head        entry;
 #endif
@@ -236,13 +189,48 @@ extern void device_resume(void);
 
 #ifdef CONFIG_PM
 extern int device_suspend(pm_message_t state);
-#else
+
+#define device_set_wakeup_enable(dev,val) \
+        ((dev)->power.should_wakeup = !!(val))
+#define device_may_wakeup(dev) \
+        (device_can_wakeup(dev) && (dev)->power.should_wakeup)
+
+extern int dpm_runtime_suspend(struct device *, pm_message_t);
+extern void dpm_runtime_resume(struct device *);
+
+#else /* !CONFIG_PM */
+
 static inline int device_suspend(pm_message_t state)
 {
         return 0;
 }
+
+#define device_set_wakeup_enable(dev,val)       do{}while(0)
+#define device_may_wakeup(dev)                  (0)
+
+static inline int dpm_runtime_suspend(struct device * dev, pm_message_t state)
+{
+        return 0;
+}
+
+static inline void dpm_runtime_resume(struct device * dev)
+{
+
+}
+
 #endif
 
+/* changes to device_may_wakeup take effect on the next pm state change.
+ * by default, devices should wakeup if they can.
+ */
+#define device_can_wakeup(dev) \
+        ((dev)->power.can_wakeup)
+#define device_init_wakeup(dev,val) \
+        do { \
+                device_can_wakeup(dev) = !!(val); \
+                device_set_wakeup_enable(dev,val); \
+        } while(0)
+
 #endif /* __KERNEL__ */
 
 #endif /* _LINUX_PM_H */
diff --git a/include/linux/pm_legacy.h b/include/linux/pm_legacy.h
new file mode 100644
index 000000000000..1252b45face1
--- /dev/null
+++ b/include/linux/pm_legacy.h
@@ -0,0 +1,56 @@
+#ifndef __LINUX_PM_LEGACY_H__
+#define __LINUX_PM_LEGACY_H__
+
+#include <linux/config.h>
+
+#ifdef CONFIG_PM_LEGACY
+
+extern int pm_active;
+
+#define PM_IS_ACTIVE() (pm_active != 0)
+
+/*
+ * Register a device with power management
+ */
+struct pm_dev __deprecated *
+pm_register(pm_dev_t type, unsigned long id, pm_callback callback);
+
+/*
+ * Unregister a device with power management
+ */
+void __deprecated pm_unregister(struct pm_dev *dev);
+
+/*
+ * Unregister all devices with matching callback
+ */
+void __deprecated pm_unregister_all(pm_callback callback);
+
+/*
+ * Send a request to all devices
+ */
+int __deprecated pm_send_all(pm_request_t rqst, void *data);
+
+#else /* CONFIG_PM_LEGACY */
+
+#define PM_IS_ACTIVE() 0
+
+static inline struct pm_dev *pm_register(pm_dev_t type,
+                                         unsigned long id,
+                                         pm_callback callback)
+{
+        return NULL;
+}
+
+static inline void pm_unregister(struct pm_dev *dev) {}
+
+static inline void pm_unregister_all(pm_callback callback) {}
+
+static inline int pm_send_all(pm_request_t rqst, void *data)
+{
+        return 0;
+}
+
+#endif /* CONFIG_PM_LEGACY */
+
+#endif /* __LINUX_PM_LEGACY_H__ */
+
diff --git a/include/linux/pnp.h b/include/linux/pnp.h
index aadbac29103c..584d57cb393a 100644
--- a/include/linux/pnp.h
+++ b/include/linux/pnp.h
@@ -353,7 +353,6 @@ struct pnp_protocol {
 int pnp_register_protocol(struct pnp_protocol *protocol);
 void pnp_unregister_protocol(struct pnp_protocol *protocol);
 int pnp_add_device(struct pnp_dev *dev);
-void pnp_remove_device(struct pnp_dev *dev);
 int pnp_device_attach(struct pnp_dev *pnp_dev);
 void pnp_device_detach(struct pnp_dev *pnp_dev);
 extern struct list_head pnp_global;
@@ -399,7 +398,6 @@ static inline int pnp_register_protocol(struct pnp_protocol *protocol) { return
 static inline void pnp_unregister_protocol(struct pnp_protocol *protocol) { }
 static inline int pnp_init_device(struct pnp_dev *dev) { return -ENODEV; }
 static inline int pnp_add_device(struct pnp_dev *dev) { return -ENODEV; }
-static inline void pnp_remove_device(struct pnp_dev *dev) { }
 static inline int pnp_device_attach(struct pnp_dev *pnp_dev) { return -ENODEV; }
 static inline void pnp_device_detach(struct pnp_dev *pnp_dev) { ; }
 
diff --git a/include/linux/posix_acl.h b/include/linux/posix_acl.h
index 4caedddaa033..4bc241290c24 100644
--- a/include/linux/posix_acl.h
+++ b/include/linux/posix_acl.h
@@ -71,11 +71,11 @@ posix_acl_release(struct posix_acl *acl)
 
 /* posix_acl.c */
 
-extern struct posix_acl *posix_acl_alloc(int, unsigned int __nocast);
-extern struct posix_acl *posix_acl_clone(const struct posix_acl *, unsigned int __nocast);
+extern struct posix_acl *posix_acl_alloc(int, gfp_t);
+extern struct posix_acl *posix_acl_clone(const struct posix_acl *, gfp_t);
 extern int posix_acl_valid(const struct posix_acl *);
 extern int posix_acl_permission(struct inode *, const struct posix_acl *, int);
-extern struct posix_acl *posix_acl_from_mode(mode_t, unsigned int __nocast);
+extern struct posix_acl *posix_acl_from_mode(mode_t, gfp_t);
 extern int posix_acl_equiv_mode(const struct posix_acl *, mode_t *);
 extern int posix_acl_create_masq(struct posix_acl *, mode_t *);
 extern int posix_acl_chmod_masq(struct posix_acl *, mode_t);
diff --git a/include/linux/ppp-comp.h b/include/linux/ppp-comp.h
index 7227e653b3be..e86a7a5cf355 100644
--- a/include/linux/ppp-comp.h
+++ b/include/linux/ppp-comp.h
@@ -111,6 +111,8 @@ struct compressor {
 
         /* Used in locking compressor modules */
         struct module *owner;
+        /* Extra skb space needed by the compressor algorithm */
+        unsigned int comp_extra;
 };
 
 /*
@@ -191,6 +193,13 @@ struct compressor {
 #define DEFLATE_CHK_SEQUENCE    0
 
 /*
+ * Definitions for MPPE.
+ */
+
+#define CI_MPPE                18      /* config option for MPPE */
+#define CILEN_MPPE              6      /* length of config option */
+
+/*
  * Definitions for other, as yet unsupported, compression methods.
  */
 
diff --git a/include/linux/preempt.h b/include/linux/preempt.h
index dd98c54a23b4..d9a2f5254a51 100644
--- a/include/linux/preempt.h
+++ b/include/linux/preempt.h
@@ -7,6 +7,7 @@
  */
 
 #include <linux/config.h>
+#include <linux/thread_info.h>
 #include <linux/linkage.h>
 
 #ifdef CONFIG_DEBUG_PREEMPT
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 0563581e3a02..74488e49166d 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -66,6 +66,7 @@ struct proc_dir_entry {
         write_proc_t *write_proc;
         atomic_t count;         /* use count */
         int deleted;            /* delete flag */
+        void *set;
 };
 
 struct kcore_list {
@@ -139,15 +140,12 @@ extern void proc_tty_unregister_driver(struct tty_driver *driver);
 /*
  * proc_devtree.c
  */
+#ifdef CONFIG_PROC_DEVICETREE
 struct device_node;
+struct property;
 extern void proc_device_tree_init(void);
-#ifdef CONFIG_PROC_DEVICETREE
 extern void proc_device_tree_add_node(struct device_node *, struct proc_dir_entry *);
-#else /* !CONFIG_PROC_DEVICETREE */
-static inline void proc_device_tree_add_node(struct device_node *np, struct proc_dir_entry *pde)
-{
-        return;
-}
+extern void proc_device_tree_add_prop(struct proc_dir_entry *pde, struct property *prop);
 #endif /* CONFIG_PROC_DEVICETREE */
 
 extern struct proc_dir_entry *proc_symlink(const char *,
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index dc6f3647bfbc..b2b3dba1298d 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -78,6 +78,8 @@
 #include <linux/compiler.h>             /* For unlikely.  */
 #include <linux/sched.h>                /* For struct task_struct.  */
 
+
+extern long arch_ptrace(struct task_struct *child, long request, long addr, long data);
 extern int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len);
 extern int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len);
 extern int ptrace_attach(struct task_struct *tsk);
diff --git a/include/linux/quota.h b/include/linux/quota.h
index 700ead45084f..f33aeb22c26a 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -289,7 +289,6 @@ struct quota_info {
         struct semaphore dqonoff_sem;           /* Serialize quotaon & quotaoff */
         struct rw_semaphore dqptr_sem;          /* serialize ops using quota_info struct, pointers from inode to dquots */
         struct inode *files[MAXQUOTAS];         /* inodes of quotafiles */
-        struct vfsmount *mnt[MAXQUOTAS];        /* mountpoint entries of filesystems with quota files */
         struct mem_dqinfo info[MAXQUOTAS];      /* Information for each quota type */
         struct quota_format_ops *ops[MAXQUOTAS];        /* Operations for each type */
 };
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index d211507ab246..4f34d3d60f2e 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -198,38 +198,38 @@ static __inline__ int DQUOT_OFF(struct super_block *sb)
 #define DQUOT_SYNC(sb)                          do { } while(0)
 #define DQUOT_OFF(sb)                           do { } while(0)
 #define DQUOT_TRANSFER(inode, iattr)            (0)
-extern __inline__ int DQUOT_PREALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
+static inline int DQUOT_PREALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
 {
         inode_add_bytes(inode, nr);
         return 0;
 }
 
-extern __inline__ int DQUOT_PREALLOC_SPACE(struct inode *inode, qsize_t nr)
+static inline int DQUOT_PREALLOC_SPACE(struct inode *inode, qsize_t nr)
 {
         DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr);
         mark_inode_dirty(inode);
         return 0;
 }
 
-extern __inline__ int DQUOT_ALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
+static inline int DQUOT_ALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
 {
         inode_add_bytes(inode, nr);
         return 0;
 }
 
-extern __inline__ int DQUOT_ALLOC_SPACE(struct inode *inode, qsize_t nr)
+static inline int DQUOT_ALLOC_SPACE(struct inode *inode, qsize_t nr)
 {
         DQUOT_ALLOC_SPACE_NODIRTY(inode, nr);
         mark_inode_dirty(inode);
         return 0;
 }
 
-extern __inline__ void DQUOT_FREE_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
+static inline void DQUOT_FREE_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
 {
         inode_sub_bytes(inode, nr);
 }
 
-extern __inline__ void DQUOT_FREE_SPACE(struct inode *inode, qsize_t nr)
+static inline void DQUOT_FREE_SPACE(struct inode *inode, qsize_t nr)
 {
         DQUOT_FREE_SPACE_NODIRTY(inode, nr);
         mark_inode_dirty(inode);
diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h
index 9c51917b1cce..36e5d269612f 100644
--- a/include/linux/radix-tree.h
+++ b/include/linux/radix-tree.h
@@ -24,7 +24,7 @@
 
 struct radix_tree_root {
         unsigned int            height;
-        unsigned int            gfp_mask;
+        gfp_t                   gfp_mask;
         struct radix_tree_node  *rnode;
 };
 
@@ -46,11 +46,12 @@ do {									\
 
 int radix_tree_insert(struct radix_tree_root *, unsigned long, void *);
 void *radix_tree_lookup(struct radix_tree_root *, unsigned long);
+void **radix_tree_lookup_slot(struct radix_tree_root *, unsigned long);
 void *radix_tree_delete(struct radix_tree_root *, unsigned long);
 unsigned int
 radix_tree_gang_lookup(struct radix_tree_root *root, void **results,
                         unsigned long first_index, unsigned int max_items);
-int radix_tree_preload(unsigned int __nocast gfp_mask);
+int radix_tree_preload(gfp_t gfp_mask);
 void radix_tree_init(void);
 void *radix_tree_tag_set(struct radix_tree_root *root,
                         unsigned long index, int tag);
diff --git a/include/linux/raid/bitmap.h b/include/linux/raid/bitmap.h
index 9de99198caf1..899437802aea 100644
--- a/include/linux/raid/bitmap.h
+++ b/include/linux/raid/bitmap.h
@@ -6,7 +6,13 @@
 #ifndef BITMAP_H
 #define BITMAP_H 1
 
-#define BITMAP_MAJOR 3
+#define BITMAP_MAJOR_LO 3
+/* version 4 insists the bitmap is in little-endian order
+ * with version 3, it is host-endian which is non-portable
+ */
+#define BITMAP_MAJOR_HI 4
+#define BITMAP_MAJOR_HOSTENDIAN 3
+
 #define BITMAP_MINOR 39
 
 /*
@@ -133,7 +139,8 @@ typedef __u16 bitmap_counter_t;
 /* use these for bitmap->flags and bitmap->sb->state bit-fields */
 enum bitmap_state {
         BITMAP_ACTIVE = 0x001, /* the bitmap is in use */
-        BITMAP_STALE  = 0x002  /* the bitmap file is out of date or had -EIO */
+        BITMAP_STALE  = 0x002,  /* the bitmap file is out of date or had -EIO */
+        BITMAP_HOSTENDIAN = 0x8000,
 };
 
 /* the superblock at the front of the bitmap file -- little endian */
diff --git a/include/linux/raid/md.h b/include/linux/raid/md.h
index ffa316ce4dc8..13e7c4b62367 100644
--- a/include/linux/raid/md.h
+++ b/include/linux/raid/md.h
@@ -66,8 +66,10 @@
  *     and major_version/minor_version accordingly
  * >=2 means that Internal bitmaps are supported by setting MD_SB_BITMAP_PRESENT
  *     in the super status byte
+ * >=3 means that bitmap superblock version 4 is supported, which uses
+ *     little-ending representation rather than host-endian
  */
-#define MD_PATCHLEVEL_VERSION           2
+#define MD_PATCHLEVEL_VERSION           3
 
 extern int register_md_personality (int p_num, mdk_personality_t *p);
 extern int unregister_md_personality (int p_num);
@@ -87,6 +89,7 @@ extern void md_print_devices (void);
 
 extern void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
                            sector_t sector, int size, struct page *page);
+extern void md_super_wait(mddev_t *mddev);
 extern int sync_page_io(struct block_device *bdev, sector_t sector, int size,
                         struct page *page, int rw);
 
diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h
index ebce949b1443..46629a275ba9 100644
--- a/include/linux/raid/md_k.h
+++ b/include/linux/raid/md_k.h
@@ -105,6 +105,8 @@ struct mdk_rdev_s
         int             sb_size;        /* bytes in the superblock */
         int             preferred_minor;        /* autorun support */
 
+        struct kobject  kobj;
+
         /* A device can be in one of three states based on two flags:
          * Not working:   faulty==1 in_sync==0
          * Fully working: faulty==0 in_sync==1
@@ -115,11 +117,12 @@ struct mdk_rdev_s
          * It can never have faulty==1, in_sync==1
          * This reduces the burden of testing multiple flags in many cases
          */
-        int faulty;                     /* if faulty do not issue IO requests */
-        int in_sync;                    /* device is a full member of the array */
 
-        unsigned long   flags;          /* Should include faulty and in_sync here. */
+        unsigned long   flags;
+#define Faulty          1               /* device is known to have a fault */
+#define In_sync         2               /* device is in_sync with rest of array */
 #define WriteMostly     4               /* Avoid reading if at all possible */
+#define BarriersNotsupp 5               /* BIO_RW_BARRIER is not supported */
 
         int desc_nr;                    /* descriptor index in the superblock */
         int raid_disk;                  /* role of device in array */
@@ -132,6 +135,9 @@ struct mdk_rdev_s
                                          * only maintained for arrays that
                                          * support hot removal
                                          */
+        atomic_t        read_errors;    /* number of consecutive read errors that
+                                         * we have tried to ignore.
+                                         */
 };
 
 typedef struct mdk_personality_s mdk_personality_t;
@@ -148,6 +154,8 @@ struct mddev_s
 
         struct gendisk                  *gendisk;
 
+        struct kobject                  kobj;
+
         /* Superblock information */
         int                             major_version,
                                         minor_version,
@@ -171,6 +179,10 @@ struct mddev_s
         sector_t                        resync_mark_cnt;/* blocks written at resync_mark */
 
         sector_t                        resync_max_sectors; /* may be set by personality */
+
+        sector_t                        resync_mismatches; /* count of sectors where
+                                                            * parity/replica mismatch found
+                                                            */
         /* recovery/resync flags 
          * NEEDED:   we might need to start a resync/recover
          * RUNNING:  a thread is running, or about to be started
@@ -178,6 +190,8 @@ struct mddev_s
          * ERR:      and IO error was detected - abort the resync/recovery
          * INTR:     someone requested a (clean) early abort.
          * DONE:     thread is done and is waiting to be reaped
+         * REQUEST:  user-space has requested a sync (used with SYNC)
+         * CHECK:    user-space request for for check-only, no repair
          */
 #define MD_RECOVERY_RUNNING     0
 #define MD_RECOVERY_SYNC        1
@@ -185,6 +199,8 @@ struct mddev_s
 #define MD_RECOVERY_INTR        3
 #define MD_RECOVERY_DONE        4
 #define MD_RECOVERY_NEEDED      5
+#define MD_RECOVERY_REQUESTED   6
+#define MD_RECOVERY_CHECK       7
         unsigned long                   recovery;
 
         int                             in_sync;        /* know to not need resync */
@@ -195,6 +211,13 @@ struct mddev_s
         int                             degraded;       /* whether md should consider
                                                          * adding a spare
                                                          */
+        int                             barriers_work;  /* initialised to true, cleared as soon
+                                                         * as a barrier request to slave
+                                                         * fails.  Only supported
+                                                         */
+        struct bio                      *biolist;       /* bios that need to be retried
+                                                         * because BIO_RW_BARRIER is not supported
+                                                         */
 
         atomic_t                        recovery_active; /* blocks scheduled, but not written */
         wait_queue_head_t               recovery_wait;
@@ -232,7 +255,7 @@ struct mddev_s
 
 static inline void rdev_dec_pending(mdk_rdev_t *rdev, mddev_t *mddev)
 {
-        int faulty = rdev->faulty;
+        int faulty = test_bit(Faulty, &rdev->flags);
         if (atomic_dec_and_test(&rdev->nr_pending) && faulty)
                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
 }
@@ -270,6 +293,13 @@ struct mdk_personality_s
 };
 
 
+struct md_sysfs_entry {
+        struct attribute attr;
+        ssize_t (*show)(mddev_t *, char *);
+        ssize_t (*store)(mddev_t *, const char *, size_t);
+};
+
+
 static inline char * mdname (mddev_t * mddev)
 {
         return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
@@ -304,10 +334,8 @@ typedef struct mdk_thread_s {
         mddev_t                 *mddev;
         wait_queue_head_t       wqueue;
         unsigned long           flags;
-        struct completion       *event;
         struct task_struct      *tsk;
         unsigned long           timeout;
-        const char              *name;
 } mdk_thread_t;
 
 #define THREAD_WAKEUP  0
diff --git a/include/linux/raid/raid1.h b/include/linux/raid/raid1.h
index 60e19b667548..292b98f2b408 100644
--- a/include/linux/raid/raid1.h
+++ b/include/linux/raid/raid1.h
@@ -110,7 +110,9 @@ struct r1bio_s {
 #define R1BIO_Uptodate  0
 #define R1BIO_IsSync    1
 #define R1BIO_Degraded  2
-#define R1BIO_BehindIO   3
+#define R1BIO_BehindIO  3
+#define R1BIO_Barrier   4
+#define R1BIO_BarrierRetry 5
 /* For write-behind requests, we call bi_end_io when
  * the last non-write-behind device completes, providing
  * any write was successful.  Otherwise we call when
diff --git a/include/linux/raid/raid5.h b/include/linux/raid/raid5.h
index 176fc653c284..f025ba6fb14c 100644
--- a/include/linux/raid/raid5.h
+++ b/include/linux/raid/raid5.h
@@ -154,6 +154,8 @@ struct stripe_head {
 #define R5_Wantwrite    5
 #define R5_Syncio       6       /* this io need to be accounted as resync io */
 #define R5_Overlap      7       /* There is a pending overlapping request on this block */
+#define R5_ReadError    8       /* seen a read error here recently */
+#define R5_ReWrite      9       /* have tried to over-write the readerror */
 
 /*
  * Write method
diff --git a/include/linux/raid_class.h b/include/linux/raid_class.h
index a71123c28272..48831eac2910 100644
--- a/include/linux/raid_class.h
+++ b/include/linux/raid_class.h
@@ -1,4 +1,9 @@
 /*
+ * raid_class.h - a generic raid visualisation class
+ *
+ * Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>
+ *
+ * This file is licensed under GPLv2
  */
 #include <linux/transport_class.h>
 
@@ -14,20 +19,35 @@ struct raid_function_template {
 };
 
 enum raid_state {
-        RAID_ACTIVE = 1,
-        RAID_DEGRADED,
-        RAID_RESYNCING,
-        RAID_OFFLINE,
+        RAID_STATE_UNKNOWN = 0,
+        RAID_STATE_ACTIVE,
+        RAID_STATE_DEGRADED,
+        RAID_STATE_RESYNCING,
+        RAID_STATE_OFFLINE,
+};
+
+enum raid_level {
+        RAID_LEVEL_UNKNOWN = 0,
+        RAID_LEVEL_LINEAR,
+        RAID_LEVEL_0,
+        RAID_LEVEL_1,
+        RAID_LEVEL_3,
+        RAID_LEVEL_4,
+        RAID_LEVEL_5,
+        RAID_LEVEL_6,
 };
 
 struct raid_data {
         struct list_head component_list;
         int component_count;
-        int level;
+        enum raid_level level;
         enum raid_state state;
         int resync;
 };
 
+/* resync complete goes from 0 to this */
+#define RAID_MAX_RESYNC         (10000)
+
 #define DEFINE_RAID_ATTRIBUTE(type, attr)                                     \
 static inline void                                                            \
 raid_set_##attr(struct raid_template *r, struct device *dev, type value) {    \
@@ -48,7 +68,7 @@ raid_get_##attr(struct raid_template *r, struct device *dev) {		      \
         return rd->attr;                                                      \
 }
 
-DEFINE_RAID_ATTRIBUTE(int, level)
+DEFINE_RAID_ATTRIBUTE(enum raid_level, level)
 DEFINE_RAID_ATTRIBUTE(int, resync)
 DEFINE_RAID_ATTRIBUTE(enum raid_state, state)
         
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 4e65eb44adfd..cce25591eec2 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -94,6 +94,7 @@ struct rcu_data {
         long            batch;           /* Batch # for current RCU batch */
         struct rcu_head *nxtlist;
         struct rcu_head **nxttail;
+        long            count; /* # of queued items */
         struct rcu_head *curlist;
         struct rcu_head **curtail;
         struct rcu_head *donelist;
@@ -274,6 +275,7 @@ static inline int rcu_pending(int cpu)
 extern void rcu_init(void);
 extern void rcu_check_callbacks(int cpu, int user);
 extern void rcu_restart_cpu(int cpu);
+extern long rcu_batches_completed(void);
 
 /* Exported interfaces */
 extern void FASTCALL(call_rcu(struct rcu_head *head, 
diff --git a/include/linux/reboot.h b/include/linux/reboot.h
index 3b3266ff1a95..7ab2cdb83ef0 100644
--- a/include/linux/reboot.h
+++ b/include/linux/reboot.h
@@ -59,6 +59,10 @@ extern void machine_crash_shutdown(struct pt_regs *);
  * Architecture independent implemenations of sys_reboot commands.
  */
 
+extern void kernel_restart_prepare(char *cmd);
+extern void kernel_halt_prepare(void);
+extern void kernel_power_off_prepare(void);
+
 extern void kernel_restart(char *cmd);
 extern void kernel_halt(void);
 extern void kernel_power_off(void);
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index af00b10294cd..001ab82df051 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -1972,7 +1972,7 @@ extern struct address_space_operations reiserfs_address_space_operations;
 
 /* fix_nodes.c */
 #ifdef CONFIG_REISERFS_CHECK
-void *reiserfs_kmalloc(size_t size, int flags, struct super_block *s);
+void *reiserfs_kmalloc(size_t size, gfp_t flags, struct super_block *s);
 void reiserfs_kfree(const void *vp, size_t size, struct super_block *s);
 #else
 static inline void *reiserfs_kmalloc(size_t size, int flags,
diff --git a/include/linux/rio.h b/include/linux/rio.h
new file mode 100644
index 000000000000..c7e907faae9c
--- /dev/null
+++ b/include/linux/rio.h
@@ -0,0 +1,325 @@
+/*
+ * RapidIO interconnect services
+ * (RapidIO Interconnect Specification, http://www.rapidio.org)
+ *
+ * Copyright 2005 MontaVista Software, Inc.
+ * Matt Porter <mporter@kernel.crashing.org>
+ *
+ * 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 LINUX_RIO_H
+#define LINUX_RIO_H
+
+#ifdef __KERNEL__
+
+#include <linux/types.h>
+#include <linux/config.h>
+#include <linux/ioport.h>
+#include <linux/list.h>
+#include <linux/errno.h>
+#include <linux/device.h>
+#include <linux/rio_regs.h>
+
+#define RIO_ANY_DESTID          0xff
+#define RIO_NO_HOPCOUNT         -1
+
+#define RIO_MAX_MPORT_RESOURCES 16
+#define RIO_MAX_DEV_RESOURCES   16
+
+#define RIO_GLOBAL_TABLE        0xff    /* Indicates access of a switch's
+                                           global routing table if it
+                                           has multiple (or per port)
+                                           tables */
+
+#define RIO_INVALID_ROUTE       0xff    /* Indicates that a route table
+                                           entry is invalid (no route
+                                           exists for the device ID) */
+
+#ifdef CONFIG_RAPIDIO_8_BIT_TRANSPORT
+#define RIO_MAX_ROUTE_ENTRIES   (1 << 8)
+#else
+#define RIO_MAX_ROUTE_ENTRIES   (1 << 16)
+#endif
+
+#define RIO_MAX_MBOX            4
+#define RIO_MAX_MSG_SIZE        0x1000
+
+/*
+ * Error values that may be returned by RIO functions.
+ */
+#define RIO_SUCCESSFUL                  0x00
+#define RIO_BAD_SIZE                    0x81
+
+/*
+ * For RIO devices, the region numbers are assigned this way:
+ *
+ *      0       RapidIO outbound doorbells
+ *      1-15    RapidIO memory regions
+ *
+ * For RIO master ports, the region number are assigned this way:
+ *
+ *      0       RapidIO inbound doorbells
+ *      1       RapidIO inbound mailboxes
+ *      1       RapidIO outbound mailboxes
+ */
+#define RIO_DOORBELL_RESOURCE   0
+#define RIO_INB_MBOX_RESOURCE   1
+#define RIO_OUTB_MBOX_RESOURCE  2
+
+extern struct bus_type rio_bus_type;
+extern struct list_head rio_devices;    /* list of all devices */
+
+struct rio_mport;
+
+/**
+ * struct rio_dev - RIO device info
+ * @global_list: Node in list of all RIO devices
+ * @net_list: Node in list of RIO devices in a network
+ * @net: Network this device is a part of
+ * @did: Device ID
+ * @vid: Vendor ID
+ * @device_rev: Device revision
+ * @asm_did: Assembly device ID
+ * @asm_vid: Assembly vendor ID
+ * @asm_rev: Assembly revision
+ * @efptr: Extended feature pointer
+ * @pef: Processing element features
+ * @swpinfo: Switch port info
+ * @src_ops: Source operation capabilities
+ * @dst_ops: Destination operation capabilities
+ * @dma_mask: Mask of bits of RIO address this device implements
+ * @rswitch: Pointer to &struct rio_switch if valid for this device
+ * @driver: Driver claiming this device
+ * @dev: Device model device
+ * @riores: RIO resources this device owns
+ * @destid: Network destination ID
+ */
+struct rio_dev {
+        struct list_head global_list;   /* node in list of all RIO devices */
+        struct list_head net_list;      /* node in per net list */
+        struct rio_net *net;    /* RIO net this device resides in */
+        u16 did;
+        u16 vid;
+        u32 device_rev;
+        u16 asm_did;
+        u16 asm_vid;
+        u16 asm_rev;
+        u16 efptr;
+        u32 pef;
+        u32 swpinfo;            /* Only used for switches */
+        u32 src_ops;
+        u32 dst_ops;
+        u64 dma_mask;
+        struct rio_switch *rswitch;     /* RIO switch info */
+        struct rio_driver *driver;      /* RIO driver claiming this device */
+        struct device dev;      /* LDM device structure */
+        struct resource riores[RIO_MAX_DEV_RESOURCES];
+        u16 destid;
+};
+
+#define rio_dev_g(n) list_entry(n, struct rio_dev, global_list)
+#define rio_dev_f(n) list_entry(n, struct rio_dev, net_list)
+#define to_rio_dev(n) container_of(n, struct rio_dev, dev)
+
+/**
+ * struct rio_msg - RIO message event
+ * @res: Mailbox resource
+ * @mcback: Message event callback
+ */
+struct rio_msg {
+        struct resource *res;
+        void (*mcback) (struct rio_mport * mport, void *dev_id, int mbox, int slot);
+};
+
+/**
+ * struct rio_dbell - RIO doorbell event
+ * @node: Node in list of doorbell events
+ * @res: Doorbell resource
+ * @dinb: Doorbell event callback
+ * @dev_id: Device specific pointer to pass on event
+ */
+struct rio_dbell {
+        struct list_head node;
+        struct resource *res;
+        void (*dinb) (struct rio_mport *mport, void *dev_id, u16 src, u16 dst, u16 info);
+        void *dev_id;
+};
+
+/**
+ * struct rio_mport - RIO master port info
+ * @dbells: List of doorbell events
+ * @node: Node in global list of master ports
+ * @nnode: Node in network list of master ports
+ * @iores: I/O mem resource that this master port interface owns
+ * @riores: RIO resources that this master port interfaces owns
+ * @inb_msg: RIO inbound message event descriptors
+ * @outb_msg: RIO outbound message event descriptors
+ * @host_deviceid: Host device ID associated with this master port
+ * @ops: configuration space functions
+ * @id: Port ID, unique among all ports
+ * @index: Port index, unique among all port interfaces of the same type
+ * @name: Port name string
+ */
+struct rio_mport {
+        struct list_head dbells;        /* list of doorbell events */
+        struct list_head node;  /* node in global list of ports */
+        struct list_head nnode; /* node in net list of ports */
+        struct resource iores;
+        struct resource riores[RIO_MAX_MPORT_RESOURCES];
+        struct rio_msg inb_msg[RIO_MAX_MBOX];
+        struct rio_msg outb_msg[RIO_MAX_MBOX];
+        int host_deviceid;      /* Host device ID */
+        struct rio_ops *ops;    /* maintenance transaction functions */
+        unsigned char id;       /* port ID, unique among all ports */
+        unsigned char index;    /* port index, unique among all port
+                                   interfaces of the same type */
+        unsigned char name[40];
+};
+
+/**
+ * struct rio_net - RIO network info
+ * @node: Node in global list of RIO networks
+ * @devices: List of devices in this network
+ * @mports: List of master ports accessing this network
+ * @hport: Default port for accessing this network
+ * @id: RIO network ID
+ */
+struct rio_net {
+        struct list_head node;  /* node in list of networks */
+        struct list_head devices;       /* list of devices in this net */
+        struct list_head mports;        /* list of ports accessing net */
+        struct rio_mport *hport;        /* primary port for accessing net */
+        unsigned char id;       /* RIO network ID */
+};
+
+/**
+ * struct rio_switch - RIO switch info
+ * @node: Node in global list of switches
+ * @switchid: Switch ID that is unique across a network
+ * @hopcount: Hopcount to this switch
+ * @destid: Associated destid in the path
+ * @route_table: Copy of switch routing table
+ * @add_entry: Callback for switch-specific route add function
+ * @get_entry: Callback for switch-specific route get function
+ */
+struct rio_switch {
+        struct list_head node;
+        u16 switchid;
+        u16 hopcount;
+        u16 destid;
+        u8 route_table[RIO_MAX_ROUTE_ENTRIES];
+        int (*add_entry) (struct rio_mport * mport, u16 destid, u8 hopcount,
+                          u16 table, u16 route_destid, u8 route_port);
+        int (*get_entry) (struct rio_mport * mport, u16 destid, u8 hopcount,
+                          u16 table, u16 route_destid, u8 * route_port);
+};
+
+/* Low-level architecture-dependent routines */
+
+/**
+ * struct rio_ops - Low-level RIO configuration space operations
+ * @lcread: Callback to perform local (master port) read of config space.
+ * @lcwrite: Callback to perform local (master port) write of config space.
+ * @cread: Callback to perform network read of config space.
+ * @cwrite: Callback to perform network write of config space.
+ * @dsend: Callback to send a doorbell message.
+ */
+struct rio_ops {
+        int (*lcread) (int index, u32 offset, int len, u32 * data);
+        int (*lcwrite) (int index, u32 offset, int len, u32 data);
+        int (*cread) (int index, u16 destid, u8 hopcount, u32 offset, int len,
+                      u32 * data);
+        int (*cwrite) (int index, u16 destid, u8 hopcount, u32 offset, int len,
+                       u32 data);
+        int (*dsend) (int index, u16 destid, u16 data);
+};
+
+#define RIO_RESOURCE_MEM        0x00000100
+#define RIO_RESOURCE_DOORBELL   0x00000200
+#define RIO_RESOURCE_MAILBOX    0x00000400
+
+#define RIO_RESOURCE_CACHEABLE  0x00010000
+#define RIO_RESOURCE_PCI        0x00020000
+
+#define RIO_RESOURCE_BUSY       0x80000000
+
+/**
+ * struct rio_driver - RIO driver info
+ * @node: Node in list of drivers
+ * @name: RIO driver name
+ * @id_table: RIO device ids to be associated with this driver
+ * @probe: RIO device inserted
+ * @remove: RIO device removed
+ * @suspend: RIO device suspended
+ * @resume: RIO device awakened
+ * @enable_wake: RIO device enable wake event
+ * @driver: LDM driver struct
+ *
+ * Provides info on a RIO device driver for insertion/removal and
+ * power management purposes.
+ */
+struct rio_driver {
+        struct list_head node;
+        char *name;
+        const struct rio_device_id *id_table;
+        int (*probe) (struct rio_dev * dev, const struct rio_device_id * id);
+        void (*remove) (struct rio_dev * dev);
+        int (*suspend) (struct rio_dev * dev, u32 state);
+        int (*resume) (struct rio_dev * dev);
+        int (*enable_wake) (struct rio_dev * dev, u32 state, int enable);
+        struct device_driver driver;
+};
+
+#define to_rio_driver(drv) container_of(drv,struct rio_driver, driver)
+
+/**
+ * struct rio_device_id - RIO device identifier
+ * @did: RIO device ID
+ * @vid: RIO vendor ID
+ * @asm_did: RIO assembly device ID
+ * @asm_vid: RIO assembly vendor ID
+ *
+ * Identifies a RIO device based on both the device/vendor IDs and
+ * the assembly device/vendor IDs.
+ */
+struct rio_device_id {
+        u16 did, vid;
+        u16 asm_did, asm_vid;
+};
+
+/**
+ * struct rio_route_ops - Per-switch route operations
+ * @vid: RIO vendor ID
+ * @did: RIO device ID
+ * @add_hook: Callback that adds a route entry
+ * @get_hook: Callback that gets a route entry
+ *
+ * Defines the operations that are necessary to manipulate the route
+ * tables for a particular RIO switch device.
+ */
+struct rio_route_ops {
+        u16 vid, did;
+        int (*add_hook) (struct rio_mport * mport, u16 destid, u8 hopcount,
+                         u16 table, u16 route_destid, u8 route_port);
+        int (*get_hook) (struct rio_mport * mport, u16 destid, u8 hopcount,
+                         u16 table, u16 route_destid, u8 * route_port);
+};
+
+/* Architecture and hardware-specific functions */
+extern int rio_init_mports(void);
+extern void rio_register_mport(struct rio_mport *);
+extern int rio_hw_add_outb_message(struct rio_mport *, struct rio_dev *, int,
+                                   void *, size_t);
+extern int rio_hw_add_inb_buffer(struct rio_mport *, int, void *);
+extern void *rio_hw_get_inb_message(struct rio_mport *, int);
+extern int rio_open_inb_mbox(struct rio_mport *, void *, int, int);
+extern void rio_close_inb_mbox(struct rio_mport *, int);
+extern int rio_open_outb_mbox(struct rio_mport *, void *, int, int);
+extern void rio_close_outb_mbox(struct rio_mport *, int);
+
+#endif                          /* __KERNEL__ */
+#endif                          /* LINUX_RIO_H */
diff --git a/include/linux/rio_drv.h b/include/linux/rio_drv.h
new file mode 100644
index 000000000000..3bd7cce19e26
--- /dev/null
+++ b/include/linux/rio_drv.h
@@ -0,0 +1,469 @@
+/*
+ * RapidIO driver services
+ *
+ * Copyright 2005 MontaVista Software, Inc.
+ * Matt Porter <mporter@kernel.crashing.org>
+ *
+ * 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 LINUX_RIO_DRV_H
+#define LINUX_RIO_DRV_H
+
+#ifdef __KERNEL__
+
+#include <linux/types.h>
+#include <linux/config.h>
+#include <linux/ioport.h>
+#include <linux/list.h>
+#include <linux/errno.h>
+#include <linux/device.h>
+#include <linux/rio.h>
+
+extern int __rio_local_read_config_32(struct rio_mport *port, u32 offset,
+                                      u32 * data);
+extern int __rio_local_write_config_32(struct rio_mport *port, u32 offset,
+                                       u32 data);
+extern int __rio_local_read_config_16(struct rio_mport *port, u32 offset,
+                                      u16 * data);
+extern int __rio_local_write_config_16(struct rio_mport *port, u32 offset,
+                                       u16 data);
+extern int __rio_local_read_config_8(struct rio_mport *port, u32 offset,
+                                     u8 * data);
+extern int __rio_local_write_config_8(struct rio_mport *port, u32 offset,
+                                      u8 data);
+
+extern int rio_mport_read_config_32(struct rio_mport *port, u16 destid,
+                                    u8 hopcount, u32 offset, u32 * data);
+extern int rio_mport_write_config_32(struct rio_mport *port, u16 destid,
+                                     u8 hopcount, u32 offset, u32 data);
+extern int rio_mport_read_config_16(struct rio_mport *port, u16 destid,
+                                    u8 hopcount, u32 offset, u16 * data);
+extern int rio_mport_write_config_16(struct rio_mport *port, u16 destid,
+                                     u8 hopcount, u32 offset, u16 data);
+extern int rio_mport_read_config_8(struct rio_mport *port, u16 destid,
+                                   u8 hopcount, u32 offset, u8 * data);
+extern int rio_mport_write_config_8(struct rio_mport *port, u16 destid,
+                                    u8 hopcount, u32 offset, u8 data);
+
+/**
+ * rio_local_read_config_32 - Read 32 bits from local configuration space
+ * @port: Master port
+ * @offset: Offset into local configuration space
+ * @data: Pointer to read data into
+ *
+ * Reads 32 bits of data from the specified offset within the local
+ * device's configuration space.
+ */
+static inline int rio_local_read_config_32(struct rio_mport *port, u32 offset,
+                                           u32 * data)
+{
+        return __rio_local_read_config_32(port, offset, data);
+}
+
+/**
+ * rio_local_write_config_32 - Write 32 bits to local configuration space
+ * @port: Master port
+ * @offset: Offset into local configuration space
+ * @data: Data to be written
+ *
+ * Writes 32 bits of data to the specified offset within the local
+ * device's configuration space.
+ */
+static inline int rio_local_write_config_32(struct rio_mport *port, u32 offset,
+                                            u32 data)
+{
+        return __rio_local_write_config_32(port, offset, data);
+}
+
+/**
+ * rio_local_read_config_16 - Read 16 bits from local configuration space
+ * @port: Master port
+ * @offset: Offset into local configuration space
+ * @data: Pointer to read data into
+ *
+ * Reads 16 bits of data from the specified offset within the local
+ * device's configuration space.
+ */
+static inline int rio_local_read_config_16(struct rio_mport *port, u32 offset,
+                                           u16 * data)
+{
+        return __rio_local_read_config_16(port, offset, data);
+}
+
+/**
+ * rio_local_write_config_16 - Write 16 bits to local configuration space
+ * @port: Master port
+ * @offset: Offset into local configuration space
+ * @data: Data to be written
+ *
+ * Writes 16 bits of data to the specified offset within the local
+ * device's configuration space.
+ */
+
+static inline int rio_local_write_config_16(struct rio_mport *port, u32 offset,
+                                            u16 data)
+{
+        return __rio_local_write_config_16(port, offset, data);
+}
+
+/**
+ * rio_local_read_config_8 - Read 8 bits from local configuration space
+ * @port: Master port
+ * @offset: Offset into local configuration space
+ * @data: Pointer to read data into
+ *
+ * Reads 8 bits of data from the specified offset within the local
+ * device's configuration space.
+ */
+static inline int rio_local_read_config_8(struct rio_mport *port, u32 offset,
+                                          u8 * data)
+{
+        return __rio_local_read_config_8(port, offset, data);
+}
+
+/**
+ * rio_local_write_config_8 - Write 8 bits to local configuration space
+ * @port: Master port
+ * @offset: Offset into local configuration space
+ * @data: Data to be written
+ *
+ * Writes 8 bits of data to the specified offset within the local
+ * device's configuration space.
+ */
+static inline int rio_local_write_config_8(struct rio_mport *port, u32 offset,
+                                           u8 data)
+{
+        return __rio_local_write_config_8(port, offset, data);
+}
+
+/**
+ * rio_read_config_32 - Read 32 bits from configuration space
+ * @rdev: RIO device
+ * @offset: Offset into device configuration space
+ * @data: Pointer to read data into
+ *
+ * Reads 32 bits of data from the specified offset within the
+ * RIO device's configuration space.
+ */
+static inline int rio_read_config_32(struct rio_dev *rdev, u32 offset,
+                                     u32 * data)
+{
+        u8 hopcount = 0xff;
+        u16 destid = rdev->destid;
+
+        if (rdev->rswitch) {
+                destid = rdev->rswitch->destid;
+                hopcount = rdev->rswitch->hopcount;
+        }
+
+        return rio_mport_read_config_32(rdev->net->hport, destid, hopcount,
+                                        offset, data);
+};
+
+/**
+ * rio_write_config_32 - Write 32 bits to configuration space
+ * @rdev: RIO device
+ * @offset: Offset into device configuration space
+ * @data: Data to be written
+ *
+ * Writes 32 bits of data to the specified offset within the
+ * RIO device's configuration space.
+ */
+static inline int rio_write_config_32(struct rio_dev *rdev, u32 offset,
+                                      u32 data)
+{
+        u8 hopcount = 0xff;
+        u16 destid = rdev->destid;
+
+        if (rdev->rswitch) {
+                destid = rdev->rswitch->destid;
+                hopcount = rdev->rswitch->hopcount;
+        }
+
+        return rio_mport_write_config_32(rdev->net->hport, destid, hopcount,
+                                         offset, data);
+};
+
+/**
+ * rio_read_config_16 - Read 16 bits from configuration space
+ * @rdev: RIO device
+ * @offset: Offset into device configuration space
+ * @data: Pointer to read data into
+ *
+ * Reads 16 bits of data from the specified offset within the
+ * RIO device's configuration space.
+ */
+static inline int rio_read_config_16(struct rio_dev *rdev, u32 offset,
+                                     u16 * data)
+{
+        u8 hopcount = 0xff;
+        u16 destid = rdev->destid;
+
+        if (rdev->rswitch) {
+                destid = rdev->rswitch->destid;
+                hopcount = rdev->rswitch->hopcount;
+        }
+
+        return rio_mport_read_config_16(rdev->net->hport, destid, hopcount,
+                                        offset, data);
+};
+
+/**
+ * rio_write_config_16 - Write 16 bits to configuration space
+ * @rdev: RIO device
+ * @offset: Offset into device configuration space
+ * @data: Data to be written
+ *
+ * Writes 16 bits of data to the specified offset within the
+ * RIO device's configuration space.
+ */
+static inline int rio_write_config_16(struct rio_dev *rdev, u32 offset,
+                                      u16 data)
+{
+        u8 hopcount = 0xff;
+        u16 destid = rdev->destid;
+
+        if (rdev->rswitch) {
+                destid = rdev->rswitch->destid;
+                hopcount = rdev->rswitch->hopcount;
+        }
+
+        return rio_mport_write_config_16(rdev->net->hport, destid, hopcount,
+                                         offset, data);
+};
+
+/**
+ * rio_read_config_8 - Read 8 bits from configuration space
+ * @rdev: RIO device
+ * @offset: Offset into device configuration space
+ * @data: Pointer to read data into
+ *
+ * Reads 8 bits of data from the specified offset within the
+ * RIO device's configuration space.
+ */
+static inline int rio_read_config_8(struct rio_dev *rdev, u32 offset, u8 * data)
+{
+        u8 hopcount = 0xff;
+        u16 destid = rdev->destid;
+
+        if (rdev->rswitch) {
+                destid = rdev->rswitch->destid;
+                hopcount = rdev->rswitch->hopcount;
+        }
+
+        return rio_mport_read_config_8(rdev->net->hport, destid, hopcount,
+                                       offset, data);
+};
+
+/**
+ * rio_write_config_8 - Write 8 bits to configuration space
+ * @rdev: RIO device
+ * @offset: Offset into device configuration space
+ * @data: Data to be written
+ *
+ * Writes 8 bits of data to the specified offset within the
+ * RIO device's configuration space.
+ */
+static inline int rio_write_config_8(struct rio_dev *rdev, u32 offset, u8 data)
+{
+        u8 hopcount = 0xff;
+        u16 destid = rdev->destid;
+
+        if (rdev->rswitch) {
+                destid = rdev->rswitch->destid;
+                hopcount = rdev->rswitch->hopcount;
+        }
+
+        return rio_mport_write_config_8(rdev->net->hport, destid, hopcount,
+                                        offset, data);
+};
+
+extern int rio_mport_send_doorbell(struct rio_mport *mport, u16 destid,
+                                   u16 data);
+
+/**
+ * rio_send_doorbell - Send a doorbell message to a device
+ * @rdev: RIO device
+ * @data: Doorbell message data
+ *
+ * Send a doorbell message to a RIO device. The doorbell message
+ * has a 16-bit info field provided by the @data argument.
+ */
+static inline int rio_send_doorbell(struct rio_dev *rdev, u16 data)
+{
+        return rio_mport_send_doorbell(rdev->net->hport, rdev->destid, data);
+};
+
+/**
+ * rio_init_mbox_res - Initialize a RIO mailbox resource
+ * @res: resource struct
+ * @start: start of mailbox range
+ * @end: end of mailbox range
+ *
+ * This function is used to initialize the fields of a resource
+ * for use as a mailbox resource.  It initializes a range of
+ * mailboxes using the start and end arguments.
+ */
+static inline void rio_init_mbox_res(struct resource *res, int start, int end)
+{
+        memset(res, 0, sizeof(struct resource));
+        res->start = start;
+        res->end = end;
+        res->flags = RIO_RESOURCE_MAILBOX;
+}
+
+/**
+ * rio_init_dbell_res - Initialize a RIO doorbell resource
+ * @res: resource struct
+ * @start: start of doorbell range
+ * @end: end of doorbell range
+ *
+ * This function is used to initialize the fields of a resource
+ * for use as a doorbell resource.  It initializes a range of
+ * doorbell messages using the start and end arguments.
+ */
+static inline void rio_init_dbell_res(struct resource *res, u16 start, u16 end)
+{
+        memset(res, 0, sizeof(struct resource));
+        res->start = start;
+        res->end = end;
+        res->flags = RIO_RESOURCE_DOORBELL;
+}
+
+/**
+ * RIO_DEVICE - macro used to describe a specific RIO device
+ * @vid: the 16 bit RIO vendor ID
+ * @did: the 16 bit RIO device ID
+ *
+ * This macro is used to create a struct rio_device_id that matches a
+ * specific device.  The assembly vendor and assembly device fields
+ * will be set to %RIO_ANY_ID.
+ */
+#define RIO_DEVICE(dev,ven) \
+        .did = (dev), .vid = (ven), \
+        .asm_did = RIO_ANY_ID, .asm_vid = RIO_ANY_ID
+
+/* Mailbox management */
+extern int rio_request_outb_mbox(struct rio_mport *, void *, int, int,
+                                 void (*)(struct rio_mport *, void *,int, int));
+extern int rio_release_outb_mbox(struct rio_mport *, int);
+
+/**
+ * rio_add_outb_message - Add RIO message to an outbound mailbox queue
+ * @mport: RIO master port containing the outbound queue
+ * @rdev: RIO device the message is be sent to
+ * @mbox: The outbound mailbox queue
+ * @buffer: Pointer to the message buffer
+ * @len: Length of the message buffer
+ *
+ * Adds a RIO message buffer to an outbound mailbox queue for
+ * transmission. Returns 0 on success.
+ */
+static inline int rio_add_outb_message(struct rio_mport *mport,
+                                       struct rio_dev *rdev, int mbox,
+                                       void *buffer, size_t len)
+{
+        return rio_hw_add_outb_message(mport, rdev, mbox, buffer, len);
+}
+
+extern int rio_request_inb_mbox(struct rio_mport *, void *, int, int,
+                                void (*)(struct rio_mport *, void *, int, int));
+extern int rio_release_inb_mbox(struct rio_mport *, int);
+
+/**
+ * rio_add_inb_buffer - Add buffer to an inbound mailbox queue
+ * @mport: Master port containing the inbound mailbox
+ * @mbox: The inbound mailbox number
+ * @buffer: Pointer to the message buffer
+ *
+ * Adds a buffer to an inbound mailbox queue for reception. Returns
+ * 0 on success.
+ */
+static inline int rio_add_inb_buffer(struct rio_mport *mport, int mbox,
+                                     void *buffer)
+{
+        return rio_hw_add_inb_buffer(mport, mbox, buffer);
+}
+
+/**
+ * rio_get_inb_message - Get A RIO message from an inbound mailbox queue
+ * @mport: Master port containing the inbound mailbox
+ * @mbox: The inbound mailbox number
+ * @buffer: Pointer to the message buffer
+ *
+ * Get a RIO message from an inbound mailbox queue. Returns 0 on success.
+ */
+static inline void *rio_get_inb_message(struct rio_mport *mport, int mbox)
+{
+        return rio_hw_get_inb_message(mport, mbox);
+}
+
+/* Doorbell management */
+extern int rio_request_inb_dbell(struct rio_mport *, void *, u16, u16,
+                                 void (*)(struct rio_mport *, void *, u16, u16, u16));
+extern int rio_release_inb_dbell(struct rio_mport *, u16, u16);
+extern struct resource *rio_request_outb_dbell(struct rio_dev *, u16, u16);
+extern int rio_release_outb_dbell(struct rio_dev *, struct resource *);
+
+/* Memory region management */
+int rio_claim_resource(struct rio_dev *, int);
+int rio_request_regions(struct rio_dev *, char *);
+void rio_release_regions(struct rio_dev *);
+int rio_request_region(struct rio_dev *, int, char *);
+void rio_release_region(struct rio_dev *, int);
+
+/* LDM support */
+int rio_register_driver(struct rio_driver *);
+void rio_unregister_driver(struct rio_driver *);
+struct rio_dev *rio_dev_get(struct rio_dev *);
+void rio_dev_put(struct rio_dev *);
+
+/**
+ * rio_name - Get the unique RIO device identifier
+ * @rdev: RIO device
+ *
+ * Get the unique RIO device identifier. Returns the device
+ * identifier string.
+ */
+static inline char *rio_name(struct rio_dev *rdev)
+{
+        return rdev->dev.bus_id;
+}
+
+/**
+ * rio_get_drvdata - Get RIO driver specific data
+ * @rdev: RIO device
+ *
+ * Get RIO driver specific data. Returns a pointer to the
+ * driver specific data.
+ */
+static inline void *rio_get_drvdata(struct rio_dev *rdev)
+{
+        return dev_get_drvdata(&rdev->dev);
+}
+
+/**
+ * rio_set_drvdata - Set RIO driver specific data
+ * @rdev: RIO device
+ * @data: Pointer to driver specific data
+ *
+ * Set RIO driver specific data. device struct driver data pointer
+ * is set to the @data argument.
+ */
+static inline void rio_set_drvdata(struct rio_dev *rdev, void *data)
+{
+        dev_set_drvdata(&rdev->dev, data);
+}
+
+/* Misc driver helpers */
+extern u16 rio_local_get_device_id(struct rio_mport *port);
+extern struct rio_dev *rio_get_device(u16 vid, u16 did, struct rio_dev *from);
+extern struct rio_dev *rio_get_asm(u16 vid, u16 did, u16 asm_vid, u16 asm_did,
+                                   struct rio_dev *from);
+
+#endif                          /* __KERNEL__ */
+#endif                          /* LINUX_RIO_DRV_H */
diff --git a/include/linux/rio_ids.h b/include/linux/rio_ids.h
new file mode 100644
index 000000000000..919d4e07d54e
--- /dev/null
+++ b/include/linux/rio_ids.h
@@ -0,0 +1,24 @@
+/*
+ * RapidIO devices
+ *
+ * Copyright 2005 MontaVista Software, Inc.
+ * Matt Porter <mporter@kernel.crashing.org>
+ *
+ * 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 LINUX_RIO_IDS_H
+#define LINUX_RIO_IDS_H
+
+#define RIO_ANY_ID                      0xffff
+
+#define RIO_VID_FREESCALE               0x0002
+#define RIO_DID_MPC8560                 0x0003
+
+#define RIO_VID_TUNDRA                  0x000d
+#define RIO_DID_TSI500                  0x0500
+
+#endif                          /* LINUX_RIO_IDS_H */
diff --git a/include/linux/rio_regs.h b/include/linux/rio_regs.h
new file mode 100644
index 000000000000..326540f9b54e
--- /dev/null
+++ b/include/linux/rio_regs.h
@@ -0,0 +1,215 @@
+/*
+ * RapidIO register definitions
+ *
+ * Copyright 2005 MontaVista Software, Inc.
+ * Matt Porter <mporter@kernel.crashing.org>
+ *
+ * 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 LINUX_RIO_REGS_H
+#define LINUX_RIO_REGS_H
+
+/*
+ * In RapidIO, each device has a 2MB configuration space that is
+ * accessed via maintenance transactions.  Portions of configuration
+ * space are standardized and/or reserved.
+ */
+#define RIO_DEV_ID_CAR          0x00    /* [I] Device Identity CAR */
+#define RIO_DEV_INFO_CAR        0x04    /* [I] Device Information CAR */
+#define RIO_ASM_ID_CAR          0x08    /* [I] Assembly Identity CAR */
+#define  RIO_ASM_ID_MASK                0xffff0000      /* [I] Asm ID Mask */
+#define  RIO_ASM_VEN_ID_MASK            0x0000ffff      /* [I] Asm Vend Mask */
+
+#define RIO_ASM_INFO_CAR        0x0c    /* [I] Assembly Information CAR */
+#define  RIO_ASM_REV_MASK               0xffff0000      /* [I] Asm Rev Mask */
+#define  RIO_EXT_FTR_PTR_MASK           0x0000ffff      /* [I] EF_PTR Mask */
+
+#define RIO_PEF_CAR             0x10    /* [I] Processing Element Features CAR */
+#define  RIO_PEF_BRIDGE                 0x80000000      /* [I] Bridge */
+#define  RIO_PEF_MEMORY                 0x40000000      /* [I] MMIO */
+#define  RIO_PEF_PROCESSOR              0x20000000      /* [I] Processor */
+#define  RIO_PEF_SWITCH                 0x10000000      /* [I] Switch */
+#define  RIO_PEF_INB_MBOX               0x00f00000      /* [II] Mailboxes */
+#define  RIO_PEF_INB_MBOX0              0x00800000      /* [II] Mailbox 0 */
+#define  RIO_PEF_INB_MBOX1              0x00400000      /* [II] Mailbox 1 */
+#define  RIO_PEF_INB_MBOX2              0x00200000      /* [II] Mailbox 2 */
+#define  RIO_PEF_INB_MBOX3              0x00100000      /* [II] Mailbox 3 */
+#define  RIO_PEF_INB_DOORBELL           0x00080000      /* [II] Doorbells */
+#define  RIO_PEF_CTLS                   0x00000010      /* [III] CTLS */
+#define  RIO_PEF_EXT_FEATURES           0x00000008      /* [I] EFT_PTR valid */
+#define  RIO_PEF_ADDR_66                0x00000004      /* [I] 66 bits */
+#define  RIO_PEF_ADDR_50                0x00000002      /* [I] 50 bits */
+#define  RIO_PEF_ADDR_34                0x00000001      /* [I] 34 bits */
+
+#define RIO_SWP_INFO_CAR        0x14    /* [I] Switch Port Information CAR */
+#define  RIO_SWP_INFO_PORT_TOTAL_MASK   0x0000ff00      /* [I] Total number of ports */
+#define  RIO_SWP_INFO_PORT_NUM_MASK     0x000000ff      /* [I] Maintenance transaction port number */
+#define  RIO_GET_TOTAL_PORTS(x)         ((x & RIO_SWP_INFO_PORT_TOTAL_MASK) >> 8)
+
+#define RIO_SRC_OPS_CAR         0x18    /* [I] Source Operations CAR */
+#define  RIO_SRC_OPS_READ               0x00008000      /* [I] Read op */
+#define  RIO_SRC_OPS_WRITE              0x00004000      /* [I] Write op */
+#define  RIO_SRC_OPS_STREAM_WRITE       0x00002000      /* [I] Str-write op */
+#define  RIO_SRC_OPS_WRITE_RESPONSE     0x00001000      /* [I] Write/resp op */
+#define  RIO_SRC_OPS_DATA_MSG           0x00000800      /* [II] Data msg op */
+#define  RIO_SRC_OPS_DOORBELL           0x00000400      /* [II] Doorbell op */
+#define  RIO_SRC_OPS_ATOMIC_TST_SWP     0x00000100      /* [I] Atomic TAS op */
+#define  RIO_SRC_OPS_ATOMIC_INC         0x00000080      /* [I] Atomic inc op */
+#define  RIO_SRC_OPS_ATOMIC_DEC         0x00000040      /* [I] Atomic dec op */
+#define  RIO_SRC_OPS_ATOMIC_SET         0x00000020      /* [I] Atomic set op */
+#define  RIO_SRC_OPS_ATOMIC_CLR         0x00000010      /* [I] Atomic clr op */
+#define  RIO_SRC_OPS_PORT_WRITE         0x00000004      /* [I] Port-write op */
+
+#define RIO_DST_OPS_CAR         0x1c    /* Destination Operations CAR */
+#define  RIO_DST_OPS_READ               0x00008000      /* [I] Read op */
+#define  RIO_DST_OPS_WRITE              0x00004000      /* [I] Write op */
+#define  RIO_DST_OPS_STREAM_WRITE       0x00002000      /* [I] Str-write op */
+#define  RIO_DST_OPS_WRITE_RESPONSE     0x00001000      /* [I] Write/resp op */
+#define  RIO_DST_OPS_DATA_MSG           0x00000800      /* [II] Data msg op */
+#define  RIO_DST_OPS_DOORBELL           0x00000400      /* [II] Doorbell op */
+#define  RIO_DST_OPS_ATOMIC_TST_SWP     0x00000100      /* [I] Atomic TAS op */
+#define  RIO_DST_OPS_ATOMIC_INC         0x00000080      /* [I] Atomic inc op */
+#define  RIO_DST_OPS_ATOMIC_DEC         0x00000040      /* [I] Atomic dec op */
+#define  RIO_DST_OPS_ATOMIC_SET         0x00000020      /* [I] Atomic set op */
+#define  RIO_DST_OPS_ATOMIC_CLR         0x00000010      /* [I] Atomic clr op */
+#define  RIO_DST_OPS_PORT_WRITE         0x00000004      /* [I] Port-write op */
+
+#define  RIO_OPS_READ                   0x00008000      /* [I] Read op */
+#define  RIO_OPS_WRITE                  0x00004000      /* [I] Write op */
+#define  RIO_OPS_STREAM_WRITE           0x00002000      /* [I] Str-write op */
+#define  RIO_OPS_WRITE_RESPONSE         0x00001000      /* [I] Write/resp op */
+#define  RIO_OPS_DATA_MSG               0x00000800      /* [II] Data msg op */
+#define  RIO_OPS_DOORBELL               0x00000400      /* [II] Doorbell op */
+#define  RIO_OPS_ATOMIC_TST_SWP         0x00000100      /* [I] Atomic TAS op */
+#define  RIO_OPS_ATOMIC_INC             0x00000080      /* [I] Atomic inc op */
+#define  RIO_OPS_ATOMIC_DEC             0x00000040      /* [I] Atomic dec op */
+#define  RIO_OPS_ATOMIC_SET             0x00000020      /* [I] Atomic set op */
+#define  RIO_OPS_ATOMIC_CLR             0x00000010      /* [I] Atomic clr op */
+#define  RIO_OPS_PORT_WRITE             0x00000004      /* [I] Port-write op */
+
+                                        /* 0x20-0x3c *//* Reserved */
+
+#define RIO_MBOX_CSR            0x40    /* [II] Mailbox CSR */
+#define  RIO_MBOX0_AVAIL                0x80000000      /* [II] Mbox 0 avail */
+#define  RIO_MBOX0_FULL                 0x40000000      /* [II] Mbox 0 full */
+#define  RIO_MBOX0_EMPTY                0x20000000      /* [II] Mbox 0 empty */
+#define  RIO_MBOX0_BUSY                 0x10000000      /* [II] Mbox 0 busy */
+#define  RIO_MBOX0_FAIL                 0x08000000      /* [II] Mbox 0 fail */
+#define  RIO_MBOX0_ERROR                0x04000000      /* [II] Mbox 0 error */
+#define  RIO_MBOX1_AVAIL                0x00800000      /* [II] Mbox 1 avail */
+#define  RIO_MBOX1_FULL                 0x00200000      /* [II] Mbox 1 full */
+#define  RIO_MBOX1_EMPTY                0x00200000      /* [II] Mbox 1 empty */
+#define  RIO_MBOX1_BUSY                 0x00100000      /* [II] Mbox 1 busy */
+#define  RIO_MBOX1_FAIL                 0x00080000      /* [II] Mbox 1 fail */
+#define  RIO_MBOX1_ERROR                0x00040000      /* [II] Mbox 1 error */
+#define  RIO_MBOX2_AVAIL                0x00008000      /* [II] Mbox 2 avail */
+#define  RIO_MBOX2_FULL                 0x00004000      /* [II] Mbox 2 full */
+#define  RIO_MBOX2_EMPTY                0x00002000      /* [II] Mbox 2 empty */
+#define  RIO_MBOX2_BUSY                 0x00001000      /* [II] Mbox 2 busy */
+#define  RIO_MBOX2_FAIL                 0x00000800      /* [II] Mbox 2 fail */
+#define  RIO_MBOX2_ERROR                0x00000400      /* [II] Mbox 2 error */
+#define  RIO_MBOX3_AVAIL                0x00000080      /* [II] Mbox 3 avail */
+#define  RIO_MBOX3_FULL                 0x00000040      /* [II] Mbox 3 full */
+#define  RIO_MBOX3_EMPTY                0x00000020      /* [II] Mbox 3 empty */
+#define  RIO_MBOX3_BUSY                 0x00000010      /* [II] Mbox 3 busy */
+#define  RIO_MBOX3_FAIL                 0x00000008      /* [II] Mbox 3 fail */
+#define  RIO_MBOX3_ERROR                0x00000004      /* [II] Mbox 3 error */
+
+#define RIO_WRITE_PORT_CSR      0x44    /* [I] Write Port CSR */
+#define RIO_DOORBELL_CSR        0x44    /* [II] Doorbell CSR */
+#define  RIO_DOORBELL_AVAIL             0x80000000      /* [II] Doorbell avail */
+#define  RIO_DOORBELL_FULL              0x40000000      /* [II] Doorbell full */
+#define  RIO_DOORBELL_EMPTY             0x20000000      /* [II] Doorbell empty */
+#define  RIO_DOORBELL_BUSY              0x10000000      /* [II] Doorbell busy */
+#define  RIO_DOORBELL_FAILED            0x08000000      /* [II] Doorbell failed */
+#define  RIO_DOORBELL_ERROR             0x04000000      /* [II] Doorbell error */
+#define  RIO_WRITE_PORT_AVAILABLE       0x00000080      /* [I] Write Port Available */
+#define  RIO_WRITE_PORT_FULL            0x00000040      /* [I] Write Port Full */
+#define  RIO_WRITE_PORT_EMPTY           0x00000020      /* [I] Write Port Empty */
+#define  RIO_WRITE_PORT_BUSY            0x00000010      /* [I] Write Port Busy */
+#define  RIO_WRITE_PORT_FAILED          0x00000008      /* [I] Write Port Failed */
+#define  RIO_WRITE_PORT_ERROR           0x00000004      /* [I] Write Port Error */
+
+                                        /* 0x48 *//* Reserved */
+
+#define RIO_PELL_CTRL_CSR       0x4c    /* [I] PE Logical Layer Control CSR */
+#define   RIO_PELL_ADDR_66              0x00000004      /* [I] 66-bit addr */
+#define   RIO_PELL_ADDR_50              0x00000002      /* [I] 50-bit addr */
+#define   RIO_PELL_ADDR_34              0x00000001      /* [I] 34-bit addr */
+
+                                        /* 0x50-0x54 *//* Reserved */
+
+#define RIO_LCSH_BA             0x58    /* [I] LCS High Base Address */
+#define RIO_LCSL_BA             0x5c    /* [I] LCS Base Address */
+
+#define RIO_DID_CSR             0x60    /* [III] Base Device ID CSR */
+
+                                        /* 0x64 *//* Reserved */
+
+#define RIO_HOST_DID_LOCK_CSR   0x68    /* [III] Host Base Device ID Lock CSR */
+#define RIO_COMPONENT_TAG_CSR   0x6c    /* [III] Component Tag CSR */
+
+                                        /* 0x70-0xf8 *//* Reserved */
+                                        /* 0x100-0xfff8 *//* [I] Extended Features Space */
+                                        /* 0x10000-0xfffff8 *//* [I] Implementation-defined Space */
+
+/*
+ * Extended Features Space is a configuration space area where
+ * functionality is mapped into extended feature blocks via a
+ * singly linked list of extended feature pointers (EFT_PTR).
+ *
+ * Each extended feature block can be identified/located in
+ * Extended Features Space by walking the extended feature
+ * list starting with the Extended Feature Pointer located
+ * in the Assembly Information CAR.
+ *
+ * Extended Feature Blocks (EFBs) are identified with an assigned
+ * EFB ID. Extended feature block offsets in the definitions are
+ * relative to the offset of the EFB within the  Extended Features
+ * Space.
+ */
+
+/* Helper macros to parse the Extended Feature Block header */
+#define RIO_EFB_PTR_MASK        0xffff0000
+#define RIO_EFB_ID_MASK         0x0000ffff
+#define RIO_GET_BLOCK_PTR(x)    ((x & RIO_EFB_PTR_MASK) >> 16)
+#define RIO_GET_BLOCK_ID(x)     (x & RIO_EFB_ID_MASK)
+
+/* Extended Feature Block IDs */
+#define RIO_EFB_PAR_EP_ID       0x0001  /* [IV] LP/LVDS EP Devices */
+#define RIO_EFB_PAR_EP_REC_ID   0x0002  /* [IV] LP/LVDS EP Recovery Devices */
+#define RIO_EFB_PAR_EP_FREE_ID  0x0003  /* [IV] LP/LVDS EP Free Devices */
+#define RIO_EFB_SER_EP_ID       0x0004  /* [VI] LP/Serial EP Devices */
+#define RIO_EFB_SER_EP_REC_ID   0x0005  /* [VI] LP/Serial EP Recovery Devices */
+#define RIO_EFB_SER_EP_FREE_ID  0x0006  /* [VI] LP/Serial EP Free Devices */
+
+/*
+ * Physical 8/16 LP-LVDS
+ * ID=0x0001, Generic End Point Devices
+ * ID=0x0002, Generic End Point Devices, software assisted recovery option
+ * ID=0x0003, Generic End Point Free Devices
+ *
+ * Physical LP-Serial
+ * ID=0x0004, Generic End Point Devices
+ * ID=0x0005, Generic End Point Devices, software assisted recovery option
+ * ID=0x0006, Generic End Point Free Devices
+ */
+#define RIO_PORT_MNT_HEADER             0x0000
+#define RIO_PORT_REQ_CTL_CSR            0x0020
+#define RIO_PORT_RSP_CTL_CSR            0x0024  /* 0x0001/0x0002 */
+#define RIO_PORT_GEN_CTL_CSR            0x003c
+#define  RIO_PORT_GEN_HOST              0x80000000
+#define  RIO_PORT_GEN_MASTER            0x40000000
+#define  RIO_PORT_GEN_DISCOVERED        0x20000000
+#define RIO_PORT_N_MNT_REQ_CSR(x)       (0x0040 + x*0x20)       /* 0x0002 */
+#define RIO_PORT_N_MNT_RSP_CSR(x)       (0x0044 + x*0x20)       /* 0x0002 */
+#define RIO_PORT_N_ACK_STS_CSR(x)       (0x0048 + x*0x20)       /* 0x0002 */
+#define RIO_PORT_N_ERR_STS_CSR(x)       (0x58 + x*0x20)
+#define PORT_N_ERR_STS_PORT_OK  0x00000002
+#define RIO_PORT_N_CTL_CSR(x)           (0x5c + x*0x20)
+
+#endif                          /* LINUX_RIO_REGS_H */
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index e80fb7ee6efd..33261f1d2239 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -89,14 +89,14 @@ static inline void page_dup_rmap(struct page *page)
 /*
  * Called from mm/vmscan.c to handle paging out
  */
-int page_referenced(struct page *, int is_locked, int ignore_token);
+int page_referenced(struct page *, int is_locked);
 int try_to_unmap(struct page *);
 
 /*
  * Called from mm/filemap_xip.c to unmap empty zero page
  */
-pte_t *page_check_address(struct page *, struct mm_struct *, unsigned long);
-
+pte_t *page_check_address(struct page *, struct mm_struct *,
+                                unsigned long, spinlock_t **);
 
 /*
  * Used by swapoff to help locate where page is expected in vma.
@@ -109,7 +109,7 @@ unsigned long page_address_in_vma(struct page *, struct vm_area_struct *);
 #define anon_vma_prepare(vma)   (0)
 #define anon_vma_link(vma)      do {} while (0)
 
-#define page_referenced(page,l,i) TestClearPageReferenced(page)
+#define page_referenced(page,l) TestClearPageReferenced(page)
 #define try_to_unmap(page)      SWAP_FAIL
 
 #endif  /* CONFIG_MMU */
diff --git a/include/linux/rslib.h b/include/linux/rslib.h
index 980c8f74d8dc..ace25acfdc97 100644
--- a/include/linux/rslib.h
+++ b/include/linux/rslib.h
@@ -1,15 +1,15 @@
-/* 
+/*
  * include/linux/rslib.h
  *
  * Overview:
  *   Generic Reed Solomon encoder / decoder library
- *   
+ *
  * Copyright (C) 2004 Thomas Gleixner (tglx@linutronix.de)
  *
  * RS code lifted from reed solomon library written by Phil Karn
  * Copyright 2002 Phil Karn, KA9Q
  *
- * $Id: rslib.h,v 1.3 2004/10/05 22:08:22 gleixner Exp $
+ * $Id: rslib.h,v 1.4 2005/11/07 11:14:52 gleixner Exp $
  *
  * 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
@@ -21,20 +21,20 @@
 
 #include <linux/list.h>
 
-/** 
+/**
  * struct rs_control - rs control structure
- * 
+ *
  * @mm:         Bits per symbol
  * @nn:         Symbols per block (= (1<<mm)-1)
  * @alpha_to:   log lookup table
  * @index_of:   Antilog lookup table
- * @genpoly:    Generator polynomial 
+ * @genpoly:    Generator polynomial
  * @nroots:     Number of generator roots = number of parity symbols
  * @fcr:        First consecutive root, index form
- * @prim:       Primitive element, index form 
- * @iprim:      prim-th root of 1, index form 
- * @gfpoly:     The primitive generator polynominal 
- * @users:      Users of this structure 
+ * @prim:       Primitive element, index form
+ * @iprim:      prim-th root of 1, index form
+ * @gfpoly:     The primitive generator polynominal
+ * @users:      Users of this structure
  * @list:       List entry for the rs control list
 */
 struct rs_control {
@@ -58,7 +58,7 @@ int encode_rs8(struct rs_control *rs, uint8_t *data, int len, uint16_t *par,
                uint16_t invmsk);
 #endif
 #ifdef CONFIG_REED_SOLOMON_DEC8
-int decode_rs8(struct rs_control *rs, uint8_t *data, uint16_t *par, int len, 
+int decode_rs8(struct rs_control *rs, uint8_t *data, uint16_t *par, int len,
                 uint16_t *s, int no_eras, int *eras_pos, uint16_t invmsk,
                uint16_t *corr);
 #endif
@@ -75,7 +75,7 @@ int decode_rs16(struct rs_control *rs, uint16_t *data, uint16_t *par, int len,
 #endif
 
 /* Create or get a matching rs control structure */
-struct rs_control *init_rs(int symsize, int gfpoly, int fcr, int prim, 
+struct rs_control *init_rs(int symsize, int gfpoly, int fcr, int prim,
                            int nroots);
 
 /* Release a rs control structure */
@@ -87,9 +87,9 @@ void free_rs(struct rs_control *rs);
  *  @x:         the value to reduce
  *
  *  where
- *  rs->mm = number of bits per symbol  
+ *  rs->mm = number of bits per symbol
  *  rs->nn = (2^rs->mm) - 1
- *  
+ *
  *  Simple arithmetic modulo would return a wrong result for values
  *  >= 3 * rs->nn
 */
diff --git a/include/linux/rwsem-spinlock.h b/include/linux/rwsem-spinlock.h
index b52a2af25f1f..f30f805080ae 100644
--- a/include/linux/rwsem-spinlock.h
+++ b/include/linux/rwsem-spinlock.h
@@ -61,5 +61,10 @@ extern void FASTCALL(__up_read(struct rw_semaphore *sem));
 extern void FASTCALL(__up_write(struct rw_semaphore *sem));
 extern void FASTCALL(__downgrade_write(struct rw_semaphore *sem));
 
+static inline int rwsem_is_locked(struct rw_semaphore *sem)
+{
+        return (sem->activity != 0);
+}
+
 #endif /* __KERNEL__ */
 #endif /* _LINUX_RWSEM_SPINLOCK_H */
diff --git a/include/linux/scatterlist.h b/include/linux/scatterlist.h
index 7f717e95ae37..66ff545552f7 100644
--- a/include/linux/scatterlist.h
+++ b/include/linux/scatterlist.h
@@ -1,14 +1,23 @@
 #ifndef _LINUX_SCATTERLIST_H
 #define _LINUX_SCATTERLIST_H
 
-static inline void sg_init_one(struct scatterlist *sg,
-                               u8 *buf, unsigned int buflen)
-{
-        memset(sg, 0, sizeof(*sg));
+#include <asm/scatterlist.h>
+#include <linux/mm.h>
+#include <linux/string.h>
 
+static inline void sg_set_buf(struct scatterlist *sg, void *buf,
+                              unsigned int buflen)
+{
         sg->page = virt_to_page(buf);
         sg->offset = offset_in_page(buf);
         sg->length = buflen;
 }
 
+static inline void sg_init_one(struct scatterlist *sg, void *buf,
+                               unsigned int buflen)
+{
+        memset(sg, 0, sizeof(*sg));
+        sg_set_buf(sg, buf, buflen);
+}
+
 #endif /* _LINUX_SCATTERLIST_H */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 49e617fa0f66..b0ad6f30679e 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -107,13 +107,25 @@ extern unsigned long nr_iowait(void);
 
 #include <asm/processor.h>
 
+/*
+ * Task state bitmask. NOTE! These bits are also
+ * encoded in fs/proc/array.c: get_task_state().
+ *
+ * We have two separate sets of flags: task->state
+ * is about runnability, while task->exit_state are
+ * about the task exiting. Confusing, but this way
+ * modifying one set can't modify the other one by
+ * mistake.
+ */
 #define TASK_RUNNING            0
 #define TASK_INTERRUPTIBLE      1
 #define TASK_UNINTERRUPTIBLE    2
 #define TASK_STOPPED            4
 #define TASK_TRACED             8
+/* in tsk->exit_state */
 #define EXIT_ZOMBIE             16
 #define EXIT_DEAD               32
+/* in tsk->state again */
 #define TASK_NONINTERACTIVE     64
 
 #define __set_task_state(tsk, state_value)              \
@@ -237,6 +249,36 @@ arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
 extern void arch_unmap_area(struct mm_struct *, unsigned long);
 extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
 
+#if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
+/*
+ * The mm counters are not protected by its page_table_lock,
+ * so must be incremented atomically.
+ */
+#ifdef ATOMIC64_INIT
+#define set_mm_counter(mm, member, value) atomic64_set(&(mm)->_##member, value)
+#define get_mm_counter(mm, member) ((unsigned long)atomic64_read(&(mm)->_##member))
+#define add_mm_counter(mm, member, value) atomic64_add(value, &(mm)->_##member)
+#define inc_mm_counter(mm, member) atomic64_inc(&(mm)->_##member)
+#define dec_mm_counter(mm, member) atomic64_dec(&(mm)->_##member)
+typedef atomic64_t mm_counter_t;
+#else /* !ATOMIC64_INIT */
+/*
+ * The counters wrap back to 0 at 2^32 * PAGE_SIZE,
+ * that is, at 16TB if using 4kB page size.
+ */
+#define set_mm_counter(mm, member, value) atomic_set(&(mm)->_##member, value)
+#define get_mm_counter(mm, member) ((unsigned long)atomic_read(&(mm)->_##member))
+#define add_mm_counter(mm, member, value) atomic_add(value, &(mm)->_##member)
+#define inc_mm_counter(mm, member) atomic_inc(&(mm)->_##member)
+#define dec_mm_counter(mm, member) atomic_dec(&(mm)->_##member)
+typedef atomic_t mm_counter_t;
+#endif /* !ATOMIC64_INIT */
+
+#else  /* NR_CPUS < CONFIG_SPLIT_PTLOCK_CPUS */
+/*
+ * The mm counters are protected by its page_table_lock,
+ * so can be incremented directly.
+ */
 #define set_mm_counter(mm, member, value) (mm)->_##member = (value)
 #define get_mm_counter(mm, member) ((mm)->_##member)
 #define add_mm_counter(mm, member, value) (mm)->_##member += (value)
@@ -244,6 +286,20 @@ extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
 #define dec_mm_counter(mm, member) (mm)->_##member--
 typedef unsigned long mm_counter_t;
 
+#endif /* NR_CPUS < CONFIG_SPLIT_PTLOCK_CPUS */
+
+#define get_mm_rss(mm)                                  \
+        (get_mm_counter(mm, file_rss) + get_mm_counter(mm, anon_rss))
+#define update_hiwater_rss(mm)  do {                    \
+        unsigned long _rss = get_mm_rss(mm);            \
+        if ((mm)->hiwater_rss < _rss)                   \
+                (mm)->hiwater_rss = _rss;               \
+} while (0)
+#define update_hiwater_vm(mm)   do {                    \
+        if ((mm)->hiwater_vm < (mm)->total_vm)          \
+                (mm)->hiwater_vm = (mm)->total_vm;      \
+} while (0)
+
 struct mm_struct {
         struct vm_area_struct * mmap;           /* list of VMAs */
         struct rb_root mm_rb;
@@ -267,15 +323,20 @@ struct mm_struct {
                                                  * by mmlist_lock
                                                  */
 
+        /* Special counters, in some configurations protected by the
+         * page_table_lock, in other configurations by being atomic.
+         */
+        mm_counter_t _file_rss;
+        mm_counter_t _anon_rss;
+
+        unsigned long hiwater_rss;      /* High-watermark of RSS usage */
+        unsigned long hiwater_vm;       /* High-water virtual memory usage */
+
+        unsigned long total_vm, locked_vm, shared_vm, exec_vm;
+        unsigned long stack_vm, reserved_vm, def_flags, nr_ptes;
         unsigned long start_code, end_code, start_data, end_data;
         unsigned long start_brk, brk, start_stack;
         unsigned long arg_start, arg_end, env_start, env_end;
-        unsigned long total_vm, locked_vm, shared_vm;
-        unsigned long exec_vm, stack_vm, reserved_vm, def_flags, nr_ptes;
-
-        /* Special counters protected by the page_table_lock */
-        mm_counter_t _rss;
-        mm_counter_t _anon_rss;
 
         unsigned long saved_auxv[AT_VECTOR_SIZE]; /* for /proc/PID/auxv */
 
@@ -296,11 +357,6 @@ struct mm_struct {
         /* aio bits */
         rwlock_t                ioctx_list_lock;
         struct kioctx           *ioctx_list;
-
-        struct kioctx           default_kioctx;
-
-        unsigned long hiwater_rss;      /* High-water RSS usage */
-        unsigned long hiwater_vm;       /* High-water virtual memory usage */
 };
 
 struct sighand_struct {
@@ -883,7 +939,7 @@ extern int set_cpus_allowed(task_t *p, cpumask_t new_mask);
 #else
 static inline int set_cpus_allowed(task_t *p, cpumask_t new_mask)
 {
-        if (!cpus_intersects(new_mask, cpu_online_map))
+        if (!cpu_isset(0, new_mask))
                 return -EINVAL;
         return 0;
 }
@@ -1006,6 +1062,7 @@ extern int force_sig_info(int, struct siginfo *, struct task_struct *);
 extern int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp);
 extern int kill_pg_info(int, struct siginfo *, pid_t);
 extern int kill_proc_info(int, struct siginfo *, pid_t);
+extern int kill_proc_info_as_uid(int, struct siginfo *, pid_t, uid_t, uid_t);
 extern void do_notify_parent(struct task_struct *, int);
 extern void force_sig(int, struct task_struct *);
 extern void force_sig_specific(int, struct task_struct *);
@@ -1026,6 +1083,11 @@ extern int do_sigaltstack(const stack_t __user *, stack_t __user *, unsigned lon
 #define SEND_SIG_PRIV   ((struct siginfo *) 1)
 #define SEND_SIG_FORCED ((struct siginfo *) 2)
 
+static inline int is_si_special(const struct siginfo *info)
+{
+        return info <= SEND_SIG_FORCED;
+}
+
 /* True if we are on the alternate signal stack.  */
 
 static inline int on_sig_stack(unsigned long sp)
@@ -1153,7 +1215,7 @@ extern void unhash_process(struct task_struct *p);
 /*
  * Protects ->fs, ->files, ->mm, ->ptrace, ->group_info, ->comm, keyring
  * subscriptions and synchronises with wait4().  Also used in procfs.  Also
- * pins the final release of task.io_context.
+ * pins the final release of task.io_context.  Also protects ->cpuset.
  *
  * Nests both inside and outside of read_lock(&tasklist_lock).
  * It must not be nested with write_lock_irq(&tasklist_lock),
@@ -1169,32 +1231,49 @@ static inline void task_unlock(struct task_struct *p)
         spin_unlock(&p->alloc_lock);
 }
 
+#ifndef __HAVE_THREAD_FUNCTIONS
+
+#define task_thread_info(task) (task)->thread_info
+
+static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
+{
+        *task_thread_info(p) = *task_thread_info(org);
+        task_thread_info(p)->task = p;
+}
+
+static inline unsigned long *end_of_stack(struct task_struct *p)
+{
+        return (unsigned long *)(p->thread_info + 1);
+}
+
+#endif
+
 /* set thread flags in other task's structures
  * - see asm/thread_info.h for TIF_xxxx flags available
  */
 static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
-        set_ti_thread_flag(tsk->thread_info,flag);
+        set_ti_thread_flag(task_thread_info(tsk), flag);
 }
 
 static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
-        clear_ti_thread_flag(tsk->thread_info,flag);
+        clear_ti_thread_flag(task_thread_info(tsk), flag);
 }
 
 static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
-        return test_and_set_ti_thread_flag(tsk->thread_info,flag);
+        return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
 }
 
 static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
-        return test_and_clear_ti_thread_flag(tsk->thread_info,flag);
+        return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
 }
 
 static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
-        return test_ti_thread_flag(tsk->thread_info,flag);
+        return test_ti_thread_flag(task_thread_info(tsk), flag);
 }
 
 static inline void set_tsk_need_resched(struct task_struct *tsk)
@@ -1265,12 +1344,12 @@ extern void signal_wake_up(struct task_struct *t, int resume_stopped);
 
 static inline unsigned int task_cpu(const struct task_struct *p)
 {
-        return p->thread_info->cpu;
+        return task_thread_info(p)->cpu;
 }
 
 static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
 {
-        p->thread_info->cpu = cpu;
+        task_thread_info(p)->cpu = cpu;
 }
 
 #else
diff --git a/include/linux/sdladrv.h b/include/linux/sdladrv.h
index 78f634007fc6..c85e103d5e7b 100644
--- a/include/linux/sdladrv.h
+++ b/include/linux/sdladrv.h
@@ -52,12 +52,8 @@ typedef struct sdlahw
 
 extern int sdla_setup   (sdlahw_t* hw, void* sfm, unsigned len);
 extern int sdla_down    (sdlahw_t* hw);
-extern int sdla_inten   (sdlahw_t* hw);
-extern int sdla_intde   (sdlahw_t* hw);
-extern int sdla_intack  (sdlahw_t* hw);
 extern void S514_intack  (sdlahw_t* hw, u32 int_status);
 extern void read_S514_int_stat (sdlahw_t* hw, u32* int_status);
-extern int sdla_intr    (sdlahw_t* hw);
 extern int sdla_mapmem  (sdlahw_t* hw, unsigned long addr);
 extern int sdla_peek    (sdlahw_t* hw, unsigned long addr, void* buf,
                          unsigned len);
diff --git a/include/linux/security.h b/include/linux/security.h
index 0e43460d374e..f7e0ae018712 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -30,6 +30,7 @@
 #include <linux/shm.h>
 #include <linux/msg.h>
 #include <linux/sched.h>
+#include <linux/key.h>
 
 struct ctl_table;
 
@@ -385,6 +386,9 @@ struct swap_info_struct;
  *      NULL to request the size of the buffer required.  @size indicates
  *      the size of @buffer in bytes.  Note that @name is the remainder
  *      of the attribute name after the security. prefix has been removed.
+ *      @err is the return value from the preceding fs getxattr call,
+ *      and can be used by the security module to determine whether it
+ *      should try and canonicalize the attribute value.
  *      Return number of bytes used/required on success.
  * @inode_setsecurity:
  *      Set the security label associated with @name for @inode from the
@@ -785,6 +789,27 @@ struct swap_info_struct;
  * @sk_free_security:
  *      Deallocate security structure.
  *
+ * Security hooks affecting all Key Management operations
+ *
+ * @key_alloc:
+ *      Permit allocation of a key and assign security data. Note that key does
+ *      not have a serial number assigned at this point.
+ *      @key points to the key.
+ *      Return 0 if permission is granted, -ve error otherwise.
+ * @key_free:
+ *      Notification of destruction; free security data.
+ *      @key points to the key.
+ *      No return value.
+ * @key_permission:
+ *      See whether a specific operational right is granted to a process on a
+ *      key.
+ *      @key_ref refers to the key (key pointer + possession attribute bit).
+ *      @context points to the process to provide the context against which to
+ *       evaluate the security data on the key.
+ *      @perm describes the combination of permissions required of this key.
+ *      Return 1 if permission granted, 0 if permission denied and -ve it the
+ *      normal permissions model should be effected.
+ *
  * Security hooks affecting all System V IPC operations.
  *
  * @ipc_permission:
@@ -1091,7 +1116,7 @@ struct security_operations {
         int (*inode_getxattr) (struct dentry *dentry, char *name);
         int (*inode_listxattr) (struct dentry *dentry);
         int (*inode_removexattr) (struct dentry *dentry, char *name);
-        int (*inode_getsecurity)(struct inode *inode, const char *name, void *buffer, size_t size);
+        int (*inode_getsecurity)(struct inode *inode, const char *name, void *buffer, size_t size, int err);
         int (*inode_setsecurity)(struct inode *inode, const char *name, const void *value, size_t size, int flags);
         int (*inode_listsecurity)(struct inode *inode, char *buffer, size_t buffer_size);
 
@@ -1210,9 +1235,20 @@ struct security_operations {
         int (*socket_shutdown) (struct socket * sock, int how);
         int (*socket_sock_rcv_skb) (struct sock * sk, struct sk_buff * skb);
         int (*socket_getpeersec) (struct socket *sock, char __user *optval, int __user *optlen, unsigned len);
-        int (*sk_alloc_security) (struct sock *sk, int family, int priority);
+        int (*sk_alloc_security) (struct sock *sk, int family, gfp_t priority);
         void (*sk_free_security) (struct sock *sk);
 #endif  /* CONFIG_SECURITY_NETWORK */
+
+        /* key management security hooks */
+#ifdef CONFIG_KEYS
+        int (*key_alloc)(struct key *key);
+        void (*key_free)(struct key *key);
+        int (*key_permission)(key_ref_t key_ref,
+                              struct task_struct *context,
+                              key_perm_t perm);
+
+#endif  /* CONFIG_KEYS */
+
 };
 
 /* global variables */
@@ -1580,11 +1616,11 @@ static inline int security_inode_removexattr (struct dentry *dentry, char *name)
         return security_ops->inode_removexattr (dentry, name);
 }
 
-static inline int security_inode_getsecurity(struct inode *inode, const char *name, void *buffer, size_t size)
+static inline int security_inode_getsecurity(struct inode *inode, const char *name, void *buffer, size_t size, int err)
 {
         if (unlikely (IS_PRIVATE (inode)))
                 return 0;
-        return security_ops->inode_getsecurity(inode, name, buffer, size);
+        return security_ops->inode_getsecurity(inode, name, buffer, size, err);
 }
 
 static inline int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags)
@@ -2222,7 +2258,7 @@ static inline int security_inode_removexattr (struct dentry *dentry, char *name)
         return cap_inode_removexattr(dentry, name);
 }
 
-static inline int security_inode_getsecurity(struct inode *inode, const char *name, void *buffer, size_t size)
+static inline int security_inode_getsecurity(struct inode *inode, const char *name, void *buffer, size_t size, int err)
 {
         return -EOPNOTSUPP;
 }
@@ -2634,8 +2670,7 @@ static inline int security_socket_getpeersec(struct socket *sock, char __user *o
         return security_ops->socket_getpeersec(sock, optval, optlen, len);
 }
 
-static inline int security_sk_alloc(struct sock *sk, int family,
-                                    unsigned int __nocast priority)
+static inline int security_sk_alloc(struct sock *sk, int family, gfp_t priority)
 {
         return security_ops->sk_alloc_security(sk, family, priority);
 }
@@ -2752,8 +2787,7 @@ static inline int security_socket_getpeersec(struct socket *sock, char __user *o
         return -ENOPROTOOPT;
 }
 
-static inline int security_sk_alloc(struct sock *sk, int family,
-                                    unsigned int __nocast priority)
+static inline int security_sk_alloc(struct sock *sk, int family, gfp_t priority)
 {
         return 0;
 }
@@ -2763,5 +2797,45 @@ static inline void security_sk_free(struct sock *sk)
 }
 #endif  /* CONFIG_SECURITY_NETWORK */
 
+#ifdef CONFIG_KEYS
+#ifdef CONFIG_SECURITY
+static inline int security_key_alloc(struct key *key)
+{
+        return security_ops->key_alloc(key);
+}
+
+static inline void security_key_free(struct key *key)
+{
+        security_ops->key_free(key);
+}
+
+static inline int security_key_permission(key_ref_t key_ref,
+                                          struct task_struct *context,
+                                          key_perm_t perm)
+{
+        return security_ops->key_permission(key_ref, context, perm);
+}
+
+#else
+
+static inline int security_key_alloc(struct key *key)
+{
+        return 0;
+}
+
+static inline void security_key_free(struct key *key)
+{
+}
+
+static inline int security_key_permission(key_ref_t key_ref,
+                                          struct task_struct *context,
+                                          key_perm_t perm)
+{
+        return 0;
+}
+
+#endif
+#endif /* CONFIG_KEYS */
+
 #endif /* ! __LINUX_SECURITY_H */
 
diff --git a/include/linux/sem.h b/include/linux/sem.h
index 106f9757339a..3c1f1120fe88 100644
--- a/include/linux/sem.h
+++ b/include/linux/sem.h
@@ -79,6 +79,8 @@ struct  seminfo {
 
 #ifdef __KERNEL__
 
+struct task_struct;
+
 /* One semaphore structure for each semaphore in the system. */
 struct sem {
         int     semval;         /* current value */
diff --git a/include/linux/serial.h b/include/linux/serial.h
index 12cd9cf65e8f..33fc8cb8ddfb 100644
--- a/include/linux/serial.h
+++ b/include/linux/serial.h
@@ -11,6 +11,7 @@
 #define _LINUX_SERIAL_H
 
 #ifdef __KERNEL__
+#include <linux/types.h>
 #include <asm/page.h>
 
 /*
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index 317a979b24de..cee302aefdb7 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -12,7 +12,7 @@
 #define _LINUX_SERIAL_8250_H
 
 #include <linux/serial_core.h>
-#include <linux/device.h>
+#include <linux/platform_device.h>
 
 /*
  * This is the platform device platform_data structure
@@ -42,6 +42,7 @@ enum {
         PLAT8250_DEV_BOCA,
         PLAT8250_DEV_HUB6,
         PLAT8250_DEV_MCA,
+        PLAT8250_DEV_AU1X00,
 };
 
 /*
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 27db8da43aa4..e3710d7e260a 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -117,7 +117,12 @@
 #define PORT_M32R_SIO   68
 
 /*Digi jsm */
-#define PORT_JSM        65
+#define PORT_JSM        69
+
+#define PORT_IP3106     70
+
+/* Hilscher netx */
+#define PORT_NETX       71
 
 #ifdef __KERNEL__
 
@@ -209,6 +214,7 @@ struct uart_port {
 #define UPIO_HUB6               (1)
 #define UPIO_MEM                (2)
 #define UPIO_MEM32              (3)
+#define UPIO_AU                 (4)                     /* Au1x00 type IO */
 
         unsigned int            read_status_mask;       /* driver specific */
         unsigned int            ignore_status_mask;     /* driver specific */
diff --git a/include/linux/serial_ip3106.h b/include/linux/serial_ip3106.h
new file mode 100644
index 000000000000..f500ac602c5c
--- /dev/null
+++ b/include/linux/serial_ip3106.h
@@ -0,0 +1,81 @@
+/*
+ * Embedded Alley Solutions, source@embeddedalley.com.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LINUX_SERIAL_IP3106_H
+#define _LINUX_SERIAL_IP3106_H
+
+#include <linux/serial_core.h>
+#include <linux/device.h>
+
+#define IP3106_NR_PORTS         2
+
+struct ip3106_port {
+        struct uart_port        port;
+        struct timer_list       timer;
+        unsigned int            old_status;
+};
+
+/* register offsets */
+#define IP3106_LCR              0
+#define IP3106_MCR              0x004
+#define IP3106_BAUD             0x008
+#define IP3106_CFG              0x00c
+#define IP3106_FIFO             0x028
+#define IP3106_ISTAT            0xfe0
+#define IP3106_IEN              0xfe4
+#define IP3106_ICLR             0xfe8
+#define IP3106_ISET             0xfec
+#define IP3106_PD               0xff4
+#define IP3106_MID              0xffc
+
+#define IP3106_UART_LCR_TXBREAK         (1<<30)
+#define IP3106_UART_LCR_PAREVN          0x10000000
+#define IP3106_UART_LCR_PAREN           0x08000000
+#define IP3106_UART_LCR_2STOPB          0x04000000
+#define IP3106_UART_LCR_8BIT            0x01000000
+#define IP3106_UART_LCR_TX_RST          0x00040000
+#define IP3106_UART_LCR_RX_RST          0x00020000
+#define IP3106_UART_LCR_RX_NEXT         0x00010000
+
+#define IP3106_UART_MCR_SCR             0xFF000000
+#define IP3106_UART_MCR_DCD             0x00800000
+#define IP3106_UART_MCR_CTS             0x00100000
+#define IP3106_UART_MCR_LOOP            0x00000010
+#define IP3106_UART_MCR_RTS             0x00000002
+#define IP3106_UART_MCR_DTR             0x00000001
+
+#define IP3106_UART_INT_TX              0x00000080
+#define IP3106_UART_INT_EMPTY           0x00000040
+#define IP3106_UART_INT_RCVTO           0x00000020
+#define IP3106_UART_INT_RX              0x00000010
+#define IP3106_UART_INT_RXOVRN          0x00000008
+#define IP3106_UART_INT_FRERR           0x00000004
+#define IP3106_UART_INT_BREAK           0x00000002
+#define IP3106_UART_INT_PARITY          0x00000001
+#define IP3106_UART_INT_ALLRX           0x0000003F
+#define IP3106_UART_INT_ALLTX           0x000000C0
+
+#define IP3106_UART_FIFO_TXFIFO         0x001F0000
+#define IP3106_UART_FIFO_TXFIFO_STA     (0x1f<<16)
+#define IP3106_UART_FIFO_RXBRK          0x00008000
+#define IP3106_UART_FIFO_RXFE           0x00004000
+#define IP3106_UART_FIFO_RXPAR          0x00002000
+#define IP3106_UART_FIFO_RXFIFO         0x00001F00
+#define IP3106_UART_FIFO_RBRTHR         0x000000FF
+
+#endif
diff --git a/include/linux/shm.h b/include/linux/shm.h
index 80113a1f60bc..a2c896ad0bef 100644
--- a/include/linux/shm.h
+++ b/include/linux/shm.h
@@ -92,6 +92,7 @@ struct shmid_kernel /* private to the kernel */
 #define SHM_DEST        01000   /* segment will be destroyed on last detach */
 #define SHM_LOCKED      02000   /* segment will not be swapped */
 #define SHM_HUGETLB     04000   /* segment will use huge TLB pages */
+#define SHM_NORESERVE   010000  /* don't check for reservations */
 
 #ifdef CONFIG_SYSVIPC
 long do_shmat(int shmid, char __user *shmaddr, int shmflg, unsigned long *addr);
diff --git a/include/linux/signal.h b/include/linux/signal.h
index 7be18b5e2fb4..5dd5f02c5c5f 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -25,7 +25,6 @@
 
 struct sigqueue {
         struct list_head list;
-        spinlock_t *lock;
         int flags;
         siginfo_t info;
         struct user_struct *user;
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 2741c0c55e83..8c5d6001a923 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -137,6 +137,8 @@ struct skb_shared_info {
         unsigned int    nr_frags;
         unsigned short  tso_size;
         unsigned short  tso_segs;
+        unsigned short  ufo_size;
+        unsigned int    ip6_frag_id;
         struct sk_buff  *frag_list;
         skb_frag_t      frags[MAX_SKB_FRAGS];
 };
@@ -155,8 +157,6 @@ struct skb_shared_info {
 #define SKB_DATAREF_SHIFT 16
 #define SKB_DATAREF_MASK ((1 << SKB_DATAREF_SHIFT) - 1)
 
-extern struct timeval skb_tv_base;
-
 struct skb_timeval {
         u32     off_sec;
         u32     off_usec;
@@ -173,9 +173,8 @@ enum {
  *      struct sk_buff - socket buffer
  *      @next: Next buffer in list
  *      @prev: Previous buffer in list
- *      @list: List we are on
  *      @sk: Socket we are owned by
- *      @tstamp: Time we arrived stored as offset to skb_tv_base
+ *      @tstamp: Time we arrived
  *      @dev: Device we arrived on/are leaving by
  *      @input_dev: Device we arrived on
  *      @h: Transport layer header
@@ -192,6 +191,7 @@ enum {
  *      @cloned: Head may be cloned (check refcnt to be sure)
  *      @nohdr: Payload reference only, must not modify header
  *      @pkt_type: Packet class
+ *      @fclone: skbuff clone status
  *      @ip_summed: Driver fed us an IP checksum
  *      @priority: Packet queueing priority
  *      @users: User count - see {datagram,tcp}.c
@@ -204,7 +204,9 @@ enum {
  *      @destructor: Destruct function
  *      @nfmark: Can be used for communication between hooks
  *      @nfct: Associated connection, if any
+ *      @ipvs_property: skbuff is owned by ipvs
  *      @nfctinfo: Relationship of this skb to the connection
+ *      @nfct_reasm: netfilter conntrack re-assembly pointer
  *      @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
  *      @tc_index: Traffic control index
  *      @tc_verd: traffic control verdict
@@ -263,15 +265,16 @@ struct sk_buff {
                                 nohdr:1,
                                 nfctinfo:3;
         __u8                    pkt_type:3,
-                                fclone:2;
+                                fclone:2,
+                                ipvs_property:1;
         __be16                  protocol;
 
         void                    (*destructor)(struct sk_buff *skb);
 #ifdef CONFIG_NETFILTER
         __u32                   nfmark;
         struct nf_conntrack     *nfct;
-#if defined(CONFIG_IP_VS) || defined(CONFIG_IP_VS_MODULE)
-        __u8                    ipvs_property:1;
+#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
+        struct sk_buff          *nfct_reasm;
 #endif
 #ifdef CONFIG_BRIDGE_NETFILTER
         struct nf_bridge_info   *nf_bridge;
@@ -304,37 +307,37 @@ struct sk_buff {
 
 extern void            __kfree_skb(struct sk_buff *skb);
 extern struct sk_buff *__alloc_skb(unsigned int size,
-                                   unsigned int __nocast priority, int fclone);
+                                   gfp_t priority, int fclone);
 static inline struct sk_buff *alloc_skb(unsigned int size,
-                                        unsigned int __nocast priority)
+                                        gfp_t priority)
 {
         return __alloc_skb(size, priority, 0);
 }
 
 static inline struct sk_buff *alloc_skb_fclone(unsigned int size,
-                                               unsigned int __nocast priority)
+                                               gfp_t priority)
 {
         return __alloc_skb(size, priority, 1);
 }
 
 extern struct sk_buff *alloc_skb_from_cache(kmem_cache_t *cp,
                                             unsigned int size,
-                                            unsigned int __nocast priority);
+                                            gfp_t priority);
 extern void            kfree_skbmem(struct sk_buff *skb);
 extern struct sk_buff *skb_clone(struct sk_buff *skb,
-                                 unsigned int __nocast priority);
+                                 gfp_t priority);
 extern struct sk_buff *skb_copy(const struct sk_buff *skb,
-                                unsigned int __nocast priority);
+                                gfp_t priority);
 extern struct sk_buff *pskb_copy(struct sk_buff *skb,
-                                 unsigned int __nocast gfp_mask);
+                                 gfp_t gfp_mask);
 extern int             pskb_expand_head(struct sk_buff *skb,
                                         int nhead, int ntail,
-                                        unsigned int __nocast gfp_mask);
+                                        gfp_t gfp_mask);
 extern struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
                                             unsigned int headroom);
 extern struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
                                        int newheadroom, int newtailroom,
-                                       unsigned int __nocast priority);
+                                       gfp_t priority);
 extern struct sk_buff *         skb_pad(struct sk_buff *skb, int pad);
 #define dev_kfree_skb(a)        kfree_skb(a)
 extern void           skb_over_panic(struct sk_buff *skb, int len,
@@ -342,6 +345,11 @@ extern void	      skb_over_panic(struct sk_buff *skb, int len,
 extern void           skb_under_panic(struct sk_buff *skb, int len,
                                       void *here);
 
+extern int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
+                        int getfrag(void *from, char *to, int offset,
+                        int len,int odd, struct sk_buff *skb),
+                        void *from, int length);
+
 struct skb_seq_state
 {
         __u32           lower_offset;
@@ -486,7 +494,7 @@ static inline int skb_shared(const struct sk_buff *skb)
  *      NULL is returned on a memory allocation failure.
  */
 static inline struct sk_buff *skb_share_check(struct sk_buff *skb,
-                                              unsigned int __nocast pri)
+                                              gfp_t pri)
 {
         might_sleep_if(pri & __GFP_WAIT);
         if (skb_shared(skb)) {
@@ -518,7 +526,7 @@ static inline struct sk_buff *skb_share_check(struct sk_buff *skb,
  *      %NULL is returned on a memory allocation failure.
  */
 static inline struct sk_buff *skb_unshare(struct sk_buff *skb,
-                                          unsigned int __nocast pri)
+                                          gfp_t pri)
 {
         might_sleep_if(pri & __GFP_WAIT);
         if (skb_cloned(skb)) {
@@ -597,23 +605,23 @@ static inline void skb_queue_head_init(struct sk_buff_head *list)
  */
 
 /**
- *      __skb_queue_head - queue a buffer at the list head
+ *      __skb_queue_after - queue a buffer at the list head
  *      @list: list to use
+ *      @prev: place after this buffer
  *      @newsk: buffer to queue
  *
- *      Queue a buffer at the start of a list. This function takes no locks
+ *      Queue a buffer int the middle of a list. This function takes no locks
  *      and you must therefore hold required locks before calling it.
  *
  *      A buffer cannot be placed on two lists at the same time.
  */
-extern void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
-static inline void __skb_queue_head(struct sk_buff_head *list,
-                                    struct sk_buff *newsk)
+static inline void __skb_queue_after(struct sk_buff_head *list,
+                                     struct sk_buff *prev,
+                                     struct sk_buff *newsk)
 {
-        struct sk_buff *prev, *next;
-
+        struct sk_buff *next;
         list->qlen++;
-        prev = (struct sk_buff *)list;
+
         next = prev->next;
         newsk->next = next;
         newsk->prev = prev;
@@ -621,6 +629,23 @@ static inline void __skb_queue_head(struct sk_buff_head *list,
 }
 
 /**
+ *      __skb_queue_head - queue a buffer at the list head
+ *      @list: list to use
+ *      @newsk: buffer to queue
+ *
+ *      Queue a buffer at the start of a list. This function takes no locks
+ *      and you must therefore hold required locks before calling it.
+ *
+ *      A buffer cannot be placed on two lists at the same time.
+ */
+extern void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
+static inline void __skb_queue_head(struct sk_buff_head *list,
+                                    struct sk_buff *newsk)
+{
+        __skb_queue_after(list, (struct sk_buff *)list, newsk);
+}
+
+/**
  *      __skb_queue_tail - queue a buffer at the list tail
  *      @list: list to use
  *      @newsk: buffer to queue
@@ -1019,7 +1044,7 @@ static inline void __skb_queue_purge(struct sk_buff_head *list)
  *      %NULL is returned in there is no free memory.
  */
 static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
-                                              unsigned int __nocast gfp_mask)
+                                              gfp_t gfp_mask)
 {
         struct sk_buff *skb = alloc_skb(length + 16, gfp_mask);
         if (likely(skb))
@@ -1132,8 +1157,8 @@ static inline int skb_can_coalesce(struct sk_buff *skb, int i,
  *      If there is no free memory -ENOMEM is returned, otherwise zero
  *      is returned and the old skb data released.
  */
-extern int __skb_linearize(struct sk_buff *skb, unsigned int __nocast gfp);
-static inline int skb_linearize(struct sk_buff *skb, unsigned int __nocast gfp)
+extern int __skb_linearize(struct sk_buff *skb, gfp_t gfp);
+static inline int skb_linearize(struct sk_buff *skb, gfp_t gfp)
 {
         return __skb_linearize(skb, gfp);
 }
@@ -1197,6 +1222,11 @@ static inline void kunmap_skb_frag(void *vaddr)
                      prefetch(skb->next), (skb != (struct sk_buff *)(queue));   \
                      skb = skb->next)
 
+#define skb_queue_reverse_walk(queue, skb) \
+                for (skb = (queue)->prev;                                       \
+                     prefetch(skb->prev), (skb != (struct sk_buff *)(queue));   \
+                     skb = skb->prev)
+
 
 extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
                                          int noblock, int *err);
@@ -1205,8 +1235,7 @@ extern unsigned int    datagram_poll(struct file *file, struct socket *sock,
 extern int             skb_copy_datagram_iovec(const struct sk_buff *from,
                                                int offset, struct iovec *to,
                                                int size);
-extern int             skb_copy_and_csum_datagram_iovec(const
-                                                        struct sk_buff *skb,
+extern int             skb_copy_and_csum_datagram_iovec(struct sk_buff *skb,
                                                         int hlen,
                                                         struct iovec *iov);
 extern void            skb_free_datagram(struct sock *sk, struct sk_buff *skb);
@@ -1255,10 +1284,6 @@ static inline void skb_get_timestamp(const struct sk_buff *skb, struct timeval *
 {
         stamp->tv_sec  = skb->tstamp.off_sec;
         stamp->tv_usec = skb->tstamp.off_usec;
-        if (skb->tstamp.off_sec) {
-                stamp->tv_sec  += skb_tv_base.tv_sec;
-                stamp->tv_usec += skb_tv_base.tv_usec;
-        }
 }
 
 /**
@@ -1272,12 +1297,36 @@ static inline void skb_get_timestamp(const struct sk_buff *skb, struct timeval *
  */
 static inline void skb_set_timestamp(struct sk_buff *skb, const struct timeval *stamp)
 {
-        skb->tstamp.off_sec  = stamp->tv_sec - skb_tv_base.tv_sec;
-        skb->tstamp.off_usec = stamp->tv_usec - skb_tv_base.tv_usec;
+        skb->tstamp.off_sec  = stamp->tv_sec;
+        skb->tstamp.off_usec = stamp->tv_usec;
 }
 
 extern void __net_timestamp(struct sk_buff *skb);
 
+extern unsigned int __skb_checksum_complete(struct sk_buff *skb);
+
+/**
+ *      skb_checksum_complete - Calculate checksum of an entire packet
+ *      @skb: packet to process
+ *
+ *      This function calculates the checksum over the entire packet plus
+ *      the value of skb->csum.  The latter can be used to supply the
+ *      checksum of a pseudo header as used by TCP/UDP.  It returns the
+ *      checksum.
+ *
+ *      For protocols that contain complete checksums such as ICMP/TCP/UDP,
+ *      this function can be used to verify that checksum on received
+ *      packets.  In that case the function should return zero if the
+ *      checksum is correct.  In particular, this function will return zero
+ *      if skb->ip_summed is CHECKSUM_UNNECESSARY which indicates that the
+ *      hardware has already verified the correctness of the checksum.
+ */
+static inline unsigned int skb_checksum_complete(struct sk_buff *skb)
+{
+        return skb->ip_summed != CHECKSUM_UNNECESSARY &&
+                __skb_checksum_complete(skb);
+}
+
 #ifdef CONFIG_NETFILTER
 static inline void nf_conntrack_put(struct nf_conntrack *nfct)
 {
@@ -1289,10 +1338,26 @@ static inline void nf_conntrack_get(struct nf_conntrack *nfct)
         if (nfct)
                 atomic_inc(&nfct->use);
 }
+#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
+static inline void nf_conntrack_get_reasm(struct sk_buff *skb)
+{
+        if (skb)
+                atomic_inc(&skb->users);
+}
+static inline void nf_conntrack_put_reasm(struct sk_buff *skb)
+{
+        if (skb)
+                kfree_skb(skb);
+}
+#endif
 static inline void nf_reset(struct sk_buff *skb)
 {
         nf_conntrack_put(skb->nfct);
         skb->nfct = NULL;
+#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
+        nf_conntrack_put_reasm(skb->nfct_reasm);
+        skb->nfct_reasm = NULL;
+#endif
 }
 
 #ifdef CONFIG_BRIDGE_NETFILTER
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 1f356f3bbc64..d1ea4051b996 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -9,7 +9,7 @@
 
 #if     defined(__KERNEL__)
 
-typedef struct kmem_cache_s kmem_cache_t;
+typedef struct kmem_cache kmem_cache_t;
 
 #include        <linux/config.h>        /* kmalloc_sizes.h needs CONFIG_ options */
 #include        <linux/gfp.h>
@@ -61,11 +61,11 @@ extern kmem_cache_t *kmem_cache_create(const char *, size_t, size_t, unsigned lo
                                        void (*)(void *, kmem_cache_t *, unsigned long));
 extern int kmem_cache_destroy(kmem_cache_t *);
 extern int kmem_cache_shrink(kmem_cache_t *);
-extern void *kmem_cache_alloc(kmem_cache_t *, unsigned int __nocast);
+extern void *kmem_cache_alloc(kmem_cache_t *, gfp_t);
 extern void kmem_cache_free(kmem_cache_t *, void *);
 extern unsigned int kmem_cache_size(kmem_cache_t *);
 extern const char *kmem_cache_name(kmem_cache_t *);
-extern kmem_cache_t *kmem_find_general_cachep(size_t size, unsigned int __nocast gfpflags);
+extern kmem_cache_t *kmem_find_general_cachep(size_t size, gfp_t gfpflags);
 
 /* Size description struct for general caches. */
 struct cache_sizes {
@@ -74,9 +74,9 @@ struct cache_sizes {
         kmem_cache_t    *cs_dmacachep;
 };
 extern struct cache_sizes malloc_sizes[];
-extern void *__kmalloc(size_t, unsigned int __nocast);
+extern void *__kmalloc(size_t, gfp_t);
 
-static inline void *kmalloc(size_t size, unsigned int __nocast flags)
+static inline void *kmalloc(size_t size, gfp_t flags)
 {
         if (__builtin_constant_p(size)) {
                 int i = 0;
@@ -99,7 +99,7 @@ found:
         return __kmalloc(size, flags);
 }
 
-extern void *kzalloc(size_t, unsigned int __nocast);
+extern void *kzalloc(size_t, gfp_t);
 
 /**
  * kcalloc - allocate memory for an array. The memory is set to zero.
@@ -107,7 +107,7 @@ extern void *kzalloc(size_t, unsigned int __nocast);
  * @size: element size.
  * @flags: the type of memory to allocate.
  */
-static inline void *kcalloc(size_t n, size_t size, unsigned int __nocast flags)
+static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
 {
         if (n != 0 && size > INT_MAX / n)
                 return NULL;
@@ -118,15 +118,14 @@ extern void kfree(const void *);
 extern unsigned int ksize(const void *);
 
 #ifdef CONFIG_NUMA
-extern void *kmem_cache_alloc_node(kmem_cache_t *,
-                        unsigned int __nocast flags, int node);
-extern void *kmalloc_node(size_t size, unsigned int __nocast flags, int node);
+extern void *kmem_cache_alloc_node(kmem_cache_t *, gfp_t flags, int node);
+extern void *kmalloc_node(size_t size, gfp_t flags, int node);
 #else
-static inline void *kmem_cache_alloc_node(kmem_cache_t *cachep, int flags, int node)
+static inline void *kmem_cache_alloc_node(kmem_cache_t *cachep, gfp_t flags, int node)
 {
         return kmem_cache_alloc(cachep, flags);
 }
-static inline void *kmalloc_node(size_t size, unsigned int __nocast flags, int node)
+static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 {
         return kmalloc(size, flags);
 }
diff --git a/include/linux/smp_lock.h b/include/linux/smp_lock.h
index b63ce7014093..fa1ff3b165fe 100644
--- a/include/linux/smp_lock.h
+++ b/include/linux/smp_lock.h
@@ -2,11 +2,10 @@
 #define __LINUX_SMPLOCK_H
 
 #include <linux/config.h>
+#ifdef CONFIG_LOCK_KERNEL
 #include <linux/sched.h>
 #include <linux/spinlock.h>
 
-#ifdef CONFIG_LOCK_KERNEL
-
 #define kernel_locked()         (current->lock_depth >= 0)
 
 extern int __lockfunc __reacquire_kernel_lock(void);
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index cdc99a27840d..0e9682c9def5 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -171,23 +171,42 @@ extern int __lockfunc generic__raw_read_trylock(raw_rwlock_t *lock);
 #define write_lock_irq(lock)            _write_lock_irq(lock)
 #define write_lock_bh(lock)             _write_lock_bh(lock)
 
-#define spin_unlock(lock)               _spin_unlock(lock)
-#define write_unlock(lock)              _write_unlock(lock)
-#define read_unlock(lock)               _read_unlock(lock)
+/*
+ * We inline the unlock functions in the nondebug case:
+ */
+#if defined(CONFIG_DEBUG_SPINLOCK) || defined(CONFIG_PREEMPT) || !defined(CONFIG_SMP)
+# define spin_unlock(lock)              _spin_unlock(lock)
+# define read_unlock(lock)              _read_unlock(lock)
+# define write_unlock(lock)             _write_unlock(lock)
+#else
+# define spin_unlock(lock)              __raw_spin_unlock(&(lock)->raw_lock)
+# define read_unlock(lock)              __raw_read_unlock(&(lock)->raw_lock)
+# define write_unlock(lock)             __raw_write_unlock(&(lock)->raw_lock)
+#endif
+
+#if defined(CONFIG_DEBUG_SPINLOCK) || defined(CONFIG_PREEMPT) || !defined(CONFIG_SMP)
+# define spin_unlock_irq(lock)          _spin_unlock_irq(lock)
+# define read_unlock_irq(lock)          _read_unlock_irq(lock)
+# define write_unlock_irq(lock)         _write_unlock_irq(lock)
+#else
+# define spin_unlock_irq(lock) \
+    do { __raw_spin_unlock(&(lock)->raw_lock); local_irq_enable(); } while (0)
+# define read_unlock_irq(lock) \
+    do { __raw_read_unlock(&(lock)->raw_lock); local_irq_enable(); } while (0)
+# define write_unlock_irq(lock) \
+    do { __raw_write_unlock(&(lock)->raw_lock); local_irq_enable(); } while (0)
+#endif
 
 #define spin_unlock_irqrestore(lock, flags) \
                                         _spin_unlock_irqrestore(lock, flags)
-#define spin_unlock_irq(lock)           _spin_unlock_irq(lock)
 #define spin_unlock_bh(lock)            _spin_unlock_bh(lock)
 
 #define read_unlock_irqrestore(lock, flags) \
                                         _read_unlock_irqrestore(lock, flags)
-#define read_unlock_irq(lock)           _read_unlock_irq(lock)
 #define read_unlock_bh(lock)            _read_unlock_bh(lock)
 
 #define write_unlock_irqrestore(lock, flags) \
                                         _write_unlock_irqrestore(lock, flags)
-#define write_unlock_irq(lock)          _write_unlock_irq(lock)
 #define write_unlock_bh(lock)           _write_unlock_bh(lock)
 
 #define spin_trylock_bh(lock)           __cond_lock(_spin_trylock_bh(lock))
diff --git a/include/linux/stallion.h b/include/linux/stallion.h
index e89b77b6505a..13a37f137ea2 100644
--- a/include/linux/stallion.h
+++ b/include/linux/stallion.h
@@ -21,8 +21,6 @@
  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <linux/version.h>
-
 /*****************************************************************************/
 #ifndef _STALLION_H
 #define _STALLION_H
diff --git a/include/linux/string.h b/include/linux/string.h
index dab2652acbd8..369be3264a55 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -88,7 +88,7 @@ extern int memcmp(const void *,const void *,__kernel_size_t);
 extern void * memchr(const void *,int,__kernel_size_t);
 #endif
 
-extern char *kstrdup(const char *s, unsigned int __nocast gfp);
+extern char *kstrdup(const char *s, gfp_t gfp);
 
 #ifdef __cplusplus
 }
diff --git a/include/linux/sunrpc/auth.h b/include/linux/sunrpc/auth.h
index 04ebc24db348..b68c11a2d6dd 100644
--- a/include/linux/sunrpc/auth.h
+++ b/include/linux/sunrpc/auth.h
@@ -66,7 +66,12 @@ struct rpc_cred_cache {
 
 struct rpc_auth {
         unsigned int            au_cslack;      /* call cred size estimate */
-        unsigned int            au_rslack;      /* reply verf size guess */
+                                /* guess at number of u32's auth adds before
+                                 * reply data; normally the verifier size: */
+        unsigned int            au_rslack;
+                                /* for gss, used to calculate au_rslack: */
+        unsigned int            au_verfsize;
+
         unsigned int            au_flags;       /* various flags */
         struct rpc_authops *    au_ops;         /* operations */
         rpc_authflavor_t        au_flavor;      /* pseudoflavor (note may
diff --git a/include/linux/sunrpc/debug.h b/include/linux/sunrpc/debug.h
index eadb31e3c198..1a42d902bc11 100644
--- a/include/linux/sunrpc/debug.h
+++ b/include/linux/sunrpc/debug.h
@@ -32,6 +32,7 @@
 #define RPCDBG_AUTH             0x0010
 #define RPCDBG_PMAP             0x0020
 #define RPCDBG_SCHED            0x0040
+#define RPCDBG_TRANS            0x0080
 #define RPCDBG_SVCSOCK          0x0100
 #define RPCDBG_SVCDSP           0x0200
 #define RPCDBG_MISC             0x0400
@@ -94,6 +95,8 @@ enum {
         CTL_NLMDEBUG,
         CTL_SLOTTABLE_UDP,
         CTL_SLOTTABLE_TCP,
+        CTL_MIN_RESVPORT,
+        CTL_MAX_RESVPORT,
 };
 
 #endif /* _LINUX_SUNRPC_DEBUG_H_ */
diff --git a/include/linux/sunrpc/gss_api.h b/include/linux/sunrpc/gss_api.h
index 689262f63059..9b8bcf125c18 100644
--- a/include/linux/sunrpc/gss_api.h
+++ b/include/linux/sunrpc/gss_api.h
@@ -40,14 +40,21 @@ int gss_import_sec_context(
                 struct gss_ctx          **ctx_id);
 u32 gss_get_mic(
                 struct gss_ctx          *ctx_id,
-                u32                     qop,
                 struct xdr_buf          *message,
                 struct xdr_netobj       *mic_token);
 u32 gss_verify_mic(
                 struct gss_ctx          *ctx_id,
                 struct xdr_buf          *message,
-                struct xdr_netobj       *mic_token,
-                u32                     *qstate);
+                struct xdr_netobj       *mic_token);
+u32 gss_wrap(
+                struct gss_ctx          *ctx_id,
+                int                     offset,
+                struct xdr_buf          *outbuf,
+                struct page             **inpages);
+u32 gss_unwrap(
+                struct gss_ctx          *ctx_id,
+                int                     offset,
+                struct xdr_buf          *inbuf);
 u32 gss_delete_sec_context(
                 struct gss_ctx          **ctx_id);
 
@@ -56,7 +63,6 @@ char *gss_service_to_auth_domain_name(struct gss_api_mech *, u32 service);
 
 struct pf_desc {
         u32     pseudoflavor;
-        u32     qop;
         u32     service;
         char    *name;
         char    *auth_domain_name;
@@ -85,14 +91,21 @@ struct gss_api_ops {
                         struct gss_ctx          *ctx_id);
         u32 (*gss_get_mic)(
                         struct gss_ctx          *ctx_id,
-                        u32                     qop, 
                         struct xdr_buf          *message,
                         struct xdr_netobj       *mic_token);
         u32 (*gss_verify_mic)(
                         struct gss_ctx          *ctx_id,
                         struct xdr_buf          *message,
-                        struct xdr_netobj       *mic_token,
-                        u32                     *qstate);
+                        struct xdr_netobj       *mic_token);
+        u32 (*gss_wrap)(
+                        struct gss_ctx          *ctx_id,
+                        int                     offset,
+                        struct xdr_buf          *outbuf,
+                        struct page             **inpages);
+        u32 (*gss_unwrap)(
+                        struct gss_ctx          *ctx_id,
+                        int                     offset,
+                        struct xdr_buf          *buf);
         void (*gss_delete_sec_context)(
                         void                    *internal_ctx_id);
 };
diff --git a/include/linux/sunrpc/gss_err.h b/include/linux/sunrpc/gss_err.h
index 92608a2e574c..a6807867bd21 100644
--- a/include/linux/sunrpc/gss_err.h
+++ b/include/linux/sunrpc/gss_err.h
@@ -66,16 +66,6 @@ typedef unsigned int OM_uint32;
 
 
 /*
- * Define the default Quality of Protection for per-message services.  Note
- * that an implementation that offers multiple levels of QOP may either reserve
- * a value (for example zero, as assumed here) to mean "default protection", or
- * alternatively may simply equate GSS_C_QOP_DEFAULT to a specific explicit
- * QOP value.  However a value of 0 should always be interpreted by a GSSAPI
- * implementation as a request for the default protection level.
- */
-#define GSS_C_QOP_DEFAULT 0
-
-/*
  * Expiration time of 2^32-1 seconds means infinite lifetime for a
  * credential or security context
  */
diff --git a/include/linux/sunrpc/gss_krb5.h b/include/linux/sunrpc/gss_krb5.h
index ffe31d2eb9ec..2c3601d31045 100644
--- a/include/linux/sunrpc/gss_krb5.h
+++ b/include/linux/sunrpc/gss_krb5.h
@@ -116,18 +116,22 @@ enum seal_alg {
 
 s32
 make_checksum(s32 cksumtype, char *header, int hdrlen, struct xdr_buf *body,
-                   struct xdr_netobj *cksum);
+                   int body_offset, struct xdr_netobj *cksum);
+
+u32 gss_get_mic_kerberos(struct gss_ctx *, struct xdr_buf *,
+                struct xdr_netobj *);
+
+u32 gss_verify_mic_kerberos(struct gss_ctx *, struct xdr_buf *,
+                struct xdr_netobj *);
 
 u32
-krb5_make_token(struct krb5_ctx *context_handle, int qop_req,
-        struct xdr_buf *input_message_buffer,
-        struct xdr_netobj *output_message_buffer, int toktype);
+gss_wrap_kerberos(struct gss_ctx *ctx_id, int offset,
+                struct xdr_buf *outbuf, struct page **pages);
 
 u32
-krb5_read_token(struct krb5_ctx *context_handle,
-          struct xdr_netobj *input_token_buffer,
-          struct xdr_buf *message_buffer,
-          int *qop_state, int toktype);
+gss_unwrap_kerberos(struct gss_ctx *ctx_id, int offset,
+                struct xdr_buf *buf);
+
 
 u32
 krb5_encrypt(struct crypto_tfm * key,
@@ -137,6 +141,13 @@ u32
 krb5_decrypt(struct crypto_tfm * key,
              void *iv, void *in, void *out, int length); 
 
+int
+gss_encrypt_xdr_buf(struct crypto_tfm *tfm, struct xdr_buf *outbuf, int offset,
+                struct page **pages);
+
+int
+gss_decrypt_xdr_buf(struct crypto_tfm *tfm, struct xdr_buf *inbuf, int offset);
+
 s32
 krb5_make_seq_num(struct crypto_tfm * key,
                 int direction,
diff --git a/include/linux/sunrpc/gss_spkm3.h b/include/linux/sunrpc/gss_spkm3.h
index b5c9968c3c17..0beb2cf00a84 100644
--- a/include/linux/sunrpc/gss_spkm3.h
+++ b/include/linux/sunrpc/gss_spkm3.h
@@ -41,9 +41,9 @@ struct spkm3_ctx {
 #define SPKM_WRAP_TOK   5
 #define SPKM_DEL_TOK    6
 
-u32 spkm3_make_token(struct spkm3_ctx *ctx, int qop_req, struct xdr_buf * text, struct xdr_netobj * token, int toktype);
+u32 spkm3_make_token(struct spkm3_ctx *ctx, struct xdr_buf * text, struct xdr_netobj * token, int toktype);
 
-u32 spkm3_read_token(struct spkm3_ctx *ctx, struct xdr_netobj *read_token, struct xdr_buf *message_buffer, int *qop_state, int toktype);
+u32 spkm3_read_token(struct spkm3_ctx *ctx, struct xdr_netobj *read_token, struct xdr_buf *message_buffer, int toktype);
 
 #define CKSUMTYPE_RSA_MD5            0x0007
 
diff --git a/include/linux/sunrpc/msg_prot.h b/include/linux/sunrpc/msg_prot.h
index 15f115332389..f43f237360ae 100644
--- a/include/linux/sunrpc/msg_prot.h
+++ b/include/linux/sunrpc/msg_prot.h
@@ -76,5 +76,30 @@ enum rpc_auth_stat {
 
 #define RPC_MAXNETNAMELEN       256
 
+/*
+ * From RFC 1831:
+ *
+ * "A record is composed of one or more record fragments.  A record
+ *  fragment is a four-byte header followed by 0 to (2**31) - 1 bytes of
+ *  fragment data.  The bytes encode an unsigned binary number; as with
+ *  XDR integers, the byte order is from highest to lowest.  The number
+ *  encodes two values -- a boolean which indicates whether the fragment
+ *  is the last fragment of the record (bit value 1 implies the fragment
+ *  is the last fragment) and a 31-bit unsigned binary value which is the
+ *  length in bytes of the fragment's data.  The boolean value is the
+ *  highest-order bit of the header; the length is the 31 low-order bits.
+ *  (Note that this record specification is NOT in XDR standard form!)"
+ *
+ * The Linux RPC client always sends its requests in a single record
+ * fragment, limiting the maximum payload size for stream transports to
+ * 2GB.
+ */
+
+typedef u32     rpc_fraghdr;
+
+#define RPC_LAST_STREAM_FRAGMENT        (1U << 31)
+#define RPC_FRAGMENT_SIZE_MASK          (~RPC_LAST_STREAM_FRAGMENT)
+#define RPC_MAX_FRAGMENT_SIZE           ((1U << 31) - 1)
+
 #endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_MSGPROT_H_ */
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index 5af8800e0ce3..e4086ec8b952 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -171,7 +171,8 @@ xdr_argsize_check(struct svc_rqst *rqstp, u32 *p)
 {
         char *cp = (char *)p;
         struct kvec *vec = &rqstp->rq_arg.head[0];
-        return cp - (char*)vec->iov_base <= vec->iov_len;
+        return cp >= (char*)vec->iov_base
+                && cp <= (char*)vec->iov_base + vec->iov_len;
 }
 
 static inline int
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
index 23448d0fb5bc..5da968729cf8 100644
--- a/include/linux/sunrpc/xdr.h
+++ b/include/linux/sunrpc/xdr.h
@@ -161,14 +161,10 @@ typedef struct {
 
 typedef size_t (*skb_read_actor_t)(skb_reader_t *desc, void *to, size_t len);
 
+extern int csum_partial_copy_to_xdr(struct xdr_buf *, struct sk_buff *);
 extern ssize_t xdr_partial_copy_from_skb(struct xdr_buf *, unsigned int,
                 skb_reader_t *, skb_read_actor_t);
 
-struct socket;
-struct sockaddr;
-extern int xdr_sendpages(struct socket *, struct sockaddr *, int,
-                struct xdr_buf *, unsigned int, int);
-
 extern int xdr_encode_word(struct xdr_buf *, int, u32);
 extern int xdr_decode_word(struct xdr_buf *, int, u32 *);
 
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index e618c1649814..3b8b6e823c70 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -1,5 +1,5 @@
 /*
- *  linux/include/linux/sunrpc/clnt_xprt.h
+ *  linux/include/linux/sunrpc/xprt.h
  *
  *  Declarations for the RPC transport interface.
  *
@@ -15,20 +15,6 @@
 #include <linux/sunrpc/sched.h>
 #include <linux/sunrpc/xdr.h>
 
-/*
- * The transport code maintains an estimate on the maximum number of out-
- * standing RPC requests, using a smoothed version of the congestion
- * avoidance implemented in 44BSD. This is basically the Van Jacobson
- * congestion algorithm: If a retransmit occurs, the congestion window is
- * halved; otherwise, it is incremented by 1/cwnd when
- *
- *      -       a reply is received and
- *      -       a full number of requests are outstanding and
- *      -       the congestion window hasn't been updated recently.
- *
- * Upper procedures may check whether a request would block waiting for
- * a free RPC slot by using the RPC_CONGESTED() macro.
- */
 extern unsigned int xprt_udp_slot_table_entries;
 extern unsigned int xprt_tcp_slot_table_entries;
 
@@ -36,34 +22,23 @@ extern unsigned int xprt_tcp_slot_table_entries;
 #define RPC_DEF_SLOT_TABLE      (16U)
 #define RPC_MAX_SLOT_TABLE      (128U)
 
-#define RPC_CWNDSHIFT           (8U)
-#define RPC_CWNDSCALE           (1U << RPC_CWNDSHIFT)
-#define RPC_INITCWND            RPC_CWNDSCALE
-#define RPC_MAXCWND(xprt)       ((xprt)->max_reqs << RPC_CWNDSHIFT)
-#define RPCXPRT_CONGESTED(xprt) ((xprt)->cong >= (xprt)->cwnd)
-
-/* Default timeout values */
-#define RPC_MAX_UDP_TIMEOUT     (60*HZ)
-#define RPC_MAX_TCP_TIMEOUT     (600*HZ)
-
 /*
- * Wait duration for an RPC TCP connection to be established.  Solaris
- * NFS over TCP uses 60 seconds, for example, which is in line with how
- * long a server takes to reboot.
+ * RPC call and reply header size as number of 32bit words (verifier
+ * size computed separately)
  */
-#define RPC_CONNECT_TIMEOUT     (60*HZ)
+#define RPC_CALLHDRSIZE         6
+#define RPC_REPHDRSIZE          4
 
 /*
- * Delay an arbitrary number of seconds before attempting to reconnect
- * after an error.
+ * Parameters for choosing a free port
  */
-#define RPC_REESTABLISH_TIMEOUT (15*HZ)
+extern unsigned int xprt_min_resvport;
+extern unsigned int xprt_max_resvport;
 
-/* RPC call and reply header size as number of 32bit words (verifier
- * size computed separately)
- */
-#define RPC_CALLHDRSIZE         6
-#define RPC_REPHDRSIZE          4
+#define RPC_MIN_RESVPORT        (1U)
+#define RPC_MAX_RESVPORT        (65535U)
+#define RPC_DEF_MIN_RESVPORT    (650U)
+#define RPC_DEF_MAX_RESVPORT    (1023U)
 
 /*
  * This describes a timeout strategy
@@ -76,6 +51,9 @@ struct rpc_timeout {
         unsigned char           to_exponential;
 };
 
+struct rpc_task;
+struct rpc_xprt;
+
 /*
  * This describes a complete RPC request
  */
@@ -95,7 +73,10 @@ struct rpc_rqst {
         int                     rq_cong;        /* has incremented xprt->cong */
         int                     rq_received;    /* receive completed */
         u32                     rq_seqno;       /* gss seq no. used on req. */
-
+        int                     rq_enc_pages_num;
+        struct page             **rq_enc_pages; /* scratch pages for use by
+                                                   gss privacy code */
+        void (*rq_release_snd_buf)(struct rpc_rqst *); /* release rq_enc_pages */
         struct list_head        rq_list;
 
         struct xdr_buf          rq_private_buf;         /* The receive buffer
@@ -121,12 +102,21 @@ struct rpc_rqst {
 #define rq_svec                 rq_snd_buf.head
 #define rq_slen                 rq_snd_buf.len
 
-#define XPRT_LAST_FRAG          (1 << 0)
-#define XPRT_COPY_RECM          (1 << 1)
-#define XPRT_COPY_XID           (1 << 2)
-#define XPRT_COPY_DATA          (1 << 3)
+struct rpc_xprt_ops {
+        void            (*set_buffer_size)(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize);
+        int             (*reserve_xprt)(struct rpc_task *task);
+        void            (*release_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
+        void            (*connect)(struct rpc_task *task);
+        int             (*send_request)(struct rpc_task *task);
+        void            (*set_retrans_timeout)(struct rpc_task *task);
+        void            (*timer)(struct rpc_task *task);
+        void            (*release_request)(struct rpc_task *task);
+        void            (*close)(struct rpc_xprt *xprt);
+        void            (*destroy)(struct rpc_xprt *xprt);
+};
 
 struct rpc_xprt {
+        struct rpc_xprt_ops *   ops;            /* transport methods */
         struct socket *         sock;           /* BSD socket layer */
         struct sock *           inet;           /* INET layer */
 
@@ -137,11 +127,13 @@ struct rpc_xprt {
         unsigned long           cong;           /* current congestion */
         unsigned long           cwnd;           /* congestion window */
 
-        unsigned int            rcvsize,        /* socket receive buffer size */
-                                sndsize;        /* socket send buffer size */
+        size_t                  rcvsize,        /* transport rcv buffer size */
+                                sndsize;        /* transport send buffer size */
 
         size_t                  max_payload;    /* largest RPC payload size,
                                                    in bytes */
+        unsigned int            tsh_size;       /* size of transport specific
+                                                   header */
 
         struct rpc_wait_queue   sending;        /* requests waiting to send */
         struct rpc_wait_queue   resend;         /* requests waiting to resend */
@@ -150,11 +142,9 @@ struct rpc_xprt {
         struct list_head        free;           /* free slots */
         struct rpc_rqst *       slot;           /* slot table storage */
         unsigned int            max_reqs;       /* total slots */
-        unsigned long           sockstate;      /* Socket state */
+        unsigned long           state;          /* transport state */
         unsigned char           shutdown   : 1, /* being shut down */
-                                nocong     : 1, /* no congestion control */
-                                resvport   : 1, /* use a reserved port */
-                                stream     : 1; /* TCP */
+                                resvport   : 1; /* use a reserved port */
 
         /*
          * XID
@@ -171,22 +161,27 @@ struct rpc_xprt {
         unsigned long           tcp_copied,     /* copied to request */
                                 tcp_flags;
         /*
-         * Connection of sockets
+         * Connection of transports
          */
-        struct work_struct      sock_connect;
+        unsigned long           connect_timeout,
+                                bind_timeout,
+                                reestablish_timeout;
+        struct work_struct      connect_worker;
         unsigned short          port;
+
         /*
-         * Disconnection of idle sockets
+         * Disconnection of idle transports
          */
         struct work_struct      task_cleanup;
         struct timer_list       timer;
-        unsigned long           last_used;
+        unsigned long           last_used,
+                                idle_timeout;
 
         /*
          * Send stuff
          */
-        spinlock_t              sock_lock;      /* lock socket info */
-        spinlock_t              xprt_lock;      /* lock xprt info */
+        spinlock_t              transport_lock; /* lock transport info */
+        spinlock_t              reserve_lock;   /* lock slot table */
         struct rpc_task *       snd_task;       /* Task blocked in send */
 
         struct list_head        recv;
@@ -195,37 +190,111 @@ struct rpc_xprt {
         void                    (*old_data_ready)(struct sock *, int);
         void                    (*old_state_change)(struct sock *);
         void                    (*old_write_space)(struct sock *);
-
-        wait_queue_head_t       cong_wait;
 };
 
+#define XPRT_LAST_FRAG          (1 << 0)
+#define XPRT_COPY_RECM          (1 << 1)
+#define XPRT_COPY_XID           (1 << 2)
+#define XPRT_COPY_DATA          (1 << 3)
+
 #ifdef __KERNEL__
 
-struct rpc_xprt *       xprt_create_proto(int proto, struct sockaddr_in *addr,
-                                        struct rpc_timeout *toparms);
-int                     xprt_destroy(struct rpc_xprt *);
-void                    xprt_set_timeout(struct rpc_timeout *, unsigned int,
-                                        unsigned long);
+/*
+ * Transport operations used by ULPs
+ */
+struct rpc_xprt *       xprt_create_proto(int proto, struct sockaddr_in *addr, struct rpc_timeout *to);
+void                    xprt_set_timeout(struct rpc_timeout *to, unsigned int retr, unsigned long incr);
 
-void                    xprt_reserve(struct rpc_task *);
-int                     xprt_prepare_transmit(struct rpc_task *);
-void                    xprt_transmit(struct rpc_task *);
-void                    xprt_receive(struct rpc_task *);
+/*
+ * Generic internal transport functions
+ */
+void                    xprt_connect(struct rpc_task *task);
+void                    xprt_reserve(struct rpc_task *task);
+int                     xprt_reserve_xprt(struct rpc_task *task);
+int                     xprt_reserve_xprt_cong(struct rpc_task *task);
+int                     xprt_prepare_transmit(struct rpc_task *task);
+void                    xprt_transmit(struct rpc_task *task);
+void                    xprt_abort_transmit(struct rpc_task *task);
 int                     xprt_adjust_timeout(struct rpc_rqst *req);
-void                    xprt_release(struct rpc_task *);
-void                    xprt_connect(struct rpc_task *);
-void                    xprt_sock_setbufsize(struct rpc_xprt *);
-
-#define XPRT_LOCKED     0
-#define XPRT_CONNECT    1
-#define XPRT_CONNECTING 2
-
-#define xprt_connected(xp)              (test_bit(XPRT_CONNECT, &(xp)->sockstate))
-#define xprt_set_connected(xp)          (set_bit(XPRT_CONNECT, &(xp)->sockstate))
-#define xprt_test_and_set_connected(xp) (test_and_set_bit(XPRT_CONNECT, &(xp)->sockstate))
-#define xprt_test_and_clear_connected(xp) \
-                                        (test_and_clear_bit(XPRT_CONNECT, &(xp)->sockstate))
-#define xprt_clear_connected(xp)        (clear_bit(XPRT_CONNECT, &(xp)->sockstate))
+void                    xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task);
+void                    xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task);
+void                    xprt_release(struct rpc_task *task);
+int                     xprt_destroy(struct rpc_xprt *xprt);
+
+static inline u32 *xprt_skip_transport_header(struct rpc_xprt *xprt, u32 *p)
+{
+        return p + xprt->tsh_size;
+}
+
+/*
+ * Transport switch helper functions
+ */
+void                    xprt_set_retrans_timeout_def(struct rpc_task *task);
+void                    xprt_set_retrans_timeout_rtt(struct rpc_task *task);
+void                    xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status);
+void                    xprt_wait_for_buffer_space(struct rpc_task *task);
+void                    xprt_write_space(struct rpc_xprt *xprt);
+void                    xprt_update_rtt(struct rpc_task *task);
+void                    xprt_adjust_cwnd(struct rpc_task *task, int result);
+struct rpc_rqst *       xprt_lookup_rqst(struct rpc_xprt *xprt, u32 xid);
+void                    xprt_complete_rqst(struct rpc_task *task, int copied);
+void                    xprt_release_rqst_cong(struct rpc_task *task);
+void                    xprt_disconnect(struct rpc_xprt *xprt);
+
+/*
+ * Socket transport setup operations
+ */
+int                     xs_setup_udp(struct rpc_xprt *xprt, struct rpc_timeout *to);
+int                     xs_setup_tcp(struct rpc_xprt *xprt, struct rpc_timeout *to);
+
+/*
+ * Reserved bit positions in xprt->state
+ */
+#define XPRT_LOCKED             (0)
+#define XPRT_CONNECTED          (1)
+#define XPRT_CONNECTING         (2)
+
+static inline void xprt_set_connected(struct rpc_xprt *xprt)
+{
+        set_bit(XPRT_CONNECTED, &xprt->state);
+}
+
+static inline void xprt_clear_connected(struct rpc_xprt *xprt)
+{
+        clear_bit(XPRT_CONNECTED, &xprt->state);
+}
+
+static inline int xprt_connected(struct rpc_xprt *xprt)
+{
+        return test_bit(XPRT_CONNECTED, &xprt->state);
+}
+
+static inline int xprt_test_and_set_connected(struct rpc_xprt *xprt)
+{
+        return test_and_set_bit(XPRT_CONNECTED, &xprt->state);
+}
+
+static inline int xprt_test_and_clear_connected(struct rpc_xprt *xprt)
+{
+        return test_and_clear_bit(XPRT_CONNECTED, &xprt->state);
+}
+
+static inline void xprt_clear_connecting(struct rpc_xprt *xprt)
+{
+        smp_mb__before_clear_bit();
+        clear_bit(XPRT_CONNECTING, &xprt->state);
+        smp_mb__after_clear_bit();
+}
+
+static inline int xprt_connecting(struct rpc_xprt *xprt)
+{
+        return test_bit(XPRT_CONNECTING, &xprt->state);
+}
+
+static inline int xprt_test_and_set_connecting(struct rpc_xprt *xprt)
+{
+        return test_and_set_bit(XPRT_CONNECTING, &xprt->state);
+}
 
 #endif /* __KERNEL__*/
 
diff --git a/include/linux/superhyway.h b/include/linux/superhyway.h
index c906c5a0aaef..17ea468fa362 100644
--- a/include/linux/superhyway.h
+++ b/include/linux/superhyway.h
@@ -19,7 +19,7 @@
  */
 #define SUPERHYWAY_DEVICE_ID_SH5_DMAC   0x0183
 
-struct vcr_info {
+struct superhyway_vcr_info {
         u8      perr_flags;     /* P-port Error flags */
         u8      merr_flags;     /* Module Error flags */
         u16     mod_vers;       /* Module Version */
@@ -28,6 +28,17 @@ struct vcr_info {
         u8      top_mb;         /* Top Memory block */
 };
 
+struct superhyway_ops {
+        int (*read_vcr)(unsigned long base, struct superhyway_vcr_info *vcr);
+        int (*write_vcr)(unsigned long base, struct superhyway_vcr_info vcr);
+};
+
+struct superhyway_bus {
+        struct superhyway_ops *ops;
+};
+
+extern struct superhyway_bus superhyway_channels[];
+
 struct superhyway_device_id {
         unsigned int id;
         unsigned long driver_data;
@@ -55,9 +66,11 @@ struct superhyway_device {
 
         struct superhyway_device_id id;
         struct superhyway_driver *drv;
+        struct superhyway_bus *bus;
 
-        struct resource resource;
-        struct vcr_info vcr;
+        int num_resources;
+        struct resource *resource;
+        struct superhyway_vcr_info vcr;
 };
 
 #define to_superhyway_device(d) container_of((d), struct superhyway_device, dev)
@@ -65,12 +78,27 @@ struct superhyway_device {
 #define superhyway_get_drvdata(d)       dev_get_drvdata(&(d)->dev)
 #define superhyway_set_drvdata(d,p)     dev_set_drvdata(&(d)->dev, (p))
 
-extern int superhyway_scan_bus(void);
+static inline int
+superhyway_read_vcr(struct superhyway_device *dev, unsigned long base,
+                    struct superhyway_vcr_info *vcr)
+{
+        return dev->bus->ops->read_vcr(base, vcr);
+}
+
+static inline int
+superhyway_write_vcr(struct superhyway_device *dev, unsigned long base,
+                     struct superhyway_vcr_info vcr)
+{
+        return dev->bus->ops->write_vcr(base, vcr);
+}
+
+extern int superhyway_scan_bus(struct superhyway_bus *);
 
 /* drivers/sh/superhyway/superhyway.c */
 int superhyway_register_driver(struct superhyway_driver *);
 void superhyway_unregister_driver(struct superhyway_driver *);
-int superhyway_add_device(unsigned int, unsigned long, unsigned long long);
+int superhyway_add_device(unsigned long base, struct superhyway_device *, struct superhyway_bus *);
+int superhyway_add_devices(struct superhyway_bus *bus, struct superhyway_device **devices, int nr_devices);
 
 /* drivers/sh/superhyway/superhyway-sysfs.c */
 extern struct device_attribute superhyway_dev_attrs[];
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index f2e96fdfaae0..a61c04f804b2 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -71,5 +71,12 @@ void restore_processor_state(void);
 struct saved_context;
 void __save_processor_state(struct saved_context *ctxt);
 void __restore_processor_state(struct saved_context *ctxt);
+unsigned long get_safe_page(gfp_t gfp_mask);
+
+/*
+ * XXX: We try to keep some more pages free so that I/O operations succeed
+ * without paging. Might this be more?
+ */
+#define PAGES_FOR_IO    512
 
 #endif /* _LINUX_SWSUSP_H */
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 3c9ff0048153..508668f840b6 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -147,7 +147,7 @@ struct swap_list_t {
 #define vm_swap_full() (nr_swap_pages*2 < total_swap_pages)
 
 /* linux/mm/oom_kill.c */
-extern void out_of_memory(unsigned int __nocast gfp_mask, int order);
+extern void out_of_memory(gfp_t gfp_mask, int order);
 
 /* linux/mm/memory.c */
 extern void swapin_readahead(swp_entry_t, unsigned long, struct vm_area_struct *);
@@ -171,8 +171,8 @@ extern int rotate_reclaimable_page(struct page *page);
 extern void swap_setup(void);
 
 /* linux/mm/vmscan.c */
-extern int try_to_free_pages(struct zone **, unsigned int);
-extern int zone_reclaim(struct zone *, unsigned int, unsigned int);
+extern int try_to_free_pages(struct zone **, gfp_t);
+extern int zone_reclaim(struct zone *, gfp_t, unsigned int);
 extern int shrink_all_memory(int);
 extern int vm_swappiness;
 
@@ -239,6 +239,11 @@ static inline void put_swap_token(struct mm_struct *mm)
                 __put_swap_token(mm);
 }
 
+static inline void disable_swap_token(void)
+{
+        put_swap_token(swap_token_mm);
+}
+
 #else /* CONFIG_SWAP */
 
 #define total_swap_pages                        0
@@ -283,6 +288,7 @@ static inline swp_entry_t get_swap_page(void)
 #define put_swap_token(x) do { } while(0)
 #define grab_swap_token()  do { } while(0)
 #define has_swap_token(x) 0
+#define disable_swap_token() do { } while(0)
 
 #endif /* CONFIG_SWAP */
 #endif /* __KERNEL__*/
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index a6f03e473737..c7007b1db91d 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -491,6 +491,7 @@ asmlinkage long sys_nfsservctl(int cmd,
 asmlinkage long sys_syslog(int type, char __user *buf, int len);
 asmlinkage long sys_uselib(const char __user *library);
 asmlinkage long sys_ni_syscall(void);
+asmlinkage long sys_ptrace(long request, long pid, long addr, long data);
 
 asmlinkage long sys_add_key(const char __user *_type,
                             const char __user *_description,
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index 3a29a9f9b451..6bc03c911a83 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -20,10 +20,10 @@
 
 #include <linux/kernel.h>
 #include <linux/types.h>
-#include <linux/list.h>
 #include <linux/compiler.h>
 
 struct file;
+struct completion;
 
 #define CTL_MAXNAME 10          /* how many path components do we allow in a
                                    call to sysctl?   In other words, what is
@@ -202,7 +202,9 @@ enum
         NET_TR=14,
         NET_DECNET=15,
         NET_ECONET=16,
-        NET_SCTP=17, 
+        NET_SCTP=17,
+        NET_LLC=18,
+        NET_NETFILTER=19,
 };
 
 /* /proc/sys/kernel/random */
@@ -268,6 +270,42 @@ enum
         NET_UNIX_MAX_DGRAM_QLEN=3,
 };
 
+/* /proc/sys/net/netfilter */
+enum
+{
+        NET_NF_CONNTRACK_MAX=1,
+        NET_NF_CONNTRACK_TCP_TIMEOUT_SYN_SENT=2,
+        NET_NF_CONNTRACK_TCP_TIMEOUT_SYN_RECV=3,
+        NET_NF_CONNTRACK_TCP_TIMEOUT_ESTABLISHED=4,
+        NET_NF_CONNTRACK_TCP_TIMEOUT_FIN_WAIT=5,
+        NET_NF_CONNTRACK_TCP_TIMEOUT_CLOSE_WAIT=6,
+        NET_NF_CONNTRACK_TCP_TIMEOUT_LAST_ACK=7,
+        NET_NF_CONNTRACK_TCP_TIMEOUT_TIME_WAIT=8,
+        NET_NF_CONNTRACK_TCP_TIMEOUT_CLOSE=9,
+        NET_NF_CONNTRACK_UDP_TIMEOUT=10,
+        NET_NF_CONNTRACK_UDP_TIMEOUT_STREAM=11,
+        NET_NF_CONNTRACK_ICMP_TIMEOUT=12,
+        NET_NF_CONNTRACK_GENERIC_TIMEOUT=13,
+        NET_NF_CONNTRACK_BUCKETS=14,
+        NET_NF_CONNTRACK_LOG_INVALID=15,
+        NET_NF_CONNTRACK_TCP_TIMEOUT_MAX_RETRANS=16,
+        NET_NF_CONNTRACK_TCP_LOOSE=17,
+        NET_NF_CONNTRACK_TCP_BE_LIBERAL=18,
+        NET_NF_CONNTRACK_TCP_MAX_RETRANS=19,
+        NET_NF_CONNTRACK_SCTP_TIMEOUT_CLOSED=20,
+        NET_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_WAIT=21,
+        NET_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_ECHOED=22,
+        NET_NF_CONNTRACK_SCTP_TIMEOUT_ESTABLISHED=23,
+        NET_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_SENT=24,
+        NET_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_RECD=25,
+        NET_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_ACK_SENT=26,
+        NET_NF_CONNTRACK_COUNT=27,
+        NET_NF_CONNTRACK_ICMPV6_TIMEOUT=28,
+        NET_NF_CONNTRACK_FRAG6_TIMEOUT=29,
+        NET_NF_CONNTRACK_FRAG6_LOW_THRESH=30,
+        NET_NF_CONNTRACK_FRAG6_HIGH_THRESH=31,
+};
+
 /* /proc/sys/net/ipv4 */
 enum
 {
@@ -351,6 +389,7 @@ enum
         NET_TCP_BIC_BETA=108,
         NET_IPV4_ICMP_ERRORS_USE_INBOUND_IFADDR=109,
         NET_TCP_CONG_CONTROL=110,
+        NET_TCP_ABC=111,
 };
 
 enum {
@@ -522,6 +561,29 @@ enum {
         NET_IPX_FORWARDING=2
 };
 
+/* /proc/sys/net/llc */
+enum {
+        NET_LLC2=1,
+        NET_LLC_STATION=2,
+};
+
+/* /proc/sys/net/llc/llc2 */
+enum {
+        NET_LLC2_TIMEOUT=1,
+};
+
+/* /proc/sys/net/llc/station */
+enum {
+        NET_LLC_STATION_ACK_TIMEOUT=1,
+};
+
+/* /proc/sys/net/llc/llc2/timeout */
+enum {
+        NET_LLC2_ACK_TIMEOUT=1,
+        NET_LLC2_P_TIMEOUT=2,
+        NET_LLC2_REJ_TIMEOUT=3,
+        NET_LLC2_BUSY_TIMEOUT=4,
+};
 
 /* /proc/sys/net/appletalk */
 enum {
@@ -652,6 +714,7 @@ enum {
         NET_SCTP_PRSCTP_ENABLE           = 14,
         NET_SCTP_SNDBUF_POLICY           = 15,
         NET_SCTP_SACK_TIMEOUT            = 16,
+        NET_SCTP_RCVBUF_POLICY           = 17,
 };
 
 /* /proc/sys/net/bridge */
@@ -795,6 +858,7 @@ enum
 };
 
 #ifdef __KERNEL__
+#include <linux/list.h>
 
 extern void sysctl_init(void);
 
@@ -901,6 +965,8 @@ struct ctl_table_header
 {
         ctl_table *ctl_table;
         struct list_head ctl_entry;
+        int used;
+        struct completion *unregistering;
 };
 
 struct ctl_table_header * register_sysctl_table(ctl_table * table, 
diff --git a/include/linux/tc_ematch/tc_em_meta.h b/include/linux/tc_ematch/tc_em_meta.h
index 081b1ee8516e..e21937cf91d0 100644
--- a/include/linux/tc_ematch/tc_em_meta.h
+++ b/include/linux/tc_ematch/tc_em_meta.h
@@ -71,7 +71,7 @@ enum
         TCF_META_ID_SK_SNDBUF,
         TCF_META_ID_SK_ALLOCS,
         TCF_META_ID_SK_ROUTE_CAPS,
-        TCF_META_ID_SK_HASHENT,
+        TCF_META_ID_SK_HASH,
         TCF_META_ID_SK_LINGERTIME,
         TCF_META_ID_SK_ACK_BACKLOG,
         TCF_META_ID_SK_MAX_ACK_BACKLOG,
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index ac4ca44c75ca..0e1da6602e05 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -307,6 +307,21 @@ struct tcp_sock {
         struct tcp_sack_block duplicate_sack[1]; /* D-SACK block */
         struct tcp_sack_block selective_acks[4]; /* The SACKS themselves*/
 
+        struct tcp_sack_block recv_sack_cache[4];
+
+        /* from STCP, retrans queue hinting */
+        struct sk_buff* lost_skb_hint;
+
+        struct sk_buff *scoreboard_skb_hint;
+        struct sk_buff *retransmit_skb_hint;
+        struct sk_buff *forward_skb_hint;
+        struct sk_buff *fastpath_skb_hint;
+
+        int     fastpath_cnt_hint;
+        int     lost_cnt_hint;
+        int     retransmit_cnt_hint;
+        int     forward_cnt_hint;
+
         __u16   advmss;         /* Advertised MSS                       */
         __u16   prior_ssthresh; /* ssthresh saved at recovery start     */
         __u32   lost_out;       /* Lost packets                 */
@@ -326,6 +341,7 @@ struct tcp_sock {
         __u32   snd_up;         /* Urgent pointer               */
 
         __u32   total_retrans;  /* Total retransmits for entire connection */
+        __u32   bytes_acked;    /* Appropriate Byte Counting - RFC3465 */
 
         unsigned int            keepalive_time;   /* time before keep alive takes place */
         unsigned int            keepalive_intvl;  /* time interval between keep alive probes */
diff --git a/include/linux/textsearch.h b/include/linux/textsearch.h
index 941f45ac117a..7dac8f04d28e 100644
--- a/include/linux/textsearch.h
+++ b/include/linux/textsearch.h
@@ -8,6 +8,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/err.h>
+#include <linux/slab.h>
 
 struct ts_config;
 
@@ -40,7 +41,7 @@ struct ts_state
 struct ts_ops
 {
         const char              *name;
-        struct ts_config *      (*init)(const void *, unsigned int, int);
+        struct ts_config *      (*init)(const void *, unsigned int, gfp_t);
         unsigned int            (*find)(struct ts_config *,
                                         struct ts_state *);
         void                    (*destroy)(struct ts_config *);
@@ -148,7 +149,7 @@ static inline unsigned int textsearch_get_pattern_len(struct ts_config *conf)
 extern int textsearch_register(struct ts_ops *);
 extern int textsearch_unregister(struct ts_ops *);
 extern struct ts_config *textsearch_prepare(const char *, const void *,
-                                            unsigned int, int, int);
+                                            unsigned int, gfp_t, int);
 extern void textsearch_destroy(struct ts_config *conf);
 extern unsigned int textsearch_find_continuous(struct ts_config *,
                                                struct ts_state *,
@@ -158,7 +159,8 @@ extern unsigned int textsearch_find_continuous(struct ts_config *,
 #define TS_PRIV_ALIGNTO 8
 #define TS_PRIV_ALIGN(len) (((len) + TS_PRIV_ALIGNTO-1) & ~(TS_PRIV_ALIGNTO-1))
 
-static inline struct ts_config *alloc_ts_config(size_t payload, int gfp_mask)
+static inline struct ts_config *alloc_ts_config(size_t payload,
+                                                gfp_t gfp_mask)
 {
         struct ts_config *conf;
 
diff --git a/include/linux/thread_info.h b/include/linux/thread_info.h
index d252f45a0f9b..1c4eb41dbd89 100644
--- a/include/linux/thread_info.h
+++ b/include/linux/thread_info.h
@@ -27,31 +27,6 @@ extern long do_no_restart_syscall(struct restart_block *parm);
  * - pass TIF_xxxx constants to these functions
  */
 
-static inline void set_thread_flag(int flag)
-{
-        set_bit(flag,&current_thread_info()->flags);
-}
-
-static inline void clear_thread_flag(int flag)
-{
-        clear_bit(flag,&current_thread_info()->flags);
-}
-
-static inline int test_and_set_thread_flag(int flag)
-{
-        return test_and_set_bit(flag,&current_thread_info()->flags);
-}
-
-static inline int test_and_clear_thread_flag(int flag)
-{
-        return test_and_clear_bit(flag,&current_thread_info()->flags);
-}
-
-static inline int test_thread_flag(int flag)
-{
-        return test_bit(flag,&current_thread_info()->flags);
-}
-
 static inline void set_ti_thread_flag(struct thread_info *ti, int flag)
 {
         set_bit(flag,&ti->flags);
@@ -77,15 +52,19 @@ static inline int test_ti_thread_flag(struct thread_info *ti, int flag)
         return test_bit(flag,&ti->flags);
 }
 
-static inline void set_need_resched(void)
-{
-        set_thread_flag(TIF_NEED_RESCHED);
-}
-
-static inline void clear_need_resched(void)
-{
-        clear_thread_flag(TIF_NEED_RESCHED);
-}
+#define set_thread_flag(flag) \
+        set_ti_thread_flag(current_thread_info(), flag)
+#define clear_thread_flag(flag) \
+        clear_ti_thread_flag(current_thread_info(), flag)
+#define test_and_set_thread_flag(flag) \
+        test_and_set_ti_thread_flag(current_thread_info(), flag)
+#define test_and_clear_thread_flag(flag) \
+        test_and_clear_ti_thread_flag(current_thread_info(), flag)
+#define test_thread_flag(flag) \
+        test_ti_thread_flag(current_thread_info(), flag)
+
+#define set_need_resched()      set_thread_flag(TIF_NEED_RESCHED)
+#define clear_need_resched()    clear_thread_flag(TIF_NEED_RESCHED)
 
 #endif
 
diff --git a/include/linux/time.h b/include/linux/time.h
index 8e83f4e778bb..bfbe92d0767c 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -101,7 +101,7 @@ extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
 static inline void
 set_normalized_timespec (struct timespec *ts, time_t sec, long nsec)
 {
-        while (nsec > NSEC_PER_SEC) {
+        while (nsec >= NSEC_PER_SEC) {
                 nsec -= NSEC_PER_SEC;
                 ++sec;
         }
diff --git a/include/linux/timer.h b/include/linux/timer.h
index 3340f3bd135d..72f3a7781106 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -12,16 +12,12 @@ struct timer_list {
         struct list_head entry;
         unsigned long expires;
 
-        unsigned long magic;
-
         void (*function)(unsigned long);
         unsigned long data;
 
         struct timer_base_s *base;
 };
 
-#define TIMER_MAGIC     0x4b87ad6e
-
 extern struct timer_base_s __init_timer_base;
 
 #define TIMER_INITIALIZER(_function, _expires, _data) {         \
@@ -29,7 +25,6 @@ extern struct timer_base_s __init_timer_base;
                 .expires = (_expires),                          \
                 .data = (_data),                                \
                 .base = &__init_timer_base,                     \
-                .magic = TIMER_MAGIC,                           \
         }
 
 #define DEFINE_TIMER(_name, _function, _expires, _data)         \
@@ -38,6 +33,15 @@ extern struct timer_base_s __init_timer_base;
 
 void fastcall init_timer(struct timer_list * timer);
 
+static inline void setup_timer(struct timer_list * timer,
+                                void (*function)(unsigned long),
+                                unsigned long data)
+{
+        timer->function = function;
+        timer->data = data;
+        init_timer(timer);
+}
+
 /***
  * timer_pending - is a timer pending?
  * @timer: the timer in question
@@ -74,8 +78,9 @@ extern unsigned long next_timer_interrupt(void);
  * Timers with an ->expired field in the past will be executed in the next
  * timer tick.
  */
-static inline void add_timer(struct timer_list * timer)
+static inline void add_timer(struct timer_list *timer)
 {
+        BUG_ON(timer_pending(timer));
         __mod_timer(timer, timer->expires);
 }
 
diff --git a/include/linux/timex.h b/include/linux/timex.h
index 7e050a2cc35b..04a4a8cb4ed3 100644
--- a/include/linux/timex.h
+++ b/include/linux/timex.h
@@ -282,6 +282,13 @@ static inline int ntp_synced(void)
         return !(time_status & STA_UNSYNC);
 }
 
+/* Required to safely shift negative values */
+#define shift_right(x, s) ({    \
+        __typeof__(x) __x = (x);        \
+        __typeof__(s) __s = (s);        \
+        __x < 0 ? -(-__x >> __s) : __x >> __s;  \
+})
+
 
 #ifdef CONFIG_TIME_INTERPOLATION
 
diff --git a/include/linux/types.h b/include/linux/types.h
index 2b678c22ca4a..21b9ce803644 100644
--- a/include/linux/types.h
+++ b/include/linux/types.h
@@ -151,7 +151,12 @@ typedef unsigned long sector_t;
  */
 
 #ifdef __CHECKER__
-#define __bitwise __attribute__((bitwise))
+#define __bitwise__ __attribute__((bitwise))
+#else
+#define __bitwise__
+#endif
+#ifdef __CHECK_ENDIAN__
+#define __bitwise __bitwise__
 #else
 #define __bitwise
 #endif
@@ -165,6 +170,10 @@ typedef __u64 __bitwise __le64;
 typedef __u64 __bitwise __be64;
 #endif
 
+#ifdef __KERNEL__
+typedef unsigned __bitwise__ gfp_t;
+#endif
+
 struct ustat {
         __kernel_daddr_t        f_tfree;
         __kernel_ino_t          f_tinode;
diff --git a/include/linux/uinput.h b/include/linux/uinput.h
index 84876077027f..0ff7ca68e5c5 100644
--- a/include/linux/uinput.h
+++ b/include/linux/uinput.h
@@ -34,8 +34,7 @@
 #define UINPUT_BUFFER_SIZE      16
 #define UINPUT_NUM_REQUESTS     16
 
-/* state flags => bit index for {set|clear|test}_bit ops */
-#define UIST_CREATED            0
+enum uinput_state { UIST_NEW_DEVICE, UIST_SETUP_COMPLETE, UIST_CREATED };
 
 struct uinput_request {
         int                     id;
@@ -52,11 +51,12 @@ struct uinput_request {
 
 struct uinput_device {
         struct input_dev        *dev;
-        unsigned long           state;
+        struct semaphore        sem;
+        enum uinput_state       state;
         wait_queue_head_t       waitq;
-        unsigned char           ready,
-                                head,
-                                tail;
+        unsigned char           ready;
+        unsigned char           head;
+        unsigned char           tail;
         struct input_event      buff[UINPUT_BUFFER_SIZE];
 
         struct uinput_request   *requests[UINPUT_NUM_REQUESTS];
@@ -91,6 +91,7 @@ struct uinput_ff_erase {
 #define UI_SET_SNDBIT           _IOW(UINPUT_IOCTL_BASE, 106, int)
 #define UI_SET_FFBIT            _IOW(UINPUT_IOCTL_BASE, 107, int)
 #define UI_SET_PHYS             _IOW(UINPUT_IOCTL_BASE, 108, char*)
+#define UI_SET_SWBIT            _IOW(UINPUT_IOCTL_BASE, 109, int)
 
 #define UI_BEGIN_FF_UPLOAD      _IOWR(UINPUT_IOCTL_BASE, 200, struct uinput_ff_upload)
 #define UI_END_FF_UPLOAD        _IOW(UINPUT_IOCTL_BASE, 201, struct uinput_ff_upload)
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 4dbe580f9335..d81b050e5955 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -47,6 +47,7 @@ struct usb_driver;
  * @urb_list: urbs queued to this endpoint; maintained by usbcore
  * @hcpriv: for use by HCD; typically holds hardware dma queue head (QH)
  *      with one or more transfer descriptors (TDs) per urb
+ * @kobj: kobject for sysfs info
  * @extra: descriptors following this endpoint in the configuration
  * @extralen: how many bytes of "extra" are valid
  *
@@ -57,6 +58,7 @@ struct usb_host_endpoint {
         struct usb_endpoint_descriptor  desc;
         struct list_head                urb_list;
         void                            *hcpriv;
+        struct kobject                  *kobj;  /* For sysfs info */
 
         unsigned char *extra;   /* Extra descriptors */
         int extralen;
@@ -136,7 +138,8 @@ struct usb_interface {
                                          * active alternate setting */
         unsigned num_altsetting;        /* number of alternate settings */
 
-        int minor;                      /* minor number this interface is bound to */
+        int minor;                      /* minor number this interface is
+                                         * bound to */
         enum usb_interface_condition condition;         /* state of binding */
         struct device dev;              /* interface specific device info */
         struct class_device *class_dev;
@@ -229,7 +232,7 @@ struct usb_interface_cache {
 struct usb_host_config {
         struct usb_config_descriptor    desc;
 
-        char *string;
+        char *string;           /* iConfiguration string, if present */
         /* the interfaces associated with this configuration,
          * stored in no particular order */
         struct usb_interface *interface[USB_MAXINTERFACES];
@@ -248,7 +251,7 @@ int __usb_get_extra_descriptor(char *buffer, unsigned size,
         __usb_get_extra_descriptor((ifpoint)->extra,(ifpoint)->extralen,\
                 type,(void**)ptr)
 
-/* -------------------------------------------------------------------------- */
+/* ----------------------------------------------------------------------- */
 
 struct usb_operations;
 
@@ -268,7 +271,8 @@ struct usb_bus {
         unsigned is_b_host:1;           /* true during some HNP roleswitches */
         unsigned b_hnp_enable:1;        /* OTG: did A-Host enable HNP? */
 
-        int devnum_next;                /* Next open device number in round-robin allocation */
+        int devnum_next;                /* Next open device number in
+                                         * round-robin allocation */
 
         struct usb_devmap devmap;       /* device address allocation map */
         struct usb_operations *op;      /* Operations (specific to the HC) */
@@ -289,15 +293,16 @@ struct usb_bus {
         struct dentry *usbfs_dentry;    /* usbfs dentry entry for the bus */
 
         struct class_device *class_dev; /* class device for this bus */
-        struct kref kref;               /* handles reference counting this bus */
-        void (*release)(struct usb_bus *bus);   /* function to destroy this bus's memory */
+        struct kref kref;               /* reference counting for this bus */
+        void (*release)(struct usb_bus *bus);
+
 #if defined(CONFIG_USB_MON)
         struct mon_bus *mon_bus;        /* non-null when associated */
         int monitored;                  /* non-zero when monitored */
 #endif
 };
 
-/* -------------------------------------------------------------------------- */
+/* ----------------------------------------------------------------------- */
 
 /* This is arbitrary.
  * From USB 2.0 spec Table 11-13, offset 7, a hub can
@@ -326,7 +331,8 @@ struct usb_device {
 
         struct semaphore serialize;
 
-        unsigned int toggle[2];         /* one bit for each endpoint ([0] = IN, [1] = OUT) */
+        unsigned int toggle[2];         /* one bit for each endpoint
+                                         * ([0] = IN, [1] = OUT) */
 
         struct usb_device *parent;      /* our hub, unless we're the root */
         struct usb_bus *bus;            /* Bus we're part of */
@@ -343,12 +349,14 @@ struct usb_device {
 
         char **rawdescriptors;          /* Raw descriptors for each config */
 
-        int have_langid;                /* whether string_langid is valid yet */
+        int have_langid;                /* whether string_langid is valid */
         int string_langid;              /* language ID for strings */
 
-        char *product;
-        char *manufacturer;
-        char *serial;                   /* static strings from the device */
+        /* static strings from the device */
+        char *product;                  /* iProduct string, if present */
+        char *manufacturer;             /* iManufacturer string, if present */
+        char *serial;                   /* iSerialNumber string, if present */
+
         struct list_head filelist;
         struct class_device *class_dev;
         struct dentry *usbfs_dentry;    /* usbfs dentry entry for the device */
@@ -440,22 +448,31 @@ extern struct usb_host_interface *usb_altnum_to_altsetting(
  * USB 2.0 root hubs (EHCI host controllers) will get one path ID if they are
  * high speed, and a different one if they are full or low speed.
  */
-static inline int usb_make_path (struct usb_device *dev, char *buf, size_t size)
+static inline int usb_make_path (struct usb_device *dev, char *buf,
+                size_t size)
 {
         int actual;
-        actual = snprintf (buf, size, "usb-%s-%s", dev->bus->bus_name, dev->devpath);
+        actual = snprintf (buf, size, "usb-%s-%s", dev->bus->bus_name,
+                        dev->devpath);
         return (actual >= (int)size) ? -1 : actual;
 }
 
 /*-------------------------------------------------------------------------*/
 
-#define USB_DEVICE_ID_MATCH_DEVICE              (USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT)
-#define USB_DEVICE_ID_MATCH_DEV_RANGE           (USB_DEVICE_ID_MATCH_DEV_LO | USB_DEVICE_ID_MATCH_DEV_HI)
-#define USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION  (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_RANGE)
+#define USB_DEVICE_ID_MATCH_DEVICE \
+                (USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT)
+#define USB_DEVICE_ID_MATCH_DEV_RANGE \
+                (USB_DEVICE_ID_MATCH_DEV_LO | USB_DEVICE_ID_MATCH_DEV_HI)
+#define USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION \
+                (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_RANGE)
 #define USB_DEVICE_ID_MATCH_DEV_INFO \
-        (USB_DEVICE_ID_MATCH_DEV_CLASS | USB_DEVICE_ID_MATCH_DEV_SUBCLASS | USB_DEVICE_ID_MATCH_DEV_PROTOCOL)
+                (USB_DEVICE_ID_MATCH_DEV_CLASS | \
+                USB_DEVICE_ID_MATCH_DEV_SUBCLASS | \
+                USB_DEVICE_ID_MATCH_DEV_PROTOCOL)
 #define USB_DEVICE_ID_MATCH_INT_INFO \
-        (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS | USB_DEVICE_ID_MATCH_INT_PROTOCOL)
+                (USB_DEVICE_ID_MATCH_INT_CLASS | \
+                USB_DEVICE_ID_MATCH_INT_SUBCLASS | \
+                USB_DEVICE_ID_MATCH_INT_PROTOCOL)
 
 /**
  * USB_DEVICE - macro used to describe a specific usb device
@@ -466,9 +483,11 @@ static inline int usb_make_path (struct usb_device *dev, char *buf, size_t size)
  * specific device.
  */
 #define USB_DEVICE(vend,prod) \
-        .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = (vend), .idProduct = (prod)
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = (vend), \
+                        .idProduct = (prod)
 /**
- * USB_DEVICE_VER - macro used to describe a specific usb device with a version range
+ * USB_DEVICE_VER - macro used to describe a specific usb device with a
+ *              version range
  * @vend: the 16 bit USB Vendor ID
  * @prod: the 16 bit USB Product ID
  * @lo: the bcdDevice_lo value
@@ -478,7 +497,9 @@ static inline int usb_make_path (struct usb_device *dev, char *buf, size_t size)
  * specific device, with a version range.
  */
 #define USB_DEVICE_VER(vend,prod,lo,hi) \
-        .match_flags = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION, .idVendor = (vend), .idProduct = (prod), .bcdDevice_lo = (lo), .bcdDevice_hi = (hi)
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION, \
+        .idVendor = (vend), .idProduct = (prod), \
+        .bcdDevice_lo = (lo), .bcdDevice_hi = (hi)
 
 /**
  * USB_DEVICE_INFO - macro used to describe a class of usb devices
@@ -490,7 +511,8 @@ static inline int usb_make_path (struct usb_device *dev, char *buf, size_t size)
  * specific class of devices.
  */
 #define USB_DEVICE_INFO(cl,sc,pr) \
-        .match_flags = USB_DEVICE_ID_MATCH_DEV_INFO, .bDeviceClass = (cl), .bDeviceSubClass = (sc), .bDeviceProtocol = (pr)
+        .match_flags = USB_DEVICE_ID_MATCH_DEV_INFO, .bDeviceClass = (cl), \
+        .bDeviceSubClass = (sc), .bDeviceProtocol = (pr)
 
 /**
  * USB_INTERFACE_INFO - macro used to describe a class of usb interfaces 
@@ -502,9 +524,10 @@ static inline int usb_make_path (struct usb_device *dev, char *buf, size_t size)
  * specific class of interfaces.
  */
 #define USB_INTERFACE_INFO(cl,sc,pr) \
-        .match_flags = USB_DEVICE_ID_MATCH_INT_INFO, .bInterfaceClass = (cl), .bInterfaceSubClass = (sc), .bInterfaceProtocol = (pr)
+        .match_flags = USB_DEVICE_ID_MATCH_INT_INFO, .bInterfaceClass = (cl), \
+        .bInterfaceSubClass = (sc), .bInterfaceProtocol = (pr)
 
-/* -------------------------------------------------------------------------- */
+/* ----------------------------------------------------------------------- */
 
 /**
  * struct usb_driver - identifies USB driver to usbcore
@@ -557,7 +580,8 @@ struct usb_driver {
 
         void (*disconnect) (struct usb_interface *intf);
 
-        int (*ioctl) (struct usb_interface *intf, unsigned int code, void *buf);
+        int (*ioctl) (struct usb_interface *intf, unsigned int code,
+                        void *buf);
 
         int (*suspend) (struct usb_interface *intf, pm_message_t message);
         int (*resume) (struct usb_interface *intf);
@@ -572,10 +596,8 @@ extern struct bus_type usb_bus_type;
 
 /**
  * struct usb_class_driver - identifies a USB driver that wants to use the USB major number
- * @name: devfs name for this driver.  Will also be used by the driver
- *      class code to create a usb class device.
+ * @name: the usb class device name for this driver.  Will show up in sysfs.
  * @fops: pointer to the struct file_operations of this driver.
- * @mode: the mode for the devfs file to be created for this driver.
  * @minor_base: the start of the minor range for this driver.
  *
  * This structure is used for the usb_register_dev() and
@@ -585,8 +607,7 @@ extern struct bus_type usb_bus_type;
 struct usb_class_driver {
         char *name;
         struct file_operations *fops;
-        mode_t mode;
-        int minor_base; 
+        int minor_base;
 };
 
 /*
@@ -603,7 +624,7 @@ extern void usb_deregister_dev(struct usb_interface *intf,
 
 extern int usb_disabled(void);
 
-/* -------------------------------------------------------------------------- */
+/* ----------------------------------------------------------------------- */
 
 /*
  * URB support, for asynchronous request completions
@@ -613,12 +634,14 @@ extern int usb_disabled(void);
  * urb->transfer_flags:
  */
 #define URB_SHORT_NOT_OK        0x0001  /* report short reads as errors */
-#define URB_ISO_ASAP            0x0002  /* iso-only, urb->start_frame ignored */
+#define URB_ISO_ASAP            0x0002  /* iso-only, urb->start_frame
+                                         * ignored */
 #define URB_NO_TRANSFER_DMA_MAP 0x0004  /* urb->transfer_dma valid on submit */
 #define URB_NO_SETUP_DMA_MAP    0x0008  /* urb->setup_dma valid on submit */
 #define URB_NO_FSBR             0x0020  /* UHCI-specific */
-#define URB_ZERO_PACKET         0x0040  /* Finish bulk OUTs with short packet */
-#define URB_NO_INTERRUPT        0x0080  /* HINT: no non-error interrupt needed */
+#define URB_ZERO_PACKET         0x0040  /* Finish bulk OUT with short packet */
+#define URB_NO_INTERRUPT        0x0080  /* HINT: no non-error interrupt
+                                         * needed */
 
 struct usb_iso_packet_descriptor {
         unsigned int offset;
@@ -797,7 +820,7 @@ typedef void (*usb_complete_t)(struct urb *, struct pt_regs *);
  */
 struct urb
 {
-        /* private, usb core and host controller only fields in the urb */
+        /* private: usb core and host controller only fields in the urb */
         struct kref kref;               /* reference count of the URB */
         spinlock_t lock;                /* lock for the URB */
         void *hcpriv;                   /* private data for host controller */
@@ -805,8 +828,9 @@ struct urb
         atomic_t use_count;             /* concurrent submissions counter */
         u8 reject;                      /* submissions will fail */
 
-        /* public, documented fields in the urb that can be used by drivers */
-        struct list_head urb_list;      /* list head for use by the urb owner */
+        /* public: documented fields in the urb that can be used by drivers */
+        struct list_head urb_list;      /* list head for use by the urb's
+                                         * current owner */
         struct usb_device *dev;         /* (in) pointer to associated device */
         unsigned int pipe;              /* (in) pipe information */
         int status;                     /* (return) non-ISO status */
@@ -819,14 +843,16 @@ struct urb
         dma_addr_t setup_dma;           /* (in) dma addr for setup_packet */
         int start_frame;                /* (modify) start frame (ISO) */
         int number_of_packets;          /* (in) number of ISO packets */
-        int interval;                   /* (modify) transfer interval (INT/ISO) */
+        int interval;                   /* (modify) transfer interval
+                                         * (INT/ISO) */
         int error_count;                /* (return) number of ISO errors */
         void *context;                  /* (in) context for completion */
         usb_complete_t complete;        /* (in) completion routine */
-        struct usb_iso_packet_descriptor iso_frame_desc[0];     /* (in) ISO ONLY */
+        struct usb_iso_packet_descriptor iso_frame_desc[0];
+                                        /* (in) ISO ONLY */
 };
 
-/* -------------------------------------------------------------------------- */
+/* ----------------------------------------------------------------------- */
 
 /**
  * usb_fill_control_urb - initializes a control urb
@@ -933,17 +959,17 @@ static inline void usb_fill_int_urb (struct urb *urb,
 }
 
 extern void usb_init_urb(struct urb *urb);
-extern struct urb *usb_alloc_urb(int iso_packets, unsigned mem_flags);
+extern struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags);
 extern void usb_free_urb(struct urb *urb);
 #define usb_put_urb usb_free_urb
 extern struct urb *usb_get_urb(struct urb *urb);
-extern int usb_submit_urb(struct urb *urb, unsigned mem_flags);
+extern int usb_submit_urb(struct urb *urb, gfp_t mem_flags);
 extern int usb_unlink_urb(struct urb *urb);
 extern void usb_kill_urb(struct urb *urb);
 
 #define HAVE_USB_BUFFERS
 void *usb_buffer_alloc (struct usb_device *dev, size_t size,
-        unsigned mem_flags, dma_addr_t *dma);
+        gfp_t mem_flags, dma_addr_t *dma);
 void usb_buffer_free (struct usb_device *dev, size_t size,
         void *addr, dma_addr_t dma);
 
@@ -974,11 +1000,6 @@ extern int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,
         void *data, int len, int *actual_length,
         int timeout);
 
-/* selective suspend/resume */
-extern int usb_suspend_device(struct usb_device *dev, pm_message_t message);
-extern int usb_resume_device(struct usb_device *dev);
-
-
 /* wrappers around usb_control_msg() for the most common standard requests */
 extern int usb_get_descriptor(struct usb_device *dev, unsigned char desctype,
         unsigned char descindex, void *buf, int size);
@@ -1025,7 +1046,7 @@ struct usb_sg_request {
         size_t                  bytes;
 
         /* 
-         * members below are private to usbcore,
+         * members below are private: to usbcore,
          * and are not provided for driver access!
          */
         spinlock_t              lock;
@@ -1050,13 +1071,13 @@ int usb_sg_init (
         struct scatterlist      *sg,
         int                     nents,
         size_t                  length,
-        unsigned                mem_flags
+        gfp_t                   mem_flags
 );
 void usb_sg_cancel (struct usb_sg_request *io);
 void usb_sg_wait (struct usb_sg_request *io);
 
 
-/* -------------------------------------------------------------------------- */
+/* ----------------------------------------------------------------------- */
 
 /*
  * For various legacy reasons, Linux has a small cookie that's paired with
@@ -1097,23 +1118,34 @@ void usb_sg_wait (struct usb_sg_request *io);
 /* The D0/D1 toggle bits ... USE WITH CAUTION (they're almost hcd-internal) */
 #define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> (ep)) & 1)
 #define usb_dotoggle(dev, ep, out)  ((dev)->toggle[out] ^= (1 << (ep)))
-#define usb_settoggle(dev, ep, out, bit) ((dev)->toggle[out] = ((dev)->toggle[out] & ~(1 << (ep))) | ((bit) << (ep)))
+#define usb_settoggle(dev, ep, out, bit) \
+                ((dev)->toggle[out] = ((dev)->toggle[out] & ~(1 << (ep))) | \
+                 ((bit) << (ep)))
 
 
-static inline unsigned int __create_pipe(struct usb_device *dev, unsigned int endpoint)
+static inline unsigned int __create_pipe(struct usb_device *dev,
+                unsigned int endpoint)
 {
         return (dev->devnum << 8) | (endpoint << 15);
 }
 
 /* Create various pipes... */
-#define usb_sndctrlpipe(dev,endpoint)   ((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint))
-#define usb_rcvctrlpipe(dev,endpoint)   ((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
-#define usb_sndisocpipe(dev,endpoint)   ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev,endpoint))
-#define usb_rcvisocpipe(dev,endpoint)   ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
-#define usb_sndbulkpipe(dev,endpoint)   ((PIPE_BULK << 30) | __create_pipe(dev,endpoint))
-#define usb_rcvbulkpipe(dev,endpoint)   ((PIPE_BULK << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
-#define usb_sndintpipe(dev,endpoint)    ((PIPE_INTERRUPT << 30) | __create_pipe(dev,endpoint))
-#define usb_rcvintpipe(dev,endpoint)    ((PIPE_INTERRUPT << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
+#define usb_sndctrlpipe(dev,endpoint)   \
+        ((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint))
+#define usb_rcvctrlpipe(dev,endpoint)   \
+        ((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
+#define usb_sndisocpipe(dev,endpoint)   \
+        ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev,endpoint))
+#define usb_rcvisocpipe(dev,endpoint)   \
+        ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
+#define usb_sndbulkpipe(dev,endpoint)   \
+        ((PIPE_BULK << 30) | __create_pipe(dev,endpoint))
+#define usb_rcvbulkpipe(dev,endpoint)   \
+        ((PIPE_BULK << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
+#define usb_sndintpipe(dev,endpoint)    \
+        ((PIPE_INTERRUPT << 30) | __create_pipe(dev,endpoint))
+#define usb_rcvintpipe(dev,endpoint)    \
+        ((PIPE_INTERRUPT << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
 
 /*-------------------------------------------------------------------------*/
 
@@ -1137,17 +1169,29 @@ usb_maxpacket(struct usb_device *udev, int pipe, int is_out)
         return le16_to_cpu(ep->desc.wMaxPacketSize);
 }
 
-/* -------------------------------------------------------------------------- */
+/* ----------------------------------------------------------------------- */
+
+/* Events from the usb core */
+#define USB_DEVICE_ADD          0x0001
+#define USB_DEVICE_REMOVE       0x0002
+#define USB_BUS_ADD             0x0003
+#define USB_BUS_REMOVE          0x0004
+extern void usb_register_notify(struct notifier_block *nb);
+extern void usb_unregister_notify(struct notifier_block *nb);
 
 #ifdef DEBUG
-#define dbg(format, arg...) printk(KERN_DEBUG "%s: " format "\n" , __FILE__ , ## arg)
+#define dbg(format, arg...) printk(KERN_DEBUG "%s: " format "\n" , \
+        __FILE__ , ## arg)
 #else
 #define dbg(format, arg...) do {} while (0)
 #endif
 
-#define err(format, arg...) printk(KERN_ERR "%s: " format "\n" , __FILE__ , ## arg)
-#define info(format, arg...) printk(KERN_INFO "%s: " format "\n" , __FILE__ , ## arg)
-#define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n" , __FILE__ , ## arg)
+#define err(format, arg...) printk(KERN_ERR "%s: " format "\n" , \
+        __FILE__ , ## arg)
+#define info(format, arg...) printk(KERN_INFO "%s: " format "\n" , \
+        __FILE__ , ## arg)
+#define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n" , \
+        __FILE__ , ## arg)
 
 
 #endif  /* __KERNEL__ */
diff --git a/include/linux/usb_gadget.h b/include/linux/usb_gadget.h
index 71e608607324..ff81117eb733 100644
--- a/include/linux/usb_gadget.h
+++ b/include/linux/usb_gadget.h
@@ -107,18 +107,18 @@ struct usb_ep_ops {
         int (*disable) (struct usb_ep *ep);
 
         struct usb_request *(*alloc_request) (struct usb_ep *ep,
-                unsigned gfp_flags);
+                gfp_t gfp_flags);
         void (*free_request) (struct usb_ep *ep, struct usb_request *req);
 
         void *(*alloc_buffer) (struct usb_ep *ep, unsigned bytes,
-                dma_addr_t *dma, unsigned gfp_flags);
+                dma_addr_t *dma, gfp_t gfp_flags);
         void (*free_buffer) (struct usb_ep *ep, void *buf, dma_addr_t dma,
                 unsigned bytes);
         // NOTE:  on 2.6, drivers may also use dma_map() and
         // dma_sync_single_*() to directly manage dma overhead. 
 
         int (*queue) (struct usb_ep *ep, struct usb_request *req,
-                unsigned gfp_flags);
+                gfp_t gfp_flags);
         int (*dequeue) (struct usb_ep *ep, struct usb_request *req);
 
         int (*set_halt) (struct usb_ep *ep, int value);
@@ -214,7 +214,7 @@ usb_ep_disable (struct usb_ep *ep)
  * Returns the request, or null if one could not be allocated.
  */
 static inline struct usb_request *
-usb_ep_alloc_request (struct usb_ep *ep, unsigned gfp_flags)
+usb_ep_alloc_request (struct usb_ep *ep, gfp_t gfp_flags)
 {
         return ep->ops->alloc_request (ep, gfp_flags);
 }
@@ -254,7 +254,7 @@ usb_ep_free_request (struct usb_ep *ep, struct usb_request *req)
  */
 static inline void *
 usb_ep_alloc_buffer (struct usb_ep *ep, unsigned len, dma_addr_t *dma,
-        unsigned gfp_flags)
+        gfp_t gfp_flags)
 {
         return ep->ops->alloc_buffer (ep, len, dma, gfp_flags);
 }
@@ -330,7 +330,7 @@ usb_ep_free_buffer (struct usb_ep *ep, void *buf, dma_addr_t dma, unsigned len)
  * reported when the usb peripheral is disconnected.
  */
 static inline int
-usb_ep_queue (struct usb_ep *ep, struct usb_request *req, unsigned gfp_flags)
+usb_ep_queue (struct usb_ep *ep, struct usb_request *req, gfp_t gfp_flags)
 {
         return ep->ops->queue (ep, req, gfp_flags);
 }
diff --git a/include/linux/usb_otg.h b/include/linux/usb_otg.h
index c6683146e9b0..f827f6e203c2 100644
--- a/include/linux/usb_otg.h
+++ b/include/linux/usb_otg.h
@@ -63,6 +63,10 @@ struct otg_transceiver {
         int     (*set_power)(struct otg_transceiver *otg,
                                 unsigned mA);
 
+        /* for non-OTG B devices: set transceiver into suspend mode */
+        int     (*set_suspend)(struct otg_transceiver *otg,
+                                int suspend);
+
         /* for B devices only:  start session with A-Host */
         int     (*start_srp)(struct otg_transceiver *otg);
 
@@ -108,6 +112,15 @@ otg_set_power(struct otg_transceiver *otg, unsigned mA)
 }
 
 static inline int
+otg_set_suspend(struct otg_transceiver *otg, int suspend)
+{
+        if (otg->set_suspend != NULL)
+                return otg->set_suspend(otg, suspend);
+        else
+                return 0;
+}
+
+static inline int
 otg_start_srp(struct otg_transceiver *otg)
 {
         return otg->start_srp(otg);
diff --git a/include/linux/usbdevice_fs.h b/include/linux/usbdevice_fs.h
index 9facf733800c..8859f0b41543 100644
--- a/include/linux/usbdevice_fs.h
+++ b/include/linux/usbdevice_fs.h
@@ -140,6 +140,12 @@ struct usbdevfs_urb32 {
         compat_caddr_t usercontext; /* unused */
         struct usbdevfs_iso_packet_desc iso_frame_desc[0];
 };
+
+struct usbdevfs_ioctl32 {
+        s32 ifno;
+        s32 ioctl_code;
+        compat_caddr_t data;
+};
 #endif
 
 #define USBDEVFS_CONTROL           _IOWR('U', 0, struct usbdevfs_ctrltransfer)
@@ -160,6 +166,7 @@ struct usbdevfs_urb32 {
 #define USBDEVFS_RELEASEINTERFACE  _IOR('U', 16, unsigned int)
 #define USBDEVFS_CONNECTINFO       _IOW('U', 17, struct usbdevfs_connectinfo)
 #define USBDEVFS_IOCTL             _IOWR('U', 18, struct usbdevfs_ioctl)
+#define USBDEVFS_IOCTL32           _IOWR('U', 18, struct usbdevfs_ioctl32)
 #define USBDEVFS_HUB_PORTINFO      _IOR('U', 19, struct usbdevfs_hub_portinfo)
 #define USBDEVFS_RESET             _IO('U', 20)
 #define USBDEVFS_CLEAR_HALT        _IOR('U', 21, unsigned int)
diff --git a/include/linux/videodev.h b/include/linux/videodev.h
index 1cc8c31b7988..91140091ced2 100644
--- a/include/linux/videodev.h
+++ b/include/linux/videodev.h
@@ -1,57 +1,16 @@
 #ifndef __LINUX_VIDEODEV_H
 #define __LINUX_VIDEODEV_H
 
-#include <linux/compiler.h>
 #include <linux/types.h>
 
-#define HAVE_V4L2 1
+#define HAVE_V4L1 1
+
 #include <linux/videodev2.h>
 
 #ifdef __KERNEL__
 
-#include <linux/poll.h>
 #include <linux/mm.h>
-#include <linux/device.h>
-
-struct video_device
-{
-        /* device info */
-        struct device *dev;
-        char name[32];
-        int type;       /* v4l1 */
-        int type2;      /* v4l2 */
-        int hardware;
-        int minor;
-
-        /* device ops + callbacks */
-        struct file_operations *fops;
-        void (*release)(struct video_device *vfd);
-
-
-        /* obsolete -- fops->owner is used instead */
-        struct module *owner;
-        /* dev->driver_data will be used instead some day.
-         * Use the video_{get|set}_drvdata() helper functions,
-         * so the switch over will be transparent for you.
-         * Or use {pci|usb}_{get|set}_drvdata() directly. */
-        void *priv;
-
-        /* for videodev.c intenal usage -- please don't touch */
-        int users;                     /* video_exclusive_{open|close} ... */
-        struct semaphore lock;         /* ... helper function uses these   */
-        char devfs_name[64];           /* devfs */
-        struct class_device class_dev; /* sysfs */
-};
-
-#define VIDEO_MAJOR     81
-
-#define VFL_TYPE_GRABBER        0
-#define VFL_TYPE_VBI            1
-#define VFL_TYPE_RADIO          2
-#define VFL_TYPE_VTX            3
 
-extern int video_register_device(struct video_device *, int type, int nr);
-extern void video_unregister_device(struct video_device *);
 extern struct video_device* video_devdata(struct file*);
 
 #define to_video_device(cd) container_of(cd, struct video_device, class_dev)
@@ -68,11 +27,7 @@ video_device_remove_file(struct video_device *vfd,
         class_device_remove_file(&vfd->class_dev, attr);
 }
 
-/* helper functions to alloc / release struct video_device, the
-   later can be used for video_device->release() */
-struct video_device *video_device_alloc(void);
-void video_device_release(struct video_device *vfd);
-
+#if OBSOLETE_OWNER /* to be removed in 2.6.15 */
 /* helper functions to access driver private data. */
 static inline void *video_get_drvdata(struct video_device *dev)
 {
@@ -83,30 +38,12 @@ static inline void video_set_drvdata(struct video_device *dev, void *data)
 {
         dev->priv = data;
 }
+#endif
 
 extern int video_exclusive_open(struct inode *inode, struct file *file);
 extern int video_exclusive_release(struct inode *inode, struct file *file);
-extern int video_usercopy(struct inode *inode, struct file *file,
-                          unsigned int cmd, unsigned long arg,
-                          int (*func)(struct inode *inode, struct file *file,
-                                      unsigned int cmd, void *arg));
 #endif /* __KERNEL__ */
 
-#define VID_TYPE_CAPTURE        1       /* Can capture */
-#define VID_TYPE_TUNER          2       /* Can tune */
-#define VID_TYPE_TELETEXT       4       /* Does teletext */
-#define VID_TYPE_OVERLAY        8       /* Overlay onto frame buffer */
-#define VID_TYPE_CHROMAKEY      16      /* Overlay by chromakey */
-#define VID_TYPE_CLIPPING       32      /* Can clip */
-#define VID_TYPE_FRAMERAM       64      /* Uses the frame buffer memory */
-#define VID_TYPE_SCALES         128     /* Scalable */
-#define VID_TYPE_MONOCHROME     256     /* Monochrome only */
-#define VID_TYPE_SUBCAPTURE     512     /* Can capture subareas of the image */
-#define VID_TYPE_MPEG_DECODER   1024    /* Can decode MPEG streams */
-#define VID_TYPE_MPEG_ENCODER   2048    /* Can encode MPEG streams */
-#define VID_TYPE_MJPEG_DECODER  4096    /* Can decode MJPEG streams */
-#define VID_TYPE_MJPEG_ENCODER  8192    /* Can encode MJPEG streams */
-
 struct video_capability
 {
         char name[32];
@@ -202,9 +139,9 @@ struct video_audio
 #define VIDEO_SOUND_STEREO      2
 #define VIDEO_SOUND_LANG1       4
 #define VIDEO_SOUND_LANG2       8
-        __u16   mode;
-        __u16   balance;        /* Stereo balance */
-        __u16   step;           /* Step actual volume uses */
+        __u16   mode;
+        __u16   balance;        /* Stereo balance */
+        __u16   step;           /* Step actual volume uses */
 };
 
 struct video_clip
@@ -260,9 +197,6 @@ struct video_key
         __u32   flags;
 };
 
-
-#define VIDEO_MAX_FRAME         32
-
 struct video_mbuf
 {
         int     size;           /* Total memory to map */
@@ -270,10 +204,8 @@ struct video_mbuf
         int     offsets[VIDEO_MAX_FRAME];
 };
 
-
 #define         VIDEO_NO_UNIT   (-1)
 
-
 struct video_unit
 {
         int     video;          /* Video minor */
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 89a055761bed..1cded681eb6d 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -15,16 +15,99 @@
  */
 #ifdef __KERNEL__
 #include <linux/time.h> /* need struct timeval */
+#include <linux/poll.h>
+#include <linux/device.h>
 #endif
 #include <linux/compiler.h> /* need __user */
 
+
+#define OBSOLETE_OWNER 1 /* It will be removed for 2.6.15 */
+#define HAVE_V4L2 1
+
+/*
+ * Common stuff for both V4L1 and V4L2
+ * Moved from videodev.h
+ */
+
+#define VIDEO_MAX_FRAME               32
+
+#define VID_TYPE_CAPTURE        1       /* Can capture */
+#define VID_TYPE_TUNER          2       /* Can tune */
+#define VID_TYPE_TELETEXT       4       /* Does teletext */
+#define VID_TYPE_OVERLAY        8       /* Overlay onto frame buffer */
+#define VID_TYPE_CHROMAKEY      16      /* Overlay by chromakey */
+#define VID_TYPE_CLIPPING       32      /* Can clip */
+#define VID_TYPE_FRAMERAM       64      /* Uses the frame buffer memory */
+#define VID_TYPE_SCALES         128     /* Scalable */
+#define VID_TYPE_MONOCHROME     256     /* Monochrome only */
+#define VID_TYPE_SUBCAPTURE     512     /* Can capture subareas of the image */
+#define VID_TYPE_MPEG_DECODER   1024    /* Can decode MPEG streams */
+#define VID_TYPE_MPEG_ENCODER   2048    /* Can encode MPEG streams */
+#define VID_TYPE_MJPEG_DECODER  4096    /* Can decode MJPEG streams */
+#define VID_TYPE_MJPEG_ENCODER  8192    /* Can encode MJPEG streams */
+
+#ifdef __KERNEL__
+
+#define VFL_TYPE_GRABBER        0
+#define VFL_TYPE_VBI            1
+#define VFL_TYPE_RADIO          2
+#define VFL_TYPE_VTX            3
+
+struct video_device
+{
+        /* device info */
+        struct device *dev;
+        char name[32];
+        int type;       /* v4l1 */
+        int type2;      /* v4l2 */
+        int hardware;
+        int minor;
+
+        /* device ops + callbacks */
+        struct file_operations *fops;
+        void (*release)(struct video_device *vfd);
+
+
+#if OBSOLETE_OWNER /* to be removed in 2.6.15 */
+        /* obsolete -- fops->owner is used instead */
+        struct module *owner;
+        /* dev->driver_data will be used instead some day.
+         * Use the video_{get|set}_drvdata() helper functions,
+         * so the switch over will be transparent for you.
+         * Or use {pci|usb}_{get|set}_drvdata() directly. */
+        void *priv;
+#endif
+
+        /* for videodev.c intenal usage -- please don't touch */
+        int users;                     /* video_exclusive_{open|close} ... */
+        struct semaphore lock;         /* ... helper function uses these   */
+        char devfs_name[64];           /* devfs */
+        struct class_device class_dev; /* sysfs */
+};
+
+#define VIDEO_MAJOR     81
+
+extern int video_register_device(struct video_device *, int type, int nr);
+extern void video_unregister_device(struct video_device *);
+extern int video_usercopy(struct inode *inode, struct file *file,
+                          unsigned int cmd, unsigned long arg,
+                          int (*func)(struct inode *inode, struct file *file,
+                                      unsigned int cmd, void *arg));
+
+/* helper functions to alloc / release struct video_device, the
+   later can be used for video_device->release() */
+struct video_device *video_device_alloc(void);
+void video_device_release(struct video_device *vfd);
+
+#endif
+
 /*
  *      M I S C E L L A N E O U S
  */
 
 /*  Four-character-code (FOURCC) */
 #define v4l2_fourcc(a,b,c,d)\
-        (((__u32)(a)<<0)|((__u32)(b)<<8)|((__u32)(c)<<16)|((__u32)(d)<<24))
+        (((__u32)(a)<<0)|((__u32)(b)<<8)|((__u32)(c)<<16)|((__u32)(d)<<24))
 
 /*
  *      E N U M S
@@ -154,20 +237,20 @@ struct v4l2_capability
 };
 
 /* Values for 'capabilities' field */
-#define V4L2_CAP_VIDEO_CAPTURE          0x00000001  /* Is a video capture device */
-#define V4L2_CAP_VIDEO_OUTPUT           0x00000002  /* Is a video output device */
-#define V4L2_CAP_VIDEO_OVERLAY          0x00000004  /* Can do video overlay */
-#define V4L2_CAP_VBI_CAPTURE            0x00000010  /* Is a raw VBI capture device */
-#define V4L2_CAP_VBI_OUTPUT             0x00000020  /* Is a raw VBI output device */
+#define V4L2_CAP_VIDEO_CAPTURE          0x00000001  /* Is a video capture device */
+#define V4L2_CAP_VIDEO_OUTPUT           0x00000002  /* Is a video output device */
+#define V4L2_CAP_VIDEO_OVERLAY          0x00000004  /* Can do video overlay */
+#define V4L2_CAP_VBI_CAPTURE            0x00000010  /* Is a raw VBI capture device */
+#define V4L2_CAP_VBI_OUTPUT             0x00000020  /* Is a raw VBI output device */
 #if 1
 #define V4L2_CAP_SLICED_VBI_CAPTURE     0x00000040  /* Is a sliced VBI capture device */
 #define V4L2_CAP_SLICED_VBI_OUTPUT      0x00000080  /* Is a sliced VBI output device */
 #endif
-#define V4L2_CAP_RDS_CAPTURE            0x00000100  /* RDS data capture */
+#define V4L2_CAP_RDS_CAPTURE            0x00000100  /* RDS data capture */
 
-#define V4L2_CAP_TUNER                  0x00010000  /* has a tuner */
-#define V4L2_CAP_AUDIO                  0x00020000  /* has audio support */
-#define V4L2_CAP_RADIO                  0x00040000  /* is a radio device */
+#define V4L2_CAP_TUNER                  0x00010000  /* has a tuner */
+#define V4L2_CAP_AUDIO                  0x00020000  /* has audio support */
+#define V4L2_CAP_RADIO                  0x00040000  /* is a radio device */
 
 #define V4L2_CAP_READWRITE              0x01000000  /* read/write systemcalls */
 #define V4L2_CAP_ASYNCIO                0x02000000  /* async I/O */
@@ -179,13 +262,13 @@ struct v4l2_capability
 
 struct v4l2_pix_format
 {
-        __u32                   width;
-        __u32                   height;
-        __u32                   pixelformat;
+        __u32                   width;
+        __u32                   height;
+        __u32                   pixelformat;
         enum v4l2_field         field;
         __u32                   bytesperline;   /* for padding, zero if unused */
-        __u32                   sizeimage;
-        enum v4l2_colorspace    colorspace;
+        __u32                   sizeimage;
+        enum v4l2_colorspace    colorspace;
         __u32                   priv;           /* private data, depends on pixelformat */
 };
 
@@ -238,12 +321,12 @@ struct v4l2_pix_format
  */
 struct v4l2_fmtdesc
 {
-        __u32               index;             /* Format number      */
+        __u32               index;             /* Format number      */
         enum v4l2_buf_type  type;              /* buffer type        */
         __u32               flags;
-        __u8                description[32];   /* Description string */
-        __u32               pixelformat;       /* Format fourcc      */
-        __u32               reserved[4];
+        __u8                description[32];   /* Description string */
+        __u32               pixelformat;       /* Format fourcc      */
+        __u32               reserved[4];
 };
 
 #define V4L2_FMT_FLAG_COMPRESSED 0x0001
@@ -393,7 +476,7 @@ struct v4l2_jpegcompression
 #define V4L2_JPEG_MARKER_DRI (1<<5)    /* Define Restart Interval */
 #define V4L2_JPEG_MARKER_COM (1<<6)    /* Comment segment */
 #define V4L2_JPEG_MARKER_APP (1<<7)    /* App segment, driver will
-                                        * allways use APP0 */
+                                        * allways use APP0 */
 };
 
 
@@ -402,10 +485,10 @@ struct v4l2_jpegcompression
  */
 struct v4l2_requestbuffers
 {
-        __u32                   count;
+        __u32                   count;
         enum v4l2_buf_type      type;
         enum v4l2_memory        memory;
-        __u32                   reserved[2];
+        __u32                   reserved[2];
 };
 
 struct v4l2_buffer
@@ -511,9 +594,9 @@ struct v4l2_outputparm
 
 struct v4l2_cropcap {
         enum v4l2_buf_type      type;
-        struct v4l2_rect        bounds;
-        struct v4l2_rect        defrect;
-        struct v4l2_fract       pixelaspect;
+        struct v4l2_rect        bounds;
+        struct v4l2_rect        defrect;
+        struct v4l2_fract       pixelaspect;
 };
 
 struct v4l2_crop {
@@ -544,6 +627,7 @@ typedef __u64 v4l2_std_id;
 
 #define V4L2_STD_NTSC_M         ((v4l2_std_id)0x00001000)
 #define V4L2_STD_NTSC_M_JP      ((v4l2_std_id)0x00002000)
+#define V4L2_STD_NTSC_443       ((v4l2_std_id)0x00004000)
 
 #define V4L2_STD_SECAM_B        ((v4l2_std_id)0x00010000)
 #define V4L2_STD_SECAM_D        ((v4l2_std_id)0x00020000)
@@ -552,6 +636,7 @@ typedef __u64 v4l2_std_id;
 #define V4L2_STD_SECAM_K        ((v4l2_std_id)0x00100000)
 #define V4L2_STD_SECAM_K1       ((v4l2_std_id)0x00200000)
 #define V4L2_STD_SECAM_L        ((v4l2_std_id)0x00400000)
+#define V4L2_STD_SECAM_LC       ((v4l2_std_id)0x00800000)
 
 /* ATSC/HDTV */
 #define V4L2_STD_ATSC_8_VSB     ((v4l2_std_id)0x01000000)
@@ -581,13 +666,14 @@ typedef __u64 v4l2_std_id;
 
 #define V4L2_STD_525_60         (V4L2_STD_PAL_M         |\
                                  V4L2_STD_PAL_60        |\
-                                 V4L2_STD_NTSC)
+                                 V4L2_STD_NTSC          |\
+                                 V4L2_STD_NTSC_443)
 #define V4L2_STD_625_50         (V4L2_STD_PAL           |\
                                  V4L2_STD_PAL_N         |\
                                  V4L2_STD_PAL_Nc        |\
                                  V4L2_STD_SECAM)
 #define V4L2_STD_ATSC           (V4L2_STD_ATSC_8_VSB    |\
-                                 V4L2_STD_ATSC_16_VSB)
+                                 V4L2_STD_ATSC_16_VSB)
 
 #define V4L2_STD_UNKNOWN        0
 #define V4L2_STD_ALL            (V4L2_STD_525_60        |\
@@ -595,7 +681,7 @@ typedef __u64 v4l2_std_id;
 
 struct v4l2_standard
 {
-        __u32                index;
+        __u32                index;
         v4l2_std_id          id;
         __u8                 name[24];
         struct v4l2_fract    frameperiod; /* Frames, not fields */
@@ -610,9 +696,9 @@ struct v4l2_standard
 struct v4l2_input
 {
         __u32        index;             /*  Which input */
-        __u8         name[32];          /*  Label */
+        __u8         name[32];          /*  Label */
         __u32        type;              /*  Type of input */
-        __u32        audioset;          /*  Associated audios (bitfield) */
+        __u32        audioset;          /*  Associated audios (bitfield) */
         __u32        tuner;             /*  Associated tuner */
         v4l2_std_id  std;
         __u32        status;
@@ -647,9 +733,9 @@ struct v4l2_input
 struct v4l2_output
 {
         __u32        index;             /*  Which output */
-        __u8         name[32];          /*  Label */
+        __u8         name[32];          /*  Label */
         __u32        type;              /*  Type of output */
-        __u32        audioset;          /*  Associated audios (bitfield) */
+        __u32        audioset;          /*  Associated audios (bitfield) */
         __u32        modulator;         /*  Associated modulator */
         v4l2_std_id  std;
         __u32        reserved[4];
@@ -671,12 +757,12 @@ struct v4l2_control
 /*  Used in the VIDIOC_QUERYCTRL ioctl for querying controls */
 struct v4l2_queryctrl
 {
-        __u32                id;
+        __u32                id;
         enum v4l2_ctrl_type  type;
         __u8                 name[32];  /* Whatever */
         __s32                minimum;   /* Note signedness */
         __s32                maximum;
-        __s32                step;
+        __s32                step;
         __s32                default_value;
         __u32                flags;
         __u32                reserved[2];
@@ -779,10 +865,10 @@ struct v4l2_modulator
 
 struct v4l2_frequency
 {
-        __u32                 tuner;
+        __u32                 tuner;
         enum v4l2_tuner_type  type;
-        __u32                 frequency;
-        __u32                 reserved[8];
+        __u32                 frequency;
+        __u32                 reserved[8];
 };
 
 /*
@@ -802,6 +888,7 @@ struct v4l2_audio
 
 /*  Flags for the 'mode' field */
 #define V4L2_AUDMODE_AVL                0x00001
+#define V4L2_AUDMODE_32BITS             0x00002
 
 struct v4l2_audioout
 {
@@ -846,14 +933,14 @@ struct v4l2_vbi_format
 
 struct v4l2_sliced_vbi_format
 {
-        __u16   service_set;
-        /* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
-           service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
-                                 (equals frame lines 313-336 for 625 line video
-                                  standards, 263-286 for 525 line standards) */
-        __u16   service_lines[2][24];
-        __u32   io_size;
-        __u32   reserved[2];            /* must be zero */
+        __u16   service_set;
+        /* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
+           service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
+                                 (equals frame lines 313-336 for 625 line video
+                                  standards, 263-286 for 525 line standards) */
+        __u16   service_lines[2][24];
+        __u32   io_size;
+        __u32   reserved[2];            /* must be zero */
 };
 
 #define V4L2_SLICED_TELETEXT_B          (0x0001)
@@ -866,22 +953,22 @@ struct v4l2_sliced_vbi_format
 
 struct v4l2_sliced_vbi_cap
 {
-        __u16   service_set;
-        /* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
-           service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
-                                 (equals frame lines 313-336 for 625 line video
-                                  standards, 263-286 for 525 line standards) */
-        __u16   service_lines[2][24];
-        __u32   reserved[4];    /* must be 0 */
+        __u16   service_set;
+        /* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
+           service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
+                                 (equals frame lines 313-336 for 625 line video
+                                  standards, 263-286 for 525 line standards) */
+        __u16   service_lines[2][24];
+        __u32   reserved[4];    /* must be 0 */
 };
 
 struct v4l2_sliced_vbi_data
 {
-        __u32   id;
-        __u32   field;          /* 0: first field, 1: second field */
-        __u32   line;           /* 1-23 */
-        __u32   reserved;       /* must be 0 */
-        __u8    data[48];
+        __u32   id;
+        __u32   field;          /* 0: first field, 1: second field */
+        __u32   line;           /* 1-23 */
+        __u32   reserved;       /* must be 0 */
+        __u8    data[48];
 };
 #endif
 
@@ -896,9 +983,9 @@ struct v4l2_format
         enum v4l2_buf_type type;
         union
         {
-                struct v4l2_pix_format          pix;     // V4L2_BUF_TYPE_VIDEO_CAPTURE
-                struct v4l2_window              win;     // V4L2_BUF_TYPE_VIDEO_OVERLAY
-                struct v4l2_vbi_format          vbi;     // V4L2_BUF_TYPE_VBI_CAPTURE
+                struct v4l2_pix_format          pix;     // V4L2_BUF_TYPE_VIDEO_CAPTURE
+                struct v4l2_window              win;     // V4L2_BUF_TYPE_VIDEO_OVERLAY
+                struct v4l2_vbi_format          vbi;     // V4L2_BUF_TYPE_VBI_CAPTURE
 #if 1
                 struct v4l2_sliced_vbi_format   sliced;  // V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
 #endif
@@ -981,6 +1068,7 @@ struct v4l2_streamparm
 #if 1
 #define VIDIOC_G_SLICED_VBI_CAP _IOR  ('V', 69, struct v4l2_sliced_vbi_cap)
 #endif
+#define VIDIOC_LOG_STATUS       _IO   ('V', 70)
 
 /* for compatibility, will go away some day */
 #define VIDIOC_OVERLAY_OLD      _IOWR ('V', 14, int)
diff --git a/include/linux/vmalloc.h b/include/linux/vmalloc.h
index b244f69ef682..1d5577b2b752 100644
--- a/include/linux/vmalloc.h
+++ b/include/linux/vmalloc.h
@@ -32,10 +32,14 @@ struct vm_struct {
  *      Highlevel APIs for driver use
  */
 extern void *vmalloc(unsigned long size);
+extern void *vmalloc_node(unsigned long size, int node);
 extern void *vmalloc_exec(unsigned long size);
 extern void *vmalloc_32(unsigned long size);
-extern void *__vmalloc(unsigned long size, unsigned int __nocast gfp_mask, pgprot_t prot);
-extern void *__vmalloc_area(struct vm_struct *area, unsigned int __nocast gfp_mask, pgprot_t prot);
+extern void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot);
+extern void *__vmalloc_area(struct vm_struct *area, gfp_t gfp_mask,
+                                pgprot_t prot);
+extern void *__vmalloc_node(unsigned long size, gfp_t gfp_mask,
+                                pgprot_t prot, int node);
 extern void vfree(void *addr);
 
 extern void *vmap(struct page **pages, unsigned int count,
@@ -48,6 +52,8 @@ extern void vunmap(void *addr);
 extern struct vm_struct *get_vm_area(unsigned long size, unsigned long flags);
 extern struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
                                         unsigned long start, unsigned long end);
+extern struct vm_struct *get_vm_area_node(unsigned long size,
+                                        unsigned long flags, int node);
 extern struct vm_struct *remove_vm_area(void *addr);
 extern struct vm_struct *__remove_vm_area(void *addr);
 extern int map_vm_area(struct vm_struct *area, pgprot_t prot,
diff --git a/include/linux/wait.h b/include/linux/wait.h
index d38c9fecdc36..d28518236b62 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -54,6 +54,7 @@ struct __wait_queue_head {
 };
 typedef struct __wait_queue_head wait_queue_head_t;
 
+struct task_struct;
 
 /*
  * Macros for declaration and initialisaton of the datatypes
diff --git a/include/linux/wanpipe.h b/include/linux/wanpipe.h
index 167d956c492b..dae9860091dd 100644
--- a/include/linux/wanpipe.h
+++ b/include/linux/wanpipe.h
@@ -265,15 +265,6 @@ typedef struct {
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
 
-
-#define is_digit(ch) (((ch)>=(unsigned)'0'&&(ch)<=(unsigned)'9')?1:0)
-#define is_alpha(ch) ((((ch)>=(unsigned)'a'&&(ch)<=(unsigned)'z')||\
-                  ((ch)>=(unsigned)'A'&&(ch)<=(unsigned)'Z'))?1:0)
-#define is_hex_digit(ch) ((((ch)>=(unsigned)'0'&&(ch)<=(unsigned)'9')||\
-                  ((ch)>=(unsigned)'a'&&(ch)<=(unsigned)'f')||\
-                  ((ch)>=(unsigned)'A'&&(ch)<=(unsigned)'F'))?1:0)
-
-
 /****** Data Structures *****************************************************/
 
 /* Adapter Data Space.
diff --git a/include/linux/x1205.h b/include/linux/x1205.h
new file mode 100644
index 000000000000..64fd3af894a5
--- /dev/null
+++ b/include/linux/x1205.h
@@ -0,0 +1,31 @@
+/*
+ *  x1205.h - defines for drivers/i2c/chips/x1205.c
+ *  Copyright 2004 Karen Spearel
+ *  Copyright 2005 Alessandro Zummo
+ *
+ *  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 __LINUX_X1205_H__
+#define __LINUX_X1205_H__
+
+/* commands */
+
+#define X1205_CMD_GETDATETIME   0
+#define X1205_CMD_SETTIME       1
+#define X1205_CMD_SETDATETIME   2
+#define X1205_CMD_GETALARM      3
+#define X1205_CMD_SETALARM      4
+#define X1205_CMD_GETDTRIM      5
+#define X1205_CMD_SETDTRIM      6
+#define X1205_CMD_GETATRIM      7
+#define X1205_CMD_SETATRIM      8
+
+extern int x1205_do_command(unsigned int cmd, void *arg);
+extern int x1205_direct_attach(int adapter_id,
+        struct i2c_client_address_data *address_data);
+
+#endif /* __LINUX_X1205_H__ */
diff --git a/include/linux/zutil.h b/include/linux/zutil.h
index fdfd5ed41ec4..ee0c59cf2136 100644
--- a/include/linux/zutil.h
+++ b/include/linux/zutil.h
@@ -15,7 +15,6 @@
 
 #include <linux/zlib.h>
 #include <linux/string.h>
-#include <linux/errno.h>
 #include <linux/kernel.h>
 
 typedef unsigned char  uch;