Merge ../torvalds-2.6/

186 files changed, 3534 insertions, 2640 deletions

diff --git a/include/asm-alpha/spinlock.h b/include/asm-alpha/spinlock.h
index 80780dba9986..8197c69eff44 100644
--- a/include/asm-alpha/spinlock.h
+++ b/include/asm-alpha/spinlock.h
@@ -6,7 +6,6 @@
 #include <linux/kernel.h>
 #include <asm/current.h>
 
-
 /*
  * Simple spin lock operations.  There are two variants, one clears IRQ's
  * on the local processor, one does not.
@@ -14,43 +13,18 @@
  * We make no fairness assumptions. They have a cost.
  */
 
-typedef struct {
-        volatile unsigned int lock;
-#ifdef CONFIG_DEBUG_SPINLOCK
-        int on_cpu;
-        int line_no;
-        void *previous;
-        struct task_struct * task;
-        const char *base_file;
-#endif
-} spinlock_t;
-
-#ifdef CONFIG_DEBUG_SPINLOCK
-#define SPIN_LOCK_UNLOCKED      (spinlock_t){ 0, -1, 0, NULL, NULL, NULL }
-#else
-#define SPIN_LOCK_UNLOCKED      (spinlock_t){ 0 }
-#endif
-
-#define spin_lock_init(x)       do { *(x) = SPIN_LOCK_UNLOCKED; } while(0)
-#define spin_is_locked(x)       ((x)->lock != 0)
-#define spin_unlock_wait(x)     do { barrier(); } while ((x)->lock)
-
-#ifdef CONFIG_DEBUG_SPINLOCK
-extern void _raw_spin_unlock(spinlock_t * lock);
-extern void debug_spin_lock(spinlock_t * lock, const char *, int);
-extern int debug_spin_trylock(spinlock_t * lock, const char *, int);
-#define _raw_spin_lock(LOCK) \
-        debug_spin_lock(LOCK, __BASE_FILE__, __LINE__)
-#define _raw_spin_trylock(LOCK) \
-        debug_spin_trylock(LOCK, __BASE_FILE__, __LINE__)
-#else
-static inline void _raw_spin_unlock(spinlock_t * lock)
+#define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)
+#define __raw_spin_is_locked(x) ((x)->lock != 0)
+#define __raw_spin_unlock_wait(x) \
+                do { cpu_relax(); } while ((x)->lock)
+
+static inline void __raw_spin_unlock(raw_spinlock_t * lock)
 {
         mb();
         lock->lock = 0;
 }
 
-static inline void _raw_spin_lock(spinlock_t * lock)
+static inline void __raw_spin_lock(raw_spinlock_t * lock)
 {
         long tmp;
 
@@ -70,80 +44,64 @@ static inline void _raw_spin_lock(spinlock_t * lock)
         : "m"(lock->lock) : "memory");
 }
 
-static inline int _raw_spin_trylock(spinlock_t *lock)
+static inline int __raw_spin_trylock(raw_spinlock_t *lock)
 {
         return !test_and_set_bit(0, &lock->lock);
 }
-#endif /* CONFIG_DEBUG_SPINLOCK */
-
-#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
 
 /***********************************************************/
 
-typedef struct {
-        volatile unsigned int lock;
-} rwlock_t;
-
-#define RW_LOCK_UNLOCKED        (rwlock_t){ 0 }
-
-#define rwlock_init(x)          do { *(x) = RW_LOCK_UNLOCKED; } while(0)
-
-static inline int read_can_lock(rwlock_t *lock)
+static inline int __raw_read_can_lock(raw_rwlock_t *lock)
 {
         return (lock->lock & 1) == 0;
 }
 
-static inline int write_can_lock(rwlock_t *lock)
+static inline int __raw_write_can_lock(raw_rwlock_t *lock)
 {
         return lock->lock == 0;
 }
 
-#ifdef CONFIG_DEBUG_RWLOCK
-extern void _raw_write_lock(rwlock_t * lock);
-extern void _raw_read_lock(rwlock_t * lock);
-#else
-static inline void _raw_write_lock(rwlock_t * lock)
+static inline void __raw_read_lock(raw_rwlock_t *lock)
 {
         long regx;
 
         __asm__ __volatile__(
         "1:     ldl_l   %1,%0\n"
-        "       bne     %1,6f\n"
-        "       lda     %1,1\n"
+        "       blbs    %1,6f\n"
+        "       subl    %1,2,%1\n"
         "       stl_c   %1,%0\n"
         "       beq     %1,6f\n"
         "       mb\n"
         ".subsection 2\n"
         "6:     ldl     %1,%0\n"
-        "       bne     %1,6b\n"
+        "       blbs    %1,6b\n"
         "       br      1b\n"
         ".previous"
         : "=m" (*lock), "=&r" (regx)
         : "m" (*lock) : "memory");
 }
 
-static inline void _raw_read_lock(rwlock_t * lock)
+static inline void __raw_write_lock(raw_rwlock_t *lock)
 {
         long regx;
 
         __asm__ __volatile__(
         "1:     ldl_l   %1,%0\n"
-        "       blbs    %1,6f\n"
-        "       subl    %1,2,%1\n"
+        "       bne     %1,6f\n"
+        "       lda     %1,1\n"
         "       stl_c   %1,%0\n"
         "       beq     %1,6f\n"
         "       mb\n"
         ".subsection 2\n"
         "6:     ldl     %1,%0\n"
-        "       blbs    %1,6b\n"
+        "       bne     %1,6b\n"
         "       br      1b\n"
         ".previous"
         : "=m" (*lock), "=&r" (regx)
         : "m" (*lock) : "memory");
 }
-#endif /* CONFIG_DEBUG_RWLOCK */
 
-static inline int _raw_read_trylock(rwlock_t * lock)
+static inline int __raw_read_trylock(raw_rwlock_t * lock)
 {
         long regx;
         int success;
@@ -165,7 +123,7 @@ static inline int _raw_read_trylock(rwlock_t * lock)
         return success;
 }
 
-static inline int _raw_write_trylock(rwlock_t * lock)
+static inline int __raw_write_trylock(raw_rwlock_t * lock)
 {
         long regx;
         int success;
@@ -187,13 +145,7 @@ static inline int _raw_write_trylock(rwlock_t * lock)
         return success;
 }
 
-static inline void _raw_write_unlock(rwlock_t * lock)
-{
-        mb();
-        lock->lock = 0;
-}
-
-static inline void _raw_read_unlock(rwlock_t * lock)
+static inline void __raw_read_unlock(raw_rwlock_t * lock)
 {
         long regx;
         __asm__ __volatile__(
@@ -209,4 +161,10 @@ static inline void _raw_read_unlock(rwlock_t * lock)
         : "m" (*lock) : "memory");
 }
 
+static inline void __raw_write_unlock(raw_rwlock_t * lock)
+{
+        mb();
+        lock->lock = 0;
+}
+
 #endif /* _ALPHA_SPINLOCK_H */
diff --git a/include/asm-alpha/spinlock_types.h b/include/asm-alpha/spinlock_types.h
new file mode 100644
index 000000000000..8141eb5ebf0d
--- /dev/null
+++ b/include/asm-alpha/spinlock_types.h
@@ -0,0 +1,20 @@
+#ifndef _ALPHA_SPINLOCK_TYPES_H
+#define _ALPHA_SPINLOCK_TYPES_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+typedef struct {
+        volatile unsigned int lock;
+} raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED        { 0 }
+
+typedef struct {
+        volatile unsigned int lock;
+} raw_rwlock_t;
+
+#define __RAW_RW_LOCK_UNLOCKED          { 0 }
+
+#endif
diff --git a/include/asm-arm/arch-pxa/pxafb.h b/include/asm-arm/arch-pxa/pxafb.h
index 27d71e9d413b..21c0e16dce5f 100644
--- a/include/asm-arm/arch-pxa/pxafb.h
+++ b/include/asm-arm/arch-pxa/pxafb.h
@@ -66,3 +66,4 @@ struct pxafb_mach_info {
 
 };
 void set_pxa_fb_info(struct pxafb_mach_info *hard_pxa_fb_info);
+unsigned long pxafb_get_hsync_time(struct device *dev);
diff --git a/include/asm-arm/arch-s3c2410/fb.h b/include/asm-arm/arch-s3c2410/fb.h
new file mode 100644
index 000000000000..ac57bc887d82
--- /dev/null
+++ b/include/asm-arm/arch-s3c2410/fb.h
@@ -0,0 +1,69 @@
+/* linux/include/asm/arch-s3c2410/fb.h
+ *
+ * Copyright (c) 2004 Arnaud Patard <arnaud.patard@rtp-net.org>
+ *
+ * Inspired by pxafb.h
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ *
+ *  Changelog:
+ *      07-Sep-2004     RTP     Created file
+ *      03-Nov-2004     BJD     Updated and minor cleanups
+ *      03-Aug-2005     RTP     Renamed to fb.h
+*/
+
+#ifndef __ASM_ARM_FB_H
+#define __ASM_ARM_FB_H
+
+#include <asm/arch/regs-lcd.h>
+
+struct s3c2410fb_val {
+        unsigned int    defval;
+        unsigned int    min;
+        unsigned int    max;
+};
+
+struct s3c2410fb_hw {
+        unsigned long   lcdcon1;
+        unsigned long   lcdcon2;
+        unsigned long   lcdcon3;
+        unsigned long   lcdcon4;
+        unsigned long   lcdcon5;
+};
+
+struct s3c2410fb_mach_info {
+        unsigned char   fixed_syncs;    /* do not update sync/border */
+
+        /* Screen size */
+        int             width;
+        int             height;
+
+        /* Screen info */
+        struct s3c2410fb_val xres;
+        struct s3c2410fb_val yres;
+        struct s3c2410fb_val bpp;
+
+        /* lcd configuration registers */
+        struct s3c2410fb_hw  regs;
+
+        /* GPIOs */
+
+        unsigned long   gpcup;
+        unsigned long   gpcup_mask;
+        unsigned long   gpccon;
+        unsigned long   gpccon_mask;
+        unsigned long   gpdup;
+        unsigned long   gpdup_mask;
+        unsigned long   gpdcon;
+        unsigned long   gpdcon_mask;
+
+        /* lpc3600 control register */
+        unsigned long   lpcsel;
+};
+
+void __init set_s3c2410fb_info(struct s3c2410fb_mach_info *hard_s3c2410fb_info);
+
+#endif /* __ASM_ARM_FB_H */
diff --git a/include/asm-arm/arch-s3c2410/regs-lcd.h b/include/asm-arm/arch-s3c2410/regs-lcd.h
index 7f882ea92b2a..b6b1b4e8bbeb 100644
--- a/include/asm-arm/arch-s3c2410/regs-lcd.h
+++ b/include/asm-arm/arch-s3c2410/regs-lcd.h
@@ -51,21 +51,32 @@
 
 #define S3C2410_LCDCON1_ENVID      (1)
 
+#define S3C2410_LCDCON1_MODEMASK    0x1E
+
 #define S3C2410_LCDCON2_VBPD(x)     ((x) << 24)
 #define S3C2410_LCDCON2_LINEVAL(x)  ((x) << 14)
 #define S3C2410_LCDCON2_VFPD(x)     ((x) << 6)
 #define S3C2410_LCDCON2_VSPW(x)     ((x) << 0)
 
+#define S3C2410_LCDCON2_GET_VBPD(x) ( ((x) >> 24) & 0xFF)
+#define S3C2410_LCDCON2_GET_VFPD(x) ( ((x) >>  6) & 0xFF)
+#define S3C2410_LCDCON2_GET_VSPW(x) ( ((x) >>  0) & 0x3F)
+
 #define S3C2410_LCDCON3_HBPD(x)     ((x) << 19)
 #define S3C2410_LCDCON3_WDLY(x)     ((x) << 19)
 #define S3C2410_LCDCON3_HOZVAL(x)   ((x) << 8)
 #define S3C2410_LCDCON3_HFPD(x)     ((x) << 0)
 #define S3C2410_LCDCON3_LINEBLANK(x)((x) << 0)
 
+#define S3C2410_LCDCON3_GET_HBPD(x) ( ((x) >> 19) & 0x7F)
+#define S3C2410_LCDCON3_GET_HFPD(x) ( ((x) >>  0) & 0xFF)
+
 #define S3C2410_LCDCON4_MVAL(x)     ((x) << 8)
 #define S3C2410_LCDCON4_HSPW(x)     ((x) << 0)
 #define S3C2410_LCDCON4_WLH(x)      ((x) << 0)
 
+#define S3C2410_LCDCON4_GET_HSPW(x) ( ((x) >>  0) & 0xFF)
+
 #define S3C2410_LCDCON5_BPP24BL     (1<<12)
 #define S3C2410_LCDCON5_FRM565      (1<<11)
 #define S3C2410_LCDCON5_INVVCLK     (1<<10)
@@ -100,10 +111,16 @@
 #define S3C2410_DITHMODE   S3C2410_LCDREG(0x4C)
 #define S3C2410_TPAL       S3C2410_LCDREG(0x50)
 
+#define S3C2410_TPAL_EN         (1<<24)
+
 /* interrupt info */
 #define S3C2410_LCDINTPND  S3C2410_LCDREG(0x54)
 #define S3C2410_LCDSRCPND  S3C2410_LCDREG(0x58)
 #define S3C2410_LCDINTMSK  S3C2410_LCDREG(0x5C)
+#define S3C2410_LCDINT_FIWSEL   (1<<2)
+#define S3C2410_LCDINT_FRSYNC   (1<<1)
+#define S3C2410_LCDINT_FICNT    (1<<0)
+
 #define S3C2410_LPCSEL     S3C2410_LCDREG(0x60)
 
 #define S3C2410_TFTPAL(x)  S3C2410_LCDREG((0x400 + (x)*4))
diff --git a/include/asm-arm/spinlock.h b/include/asm-arm/spinlock.h
index 1f906d09b688..cb4906b45555 100644
--- a/include/asm-arm/spinlock.h
+++ b/include/asm-arm/spinlock.h
@@ -16,21 +16,14 @@
  * Unlocked value: 0
  * Locked value: 1
  */
-typedef struct {
-        volatile unsigned int lock;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} spinlock_t;
 
-#define SPIN_LOCK_UNLOCKED      (spinlock_t) { 0 }
+#define __raw_spin_is_locked(x)         ((x)->lock != 0)
+#define __raw_spin_unlock_wait(lock) \
+        do { while (__raw_spin_is_locked(lock)) cpu_relax(); } while (0)
 
-#define spin_lock_init(x)       do { *(x) = SPIN_LOCK_UNLOCKED; } while (0)
-#define spin_is_locked(x)       ((x)->lock != 0)
-#define spin_unlock_wait(x)     do { barrier(); } while (spin_is_locked(x))
-#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
+#define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)
 
-static inline void _raw_spin_lock(spinlock_t *lock)
+static inline void __raw_spin_lock(raw_spinlock_t *lock)
 {
         unsigned long tmp;
 
@@ -47,7 +40,7 @@ static inline void _raw_spin_lock(spinlock_t *lock)
         smp_mb();
 }
 
-static inline int _raw_spin_trylock(spinlock_t *lock)
+static inline int __raw_spin_trylock(raw_spinlock_t *lock)
 {
         unsigned long tmp;
 
@@ -67,7 +60,7 @@ static inline int _raw_spin_trylock(spinlock_t *lock)
         }
 }
 
-static inline void _raw_spin_unlock(spinlock_t *lock)
+static inline void __raw_spin_unlock(raw_spinlock_t *lock)
 {
         smp_mb();
 
@@ -80,23 +73,14 @@ static inline void _raw_spin_unlock(spinlock_t *lock)
 
 /*
  * RWLOCKS
- */
-typedef struct {
-        volatile unsigned int lock;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} rwlock_t;
-
-#define RW_LOCK_UNLOCKED        (rwlock_t) { 0 }
-#define rwlock_init(x)          do { *(x) = RW_LOCK_UNLOCKED; } while (0)
-#define rwlock_is_locked(x)     (*((volatile unsigned int *)(x)) != 0)
-
-/*
+ *
+ *
  * Write locks are easy - we just set bit 31.  When unlocking, we can
  * just write zero since the lock is exclusively held.
  */
-static inline void _raw_write_lock(rwlock_t *rw)
+#define rwlock_is_locked(x)     (*((volatile unsigned int *)(x)) != 0)
+
+static inline void __raw_write_lock(rwlock_t *rw)
 {
         unsigned long tmp;
 
@@ -113,7 +97,7 @@ static inline void _raw_write_lock(rwlock_t *rw)
         smp_mb();
 }
 
-static inline int _raw_write_trylock(rwlock_t *rw)
+static inline int __raw_write_trylock(rwlock_t *rw)
 {
         unsigned long tmp;
 
@@ -133,7 +117,7 @@ static inline int _raw_write_trylock(rwlock_t *rw)
         }
 }
 
-static inline void _raw_write_unlock(rwlock_t *rw)
+static inline void __raw_write_unlock(raw_rwlock_t *rw)
 {
         smp_mb();
 
@@ -156,7 +140,7 @@ static inline void _raw_write_unlock(rwlock_t *rw)
  * currently active.  However, we know we won't have any write
  * locks.
  */
-static inline void _raw_read_lock(rwlock_t *rw)
+static inline void __raw_read_lock(raw_rwlock_t *rw)
 {
         unsigned long tmp, tmp2;
 
@@ -173,7 +157,7 @@ static inline void _raw_read_lock(rwlock_t *rw)
         smp_mb();
 }
 
-static inline void _raw_read_unlock(rwlock_t *rw)
+static inline void __raw_read_unlock(rwlock_t *rw)
 {
         unsigned long tmp, tmp2;
 
@@ -190,6 +174,6 @@ static inline void _raw_read_unlock(rwlock_t *rw)
         : "cc");
 }
 
-#define _raw_read_trylock(lock) generic_raw_read_trylock(lock)
+#define __raw_read_trylock(lock) generic__raw_read_trylock(lock)
 
 #endif /* __ASM_SPINLOCK_H */
diff --git a/include/asm-arm/spinlock_types.h b/include/asm-arm/spinlock_types.h
new file mode 100644
index 000000000000..43e83f6d2ee5
--- /dev/null
+++ b/include/asm-arm/spinlock_types.h
@@ -0,0 +1,20 @@
+#ifndef __ASM_SPINLOCK_TYPES_H
+#define __ASM_SPINLOCK_TYPES_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+typedef struct {
+        volatile unsigned int lock;
+} raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED        { 0 }
+
+typedef struct {
+        volatile unsigned int lock;
+} raw_rwlock_t;
+
+#define __RAW_RW_LOCK_UNLOCKED          { 0 }
+
+#endif
diff --git a/include/asm-arm/unistd.h b/include/asm-arm/unistd.h
index 278de61224d1..c49df635a80f 100644
--- a/include/asm-arm/unistd.h
+++ b/include/asm-arm/unistd.h
@@ -355,6 +355,9 @@
 #define __NR_inotify_init               (__NR_SYSCALL_BASE+316)
 #define __NR_inotify_add_watch          (__NR_SYSCALL_BASE+317)
 #define __NR_inotify_rm_watch           (__NR_SYSCALL_BASE+318)
+#define __NR_mbind                      (__NR_SYSCALL_BASE+319)
+#define __NR_get_mempolicy              (__NR_SYSCALL_BASE+320)
+#define __NR_set_mempolicy              (__NR_SYSCALL_BASE+321)
 
 /*
  * The following SWIs are ARM private.
diff --git a/include/asm-arm26/hardirq.h b/include/asm-arm26/hardirq.h
index 791ee1da9bfa..dc28daab8aa8 100644
--- a/include/asm-arm26/hardirq.h
+++ b/include/asm-arm26/hardirq.h
@@ -22,8 +22,6 @@ typedef struct {
 # error HARDIRQ_BITS is too low!
 #endif
 
-#define irq_enter()             (preempt_count() += HARDIRQ_OFFSET)
-
 #ifndef CONFIG_SMP
 
 extern asmlinkage void __do_softirq(void);
diff --git a/include/asm-generic/tlb.h b/include/asm-generic/tlb.h
index faff403e1061..7d0298347ee7 100644
--- a/include/asm-generic/tlb.h
+++ b/include/asm-generic/tlb.h
@@ -23,7 +23,11 @@
  * and page free order so much..
  */
 #ifdef CONFIG_SMP
-  #define FREE_PTE_NR   506
+  #ifdef ARCH_FREE_PTR_NR
+    #define FREE_PTR_NR   ARCH_FREE_PTR_NR
+  #else
+    #define FREE_PTE_NR 506
+  #endif
   #define tlb_fast_mode(tlb) ((tlb)->nr == ~0U)
 #else
   #define FREE_PTE_NR   1
diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h
index 6f857be2b644..a9c55490fb82 100644
--- a/include/asm-generic/vmlinux.lds.h
+++ b/include/asm-generic/vmlinux.lds.h
@@ -103,3 +103,41 @@
                 VMLINUX_SYMBOL(__kprobes_text_start) = .;               \
                 *(.kprobes.text)                                        \
                 VMLINUX_SYMBOL(__kprobes_text_end) = .;
+
+                /* DWARF debug sections.
+                Symbols in the DWARF debugging sections are relative to
+                the beginning of the section so we begin them at 0.  */
+#define DWARF_DEBUG                                                     \
+                /* DWARF 1 */                                           \
+                .debug          0 : { *(.debug) }                       \
+                .line           0 : { *(.line) }                        \
+                /* GNU DWARF 1 extensions */                            \
+                .debug_srcinfo  0 : { *(.debug_srcinfo) }               \
+                .debug_sfnames  0 : { *(.debug_sfnames) }               \
+                /* DWARF 1.1 and DWARF 2 */                             \
+                .debug_aranges  0 : { *(.debug_aranges) }               \
+                .debug_pubnames 0 : { *(.debug_pubnames) }              \
+                /* DWARF 2 */                                           \
+                .debug_info     0 : { *(.debug_info                     \
+                                .gnu.linkonce.wi.*) }                   \
+                .debug_abbrev   0 : { *(.debug_abbrev) }                \
+                .debug_line     0 : { *(.debug_line) }                  \
+                .debug_frame    0 : { *(.debug_frame) }                 \
+                .debug_str      0 : { *(.debug_str) }                   \
+                .debug_loc      0 : { *(.debug_loc) }                   \
+                .debug_macinfo  0 : { *(.debug_macinfo) }               \
+                /* SGI/MIPS DWARF 2 extensions */                       \
+                .debug_weaknames 0 : { *(.debug_weaknames) }            \
+                .debug_funcnames 0 : { *(.debug_funcnames) }            \
+                .debug_typenames 0 : { *(.debug_typenames) }            \
+                .debug_varnames  0 : { *(.debug_varnames) }             \
+
+                /* Stabs debugging sections.  */
+#define STABS_DEBUG                                                     \
+                .stab 0 : { *(.stab) }                                  \
+                .stabstr 0 : { *(.stabstr) }                            \
+                .stab.excl 0 : { *(.stab.excl) }                        \
+                .stab.exclstr 0 : { *(.stab.exclstr) }                  \
+                .stab.index 0 : { *(.stab.index) }                      \
+                .stab.indexstr 0 : { *(.stab.indexstr) }                \
+                .comment 0 : { *(.comment) }
diff --git a/include/asm-i386/apic.h b/include/asm-i386/apic.h
index 6a1b1882285c..8c454aa58ac6 100644
--- a/include/asm-i386/apic.h
+++ b/include/asm-i386/apic.h
@@ -130,6 +130,8 @@ extern unsigned int nmi_watchdog;
 #define NMI_LOCAL_APIC  2
 #define NMI_INVALID     3
 
+extern int disable_timer_pin_1;
+
 #else /* !CONFIG_X86_LOCAL_APIC */
 static inline void lapic_shutdown(void) { }
 
diff --git a/include/asm-i386/div64.h b/include/asm-i386/div64.h
index 28ed8b296afc..75c67c785bb8 100644
--- a/include/asm-i386/div64.h
+++ b/include/asm-i386/div64.h
@@ -35,7 +35,7 @@
  */
 #define div_long_long_rem(a,b,c) div_ll_X_l_rem(a,b,c)
 
-extern inline long
+static inline long
 div_ll_X_l_rem(long long divs, long div, long *rem)
 {
         long dum2;
diff --git a/include/asm-i386/mach-default/mach_reboot.h b/include/asm-i386/mach-default/mach_reboot.h
index 521e227db679..06ae4d81ba6a 100644
--- a/include/asm-i386/mach-default/mach_reboot.h
+++ b/include/asm-i386/mach-default/mach_reboot.h
@@ -22,7 +22,15 @@ static inline void mach_reboot(void)
         for (i = 0; i < 100; i++) {
                 kb_wait();
                 udelay(50);
-                outb(0xfe, 0x64);         /* pulse reset low */
+                outb(0x60, 0x64);       /* write Controller Command Byte */
+                udelay(50);
+                kb_wait();
+                udelay(50);
+                outb(0x14, 0x60);       /* set "System flag" */
+                udelay(50);
+                kb_wait();
+                udelay(50);
+                outb(0xfe, 0x64);       /* pulse reset low */
                 udelay(50);
         }
 }
diff --git a/include/asm-i386/mmzone.h b/include/asm-i386/mmzone.h
index 516421300ea2..348fe3a4879d 100644
--- a/include/asm-i386/mmzone.h
+++ b/include/asm-i386/mmzone.h
@@ -29,7 +29,7 @@ static inline void get_memcfg_numa(void)
 #ifdef CONFIG_X86_NUMAQ
         if (get_memcfg_numaq())
                 return;
-#elif CONFIG_ACPI_SRAT
+#elif defined(CONFIG_ACPI_SRAT)
         if (get_memcfg_from_srat())
                 return;
 #endif
diff --git a/include/asm-i386/numa.h b/include/asm-i386/numa.h
new file mode 100644
index 000000000000..96fcb157db1d
--- /dev/null
+++ b/include/asm-i386/numa.h
@@ -0,0 +1,3 @@
+
+int pxm_to_nid(int pxm);
+
diff --git a/include/asm-i386/processor.h b/include/asm-i386/processor.h
index 37bef8ed7bed..0a4ec764377c 100644
--- a/include/asm-i386/processor.h
+++ b/include/asm-i386/processor.h
@@ -679,7 +679,7 @@ static inline void rep_nop(void)
    However we don't do prefetches for pre XP Athlons currently
    That should be fixed. */
 #define ARCH_HAS_PREFETCH
-extern inline void prefetch(const void *x)
+static inline void prefetch(const void *x)
 {
         alternative_input(ASM_NOP4,
                           "prefetchnta (%1)",
@@ -693,7 +693,7 @@ extern inline void prefetch(const void *x)
 
 /* 3dnow! prefetch to get an exclusive cache line. Useful for 
    spinlocks to avoid one state transition in the cache coherency protocol. */
-extern inline void prefetchw(const void *x)
+static inline void prefetchw(const void *x)
 {
         alternative_input(ASM_NOP4,
                           "prefetchw (%1)",
diff --git a/include/asm-i386/spinlock.h b/include/asm-i386/spinlock.h
index f9ff31f40036..23604350cdf4 100644
--- a/include/asm-i386/spinlock.h
+++ b/include/asm-i386/spinlock.h
@@ -7,46 +7,21 @@
 #include <linux/config.h>
 #include <linux/compiler.h>
 
-asmlinkage int printk(const char * fmt, ...)
-        __attribute__ ((format (printf, 1, 2)));
-
 /*
  * Your basic SMP spinlocks, allowing only a single CPU anywhere
- */
-
-typedef struct {
-        volatile unsigned int slock;
-#ifdef CONFIG_DEBUG_SPINLOCK
-        unsigned magic;
-#endif
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} spinlock_t;
-
-#define SPINLOCK_MAGIC  0xdead4ead
-
-#ifdef CONFIG_DEBUG_SPINLOCK
-#define SPINLOCK_MAGIC_INIT     , SPINLOCK_MAGIC
-#else
-#define SPINLOCK_MAGIC_INIT     /* */
-#endif
-
-#define SPIN_LOCK_UNLOCKED (spinlock_t) { 1 SPINLOCK_MAGIC_INIT }
-
-#define spin_lock_init(x)       do { *(x) = SPIN_LOCK_UNLOCKED; } while(0)
-
-/*
+ *
  * Simple spin lock operations.  There are two variants, one clears IRQ's
  * on the local processor, one does not.
  *
  * We make no fairness assumptions. They have a cost.
+ *
+ * (the type definitions are in asm/spinlock_types.h)
  */
 
-#define spin_is_locked(x)       (*(volatile signed char *)(&(x)->slock) <= 0)
-#define spin_unlock_wait(x)     do { barrier(); } while(spin_is_locked(x))
+#define __raw_spin_is_locked(x) \
+                (*(volatile signed char *)(&(x)->slock) <= 0)
 
-#define spin_lock_string \
+#define __raw_spin_lock_string \
         "\n1:\t" \
         "lock ; decb %0\n\t" \
         "jns 3f\n" \
@@ -57,7 +32,7 @@ typedef struct {
         "jmp 1b\n" \
         "3:\n\t"
 
-#define spin_lock_string_flags \
+#define __raw_spin_lock_string_flags \
         "\n1:\t" \
         "lock ; decb %0\n\t" \
         "jns 4f\n\t" \
@@ -73,86 +48,71 @@ typedef struct {
         "jmp 1b\n" \
         "4:\n\t"
 
+static inline void __raw_spin_lock(raw_spinlock_t *lock)
+{
+        __asm__ __volatile__(
+                __raw_spin_lock_string
+                :"=m" (lock->slock) : : "memory");
+}
+
+static inline void __raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long flags)
+{
+        __asm__ __volatile__(
+                __raw_spin_lock_string_flags
+                :"=m" (lock->slock) : "r" (flags) : "memory");
+}
+
+static inline int __raw_spin_trylock(raw_spinlock_t *lock)
+{
+        char oldval;
+        __asm__ __volatile__(
+                "xchgb %b0,%1"
+                :"=q" (oldval), "=m" (lock->slock)
+                :"0" (0) : "memory");
+        return oldval > 0;
+}
+
 /*
- * This works. Despite all the confusion.
- * (except on PPro SMP or if we are using OOSTORE)
+ * __raw_spin_unlock based on writing $1 to the low byte.
+ * This method works. Despite all the confusion.
+ * (except on PPro SMP or if we are using OOSTORE, so we use xchgb there)
  * (PPro errata 66, 92)
  */
 
 #if !defined(CONFIG_X86_OOSTORE) && !defined(CONFIG_X86_PPRO_FENCE)
 
-#define spin_unlock_string \
+#define __raw_spin_unlock_string \
         "movb $1,%0" \
                 :"=m" (lock->slock) : : "memory"
 
 
-static inline void _raw_spin_unlock(spinlock_t *lock)
+static inline void __raw_spin_unlock(raw_spinlock_t *lock)
 {
-#ifdef CONFIG_DEBUG_SPINLOCK
-        BUG_ON(lock->magic != SPINLOCK_MAGIC);
-        BUG_ON(!spin_is_locked(lock));
-#endif
         __asm__ __volatile__(
-                spin_unlock_string
+                __raw_spin_unlock_string
         );
 }
 
 #else
 
-#define spin_unlock_string \
+#define __raw_spin_unlock_string \
         "xchgb %b0, %1" \
                 :"=q" (oldval), "=m" (lock->slock) \
                 :"0" (oldval) : "memory"
 
-static inline void _raw_spin_unlock(spinlock_t *lock)
+static inline void __raw_spin_unlock(raw_spinlock_t *lock)
 {
         char oldval = 1;
-#ifdef CONFIG_DEBUG_SPINLOCK
-        BUG_ON(lock->magic != SPINLOCK_MAGIC);
-        BUG_ON(!spin_is_locked(lock));
-#endif
-        __asm__ __volatile__(
-                spin_unlock_string
-        );
-}
 
-#endif
-
-static inline int _raw_spin_trylock(spinlock_t *lock)
-{
-        char oldval;
         __asm__ __volatile__(
-                "xchgb %b0,%1"
-                :"=q" (oldval), "=m" (lock->slock)
-                :"0" (0) : "memory");
-        return oldval > 0;
+                __raw_spin_unlock_string
+        );
 }
 
-static inline void _raw_spin_lock(spinlock_t *lock)
-{
-#ifdef CONFIG_DEBUG_SPINLOCK
-        if (unlikely(lock->magic != SPINLOCK_MAGIC)) {
-                printk("eip: %p\n", __builtin_return_address(0));
-                BUG();
-        }
 #endif
-        __asm__ __volatile__(
-                spin_lock_string
-                :"=m" (lock->slock) : : "memory");
-}
 
-static inline void _raw_spin_lock_flags (spinlock_t *lock, unsigned long flags)
-{
-#ifdef CONFIG_DEBUG_SPINLOCK
-        if (unlikely(lock->magic != SPINLOCK_MAGIC)) {
-                printk("eip: %p\n", __builtin_return_address(0));
-                BUG();
-        }
-#endif
-        __asm__ __volatile__(
-                spin_lock_string_flags
-                :"=m" (lock->slock) : "r" (flags) : "memory");
-}
+#define __raw_spin_unlock_wait(lock) \
+        do { while (__raw_spin_is_locked(lock)) cpu_relax(); } while (0)
 
 /*
  * Read-write spinlocks, allowing multiple readers
@@ -163,72 +123,41 @@ static inline void _raw_spin_lock_flags (spinlock_t *lock, unsigned long flags)
  * can "mix" irq-safe locks - any writer needs to get a
  * irq-safe write-lock, but readers can get non-irqsafe
  * read-locks.
+ *
+ * On x86, we implement read-write locks as a 32-bit counter
+ * with the high bit (sign) being the "contended" bit.
+ *
+ * The inline assembly is non-obvious. Think about it.
+ *
+ * Changed to use the same technique as rw semaphores.  See
+ * semaphore.h for details.  -ben
+ *
+ * the helpers are in arch/i386/kernel/semaphore.c
  */
-typedef struct {
-        volatile unsigned int lock;
-#ifdef CONFIG_DEBUG_SPINLOCK
-        unsigned magic;
-#endif
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} rwlock_t;
-
-#define RWLOCK_MAGIC    0xdeaf1eed
-
-#ifdef CONFIG_DEBUG_SPINLOCK
-#define RWLOCK_MAGIC_INIT       , RWLOCK_MAGIC
-#else
-#define RWLOCK_MAGIC_INIT       /* */
-#endif
-
-#define RW_LOCK_UNLOCKED (rwlock_t) { RW_LOCK_BIAS RWLOCK_MAGIC_INIT }
-
-#define rwlock_init(x)  do { *(x) = RW_LOCK_UNLOCKED; } while(0)
 
 /**
  * read_can_lock - would read_trylock() succeed?
  * @lock: the rwlock in question.
  */
-#define read_can_lock(x) ((int)(x)->lock > 0)
+#define __raw_read_can_lock(x)          ((int)(x)->lock > 0)
 
 /**
  * write_can_lock - would write_trylock() succeed?
  * @lock: the rwlock in question.
  */
-#define write_can_lock(x) ((x)->lock == RW_LOCK_BIAS)
+#define __raw_write_can_lock(x)         ((x)->lock == RW_LOCK_BIAS)
 
-/*
- * On x86, we implement read-write locks as a 32-bit counter
- * with the high bit (sign) being the "contended" bit.
- *
- * The inline assembly is non-obvious. Think about it.
- *
- * Changed to use the same technique as rw semaphores.  See
- * semaphore.h for details.  -ben
- */
-/* the spinlock helpers are in arch/i386/kernel/semaphore.c */
-
-static inline void _raw_read_lock(rwlock_t *rw)
+static inline void __raw_read_lock(raw_rwlock_t *rw)
 {
-#ifdef CONFIG_DEBUG_SPINLOCK
-        BUG_ON(rw->magic != RWLOCK_MAGIC);
-#endif
         __build_read_lock(rw, "__read_lock_failed");
 }
 
-static inline void _raw_write_lock(rwlock_t *rw)
+static inline void __raw_write_lock(raw_rwlock_t *rw)
 {
-#ifdef CONFIG_DEBUG_SPINLOCK
-        BUG_ON(rw->magic != RWLOCK_MAGIC);
-#endif
         __build_write_lock(rw, "__write_lock_failed");
 }
 
-#define _raw_read_unlock(rw)            asm volatile("lock ; incl %0" :"=m" ((rw)->lock) : : "memory")
-#define _raw_write_unlock(rw)   asm volatile("lock ; addl $" RW_LOCK_BIAS_STR ",%0":"=m" ((rw)->lock) : : "memory")
-
-static inline int _raw_read_trylock(rwlock_t *lock)
+static inline int __raw_read_trylock(raw_rwlock_t *lock)
 {
         atomic_t *count = (atomic_t *)lock;
         atomic_dec(count);
@@ -238,7 +167,7 @@ static inline int _raw_read_trylock(rwlock_t *lock)
         return 0;
 }
 
-static inline int _raw_write_trylock(rwlock_t *lock)
+static inline int __raw_write_trylock(raw_rwlock_t *lock)
 {
         atomic_t *count = (atomic_t *)lock;
         if (atomic_sub_and_test(RW_LOCK_BIAS, count))
@@ -247,4 +176,15 @@ static inline int _raw_write_trylock(rwlock_t *lock)
         return 0;
 }
 
+static inline void __raw_read_unlock(raw_rwlock_t *rw)
+{
+        asm volatile("lock ; incl %0" :"=m" (rw->lock) : : "memory");
+}
+
+static inline void __raw_write_unlock(raw_rwlock_t *rw)
+{
+        asm volatile("lock ; addl $" RW_LOCK_BIAS_STR ", %0"
+                                 : "=m" (rw->lock) : : "memory");
+}
+
 #endif /* __ASM_SPINLOCK_H */
diff --git a/include/asm-i386/spinlock_types.h b/include/asm-i386/spinlock_types.h
new file mode 100644
index 000000000000..59efe849f351
--- /dev/null
+++ b/include/asm-i386/spinlock_types.h
@@ -0,0 +1,20 @@
+#ifndef __ASM_SPINLOCK_TYPES_H
+#define __ASM_SPINLOCK_TYPES_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+typedef struct {
+        volatile unsigned int slock;
+} raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED        { 1 }
+
+typedef struct {
+        volatile unsigned int lock;
+} raw_rwlock_t;
+
+#define __RAW_RW_LOCK_UNLOCKED          { RW_LOCK_BIAS }
+
+#endif
diff --git a/include/asm-i386/thread_info.h b/include/asm-i386/thread_info.h
index e2cb9fa6f563..8fbf791651bf 100644
--- a/include/asm-i386/thread_info.h
+++ b/include/asm-i386/thread_info.h
@@ -48,7 +48,7 @@ struct thread_info {
 
 #else /* !__ASSEMBLY__ */
 
-#include <asm/asm_offsets.h>
+#include <asm/asm-offsets.h>
 
 #endif
 
diff --git a/include/asm-i386/topology.h b/include/asm-i386/topology.h
index 2461b731781e..0ec27c9e8e45 100644
--- a/include/asm-i386/topology.h
+++ b/include/asm-i386/topology.h
@@ -60,7 +60,7 @@ static inline int node_to_first_cpu(int node)
         return first_cpu(mask);
 }
 
-#define pcibus_to_node(bus) mp_bus_id_to_node[(bus)->number]
+#define pcibus_to_node(bus) ((long) (bus)->sysdata)
 #define pcibus_to_cpumask(bus) node_to_cpumask(pcibus_to_node(bus))
 
 /* sched_domains SD_NODE_INIT for NUMAQ machines */
diff --git a/include/asm-i386/unistd.h b/include/asm-i386/unistd.h
index a7cb377745bf..fbaf90a3968c 100644
--- a/include/asm-i386/unistd.h
+++ b/include/asm-i386/unistd.h
@@ -332,7 +332,7 @@ type name(type1 arg1) \
 long __res; \
 __asm__ volatile ("int $0x80" \
         : "=a" (__res) \
-        : "0" (__NR_##name),"b" ((long)(arg1))); \
+        : "0" (__NR_##name),"b" ((long)(arg1)) : "memory"); \
 __syscall_return(type,__res); \
 }
 
@@ -342,7 +342,7 @@ type name(type1 arg1,type2 arg2) \
 long __res; \
 __asm__ volatile ("int $0x80" \
         : "=a" (__res) \
-        : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2))); \
+        : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)) : "memory"); \
 __syscall_return(type,__res); \
 }
 
@@ -353,7 +353,7 @@ long __res; \
 __asm__ volatile ("int $0x80" \
         : "=a" (__res) \
         : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
-                  "d" ((long)(arg3))); \
+                  "d" ((long)(arg3)) : "memory"); \
 __syscall_return(type,__res); \
 }
 
@@ -364,7 +364,7 @@ long __res; \
 __asm__ volatile ("int $0x80" \
         : "=a" (__res) \
         : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
-          "d" ((long)(arg3)),"S" ((long)(arg4))); \
+          "d" ((long)(arg3)),"S" ((long)(arg4)) : "memory"); \
 __syscall_return(type,__res); \
 } 
 
@@ -376,7 +376,7 @@ long __res; \
 __asm__ volatile ("int $0x80" \
         : "=a" (__res) \
         : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
-          "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5))); \
+          "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5)) : "memory"); \
 __syscall_return(type,__res); \
 }
 
@@ -389,7 +389,7 @@ __asm__ volatile ("push %%ebp ; movl %%eax,%%ebp ; movl %1,%%eax ; int $0x80 ; p
         : "=a" (__res) \
         : "i" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
           "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5)), \
-          "0" ((long)(arg6))); \
+          "0" ((long)(arg6)) : "memory"); \
 __syscall_return(type,__res); \
 }
 
diff --git a/include/asm-ia64/mca.h b/include/asm-ia64/mca.h
index 149ad0118455..97a28b8b2ddd 100644
--- a/include/asm-ia64/mca.h
+++ b/include/asm-ia64/mca.h
@@ -11,8 +11,6 @@
 #ifndef _ASM_IA64_MCA_H
 #define _ASM_IA64_MCA_H
 
-#define IA64_MCA_STACK_SIZE     8192
-
 #if !defined(__ASSEMBLY__)
 
 #include <linux/interrupt.h>
@@ -48,7 +46,8 @@ typedef union cmcv_reg_u {
 
 enum {
         IA64_MCA_RENDEZ_CHECKIN_NOTDONE =       0x0,
-        IA64_MCA_RENDEZ_CHECKIN_DONE    =       0x1
+        IA64_MCA_RENDEZ_CHECKIN_DONE    =       0x1,
+        IA64_MCA_RENDEZ_CHECKIN_INIT    =       0x2,
 };
 
 /* Information maintained by the MC infrastructure */
@@ -63,18 +62,42 @@ typedef struct ia64_mc_info_s {
 
 } ia64_mc_info_t;
 
-typedef struct ia64_mca_sal_to_os_state_s {
-        u64             imsto_os_gp;            /* GP of the os registered with the SAL */
-        u64             imsto_pal_proc;         /* PAL_PROC entry point - physical addr */
-        u64             imsto_sal_proc;         /* SAL_PROC entry point - physical addr */
-        u64             imsto_sal_gp;           /* GP of the SAL - physical */
-        u64             imsto_rendez_state;     /* Rendez state information */
-        u64             imsto_sal_check_ra;     /* Return address in SAL_CHECK while going
-                                                 * back to SAL from OS after MCA handling.
-                                                 */
-        u64             pal_min_state;          /* from PAL in r17 */
-        u64             proc_state_param;       /* from PAL in r18. See SDV 2:268 11.3.2.1 */
-} ia64_mca_sal_to_os_state_t;
+/* Handover state from SAL to OS and vice versa, for both MCA and INIT events.
+ * Besides the handover state, it also contains some saved registers from the
+ * time of the event.
+ * Note: mca_asm.S depends on the precise layout of this structure.
+ */
+
+struct ia64_sal_os_state {
+        /* SAL to OS, must be at offset 0 */
+        u64                     os_gp;                  /* GP of the os registered with the SAL, physical */
+        u64                     pal_proc;               /* PAL_PROC entry point, physical */
+        u64                     sal_proc;               /* SAL_PROC entry point, physical */
+        u64                     rv_rc;                  /* MCA - Rendezvous state, INIT - reason code */
+        u64                     proc_state_param;       /* from R18 */
+        u64                     monarch;                /* 1 for a monarch event, 0 for a slave */
+        /* common, must follow SAL to OS */
+        u64                     sal_ra;                 /* Return address in SAL, physical */
+        u64                     sal_gp;                 /* GP of the SAL - physical */
+        pal_min_state_area_t    *pal_min_state;         /* from R17.  physical in asm, virtual in C */
+        u64                     prev_IA64_KR_CURRENT;   /* previous value of IA64_KR(CURRENT) */
+        struct task_struct      *prev_task;             /* previous task, NULL if it is not useful */
+        /* Some interrupt registers are not saved in minstate, pt_regs or
+         * switch_stack.  Because MCA/INIT can occur when interrupts are
+         * disabled, we need to save the additional interrupt registers over
+         * MCA/INIT and resume.
+         */
+        u64                     isr;
+        u64                     ifa;
+        u64                     itir;
+        u64                     iipa;
+        u64                     iim;
+        u64                     iha;
+        /* OS to SAL, must follow common */
+        u64                     os_status;              /* OS status to SAL, enum below */
+        u64                     context;                /* 0 if return to same context
+                                                           1 if return to new context */
+};
 
 enum {
         IA64_MCA_CORRECTED      =       0x0,    /* Error has been corrected by OS_MCA */
@@ -84,35 +107,21 @@ enum {
 };
 
 enum {
+        IA64_INIT_RESUME        =       0x0,    /* Resume after return from INIT */
+        IA64_INIT_WARM_BOOT     =       -1,     /* Warm boot of the system need from SAL */
+};
+
+enum {
         IA64_MCA_SAME_CONTEXT   =       0x0,    /* SAL to return to same context */
         IA64_MCA_NEW_CONTEXT    =       -1      /* SAL to return to new context */
 };
 
-typedef struct ia64_mca_os_to_sal_state_s {
-        u64             imots_os_status;        /*   OS status to SAL as to what happened
-                                                 *   with the MCA handling.
-                                                 */
-        u64             imots_sal_gp;           /* GP of the SAL - physical */
-        u64             imots_context;          /* 0 if return to same context
-                                                   1 if return to new context */
-        u64             *imots_new_min_state;   /* Pointer to structure containing
-                                                 * new values of registers in the min state
-                                                 * save area.
-                                                 */
-        u64             imots_sal_check_ra;     /* Return address in SAL_CHECK while going
-                                                 * back to SAL from OS after MCA handling.
-                                                 */
-} ia64_mca_os_to_sal_state_t;
-
 /* Per-CPU MCA state that is too big for normal per-CPU variables.  */
 
 struct ia64_mca_cpu {
-        u64 stack[IA64_MCA_STACK_SIZE/8];       /* MCA memory-stack */
-        u64 proc_state_dump[512];
-        u64 stackframe[32];
-        u64 rbstore[IA64_MCA_STACK_SIZE/8];     /* MCA reg.-backing store */
+        u64 mca_stack[KERNEL_STACK_SIZE/8];
         u64 init_stack[KERNEL_STACK_SIZE/8];
-} __attribute__ ((aligned(16)));
+};
 
 /* Array of physical addresses of each CPU's MCA area.  */
 extern unsigned long __per_cpu_mca[NR_CPUS];
@@ -121,12 +130,29 @@ extern void ia64_mca_init(void);
 extern void ia64_mca_cpu_init(void *);
 extern void ia64_os_mca_dispatch(void);
 extern void ia64_os_mca_dispatch_end(void);
-extern void ia64_mca_ucmc_handler(void);
+extern void ia64_mca_ucmc_handler(struct pt_regs *, struct ia64_sal_os_state *);
+extern void ia64_init_handler(struct pt_regs *,
+                              struct switch_stack *,
+                              struct ia64_sal_os_state *);
 extern void ia64_monarch_init_handler(void);
 extern void ia64_slave_init_handler(void);
 extern void ia64_mca_cmc_vector_setup(void);
-extern int  ia64_reg_MCA_extension(void*);
+extern int  ia64_reg_MCA_extension(int (*fn)(void *, struct ia64_sal_os_state *));
 extern void ia64_unreg_MCA_extension(void);
+extern u64 ia64_get_rnat(u64 *);
+
+#else   /* __ASSEMBLY__ */
+
+#define IA64_MCA_CORRECTED      0x0     /* Error has been corrected by OS_MCA */
+#define IA64_MCA_WARM_BOOT      -1      /* Warm boot of the system need from SAL */
+#define IA64_MCA_COLD_BOOT      -2      /* Cold boot of the system need from SAL */
+#define IA64_MCA_HALT           -3      /* System to be halted by SAL */
+
+#define IA64_INIT_RESUME        0x0     /* Resume after return from INIT */
+#define IA64_INIT_WARM_BOOT     -1      /* Warm boot of the system need from SAL */
+
+#define IA64_MCA_SAME_CONTEXT   0x0     /* SAL to return to same context */
+#define IA64_MCA_NEW_CONTEXT    -1      /* SAL to return to new context */
 
 #endif /* !__ASSEMBLY__ */
 #endif /* _ASM_IA64_MCA_H */
diff --git a/include/asm-ia64/mca_asm.h b/include/asm-ia64/mca_asm.h
index 836953e0f91f..27c9203d8ce3 100644
--- a/include/asm-ia64/mca_asm.h
+++ b/include/asm-ia64/mca_asm.h
@@ -8,6 +8,8 @@
  * Copyright (C) 2000 David Mosberger-Tang <davidm@hpl.hp.com>
  * Copyright (C) 2002 Intel Corp.
  * Copyright (C) 2002 Jenna Hall <jenna.s.hall@intel.com>
+ * Copyright (C) 2005 Silicon Graphics, Inc
+ * Copyright (C) 2005 Keith Owens <kaos@sgi.com>
  */
 #ifndef _ASM_IA64_MCA_ASM_H
 #define _ASM_IA64_MCA_ASM_H
@@ -207,106 +209,33 @@
         ;;
 
 /*
- * The following offsets capture the order in which the
- * RSE related registers from the old context are
- * saved onto the new stack frame.
+ * The MCA and INIT stacks in struct ia64_mca_cpu look like normal kernel
+ * stacks, except that the SAL/OS state and a switch_stack are stored near the
+ * top of the MCA/INIT stack.  To support concurrent entry to MCA or INIT, as
+ * well as MCA over INIT, each event needs its own SAL/OS state.  All entries
+ * are 16 byte aligned.
  *
- *      +-----------------------+
- *      |NDIRTY [BSP - BSPSTORE]|
- *      +-----------------------+
- *      |       RNAT            |
- *      +-----------------------+
- *      |       BSPSTORE        |
- *      +-----------------------+
- *      |       IFS             |
- *      +-----------------------+
- *      |       PFS             |
- *      +-----------------------+
- *      |       RSC             |
- *      +-----------------------+ <-------- Bottom of new stack frame
+ *      +---------------------------+
+ *      |          pt_regs          |
+ *      +---------------------------+
+ *      |        switch_stack       |
+ *      +---------------------------+
+ *      |        SAL/OS state       |
+ *      +---------------------------+
+ *      |    16 byte scratch area   |
+ *      +---------------------------+ <-------- SP at start of C MCA handler
+ *      |           .....           |
+ *      +---------------------------+
+ *      | RBS for MCA/INIT handler  |
+ *      +---------------------------+
+ *      | struct task for MCA/INIT  |
+ *      +---------------------------+ <-------- Bottom of MCA/INIT stack
  */
-#define  rse_rsc_offset         0
-#define  rse_pfs_offset         (rse_rsc_offset+0x08)
-#define  rse_ifs_offset         (rse_pfs_offset+0x08)
-#define  rse_bspstore_offset    (rse_ifs_offset+0x08)
-#define  rse_rnat_offset        (rse_bspstore_offset+0x08)
-#define  rse_ndirty_offset      (rse_rnat_offset+0x08)
 
-/*
- * rse_switch_context
- *
- *      1. Save old RSC onto the new stack frame
- *      2. Save PFS onto new stack frame
- *      3. Cover the old frame and start a new frame.
- *      4. Save IFS onto new stack frame
- *      5. Save the old BSPSTORE on the new stack frame
- *      6. Save the old RNAT on the new stack frame
- *      7. Write BSPSTORE with the new backing store pointer
- *      8. Read and save the new BSP to calculate the #dirty registers
- * NOTE: Look at pages 11-10, 11-11 in PRM Vol 2
- */
-#define rse_switch_context(temp,p_stackframe,p_bspstore)                        \
-        ;;                                                                      \
-        mov     temp=ar.rsc;;                                                   \
-        st8     [p_stackframe]=temp,8;;                                 \
-        mov     temp=ar.pfs;;                                                   \
-        st8     [p_stackframe]=temp,8;                                          \
-        cover ;;                                                                \
-        mov     temp=cr.ifs;;                                                   \
-        st8     [p_stackframe]=temp,8;;                                         \
-        mov     temp=ar.bspstore;;                                              \
-        st8     [p_stackframe]=temp,8;;                                 \
-        mov     temp=ar.rnat;;                                                  \
-        st8     [p_stackframe]=temp,8;                                          \
-        mov     ar.bspstore=p_bspstore;;                                        \
-        mov     temp=ar.bsp;;                                                   \
-        sub     temp=temp,p_bspstore;;                                          \
-        st8     [p_stackframe]=temp,8;;
-
-/*
- * rse_return_context
- *      1. Allocate a zero-sized frame
- *      2. Store the number of dirty registers RSC.loadrs field
- *      3. Issue a loadrs to insure that any registers from the interrupted
- *         context which were saved on the new stack frame have been loaded
- *         back into the stacked registers
- *      4. Restore BSPSTORE
- *      5. Restore RNAT
- *      6. Restore PFS
- *      7. Restore IFS
- *      8. Restore RSC
- *      9. Issue an RFI
- */
-#define rse_return_context(psr_mask_reg,temp,p_stackframe)                      \
-        ;;                                                                      \
-        alloc   temp=ar.pfs,0,0,0,0;                                            \
-        add     p_stackframe=rse_ndirty_offset,p_stackframe;;                   \
-        ld8     temp=[p_stackframe];;                                           \
-        shl     temp=temp,16;;                                                  \
-        mov     ar.rsc=temp;;                                                   \
-        loadrs;;                                                                \
-        add     p_stackframe=-rse_ndirty_offset+rse_bspstore_offset,p_stackframe;;\
-        ld8     temp=[p_stackframe];;                                           \
-        mov     ar.bspstore=temp;;                                              \
-        add     p_stackframe=-rse_bspstore_offset+rse_rnat_offset,p_stackframe;;\
-        ld8     temp=[p_stackframe];;                                           \
-        mov     ar.rnat=temp;;                                                  \
-        add     p_stackframe=-rse_rnat_offset+rse_pfs_offset,p_stackframe;;     \
-        ld8     temp=[p_stackframe];;                                           \
-        mov     ar.pfs=temp;;                                                   \
-        add     p_stackframe=-rse_pfs_offset+rse_ifs_offset,p_stackframe;;      \
-        ld8     temp=[p_stackframe];;                                           \
-        mov     cr.ifs=temp;;                                                   \
-        add     p_stackframe=-rse_ifs_offset+rse_rsc_offset,p_stackframe;;      \
-        ld8     temp=[p_stackframe];;                                           \
-        mov     ar.rsc=temp ;                                                   \
-        mov     temp=psr;;                                                      \
-        or      temp=temp,psr_mask_reg;;                                        \
-        mov     cr.ipsr=temp;;                                                  \
-        mov     temp=ip;;                                                       \
-        add     temp=0x30,temp;;                                                \
-        mov     cr.iip=temp;;                                                   \
-        srlz.i;;                                                                \
-        rfi;;
+#define ALIGN16(x)                      ((x)&~15)
+#define MCA_PT_REGS_OFFSET              ALIGN16(KERNEL_STACK_SIZE-IA64_PT_REGS_SIZE)
+#define MCA_SWITCH_STACK_OFFSET         ALIGN16(MCA_PT_REGS_OFFSET-IA64_SWITCH_STACK_SIZE)
+#define MCA_SOS_OFFSET                  ALIGN16(MCA_SWITCH_STACK_OFFSET-IA64_SAL_OS_STATE_SIZE)
+#define MCA_SP_OFFSET                   ALIGN16(MCA_SOS_OFFSET-16)
 
 #endif /* _ASM_IA64_MCA_ASM_H */
diff --git a/include/asm-ia64/ptrace.h b/include/asm-ia64/ptrace.h
index 0bef19538406..fc544929ac34 100644
--- a/include/asm-ia64/ptrace.h
+++ b/include/asm-ia64/ptrace.h
@@ -57,7 +57,7 @@
 #include <linux/config.h>
 
 #include <asm/fpu.h>
-#include <asm/offsets.h>
+#include <asm/asm-offsets.h>
 
 /*
  * Base-2 logarithm of number of pages to allocate per task structure
@@ -119,7 +119,7 @@ struct pt_regs {
         unsigned long ar_unat;          /* interrupted task's NaT register (preserved) */
         unsigned long ar_pfs;           /* prev function state  */
         unsigned long ar_rsc;           /* RSE configuration */
-        /* The following two are valid only if cr_ipsr.cpl > 0: */
+        /* The following two are valid only if cr_ipsr.cpl > 0 || ti->flags & _TIF_MCA_INIT */
         unsigned long ar_rnat;          /* RSE NaT */
         unsigned long ar_bspstore;      /* RSE bspstore */
 
diff --git a/include/asm-ia64/sn/sn_feature_sets.h b/include/asm-ia64/sn/sn_feature_sets.h
new file mode 100644
index 000000000000..e68a80853d5d
--- /dev/null
+++ b/include/asm-ia64/sn/sn_feature_sets.h
@@ -0,0 +1,57 @@
+#ifndef _ASM_IA64_SN_FEATURE_SETS_H
+#define _ASM_IA64_SN_FEATURE_SETS_H
+
+/*
+ * SN PROM Features
+ *
+ * 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.
+ *
+ * Copyright (c) 2005 Silicon Graphics, Inc.  All rights reserved.
+ */
+
+
+#include <asm/types.h>
+#include <asm/bitops.h>
+
+/* --------------------- PROM Features -----------------------------*/
+extern int sn_prom_feature_available(int id);
+
+#define MAX_PROM_FEATURE_SETS                   2
+
+/*
+ * The following defines features that may or may not be supported by the
+ * current PROM. The OS uses sn_prom_feature_available(feature) to test for
+ * the presence of a PROM feature. Down rev (old) PROMs will always test
+ * "false" for new features.
+ *
+ * Use:
+ *              if (sn_prom_feature_available(PRF_FEATURE_XXX))
+ *                      ...
+ */
+
+/*
+ * Example: feature XXX
+ */
+#define PRF_FEATURE_XXX         0
+
+
+
+/* --------------------- OS Features -------------------------------*/
+
+/*
+ * The following defines OS features that are optionally present in
+ * the operating system.
+ * During boot, PROM is notified of these features via a series of calls:
+ *
+ *              ia64_sn_set_os_feature(feature1);
+ *
+ * Once enabled, a feature cannot be disabled.
+ *
+ * By default, features are disabled unless explicitly enabled.
+ */
+#define  OSF_MCA_SLV_TO_OS_INIT_SLV             0
+#define  OSF_FEAT_LOG_SBES                      1
+
+#endif /* _ASM_IA64_SN_FEATURE_SETS_H */
diff --git a/include/asm-ia64/sn/sn_sal.h b/include/asm-ia64/sn/sn_sal.h
index e67825ad1930..fea35b33d4e4 100644
--- a/include/asm-ia64/sn/sn_sal.h
+++ b/include/asm-ia64/sn/sn_sal.h
@@ -80,6 +80,9 @@
 #define SN_SAL_RESERVED_DO_NOT_USE                 0x02000062
 #define SN_SAL_IOIF_GET_PCI_TOPOLOGY               0x02000064
 
+#define  SN_SAL_GET_PROM_FEATURE_SET               0x02000065
+#define  SN_SAL_SET_OS_FEATURE_SET                 0x02000066
+
 /*
  * Service-specific constants
  */
@@ -118,8 +121,8 @@
 /*
  * Error Handling Features
  */
-#define SAL_ERR_FEAT_MCA_SLV_TO_OS_INIT_SLV     0x1
-#define SAL_ERR_FEAT_LOG_SBES                   0x2
+#define SAL_ERR_FEAT_MCA_SLV_TO_OS_INIT_SLV     0x1     // obsolete
+#define SAL_ERR_FEAT_LOG_SBES                   0x2     // obsolete
 #define SAL_ERR_FEAT_MFR_OVERRIDE               0x4
 #define SAL_ERR_FEAT_SBE_THRESHOLD              0xffff0000
 
@@ -152,12 +155,6 @@ sn_sal_rev(void)
 }
 
 /*
- * Specify the minimum PROM revsion required for this kernel.
- * Note that they're stored in hex format...
- */
-#define SN_SAL_MIN_VERSION      0x0404
-
-/*
  * Returns the master console nasid, if the call fails, return an illegal
  * value.
  */
@@ -336,7 +333,7 @@ ia64_sn_plat_cpei_handler(void)
 }
 
 /*
- * Set Error Handling Features
+ * Set Error Handling Features  (Obsolete)
  */
 static inline u64
 ia64_sn_plat_set_error_handling_features(void)
@@ -1052,4 +1049,25 @@ ia64_sn_is_fake_prom(void)
         return (rv.status == 0);
 }
 
+static inline int
+ia64_sn_get_prom_feature_set(int set, unsigned long *feature_set)
+{
+        struct ia64_sal_retval rv;
+
+        SAL_CALL_NOLOCK(rv, SN_SAL_GET_PROM_FEATURE_SET, set, 0, 0, 0, 0, 0, 0);
+        if (rv.status != 0)
+                return rv.status;
+        *feature_set = rv.v0;
+        return 0;
+}
+
+static inline int
+ia64_sn_set_os_feature(int feature)
+{
+        struct ia64_sal_retval rv;
+
+        SAL_CALL_NOLOCK(rv, SN_SAL_SET_OS_FEATURE_SET, feature, 0, 0, 0, 0, 0, 0);
+        return rv.status;
+}
+
 #endif /* _ASM_IA64_SN_SN_SAL_H */
diff --git a/include/asm-ia64/spinlock.h b/include/asm-ia64/spinlock.h
index d2430aa0d49d..5b78611411c3 100644
--- a/include/asm-ia64/spinlock.h
+++ b/include/asm-ia64/spinlock.h
@@ -17,28 +17,20 @@
 #include <asm/intrinsics.h>
 #include <asm/system.h>
 
-typedef struct {
-        volatile unsigned int lock;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} spinlock_t;
-
-#define SPIN_LOCK_UNLOCKED                      (spinlock_t) { 0 }
-#define spin_lock_init(x)                       ((x)->lock = 0)
+#define __raw_spin_lock_init(x)                 ((x)->lock = 0)
 
 #ifdef ASM_SUPPORTED
 /*
  * Try to get the lock.  If we fail to get the lock, make a non-standard call to
  * ia64_spinlock_contention().  We do not use a normal call because that would force all
- * callers of spin_lock() to be non-leaf routines.  Instead, ia64_spinlock_contention() is
- * carefully coded to touch only those registers that spin_lock() marks "clobbered".
+ * callers of __raw_spin_lock() to be non-leaf routines.  Instead, ia64_spinlock_contention() is
+ * carefully coded to touch only those registers that __raw_spin_lock() marks "clobbered".
  */
 
 #define IA64_SPINLOCK_CLOBBERS "ar.ccv", "ar.pfs", "p14", "p15", "r27", "r28", "r29", "r30", "b6", "memory"
 
 static inline void
-_raw_spin_lock_flags (spinlock_t *lock, unsigned long flags)
+__raw_spin_lock_flags (raw_spinlock_t *lock, unsigned long flags)
 {
         register volatile unsigned int *ptr asm ("r31") = &lock->lock;
 
@@ -94,17 +86,17 @@ _raw_spin_lock_flags (spinlock_t *lock, unsigned long flags)
 #endif
 }
 
-#define _raw_spin_lock(lock) _raw_spin_lock_flags(lock, 0)
+#define __raw_spin_lock(lock) __raw_spin_lock_flags(lock, 0)
 
 /* Unlock by doing an ordered store and releasing the cacheline with nta */
-static inline void _raw_spin_unlock(spinlock_t *x) {
+static inline void __raw_spin_unlock(raw_spinlock_t *x) {
         barrier();
         asm volatile ("st4.rel.nta [%0] = r0\n\t" :: "r"(x));
 }
 
 #else /* !ASM_SUPPORTED */
-#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
-# define _raw_spin_lock(x)                                                              \
+#define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)
+# define __raw_spin_lock(x)                                                             \
 do {                                                                                    \
         __u32 *ia64_spinlock_ptr = (__u32 *) (x);                                       \
         __u64 ia64_spinlock_val;                                                        \
@@ -117,29 +109,20 @@ do {											\
                 } while (ia64_spinlock_val);                                            \
         }                                                                               \
 } while (0)
-#define _raw_spin_unlock(x)     do { barrier(); ((spinlock_t *) x)->lock = 0; } while (0)
+#define __raw_spin_unlock(x)    do { barrier(); ((raw_spinlock_t *) x)->lock = 0; } while (0)
 #endif /* !ASM_SUPPORTED */
 
-#define spin_is_locked(x)       ((x)->lock != 0)
-#define _raw_spin_trylock(x)    (cmpxchg_acq(&(x)->lock, 0, 1) == 0)
-#define spin_unlock_wait(x)     do { barrier(); } while ((x)->lock)
-
-typedef struct {
-        volatile unsigned int read_counter      : 24;
-        volatile unsigned int write_lock        :  8;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} rwlock_t;
-#define RW_LOCK_UNLOCKED (rwlock_t) { 0, 0 }
+#define __raw_spin_is_locked(x)         ((x)->lock != 0)
+#define __raw_spin_trylock(x)           (cmpxchg_acq(&(x)->lock, 0, 1) == 0)
+#define __raw_spin_unlock_wait(lock) \
+        do { while (__raw_spin_is_locked(lock)) cpu_relax(); } while (0)
 
-#define rwlock_init(x)          do { *(x) = RW_LOCK_UNLOCKED; } while(0)
-#define read_can_lock(rw)       (*(volatile int *)(rw) >= 0)
-#define write_can_lock(rw)      (*(volatile int *)(rw) == 0)
+#define __raw_read_can_lock(rw)         (*(volatile int *)(rw) >= 0)
+#define __raw_write_can_lock(rw)        (*(volatile int *)(rw) == 0)
 
-#define _raw_read_lock(rw)                                                              \
+#define __raw_read_lock(rw)                                                             \
 do {                                                                                    \
-        rwlock_t *__read_lock_ptr = (rw);                                               \
+        raw_rwlock_t *__read_lock_ptr = (rw);                                           \
                                                                                         \
         while (unlikely(ia64_fetchadd(1, (int *) __read_lock_ptr, acq) < 0)) {          \
                 ia64_fetchadd(-1, (int *) __read_lock_ptr, rel);                        \
@@ -148,14 +131,14 @@ do {											\
         }                                                                               \
 } while (0)
 
-#define _raw_read_unlock(rw)                                    \
+#define __raw_read_unlock(rw)                                   \
 do {                                                            \
-        rwlock_t *__read_lock_ptr = (rw);                       \
+        raw_rwlock_t *__read_lock_ptr = (rw);                   \
         ia64_fetchadd(-1, (int *) __read_lock_ptr, rel);        \
 } while (0)
 
 #ifdef ASM_SUPPORTED
-#define _raw_write_lock(rw)                                                     \
+#define __raw_write_lock(rw)                                                    \
 do {                                                                            \
         __asm__ __volatile__ (                                                  \
                 "mov ar.ccv = r0\n"                                             \
@@ -170,7 +153,7 @@ do {										\
                 :: "r"(rw) : "ar.ccv", "p7", "r2", "r29", "memory");            \
 } while(0)
 
-#define _raw_write_trylock(rw)                                                  \
+#define __raw_write_trylock(rw)                                                 \
 ({                                                                              \
         register long result;                                                   \
                                                                                 \
@@ -182,7 +165,7 @@ do {										\
         (result == 0);                                                          \
 })
 
-static inline void _raw_write_unlock(rwlock_t *x)
+static inline void __raw_write_unlock(raw_rwlock_t *x)
 {
         u8 *y = (u8 *)x;
         barrier();
@@ -191,7 +174,7 @@ static inline void _raw_write_unlock(rwlock_t *x)
 
 #else /* !ASM_SUPPORTED */
 
-#define _raw_write_lock(l)                                                              \
+#define __raw_write_lock(l)                                                             \
 ({                                                                                      \
         __u64 ia64_val, ia64_set_val = ia64_dep_mi(-1, 0, 31, 1);                       \
         __u32 *ia64_write_lock_ptr = (__u32 *) (l);                                     \
@@ -202,7 +185,7 @@ static inline void _raw_write_unlock(rwlock_t *x)
         } while (ia64_val);                                                             \
 })
 
-#define _raw_write_trylock(rw)                                          \
+#define __raw_write_trylock(rw)                                         \
 ({                                                                      \
         __u64 ia64_val;                                                 \
         __u64 ia64_set_val = ia64_dep_mi(-1, 0, 31,1);                  \
@@ -210,7 +193,7 @@ static inline void _raw_write_unlock(rwlock_t *x)
         (ia64_val == 0);                                                \
 })
 
-static inline void _raw_write_unlock(rwlock_t *x)
+static inline void __raw_write_unlock(raw_rwlock_t *x)
 {
         barrier();
         x->write_lock = 0;
@@ -218,6 +201,6 @@ static inline void _raw_write_unlock(rwlock_t *x)
 
 #endif /* !ASM_SUPPORTED */
 
-#define _raw_read_trylock(lock) generic_raw_read_trylock(lock)
+#define __raw_read_trylock(lock) generic__raw_read_trylock(lock)
 
 #endif /*  _ASM_IA64_SPINLOCK_H */
diff --git a/include/asm-ia64/spinlock_types.h b/include/asm-ia64/spinlock_types.h
new file mode 100644
index 000000000000..474e46f1ab4a
--- /dev/null
+++ b/include/asm-ia64/spinlock_types.h
@@ -0,0 +1,21 @@
+#ifndef _ASM_IA64_SPINLOCK_TYPES_H
+#define _ASM_IA64_SPINLOCK_TYPES_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+typedef struct {
+        volatile unsigned int lock;
+} raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED        { 0 }
+
+typedef struct {
+        volatile unsigned int read_counter      : 31;
+        volatile unsigned int write_lock        :  1;
+} raw_rwlock_t;
+
+#define __RAW_RW_LOCK_UNLOCKED          { 0, 0 }
+
+#endif
diff --git a/include/asm-ia64/system.h b/include/asm-ia64/system.h
index 33256db4a7cf..635235fa1e32 100644
--- a/include/asm-ia64/system.h
+++ b/include/asm-ia64/system.h
@@ -275,6 +275,7 @@ extern void ia64_load_extra (struct task_struct *task);
  */
 #define __ARCH_WANT_UNLOCKED_CTXSW
 
+#define ARCH_HAS_PREFETCH_SWITCH_STACK
 #define ia64_platform_is(x) (strcmp(x, platform_name) == 0)
 
 void cpu_idle_wait(void);
diff --git a/include/asm-ia64/thread_info.h b/include/asm-ia64/thread_info.h
index 7dc8951708a3..cf4a950a0f4f 100644
--- a/include/asm-ia64/thread_info.h
+++ b/include/asm-ia64/thread_info.h
@@ -5,7 +5,7 @@
 #ifndef _ASM_IA64_THREAD_INFO_H
 #define _ASM_IA64_THREAD_INFO_H
 
-#include <asm/offsets.h>
+#include <asm/asm-offsets.h>
 #include <asm/processor.h>
 #include <asm/ptrace.h>
 
@@ -76,6 +76,7 @@ struct thread_info {
 #define TIF_SIGDELAYED          5       /* signal delayed from MCA/INIT/NMI/PMI context */
 #define TIF_POLLING_NRFLAG      16      /* true if poll_idle() is polling TIF_NEED_RESCHED */
 #define TIF_MEMDIE              17
+#define TIF_MCA_INIT            18      /* this task is processing MCA or INIT */
 
 #define _TIF_SYSCALL_TRACE      (1 << TIF_SYSCALL_TRACE)
 #define _TIF_SYSCALL_AUDIT      (1 << TIF_SYSCALL_AUDIT)
@@ -85,6 +86,7 @@ struct thread_info {
 #define _TIF_NEED_RESCHED       (1 << TIF_NEED_RESCHED)
 #define _TIF_SIGDELAYED (1 << TIF_SIGDELAYED)
 #define _TIF_POLLING_NRFLAG     (1 << TIF_POLLING_NRFLAG)
+#define _TIF_MCA_INIT           (1 << TIF_MCA_INIT)
 
 /* "work to do on user-return" bits */
 #define TIF_ALLWORK_MASK        (_TIF_NOTIFY_RESUME|_TIF_SIGPENDING|_TIF_NEED_RESCHED|_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SIGDELAYED)
diff --git a/include/asm-ia64/unwind.h b/include/asm-ia64/unwind.h
index 61426ad3ecdb..5df0276b0493 100644
--- a/include/asm-ia64/unwind.h
+++ b/include/asm-ia64/unwind.h
@@ -114,13 +114,6 @@ extern void unw_remove_unwind_table (void *handle);
  */
 extern void unw_init_from_blocked_task (struct unw_frame_info *info, struct task_struct *t);
 
-/*
- * Prepare to unwind from interruption.  The pt-regs and switch-stack structures must have
- * be "adjacent" (no state modifications between pt-regs and switch-stack).
- */
-extern void unw_init_from_interruption (struct unw_frame_info *info, struct task_struct *t,
-                                        struct pt_regs *pt, struct switch_stack *sw);
-
 extern void unw_init_frame_info (struct unw_frame_info *info, struct task_struct *t,
                                  struct switch_stack *sw);
 
diff --git a/include/asm-m32r/spinlock.h b/include/asm-m32r/spinlock.h
index 6608d8371c50..7de7def28da9 100644
--- a/include/asm-m32r/spinlock.h
+++ b/include/asm-m32r/spinlock.h
@@ -14,57 +14,30 @@
 #include <asm/atomic.h>
 #include <asm/page.h>
 
-extern int printk(const char * fmt, ...)
-        __attribute__ ((format (printf, 1, 2)));
-
-#define RW_LOCK_BIAS             0x01000000
-#define RW_LOCK_BIAS_STR        "0x01000000"
-
 /*
  * Your basic SMP spinlocks, allowing only a single CPU anywhere
- */
-
-typedef struct {
-        volatile int slock;
-#ifdef CONFIG_DEBUG_SPINLOCK
-        unsigned magic;
-#endif
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} spinlock_t;
-
-#define SPINLOCK_MAGIC  0xdead4ead
-
-#ifdef CONFIG_DEBUG_SPINLOCK
-#define SPINLOCK_MAGIC_INIT     , SPINLOCK_MAGIC
-#else
-#define SPINLOCK_MAGIC_INIT     /* */
-#endif
-
-#define SPIN_LOCK_UNLOCKED (spinlock_t) { 1 SPINLOCK_MAGIC_INIT }
-
-#define spin_lock_init(x)       do { *(x) = SPIN_LOCK_UNLOCKED; } while(0)
-
-/*
+ *
+ * (the type definitions are in asm/spinlock_types.h)
+ *
  * Simple spin lock operations.  There are two variants, one clears IRQ's
  * on the local processor, one does not.
  *
  * We make no fairness assumptions. They have a cost.
  */
 
-#define spin_is_locked(x)       (*(volatile int *)(&(x)->slock) <= 0)
-#define spin_unlock_wait(x)     do { barrier(); } while(spin_is_locked(x))
-#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
+#define __raw_spin_is_locked(x)         (*(volatile int *)(&(x)->slock) <= 0)
+#define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)
+#define __raw_spin_unlock_wait(x) \
+                do { cpu_relax(); } while (__raw_spin_is_locked(x))
 
 /**
- * _raw_spin_trylock - Try spin lock and return a result
+ * __raw_spin_trylock - Try spin lock and return a result
  * @lock: Pointer to the lock variable
  *
- * _raw_spin_trylock() tries to get the lock and returns a result.
+ * __raw_spin_trylock() tries to get the lock and returns a result.
  * On the m32r, the result value is 1 (= Success) or 0 (= Failure).
  */
-static inline int _raw_spin_trylock(spinlock_t *lock)
+static inline int __raw_spin_trylock(raw_spinlock_t *lock)
 {
         int oldval;
         unsigned long tmp1, tmp2;
@@ -78,7 +51,7 @@ static inline int _raw_spin_trylock(spinlock_t *lock)
          * }
          */
         __asm__ __volatile__ (
-                "# spin_trylock                 \n\t"
+                "# __raw_spin_trylock           \n\t"
                 "ldi    %1, #0;                 \n\t"
                 "mvfc   %2, psw;                \n\t"
                 "clrpsw #0x40 -> nop;           \n\t"
@@ -97,16 +70,10 @@ static inline int _raw_spin_trylock(spinlock_t *lock)
         return (oldval > 0);
 }
 
-static inline void _raw_spin_lock(spinlock_t *lock)
+static inline void __raw_spin_lock(raw_spinlock_t *lock)
 {
         unsigned long tmp0, tmp1;
 
-#ifdef CONFIG_DEBUG_SPINLOCK
-        if (unlikely(lock->magic != SPINLOCK_MAGIC)) {
-                printk("pc: %p\n", __builtin_return_address(0));
-                BUG();
-        }
-#endif
         /*
          * lock->slock :  =1 : unlock
          *             : <=0 : lock
@@ -118,7 +85,7 @@ static inline void _raw_spin_lock(spinlock_t *lock)
          * }
          */
         __asm__ __volatile__ (
-                "# spin_lock                    \n\t"
+                "# __raw_spin_lock              \n\t"
                 ".fillinsn                      \n"
                 "1:                             \n\t"
                 "mvfc   %1, psw;                \n\t"
@@ -145,12 +112,8 @@ static inline void _raw_spin_lock(spinlock_t *lock)
         );
 }
 
-static inline void _raw_spin_unlock(spinlock_t *lock)
+static inline void __raw_spin_unlock(raw_spinlock_t *lock)
 {
-#ifdef CONFIG_DEBUG_SPINLOCK
-        BUG_ON(lock->magic != SPINLOCK_MAGIC);
-        BUG_ON(!spin_is_locked(lock));
-#endif
         mb();
         lock->slock = 1;
 }
@@ -164,59 +127,32 @@ static inline void _raw_spin_unlock(spinlock_t *lock)
  * can "mix" irq-safe locks - any writer needs to get a
  * irq-safe write-lock, but readers can get non-irqsafe
  * read-locks.
+ *
+ * On x86, we implement read-write locks as a 32-bit counter
+ * with the high bit (sign) being the "contended" bit.
+ *
+ * The inline assembly is non-obvious. Think about it.
+ *
+ * Changed to use the same technique as rw semaphores.  See
+ * semaphore.h for details.  -ben
  */
-typedef struct {
-        volatile int lock;
-#ifdef CONFIG_DEBUG_SPINLOCK
-        unsigned magic;
-#endif
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} rwlock_t;
-
-#define RWLOCK_MAGIC    0xdeaf1eed
-
-#ifdef CONFIG_DEBUG_SPINLOCK
-#define RWLOCK_MAGIC_INIT       , RWLOCK_MAGIC
-#else
-#define RWLOCK_MAGIC_INIT       /* */
-#endif
-
-#define RW_LOCK_UNLOCKED (rwlock_t) { RW_LOCK_BIAS RWLOCK_MAGIC_INIT }
-
-#define rwlock_init(x)  do { *(x) = RW_LOCK_UNLOCKED; } while(0)
 
 /**
  * read_can_lock - would read_trylock() succeed?
  * @lock: the rwlock in question.
  */
-#define read_can_lock(x) ((int)(x)->lock > 0)
+#define __raw_read_can_lock(x) ((int)(x)->lock > 0)
 
 /**
  * write_can_lock - would write_trylock() succeed?
  * @lock: the rwlock in question.
  */
-#define write_can_lock(x) ((x)->lock == RW_LOCK_BIAS)
-
-/*
- * On x86, we implement read-write locks as a 32-bit counter
- * with the high bit (sign) being the "contended" bit.
- *
- * The inline assembly is non-obvious. Think about it.
- *
- * Changed to use the same technique as rw semaphores.  See
- * semaphore.h for details.  -ben
- */
-/* the spinlock helpers are in arch/i386/kernel/semaphore.c */
+#define __raw_write_can_lock(x) ((x)->lock == RW_LOCK_BIAS)
 
-static inline void _raw_read_lock(rwlock_t *rw)
+static inline void __raw_read_lock(raw_rwlock_t *rw)
 {
         unsigned long tmp0, tmp1;
 
-#ifdef CONFIG_DEBUG_SPINLOCK
-        BUG_ON(rw->magic != RWLOCK_MAGIC);
-#endif
         /*
          * rw->lock :  >0 : unlock
          *          : <=0 : lock
@@ -264,13 +200,10 @@ static inline void _raw_read_lock(rwlock_t *rw)
         );
 }
 
-static inline void _raw_write_lock(rwlock_t *rw)
+static inline void __raw_write_lock(raw_rwlock_t *rw)
 {
         unsigned long tmp0, tmp1, tmp2;
 
-#ifdef CONFIG_DEBUG_SPINLOCK
-        BUG_ON(rw->magic != RWLOCK_MAGIC);
-#endif
         /*
          * rw->lock :  =RW_LOCK_BIAS_STR : unlock
          *          : !=RW_LOCK_BIAS_STR : lock
@@ -320,7 +253,7 @@ static inline void _raw_write_lock(rwlock_t *rw)
         );
 }
 
-static inline void _raw_read_unlock(rwlock_t *rw)
+static inline void __raw_read_unlock(raw_rwlock_t *rw)
 {
         unsigned long tmp0, tmp1;
 
@@ -342,7 +275,7 @@ static inline void _raw_read_unlock(rwlock_t *rw)
         );
 }
 
-static inline void _raw_write_unlock(rwlock_t *rw)
+static inline void __raw_write_unlock(raw_rwlock_t *rw)
 {
         unsigned long tmp0, tmp1, tmp2;
 
@@ -366,9 +299,9 @@ static inline void _raw_write_unlock(rwlock_t *rw)
         );
 }
 
-#define _raw_read_trylock(lock) generic_raw_read_trylock(lock)
+#define __raw_read_trylock(lock) generic__raw_read_trylock(lock)
 
-static inline int _raw_write_trylock(rwlock_t *lock)
+static inline int __raw_write_trylock(raw_rwlock_t *lock)
 {
         atomic_t *count = (atomic_t *)lock;
         if (atomic_sub_and_test(RW_LOCK_BIAS, count))
diff --git a/include/asm-m32r/spinlock_types.h b/include/asm-m32r/spinlock_types.h
new file mode 100644
index 000000000000..7e9941c45f40
--- /dev/null
+++ b/include/asm-m32r/spinlock_types.h
@@ -0,0 +1,23 @@
+#ifndef _ASM_M32R_SPINLOCK_TYPES_H
+#define _ASM_M32R_SPINLOCK_TYPES_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+typedef struct {
+        volatile int slock;
+} raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED        { 1 }
+
+typedef struct {
+        volatile int lock;
+} raw_rwlock_t;
+
+#define RW_LOCK_BIAS                    0x01000000
+#define RW_LOCK_BIAS_STR                "0x01000000"
+
+#define __RAW_RW_LOCK_UNLOCKED          { RW_LOCK_BIAS }
+
+#endif
diff --git a/include/asm-m68knommu/bitops.h b/include/asm-m68knommu/bitops.h
index f95e32b40425..c42f88a9b9f9 100644
--- a/include/asm-m68knommu/bitops.h
+++ b/include/asm-m68knommu/bitops.h
@@ -259,7 +259,7 @@ static __inline__ int __test_bit(int nr, const volatile unsigned long * addr)
 #define find_first_bit(addr, size) \
         find_next_bit((addr), (size), 0)
 
-static __inline__ int find_next_zero_bit (void * addr, int size, int offset)
+static __inline__ int find_next_zero_bit (const void * addr, int size, int offset)
 {
         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
         unsigned long result = offset & ~31UL;
diff --git a/include/asm-m68knommu/checksum.h b/include/asm-m68knommu/checksum.h
index 92cf102c2534..294ec7583ac9 100644
--- a/include/asm-m68knommu/checksum.h
+++ b/include/asm-m68knommu/checksum.h
@@ -25,7 +25,8 @@ unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum)
  * better 64-bit) boundary
  */
 
-unsigned int csum_partial_copy(const char *src, char *dst, int len, int sum);
+unsigned int csum_partial_copy(const unsigned char *src, unsigned char *dst,
+        int len, int sum);
 
 
 /*
@@ -35,8 +36,8 @@ unsigned int csum_partial_copy(const char *src, char *dst, int len, int sum);
  * better 64-bit) boundary
  */
 
-extern unsigned int csum_partial_copy_from_user(const char *src, char *dst,
-                                                int len, int sum, int *csum_err);
+extern unsigned int csum_partial_copy_from_user(const unsigned char *src,
+        unsigned char *dst, int len, int sum, int *csum_err);
 
 #define csum_partial_copy_nocheck(src, dst, len, sum)   \
         csum_partial_copy((src), (dst), (len), (sum))
diff --git a/include/asm-m68knommu/m527xsim.h b/include/asm-m68knommu/m527xsim.h
index d280d013da03..e7878d0f7d7a 100644
--- a/include/asm-m68knommu/m527xsim.h
+++ b/include/asm-m68knommu/m527xsim.h
@@ -37,13 +37,14 @@
 /*
  *      SDRAM configuration registers.
  */
-#ifdef CONFIG_M5271EVB
+#ifdef CONFIG_M5271
 #define MCFSIM_DCR              0x40            /* SDRAM control */
 #define MCFSIM_DACR0            0x48            /* SDRAM base address 0 */
 #define MCFSIM_DMR0             0x4c            /* SDRAM address mask 0 */
 #define MCFSIM_DACR1            0x50            /* SDRAM base address 1 */
 #define MCFSIM_DMR1             0x54            /* SDRAM address mask 1 */
-#else
+#endif
+#ifdef CONFIG_M5275
 #define MCFSIM_DMR              0x40            /* SDRAM mode */
 #define MCFSIM_DCR              0x44            /* SDRAM control */
 #define MCFSIM_DCFG1            0x48            /* SDRAM configuration 1 */
@@ -54,5 +55,21 @@
 #define MCFSIM_DMR1             0x5c            /* SDRAM address mask 1 */
 #endif
 
+/*
+ *      GPIO pins setups to enable the UARTs.
+ */
+#ifdef CONFIG_M5271
+#define MCF_GPIO_PAR_UART       0x100048        /* PAR UART address */
+#define UART0_ENABLE_MASK       0x000f
+#define UART1_ENABLE_MASK       0x0ff0
+#define UART2_ENABLE_MASK       0x3000
+#endif
+#ifdef CONFIG_M5275
+#define MCF_GPIO_PAR_UART       0x10007c        /* PAR UART address */
+#define UART0_ENABLE_MASK       0x000f
+#define UART1_ENABLE_MASK       0x00f0
+#define UART2_ENABLE_MASK       0x3f00 
+#endif
+
 /****************************************************************************/
 #endif  /* m527xsim_h */
diff --git a/include/asm-m68knommu/m528xsim.h b/include/asm-m68knommu/m528xsim.h
index 371993a206ac..610774a17f70 100644
--- a/include/asm-m68knommu/m528xsim.h
+++ b/include/asm-m68knommu/m528xsim.h
@@ -41,5 +41,117 @@
 #define MCFSIM_DACR1            0x50            /* SDRAM base address 1 */
 #define MCFSIM_DMR1             0x54            /* SDRAM address mask 1 */
 
+/*
+ *      Derek Cheung - 6 Feb 2005
+ *              add I2C and QSPI register definition using Freescale's MCF5282
+ */
+/* set Port AS pin for I2C or UART */
+#define MCF5282_GPIO_PASPAR     (volatile u16 *) (MCF_IPSBAR + 0x00100056)
+
+/* Interrupt Mask Register Register Low */ 
+#define MCF5282_INTC0_IMRL      (volatile u32 *) (MCF_IPSBAR + 0x0C0C)
+/* Interrupt Control Register 7 */
+#define MCF5282_INTC0_ICR17     (volatile u8 *) (MCF_IPSBAR + 0x0C51)
+
+
+
+/*********************************************************************
+*
+* Inter-IC (I2C) Module
+*
+*********************************************************************/
+/* Read/Write access macros for general use */
+#define MCF5282_I2C_I2ADR       (volatile u8 *) (MCF_IPSBAR + 0x0300) // Address 
+#define MCF5282_I2C_I2FDR       (volatile u8 *) (MCF_IPSBAR + 0x0304) // Freq Divider
+#define MCF5282_I2C_I2CR        (volatile u8 *) (MCF_IPSBAR + 0x0308) // Control
+#define MCF5282_I2C_I2SR        (volatile u8 *) (MCF_IPSBAR + 0x030C) // Status
+#define MCF5282_I2C_I2DR        (volatile u8 *) (MCF_IPSBAR + 0x0310) // Data I/O
+
+/* Bit level definitions and macros */
+#define MCF5282_I2C_I2ADR_ADDR(x)                       (((x)&0x7F)<<0x01)
+
+#define MCF5282_I2C_I2FDR_IC(x)                         (((x)&0x3F))
+
+#define MCF5282_I2C_I2CR_IEN    (0x80)  // I2C enable
+#define MCF5282_I2C_I2CR_IIEN   (0x40)  // interrupt enable
+#define MCF5282_I2C_I2CR_MSTA   (0x20)  // master/slave mode
+#define MCF5282_I2C_I2CR_MTX    (0x10)  // transmit/receive mode
+#define MCF5282_I2C_I2CR_TXAK   (0x08)  // transmit acknowledge enable
+#define MCF5282_I2C_I2CR_RSTA   (0x04)  // repeat start
+
+#define MCF5282_I2C_I2SR_ICF    (0x80)  // data transfer bit
+#define MCF5282_I2C_I2SR_IAAS   (0x40)  // I2C addressed as a slave
+#define MCF5282_I2C_I2SR_IBB    (0x20)  // I2C bus busy
+#define MCF5282_I2C_I2SR_IAL    (0x10)  // aribitration lost
+#define MCF5282_I2C_I2SR_SRW    (0x04)  // slave read/write
+#define MCF5282_I2C_I2SR_IIF    (0x02)  // I2C interrupt
+#define MCF5282_I2C_I2SR_RXAK   (0x01)  // received acknowledge
+
+
+
+/*********************************************************************
+*
+* Queued Serial Peripheral Interface (QSPI) Module
+*
+*********************************************************************/
+/* Derek - 21 Feb 2005 */
+/* change to the format used in I2C */
+/* Read/Write access macros for general use */
+#define MCF5282_QSPI_QMR        MCF_IPSBAR + 0x0340
+#define MCF5282_QSPI_QDLYR      MCF_IPSBAR + 0x0344
+#define MCF5282_QSPI_QWR        MCF_IPSBAR + 0x0348
+#define MCF5282_QSPI_QIR        MCF_IPSBAR + 0x034C
+#define MCF5282_QSPI_QAR        MCF_IPSBAR + 0x0350
+#define MCF5282_QSPI_QDR        MCF_IPSBAR + 0x0354
+#define MCF5282_QSPI_QCR        MCF_IPSBAR + 0x0354
+
+/* Bit level definitions and macros */
+#define MCF5282_QSPI_QMR_MSTR                           (0x8000)
+#define MCF5282_QSPI_QMR_DOHIE                          (0x4000)
+#define MCF5282_QSPI_QMR_BITS_16                        (0x0000)
+#define MCF5282_QSPI_QMR_BITS_8                         (0x2000)
+#define MCF5282_QSPI_QMR_BITS_9                         (0x2400)
+#define MCF5282_QSPI_QMR_BITS_10                        (0x2800)
+#define MCF5282_QSPI_QMR_BITS_11                        (0x2C00)
+#define MCF5282_QSPI_QMR_BITS_12                        (0x3000)
+#define MCF5282_QSPI_QMR_BITS_13                        (0x3400)
+#define MCF5282_QSPI_QMR_BITS_14                        (0x3800)
+#define MCF5282_QSPI_QMR_BITS_15                        (0x3C00)
+#define MCF5282_QSPI_QMR_CPOL                           (0x0200)
+#define MCF5282_QSPI_QMR_CPHA                           (0x0100)
+#define MCF5282_QSPI_QMR_BAUD(x)                        (((x)&0x00FF))
+
+#define MCF5282_QSPI_QDLYR_SPE                          (0x80)
+#define MCF5282_QSPI_QDLYR_QCD(x)                       (((x)&0x007F)<<8)
+#define MCF5282_QSPI_QDLYR_DTL(x)                       (((x)&0x00FF))
+
+#define MCF5282_QSPI_QWR_HALT                           (0x8000)
+#define MCF5282_QSPI_QWR_WREN                           (0x4000)
+#define MCF5282_QSPI_QWR_WRTO                           (0x2000)
+#define MCF5282_QSPI_QWR_CSIV                           (0x1000)
+#define MCF5282_QSPI_QWR_ENDQP(x)                       (((x)&0x000F)<<8)
+#define MCF5282_QSPI_QWR_CPTQP(x)                       (((x)&0x000F)<<4)
+#define MCF5282_QSPI_QWR_NEWQP(x)                       (((x)&0x000F))
+
+#define MCF5282_QSPI_QIR_WCEFB                          (0x8000)
+#define MCF5282_QSPI_QIR_ABRTB                          (0x4000)
+#define MCF5282_QSPI_QIR_ABRTL                          (0x1000)
+#define MCF5282_QSPI_QIR_WCEFE                          (0x0800)
+#define MCF5282_QSPI_QIR_ABRTE                          (0x0400)
+#define MCF5282_QSPI_QIR_SPIFE                          (0x0100)
+#define MCF5282_QSPI_QIR_WCEF                           (0x0008)
+#define MCF5282_QSPI_QIR_ABRT                           (0x0004)
+#define MCF5282_QSPI_QIR_SPIF                           (0x0001)
+
+#define MCF5282_QSPI_QAR_ADDR(x)                        (((x)&0x003F))
+
+#define MCF5282_QSPI_QDR_COMMAND(x)                     (((x)&0xFF00))
+#define MCF5282_QSPI_QCR_DATA(x)                        (((x)&0x00FF)<<8)
+#define MCF5282_QSPI_QCR_CONT                           (0x8000)
+#define MCF5282_QSPI_QCR_BITSE                          (0x4000)
+#define MCF5282_QSPI_QCR_DT                             (0x2000)
+#define MCF5282_QSPI_QCR_DSCK                           (0x1000)
+#define MCF5282_QSPI_QCR_CS                             (((x)&0x000F)<<8)
+
 /****************************************************************************/
 #endif  /* m528xsim_h */
diff --git a/include/asm-m68knommu/mcfcache.h b/include/asm-m68knommu/mcfcache.h
index bdd8c53ef34c..b17cd920977f 100644
--- a/include/asm-m68knommu/mcfcache.h
+++ b/include/asm-m68knommu/mcfcache.h
@@ -33,7 +33,7 @@
 .endm
 #endif /* CONFIG_M5206 || CONFIG_M5206e || CONFIG_M5272 */
 
-#if defined(CONFIG_M527x)
+#if defined(CONFIG_M523x) || defined(CONFIG_M527x)
 /*
  *      New version 2 cores have a configurable split cache arrangement.
  *      For now I am just enabling instruction cache - but ultimately I
@@ -51,23 +51,20 @@
         movec   %d0,%CACR               /* enable cache */
         nop
 .endm
-#endif /* CONFIG_M527x */
+#endif /* CONFIG_M523x || CONFIG_M527x */
 
 #if defined(CONFIG_M528x)
-/*
- *      Cache is totally broken on early 5282 silicon. So far now we
- *      disable its cache all together.
- */
 .macro CACHE_ENABLE
-        movel   #0x01000000,%d0
-        movec   %d0,%CACR               /* invalidate cache */
         nop
-        movel   #0x0000c000,%d0         /* set SDRAM cached only */
-        movec   %d0,%ACR0
-        movel   #0x00000000,%d0         /* no other regions cached */
-        movec   %d0,%ACR1
-        movel   #0x00000000,%d0         /* configure cache */
-        movec   %d0,%CACR               /* enable cache */
+        movel   #0x01000000, %d0
+        movec   %d0, %CACR              /* Invalidate cache */
+        nop
+        movel   #0x0000c020, %d0        /* Set SDRAM cached only */
+        movec   %d0, %ACR0
+        movel   #0xff00c000, %d0        /* Cache Flash also */
+        movec   %d0, %ACR1
+        movel   #0x80000200, %d0        /* Setup cache mask */
+        movec   %d0, %CACR              /* Enable cache */
         nop
 .endm
 #endif /* CONFIG_M528x */
diff --git a/include/asm-m68knommu/mcfdma.h b/include/asm-m68knommu/mcfdma.h
index 350c6090b5c1..b93f8ba8a248 100644
--- a/include/asm-m68knommu/mcfdma.h
+++ b/include/asm-m68knommu/mcfdma.h
@@ -21,7 +21,7 @@
 #define MCFDMA_BASE1            0x240           /* Base address of DMA 1 */
 #elif defined(CONFIG_M5272)
 #define MCFDMA_BASE0            0x0e0           /* Base address of DMA 0 */
-#elif defined(CONFIG_M527x) || defined(CONFIG_M528x)
+#elif defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x)
 /* These are relative to the IPSBAR, not MBAR */
 #define MCFDMA_BASE0            0x100           /* Base address of DMA 0 */
 #define MCFDMA_BASE1            0x140           /* Base address of DMA 1 */
diff --git a/include/asm-mips/asmmacro-32.h b/include/asm-mips/asmmacro-32.h
index ac8823df2554..11daf5ceb7b4 100644
--- a/include/asm-mips/asmmacro-32.h
+++ b/include/asm-mips/asmmacro-32.h
@@ -7,7 +7,7 @@
 #ifndef _ASM_ASMMACRO_32_H
 #define _ASM_ASMMACRO_32_H
 
-#include <asm/offset.h>
+#include <asm/asm-offsets.h>
 #include <asm/regdef.h>
 #include <asm/fpregdef.h>
 #include <asm/mipsregs.h>
diff --git a/include/asm-mips/asmmacro-64.h b/include/asm-mips/asmmacro-64.h
index bbed35511f5a..559c355b9b86 100644
--- a/include/asm-mips/asmmacro-64.h
+++ b/include/asm-mips/asmmacro-64.h
@@ -8,7 +8,7 @@
 #ifndef _ASM_ASMMACRO_64_H
 #define _ASM_ASMMACRO_64_H
 
-#include <asm/offset.h>
+#include <asm/asm-offsets.h>
 #include <asm/regdef.h>
 #include <asm/fpregdef.h>
 #include <asm/mipsregs.h>
diff --git a/include/asm-mips/irq.h b/include/asm-mips/irq.h
index b90b11d0b886..3f2470e9e678 100644
--- a/include/asm-mips/irq.h
+++ b/include/asm-mips/irq.h
@@ -49,7 +49,4 @@ do {									\
 
 extern void arch_init_irq(void);
 
-struct irqaction;
-int handle_IRQ_event(unsigned int, struct pt_regs *, struct irqaction *);
-
 #endif /* _ASM_IRQ_H */
diff --git a/include/asm-mips/sim.h b/include/asm-mips/sim.h
index 3ccfe09fa744..9c2af1b00e19 100644
--- a/include/asm-mips/sim.h
+++ b/include/asm-mips/sim.h
@@ -11,7 +11,7 @@
 
 #include <linux/config.h>
 
-#include <asm/offset.h>
+#include <asm/asm-offsets.h>
 
 #define __str2(x) #x
 #define __str(x) __str2(x)
diff --git a/include/asm-mips/spinlock.h b/include/asm-mips/spinlock.h
index 114d3eb98a6a..4d0135b11156 100644
--- a/include/asm-mips/spinlock.h
+++ b/include/asm-mips/spinlock.h
@@ -16,20 +16,10 @@
  * Your basic SMP spinlocks, allowing only a single CPU anywhere
  */
 
-typedef struct {
-        volatile unsigned int lock;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} spinlock_t;
-
-#define SPIN_LOCK_UNLOCKED (spinlock_t) { 0 }
-
-#define spin_lock_init(x)       do { (x)->lock = 0; } while(0)
-
-#define spin_is_locked(x)       ((x)->lock != 0)
-#define spin_unlock_wait(x)     do { barrier(); } while ((x)->lock)
-#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
+#define __raw_spin_is_locked(x) ((x)->lock != 0)
+#define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)
+#define __raw_spin_unlock_wait(x) \
+                do { cpu_relax(); } while ((x)->lock)
 
 /*
  * Simple spin lock operations.  There are two variants, one clears IRQ's
@@ -38,13 +28,13 @@ typedef struct {
  * We make no fairness assumptions.  They have a cost.
  */
 
-static inline void _raw_spin_lock(spinlock_t *lock)
+static inline void __raw_spin_lock(raw_spinlock_t *lock)
 {
         unsigned int tmp;
 
         if (R10000_LLSC_WAR) {
                 __asm__ __volatile__(
-                "       .set    noreorder       # _raw_spin_lock        \n"
+                "       .set    noreorder       # __raw_spin_lock       \n"
                 "1:     ll      %1, %2                                  \n"
                 "       bnez    %1, 1b                                  \n"
                 "        li     %1, 1                                   \n"
@@ -58,7 +48,7 @@ static inline void _raw_spin_lock(spinlock_t *lock)
                 : "memory");
         } else {
                 __asm__ __volatile__(
-                "       .set    noreorder       # _raw_spin_lock        \n"
+                "       .set    noreorder       # __raw_spin_lock       \n"
                 "1:     ll      %1, %2                                  \n"
                 "       bnez    %1, 1b                                  \n"
                 "        li     %1, 1                                   \n"
@@ -72,10 +62,10 @@ static inline void _raw_spin_lock(spinlock_t *lock)
         }
 }
 
-static inline void _raw_spin_unlock(spinlock_t *lock)
+static inline void __raw_spin_unlock(raw_spinlock_t *lock)
 {
         __asm__ __volatile__(
-        "       .set    noreorder       # _raw_spin_unlock      \n"
+        "       .set    noreorder       # __raw_spin_unlock     \n"
         "       sync                                            \n"
         "       sw      $0, %0                                  \n"
         "       .set\treorder                                   \n"
@@ -84,13 +74,13 @@ static inline void _raw_spin_unlock(spinlock_t *lock)
         : "memory");
 }
 
-static inline unsigned int _raw_spin_trylock(spinlock_t *lock)
+static inline unsigned int __raw_spin_trylock(raw_spinlock_t *lock)
 {
         unsigned int temp, res;
 
         if (R10000_LLSC_WAR) {
                 __asm__ __volatile__(
-                "       .set    noreorder       # _raw_spin_trylock     \n"
+                "       .set    noreorder       # __raw_spin_trylock    \n"
                 "1:     ll      %0, %3                                  \n"
                 "       ori     %2, %0, 1                               \n"
                 "       sc      %2, %1                                  \n"
@@ -104,7 +94,7 @@ static inline unsigned int _raw_spin_trylock(spinlock_t *lock)
                 : "memory");
         } else {
                 __asm__ __volatile__(
-                "       .set    noreorder       # _raw_spin_trylock     \n"
+                "       .set    noreorder       # __raw_spin_trylock    \n"
                 "1:     ll      %0, %3                                  \n"
                 "       ori     %2, %0, 1                               \n"
                 "       sc      %2, %1                                  \n"
@@ -129,24 +119,13 @@ static inline unsigned int _raw_spin_trylock(spinlock_t *lock)
  * read-locks.
  */
 
-typedef struct {
-        volatile unsigned int lock;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} rwlock_t;
-
-#define RW_LOCK_UNLOCKED (rwlock_t) { 0 }
-
-#define rwlock_init(x)  do { *(x) = RW_LOCK_UNLOCKED; } while(0)
-
-static inline void _raw_read_lock(rwlock_t *rw)
+static inline void __raw_read_lock(raw_rwlock_t *rw)
 {
         unsigned int tmp;
 
         if (R10000_LLSC_WAR) {
                 __asm__ __volatile__(
-                "       .set    noreorder       # _raw_read_lock        \n"
+                "       .set    noreorder       # __raw_read_lock       \n"
                 "1:     ll      %1, %2                                  \n"
                 "       bltz    %1, 1b                                  \n"
                 "        addu   %1, 1                                   \n"
@@ -160,7 +139,7 @@ static inline void _raw_read_lock(rwlock_t *rw)
                 : "memory");
         } else {
                 __asm__ __volatile__(
-                "       .set    noreorder       # _raw_read_lock        \n"
+                "       .set    noreorder       # __raw_read_lock       \n"
                 "1:     ll      %1, %2                                  \n"
                 "       bltz    %1, 1b                                  \n"
                 "        addu   %1, 1                                   \n"
@@ -177,13 +156,13 @@ static inline void _raw_read_lock(rwlock_t *rw)
 /* Note the use of sub, not subu which will make the kernel die with an
    overflow exception if we ever try to unlock an rwlock that is already
    unlocked or is being held by a writer.  */
-static inline void _raw_read_unlock(rwlock_t *rw)
+static inline void __raw_read_unlock(raw_rwlock_t *rw)
 {
         unsigned int tmp;
 
         if (R10000_LLSC_WAR) {
                 __asm__ __volatile__(
-                "1:     ll      %1, %2          # _raw_read_unlock      \n"
+                "1:     ll      %1, %2          # __raw_read_unlock     \n"
                 "       sub     %1, 1                                   \n"
                 "       sc      %1, %0                                  \n"
                 "       beqzl   %1, 1b                                  \n"
@@ -193,7 +172,7 @@ static inline void _raw_read_unlock(rwlock_t *rw)
                 : "memory");
         } else {
                 __asm__ __volatile__(
-                "       .set    noreorder       # _raw_read_unlock      \n"
+                "       .set    noreorder       # __raw_read_unlock     \n"
                 "1:     ll      %1, %2                                  \n"
                 "       sub     %1, 1                                   \n"
                 "       sc      %1, %0                                  \n"
@@ -206,13 +185,13 @@ static inline void _raw_read_unlock(rwlock_t *rw)
         }
 }
 
-static inline void _raw_write_lock(rwlock_t *rw)
+static inline void __raw_write_lock(raw_rwlock_t *rw)
 {
         unsigned int tmp;
 
         if (R10000_LLSC_WAR) {
                 __asm__ __volatile__(
-                "       .set    noreorder       # _raw_write_lock       \n"
+                "       .set    noreorder       # __raw_write_lock      \n"
                 "1:     ll      %1, %2                                  \n"
                 "       bnez    %1, 1b                                  \n"
                 "        lui    %1, 0x8000                              \n"
@@ -226,7 +205,7 @@ static inline void _raw_write_lock(rwlock_t *rw)
                 : "memory");
         } else {
                 __asm__ __volatile__(
-                "       .set    noreorder       # _raw_write_lock       \n"
+                "       .set    noreorder       # __raw_write_lock      \n"
                 "1:     ll      %1, %2                                  \n"
                 "       bnez    %1, 1b                                  \n"
                 "        lui    %1, 0x8000                              \n"
@@ -241,26 +220,26 @@ static inline void _raw_write_lock(rwlock_t *rw)
         }
 }
 
-static inline void _raw_write_unlock(rwlock_t *rw)
+static inline void __raw_write_unlock(raw_rwlock_t *rw)
 {
         __asm__ __volatile__(
-        "       sync                    # _raw_write_unlock     \n"
+        "       sync                    # __raw_write_unlock    \n"
         "       sw      $0, %0                                  \n"
         : "=m" (rw->lock)
         : "m" (rw->lock)
         : "memory");
 }
 
-#define _raw_read_trylock(lock) generic_raw_read_trylock(lock)
+#define __raw_read_trylock(lock) generic__raw_read_trylock(lock)
 
-static inline int _raw_write_trylock(rwlock_t *rw)
+static inline int __raw_write_trylock(raw_rwlock_t *rw)
 {
         unsigned int tmp;
         int ret;
 
         if (R10000_LLSC_WAR) {
                 __asm__ __volatile__(
-                "       .set    noreorder       # _raw_write_trylock    \n"
+                "       .set    noreorder       # __raw_write_trylock   \n"
                 "       li      %2, 0                                   \n"
                 "1:     ll      %1, %3                                  \n"
                 "       bnez    %1, 2f                                  \n"
@@ -277,7 +256,7 @@ static inline int _raw_write_trylock(rwlock_t *rw)
                 : "memory");
         } else {
                 __asm__ __volatile__(
-                "       .set    noreorder       # _raw_write_trylock    \n"
+                "       .set    noreorder       # __raw_write_trylock   \n"
                 "       li      %2, 0                                   \n"
                 "1:     ll      %1, %3                                  \n"
                 "       bnez    %1, 2f                                  \n"
diff --git a/include/asm-mips/spinlock_types.h b/include/asm-mips/spinlock_types.h
new file mode 100644
index 000000000000..ce26c5048b15
--- /dev/null
+++ b/include/asm-mips/spinlock_types.h
@@ -0,0 +1,20 @@
+#ifndef _ASM_SPINLOCK_TYPES_H
+#define _ASM_SPINLOCK_TYPES_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+typedef struct {
+        volatile unsigned int lock;
+} raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED        { 0 }
+
+typedef struct {
+        volatile unsigned int lock;
+} raw_rwlock_t;
+
+#define __RAW_RW_LOCK_UNLOCKED          { 0 }
+
+#endif
diff --git a/include/asm-mips/stackframe.h b/include/asm-mips/stackframe.h
index fb42f99f8527..7b5e64600bc8 100644
--- a/include/asm-mips/stackframe.h
+++ b/include/asm-mips/stackframe.h
@@ -15,7 +15,7 @@
 
 #include <asm/asm.h>
 #include <asm/mipsregs.h>
-#include <asm/offset.h>
+#include <asm/asm-offsets.h>
 
                 .macro  SAVE_AT
                 .set    push
diff --git a/include/asm-mips/vr41xx/tb0287.h b/include/asm-mips/vr41xx/tb0287.h
new file mode 100644
index 000000000000..dd9832313afe
--- /dev/null
+++ b/include/asm-mips/vr41xx/tb0287.h
@@ -0,0 +1,43 @@
+/*
+ *  tb0287.h, Include file for TANBAC TB0287 mini-ITX board.
+ *
+ *  Copyright (C) 2005  Media Lab Inc. <ito@mlb.co.jp>
+ *
+ *  This code is largely based on tb0219.h.
+ *
+ *  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 __TANBAC_TB0287_H
+#define __TANBAC_TB0287_H
+
+#include <asm/vr41xx/vr41xx.h>
+
+/*
+ * General-Purpose I/O Pin Number
+ */
+#define TB0287_PCI_SLOT_PIN             2
+#define TB0287_SM501_PIN                3
+#define TB0287_SIL680A_PIN              8
+#define TB0287_RTL8110_PIN              13
+
+/*
+ * Interrupt Number
+ */
+#define TB0287_PCI_SLOT_IRQ             GIU_IRQ(TB0287_PCI_SLOT_PIN)
+#define TB0287_SM501_IRQ                GIU_IRQ(TB0287_SM501_PIN)
+#define TB0287_SIL680A_IRQ              GIU_IRQ(TB0287_SIL680A_PIN)
+#define TB0287_RTL8110_IRQ              GIU_IRQ(TB0287_RTL8110_PIN)
+
+#endif /* __TANBAC_TB0287_H */
diff --git a/include/asm-parisc/assembly.h b/include/asm-parisc/assembly.h
index cbc286f49b36..30b023411fef 100644
--- a/include/asm-parisc/assembly.h
+++ b/include/asm-parisc/assembly.h
@@ -63,7 +63,7 @@
         .level 2.0w
 #endif
 
-#include <asm/offsets.h>
+#include <asm/asm-offsets.h>
 #include <asm/page.h>
 
 #include <asm/asmregs.h>
diff --git a/include/asm-parisc/atomic.h b/include/asm-parisc/atomic.h
index e24f7579adb0..048a2c7fd0c0 100644
--- a/include/asm-parisc/atomic.h
+++ b/include/asm-parisc/atomic.h
@@ -24,19 +24,19 @@
 #  define ATOMIC_HASH_SIZE 4
 #  define ATOMIC_HASH(a) (&(__atomic_hash[ (((unsigned long) a)/L1_CACHE_BYTES) & (ATOMIC_HASH_SIZE-1) ]))
 
-extern spinlock_t __atomic_hash[ATOMIC_HASH_SIZE] __lock_aligned;
+extern raw_spinlock_t __atomic_hash[ATOMIC_HASH_SIZE] __lock_aligned;
 
-/* Can't use _raw_spin_lock_irq because of #include problems, so
+/* Can't use raw_spin_lock_irq because of #include problems, so
  * this is the substitute */
 #define _atomic_spin_lock_irqsave(l,f) do {     \
-        spinlock_t *s = ATOMIC_HASH(l);         \
+        raw_spinlock_t *s = ATOMIC_HASH(l);             \
         local_irq_save(f);                      \
-        _raw_spin_lock(s);                      \
+        __raw_spin_lock(s);                     \
 } while(0)
 
 #define _atomic_spin_unlock_irqrestore(l,f) do {        \
-        spinlock_t *s = ATOMIC_HASH(l);                 \
-        _raw_spin_unlock(s);                            \
+        raw_spinlock_t *s = ATOMIC_HASH(l);                     \
+        __raw_spin_unlock(s);                           \
         local_irq_restore(f);                           \
 } while(0)
 
diff --git a/include/asm-parisc/bitops.h b/include/asm-parisc/bitops.h
index 928e5ef850bd..af7db694b22d 100644
--- a/include/asm-parisc/bitops.h
+++ b/include/asm-parisc/bitops.h
@@ -2,7 +2,7 @@
 #define _PARISC_BITOPS_H
 
 #include <linux/compiler.h>
-#include <asm/system.h>
+#include <asm/spinlock.h>
 #include <asm/byteorder.h>
 #include <asm/atomic.h>
 
diff --git a/include/asm-parisc/cacheflush.h b/include/asm-parisc/cacheflush.h
index 06732719d927..aa592d8c0e39 100644
--- a/include/asm-parisc/cacheflush.h
+++ b/include/asm-parisc/cacheflush.h
@@ -3,6 +3,7 @@
 
 #include <linux/config.h>
 #include <linux/mm.h>
+#include <asm/cache.h>  /* for flush_user_dcache_range_asm() proto */
 
 /* The usual comment is "Caches aren't brain-dead on the <architecture>".
  * Unfortunately, that doesn't apply to PA-RISC. */
diff --git a/include/asm-parisc/processor.h b/include/asm-parisc/processor.h
index 0b61f51d8467..a9dfadd05658 100644
--- a/include/asm-parisc/processor.h
+++ b/include/asm-parisc/processor.h
@@ -11,6 +11,7 @@
 #ifndef __ASSEMBLY__
 #include <linux/config.h>
 #include <linux/threads.h>
+#include <linux/spinlock_types.h>
 
 #include <asm/hardware.h>
 #include <asm/page.h>
diff --git a/include/asm-parisc/spinlock.h b/include/asm-parisc/spinlock.h
index 679ea1c651ef..43eaa6e742e0 100644
--- a/include/asm-parisc/spinlock.h
+++ b/include/asm-parisc/spinlock.h
@@ -2,30 +2,25 @@
 #define __ASM_SPINLOCK_H
 
 #include <asm/system.h>
+#include <asm/processor.h>
+#include <asm/spinlock_types.h>
 
 /* Note that PA-RISC has to use `1' to mean unlocked and `0' to mean locked
  * since it only has load-and-zero. Moreover, at least on some PA processors,
  * the semaphore address has to be 16-byte aligned.
  */
 
-#ifndef CONFIG_DEBUG_SPINLOCK
-
-#define __SPIN_LOCK_UNLOCKED    { { 1, 1, 1, 1 } }
-#undef SPIN_LOCK_UNLOCKED
-#define SPIN_LOCK_UNLOCKED (spinlock_t) __SPIN_LOCK_UNLOCKED
-
-#define spin_lock_init(x)       do { *(x) = SPIN_LOCK_UNLOCKED; } while(0)
-
-static inline int spin_is_locked(spinlock_t *x)
+static inline int __raw_spin_is_locked(raw_spinlock_t *x)
 {
         volatile unsigned int *a = __ldcw_align(x);
         return *a == 0;
 }
 
-#define spin_unlock_wait(x)     do { barrier(); } while(spin_is_locked(x))
-#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
+#define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)
+#define __raw_spin_unlock_wait(x) \
+                do { cpu_relax(); } while (__raw_spin_is_locked(x))
 
-static inline void _raw_spin_lock(spinlock_t *x)
+static inline void __raw_spin_lock(raw_spinlock_t *x)
 {
         volatile unsigned int *a;
 
@@ -36,7 +31,7 @@ static inline void _raw_spin_lock(spinlock_t *x)
         mb();
 }
 
-static inline void _raw_spin_unlock(spinlock_t *x)
+static inline void __raw_spin_unlock(raw_spinlock_t *x)
 {
         volatile unsigned int *a;
         mb();
@@ -45,7 +40,7 @@ static inline void _raw_spin_unlock(spinlock_t *x)
         mb();
 }
 
-static inline int _raw_spin_trylock(spinlock_t *x)
+static inline int __raw_spin_trylock(raw_spinlock_t *x)
 {
         volatile unsigned int *a;
         int ret;
@@ -57,131 +52,38 @@ static inline int _raw_spin_trylock(spinlock_t *x)
 
         return ret;
 }
-        
-#define spin_lock_own(LOCK, LOCATION)   ((void)0)
-
-#else /* !(CONFIG_DEBUG_SPINLOCK) */
-
-#define SPINLOCK_MAGIC  0x1D244B3C
-
-#define __SPIN_LOCK_UNLOCKED    { { 1, 1, 1, 1 }, SPINLOCK_MAGIC, 10, __FILE__ , NULL, 0, -1, NULL, NULL }
-#undef SPIN_LOCK_UNLOCKED
-#define SPIN_LOCK_UNLOCKED (spinlock_t) __SPIN_LOCK_UNLOCKED
-
-#define spin_lock_init(x)       do { *(x) = SPIN_LOCK_UNLOCKED; } while(0)
-
-#define CHECK_LOCK(x)                                                   \
-        do {                                                            \
-                if (unlikely((x)->magic != SPINLOCK_MAGIC)) {                   \
-                        printk(KERN_ERR "%s:%d: spin_is_locked"         \
-                        " on uninitialized spinlock %p.\n",             \
-                                __FILE__, __LINE__, (x));               \
-                }                                                       \
-        } while(0)
-
-#define spin_is_locked(x)                                               \
-        ({                                                              \
-                CHECK_LOCK(x);                                          \
-                volatile unsigned int *a = __ldcw_align(x);             \
-                if (unlikely((*a == 0) && (x)->babble)) {                               \
-                        (x)->babble--;                                  \
-                        printk("KERN_WARNING                            \
-                                %s:%d: spin_is_locked(%s/%p) already"   \
-                                " locked by %s:%d in %s at %p(%d)\n",   \
-                                __FILE__,__LINE__, (x)->module, (x),    \
-                                (x)->bfile, (x)->bline, (x)->task->comm,\
-                                (x)->previous, (x)->oncpu);             \
-                }                                                       \
-                *a == 0;                                                \
-        })
-
-#define spin_unlock_wait(x)                                             \
-        do {                                                            \
-                CHECK_LOCK(x);                                          \
-                volatile unsigned int *a = __ldcw_align(x);             \
-                if (unlikely((*a == 0) && (x)->babble)) {                               \
-                        (x)->babble--;                                  \
-                        printk("KERN_WARNING                            \
-                                %s:%d: spin_unlock_wait(%s/%p)"         \
-                                " owned by %s:%d in %s at %p(%d)\n",    \
-                                __FILE__,__LINE__, (x)->module, (x),    \
-                                (x)->bfile, (x)->bline, (x)->task->comm,\
-                                (x)->previous, (x)->oncpu);             \
-                }                                                       \
-                barrier();                                              \
-        } while (*((volatile unsigned char *)(__ldcw_align(x))) == 0)
-
-extern void _dbg_spin_lock(spinlock_t *lock, const char *base_file, int line_no);
-extern void _dbg_spin_unlock(spinlock_t *lock, const char *, int);
-extern int _dbg_spin_trylock(spinlock_t * lock, const char *, int);
-
-#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
-
-#define _raw_spin_unlock(lock)  _dbg_spin_unlock(lock, __FILE__, __LINE__)
-#define _raw_spin_lock(lock) _dbg_spin_lock(lock, __FILE__, __LINE__)
-#define _raw_spin_trylock(lock) _dbg_spin_trylock(lock, __FILE__, __LINE__)
-
-/* just in case we need it */
-#define spin_lock_own(LOCK, LOCATION)                                   \
-do {                                                                    \
-        volatile unsigned int *a = __ldcw_align(LOCK);                  \
-        if (!((*a == 0) && ((LOCK)->oncpu == smp_processor_id())))      \
-                printk("KERN_WARNING                                    \
-                        %s: called on %d from %p but lock %s on %d\n",  \
-                        LOCATION, smp_processor_id(),                   \
-                        __builtin_return_address(0),                    \
-                        (*a == 0) ? "taken" : "freed", (LOCK)->on_cpu); \
-} while (0)
-
-#endif /* !(CONFIG_DEBUG_SPINLOCK) */
 
 /*
  * Read-write spinlocks, allowing multiple readers
  * but only one writer.
  */
-typedef struct {
-        spinlock_t lock;
-        volatile int counter;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} rwlock_t;
-
-#define RW_LOCK_UNLOCKED (rwlock_t) { __SPIN_LOCK_UNLOCKED, 0 }
-
-#define rwlock_init(lp) do { *(lp) = RW_LOCK_UNLOCKED; } while (0)
 
-#define _raw_read_trylock(lock) generic_raw_read_trylock(lock)
+#define __raw_read_trylock(lock) generic__raw_read_trylock(lock)
 
 /* read_lock, read_unlock are pretty straightforward.  Of course it somehow
  * sucks we end up saving/restoring flags twice for read_lock_irqsave aso. */
 
-#ifdef CONFIG_DEBUG_RWLOCK
-extern void _dbg_read_lock(rwlock_t * rw, const char *bfile, int bline);
-#define _raw_read_lock(rw) _dbg_read_lock(rw, __FILE__, __LINE__)
-#else
-static  __inline__ void _raw_read_lock(rwlock_t *rw)
+static  __inline__ void __raw_read_lock(raw_rwlock_t *rw)
 {
         unsigned long flags;
         local_irq_save(flags);
-        _raw_spin_lock(&rw->lock); 
+        __raw_spin_lock(&rw->lock);
 
         rw->counter++;
 
-        _raw_spin_unlock(&rw->lock);
+        __raw_spin_unlock(&rw->lock);
         local_irq_restore(flags);
 }
-#endif  /* CONFIG_DEBUG_RWLOCK */
 
-static  __inline__ void _raw_read_unlock(rwlock_t *rw)
+static  __inline__ void __raw_read_unlock(raw_rwlock_t *rw)
 {
         unsigned long flags;
         local_irq_save(flags);
-        _raw_spin_lock(&rw->lock); 
+        __raw_spin_lock(&rw->lock);
 
         rw->counter--;
 
-        _raw_spin_unlock(&rw->lock);
+        __raw_spin_unlock(&rw->lock);
         local_irq_restore(flags);
 }
 
@@ -194,20 +96,17 @@ static  __inline__ void _raw_read_unlock(rwlock_t *rw)
  * writers) in interrupt handlers someone fucked up and we'd dead-lock
  * sooner or later anyway.   prumpf */
 
-#ifdef CONFIG_DEBUG_RWLOCK
-extern void _dbg_write_lock(rwlock_t * rw, const char *bfile, int bline);
-#define _raw_write_lock(rw) _dbg_write_lock(rw, __FILE__, __LINE__)
-#else
-static  __inline__ void _raw_write_lock(rwlock_t *rw)
+static  __inline__ void __raw_write_lock(raw_rwlock_t *rw)
 {
 retry:
-        _raw_spin_lock(&rw->lock);
+        __raw_spin_lock(&rw->lock);
 
         if(rw->counter != 0) {
                 /* this basically never happens */
-                _raw_spin_unlock(&rw->lock);
+                __raw_spin_unlock(&rw->lock);
 
-                while(rw->counter != 0);
+                while (rw->counter != 0)
+                        cpu_relax();
 
                 goto retry;
         }
@@ -215,26 +114,21 @@ retry:
         /* got it.  now leave without unlocking */
         rw->counter = -1; /* remember we are locked */
 }
-#endif /* CONFIG_DEBUG_RWLOCK */
 
 /* write_unlock is absolutely trivial - we don't have to wait for anything */
 
-static  __inline__ void _raw_write_unlock(rwlock_t *rw)
+static  __inline__ void __raw_write_unlock(raw_rwlock_t *rw)
 {
         rw->counter = 0;
-        _raw_spin_unlock(&rw->lock);
+        __raw_spin_unlock(&rw->lock);
 }
 
-#ifdef CONFIG_DEBUG_RWLOCK
-extern int _dbg_write_trylock(rwlock_t * rw, const char *bfile, int bline);
-#define _raw_write_trylock(rw) _dbg_write_trylock(rw, __FILE__, __LINE__)
-#else
-static  __inline__ int _raw_write_trylock(rwlock_t *rw)
+static  __inline__ int __raw_write_trylock(raw_rwlock_t *rw)
 {
-        _raw_spin_lock(&rw->lock);
+        __raw_spin_lock(&rw->lock);
         if (rw->counter != 0) {
                 /* this basically never happens */
-                _raw_spin_unlock(&rw->lock);
+                __raw_spin_unlock(&rw->lock);
 
                 return 0;
         }
@@ -243,14 +137,13 @@ static  __inline__ int _raw_write_trylock(rwlock_t *rw)
         rw->counter = -1; /* remember we are locked */
         return 1;
 }
-#endif /* CONFIG_DEBUG_RWLOCK */
 
-static __inline__ int is_read_locked(rwlock_t *rw)
+static __inline__ int __raw_is_read_locked(raw_rwlock_t *rw)
 {
         return rw->counter > 0;
 }
 
-static __inline__ int is_write_locked(rwlock_t *rw)
+static __inline__ int __raw_is_write_locked(raw_rwlock_t *rw)
 {
         return rw->counter < 0;
 }
diff --git a/include/asm-parisc/spinlock_types.h b/include/asm-parisc/spinlock_types.h
new file mode 100644
index 000000000000..785bba822fbf
--- /dev/null
+++ b/include/asm-parisc/spinlock_types.h
@@ -0,0 +1,21 @@
+#ifndef __ASM_SPINLOCK_TYPES_H
+#define __ASM_SPINLOCK_TYPES_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+typedef struct {
+        volatile unsigned int lock[4];
+} raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED        { { 1, 1, 1, 1 } }
+
+typedef struct {
+        raw_spinlock_t lock;
+        volatile int counter;
+} raw_rwlock_t;
+
+#define __RAW_RW_LOCK_UNLOCKED          { __RAW_SPIN_LOCK_UNLOCKED, 0 }
+
+#endif
diff --git a/include/asm-parisc/system.h b/include/asm-parisc/system.h
index 81c543339036..26ff844a21c1 100644
--- a/include/asm-parisc/system.h
+++ b/include/asm-parisc/system.h
@@ -160,29 +160,7 @@ static inline void set_eiem(unsigned long val)
 })
 
 #ifdef CONFIG_SMP
-/*
- * Your basic SMP spinlocks, allowing only a single CPU anywhere
- */
-
-typedef struct {
-        volatile unsigned int lock[4];
-#ifdef CONFIG_DEBUG_SPINLOCK
-        unsigned long magic;
-        volatile unsigned int babble;
-        const char *module;
-        char *bfile;
-        int bline;
-        int oncpu;
-        void *previous;
-        struct task_struct * task;
-#endif
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} spinlock_t;
-
-#define __lock_aligned __attribute__((__section__(".data.lock_aligned")))
-
+# define __lock_aligned __attribute__((__section__(".data.lock_aligned")))
 #endif
 
 #define KERNEL_START (0x10100000 - 0x1000)
diff --git a/include/asm-powerpc/siginfo.h b/include/asm-powerpc/siginfo.h
index 538ea8ef509b..12f1bce037be 100644
--- a/include/asm-powerpc/siginfo.h
+++ b/include/asm-powerpc/siginfo.h
@@ -15,4 +15,12 @@
 
 #include <asm-generic/siginfo.h>
 
+/*
+ * SIGTRAP si_codes
+ */
+#define TRAP_BRANCH     (__SI_FAULT|3)  /* process taken branch trap */
+#define TRAP_HWBKPT     (__SI_FAULT|4)  /* hardware breakpoint or watchpoint */
+#undef NSIGTRAP
+#define NSIGTRAP        4
+
 #endif  /* _ASM_POWERPC_SIGINFO_H */
diff --git a/include/asm-ppc/irq.h b/include/asm-ppc/irq.h
index b4b270457edd..55752474d0d9 100644
--- a/include/asm-ppc/irq.h
+++ b/include/asm-ppc/irq.h
@@ -404,9 +404,5 @@ extern unsigned long ppc_cached_irq_mask[NR_MASK_WORDS];
 extern unsigned long ppc_lost_interrupts[NR_MASK_WORDS];
 extern atomic_t ppc_n_lost_interrupts;
 
-struct irqaction;
-struct pt_regs;
-int handle_IRQ_event(unsigned int, struct pt_regs *, struct irqaction *);
-
 #endif /* _ASM_IRQ_H */
 #endif /* __KERNEL__ */
diff --git a/include/asm-ppc/ptrace.h b/include/asm-ppc/ptrace.h
index 9d4e4ea530c3..7043c164b537 100644
--- a/include/asm-ppc/ptrace.h
+++ b/include/asm-ppc/ptrace.h
@@ -142,4 +142,11 @@ do {									      \
 #define PTRACE_GETEVRREGS       20
 #define PTRACE_SETEVRREGS       21
 
+/*
+ * Get or set a debug register. The first 16 are DABR registers and the
+ * second 16 are IABR registers.
+ */
+#define PTRACE_GET_DEBUGREG     25
+#define PTRACE_SET_DEBUGREG     26
+
 #endif
diff --git a/include/asm-ppc/reg.h b/include/asm-ppc/reg.h
index 88b4222154d4..73c33e3ef9c6 100644
--- a/include/asm-ppc/reg.h
+++ b/include/asm-ppc/reg.h
@@ -366,12 +366,6 @@
 #define PVR_STB03XXX    0x40310000
 #define PVR_NP405H      0x41410000
 #define PVR_NP405L      0x41610000
-#define PVR_440GP_RB    0x40120440
-#define PVR_440GP_RC1   0x40120481
-#define PVR_440GP_RC2   0x40200481
-#define PVR_440GX_RA    0x51b21850
-#define PVR_440GX_RB    0x51b21851
-#define PVR_440GX_RC    0x51b21892
 #define PVR_601         0x00010000
 #define PVR_602         0x00050000
 #define PVR_603         0x00030000
diff --git a/include/asm-ppc/smp.h b/include/asm-ppc/smp.h
index 17530c232c76..829481c0a9dc 100644
--- a/include/asm-ppc/smp.h
+++ b/include/asm-ppc/smp.h
@@ -41,6 +41,10 @@ extern void smp_send_xmon_break(int cpu);
 struct pt_regs;
 extern void smp_message_recv(int, struct pt_regs *);
 
+extern int __cpu_disable(void);
+extern void __cpu_die(unsigned int cpu);
+extern void cpu_die(void) __attribute__((noreturn));
+
 #define NO_PROC_ID              0xFF            /* No processor magic marker */
 #define PROC_CHANGE_PENALTY     20
 
@@ -64,6 +68,8 @@ extern struct klock_info_struct klock_info;
 
 #else /* !(CONFIG_SMP) */
 
+static inline void cpu_die(void) { }
+
 #endif /* !(CONFIG_SMP) */
 
 #endif /* !(_PPC_SMP_H) */
diff --git a/include/asm-ppc/spinlock.h b/include/asm-ppc/spinlock.h
index 909199aae104..20edcf2a6e0c 100644
--- a/include/asm-ppc/spinlock.h
+++ b/include/asm-ppc/spinlock.h
@@ -5,41 +5,21 @@
 
 /*
  * Simple spin lock operations.
+ *
+ * (the type definitions are in asm/raw_spinlock_types.h)
  */
 
-typedef struct {
-        volatile unsigned long lock;
-#ifdef CONFIG_DEBUG_SPINLOCK
-        volatile unsigned long owner_pc;
-        volatile unsigned long owner_cpu;
-#endif
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} spinlock_t;
-
-#ifdef __KERNEL__
-#ifdef CONFIG_DEBUG_SPINLOCK
-#define SPINLOCK_DEBUG_INIT     , 0, 0
-#else
-#define SPINLOCK_DEBUG_INIT     /* */
-#endif
-
-#define SPIN_LOCK_UNLOCKED      (spinlock_t) { 0 SPINLOCK_DEBUG_INIT }
-
-#define spin_lock_init(x)       do { *(x) = SPIN_LOCK_UNLOCKED; } while(0)
-#define spin_is_locked(x)       ((x)->lock != 0)
-#define spin_unlock_wait(x)     do { barrier(); } while(spin_is_locked(x))
-#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
-
-#ifndef CONFIG_DEBUG_SPINLOCK
-
-static inline void _raw_spin_lock(spinlock_t *lock)
+#define __raw_spin_is_locked(x)         ((x)->lock != 0)
+#define __raw_spin_unlock_wait(lock) \
+        do { while (__raw_spin_is_locked(lock)) cpu_relax(); } while (0)
+#define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)
+
+static inline void __raw_spin_lock(raw_spinlock_t *lock)
 {
         unsigned long tmp;
 
         __asm__ __volatile__(
-        "b      1f              # spin_lock\n\
+        "b      1f              # __raw_spin_lock\n\
 2:      lwzx    %0,0,%1\n\
         cmpwi   0,%0,0\n\
         bne+    2b\n\
@@ -55,21 +35,13 @@ static inline void _raw_spin_lock(spinlock_t *lock)
         : "cr0", "memory");
 }
 
-static inline void _raw_spin_unlock(spinlock_t *lock)
+static inline void __raw_spin_unlock(raw_spinlock_t *lock)
 {
-        __asm__ __volatile__("eieio             # spin_unlock": : :"memory");
+        __asm__ __volatile__("eieio     # __raw_spin_unlock": : :"memory");
         lock->lock = 0;
 }
 
-#define _raw_spin_trylock(l) (!test_and_set_bit(0,&(l)->lock))
-
-#else
-
-extern void _raw_spin_lock(spinlock_t *lock);
-extern void _raw_spin_unlock(spinlock_t *lock);
-extern int _raw_spin_trylock(spinlock_t *lock);
-
-#endif
+#define __raw_spin_trylock(l) (!test_and_set_bit(0,&(l)->lock))
 
 /*
  * Read-write spinlocks, allowing multiple readers
@@ -81,22 +53,11 @@ extern int _raw_spin_trylock(spinlock_t *lock);
  * irq-safe write-lock, but readers can get non-irqsafe
  * read-locks.
  */
-typedef struct {
-        volatile signed int lock;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} rwlock_t;
 
-#define RW_LOCK_UNLOCKED (rwlock_t) { 0 }
-#define rwlock_init(lp) do { *(lp) = RW_LOCK_UNLOCKED; } while(0)
+#define __raw_read_can_lock(rw) ((rw)->lock >= 0)
+#define __raw_write_can_lock(rw)        (!(rw)->lock)
 
-#define read_can_lock(rw)       ((rw)->lock >= 0)
-#define write_can_lock(rw)      (!(rw)->lock)
-
-#ifndef CONFIG_DEBUG_SPINLOCK
-
-static __inline__ int _raw_read_trylock(rwlock_t *rw)
+static __inline__ int __raw_read_trylock(raw_rwlock_t *rw)
 {
         signed int tmp;
 
@@ -116,7 +77,7 @@ static __inline__ int _raw_read_trylock(rwlock_t *rw)
         return tmp > 0;
 }
 
-static __inline__ void _raw_read_lock(rwlock_t *rw)
+static __inline__ void __raw_read_lock(raw_rwlock_t *rw)
 {
         signed int tmp;
 
@@ -137,7 +98,7 @@ static __inline__ void _raw_read_lock(rwlock_t *rw)
         : "cr0", "memory");
 }
 
-static __inline__ void _raw_read_unlock(rwlock_t *rw)
+static __inline__ void __raw_read_unlock(raw_rwlock_t *rw)
 {
         signed int tmp;
 
@@ -153,7 +114,7 @@ static __inline__ void _raw_read_unlock(rwlock_t *rw)
         : "cr0", "memory");
 }
 
-static __inline__ int _raw_write_trylock(rwlock_t *rw)
+static __inline__ int __raw_write_trylock(raw_rwlock_t *rw)
 {
         signed int tmp;
 
@@ -173,7 +134,7 @@ static __inline__ int _raw_write_trylock(rwlock_t *rw)
         return tmp == 0;
 }
 
-static __inline__ void _raw_write_lock(rwlock_t *rw)
+static __inline__ void __raw_write_lock(raw_rwlock_t *rw)
 {
         signed int tmp;
 
@@ -194,22 +155,10 @@ static __inline__ void _raw_write_lock(rwlock_t *rw)
         : "cr0", "memory");
 }
 
-static __inline__ void _raw_write_unlock(rwlock_t *rw)
+static __inline__ void __raw_write_unlock(raw_rwlock_t *rw)
 {
         __asm__ __volatile__("eieio             # write_unlock": : :"memory");
         rw->lock = 0;
 }
 
-#else
-
-extern void _raw_read_lock(rwlock_t *rw);
-extern void _raw_read_unlock(rwlock_t *rw);
-extern void _raw_write_lock(rwlock_t *rw);
-extern void _raw_write_unlock(rwlock_t *rw);
-extern int _raw_read_trylock(rwlock_t *rw);
-extern int _raw_write_trylock(rwlock_t *rw);
-
-#endif
-
 #endif /* __ASM_SPINLOCK_H */
-#endif /* __KERNEL__ */
diff --git a/include/asm-ppc/spinlock_types.h b/include/asm-ppc/spinlock_types.h
new file mode 100644
index 000000000000..7919ccc75b8a
--- /dev/null
+++ b/include/asm-ppc/spinlock_types.h
@@ -0,0 +1,20 @@
+#ifndef __ASM_SPINLOCK_TYPES_H
+#define __ASM_SPINLOCK_TYPES_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+typedef struct {
+        volatile unsigned long lock;
+} raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED        { 0 }
+
+typedef struct {
+        volatile signed int lock;
+} raw_rwlock_t;
+
+#define __RAW_RW_LOCK_UNLOCKED          { 0 }
+
+#endif
diff --git a/include/asm-ppc/system.h b/include/asm-ppc/system.h
index 513a334c5810..d754ab570fe0 100644
--- a/include/asm-ppc/system.h
+++ b/include/asm-ppc/system.h
@@ -88,6 +88,7 @@ extern void *cacheable_memcpy(void *, const void *, unsigned int);
 extern int do_page_fault(struct pt_regs *, unsigned long, unsigned long);
 extern void bad_page_fault(struct pt_regs *, unsigned long, int);
 extern void die(const char *, struct pt_regs *, long);
+extern void _exception(int, struct pt_regs *, int, unsigned long);
 #ifdef CONFIG_BOOKE_WDT
 extern u32 booke_wdt_enabled;
 extern u32 booke_wdt_period;
diff --git a/include/asm-ppc64/hvcall.h b/include/asm-ppc64/hvcall.h
index 4f668a4baff0..ab7c3cf24888 100644
--- a/include/asm-ppc64/hvcall.h
+++ b/include/asm-ppc64/hvcall.h
@@ -56,6 +56,11 @@
 #define H_PP1                   (1UL<<(63-62))
 #define H_PP2                   (1UL<<(63-63))
 
+/* DABRX flags */
+#define H_DABRX_HYPERVISOR      (1UL<<(63-61))
+#define H_DABRX_KERNEL          (1UL<<(63-62))
+#define H_DABRX_USER            (1UL<<(63-63))
+
 /* pSeries hypervisor opcodes */
 #define H_REMOVE                0x04
 #define H_ENTER                 0x08
@@ -101,6 +106,7 @@
 #define H_VIO_SIGNAL            0x104
 #define H_SEND_CRQ              0x108
 #define H_COPY_RDMA             0x110
+#define H_SET_XDABR             0x134
 #define H_STUFF_TCE             0x138
 #define H_PUT_TCE_INDIRECT      0x13C
 #define H_VTERM_PARTNER_INFO    0x150
diff --git a/include/asm-ppc64/machdep.h b/include/asm-ppc64/machdep.h
index 9a1ef4427ed2..8027160ec96d 100644
--- a/include/asm-ppc64/machdep.h
+++ b/include/asm-ppc64/machdep.h
@@ -88,6 +88,7 @@ struct machdep_calls {
 
         /* PCI stuff */
         void            (*pcibios_fixup)(void);
+        int             (*pci_probe_mode)(struct pci_bus *);
 
         void            (*restart)(char *cmd);
         void            (*power_off)(void);
@@ -173,10 +174,6 @@ extern sys_ctrler_t sys_ctrler;
 void ppc64_boot_msg(unsigned int src, const char *msg);
 /* Print a termination message (print only -- does not stop the kernel) */
 void ppc64_terminate_msg(unsigned int src, const char *msg);
-/* Print something that needs attention (device error, etc) */
-void ppc64_attention_msg(unsigned int src, const char *msg);
-/* Print a dump progress message. */
-void ppc64_dump_msg(unsigned int src, const char *msg);
 
 static inline void log_error(char *buf, unsigned int err_type, int fatal)
 {
diff --git a/include/asm-ppc64/pci-bridge.h b/include/asm-ppc64/pci-bridge.h
index 6b4a5b1f695e..d8991389ab39 100644
--- a/include/asm-ppc64/pci-bridge.h
+++ b/include/asm-ppc64/pci-bridge.h
@@ -119,5 +119,10 @@ static inline struct pci_controller *pci_bus_to_host(struct pci_bus *bus)
         return PCI_DN(busdn)->phb;
 }
 
+/* Return values for ppc_md.pci_probe_mode function */
+#define PCI_PROBE_NONE          -1      /* Don't look at this bus at all */
+#define PCI_PROBE_NORMAL        0       /* Do normal PCI probing */
+#define PCI_PROBE_DEVTREE       1       /* Instantiate from device tree */
+
 #endif
 #endif /* __KERNEL__ */
diff --git a/include/asm-ppc64/plpar_wrappers.h b/include/asm-ppc64/plpar_wrappers.h
index f4a5fb7d67c7..72dd2449ee76 100644
--- a/include/asm-ppc64/plpar_wrappers.h
+++ b/include/asm-ppc64/plpar_wrappers.h
@@ -107,5 +107,14 @@ static inline long plpar_put_term_char(unsigned long termno,
                                   lbuf[1]);
 }
 
+static inline long plpar_set_xdabr(unsigned long address, unsigned long flags)
+{
+        return plpar_hcall_norets(H_SET_XDABR, address, flags);
+}
+
+static inline long plpar_set_dabr(unsigned long val)
+{
+        return plpar_hcall_norets(H_SET_DABR, val);
+}
 
 #endif /* _PPC64_PLPAR_WRAPPERS_H */
diff --git a/include/asm-ppc64/processor.h b/include/asm-ppc64/processor.h
index 8bd7aa959385..4146189006e3 100644
--- a/include/asm-ppc64/processor.h
+++ b/include/asm-ppc64/processor.h
@@ -433,6 +433,7 @@ struct thread_struct {
         unsigned long   start_tb;       /* Start purr when proc switched in */
         unsigned long   accum_tb;       /* Total accumilated purr for process */
         unsigned long   vdso_base;      /* base of the vDSO library */
+        unsigned long   dabr;           /* Data address breakpoint register */
 #ifdef CONFIG_ALTIVEC
         /* Complete AltiVec register set */
         vector128       vr[32] __attribute((aligned(16)));
diff --git a/include/asm-ppc64/ptrace-common.h b/include/asm-ppc64/ptrace-common.h
index af03547f9c7e..b1babb729673 100644
--- a/include/asm-ppc64/ptrace-common.h
+++ b/include/asm-ppc64/ptrace-common.h
@@ -11,6 +11,10 @@
 
 #ifndef _PPC64_PTRACE_COMMON_H
 #define _PPC64_PTRACE_COMMON_H
+
+#include <linux/config.h>
+#include <asm/system.h>
+
 /*
  * Set of msr bits that gdb can change on behalf of a process.
  */
@@ -69,4 +73,92 @@ static inline void clear_single_step(struct task_struct *task)
         clear_ti_thread_flag(task->thread_info, TIF_SINGLESTEP);
 }
 
+#ifdef CONFIG_ALTIVEC
+/*
+ * Get/set all the altivec registers vr0..vr31, vscr, vrsave, in one go.
+ * The transfer totals 34 quadword.  Quadwords 0-31 contain the
+ * corresponding vector registers.  Quadword 32 contains the vscr as the
+ * last word (offset 12) within that quadword.  Quadword 33 contains the
+ * vrsave as the first word (offset 0) within the quadword.
+ *
+ * This definition of the VMX state is compatible with the current PPC32
+ * ptrace interface.  This allows signal handling and ptrace to use the
+ * same structures.  This also simplifies the implementation of a bi-arch
+ * (combined (32- and 64-bit) gdb.
+ */
+
+/*
+ * Get contents of AltiVec register state in task TASK
+ */
+static inline int get_vrregs(unsigned long __user *data,
+                             struct task_struct *task)
+{
+        unsigned long regsize;
+
+        /* copy AltiVec registers VR[0] .. VR[31] */
+        regsize = 32 * sizeof(vector128);
+        if (copy_to_user(data, task->thread.vr, regsize))
+                return -EFAULT;
+        data += (regsize / sizeof(unsigned long));
+
+        /* copy VSCR */
+        regsize = 1 * sizeof(vector128);
+        if (copy_to_user(data, &task->thread.vscr, regsize))
+                return -EFAULT;
+        data += (regsize / sizeof(unsigned long));
+
+        /* copy VRSAVE */
+        if (put_user(task->thread.vrsave, (u32 __user *)data))
+                return -EFAULT;
+
+        return 0;
+}
+
+/*
+ * Write contents of AltiVec register state into task TASK.
+ */
+static inline int set_vrregs(struct task_struct *task,
+                             unsigned long __user *data)
+{
+        unsigned long regsize;
+
+        /* copy AltiVec registers VR[0] .. VR[31] */
+        regsize = 32 * sizeof(vector128);
+        if (copy_from_user(task->thread.vr, data, regsize))
+                return -EFAULT;
+        data += (regsize / sizeof(unsigned long));
+
+        /* copy VSCR */
+        regsize = 1 * sizeof(vector128);
+        if (copy_from_user(&task->thread.vscr, data, regsize))
+                return -EFAULT;
+        data += (regsize / sizeof(unsigned long));
+
+        /* copy VRSAVE */
+        if (get_user(task->thread.vrsave, (u32 __user *)data))
+                return -EFAULT;
+
+        return 0;
+}
+#endif
+
+static inline int ptrace_set_debugreg(struct task_struct *task,
+                                      unsigned long addr, unsigned long data)
+{
+        /* We only support one DABR and no IABRS at the moment */
+        if (addr > 0)
+                return -EINVAL;
+
+        /* The bottom 3 bits are flags */
+        if ((data & ~0x7UL) >= TASK_SIZE)
+                return -EIO;
+
+        /* Ensure translation is on */
+        if (data && !(data & DABR_TRANSLATION))
+                return -EIO;
+
+        task->thread.dabr = data;
+        return 0;
+}
+
 #endif /* _PPC64_PTRACE_COMMON_H */
diff --git a/include/asm-ppc64/ptrace.h b/include/asm-ppc64/ptrace.h
index c96aad28fc08..3a55377f1fd3 100644
--- a/include/asm-ppc64/ptrace.h
+++ b/include/asm-ppc64/ptrace.h
@@ -25,56 +25,49 @@
  */
 
 #ifndef __ASSEMBLY__
-#define PPC_REG unsigned long
+
 struct pt_regs {
-        PPC_REG gpr[32];
-        PPC_REG nip;
-        PPC_REG msr;
-        PPC_REG orig_gpr3;      /* Used for restarting system calls */
-        PPC_REG ctr;
-        PPC_REG link;
-        PPC_REG xer;
-        PPC_REG ccr;
-        PPC_REG softe;          /* Soft enabled/disabled */
-        PPC_REG trap;           /* Reason for being here */
-        PPC_REG dar;            /* Fault registers */
-        PPC_REG dsisr;
-        PPC_REG result;         /* Result of a system call */
+        unsigned long gpr[32];
+        unsigned long nip;
+        unsigned long msr;
+        unsigned long orig_gpr3; /* Used for restarting system calls */
+        unsigned long ctr;
+        unsigned long link;
+        unsigned long xer;
+        unsigned long ccr;
+        unsigned long softe;    /* Soft enabled/disabled */
+        unsigned long trap;     /* Reason for being here */
+        unsigned long dar;      /* Fault registers */
+        unsigned long dsisr;
+        unsigned long result;   /* Result of a system call */
 };
 
-#define PPC_REG_32 unsigned int
 struct pt_regs32 {
-        PPC_REG_32 gpr[32];
-        PPC_REG_32 nip;
-        PPC_REG_32 msr;
-        PPC_REG_32 orig_gpr3;   /* Used for restarting system calls */
-        PPC_REG_32 ctr;
-        PPC_REG_32 link;
-        PPC_REG_32 xer;
-        PPC_REG_32 ccr;
-        PPC_REG_32 mq;          /* 601 only (not used at present) */
-                                /* Used on APUS to hold IPL value. */
-        PPC_REG_32 trap;                /* Reason for being here */
-        PPC_REG_32 dar;         /* Fault registers */
-        PPC_REG_32 dsisr;
-        PPC_REG_32 result;      /* Result of a system call */
+        unsigned int gpr[32];
+        unsigned int nip;
+        unsigned int msr;
+        unsigned int orig_gpr3; /* Used for restarting system calls */
+        unsigned int ctr;
+        unsigned int link;
+        unsigned int xer;
+        unsigned int ccr;
+        unsigned int mq;        /* 601 only (not used at present) */
+        unsigned int trap;      /* Reason for being here */
+        unsigned int dar;       /* Fault registers */
+        unsigned int dsisr;
+        unsigned int result;    /* Result of a system call */
 };
 
+#ifdef __KERNEL__
+
 #define instruction_pointer(regs) ((regs)->nip)
+
 #ifdef CONFIG_SMP
 extern unsigned long profile_pc(struct pt_regs *regs);
 #else
 #define profile_pc(regs) instruction_pointer(regs)
 #endif
 
-#endif /* __ASSEMBLY__ */
-
-#define STACK_FRAME_OVERHEAD    112     /* size of minimum stack frame */
-
-/* Size of dummy stack frame allocated when calling signal handler. */
-#define __SIGNAL_FRAMESIZE      128
-#define __SIGNAL_FRAMESIZE32    64
-
 #define user_mode(regs) ((((regs)->msr) >> MSR_PR_LG) & 0x1)
 
 #define force_successful_syscall_return()   \
@@ -89,6 +82,16 @@ extern unsigned long profile_pc(struct pt_regs *regs);
 #define TRAP(regs)              ((regs)->trap & ~0xF)
 #define CHECK_FULL_REGS(regs)   BUG_ON(regs->trap & 1)
 
+#endif /* __KERNEL__ */
+
+#endif /* __ASSEMBLY__ */
+
+#define STACK_FRAME_OVERHEAD    112     /* size of minimum stack frame */
+
+/* Size of dummy stack frame allocated when calling signal handler. */
+#define __SIGNAL_FRAMESIZE      128
+#define __SIGNAL_FRAMESIZE32    64
+
 /*
  * Offsets used by 'ptrace' system call interface.
  */
@@ -135,17 +138,21 @@ extern unsigned long profile_pc(struct pt_regs *regs);
 #define PT_XER  37
 #define PT_CCR  38
 #define PT_SOFTE 39
+#define PT_TRAP 40
+#define PT_DAR  41
+#define PT_DSISR 42
 #define PT_RESULT 43
 
 #define PT_FPR0 48
 
-/* Kernel and userspace will both use this PT_FPSCR value.  32-bit apps will have
- * visibility to the asm-ppc/ptrace.h header instead of this one.
+/*
+ * Kernel and userspace will both use this PT_FPSCR value.  32-bit apps will
+ * have visibility to the asm-ppc/ptrace.h header instead of this one.
  */
-#define PT_FPSCR (PT_FPR0 + 32)   /* each FP reg occupies 1 slot in 64-bit space */
+#define PT_FPSCR (PT_FPR0 + 32) /* each FP reg occupies 1 slot in 64-bit space */
 
 #ifdef __KERNEL__
-#define PT_FPSCR32 (PT_FPR0 + 2*32 + 1)   /* each FP reg occupies 2 32-bit userspace slots */
+#define PT_FPSCR32 (PT_FPR0 + 2*32 + 1) /* each FP reg occupies 2 32-bit userspace slots */
 #endif
 
 #define PT_VR0 82       /* each Vector reg occupies 2 slots in 64-bit */
@@ -173,17 +180,34 @@ extern unsigned long profile_pc(struct pt_regs *regs);
 #define PTRACE_GETVRREGS        18
 #define PTRACE_SETVRREGS        19
 
-/* Additional PTRACE requests implemented on PowerPC. */
-#define PPC_PTRACE_GETREGS            0x99  /* Get GPRs 0 - 31 */
-#define PPC_PTRACE_SETREGS            0x98  /* Set GPRs 0 - 31 */
-#define PPC_PTRACE_GETFPREGS        0x97  /* Get FPRs 0 - 31 */
-#define PPC_PTRACE_SETFPREGS        0x96  /* Set FPRs 0 - 31 */
-#define PPC_PTRACE_PEEKTEXT_3264  0x95  /* Read word at location ADDR on a 64-bit process from a 32-bit process. */
-#define PPC_PTRACE_PEEKDATA_3264  0x94  /* Read word at location ADDR on a 64-bit process from a 32-bit process. */
-#define PPC_PTRACE_POKETEXT_3264  0x93  /* Write word at location ADDR on a 64-bit process from a 32-bit process. */
-#define PPC_PTRACE_POKEDATA_3264  0x92  /* Write word at location ADDR on a 64-bit process from a 32-bit process. */
-#define PPC_PTRACE_PEEKUSR_3264   0x91  /* Read a register (specified by ADDR) out of the "user area" on a 64-bit process from a 32-bit process. */
-#define PPC_PTRACE_POKEUSR_3264   0x90  /* Write DATA into location ADDR within the "user area" on a 64-bit process from a 32-bit process. */
+/*
+ * While we dont have 64bit book E processors, we need to reserve the
+ * relevant ptrace calls for 32bit compatibility.
+ */
+#if 0
+#define PTRACE_GETEVRREGS       20
+#define PTRACE_SETEVRREGS       21
+#endif
 
+/*
+ * Get or set a debug register. The first 16 are DABR registers and the
+ * second 16 are IABR registers.
+ */
+#define PTRACE_GET_DEBUGREG     25
+#define PTRACE_SET_DEBUGREG     26
+
+/* Additional PTRACE requests implemented on PowerPC. */
+#define PPC_PTRACE_GETREGS      0x99    /* Get GPRs 0 - 31 */
+#define PPC_PTRACE_SETREGS      0x98    /* Set GPRs 0 - 31 */
+#define PPC_PTRACE_GETFPREGS    0x97    /* Get FPRs 0 - 31 */
+#define PPC_PTRACE_SETFPREGS    0x96    /* Set FPRs 0 - 31 */
+
+/* Calls to trace a 64bit program from a 32bit program */
+#define PPC_PTRACE_PEEKTEXT_3264 0x95
+#define PPC_PTRACE_PEEKDATA_3264 0x94
+#define PPC_PTRACE_POKETEXT_3264 0x93
+#define PPC_PTRACE_POKEDATA_3264 0x92
+#define PPC_PTRACE_PEEKUSR_3264  0x91
+#define PPC_PTRACE_POKEUSR_3264  0x90
 
 #endif /* _PPC64_PTRACE_H */
diff --git a/include/asm-ppc64/spinlock.h b/include/asm-ppc64/spinlock.h
index acd11564dd75..14cb895bb607 100644
--- a/include/asm-ppc64/spinlock.h
+++ b/include/asm-ppc64/spinlock.h
@@ -15,36 +15,42 @@
  * 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.
+ *
+ * (the type definitions are in asm/spinlock_types.h)
  */
 #include <linux/config.h>
 #include <asm/paca.h>
 #include <asm/hvcall.h>
 #include <asm/iSeries/HvCall.h>
 
-typedef struct {
-        volatile unsigned int lock;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} spinlock_t;
+#define __raw_spin_is_locked(x)         ((x)->slock != 0)
 
-typedef struct {
-        volatile signed int lock;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} rwlock_t;
+/*
+ * This returns the old value in the lock, so we succeeded
+ * in getting the lock if the return value is 0.
+ */
+static __inline__ unsigned long __spin_trylock(raw_spinlock_t *lock)
+{
+        unsigned long tmp, tmp2;
 
-#ifdef __KERNEL__
-#define SPIN_LOCK_UNLOCKED      (spinlock_t) { 0 }
+        __asm__ __volatile__(
+"       lwz             %1,%3(13)               # __spin_trylock\n\
+1:      lwarx           %0,0,%2\n\
+        cmpwi           0,%0,0\n\
+        bne-            2f\n\
+        stwcx.          %1,0,%2\n\
+        bne-            1b\n\
+        isync\n\
+2:"     : "=&r" (tmp), "=&r" (tmp2)
+        : "r" (&lock->slock), "i" (offsetof(struct paca_struct, lock_token))
+        : "cr0", "memory");
 
-#define spin_is_locked(x)       ((x)->lock != 0)
-#define spin_lock_init(x)       do { *(x) = SPIN_LOCK_UNLOCKED; } while(0)
+        return tmp;
+}
 
-static __inline__ void _raw_spin_unlock(spinlock_t *lock)
+static int __inline__ __raw_spin_trylock(raw_spinlock_t *lock)
 {
-        __asm__ __volatile__("lwsync    # spin_unlock": : :"memory");
-        lock->lock = 0;
+        return __spin_trylock(lock) == 0;
 }
 
 /*
@@ -64,44 +70,15 @@ static __inline__ void _raw_spin_unlock(spinlock_t *lock)
 #if defined(CONFIG_PPC_SPLPAR) || defined(CONFIG_PPC_ISERIES)
 /* We only yield to the hypervisor if we are in shared processor mode */
 #define SHARED_PROCESSOR (get_paca()->lppaca.shared_proc)
-extern void __spin_yield(spinlock_t *lock);
-extern void __rw_yield(rwlock_t *lock);
+extern void __spin_yield(raw_spinlock_t *lock);
+extern void __rw_yield(raw_rwlock_t *lock);
 #else /* SPLPAR || ISERIES */
 #define __spin_yield(x) barrier()
 #define __rw_yield(x)   barrier()
 #define SHARED_PROCESSOR        0
 #endif
-extern void spin_unlock_wait(spinlock_t *lock);
-
-/*
- * This returns the old value in the lock, so we succeeded
- * in getting the lock if the return value is 0.
- */
-static __inline__ unsigned long __spin_trylock(spinlock_t *lock)
-{
-        unsigned long tmp, tmp2;
-
-        __asm__ __volatile__(
-"       lwz             %1,%3(13)               # __spin_trylock\n\
-1:      lwarx           %0,0,%2\n\
-        cmpwi           0,%0,0\n\
-        bne-            2f\n\
-        stwcx.          %1,0,%2\n\
-        bne-            1b\n\
-        isync\n\
-2:"     : "=&r" (tmp), "=&r" (tmp2)
-        : "r" (&lock->lock), "i" (offsetof(struct paca_struct, lock_token))
-        : "cr0", "memory");
-
-        return tmp;
-}
-
-static int __inline__ _raw_spin_trylock(spinlock_t *lock)
-{
-        return __spin_trylock(lock) == 0;
-}
 
-static void __inline__ _raw_spin_lock(spinlock_t *lock)
+static void __inline__ __raw_spin_lock(raw_spinlock_t *lock)
 {
         while (1) {
                 if (likely(__spin_trylock(lock) == 0))
@@ -110,12 +87,12 @@ static void __inline__ _raw_spin_lock(spinlock_t *lock)
                         HMT_low();
                         if (SHARED_PROCESSOR)
                                 __spin_yield(lock);
-                } while (unlikely(lock->lock != 0));
+                } while (unlikely(lock->slock != 0));
                 HMT_medium();
         }
 }
 
-static void __inline__ _raw_spin_lock_flags(spinlock_t *lock, unsigned long flags)
+static void __inline__ __raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long flags)
 {
         unsigned long flags_dis;
 
@@ -128,12 +105,20 @@ static void __inline__ _raw_spin_lock_flags(spinlock_t *lock, unsigned long flag
                         HMT_low();
                         if (SHARED_PROCESSOR)
                                 __spin_yield(lock);
-                } while (unlikely(lock->lock != 0));
+                } while (unlikely(lock->slock != 0));
                 HMT_medium();
                 local_irq_restore(flags_dis);
         }
 }
 
+static __inline__ void __raw_spin_unlock(raw_spinlock_t *lock)
+{
+        __asm__ __volatile__("lwsync    # __raw_spin_unlock": : :"memory");
+        lock->slock = 0;
+}
+
+extern void __raw_spin_unlock_wait(raw_spinlock_t *lock);
+
 /*
  * Read-write spinlocks, allowing multiple readers
  * but only one writer.
@@ -144,24 +129,15 @@ static void __inline__ _raw_spin_lock_flags(spinlock_t *lock, unsigned long flag
  * irq-safe write-lock, but readers can get non-irqsafe
  * read-locks.
  */
-#define RW_LOCK_UNLOCKED (rwlock_t) { 0 }
 
-#define rwlock_init(x)          do { *(x) = RW_LOCK_UNLOCKED; } while(0)
-
-#define read_can_lock(rw)       ((rw)->lock >= 0)
-#define write_can_lock(rw)      (!(rw)->lock)
-
-static __inline__ void _raw_write_unlock(rwlock_t *rw)
-{
-        __asm__ __volatile__("lwsync            # write_unlock": : :"memory");
-        rw->lock = 0;
-}
+#define __raw_read_can_lock(rw)         ((rw)->lock >= 0)
+#define __raw_write_can_lock(rw)        (!(rw)->lock)
 
 /*
  * This returns the old value in the lock + 1,
  * so we got a read lock if the return value is > 0.
  */
-static long __inline__ __read_trylock(rwlock_t *rw)
+static long __inline__ __read_trylock(raw_rwlock_t *rw)
 {
         long tmp;
 
@@ -180,45 +156,11 @@ static long __inline__ __read_trylock(rwlock_t *rw)
         return tmp;
 }
 
-static int __inline__ _raw_read_trylock(rwlock_t *rw)
-{
-        return __read_trylock(rw) > 0;
-}
-
-static void __inline__ _raw_read_lock(rwlock_t *rw)
-{
-        while (1) {
-                if (likely(__read_trylock(rw) > 0))
-                        break;
-                do {
-                        HMT_low();
-                        if (SHARED_PROCESSOR)
-                                __rw_yield(rw);
-                } while (unlikely(rw->lock < 0));
-                HMT_medium();
-        }
-}
-
-static void __inline__ _raw_read_unlock(rwlock_t *rw)
-{
-        long tmp;
-
-        __asm__ __volatile__(
-        "eieio                          # read_unlock\n\
-1:      lwarx           %0,0,%1\n\
-        addic           %0,%0,-1\n\
-        stwcx.          %0,0,%1\n\
-        bne-            1b"
-        : "=&r"(tmp)
-        : "r"(&rw->lock)
-        : "cr0", "memory");
-}
-
 /*
  * This returns the old value in the lock,
  * so we got the write lock if the return value is 0.
  */
-static __inline__ long __write_trylock(rwlock_t *rw)
+static __inline__ long __write_trylock(raw_rwlock_t *rw)
 {
         long tmp, tmp2;
 
@@ -237,12 +179,21 @@ static __inline__ long __write_trylock(rwlock_t *rw)
         return tmp;
 }
 
-static int __inline__ _raw_write_trylock(rwlock_t *rw)
+static void __inline__ __raw_read_lock(raw_rwlock_t *rw)
 {
-        return __write_trylock(rw) == 0;
+        while (1) {
+                if (likely(__read_trylock(rw) > 0))
+                        break;
+                do {
+                        HMT_low();
+                        if (SHARED_PROCESSOR)
+                                __rw_yield(rw);
+                } while (unlikely(rw->lock < 0));
+                HMT_medium();
+        }
 }
 
-static void __inline__ _raw_write_lock(rwlock_t *rw)
+static void __inline__ __raw_write_lock(raw_rwlock_t *rw)
 {
         while (1) {
                 if (likely(__write_trylock(rw) == 0))
@@ -256,5 +207,35 @@ static void __inline__ _raw_write_lock(rwlock_t *rw)
         }
 }
 
-#endif /* __KERNEL__ */
+static int __inline__ __raw_read_trylock(raw_rwlock_t *rw)
+{
+        return __read_trylock(rw) > 0;
+}
+
+static int __inline__ __raw_write_trylock(raw_rwlock_t *rw)
+{
+        return __write_trylock(rw) == 0;
+}
+
+static void __inline__ __raw_read_unlock(raw_rwlock_t *rw)
+{
+        long tmp;
+
+        __asm__ __volatile__(
+        "eieio                          # read_unlock\n\
+1:      lwarx           %0,0,%1\n\
+        addic           %0,%0,-1\n\
+        stwcx.          %0,0,%1\n\
+        bne-            1b"
+        : "=&r"(tmp)
+        : "r"(&rw->lock)
+        : "cr0", "memory");
+}
+
+static __inline__ void __raw_write_unlock(raw_rwlock_t *rw)
+{
+        __asm__ __volatile__("lwsync    # write_unlock": : :"memory");
+        rw->lock = 0;
+}
+
 #endif /* __ASM_SPINLOCK_H */
diff --git a/include/asm-ppc64/spinlock_types.h b/include/asm-ppc64/spinlock_types.h
new file mode 100644
index 000000000000..a37c8eabb9f2
--- /dev/null
+++ b/include/asm-ppc64/spinlock_types.h
@@ -0,0 +1,20 @@
+#ifndef __ASM_SPINLOCK_TYPES_H
+#define __ASM_SPINLOCK_TYPES_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+typedef struct {
+        volatile unsigned int slock;
+} raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED        { 0 }
+
+typedef struct {
+        volatile signed int lock;
+} raw_rwlock_t;
+
+#define __RAW_RW_LOCK_UNLOCKED          { 0 }
+
+#endif
diff --git a/include/asm-ppc64/system.h b/include/asm-ppc64/system.h
index c0396428cc3c..375015c62f20 100644
--- a/include/asm-ppc64/system.h
+++ b/include/asm-ppc64/system.h
@@ -101,6 +101,9 @@ static inline int debugger_dabr_match(struct pt_regs *regs) { return 0; }
 static inline int debugger_fault_handler(struct pt_regs *regs) { return 0; }
 #endif
 
+extern int set_dabr(unsigned long dabr);
+extern void _exception(int signr, struct pt_regs *regs, int code,
+                       unsigned long addr);
 extern int fix_alignment(struct pt_regs *regs);
 extern void bad_page_fault(struct pt_regs *regs, unsigned long address,
                            int sig);
diff --git a/include/asm-s390/spinlock.h b/include/asm-s390/spinlock.h
index 321b23bba1ec..273dbecf8ace 100644
--- a/include/asm-s390/spinlock.h
+++ b/include/asm-s390/spinlock.h
@@ -27,25 +27,19 @@ _raw_compare_and_swap(volatile unsigned int *lock,
  * on the local processor, one does not.
  *
  * We make no fairness assumptions. They have a cost.
+ *
+ * (the type definitions are in asm/spinlock_types.h)
  */
 
-typedef struct {
-        volatile unsigned int lock;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} __attribute__ ((aligned (4))) spinlock_t;
-
-#define SPIN_LOCK_UNLOCKED      (spinlock_t) { 0 }
-#define spin_lock_init(lp)      do { (lp)->lock = 0; } while(0)
-#define spin_unlock_wait(lp)    do { barrier(); } while(((volatile spinlock_t *)(lp))->lock)
-#define spin_is_locked(x)       ((x)->lock != 0)
-#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
+#define __raw_spin_is_locked(x) ((x)->lock != 0)
+#define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)
+#define __raw_spin_unlock_wait(lock) \
+        do { while (__raw_spin_is_locked(lock)) cpu_relax(); } while (0)
 
-extern void _raw_spin_lock_wait(spinlock_t *lp, unsigned int pc);
-extern int _raw_spin_trylock_retry(spinlock_t *lp, unsigned int pc);
+extern void _raw_spin_lock_wait(raw_spinlock_t *lp, unsigned int pc);
+extern int _raw_spin_trylock_retry(raw_spinlock_t *lp, unsigned int pc);
 
-static inline void _raw_spin_lock(spinlock_t *lp)
+static inline void __raw_spin_lock(raw_spinlock_t *lp)
 {
         unsigned long pc = 1 | (unsigned long) __builtin_return_address(0);
 
@@ -53,7 +47,7 @@ static inline void _raw_spin_lock(spinlock_t *lp)
                 _raw_spin_lock_wait(lp, pc);
 }
 
-static inline int _raw_spin_trylock(spinlock_t *lp)
+static inline int __raw_spin_trylock(raw_spinlock_t *lp)
 {
         unsigned long pc = 1 | (unsigned long) __builtin_return_address(0);
 
@@ -62,7 +56,7 @@ static inline int _raw_spin_trylock(spinlock_t *lp)
         return _raw_spin_trylock_retry(lp, pc);
 }
 
-static inline void _raw_spin_unlock(spinlock_t *lp)
+static inline void __raw_spin_unlock(raw_spinlock_t *lp)
 {
         _raw_compare_and_swap(&lp->lock, lp->lock, 0);
 }
@@ -77,36 +71,25 @@ static inline void _raw_spin_unlock(spinlock_t *lp)
  * irq-safe write-lock, but readers can get non-irqsafe
  * read-locks.
  */
-typedef struct {
-        volatile unsigned int lock;
-        volatile unsigned long owner_pc;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} rwlock_t;
-
-#define RW_LOCK_UNLOCKED (rwlock_t) { 0, 0 }
-
-#define rwlock_init(x)  do { *(x) = RW_LOCK_UNLOCKED; } while(0)
 
 /**
  * read_can_lock - would read_trylock() succeed?
  * @lock: the rwlock in question.
  */
-#define read_can_lock(x) ((int)(x)->lock >= 0)
+#define __raw_read_can_lock(x) ((int)(x)->lock >= 0)
 
 /**
  * write_can_lock - would write_trylock() succeed?
  * @lock: the rwlock in question.
  */
-#define write_can_lock(x) ((x)->lock == 0)
+#define __raw_write_can_lock(x) ((x)->lock == 0)
 
-extern void _raw_read_lock_wait(rwlock_t *lp);
-extern int _raw_read_trylock_retry(rwlock_t *lp);
-extern void _raw_write_lock_wait(rwlock_t *lp);
-extern int _raw_write_trylock_retry(rwlock_t *lp);
+extern void _raw_read_lock_wait(raw_rwlock_t *lp);
+extern int _raw_read_trylock_retry(raw_rwlock_t *lp);
+extern void _raw_write_lock_wait(raw_rwlock_t *lp);
+extern int _raw_write_trylock_retry(raw_rwlock_t *lp);
 
-static inline void _raw_read_lock(rwlock_t *rw)
+static inline void __raw_read_lock(raw_rwlock_t *rw)
 {
         unsigned int old;
         old = rw->lock & 0x7fffffffU;
@@ -114,7 +97,7 @@ static inline void _raw_read_lock(rwlock_t *rw)
                 _raw_read_lock_wait(rw);
 }
 
-static inline void _raw_read_unlock(rwlock_t *rw)
+static inline void __raw_read_unlock(raw_rwlock_t *rw)
 {
         unsigned int old, cmp;
 
@@ -125,18 +108,18 @@ static inline void _raw_read_unlock(rwlock_t *rw)
         } while (cmp != old);
 }
 
-static inline void _raw_write_lock(rwlock_t *rw)
+static inline void __raw_write_lock(raw_rwlock_t *rw)
 {
         if (unlikely(_raw_compare_and_swap(&rw->lock, 0, 0x80000000) != 0))
                 _raw_write_lock_wait(rw);
 }
 
-static inline void _raw_write_unlock(rwlock_t *rw)
+static inline void __raw_write_unlock(raw_rwlock_t *rw)
 {
         _raw_compare_and_swap(&rw->lock, 0x80000000, 0);
 }
 
-static inline int _raw_read_trylock(rwlock_t *rw)
+static inline int __raw_read_trylock(raw_rwlock_t *rw)
 {
         unsigned int old;
         old = rw->lock & 0x7fffffffU;
@@ -145,7 +128,7 @@ static inline int _raw_read_trylock(rwlock_t *rw)
         return _raw_read_trylock_retry(rw);
 }
 
-static inline int _raw_write_trylock(rwlock_t *rw)
+static inline int __raw_write_trylock(raw_rwlock_t *rw)
 {
         if (likely(_raw_compare_and_swap(&rw->lock, 0, 0x80000000) == 0))
                 return 1;
diff --git a/include/asm-s390/spinlock_types.h b/include/asm-s390/spinlock_types.h
new file mode 100644
index 000000000000..f79a2216204f
--- /dev/null
+++ b/include/asm-s390/spinlock_types.h
@@ -0,0 +1,21 @@
+#ifndef __ASM_SPINLOCK_TYPES_H
+#define __ASM_SPINLOCK_TYPES_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+typedef struct {
+        volatile unsigned int lock;
+} __attribute__ ((aligned (4))) raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED        { 0 }
+
+typedef struct {
+        volatile unsigned int lock;
+        volatile unsigned int owner_pc;
+} raw_rwlock_t;
+
+#define __RAW_RW_LOCK_UNLOCKED          { 0, 0 }
+
+#endif
diff --git a/include/asm-sh/irq.h b/include/asm-sh/irq.h
index 831e52ee45b5..614a8c13b721 100644
--- a/include/asm-sh/irq.h
+++ b/include/asm-sh/irq.h
@@ -587,10 +587,6 @@ static inline int generic_irq_demux(int irq)
 #define irq_canonicalize(irq)   (irq)
 #define irq_demux(irq)          __irq_demux(sh_mv.mv_irq_demux(irq))
 
-struct irqaction;
-struct pt_regs;
-int handle_IRQ_event(unsigned int, struct pt_regs *, struct irqaction *);
-
 #if defined(CONFIG_CPU_SUBTYPE_SH73180)
 #include <asm/irq-sh73180.h>
 #endif
diff --git a/include/asm-sh/spinlock.h b/include/asm-sh/spinlock.h
index e770b55649eb..846322d4c35d 100644
--- a/include/asm-sh/spinlock.h
+++ b/include/asm-sh/spinlock.h
@@ -15,20 +15,11 @@
 /*
  * Your basic SMP spinlocks, allowing only a single CPU anywhere
  */
-typedef struct {
-        volatile unsigned long lock;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} spinlock_t;
 
-#define SPIN_LOCK_UNLOCKED      (spinlock_t) { 0 }
-
-#define spin_lock_init(x)       do { *(x) = SPIN_LOCK_UNLOCKED; } while(0)
-
-#define spin_is_locked(x)       ((x)->lock != 0)
-#define spin_unlock_wait(x)     do { barrier(); } while (spin_is_locked(x))
-#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
+#define __raw_spin_is_locked(x) ((x)->lock != 0)
+#define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)
+#define __raw_spin_unlock_wait(x) \
+        do { cpu_relax(); } while (__raw_spin_is_locked(x))
 
 /*
  * Simple spin lock operations.  There are two variants, one clears IRQ's
@@ -36,7 +27,7 @@ typedef struct {
  *
  * We make no fairness assumptions.  They have a cost.
  */
-static inline void _raw_spin_lock(spinlock_t *lock)
+static inline void __raw_spin_lock(raw_spinlock_t *lock)
 {
         __asm__ __volatile__ (
                 "1:\n\t"
@@ -49,14 +40,14 @@ static inline void _raw_spin_lock(spinlock_t *lock)
         );
 }
 
-static inline void _raw_spin_unlock(spinlock_t *lock)
+static inline void __raw_spin_unlock(raw_spinlock_t *lock)
 {
         assert_spin_locked(lock);
 
         lock->lock = 0;
 }
 
-#define _raw_spin_trylock(x) (!test_and_set_bit(0, &(x)->lock))
+#define __raw_spin_trylock(x) (!test_and_set_bit(0, &(x)->lock))
 
 /*
  * Read-write spinlocks, allowing multiple readers but only one writer.
@@ -66,51 +57,40 @@ static inline void _raw_spin_unlock(spinlock_t *lock)
  * needs to get a irq-safe write-lock, but readers can get non-irqsafe
  * read-locks.
  */
-typedef struct {
-        spinlock_t lock;
-        atomic_t counter;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} rwlock_t;
-
-#define RW_LOCK_BIAS            0x01000000
-#define RW_LOCK_UNLOCKED        (rwlock_t) { { 0 }, { RW_LOCK_BIAS } }
-#define rwlock_init(x)          do { *(x) = RW_LOCK_UNLOCKED; } while (0)
-
-static inline void _raw_read_lock(rwlock_t *rw)
+
+static inline void __raw_read_lock(raw_rwlock_t *rw)
 {
-        _raw_spin_lock(&rw->lock);
+        __raw_spin_lock(&rw->lock);
 
         atomic_inc(&rw->counter);
 
-        _raw_spin_unlock(&rw->lock);
+        __raw_spin_unlock(&rw->lock);
 }
 
-static inline void _raw_read_unlock(rwlock_t *rw)
+static inline void __raw_read_unlock(raw_rwlock_t *rw)
 {
-        _raw_spin_lock(&rw->lock);
+        __raw_spin_lock(&rw->lock);
 
         atomic_dec(&rw->counter);
 
-        _raw_spin_unlock(&rw->lock);
+        __raw_spin_unlock(&rw->lock);
 }
 
-static inline void _raw_write_lock(rwlock_t *rw)
+static inline void __raw_write_lock(raw_rwlock_t *rw)
 {
-        _raw_spin_lock(&rw->lock);
+        __raw_spin_lock(&rw->lock);
         atomic_set(&rw->counter, -1);
 }
 
-static inline void _raw_write_unlock(rwlock_t *rw)
+static inline void __raw_write_unlock(raw_rwlock_t *rw)
 {
         atomic_set(&rw->counter, 0);
-        _raw_spin_unlock(&rw->lock);
+        __raw_spin_unlock(&rw->lock);
 }
 
-#define _raw_read_trylock(lock) generic_raw_read_trylock(lock)
+#define __raw_read_trylock(lock) generic__raw_read_trylock(lock)
 
-static inline int _raw_write_trylock(rwlock_t *rw)
+static inline int __raw_write_trylock(raw_rwlock_t *rw)
 {
         if (atomic_sub_and_test(RW_LOCK_BIAS, &rw->counter))
                 return 1;
@@ -121,4 +101,3 @@ static inline int _raw_write_trylock(rwlock_t *rw)
 }
 
 #endif /* __ASM_SH_SPINLOCK_H */
-
diff --git a/include/asm-sh/spinlock_types.h b/include/asm-sh/spinlock_types.h
new file mode 100644
index 000000000000..8c41b6c3aac8
--- /dev/null
+++ b/include/asm-sh/spinlock_types.h
@@ -0,0 +1,22 @@
+#ifndef __ASM_SH_SPINLOCK_TYPES_H
+#define __ASM_SH_SPINLOCK_TYPES_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+typedef struct {
+        volatile unsigned long lock;
+} raw_spinlock_t;
+
+#define __SPIN_LOCK_UNLOCKED            { 0 }
+
+typedef struct {
+        raw_spinlock_t lock;
+        atomic_t counter;
+} raw_rwlock_t;
+
+#define RW_LOCK_BIAS                    0x01000000
+#define __RAW_RW_LOCK_UNLOCKED          { { 0 }, { RW_LOCK_BIAS } }
+
+#endif
diff --git a/include/asm-sparc/ptrace.h b/include/asm-sparc/ptrace.h
index dd9d94d7e0ae..a8ecb2d6977a 100644
--- a/include/asm-sparc/ptrace.h
+++ b/include/asm-sparc/ptrace.h
@@ -73,11 +73,11 @@ extern void show_regs(struct pt_regs *);
 #endif
 
 /*
- * The asm_offsets.h is a generated file, so we cannot include it.
+ * The asm-offsets.h is a generated file, so we cannot include it.
  * It may be OK for glibc headers, but it's utterly pointless for C code.
  * The assembly code using those offsets has to include it explicitly.
  */
-/* #include <asm/asm_offsets.h> */
+/* #include <asm/asm-offsets.h> */
 
 /* These are for pt_regs. */
 #define PT_PSR    0x0
diff --git a/include/asm-sparc/spinlock.h b/include/asm-sparc/spinlock.h
index 0cbd87ad4912..111727a2bb4e 100644
--- a/include/asm-sparc/spinlock.h
+++ b/include/asm-sparc/spinlock.h
@@ -12,96 +12,12 @@
 
 #include <asm/psr.h>
 
-#ifdef CONFIG_DEBUG_SPINLOCK
-struct _spinlock_debug {
-        unsigned char lock;
-        unsigned long owner_pc;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-};
-typedef struct _spinlock_debug spinlock_t;
-
-#define SPIN_LOCK_UNLOCKED      (spinlock_t) { 0, 0 }
-#define spin_lock_init(lp)      do { *(lp)= SPIN_LOCK_UNLOCKED; } while(0)
-#define spin_is_locked(lp)  (*((volatile unsigned char *)(&((lp)->lock))) != 0)
-#define spin_unlock_wait(lp)    do { barrier(); } while(*(volatile unsigned char *)(&(lp)->lock))
-
-extern void _do_spin_lock(spinlock_t *lock, char *str);
-extern int _spin_trylock(spinlock_t *lock);
-extern void _do_spin_unlock(spinlock_t *lock);
-
-#define _raw_spin_trylock(lp)   _spin_trylock(lp)
-#define _raw_spin_lock(lock)    _do_spin_lock(lock, "spin_lock")
-#define _raw_spin_unlock(lock)  _do_spin_unlock(lock)
-
-struct _rwlock_debug {
-        volatile unsigned int lock;
-        unsigned long owner_pc;
-        unsigned long reader_pc[NR_CPUS];
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-};
-typedef struct _rwlock_debug rwlock_t;
-
-#define RW_LOCK_UNLOCKED (rwlock_t) { 0, 0, {0} }
-
-#define rwlock_init(lp) do { *(lp)= RW_LOCK_UNLOCKED; } while(0)
-
-extern void _do_read_lock(rwlock_t *rw, char *str);
-extern void _do_read_unlock(rwlock_t *rw, char *str);
-extern void _do_write_lock(rwlock_t *rw, char *str);
-extern void _do_write_unlock(rwlock_t *rw);
-
-#define _raw_read_lock(lock)    \
-do {    unsigned long flags; \
-        local_irq_save(flags); \
-        _do_read_lock(lock, "read_lock"); \
-        local_irq_restore(flags); \
-} while(0)
-
-#define _raw_read_unlock(lock) \
-do {    unsigned long flags; \
-        local_irq_save(flags); \
-        _do_read_unlock(lock, "read_unlock"); \
-        local_irq_restore(flags); \
-} while(0)
-
-#define _raw_write_lock(lock) \
-do {    unsigned long flags; \
-        local_irq_save(flags); \
-        _do_write_lock(lock, "write_lock"); \
-        local_irq_restore(flags); \
-} while(0)
-
-#define _raw_write_unlock(lock) \
-do {    unsigned long flags; \
-        local_irq_save(flags); \
-        _do_write_unlock(lock); \
-        local_irq_restore(flags); \
-} while(0)
-
-#else /* !CONFIG_DEBUG_SPINLOCK */
-
-typedef struct {
-        unsigned char lock;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} spinlock_t;
-
-#define SPIN_LOCK_UNLOCKED      (spinlock_t) { 0 }
-
-#define spin_lock_init(lock)   (*((unsigned char *)(lock)) = 0)
-#define spin_is_locked(lock)    (*((volatile unsigned char *)(lock)) != 0)
+#define __raw_spin_is_locked(lock) (*((volatile unsigned char *)(lock)) != 0)
 
-#define spin_unlock_wait(lock) \
-do { \
-        barrier(); \
-} while(*((volatile unsigned char *)lock))
+#define __raw_spin_unlock_wait(lock) \
+        do { while (__raw_spin_is_locked(lock)) cpu_relax(); } while (0)
 
-extern __inline__ void _raw_spin_lock(spinlock_t *lock)
+extern __inline__ void __raw_spin_lock(raw_spinlock_t *lock)
 {
         __asm__ __volatile__(
         "\n1:\n\t"
@@ -121,7 +37,7 @@ extern __inline__ void _raw_spin_lock(spinlock_t *lock)
         : "g2", "memory", "cc");
 }
 
-extern __inline__ int _raw_spin_trylock(spinlock_t *lock)
+extern __inline__ int __raw_spin_trylock(raw_spinlock_t *lock)
 {
         unsigned int result;
         __asm__ __volatile__("ldstub [%1], %0"
@@ -131,7 +47,7 @@ extern __inline__ int _raw_spin_trylock(spinlock_t *lock)
         return (result == 0);
 }
 
-extern __inline__ void _raw_spin_unlock(spinlock_t *lock)
+extern __inline__ void __raw_spin_unlock(raw_spinlock_t *lock)
 {
         __asm__ __volatile__("stb %%g0, [%0]" : : "r" (lock) : "memory");
 }
@@ -147,23 +63,11 @@ extern __inline__ void _raw_spin_unlock(spinlock_t *lock)
  *
  * XXX This might create some problems with my dual spinlock
  * XXX scheme, deadlocks etc. -DaveM
- */
-typedef struct {
-        volatile unsigned int lock;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} rwlock_t;
-
-#define RW_LOCK_UNLOCKED (rwlock_t) { 0 }
-
-#define rwlock_init(lp) do { *(lp)= RW_LOCK_UNLOCKED; } while(0)
-
-
-/* Sort of like atomic_t's on Sparc, but even more clever.
+ *
+ * Sort of like atomic_t's on Sparc, but even more clever.
  *
  *      ------------------------------------
- *      | 24-bit counter           | wlock |  rwlock_t
+ *      | 24-bit counter           | wlock |  raw_rwlock_t
  *      ------------------------------------
  *       31                       8 7     0
  *
@@ -174,9 +78,9 @@ typedef struct {
  *
  * Unfortunately this scheme limits us to ~16,000,000 cpus.
  */
-extern __inline__ void _read_lock(rwlock_t *rw)
+extern __inline__ void __read_lock(raw_rwlock_t *rw)
 {
-        register rwlock_t *lp asm("g1");
+        register raw_rwlock_t *lp asm("g1");
         lp = rw;
         __asm__ __volatile__(
         "mov    %%o7, %%g4\n\t"
@@ -187,16 +91,16 @@ extern __inline__ void _read_lock(rwlock_t *rw)
         : "g2", "g4", "memory", "cc");
 }
 
-#define _raw_read_lock(lock) \
+#define __raw_read_lock(lock) \
 do {    unsigned long flags; \
         local_irq_save(flags); \
-        _read_lock(lock); \
+        __raw_read_lock(lock); \
         local_irq_restore(flags); \
 } while(0)
 
-extern __inline__ void _read_unlock(rwlock_t *rw)
+extern __inline__ void __read_unlock(raw_rwlock_t *rw)
 {
-        register rwlock_t *lp asm("g1");
+        register raw_rwlock_t *lp asm("g1");
         lp = rw;
         __asm__ __volatile__(
         "mov    %%o7, %%g4\n\t"
@@ -207,16 +111,16 @@ extern __inline__ void _read_unlock(rwlock_t *rw)
         : "g2", "g4", "memory", "cc");
 }
 
-#define _raw_read_unlock(lock) \
+#define __raw_read_unlock(lock) \
 do {    unsigned long flags; \
         local_irq_save(flags); \
-        _read_unlock(lock); \
+        __raw_read_unlock(lock); \
         local_irq_restore(flags); \
 } while(0)
 
-extern __inline__ void _raw_write_lock(rwlock_t *rw)
+extern __inline__ void __raw_write_lock(raw_rwlock_t *rw)
 {
-        register rwlock_t *lp asm("g1");
+        register raw_rwlock_t *lp asm("g1");
         lp = rw;
         __asm__ __volatile__(
         "mov    %%o7, %%g4\n\t"
@@ -227,11 +131,9 @@ extern __inline__ void _raw_write_lock(rwlock_t *rw)
         : "g2", "g4", "memory", "cc");
 }
 
-#define _raw_write_unlock(rw)   do { (rw)->lock = 0; } while(0)
-
-#endif /* CONFIG_DEBUG_SPINLOCK */
+#define __raw_write_unlock(rw)  do { (rw)->lock = 0; } while(0)
 
-#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
+#define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)
 
 #endif /* !(__ASSEMBLY__) */
 
diff --git a/include/asm-sparc/spinlock_types.h b/include/asm-sparc/spinlock_types.h
new file mode 100644
index 000000000000..0a0fb116c4ec
--- /dev/null
+++ b/include/asm-sparc/spinlock_types.h
@@ -0,0 +1,20 @@
+#ifndef __SPARC_SPINLOCK_TYPES_H
+#define __SPARC_SPINLOCK_TYPES_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+typedef struct {
+        unsigned char lock;
+} raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED        { 0 }
+
+typedef struct {
+        volatile unsigned int lock;
+} raw_rwlock_t;
+
+#define __RAW_RW_LOCK_UNLOCKED          { 0 }
+
+#endif
diff --git a/include/asm-sparc64/spinlock.h b/include/asm-sparc64/spinlock.h
index a02c4370eb42..ec85d12d73b9 100644
--- a/include/asm-sparc64/spinlock.h
+++ b/include/asm-sparc64/spinlock.h
@@ -29,24 +29,13 @@
  * must be pre-V9 branches.
  */
 
-#ifndef CONFIG_DEBUG_SPINLOCK
+#define __raw_spin_is_locked(lp)        ((lp)->lock != 0)
 
-typedef struct {
-        volatile unsigned char lock;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} spinlock_t;
-#define SPIN_LOCK_UNLOCKED      (spinlock_t) {0,}
+#define __raw_spin_unlock_wait(lp)      \
+        do {    rmb();                  \
+        } while((lp)->lock)
 
-#define spin_lock_init(lp)      do { *(lp)= SPIN_LOCK_UNLOCKED; } while(0)
-#define spin_is_locked(lp)  ((lp)->lock != 0)
-
-#define spin_unlock_wait(lp)    \
-do {    rmb();                  \
-} while((lp)->lock)
-
-static inline void _raw_spin_lock(spinlock_t *lock)
+static inline void __raw_spin_lock(raw_spinlock_t *lock)
 {
         unsigned long tmp;
 
@@ -67,7 +56,7 @@ static inline void _raw_spin_lock(spinlock_t *lock)
         : "memory");
 }
 
-static inline int _raw_spin_trylock(spinlock_t *lock)
+static inline int __raw_spin_trylock(raw_spinlock_t *lock)
 {
         unsigned long result;
 
@@ -81,7 +70,7 @@ static inline int _raw_spin_trylock(spinlock_t *lock)
         return (result == 0UL);
 }
 
-static inline void _raw_spin_unlock(spinlock_t *lock)
+static inline void __raw_spin_unlock(raw_spinlock_t *lock)
 {
         __asm__ __volatile__(
 "       membar          #StoreStore | #LoadStore\n"
@@ -91,7 +80,7 @@ static inline void _raw_spin_unlock(spinlock_t *lock)
         : "memory");
 }
 
-static inline void _raw_spin_lock_flags(spinlock_t *lock, unsigned long flags)
+static inline void __raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long flags)
 {
         unsigned long tmp1, tmp2;
 
@@ -115,51 +104,9 @@ static inline void _raw_spin_lock_flags(spinlock_t *lock, unsigned long flags)
         : "memory");
 }
 
-#else /* !(CONFIG_DEBUG_SPINLOCK) */
-
-typedef struct {
-        volatile unsigned char lock;
-        unsigned int owner_pc, owner_cpu;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} spinlock_t;
-#define SPIN_LOCK_UNLOCKED (spinlock_t) { 0, 0, 0xff }
-#define spin_lock_init(lp)      do { *(lp)= SPIN_LOCK_UNLOCKED; } while(0)
-#define spin_is_locked(__lock)  ((__lock)->lock != 0)
-#define spin_unlock_wait(__lock)        \
-do { \
-        rmb(); \
-} while((__lock)->lock)
-
-extern void _do_spin_lock(spinlock_t *lock, char *str, unsigned long caller);
-extern void _do_spin_unlock(spinlock_t *lock);
-extern int _do_spin_trylock(spinlock_t *lock, unsigned long caller);
-
-#define _raw_spin_trylock(lp)   \
-        _do_spin_trylock(lp, (unsigned long) __builtin_return_address(0))
-#define _raw_spin_lock(lock)    \
-        _do_spin_lock(lock, "spin_lock", \
-                      (unsigned long) __builtin_return_address(0))
-#define _raw_spin_unlock(lock)  _do_spin_unlock(lock)
-#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
-
-#endif /* CONFIG_DEBUG_SPINLOCK */
-
 /* Multi-reader locks, these are much saner than the 32-bit Sparc ones... */
 
-#ifndef CONFIG_DEBUG_SPINLOCK
-
-typedef struct {
-        volatile unsigned int lock;
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} rwlock_t;
-#define RW_LOCK_UNLOCKED        (rwlock_t) {0,}
-#define rwlock_init(lp) do { *(lp) = RW_LOCK_UNLOCKED; } while(0)
-
-static void inline __read_lock(rwlock_t *lock)
+static void inline __read_lock(raw_rwlock_t *lock)
 {
         unsigned long tmp1, tmp2;
 
@@ -184,7 +131,7 @@ static void inline __read_lock(rwlock_t *lock)
         : "memory");
 }
 
-static void inline __read_unlock(rwlock_t *lock)
+static void inline __read_unlock(raw_rwlock_t *lock)
 {
         unsigned long tmp1, tmp2;
 
@@ -201,7 +148,7 @@ static void inline __read_unlock(rwlock_t *lock)
         : "memory");
 }
 
-static void inline __write_lock(rwlock_t *lock)
+static void inline __write_lock(raw_rwlock_t *lock)
 {
         unsigned long mask, tmp1, tmp2;
 
@@ -228,7 +175,7 @@ static void inline __write_lock(rwlock_t *lock)
         : "memory");
 }
 
-static void inline __write_unlock(rwlock_t *lock)
+static void inline __write_unlock(raw_rwlock_t *lock)
 {
         __asm__ __volatile__(
 "       membar          #LoadStore | #StoreStore\n"
@@ -238,7 +185,7 @@ static void inline __write_unlock(rwlock_t *lock)
         : "memory");
 }
 
-static int inline __write_trylock(rwlock_t *lock)
+static int inline __write_trylock(raw_rwlock_t *lock)
 {
         unsigned long mask, tmp1, tmp2, result;
 
@@ -263,78 +210,15 @@ static int inline __write_trylock(rwlock_t *lock)
         return result;
 }
 
-#define _raw_read_lock(p)       __read_lock(p)
-#define _raw_read_unlock(p)     __read_unlock(p)
-#define _raw_write_lock(p)      __write_lock(p)
-#define _raw_write_unlock(p)    __write_unlock(p)
-#define _raw_write_trylock(p)   __write_trylock(p)
-
-#else /* !(CONFIG_DEBUG_SPINLOCK) */
-
-typedef struct {
-        volatile unsigned long lock;
-        unsigned int writer_pc, writer_cpu;
-        unsigned int reader_pc[NR_CPUS];
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} rwlock_t;
-#define RW_LOCK_UNLOCKED        (rwlock_t) { 0, 0, 0xff, { } }
-#define rwlock_init(lp) do { *(lp) = RW_LOCK_UNLOCKED; } while(0)
-
-extern void _do_read_lock(rwlock_t *rw, char *str, unsigned long caller);
-extern void _do_read_unlock(rwlock_t *rw, char *str, unsigned long caller);
-extern void _do_write_lock(rwlock_t *rw, char *str, unsigned long caller);
-extern void _do_write_unlock(rwlock_t *rw, unsigned long caller);
-extern int _do_write_trylock(rwlock_t *rw, char *str, unsigned long caller);
-
-#define _raw_read_lock(lock) \
-do {    unsigned long flags; \
-        local_irq_save(flags); \
-        _do_read_lock(lock, "read_lock", \
-                      (unsigned long) __builtin_return_address(0)); \
-        local_irq_restore(flags); \
-} while(0)
-
-#define _raw_read_unlock(lock) \
-do {    unsigned long flags; \
-        local_irq_save(flags); \
-        _do_read_unlock(lock, "read_unlock", \
-                      (unsigned long) __builtin_return_address(0)); \
-        local_irq_restore(flags); \
-} while(0)
-
-#define _raw_write_lock(lock) \
-do {    unsigned long flags; \
-        local_irq_save(flags); \
-        _do_write_lock(lock, "write_lock", \
-                      (unsigned long) __builtin_return_address(0)); \
-        local_irq_restore(flags); \
-} while(0)
-
-#define _raw_write_unlock(lock) \
-do {    unsigned long flags; \
-        local_irq_save(flags); \
-        _do_write_unlock(lock, \
-                      (unsigned long) __builtin_return_address(0)); \
-        local_irq_restore(flags); \
-} while(0)
-
-#define _raw_write_trylock(lock) \
-({      unsigned long flags; \
-        int val; \
-        local_irq_save(flags); \
-        val = _do_write_trylock(lock, "write_trylock", \
-                                (unsigned long) __builtin_return_address(0)); \
-        local_irq_restore(flags); \
-        val; \
-})
-
-#endif /* CONFIG_DEBUG_SPINLOCK */
-
-#define _raw_read_trylock(lock) generic_raw_read_trylock(lock)
-#define read_can_lock(rw)       (!((rw)->lock & 0x80000000UL))
-#define write_can_lock(rw)      (!(rw)->lock)
+#define __raw_read_lock(p)      __read_lock(p)
+#define __raw_read_unlock(p)    __read_unlock(p)
+#define __raw_write_lock(p)     __write_lock(p)
+#define __raw_write_unlock(p)   __write_unlock(p)
+#define __raw_write_trylock(p)  __write_trylock(p)
+
+#define __raw_read_trylock(lock)        generic__raw_read_trylock(lock)
+#define __raw_read_can_lock(rw)         (!((rw)->lock & 0x80000000UL))
+#define __raw_write_can_lock(rw)        (!(rw)->lock)
 
 #endif /* !(__ASSEMBLY__) */
 
diff --git a/include/asm-sparc64/spinlock_types.h b/include/asm-sparc64/spinlock_types.h
new file mode 100644
index 000000000000..e128112a0d7c
--- /dev/null
+++ b/include/asm-sparc64/spinlock_types.h
@@ -0,0 +1,20 @@
+#ifndef __SPARC64_SPINLOCK_TYPES_H
+#define __SPARC64_SPINLOCK_TYPES_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+typedef struct {
+        volatile unsigned char lock;
+} raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED        { 0 }
+
+typedef struct {
+        volatile unsigned int lock;
+} raw_rwlock_t;
+
+#define __RAW_RW_LOCK_UNLOCKED          { 0 }
+
+#endif
diff --git a/include/asm-um/page.h b/include/asm-um/page.h
index bd850a249183..2c192abe9aeb 100644
--- a/include/asm-um/page.h
+++ b/include/asm-um/page.h
@@ -96,8 +96,7 @@ extern unsigned long uml_physmem;
 
 #define __va_space (8*1024*1024)
 
-extern unsigned long to_phys(void *virt);
-extern void *to_virt(unsigned long phys);
+#include "mem.h"
 
 /* Cast to unsigned long before casting to void * to avoid a warning from
  * mmap_kmem about cutting a long long down to a void *.  Not sure that
diff --git a/include/asm-um/pgtable.h b/include/asm-um/pgtable.h
index b48e0966ecd7..ed06170e0edd 100644
--- a/include/asm-um/pgtable.h
+++ b/include/asm-um/pgtable.h
@@ -326,14 +326,22 @@ static inline void set_pte(pte_t *pteptr, pte_t pteval)
 }
 #define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)
 
-extern phys_t page_to_phys(struct page *page);
-
 /*
  * Conversion functions: convert a page and protection to a page entry,
  * and a page entry and page directory to the page they refer to.
  */
 
-extern pte_t mk_pte(struct page *page, pgprot_t pgprot);
+#define phys_to_page(phys) pfn_to_page(phys_to_pfn(phys))
+#define __virt_to_page(virt) phys_to_page(__pa(virt))
+#define page_to_phys(page) pfn_to_phys(page_to_pfn(page))
+
+#define mk_pte(page, pgprot) \
+        ({ pte_t pte;                                   \
+                                                        \
+        pte_set_val(pte, page_to_phys(page), (pgprot)); \
+        if (pte_present(pte))                           \
+                pte_mknewprot(pte_mknewpage(pte));      \
+        pte;})
 
 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
 {
@@ -410,8 +418,6 @@ static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
 #endif
 #endif
 
-extern struct page *phys_to_page(const unsigned long phys);
-extern struct page *__virt_to_page(const unsigned long virt);
 #define virt_to_page(addr) __virt_to_page((const unsigned long) addr)
 
 /*
diff --git a/include/asm-um/spinlock_types.h b/include/asm-um/spinlock_types.h
new file mode 100644
index 000000000000..e5a94294bf82
--- /dev/null
+++ b/include/asm-um/spinlock_types.h
@@ -0,0 +1,6 @@
+#ifndef __UM_SPINLOCK_TYPES_H
+#define __UM_SPINLOCK_TYPES_H
+
+#include "asm/arch/spinlock_types.h"
+
+#endif
diff --git a/include/asm-x86_64/apic.h b/include/asm-x86_64/apic.h
index 16ec82e16b21..6c5d5ca8383a 100644
--- a/include/asm-x86_64/apic.h
+++ b/include/asm-x86_64/apic.h
@@ -109,9 +109,10 @@ extern unsigned int nmi_watchdog;
 #define NMI_LOCAL_APIC  2
 #define NMI_INVALID     3
 
+extern int disable_timer_pin_1;
+
 #endif /* CONFIG_X86_LOCAL_APIC */
 
-#define esr_disable 0
 extern unsigned boot_cpu_id;
 
 #endif /* __ASM_APIC_H */
diff --git a/include/asm-x86_64/apicdef.h b/include/asm-x86_64/apicdef.h
index 9388062c4f6e..fb1c99ac669f 100644
--- a/include/asm-x86_64/apicdef.h
+++ b/include/asm-x86_64/apicdef.h
@@ -113,6 +113,7 @@
 #define APIC_BASE (fix_to_virt(FIX_APIC_BASE))
 
 #define MAX_IO_APICS 128
+#define MAX_LOCAL_APIC 256
 
 /*
  * All x86-64 systems are xAPIC compatible.
diff --git a/include/asm-x86_64/bug.h b/include/asm-x86_64/bug.h
index eed785667289..80ac1fe966ac 100644
--- a/include/asm-x86_64/bug.h
+++ b/include/asm-x86_64/bug.h
@@ -9,10 +9,8 @@
  */
 struct bug_frame {
         unsigned char ud2[2];
-        unsigned char mov;
-        /* should use 32bit offset instead, but the assembler doesn't 
-           like it */
-        char *filename;
+        unsigned char push;
+        signed int filename;
         unsigned char ret;
         unsigned short line;
 } __attribute__((packed));
@@ -25,8 +23,8 @@ struct bug_frame {
    The magic numbers generate mov $64bitimm,%eax ; ret $offset. */
 #define BUG()                                                           \
         asm volatile(                                                   \
-        "ud2 ; .byte 0xa3 ; .quad %c1 ; .byte 0xc2 ; .short %c0" ::     \
-                     "i"(__LINE__), "i" (__stringify(__FILE__)))
+        "ud2 ; pushq $%c1 ; ret $%c0" ::                                \
+                     "i"(__LINE__), "i" (__FILE__))
 void out_of_line_bug(void);
 #else
 static inline void out_of_line_bug(void) { }
diff --git a/include/asm-x86_64/calling.h b/include/asm-x86_64/calling.h
index 0bc12655fa5b..fc2c5a6c262a 100644
--- a/include/asm-x86_64/calling.h
+++ b/include/asm-x86_64/calling.h
@@ -65,27 +65,36 @@
         .if \skipr11
         .else
         movq (%rsp),%r11
+        CFI_RESTORE r11
         .endif
         .if \skipr8910
         .else
         movq 1*8(%rsp),%r10
+        CFI_RESTORE r10
         movq 2*8(%rsp),%r9
+        CFI_RESTORE r9
         movq 3*8(%rsp),%r8
+        CFI_RESTORE r8
         .endif
         .if \skiprax
         .else
         movq 4*8(%rsp),%rax
+        CFI_RESTORE rax
         .endif
         .if \skiprcx
         .else
         movq 5*8(%rsp),%rcx
+        CFI_RESTORE rcx
         .endif
         .if \skiprdx
         .else
         movq 6*8(%rsp),%rdx
+        CFI_RESTORE rdx
         .endif
         movq 7*8(%rsp),%rsi
+        CFI_RESTORE rsi
         movq 8*8(%rsp),%rdi
+        CFI_RESTORE rdi
         .if ARG_SKIP+\addskip > 0
         addq $ARG_SKIP+\addskip,%rsp
         CFI_ADJUST_CFA_OFFSET   -(ARG_SKIP+\addskip)
@@ -124,11 +133,17 @@
 
         .macro RESTORE_REST
         movq (%rsp),%r15
+        CFI_RESTORE r15
         movq 1*8(%rsp),%r14
+        CFI_RESTORE r14
         movq 2*8(%rsp),%r13
+        CFI_RESTORE r13
         movq 3*8(%rsp),%r12
+        CFI_RESTORE r12
         movq 4*8(%rsp),%rbp
+        CFI_RESTORE rbp
         movq 5*8(%rsp),%rbx
+        CFI_RESTORE rbx
         addq $REST_SKIP,%rsp
         CFI_ADJUST_CFA_OFFSET   -(REST_SKIP)
         .endm
@@ -146,11 +161,3 @@
         .macro icebp
         .byte 0xf1
         .endm
-
-#ifdef CONFIG_FRAME_POINTER
-#define ENTER enter
-#define LEAVE leave
-#else
-#define ENTER
-#define LEAVE
-#endif
diff --git a/include/asm-x86_64/current.h b/include/asm-x86_64/current.h
index 7db560ee6f70..bc8adecee66d 100644
--- a/include/asm-x86_64/current.h
+++ b/include/asm-x86_64/current.h
@@ -17,7 +17,7 @@ static inline struct task_struct *get_current(void)
 #else
 
 #ifndef ASM_OFFSET_H
-#include <asm/offset.h> 
+#include <asm/asm-offsets.h> 
 #endif
 
 #define GET_CURRENT(reg) movq %gs:(pda_pcurrent),reg
diff --git a/include/asm-x86_64/desc.h b/include/asm-x86_64/desc.h
index c89b58bebee2..594e610f4a1e 100644
--- a/include/asm-x86_64/desc.h
+++ b/include/asm-x86_64/desc.h
@@ -191,7 +191,7 @@ static inline void load_TLS(struct thread_struct *t, unsigned int cpu)
 /*
  * load one particular LDT into the current CPU
  */
-extern inline void load_LDT_nolock (mm_context_t *pc, int cpu)
+static inline void load_LDT_nolock (mm_context_t *pc, int cpu)
 {
         int count = pc->size;
 
diff --git a/include/asm-x86_64/dma-mapping.h b/include/asm-x86_64/dma-mapping.h
index a416dc31634a..e784fdc524f1 100644
--- a/include/asm-x86_64/dma-mapping.h
+++ b/include/asm-x86_64/dma-mapping.h
@@ -85,6 +85,11 @@ static inline void dma_sync_single_for_device(struct device *hwdev,
         flush_write_buffers();
 }
 
+#define dma_sync_single_range_for_cpu(dev, dma_handle, offset, size, dir)       \
+        dma_sync_single_for_cpu(dev, dma_handle, size, dir)
+#define dma_sync_single_range_for_device(dev, dma_handle, offset, size, dir)    \
+        dma_sync_single_for_device(dev, dma_handle, size, dir)
+
 static inline void dma_sync_sg_for_cpu(struct device *hwdev,
                                        struct scatterlist *sg,
                                        int nelems, int direction)
diff --git a/include/asm-x86_64/dwarf2.h b/include/asm-x86_64/dwarf2.h
index afd4212e860b..582757fc0365 100644
--- a/include/asm-x86_64/dwarf2.h
+++ b/include/asm-x86_64/dwarf2.h
@@ -24,6 +24,10 @@
 #define CFI_ADJUST_CFA_OFFSET .cfi_adjust_cfa_offset
 #define CFI_OFFSET .cfi_offset
 #define CFI_REL_OFFSET .cfi_rel_offset
+#define CFI_REGISTER .cfi_register
+#define CFI_RESTORE .cfi_restore
+#define CFI_REMEMBER_STATE .cfi_remember_state
+#define CFI_RESTORE_STATE .cfi_restore_state
 
 #else
 
@@ -36,6 +40,10 @@
 #define CFI_ADJUST_CFA_OFFSET   #
 #define CFI_OFFSET      #
 #define CFI_REL_OFFSET  #
+#define CFI_REGISTER    #
+#define CFI_RESTORE     #
+#define CFI_REMEMBER_STATE      #
+#define CFI_RESTORE_STATE       #
 
 #endif
 
diff --git a/include/asm-x86_64/fixmap.h b/include/asm-x86_64/fixmap.h
index cf8b16cbe8db..a582cfcf2231 100644
--- a/include/asm-x86_64/fixmap.h
+++ b/include/asm-x86_64/fixmap.h
@@ -76,7 +76,7 @@ extern void __this_fixmap_does_not_exist(void);
  * directly without translation, we catch the bug with a NULL-deference
  * kernel oops. Illegal ranges of incoming indices are caught too.
  */
-extern inline unsigned long fix_to_virt(const unsigned int idx)
+static inline unsigned long fix_to_virt(const unsigned int idx)
 {
         /*
          * this branch gets completely eliminated after inlining,
diff --git a/include/asm-x86_64/hardirq.h b/include/asm-x86_64/hardirq.h
index 27c381fa1c9d..8661b476fb40 100644
--- a/include/asm-x86_64/hardirq.h
+++ b/include/asm-x86_64/hardirq.h
@@ -9,11 +9,12 @@
 
 #define __ARCH_IRQ_STAT 1
 
-/* Generate a lvalue for a pda member. Should fix softirq.c instead to use
-   special access macros. This would generate better code. */ 
-#define __IRQ_STAT(cpu,member) (read_pda(me)->member)
+#define local_softirq_pending() read_pda(__softirq_pending)
 
-#include <linux/irq_cpustat.h>  /* Standard mappings for irq_cpustat_t above */
+#define __ARCH_SET_SOFTIRQ_PENDING 1
+
+#define set_softirq_pending(x) write_pda(__softirq_pending, (x))
+#define or_softirq_pending(x)  or_pda(__softirq_pending, (x))
 
 /*
  * 'what should we do if we get a hw irq event on an illegal vector'.
diff --git a/include/asm-x86_64/hw_irq.h b/include/asm-x86_64/hw_irq.h
index 2b5cb2865d21..dc97668ea0f9 100644
--- a/include/asm-x86_64/hw_irq.h
+++ b/include/asm-x86_64/hw_irq.h
@@ -26,6 +26,7 @@
 struct hw_interrupt_type;
 #endif
 
+#define NMI_VECTOR              0x02
 /*
  * IDT vectors usable for external interrupt sources start
  * at 0x20:
@@ -50,14 +51,15 @@ struct hw_interrupt_type;
  */
 #define SPURIOUS_APIC_VECTOR    0xff
 #define ERROR_APIC_VECTOR       0xfe
-#define INVALIDATE_TLB_VECTOR   0xfd
-#define RESCHEDULE_VECTOR       0xfc
-#define TASK_MIGRATION_VECTOR   0xfb
-#define CALL_FUNCTION_VECTOR    0xfa
-#define KDB_VECTOR      0xf9
-
-#define THERMAL_APIC_VECTOR     0xf0
-
+#define RESCHEDULE_VECTOR       0xfd
+#define CALL_FUNCTION_VECTOR    0xfc
+#define KDB_VECTOR              0xfb    /* reserved for KDB */
+#define THERMAL_APIC_VECTOR     0xfa
+/* 0xf9 free */
+#define INVALIDATE_TLB_VECTOR_END       0xf8
+#define INVALIDATE_TLB_VECTOR_START     0xf0    /* f0-f8 used for TLB flush */
+
+#define NUM_INVALIDATE_TLB_VECTORS      8
 
 /*
  * Local APIC timer IRQ vector is on a different priority level,
diff --git a/include/asm-x86_64/io.h b/include/asm-x86_64/io.h
index 37fc3f149a5a..52ff269fe054 100644
--- a/include/asm-x86_64/io.h
+++ b/include/asm-x86_64/io.h
@@ -48,7 +48,7 @@
  * Talk about misusing macros..
  */
 #define __OUT1(s,x) \
-extern inline void out##s(unsigned x value, unsigned short port) {
+static inline void out##s(unsigned x value, unsigned short port) {
 
 #define __OUT2(s,s1,s2) \
 __asm__ __volatile__ ("out" #s " %" s1 "0,%" s2 "1"
@@ -58,7 +58,7 @@ __OUT1(s,x) __OUT2(s,s1,"w") : : "a" (value), "Nd" (port)); } \
 __OUT1(s##_p,x) __OUT2(s,s1,"w") __FULL_SLOW_DOWN_IO : : "a" (value), "Nd" (port));} \
 
 #define __IN1(s) \
-extern inline RETURN_TYPE in##s(unsigned short port) { RETURN_TYPE _v;
+static inline RETURN_TYPE in##s(unsigned short port) { RETURN_TYPE _v;
 
 #define __IN2(s,s1,s2) \
 __asm__ __volatile__ ("in" #s " %" s2 "1,%" s1 "0"
@@ -68,12 +68,12 @@ __IN1(s) __IN2(s,s1,"w") : "=a" (_v) : "Nd" (port) ,##i ); return _v; } \
 __IN1(s##_p) __IN2(s,s1,"w") __FULL_SLOW_DOWN_IO : "=a" (_v) : "Nd" (port) ,##i ); return _v; } \
 
 #define __INS(s) \
-extern inline void ins##s(unsigned short port, void * addr, unsigned long count) \
+static inline void ins##s(unsigned short port, void * addr, unsigned long count) \
 { __asm__ __volatile__ ("rep ; ins" #s \
 : "=D" (addr), "=c" (count) : "d" (port),"0" (addr),"1" (count)); }
 
 #define __OUTS(s) \
-extern inline void outs##s(unsigned short port, const void * addr, unsigned long count) \
+static inline void outs##s(unsigned short port, const void * addr, unsigned long count) \
 { __asm__ __volatile__ ("rep ; outs" #s \
 : "=S" (addr), "=c" (count) : "d" (port),"0" (addr),"1" (count)); }
 
@@ -110,12 +110,12 @@ __OUTS(l)
  * Change virtual addresses to physical addresses and vv.
  * These are pretty trivial
  */
-extern inline unsigned long virt_to_phys(volatile void * address)
+static inline unsigned long virt_to_phys(volatile void * address)
 {
         return __pa(address);
 }
 
-extern inline void * phys_to_virt(unsigned long address)
+static inline void * phys_to_virt(unsigned long address)
 {
         return __va(address);
 }
@@ -130,7 +130,7 @@ extern inline void * phys_to_virt(unsigned long address)
 
 extern void __iomem *__ioremap(unsigned long offset, unsigned long size, unsigned long flags);
 
-extern inline void __iomem * ioremap (unsigned long offset, unsigned long size)
+static inline void __iomem * ioremap (unsigned long offset, unsigned long size)
 {
         return __ioremap(offset, size, 0);
 }
diff --git a/include/asm-x86_64/ipi.h b/include/asm-x86_64/ipi.h
index 5e166b9d3bde..022e9d340ad7 100644
--- a/include/asm-x86_64/ipi.h
+++ b/include/asm-x86_64/ipi.h
@@ -31,9 +31,20 @@
 
 static inline unsigned int __prepare_ICR (unsigned int shortcut, int vector, unsigned int dest)
 {
-        unsigned int icr =  APIC_DM_FIXED | shortcut | vector | dest;
-        if (vector == KDB_VECTOR)
-                icr = (icr & (~APIC_VECTOR_MASK)) | APIC_DM_NMI;
+        unsigned int icr = shortcut | dest;
+
+        switch (vector) {
+        default:
+                icr |= APIC_DM_FIXED | vector;
+                break;
+        case NMI_VECTOR:
+                /*
+                 * Setup KDB IPI to be delivered as an NMI
+                 */
+        case KDB_VECTOR:
+                icr |= APIC_DM_NMI;
+                break;
+        }
         return icr;
 }
 
@@ -66,7 +77,7 @@ static inline void __send_IPI_shortcut(unsigned int shortcut, int vector, unsign
         /*
          * Send the IPI. The write to APIC_ICR fires this off.
          */
-        apic_write_around(APIC_ICR, cfg);
+        apic_write(APIC_ICR, cfg);
 }
 
 
@@ -92,7 +103,7 @@ static inline void send_IPI_mask_sequence(cpumask_t mask, int vector)
                  * prepare target chip field
                  */
                 cfg = __prepare_ICR2(x86_cpu_to_apicid[query_cpu]);
-                apic_write_around(APIC_ICR2, cfg);
+                apic_write(APIC_ICR2, cfg);
 
                 /*
                  * program the ICR
@@ -102,7 +113,7 @@ static inline void send_IPI_mask_sequence(cpumask_t mask, int vector)
                 /*
                  * Send the IPI. The write to APIC_ICR fires this off.
                  */
-                apic_write_around(APIC_ICR, cfg);
+                apic_write(APIC_ICR, cfg);
         }
         local_irq_restore(flags);
 }
diff --git a/include/asm-x86_64/irq.h b/include/asm-x86_64/irq.h
index 4482657777bb..fb724ba37ae6 100644
--- a/include/asm-x86_64/irq.h
+++ b/include/asm-x86_64/irq.h
@@ -48,10 +48,6 @@ static __inline__ int irq_canonicalize(int irq)
 #define ARCH_HAS_NMI_WATCHDOG           /* See include/linux/nmi.h */
 #endif
 
-struct irqaction;
-struct pt_regs;
-int handle_IRQ_event(unsigned int, struct pt_regs *, struct irqaction *);
-
 #ifdef CONFIG_HOTPLUG_CPU
 #include <linux/cpumask.h>
 extern void fixup_irqs(cpumask_t map);
diff --git a/include/asm-x86_64/kdebug.h b/include/asm-x86_64/kdebug.h
index b90341994d80..f604e84c5303 100644
--- a/include/asm-x86_64/kdebug.h
+++ b/include/asm-x86_64/kdebug.h
@@ -46,7 +46,7 @@ extern void die(const char *,struct pt_regs *,long);
 extern void __die(const char *,struct pt_regs *,long);
 extern void show_registers(struct pt_regs *regs);
 extern void dump_pagetable(unsigned long);
-extern void oops_begin(void);
-extern void oops_end(void);
+extern unsigned long oops_begin(void);
+extern void oops_end(unsigned long);
 
 #endif
diff --git a/include/asm-x86_64/local.h b/include/asm-x86_64/local.h
index c954f15c1a75..3e72c41727c5 100644
--- a/include/asm-x86_64/local.h
+++ b/include/asm-x86_64/local.h
@@ -29,7 +29,7 @@ static __inline__ void local_dec(local_t *v)
                 :"m" (v->counter));
 }
 
-static __inline__ void local_add(unsigned long i, local_t *v)
+static __inline__ void local_add(unsigned int i, local_t *v)
 {
         __asm__ __volatile__(
                 "addl %1,%0"
@@ -37,7 +37,7 @@ static __inline__ void local_add(unsigned long i, local_t *v)
                 :"ir" (i), "m" (v->counter));
 }
 
-static __inline__ void local_sub(unsigned long i, local_t *v)
+static __inline__ void local_sub(unsigned int i, local_t *v)
 {
         __asm__ __volatile__(
                 "subl %1,%0"
diff --git a/include/asm-x86_64/mmzone.h b/include/asm-x86_64/mmzone.h
index 768413751b34..b40c661f111e 100644
--- a/include/asm-x86_64/mmzone.h
+++ b/include/asm-x86_64/mmzone.h
@@ -12,7 +12,7 @@
 
 #include <asm/smp.h>
 
-#define NODEMAPSIZE 0xff
+#define NODEMAPSIZE 0xfff
 
 /* Simple perfect hash to map physical addresses to node numbers */
 extern int memnode_shift; 
@@ -54,7 +54,7 @@ static inline __attribute__((pure)) int phys_to_nid(unsigned long addr)
 
 #define pfn_valid(pfn) ((pfn) >= num_physpages ? 0 : \
                         ({ u8 nid__ = pfn_to_nid(pfn); \
-                           nid__ != 0xff && (pfn) >= node_start_pfn(nid__) && (pfn) <= node_end_pfn(nid__); }))
+                           nid__ != 0xff && (pfn) >= node_start_pfn(nid__) && (pfn) < node_end_pfn(nid__); }))
 #endif
 
 #define local_mapnr(kvaddr) \
diff --git a/include/asm-x86_64/msr.h b/include/asm-x86_64/msr.h
index ba15279a79d0..4d727f3f5550 100644
--- a/include/asm-x86_64/msr.h
+++ b/include/asm-x86_64/msr.h
@@ -29,22 +29,37 @@
 #define wrmsrl(msr,val) wrmsr(msr,(__u32)((__u64)(val)),((__u64)(val))>>32) 
 
 /* wrmsr with exception handling */
-#define wrmsr_safe(msr,a,b) ({ int ret__;                                               \
-        asm volatile("2: wrmsr ; xorl %0,%0\n"                                          \
-                     "1:\n\t"                                                           \
-                     ".section .fixup,\"ax\"\n\t"                                       \
-                     "3:  movl %4,%0 ; jmp 1b\n\t"                                      \
-                     ".previous\n\t"                                                    \
-                     ".section __ex_table,\"a\"\n"                                      \
-                     "   .align 8\n\t"                                                  \
-                     "   .quad  2b,3b\n\t"                                              \
-                     ".previous"                                                        \
-                     : "=a" (ret__)                                                     \
-                     : "c" (msr), "0" (a), "d" (b), "i" (-EFAULT));\
+#define wrmsr_safe(msr,a,b) ({ int ret__;                       \
+        asm volatile("2: wrmsr ; xorl %0,%0\n"                  \
+                     "1:\n\t"                                   \
+                     ".section .fixup,\"ax\"\n\t"               \
+                     "3:  movl %4,%0 ; jmp 1b\n\t"              \
+                     ".previous\n\t"                            \
+                     ".section __ex_table,\"a\"\n"              \
+                     "   .align 8\n\t"                          \
+                     "   .quad  2b,3b\n\t"                      \
+                     ".previous"                                \
+                     : "=a" (ret__)                             \
+                     : "c" (msr), "0" (a), "d" (b), "i" (-EFAULT)); \
         ret__; })
 
 #define checking_wrmsrl(msr,val) wrmsr_safe(msr,(u32)(val),(u32)((val)>>32))
 
+#define rdmsr_safe(msr,a,b) \
+        ({ int ret__;                                           \
+          asm volatile ("1:       rdmsr\n"                      \
+                      "2:\n"                                    \
+                      ".section .fixup,\"ax\"\n"                \
+                      "3:       movl %4,%0\n"                   \
+                      " jmp 2b\n"                               \
+                      ".previous\n"                             \
+                      ".section __ex_table,\"a\"\n"             \
+                      " .align 8\n"                             \
+                      " .quad 1b,3b\n"                          \
+                      ".previous":"=&bDS" (ret__), "=a"(a), "=d"(b)\
+                      :"c"(msr), "i"(-EIO), "0"(0));            \
+          ret__; })             
+
 #define rdtsc(low,high) \
      __asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high))
 
@@ -64,7 +79,7 @@
                           : "=a" (low), "=d" (high) \
                           : "c" (counter))
 
-extern inline void cpuid(int op, unsigned int *eax, unsigned int *ebx,
+static inline void cpuid(int op, unsigned int *eax, unsigned int *ebx,
                          unsigned int *ecx, unsigned int *edx)
 {
         __asm__("cpuid"
@@ -90,7 +105,7 @@ static inline void cpuid_count(int op, int count, int *eax, int *ebx, int *ecx,
 /*
  * CPUID functions returning a single datum
  */
-extern inline unsigned int cpuid_eax(unsigned int op)
+static inline unsigned int cpuid_eax(unsigned int op)
 {
         unsigned int eax;
 
@@ -100,7 +115,7 @@ extern inline unsigned int cpuid_eax(unsigned int op)
                 : "bx", "cx", "dx");
         return eax;
 }
-extern inline unsigned int cpuid_ebx(unsigned int op)
+static inline unsigned int cpuid_ebx(unsigned int op)
 {
         unsigned int eax, ebx;
 
@@ -110,7 +125,7 @@ extern inline unsigned int cpuid_ebx(unsigned int op)
                 : "cx", "dx" );
         return ebx;
 }
-extern inline unsigned int cpuid_ecx(unsigned int op)
+static inline unsigned int cpuid_ecx(unsigned int op)
 {
         unsigned int eax, ecx;
 
@@ -120,7 +135,7 @@ extern inline unsigned int cpuid_ecx(unsigned int op)
                 : "bx", "dx" );
         return ecx;
 }
-extern inline unsigned int cpuid_edx(unsigned int op)
+static inline unsigned int cpuid_edx(unsigned int op)
 {
         unsigned int eax, edx;
 
diff --git a/include/asm-x86_64/numa.h b/include/asm-x86_64/numa.h
index 5c363a1482e4..bcf55c3f7f7f 100644
--- a/include/asm-x86_64/numa.h
+++ b/include/asm-x86_64/numa.h
@@ -9,6 +9,7 @@ struct node {
 };
 
 extern int compute_hash_shift(struct node *nodes, int numnodes);
+extern int pxm_to_node(int nid);
 
 #define ZONE_ALIGN (1UL << (MAX_ORDER+PAGE_SHIFT))
 
@@ -16,6 +17,8 @@ extern void numa_add_cpu(int cpu);
 extern void numa_init_array(void);
 extern int numa_off;
 
+extern unsigned char apicid_to_node[256];
+
 #define NUMA_NO_NODE 0xff
 
 #endif
diff --git a/include/asm-x86_64/page.h b/include/asm-x86_64/page.h
index 135ffaa0393b..e5ab4d231f2c 100644
--- a/include/asm-x86_64/page.h
+++ b/include/asm-x86_64/page.h
@@ -32,6 +32,8 @@
 #ifdef __KERNEL__
 #ifndef __ASSEMBLY__
 
+extern unsigned long end_pfn;
+
 void clear_page(void *);
 void copy_page(void *, void *);
 
@@ -111,7 +113,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 #ifdef CONFIG_FLATMEM
 #define pfn_to_page(pfn)        (mem_map + (pfn))
 #define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
-#define pfn_valid(pfn)          ((pfn) < max_mapnr)
+#define pfn_valid(pfn)          ((pfn) < end_pfn)
 #endif
 
 #define virt_to_page(kaddr)     pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
diff --git a/include/asm-x86_64/pci.h b/include/asm-x86_64/pci.h
index eeb3088a1c9e..5a82a6762c21 100644
--- a/include/asm-x86_64/pci.h
+++ b/include/asm-x86_64/pci.h
@@ -50,10 +50,10 @@ extern int iommu_setup(char *opt);
  * address space.  The networking and block device layers use
  * this boolean for bounce buffer decisions
  *
- * On AMD64 it mostly equals, but we set it to zero to tell some subsystems
- * that an IOMMU is available.
+ * On x86-64 it mostly equals, but we set it to zero to tell some subsystems
+ * that an hard or soft IOMMU is available.
  */
-#define PCI_DMA_BUS_IS_PHYS     (no_iommu ? 1 : 0)
+#define PCI_DMA_BUS_IS_PHYS 0
 
 /*
  * x86-64 always supports DAC, but sometimes it is useful to force
diff --git a/include/asm-x86_64/pda.h b/include/asm-x86_64/pda.h
index 36b766cfc4d5..bbf89aa8a1af 100644
--- a/include/asm-x86_64/pda.h
+++ b/include/asm-x86_64/pda.h
@@ -10,10 +10,8 @@
 struct x8664_pda {
         struct task_struct *pcurrent;   /* Current process */
         unsigned long data_offset;      /* Per cpu data offset from linker address */
-        struct x8664_pda *me;       /* Pointer to itself */  
         unsigned long kernelstack;  /* top of kernel stack for current */ 
         unsigned long oldrsp;       /* user rsp for system call */
-        unsigned long irqrsp;       /* Old rsp for interrupts. */ 
         int irqcount;               /* Irq nesting counter. Starts with -1 */   
         int cpunumber;              /* Logical CPU number */
         char *irqstackptr;      /* top of irqstack */
@@ -22,7 +20,7 @@ struct x8664_pda {
         struct mm_struct *active_mm;
         int mmu_state;     
         unsigned apic_timer_irqs;
-} ____cacheline_aligned;
+} ____cacheline_aligned_in_smp;
 
 
 #define IRQSTACK_ORDER 2
@@ -42,13 +40,14 @@ extern void __bad_pda_field(void);
 #define pda_offset(field) offsetof(struct x8664_pda, field)
 
 #define pda_to_op(op,field,val) do { \
+        typedef typeof_field(struct x8664_pda, field) T__; \
        switch (sizeof_field(struct x8664_pda, field)) {                 \
 case 2: \
-asm volatile(op "w %0,%%gs:%P1"::"r" (val),"i"(pda_offset(field)):"memory"); break; \
+asm volatile(op "w %0,%%gs:%P1"::"ri" ((T__)val),"i"(pda_offset(field)):"memory"); break; \
 case 4: \
-asm volatile(op "l %0,%%gs:%P1"::"r" (val),"i"(pda_offset(field)):"memory"); break; \
+asm volatile(op "l %0,%%gs:%P1"::"ri" ((T__)val),"i"(pda_offset(field)):"memory"); break; \
 case 8: \
-asm volatile(op "q %0,%%gs:%P1"::"r" (val),"i"(pda_offset(field)):"memory"); break; \
+asm volatile(op "q %0,%%gs:%P1"::"ri" ((T__)val),"i"(pda_offset(field)):"memory"); break; \
        default: __bad_pda_field();                                      \
        } \
        } while (0)
@@ -58,7 +57,7 @@ asm volatile(op "q %0,%%gs:%P1"::"r" (val),"i"(pda_offset(field)):"memory"); bre
  * Unfortunately removing them causes all hell to break lose currently.
  */
 #define pda_from_op(op,field) ({ \
-       typedef typeof_field(struct x8664_pda, field) T__; T__ ret__; \
+       typeof_field(struct x8664_pda, field) ret__; \
        switch (sizeof_field(struct x8664_pda, field)) {                 \
 case 2: \
 asm volatile(op "w %%gs:%P1,%0":"=r" (ret__):"i"(pda_offset(field)):"memory"); break;\
@@ -75,6 +74,7 @@ asm volatile(op "q %%gs:%P1,%0":"=r" (ret__):"i"(pda_offset(field)):"memory"); b
 #define write_pda(field,val) pda_to_op("mov",field,val)
 #define add_pda(field,val) pda_to_op("add",field,val)
 #define sub_pda(field,val) pda_to_op("sub",field,val)
+#define or_pda(field,val) pda_to_op("or",field,val)
 
 #endif
 
diff --git a/include/asm-x86_64/pgalloc.h b/include/asm-x86_64/pgalloc.h
index deadd146978b..08cad2482bcb 100644
--- a/include/asm-x86_64/pgalloc.h
+++ b/include/asm-x86_64/pgalloc.h
@@ -18,12 +18,12 @@ static inline void pmd_populate(struct mm_struct *mm, pmd_t *pmd, struct page *p
         set_pmd(pmd, __pmd(_PAGE_TABLE | (page_to_pfn(pte) << PAGE_SHIFT)));
 }
 
-extern __inline__ pmd_t *get_pmd(void)
+static inline pmd_t *get_pmd(void)
 {
         return (pmd_t *)get_zeroed_page(GFP_KERNEL);
 }
 
-extern __inline__ void pmd_free(pmd_t *pmd)
+static inline void pmd_free(pmd_t *pmd)
 {
         BUG_ON((unsigned long)pmd & (PAGE_SIZE-1));
         free_page((unsigned long)pmd);
@@ -86,13 +86,13 @@ static inline struct page *pte_alloc_one(struct mm_struct *mm, unsigned long add
 /* Should really implement gc for free page table pages. This could be
    done with a reference count in struct page. */
 
-extern __inline__ void pte_free_kernel(pte_t *pte)
+static inline void pte_free_kernel(pte_t *pte)
 {
         BUG_ON((unsigned long)pte & (PAGE_SIZE-1));
         free_page((unsigned long)pte); 
 }
 
-extern inline void pte_free(struct page *pte)
+static inline void pte_free(struct page *pte)
 {
         __free_page(pte);
 } 
diff --git a/include/asm-x86_64/pgtable.h b/include/asm-x86_64/pgtable.h
index 5e0f2fdab0d3..1dc110ba82d6 100644
--- a/include/asm-x86_64/pgtable.h
+++ b/include/asm-x86_64/pgtable.h
@@ -85,7 +85,7 @@ static inline void set_pud(pud_t *dst, pud_t val)
         pud_val(*dst) = pud_val(val);
 }
 
-extern inline void pud_clear (pud_t *pud)
+static inline void pud_clear (pud_t *pud)
 {
         set_pud(pud, __pud(0));
 }
@@ -95,7 +95,7 @@ static inline void set_pgd(pgd_t *dst, pgd_t val)
         pgd_val(*dst) = pgd_val(val); 
 } 
 
-extern inline void pgd_clear (pgd_t * pgd)
+static inline void pgd_clear (pgd_t * pgd)
 {
         set_pgd(pgd, __pgd(0));
 }
@@ -375,7 +375,7 @@ static inline pte_t mk_pte_phys(unsigned long physpage, pgprot_t pgprot)
 }
  
 /* Change flags of a PTE */
-extern inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
+static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
 { 
         pte_val(pte) &= _PAGE_CHG_MASK;
         pte_val(pte) |= pgprot_val(newprot);
diff --git a/include/asm-x86_64/processor.h b/include/asm-x86_64/processor.h
index a8321999448f..03837d34fba0 100644
--- a/include/asm-x86_64/processor.h
+++ b/include/asm-x86_64/processor.h
@@ -254,7 +254,13 @@ struct thread_struct {
         u64 tls_array[GDT_ENTRY_TLS_ENTRIES];
 } __attribute__((aligned(16)));
 
-#define INIT_THREAD  {}
+#define INIT_THREAD  { \
+        .rsp0 = (unsigned long)&init_stack + sizeof(init_stack) \
+}
+
+#define INIT_TSS  { \
+        .rsp0 = (unsigned long)&init_stack + sizeof(init_stack) \
+}
 
 #define INIT_MMAP \
 { &init_mm, 0, 0, NULL, PAGE_SHARED, VM_READ | VM_WRITE | VM_EXEC, 1, NULL, NULL }
@@ -375,13 +381,13 @@ struct extended_sigtable {
 #define ASM_NOP_MAX 8
 
 /* REP NOP (PAUSE) is a good thing to insert into busy-wait loops. */
-extern inline void rep_nop(void)
+static inline void rep_nop(void)
 {
         __asm__ __volatile__("rep;nop": : :"memory");
 }
 
 /* Stop speculative execution */
-extern inline void sync_core(void)
+static inline void sync_core(void)
 { 
         int tmp;
         asm volatile("cpuid" : "=a" (tmp) : "0" (1) : "ebx","ecx","edx","memory");
diff --git a/include/asm-x86_64/proto.h b/include/asm-x86_64/proto.h
index 6c813eb521f3..dbb37b0adb43 100644
--- a/include/asm-x86_64/proto.h
+++ b/include/asm-x86_64/proto.h
@@ -8,7 +8,6 @@
 struct cpuinfo_x86; 
 struct pt_regs;
 
-extern void get_cpu_vendor(struct cpuinfo_x86*);
 extern void start_kernel(void);
 extern void pda_init(int); 
 
@@ -75,9 +74,6 @@ extern void acpi_reserve_bootmem(void);
 
 extern void swap_low_mappings(void);
 
-extern void oops_begin(void);
-extern void die(const char *,struct pt_regs *,long);
-extern void __die(const char * str, struct pt_regs * regs, long err);
 extern void __show_regs(struct pt_regs * regs);
 extern void show_regs(struct pt_regs * regs);
 
@@ -94,8 +90,6 @@ extern int unhandled_signal(struct task_struct *tsk, int sig);
 extern void select_idle_routine(const struct cpuinfo_x86 *c);
 extern void swiotlb_init(void);
 
-extern unsigned long max_mapnr;
-extern unsigned long end_pfn; 
 extern unsigned long table_start, table_end;
 
 extern int exception_trace;
diff --git a/include/asm-x86_64/signal.h b/include/asm-x86_64/signal.h
index fe9b96d94815..f8d55798535a 100644
--- a/include/asm-x86_64/signal.h
+++ b/include/asm-x86_64/signal.h
@@ -143,23 +143,23 @@ typedef struct sigaltstack {
 #undef __HAVE_ARCH_SIG_BITOPS
 #if 0
 
-extern __inline__ void sigaddset(sigset_t *set, int _sig)
+static inline void sigaddset(sigset_t *set, int _sig)
 {
         __asm__("btsq %1,%0" : "=m"(*set) : "Ir"(_sig - 1) : "cc");
 }
 
-extern __inline__ void sigdelset(sigset_t *set, int _sig)
+static inline void sigdelset(sigset_t *set, int _sig)
 {
         __asm__("btrq %1,%0" : "=m"(*set) : "Ir"(_sig - 1) : "cc");
 }
 
-extern __inline__ int __const_sigismember(sigset_t *set, int _sig)
+static inline int __const_sigismember(sigset_t *set, int _sig)
 {
         unsigned long sig = _sig - 1;
         return 1 & (set->sig[sig / _NSIG_BPW] >> (sig & ~(_NSIG_BPW-1)));
 }
 
-extern __inline__ int __gen_sigismember(sigset_t *set, int _sig)
+static inline int __gen_sigismember(sigset_t *set, int _sig)
 {
         int ret;
         __asm__("btq %2,%1\n\tsbbq %0,%0"
@@ -172,7 +172,7 @@ extern __inline__ int __gen_sigismember(sigset_t *set, int _sig)
          __const_sigismember((set),(sig)) :     \
          __gen_sigismember((set),(sig)))
 
-extern __inline__ int sigfindinword(unsigned long word)
+static inline int sigfindinword(unsigned long word)
 {
         __asm__("bsfq %1,%0" : "=r"(word) : "rm"(word) : "cc");
         return word;
diff --git a/include/asm-x86_64/smp.h b/include/asm-x86_64/smp.h
index de8b57b2b62b..24e32611f0bf 100644
--- a/include/asm-x86_64/smp.h
+++ b/include/asm-x86_64/smp.h
@@ -72,7 +72,7 @@ static inline int num_booting_cpus(void)
 
 #define raw_smp_processor_id() read_pda(cpunumber)
 
-extern __inline int hard_smp_processor_id(void)
+static inline int hard_smp_processor_id(void)
 {
         /* we don't want to mark this access volatile - bad code generation */
         return GET_APIC_ID(*(unsigned int *)(APIC_BASE+APIC_ID));
diff --git a/include/asm-x86_64/spinlock.h b/include/asm-x86_64/spinlock.h
index 5aeb57a3baad..69636831ad2f 100644
--- a/include/asm-x86_64/spinlock.h
+++ b/include/asm-x86_64/spinlock.h
@@ -6,47 +6,21 @@
 #include <asm/page.h>
 #include <linux/config.h>
 
-extern int printk(const char * fmt, ...)
-        __attribute__ ((format (printf, 1, 2)));
-
 /*
  * Your basic SMP spinlocks, allowing only a single CPU anywhere
- */
-
-typedef struct {
-        volatile unsigned int lock;
-#ifdef CONFIG_DEBUG_SPINLOCK
-        unsigned magic;
-#endif
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} spinlock_t;
-
-#define SPINLOCK_MAGIC  0xdead4ead
-
-#ifdef CONFIG_DEBUG_SPINLOCK
-#define SPINLOCK_MAGIC_INIT     , SPINLOCK_MAGIC
-#else
-#define SPINLOCK_MAGIC_INIT     /* */
-#endif
-
-#define SPIN_LOCK_UNLOCKED (spinlock_t) { 1 SPINLOCK_MAGIC_INIT }
-
-#define spin_lock_init(x)       do { *(x) = SPIN_LOCK_UNLOCKED; } while(0)
-
-/*
+ *
  * Simple spin lock operations.  There are two variants, one clears IRQ's
  * on the local processor, one does not.
  *
  * We make no fairness assumptions. They have a cost.
+ *
+ * (the type definitions are in asm/spinlock_types.h)
  */
 
-#define spin_is_locked(x)       (*(volatile signed char *)(&(x)->lock) <= 0)
-#define spin_unlock_wait(x)     do { barrier(); } while(spin_is_locked(x))
-#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
+#define __raw_spin_is_locked(x) \
+                (*(volatile signed char *)(&(x)->slock) <= 0)
 
-#define spin_lock_string \
+#define __raw_spin_lock_string \
         "\n1:\t" \
         "lock ; decb %0\n\t" \
         "js 2f\n" \
@@ -58,74 +32,40 @@ typedef struct {
         "jmp 1b\n" \
         LOCK_SECTION_END
 
-/*
- * This works. Despite all the confusion.
- * (except on PPro SMP or if we are using OOSTORE)
- * (PPro errata 66, 92)
- */
- 
-#if !defined(CONFIG_X86_OOSTORE) && !defined(CONFIG_X86_PPRO_FENCE)
-
-#define spin_unlock_string \
+#define __raw_spin_unlock_string \
         "movb $1,%0" \
-                :"=m" (lock->lock) : : "memory"
-
-
-static inline void _raw_spin_unlock(spinlock_t *lock)
-{
-#ifdef CONFIG_DEBUG_SPINLOCK
-        BUG_ON(lock->magic != SPINLOCK_MAGIC);
-        assert_spin_locked(lock);
-#endif
-        __asm__ __volatile__(
-                spin_unlock_string
-        );
-}
-
-#else
-
-#define spin_unlock_string \
-        "xchgb %b0, %1" \
-                :"=q" (oldval), "=m" (lock->lock) \
-                :"0" (oldval) : "memory"
+                :"=m" (lock->slock) : : "memory"
 
-static inline void _raw_spin_unlock(spinlock_t *lock)
+static inline void __raw_spin_lock(raw_spinlock_t *lock)
 {
-        char oldval = 1;
-#ifdef CONFIG_DEBUG_SPINLOCK
-        BUG_ON(lock->magic != SPINLOCK_MAGIC);
-        assert_spin_locked(lock);
-#endif
         __asm__ __volatile__(
-                spin_unlock_string
-        );
+                __raw_spin_lock_string
+                :"=m" (lock->slock) : : "memory");
 }
 
-#endif
+#define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)
 
-static inline int _raw_spin_trylock(spinlock_t *lock)
+static inline int __raw_spin_trylock(raw_spinlock_t *lock)
 {
         char oldval;
+
         __asm__ __volatile__(
                 "xchgb %b0,%1"
-                :"=q" (oldval), "=m" (lock->lock)
+                :"=q" (oldval), "=m" (lock->slock)
                 :"0" (0) : "memory");
+
         return oldval > 0;
 }
 
-static inline void _raw_spin_lock(spinlock_t *lock)
+static inline void __raw_spin_unlock(raw_spinlock_t *lock)
 {
-#ifdef CONFIG_DEBUG_SPINLOCK
-        if (lock->magic != SPINLOCK_MAGIC) {
-                printk("eip: %p\n", __builtin_return_address(0));
-                BUG();
-        }
-#endif
         __asm__ __volatile__(
-                spin_lock_string
-                :"=m" (lock->lock) : : "memory");
+                __raw_spin_unlock_string
+        );
 }
 
+#define __raw_spin_unlock_wait(lock) \
+        do { while (__raw_spin_is_locked(lock)) cpu_relax(); } while (0)
 
 /*
  * Read-write spinlocks, allowing multiple readers
@@ -136,33 +76,7 @@ static inline void _raw_spin_lock(spinlock_t *lock)
  * can "mix" irq-safe locks - any writer needs to get a
  * irq-safe write-lock, but readers can get non-irqsafe
  * read-locks.
- */
-typedef struct {
-        volatile unsigned int lock;
-#ifdef CONFIG_DEBUG_SPINLOCK
-        unsigned magic;
-#endif
-#ifdef CONFIG_PREEMPT
-        unsigned int break_lock;
-#endif
-} rwlock_t;
-
-#define RWLOCK_MAGIC    0xdeaf1eed
-
-#ifdef CONFIG_DEBUG_SPINLOCK
-#define RWLOCK_MAGIC_INIT       , RWLOCK_MAGIC
-#else
-#define RWLOCK_MAGIC_INIT       /* */
-#endif
-
-#define RW_LOCK_UNLOCKED (rwlock_t) { RW_LOCK_BIAS RWLOCK_MAGIC_INIT }
-
-#define rwlock_init(x)  do { *(x) = RW_LOCK_UNLOCKED; } while(0)
-
-#define read_can_lock(x)        ((int)(x)->lock > 0)
-#define write_can_lock(x)       ((x)->lock == RW_LOCK_BIAS)
-
-/*
+ *
  * On x86, we implement read-write locks as a 32-bit counter
  * with the high bit (sign) being the "contended" bit.
  *
@@ -170,29 +84,24 @@ typedef struct {
  *
  * Changed to use the same technique as rw semaphores.  See
  * semaphore.h for details.  -ben
+ *
+ * the helpers are in arch/i386/kernel/semaphore.c
  */
-/* the spinlock helpers are in arch/i386/kernel/semaphore.c */
 
-static inline void _raw_read_lock(rwlock_t *rw)
+#define __raw_read_can_lock(x)          ((int)(x)->lock > 0)
+#define __raw_write_can_lock(x)         ((x)->lock == RW_LOCK_BIAS)
+
+static inline void __raw_read_lock(raw_rwlock_t *rw)
 {
-#ifdef CONFIG_DEBUG_SPINLOCK
-        BUG_ON(rw->magic != RWLOCK_MAGIC);
-#endif
         __build_read_lock(rw, "__read_lock_failed");
 }
 
-static inline void _raw_write_lock(rwlock_t *rw)
+static inline void __raw_write_lock(raw_rwlock_t *rw)
 {
-#ifdef CONFIG_DEBUG_SPINLOCK
-        BUG_ON(rw->magic != RWLOCK_MAGIC);
-#endif
         __build_write_lock(rw, "__write_lock_failed");
 }
 
-#define _raw_read_unlock(rw)            asm volatile("lock ; incl %0" :"=m" ((rw)->lock) : : "memory")
-#define _raw_write_unlock(rw)   asm volatile("lock ; addl $" RW_LOCK_BIAS_STR ",%0":"=m" ((rw)->lock) : : "memory")
-
-static inline int _raw_read_trylock(rwlock_t *lock)
+static inline int __raw_read_trylock(raw_rwlock_t *lock)
 {
         atomic_t *count = (atomic_t *)lock;
         atomic_dec(count);
@@ -202,7 +111,7 @@ static inline int _raw_read_trylock(rwlock_t *lock)
         return 0;
 }
 
-static inline int _raw_write_trylock(rwlock_t *lock)
+static inline int __raw_write_trylock(raw_rwlock_t *lock)
 {
         atomic_t *count = (atomic_t *)lock;
         if (atomic_sub_and_test(RW_LOCK_BIAS, count))
@@ -211,4 +120,15 @@ static inline int _raw_write_trylock(rwlock_t *lock)
         return 0;
 }
 
+static inline void __raw_read_unlock(raw_rwlock_t *rw)
+{
+        asm volatile("lock ; incl %0" :"=m" (rw->lock) : : "memory");
+}
+
+static inline void __raw_write_unlock(raw_rwlock_t *rw)
+{
+        asm volatile("lock ; addl $" RW_LOCK_BIAS_STR ",%0"
+                                : "=m" (rw->lock) : : "memory");
+}
+
 #endif /* __ASM_SPINLOCK_H */
diff --git a/include/asm-x86_64/spinlock_types.h b/include/asm-x86_64/spinlock_types.h
new file mode 100644
index 000000000000..59efe849f351
--- /dev/null
+++ b/include/asm-x86_64/spinlock_types.h
@@ -0,0 +1,20 @@
+#ifndef __ASM_SPINLOCK_TYPES_H
+#define __ASM_SPINLOCK_TYPES_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+typedef struct {
+        volatile unsigned int slock;
+} raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED        { 1 }
+
+typedef struct {
+        volatile unsigned int lock;
+} raw_rwlock_t;
+
+#define __RAW_RW_LOCK_UNLOCKED          { RW_LOCK_BIAS }
+
+#endif
diff --git a/include/asm-x86_64/system.h b/include/asm-x86_64/system.h
index 8606e170a7dc..85348e02ad2e 100644
--- a/include/asm-x86_64/system.h
+++ b/include/asm-x86_64/system.h
@@ -188,7 +188,7 @@ static inline void write_cr4(unsigned long val)
 
 #define __xg(x) ((volatile long *)(x))
 
-extern inline void set_64bit(volatile unsigned long *ptr, unsigned long val)
+static inline void set_64bit(volatile unsigned long *ptr, unsigned long val)
 {
         *ptr = val;
 }
@@ -253,19 +253,19 @@ static inline unsigned long __cmpxchg(volatile void *ptr, unsigned long old,
         case 2:
                 __asm__ __volatile__(LOCK_PREFIX "cmpxchgw %w1,%2"
                                      : "=a"(prev)
-                                     : "q"(new), "m"(*__xg(ptr)), "0"(old)
+                                     : "r"(new), "m"(*__xg(ptr)), "0"(old)
                                      : "memory");
                 return prev;
         case 4:
                 __asm__ __volatile__(LOCK_PREFIX "cmpxchgl %k1,%2"
                                      : "=a"(prev)
-                                     : "q"(new), "m"(*__xg(ptr)), "0"(old)
+                                     : "r"(new), "m"(*__xg(ptr)), "0"(old)
                                      : "memory");
                 return prev;
         case 8:
                 __asm__ __volatile__(LOCK_PREFIX "cmpxchgq %1,%2"
                                      : "=a"(prev)
-                                     : "q"(new), "m"(*__xg(ptr)), "0"(old)
+                                     : "r"(new), "m"(*__xg(ptr)), "0"(old)
                                      : "memory");
                 return prev;
         }
diff --git a/include/asm-x86_64/timex.h b/include/asm-x86_64/timex.h
index 24ecf6a637cb..f971f45d6d78 100644
--- a/include/asm-x86_64/timex.h
+++ b/include/asm-x86_64/timex.h
@@ -6,7 +6,6 @@
 #ifndef _ASMx8664_TIMEX_H
 #define _ASMx8664_TIMEX_H
 
-#include <linux/config.h>
 #include <asm/8253pit.h>
 #include <asm/msr.h>
 #include <asm/vsyscall.h>
diff --git a/include/asm-x86_64/tlbflush.h b/include/asm-x86_64/tlbflush.h
index 505b0cf906de..4a9c20ea9b10 100644
--- a/include/asm-x86_64/tlbflush.h
+++ b/include/asm-x86_64/tlbflush.h
@@ -109,6 +109,10 @@ static inline void flush_tlb_range(struct vm_area_struct * vma, unsigned long st
 #define TLBSTATE_OK     1
 #define TLBSTATE_LAZY   2
 
+/* Roughly an IPI every 20MB with 4k pages for freeing page table
+   ranges. Cost is about 42k of memory for each CPU. */
+#define ARCH_FREE_PTE_NR 5350   
+
 #endif
 
 #define flush_tlb_kernel_range(start, end) flush_tlb_all()
diff --git a/include/asm-x86_64/topology.h b/include/asm-x86_64/topology.h
index c1bc3fad482e..1c603cd7e4d0 100644
--- a/include/asm-x86_64/topology.h
+++ b/include/asm-x86_64/topology.h
@@ -13,7 +13,6 @@
 extern cpumask_t cpu_online_map;
 
 extern unsigned char cpu_to_node[];
-extern unsigned char pci_bus_to_node[];
 extern cpumask_t     node_to_cpumask[];
 
 #ifdef CONFIG_ACPI_NUMA
@@ -26,7 +25,7 @@ extern int __node_distance(int, int);
 #define parent_node(node)               (node)
 #define node_to_first_cpu(node)         (__ffs(node_to_cpumask[node]))
 #define node_to_cpumask(node)           (node_to_cpumask[node])
-#define pcibus_to_node(bus)             pci_bus_to_node[(bus)->number]
+#define pcibus_to_node(bus)             ((long)(bus->sysdata))  
 #define pcibus_to_cpumask(bus)          node_to_cpumask(pcibus_to_node(bus));
 
 /* sched_domains SD_NODE_INIT for x86_64 machines */
diff --git a/include/asm-x86_64/vsyscall.h b/include/asm-x86_64/vsyscall.h
index 2872da23fc7e..438a3f52f839 100644
--- a/include/asm-x86_64/vsyscall.h
+++ b/include/asm-x86_64/vsyscall.h
@@ -29,7 +29,6 @@ enum vsyscall_num {
 
 struct vxtime_data {
         long hpet_address;      /* HPET base address */
-        unsigned long hz;       /* HPET clocks / sec */
         int last;
         unsigned long last_tsc;
         long quot;
diff --git a/include/asm-xtensa/ptrace.h b/include/asm-xtensa/ptrace.h
index 2848a5ff8349..aa4fd7fb3ce7 100644
--- a/include/asm-xtensa/ptrace.h
+++ b/include/asm-xtensa/ptrace.h
@@ -127,7 +127,7 @@ extern void show_regs(struct pt_regs *);
 #else   /* __ASSEMBLY__ */
 
 #ifdef __KERNEL__
-# include <asm/offsets.h>
+# include <asm/asm-offsets.h>
 #define PT_REGS_OFFSET    (KERNEL_STACK_SIZE - PT_USER_SIZE)
 #endif
 
diff --git a/include/asm-xtensa/uaccess.h b/include/asm-xtensa/uaccess.h
index fc268ac923c0..06a22b83ba17 100644
--- a/include/asm-xtensa/uaccess.h
+++ b/include/asm-xtensa/uaccess.h
@@ -25,7 +25,7 @@
 
 #define _ASMLANGUAGE
 #include <asm/current.h>
-#include <asm/offsets.h>
+#include <asm/asm-offsets.h>
 #include <asm/processor.h>
 
 /*
diff --git a/include/linux/bfs_fs.h b/include/linux/bfs_fs.h
index f7f0913cd110..c1237aa92e38 100644
--- a/include/linux/bfs_fs.h
+++ b/include/linux/bfs_fs.h
@@ -14,8 +14,9 @@
 #define BFS_INODES_PER_BLOCK    8
 
 /* SVR4 vnode type values (bfs_inode->i_vtype) */
-#define BFS_VDIR                2
-#define BFS_VREG                1
+#define BFS_VDIR 2L
+#define BFS_VREG 1L
+
 
 /* BFS inode layout on disk */
 struct bfs_inode {
@@ -58,22 +59,22 @@ struct bfs_super_block {
         __u32 s_padding[118];
 };
 
-#define BFS_NZFILESIZE(ip) \
-        (((ip)->i_eoffset + 1) - (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 : ((ip)->i_eblock + 1) - (ip)->i_sblock)
 
 #define BFS_OFF2INO(offset) \
         ((((offset) - BFS_BSIZE) / sizeof(struct bfs_inode)) + BFS_ROOT_INO)
 
 #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)
+
+#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))
 #define BFS_UNCLEAN(bfs_sb, sb) \
-        ((bfs_sb->s_from != -1) && (bfs_sb->s_to != -1) && !(sb->s_flags & MS_RDONLY))
+        ((cpu_to_le32(bfs_sb->s_from) != -1) && (cpu_to_le32(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 cdaf03a14a51..6e1c79c8b6bf 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -314,9 +314,8 @@ void zero_fill_bio(struct bio *bio);
  * bvec_kmap_irq and bvec_kunmap_irq!!
  *
  * This function MUST be inlined - it plays with the CPU interrupt flags.
- * Hence the `extern inline'.
  */
-extern inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
+static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
 {
         unsigned long addr;
 
@@ -332,7 +331,7 @@ extern inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
         return (char *) addr + bvec->bv_offset;
 }
 
-extern inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
+static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
 {
         unsigned long ptr = (unsigned long) buffer & PAGE_MASK;
 
@@ -345,7 +344,7 @@ extern inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
 #define bvec_kunmap_irq(buf, flags)     do { *(flags) = 0; } while (0)
 #endif
 
-extern inline char *__bio_kmap_irq(struct bio *bio, unsigned short idx,
+static inline char *__bio_kmap_irq(struct bio *bio, unsigned short idx,
                                    unsigned long *flags)
 {
         return bvec_kmap_irq(bio_iovec_idx(bio, idx), flags);
diff --git a/include/linux/bit_spinlock.h b/include/linux/bit_spinlock.h
new file mode 100644
index 000000000000..6b20af0bbb79
--- /dev/null
+++ b/include/linux/bit_spinlock.h
@@ -0,0 +1,77 @@
+#ifndef __LINUX_BIT_SPINLOCK_H
+#define __LINUX_BIT_SPINLOCK_H
+
+/*
+ *  bit-based spin_lock()
+ *
+ * Don't use this unless you really need to: spin_lock() and spin_unlock()
+ * are significantly faster.
+ */
+static inline void bit_spin_lock(int bitnum, unsigned long *addr)
+{
+        /*
+         * Assuming the lock is uncontended, this never enters
+         * the body of the outer loop. If it is contended, then
+         * within the inner loop a non-atomic test is used to
+         * busywait with less bus contention for a good time to
+         * attempt to acquire the lock bit.
+         */
+        preempt_disable();
+#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
+        while (test_and_set_bit(bitnum, addr)) {
+                while (test_bit(bitnum, addr)) {
+                        preempt_enable();
+                        cpu_relax();
+                        preempt_disable();
+                }
+        }
+#endif
+        __acquire(bitlock);
+}
+
+/*
+ * Return true if it was acquired
+ */
+static inline int bit_spin_trylock(int bitnum, unsigned long *addr)
+{
+        preempt_disable();
+#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
+        if (test_and_set_bit(bitnum, addr)) {
+                preempt_enable();
+                return 0;
+        }
+#endif
+        __acquire(bitlock);
+        return 1;
+}
+
+/*
+ *  bit-based spin_unlock()
+ */
+static inline void bit_spin_unlock(int bitnum, unsigned long *addr)
+{
+#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
+        BUG_ON(!test_bit(bitnum, addr));
+        smp_mb__before_clear_bit();
+        clear_bit(bitnum, addr);
+#endif
+        preempt_enable();
+        __release(bitlock);
+}
+
+/*
+ * Return true if the lock is held.
+ */
+static inline int bit_spin_is_locked(int bitnum, unsigned long *addr)
+{
+#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
+        return test_bit(bitnum, addr);
+#elif defined CONFIG_PREEMPT
+        return preempt_count();
+#else
+        return 1;
+#endif
+}
+
+#endif /* __LINUX_BIT_SPINLOCK_H */
+
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index aefa26fbae8a..efdc9b5bc05c 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -728,7 +728,7 @@ static inline unsigned int blksize_bits(unsigned int size)
         return bits;
 }
 
-extern inline unsigned int block_size(struct block_device *bdev)
+static inline unsigned int block_size(struct block_device *bdev)
 {
         return bdev->bd_block_size;
 }
diff --git a/include/linux/chio.h b/include/linux/chio.h
index 63035ae67e63..a404c111c937 100644
--- a/include/linux/chio.h
+++ b/include/linux/chio.h
@@ -96,7 +96,7 @@ struct changer_position {
  */
 struct changer_element_status {
         int             ces_type;
-        unsigned char   *ces_data;
+        unsigned char   __user *ces_data;
 };
 #define CESTATUS_FULL     0x01 /* full */
 #define CESTATUS_IMPEXP   0x02  /* media was imported (inserted by sysop) */
diff --git a/include/linux/dccp.h b/include/linux/dccp.h
index 007c290f74d4..8bf4bacb5051 100644
--- a/include/linux/dccp.h
+++ b/include/linux/dccp.h
@@ -432,7 +432,10 @@ struct dccp_sock {
         struct ccid                     *dccps_hc_rx_ccid;
         struct ccid                     *dccps_hc_tx_ccid;
         struct dccp_options_received    dccps_options_received;
+        struct timeval                  dccps_epoch;
         enum dccp_role                  dccps_role:2;
+        __u8                            dccps_hc_rx_insert_options:1;
+        __u8                            dccps_hc_tx_insert_options:1;
 };
  
 static inline struct dccp_sock *dccp_sk(const struct sock *sk)
diff --git a/include/linux/dmapool.h b/include/linux/dmapool.h
index e60bfdac348d..4932ee5c77f0 100644
--- a/include/linux/dmapool.h
+++ b/include/linux/dmapool.h
@@ -19,7 +19,8 @@ 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, int mem_flags, dma_addr_t *handle);
+void *dma_pool_alloc(struct dma_pool *pool, unsigned int __nocast 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 c30175e8dec6..a415f1d93e9a 100644
--- a/include/linux/dmi.h
+++ b/include/linux/dmi.h
@@ -70,7 +70,7 @@ extern struct dmi_device * dmi_find_device(int type, const char *name,
 
 static inline int dmi_check_system(struct dmi_system_id *list) { return 0; }
 static inline char * dmi_get_system_info(int field) { return NULL; }
-static struct dmi_device * dmi_find_device(int type, const char *name,
+static inline struct dmi_device * dmi_find_device(int type, const char *name,
         struct dmi_device *from) { return NULL; }
 
 #endif
diff --git a/include/linux/fb.h b/include/linux/fb.h
index bc24beeed971..82e39cd0c4fb 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -107,6 +107,8 @@
 #define FB_ACCEL_NV_20          44      /* nVidia Arch 20               */
 #define FB_ACCEL_NV_30          45      /* nVidia Arch 30               */
 #define FB_ACCEL_NV_40          46      /* nVidia Arch 40               */
+#define FB_ACCEL_XGI_VOLARI_V   47      /* XGI Volari V3XT, V5, V8      */
+#define FB_ACCEL_XGI_VOLARI_Z   48      /* XGI Volari Z7                */
 #define FB_ACCEL_NEOMAGIC_NM2070 90     /* NeoMagic NM2070              */
 #define FB_ACCEL_NEOMAGIC_NM2090 91     /* NeoMagic NM2090              */
 #define FB_ACCEL_NEOMAGIC_NM2093 92     /* NeoMagic NM2093              */
@@ -495,6 +497,9 @@ struct fb_cursor_user {
 #define FB_EVENT_BLANK                  0x08
 /*      Private modelist is to be replaced */
 #define FB_EVENT_NEW_MODELIST           0x09
+/*      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
 
 struct fb_event {
         struct fb_info *info;
@@ -820,13 +825,29 @@ 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);
 extern void fb_pad_aligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch, u32 height);
 extern void fb_set_suspend(struct fb_info *info, int state);
-extern int fb_get_color_depth(struct fb_var_screeninfo *var);
+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 struct fb_info *registered_fb[FB_MAX];
 extern int num_registered_fb;
 
+static inline void __fb_pad_aligned_buffer(u8 *dst, u32 d_pitch,
+                                           u8 *src, u32 s_pitch, u32 height)
+{
+        int i, j;
+
+        d_pitch -= s_pitch;
+
+        for (i = height; i--; ) {
+                /* s_pitch is a few bytes at the most, memcpy is suboptimal */
+                for (j = 0; j < s_pitch; j++)
+                        *dst++ = *src++;
+                dst += d_pitch;
+        }
+}
+
 /* drivers/video/fbsysfs.c */
 extern struct fb_info *framebuffer_alloc(size_t size, struct device *dev);
 extern void framebuffer_release(struct fb_info *info);
@@ -856,8 +877,11 @@ extern int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var,
 extern int fb_validate_mode(const struct fb_var_screeninfo *var,
                             struct fb_info *info);
 extern int fb_parse_edid(unsigned char *edid, struct fb_var_screeninfo *var);
-extern void fb_edid_to_monspecs(unsigned char *edid, struct fb_monspecs *specs);
+extern const unsigned char *fb_firmware_edid(struct device *device);
+extern void fb_edid_to_monspecs(unsigned char *edid,
+                                struct fb_monspecs *specs);
 extern void fb_destroy_modedb(struct fb_videomode *modedb);
+extern int fb_find_mode_cvt(struct fb_videomode *mode, int margins, int rb);
 
 /* drivers/video/modedb.c */
 #define VESA_MODEDB_SIZE 34
diff --git a/include/linux/file.h b/include/linux/file.h
index 5206beb9a80e..f5bbd4c508b3 100644
--- a/include/linux/file.h
+++ b/include/linux/file.h
@@ -9,6 +9,7 @@
 #include <linux/posix_types.h>
 #include <linux/compiler.h>
 #include <linux/spinlock.h>
+#include <linux/rcupdate.h>
 
 /*
  * The default fd array needs to be at least BITS_PER_LONG,
@@ -16,23 +17,33 @@
  */
 #define NR_OPEN_DEFAULT BITS_PER_LONG
 
+struct fdtable {
+        unsigned int max_fds;
+        int max_fdset;
+        int next_fd;
+        struct file ** fd;      /* current fd array */
+        fd_set *close_on_exec;
+        fd_set *open_fds;
+        struct rcu_head rcu;
+        struct files_struct *free_files;
+        struct fdtable *next;
+};
+
 /*
  * Open file table structure
  */
 struct files_struct {
         atomic_t count;
         spinlock_t file_lock;     /* Protects all the below members.  Nests inside tsk->alloc_lock */
-        int max_fds;
-        int max_fdset;
-        int next_fd;
-        struct file ** fd;      /* current fd array */
-        fd_set *close_on_exec;
-        fd_set *open_fds;
+        struct fdtable *fdt;
+        struct fdtable fdtab;
         fd_set close_on_exec_init;
         fd_set open_fds_init;
         struct file * fd_array[NR_OPEN_DEFAULT];
 };
 
+#define files_fdtable(files) (rcu_dereference((files)->fdt))
+
 extern void FASTCALL(__fput(struct file *));
 extern void FASTCALL(fput(struct file *));
 
@@ -59,13 +70,16 @@ extern fd_set *alloc_fdset(int);
 extern void free_fdset(fd_set *, int);
 
 extern int expand_files(struct files_struct *, int nr);
+extern void free_fdtable(struct fdtable *fdt);
+extern void __init files_defer_init(void);
 
 static inline struct file * fcheck_files(struct files_struct *files, unsigned int fd)
 {
         struct file * file = NULL;
+        struct fdtable *fdt = files_fdtable(files);
 
-        if (fd < files->max_fds)
-                file = files->fd[fd];
+        if (fd < fdt->max_fds)
+                file = rcu_dereference(fdt->fd[fd]);
         return file;
 }
 
diff --git a/include/linux/fs.h b/include/linux/fs.h
index fd93ab7da905..e0b77c5af9a0 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -9,6 +9,7 @@
 #include <linux/config.h>
 #include <linux/limits.h>
 #include <linux/ioctl.h>
+#include <linux/rcuref.h>
 
 /*
  * It's silly to have NR_OPEN bigger than NR_FILE, but you can change
@@ -597,12 +598,13 @@ 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);
 #define file_list_unlock() spin_unlock(&files_lock);
 
-#define get_file(x)     atomic_inc(&(x)->f_count)
+#define get_file(x)     rcuref_inc(&(x)->f_count)
 #define file_count(x)   atomic_read(&(x)->f_count)
 
 #define MAX_NON_LFS     ((1UL<<31) - 1)
@@ -1507,8 +1509,6 @@ extern void do_generic_mapping_read(struct address_space *mapping,
                                     loff_t *, read_descriptor_t *, read_actor_t);
 extern void
 file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
-extern ssize_t generic_file_direct_IO(int rw, struct kiocb *iocb,
-        const struct iovec *iov, loff_t offset, unsigned long nr_segs);
 extern ssize_t generic_file_readv(struct file *filp, const struct iovec *iov, 
         unsigned long nr_segs, loff_t *ppos);
 ssize_t generic_file_writev(struct file *filp, const struct iovec *iov, 
diff --git a/include/linux/fuse.h b/include/linux/fuse.h
new file mode 100644
index 000000000000..acbeb96a3353
--- /dev/null
+++ b/include/linux/fuse.h
@@ -0,0 +1,259 @@
+/*
+    FUSE: Filesystem in Userspace
+    Copyright (C) 2001-2005  Miklos Szeredi <miklos@szeredi.hu>
+
+    This program can be distributed under the terms of the GNU GPL.
+    See the file COPYING.
+*/
+
+/* This file defines the kernel interface of FUSE */
+
+#include <asm/types.h>
+
+/** Version number of this interface */
+#define FUSE_KERNEL_VERSION 7
+
+/** Minor version number of this interface */
+#define FUSE_KERNEL_MINOR_VERSION 2
+
+/** The node ID of the root inode */
+#define FUSE_ROOT_ID 1
+
+/** The major number of the fuse character device */
+#define FUSE_MAJOR 10
+
+/** The minor number of the fuse character device */
+#define FUSE_MINOR 229
+
+/* Make sure all structures are padded to 64bit boundary, so 32bit
+   userspace works under 64bit kernels */
+
+struct fuse_attr {
+        __u64   ino;
+        __u64   size;
+        __u64   blocks;
+        __u64   atime;
+        __u64   mtime;
+        __u64   ctime;
+        __u32   atimensec;
+        __u32   mtimensec;
+        __u32   ctimensec;
+        __u32   mode;
+        __u32   nlink;
+        __u32   uid;
+        __u32   gid;
+        __u32   rdev;
+};
+
+struct fuse_kstatfs {
+        __u64   blocks;
+        __u64   bfree;
+        __u64   bavail;
+        __u64   files;
+        __u64   ffree;
+        __u32   bsize;
+        __u32   namelen;
+};
+
+#define FATTR_MODE      (1 << 0)
+#define FATTR_UID       (1 << 1)
+#define FATTR_GID       (1 << 2)
+#define FATTR_SIZE      (1 << 3)
+#define FATTR_ATIME     (1 << 4)
+#define FATTR_MTIME     (1 << 5)
+#define FATTR_CTIME     (1 << 6)
+
+/**
+ * Flags returned by the OPEN request
+ *
+ * FOPEN_DIRECT_IO: bypass page cache for this open file
+ * FOPEN_KEEP_CACHE: don't invalidate the data cache on open
+ */
+#define FOPEN_DIRECT_IO         (1 << 0)
+#define FOPEN_KEEP_CACHE        (1 << 1)
+
+enum fuse_opcode {
+        FUSE_LOOKUP        = 1,
+        FUSE_FORGET        = 2,  /* no reply */
+        FUSE_GETATTR       = 3,
+        FUSE_SETATTR       = 4,
+        FUSE_READLINK      = 5,
+        FUSE_SYMLINK       = 6,
+        FUSE_MKNOD         = 8,
+        FUSE_MKDIR         = 9,
+        FUSE_UNLINK        = 10,
+        FUSE_RMDIR         = 11,
+        FUSE_RENAME        = 12,
+        FUSE_LINK          = 13,
+        FUSE_OPEN          = 14,
+        FUSE_READ          = 15,
+        FUSE_WRITE         = 16,
+        FUSE_STATFS        = 17,
+        FUSE_RELEASE       = 18,
+        FUSE_FSYNC         = 20,
+        FUSE_SETXATTR      = 21,
+        FUSE_GETXATTR      = 22,
+        FUSE_LISTXATTR     = 23,
+        FUSE_REMOVEXATTR   = 24,
+        FUSE_FLUSH         = 25,
+        FUSE_INIT          = 26,
+        FUSE_OPENDIR       = 27,
+        FUSE_READDIR       = 28,
+        FUSE_RELEASEDIR    = 29,
+        FUSE_FSYNCDIR      = 30
+};
+
+/* Conservative buffer size for the client */
+#define FUSE_MAX_IN 8192
+
+#define FUSE_NAME_MAX 1024
+#define FUSE_SYMLINK_MAX 4096
+#define FUSE_XATTR_SIZE_MAX 4096
+
+struct fuse_entry_out {
+        __u64   nodeid;         /* Inode ID */
+        __u64   generation;     /* Inode generation: nodeid:gen must
+                                   be unique for the fs's lifetime */
+        __u64   entry_valid;    /* Cache timeout for the name */
+        __u64   attr_valid;     /* Cache timeout for the attributes */
+        __u32   entry_valid_nsec;
+        __u32   attr_valid_nsec;
+        struct fuse_attr attr;
+};
+
+struct fuse_forget_in {
+        __u64   nlookup;
+};
+
+struct fuse_attr_out {
+        __u64   attr_valid;     /* Cache timeout for the attributes */
+        __u32   attr_valid_nsec;
+        __u32   dummy;
+        struct fuse_attr attr;
+};
+
+struct fuse_mknod_in {
+        __u32   mode;
+        __u32   rdev;
+};
+
+struct fuse_mkdir_in {
+        __u32   mode;
+        __u32   padding;
+};
+
+struct fuse_rename_in {
+        __u64   newdir;
+};
+
+struct fuse_link_in {
+        __u64   oldnodeid;
+};
+
+struct fuse_setattr_in {
+        __u32   valid;
+        __u32   padding;
+        struct fuse_attr attr;
+};
+
+struct fuse_open_in {
+        __u32   flags;
+        __u32   padding;
+};
+
+struct fuse_open_out {
+        __u64   fh;
+        __u32   open_flags;
+        __u32   padding;
+};
+
+struct fuse_release_in {
+        __u64   fh;
+        __u32   flags;
+        __u32   padding;
+};
+
+struct fuse_flush_in {
+        __u64   fh;
+        __u32   flush_flags;
+        __u32   padding;
+};
+
+struct fuse_read_in {
+        __u64   fh;
+        __u64   offset;
+        __u32   size;
+        __u32   padding;
+};
+
+struct fuse_write_in {
+        __u64   fh;
+        __u64   offset;
+        __u32   size;
+        __u32   write_flags;
+};
+
+struct fuse_write_out {
+        __u32   size;
+        __u32   padding;
+};
+
+struct fuse_statfs_out {
+        struct fuse_kstatfs st;
+};
+
+struct fuse_fsync_in {
+        __u64   fh;
+        __u32   fsync_flags;
+        __u32   padding;
+};
+
+struct fuse_setxattr_in {
+        __u32   size;
+        __u32   flags;
+};
+
+struct fuse_getxattr_in {
+        __u32   size;
+        __u32   padding;
+};
+
+struct fuse_getxattr_out {
+        __u32   size;
+        __u32   padding;
+};
+
+struct fuse_init_in_out {
+        __u32   major;
+        __u32   minor;
+};
+
+struct fuse_in_header {
+        __u32   len;
+        __u32   opcode;
+        __u64   unique;
+        __u64   nodeid;
+        __u32   uid;
+        __u32   gid;
+        __u32   pid;
+        __u32   padding;
+};
+
+struct fuse_out_header {
+        __u32   len;
+        __s32   error;
+        __u64   unique;
+};
+
+struct fuse_dirent {
+        __u64   ino;
+        __u64   off;
+        __u32   namelen;
+        __u32   type;
+        char name[0];
+};
+
+#define FUSE_NAME_OFFSET ((unsigned) ((struct fuse_dirent *) 0)->name)
+#define FUSE_DIRENT_ALIGN(x) (((x) + sizeof(__u64) - 1) & ~(sizeof(__u64) - 1))
+#define FUSE_DIRENT_SIZE(d) \
+        FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
diff --git a/include/linux/in6.h b/include/linux/in6.h
index bd32b79d6295..304aaedea305 100644
--- a/include/linux/in6.h
+++ b/include/linux/in6.h
@@ -198,27 +198,43 @@ struct in6_flowlabel_req
  * MCAST_MSFILTER               48
  */
 
-/* RFC3542 advanced socket options (50-67) */
-#define IPV6_RECVPKTINFO        50
-#define IPV6_PKTINFO            51
-#if 0
-#define IPV6_RECVPATHMTU        52
-#define IPV6_PATHMTU            53
-#define IPV6_DONTFRAG           54
-#define IPV6_USE_MIN_MTU        55
-#endif
-#define IPV6_RECVHOPOPTS        56
-#define IPV6_HOPOPTS            57
-#if 0
-#define IPV6_RECVRTHDRDSTOPTS   58      /* Unused, see net/ipv6/datagram.c */
+/*
+ * Advanced API (RFC3542) (1)
+ *
+ * Note: IPV6_RECVRTHDRDSTOPTS does not exist. see net/ipv6/datagram.c.
+ */
+
+#define IPV6_RECVPKTINFO        49
+#define IPV6_PKTINFO            50
+#define IPV6_RECVHOPLIMIT       51
+#define IPV6_HOPLIMIT           52
+#define IPV6_RECVHOPOPTS        53
+#define IPV6_HOPOPTS            54
+#define IPV6_RTHDRDSTOPTS       55
+#define IPV6_RECVRTHDR          56
+#define IPV6_RTHDR              57
+#define IPV6_RECVDSTOPTS        58
+#define IPV6_DSTOPTS            59
+#if 0   /* not yet */
+#define IPV6_RECVPATHMTU        60
+#define IPV6_PATHMTU            61
+#define IPV6_DONTFRAG           62
+#define IPV6_USE_MIN_MTU        63
 #endif
-#define IPV6_RTHDRDSTOPTS       59
-#define IPV6_RECVRTHDR          60
-#define IPV6_RTHDR              61
-#define IPV6_RECVDSTOPTS        62
-#define IPV6_DSTOPTS            63
-#define IPV6_RECVHOPLIMIT       64
-#define IPV6_HOPLIMIT           65
+
+/*
+ * Netfilter
+ *
+ * Following socket options are used in ip6_tables;
+ * see include/linux/netfilter_ipv6/ip6_tables.h.
+ *
+ * IP6T_SO_SET_REPLACE / IP6T_SO_GET_INFO               64
+ * IP6T_SO_SET_ADD_COUNTERS / IP6T_SO_GET_ENTRIES       65
+ */
+
+/*
+ * Advanced API (RFC3542) (2)
+ */
 #define IPV6_RECVTCLASS         66
 #define IPV6_TCLASS             67
 
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index c727c195a91a..68ab5f2ab9cd 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -2,17 +2,27 @@
 #define _LINUX__INIT_TASK_H
 
 #include <linux/file.h>
+#include <linux/rcupdate.h>
 
-#define INIT_FILES \
-{                                                       \
-        .count          = ATOMIC_INIT(1),               \
-        .file_lock      = SPIN_LOCK_UNLOCKED,           \
+#define INIT_FDTABLE \
+{                                                       \
         .max_fds        = NR_OPEN_DEFAULT,              \
         .max_fdset      = __FD_SETSIZE,                 \
         .next_fd        = 0,                            \
         .fd             = &init_files.fd_array[0],      \
         .close_on_exec  = &init_files.close_on_exec_init, \
         .open_fds       = &init_files.open_fds_init,    \
+        .rcu            = RCU_HEAD_INIT,                \
+        .free_files     = NULL,                         \
+        .next           = NULL,                         \
+}
+
+#define INIT_FILES \
+{                                                       \
+        .count          = ATOMIC_INIT(1),               \
+        .file_lock      = SPIN_LOCK_UNLOCKED,           \
+        .fdt            = &init_files.fdtab,            \
+        .fdtab          = INIT_FDTABLE,                 \
         .close_on_exec_init = { { 0, } },               \
         .open_fds_init  = { { 0, } },                   \
         .fd_array       = { NULL, }                     \
diff --git a/include/linux/input.h b/include/linux/input.h
index 4767e5429534..e8c296ff6257 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -289,6 +289,8 @@ struct input_absinfo {
 #define KEY_SCROLLDOWN          178
 #define KEY_KPLEFTPAREN         179
 #define KEY_KPRIGHTPAREN        180
+#define KEY_NEW                 181
+#define KEY_REDO                182
 
 #define KEY_F13                 183
 #define KEY_F14                 184
@@ -335,6 +337,12 @@ struct input_absinfo {
 #define KEY_KBDILLUMDOWN        229
 #define KEY_KBDILLUMUP          230
 
+#define KEY_SEND                231
+#define KEY_REPLY               232
+#define KEY_FORWARDMAIL         233
+#define KEY_SAVE                234
+#define KEY_DOCUMENTS           235
+
 #define KEY_UNKNOWN             240
 
 #define BTN_MISC                0x100
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index d99e7aeb7d33..0a90205184b0 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -57,6 +57,11 @@ extern void disable_irq(unsigned int irq);
 extern void enable_irq(unsigned int irq);
 #endif
 
+#ifndef __ARCH_SET_SOFTIRQ_PENDING
+#define set_softirq_pending(x) (local_softirq_pending() = (x))
+#define or_softirq_pending(x)  (local_softirq_pending() |= (x))
+#endif
+
 /*
  * Temporary defines for UP kernels, until all code gets fixed.
  */
@@ -123,7 +128,7 @@ struct softirq_action
 asmlinkage void do_softirq(void);
 extern void open_softirq(int nr, void (*action)(struct softirq_action*), void *data);
 extern void softirq_init(void);
-#define __raise_softirq_irqoff(nr) do { local_softirq_pending() |= 1UL << (nr); } while (0)
+#define __raise_softirq_irqoff(nr) do { or_softirq_pending(1UL << (nr)); } while (0)
 extern void FASTCALL(raise_softirq_irqoff(unsigned int nr));
 extern void FASTCALL(raise_softirq(unsigned int nr));
 
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index 6c5f7b39a4b0..bb6f88e14061 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -68,7 +68,7 @@ struct ipv6_opt_hdr {
 
 struct rt0_hdr {
         struct ipv6_rt_hdr      rt_hdr;
-        __u32                   bitmap;         /* strict/loose bit map */
+        __u32                   reserved;
         struct in6_addr         addr[0];
 
 #define rt0_type                rt_hdr.type
diff --git a/include/linux/jbd.h b/include/linux/jbd.h
index 84321a4cac93..de097269bd7f 100644
--- a/include/linux/jbd.h
+++ b/include/linux/jbd.h
@@ -28,6 +28,7 @@
 #include <linux/buffer_head.h>
 #include <linux/journal-head.h>
 #include <linux/stddef.h>
+#include <linux/bit_spinlock.h>
 #include <asm/semaphore.h>
 #endif
 
diff --git a/include/linux/jiffies.h b/include/linux/jiffies.h
index d7a2555a886c..6acfdbba734b 100644
--- a/include/linux/jiffies.h
+++ b/include/linux/jiffies.h
@@ -254,23 +254,23 @@ static inline u64 get_jiffies_64(void)
  */
 static inline unsigned int jiffies_to_msecs(const unsigned long j)
 {
-#if HZ <= 1000 && !(1000 % HZ)
-        return (1000 / HZ) * j;
-#elif HZ > 1000 && !(HZ % 1000)
-        return (j + (HZ / 1000) - 1)/(HZ / 1000);
+#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
+        return (MSEC_PER_SEC / HZ) * j;
+#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
+        return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
 #else
-        return (j * 1000) / HZ;
+        return (j * MSEC_PER_SEC) / HZ;
 #endif
 }
 
 static inline unsigned int jiffies_to_usecs(const unsigned long j)
 {
-#if HZ <= 1000000 && !(1000000 % HZ)
-        return (1000000 / HZ) * j;
-#elif HZ > 1000000 && !(HZ % 1000000)
-        return (j + (HZ / 1000000) - 1)/(HZ / 1000000);
+#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
+        return (USEC_PER_SEC / HZ) * j;
+#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
+        return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
 #else
-        return (j * 1000000) / HZ;
+        return (j * USEC_PER_SEC) / HZ;
 #endif
 }
 
@@ -278,12 +278,12 @@ static inline unsigned long msecs_to_jiffies(const unsigned int m)
 {
         if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
                 return MAX_JIFFY_OFFSET;
-#if HZ <= 1000 && !(1000 % HZ)
-        return (m + (1000 / HZ) - 1) / (1000 / HZ);
-#elif HZ > 1000 && !(HZ % 1000)
-        return m * (HZ / 1000);
+#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
+        return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
+#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
+        return m * (HZ / MSEC_PER_SEC);
 #else
-        return (m * HZ + 999) / 1000;
+        return (m * HZ + MSEC_PER_SEC - 1) / MSEC_PER_SEC;
 #endif
 }
 
@@ -291,12 +291,12 @@ static inline unsigned long usecs_to_jiffies(const unsigned int u)
 {
         if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
                 return MAX_JIFFY_OFFSET;
-#if HZ <= 1000000 && !(1000000 % HZ)
-        return (u + (1000000 / HZ) - 1) / (1000000 / HZ);
-#elif HZ > 1000000 && !(HZ % 1000000)
-        return u * (HZ / 1000000);
+#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
+        return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
+#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
+        return u * (HZ / USEC_PER_SEC);
 #else
-        return (u * HZ + 999999) / 1000000;
+        return (u * HZ + USEC_PER_SEC - 1) / USEC_PER_SEC;
 #endif
 }
 
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 6caaba0af469..7349058ed778 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -315,8 +315,11 @@ static inline struct pci_bus *pci_scan_bus(int bus, struct pci_ops *ops, void *s
                 pci_bus_add_devices(root_bus);
         return root_bus;
 }
+struct pci_bus *pci_create_bus(struct device *parent, int bus, struct pci_ops *ops, void *sysdata);
+struct pci_bus * pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr);
 int pci_scan_slot(struct pci_bus *bus, int devfn);
 struct pci_dev * pci_scan_single_device(struct pci_bus *bus, int devfn);
+void pci_device_add(struct pci_dev *dev, struct pci_bus *bus);
 unsigned int pci_scan_child_bus(struct pci_bus *bus);
 void pci_bus_add_device(struct pci_dev *dev);
 void pci_read_bridge_bases(struct pci_bus *child);
@@ -326,6 +329,7 @@ extern struct pci_dev *pci_dev_get(struct pci_dev *dev);
 extern void pci_dev_put(struct pci_dev *dev);
 extern void pci_remove_bus(struct pci_bus *b);
 extern void pci_remove_bus_device(struct pci_dev *dev);
+void pci_setup_cardbus(struct pci_bus *bus);
 
 /* Generic PCI functions exported to card drivers */
 
@@ -391,8 +395,8 @@ int pci_assign_resource(struct pci_dev *dev, int i);
 void pci_restore_bars(struct pci_dev *dev);
 
 /* ROM control related routines */
-void __iomem *pci_map_rom(struct pci_dev *pdev, size_t *size);
-void __iomem *pci_map_rom_copy(struct pci_dev *pdev, size_t *size);
+void __iomem __must_check *pci_map_rom(struct pci_dev *pdev, size_t *size);
+void __iomem __must_check *pci_map_rom_copy(struct pci_dev *pdev, size_t *size);
 void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom);
 void pci_remove_rom(struct pci_dev *pdev);
 
diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h
index 8081a281fa5e..9c51917b1cce 100644
--- a/include/linux/radix-tree.h
+++ b/include/linux/radix-tree.h
@@ -24,7 +24,7 @@
 
 struct radix_tree_root {
         unsigned int            height;
-        int                     gfp_mask;
+        unsigned int            gfp_mask;
         struct radix_tree_node  *rnode;
 };
 
@@ -50,7 +50,7 @@ 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(int gfp_mask);
+int radix_tree_preload(unsigned int __nocast 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 4bf1659f8aa8..9de99198caf1 100644
--- a/include/linux/raid/bitmap.h
+++ b/include/linux/raid/bitmap.h
@@ -7,7 +7,7 @@
 #define BITMAP_H 1
 
 #define BITMAP_MAJOR 3
-#define BITMAP_MINOR 38
+#define BITMAP_MINOR 39
 
 /*
  * in-memory bitmap:
@@ -147,8 +147,9 @@ typedef struct bitmap_super_s {
         __u32 state;        /* 48  bitmap state information */
         __u32 chunksize;    /* 52  the bitmap chunk size in bytes */
         __u32 daemon_sleep; /* 56  seconds between disk flushes */
+        __u32 write_behind; /* 60  number of outstanding write-behind writes */
 
-        __u8  pad[256 - 60]; /* set to zero */
+        __u8  pad[256 - 64]; /* set to zero */
 } bitmap_super_t;
 
 /* notes:
@@ -226,6 +227,9 @@ struct bitmap {
 
         unsigned long flags;
 
+        unsigned long max_write_behind; /* write-behind mode */
+        atomic_t behind_writes;
+
         /*
          * the bitmap daemon - periodically wakes up and sweeps the bitmap
          * file, cleaning up bits and flushing out pages to disk as necessary
@@ -260,9 +264,10 @@ int  bitmap_setallbits(struct bitmap *bitmap);
 void bitmap_write_all(struct bitmap *bitmap);
 
 /* these are exported */
-int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors);
-void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors,
-                     int success);
+int bitmap_startwrite(struct bitmap *bitmap, sector_t offset,
+                        unsigned long sectors, int behind);
+void bitmap_endwrite(struct bitmap *bitmap, sector_t offset,
+                        unsigned long sectors, int success, int behind);
 int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, int *blocks, int degraded);
 void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, int *blocks, int aborted);
 void bitmap_close_sync(struct bitmap *bitmap);
diff --git a/include/linux/raid/linear.h b/include/linux/raid/linear.h
index e04c4fe45b53..7eaf290e10e7 100644
--- a/include/linux/raid/linear.h
+++ b/include/linux/raid/linear.h
@@ -14,8 +14,8 @@ typedef struct dev_info dev_info_t;
 struct linear_private_data
 {
         dev_info_t              **hash_table;
-        dev_info_t              *smallest;
-        int                     nr_zones;
+        sector_t                hash_spacing;
+        int                     preshift; /* shift before dividing by hash_spacing */
         dev_info_t              disks[0];
 };
 
diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h
index 8c14ba565a45..ebce949b1443 100644
--- a/include/linux/raid/md_k.h
+++ b/include/linux/raid/md_k.h
@@ -86,70 +86,6 @@ typedef struct mdk_rdev_s mdk_rdev_t;
 #define MAX_CHUNK_SIZE (4096*1024)
 
 /*
- * default readahead
- */
-
-static inline int disk_faulty(mdp_disk_t * d)
-{
-        return d->state & (1 << MD_DISK_FAULTY);
-}
-
-static inline int disk_active(mdp_disk_t * d)
-{
-        return d->state & (1 << MD_DISK_ACTIVE);
-}
-
-static inline int disk_sync(mdp_disk_t * d)
-{
-        return d->state & (1 << MD_DISK_SYNC);
-}
-
-static inline int disk_spare(mdp_disk_t * d)
-{
-        return !disk_sync(d) && !disk_active(d) && !disk_faulty(d);
-}
-
-static inline int disk_removed(mdp_disk_t * d)
-{
-        return d->state & (1 << MD_DISK_REMOVED);
-}
-
-static inline void mark_disk_faulty(mdp_disk_t * d)
-{
-        d->state |= (1 << MD_DISK_FAULTY);
-}
-
-static inline void mark_disk_active(mdp_disk_t * d)
-{
-        d->state |= (1 << MD_DISK_ACTIVE);
-}
-
-static inline void mark_disk_sync(mdp_disk_t * d)
-{
-        d->state |= (1 << MD_DISK_SYNC);
-}
-
-static inline void mark_disk_spare(mdp_disk_t * d)
-{
-        d->state = 0;
-}
-
-static inline void mark_disk_removed(mdp_disk_t * d)
-{
-        d->state = (1 << MD_DISK_FAULTY) | (1 << MD_DISK_REMOVED);
-}
-
-static inline void mark_disk_inactive(mdp_disk_t * d)
-{
-        d->state &= ~(1 << MD_DISK_ACTIVE);
-}
-
-static inline void mark_disk_nonsync(mdp_disk_t * d)
-{
-        d->state &= ~(1 << MD_DISK_SYNC);
-}
-
-/*
  * MD's 'extended' device
  */
 struct mdk_rdev_s
@@ -166,6 +102,7 @@ struct mdk_rdev_s
         int             sb_loaded;
         sector_t        data_offset;    /* start of data in array */
         sector_t        sb_offset;
+        int             sb_size;        /* bytes in the superblock */
         int             preferred_minor;        /* autorun support */
 
         /* A device can be in one of three states based on two flags:
@@ -181,6 +118,9 @@ struct mdk_rdev_s
         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. */
+#define WriteMostly     4               /* Avoid reading if at all possible */
+
         int desc_nr;                    /* descriptor index in the superblock */
         int raid_disk;                  /* role of device in array */
         int saved_raid_disk;            /* role that device used to have in the
@@ -272,12 +212,19 @@ struct mddev_s
         atomic_t                        writes_pending; 
         request_queue_t                 *queue; /* for plugging ... */
 
+        atomic_t                        write_behind; /* outstanding async IO */
+        unsigned int                    max_write_behind; /* 0 = sync */
+
         struct bitmap                   *bitmap; /* the bitmap for the device */
         struct file                     *bitmap_file; /* the bitmap file */
         long                            bitmap_offset; /* offset from superblock of
                                                         * start of bitmap. May be
                                                         * negative, but not '0'
                                                         */
+        long                            default_bitmap_offset; /* this is the offset to use when
+                                                                * hot-adding a bitmap.  It should
+                                                                * eventually be settable by sysfs.
+                                                                */
 
         struct list_head                all_mddevs;
 };
@@ -314,6 +261,12 @@ struct mdk_personality_s
         int (*resize) (mddev_t *mddev, sector_t sectors);
         int (*reshape) (mddev_t *mddev, int raid_disks);
         int (*reconfig) (mddev_t *mddev, int layout, int chunk_size);
+        /* quiesce moves between quiescence states
+         * 0 - fully active
+         * 1 - no new requests allowed
+         * others - reserved
+         */
+        void (*quiesce) (mddev_t *mddev, int state);
 };
 
 
diff --git a/include/linux/raid/md_p.h b/include/linux/raid/md_p.h
index dc65cd435494..c100fa5d4bfa 100644
--- a/include/linux/raid/md_p.h
+++ b/include/linux/raid/md_p.h
@@ -79,6 +79,11 @@
 #define MD_DISK_SYNC            2 /* disk is in sync with the raid set */
 #define MD_DISK_REMOVED         3 /* disk is in sync with the raid set */
 
+#define MD_DISK_WRITEMOSTLY     9 /* disk is "write-mostly" is RAID1 config.
+                                   * read requests will only be sent here in
+                                   * dire need
+                                   */
+
 typedef struct mdp_device_descriptor_s {
         __u32 number;           /* 0 Device number in the entire set          */
         __u32 major;            /* 1 Device major number                      */
@@ -193,7 +198,7 @@ struct mdp_superblock_1 {
 
         __u64   ctime;          /* lo 40 bits are seconds, top 24 are microseconds or 0*/
         __u32   level;          /* -4 (multipath), -1 (linear), 0,1,4,5 */
-        __u32   layout;         /* only for raid5 currently */
+        __u32   layout;         /* only for raid5 and raid10 currently */
         __u64   size;           /* used size of component devices, in 512byte sectors */
 
         __u32   chunksize;      /* in 512byte sectors */
@@ -212,7 +217,9 @@ struct mdp_superblock_1 {
         __u32   dev_number;     /* permanent identifier of this  device - not role in raid */
         __u32   cnt_corrected_read; /* number of read errors that were corrected by re-writing */
         __u8    device_uuid[16]; /* user-space setable, ignored by kernel */
-        __u8    pad2[64-56];    /* set to 0 when writing */
+        __u8    devflags;       /* per-device flags.  Only one defined...*/
+#define WriteMostly1    1       /* mask for writemostly flag in above */
+        __u8    pad2[64-57];    /* set to 0 when writing */
 
         /* array state information - 64 bytes */
         __u64   utime;          /* 40 bits second, 24 btes microseconds */
@@ -231,5 +238,10 @@ struct mdp_superblock_1 {
         __u16   dev_roles[0];   /* role in array, or 0xffff for a spare, or 0xfffe for faulty */
 };
 
+/* feature_map bits */
+#define MD_FEATURE_BITMAP_OFFSET        1
+
+#define MD_FEATURE_ALL                  1
+
 #endif 
 
diff --git a/include/linux/raid/raid1.h b/include/linux/raid/raid1.h
index 9d93cf12e890..60e19b667548 100644
--- a/include/linux/raid/raid1.h
+++ b/include/linux/raid/raid1.h
@@ -80,6 +80,9 @@ struct r1bio_s {
         atomic_t                remaining; /* 'have we finished' count,
                                             * used from IRQ handlers
                                             */
+        atomic_t                behind_remaining; /* number of write-behind ios remaining
+                                                 * in this BehindIO request
+                                                 */
         sector_t                sector;
         int                     sectors;
         unsigned long           state;
@@ -107,4 +110,14 @@ struct r1bio_s {
 #define R1BIO_Uptodate  0
 #define R1BIO_IsSync    1
 #define R1BIO_Degraded  2
+#define R1BIO_BehindIO   3
+/* 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
+ * any write-behind write succeeds, otherwise we call
+ * with failure when last write completes (and all failed).
+ * Record that bi_end_io was called with this flag...
+ */
+#define R1BIO_Returned 4
+
 #endif
diff --git a/include/linux/raid/raid5.h b/include/linux/raid/raid5.h
index d63ddcb4afad..176fc653c284 100644
--- a/include/linux/raid/raid5.h
+++ b/include/linux/raid/raid5.h
@@ -134,6 +134,7 @@ struct stripe_head {
         unsigned long           state;                  /* state flags */
         atomic_t                count;                  /* nr of active thread/requests */
         spinlock_t              lock;
+        int                     bm_seq; /* sequence number for bitmap flushes */
         struct r5dev {
                 struct bio      req;
                 struct bio_vec  vec;
@@ -165,12 +166,13 @@ struct stripe_head {
 /*
  * Stripe state
  */
-#define STRIPE_ERROR            1
 #define STRIPE_HANDLE           2
 #define STRIPE_SYNCING          3
 #define STRIPE_INSYNC           4
 #define STRIPE_PREREAD_ACTIVE   5
 #define STRIPE_DELAYED          6
+#define STRIPE_DEGRADED         7
+#define STRIPE_BIT_DELAY        8
 
 /*
  * Plugging:
@@ -210,10 +212,20 @@ struct raid5_private_data {
 
         struct list_head        handle_list; /* stripes needing handling */
         struct list_head        delayed_list; /* stripes that have plugged requests */
+        struct list_head        bitmap_list; /* stripes delaying awaiting bitmap update */
         atomic_t                preread_active_stripes; /* stripes with scheduled io */
 
         char                    cache_name[20];
         kmem_cache_t            *slab_cache; /* for allocating stripes */
+
+        int                     seq_flush, seq_write;
+        int                     quiesce;
+
+        int                     fullsync;  /* set to 1 if a full sync is needed,
+                                            * (fresh device added).
+                                            * Cleared when a sync completes.
+                                            */
+
         /*
          * Free stripes pool
          */
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index fd276adf0fd5..4e65eb44adfd 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -52,8 +52,8 @@ struct rcu_head {
         void (*func)(struct rcu_head *head);
 };
 
-#define RCU_HEAD_INIT(head) { .next = NULL, .func = NULL }
-#define RCU_HEAD(head) struct rcu_head head = RCU_HEAD_INIT(head)
+#define RCU_HEAD_INIT   { .next = NULL, .func = NULL }
+#define RCU_HEAD(head) struct rcu_head head = RCU_HEAD_INIT
 #define INIT_RCU_HEAD(ptr) do { \
        (ptr)->next = NULL; (ptr)->func = NULL; \
 } while (0)
diff --git a/include/linux/rcuref.h b/include/linux/rcuref.h
new file mode 100644
index 000000000000..e1adbba14b67
--- /dev/null
+++ b/include/linux/rcuref.h
@@ -0,0 +1,220 @@
+/*
+ * rcuref.h
+ *
+ * Reference counting for elements of lists/arrays protected by
+ * RCU.
+ *
+ * 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.
+ *
+ * Copyright (C) IBM Corporation, 2005
+ *
+ * Author: Dipankar Sarma <dipankar@in.ibm.com>
+ *         Ravikiran Thirumalai <kiran_th@gmail.com>
+ *
+ * See Documentation/RCU/rcuref.txt for detailed user guide.
+ *
+ */
+
+#ifndef _RCUREF_H_
+#define _RCUREF_H_
+
+#ifdef __KERNEL__
+
+#include <linux/types.h>
+#include <linux/interrupt.h>
+#include <linux/spinlock.h>
+#include <asm/atomic.h>
+
+/*
+ * These APIs work on traditional atomic_t counters used in the
+ * kernel for reference counting. Under special circumstances
+ * where a lock-free get() operation races with a put() operation
+ * these APIs can be used. See Documentation/RCU/rcuref.txt.
+ */
+
+#ifdef __HAVE_ARCH_CMPXCHG
+
+/**
+ * rcuref_inc - increment refcount for object.
+ * @rcuref: reference counter in the object in question.
+ *
+ * This should be used only for objects where we use RCU and
+ * use the rcuref_inc_lf() api to acquire a reference
+ * in a lock-free reader-side critical section.
+ */
+static inline void rcuref_inc(atomic_t *rcuref)
+{
+        atomic_inc(rcuref);
+}
+
+/**
+ * rcuref_dec - decrement refcount for object.
+ * @rcuref: reference counter in the object in question.
+ *
+ * This should be used only for objects where we use RCU and
+ * use the rcuref_inc_lf() api to acquire a reference
+ * in a lock-free reader-side critical section.
+ */
+static inline void rcuref_dec(atomic_t *rcuref)
+{
+        atomic_dec(rcuref);
+}
+
+/**
+ * rcuref_dec_and_test - decrement refcount for object and test
+ * @rcuref: reference counter in the object.
+ * @release: pointer to the function that will clean up the object
+ *           when the last reference to the object is released.
+ *           This pointer is required.
+ *
+ * Decrement the refcount, and if 0, return 1. Else return 0.
+ *
+ * This should be used only for objects where we use RCU and
+ * use the rcuref_inc_lf() api to acquire a reference
+ * in a lock-free reader-side critical section.
+ */
+static inline int rcuref_dec_and_test(atomic_t *rcuref)
+{
+        return atomic_dec_and_test(rcuref);
+}
+
+/*
+ * cmpxchg is needed on UP too, if deletions to the list/array can happen
+ * in interrupt context.
+ */
+
+/**
+ * rcuref_inc_lf - Take reference to an object in a read-side
+ * critical section protected by RCU.
+ * @rcuref: reference counter in the object in question.
+ *
+ * Try and increment the refcount by 1.  The increment might fail if
+ * the reference counter has been through a 1 to 0 transition and
+ * is no longer part of the lock-free list.
+ * Returns non-zero on successful increment and zero otherwise.
+ */
+static inline int rcuref_inc_lf(atomic_t *rcuref)
+{
+        int c, old;
+        c = atomic_read(rcuref);
+        while (c && (old = cmpxchg(&rcuref->counter, c, c + 1)) != c)
+                c = old;
+        return c;
+}
+
+#else                           /* !__HAVE_ARCH_CMPXCHG */
+
+extern spinlock_t __rcuref_hash[];
+
+/*
+ * Use a hash table of locks to protect the reference count
+ * since cmpxchg is not available in this arch.
+ */
+#ifdef  CONFIG_SMP
+#define RCUREF_HASH_SIZE        4
+#define RCUREF_HASH(k) \
+        (&__rcuref_hash[(((unsigned long)k)>>8) & (RCUREF_HASH_SIZE-1)])
+#else
+#define RCUREF_HASH_SIZE        1
+#define RCUREF_HASH(k)  &__rcuref_hash[0]
+#endif                          /* CONFIG_SMP */
+
+/**
+ * rcuref_inc - increment refcount for object.
+ * @rcuref: reference counter in the object in question.
+ *
+ * This should be used only for objects where we use RCU and
+ * use the rcuref_inc_lf() api to acquire a reference in a lock-free
+ * reader-side critical section.
+ */
+static inline void rcuref_inc(atomic_t *rcuref)
+{
+        unsigned long flags;
+        spin_lock_irqsave(RCUREF_HASH(rcuref), flags);
+        rcuref->counter += 1;
+        spin_unlock_irqrestore(RCUREF_HASH(rcuref), flags);
+}
+
+/**
+ * rcuref_dec - decrement refcount for object.
+ * @rcuref: reference counter in the object in question.
+ *
+ * This should be used only for objects where we use RCU and
+ * use the rcuref_inc_lf() api to acquire a reference in a lock-free
+ * reader-side critical section.
+ */
+static inline void rcuref_dec(atomic_t *rcuref)
+{
+        unsigned long flags;
+        spin_lock_irqsave(RCUREF_HASH(rcuref), flags);
+        rcuref->counter -= 1;
+        spin_unlock_irqrestore(RCUREF_HASH(rcuref), flags);
+}
+
+/**
+ * rcuref_dec_and_test - decrement refcount for object and test
+ * @rcuref: reference counter in the object.
+ * @release: pointer to the function that will clean up the object
+ *           when the last reference to the object is released.
+ *           This pointer is required.
+ *
+ * Decrement the refcount, and if 0, return 1. Else return 0.
+ *
+ * This should be used only for objects where we use RCU and
+ * use the rcuref_inc_lf() api to acquire a reference in a lock-free
+ * reader-side critical section.
+ */
+static inline int rcuref_dec_and_test(atomic_t *rcuref)
+{
+        unsigned long flags;
+        spin_lock_irqsave(RCUREF_HASH(rcuref), flags);
+        rcuref->counter--;
+        if (!rcuref->counter) {
+                spin_unlock_irqrestore(RCUREF_HASH(rcuref), flags);
+                return 1;
+        } else {
+                spin_unlock_irqrestore(RCUREF_HASH(rcuref), flags);
+                return 0;
+        }
+}
+
+/**
+ * rcuref_inc_lf - Take reference to an object of a lock-free collection
+ * by traversing a lock-free list/array.
+ * @rcuref: reference counter in the object in question.
+ *
+ * Try and increment the refcount by 1.  The increment might fail if
+ * the reference counter has been through a 1 to 0 transition and
+ * object is no longer part of the lock-free list.
+ * Returns non-zero on successful increment and zero otherwise.
+ */
+static inline int rcuref_inc_lf(atomic_t *rcuref)
+{
+        int ret;
+        unsigned long flags;
+        spin_lock_irqsave(RCUREF_HASH(rcuref), flags);
+        if (rcuref->counter)
+                ret = rcuref->counter++;
+        else
+                ret = 0;
+        spin_unlock_irqrestore(RCUREF_HASH(rcuref), flags);
+        return ret;
+}
+
+
+#endif /* !__HAVE_ARCH_CMPXCHG */
+
+#endif /* __KERNEL__ */
+#endif /* _RCUREF_H_ */
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index 17e458e17e2b..af00b10294cd 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -2097,7 +2097,7 @@ void reiserfs_free_block(struct reiserfs_transaction_handle *th, struct inode *,
                          b_blocknr_t, int for_unformatted);
 int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t *, b_blocknr_t *, int,
                                int);
-extern inline int reiserfs_new_form_blocknrs(struct tree_balance *tb,
+static inline int reiserfs_new_form_blocknrs(struct tree_balance *tb,
                                              b_blocknr_t * new_blocknrs,
                                              int amount_needed)
 {
@@ -2113,7 +2113,7 @@ extern inline int reiserfs_new_form_blocknrs(struct tree_balance *tb,
                                           0);
 }
 
-extern inline int reiserfs_new_unf_blocknrs(struct reiserfs_transaction_handle
+static inline int reiserfs_new_unf_blocknrs(struct reiserfs_transaction_handle
                                             *th, struct inode *inode,
                                             b_blocknr_t * new_blocknrs,
                                             struct path *path, long block)
@@ -2130,7 +2130,7 @@ extern inline int reiserfs_new_unf_blocknrs(struct reiserfs_transaction_handle
 }
 
 #ifdef REISERFS_PREALLOCATE
-extern inline int reiserfs_new_unf_blocknrs2(struct reiserfs_transaction_handle
+static inline int reiserfs_new_unf_blocknrs2(struct reiserfs_transaction_handle
                                              *th, struct inode *inode,
                                              b_blocknr_t * new_blocknrs,
                                              struct path *path, long block)
diff --git a/include/linux/sched.h b/include/linux/sched.h
index ea1b5f32ec5c..38c8654aaa96 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -114,6 +114,7 @@ extern unsigned long nr_iowait(void);
 #define TASK_TRACED             8
 #define EXIT_ZOMBIE             16
 #define EXIT_DEAD               32
+#define TASK_NONINTERACTIVE     64
 
 #define __set_task_state(tsk, state_value)              \
         do { (tsk)->state = (state_value); } while (0)
@@ -202,6 +203,8 @@ extern int in_sched_functions(unsigned long addr);
 
 #define MAX_SCHEDULE_TIMEOUT    LONG_MAX
 extern signed long FASTCALL(schedule_timeout(signed long timeout));
+extern signed long schedule_timeout_interruptible(signed long timeout);
+extern signed long schedule_timeout_uninterruptible(signed long timeout);
 asmlinkage void schedule(void);
 
 struct namespace;
@@ -604,6 +607,11 @@ extern int groups_search(struct group_info *group_info, gid_t grp);
 #define GROUP_AT(gi, i) \
     ((gi)->blocks[(i)/NGROUPS_PER_BLOCK][(i)%NGROUPS_PER_BLOCK])
 
+#ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
+extern void prefetch_stack(struct task_struct*);
+#else
+static inline void prefetch_stack(struct task_struct *t) { }
+#endif
 
 struct audit_context;           /* See audit.c */
 struct mempolicy;
@@ -895,6 +903,8 @@ extern int task_curr(const task_t *p);
 extern int idle_cpu(int cpu);
 extern int sched_setscheduler(struct task_struct *, int, struct sched_param *);
 extern task_t *idle_task(int cpu);
+extern task_t *curr_task(int cpu);
+extern void set_curr_task(int cpu, task_t *p);
 
 void yield(void);
 
diff --git a/include/linux/security.h b/include/linux/security.h
index 7aab6ab7c57f..55b02e1c73f4 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -250,29 +250,37 @@ struct swap_info_struct;
  *      @inode contains the inode structure.
  *      Deallocate the inode security structure and set @inode->i_security to
  *      NULL. 
+ * @inode_init_security:
+ *      Obtain the security attribute name suffix and value to set on a newly
+ *      created inode and set up the incore security field for the new inode.
+ *      This hook is called by the fs code as part of the inode creation
+ *      transaction and provides for atomic labeling of the inode, unlike
+ *      the post_create/mkdir/... hooks called by the VFS.  The hook function
+ *      is expected to allocate the name and value via kmalloc, with the caller
+ *      being responsible for calling kfree after using them.
+ *      If the security module does not use security attributes or does
+ *      not wish to put a security attribute on this particular inode,
+ *      then it should return -EOPNOTSUPP to skip this processing.
+ *      @inode contains the inode structure of the newly created inode.
+ *      @dir contains the inode structure of the parent directory.
+ *      @name will be set to the allocated name suffix (e.g. selinux).
+ *      @value will be set to the allocated attribute value.
+ *      @len will be set to the length of the value.
+ *      Returns 0 if @name and @value have been successfully set,
+ *              -EOPNOTSUPP if no security attribute is needed, or
+ *              -ENOMEM on memory allocation failure.
  * @inode_create:
  *      Check permission to create a regular file.
  *      @dir contains inode structure of the parent of the new file.
  *      @dentry contains the dentry structure for the file to be created.
  *      @mode contains the file mode of the file to be created.
  *      Return 0 if permission is granted.
- * @inode_post_create:
- *      Set the security attributes on a newly created regular file.  This hook
- *      is called after a file has been successfully created.
- *      @dir contains the inode structure of the parent directory of the new file.
- *      @dentry contains the the dentry structure for the newly created file.
- *      @mode contains the file mode.
  * @inode_link:
  *      Check permission before creating a new hard link to a file.
  *      @old_dentry contains the dentry structure for an existing link to the file.
  *      @dir contains the inode structure of the parent directory of the new link.
  *      @new_dentry contains the dentry structure for the new link.
  *      Return 0 if permission is granted.
- * @inode_post_link:
- *      Set security attributes for a new hard link to a file.
- *      @old_dentry contains the dentry structure for the existing link.
- *      @dir contains the inode structure of the parent directory of the new file.
- *      @new_dentry contains the dentry structure for the new file link.
  * @inode_unlink:
  *      Check the permission to remove a hard link to a file. 
  *      @dir contains the inode structure of parent directory of the file.
@@ -284,13 +292,6 @@ struct swap_info_struct;
  *      @dentry contains the dentry structure of the symbolic link.
  *      @old_name contains the pathname of file.
  *      Return 0 if permission is granted.
- * @inode_post_symlink:
- *      @dir contains the inode structure of the parent directory of the new link.
- *      @dentry contains the dentry structure of new symbolic link.
- *      @old_name contains the pathname of file.
- *      Set security attributes for a newly created symbolic link.  Note that
- *      @dentry->d_inode may be NULL, since the filesystem might not
- *      instantiate the dentry (e.g. NFS).
  * @inode_mkdir:
  *      Check permissions to create a new directory in the existing directory
  *      associated with inode strcture @dir. 
@@ -298,11 +299,6 @@ struct swap_info_struct;
  *      @dentry contains the dentry structure of new directory.
  *      @mode contains the mode of new directory.
  *      Return 0 if permission is granted.
- * @inode_post_mkdir:
- *      Set security attributes on a newly created directory.
- *      @dir contains the inode structure of parent of the directory to be created.
- *      @dentry contains the dentry structure of new directory.
- *      @mode contains the mode of new directory.
  * @inode_rmdir:
  *      Check the permission to remove a directory.
  *      @dir contains the inode structure of parent of the directory to be removed.
@@ -318,13 +314,6 @@ struct swap_info_struct;
  *      @mode contains the mode of the new file.
  *      @dev contains the the device number.
  *      Return 0 if permission is granted.
- * @inode_post_mknod:
- *      Set security attributes on a newly created special file (or socket or
- *      fifo file created via the mknod system call).
- *      @dir contains the inode structure of parent of the new node.
- *      @dentry contains the dentry structure of the new node.
- *      @mode contains the mode of the new node.
- *      @dev contains the the device number.
  * @inode_rename:
  *      Check for permission to rename a file or directory.
  *      @old_dir contains the inode structure for parent of the old link.
@@ -332,12 +321,6 @@ struct swap_info_struct;
  *      @new_dir contains the inode structure for parent of the new link.
  *      @new_dentry contains the dentry structure of the new link.
  *      Return 0 if permission is granted.
- * @inode_post_rename:
- *      Set security attributes on a renamed file or directory.
- *      @old_dir contains the inode structure for parent of the old link.
- *      @old_dentry contains the dentry structure of the old link.
- *      @new_dir contains the inode structure for parent of the new link.
- *      @new_dentry contains the dentry structure of the new link.
  * @inode_readlink:
  *      Check the permission to read the symbolic link.
  *      @dentry contains the dentry structure for the file link.
@@ -1080,34 +1063,21 @@ struct security_operations {
 
         int (*inode_alloc_security) (struct inode *inode);      
         void (*inode_free_security) (struct inode *inode);
+        int (*inode_init_security) (struct inode *inode, struct inode *dir,
+                                    char **name, void **value, size_t *len);
         int (*inode_create) (struct inode *dir,
                              struct dentry *dentry, int mode);
-        void (*inode_post_create) (struct inode *dir,
-                                   struct dentry *dentry, int mode);
         int (*inode_link) (struct dentry *old_dentry,
                            struct inode *dir, struct dentry *new_dentry);
-        void (*inode_post_link) (struct dentry *old_dentry,
-                                 struct inode *dir, struct dentry *new_dentry);
         int (*inode_unlink) (struct inode *dir, struct dentry *dentry);
         int (*inode_symlink) (struct inode *dir,
                               struct dentry *dentry, const char *old_name);
-        void (*inode_post_symlink) (struct inode *dir,
-                                    struct dentry *dentry,
-                                    const char *old_name);
         int (*inode_mkdir) (struct inode *dir, struct dentry *dentry, int mode);
-        void (*inode_post_mkdir) (struct inode *dir, struct dentry *dentry, 
-                            int mode);
         int (*inode_rmdir) (struct inode *dir, struct dentry *dentry);
         int (*inode_mknod) (struct inode *dir, struct dentry *dentry,
                             int mode, dev_t dev);
-        void (*inode_post_mknod) (struct inode *dir, struct dentry *dentry,
-                                  int mode, dev_t dev);
         int (*inode_rename) (struct inode *old_dir, struct dentry *old_dentry,
                              struct inode *new_dir, struct dentry *new_dentry);
-        void (*inode_post_rename) (struct inode *old_dir,
-                                   struct dentry *old_dentry,
-                                   struct inode *new_dir,
-                                   struct dentry *new_dentry);
         int (*inode_readlink) (struct dentry *dentry);
         int (*inode_follow_link) (struct dentry *dentry, struct nameidata *nd);
         int (*inode_permission) (struct inode *inode, int mask, struct nameidata *nd);
@@ -1442,6 +1412,17 @@ static inline void security_inode_free (struct inode *inode)
                 return;
         security_ops->inode_free_security (inode);
 }
+
+static inline int security_inode_init_security (struct inode *inode,
+                                                struct inode *dir,
+                                                char **name,
+                                                void **value,
+                                                size_t *len)
+{
+        if (unlikely (IS_PRIVATE (inode)))
+                return -EOPNOTSUPP;
+        return security_ops->inode_init_security (inode, dir, name, value, len);
+}
         
 static inline int security_inode_create (struct inode *dir,
                                          struct dentry *dentry,
@@ -1452,15 +1433,6 @@ static inline int security_inode_create (struct inode *dir,
         return security_ops->inode_create (dir, dentry, mode);
 }
 
-static inline void security_inode_post_create (struct inode *dir,
-                                               struct dentry *dentry,
-                                               int mode)
-{
-        if (dentry->d_inode && unlikely (IS_PRIVATE (dentry->d_inode)))
-                return;
-        security_ops->inode_post_create (dir, dentry, mode);
-}
-
 static inline int security_inode_link (struct dentry *old_dentry,
                                        struct inode *dir,
                                        struct dentry *new_dentry)
@@ -1470,15 +1442,6 @@ static inline int security_inode_link (struct dentry *old_dentry,
         return security_ops->inode_link (old_dentry, dir, new_dentry);
 }
 
-static inline void security_inode_post_link (struct dentry *old_dentry,
-                                             struct inode *dir,
-                                             struct dentry *new_dentry)
-{
-        if (new_dentry->d_inode && unlikely (IS_PRIVATE (new_dentry->d_inode)))
-                return;
-        security_ops->inode_post_link (old_dentry, dir, new_dentry);
-}
-
 static inline int security_inode_unlink (struct inode *dir,
                                          struct dentry *dentry)
 {
@@ -1496,15 +1459,6 @@ static inline int security_inode_symlink (struct inode *dir,
         return security_ops->inode_symlink (dir, dentry, old_name);
 }
 
-static inline void security_inode_post_symlink (struct inode *dir,
-                                                struct dentry *dentry,
-                                                const char *old_name)
-{
-        if (dentry->d_inode && unlikely (IS_PRIVATE (dentry->d_inode)))
-                return;
-        security_ops->inode_post_symlink (dir, dentry, old_name);
-}
-
 static inline int security_inode_mkdir (struct inode *dir,
                                         struct dentry *dentry,
                                         int mode)
@@ -1514,15 +1468,6 @@ static inline int security_inode_mkdir (struct inode *dir,
         return security_ops->inode_mkdir (dir, dentry, mode);
 }
 
-static inline void security_inode_post_mkdir (struct inode *dir,
-                                              struct dentry *dentry,
-                                              int mode)
-{
-        if (dentry->d_inode && unlikely (IS_PRIVATE (dentry->d_inode)))
-                return;
-        security_ops->inode_post_mkdir (dir, dentry, mode);
-}
-
 static inline int security_inode_rmdir (struct inode *dir,
                                         struct dentry *dentry)
 {
@@ -1540,15 +1485,6 @@ static inline int security_inode_mknod (struct inode *dir,
         return security_ops->inode_mknod (dir, dentry, mode, dev);
 }
 
-static inline void security_inode_post_mknod (struct inode *dir,
-                                              struct dentry *dentry,
-                                              int mode, dev_t dev)
-{
-        if (dentry->d_inode && unlikely (IS_PRIVATE (dentry->d_inode)))
-                return;
-        security_ops->inode_post_mknod (dir, dentry, mode, dev);
-}
-
 static inline int security_inode_rename (struct inode *old_dir,
                                          struct dentry *old_dentry,
                                          struct inode *new_dir,
@@ -1561,18 +1497,6 @@ static inline int security_inode_rename (struct inode *old_dir,
                                            new_dir, new_dentry);
 }
 
-static inline void security_inode_post_rename (struct inode *old_dir,
-                                               struct dentry *old_dentry,
-                                               struct inode *new_dir,
-                                               struct dentry *new_dentry)
-{
-        if (unlikely (IS_PRIVATE (old_dentry->d_inode) ||
-            (new_dentry->d_inode && IS_PRIVATE (new_dentry->d_inode))))
-                return;
-        security_ops->inode_post_rename (old_dir, old_dentry,
-                                                new_dir, new_dentry);
-}
-
 static inline int security_inode_readlink (struct dentry *dentry)
 {
         if (unlikely (IS_PRIVATE (dentry->d_inode)))
@@ -2171,6 +2095,15 @@ static inline int security_inode_alloc (struct inode *inode)
 
 static inline void security_inode_free (struct inode *inode)
 { }
+
+static inline int security_inode_init_security (struct inode *inode,
+                                                struct inode *dir,
+                                                char **name,
+                                                void **value,
+                                                size_t *len)
+{
+        return -EOPNOTSUPP;
+}
         
 static inline int security_inode_create (struct inode *dir,
                                          struct dentry *dentry,
@@ -2179,11 +2112,6 @@ static inline int security_inode_create (struct inode *dir,
         return 0;
 }
 
-static inline void security_inode_post_create (struct inode *dir,
-                                               struct dentry *dentry,
-                                               int mode)
-{ }
-
 static inline int security_inode_link (struct dentry *old_dentry,
                                        struct inode *dir,
                                        struct dentry *new_dentry)
@@ -2191,11 +2119,6 @@ static inline int security_inode_link (struct dentry *old_dentry,
         return 0;
 }
 
-static inline void security_inode_post_link (struct dentry *old_dentry,
-                                             struct inode *dir,
-                                             struct dentry *new_dentry)
-{ }
-
 static inline int security_inode_unlink (struct inode *dir,
                                          struct dentry *dentry)
 {
@@ -2209,11 +2132,6 @@ static inline int security_inode_symlink (struct inode *dir,
         return 0;
 }
 
-static inline void security_inode_post_symlink (struct inode *dir,
-                                                struct dentry *dentry,
-                                                const char *old_name)
-{ }
-
 static inline int security_inode_mkdir (struct inode *dir,
                                         struct dentry *dentry,
                                         int mode)
@@ -2221,11 +2139,6 @@ static inline int security_inode_mkdir (struct inode *dir,
         return 0;
 }
 
-static inline void security_inode_post_mkdir (struct inode *dir,
-                                              struct dentry *dentry,
-                                              int mode)
-{ }
-
 static inline int security_inode_rmdir (struct inode *dir,
                                         struct dentry *dentry)
 {
@@ -2239,11 +2152,6 @@ static inline int security_inode_mknod (struct inode *dir,
         return 0;
 }
 
-static inline void security_inode_post_mknod (struct inode *dir,
-                                              struct dentry *dentry,
-                                              int mode, dev_t dev)
-{ }
-
 static inline int security_inode_rename (struct inode *old_dir,
                                          struct dentry *old_dentry,
                                          struct inode *new_dir,
@@ -2252,12 +2160,6 @@ static inline int security_inode_rename (struct inode *old_dir,
         return 0;
 }
 
-static inline void security_inode_post_rename (struct inode *old_dir,
-                                               struct dentry *old_dentry,
-                                               struct inode *new_dir,
-                                               struct dentry *new_dentry)
-{ }
-
 static inline int security_inode_readlink (struct dentry *dentry)
 {
         return 0;
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 42a6bea58af3..1f356f3bbc64 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -118,7 +118,8 @@ extern void kfree(const void *);
 extern unsigned int ksize(const void *);
 
 #ifdef CONFIG_NUMA
-extern void *kmem_cache_alloc_node(kmem_cache_t *, int flags, int node);
+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);
 #else
 static inline void *kmem_cache_alloc_node(kmem_cache_t *cachep, int flags, int node)
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index d6ba068719b6..cdc99a27840d 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -2,7 +2,48 @@
 #define __LINUX_SPINLOCK_H
 
 /*
- * include/linux/spinlock.h - generic locking declarations
+ * include/linux/spinlock.h - generic spinlock/rwlock declarations
+ *
+ * here's the role of the various spinlock/rwlock related include files:
+ *
+ * on SMP builds:
+ *
+ *  asm/spinlock_types.h: contains the raw_spinlock_t/raw_rwlock_t and the
+ *                        initializers
+ *
+ *  linux/spinlock_types.h:
+ *                        defines the generic type and initializers
+ *
+ *  asm/spinlock.h:       contains the __raw_spin_*()/etc. lowlevel
+ *                        implementations, mostly inline assembly code
+ *
+ *   (also included on UP-debug builds:)
+ *
+ *  linux/spinlock_api_smp.h:
+ *                        contains the prototypes for the _spin_*() APIs.
+ *
+ *  linux/spinlock.h:     builds the final spin_*() APIs.
+ *
+ * on UP builds:
+ *
+ *  linux/spinlock_type_up.h:
+ *                        contains the generic, simplified UP spinlock type.
+ *                        (which is an empty structure on non-debug builds)
+ *
+ *  linux/spinlock_types.h:
+ *                        defines the generic type and initializers
+ *
+ *  linux/spinlock_up.h:
+ *                        contains the __raw_spin_*()/etc. version of UP
+ *                        builds. (which are NOPs on non-debug, non-preempt
+ *                        builds)
+ *
+ *   (included on UP-non-debug builds:)
+ *
+ *  linux/spinlock_api_up.h:
+ *                        builds the _spin_*() APIs.
+ *
+ *  linux/spinlock.h:     builds the final spin_*() APIs.
  */
 
 #include <linux/config.h>
@@ -13,7 +54,6 @@
 #include <linux/kernel.h>
 #include <linux/stringify.h>
 
-#include <asm/processor.h>      /* for cpu relax */
 #include <asm/system.h>
 
 /*
@@ -35,423 +75,84 @@
 #define __lockfunc fastcall __attribute__((section(".spinlock.text")))
 
 /*
- * If CONFIG_SMP is set, pull in the _raw_* definitions
+ * Pull the raw_spinlock_t and raw_rwlock_t definitions:
  */
-#ifdef CONFIG_SMP
-
-#define assert_spin_locked(x)   BUG_ON(!spin_is_locked(x))
-#include <asm/spinlock.h>
-
-int __lockfunc _spin_trylock(spinlock_t *lock);
-int __lockfunc _read_trylock(rwlock_t *lock);
-int __lockfunc _write_trylock(rwlock_t *lock);
-
-void __lockfunc _spin_lock(spinlock_t *lock)    __acquires(spinlock_t);
-void __lockfunc _read_lock(rwlock_t *lock)      __acquires(rwlock_t);
-void __lockfunc _write_lock(rwlock_t *lock)     __acquires(rwlock_t);
-
-void __lockfunc _spin_unlock(spinlock_t *lock)  __releases(spinlock_t);
-void __lockfunc _read_unlock(rwlock_t *lock)    __releases(rwlock_t);
-void __lockfunc _write_unlock(rwlock_t *lock)   __releases(rwlock_t);
-
-unsigned long __lockfunc _spin_lock_irqsave(spinlock_t *lock)   __acquires(spinlock_t);
-unsigned long __lockfunc _read_lock_irqsave(rwlock_t *lock)     __acquires(rwlock_t);
-unsigned long __lockfunc _write_lock_irqsave(rwlock_t *lock)    __acquires(rwlock_t);
-
-void __lockfunc _spin_lock_irq(spinlock_t *lock)        __acquires(spinlock_t);
-void __lockfunc _spin_lock_bh(spinlock_t *lock)         __acquires(spinlock_t);
-void __lockfunc _read_lock_irq(rwlock_t *lock)          __acquires(rwlock_t);
-void __lockfunc _read_lock_bh(rwlock_t *lock)           __acquires(rwlock_t);
-void __lockfunc _write_lock_irq(rwlock_t *lock)         __acquires(rwlock_t);
-void __lockfunc _write_lock_bh(rwlock_t *lock)          __acquires(rwlock_t);
-
-void __lockfunc _spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)  __releases(spinlock_t);
-void __lockfunc _spin_unlock_irq(spinlock_t *lock)                              __releases(spinlock_t);
-void __lockfunc _spin_unlock_bh(spinlock_t *lock)                               __releases(spinlock_t);
-void __lockfunc _read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)    __releases(rwlock_t);
-void __lockfunc _read_unlock_irq(rwlock_t *lock)                                __releases(rwlock_t);
-void __lockfunc _read_unlock_bh(rwlock_t *lock)                                 __releases(rwlock_t);
-void __lockfunc _write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)   __releases(rwlock_t);
-void __lockfunc _write_unlock_irq(rwlock_t *lock)                               __releases(rwlock_t);
-void __lockfunc _write_unlock_bh(rwlock_t *lock)                                __releases(rwlock_t);
-
-int __lockfunc _spin_trylock_bh(spinlock_t *lock);
-int __lockfunc generic_raw_read_trylock(rwlock_t *lock);
-int in_lock_functions(unsigned long addr);
-
-#else
+#include <linux/spinlock_types.h>
 
-#define in_lock_functions(ADDR) 0
+extern int __lockfunc generic__raw_read_trylock(raw_rwlock_t *lock);
 
-#if !defined(CONFIG_PREEMPT) && !defined(CONFIG_DEBUG_SPINLOCK)
-# define _atomic_dec_and_lock(atomic,lock) atomic_dec_and_test(atomic)
-# define ATOMIC_DEC_AND_LOCK
-#endif
-
-#ifdef CONFIG_DEBUG_SPINLOCK
- 
-#define SPINLOCK_MAGIC  0x1D244B3C
-typedef struct {
-        unsigned long magic;
-        volatile unsigned long lock;
-        volatile unsigned int babble;
-        const char *module;
-        char *owner;
-        int oline;
-} spinlock_t;
-#define SPIN_LOCK_UNLOCKED (spinlock_t) { SPINLOCK_MAGIC, 0, 10, __FILE__ , NULL, 0}
-
-#define spin_lock_init(x) \
-        do { \
-                (x)->magic = SPINLOCK_MAGIC; \
-                (x)->lock = 0; \
-                (x)->babble = 5; \
-                (x)->module = __FILE__; \
-                (x)->owner = NULL; \
-                (x)->oline = 0; \
-        } while (0)
-
-#define CHECK_LOCK(x) \
-        do { \
-                if ((x)->magic != SPINLOCK_MAGIC) { \
-                        printk(KERN_ERR "%s:%d: spin_is_locked on uninitialized spinlock %p.\n", \
-                                        __FILE__, __LINE__, (x)); \
-                } \
-        } while(0)
-
-#define _raw_spin_lock(x)               \
-        do { \
-                CHECK_LOCK(x); \
-                if ((x)->lock&&(x)->babble) { \
-                        (x)->babble--; \
-                        printk("%s:%d: spin_lock(%s:%p) already locked by %s/%d\n", \
-                                        __FILE__,__LINE__, (x)->module, \
-                                        (x), (x)->owner, (x)->oline); \
-                } \
-                (x)->lock = 1; \
-                (x)->owner = __FILE__; \
-                (x)->oline = __LINE__; \
-        } while (0)
-
-/* without debugging, spin_is_locked on UP always says
- * FALSE. --> printk if already locked. */
-#define spin_is_locked(x) \
-        ({ \
-                CHECK_LOCK(x); \
-                if ((x)->lock&&(x)->babble) { \
-                        (x)->babble--; \
-                        printk("%s:%d: spin_is_locked(%s:%p) already locked by %s/%d\n", \
-                                        __FILE__,__LINE__, (x)->module, \
-                                        (x), (x)->owner, (x)->oline); \
-                } \
-                0; \
-        })
-
-/* with debugging, assert_spin_locked() on UP does check
- * the lock value properly */
-#define assert_spin_locked(x) \
-        ({ \
-                CHECK_LOCK(x); \
-                BUG_ON(!(x)->lock); \
-        })
-
-/* without debugging, spin_trylock on UP always says
- * TRUE. --> printk if already locked. */
-#define _raw_spin_trylock(x) \
-        ({ \
-                CHECK_LOCK(x); \
-                if ((x)->lock&&(x)->babble) { \
-                        (x)->babble--; \
-                        printk("%s:%d: spin_trylock(%s:%p) already locked by %s/%d\n", \
-                                        __FILE__,__LINE__, (x)->module, \
-                                        (x), (x)->owner, (x)->oline); \
-                } \
-                (x)->lock = 1; \
-                (x)->owner = __FILE__; \
-                (x)->oline = __LINE__; \
-                1; \
-        })
-
-#define spin_unlock_wait(x)     \
-        do { \
-                CHECK_LOCK(x); \
-                if ((x)->lock&&(x)->babble) { \
-                        (x)->babble--; \
-                        printk("%s:%d: spin_unlock_wait(%s:%p) owned by %s/%d\n", \
-                                        __FILE__,__LINE__, (x)->module, (x), \
-                                        (x)->owner, (x)->oline); \
-                }\
-        } while (0)
-
-#define _raw_spin_unlock(x) \
-        do { \
-                CHECK_LOCK(x); \
-                if (!(x)->lock&&(x)->babble) { \
-                        (x)->babble--; \
-                        printk("%s:%d: spin_unlock(%s:%p) not locked\n", \
-                                        __FILE__,__LINE__, (x)->module, (x));\
-                } \
-                (x)->lock = 0; \
-        } while (0)
-#else
 /*
- * gcc versions before ~2.95 have a nasty bug with empty initializers.
+ * Pull the __raw*() functions/declarations (UP-nondebug doesnt need them):
  */
-#if (__GNUC__ > 2)
-  typedef struct { } spinlock_t;
-  #define SPIN_LOCK_UNLOCKED (spinlock_t) { }
+#if defined(CONFIG_SMP)
+# include <asm/spinlock.h>
 #else
-  typedef struct { int gcc_is_buggy; } spinlock_t;
-  #define SPIN_LOCK_UNLOCKED (spinlock_t) { 0 }
+# include <linux/spinlock_up.h>
 #endif
 
+#define spin_lock_init(lock)    do { *(lock) = SPIN_LOCK_UNLOCKED; } while (0)
+#define rwlock_init(lock)       do { *(lock) = RW_LOCK_UNLOCKED; } while (0)
+
+#define spin_is_locked(lock)    __raw_spin_is_locked(&(lock)->raw_lock)
+
+/**
+ * spin_unlock_wait - wait until the spinlock gets unlocked
+ * @lock: the spinlock in question.
+ */
+#define spin_unlock_wait(lock)  __raw_spin_unlock_wait(&(lock)->raw_lock)
+
 /*
- * If CONFIG_SMP is unset, declare the _raw_* definitions as nops
+ * Pull the _spin_*()/_read_*()/_write_*() functions/declarations:
  */
-#define spin_lock_init(lock)    do { (void)(lock); } while(0)
-#define _raw_spin_lock(lock)    do { (void)(lock); } while(0)
-#define spin_is_locked(lock)    ((void)(lock), 0)
-#define assert_spin_locked(lock)        do { (void)(lock); } while(0)
-#define _raw_spin_trylock(lock) (((void)(lock), 1))
-#define spin_unlock_wait(lock)  (void)(lock)
-#define _raw_spin_unlock(lock) do { (void)(lock); } while(0)
-#endif /* CONFIG_DEBUG_SPINLOCK */
-
-/* RW spinlocks: No debug version */
-
-#if (__GNUC__ > 2)
-  typedef struct { } rwlock_t;
-  #define RW_LOCK_UNLOCKED (rwlock_t) { }
+#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
+# include <linux/spinlock_api_smp.h>
 #else
-  typedef struct { int gcc_is_buggy; } rwlock_t;
-  #define RW_LOCK_UNLOCKED (rwlock_t) { 0 }
+# include <linux/spinlock_api_up.h>
 #endif
 
-#define rwlock_init(lock)       do { (void)(lock); } while(0)
-#define _raw_read_lock(lock)    do { (void)(lock); } while(0)
-#define _raw_read_unlock(lock)  do { (void)(lock); } while(0)
-#define _raw_write_lock(lock)   do { (void)(lock); } while(0)
-#define _raw_write_unlock(lock) do { (void)(lock); } while(0)
-#define read_can_lock(lock)     (((void)(lock), 1))
-#define write_can_lock(lock)    (((void)(lock), 1))
-#define _raw_read_trylock(lock) ({ (void)(lock); (1); })
-#define _raw_write_trylock(lock) ({ (void)(lock); (1); })
-
-#define _spin_trylock(lock)     ({preempt_disable(); _raw_spin_trylock(lock) ? \
-                                1 : ({preempt_enable(); 0;});})
-
-#define _read_trylock(lock)     ({preempt_disable();_raw_read_trylock(lock) ? \
-                                1 : ({preempt_enable(); 0;});})
-
-#define _write_trylock(lock)    ({preempt_disable(); _raw_write_trylock(lock) ? \
-                                1 : ({preempt_enable(); 0;});})
-
-#define _spin_trylock_bh(lock)  ({preempt_disable(); local_bh_disable(); \
-                                _raw_spin_trylock(lock) ? \
-                                1 : ({preempt_enable_no_resched(); local_bh_enable(); 0;});})
-
-#define _spin_lock(lock)        \
-do { \
-        preempt_disable(); \
-        _raw_spin_lock(lock); \
-        __acquire(lock); \
-} while(0)
-
-#define _write_lock(lock) \
-do { \
-        preempt_disable(); \
-        _raw_write_lock(lock); \
-        __acquire(lock); \
-} while(0)
- 
-#define _read_lock(lock)        \
-do { \
-        preempt_disable(); \
-        _raw_read_lock(lock); \
-        __acquire(lock); \
-} while(0)
-
-#define _spin_unlock(lock) \
-do { \
-        _raw_spin_unlock(lock); \
-        preempt_enable(); \
-        __release(lock); \
-} while (0)
-
-#define _write_unlock(lock) \
-do { \
-        _raw_write_unlock(lock); \
-        preempt_enable(); \
-        __release(lock); \
-} while(0)
-
-#define _read_unlock(lock) \
-do { \
-        _raw_read_unlock(lock); \
-        preempt_enable(); \
-        __release(lock); \
-} while(0)
-
-#define _spin_lock_irqsave(lock, flags) \
-do {    \
-        local_irq_save(flags); \
-        preempt_disable(); \
-        _raw_spin_lock(lock); \
-        __acquire(lock); \
-} while (0)
-
-#define _spin_lock_irq(lock) \
-do { \
-        local_irq_disable(); \
-        preempt_disable(); \
-        _raw_spin_lock(lock); \
-        __acquire(lock); \
-} while (0)
-
-#define _spin_lock_bh(lock) \
-do { \
-        local_bh_disable(); \
-        preempt_disable(); \
-        _raw_spin_lock(lock); \
-        __acquire(lock); \
-} while (0)
-
-#define _read_lock_irqsave(lock, flags) \
-do {    \
-        local_irq_save(flags); \
-        preempt_disable(); \
-        _raw_read_lock(lock); \
-        __acquire(lock); \
-} while (0)
-
-#define _read_lock_irq(lock) \
-do { \
-        local_irq_disable(); \
-        preempt_disable(); \
-        _raw_read_lock(lock); \
-        __acquire(lock); \
-} while (0)
-
-#define _read_lock_bh(lock) \
-do { \
-        local_bh_disable(); \
-        preempt_disable(); \
-        _raw_read_lock(lock); \
-        __acquire(lock); \
-} while (0)
-
-#define _write_lock_irqsave(lock, flags) \
-do {    \
-        local_irq_save(flags); \
-        preempt_disable(); \
-        _raw_write_lock(lock); \
-        __acquire(lock); \
-} while (0)
+#ifdef CONFIG_DEBUG_SPINLOCK
+ extern void _raw_spin_lock(spinlock_t *lock);
+#define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
+ extern int _raw_spin_trylock(spinlock_t *lock);
+ extern void _raw_spin_unlock(spinlock_t *lock);
+
+ extern void _raw_read_lock(rwlock_t *lock);
+ extern int _raw_read_trylock(rwlock_t *lock);
+ extern void _raw_read_unlock(rwlock_t *lock);
+ extern void _raw_write_lock(rwlock_t *lock);
+ extern int _raw_write_trylock(rwlock_t *lock);
+ extern void _raw_write_unlock(rwlock_t *lock);
+#else
+# define _raw_spin_unlock(lock)         __raw_spin_unlock(&(lock)->raw_lock)
+# define _raw_spin_trylock(lock)        __raw_spin_trylock(&(lock)->raw_lock)
+# define _raw_spin_lock(lock)           __raw_spin_lock(&(lock)->raw_lock)
+# define _raw_spin_lock_flags(lock, flags) \
+                __raw_spin_lock_flags(&(lock)->raw_lock, *(flags))
+# define _raw_read_lock(rwlock)         __raw_read_lock(&(rwlock)->raw_lock)
+# define _raw_write_lock(rwlock)        __raw_write_lock(&(rwlock)->raw_lock)
+# define _raw_read_unlock(rwlock)       __raw_read_unlock(&(rwlock)->raw_lock)
+# define _raw_write_unlock(rwlock)      __raw_write_unlock(&(rwlock)->raw_lock)
+# define _raw_read_trylock(rwlock)      __raw_read_trylock(&(rwlock)->raw_lock)
+# define _raw_write_trylock(rwlock)     __raw_write_trylock(&(rwlock)->raw_lock)
+#endif
 
-#define _write_lock_irq(lock) \
-do { \
-        local_irq_disable(); \
-        preempt_disable(); \
-        _raw_write_lock(lock); \
-        __acquire(lock); \
-} while (0)
-
-#define _write_lock_bh(lock) \
-do { \
-        local_bh_disable(); \
-        preempt_disable(); \
-        _raw_write_lock(lock); \
-        __acquire(lock); \
-} while (0)
-
-#define _spin_unlock_irqrestore(lock, flags) \
-do { \
-        _raw_spin_unlock(lock); \
-        local_irq_restore(flags); \
-        preempt_enable(); \
-        __release(lock); \
-} while (0)
-
-#define _spin_unlock_irq(lock) \
-do { \
-        _raw_spin_unlock(lock); \
-        local_irq_enable(); \
-        preempt_enable(); \
-        __release(lock); \
-} while (0)
-
-#define _spin_unlock_bh(lock) \
-do { \
-        _raw_spin_unlock(lock); \
-        preempt_enable_no_resched(); \
-        local_bh_enable(); \
-        __release(lock); \
-} while (0)
-
-#define _write_unlock_bh(lock) \
-do { \
-        _raw_write_unlock(lock); \
-        preempt_enable_no_resched(); \
-        local_bh_enable(); \
-        __release(lock); \
-} while (0)
-
-#define _read_unlock_irqrestore(lock, flags) \
-do { \
-        _raw_read_unlock(lock); \
-        local_irq_restore(flags); \
-        preempt_enable(); \
-        __release(lock); \
-} while (0)
-
-#define _write_unlock_irqrestore(lock, flags) \
-do { \
-        _raw_write_unlock(lock); \
-        local_irq_restore(flags); \
-        preempt_enable(); \
-        __release(lock); \
-} while (0)
-
-#define _read_unlock_irq(lock)  \
-do { \
-        _raw_read_unlock(lock); \
-        local_irq_enable();     \
-        preempt_enable();       \
-        __release(lock); \
-} while (0)
-
-#define _read_unlock_bh(lock)   \
-do { \
-        _raw_read_unlock(lock); \
-        preempt_enable_no_resched();    \
-        local_bh_enable();      \
-        __release(lock); \
-} while (0)
-
-#define _write_unlock_irq(lock) \
-do { \
-        _raw_write_unlock(lock);        \
-        local_irq_enable();     \
-        preempt_enable();       \
-        __release(lock); \
-} while (0)
-
-#endif /* !SMP */
+#define read_can_lock(rwlock)           __raw_read_can_lock(&(rwlock)->raw_lock)
+#define write_can_lock(rwlock)          __raw_write_can_lock(&(rwlock)->raw_lock)
 
 /*
  * Define the various spin_lock and rw_lock methods.  Note we define these
  * regardless of whether CONFIG_SMP or CONFIG_PREEMPT are set. The various
  * methods are defined as nops in the case they are not required.
  */
-#define spin_trylock(lock)      __cond_lock(_spin_trylock(lock))
-#define read_trylock(lock)      __cond_lock(_read_trylock(lock))
-#define write_trylock(lock)     __cond_lock(_write_trylock(lock))
+#define spin_trylock(lock)              __cond_lock(_spin_trylock(lock))
+#define read_trylock(lock)              __cond_lock(_read_trylock(lock))
+#define write_trylock(lock)             __cond_lock(_write_trylock(lock))
 
-#define spin_lock(lock)         _spin_lock(lock)
-#define write_lock(lock)        _write_lock(lock)
-#define read_lock(lock)         _read_lock(lock)
+#define spin_lock(lock)                 _spin_lock(lock)
+#define write_lock(lock)                _write_lock(lock)
+#define read_lock(lock)                 _read_lock(lock)
 
-#ifdef CONFIG_SMP
+#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
 #define spin_lock_irqsave(lock, flags)  flags = _spin_lock_irqsave(lock)
 #define read_lock_irqsave(lock, flags)  flags = _read_lock_irqsave(lock)
 #define write_lock_irqsave(lock, flags) flags = _write_lock_irqsave(lock)
@@ -470,137 +171,59 @@ do { \
 #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)
+#define spin_unlock(lock)               _spin_unlock(lock)
+#define write_unlock(lock)              _write_unlock(lock)
+#define read_unlock(lock)               _read_unlock(lock)
 
-#define spin_unlock_irqrestore(lock, flags)     _spin_unlock_irqrestore(lock, flags)
+#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 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 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))
+#define spin_trylock_bh(lock)           __cond_lock(_spin_trylock_bh(lock))
 
 #define spin_trylock_irq(lock) \
 ({ \
         local_irq_disable(); \
         _spin_trylock(lock) ? \
-        1 : ({local_irq_enable(); 0; }); \
+        1 : ({ local_irq_enable(); 0;  }); \
 })
 
 #define spin_trylock_irqsave(lock, flags) \
 ({ \
         local_irq_save(flags); \
         _spin_trylock(lock) ? \
-        1 : ({local_irq_restore(flags); 0;}); \
+        1 : ({ local_irq_restore(flags); 0; }); \
 })
 
-#ifdef CONFIG_LOCKMETER
-extern void _metered_spin_lock   (spinlock_t *lock);
-extern void _metered_spin_unlock (spinlock_t *lock);
-extern int  _metered_spin_trylock(spinlock_t *lock);
-extern void _metered_read_lock    (rwlock_t *lock);
-extern void _metered_read_unlock  (rwlock_t *lock);
-extern void _metered_write_lock   (rwlock_t *lock);
-extern void _metered_write_unlock (rwlock_t *lock);
-extern int  _metered_read_trylock (rwlock_t *lock);
-extern int  _metered_write_trylock(rwlock_t *lock);
-#endif
-
-/* "lock on reference count zero" */
-#ifndef ATOMIC_DEC_AND_LOCK
-#include <asm/atomic.h>
-extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
-#endif
-
-#define atomic_dec_and_lock(atomic,lock) __cond_lock(_atomic_dec_and_lock(atomic,lock))
-
-/*
- *  bit-based spin_lock()
- *
- * Don't use this unless you really need to: spin_lock() and spin_unlock()
- * are significantly faster.
- */
-static inline void bit_spin_lock(int bitnum, unsigned long *addr)
-{
-        /*
-         * Assuming the lock is uncontended, this never enters
-         * the body of the outer loop. If it is contended, then
-         * within the inner loop a non-atomic test is used to
-         * busywait with less bus contention for a good time to
-         * attempt to acquire the lock bit.
-         */
-        preempt_disable();
-#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
-        while (test_and_set_bit(bitnum, addr)) {
-                while (test_bit(bitnum, addr)) {
-                        preempt_enable();
-                        cpu_relax();
-                        preempt_disable();
-                }
-        }
-#endif
-        __acquire(bitlock);
-}
-
 /*
- * Return true if it was acquired
+ * Pull the atomic_t declaration:
+ * (asm-mips/atomic.h needs above definitions)
  */
-static inline int bit_spin_trylock(int bitnum, unsigned long *addr)
-{
-        preempt_disable();      
-#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
-        if (test_and_set_bit(bitnum, addr)) {
-                preempt_enable();
-                return 0;
-        }
-#endif
-        __acquire(bitlock);
-        return 1;
-}
-
-/*
- *  bit-based spin_unlock()
- */
-static inline void bit_spin_unlock(int bitnum, unsigned long *addr)
-{
-#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
-        BUG_ON(!test_bit(bitnum, addr));
-        smp_mb__before_clear_bit();
-        clear_bit(bitnum, addr);
-#endif
-        preempt_enable();
-        __release(bitlock);
-}
-
-/*
- * Return true if the lock is held.
+#include <asm/atomic.h>
+/**
+ * atomic_dec_and_lock - lock on reaching reference count zero
+ * @atomic: the atomic counter
+ * @lock: the spinlock in question
  */
-static inline int bit_spin_is_locked(int bitnum, unsigned long *addr)
-{
-#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
-        return test_bit(bitnum, addr);
-#elif defined CONFIG_PREEMPT
-        return preempt_count();
-#else
-        return 1;
-#endif
-}
-
-#define DEFINE_SPINLOCK(x) spinlock_t x = SPIN_LOCK_UNLOCKED
-#define DEFINE_RWLOCK(x) rwlock_t x = RW_LOCK_UNLOCKED
+extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
+#define atomic_dec_and_lock(atomic, lock) \
+                __cond_lock(_atomic_dec_and_lock(atomic, lock))
 
 /**
  * spin_can_lock - would spin_trylock() succeed?
  * @lock: the spinlock in question.
  */
-#define spin_can_lock(lock)             (!spin_is_locked(lock))
+#define spin_can_lock(lock)     (!spin_is_locked(lock))
 
 #endif /* __LINUX_SPINLOCK_H */
diff --git a/include/linux/spinlock_api_smp.h b/include/linux/spinlock_api_smp.h
new file mode 100644
index 000000000000..78e6989ffb54
--- /dev/null
+++ b/include/linux/spinlock_api_smp.h
@@ -0,0 +1,57 @@
+#ifndef __LINUX_SPINLOCK_API_SMP_H
+#define __LINUX_SPINLOCK_API_SMP_H
+
+#ifndef __LINUX_SPINLOCK_H
+# error "please don't include this file directly"
+#endif
+
+/*
+ * include/linux/spinlock_api_smp.h
+ *
+ * spinlock API declarations on SMP (and debug)
+ * (implemented in kernel/spinlock.c)
+ *
+ * portions Copyright 2005, Red Hat, Inc., Ingo Molnar
+ * Released under the General Public License (GPL).
+ */
+
+int in_lock_functions(unsigned long addr);
+
+#define assert_spin_locked(x)   BUG_ON(!spin_is_locked(x))
+
+void __lockfunc _spin_lock(spinlock_t *lock)            __acquires(spinlock_t);
+void __lockfunc _read_lock(rwlock_t *lock)              __acquires(rwlock_t);
+void __lockfunc _write_lock(rwlock_t *lock)             __acquires(rwlock_t);
+void __lockfunc _spin_lock_bh(spinlock_t *lock)         __acquires(spinlock_t);
+void __lockfunc _read_lock_bh(rwlock_t *lock)           __acquires(rwlock_t);
+void __lockfunc _write_lock_bh(rwlock_t *lock)          __acquires(rwlock_t);
+void __lockfunc _spin_lock_irq(spinlock_t *lock)        __acquires(spinlock_t);
+void __lockfunc _read_lock_irq(rwlock_t *lock)          __acquires(rwlock_t);
+void __lockfunc _write_lock_irq(rwlock_t *lock)         __acquires(rwlock_t);
+unsigned long __lockfunc _spin_lock_irqsave(spinlock_t *lock)
+                                                        __acquires(spinlock_t);
+unsigned long __lockfunc _read_lock_irqsave(rwlock_t *lock)
+                                                        __acquires(rwlock_t);
+unsigned long __lockfunc _write_lock_irqsave(rwlock_t *lock)
+                                                        __acquires(rwlock_t);
+int __lockfunc _spin_trylock(spinlock_t *lock);
+int __lockfunc _read_trylock(rwlock_t *lock);
+int __lockfunc _write_trylock(rwlock_t *lock);
+int __lockfunc _spin_trylock_bh(spinlock_t *lock);
+void __lockfunc _spin_unlock(spinlock_t *lock)          __releases(spinlock_t);
+void __lockfunc _read_unlock(rwlock_t *lock)            __releases(rwlock_t);
+void __lockfunc _write_unlock(rwlock_t *lock)           __releases(rwlock_t);
+void __lockfunc _spin_unlock_bh(spinlock_t *lock)       __releases(spinlock_t);
+void __lockfunc _read_unlock_bh(rwlock_t *lock)         __releases(rwlock_t);
+void __lockfunc _write_unlock_bh(rwlock_t *lock)        __releases(rwlock_t);
+void __lockfunc _spin_unlock_irq(spinlock_t *lock)      __releases(spinlock_t);
+void __lockfunc _read_unlock_irq(rwlock_t *lock)        __releases(rwlock_t);
+void __lockfunc _write_unlock_irq(rwlock_t *lock)       __releases(rwlock_t);
+void __lockfunc _spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
+                                                        __releases(spinlock_t);
+void __lockfunc _read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
+                                                        __releases(rwlock_t);
+void __lockfunc _write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
+                                                        __releases(rwlock_t);
+
+#endif /* __LINUX_SPINLOCK_API_SMP_H */
diff --git a/include/linux/spinlock_api_up.h b/include/linux/spinlock_api_up.h
new file mode 100644
index 000000000000..cd81cee566f4
--- /dev/null
+++ b/include/linux/spinlock_api_up.h
@@ -0,0 +1,80 @@
+#ifndef __LINUX_SPINLOCK_API_UP_H
+#define __LINUX_SPINLOCK_API_UP_H
+
+#ifndef __LINUX_SPINLOCK_H
+# error "please don't include this file directly"
+#endif
+
+/*
+ * include/linux/spinlock_api_up.h
+ *
+ * spinlock API implementation on UP-nondebug (inlined implementation)
+ *
+ * portions Copyright 2005, Red Hat, Inc., Ingo Molnar
+ * Released under the General Public License (GPL).
+ */
+
+#define in_lock_functions(ADDR)         0
+
+#define assert_spin_locked(lock)        do { (void)(lock); } while (0)
+
+/*
+ * In the UP-nondebug case there's no real locking going on, so the
+ * only thing we have to do is to keep the preempt counts and irq
+ * flags straight, to supress compiler warnings of unused lock
+ * variables, and to add the proper checker annotations:
+ */
+#define __LOCK(lock) \
+  do { preempt_disable(); __acquire(lock); (void)(lock); } while (0)
+
+#define __LOCK_BH(lock) \
+  do { local_bh_disable(); __LOCK(lock); } while (0)
+
+#define __LOCK_IRQ(lock) \
+  do { local_irq_disable(); __LOCK(lock); } while (0)
+
+#define __LOCK_IRQSAVE(lock, flags) \
+  do { local_irq_save(flags); __LOCK(lock); } while (0)
+
+#define __UNLOCK(lock) \
+  do { preempt_enable(); __release(lock); (void)(lock); } while (0)
+
+#define __UNLOCK_BH(lock) \
+  do { preempt_enable_no_resched(); local_bh_enable(); __release(lock); (void)(lock); } while (0)
+
+#define __UNLOCK_IRQ(lock) \
+  do { local_irq_enable(); __UNLOCK(lock); } while (0)
+
+#define __UNLOCK_IRQRESTORE(lock, flags) \
+  do { local_irq_restore(flags); __UNLOCK(lock); } while (0)
+
+#define _spin_lock(lock)                        __LOCK(lock)
+#define _read_lock(lock)                        __LOCK(lock)
+#define _write_lock(lock)                       __LOCK(lock)
+#define _spin_lock_bh(lock)                     __LOCK_BH(lock)
+#define _read_lock_bh(lock)                     __LOCK_BH(lock)
+#define _write_lock_bh(lock)                    __LOCK_BH(lock)
+#define _spin_lock_irq(lock)                    __LOCK_IRQ(lock)
+#define _read_lock_irq(lock)                    __LOCK_IRQ(lock)
+#define _write_lock_irq(lock)                   __LOCK_IRQ(lock)
+#define _spin_lock_irqsave(lock, flags)         __LOCK_IRQSAVE(lock, flags)
+#define _read_lock_irqsave(lock, flags)         __LOCK_IRQSAVE(lock, flags)
+#define _write_lock_irqsave(lock, flags)        __LOCK_IRQSAVE(lock, flags)
+#define _spin_trylock(lock)                     ({ __LOCK(lock); 1; })
+#define _read_trylock(lock)                     ({ __LOCK(lock); 1; })
+#define _write_trylock(lock)                    ({ __LOCK(lock); 1; })
+#define _spin_trylock_bh(lock)                  ({ __LOCK_BH(lock); 1; })
+#define _spin_unlock(lock)                      __UNLOCK(lock)
+#define _read_unlock(lock)                      __UNLOCK(lock)
+#define _write_unlock(lock)                     __UNLOCK(lock)
+#define _spin_unlock_bh(lock)                   __UNLOCK_BH(lock)
+#define _write_unlock_bh(lock)                  __UNLOCK_BH(lock)
+#define _read_unlock_bh(lock)                   __UNLOCK_BH(lock)
+#define _spin_unlock_irq(lock)                  __UNLOCK_IRQ(lock)
+#define _read_unlock_irq(lock)                  __UNLOCK_IRQ(lock)
+#define _write_unlock_irq(lock)                 __UNLOCK_IRQ(lock)
+#define _spin_unlock_irqrestore(lock, flags)    __UNLOCK_IRQRESTORE(lock, flags)
+#define _read_unlock_irqrestore(lock, flags)    __UNLOCK_IRQRESTORE(lock, flags)
+#define _write_unlock_irqrestore(lock, flags)   __UNLOCK_IRQRESTORE(lock, flags)
+
+#endif /* __LINUX_SPINLOCK_API_UP_H */
diff --git a/include/linux/spinlock_types.h b/include/linux/spinlock_types.h
new file mode 100644
index 000000000000..9cb51e070390
--- /dev/null
+++ b/include/linux/spinlock_types.h
@@ -0,0 +1,67 @@
+#ifndef __LINUX_SPINLOCK_TYPES_H
+#define __LINUX_SPINLOCK_TYPES_H
+
+/*
+ * include/linux/spinlock_types.h - generic spinlock type definitions
+ *                                  and initializers
+ *
+ * portions Copyright 2005, Red Hat, Inc., Ingo Molnar
+ * Released under the General Public License (GPL).
+ */
+
+#if defined(CONFIG_SMP)
+# include <asm/spinlock_types.h>
+#else
+# include <linux/spinlock_types_up.h>
+#endif
+
+typedef struct {
+        raw_spinlock_t raw_lock;
+#if defined(CONFIG_PREEMPT) && defined(CONFIG_SMP)
+        unsigned int break_lock;
+#endif
+#ifdef CONFIG_DEBUG_SPINLOCK
+        unsigned int magic, owner_cpu;
+        void *owner;
+#endif
+} spinlock_t;
+
+#define SPINLOCK_MAGIC          0xdead4ead
+
+typedef struct {
+        raw_rwlock_t raw_lock;
+#if defined(CONFIG_PREEMPT) && defined(CONFIG_SMP)
+        unsigned int break_lock;
+#endif
+#ifdef CONFIG_DEBUG_SPINLOCK
+        unsigned int magic, owner_cpu;
+        void *owner;
+#endif
+} rwlock_t;
+
+#define RWLOCK_MAGIC            0xdeaf1eed
+
+#define SPINLOCK_OWNER_INIT     ((void *)-1L)
+
+#ifdef CONFIG_DEBUG_SPINLOCK
+# define SPIN_LOCK_UNLOCKED                                             \
+        (spinlock_t)    {       .raw_lock = __RAW_SPIN_LOCK_UNLOCKED,   \
+                                .magic = SPINLOCK_MAGIC,                \
+                                .owner = SPINLOCK_OWNER_INIT,           \
+                                .owner_cpu = -1 }
+#define RW_LOCK_UNLOCKED                                                \
+        (rwlock_t)      {       .raw_lock = __RAW_RW_LOCK_UNLOCKED,     \
+                                .magic = RWLOCK_MAGIC,                  \
+                                .owner = SPINLOCK_OWNER_INIT,           \
+                                .owner_cpu = -1 }
+#else
+# define SPIN_LOCK_UNLOCKED \
+        (spinlock_t)    {       .raw_lock = __RAW_SPIN_LOCK_UNLOCKED }
+#define RW_LOCK_UNLOCKED \
+        (rwlock_t)      {       .raw_lock = __RAW_RW_LOCK_UNLOCKED }
+#endif
+
+#define DEFINE_SPINLOCK(x)      spinlock_t x = SPIN_LOCK_UNLOCKED
+#define DEFINE_RWLOCK(x)        rwlock_t x = RW_LOCK_UNLOCKED
+
+#endif /* __LINUX_SPINLOCK_TYPES_H */
diff --git a/include/linux/spinlock_types_up.h b/include/linux/spinlock_types_up.h
new file mode 100644
index 000000000000..def2d173a8db
--- /dev/null
+++ b/include/linux/spinlock_types_up.h
@@ -0,0 +1,51 @@
+#ifndef __LINUX_SPINLOCK_TYPES_UP_H
+#define __LINUX_SPINLOCK_TYPES_UP_H
+
+#ifndef __LINUX_SPINLOCK_TYPES_H
+# error "please don't include this file directly"
+#endif
+
+/*
+ * include/linux/spinlock_types_up.h - spinlock type definitions for UP
+ *
+ * portions Copyright 2005, Red Hat, Inc., Ingo Molnar
+ * Released under the General Public License (GPL).
+ */
+
+#ifdef CONFIG_DEBUG_SPINLOCK
+
+typedef struct {
+        volatile unsigned int slock;
+} raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED { 1 }
+
+#else
+
+/*
+ * All gcc 2.95 versions and early versions of 2.96 have a nasty bug
+ * with empty initializers.
+ */
+#if (__GNUC__ > 2)
+typedef struct { } raw_spinlock_t;
+
+#define __RAW_SPIN_LOCK_UNLOCKED { }
+#else
+typedef struct { int gcc_is_buggy; } raw_spinlock_t;
+#define __RAW_SPIN_LOCK_UNLOCKED (raw_spinlock_t) { 0 }
+#endif
+
+#endif
+
+#if (__GNUC__ > 2)
+typedef struct {
+        /* no debug version on UP */
+} raw_rwlock_t;
+
+#define __RAW_RW_LOCK_UNLOCKED { }
+#else
+typedef struct { int gcc_is_buggy; } raw_rwlock_t;
+#define __RAW_RW_LOCK_UNLOCKED (raw_rwlock_t) { 0 }
+#endif
+
+#endif /* __LINUX_SPINLOCK_TYPES_UP_H */
diff --git a/include/linux/spinlock_up.h b/include/linux/spinlock_up.h
new file mode 100644
index 000000000000..31accf2f0b13
--- /dev/null
+++ b/include/linux/spinlock_up.h
@@ -0,0 +1,74 @@
+#ifndef __LINUX_SPINLOCK_UP_H
+#define __LINUX_SPINLOCK_UP_H
+
+#ifndef __LINUX_SPINLOCK_H
+# error "please don't include this file directly"
+#endif
+
+/*
+ * include/linux/spinlock_up.h - UP-debug version of spinlocks.
+ *
+ * portions Copyright 2005, Red Hat, Inc., Ingo Molnar
+ * Released under the General Public License (GPL).
+ *
+ * In the debug case, 1 means unlocked, 0 means locked. (the values
+ * are inverted, to catch initialization bugs)
+ *
+ * No atomicity anywhere, we are on UP.
+ */
+
+#ifdef CONFIG_DEBUG_SPINLOCK
+
+#define __raw_spin_is_locked(x)         ((x)->slock == 0)
+
+static inline void __raw_spin_lock(raw_spinlock_t *lock)
+{
+        lock->slock = 0;
+}
+
+static inline void
+__raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long flags)
+{
+        local_irq_save(flags);
+        lock->slock = 0;
+}
+
+static inline int __raw_spin_trylock(raw_spinlock_t *lock)
+{
+        char oldval = lock->slock;
+
+        lock->slock = 0;
+
+        return oldval > 0;
+}
+
+static inline void __raw_spin_unlock(raw_spinlock_t *lock)
+{
+        lock->slock = 1;
+}
+
+/*
+ * Read-write spinlocks. No debug version.
+ */
+#define __raw_read_lock(lock)           do { (void)(lock); } while (0)
+#define __raw_write_lock(lock)          do { (void)(lock); } while (0)
+#define __raw_read_trylock(lock)        ({ (void)(lock); 1; })
+#define __raw_write_trylock(lock)       ({ (void)(lock); 1; })
+#define __raw_read_unlock(lock)         do { (void)(lock); } while (0)
+#define __raw_write_unlock(lock)        do { (void)(lock); } while (0)
+
+#else /* DEBUG_SPINLOCK */
+#define __raw_spin_is_locked(lock)      ((void)(lock), 0)
+/* for sched.c and kernel_lock.c: */
+# define __raw_spin_lock(lock)          do { (void)(lock); } while (0)
+# define __raw_spin_unlock(lock)        do { (void)(lock); } while (0)
+# define __raw_spin_trylock(lock)       ({ (void)(lock); 1; })
+#endif /* DEBUG_SPINLOCK */
+
+#define __raw_read_can_lock(lock)       (((void)(lock), 1))
+#define __raw_write_can_lock(lock)      (((void)(lock), 1))
+
+#define __raw_spin_unlock_wait(lock) \
+                do { cpu_relax(); } while (__raw_spin_is_locked(lock))
+
+#endif /* __LINUX_SPINLOCK_UP_H */
diff --git a/include/linux/time.h b/include/linux/time.h
index c10d4c21c183..8e83f4e778bb 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -28,17 +28,10 @@ struct timezone {
 #ifdef __KERNEL__
 
 /* Parameters used to convert the timespec values */
-#ifndef USEC_PER_SEC
+#define MSEC_PER_SEC (1000L)
 #define USEC_PER_SEC (1000000L)
-#endif
-
-#ifndef NSEC_PER_SEC
 #define NSEC_PER_SEC (1000000000L)
-#endif
-
-#ifndef NSEC_PER_USEC
 #define NSEC_PER_USEC (1000L)
-#endif
 
 static __inline__ int timespec_equal(struct timespec *a, struct timespec *b) 
 { 
diff --git a/include/linux/timer.h b/include/linux/timer.h
index 221f81ac2002..3340f3bd135d 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -32,6 +32,10 @@ extern struct timer_base_s __init_timer_base;
                 .magic = TIMER_MAGIC,                           \
         }
 
+#define DEFINE_TIMER(_name, _function, _expires, _data)         \
+        struct timer_list _name =                               \
+                TIMER_INITIALIZER(_function, _expires, _data)
+
 void fastcall init_timer(struct timer_list * timer);
 
 /***
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 59ff42c629ec..1267f88ece6e 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -74,7 +74,8 @@ struct screen_info {
         u16 vesapm_off;         /* 0x30 */
         u16 pages;              /* 0x32 */
         u16 vesa_attributes;    /* 0x34 */
-                                /* 0x36 -- 0x3f reserved for future expansion */
+        u32  capabilities;      /* 0x36 */
+                                /* 0x3a -- 0x3f reserved for future expansion */
 };
 
 extern struct screen_info screen_info;
diff --git a/include/linux/videodev.h b/include/linux/videodev.h
index 9d6fbde3d29c..1cc8c31b7988 100644
--- a/include/linux/videodev.h
+++ b/include/linux/videodev.h
@@ -3,7 +3,6 @@
 
 #include <linux/compiler.h>
 #include <linux/types.h>
-#include <linux/version.h>
 
 #define HAVE_V4L2 1
 #include <linux/videodev2.h>
@@ -29,7 +28,6 @@ struct video_device
         void (*release)(struct video_device *vfd);
 
 
-#if 1 /* to be removed in 2.7.x */
         /* obsolete -- fops->owner is used instead */
         struct module *owner;
         /* dev->driver_data will be used instead some day.
@@ -37,7 +35,6 @@ struct video_device
          * 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} ... */
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index acbfc525576d..f623a33b9abe 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -270,7 +270,6 @@ struct v4l2_timecode
 /* The above is based on SMPTE timecodes */
 
 
-#if 1
 /*
  *      M P E G   C O M P R E S S I O N   P A R A M E T E R S
  *
@@ -357,7 +356,6 @@ struct v4l2_mpeg_compression {
         /* I don't expect the above being perfect yet ;) */
         __u32                           reserved_5[8];
 };
-#endif
 
 struct v4l2_jpegcompression
 {
@@ -871,10 +869,8 @@ struct v4l2_streamparm
 #define VIDIOC_ENUM_FMT         _IOWR ('V',  2, struct v4l2_fmtdesc)
 #define VIDIOC_G_FMT            _IOWR ('V',  4, struct v4l2_format)
 #define VIDIOC_S_FMT            _IOWR ('V',  5, struct v4l2_format)
-#if 1 /* experimental */
 #define VIDIOC_G_MPEGCOMP       _IOR  ('V',  6, struct v4l2_mpeg_compression)
 #define VIDIOC_S_MPEGCOMP       _IOW  ('V',  7, struct v4l2_mpeg_compression)
-#endif
 #define VIDIOC_REQBUFS          _IOWR ('V',  8, struct v4l2_requestbuffers)
 #define VIDIOC_QUERYBUF         _IOWR ('V',  9, struct v4l2_buffer)
 #define VIDIOC_G_FBUF           _IOR  ('V', 10, struct v4l2_framebuffer)
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 542dbaee6512..343d883d69c5 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -109,8 +109,6 @@ int pdflush_operation(void (*fn)(unsigned long), unsigned long arg0);
 int do_writepages(struct address_space *mapping, struct writeback_control *wbc);
 int sync_page_range(struct inode *inode, struct address_space *mapping,
                         loff_t pos, size_t count);
-int sync_page_range_nolock(struct inode *inode, struct address_space
-                *mapping, loff_t pos, size_t count);
 
 /* pdflush.c */
 extern int nr_pdflush_threads;  /* Global so it can be exported to sysctl
diff --git a/include/media/audiochip.h b/include/media/audiochip.h
index cd831168fdc1..a7ceee9fc5e9 100644
--- a/include/media/audiochip.h
+++ b/include/media/audiochip.h
@@ -1,5 +1,4 @@
 /*
- * $Id: audiochip.h,v 1.5 2005/06/16 22:59:16 hhackmann Exp $
  */
 
 #ifndef AUDIOCHIP_H
diff --git a/include/media/id.h b/include/media/id.h
index 801ddef301aa..6d02c94cdc0d 100644
--- a/include/media/id.h
+++ b/include/media/id.h
@@ -1,5 +1,4 @@
 /*
- * $Id: id.h,v 1.4 2005/06/12 04:19:19 mchehab Exp $
  */
 
 /* FIXME: this temporarely, until these are included in linux/i2c-id.h */
diff --git a/include/media/ir-common.h b/include/media/ir-common.h
index 698670547f16..01b56822df4d 100644
--- a/include/media/ir-common.h
+++ b/include/media/ir-common.h
@@ -1,5 +1,4 @@
 /*
- * $Id: ir-common.h,v 1.9 2005/05/15 19:01:26 mchehab Exp $
  *
  * some common structs and functions to handle infrared remotes via
  * input layer ...
@@ -21,11 +20,11 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include <linux/version.h>
 #include <linux/input.h>
 
 
 #define IR_TYPE_RC5     1
+#define IR_TYPE_PD      2 /* Pulse distance encoded IR */
 #define IR_TYPE_OTHER  99
 
 #define IR_KEYTAB_TYPE  u32
@@ -60,6 +59,7 @@ void ir_input_keydown(struct input_dev *dev, struct ir_input_state *ir,
 u32  ir_extract_bits(u32 data, u32 mask);
 int  ir_dump_samples(u32 *samples, int count);
 int  ir_decode_biphase(u32 *samples, int count, int low, int high);
+int  ir_decode_pulsedistance(u32 *samples, int count, int low, int high);
 
 /*
  * Local variables:
diff --git a/include/media/saa7146.h b/include/media/saa7146.h
index 3dfb8d670eb7..2a897c3a6a9a 100644
--- a/include/media/saa7146.h
+++ b/include/media/saa7146.h
@@ -1,7 +1,6 @@
 #ifndef __SAA7146__
 #define __SAA7146__
 
-#include <linux/version.h>      /* for version macros */
 #include <linux/module.h>       /* for module-version */
 #include <linux/delay.h>        /* for delay-stuff */
 #include <linux/slab.h>         /* for kmalloc/kfree */
@@ -15,12 +14,7 @@
 #include <linux/vmalloc.h>      /* for vmalloc() */
 #include <linux/mm.h>           /* for vmalloc_to_page() */
 
-/* ugly, but necessary to build the dvb stuff under 2.4. */
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,51)
-        #include "dvb_functions.h"
-#endif
-
-#define SAA7146_VERSION_CODE KERNEL_VERSION(0,5,0)
+#define SAA7146_VERSION_CODE 0x000500   /* 0.5.0 */
 
 #define saa7146_write(sxy,adr,dat)    writel((dat),(sxy->mem+(adr)))
 #define saa7146_read(sxy,adr)         readl(sxy->mem+(adr))
@@ -33,13 +27,8 @@ extern unsigned int saa7146_debug;
         #define DEBUG_VARIABLE saa7146_debug
 #endif
 
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,51)
-#define DEBUG_PROLOG printk("%s: %s(): ",__stringify(KBUILD_BASENAME),__FUNCTION__)
-#define INFO(x) { printk("%s: ",__stringify(KBUILD_BASENAME)); printk x; }
-#else
 #define DEBUG_PROLOG printk("%s: %s(): ",__stringify(KBUILD_MODNAME),__FUNCTION__)
 #define INFO(x) { printk("%s: ",__stringify(KBUILD_MODNAME)); printk x; }
-#endif
 
 #define ERR(x) { DEBUG_PROLOG; printk x; }
 
diff --git a/include/media/tuner.h b/include/media/tuner.h
index eeaa15ddee85..4ad08e24a1aa 100644
--- a/include/media/tuner.h
+++ b/include/media/tuner.h
@@ -1,6 +1,4 @@
-
-/* $Id: tuner.h,v 1.45 2005/07/28 18:41:21 mchehab Exp $
- *
+/*
     tuner.h - definition for different tuners
 
     Copyright (C) 1997 Markus Schroeder (schroedm@uni-duesseldorf.de)
@@ -28,88 +26,90 @@
 
 #define ADDR_UNSET (255)
 
-#define TUNER_TEMIC_PAL     0        /* 4002 FH5 (3X 7756, 9483) */
-#define TUNER_PHILIPS_PAL_I 1
-#define TUNER_PHILIPS_NTSC  2
-#define TUNER_PHILIPS_SECAM 3           /* you must actively select B/G, L, L` */
-
-#define TUNER_ABSENT        4
-#define TUNER_PHILIPS_PAL   5
-#define TUNER_TEMIC_NTSC    6        /* 4032 FY5 (3X 7004, 9498, 9789)  */
-#define TUNER_TEMIC_PAL_I   7        /* 4062 FY5 (3X 8501, 9957)        */
-
-#define TUNER_TEMIC_4036FY5_NTSC 8   /* 4036 FY5 (3X 1223, 1981, 7686)  */
-#define TUNER_ALPS_TSBH1_NTSC    9
-#define TUNER_ALPS_TSBE1_PAL    10
-#define TUNER_ALPS_TSBB5_PAL_I  11
-
-#define TUNER_ALPS_TSBE5_PAL    12
-#define TUNER_ALPS_TSBC5_PAL    13
-#define TUNER_TEMIC_4006FH5_PAL 14   /* 4006 FH5 (3X 9500, 9501, 7291)     */
-#define TUNER_ALPS_TSHC6_NTSC   15
-
-#define TUNER_TEMIC_PAL_DK      16   /* 4016 FY5 (3X 1392, 1393)     */
-#define TUNER_PHILIPS_NTSC_M    17
-#define TUNER_TEMIC_4066FY5_PAL_I       18  /* 4066 FY5 (3X 7032, 7035) */
-#define TUNER_TEMIC_4006FN5_MULTI_PAL   19  /* B/G, I and D/K autodetected (3X 7595, 7606, 7657)*/
-
-#define TUNER_TEMIC_4009FR5_PAL         20  /* incl. FM radio (3X 7607, 7488, 7711)*/
-#define TUNER_TEMIC_4039FR5_NTSC        21  /* incl. FM radio (3X 7246, 7578, 7732)*/
-#define TUNER_TEMIC_4046FM5             22  /* you must actively select B/G, D/K, I, L, L` !  (3X 7804, 7806, 8103, 8104)*/
+#define TUNER_TEMIC_PAL                 0        /* 4002 FH5 (3X 7756, 9483) */
+#define TUNER_PHILIPS_PAL_I             1
+#define TUNER_PHILIPS_NTSC              2
+#define TUNER_PHILIPS_SECAM             3       /* you must actively select B/G, L, L` */
+
+#define TUNER_ABSENT                    4
+#define TUNER_PHILIPS_PAL               5
+#define TUNER_TEMIC_NTSC                6       /* 4032 FY5 (3X 7004, 9498, 9789)  */
+#define TUNER_TEMIC_PAL_I               7       /* 4062 FY5 (3X 8501, 9957) */
+
+#define TUNER_TEMIC_4036FY5_NTSC        8       /* 4036 FY5 (3X 1223, 1981, 7686) */
+#define TUNER_ALPS_TSBH1_NTSC           9
+#define TUNER_ALPS_TSBE1_PAL            10
+#define TUNER_ALPS_TSBB5_PAL_I          11
+
+#define TUNER_ALPS_TSBE5_PAL            12
+#define TUNER_ALPS_TSBC5_PAL            13
+#define TUNER_TEMIC_4006FH5_PAL         14      /* 4006 FH5 (3X 9500, 9501, 7291) */
+#define TUNER_ALPS_TSHC6_NTSC           15
+
+#define TUNER_TEMIC_PAL_DK              16      /* 4016 FY5 (3X 1392, 1393) */
+#define TUNER_PHILIPS_NTSC_M            17
+#define TUNER_TEMIC_4066FY5_PAL_I       18      /* 4066 FY5 (3X 7032, 7035) */
+#define TUNER_TEMIC_4006FN5_MULTI_PAL   19      /* B/G, I and D/K autodetected (3X 7595, 7606, 7657) */
+
+#define TUNER_TEMIC_4009FR5_PAL         20      /* incl. FM radio (3X 7607, 7488, 7711) */
+#define TUNER_TEMIC_4039FR5_NTSC        21      /* incl. FM radio (3X 7246, 7578, 7732) */
+#define TUNER_TEMIC_4046FM5             22      /* you must actively select B/G, D/K, I, L, L` !  (3X 7804, 7806, 8103, 8104) */
 #define TUNER_PHILIPS_PAL_DK            23
 
-#define TUNER_PHILIPS_FQ1216ME          24  /* you must actively select B/G/D/K, I, L, L` */
-#define TUNER_LG_PAL_I_FM       25
-#define TUNER_LG_PAL_I          26
-#define TUNER_LG_NTSC_FM        27
+#define TUNER_PHILIPS_FQ1216ME          24      /* you must actively select B/G/D/K, I, L, L` */
+#define TUNER_LG_PAL_I_FM               25
+#define TUNER_LG_PAL_I                  26
+#define TUNER_LG_NTSC_FM                27
 
-#define TUNER_LG_PAL_FM         28
-#define TUNER_LG_PAL            29
-#define TUNER_TEMIC_4009FN5_MULTI_PAL_FM        30  /* B/G, I and D/K autodetected (3X 8155, 8160, 8163)*/
-#define TUNER_SHARP_2U5JF5540_NTSC  31
+#define TUNER_LG_PAL_FM                 28
+#define TUNER_LG_PAL                    29
+#define TUNER_TEMIC_4009FN5_MULTI_PAL_FM 30     /* B/G, I and D/K autodetected (3X 8155, 8160, 8163) */
+#define TUNER_SHARP_2U5JF5540_NTSC      31
 
-#define TUNER_Samsung_PAL_TCPM9091PD27 32
-#define TUNER_MT2032 33
-#define TUNER_TEMIC_4106FH5     34      /* 4106 FH5 (3X 7808, 7865)*/
-#define TUNER_TEMIC_4012FY5     35      /* 4012 FY5 (3X 0971, 1099)*/
+#define TUNER_Samsung_PAL_TCPM9091PD27  32
+#define TUNER_MT2032                    33
+#define TUNER_TEMIC_4106FH5             34      /* 4106 FH5 (3X 7808, 7865) */
+#define TUNER_TEMIC_4012FY5             35      /* 4012 FY5 (3X 0971, 1099) */
 
-#define TUNER_TEMIC_4136FY5     36      /* 4136 FY5 (3X 7708, 7746)*/
-#define TUNER_LG_PAL_NEW_TAPC   37
-#define TUNER_PHILIPS_FM1216ME_MK3  38
-#define TUNER_LG_NTSC_NEW_TAPC   39
+#define TUNER_TEMIC_4136FY5             36      /* 4136 FY5 (3X 7708, 7746) */
+#define TUNER_LG_PAL_NEW_TAPC           37
+#define TUNER_PHILIPS_FM1216ME_MK3      38
+#define TUNER_LG_NTSC_NEW_TAPC          39
 
-#define TUNER_HITACHI_NTSC       40
-#define TUNER_PHILIPS_PAL_MK     41
-#define TUNER_PHILIPS_ATSC       42
-#define TUNER_PHILIPS_FM1236_MK3 43
+#define TUNER_HITACHI_NTSC              40
+#define TUNER_PHILIPS_PAL_MK            41
+#define TUNER_PHILIPS_ATSC              42
+#define TUNER_PHILIPS_FM1236_MK3        43
 
-#define TUNER_PHILIPS_4IN1       44     /* ATI TV Wonder Pro - Conexant */
+#define TUNER_PHILIPS_4IN1              44      /* ATI TV Wonder Pro - Conexant */
 /* Microtune mergeged with Temic 12/31/1999 partially financed by Alps - these may be similar to Temic */
-#define TUNER_MICROTUNE_4049FM5  45
-#define TUNER_LG_NTSC_TAPE       47
-
-#define TUNER_TNF_8831BGFF       48
-#define TUNER_MICROTUNE_4042FI5  49     /* DViCO FusionHDTV 3 Gold-Q - 4042 FI5 (3X 8147) */
-#define TUNER_TCL_2002N          50
-#define TUNER_PHILIPS_FM1256_IH3   51
-
-#define TUNER_THOMSON_DTT7610    52
-#define TUNER_PHILIPS_FQ1286     53
-#define TUNER_PHILIPS_TDA8290    54
-#define TUNER_LG_PAL_TAPE        55    /* Hauppauge PVR-150 PAL */
-
-#define TUNER_PHILIPS_FQ1216AME_MK4 56 /* Hauppauge PVR-150 PAL */
-#define TUNER_PHILIPS_FQ1236A_MK4   57   /* Hauppauge PVR-500MCE NTSC */
-
-#define TUNER_YMEC_TVF_8531MF 58
-#define TUNER_YMEC_TVF_5533MF 59        /* Pixelview Pro Ultra NTSC */
-#define TUNER_THOMSON_DTT7611 60        /* DViCO FusionHDTV 3 Gold-T */
-#define TUNER_TENA_9533_DI    61
-
-#define TUNER_TEA5767         62        /* Only FM Radio Tuner */
-#define TUNER_PHILIPS_FMD1216ME_MK3 63
-#define TUNER_LG_TDVS_H062F   64        /* DViCO FusionHDTV 5 */
-#define TUNER_YMEC_TVF66T5_B_DFF 65     /* Acorp Y878F */
+#define TUNER_MICROTUNE_4049FM5         45
+#define TUNER_MICROTUNE_4042_FI5        46
+#define TUNER_LG_NTSC_TAPE              47
+
+#define TUNER_TNF_8831BGFF              48
+#define TUNER_MICROTUNE_4042FI5         49      /* DViCO FusionHDTV 3 Gold-Q - 4042 FI5 (3X 8147) */
+#define TUNER_TCL_2002N                 50
+#define TUNER_PHILIPS_FM1256_IH3        51
+
+#define TUNER_THOMSON_DTT7610           52
+#define TUNER_PHILIPS_FQ1286            53
+#define TUNER_PHILIPS_TDA8290           54
+#define TUNER_LG_PAL_TAPE               55      /* Hauppauge PVR-150 PAL */
+
+#define TUNER_PHILIPS_FQ1216AME_MK4     56      /* Hauppauge PVR-150 PAL */
+#define TUNER_PHILIPS_FQ1236A_MK4       57      /* Hauppauge PVR-500MCE NTSC */
+#define TUNER_YMEC_TVF_8531MF           58
+#define TUNER_YMEC_TVF_5533MF           59      /* Pixelview Pro Ultra NTSC */
+
+#define TUNER_THOMSON_DTT7611           60      /* DViCO FusionHDTV 3 Gold-T */
+#define TUNER_TENA_9533_DI              61
+#define TUNER_TEA5767                   62      /* Only FM Radio Tuner */
+#define TUNER_PHILIPS_FMD1216ME_MK3     63
+
+#define TUNER_LG_TDVS_H062F             64      /* DViCO FusionHDTV 5 */
+#define TUNER_YMEC_TVF66T5_B_DFF        65      /* Acorp Y878F */
+#define TUNER_LG_NTSC_TALN_MINI         66
 
 #define NOTUNER 0
 #define PAL     1       /* PAL_BG */
@@ -117,7 +117,7 @@
 #define NTSC    3
 #define SECAM   4
 #define ATSC    5
-#define RADIO   6
+#define RADIO   6
 
 #define NoTuner 0
 #define Philips 1
@@ -134,6 +134,7 @@
 #define THOMSON 12
 
 #define TUNER_SET_TYPE_ADDR          _IOW('T',3,int)
+#define TUNER_SET_STANDBY            _IOW('T',4,int)
 #define TDA9887_SET_CONFIG           _IOW('t',5,int)
 
 /* tv card specific */
@@ -153,9 +154,6 @@
 
 #ifdef __KERNEL__
 
-#define I2C_ADDR_TDA8290        0x4b
-#define I2C_ADDR_TDA8275        0x61
-
 enum tuner_mode {
         T_UNINITIALIZED = 0,
         T_RADIO         = 1 << V4L2_TUNER_RADIO,
@@ -165,21 +163,21 @@ enum tuner_mode {
 };
 
 struct tuner_setup {
-        unsigned short          addr;
-        unsigned int            type;
-        unsigned int            mode_mask;
+        unsigned short  addr;
+        unsigned int    type;
+        unsigned int    mode_mask;
 };
 
 struct tuner {
         /* device */
         struct i2c_client i2c;
 
-        unsigned int type;            /* chip type */
+        unsigned int type;      /* chip type */
 
-        unsigned int          mode;
-        unsigned int          mode_mask; /* Combination of allowable modes */
+        unsigned int mode;
+        unsigned int mode_mask; /* Combination of allowable modes */
 
-        unsigned int freq;            /* keep track of the current settings */
+        unsigned int freq;      /* keep track of the current settings */
         unsigned int audmode;
         v4l2_std_id  std;
 
@@ -198,6 +196,7 @@ struct tuner {
         void (*radio_freq)(struct i2c_client *c, unsigned int freq);
         int  (*has_signal)(struct i2c_client *c);
         int  (*is_stereo)(struct i2c_client *c);
+        void (*standby)(struct i2c_client *c);
 };
 
 extern unsigned int tuner_debug;
@@ -209,16 +208,20 @@ extern int tea5767_tuner_init(struct i2c_client *c);
 extern int default_tuner_init(struct i2c_client *c);
 extern int tea5767_autodetection(struct i2c_client *c);
 
-#define tuner_warn(fmt, arg...) \
-        dev_printk(KERN_WARNING , &t->i2c.dev , fmt , ## arg)
-#define tuner_info(fmt, arg...) \
-        dev_printk(KERN_INFO , &t->i2c.dev , fmt , ## arg)
-#define tuner_dbg(fmt, arg...) \
-        if (tuner_debug) dev_printk(KERN_DEBUG , &t->i2c.dev , fmt , ## arg)
+#define tuner_warn(fmt, arg...) do {\
+        printk(KERN_WARNING "%s %d-%04x: " fmt, t->i2c.driver->name, \
+                        t->i2c.adapter->nr, t->i2c.addr , ##arg); } while (0)
+#define tuner_info(fmt, arg...) do {\
+        printk(KERN_INFO "%s %d-%04x: " fmt, t->i2c.driver->name, \
+                        t->i2c.adapter->nr, t->i2c.addr , ##arg); } while (0)
+#define tuner_dbg(fmt, arg...) do {\
+        if (tuner_debug) \
+                printk(KERN_DEBUG "%s %d-%04x: " fmt, t->i2c.driver->name, \
+                        t->i2c.adapter->nr, t->i2c.addr , ##arg); } while (0)
 
 #endif /* __KERNEL__ */
 
-#endif
+#endif /* _TUNER_H */
 
 /*
  * Overrides for Emacs so that we follow Linus's tabbing style.
diff --git a/include/media/tveeprom.h b/include/media/tveeprom.h
index 854a2c2f105b..e2035c7da094 100644
--- a/include/media/tveeprom.h
+++ b/include/media/tveeprom.h
@@ -1,18 +1,21 @@
 /*
- * $Id: tveeprom.h,v 1.2 2005/06/12 04:19:19 mchehab Exp $
  */
 
 struct tveeprom {
         u32 has_radio;
+        u32 has_ir;     /* 0: no IR, 1: IR present, 2: unknown */
 
         u32 tuner_type;
         u32 tuner_formats;
 
+        u32 tuner2_type;
+        u32 tuner2_formats;
+
         u32 digitizer;
         u32 digitizer_formats;
 
         u32 audio_processor;
-        /* a_p_fmts? */
+        u32 decoder_processor;
 
         u32 model;
         u32 revision;
@@ -20,7 +23,7 @@ struct tveeprom {
         char rev_str[5];
 };
 
-void tveeprom_hauppauge_analog(struct tveeprom *tvee,
+void tveeprom_hauppauge_analog(struct i2c_client *c, struct tveeprom *tvee,
                                unsigned char *eeprom_data);
 
 int tveeprom_read(struct i2c_client *c, unsigned char *eedata, int len);
diff --git a/include/media/video-buf.h b/include/media/video-buf.h
index ae6da6de98de..ae8d7a000440 100644
--- a/include/media/video-buf.h
+++ b/include/media/video-buf.h
@@ -1,5 +1,4 @@
 /*
- * $Id: video-buf.h,v 1.9 2004/11/07 13:17:15 kraxel Exp $
  *
  * generic helper functions for video4linux capture buffers, to handle
  * memory management and PCI DMA.  Right now bttv + saa7134 use it.
diff --git a/include/pcmcia/ds.h b/include/pcmcia/ds.h
index b707a603351b..cb8b6e6ce66c 100644
--- a/include/pcmcia/ds.h
+++ b/include/pcmcia/ds.h
@@ -151,6 +151,8 @@ struct pcmcia_device {
            uniquely define a pcmcia_device */
         struct pcmcia_socket    *socket;
 
+        char                    *devname;
+
         u8                      device_no;
 
         /* the hardware "function" device; certain subdevices can
diff --git a/include/rdma/ib_cm.h b/include/rdma/ib_cm.h
index 77fe9039209b..5308683c8c41 100644
--- a/include/rdma/ib_cm.h
+++ b/include/rdma/ib_cm.h
@@ -290,6 +290,7 @@ struct ib_cm_id {
         enum ib_cm_lap_state    lap_state;      /* internal CM/debug use */
         __be32                  local_id;
         __be32                  remote_id;
+        u32                     remote_cm_qpn;  /* 1 unless redirected */
 };
 
 /**
diff --git a/include/rdma/ib_mad.h b/include/rdma/ib_mad.h
index fc6b1c18ffc6..53184a38fdf6 100644
--- a/include/rdma/ib_mad.h
+++ b/include/rdma/ib_mad.h
@@ -173,6 +173,27 @@ struct ib_vendor_mad {
         u8                      data[216];
 };
 
+struct ib_class_port_info
+{
+        u8                      base_version;
+        u8                      class_version;
+        __be16                  capability_mask;
+        u8                      reserved[3];
+        u8                      resp_time_value;
+        u8                      redirect_gid[16];
+        __be32                  redirect_tcslfl;
+        __be16                  redirect_lid;
+        __be16                  redirect_pkey;
+        __be32                  redirect_qp;
+        __be32                  redirect_qkey;
+        u8                      trap_gid[16];
+        __be32                  trap_tcslfl;
+        __be16                  trap_lid;
+        __be16                  trap_pkey;
+        __be32                  trap_hlqp;
+        __be32                  trap_qkey;
+};
+
 /**
  * ib_mad_send_buf - MAD data buffer and work request for sends.
  * @mad: References an allocated MAD data buffer.  The size of the data
diff --git a/include/rdma/ib_sa.h b/include/rdma/ib_sa.h
index c022edfc49da..a7555c800ecf 100644
--- a/include/rdma/ib_sa.h
+++ b/include/rdma/ib_sa.h
@@ -46,7 +46,36 @@ enum {
 
         IB_SA_METHOD_GET_TABLE          = 0x12,
         IB_SA_METHOD_GET_TABLE_RESP     = 0x92,
-        IB_SA_METHOD_DELETE             = 0x15
+        IB_SA_METHOD_DELETE             = 0x15,
+        IB_SA_METHOD_DELETE_RESP        = 0x95,
+        IB_SA_METHOD_GET_MULTI          = 0x14,
+        IB_SA_METHOD_GET_MULTI_RESP     = 0x94,
+        IB_SA_METHOD_GET_TRACE_TBL      = 0x13
+};
+
+enum {
+        IB_SA_ATTR_CLASS_PORTINFO    = 0x01,
+        IB_SA_ATTR_NOTICE            = 0x02,
+        IB_SA_ATTR_INFORM_INFO       = 0x03,
+        IB_SA_ATTR_NODE_REC          = 0x11,
+        IB_SA_ATTR_PORT_INFO_REC     = 0x12,
+        IB_SA_ATTR_SL2VL_REC         = 0x13,
+        IB_SA_ATTR_SWITCH_REC        = 0x14,
+        IB_SA_ATTR_LINEAR_FDB_REC    = 0x15,
+        IB_SA_ATTR_RANDOM_FDB_REC    = 0x16,
+        IB_SA_ATTR_MCAST_FDB_REC     = 0x17,
+        IB_SA_ATTR_SM_INFO_REC       = 0x18,
+        IB_SA_ATTR_LINK_REC          = 0x20,
+        IB_SA_ATTR_GUID_INFO_REC     = 0x30,
+        IB_SA_ATTR_SERVICE_REC       = 0x31,
+        IB_SA_ATTR_PARTITION_REC     = 0x33,
+        IB_SA_ATTR_PATH_REC          = 0x35,
+        IB_SA_ATTR_VL_ARB_REC        = 0x36,
+        IB_SA_ATTR_MC_MEMBER_REC     = 0x38,
+        IB_SA_ATTR_TRACE_REC         = 0x39,
+        IB_SA_ATTR_MULTI_PATH_REC    = 0x3a,
+        IB_SA_ATTR_SERVICE_ASSOC_REC = 0x3b,
+        IB_SA_ATTR_INFORM_INFO_REC   = 0xf3
 };
 
 enum ib_sa_selector {
diff --git a/include/rdma/ib_user_cm.h b/include/rdma/ib_user_cm.h
index 72182d16778b..e4d1654276ad 100644
--- a/include/rdma/ib_user_cm.h
+++ b/include/rdma/ib_user_cm.h
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2005 Topspin Communications.  All rights reserved.
+ * Copyright (c) 2005 Intel Corporation.  All rights reserved.
  *
  * This software is available to you under a choice of one of two
  * licenses.  You may choose to be licensed under the terms of the GNU
@@ -37,7 +38,7 @@
 
 #include <linux/types.h>
 
-#define IB_USER_CM_ABI_VERSION 1
+#define IB_USER_CM_ABI_VERSION 2
 
 enum {
         IB_USER_CM_CMD_CREATE_ID,
@@ -60,6 +61,7 @@ enum {
         IB_USER_CM_CMD_SEND_SIDR_REP,
 
         IB_USER_CM_CMD_EVENT,
+        IB_USER_CM_CMD_INIT_QP_ATTR,
 };
 /*
  * command ABI structures.
@@ -71,6 +73,7 @@ struct ib_ucm_cmd_hdr {
 };
 
 struct ib_ucm_create_id {
+        __u64 uid;
         __u64 response;
 };
 
@@ -79,9 +82,14 @@ struct ib_ucm_create_id_resp {
 };
 
 struct ib_ucm_destroy_id {
+        __u64 response;
         __u32 id;
 };
 
+struct ib_ucm_destroy_id_resp {
+        __u32 events_reported;
+};
+
 struct ib_ucm_attr_id {
         __u64 response;
         __u32 id;
@@ -94,6 +102,64 @@ struct ib_ucm_attr_id_resp {
         __be32 remote_id;
 };
 
+struct ib_ucm_init_qp_attr {
+        __u64 response;
+        __u32 id;
+        __u32 qp_state;
+};
+
+struct ib_ucm_ah_attr {
+        __u8    grh_dgid[16];
+        __u32   grh_flow_label;
+        __u16   dlid;
+        __u16   reserved;
+        __u8    grh_sgid_index;
+        __u8    grh_hop_limit;
+        __u8    grh_traffic_class;
+        __u8    sl;
+        __u8    src_path_bits;
+        __u8    static_rate;
+        __u8    is_global;
+        __u8    port_num;
+};
+
+struct ib_ucm_init_qp_attr_resp {
+        __u32   qp_attr_mask;
+        __u32   qp_state;
+        __u32   cur_qp_state;
+        __u32   path_mtu;
+        __u32   path_mig_state;
+        __u32   qkey;
+        __u32   rq_psn;
+        __u32   sq_psn;
+        __u32   dest_qp_num;
+        __u32   qp_access_flags;
+
+        struct ib_ucm_ah_attr   ah_attr;
+        struct ib_ucm_ah_attr   alt_ah_attr;
+
+        /* ib_qp_cap */
+        __u32   max_send_wr;
+        __u32   max_recv_wr;
+        __u32   max_send_sge;
+        __u32   max_recv_sge;
+        __u32   max_inline_data;
+
+        __u16   pkey_index;
+        __u16   alt_pkey_index;
+        __u8    en_sqd_async_notify;
+        __u8    sq_draining;
+        __u8    max_rd_atomic;
+        __u8    max_dest_rd_atomic;
+        __u8    min_rnr_timer;
+        __u8    port_num;
+        __u8    timeout;
+        __u8    retry_cnt;
+        __u8    rnr_retry;
+        __u8    alt_port_num;
+        __u8    alt_timeout;
+};
+
 struct ib_ucm_listen {
         __be64 service_id;
         __be64 service_mask;
@@ -157,6 +223,7 @@ struct ib_ucm_req {
 };
 
 struct ib_ucm_rep {
+        __u64 uid;
         __u64 data;
         __u32 id;
         __u32 qpn;
@@ -232,7 +299,6 @@ struct ib_ucm_event_get {
 };
 
 struct ib_ucm_req_event_resp {
-        __u32                  listen_id;
         /* device */
         /* port */
         struct ib_ucm_path_rec primary_path;
@@ -287,7 +353,6 @@ struct ib_ucm_apr_event_resp {
 };
 
 struct ib_ucm_sidr_req_event_resp {
-        __u32 listen_id;
         /* device */
         /* port */
         __u16 pkey;
@@ -307,6 +372,7 @@ struct ib_ucm_sidr_rep_event_resp {
 #define IB_UCM_PRES_ALTERNATE 0x08
 
 struct ib_ucm_event_resp {
+        __u64 uid;
         __u32 id;
         __u32 event;
         __u32 present;
diff --git a/include/rdma/ib_user_verbs.h b/include/rdma/ib_user_verbs.h
index 7ebb01c8f996..fd85725391a4 100644
--- a/include/rdma/ib_user_verbs.h
+++ b/include/rdma/ib_user_verbs.h
@@ -42,7 +42,7 @@
  * Increment this value if any changes that break userspace ABI
  * compatibility are made.
  */
-#define IB_USER_VERBS_ABI_VERSION       1
+#define IB_USER_VERBS_ABI_VERSION       2
 
 enum {
         IB_USER_VERBS_CMD_QUERY_PARAMS,
@@ -292,7 +292,14 @@ struct ib_uverbs_create_cq_resp {
 };
 
 struct ib_uverbs_destroy_cq {
+        __u64 response;
         __u32 cq_handle;
+        __u32 reserved;
+};
+
+struct ib_uverbs_destroy_cq_resp {
+        __u32 comp_events_reported;
+        __u32 async_events_reported;
 };
 
 struct ib_uverbs_create_qp {
@@ -372,7 +379,13 @@ struct ib_uverbs_modify_qp_resp {
 };
 
 struct ib_uverbs_destroy_qp {
+        __u64 response;
         __u32 qp_handle;
+        __u32 reserved;
+};
+
+struct ib_uverbs_destroy_qp_resp {
+        __u32 events_reported;
 };
 
 struct ib_uverbs_attach_mcast {
@@ -416,7 +429,13 @@ struct ib_uverbs_modify_srq {
 };
 
 struct ib_uverbs_destroy_srq {
+        __u64 response;
         __u32 srq_handle;
+        __u32 reserved;
+};
+
+struct ib_uverbs_destroy_srq_resp {
+        __u32 events_reported;
 };
 
 #endif /* IB_USER_VERBS_H */
diff --git a/include/sound/pcm.h b/include/sound/pcm.h
index 389e8ebe9c19..d6361dab0370 100644
--- a/include/sound/pcm.h
+++ b/include/sound/pcm.h
@@ -910,11 +910,10 @@ int snd_pcm_format_big_endian(snd_pcm_format_t format);
  * Returns 1 if the given PCM format is CPU-endian, 0 if
  * opposite, or a negative error code if endian not specified.
  */
-/* int snd_pcm_format_cpu_endian(snd_pcm_format_t format); */
 #ifdef SNDRV_LITTLE_ENDIAN
-#define snd_pcm_format_cpu_endian       snd_pcm_format_little_endian
+#define snd_pcm_format_cpu_endian(format) snd_pcm_format_little_endian(format)
 #else
-#define snd_pcm_format_cpu_endian       snd_pcm_format_big_endian
+#define snd_pcm_format_cpu_endian(format) snd_pcm_format_big_endian(format)
 #endif
 int snd_pcm_format_width(snd_pcm_format_t format);                      /* in bits */
 int snd_pcm_format_physical_width(snd_pcm_format_t format);             /* in bits */
diff --git a/include/sound/tea575x-tuner.h b/include/sound/tea575x-tuner.h
index ad3c3be33c03..b82e408e758f 100644
--- a/include/sound/tea575x-tuner.h
+++ b/include/sound/tea575x-tuner.h
@@ -34,9 +34,7 @@ struct snd_tea575x_ops {
 struct snd_tea575x {
         snd_card_t *card;
         struct video_device vd;         /* video device */
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)
         struct file_operations fops;
-#endif
         int dev_nr;                     /* requested device number + 1 */
         int vd_registered;              /* video device is registered */
         int tea5759;                    /* 5759 chip is present */
diff --git a/include/video/cyblafb.h b/include/video/cyblafb.h
new file mode 100644
index 000000000000..a9948232b131
--- /dev/null
+++ b/include/video/cyblafb.h
@@ -0,0 +1,171 @@
+
+#ifndef CYBLAFB_DEBUG
+#define CYBLAFB_DEBUG 0
+#endif
+
+#if CYBLAFB_DEBUG
+#define debug(f,a...)   printk("%s:" f,  __FUNCTION__ , ## a);
+#else
+#define debug(f,a...)
+#endif
+
+#define output(f, a...) printk("cyblafb: " f, ## a)
+
+#define Kb      (1024)
+#define Mb      (Kb*Kb)
+
+/* PCI IDS of supported cards temporarily here */
+
+#define CYBERBLADEi1    0x8500
+
+/* these defines are for 'lcd' variable */
+#define LCD_STRETCH     0
+#define LCD_CENTER      1
+#define LCD_BIOS        2
+
+/* display types */
+#define DISPLAY_CRT     0
+#define DISPLAY_FP      1
+
+#define ROP_S   0xCC
+
+#define point(x,y) ((y)<<16|(x))
+
+//
+// Attribute Regs, ARxx, 3c0/3c1
+//
+#define AR00    0x00
+#define AR01    0x01
+#define AR02    0x02
+#define AR03    0x03
+#define AR04    0x04
+#define AR05    0x05
+#define AR06    0x06
+#define AR07    0x07
+#define AR08    0x08
+#define AR09    0x09
+#define AR0A    0x0A
+#define AR0B    0x0B
+#define AR0C    0x0C
+#define AR0D    0x0D
+#define AR0E    0x0E
+#define AR0F    0x0F
+#define AR10    0x10
+#define AR12    0x12
+#define AR13    0x13
+
+//
+// Sequencer Regs, SRxx, 3c4/3c5
+//
+#define SR00    0x00
+#define SR01    0x01
+#define SR02    0x02
+#define SR03    0x03
+#define SR04    0x04
+#define SR0D    0x0D
+#define SR0E    0x0E
+#define SR11    0x11
+#define SR18    0x18
+#define SR19    0x19
+
+//
+//
+//
+#define CR00    0x00
+#define CR01    0x01
+#define CR02    0x02
+#define CR03    0x03
+#define CR04    0x04
+#define CR05    0x05
+#define CR06    0x06
+#define CR07    0x07
+#define CR08    0x08
+#define CR09    0x09
+#define CR0A    0x0A
+#define CR0B    0x0B
+#define CR0C    0x0C
+#define CR0D    0x0D
+#define CR0E    0x0E
+#define CR0F    0x0F
+#define CR10    0x10
+#define CR11    0x11
+#define CR12    0x12
+#define CR13    0x13
+#define CR14    0x14
+#define CR15    0x15
+#define CR16    0x16
+#define CR17    0x17
+#define CR18    0x18
+#define CR19    0x19
+#define CR1A    0x1A
+#define CR1B    0x1B
+#define CR1C    0x1C
+#define CR1D    0x1D
+#define CR1E    0x1E
+#define CR1F    0x1F
+#define CR20    0x20
+#define CR21    0x21
+#define CR27    0x27
+#define CR29    0x29
+#define CR2A    0x2A
+#define CR2B    0x2B
+#define CR2D    0x2D
+#define CR2F    0x2F
+#define CR36    0x36
+#define CR38    0x38
+#define CR39    0x39
+#define CR3A    0x3A
+#define CR55    0x55
+#define CR56    0x56
+#define CR57    0x57
+#define CR58    0x58
+
+//
+//
+//
+
+#define GR00    0x01
+#define GR01    0x01
+#define GR02    0x02
+#define GR03    0x03
+#define GR04    0x04
+#define GR05    0x05
+#define GR06    0x06
+#define GR07    0x07
+#define GR08    0x08
+#define GR0F    0x0F
+#define GR20    0x20
+#define GR23    0x23
+#define GR2F    0x2F
+#define GR30    0x30
+#define GR31    0x31
+#define GR33    0x33
+#define GR52    0x52
+#define GR53    0x53
+#define GR5D    0x5d
+
+
+//
+// Graphics Engine
+//
+#define GEBase  0x2100          // could be mapped elsewhere if we like it
+#define GE00    (GEBase+0x00)   // source 1, p 111
+#define GE04    (GEBase+0x04)   // source 2, p 111
+#define GE08    (GEBase+0x08)   // destination 1, p 111
+#define GE0C    (GEBase+0x0C)   // destination 2, p 112
+#define GE20    (GEBase+0x20)   // engine status, p 113
+#define GE24    (GEBase+0x24)   // reset all GE pointers
+#define GE44    (GEBase+0x44)   // command register, p 126
+#define GE48    (GEBase+0x48)   // raster operation, p 127
+#define GE60    (GEBase+0x60)   // foreground color, p 128
+#define GE64    (GEBase+0x64)   // background color, p 128
+#define GE6C    (GEBase+0x6C)   // Pattern and Style, p 129, ok
+#define GE9C    (GEBase+0x9C)   // pixel engine data port, p 125
+#define GEB8    (GEBase+0xB8)   // Destination Stride / Buffer Base 0, p 133
+#define GEBC    (GEBase+0xBC)   // Destination Stride / Buffer Base 1, p 133
+#define GEC0    (GEBase+0xC0)   // Destination Stride / Buffer Base 2, p 133
+#define GEC4    (GEBase+0xC4)   // Destination Stride / Buffer Base 3, p 133
+#define GEC8    (GEBase+0xC8)   // Source Stride / Buffer Base 0, p 133
+#define GECC    (GEBase+0xCC)   // Source Stride / Buffer Base 1, p 133
+#define GED0    (GEBase+0xD0)   // Source Stride / Buffer Base 2, p 133
+#define GED4    (GEBase+0xD4)   // Source Stride / Buffer Base 3, p 133
diff --git a/include/video/sisfb.h b/include/video/sisfb.h
index 136bf791643d..e402eb5b3c7a 100644
--- a/include/video/sisfb.h
+++ b/include/video/sisfb.h
@@ -1,5 +1,7 @@
 /*
- * Copyright (C) 2001-2004 by Thomas Winischhofer, Vienna, Austria.
+ * sisfb.h - definitions for the SiS framebuffer driver
+ *
+ * Copyright (C) 2001-2005 by Thomas Winischhofer, Vienna, Austria.
  *
  * 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
@@ -16,8 +18,8 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA
  */
 
-#ifndef _LINUX_SISFB
-#define _LINUX_SISFB
+#ifndef _LINUX_SISFB_H_
+#define _LINUX_SISFB_H_
 
 #include <asm/ioctl.h>
 #include <asm/types.h>
@@ -26,47 +28,35 @@
 /*                   PUBLIC                   */
 /**********************************************/
 
-/* vbflags */
-#define CRT2_DEFAULT            0x00000001
-#define CRT2_LCD                0x00000002  /* TW: Never change the order of the CRT2_XXX entries */
-#define CRT2_TV                 0x00000004  /*     (see SISCycleCRT2Type())                       */
-#define CRT2_VGA                0x00000008
-#define TV_NTSC                 0x00000010
-#define TV_PAL                  0x00000020
-#define TV_HIVISION             0x00000040
-#define TV_YPBPR                0x00000080
-#define TV_AVIDEO               0x00000100
-#define TV_SVIDEO               0x00000200
-#define TV_SCART                0x00000400
-#define VB_CONEXANT             0x00000800      /* 661 series only */
-#define VB_TRUMPION             VB_CONEXANT     /* 300 series only */
-#define TV_PALM                 0x00001000
-#define TV_PALN                 0x00002000
+/* vbflags, public (others in sis.h) */
+#define CRT2_DEFAULT            0x00000001
+#define CRT2_LCD                0x00000002
+#define CRT2_TV                 0x00000004
+#define CRT2_VGA                0x00000008
+#define TV_NTSC                 0x00000010
+#define TV_PAL                  0x00000020
+#define TV_HIVISION             0x00000040
+#define TV_YPBPR                0x00000080
+#define TV_AVIDEO               0x00000100
+#define TV_SVIDEO               0x00000200
+#define TV_SCART                0x00000400
+#define TV_PALM                 0x00001000
+#define TV_PALN                 0x00002000
 #define TV_NTSCJ                0x00001000
-#define VB_302ELV               0x00004000
-#define TV_CHSCART              0x00008000
-#define TV_CHYPBPR525I          0x00010000
+#define TV_CHSCART              0x00008000
+#define TV_CHYPBPR525I          0x00010000
 #define CRT1_VGA                0x00000000
 #define CRT1_LCDA               0x00020000
 #define VGA2_CONNECTED          0x00040000
-#define VB_DISPTYPE_CRT1        0x00080000      /* CRT1 connected and used */
-#define VB_301                  0x00100000      /* Video bridge type */
-#define VB_301B                 0x00200000
-#define VB_302B                 0x00400000
-#define VB_30xBDH               0x00800000      /* 30xB DH version (w/o LCD support) */
-#define VB_LVDS                 0x01000000
-#define VB_CHRONTEL             0x02000000
-#define VB_301LV                0x04000000
-#define VB_302LV                0x08000000
-#define VB_301C                 0x10000000
-#define VB_SINGLE_MODE          0x20000000      /* CRT1 or CRT2; determined by DISPTYPE_CRTx */
-#define VB_MIRROR_MODE          0x40000000      /* CRT1 + CRT2 identical (mirror mode) */
-#define VB_DUALVIEW_MODE        0x80000000      /* CRT1 + CRT2 independent (dual head mode) */
+#define VB_DISPTYPE_CRT1        0x00080000      /* CRT1 connected and used */
+#define VB_SINGLE_MODE          0x20000000      /* CRT1 or CRT2; determined by DISPTYPE_CRTx */
+#define VB_MIRROR_MODE          0x40000000      /* CRT1 + CRT2 identical (mirror mode) */
+#define VB_DUALVIEW_MODE        0x80000000      /* CRT1 + CRT2 independent (dual head mode) */
 
 /* Aliases: */
 #define CRT2_ENABLE             (CRT2_LCD | CRT2_TV | CRT2_VGA)
-#define TV_STANDARD             (TV_NTSC | TV_PAL | TV_PALM | TV_PALN | TV_NTSCJ)
-#define TV_INTERFACE            (TV_AVIDEO|TV_SVIDEO|TV_SCART|TV_HIVISION|TV_YPBPR|TV_CHSCART|TV_CHYPBPR525I)
+#define TV_STANDARD             (TV_NTSC | TV_PAL | TV_PALM | TV_PALN | TV_NTSCJ)
+#define TV_INTERFACE            (TV_AVIDEO|TV_SVIDEO|TV_SCART|TV_HIVISION|TV_YPBPR|TV_CHSCART|TV_CHYPBPR525I)
 
 /* Only if TV_YPBPR is set: */
 #define TV_YPBPR525I            TV_NTSC
@@ -75,89 +65,118 @@
 #define TV_YPBPR1080I           TV_PALN
 #define TV_YPBPRALL             (TV_YPBPR525I | TV_YPBPR525P | TV_YPBPR750P | TV_YPBPR1080I)
 
-#define VB_SISBRIDGE            (VB_301|VB_301B|VB_301C|VB_302B|VB_301LV|VB_302LV|VB_302ELV)
-#define VB_SISTVBRIDGE          (VB_301|VB_301B|VB_301C|VB_302B|VB_301LV|VB_302LV)
-#define VB_VIDEOBRIDGE          (VB_SISBRIDGE | VB_LVDS | VB_CHRONTEL | VB_CONEXANT)
-
 #define VB_DISPTYPE_DISP2       CRT2_ENABLE
 #define VB_DISPTYPE_CRT2        CRT2_ENABLE
 #define VB_DISPTYPE_DISP1       VB_DISPTYPE_CRT1
 #define VB_DISPMODE_SINGLE      VB_SINGLE_MODE
 #define VB_DISPMODE_MIRROR      VB_MIRROR_MODE
 #define VB_DISPMODE_DUAL        VB_DUALVIEW_MODE
-#define VB_DISPLAY_MODE         (SINGLE_MODE | MIRROR_MODE | DUALVIEW_MODE)
+#define VB_DISPLAY_MODE         (SINGLE_MODE | MIRROR_MODE | DUALVIEW_MODE)
 
 /* Structure argument for SISFB_GET_INFO ioctl  */
-typedef struct _SISFB_INFO sisfb_info, *psisfb_info;
-
-struct _SISFB_INFO {
-        __u32   sisfb_id;               /* for identifying sisfb */
+struct sisfb_info {
+        __u32   sisfb_id;               /* for identifying sisfb */
 #ifndef SISFB_ID
 #define SISFB_ID          0x53495346    /* Identify myself with 'SISF' */
 #endif
-        __u32   chip_id;                /* PCI-ID of detected chip */
-        __u32   memory;                 /* video memory in KB which sisfb manages */
-        __u32   heapstart;              /* heap start (= sisfb "mem" argument) in KB */
+        __u32   chip_id;                /* PCI-ID of detected chip */
+        __u32   memory;                 /* total video memory in KB */
+        __u32   heapstart;              /* heap start offset in KB */
         __u8    fbvidmode;              /* current sisfb mode */
 
-        __u8    sisfb_version;
-        __u8    sisfb_revision;
-        __u8    sisfb_patchlevel;
+        __u8    sisfb_version;
+        __u8    sisfb_revision;
+        __u8    sisfb_patchlevel;
 
-        __u8    sisfb_caps;             /* sisfb capabilities */
+        __u8    sisfb_caps;             /* sisfb capabilities */
 
         __u32   sisfb_tqlen;            /* turbo queue length (in KB) */
 
-        __u32   sisfb_pcibus;           /* The card's PCI ID */
-        __u32   sisfb_pcislot;
-        __u32   sisfb_pcifunc;
+        __u32   sisfb_pcibus;           /* The card's PCI ID */
+        __u32   sisfb_pcislot;
+        __u32   sisfb_pcifunc;
+
+        __u8    sisfb_lcdpdc;           /* PanelDelayCompensation */
+
+        __u8    sisfb_lcda;             /* Detected status of LCDA for low res/text modes */
+
+        __u32   sisfb_vbflags;
+        __u32   sisfb_currentvbflags;
+
+        __u32   sisfb_scalelcd;
+        __u32   sisfb_specialtiming;
+
+        __u8    sisfb_haveemi;
+        __u8    sisfb_emi30,sisfb_emi31,sisfb_emi32,sisfb_emi33;
+        __u8    sisfb_haveemilcd;
 
-        __u8    sisfb_lcdpdc;           /* PanelDelayCompensation */
+        __u8    sisfb_lcdpdca;          /* PanelDelayCompensation for LCD-via-CRT1 */
 
-        __u8    sisfb_lcda;             /* Detected status of LCDA for low res/text modes */
+        __u16   sisfb_tvxpos, sisfb_tvypos;     /* Warning: Values + 32 ! */
 
-        __u32   sisfb_vbflags;
-        __u32   sisfb_currentvbflags;
+        __u32   sisfb_heapsize;         /* heap size (in KB) */
+        __u32   sisfb_videooffset;      /* Offset of viewport in video memory (in bytes) */
 
-        __u32   sisfb_scalelcd;
-        __u32   sisfb_specialtiming;
+        __u32   sisfb_curfstn;          /* currently running FSTN/DSTN mode */
+        __u32   sisfb_curdstn;
 
-        __u8    sisfb_haveemi;
-        __u8    sisfb_emi30,sisfb_emi31,sisfb_emi32,sisfb_emi33;
-        __u8    sisfb_haveemilcd;
+        __u16   sisfb_pci_vendor;       /* PCI vendor (SiS or XGI) */
 
-        __u8    sisfb_lcdpdca;          /* PanelDelayCompensation for LCD-via-CRT1 */
+        __u32   sisfb_vbflags2;         /* ivideo->vbflags2 */
 
-        __u16   sisfb_tvxpos, sisfb_tvypos;  /* Warning: Values + 32 ! */
+        __u8    sisfb_can_post;         /* sisfb can POST this card */
+        __u8    sisfb_card_posted;      /* card is POSTED */
+        __u8    sisfb_was_boot_device;  /* This card was the boot video device (ie is primary) */
 
-        __u8    reserved[208];          /* for future use */
+        __u8    reserved[183];          /* for future use */
+};
+
+#define SISFB_CMD_GETVBFLAGS    0x55AA0001      /* no arg; result[1] = vbflags */
+#define SISFB_CMD_SWITCHCRT1    0x55AA0010      /* arg[0]: 99 = query, 0 = off, 1 = on */
+/* more to come */
+
+#define SISFB_CMD_ERR_OK        0x80000000      /* command succeeded */
+#define SISFB_CMD_ERR_LOCKED    0x80000001      /* sisfb is locked */
+#define SISFB_CMD_ERR_EARLY     0x80000002      /* request before sisfb took over gfx system */
+#define SISFB_CMD_ERR_NOVB      0x80000003      /* No video bridge */
+#define SISFB_CMD_ERR_NOCRT2    0x80000004      /* can't change CRT1 status, CRT2 disabled */
+/* more to come */
+#define SISFB_CMD_ERR_UNKNOWN   0x8000ffff      /* Unknown command */
+#define SISFB_CMD_ERR_OTHER     0x80010000      /* Other error */
+
+/* Argument for SISFB_CMD ioctl */
+struct sisfb_cmd {
+        __u32  sisfb_cmd;
+        __u32  sisfb_arg[16];
+        __u32  sisfb_result[4];
 };
 
 /* Addtional IOCTLs for communication sisfb <> X driver                */
 /* If changing this, vgatypes.h must also be changed (for X driver)    */
 
 /* ioctl for identifying and giving some info (esp. memory heap start) */
-#define SISFB_GET_INFO_SIZE     _IOR(0xF3,0x00,__u32)
-#define SISFB_GET_INFO          _IOR(0xF3,0x01,struct _SISFB_INFO)
+#define SISFB_GET_INFO_SIZE     _IOR(0xF3,0x00,__u32)
+#define SISFB_GET_INFO          _IOR(0xF3,0x01,struct sisfb_info)
 
 /* ioctrl to get current vertical retrace status */
-#define SISFB_GET_VBRSTATUS     _IOR(0xF3,0x02,__u32)
+#define SISFB_GET_VBRSTATUS     _IOR(0xF3,0x02,__u32)
 
 /* ioctl to enable/disable panning auto-maximize (like nomax parameter) */
-#define SISFB_GET_AUTOMAXIMIZE  _IOR(0xF3,0x03,__u32)
-#define SISFB_SET_AUTOMAXIMIZE  _IOW(0xF3,0x03,__u32)
+#define SISFB_GET_AUTOMAXIMIZE  _IOR(0xF3,0x03,__u32)
+#define SISFB_SET_AUTOMAXIMIZE  _IOW(0xF3,0x03,__u32)
 
 /* ioctls to relocate TV output (x=D[31:16], y=D[15:0], + 32)*/
-#define SISFB_GET_TVPOSOFFSET   _IOR(0xF3,0x04,__u32)
-#define SISFB_SET_TVPOSOFFSET   _IOW(0xF3,0x04,__u32)
+#define SISFB_GET_TVPOSOFFSET   _IOR(0xF3,0x04,__u32)
+#define SISFB_SET_TVPOSOFFSET   _IOW(0xF3,0x04,__u32)
+
+/* ioctl for internal sisfb commands (sisfbctrl) */
+#define SISFB_COMMAND           _IOWR(0xF3,0x05,struct sisfb_cmd)
 
 /* ioctl for locking sisfb (no register access during lock) */
 /* As of now, only used to avoid register access during
  * the ioctls listed above.
  */
-#define SISFB_SET_LOCK          _IOW(0xF3,0x06,__u32)
-
-/* more to come soon */
+#define SISFB_SET_LOCK          _IOW(0xF3,0x06,__u32)
 
 /* ioctls 0xF3 up to 0x3F reserved for sisfb */
 
@@ -165,7 +184,7 @@ struct _SISFB_INFO {
 /* The following are deprecated and should not be used anymore: */
 /****************************************************************/
 /* ioctl for identifying and giving some info (esp. memory heap start) */
-#define SISFB_GET_INFO_OLD         _IOR('n',0xF8,__u32)
+#define SISFB_GET_INFO_OLD         _IOR('n',0xF8,__u32)
 /* ioctrl to get current vertical retrace status */
 #define SISFB_GET_VBRSTATUS_OLD    _IOR('n',0xF9,__u32)
 /* ioctl to enable/disable panning auto-maximize (like nomax parameter) */
@@ -177,8 +196,8 @@ struct _SISFB_INFO {
 
 /* For fb memory manager (FBIO_ALLOC, FBIO_FREE) */
 struct sis_memreq {
-        __u32   offset;
-        __u32   size;
+        __u32   offset;
+        __u32   size;
 };
 
 /**********************************************/
@@ -187,12 +206,19 @@ struct sis_memreq {
 /**********************************************/
 
 #ifdef __KERNEL__
+
+#include <linux/pci.h>
+
 #define UNKNOWN_VGA  0
 #define SIS_300_VGA  1
 #define SIS_315_VGA  2
 
+#define SISFB_HAVE_MALLOC_NEW
 extern void sis_malloc(struct sis_memreq *req);
+extern void sis_malloc_new(struct pci_dev *pdev, struct sis_memreq *req);
+
 extern void sis_free(u32 base);
+extern void sis_free_new(struct pci_dev *pdev, u32 base);
 #endif
 
 #endif