Merge branch 'master' of /home/trondmy/kernel/linux-2.6/

Conflicts:

	include/linux/nfs_fs.h

Fixed up conflict with kernel header updates.

1170 files changed, 25232 insertions, 10442 deletions

diff --git a/Documentation/arm/Sharp-LH/ADC-LH7-Touchscreen b/Documentation/arm/Sharp-LH/ADC-LH7-Touchscreen
new file mode 100644
index 000000000000..1e6a23fdf2fc
--- /dev/null
+++ b/Documentation/arm/Sharp-LH/ADC-LH7-Touchscreen
@@ -0,0 +1,61 @@
+README on the ADC/Touchscreen Controller
+========================================
+
+The LH79524 and LH7A404 include a built-in Analog to Digital
+controller (ADC) that is used to process input from a touchscreen.
+The driver only implements a four-wire touch panel protocol.
+
+The touchscreen driver is maintenance free except for the pen-down or
+touch threshold.  Some resistive displays and board combinations may
+require tuning of this threshold.  The driver exposes some of it's
+internal state in the sys filesystem.  If the kernel is configured
+with it, CONFIG_SYSFS, and sysfs is mounted at /sys, there will be a
+directory
+
+  /sys/devices/platform/adc-lh7.0
+
+containing these files.
+
+  -r--r--r--    1 root     root         4096 Jan  1 00:00 samples
+  -rw-r--r--    1 root     root         4096 Jan  1 00:00 threshold
+  -r--r--r--    1 root     root         4096 Jan  1 00:00 threshold_range
+
+The threshold is the current touch threshold.  It defaults to 750 on
+most targets.
+
+  # cat threshold
+ 750
+
+The threshold_range contains the range of valid values for the
+threshold.  Values outside of this range will be silently ignored.
+
+  # cat threshold_range
+  0 1023
+
+To change the threshold, write a value to the threshold file.
+
+  # echo 500 > threshold
+  # cat threshold
+  500
+
+The samples file contains the most recently sampled values from the
+ADC.  There are 12.  Below are typical of the last sampled values when
+the pen has been released.  The first two and last two samples are for
+detecting whether or not the pen is down.  The third through sixth are
+X coordinate samples.  The seventh through tenth are Y coordinate
+samples.
+
+  # cat samples
+  1023 1023 0 0 0 0 530 529 530 529 1023 1023
+
+To determine a reasonable threshold, press on the touch panel with an
+appropriate stylus and read the values from samples.
+
+  # cat samples
+  1023 676 92 103 101 102 855 919 922 922 1023 679
+
+The first and eleventh samples are discarded.  Thus, the important
+values are the second and twelfth which are used to determine if the
+pen is down.  When both are below the threshold, the driver registers
+that the pen is down.  When either is above the threshold, it
+registers then pen is up.
diff --git a/Documentation/arm/Sharp-LH/LCDPanels b/Documentation/arm/Sharp-LH/LCDPanels
new file mode 100644
index 000000000000..fb1b21c2f2f4
--- /dev/null
+++ b/Documentation/arm/Sharp-LH/LCDPanels
@@ -0,0 +1,59 @@
+README on the LCD Panels
+========================
+
+Configuration options for several LCD panels, available from Logic PD,
+are included in the kernel source.  This README will help you
+understand the configuration data and give you some guidance for
+adding support for other panels if you wish.
+
+
+lcd-panels.h
+------------
+
+There is no way, at present, to detect which panel is attached to the
+system at runtime.  Thus the kernel configuration is static.  The file
+arch/arm/mach-ld7a40x/lcd-panels.h (or similar) defines all of the
+panel specific parameters.
+
+It should be possible for this data to be shared among several device
+families.  The current layout may be insufficiently general, but it is
+amenable to improvement.
+
+
+PIXEL_CLOCK
+-----------
+
+The panel data sheets will give a range of acceptable pixel clocks.
+The fundamental LCDCLK input frequency is divided down by a PCD
+constant in field '.tim2'.  It may happen that it is impossible to set
+the pixel clock within this range.  A clock which is too slow will
+tend to flicker.  For the highest quality image, set the clock as high
+as possible.
+
+
+MARGINS
+-------
+
+These values may be difficult to glean from the panel data sheet.  In
+the case of the Sharp panels, the upper margin is explicitly called
+out as a specific number of lines from the top of the frame.  The
+other values may not matter as much as the panels tend to
+automatically center the image.
+
+
+Sync Sense
+----------
+
+The sense of the hsync and vsync pulses may be called out in the data
+sheet.  On one panel, the sense of these pulses determine the height
+of the visible region on the panel.  Most of the Sharp panels use
+negative sense sync pulses set by the TIM2_IHS and TIM2_IVS bits in
+'.tim2'.
+
+
+Pel Layout
+----------
+
+The Sharp color TFT panels are all configured for 16 bit direct color
+modes.  The amba-lcd driver sets the pel mode to 565 for 5 bits of
+each red and blue and 6 bits of green.
diff --git a/Documentation/filesystems/inotify.txt b/Documentation/filesystems/inotify.txt
index 6d501903f68e..59a919f16144 100644
--- a/Documentation/filesystems/inotify.txt
+++ b/Documentation/filesystems/inotify.txt
@@ -69,17 +69,135 @@ Prototypes:
         int inotify_rm_watch (int fd, __u32 mask);
 
 
-(iii) Internal Kernel Implementation
+(iii) Kernel Interface
 
-Each inotify instance is associated with an inotify_device structure.
+Inotify's kernel API consists a set of functions for managing watches and an
+event callback.
+
+To use the kernel API, you must first initialize an inotify instance with a set
+of inotify_operations.  You are given an opaque inotify_handle, which you use
+for any further calls to inotify.
+
+    struct inotify_handle *ih = inotify_init(my_event_handler);
+
+You must provide a function for processing events and a function for destroying
+the inotify watch.
+
+    void handle_event(struct inotify_watch *watch, u32 wd, u32 mask,
+                      u32 cookie, const char *name, struct inode *inode)
+
+        watch - the pointer to the inotify_watch that triggered this call
+        wd - the watch descriptor
+        mask - describes the event that occurred
+        cookie - an identifier for synchronizing events
+        name - the dentry name for affected files in a directory-based event
+        inode - the affected inode in a directory-based event
+
+    void destroy_watch(struct inotify_watch *watch)
+
+You may add watches by providing a pre-allocated and initialized inotify_watch
+structure and specifying the inode to watch along with an inotify event mask.
+You must pin the inode during the call.  You will likely wish to embed the
+inotify_watch structure in a structure of your own which contains other
+information about the watch.  Once you add an inotify watch, it is immediately
+subject to removal depending on filesystem events.  You must grab a reference if
+you depend on the watch hanging around after the call.
+
+    inotify_init_watch(&my_watch->iwatch);
+    inotify_get_watch(&my_watch->iwatch);       // optional
+    s32 wd = inotify_add_watch(ih, &my_watch->iwatch, inode, mask);
+    inotify_put_watch(&my_watch->iwatch);       // optional
+
+You may use the watch descriptor (wd) or the address of the inotify_watch for
+other inotify operations.  You must not directly read or manipulate data in the
+inotify_watch.  Additionally, you must not call inotify_add_watch() more than
+once for a given inotify_watch structure, unless you have first called either
+inotify_rm_watch() or inotify_rm_wd().
+
+To determine if you have already registered a watch for a given inode, you may
+call inotify_find_watch(), which gives you both the wd and the watch pointer for
+the inotify_watch, or an error if the watch does not exist.
+
+    wd = inotify_find_watch(ih, inode, &watchp);
+
+You may use container_of() on the watch pointer to access your own data
+associated with a given watch.  When an existing watch is found,
+inotify_find_watch() bumps the refcount before releasing its locks.  You must
+put that reference with:
+
+    put_inotify_watch(watchp);
+
+Call inotify_find_update_watch() to update the event mask for an existing watch.
+inotify_find_update_watch() returns the wd of the updated watch, or an error if
+the watch does not exist.
+
+    wd = inotify_find_update_watch(ih, inode, mask);
+
+An existing watch may be removed by calling either inotify_rm_watch() or
+inotify_rm_wd().
+
+    int ret = inotify_rm_watch(ih, &my_watch->iwatch);
+    int ret = inotify_rm_wd(ih, wd);
+
+A watch may be removed while executing your event handler with the following:
+
+    inotify_remove_watch_locked(ih, iwatch);
+
+Call inotify_destroy() to remove all watches from your inotify instance and
+release it.  If there are no outstanding references, inotify_destroy() will call
+your destroy_watch op for each watch.
+
+    inotify_destroy(ih);
+
+When inotify removes a watch, it sends an IN_IGNORED event to your callback.
+You may use this event as an indication to free the watch memory.  Note that
+inotify may remove a watch due to filesystem events, as well as by your request.
+If you use IN_ONESHOT, inotify will remove the watch after the first event, at
+which point you may call the final inotify_put_watch.
+
+(iv) Kernel Interface Prototypes
+
+        struct inotify_handle *inotify_init(struct inotify_operations *ops);
+
+        inotify_init_watch(struct inotify_watch *watch);
+
+        s32 inotify_add_watch(struct inotify_handle *ih,
+                              struct inotify_watch *watch,
+                              struct inode *inode, u32 mask);
+
+        s32 inotify_find_watch(struct inotify_handle *ih, struct inode *inode,
+                               struct inotify_watch **watchp);
+
+        s32 inotify_find_update_watch(struct inotify_handle *ih,
+                                      struct inode *inode, u32 mask);
+
+        int inotify_rm_wd(struct inotify_handle *ih, u32 wd);
+
+        int inotify_rm_watch(struct inotify_handle *ih,
+                             struct inotify_watch *watch);
+
+        void inotify_remove_watch_locked(struct inotify_handle *ih,
+                                         struct inotify_watch *watch);
+
+        void inotify_destroy(struct inotify_handle *ih);
+
+        void get_inotify_watch(struct inotify_watch *watch);
+        void put_inotify_watch(struct inotify_watch *watch);
+
+
+(v) Internal Kernel Implementation
+
+Each inotify instance is represented by an inotify_handle structure.
+Inotify's userspace consumers also have an inotify_device which is
+associated with the inotify_handle, and on which events are queued.
 
 Each watch is associated with an inotify_watch structure.  Watches are chained
-off of each associated device and each associated inode.
+off of each associated inotify_handle and each associated inode.
 
-See fs/inotify.c for the locking and lifetime rules.
+See fs/inotify.c and fs/inotify_user.c for the locking and lifetime rules.
 
 
-(iv) Rationale
+(vi) Rationale
 
 Q: What is the design decision behind not tying the watch to the open fd of
    the watched object?
@@ -145,7 +263,7 @@ A: The poor user-space interface is the second biggest problem with dnotify.
    file descriptor-based one that allows basic file I/O and poll/select.
    Obtaining the fd and managing the watches could have been done either via a
    device file or a family of new system calls.  We decided to implement a
-   family of system calls because that is the preffered approach for new kernel
+   family of system calls because that is the preferred approach for new kernel
    interfaces.  The only real difference was whether we wanted to use open(2)
    and ioctl(2) or a couple of new system calls.  System calls beat ioctls.
 
diff --git a/MAINTAINERS b/MAINTAINERS
index 1421f74b6009..ce37c4b1ef94 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1843,12 +1843,12 @@ S:     linux-scsi@vger.kernel.org
 W:     http://megaraid.lsilogic.com
 S:     Maintained
 
-MEMORY TECHNOLOGY DEVICES
+MEMORY TECHNOLOGY DEVICES (MTD)
 P:      David Woodhouse
 M:      dwmw2@infradead.org
 W:      http://www.linux-mtd.infradead.org/
 L:      linux-mtd@lists.infradead.org
-T:      git kernel.org:/pub/scm/linux/kernel/git/tglx/mtd-2.6.git
+T:      git git://git.infradead.org/mtd-2.6.git
 S:      Maintained
 
 MICROTEK X6 SCANNER
@@ -1895,7 +1895,7 @@ L:	linux-kernel@vger.kernel.org
 W:      http://www.atnf.csiro.au/~rgooch/linux/kernel-patches.html
 S:      Maintained
 
-MULTIMEDIA CARD SUBSYSTEM
+MULTIMEDIA CARD (MMC) SUBSYSTEM
 P:      Russell King
 M:      rmk+mmc@arm.linux.org.uk
 S:      Maintained
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index 08b7cc900cae..f47cf9af3bc8 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -270,6 +270,11 @@ config ARCH_AT91RM9200
           Say Y here if you intend to run this kernel on an Atmel
           AT91RM9200-based board.
 
+config ARCH_PNX4008
+        bool "Philips Nexperia PNX4008 Mobile"
+        help
+          This enables support for Philips PNX4008 mobile platform.
+
 endchoice
 
 source "arch/arm/mach-clps711x/Kconfig"
diff --git a/arch/arm/Makefile b/arch/arm/Makefile
index 6f8e84c1c1f2..6c97aa70d3bc 100644
--- a/arch/arm/Makefile
+++ b/arch/arm/Makefile
@@ -116,6 +116,7 @@ endif
  machine-$(CONFIG_ARCH_REALVIEW)   := realview
  machine-$(CONFIG_ARCH_AT91RM9200) := at91rm9200
  machine-$(CONFIG_ARCH_EP93XX)     := ep93xx
+ machine-$(CONFIG_ARCH_PNX4008)    := pnx4008
 
 ifeq ($(CONFIG_ARCH_EBSA110),y)
 # This is what happens if you forget the IOCS16 line.
diff --git a/arch/arm/boot/compressed/head.S b/arch/arm/boot/compressed/head.S
index b56f5e691d65..23016f6aa645 100644
--- a/arch/arm/boot/compressed/head.S
+++ b/arch/arm/boot/compressed/head.S
@@ -605,8 +605,8 @@ proc_types:
                 b       __armv4_mmu_cache_off
                 b       __armv4_mmu_cache_flush
 
-                .word   0x00070000              @ ARMv6
-                .word   0x000f0000
+                .word   0x0007b000              @ ARMv6
+                .word   0x0007f000
                 b       __armv4_mmu_cache_on
                 b       __armv4_mmu_cache_off
                 b       __armv6_mmu_cache_flush
diff --git a/arch/arm/configs/lpd7a400_defconfig b/arch/arm/configs/lpd7a400_defconfig
index 67eaa26c2647..bf9cf9c6d2df 100644
--- a/arch/arm/configs/lpd7a400_defconfig
+++ b/arch/arm/configs/lpd7a400_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.12-rc1-bk2
-# Mon Mar 28 00:06:33 2005
+# Linux kernel version: 2.6.12
+# Thu Nov  3 14:15:32 2005
 #
 CONFIG_ARM=y
 CONFIG_MMU=y
@@ -17,6 +17,7 @@ CONFIG_EXPERIMENTAL=y
 CONFIG_CLEAN_COMPILE=y
 CONFIG_BROKEN_ON_SMP=y
 CONFIG_LOCK_KERNEL=y
+CONFIG_INIT_ENV_ARG_LIMIT=32
 
 #
 # General setup
@@ -36,6 +37,8 @@ CONFIG_EMBEDDED=y
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+CONFIG_PRINTK=y
+CONFIG_BUG=y
 CONFIG_BASE_FULL=y
 CONFIG_FUTEX=y
 # CONFIG_EPOLL is not set
@@ -71,6 +74,7 @@ CONFIG_BASE_SMALL=0
 # CONFIG_ARCH_SA1100 is not set
 # CONFIG_ARCH_S3C2410 is not set
 # CONFIG_ARCH_SHARK is not set
+# CONFIG_ARCH_LH7952X is not set
 CONFIG_ARCH_LH7A40X=y
 # CONFIG_ARCH_OMAP is not set
 # CONFIG_ARCH_VERSATILE is not set
@@ -84,6 +88,7 @@ CONFIG_ARCH_LH7A40X=y
 CONFIG_MACH_LPD7A400=y
 # CONFIG_MACH_LPD7A404 is not set
 CONFIG_ARCH_LH7A400=y
+CONFIG_LPD7A40X_CPLD_SSP=y
 # CONFIG_LH7A40X_CONTIGMEM is not set
 # CONFIG_LH7A40X_ONE_BANK_PER_NODE is not set
 
@@ -110,6 +115,8 @@ CONFIG_ARM_THUMB=y
 #
 # Bus support
 #
+CONFIG_ARM_AMBA=y
+CONFIG_ISA_DMA_API=y
 
 #
 # PCCARD (PCMCIA/CardBus) support
@@ -119,6 +126,7 @@ CONFIG_ARM_THUMB=y
 #
 # Kernel Features
 #
+# CONFIG_SMP is not set
 CONFIG_PREEMPT=y
 CONFIG_DISCONTIGMEM=y
 CONFIG_ALIGNMENT_TRAP=y
@@ -175,7 +183,7 @@ CONFIG_MTD=y
 # CONFIG_MTD_CONCAT is not set
 CONFIG_MTD_PARTITIONS=y
 # CONFIG_MTD_REDBOOT_PARTS is not set
-# CONFIG_MTD_CMDLINE_PARTS is not set
+CONFIG_MTD_CMDLINE_PARTS=y
 # CONFIG_MTD_AFS_PARTS is not set
 
 #
@@ -217,7 +225,10 @@ CONFIG_MTD_CFI_UTIL=y
 # Mapping drivers for chip access
 #
 # CONFIG_MTD_COMPLEX_MAPPINGS is not set
-# CONFIG_MTD_PHYSMAP is not set
+CONFIG_MTD_PHYSMAP=y
+CONFIG_MTD_PHYSMAP_START=0x00000000
+CONFIG_MTD_PHYSMAP_LEN=0x04000000
+CONFIG_MTD_PHYSMAP_BANKWIDTH=4
 # CONFIG_MTD_ARM_INTEGRATOR is not set
 # CONFIG_MTD_EDB7312 is not set
 
@@ -254,7 +265,6 @@ CONFIG_MTD_CFI_UTIL=y
 #
 # Block devices
 #
-# CONFIG_BLK_DEV_FD is not set
 # CONFIG_BLK_DEV_COW_COMMON is not set
 CONFIG_BLK_DEV_LOOP=y
 # CONFIG_BLK_DEV_CRYPTOLOOP is not set
@@ -288,13 +298,15 @@ CONFIG_BLK_DEV_IDEDISK=y
 # CONFIG_BLK_DEV_IDECD is not set
 # CONFIG_BLK_DEV_IDETAPE is not set
 # CONFIG_BLK_DEV_IDEFLOPPY is not set
+# CONFIG_BLK_DEV_IDESCSI is not set
 # CONFIG_IDE_TASK_IOCTL is not set
+CONFIG_IDE_POLL=y
 
 #
 # IDE chipset support/bugfixes
 #
 CONFIG_IDE_GENERIC=y
-# CONFIG_IDE_ARM is not set
+CONFIG_IDE_ARM=y
 # CONFIG_BLK_DEV_IDEDMA is not set
 # CONFIG_IDEDMA_AUTO is not set
 # CONFIG_BLK_DEV_HD is not set
@@ -302,7 +314,37 @@ CONFIG_IDE_GENERIC=y
 #
 # SCSI device support
 #
-# CONFIG_SCSI is not set
+CONFIG_SCSI=y
+# CONFIG_SCSI_PROC_FS is not set
+
+#
+# SCSI support type (disk, tape, CD-ROM)
+#
+# CONFIG_BLK_DEV_SD is not set
+# CONFIG_CHR_DEV_ST is not set
+# CONFIG_CHR_DEV_OSST is not set
+# CONFIG_BLK_DEV_SR is not set
+# CONFIG_CHR_DEV_SG is not set
+
+#
+# Some SCSI devices (e.g. CD jukebox) support multiple LUNs
+#
+# CONFIG_SCSI_MULTI_LUN is not set
+# CONFIG_SCSI_CONSTANTS is not set
+# CONFIG_SCSI_LOGGING is not set
+
+#
+# SCSI Transport Attributes
+#
+# CONFIG_SCSI_SPI_ATTRS is not set
+# CONFIG_SCSI_FC_ATTRS is not set
+# CONFIG_SCSI_ISCSI_ATTRS is not set
+
+#
+# SCSI low-level drivers
+#
+# CONFIG_SCSI_SATA is not set
+# CONFIG_SCSI_DEBUG is not set
 
 #
 # Multi-device support (RAID and LVM)
@@ -331,7 +373,6 @@ CONFIG_NET=y
 #
 CONFIG_PACKET=y
 # CONFIG_PACKET_MMAP is not set
-# CONFIG_NETLINK_DEV is not set
 CONFIG_UNIX=y
 # CONFIG_NET_KEY is not set
 CONFIG_INET=y
@@ -438,13 +479,10 @@ CONFIG_INPUT=y
 #
 # Userland interfaces
 #
-CONFIG_INPUT_MOUSEDEV=y
-CONFIG_INPUT_MOUSEDEV_PSAUX=y
-CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
-CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
+# CONFIG_INPUT_MOUSEDEV is not set
 # CONFIG_INPUT_JOYDEV is not set
 # CONFIG_INPUT_TSDEV is not set
-# CONFIG_INPUT_EVDEV is not set
+CONFIG_INPUT_EVDEV=y
 # CONFIG_INPUT_EVBUG is not set
 
 #
@@ -453,7 +491,13 @@ CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
 # CONFIG_INPUT_KEYBOARD is not set
 # CONFIG_INPUT_MOUSE is not set
 # CONFIG_INPUT_JOYSTICK is not set
-# CONFIG_INPUT_TOUCHSCREEN is not set
+CONFIG_INPUT_TOUCHSCREEN=y
+# CONFIG_TOUCHSCREEN_GUNZE is not set
+# CONFIG_TOUCHSCREEN_ELO is not set
+# CONFIG_TOUCHSCREEN_MTOUCH is not set
+# CONFIG_TOUCHSCREEN_MK712 is not set
+CONFIG_TOUCHSCREEN_ADS7843_LH7=y
+CONFIG_HAS_TOUCHSCREEN_ADS7843_LH7=y
 # CONFIG_INPUT_MISC is not set
 
 #
@@ -461,7 +505,6 @@ CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
 #
 # CONFIG_SERIO is not set
 # CONFIG_GAMEPORT is not set
-CONFIG_SOUND_GAMEPORT=y
 
 #
 # Character devices
@@ -479,6 +522,8 @@ CONFIG_HW_CONSOLE=y
 #
 # Non-8250 serial port support
 #
+# CONFIG_SERIAL_AMBA_PL010 is not set
+# CONFIG_SERIAL_AMBA_PL011 is not set
 CONFIG_SERIAL_CORE=y
 CONFIG_SERIAL_CORE_CONSOLE=y
 CONFIG_SERIAL_LH7A40X=y
@@ -510,7 +555,6 @@ CONFIG_RTC=y
 #
 # TPM devices
 #
-# CONFIG_TCG_TPM is not set
 
 #
 # I2C support
@@ -534,18 +578,73 @@ CONFIG_RTC=y
 #
 # Graphics support
 #
-# CONFIG_FB is not set
+CONFIG_FB=y
+CONFIG_FB_CFB_FILLRECT=y
+CONFIG_FB_CFB_COPYAREA=y
+CONFIG_FB_CFB_IMAGEBLIT=y
+CONFIG_FB_SOFT_CURSOR=y
+# CONFIG_FB_MACMODES is not set
+# CONFIG_FB_MODE_HELPERS is not set
+# CONFIG_FB_TILEBLITTING is not set
+CONFIG_FB_ARMCLCD=y
+CONFIG_FB_ARMCLCD_SHARP_LQ035Q7DB02_HRTFT=y
+# CONFIG_FB_ARMCLCD_SHARP_LQ057Q3DC02 is not set
+# CONFIG_FB_ARMCLCD_SHARP_LQ64D343 is not set
+# CONFIG_FB_ARMCLCD_SHARP_LQ10D368 is not set
+# CONFIG_FB_ARMCLCD_SHARP_LQ121S1DG41 is not set
+# CONFIG_FB_S1D13XXX is not set
+# CONFIG_FB_VIRTUAL is not set
 
 #
 # Console display driver support
 #
 # CONFIG_VGA_CONSOLE is not set
 CONFIG_DUMMY_CONSOLE=y
+# CONFIG_FRAMEBUFFER_CONSOLE is not set
+
+#
+# Logo configuration
+#
+# CONFIG_LOGO is not set
+# CONFIG_BACKLIGHT_LCD_SUPPORT is not set
 
 #
 # Sound
 #
-# CONFIG_SOUND is not set
+CONFIG_SOUND=y
+
+#
+# Advanced Linux Sound Architecture
+#
+CONFIG_SND=y
+CONFIG_SND_TIMER=y
+CONFIG_SND_PCM=y
+# CONFIG_SND_SEQUENCER is not set
+CONFIG_SND_OSSEMUL=y
+CONFIG_SND_MIXER_OSS=y
+CONFIG_SND_PCM_OSS=y
+# CONFIG_SND_RTCTIMER is not set
+# CONFIG_SND_VERBOSE_PRINTK is not set
+# CONFIG_SND_DEBUG is not set
+
+#
+# Generic devices
+#
+# CONFIG_SND_DUMMY is not set
+# CONFIG_SND_MTPAV is not set
+# CONFIG_SND_SERIAL_U16550 is not set
+# CONFIG_SND_MPU401 is not set
+CONFIG_SND_AC97_CODEC=y
+
+#
+# ALSA ARM devices
+#
+CONFIG_SND_LH7A40X_AC97=y
+
+#
+# Open Sound System
+#
+# CONFIG_SOUND_PRIME is not set
 
 #
 # USB support
diff --git a/arch/arm/configs/lpd7a404_defconfig b/arch/arm/configs/lpd7a404_defconfig
index 208d591ebfce..3a57be32e849 100644
--- a/arch/arm/configs/lpd7a404_defconfig
+++ b/arch/arm/configs/lpd7a404_defconfig
@@ -1,52 +1,58 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.12-rc1-bk2
-# Mon Mar 28 00:14:08 2005
+# Linux kernel version: 2.6.16
+# Thu Mar 23 17:50:31 2006
 #
 CONFIG_ARM=y
 CONFIG_MMU=y
-CONFIG_UID16=y
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_CALIBRATE_DELAY=y
-CONFIG_GENERIC_IOMAP=y
 
 #
 # Code maturity level options
 #
 CONFIG_EXPERIMENTAL=y
-CONFIG_CLEAN_COMPILE=y
 CONFIG_BROKEN_ON_SMP=y
 CONFIG_LOCK_KERNEL=y
+CONFIG_INIT_ENV_ARG_LIMIT=32
 
 #
 # General setup
 #
 CONFIG_LOCALVERSION=""
+CONFIG_LOCALVERSION_AUTO=y
 # CONFIG_SWAP is not set
 CONFIG_SYSVIPC=y
 # CONFIG_POSIX_MQUEUE is not set
 # CONFIG_BSD_PROCESS_ACCT is not set
 CONFIG_SYSCTL=y
 # CONFIG_AUDIT is not set
-# CONFIG_HOTPLUG is not set
-CONFIG_KOBJECT_UEVENT=y
 CONFIG_IKCONFIG=y
 # CONFIG_IKCONFIG_PROC is not set
+CONFIG_INITRAMFS_SOURCE=""
+CONFIG_UID16=y
+CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_EMBEDDED=y
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_HOTPLUG is not set
+CONFIG_PRINTK=y
+CONFIG_BUG=y
+CONFIG_ELF_CORE=y
 CONFIG_BASE_FULL=y
 CONFIG_FUTEX=y
 # CONFIG_EPOLL is not set
-CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_SHMEM=y
 CONFIG_CC_ALIGN_FUNCTIONS=0
 CONFIG_CC_ALIGN_LABELS=0
 CONFIG_CC_ALIGN_LOOPS=0
 CONFIG_CC_ALIGN_JUMPS=0
+CONFIG_SLAB=y
 # CONFIG_TINY_SHMEM is not set
 CONFIG_BASE_SMALL=0
+# CONFIG_SLOB is not set
+CONFIG_OBSOLETE_INTERMODULE=y
 
 #
 # Loadable module support
@@ -54,6 +60,23 @@ CONFIG_BASE_SMALL=0
 # CONFIG_MODULES is not set
 
 #
+# Block layer
+#
+
+#
+# IO Schedulers
+#
+CONFIG_IOSCHED_NOOP=y
+# CONFIG_IOSCHED_AS is not set
+# CONFIG_IOSCHED_DEADLINE is not set
+CONFIG_IOSCHED_CFQ=y
+# CONFIG_DEFAULT_AS is not set
+# CONFIG_DEFAULT_DEADLINE is not set
+CONFIG_DEFAULT_CFQ=y
+# CONFIG_DEFAULT_NOOP is not set
+CONFIG_DEFAULT_IOSCHED="cfq"
+
+#
 # System Type
 #
 # CONFIG_ARCH_CLPS7500 is not set
@@ -71,11 +94,15 @@ CONFIG_BASE_SMALL=0
 # CONFIG_ARCH_SA1100 is not set
 # CONFIG_ARCH_S3C2410 is not set
 # CONFIG_ARCH_SHARK is not set
+# CONFIG_ARCH_LH7952X is not set
 CONFIG_ARCH_LH7A40X=y
 # CONFIG_ARCH_OMAP is not set
 # CONFIG_ARCH_VERSATILE is not set
+# CONFIG_ARCH_REALVIEW is not set
 # CONFIG_ARCH_IMX is not set
 # CONFIG_ARCH_H720X is not set
+# CONFIG_ARCH_AAEC2000 is not set
+# CONFIG_ARCH_AT91RM9200 is not set
 
 #
 # LH7A40X Implementations
@@ -110,6 +137,7 @@ CONFIG_ARM_THUMB=y
 #
 # Bus support
 #
+CONFIG_ARM_AMBA=y
 
 #
 # PCCARD (PCMCIA/CardBus) support
@@ -120,7 +148,18 @@ CONFIG_ARM_THUMB=y
 # Kernel Features
 #
 CONFIG_PREEMPT=y
+# CONFIG_NO_IDLE_HZ is not set
+# CONFIG_AEABI is not set
+CONFIG_ARCH_DISCONTIGMEM_ENABLE=y
+CONFIG_SELECT_MEMORY_MODEL=y
+# CONFIG_FLATMEM_MANUAL is not set
+CONFIG_DISCONTIGMEM_MANUAL=y
+# CONFIG_SPARSEMEM_MANUAL is not set
 CONFIG_DISCONTIGMEM=y
+CONFIG_FLAT_NODE_MEM_MAP=y
+CONFIG_NEED_MULTIPLE_NODES=y
+# CONFIG_SPARSEMEM_STATIC is not set
+CONFIG_SPLIT_PTLOCK_CPUS=4096
 CONFIG_ALIGNMENT_TRAP=y
 
 #
@@ -154,6 +193,84 @@ CONFIG_BINFMT_ELF=y
 # Power management options
 #
 # CONFIG_PM is not set
+# CONFIG_APM is not set
+
+#
+# Networking
+#
+CONFIG_NET=y
+
+#
+# Networking options
+#
+# CONFIG_NETDEBUG is not set
+CONFIG_PACKET=y
+# CONFIG_PACKET_MMAP is not set
+CONFIG_UNIX=y
+# CONFIG_NET_KEY is not set
+CONFIG_INET=y
+# CONFIG_IP_MULTICAST is not set
+# CONFIG_IP_ADVANCED_ROUTER is not set
+CONFIG_IP_FIB_HASH=y
+CONFIG_IP_PNP=y
+CONFIG_IP_PNP_DHCP=y
+CONFIG_IP_PNP_BOOTP=y
+CONFIG_IP_PNP_RARP=y
+# CONFIG_NET_IPIP is not set
+# CONFIG_NET_IPGRE is not set
+# CONFIG_ARPD is not set
+# CONFIG_SYN_COOKIES is not set
+# CONFIG_INET_AH is not set
+# CONFIG_INET_ESP is not set
+# CONFIG_INET_IPCOMP is not set
+# CONFIG_INET_TUNNEL is not set
+CONFIG_INET_DIAG=y
+CONFIG_INET_TCP_DIAG=y
+# CONFIG_TCP_CONG_ADVANCED is not set
+CONFIG_TCP_CONG_BIC=y
+# CONFIG_IPV6 is not set
+# CONFIG_NETFILTER is not set
+
+#
+# DCCP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_DCCP is not set
+
+#
+# SCTP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_SCTP is not set
+
+#
+# TIPC Configuration (EXPERIMENTAL)
+#
+# CONFIG_TIPC is not set
+# CONFIG_ATM is not set
+# CONFIG_BRIDGE is not set
+# CONFIG_VLAN_8021Q is not set
+# CONFIG_DECNET is not set
+# CONFIG_LLC2 is not set
+# CONFIG_IPX is not set
+# CONFIG_ATALK is not set
+# CONFIG_X25 is not set
+# CONFIG_LAPB is not set
+# CONFIG_NET_DIVERT is not set
+# CONFIG_ECONET is not set
+# CONFIG_WAN_ROUTER is not set
+
+#
+# QoS and/or fair queueing
+#
+# CONFIG_NET_SCHED is not set
+
+#
+# Network testing
+#
+# CONFIG_NET_PKTGEN is not set
+# CONFIG_HAMRADIO is not set
+# CONFIG_IRDA is not set
+# CONFIG_BT is not set
+# CONFIG_IEEE80211 is not set
 
 #
 # Device Drivers
@@ -168,6 +285,11 @@ CONFIG_PREVENT_FIRMWARE_BUILD=y
 # CONFIG_DEBUG_DRIVER is not set
 
 #
+# Connector - unified userspace <-> kernelspace linker
+#
+# CONFIG_CONNECTOR is not set
+
+#
 # Memory Technology Devices (MTD)
 #
 CONFIG_MTD=y
@@ -175,7 +297,7 @@ CONFIG_MTD=y
 # CONFIG_MTD_CONCAT is not set
 CONFIG_MTD_PARTITIONS=y
 # CONFIG_MTD_REDBOOT_PARTS is not set
-# CONFIG_MTD_CMDLINE_PARTS is not set
+CONFIG_MTD_CMDLINE_PARTS=y
 # CONFIG_MTD_AFS_PARTS is not set
 
 #
@@ -186,6 +308,7 @@ CONFIG_MTD_BLOCK=y
 # CONFIG_FTL is not set
 # CONFIG_NFTL is not set
 # CONFIG_INFTL is not set
+# CONFIG_RFD_FTL is not set
 
 #
 # RAM/ROM/Flash chip drivers
@@ -211,15 +334,18 @@ CONFIG_MTD_CFI_UTIL=y
 # CONFIG_MTD_RAM is not set
 # CONFIG_MTD_ROM is not set
 # CONFIG_MTD_ABSENT is not set
-# CONFIG_MTD_XIP is not set
+# CONFIG_MTD_OBSOLETE_CHIPS is not set
 
 #
 # Mapping drivers for chip access
 #
 # CONFIG_MTD_COMPLEX_MAPPINGS is not set
-# CONFIG_MTD_PHYSMAP is not set
+CONFIG_MTD_PHYSMAP=y
+CONFIG_MTD_PHYSMAP_START=0x00000000
+CONFIG_MTD_PHYSMAP_LEN=0x04000000
+CONFIG_MTD_PHYSMAP_BANKWIDTH=4
 # CONFIG_MTD_ARM_INTEGRATOR is not set
-# CONFIG_MTD_EDB7312 is not set
+# CONFIG_MTD_PLATRAM is not set
 
 #
 # Self-contained MTD device drivers
@@ -243,6 +369,11 @@ CONFIG_MTD_CFI_UTIL=y
 # CONFIG_MTD_NAND is not set
 
 #
+# OneNAND Flash Device Drivers
+#
+# CONFIG_MTD_ONENAND is not set
+
+#
 # Parallel port support
 #
 # CONFIG_PARPORT is not set
@@ -254,7 +385,6 @@ CONFIG_MTD_CFI_UTIL=y
 #
 # Block devices
 #
-# CONFIG_BLK_DEV_FD is not set
 # CONFIG_BLK_DEV_COW_COMMON is not set
 CONFIG_BLK_DEV_LOOP=y
 # CONFIG_BLK_DEV_CRYPTOLOOP is not set
@@ -262,16 +392,7 @@ CONFIG_BLK_DEV_LOOP=y
 # CONFIG_BLK_DEV_UB is not set
 # CONFIG_BLK_DEV_RAM is not set
 CONFIG_BLK_DEV_RAM_COUNT=16
-CONFIG_INITRAMFS_SOURCE=""
 # CONFIG_CDROM_PKTCDVD is not set
-
-#
-# IO Schedulers
-#
-CONFIG_IOSCHED_NOOP=y
-# CONFIG_IOSCHED_AS is not set
-# CONFIG_IOSCHED_DEADLINE is not set
-CONFIG_IOSCHED_CFQ=y
 # CONFIG_ATA_OVER_ETH is not set
 
 #
@@ -291,12 +412,13 @@ CONFIG_BLK_DEV_IDEDISK=y
 # CONFIG_BLK_DEV_IDEFLOPPY is not set
 # CONFIG_BLK_DEV_IDESCSI is not set
 # CONFIG_IDE_TASK_IOCTL is not set
+CONFIG_IDE_POLL=y
 
 #
 # IDE chipset support/bugfixes
 #
 CONFIG_IDE_GENERIC=y
-# CONFIG_IDE_ARM is not set
+CONFIG_IDE_ARM=y
 # CONFIG_BLK_DEV_IDEDMA is not set
 # CONFIG_IDEDMA_AUTO is not set
 # CONFIG_BLK_DEV_HD is not set
@@ -304,6 +426,7 @@ CONFIG_IDE_GENERIC=y
 #
 # SCSI device support
 #
+# CONFIG_RAID_ATTRS is not set
 CONFIG_SCSI=y
 # CONFIG_SCSI_PROC_FS is not set
 
@@ -315,6 +438,7 @@ CONFIG_SCSI=y
 # CONFIG_CHR_DEV_OSST is not set
 # CONFIG_BLK_DEV_SR is not set
 # CONFIG_CHR_DEV_SG is not set
+# CONFIG_CHR_DEV_SCH is not set
 
 #
 # Some SCSI devices (e.g. CD jukebox) support multiple LUNs
@@ -329,10 +453,12 @@ CONFIG_SCSI=y
 # CONFIG_SCSI_SPI_ATTRS is not set
 # CONFIG_SCSI_FC_ATTRS is not set
 # CONFIG_SCSI_ISCSI_ATTRS is not set
+# CONFIG_SCSI_SAS_ATTRS is not set
 
 #
 # SCSI low-level drivers
 #
+# CONFIG_ISCSI_TCP is not set
 # CONFIG_SCSI_SATA is not set
 # CONFIG_SCSI_DEBUG is not set
 
@@ -344,6 +470,7 @@ CONFIG_SCSI=y
 #
 # Fusion MPT device support
 #
+# CONFIG_FUSION is not set
 
 #
 # IEEE 1394 (FireWire) support
@@ -354,70 +481,8 @@ CONFIG_SCSI=y
 #
 
 #
-# Networking support
+# Network device support
 #
-CONFIG_NET=y
-
-#
-# Networking options
-#
-CONFIG_PACKET=y
-# CONFIG_PACKET_MMAP is not set
-# CONFIG_NETLINK_DEV is not set
-CONFIG_UNIX=y
-# CONFIG_NET_KEY is not set
-CONFIG_INET=y
-# CONFIG_IP_MULTICAST is not set
-# CONFIG_IP_ADVANCED_ROUTER is not set
-CONFIG_IP_PNP=y
-CONFIG_IP_PNP_DHCP=y
-CONFIG_IP_PNP_BOOTP=y
-CONFIG_IP_PNP_RARP=y
-# CONFIG_NET_IPIP is not set
-# CONFIG_NET_IPGRE is not set
-# CONFIG_ARPD is not set
-# CONFIG_SYN_COOKIES is not set
-# CONFIG_INET_AH is not set
-# CONFIG_INET_ESP is not set
-# CONFIG_INET_IPCOMP is not set
-# CONFIG_INET_TUNNEL is not set
-# CONFIG_IP_TCPDIAG is not set
-# CONFIG_IP_TCPDIAG_IPV6 is not set
-# CONFIG_IPV6 is not set
-# CONFIG_NETFILTER is not set
-
-#
-# SCTP Configuration (EXPERIMENTAL)
-#
-# CONFIG_IP_SCTP is not set
-# CONFIG_ATM is not set
-# CONFIG_BRIDGE is not set
-# CONFIG_VLAN_8021Q is not set
-# CONFIG_DECNET is not set
-# CONFIG_LLC2 is not set
-# CONFIG_IPX is not set
-# CONFIG_ATALK is not set
-# CONFIG_X25 is not set
-# CONFIG_LAPB is not set
-# CONFIG_NET_DIVERT is not set
-# CONFIG_ECONET is not set
-# CONFIG_WAN_ROUTER is not set
-
-#
-# QoS and/or fair queueing
-#
-# CONFIG_NET_SCHED is not set
-# CONFIG_NET_CLS_ROUTE is not set
-
-#
-# Network testing
-#
-# CONFIG_NET_PKTGEN is not set
-# CONFIG_NETPOLL is not set
-# CONFIG_NET_POLL_CONTROLLER is not set
-# CONFIG_HAMRADIO is not set
-# CONFIG_IRDA is not set
-# CONFIG_BT is not set
 CONFIG_NETDEVICES=y
 # CONFIG_DUMMY is not set
 # CONFIG_BONDING is not set
@@ -425,11 +490,17 @@ CONFIG_NETDEVICES=y
 # CONFIG_TUN is not set
 
 #
+# PHY device support
+#
+# CONFIG_PHYLIB is not set
+
+#
 # Ethernet (10 or 100Mbit)
 #
 CONFIG_NET_ETHERNET=y
 CONFIG_MII=y
 CONFIG_SMC91X=y
+# CONFIG_DM9000 is not set
 
 #
 # Ethernet (1000 Mbit)
@@ -456,6 +527,8 @@ CONFIG_SMC91X=y
 # CONFIG_SLIP is not set
 # CONFIG_SHAPER is not set
 # CONFIG_NETCONSOLE is not set
+# CONFIG_NETPOLL is not set
+# CONFIG_NET_POLL_CONTROLLER is not set
 
 #
 # ISDN subsystem
@@ -470,10 +543,13 @@ CONFIG_INPUT=y
 #
 # Userland interfaces
 #
-# CONFIG_INPUT_MOUSEDEV is not set
+CONFIG_INPUT_MOUSEDEV=y
+# CONFIG_INPUT_MOUSEDEV_PSAUX is not set
+CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
+CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
 # CONFIG_INPUT_JOYDEV is not set
 # CONFIG_INPUT_TSDEV is not set
-# CONFIG_INPUT_EVDEV is not set
+CONFIG_INPUT_EVDEV=y
 # CONFIG_INPUT_EVBUG is not set
 
 #
@@ -482,7 +558,13 @@ CONFIG_INPUT=y
 # CONFIG_INPUT_KEYBOARD is not set
 # CONFIG_INPUT_MOUSE is not set
 # CONFIG_INPUT_JOYSTICK is not set
-# CONFIG_INPUT_TOUCHSCREEN is not set
+CONFIG_INPUT_TOUCHSCREEN=y
+# CONFIG_TOUCHSCREEN_GUNZE is not set
+# CONFIG_TOUCHSCREEN_ELO is not set
+# CONFIG_TOUCHSCREEN_MTOUCH is not set
+# CONFIG_TOUCHSCREEN_MK712 is not set
+CONFIG_TOUCHSCREEN_ADC_LH7=y
+CONFIG_HAS_TOUCHSCREEN_ADC_LH7=y
 # CONFIG_INPUT_MISC is not set
 
 #
@@ -490,7 +572,6 @@ CONFIG_INPUT=y
 #
 # CONFIG_SERIO is not set
 # CONFIG_GAMEPORT is not set
-CONFIG_SOUND_GAMEPORT=y
 
 #
 # Character devices
@@ -508,6 +589,8 @@ CONFIG_HW_CONSOLE=y
 #
 # Non-8250 serial port support
 #
+# CONFIG_SERIAL_AMBA_PL010 is not set
+# CONFIG_SERIAL_AMBA_PL011 is not set
 CONFIG_SERIAL_CORE=y
 CONFIG_SERIAL_CORE_CONSOLE=y
 CONFIG_SERIAL_LH7A40X=y
@@ -533,13 +616,13 @@ CONFIG_RTC=y
 #
 # Ftape, the floppy tape device driver
 #
-# CONFIG_DRM is not set
 # CONFIG_RAW_DRIVER is not set
 
 #
 # TPM devices
 #
 # CONFIG_TCG_TPM is not set
+# CONFIG_TELCLOCK is not set
 
 #
 # I2C support
@@ -547,10 +630,33 @@ CONFIG_RTC=y
 # CONFIG_I2C is not set
 
 #
+# SPI support
+#
+# CONFIG_SPI is not set
+# CONFIG_SPI_MASTER is not set
+
+#
+# Dallas's 1-wire bus
+#
+# CONFIG_W1 is not set
+
+#
+# Hardware Monitoring support
+#
+CONFIG_HWMON=y
+# CONFIG_HWMON_VID is not set
+# CONFIG_SENSORS_F71805F is not set
+# CONFIG_HWMON_DEBUG_CHIP is not set
+
+#
 # Misc devices
 #
 
 #
+# Multimedia Capabilities Port drivers
+#
+
+#
 # Multimedia devices
 #
 # CONFIG_VIDEO_DEV is not set
@@ -563,18 +669,83 @@ CONFIG_RTC=y
 #
 # Graphics support
 #
-# CONFIG_FB is not set
+CONFIG_FB=y
+CONFIG_FB_CFB_FILLRECT=y
+CONFIG_FB_CFB_COPYAREA=y
+CONFIG_FB_CFB_IMAGEBLIT=y
+# CONFIG_FB_MACMODES is not set
+# CONFIG_FB_MODE_HELPERS is not set
+# CONFIG_FB_TILEBLITTING is not set
+CONFIG_FB_ARMCLCD=y
+CONFIG_FB_ARMCLCD_SHARP_LQ035Q7DB02_HRTFT=y
+# CONFIG_FB_ARMCLCD_SHARP_LQ057Q3DC02 is not set
+# CONFIG_FB_ARMCLCD_SHARP_LQ64D343 is not set
+# CONFIG_FB_ARMCLCD_SHARP_LQ10D368 is not set
+# CONFIG_FB_ARMCLCD_SHARP_LQ121S1DG41 is not set
+# CONFIG_FB_ARMCLCD_AUO_A070VW01_WIDE is not set
+# CONFIG_FB_ARMCLCD_HITACHI is not set
+# CONFIG_FB_S1D13XXX is not set
+# CONFIG_FB_VIRTUAL is not set
 
 #
 # Console display driver support
 #
 # CONFIG_VGA_CONSOLE is not set
 CONFIG_DUMMY_CONSOLE=y
+# CONFIG_FRAMEBUFFER_CONSOLE is not set
+
+#
+# Logo configuration
+#
+# CONFIG_LOGO is not set
+# CONFIG_BACKLIGHT_LCD_SUPPORT is not set
 
 #
 # Sound
 #
-# CONFIG_SOUND is not set
+CONFIG_SOUND=y
+
+#
+# Advanced Linux Sound Architecture
+#
+CONFIG_SND=y
+CONFIG_SND_TIMER=y
+CONFIG_SND_PCM=y
+# CONFIG_SND_SEQUENCER is not set
+CONFIG_SND_OSSEMUL=y
+CONFIG_SND_MIXER_OSS=y
+CONFIG_SND_PCM_OSS=y
+# CONFIG_SND_RTCTIMER is not set
+# CONFIG_SND_DYNAMIC_MINORS is not set
+CONFIG_SND_SUPPORT_OLD_API=y
+# CONFIG_SND_VERBOSE_PRINTK is not set
+# CONFIG_SND_DEBUG is not set
+
+#
+# Generic devices
+#
+CONFIG_SND_AC97_CODEC=y
+CONFIG_SND_AC97_BUS=y
+# CONFIG_SND_DUMMY is not set
+# CONFIG_SND_MTPAV is not set
+# CONFIG_SND_SERIAL_U16550 is not set
+# CONFIG_SND_MPU401 is not set
+
+#
+# ALSA ARM devices
+#
+# CONFIG_SND_ARMAACI is not set
+CONFIG_SND_LH7A40X_AC97=y
+
+#
+# USB devices
+#
+# CONFIG_SND_USB_AUDIO is not set
+
+#
+# Open Sound System
+#
+# CONFIG_SOUND_PRIME is not set
 
 #
 # USB support
@@ -595,6 +766,7 @@ CONFIG_USB_DEVICEFS=y
 #
 # USB Host Controller Drivers
 #
+# CONFIG_USB_ISP116X_HCD is not set
 CONFIG_USB_OHCI_HCD=y
 # CONFIG_USB_OHCI_BIG_ENDIAN is not set
 CONFIG_USB_OHCI_LITTLE_ENDIAN=y
@@ -603,16 +775,19 @@ CONFIG_USB_OHCI_LITTLE_ENDIAN=y
 #
 # USB Device Class drivers
 #
-# CONFIG_USB_BLUETOOTH_TTY is not set
+# CONFIG_OBSOLETE_OSS_USB_DRIVER is not set
 # CONFIG_USB_ACM is not set
 # CONFIG_USB_PRINTER is not set
 
 #
-# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support' may also be needed; see USB_STORAGE Help for more information
+# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
+#
+
+#
+# may also be needed; see USB_STORAGE Help for more information
 #
 CONFIG_USB_STORAGE=y
 CONFIG_USB_STORAGE_DEBUG=y
-# CONFIG_USB_STORAGE_RW_DETECT is not set
 CONFIG_USB_STORAGE_DATAFAB=y
 # CONFIG_USB_STORAGE_FREECOM is not set
 # CONFIG_USB_STORAGE_ISD200 is not set
@@ -621,22 +796,32 @@ CONFIG_USB_STORAGE_DATAFAB=y
 # CONFIG_USB_STORAGE_SDDR09 is not set
 # CONFIG_USB_STORAGE_SDDR55 is not set
 # CONFIG_USB_STORAGE_JUMPSHOT is not set
+# CONFIG_USB_STORAGE_ALAUDA is not set
+# CONFIG_USB_STORAGE_ONETOUCH is not set
+# CONFIG_USB_LIBUSUAL is not set
 
 #
 # USB Input Devices
 #
 CONFIG_USB_HID=y
 CONFIG_USB_HIDINPUT=y
+# CONFIG_USB_HIDINPUT_POWERBOOK is not set
 # CONFIG_HID_FF is not set
 # CONFIG_USB_HIDDEV is not set
 # CONFIG_USB_AIPTEK is not set
 # CONFIG_USB_WACOM is not set
+# CONFIG_USB_ACECAD is not set
 # CONFIG_USB_KBTAB is not set
 # CONFIG_USB_POWERMATE is not set
 # CONFIG_USB_MTOUCH is not set
+# CONFIG_USB_ITMTOUCH is not set
 # CONFIG_USB_EGALAX is not set
+# CONFIG_USB_YEALINK is not set
 # CONFIG_USB_XPAD is not set
 # CONFIG_USB_ATI_REMOTE is not set
+# CONFIG_USB_ATI_REMOTE2 is not set
+# CONFIG_USB_KEYSPAN_REMOTE is not set
+# CONFIG_USB_APPLETOUCH is not set
 
 #
 # USB Imaging devices
@@ -686,16 +871,33 @@ CONFIG_USB_MON=y
 # CONFIG_USB_PHIDGETKIT is not set
 # CONFIG_USB_PHIDGETSERVO is not set
 # CONFIG_USB_IDMOUSE is not set
+# CONFIG_USB_LD is not set
 # CONFIG_USB_TEST is not set
 
 #
-# USB ATM/DSL drivers
+# USB DSL modem support
 #
 
 #
 # USB Gadget Support
 #
-# CONFIG_USB_GADGET is not set
+CONFIG_USB_GADGET=y
+# CONFIG_USB_GADGET_DEBUG_FILES is not set
+CONFIG_USB_GADGET_SELECTED=y
+# CONFIG_USB_GADGET_NET2280 is not set
+# CONFIG_USB_GADGET_PXA2XX is not set
+# CONFIG_USB_GADGET_GOKU is not set
+# CONFIG_USB_GADGET_LH7A40X is not set
+CONFIG_USB_GADGET_LH7=y
+CONFIG_USB_LH7=y
+# CONFIG_USB_GADGET_OMAP is not set
+# CONFIG_USB_GADGET_DUMMY_HCD is not set
+# CONFIG_USB_GADGET_DUALSPEED is not set
+CONFIG_USB_ZERO=y
+# CONFIG_USB_ETH is not set
+# CONFIG_USB_GADGETFS is not set
+# CONFIG_USB_FILE_STORAGE is not set
+# CONFIG_USB_G_SERIAL is not set
 
 #
 # MMC/SD Card support
@@ -707,6 +909,7 @@ CONFIG_USB_MON=y
 #
 CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
+# CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
@@ -716,17 +919,17 @@ CONFIG_JBD=y
 CONFIG_FS_MBCACHE=y
 # CONFIG_REISERFS_FS is not set
 # CONFIG_JFS_FS is not set
-
-#
-# XFS support
-#
+# CONFIG_FS_POSIX_ACL is not set
 # CONFIG_XFS_FS is not set
+# CONFIG_OCFS2_FS is not set
 # CONFIG_MINIX_FS is not set
 # CONFIG_ROMFS_FS is not set
+CONFIG_INOTIFY=y
 # CONFIG_QUOTA is not set
 CONFIG_DNOTIFY=y
 # CONFIG_AUTOFS_FS is not set
 # CONFIG_AUTOFS4_FS is not set
+# CONFIG_FUSE_FS is not set
 
 #
 # CD-ROM/DVD Filesystems
@@ -749,12 +952,11 @@ CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
 #
 CONFIG_PROC_FS=y
 CONFIG_SYSFS=y
-# CONFIG_DEVFS_FS is not set
-# CONFIG_DEVPTS_FS_XATTR is not set
 CONFIG_TMPFS=y
-# CONFIG_TMPFS_XATTR is not set
 # CONFIG_HUGETLB_PAGE is not set
 CONFIG_RAMFS=y
+# CONFIG_RELAYFS_FS is not set
+# CONFIG_CONFIGFS_FS is not set
 
 #
 # Miscellaneous filesystems
@@ -769,8 +971,8 @@ CONFIG_RAMFS=y
 # CONFIG_JFFS_FS is not set
 CONFIG_JFFS2_FS=y
 CONFIG_JFFS2_FS_DEBUG=0
-# CONFIG_JFFS2_FS_NAND is not set
-# CONFIG_JFFS2_FS_NOR_ECC is not set
+CONFIG_JFFS2_FS_WRITEBUFFER=y
+# CONFIG_JFFS2_SUMMARY is not set
 # CONFIG_JFFS2_COMPRESSION_OPTIONS is not set
 CONFIG_JFFS2_ZLIB=y
 CONFIG_JFFS2_RTIME=y
@@ -787,12 +989,14 @@ CONFIG_CRAMFS=y
 #
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
+# CONFIG_NFS_V3_ACL is not set
 # CONFIG_NFS_V4 is not set
 # CONFIG_NFS_DIRECTIO is not set
 # CONFIG_NFSD is not set
 CONFIG_ROOT_NFS=y
 CONFIG_LOCKD=y
 CONFIG_LOCKD_V4=y
+CONFIG_NFS_COMMON=y
 CONFIG_SUNRPC=y
 # CONFIG_RPCSEC_GSS_KRB5 is not set
 # CONFIG_RPCSEC_GSS_SPKM3 is not set
@@ -801,6 +1005,7 @@ CONFIG_SUNRPC=y
 # CONFIG_NCP_FS is not set
 # CONFIG_CODA_FS is not set
 # CONFIG_AFS_FS is not set
+# CONFIG_9P_FS is not set
 
 #
 # Partition Types
@@ -820,6 +1025,7 @@ CONFIG_MSDOS_PARTITION=y
 # CONFIG_SGI_PARTITION is not set
 # CONFIG_ULTRIX_PARTITION is not set
 # CONFIG_SUN_PARTITION is not set
+# CONFIG_KARMA_PARTITION is not set
 # CONFIG_EFI_PARTITION is not set
 
 #
@@ -875,19 +1081,24 @@ CONFIG_NLS_DEFAULT="iso8859-1"
 # Kernel hacking
 #
 # CONFIG_PRINTK_TIME is not set
-CONFIG_DEBUG_KERNEL=y
 CONFIG_MAGIC_SYSRQ=y
-CONFIG_LOG_BUF_SHIFT=14
+CONFIG_DEBUG_KERNEL=y
+CONFIG_LOG_BUF_SHIFT=16
+CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_DEBUG_SLAB is not set
 CONFIG_DEBUG_PREEMPT=y
+CONFIG_DEBUG_MUTEXES=y
 # CONFIG_DEBUG_SPINLOCK is not set
 # CONFIG_DEBUG_SPINLOCK_SLEEP is not set
 # CONFIG_DEBUG_KOBJECT is not set
 CONFIG_DEBUG_BUGVERBOSE=y
 CONFIG_DEBUG_INFO=y
 # CONFIG_DEBUG_FS is not set
+# CONFIG_DEBUG_VM is not set
 CONFIG_FRAME_POINTER=y
+CONFIG_FORCED_INLINING=y
+# CONFIG_RCU_TORTURE_TEST is not set
 CONFIG_DEBUG_USER=y
 # CONFIG_DEBUG_WAITQ is not set
 CONFIG_DEBUG_ERRORS=y
@@ -912,6 +1123,7 @@ CONFIG_DEBUG_ERRORS=y
 # Library routines
 #
 # CONFIG_CRC_CCITT is not set
+# CONFIG_CRC16 is not set
 CONFIG_CRC32=y
 # CONFIG_LIBCRC32C is not set
 CONFIG_ZLIB_INFLATE=y
diff --git a/arch/arm/configs/pnx4008_defconfig b/arch/arm/configs/pnx4008_defconfig
new file mode 100644
index 000000000000..8a078d479d57
--- /dev/null
+++ b/arch/arm/configs/pnx4008_defconfig
@@ -0,0 +1,2072 @@
+#
+# Automatically generated make config: don't edit
+# Linux kernel version: 2.6.17-rc1
+# Thu Apr  6 17:05:58 2006
+#
+CONFIG_ARM=y
+CONFIG_MMU=y
+CONFIG_RWSEM_GENERIC_SPINLOCK=y
+CONFIG_GENERIC_HWEIGHT=y
+CONFIG_GENERIC_CALIBRATE_DELAY=y
+CONFIG_VECTORS_BASE=0xffff0000
+
+#
+# Code maturity level options
+#
+CONFIG_EXPERIMENTAL=y
+CONFIG_BROKEN_ON_SMP=y
+CONFIG_LOCK_KERNEL=y
+CONFIG_INIT_ENV_ARG_LIMIT=32
+
+#
+# General setup
+#
+CONFIG_LOCALVERSION=""
+CONFIG_LOCALVERSION_AUTO=y
+CONFIG_SWAP=y
+CONFIG_SYSVIPC=y
+CONFIG_POSIX_MQUEUE=y
+CONFIG_BSD_PROCESS_ACCT=y
+# CONFIG_BSD_PROCESS_ACCT_V3 is not set
+CONFIG_SYSCTL=y
+CONFIG_AUDIT=y
+# CONFIG_IKCONFIG is not set
+# CONFIG_RELAY is not set
+CONFIG_INITRAMFS_SOURCE=""
+CONFIG_UID16=y
+CONFIG_CC_OPTIMIZE_FOR_SIZE=y
+CONFIG_EMBEDDED=y
+CONFIG_KALLSYMS=y
+# CONFIG_KALLSYMS_ALL is not set
+# CONFIG_KALLSYMS_EXTRA_PASS is not set
+CONFIG_HOTPLUG=y
+CONFIG_PRINTK=y
+CONFIG_BUG=y
+CONFIG_ELF_CORE=y
+CONFIG_BASE_FULL=y
+CONFIG_FUTEX=y
+CONFIG_EPOLL=y
+CONFIG_SHMEM=y
+CONFIG_SLAB=y
+# CONFIG_TINY_SHMEM is not set
+CONFIG_BASE_SMALL=0
+# CONFIG_SLOB is not set
+CONFIG_OBSOLETE_INTERMODULE=m
+
+#
+# Loadable module support
+#
+CONFIG_MODULES=y
+CONFIG_MODULE_UNLOAD=y
+CONFIG_MODULE_FORCE_UNLOAD=y
+CONFIG_MODVERSIONS=y
+CONFIG_MODULE_SRCVERSION_ALL=y
+CONFIG_KMOD=y
+
+#
+# Block layer
+#
+# CONFIG_BLK_DEV_IO_TRACE is not set
+
+#
+# IO Schedulers
+#
+CONFIG_IOSCHED_NOOP=y
+CONFIG_IOSCHED_AS=y
+CONFIG_IOSCHED_DEADLINE=y
+CONFIG_IOSCHED_CFQ=y
+CONFIG_DEFAULT_AS=y
+# CONFIG_DEFAULT_DEADLINE is not set
+# CONFIG_DEFAULT_CFQ is not set
+# CONFIG_DEFAULT_NOOP is not set
+CONFIG_DEFAULT_IOSCHED="anticipatory"
+
+#
+# System Type
+#
+# CONFIG_ARCH_CLPS7500 is not set
+# CONFIG_ARCH_CLPS711X is not set
+# CONFIG_ARCH_CO285 is not set
+# CONFIG_ARCH_EBSA110 is not set
+# CONFIG_ARCH_EP93XX is not set
+# CONFIG_ARCH_FOOTBRIDGE is not set
+# CONFIG_ARCH_INTEGRATOR is not set
+# CONFIG_ARCH_IOP3XX is not set
+# CONFIG_ARCH_IXP4XX is not set
+# CONFIG_ARCH_IXP2000 is not set
+# CONFIG_ARCH_IXP23XX is not set
+# CONFIG_ARCH_L7200 is not set
+# CONFIG_ARCH_PXA is not set
+# CONFIG_ARCH_RPC is not set
+# CONFIG_ARCH_SA1100 is not set
+# CONFIG_ARCH_S3C2410 is not set
+# CONFIG_ARCH_SHARK is not set
+# CONFIG_ARCH_LH7A40X is not set
+# CONFIG_ARCH_OMAP is not set
+# CONFIG_ARCH_VERSATILE is not set
+# CONFIG_ARCH_REALVIEW is not set
+# CONFIG_ARCH_IMX is not set
+# CONFIG_ARCH_H720X is not set
+# CONFIG_ARCH_AAEC2000 is not set
+# CONFIG_ARCH_AT91RM9200 is not set
+CONFIG_ARCH_PNX4008=y
+
+#
+# Processor Type
+#
+CONFIG_CPU_32=y
+CONFIG_CPU_ARM926T=y
+CONFIG_CPU_32v5=y
+CONFIG_CPU_ABRT_EV5TJ=y
+CONFIG_CPU_CACHE_VIVT=y
+CONFIG_CPU_COPY_V4WB=y
+CONFIG_CPU_TLB_V4WBI=y
+
+#
+# Processor Features
+#
+CONFIG_ARM_THUMB=y
+# CONFIG_CPU_ICACHE_DISABLE is not set
+# CONFIG_CPU_DCACHE_DISABLE is not set
+# CONFIG_CPU_DCACHE_WRITETHROUGH is not set
+# CONFIG_CPU_CACHE_ROUND_ROBIN is not set
+
+#
+# Bus support
+#
+
+#
+# PCCARD (PCMCIA/CardBus) support
+#
+CONFIG_PCCARD=m
+# CONFIG_PCMCIA_DEBUG is not set
+CONFIG_PCMCIA=m
+CONFIG_PCMCIA_LOAD_CIS=y
+CONFIG_PCMCIA_IOCTL=y
+
+#
+# PC-card bridges
+#
+
+#
+# Kernel Features
+#
+CONFIG_PREEMPT=y
+# CONFIG_NO_IDLE_HZ is not set
+CONFIG_HZ=100
+# CONFIG_AEABI is not set
+# CONFIG_ARCH_DISCONTIGMEM_ENABLE is not set
+CONFIG_SELECT_MEMORY_MODEL=y
+CONFIG_FLATMEM_MANUAL=y
+# CONFIG_DISCONTIGMEM_MANUAL is not set
+# CONFIG_SPARSEMEM_MANUAL is not set
+CONFIG_FLATMEM=y
+CONFIG_FLAT_NODE_MEM_MAP=y
+# CONFIG_SPARSEMEM_STATIC is not set
+CONFIG_SPLIT_PTLOCK_CPUS=4096
+CONFIG_ALIGNMENT_TRAP=y
+
+#
+# Boot options
+#
+CONFIG_ZBOOT_ROM_TEXT=0
+CONFIG_ZBOOT_ROM_BSS=0
+CONFIG_CMDLINE="mem=64M console=ttyS0,115200"
+# CONFIG_XIP_KERNEL is not set
+
+#
+# Floating point emulation
+#
+
+#
+# At least one emulation must be selected
+#
+# CONFIG_FPE_NWFPE is not set
+# CONFIG_FPE_FASTFPE is not set
+# CONFIG_VFP is not set
+
+#
+# Userspace binary formats
+#
+CONFIG_BINFMT_ELF=y
+CONFIG_BINFMT_AOUT=m
+CONFIG_BINFMT_MISC=m
+# CONFIG_ARTHUR is not set
+
+#
+# Power management options
+#
+CONFIG_PM=y
+CONFIG_PM_LEGACY=y
+# CONFIG_PM_DEBUG is not set
+CONFIG_APM=m
+
+#
+# Networking
+#
+CONFIG_NET=y
+
+#
+# Networking options
+#
+# CONFIG_NETDEBUG is not set
+CONFIG_PACKET=m
+CONFIG_PACKET_MMAP=y
+CONFIG_UNIX=m
+CONFIG_XFRM=y
+CONFIG_XFRM_USER=m
+CONFIG_NET_KEY=m
+CONFIG_INET=y
+CONFIG_IP_MULTICAST=y
+CONFIG_IP_ADVANCED_ROUTER=y
+CONFIG_ASK_IP_FIB_HASH=y
+# CONFIG_IP_FIB_TRIE is not set
+CONFIG_IP_FIB_HASH=y
+CONFIG_IP_MULTIPLE_TABLES=y
+CONFIG_IP_ROUTE_FWMARK=y
+CONFIG_IP_ROUTE_MULTIPATH=y
+# CONFIG_IP_ROUTE_MULTIPATH_CACHED is not set
+CONFIG_IP_ROUTE_VERBOSE=y
+# CONFIG_IP_PNP is not set
+CONFIG_NET_IPIP=m
+CONFIG_NET_IPGRE=m
+CONFIG_NET_IPGRE_BROADCAST=y
+CONFIG_IP_MROUTE=y
+CONFIG_IP_PIMSM_V1=y
+CONFIG_IP_PIMSM_V2=y
+# CONFIG_ARPD is not set
+CONFIG_SYN_COOKIES=y
+CONFIG_INET_AH=m
+CONFIG_INET_ESP=m
+CONFIG_INET_IPCOMP=m
+CONFIG_INET_XFRM_TUNNEL=m
+CONFIG_INET_TUNNEL=m
+CONFIG_INET_DIAG=y
+CONFIG_INET_TCP_DIAG=y
+# CONFIG_TCP_CONG_ADVANCED is not set
+CONFIG_TCP_CONG_BIC=y
+
+#
+# IP: Virtual Server Configuration
+#
+CONFIG_IP_VS=m
+# CONFIG_IP_VS_DEBUG is not set
+CONFIG_IP_VS_TAB_BITS=12
+
+#
+# IPVS transport protocol load balancing support
+#
+CONFIG_IP_VS_PROTO_TCP=y
+CONFIG_IP_VS_PROTO_UDP=y
+CONFIG_IP_VS_PROTO_ESP=y
+CONFIG_IP_VS_PROTO_AH=y
+
+#
+# IPVS scheduler
+#
+CONFIG_IP_VS_RR=m
+CONFIG_IP_VS_WRR=m
+CONFIG_IP_VS_LC=m
+CONFIG_IP_VS_WLC=m
+CONFIG_IP_VS_LBLC=m
+CONFIG_IP_VS_LBLCR=m
+CONFIG_IP_VS_DH=m
+CONFIG_IP_VS_SH=m
+CONFIG_IP_VS_SED=m
+CONFIG_IP_VS_NQ=m
+
+#
+# IPVS application helper
+#
+CONFIG_IP_VS_FTP=m
+CONFIG_IPV6=m
+CONFIG_IPV6_PRIVACY=y
+# CONFIG_IPV6_ROUTER_PREF is not set
+CONFIG_INET6_AH=m
+CONFIG_INET6_ESP=m
+CONFIG_INET6_IPCOMP=m
+CONFIG_INET6_XFRM_TUNNEL=m
+CONFIG_INET6_TUNNEL=m
+CONFIG_IPV6_TUNNEL=m
+CONFIG_NETFILTER=y
+# CONFIG_NETFILTER_DEBUG is not set
+CONFIG_BRIDGE_NETFILTER=y
+
+#
+# Core Netfilter Configuration
+#
+# CONFIG_NETFILTER_NETLINK is not set
+# CONFIG_NETFILTER_XTABLES is not set
+
+#
+# IP: Netfilter Configuration
+#
+CONFIG_IP_NF_CONNTRACK=m
+CONFIG_IP_NF_CT_ACCT=y
+CONFIG_IP_NF_CONNTRACK_MARK=y
+# CONFIG_IP_NF_CONNTRACK_EVENTS is not set
+CONFIG_IP_NF_CT_PROTO_SCTP=m
+CONFIG_IP_NF_FTP=m
+CONFIG_IP_NF_IRC=m
+# CONFIG_IP_NF_NETBIOS_NS is not set
+CONFIG_IP_NF_TFTP=m
+CONFIG_IP_NF_AMANDA=m
+# CONFIG_IP_NF_PPTP is not set
+# CONFIG_IP_NF_H323 is not set
+CONFIG_IP_NF_QUEUE=m
+
+#
+# IPv6: Netfilter Configuration (EXPERIMENTAL)
+#
+CONFIG_IP6_NF_QUEUE=m
+
+#
+# DECnet: Netfilter Configuration
+#
+CONFIG_DECNET_NF_GRABULATOR=m
+
+#
+# Bridge: Netfilter Configuration
+#
+CONFIG_BRIDGE_NF_EBTABLES=m
+CONFIG_BRIDGE_EBT_BROUTE=m
+CONFIG_BRIDGE_EBT_T_FILTER=m
+CONFIG_BRIDGE_EBT_T_NAT=m
+CONFIG_BRIDGE_EBT_802_3=m
+CONFIG_BRIDGE_EBT_AMONG=m
+CONFIG_BRIDGE_EBT_ARP=m
+CONFIG_BRIDGE_EBT_IP=m
+CONFIG_BRIDGE_EBT_LIMIT=m
+CONFIG_BRIDGE_EBT_MARK=m
+CONFIG_BRIDGE_EBT_PKTTYPE=m
+CONFIG_BRIDGE_EBT_STP=m
+CONFIG_BRIDGE_EBT_VLAN=m
+CONFIG_BRIDGE_EBT_ARPREPLY=m
+CONFIG_BRIDGE_EBT_DNAT=m
+CONFIG_BRIDGE_EBT_MARK_T=m
+CONFIG_BRIDGE_EBT_REDIRECT=m
+CONFIG_BRIDGE_EBT_SNAT=m
+CONFIG_BRIDGE_EBT_LOG=m
+# CONFIG_BRIDGE_EBT_ULOG is not set
+
+#
+# DCCP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_DCCP is not set
+
+#
+# SCTP Configuration (EXPERIMENTAL)
+#
+CONFIG_IP_SCTP=m
+# CONFIG_SCTP_DBG_MSG is not set
+# CONFIG_SCTP_DBG_OBJCNT is not set
+# CONFIG_SCTP_HMAC_NONE is not set
+# CONFIG_SCTP_HMAC_SHA1 is not set
+CONFIG_SCTP_HMAC_MD5=y
+
+#
+# TIPC Configuration (EXPERIMENTAL)
+#
+# CONFIG_TIPC is not set
+CONFIG_ATM=y
+CONFIG_ATM_CLIP=y
+# CONFIG_ATM_CLIP_NO_ICMP is not set
+CONFIG_ATM_LANE=m
+CONFIG_ATM_MPOA=m
+CONFIG_ATM_BR2684=m
+# CONFIG_ATM_BR2684_IPFILTER is not set
+CONFIG_BRIDGE=m
+CONFIG_VLAN_8021Q=m
+CONFIG_DECNET=m
+# CONFIG_DECNET_ROUTER is not set
+CONFIG_LLC=m
+CONFIG_LLC2=m
+CONFIG_IPX=m
+# CONFIG_IPX_INTERN is not set
+CONFIG_ATALK=m
+CONFIG_DEV_APPLETALK=y
+CONFIG_IPDDP=m
+CONFIG_IPDDP_ENCAP=y
+CONFIG_IPDDP_DECAP=y
+CONFIG_X25=m
+CONFIG_LAPB=m
+# CONFIG_NET_DIVERT is not set
+CONFIG_ECONET=m
+CONFIG_ECONET_AUNUDP=y
+CONFIG_ECONET_NATIVE=y
+CONFIG_WAN_ROUTER=m
+
+#
+# QoS and/or fair queueing
+#
+CONFIG_NET_SCHED=y
+CONFIG_NET_SCH_CLK_JIFFIES=y
+# CONFIG_NET_SCH_CLK_GETTIMEOFDAY is not set
+# CONFIG_NET_SCH_CLK_CPU is not set
+
+#
+# Queueing/Scheduling
+#
+CONFIG_NET_SCH_CBQ=m
+CONFIG_NET_SCH_HTB=m
+CONFIG_NET_SCH_HFSC=m
+CONFIG_NET_SCH_ATM=m
+CONFIG_NET_SCH_PRIO=m
+CONFIG_NET_SCH_RED=m
+CONFIG_NET_SCH_SFQ=m
+CONFIG_NET_SCH_TEQL=m
+CONFIG_NET_SCH_TBF=m
+CONFIG_NET_SCH_GRED=m
+CONFIG_NET_SCH_DSMARK=m
+CONFIG_NET_SCH_NETEM=m
+CONFIG_NET_SCH_INGRESS=m
+
+#
+# Classification
+#
+CONFIG_NET_CLS=y
+# CONFIG_NET_CLS_BASIC is not set
+CONFIG_NET_CLS_TCINDEX=m
+CONFIG_NET_CLS_ROUTE4=m
+CONFIG_NET_CLS_ROUTE=y
+CONFIG_NET_CLS_FW=m
+CONFIG_NET_CLS_U32=m
+# CONFIG_CLS_U32_PERF is not set
+# CONFIG_CLS_U32_MARK is not set
+CONFIG_NET_CLS_RSVP=m
+CONFIG_NET_CLS_RSVP6=m
+# CONFIG_NET_EMATCH is not set
+# CONFIG_NET_CLS_ACT is not set
+CONFIG_NET_CLS_POLICE=y
+# CONFIG_NET_CLS_IND is not set
+CONFIG_NET_ESTIMATOR=y
+
+#
+# Network testing
+#
+CONFIG_NET_PKTGEN=m
+CONFIG_HAMRADIO=y
+
+#
+# Packet Radio protocols
+#
+CONFIG_AX25=m
+# CONFIG_AX25_DAMA_SLAVE is not set
+CONFIG_NETROM=m
+CONFIG_ROSE=m
+
+#
+# AX.25 network device drivers
+#
+CONFIG_MKISS=m
+CONFIG_6PACK=m
+CONFIG_BPQETHER=m
+CONFIG_BAYCOM_SER_FDX=m
+CONFIG_BAYCOM_SER_HDX=m
+CONFIG_BAYCOM_PAR=m
+CONFIG_BAYCOM_EPP=m
+CONFIG_YAM=m
+CONFIG_IRDA=m
+
+#
+# IrDA protocols
+#
+CONFIG_IRLAN=m
+CONFIG_IRNET=m
+CONFIG_IRCOMM=m
+# CONFIG_IRDA_ULTRA is not set
+
+#
+# IrDA options
+#
+CONFIG_IRDA_CACHE_LAST_LSAP=y
+CONFIG_IRDA_FAST_RR=y
+CONFIG_IRDA_DEBUG=y
+
+#
+# Infrared-port device drivers
+#
+
+#
+# SIR device drivers
+#
+CONFIG_IRTTY_SIR=m
+
+#
+# Dongle support
+#
+CONFIG_DONGLE=y
+CONFIG_ESI_DONGLE=m
+CONFIG_ACTISYS_DONGLE=m
+CONFIG_TEKRAM_DONGLE=m
+# CONFIG_TOIM3232_DONGLE is not set
+CONFIG_LITELINK_DONGLE=m
+CONFIG_MA600_DONGLE=m
+CONFIG_GIRBIL_DONGLE=m
+CONFIG_MCP2120_DONGLE=m
+CONFIG_OLD_BELKIN_DONGLE=m
+CONFIG_ACT200L_DONGLE=m
+
+#
+# Old SIR device drivers
+#
+CONFIG_IRPORT_SIR=m
+
+#
+# Old Serial dongle support
+#
+# CONFIG_DONGLE_OLD is not set
+
+#
+# FIR device drivers
+#
+CONFIG_USB_IRDA=m
+CONFIG_SIGMATEL_FIR=m
+CONFIG_BT=m
+CONFIG_BT_L2CAP=m
+CONFIG_BT_SCO=m
+CONFIG_BT_RFCOMM=m
+CONFIG_BT_RFCOMM_TTY=y
+CONFIG_BT_BNEP=m
+CONFIG_BT_BNEP_MC_FILTER=y
+CONFIG_BT_BNEP_PROTO_FILTER=y
+CONFIG_BT_CMTP=m
+CONFIG_BT_HIDP=m
+
+#
+# Bluetooth device drivers
+#
+CONFIG_BT_HCIUSB=m
+CONFIG_BT_HCIUSB_SCO=y
+CONFIG_BT_HCIUART=m
+CONFIG_BT_HCIUART_H4=y
+CONFIG_BT_HCIUART_BCSP=y
+CONFIG_BT_HCIBCM203X=m
+# CONFIG_BT_HCIBPA10X is not set
+CONFIG_BT_HCIBFUSB=m
+CONFIG_BT_HCIDTL1=m
+CONFIG_BT_HCIBT3C=m
+CONFIG_BT_HCIBLUECARD=m
+CONFIG_BT_HCIBTUART=m
+CONFIG_BT_HCIVHCI=m
+CONFIG_IEEE80211=m
+# CONFIG_IEEE80211_DEBUG is not set
+# CONFIG_IEEE80211_CRYPT_WEP is not set
+CONFIG_IEEE80211_CRYPT_CCMP=m
+CONFIG_IEEE80211_CRYPT_TKIP=m
+# CONFIG_IEEE80211_SOFTMAC is not set
+CONFIG_WIRELESS_EXT=y
+
+#
+# Device Drivers
+#
+
+#
+# Generic Driver Options
+#
+CONFIG_STANDALONE=y
+CONFIG_PREVENT_FIRMWARE_BUILD=y
+CONFIG_FW_LOADER=m
+# CONFIG_DEBUG_DRIVER is not set
+
+#
+# Connector - unified userspace <-> kernelspace linker
+#
+# CONFIG_CONNECTOR is not set
+
+#
+# Memory Technology Devices (MTD)
+#
+CONFIG_MTD=m
+# CONFIG_MTD_DEBUG is not set
+CONFIG_MTD_CONCAT=m
+CONFIG_MTD_PARTITIONS=y
+CONFIG_MTD_REDBOOT_PARTS=m
+CONFIG_MTD_REDBOOT_DIRECTORY_BLOCK=-1
+# CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED is not set
+# CONFIG_MTD_REDBOOT_PARTS_READONLY is not set
+# CONFIG_MTD_CMDLINE_PARTS is not set
+# CONFIG_MTD_AFS_PARTS is not set
+
+#
+# User Modules And Translation Layers
+#
+CONFIG_MTD_CHAR=m
+CONFIG_MTD_BLOCK=m
+CONFIG_MTD_BLOCK_RO=m
+CONFIG_FTL=m
+CONFIG_NFTL=m
+CONFIG_NFTL_RW=y
+CONFIG_INFTL=m
+# CONFIG_RFD_FTL is not set
+
+#
+# RAM/ROM/Flash chip drivers
+#
+CONFIG_MTD_CFI=m
+CONFIG_MTD_JEDECPROBE=m
+CONFIG_MTD_GEN_PROBE=m
+# CONFIG_MTD_CFI_ADV_OPTIONS is not set
+CONFIG_MTD_MAP_BANK_WIDTH_1=y
+CONFIG_MTD_MAP_BANK_WIDTH_2=y
+CONFIG_MTD_MAP_BANK_WIDTH_4=y
+# CONFIG_MTD_MAP_BANK_WIDTH_8 is not set
+# CONFIG_MTD_MAP_BANK_WIDTH_16 is not set
+# CONFIG_MTD_MAP_BANK_WIDTH_32 is not set
+CONFIG_MTD_CFI_I1=y
+CONFIG_MTD_CFI_I2=y
+# CONFIG_MTD_CFI_I4 is not set
+# CONFIG_MTD_CFI_I8 is not set
+CONFIG_MTD_CFI_INTELEXT=m
+CONFIG_MTD_CFI_AMDSTD=m
+CONFIG_MTD_CFI_STAA=m
+CONFIG_MTD_CFI_UTIL=m
+CONFIG_MTD_RAM=m
+CONFIG_MTD_ROM=m
+CONFIG_MTD_ABSENT=m
+# CONFIG_MTD_OBSOLETE_CHIPS is not set
+
+#
+# Mapping drivers for chip access
+#
+CONFIG_MTD_COMPLEX_MAPPINGS=y
+CONFIG_MTD_PHYSMAP=m
+CONFIG_MTD_PHYSMAP_START=0x8000000
+CONFIG_MTD_PHYSMAP_LEN=0x4000000
+CONFIG_MTD_PHYSMAP_BANKWIDTH=2
+# CONFIG_MTD_ARM_INTEGRATOR is not set
+# CONFIG_MTD_IMPA7 is not set
+# CONFIG_MTD_PLATRAM is not set
+
+#
+# Self-contained MTD device drivers
+#
+CONFIG_MTD_SLRAM=m
+CONFIG_MTD_PHRAM=m
+CONFIG_MTD_MTDRAM=m
+CONFIG_MTDRAM_TOTAL_SIZE=4096
+CONFIG_MTDRAM_ERASE_SIZE=128
+CONFIG_MTD_BLKMTD=m
+# CONFIG_MTD_BLOCK2MTD is not set
+
+#
+# Disk-On-Chip Device Drivers
+#
+CONFIG_MTD_DOC2000=m
+CONFIG_MTD_DOC2001=m
+CONFIG_MTD_DOC2001PLUS=m
+CONFIG_MTD_DOCPROBE=m
+CONFIG_MTD_DOCECC=m
+# CONFIG_MTD_DOCPROBE_ADVANCED is not set
+CONFIG_MTD_DOCPROBE_ADDRESS=0
+
+#
+# NAND Flash Device Drivers
+#
+CONFIG_MTD_NAND=m
+# CONFIG_MTD_NAND_VERIFY_WRITE is not set
+CONFIG_MTD_NAND_IDS=m
+CONFIG_MTD_NAND_DISKONCHIP=m
+# CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADVANCED is not set
+CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS=0
+# CONFIG_MTD_NAND_DISKONCHIP_BBTWRITE is not set
+# CONFIG_MTD_NAND_NANDSIM is not set
+
+#
+# OneNAND Flash Device Drivers
+#
+# CONFIG_MTD_ONENAND is not set
+
+#
+# Parallel port support
+#
+CONFIG_PARPORT=m
+CONFIG_PARPORT_PC=m
+CONFIG_PARPORT_PC_FIFO=y
+# CONFIG_PARPORT_PC_SUPERIO is not set
+CONFIG_PARPORT_PC_PCMCIA=m
+CONFIG_PARPORT_NOT_PC=y
+# CONFIG_PARPORT_ARC is not set
+# CONFIG_PARPORT_GSC is not set
+CONFIG_PARPORT_1284=y
+
+#
+# Plug and Play support
+#
+
+#
+# Block devices
+#
+CONFIG_PARIDE=m
+CONFIG_PARIDE_PARPORT=m
+
+#
+# Parallel IDE high-level drivers
+#
+CONFIG_PARIDE_PD=m
+CONFIG_PARIDE_PCD=m
+CONFIG_PARIDE_PF=m
+CONFIG_PARIDE_PT=m
+CONFIG_PARIDE_PG=m
+
+#
+# Parallel IDE protocol modules
+#
+CONFIG_PARIDE_ATEN=m
+CONFIG_PARIDE_BPCK=m
+CONFIG_PARIDE_BPCK6=m
+CONFIG_PARIDE_COMM=m
+CONFIG_PARIDE_DSTR=m
+CONFIG_PARIDE_FIT2=m
+CONFIG_PARIDE_FIT3=m
+CONFIG_PARIDE_EPAT=m
+# CONFIG_PARIDE_EPATC8 is not set
+CONFIG_PARIDE_EPIA=m
+CONFIG_PARIDE_FRIQ=m
+CONFIG_PARIDE_FRPW=m
+CONFIG_PARIDE_KBIC=m
+CONFIG_PARIDE_KTTI=m
+CONFIG_PARIDE_ON20=m
+CONFIG_PARIDE_ON26=m
+# CONFIG_BLK_DEV_COW_COMMON is not set
+CONFIG_BLK_DEV_LOOP=m
+CONFIG_BLK_DEV_CRYPTOLOOP=m
+CONFIG_BLK_DEV_NBD=m
+# CONFIG_BLK_DEV_UB is not set
+CONFIG_BLK_DEV_RAM=y
+CONFIG_BLK_DEV_RAM_COUNT=16
+CONFIG_BLK_DEV_RAM_SIZE=8192
+CONFIG_BLK_DEV_INITRD=y
+CONFIG_CDROM_PKTCDVD=m
+CONFIG_CDROM_PKTCDVD_BUFFERS=8
+# CONFIG_CDROM_PKTCDVD_WCACHE is not set
+# CONFIG_ATA_OVER_ETH is not set
+
+#
+# ATA/ATAPI/MFM/RLL support
+#
+CONFIG_IDE=m
+CONFIG_BLK_DEV_IDE=m
+
+#
+# Please see Documentation/ide.txt for help/info on IDE drives
+#
+# CONFIG_BLK_DEV_IDE_SATA is not set
+CONFIG_BLK_DEV_IDEDISK=m
+# CONFIG_IDEDISK_MULTI_MODE is not set
+CONFIG_BLK_DEV_IDECS=m
+CONFIG_BLK_DEV_IDECD=m
+CONFIG_BLK_DEV_IDETAPE=m
+CONFIG_BLK_DEV_IDEFLOPPY=m
+CONFIG_BLK_DEV_IDESCSI=m
+# CONFIG_IDE_TASK_IOCTL is not set
+
+#
+# IDE chipset support/bugfixes
+#
+CONFIG_IDE_GENERIC=m
+# CONFIG_IDE_ARM is not set
+# CONFIG_BLK_DEV_IDEDMA is not set
+# CONFIG_IDEDMA_AUTO is not set
+# CONFIG_BLK_DEV_HD is not set
+
+#
+# SCSI device support
+#
+# CONFIG_RAID_ATTRS is not set
+CONFIG_SCSI=m
+CONFIG_SCSI_PROC_FS=y
+
+#
+# SCSI support type (disk, tape, CD-ROM)
+#
+CONFIG_BLK_DEV_SD=m
+CONFIG_CHR_DEV_ST=m
+CONFIG_CHR_DEV_OSST=m
+CONFIG_BLK_DEV_SR=m
+# CONFIG_BLK_DEV_SR_VENDOR is not set
+CONFIG_CHR_DEV_SG=m
+CONFIG_CHR_DEV_SCH=m
+
+#
+# Some SCSI devices (e.g. CD jukebox) support multiple LUNs
+#
+CONFIG_SCSI_MULTI_LUN=y
+CONFIG_SCSI_CONSTANTS=y
+CONFIG_SCSI_LOGGING=y
+
+#
+# SCSI Transport Attributes
+#
+CONFIG_SCSI_SPI_ATTRS=m
+CONFIG_SCSI_FC_ATTRS=m
+# CONFIG_SCSI_ISCSI_ATTRS is not set
+# CONFIG_SCSI_SAS_ATTRS is not set
+
+#
+# SCSI low-level drivers
+#
+# CONFIG_ISCSI_TCP is not set
+CONFIG_SCSI_SATA=m
+CONFIG_SCSI_PPA=m
+CONFIG_SCSI_IMM=m
+# CONFIG_SCSI_IZIP_EPP16 is not set
+# CONFIG_SCSI_IZIP_SLOW_CTR is not set
+CONFIG_SCSI_DEBUG=m
+
+#
+# PCMCIA SCSI adapter support
+#
+CONFIG_PCMCIA_AHA152X=m
+CONFIG_PCMCIA_FDOMAIN=m
+CONFIG_PCMCIA_NINJA_SCSI=m
+CONFIG_PCMCIA_QLOGIC=m
+CONFIG_PCMCIA_SYM53C500=m
+
+#
+# Multi-device support (RAID and LVM)
+#
+CONFIG_MD=y
+CONFIG_BLK_DEV_MD=m
+CONFIG_MD_LINEAR=m
+CONFIG_MD_RAID0=m
+CONFIG_MD_RAID1=m
+CONFIG_MD_RAID10=m
+CONFIG_MD_RAID5=m
+# CONFIG_MD_RAID5_RESHAPE is not set
+CONFIG_MD_RAID6=m
+CONFIG_MD_MULTIPATH=m
+CONFIG_MD_FAULTY=m
+CONFIG_BLK_DEV_DM=m
+CONFIG_DM_CRYPT=m
+CONFIG_DM_SNAPSHOT=m
+CONFIG_DM_MIRROR=m
+CONFIG_DM_ZERO=m
+# CONFIG_DM_MULTIPATH is not set
+
+#
+# Fusion MPT device support
+#
+# CONFIG_FUSION is not set
+
+#
+# IEEE 1394 (FireWire) support
+#
+
+#
+# I2O device support
+#
+
+#
+# Network device support
+#
+CONFIG_NETDEVICES=y
+CONFIG_DUMMY=m
+CONFIG_BONDING=m
+CONFIG_EQUALIZER=m
+CONFIG_TUN=m
+
+#
+# PHY device support
+#
+# CONFIG_PHYLIB is not set
+
+#
+# Ethernet (10 or 100Mbit)
+#
+CONFIG_NET_ETHERNET=y
+CONFIG_MII=m
+# CONFIG_SMC91X is not set
+# CONFIG_DM9000 is not set
+CONFIG_NET_POCKET=y
+CONFIG_DE600=m
+CONFIG_DE620=m
+
+#
+# Ethernet (1000 Mbit)
+#
+
+#
+# Ethernet (10000 Mbit)
+#
+
+#
+# Token Ring devices
+#
+
+#
+# Wireless LAN (non-hamradio)
+#
+CONFIG_NET_RADIO=y
+# CONFIG_NET_WIRELESS_RTNETLINK is not set
+
+#
+# Obsolete Wireless cards support (pre-802.11)
+#
+CONFIG_STRIP=m
+CONFIG_PCMCIA_WAVELAN=m
+CONFIG_PCMCIA_NETWAVE=m
+
+#
+# Wireless 802.11 Frequency Hopping cards support
+#
+CONFIG_PCMCIA_RAYCS=m
+
+#
+# Wireless 802.11b ISA/PCI cards support
+#
+CONFIG_HERMES=m
+CONFIG_ATMEL=m
+
+#
+# Wireless 802.11b Pcmcia/Cardbus cards support
+#
+CONFIG_PCMCIA_HERMES=m
+# CONFIG_PCMCIA_SPECTRUM is not set
+CONFIG_AIRO_CS=m
+CONFIG_PCMCIA_ATMEL=m
+CONFIG_PCMCIA_WL3501=m
+# CONFIG_HOSTAP is not set
+CONFIG_NET_WIRELESS=y
+
+#
+# PCMCIA network device support
+#
+CONFIG_NET_PCMCIA=y
+CONFIG_PCMCIA_3C589=m
+CONFIG_PCMCIA_3C574=m
+CONFIG_PCMCIA_FMVJ18X=m
+CONFIG_PCMCIA_PCNET=m
+CONFIG_PCMCIA_NMCLAN=m
+CONFIG_PCMCIA_SMC91C92=m
+CONFIG_PCMCIA_XIRC2PS=m
+CONFIG_PCMCIA_AXNET=m
+
+#
+# Wan interfaces
+#
+CONFIG_WAN=y
+CONFIG_SYNCLINK_SYNCPPP=m
+CONFIG_HDLC=m
+CONFIG_HDLC_RAW=y
+CONFIG_HDLC_RAW_ETH=y
+CONFIG_HDLC_CISCO=y
+CONFIG_HDLC_FR=y
+CONFIG_HDLC_PPP=y
+CONFIG_HDLC_X25=y
+CONFIG_DLCI=m
+CONFIG_DLCI_COUNT=24
+CONFIG_DLCI_MAX=8
+CONFIG_WAN_ROUTER_DRIVERS=y
+CONFIG_LAPBETHER=m
+CONFIG_X25_ASY=m
+
+#
+# ATM drivers
+#
+# CONFIG_ATM_DUMMY is not set
+CONFIG_ATM_TCP=m
+CONFIG_PLIP=m
+CONFIG_PPP=m
+CONFIG_PPP_MULTILINK=y
+CONFIG_PPP_FILTER=y
+CONFIG_PPP_ASYNC=m
+CONFIG_PPP_SYNC_TTY=m
+CONFIG_PPP_DEFLATE=m
+CONFIG_PPP_BSDCOMP=m
+CONFIG_PPP_MPPE=m
+CONFIG_PPPOE=m
+CONFIG_PPPOATM=m
+CONFIG_SLIP=m
+CONFIG_SLIP_COMPRESSED=y
+CONFIG_SLIP_SMART=y
+CONFIG_SLIP_MODE_SLIP6=y
+CONFIG_SHAPER=m
+CONFIG_NETCONSOLE=m
+CONFIG_NETPOLL=y
+# CONFIG_NETPOLL_RX is not set
+# CONFIG_NETPOLL_TRAP is not set
+CONFIG_NET_POLL_CONTROLLER=y
+
+#
+# ISDN subsystem
+#
+CONFIG_ISDN=m
+
+#
+# Old ISDN4Linux
+#
+CONFIG_ISDN_I4L=m
+CONFIG_ISDN_PPP=y
+CONFIG_ISDN_PPP_VJ=y
+CONFIG_ISDN_MPP=y
+CONFIG_IPPP_FILTER=y
+CONFIG_ISDN_PPP_BSDCOMP=m
+CONFIG_ISDN_AUDIO=y
+CONFIG_ISDN_TTY_FAX=y
+CONFIG_ISDN_X25=y
+
+#
+# ISDN feature submodules
+#
+CONFIG_ISDN_DRV_LOOP=m
+CONFIG_ISDN_DIVERSION=m
+
+#
+# ISDN4Linux hardware drivers
+#
+
+#
+# Passive cards
+#
+CONFIG_ISDN_DRV_HISAX=m
+
+#
+# D-channel protocol features
+#
+CONFIG_HISAX_EURO=y
+CONFIG_DE_AOC=y
+# CONFIG_HISAX_NO_SENDCOMPLETE is not set
+# CONFIG_HISAX_NO_LLC is not set
+# CONFIG_HISAX_NO_KEYPAD is not set
+CONFIG_HISAX_1TR6=y
+CONFIG_HISAX_NI1=y
+CONFIG_HISAX_MAX_CARDS=8
+
+#
+# HiSax supported cards
+#
+CONFIG_HISAX_16_3=y
+CONFIG_HISAX_S0BOX=y
+CONFIG_HISAX_FRITZPCI=y
+CONFIG_HISAX_AVM_A1_PCMCIA=y
+CONFIG_HISAX_ELSA=y
+CONFIG_HISAX_DIEHLDIVA=y
+CONFIG_HISAX_SEDLBAUER=y
+CONFIG_HISAX_NICCY=y
+CONFIG_HISAX_GAZEL=y
+CONFIG_HISAX_HFC_SX=y
+# CONFIG_HISAX_DEBUG is not set
+
+#
+# HiSax PCMCIA card service modules
+#
+CONFIG_HISAX_SEDLBAUER_CS=m
+CONFIG_HISAX_ELSA_CS=m
+CONFIG_HISAX_AVM_A1_CS=m
+CONFIG_HISAX_TELES_CS=m
+
+#
+# HiSax sub driver modules
+#
+CONFIG_HISAX_ST5481=m
+CONFIG_HISAX_HFCUSB=m
+# CONFIG_HISAX_HFC4S8S is not set
+CONFIG_HISAX_HDLC=y
+
+#
+# Active cards
+#
+
+#
+# Siemens Gigaset
+#
+# CONFIG_ISDN_DRV_GIGASET is not set
+
+#
+# CAPI subsystem
+#
+CONFIG_ISDN_CAPI=m
+CONFIG_ISDN_DRV_AVMB1_VERBOSE_REASON=y
+CONFIG_ISDN_CAPI_MIDDLEWARE=y
+CONFIG_ISDN_CAPI_CAPI20=m
+CONFIG_ISDN_CAPI_CAPIFS_BOOL=y
+CONFIG_ISDN_CAPI_CAPIFS=m
+CONFIG_ISDN_CAPI_CAPIDRV=m
+
+#
+# CAPI hardware drivers
+#
+
+#
+# Active AVM cards
+#
+CONFIG_CAPI_AVM=y
+CONFIG_ISDN_DRV_AVMB1_B1PCMCIA=m
+CONFIG_ISDN_DRV_AVMB1_AVM_CS=m
+
+#
+# Active Eicon DIVA Server cards
+#
+CONFIG_CAPI_EICON=y
+
+#
+# Input device support
+#
+CONFIG_INPUT=y
+
+#
+# Userland interfaces
+#
+CONFIG_INPUT_MOUSEDEV=m
+CONFIG_INPUT_MOUSEDEV_PSAUX=y
+CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
+CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
+CONFIG_INPUT_JOYDEV=m
+CONFIG_INPUT_TSDEV=m
+CONFIG_INPUT_TSDEV_SCREEN_X=240
+CONFIG_INPUT_TSDEV_SCREEN_Y=320
+CONFIG_INPUT_EVDEV=m
+CONFIG_INPUT_EVBUG=m
+
+#
+# Input Device Drivers
+#
+CONFIG_INPUT_KEYBOARD=y
+CONFIG_KEYBOARD_ATKBD=y
+CONFIG_KEYBOARD_SUNKBD=m
+CONFIG_KEYBOARD_LKKBD=m
+CONFIG_KEYBOARD_XTKBD=m
+CONFIG_KEYBOARD_NEWTON=m
+CONFIG_INPUT_MOUSE=y
+CONFIG_MOUSE_PS2=m
+CONFIG_MOUSE_SERIAL=m
+CONFIG_MOUSE_VSXXXAA=m
+CONFIG_INPUT_JOYSTICK=y
+CONFIG_JOYSTICK_ANALOG=m
+CONFIG_JOYSTICK_A3D=m
+CONFIG_JOYSTICK_ADI=m
+CONFIG_JOYSTICK_COBRA=m
+CONFIG_JOYSTICK_GF2K=m
+CONFIG_JOYSTICK_GRIP=m
+CONFIG_JOYSTICK_GRIP_MP=m
+CONFIG_JOYSTICK_GUILLEMOT=m
+CONFIG_JOYSTICK_INTERACT=m
+CONFIG_JOYSTICK_SIDEWINDER=m
+CONFIG_JOYSTICK_TMDC=m
+CONFIG_JOYSTICK_IFORCE=m
+CONFIG_JOYSTICK_IFORCE_USB=y
+CONFIG_JOYSTICK_IFORCE_232=y
+CONFIG_JOYSTICK_WARRIOR=m
+CONFIG_JOYSTICK_MAGELLAN=m
+CONFIG_JOYSTICK_SPACEORB=m
+CONFIG_JOYSTICK_SPACEBALL=m
+CONFIG_JOYSTICK_STINGER=m
+# CONFIG_JOYSTICK_TWIDJOY is not set
+CONFIG_JOYSTICK_DB9=m
+CONFIG_JOYSTICK_GAMECON=m
+CONFIG_JOYSTICK_TURBOGRAFX=m
+CONFIG_JOYSTICK_JOYDUMP=m
+CONFIG_INPUT_TOUCHSCREEN=y
+CONFIG_TOUCHSCREEN_GUNZE=m
+# CONFIG_TOUCHSCREEN_ELO is not set
+# CONFIG_TOUCHSCREEN_MTOUCH is not set
+# CONFIG_TOUCHSCREEN_MK712 is not set
+CONFIG_INPUT_MISC=y
+CONFIG_INPUT_UINPUT=m
+
+#
+# Hardware I/O ports
+#
+CONFIG_SERIO=y
+CONFIG_SERIO_SERPORT=m
+CONFIG_SERIO_PARKBD=m
+CONFIG_SERIO_LIBPS2=y
+CONFIG_SERIO_RAW=m
+CONFIG_GAMEPORT=m
+CONFIG_GAMEPORT_NS558=m
+CONFIG_GAMEPORT_L4=m
+
+#
+# Character devices
+#
+CONFIG_VT=y
+CONFIG_VT_CONSOLE=y
+CONFIG_HW_CONSOLE=y
+CONFIG_SERIAL_NONSTANDARD=y
+CONFIG_COMPUTONE=m
+CONFIG_ROCKETPORT=m
+CONFIG_CYCLADES=m
+# CONFIG_CYZ_INTR is not set
+CONFIG_DIGIEPCA=m
+CONFIG_MOXA_INTELLIO=m
+CONFIG_MOXA_SMARTIO=m
+# CONFIG_ISI is not set
+CONFIG_SYNCLINKMP=m
+CONFIG_N_HDLC=m
+# CONFIG_RISCOM8 is not set
+# CONFIG_SPECIALIX is not set
+CONFIG_SX=m
+CONFIG_RIO=m
+CONFIG_RIO_OLDPCI=y
+CONFIG_STALDRV=y
+CONFIG_STALLION=m
+CONFIG_ISTALLION=m
+
+#
+# Serial drivers
+#
+CONFIG_SERIAL_8250=y
+CONFIG_SERIAL_8250_CONSOLE=y
+CONFIG_SERIAL_8250_CS=m
+CONFIG_SERIAL_8250_NR_UARTS=4
+CONFIG_SERIAL_8250_RUNTIME_UARTS=4
+CONFIG_SERIAL_8250_EXTENDED=y
+CONFIG_SERIAL_8250_MANY_PORTS=y
+CONFIG_SERIAL_8250_SHARE_IRQ=y
+# CONFIG_SERIAL_8250_DETECT_IRQ is not set
+CONFIG_SERIAL_8250_RSA=y
+
+#
+# Non-8250 serial port support
+#
+CONFIG_SERIAL_CORE=y
+CONFIG_SERIAL_CORE_CONSOLE=y
+CONFIG_UNIX98_PTYS=y
+CONFIG_LEGACY_PTYS=y
+CONFIG_LEGACY_PTY_COUNT=256
+CONFIG_PRINTER=m
+# CONFIG_LP_CONSOLE is not set
+CONFIG_PPDEV=m
+CONFIG_TIPAR=m
+
+#
+# IPMI
+#
+CONFIG_IPMI_HANDLER=m
+# CONFIG_IPMI_PANIC_EVENT is not set
+CONFIG_IPMI_DEVICE_INTERFACE=m
+CONFIG_IPMI_SI=m
+CONFIG_IPMI_WATCHDOG=m
+CONFIG_IPMI_POWEROFF=m
+
+#
+# Watchdog Cards
+#
+CONFIG_WATCHDOG=y
+# CONFIG_WATCHDOG_NOWAYOUT is not set
+
+#
+# Watchdog Device Drivers
+#
+CONFIG_SOFT_WATCHDOG=m
+
+#
+# USB-based Watchdog Cards
+#
+CONFIG_USBPCWATCHDOG=m
+CONFIG_NVRAM=m
+CONFIG_DTLK=m
+CONFIG_R3964=m
+
+#
+# Ftape, the floppy tape device driver
+#
+
+#
+# PCMCIA character devices
+#
+CONFIG_SYNCLINK_CS=m
+# CONFIG_CARDMAN_4000 is not set
+# CONFIG_CARDMAN_4040 is not set
+CONFIG_RAW_DRIVER=m
+CONFIG_MAX_RAW_DEVS=256
+
+#
+# TPM devices
+#
+# CONFIG_TCG_TPM is not set
+# CONFIG_TELCLOCK is not set
+
+#
+# I2C support
+#
+CONFIG_I2C=m
+CONFIG_I2C_CHARDEV=m
+
+#
+# I2C Algorithms
+#
+CONFIG_I2C_ALGOBIT=m
+CONFIG_I2C_ALGOPCF=m
+CONFIG_I2C_ALGOPCA=m
+
+#
+# I2C Hardware Bus support
+#
+CONFIG_I2C_ISA=m
+CONFIG_I2C_PARPORT=m
+CONFIG_I2C_PARPORT_LIGHT=m
+CONFIG_I2C_STUB=m
+CONFIG_I2C_PCA_ISA=m
+
+#
+# Miscellaneous I2C Chip support
+#
+# CONFIG_SENSORS_DS1337 is not set
+# CONFIG_SENSORS_DS1374 is not set
+CONFIG_SENSORS_EEPROM=m
+CONFIG_SENSORS_PCF8574=m
+# CONFIG_SENSORS_PCA9539 is not set
+CONFIG_SENSORS_PCF8591=m
+# CONFIG_SENSORS_MAX6875 is not set
+# CONFIG_I2C_DEBUG_CORE is not set
+# CONFIG_I2C_DEBUG_ALGO is not set
+# CONFIG_I2C_DEBUG_BUS is not set
+# CONFIG_I2C_DEBUG_CHIP is not set
+
+#
+# SPI support
+#
+# CONFIG_SPI is not set
+# CONFIG_SPI_MASTER is not set
+
+#
+# Dallas's 1-wire bus
+#
+CONFIG_W1=m
+
+#
+# 1-wire Bus Masters
+#
+# CONFIG_W1_MASTER_DS9490 is not set
+# CONFIG_W1_MASTER_DS2482 is not set
+
+#
+# 1-wire Slaves
+#
+# CONFIG_W1_SLAVE_THERM is not set
+# CONFIG_W1_SLAVE_SMEM is not set
+# CONFIG_W1_SLAVE_DS2433 is not set
+
+#
+# Hardware Monitoring support
+#
+CONFIG_HWMON=y
+CONFIG_HWMON_VID=m
+CONFIG_SENSORS_ADM1021=m
+CONFIG_SENSORS_ADM1025=m
+CONFIG_SENSORS_ADM1026=m
+CONFIG_SENSORS_ADM1031=m
+# CONFIG_SENSORS_ADM9240 is not set
+CONFIG_SENSORS_ASB100=m
+# CONFIG_SENSORS_ATXP1 is not set
+CONFIG_SENSORS_DS1621=m
+# CONFIG_SENSORS_F71805F is not set
+CONFIG_SENSORS_FSCHER=m
+# CONFIG_SENSORS_FSCPOS is not set
+CONFIG_SENSORS_GL518SM=m
+# CONFIG_SENSORS_GL520SM is not set
+CONFIG_SENSORS_IT87=m
+CONFIG_SENSORS_LM63=m
+CONFIG_SENSORS_LM75=m
+CONFIG_SENSORS_LM77=m
+CONFIG_SENSORS_LM78=m
+CONFIG_SENSORS_LM80=m
+CONFIG_SENSORS_LM83=m
+CONFIG_SENSORS_LM85=m
+CONFIG_SENSORS_LM87=m
+CONFIG_SENSORS_LM90=m
+# CONFIG_SENSORS_LM92 is not set
+CONFIG_SENSORS_MAX1619=m
+CONFIG_SENSORS_PC87360=m
+CONFIG_SENSORS_SMSC47M1=m
+# CONFIG_SENSORS_SMSC47B397 is not set
+CONFIG_SENSORS_W83781D=m
+# CONFIG_SENSORS_W83792D is not set
+CONFIG_SENSORS_W83L785TS=m
+CONFIG_SENSORS_W83627HF=m
+# CONFIG_SENSORS_W83627EHF is not set
+# CONFIG_HWMON_DEBUG_CHIP is not set
+
+#
+# Misc devices
+#
+
+#
+# LED devices
+#
+# CONFIG_NEW_LEDS is not set
+
+#
+# Multimedia devices
+#
+# CONFIG_VIDEO_DEV is not set
+
+#
+# Digital Video Broadcasting Devices
+#
+CONFIG_DVB=y
+CONFIG_DVB_CORE=m
+
+#
+# Supported USB Adapters
+#
+# CONFIG_DVB_USB is not set
+CONFIG_DVB_TTUSB_BUDGET=m
+CONFIG_DVB_TTUSB_DEC=m
+CONFIG_DVB_CINERGYT2=m
+CONFIG_DVB_CINERGYT2_TUNING=y
+CONFIG_DVB_CINERGYT2_STREAM_URB_COUNT=32
+CONFIG_DVB_CINERGYT2_STREAM_BUF_SIZE=512
+CONFIG_DVB_CINERGYT2_QUERY_INTERVAL=250
+CONFIG_DVB_CINERGYT2_ENABLE_RC_INPUT_DEVICE=y
+CONFIG_DVB_CINERGYT2_RC_QUERY_INTERVAL=100
+
+#
+# Supported FlexCopII (B2C2) Adapters
+#
+# CONFIG_DVB_B2C2_FLEXCOP is not set
+
+#
+# Supported DVB Frontends
+#
+
+#
+# Customise DVB Frontends
+#
+
+#
+# DVB-S (satellite) frontends
+#
+CONFIG_DVB_STV0299=m
+CONFIG_DVB_CX24110=m
+# CONFIG_DVB_CX24123 is not set
+CONFIG_DVB_TDA8083=m
+CONFIG_DVB_MT312=m
+CONFIG_DVB_VES1X93=m
+# CONFIG_DVB_S5H1420 is not set
+
+#
+# DVB-T (terrestrial) frontends
+#
+CONFIG_DVB_SP8870=m
+CONFIG_DVB_SP887X=m
+CONFIG_DVB_CX22700=m
+CONFIG_DVB_CX22702=m
+CONFIG_DVB_L64781=m
+CONFIG_DVB_TDA1004X=m
+CONFIG_DVB_NXT6000=m
+CONFIG_DVB_MT352=m
+# CONFIG_DVB_ZL10353 is not set
+CONFIG_DVB_DIB3000MB=m
+CONFIG_DVB_DIB3000MC=m
+
+#
+# DVB-C (cable) frontends
+#
+CONFIG_DVB_VES1820=m
+CONFIG_DVB_TDA10021=m
+CONFIG_DVB_STV0297=m
+
+#
+# ATSC (North American/Korean Terresterial DTV) frontends
+#
+# CONFIG_DVB_NXT200X is not set
+# CONFIG_DVB_OR51211 is not set
+# CONFIG_DVB_OR51132 is not set
+# CONFIG_DVB_BCM3510 is not set
+# CONFIG_DVB_LGDT330X is not set
+# CONFIG_USB_DABUSB is not set
+
+#
+# Graphics support
+#
+# CONFIG_FB is not set
+
+#
+# Console display driver support
+#
+# CONFIG_VGA_CONSOLE is not set
+CONFIG_DUMMY_CONSOLE=y
+
+#
+# Sound
+#
+CONFIG_SOUND=m
+
+#
+# Advanced Linux Sound Architecture
+#
+CONFIG_SND=m
+CONFIG_SND_TIMER=m
+CONFIG_SND_PCM=m
+CONFIG_SND_HWDEP=m
+CONFIG_SND_RAWMIDI=m
+CONFIG_SND_SEQUENCER=m
+CONFIG_SND_SEQ_DUMMY=m
+CONFIG_SND_OSSEMUL=y
+CONFIG_SND_MIXER_OSS=m
+CONFIG_SND_PCM_OSS=m
+CONFIG_SND_PCM_OSS_PLUGINS=y
+CONFIG_SND_SEQUENCER_OSS=y
+# CONFIG_SND_DYNAMIC_MINORS is not set
+CONFIG_SND_SUPPORT_OLD_API=y
+CONFIG_SND_VERBOSE_PROCFS=y
+# CONFIG_SND_VERBOSE_PRINTK is not set
+# CONFIG_SND_DEBUG is not set
+
+#
+# Generic devices
+#
+CONFIG_SND_MPU401_UART=m
+CONFIG_SND_DUMMY=m
+CONFIG_SND_VIRMIDI=m
+CONFIG_SND_MTPAV=m
+CONFIG_SND_SERIAL_U16550=m
+CONFIG_SND_MPU401=m
+
+#
+# ALSA ARM devices
+#
+
+#
+# USB devices
+#
+CONFIG_SND_USB_AUDIO=m
+
+#
+# PCMCIA devices
+#
+
+#
+# Open Sound System
+#
+CONFIG_SOUND_PRIME=m
+# CONFIG_OBSOLETE_OSS_DRIVER is not set
+# CONFIG_SOUND_MSNDCLAS is not set
+# CONFIG_SOUND_MSNDPIN is not set
+CONFIG_SOUND_TVMIXER=m
+
+#
+# USB support
+#
+CONFIG_USB_ARCH_HAS_HCD=y
+# CONFIG_USB_ARCH_HAS_OHCI is not set
+# CONFIG_USB_ARCH_HAS_EHCI is not set
+CONFIG_USB=m
+# CONFIG_USB_DEBUG is not set
+
+#
+# Miscellaneous USB options
+#
+CONFIG_USB_DEVICEFS=y
+CONFIG_USB_BANDWIDTH=y
+# CONFIG_USB_DYNAMIC_MINORS is not set
+# CONFIG_USB_SUSPEND is not set
+# CONFIG_USB_OTG is not set
+
+#
+# USB Host Controller Drivers
+#
+# CONFIG_USB_ISP116X_HCD is not set
+CONFIG_USB_SL811_HCD=m
+# CONFIG_USB_SL811_CS is not set
+
+#
+# USB Device Class drivers
+#
+CONFIG_USB_ACM=m
+CONFIG_USB_PRINTER=m
+
+#
+# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
+#
+
+#
+# may also be needed; see USB_STORAGE Help for more information
+#
+CONFIG_USB_STORAGE=m
+# CONFIG_USB_STORAGE_DEBUG is not set
+CONFIG_USB_STORAGE_DATAFAB=y
+CONFIG_USB_STORAGE_FREECOM=y
+CONFIG_USB_STORAGE_ISD200=y
+CONFIG_USB_STORAGE_DPCM=y
+CONFIG_USB_STORAGE_USBAT=y
+CONFIG_USB_STORAGE_SDDR09=y
+CONFIG_USB_STORAGE_SDDR55=y
+CONFIG_USB_STORAGE_JUMPSHOT=y
+# CONFIG_USB_STORAGE_ALAUDA is not set
+# CONFIG_USB_LIBUSUAL is not set
+
+#
+# USB Input Devices
+#
+CONFIG_USB_HID=m
+CONFIG_USB_HIDINPUT=y
+# CONFIG_USB_HIDINPUT_POWERBOOK is not set
+# CONFIG_HID_FF is not set
+CONFIG_USB_HIDDEV=y
+
+#
+# USB HID Boot Protocol drivers
+#
+CONFIG_USB_KBD=m
+CONFIG_USB_MOUSE=m
+CONFIG_USB_AIPTEK=m
+CONFIG_USB_WACOM=m
+# CONFIG_USB_ACECAD is not set
+CONFIG_USB_KBTAB=m
+CONFIG_USB_POWERMATE=m
+CONFIG_USB_MTOUCH=m
+# CONFIG_USB_ITMTOUCH is not set
+CONFIG_USB_EGALAX=m
+# CONFIG_USB_YEALINK is not set
+CONFIG_USB_XPAD=m
+CONFIG_USB_ATI_REMOTE=m
+# CONFIG_USB_ATI_REMOTE2 is not set
+# CONFIG_USB_KEYSPAN_REMOTE is not set
+# CONFIG_USB_APPLETOUCH is not set
+
+#
+# USB Imaging devices
+#
+CONFIG_USB_MDC800=m
+CONFIG_USB_MICROTEK=m
+
+#
+# USB Network Adapters
+#
+CONFIG_USB_CATC=m
+CONFIG_USB_KAWETH=m
+CONFIG_USB_PEGASUS=m
+CONFIG_USB_RTL8150=m
+CONFIG_USB_USBNET=m
+CONFIG_USB_NET_AX8817X=m
+CONFIG_USB_NET_CDCETHER=m
+# CONFIG_USB_NET_GL620A is not set
+CONFIG_USB_NET_NET1080=m
+# CONFIG_USB_NET_PLUSB is not set
+# CONFIG_USB_NET_RNDIS_HOST is not set
+# CONFIG_USB_NET_CDC_SUBSET is not set
+CONFIG_USB_NET_ZAURUS=m
+# CONFIG_USB_ZD1201 is not set
+CONFIG_USB_MON=y
+
+#
+# USB port drivers
+#
+CONFIG_USB_USS720=m
+
+#
+# USB Serial Converter support
+#
+CONFIG_USB_SERIAL=m
+CONFIG_USB_SERIAL_GENERIC=y
+# CONFIG_USB_SERIAL_AIRPRIME is not set
+# CONFIG_USB_SERIAL_ANYDATA is not set
+CONFIG_USB_SERIAL_BELKIN=m
+CONFIG_USB_SERIAL_WHITEHEAT=m
+CONFIG_USB_SERIAL_DIGI_ACCELEPORT=m
+# CONFIG_USB_SERIAL_CP2101 is not set
+CONFIG_USB_SERIAL_CYPRESS_M8=m
+CONFIG_USB_SERIAL_EMPEG=m
+CONFIG_USB_SERIAL_FTDI_SIO=m
+CONFIG_USB_SERIAL_VISOR=m
+CONFIG_USB_SERIAL_IPAQ=m
+CONFIG_USB_SERIAL_IR=m
+CONFIG_USB_SERIAL_EDGEPORT=m
+CONFIG_USB_SERIAL_EDGEPORT_TI=m
+# CONFIG_USB_SERIAL_GARMIN is not set
+CONFIG_USB_SERIAL_IPW=m
+CONFIG_USB_SERIAL_KEYSPAN_PDA=m
+CONFIG_USB_SERIAL_KEYSPAN=m
+# CONFIG_USB_SERIAL_KEYSPAN_MPR is not set
+# CONFIG_USB_SERIAL_KEYSPAN_USA28 is not set
+# CONFIG_USB_SERIAL_KEYSPAN_USA28X is not set
+# CONFIG_USB_SERIAL_KEYSPAN_USA28XA is not set
+# CONFIG_USB_SERIAL_KEYSPAN_USA28XB is not set
+# CONFIG_USB_SERIAL_KEYSPAN_USA19 is not set
+# CONFIG_USB_SERIAL_KEYSPAN_USA18X is not set
+# CONFIG_USB_SERIAL_KEYSPAN_USA19W is not set
+# CONFIG_USB_SERIAL_KEYSPAN_USA19QW is not set
+# CONFIG_USB_SERIAL_KEYSPAN_USA19QI is not set
+# CONFIG_USB_SERIAL_KEYSPAN_USA49W is not set
+# CONFIG_USB_SERIAL_KEYSPAN_USA49WLC is not set
+CONFIG_USB_SERIAL_KLSI=m
+CONFIG_USB_SERIAL_KOBIL_SCT=m
+CONFIG_USB_SERIAL_MCT_U232=m
+# CONFIG_USB_SERIAL_NAVMAN is not set
+CONFIG_USB_SERIAL_PL2303=m
+# CONFIG_USB_SERIAL_HP4X is not set
+CONFIG_USB_SERIAL_SAFE=m
+# CONFIG_USB_SERIAL_SAFE_PADDED is not set
+# CONFIG_USB_SERIAL_TI is not set
+CONFIG_USB_SERIAL_CYBERJACK=m
+CONFIG_USB_SERIAL_XIRCOM=m
+CONFIG_USB_SERIAL_OMNINET=m
+CONFIG_USB_EZUSB=y
+
+#
+# USB Miscellaneous drivers
+#
+# CONFIG_USB_EMI62 is not set
+# CONFIG_USB_EMI26 is not set
+CONFIG_USB_AUERSWALD=m
+CONFIG_USB_RIO500=m
+CONFIG_USB_LEGOTOWER=m
+CONFIG_USB_LCD=m
+CONFIG_USB_LED=m
+CONFIG_USB_CYTHERM=m
+CONFIG_USB_PHIDGETKIT=m
+CONFIG_USB_PHIDGETSERVO=m
+# CONFIG_USB_IDMOUSE is not set
+# CONFIG_USB_LD is not set
+CONFIG_USB_TEST=m
+
+#
+# USB DSL modem support
+#
+CONFIG_USB_ATM=m
+CONFIG_USB_SPEEDTOUCH=m
+# CONFIG_USB_CXACRU is not set
+# CONFIG_USB_UEAGLEATM is not set
+# CONFIG_USB_XUSBATM is not set
+
+#
+# USB Gadget Support
+#
+CONFIG_USB_GADGET=m
+# CONFIG_USB_GADGET_DEBUG_FILES is not set
+CONFIG_USB_GADGET_SELECTED=y
+# CONFIG_USB_GADGET_NET2280 is not set
+# CONFIG_USB_GADGET_PXA2XX is not set
+# CONFIG_USB_GADGET_GOKU is not set
+# CONFIG_USB_GADGET_LH7A40X is not set
+# CONFIG_USB_GADGET_OMAP is not set
+# CONFIG_USB_GADGET_AT91 is not set
+CONFIG_USB_GADGET_DUMMY_HCD=y
+CONFIG_USB_DUMMY_HCD=m
+CONFIG_USB_GADGET_DUALSPEED=y
+CONFIG_USB_ZERO=m
+CONFIG_USB_ETH=m
+CONFIG_USB_ETH_RNDIS=y
+CONFIG_USB_GADGETFS=m
+CONFIG_USB_FILE_STORAGE=m
+# CONFIG_USB_FILE_STORAGE_TEST is not set
+CONFIG_USB_G_SERIAL=m
+
+#
+# MMC/SD Card support
+#
+CONFIG_MMC=m
+# CONFIG_MMC_DEBUG is not set
+CONFIG_MMC_BLOCK=m
+
+#
+# Real Time Clock
+#
+CONFIG_RTC_LIB=y
+# CONFIG_RTC_CLASS is not set
+
+#
+# File systems
+#
+CONFIG_EXT2_FS=y
+CONFIG_EXT2_FS_XATTR=y
+CONFIG_EXT2_FS_POSIX_ACL=y
+CONFIG_EXT2_FS_SECURITY=y
+# CONFIG_EXT2_FS_XIP is not set
+CONFIG_EXT3_FS=m
+CONFIG_EXT3_FS_XATTR=y
+CONFIG_EXT3_FS_POSIX_ACL=y
+CONFIG_EXT3_FS_SECURITY=y
+CONFIG_JBD=m
+# CONFIG_JBD_DEBUG is not set
+CONFIG_FS_MBCACHE=y
+CONFIG_REISERFS_FS=m
+# CONFIG_REISERFS_CHECK is not set
+# CONFIG_REISERFS_PROC_INFO is not set
+CONFIG_REISERFS_FS_XATTR=y
+CONFIG_REISERFS_FS_POSIX_ACL=y
+CONFIG_REISERFS_FS_SECURITY=y
+CONFIG_JFS_FS=m
+CONFIG_JFS_POSIX_ACL=y
+# CONFIG_JFS_SECURITY is not set
+# CONFIG_JFS_DEBUG is not set
+CONFIG_JFS_STATISTICS=y
+CONFIG_FS_POSIX_ACL=y
+CONFIG_XFS_FS=m
+CONFIG_XFS_EXPORT=y
+CONFIG_XFS_QUOTA=y
+CONFIG_XFS_SECURITY=y
+CONFIG_XFS_POSIX_ACL=y
+CONFIG_XFS_RT=y
+# CONFIG_OCFS2_FS is not set
+CONFIG_MINIX_FS=m
+CONFIG_ROMFS_FS=m
+CONFIG_INOTIFY=y
+CONFIG_QUOTA=y
+CONFIG_QFMT_V1=m
+CONFIG_QFMT_V2=m
+CONFIG_QUOTACTL=y
+CONFIG_DNOTIFY=y
+CONFIG_AUTOFS_FS=m
+CONFIG_AUTOFS4_FS=m
+# CONFIG_FUSE_FS is not set
+
+#
+# CD-ROM/DVD Filesystems
+#
+CONFIG_ISO9660_FS=m
+CONFIG_JOLIET=y
+CONFIG_ZISOFS=y
+CONFIG_ZISOFS_FS=m
+CONFIG_UDF_FS=m
+CONFIG_UDF_NLS=y
+
+#
+# DOS/FAT/NT Filesystems
+#
+CONFIG_FAT_FS=m
+CONFIG_MSDOS_FS=m
+CONFIG_VFAT_FS=m
+CONFIG_FAT_DEFAULT_CODEPAGE=437
+CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
+CONFIG_NTFS_FS=m
+# CONFIG_NTFS_DEBUG is not set
+# CONFIG_NTFS_RW is not set
+
+#
+# Pseudo filesystems
+#
+CONFIG_PROC_FS=y
+CONFIG_SYSFS=y
+CONFIG_TMPFS=y
+# CONFIG_HUGETLB_PAGE is not set
+CONFIG_RAMFS=y
+# CONFIG_CONFIGFS_FS is not set
+
+#
+# Miscellaneous filesystems
+#
+CONFIG_ADFS_FS=m
+# CONFIG_ADFS_FS_RW is not set
+CONFIG_AFFS_FS=m
+CONFIG_HFS_FS=m
+CONFIG_HFSPLUS_FS=m
+CONFIG_BEFS_FS=m
+# CONFIG_BEFS_DEBUG is not set
+CONFIG_BFS_FS=m
+CONFIG_EFS_FS=m
+CONFIG_JFFS_FS=m
+CONFIG_JFFS_FS_VERBOSE=0
+CONFIG_JFFS_PROC_FS=y
+CONFIG_JFFS2_FS=m
+CONFIG_JFFS2_FS_DEBUG=0
+CONFIG_JFFS2_FS_WRITEBUFFER=y
+# CONFIG_JFFS2_SUMMARY is not set
+# CONFIG_JFFS2_COMPRESSION_OPTIONS is not set
+CONFIG_JFFS2_ZLIB=y
+CONFIG_JFFS2_RTIME=y
+# CONFIG_JFFS2_RUBIN is not set
+CONFIG_CRAMFS=y
+CONFIG_VXFS_FS=m
+CONFIG_HPFS_FS=m
+CONFIG_QNX4FS_FS=m
+CONFIG_SYSV_FS=m
+CONFIG_UFS_FS=m
+
+#
+# Network File Systems
+#
+CONFIG_NFS_FS=m
+CONFIG_NFS_V3=y
+# CONFIG_NFS_V3_ACL is not set
+CONFIG_NFS_V4=y
+CONFIG_NFS_DIRECTIO=y
+CONFIG_NFSD=m
+CONFIG_NFSD_V3=y
+# CONFIG_NFSD_V3_ACL is not set
+CONFIG_NFSD_V4=y
+CONFIG_NFSD_TCP=y
+CONFIG_LOCKD=m
+CONFIG_LOCKD_V4=y
+CONFIG_EXPORTFS=m
+CONFIG_NFS_COMMON=y
+CONFIG_SUNRPC=m
+CONFIG_SUNRPC_GSS=m
+CONFIG_RPCSEC_GSS_KRB5=m
+CONFIG_RPCSEC_GSS_SPKM3=m
+CONFIG_SMB_FS=m
+# CONFIG_SMB_NLS_DEFAULT is not set
+CONFIG_CIFS=m
+# CONFIG_CIFS_STATS is not set
+# CONFIG_CIFS_XATTR is not set
+# CONFIG_CIFS_EXPERIMENTAL is not set
+CONFIG_NCP_FS=m
+CONFIG_NCPFS_PACKET_SIGNING=y
+CONFIG_NCPFS_IOCTL_LOCKING=y
+CONFIG_NCPFS_STRONG=y
+CONFIG_NCPFS_NFS_NS=y
+CONFIG_NCPFS_OS2_NS=y
+# CONFIG_NCPFS_SMALLDOS is not set
+CONFIG_NCPFS_NLS=y
+CONFIG_NCPFS_EXTRAS=y
+CONFIG_CODA_FS=m
+# CONFIG_CODA_FS_OLD_API is not set
+CONFIG_AFS_FS=m
+CONFIG_RXRPC=m
+# CONFIG_9P_FS is not set
+
+#
+# Partition Types
+#
+CONFIG_PARTITION_ADVANCED=y
+CONFIG_ACORN_PARTITION=y
+# CONFIG_ACORN_PARTITION_CUMANA is not set
+# CONFIG_ACORN_PARTITION_EESOX is not set
+CONFIG_ACORN_PARTITION_ICS=y
+# CONFIG_ACORN_PARTITION_ADFS is not set
+# CONFIG_ACORN_PARTITION_POWERTEC is not set
+CONFIG_ACORN_PARTITION_RISCIX=y
+CONFIG_OSF_PARTITION=y
+CONFIG_AMIGA_PARTITION=y
+CONFIG_ATARI_PARTITION=y
+CONFIG_MAC_PARTITION=y
+CONFIG_MSDOS_PARTITION=y
+CONFIG_BSD_DISKLABEL=y
+CONFIG_MINIX_SUBPARTITION=y
+CONFIG_SOLARIS_X86_PARTITION=y
+CONFIG_UNIXWARE_DISKLABEL=y
+CONFIG_LDM_PARTITION=y
+# CONFIG_LDM_DEBUG is not set
+CONFIG_SGI_PARTITION=y
+CONFIG_ULTRIX_PARTITION=y
+CONFIG_SUN_PARTITION=y
+# CONFIG_KARMA_PARTITION is not set
+# CONFIG_EFI_PARTITION is not set
+
+#
+# Native Language Support
+#
+CONFIG_NLS=y
+CONFIG_NLS_DEFAULT="cp437"
+CONFIG_NLS_CODEPAGE_437=m
+CONFIG_NLS_CODEPAGE_737=m
+CONFIG_NLS_CODEPAGE_775=m
+CONFIG_NLS_CODEPAGE_850=m
+CONFIG_NLS_CODEPAGE_852=m
+CONFIG_NLS_CODEPAGE_855=m
+CONFIG_NLS_CODEPAGE_857=m
+CONFIG_NLS_CODEPAGE_860=m
+CONFIG_NLS_CODEPAGE_861=m
+CONFIG_NLS_CODEPAGE_862=m
+CONFIG_NLS_CODEPAGE_863=m
+CONFIG_NLS_CODEPAGE_864=m
+CONFIG_NLS_CODEPAGE_865=m
+CONFIG_NLS_CODEPAGE_866=m
+CONFIG_NLS_CODEPAGE_869=m
+CONFIG_NLS_CODEPAGE_936=m
+CONFIG_NLS_CODEPAGE_950=m
+CONFIG_NLS_CODEPAGE_932=m
+CONFIG_NLS_CODEPAGE_949=m
+CONFIG_NLS_CODEPAGE_874=m
+CONFIG_NLS_ISO8859_8=m
+CONFIG_NLS_CODEPAGE_1250=m
+CONFIG_NLS_CODEPAGE_1251=m
+CONFIG_NLS_ASCII=m
+CONFIG_NLS_ISO8859_1=m
+CONFIG_NLS_ISO8859_2=m
+CONFIG_NLS_ISO8859_3=m
+CONFIG_NLS_ISO8859_4=m
+CONFIG_NLS_ISO8859_5=m
+CONFIG_NLS_ISO8859_6=m
+CONFIG_NLS_ISO8859_7=m
+CONFIG_NLS_ISO8859_9=m
+CONFIG_NLS_ISO8859_13=m
+CONFIG_NLS_ISO8859_14=m
+CONFIG_NLS_ISO8859_15=m
+CONFIG_NLS_KOI8_R=m
+CONFIG_NLS_KOI8_U=m
+CONFIG_NLS_UTF8=m
+
+#
+# Profiling support
+#
+CONFIG_PROFILING=y
+CONFIG_OPROFILE=m
+
+#
+# Kernel hacking
+#
+# CONFIG_PRINTK_TIME is not set
+CONFIG_MAGIC_SYSRQ=y
+CONFIG_DEBUG_KERNEL=y
+CONFIG_LOG_BUF_SHIFT=14
+CONFIG_DETECT_SOFTLOCKUP=y
+# CONFIG_SCHEDSTATS is not set
+# CONFIG_DEBUG_SLAB is not set
+CONFIG_DEBUG_PREEMPT=y
+CONFIG_DEBUG_MUTEXES=y
+# CONFIG_DEBUG_SPINLOCK is not set
+# CONFIG_DEBUG_SPINLOCK_SLEEP is not set
+# CONFIG_DEBUG_KOBJECT is not set
+# CONFIG_DEBUG_BUGVERBOSE is not set
+CONFIG_DEBUG_INFO=y
+# CONFIG_DEBUG_FS is not set
+# CONFIG_DEBUG_VM is not set
+CONFIG_FRAME_POINTER=y
+# CONFIG_UNWIND_INFO is not set
+CONFIG_FORCED_INLINING=y
+# CONFIG_RCU_TORTURE_TEST is not set
+# CONFIG_DEBUG_USER is not set
+# CONFIG_DEBUG_WAITQ is not set
+# CONFIG_DEBUG_ERRORS is not set
+CONFIG_DEBUG_LL=y
+# CONFIG_DEBUG_ICEDCC is not set
+
+#
+# Security options
+#
+# CONFIG_KEYS is not set
+CONFIG_SECURITY=y
+# CONFIG_SECURITY_NETWORK is not set
+CONFIG_SECURITY_CAPABILITIES=m
+CONFIG_SECURITY_ROOTPLUG=m
+CONFIG_SECURITY_SECLVL=m
+
+#
+# Cryptographic options
+#
+CONFIG_CRYPTO=y
+CONFIG_CRYPTO_HMAC=y
+CONFIG_CRYPTO_NULL=m
+CONFIG_CRYPTO_MD4=m
+CONFIG_CRYPTO_MD5=y
+CONFIG_CRYPTO_SHA1=m
+CONFIG_CRYPTO_SHA256=m
+CONFIG_CRYPTO_SHA512=m
+CONFIG_CRYPTO_WP512=m
+# CONFIG_CRYPTO_TGR192 is not set
+CONFIG_CRYPTO_DES=m
+CONFIG_CRYPTO_BLOWFISH=m
+CONFIG_CRYPTO_TWOFISH=m
+CONFIG_CRYPTO_SERPENT=m
+CONFIG_CRYPTO_AES=m
+CONFIG_CRYPTO_CAST5=m
+CONFIG_CRYPTO_CAST6=m
+CONFIG_CRYPTO_TEA=m
+CONFIG_CRYPTO_ARC4=m
+CONFIG_CRYPTO_KHAZAD=m
+CONFIG_CRYPTO_ANUBIS=m
+CONFIG_CRYPTO_DEFLATE=m
+CONFIG_CRYPTO_MICHAEL_MIC=m
+CONFIG_CRYPTO_CRC32C=m
+CONFIG_CRYPTO_TEST=m
+
+#
+# Hardware crypto devices
+#
+
+#
+# Library routines
+#
+CONFIG_CRC_CCITT=m
+CONFIG_CRC16=m
+CONFIG_CRC32=y
+CONFIG_LIBCRC32C=m
+CONFIG_ZLIB_INFLATE=y
+CONFIG_ZLIB_DEFLATE=m
+CONFIG_REED_SOLOMON=m
+CONFIG_REED_SOLOMON_DEC16=y
diff --git a/arch/arm/kernel/entry-common.S b/arch/arm/kernel/entry-common.S
index dbcb11a31f78..b5bcebca1cd6 100644
--- a/arch/arm/kernel/entry-common.S
+++ b/arch/arm/kernel/entry-common.S
@@ -271,7 +271,7 @@ ENTRY(sys_call_table)
 @ r8 = syscall table
                 .type   sys_syscall, #function
 sys_syscall:
-                eor     scno, r0, #__NR_OABI_SYSCALL_BASE
+                bic     scno, r0, #__NR_OABI_SYSCALL_BASE
                 cmp     scno, #__NR_syscall - __NR_SYSCALL_BASE
                 cmpne   scno, #NR_syscalls      @ check range
                 stmloia sp, {r5, r6}            @ shuffle args
diff --git a/arch/arm/kernel/irq.c b/arch/arm/kernel/irq.c
index 2d5896b36181..bcc19fbb32df 100644
--- a/arch/arm/kernel/irq.c
+++ b/arch/arm/kernel/irq.c
@@ -342,10 +342,10 @@ __do_irq(unsigned int irq, struct irqaction *action, struct pt_regs *regs)
 
 #ifdef CONFIG_NO_IDLE_HZ
         if (!(action->flags & SA_TIMER) && system_timer->dyn_tick != NULL) {
-                write_seqlock(&xtime_lock);
+                spin_lock(&system_timer->dyn_tick->lock);
                 if (system_timer->dyn_tick->state & DYN_TICK_ENABLED)
                         system_timer->dyn_tick->handler(irq, 0, regs);
-                write_sequnlock(&xtime_lock);
+                spin_unlock(&system_timer->dyn_tick->lock);
         }
 #endif
 
diff --git a/arch/arm/kernel/time.c b/arch/arm/kernel/time.c
index d6bd435a6857..9c12d4fefbd3 100644
--- a/arch/arm/kernel/time.c
+++ b/arch/arm/kernel/time.c
@@ -379,7 +379,7 @@ static int timer_dyn_tick_enable(void)
         int ret = -ENODEV;
 
         if (dyn_tick) {
-                write_seqlock_irqsave(&xtime_lock, flags);
+                spin_lock_irqsave(&dyn_tick->lock, flags);
                 ret = 0;
                 if (!(dyn_tick->state & DYN_TICK_ENABLED)) {
                         ret = dyn_tick->enable();
@@ -387,7 +387,7 @@ static int timer_dyn_tick_enable(void)
                         if (ret == 0)
                                 dyn_tick->state |= DYN_TICK_ENABLED;
                 }
-                write_sequnlock_irqrestore(&xtime_lock, flags);
+                spin_unlock_irqrestore(&dyn_tick->lock, flags);
         }
 
         return ret;
@@ -400,7 +400,7 @@ static int timer_dyn_tick_disable(void)
         int ret = -ENODEV;
 
         if (dyn_tick) {
-                write_seqlock_irqsave(&xtime_lock, flags);
+                spin_lock_irqsave(&dyn_tick->lock, flags);
                 ret = 0;
                 if (dyn_tick->state & DYN_TICK_ENABLED) {
                         ret = dyn_tick->disable();
@@ -408,7 +408,7 @@ static int timer_dyn_tick_disable(void)
                         if (ret == 0)
                                 dyn_tick->state &= ~DYN_TICK_ENABLED;
                 }
-                write_sequnlock_irqrestore(&xtime_lock, flags);
+                spin_unlock_irqrestore(&dyn_tick->lock, flags);
         }
 
         return ret;
@@ -422,15 +422,20 @@ static int timer_dyn_tick_disable(void)
 void timer_dyn_reprogram(void)
 {
         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
-        unsigned long next, seq;
+        unsigned long next, seq, flags;
 
-        if (dyn_tick && (dyn_tick->state & DYN_TICK_ENABLED)) {
+        if (!dyn_tick)
+                return;
+
+        spin_lock_irqsave(&dyn_tick->lock, flags);
+        if (dyn_tick->state & DYN_TICK_ENABLED) {
                 next = next_timer_interrupt();
                 do {
                         seq = read_seqbegin(&xtime_lock);
-                        dyn_tick->reprogram(next_timer_interrupt() - jiffies);
+                        dyn_tick->reprogram(next - jiffies);
                 } while (read_seqretry(&xtime_lock, seq));
         }
+        spin_unlock_irqrestore(&dyn_tick->lock, flags);
 }
 
 static ssize_t timer_show_dyn_tick(struct sys_device *dev, char *buf)
@@ -499,5 +504,10 @@ void __init time_init(void)
         if (system_timer->offset == NULL)
                 system_timer->offset = dummy_gettimeoffset;
         system_timer->init();
+
+#ifdef CONFIG_NO_IDLE_HZ
+        if (system_timer->dyn_tick)
+                system_timer->dyn_tick->lock = SPIN_LOCK_UNLOCKED;
+#endif
 }
 
diff --git a/arch/arm/mach-lh7a40x/Kconfig b/arch/arm/mach-lh7a40x/Kconfig
index 8a17867a6a24..558a34f53b1c 100644
--- a/arch/arm/mach-lh7a40x/Kconfig
+++ b/arch/arm/mach-lh7a40x/Kconfig
@@ -14,6 +14,7 @@ config MACH_LPD7A400
         bool "LPD7A400 Card Engine"
         select ARCH_LH7A400
 #       select IDE_POLL
+        select HAS_TOUCHSCREEN_ADS7843_LH7
         help
           Say Y here if you are using Logic Product Development's
           LPD7A400 CardEngine.  For the time being, the LPD7A400 and
@@ -23,6 +24,7 @@ config MACH_LPD7A404
         bool "LPD7A404 Card Engine"
         select ARCH_LH7A404
 #       select IDE_POLL
+        select HAS_TOUCHSCREEN_ADC_LH7
         help
           Say Y here if you are using Logic Product Development's
           LPD7A404 CardEngine. For the time being, the LPD7A400 and
@@ -34,6 +36,9 @@ config ARCH_LH7A400
 config ARCH_LH7A404
         bool
 
+config LPD7A40X_CPLD_SSP
+        bool
+
 config LH7A40X_CONTIGMEM
         bool "Disable NUMA Support"
         depends on ARCH_LH7A40X
diff --git a/arch/arm/mach-lh7a40x/Makefile b/arch/arm/mach-lh7a40x/Makefile
index e90512dbc2d6..94b8615fb3c3 100644
--- a/arch/arm/mach-lh7a40x/Makefile
+++ b/arch/arm/mach-lh7a40x/Makefile
@@ -4,11 +4,14 @@
 
 # Object file lists.
 
-obj-y                   := time.o
-obj-$(CONFIG_MACH_KEV7A400) += arch-kev7a400.o irq-lh7a400.o
-obj-$(CONFIG_MACH_LPD7A400) += arch-lpd7a40x.o irq-lh7a400.o
-obj-$(CONFIG_MACH_LPD7A404) += arch-lpd7a40x.o irq-lh7a404.o
-
-obj-m                   :=
-obj-n                   :=
-obj-                    :=
+obj-y                           := time.o clocks.o
+obj-m                           :=
+obj-n                           :=
+obj-                            :=
+
+obj-$(CONFIG_MACH_KEV7A400)     += arch-kev7a400.o irq-lh7a400.o
+obj-$(CONFIG_MACH_LPD7A400)     += arch-lpd7a40x.o irq-lh7a400.o
+obj-$(CONFIG_MACH_LPD7A404)     += arch-lpd7a40x.o irq-lh7a404.o
+obj-$(CONFIG_LPD7A40X_CPLD_SSP) += ssp-cpld.o
+obj-$(CONFIG_FB_ARMCLCD)        += clcd.o
+
diff --git a/arch/arm/mach-lh7a40x/arch-lpd7a40x.c b/arch/arm/mach-lh7a40x/arch-lpd7a40x.c
index 12e23277c5ea..c0e6854289f1 100644
--- a/arch/arm/mach-lh7a40x/arch-lpd7a40x.c
+++ b/arch/arm/mach-lh7a40x/arch-lpd7a40x.c
@@ -23,6 +23,28 @@
 
 #include "common.h"
 
+#define CPLD_INT_NETHERNET      (1<<0)
+#define CPLD_INTMASK_ETHERNET   (1<<2)
+#if defined (CONFIG_MACH_LPD7A400)
+# define CPLD_INT_NTOUCH                (1<<1)
+# define CPLD_INTMASK_TOUCH     (1<<3)
+# define CPLD_INT_PEN           (1<<4)
+# define CPLD_INTMASK_PEN       (1<<4)
+# define CPLD_INT_PIRQ          (1<<4)
+#endif
+#define CPLD_INTMASK_CPLD       (1<<7)
+#define CPLD_INT_CPLD           (1<<6)
+
+#define CPLD_CONTROL_SWINT              (1<<7) /* Disable all CPLD IRQs */
+#define CPLD_CONTROL_OCMSK              (1<<6) /* Mask USB1 connect IRQ */
+#define CPLD_CONTROL_PDRV               (1<<5) /* PCC_nDRV high */
+#define CPLD_CONTROL_USB1C              (1<<4) /* USB1 connect IRQ active */
+#define CPLD_CONTROL_USB1P              (1<<3) /* USB1 power disable */
+#define CPLD_CONTROL_AWKP               (1<<2) /* Auto-wakeup disabled  */
+#define CPLD_CONTROL_LCD_ENABLE         (1<<1) /* LCD Vee enable */
+#define CPLD_CONTROL_WRLAN_NENABLE      (1<<0) /* SMC91x power disable */
+
+
 static struct resource smc91x_resources[] = {
         [0] = {
                 .start  = CPLD00_PHYS,
@@ -48,12 +70,12 @@ static struct platform_device smc91x_device = {
 static struct resource lh7a40x_usbclient_resources[] = {
         [0] = {
                 .start  = USB_PHYS,
-                .end    = (USB_PHYS + 0xFF),
+                .end    = (USB_PHYS + PAGE_SIZE),
                 .flags  = IORESOURCE_MEM,
         },
         [1] = {
-                .start  = IRQ_USBINTR,
-                .end    = IRQ_USBINTR,
+                .start  = IRQ_USB,
+                .end    = IRQ_USB,
                 .flags  = IORESOURCE_IRQ,
         },
 };
@@ -61,7 +83,8 @@ static struct resource lh7a40x_usbclient_resources[] = {
 static u64 lh7a40x_usbclient_dma_mask = 0xffffffffUL;
 
 static struct platform_device lh7a40x_usbclient_device = {
-        .name           = "lh7a40x_udc",
+//      .name           = "lh7a40x_udc",
+        .name           = "lh7-udc",
         .id             = 0,
         .dev            = {
                 .dma_mask = &lh7a40x_usbclient_dma_mask,
@@ -101,7 +124,7 @@ static struct platform_device lh7a404_usbhost_device = {
 
 #endif
 
-static struct platform_device *lpd7a40x_devs[] __initdata = {
+static struct platform_device* lpd7a40x_devs[] __initdata = {
         &smc91x_device,
         &lh7a40x_usbclient_device,
 #if defined (CONFIG_ARCH_LH7A404)
@@ -113,29 +136,52 @@ extern void lpd7a400_map_io (void);
 
 static void __init lpd7a40x_init (void)
 {
-        CPLD_CONTROL |=     (1<<6); /* Mask USB1 connection IRQ */
+#if defined (CONFIG_MACH_LPD7A400)
+        CPLD_CONTROL |= 0
+                | CPLD_CONTROL_SWINT /* Disable software interrupt */
+                | CPLD_CONTROL_OCMSK; /* Mask USB1 connection IRQ */
         CPLD_CONTROL &= ~(0
-                          | (1<<1) /* Disable LCD */
-                          | (1<<0) /* Enable WLAN */
+                          | CPLD_CONTROL_LCD_ENABLE     /* Disable LCD */
+                          | CPLD_CONTROL_WRLAN_NENABLE  /* Enable SMC91x */
                 );
+#endif
+
+#if defined (CONFIG_MACH_LPD7A404)
+        CPLD_CONTROL &= ~(0
+                          | CPLD_CONTROL_WRLAN_NENABLE  /* Enable SMC91x */
+                );
+#endif
 
         platform_add_devices (lpd7a40x_devs, ARRAY_SIZE (lpd7a40x_devs));
+#if defined (CONFIG_FB_ARMCLCD)
+        lh7a40x_clcd_init ();
+#endif
 }
 
 static void lh7a40x_ack_cpld_irq (u32 irq)
 {
-        /* CPLD doesn't have ack capability */
+        /* CPLD doesn't have ack capability, but some devices may */
+
+#if defined (CPLD_INTMASK_TOUCH)
+        /* The touch control *must* mask the the interrupt because the
+         * interrupt bit is read by the driver to determine if the pen
+         * is still down. */
+        if (irq == IRQ_TOUCH)
+                CPLD_INTERRUPTS |= CPLD_INTMASK_TOUCH;
+#endif
 }
 
 static void lh7a40x_mask_cpld_irq (u32 irq)
 {
         switch (irq) {
         case IRQ_LPD7A40X_ETH_INT:
-                CPLD_INTERRUPTS = CPLD_INTERRUPTS | 0x4;
+                CPLD_INTERRUPTS |= CPLD_INTMASK_ETHERNET;
                 break;
-        case IRQ_LPD7A400_TS:
-                CPLD_INTERRUPTS = CPLD_INTERRUPTS | 0x8;
+#if defined (IRQ_TOUCH)
+        case IRQ_TOUCH:
+                CPLD_INTERRUPTS |= CPLD_INTMASK_TOUCH;
                 break;
+#endif
         }
 }
 
@@ -143,11 +189,13 @@ static void lh7a40x_unmask_cpld_irq (u32 irq)
 {
         switch (irq) {
         case IRQ_LPD7A40X_ETH_INT:
-                CPLD_INTERRUPTS = CPLD_INTERRUPTS & ~ 0x4;
+                CPLD_INTERRUPTS &= ~CPLD_INTMASK_ETHERNET;
                 break;
-        case IRQ_LPD7A400_TS:
-                CPLD_INTERRUPTS = CPLD_INTERRUPTS & ~ 0x8;
+#if defined (IRQ_TOUCH)
+        case IRQ_TOUCH:
+                CPLD_INTERRUPTS &= ~CPLD_INTMASK_TOUCH;
                 break;
+#endif
         }
 }
 
@@ -164,11 +212,13 @@ static void lpd7a40x_cpld_handler (unsigned int irq, struct irqdesc *desc,
 
         desc->chip->ack (irq);
 
-        if ((mask & 0x1) == 0)  /* WLAN */
+        if ((mask & (1<<0)) == 0)       /* WLAN */
                 IRQ_DISPATCH (IRQ_LPD7A40X_ETH_INT);
 
-        if ((mask & 0x2) == 0)  /* Touch */
-                IRQ_DISPATCH (IRQ_LPD7A400_TS);
+#if defined (IRQ_TOUCH)
+        if ((mask & (1<<1)) == 0)       /* Touch */
+                IRQ_DISPATCH (IRQ_TOUCH);
+#endif
 
         desc->chip->unmask (irq); /* Level-triggered need this */
 }
@@ -204,9 +254,21 @@ void __init lh7a40x_init_board_irq (void)
 
                 /* Then, configure CPLD interrupt */
 
-        CPLD_INTERRUPTS =   0x9c; /* Disable all CPLD interrupts */
+                        /* Disable all CPLD interrupts */
+#if defined (CONFIG_MACH_LPD7A400)
+        CPLD_INTERRUPTS = CPLD_INTMASK_TOUCH | CPLD_INTMASK_PEN
+                | CPLD_INTMASK_ETHERNET;
+        /* *** FIXME: don't know why we need 7 and 4. 7 is way wrong
+               and 4 is uncefined. */
+        // (1<<7)|(1<<4)|(1<<3)|(1<<2);
+#endif
+#if defined (CONFIG_MACH_LPD7A404)
+        CPLD_INTERRUPTS = CPLD_INTMASK_ETHERNET;
+        /* *** FIXME: don't know why we need 6 and 5, neither is defined. */
+        // (1<<6)|(1<<5)|(1<<3);
+#endif
         GPIO_PFDD       &= ~(1 << pinCPLD); /* Make input */
-        GPIO_INTTYPE1   |=  (1 << pinCPLD); /* Edge triggered */
+        GPIO_INTTYPE1   &= ~(1 << pinCPLD); /* Level triggered */
         GPIO_INTTYPE2   &= ~(1 << pinCPLD); /* Active low */
         barrier ();
         GPIO_GPIOFINTEN |=  (1 << pinCPLD); /* Enable */
@@ -216,7 +278,7 @@ void __init lh7a40x_init_board_irq (void)
         for (irq = IRQ_BOARD_START;
              irq < IRQ_BOARD_START + NR_IRQ_BOARD; ++irq) {
                 set_irq_chip (irq, &lpd7a40x_cpld_chip);
-                set_irq_handler (irq, do_edge_IRQ);
+                set_irq_handler (irq, do_level_IRQ);
                 set_irq_flags (irq, IRQF_VALID);
         }
 
@@ -226,91 +288,109 @@ void __init lh7a40x_init_board_irq (void)
                                  lpd7a40x_cpld_handler);
 }
 
-static struct map_desc lpd7a400_io_desc[] __initdata = {
+static struct map_desc lpd7a40x_io_desc[] __initdata = {
         {
-                .virtual        =     IO_VIRT,
+                .virtual        = IO_VIRT,
                 .pfn            = __phys_to_pfn(IO_PHYS),
-                .length         =           IO_SIZE,
+                .length         = IO_SIZE,
                 .type           = MT_DEVICE
-        }, {    /* Mapping added to work around chip select problems */
+        },
+        {       /* Mapping added to work around chip select problems */
                 .virtual        = IOBARRIER_VIRT,
                 .pfn            = __phys_to_pfn(IOBARRIER_PHYS),
                 .length         = IOBARRIER_SIZE,
                 .type           = MT_DEVICE
-        }, {
+        },
+        {
                 .virtual        = CF_VIRT,
                 .pfn            = __phys_to_pfn(CF_PHYS),
-                .length         =       CF_SIZE,
+                .length         = CF_SIZE,
                 .type           = MT_DEVICE
-        }, {
+        },
+        {
                 .virtual        = CPLD02_VIRT,
                 .pfn            = __phys_to_pfn(CPLD02_PHYS),
-                .length         =       CPLD02_SIZE,
+                .length         = CPLD02_SIZE,
                 .type           = MT_DEVICE
-        }, {
+        },
+        {
                 .virtual        = CPLD06_VIRT,
                 .pfn            = __phys_to_pfn(CPLD06_PHYS),
-                .length         =       CPLD06_SIZE,
+                .length         = CPLD06_SIZE,
+                .type           = MT_DEVICE
+        },
+        {
+                .virtual        = CPLD08_VIRT,
+                .pfn            = __phys_to_pfn(CPLD08_PHYS),
+                .length         = CPLD08_SIZE,
                 .type           = MT_DEVICE
-        }, {
+        },
+        {
                 .virtual        = CPLD08_VIRT,
                 .pfn            = __phys_to_pfn(CPLD08_PHYS),
-                .length         =       CPLD08_SIZE,
+                .length         = CPLD08_SIZE,
                 .type           = MT_DEVICE
-        }, {
+        },
+        {
+                .virtual        = CPLD0A_VIRT,
+                .pfn            = __phys_to_pfn(CPLD0A_PHYS),
+                .length         = CPLD0A_SIZE,
+                .type           = MT_DEVICE
+        },
+        {
                 .virtual        = CPLD0C_VIRT,
                 .pfn            = __phys_to_pfn(CPLD0C_PHYS),
-                .length         =       CPLD0C_SIZE,
+                .length         = CPLD0C_SIZE,
                 .type           = MT_DEVICE
-        }, {
+        },
+        {
                 .virtual        = CPLD0E_VIRT,
                 .pfn            = __phys_to_pfn(CPLD0E_PHYS),
-                .length         =       CPLD0E_SIZE,
+                .length         = CPLD0E_SIZE,
                 .type           = MT_DEVICE
-        }, {
+        },
+        {
                 .virtual        = CPLD10_VIRT,
                 .pfn            = __phys_to_pfn(CPLD10_PHYS),
-                .length         =       CPLD10_SIZE,
+                .length         = CPLD10_SIZE,
                 .type           = MT_DEVICE
-        }, {
+        },
+        {
                 .virtual        = CPLD12_VIRT,
                 .pfn            = __phys_to_pfn(CPLD12_PHYS),
-                .length         =       CPLD12_SIZE,
+                .length         = CPLD12_SIZE,
                 .type           = MT_DEVICE
-        }, {
+        },
+        {
                 .virtual        = CPLD14_VIRT,
                 .pfn            = __phys_to_pfn(CPLD14_PHYS),
-                .length         =       CPLD14_SIZE,
+                .length         = CPLD14_SIZE,
                 .type           = MT_DEVICE
-        }, {
+        },
+        {
                 .virtual        = CPLD16_VIRT,
                 .pfn            = __phys_to_pfn(CPLD16_PHYS),
-                .length         =       CPLD16_SIZE,
+                .length         = CPLD16_SIZE,
                 .type           = MT_DEVICE
-        }, {
+        },
+        {
                 .virtual        = CPLD18_VIRT,
                 .pfn            = __phys_to_pfn(CPLD18_PHYS),
-                .length         =       CPLD18_SIZE,
+                .length         = CPLD18_SIZE,
                 .type           = MT_DEVICE
-        }, {
+        },
+        {
                 .virtual        = CPLD1A_VIRT,
                 .pfn            = __phys_to_pfn(CPLD1A_PHYS),
-                .length         =       CPLD1A_SIZE,
+                .length         = CPLD1A_SIZE,
                 .type           = MT_DEVICE
         },
-        /* This mapping is redundant since the smc driver performs another. */
-/*      { CPLD00_VIRT,  CPLD00_PHYS,    CPLD00_SIZE,    MT_DEVICE }, */
 };
 
 void __init
-lpd7a400_map_io(void)
+lpd7a40x_map_io(void)
 {
-        iotable_init (lpd7a400_io_desc, ARRAY_SIZE (lpd7a400_io_desc));
-
-                /* Fixup (improve) Static Memory Controller settings */
-        SMC_BCR0 = 0x200039af;  /* Boot Flash */
-        SMC_BCR6 = 0x1000fbe0;  /* CPLD */
-        SMC_BCR7 = 0x1000b2c2;  /* Compact Flash */
+        iotable_init (lpd7a40x_io_desc, ARRAY_SIZE (lpd7a40x_io_desc));
 }
 
 #ifdef CONFIG_MACH_LPD7A400
@@ -320,7 +400,7 @@ MACHINE_START (LPD7A400, "Logic Product Development LPD7A400-10")
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((io_p2v (0x80000000))>>18) & 0xfffc,
         .boot_params    = 0xc0000100,
-        .map_io         = lpd7a400_map_io,
+        .map_io         = lpd7a40x_map_io,
         .init_irq       = lh7a400_init_irq,
         .timer          = &lh7a40x_timer,
         .init_machine   = lpd7a40x_init,
@@ -335,7 +415,7 @@ MACHINE_START (LPD7A404, "Logic Product Development LPD7A404-10")
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((io_p2v (0x80000000))>>18) & 0xfffc,
         .boot_params    = 0xc0000100,
-        .map_io         = lpd7a400_map_io,
+        .map_io         = lpd7a40x_map_io,
         .init_irq       = lh7a404_init_irq,
         .timer          = &lh7a40x_timer,
         .init_machine   = lpd7a40x_init,
diff --git a/arch/arm/mach-lh7a40x/clcd.c b/arch/arm/mach-lh7a40x/clcd.c
new file mode 100644
index 000000000000..93751fee793d
--- /dev/null
+++ b/arch/arm/mach-lh7a40x/clcd.c
@@ -0,0 +1,241 @@
+/*
+ *  arch/arm/mach-lh7a40x/clcd.c
+ *
+ *  Copyright (C) 2004 Marc Singer
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  version 2 as published by the Free Software Foundation.
+ *
+ */
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/sysdev.h>
+#include <linux/interrupt.h>
+
+//#include <linux/module.h>
+//#include <linux/time.h>
+//#include <asm/hardware.h>
+
+//#include <asm/mach/time.h>
+#include <asm/irq.h>
+#include <asm/mach/irq.h>
+
+#include <asm/system.h>
+#include <asm/hardware.h>
+#include <linux/amba/bus.h>
+#include <linux/amba/clcd.h>
+
+#define HRTFTC_HRSETUP          __REG(HRTFTC_PHYS + 0x00)
+#define HRTFTC_HRCON            __REG(HRTFTC_PHYS + 0x04)
+#define HRTFTC_HRTIMING1        __REG(HRTFTC_PHYS + 0x08)
+#define HRTFTC_HRTIMING2        __REG(HRTFTC_PHYS + 0x0c)
+
+#define ALI_SETUP               __REG(ALI_PHYS + 0x00)
+#define ALI_CONTROL             __REG(ALI_PHYS + 0x04)
+#define ALI_TIMING1             __REG(ALI_PHYS + 0x08)
+#define ALI_TIMING2             __REG(ALI_PHYS + 0x0c)
+
+#include "lcd-panel.h"
+
+static void lh7a40x_clcd_disable (struct clcd_fb *fb)
+{
+#if defined (CONFIG_MACH_LPD7A400)
+        CPLD_CONTROL &= ~(1<<1);        /* Disable LCD Vee */
+#endif
+
+#if defined (CONFIG_MACH_LPD7A404)
+        GPIO_PCD  &= ~(1<<3);           /* Disable LCD Vee */
+#endif
+
+#if defined (CONFIG_ARCH_LH7A400)
+        HRTFTC_HRSETUP &= ~(1<<13);     /* Disable HRTFT controller */
+#endif
+
+#if defined (CONFIG_ARCH_LH7A404)
+        ALI_SETUP &= ~(1<<13);          /* Disable ALI */
+#endif
+}
+
+static void lh7a40x_clcd_enable (struct clcd_fb *fb)
+{
+        struct clcd_panel_extra* extra
+                = (struct clcd_panel_extra*) fb->board_data;
+
+#if defined (CONFIG_MACH_LPD7A400)
+        CPLD_CONTROL |= (1<<1);         /* Enable LCD Vee */
+#endif
+
+#if defined (CONFIG_MACH_LPD7A404)
+        GPIO_PCDD &= ~(1<<3);           /* Enable LCD Vee */
+        GPIO_PCD  |=  (1<<3);
+#endif
+
+#if defined (CONFIG_ARCH_LH7A400)
+
+        if (extra) {
+                HRTFTC_HRSETUP
+                        = (1 << 13)
+                        | ((fb->fb.var.xres - 1) << 4)
+                        | 0xc
+                        | (extra->hrmode ? 1 : 0);
+                HRTFTC_HRCON
+                        = ((extra->clsen ? 1 : 0) << 1)
+                        | ((extra->spsen ? 1 : 0) << 0);
+                HRTFTC_HRTIMING1
+                        = (extra->pcdel << 8)
+                        | (extra->revdel << 4)
+                        | (extra->lpdel << 0);
+                HRTFTC_HRTIMING2
+                        = (extra->spldel << 9)
+                        | (extra->pc2del << 0);
+        }
+        else
+                HRTFTC_HRSETUP
+                        = (1 << 13)
+                        | 0xc;
+#endif
+
+#if defined (CONFIG_ARCH_LH7A404)
+
+        if (extra) {
+                ALI_SETUP
+                        = (1 << 13)
+                        | ((fb->fb.var.xres - 1) << 4)
+                        | 0xc
+                        | (extra->hrmode ? 1 : 0);
+                ALI_CONTROL
+                        = ((extra->clsen ? 1 : 0) << 1)
+                        | ((extra->spsen ? 1 : 0) << 0);
+                ALI_TIMING1
+                        = (extra->pcdel << 8)
+                        | (extra->revdel << 4)
+                        | (extra->lpdel << 0);
+                ALI_TIMING2
+                        = (extra->spldel << 9)
+                        | (extra->pc2del << 0);
+        }
+        else
+                ALI_SETUP
+                        = (1 << 13)
+                        | 0xc;
+#endif
+
+}
+
+#define FRAMESIZE(s) (((s) + PAGE_SIZE - 1)&PAGE_MASK)
+
+static int lh7a40x_clcd_setup (struct clcd_fb *fb)
+{
+        dma_addr_t dma;
+        u32 len = FRAMESIZE (lcd_panel.mode.xres*lcd_panel.mode.yres
+                             *(lcd_panel.bpp/8));
+
+        fb->panel = &lcd_panel;
+
+                /* Enforce the sync polarity defaults */
+        if (!(fb->panel->tim2 & TIM2_IHS))
+                fb->fb.var.sync |= FB_SYNC_HOR_HIGH_ACT;
+        if (!(fb->panel->tim2 & TIM2_IVS))
+                fb->fb.var.sync |= FB_SYNC_VERT_HIGH_ACT;
+
+#if defined (HAS_LCD_PANEL_EXTRA)
+        fb->board_data = &lcd_panel_extra;
+#endif
+
+        fb->fb.screen_base
+                = dma_alloc_writecombine (&fb->dev->dev, len,
+                                          &dma, GFP_KERNEL);
+        printk ("CLCD: LCD setup fb virt 0x%p phys 0x%p l %x io 0x%p \n",
+                fb->fb.screen_base, (void*) dma, len,
+                (void*) io_p2v (CLCDC_PHYS));
+        printk ("CLCD: pixclock %d\n", lcd_panel.mode.pixclock);
+
+        if (!fb->fb.screen_base) {
+                printk(KERN_ERR "CLCD: unable to map framebuffer\n");
+                return -ENOMEM;
+        }
+
+#if defined (USE_RGB555)
+        fb->fb.var.green.length = 5; /* Panel uses RGB 5:5:5 */
+#endif
+
+        fb->fb.fix.smem_start = dma;
+        fb->fb.fix.smem_len = len;
+
+                /* Drive PE4 high to prevent CPLD crash */
+        GPIO_PEDD |= (1<<4);
+        GPIO_PED  |= (1<<4);
+
+        GPIO_PINMUX |= (1<<1) | (1<<0); /* LCDVD[15:4] */
+
+//      fb->fb.fbops->fb_check_var (&fb->fb.var, &fb->fb);
+//      fb->fb.fbops->fb_set_par (&fb->fb);
+
+        return 0;
+}
+
+static int lh7a40x_clcd_mmap (struct clcd_fb *fb, struct vm_area_struct *vma)
+{
+        return dma_mmap_writecombine(&fb->dev->dev, vma,
+                                     fb->fb.screen_base,
+                                     fb->fb.fix.smem_start,
+                                     fb->fb.fix.smem_len);
+}
+
+static void lh7a40x_clcd_remove (struct clcd_fb *fb)
+{
+        dma_free_writecombine (&fb->dev->dev, fb->fb.fix.smem_len,
+                               fb->fb.screen_base, fb->fb.fix.smem_start);
+}
+
+static struct clcd_board clcd_platform_data = {
+        .name           = "lh7a40x FB",
+        .check          = clcdfb_check,
+        .decode         = clcdfb_decode,
+        .enable         = lh7a40x_clcd_enable,
+        .setup          = lh7a40x_clcd_setup,
+        .mmap           = lh7a40x_clcd_mmap,
+        .remove         = lh7a40x_clcd_remove,
+        .disable        = lh7a40x_clcd_disable,
+};
+
+#define IRQ_CLCDC (IRQ_LCDINTR)
+
+#define AMBA_DEVICE(name,busid,base,plat,pid)                   \
+static struct amba_device name##_device = {                     \
+        .dev = {                                                \
+                .coherent_dma_mask = ~0,                        \
+                .bus_id = busid,                                \
+                .platform_data = plat,                          \
+                },                                              \
+        .res = {                                                \
+                .start  = base##_PHYS,                          \
+                .end    = (base##_PHYS) + (4*1024) - 1,         \
+                .flags  = IORESOURCE_MEM,                       \
+                },                                              \
+        .dma_mask       = ~0,                                   \
+        .irq            = { IRQ_##base, },                      \
+        /* .dma         = base##_DMA,*/                         \
+        .periphid = pid,                                        \
+}
+
+AMBA_DEVICE(clcd,  "cldc-lh7a40x",  CLCDC,     &clcd_platform_data, 0x41110);
+
+static struct amba_device *amba_devs[] __initdata = {
+        &clcd_device,
+};
+
+void __init lh7a40x_clcd_init (void)
+{
+        int i;
+        int result;
+        printk ("CLCD: registering amba devices\n");
+        for (i = 0; i < ARRAY_SIZE(amba_devs); i++) {
+                struct amba_device *d = amba_devs[i];
+                result = amba_device_register(d, &iomem_resource);
+                printk ("  %d -> %d\n", i ,result);
+        }
+}
diff --git a/arch/arm/mach-lh7a40x/clocks.c b/arch/arm/mach-lh7a40x/clocks.c
new file mode 100644
index 000000000000..2291afe9f23e
--- /dev/null
+++ b/arch/arm/mach-lh7a40x/clocks.c
@@ -0,0 +1,199 @@
+/* arch/arm/mach-lh7a40x/clocks.c
+ *
+ *  Copyright (C) 2004 Marc Singer
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  version 2 as published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/config.h>
+#include <linux/cpufreq.h>
+#include <asm/hardware.h>
+#include <asm/arch/clocks.h>
+#include <linux/err.h>
+
+struct module;
+struct icst525_params;
+
+struct clk {
+        struct list_head node;
+        unsigned long rate;
+        struct module *owner;
+        const char *name;
+//      void *data;
+//      const struct icst525_params *params;
+//      void (*setvco)(struct clk *, struct icst525_vco vco);
+};
+
+int clk_register(struct clk *clk);
+void clk_unregister(struct clk *clk);
+
+/* ----- */
+
+#define MAINDIV1(c)     (((c) >>  7) & 0x0f)
+#define MAINDIV2(c)     (((c) >> 11) & 0x1f)
+#define PS(c)           (((c) >> 18) & 0x03)
+#define PREDIV(c)       (((c) >>  2) & 0x1f)
+#define HCLKDIV(c)      (((c) >>  0) & 0x02)
+#define PCLKDIV(c)      (((c) >> 16) & 0x03)
+
+unsigned int cpufreq_get (unsigned int cpu) /* in kHz */
+{
+        return fclkfreq_get ()/1000;
+}
+EXPORT_SYMBOL(cpufreq_get);
+
+unsigned int fclkfreq_get (void)
+{
+        unsigned int clkset = CSC_CLKSET;
+        unsigned int gclk
+                = XTAL_IN
+                / (1 << PS(clkset))
+                * (MAINDIV1(clkset) + 2)
+                / (PREDIV(clkset)   + 2)
+                * (MAINDIV2(clkset) + 2)
+                ;
+        return gclk;
+}
+
+unsigned int hclkfreq_get (void)
+{
+        unsigned int clkset = CSC_CLKSET;
+        unsigned int hclk = fclkfreq_get () / (HCLKDIV(clkset) + 1);
+
+        return hclk;
+}
+
+unsigned int pclkfreq_get (void)
+{
+        unsigned int clkset = CSC_CLKSET;
+        int pclkdiv = PCLKDIV(clkset);
+        unsigned int pclk;
+        if (pclkdiv == 0x3)
+                pclkdiv = 0x2;
+        pclk = hclkfreq_get () / (1 << pclkdiv);
+
+        return pclk;
+}
+
+/* ----- */
+
+static LIST_HEAD(clocks);
+static DECLARE_MUTEX(clocks_sem);
+
+struct clk *clk_get (struct device *dev, const char *id)
+{
+        struct clk *p;
+        struct clk *clk = ERR_PTR(-ENOENT);
+
+        down (&clocks_sem);
+        list_for_each_entry (p, &clocks, node) {
+                if (strcmp (id, p->name) == 0
+                    && try_module_get(p->owner)) {
+                        clk = p;
+                        break;
+                }
+        }
+        up (&clocks_sem);
+
+        return clk;
+}
+EXPORT_SYMBOL(clk_get);
+
+void clk_put (struct clk *clk)
+{
+        module_put(clk->owner);
+}
+EXPORT_SYMBOL(clk_put);
+
+int clk_enable (struct clk *clk)
+{
+        return 0;
+}
+EXPORT_SYMBOL(clk_enable);
+
+void clk_disable (struct clk *clk)
+{
+}
+EXPORT_SYMBOL(clk_disable);
+
+int clk_use (struct clk *clk)
+{
+        return 0;
+}
+EXPORT_SYMBOL(clk_use);
+
+void clk_unuse (struct clk *clk)
+{
+}
+EXPORT_SYMBOL(clk_unuse);
+
+unsigned long clk_get_rate (struct clk *clk)
+{
+        return clk->rate;
+}
+EXPORT_SYMBOL(clk_get_rate);
+
+long clk_round_rate (struct clk *clk, unsigned long rate)
+{
+        return rate;
+}
+EXPORT_SYMBOL(clk_round_rate);
+
+int clk_set_rate (struct clk *clk, unsigned long rate)
+{
+        int ret = -EIO;
+        return ret;
+}
+EXPORT_SYMBOL(clk_set_rate);
+
+#if 0
+/*
+ * These are fixed clocks.
+ */
+static struct clk kmi_clk = {
+        .name   = "KMIREFCLK",
+        .rate   = 24000000,
+};
+
+static struct clk uart_clk = {
+        .name   = "UARTCLK",
+        .rate   = 24000000,
+};
+
+static struct clk mmci_clk = {
+        .name   = "MCLK",
+        .rate   = 33000000,
+};
+#endif
+
+static struct clk clcd_clk = {
+        .name   = "CLCDCLK",
+        .rate   = 0,
+};
+
+int clk_register (struct clk *clk)
+{
+        down (&clocks_sem);
+        list_add (&clk->node, &clocks);
+        up (&clocks_sem);
+        return 0;
+}
+EXPORT_SYMBOL(clk_register);
+
+void clk_unregister (struct clk *clk)
+{
+        down (&clocks_sem);
+        list_del (&clk->node);
+        up (&clocks_sem);
+}
+EXPORT_SYMBOL(clk_unregister);
+
+static int __init clk_init (void)
+{
+        clk_register(&clcd_clk);
+        return 0;
+}
+arch_initcall(clk_init);
diff --git a/arch/arm/mach-lh7a40x/common.h b/arch/arm/mach-lh7a40x/common.h
index ea8de7e3ab1b..18e8bb4eb202 100644
--- a/arch/arm/mach-lh7a40x/common.h
+++ b/arch/arm/mach-lh7a40x/common.h
@@ -12,6 +12,7 @@ extern struct sys_timer lh7a40x_timer;
 
 extern void lh7a400_init_irq (void);
 extern void lh7a404_init_irq (void);
+extern void lh7a40x_clcd_init (void);
 extern void lh7a40x_init_board_irq (void);
 
 #define IRQ_DISPATCH(irq) desc_handle_irq((irq),(irq_desc + irq), regs)
diff --git a/arch/arm/mach-lh7a40x/irq-lh7a404.c b/arch/arm/mach-lh7a40x/irq-lh7a404.c
index e902e3d87da4..2685a81454d2 100644
--- a/arch/arm/mach-lh7a40x/irq-lh7a404.c
+++ b/arch/arm/mach-lh7a40x/irq-lh7a404.c
@@ -28,13 +28,17 @@
 
 static unsigned char irq_pri_vic1[] = {
 #if defined (USE_PRIORITIES)
-IRQ_GPIO3INTR,
+        IRQ_GPIO3INTR,                  /* CPLD */
+        IRQ_DMAM2P4, IRQ_DMAM2P5,       /* AC97 */
 #endif
 };
 static unsigned char irq_pri_vic2[] = {
 #if defined (USE_PRIORITIES)
-        IRQ_T3UI, IRQ_GPIO7INTR,
+        IRQ_T3UI,                       /* Timer */
+        IRQ_GPIO7INTR,                  /* CPLD */
         IRQ_UART1INTR, IRQ_UART2INTR, IRQ_UART3INTR,
+        IRQ_LCDINTR,                    /* LCD */
+        IRQ_TSCINTR,                    /* ADC/Touchscreen */
 #endif
 };
 
@@ -98,10 +102,19 @@ static struct irqchip lh7a404_gpio_vic2_chip = {
 
   /* IRQ initialization */
 
+#if defined (CONFIG_ARCH_LH7A400) && defined (CONFIG_ARCH_LH7A404)
+extern void* branch_irq_lh7a400;
+#endif
+
 void __init lh7a404_init_irq (void)
 {
         int irq;
 
+#if defined (CONFIG_ARCH_LH7A400) && defined (CONFIG_ARCH_LH7A404)
+#define NOP 0xe1a00000                  /* mov r0, r0 */
+        branch_irq_lh7a400 = NOP;
+#endif
+
         VIC1_INTENCLR = 0xffffffff;
         VIC2_INTENCLR = 0xffffffff;
         VIC1_INTSEL = 0;                /* All IRQs */
diff --git a/arch/arm/mach-lh7a40x/lcd-panel.h b/arch/arm/mach-lh7a40x/lcd-panel.h
new file mode 100644
index 000000000000..4fb2efc4950f
--- /dev/null
+++ b/arch/arm/mach-lh7a40x/lcd-panel.h
@@ -0,0 +1,346 @@
+/* lcd-panel.h
+     $Id$
+
+   written by Marc Singer
+   18 Jul 2005
+
+   Copyright (C) 2005 Marc Singer
+
+   -----------
+   DESCRIPTION
+   -----------
+
+   Only one panel may be defined at a time.
+
+   The pixel clock is calculated to be no greater than the target.
+
+   Each timing value is accompanied by a specification comment.
+
+     UNITS/MIN/TYP/MAX
+
+   Most of the units will be in clocks.
+
+   USE_RGB555
+
+     Define this macro to configure the AMBA LCD controller to use an
+     RGB555 encoding for the pels instead of the normal RGB565.
+
+   LPD9520, LPD79524, LPD7A400, LPD7A404-10, LPD7A404-11
+
+     These boards are best approximated by 555 for all panels.  Some
+     can use an extra low-order bit of blue in bit 16 of the color
+     value, but we don't have a way to communicate this non-linear
+     mapping to the kernel.
+
+*/
+
+#if !defined (__LCD_PANEL_H__)
+#    define   __LCD_PANEL_H__
+
+#if defined (MACH_LPD79520)\
+ || defined (MACH_LPD79524)\
+ || defined (MACH_LPD7A400)\
+ || defined (MACH_LPD7A404)
+# define USE_RGB555
+#endif
+
+struct clcd_panel_extra {
+        unsigned int hrmode;
+        unsigned int clsen;
+        unsigned int spsen;
+        unsigned int pcdel;
+        unsigned int revdel;
+        unsigned int lpdel;
+        unsigned int spldel;
+        unsigned int pc2del;
+};
+
+#define NS_TO_CLOCK(ns,c)       ((((ns)*((c)/1000) + (1000000 - 1))/1000000))
+#define CLOCK_TO_DIV(e,c)       (((c) + (e) - 1)/(e))
+
+#if defined CONFIG_FB_ARMCLCD_SHARP_LQ035Q7DB02_HRTFT
+
+        /* Logic Product Development LCD 3.5" QVGA HRTFT -10 */
+        /* Sharp PN LQ035Q7DB02 w/HRTFT controller chip */
+
+#define PIX_CLOCK_TARGET        (6800000)
+#define PIX_CLOCK_DIVIDER       CLOCK_TO_DIV (PIX_CLOCK_TARGET, HCLK)
+#define PIX_CLOCK               (HCLK/PIX_CLOCK_DIVIDER)
+
+static struct clcd_panel lcd_panel = {
+        .mode   = {
+                .name           = "3.5in QVGA (LQ035Q7DB02)",
+                .xres           = 240,
+                .yres           = 320,
+                .pixclock       = PIX_CLOCK,
+                .left_margin    = 16,
+                .right_margin   = 21,
+                .upper_margin   = 8,                    // line/8/8/8
+                .lower_margin   = 5,
+                .hsync_len      = 61,
+                .vsync_len      = NS_TO_CLOCK (60, PIX_CLOCK),
+                .vmode          = FB_VMODE_NONINTERLACED,
+        },
+        .width          = -1,
+        .height         = -1,
+        .tim2           = TIM2_IPC | (PIX_CLOCK_DIVIDER - 2),
+        .cntl           = CNTL_LCDTFT | CNTL_WATERMARK,
+        .bpp            = 16,
+};
+
+#define HAS_LCD_PANEL_EXTRA
+
+static struct clcd_panel_extra lcd_panel_extra = {
+        .hrmode = 1,
+        .clsen = 1,
+        .spsen = 1,
+        .pcdel = 8,
+        .revdel = 7,
+        .lpdel = 13,
+        .spldel = 77,
+        .pc2del = 208,
+};
+
+#endif
+
+#if defined CONFIG_FB_ARMCLCD_SHARP_LQ057Q3DC02
+
+        /* Logic Product Development LCD 5.7" QVGA -10 */
+        /* Sharp PN LQ057Q3DC02 */
+        /* QVGA mode, V/Q=LOW */
+
+/* From Sharp on 2006.1.3.  I believe some of the values are incorrect
+ * based on the datasheet.
+
+    Timing0     TIMING1         TIMING2         CONTROL
+    0x140A0C4C  0x080504EF      0x013F380D      0x00000829
+    HBP= 20     VBP=  8         BCD=  0
+    HFP= 10     VFP=  5         CPL=319
+    HSW= 12     VSW=  1         IOE=  0
+    PPL= 19     LPP=239         IPC=  1
+                                IHS=  1
+                                IVS=  1
+                                ACB=  0
+                                CSEL= 0
+                                PCD= 13
+
+ */
+
+/* The full horozontal cycle (Th) is clock/360/400/450. */
+/* The full vertical   cycle (Tv) is line/251/262/280. */
+
+#define PIX_CLOCK_TARGET        (6300000) /* -/6.3/7 MHz */
+#define PIX_CLOCK_DIVIDER       CLOCK_TO_DIV (PIX_CLOCK_TARGET, HCLK)
+#define PIX_CLOCK               (HCLK/PIX_CLOCK_DIVIDER)
+
+static struct clcd_panel lcd_panel = {
+        .mode   = {
+                .name           = "5.7in QVGA (LQ057Q3DC02)",
+                .xres           = 320,
+                .yres           = 240,
+                .pixclock       = PIX_CLOCK,
+                .left_margin    = 11,
+                .right_margin   = 400-11-320-2,
+                .upper_margin   = 7,                    // line/7/7/7
+                .lower_margin   = 262-7-240-2,
+                .hsync_len      = 2,                    // clk/2/96/200
+                .vsync_len      = 2,                    // line/2/-/34
+                .vmode          = FB_VMODE_NONINTERLACED,
+        },
+        .width          = -1,
+        .height         = -1,
+        .tim2           = TIM2_IHS | TIM2_IVS
+                        | (PIX_CLOCK_DIVIDER - 2),
+        .cntl           = CNTL_LCDTFT | CNTL_WATERMARK,
+        .bpp            = 16,
+};
+
+#endif
+
+#if defined CONFIG_FB_ARMCLCD_SHARP_LQ64D343
+
+        /* Logic Product Development LCD 6.4" VGA -10 */
+        /* Sharp PN LQ64D343 */
+
+/* The full horozontal cycle (Th) is clock/750/800/900. */
+/* The full vertical   cycle (Tv) is line/515/525/560. */
+
+#define PIX_CLOCK_TARGET        (28330000)
+#define PIX_CLOCK_DIVIDER       CLOCK_TO_DIV (PIX_CLOCK_TARGET, HCLK)
+#define PIX_CLOCK               (HCLK/PIX_CLOCK_DIVIDER)
+
+static struct clcd_panel lcd_panel = {
+        .mode   = {
+                .name           = "6.4in QVGA (LQ64D343)",
+                .xres           = 640,
+                .yres           = 480,
+                .pixclock       = PIX_CLOCK,
+                .left_margin    = 32,
+                .right_margin   = 800-32-640-96,
+                .upper_margin   = 32,                   // line/34/34/34
+                .lower_margin   = 540-32-480-2,
+                .hsync_len      = 96,                   // clk/2/96/200
+                .vsync_len      = 2,                    // line/2/-/34
+                .vmode          = FB_VMODE_NONINTERLACED,
+        },
+        .width          = -1,
+        .height         = -1,
+        .tim2           = TIM2_IHS | TIM2_IVS
+                        | (PIX_CLOCK_DIVIDER - 2),
+        .cntl           = CNTL_LCDTFT | CNTL_WATERMARK,
+        .bpp            = 16,
+};
+
+#endif
+
+#if defined CONFIG_FB_ARMCLCD_SHARP_LQ10D368
+
+        /* Logic Product Development LCD 10.4" VGA -10 */
+        /* Sharp PN LQ10D368 */
+
+#define PIX_CLOCK_TARGET        (28330000)
+#define PIX_CLOCK_DIVIDER       CLOCK_TO_DIV (PIX_CLOCK_TARGET, HCLK)
+#define PIX_CLOCK               (HCLK/PIX_CLOCK_DIVIDER)
+
+static struct clcd_panel lcd_panel = {
+        .mode   = {
+                .name           = "10.4in VGA (LQ10D368)",
+                .xres           = 640,
+                .yres           = 480,
+                .pixclock       = PIX_CLOCK,
+                .left_margin    = 21,
+                .right_margin   = 15,
+                .upper_margin   = 34,
+                .lower_margin   = 5,
+                .hsync_len      = 96,
+                .vsync_len      = 16,
+                .vmode          = FB_VMODE_NONINTERLACED,
+        },
+        .width          = -1,
+        .height         = -1,
+        .tim2           = TIM2_IHS | TIM2_IVS
+                        | (PIX_CLOCK_DIVIDER - 2),
+        .cntl           = CNTL_LCDTFT | CNTL_WATERMARK,
+        .bpp            = 16,
+};
+
+#endif
+
+#if defined CONFIG_FB_ARMCLCD_SHARP_LQ121S1DG41
+
+        /* Logic Product Development LCD 12.1" SVGA -10 */
+        /* Sharp PN LQ121S1DG41, was LQ121S1DG31 */
+
+/* Note that with a 99993900 Hz HCLK, it is not possible to hit the
+ * target clock frequency range of 35MHz to 42MHz. */
+
+/* If the target pixel clock is substantially lower than the panel
+ * spec, this is done to prevent the LCD display from glitching when
+ * the CPU is under load.  A pixel clock higher than 25MHz
+ * (empirically determined) will compete with the CPU for bus cycles
+ * for the Ethernet chip.  However, even a pixel clock of 10MHz
+ * competes with Compact Flash interface during some operations
+ * (fdisk, e2fsck).  And, at that speed the display may have a visible
+ * flicker. */
+
+/* The full horozontal cycle (Th) is clock/832/1056/1395. */
+
+#define PIX_CLOCK_TARGET        (20000000)
+#define PIX_CLOCK_DIVIDER       CLOCK_TO_DIV (PIX_CLOCK_TARGET, HCLK)
+#define PIX_CLOCK               (HCLK/PIX_CLOCK_DIVIDER)
+
+static struct clcd_panel lcd_panel = {
+        .mode   = {
+                .name           = "12.1in SVGA (LQ121S1DG41)",
+                .xres           = 800,
+                .yres           = 600,
+                .pixclock       = PIX_CLOCK,
+                .left_margin    = 89,           // ns/5/-/(1/PIX_CLOCK)-10
+                .right_margin   = 1056-800-89-128,
+                .upper_margin   = 23,           // line/23/23/23
+                .lower_margin   = 44,
+                .hsync_len      = 128,          // clk/2/128/200
+                .vsync_len      = 4,            // line/2/4/6
+                .vmode          = FB_VMODE_NONINTERLACED,
+        },
+        .width          = -1,
+        .height         = -1,
+        .tim2           = TIM2_IHS | TIM2_IVS
+                        | (PIX_CLOCK_DIVIDER - 2),
+        .cntl           = CNTL_LCDTFT | CNTL_WATERMARK,
+        .bpp            = 16,
+};
+
+#endif
+
+#if defined CONFIG_FB_ARMCLCD_HITACHI
+
+        /* Hitachi*/
+        /* Submitted by Michele Da Rold <michele.darold@ecsproject.com> */
+
+#define PIX_CLOCK_TARGET        (49000000)
+#define PIX_CLOCK_DIVIDER       CLOCK_TO_DIV (PIX_CLOCK_TARGET, HCLK)
+#define PIX_CLOCK               (HCLK/PIX_CLOCK_DIVIDER)
+
+static struct clcd_panel lcd_panel = {
+        .mode   = {
+                .name           = "Hitachi 800x480",
+                .xres           = 800,
+                .yres           = 480,
+                .pixclock       = PIX_CLOCK,
+                .left_margin    = 88,
+                .right_margin   = 40,
+                .upper_margin   = 32,
+                .lower_margin   = 11,
+                .hsync_len      = 128,
+                .vsync_len      = 2,
+                .vmode          = FB_VMODE_NONINTERLACED,
+        },
+        .width          = -1,
+        .height         = -1,
+        .tim2           = TIM2_IPC | TIM2_IHS | TIM2_IVS
+                        | (PIX_CLOCK_DIVIDER - 2),
+        .cntl           = CNTL_LCDTFT | CNTL_WATERMARK,
+        .bpp            = 16,
+};
+
+#endif
+
+
+#if defined CONFIG_FB_ARMCLCD_AUO_A070VW01_WIDE
+
+        /* AU Optotronics  A070VW01 7.0 Wide Screen color Display*/
+        /* Submitted by Michele Da Rold <michele.darold@ecsproject.com> */
+
+#define PIX_CLOCK_TARGET        (10000000)
+#define PIX_CLOCK_DIVIDER       CLOCK_TO_DIV (PIX_CLOCK_TARGET, HCLK)
+#define PIX_CLOCK               (HCLK/PIX_CLOCK_DIVIDER)
+
+static struct clcd_panel lcd_panel = {
+        .mode   = {
+                .name           = "7.0in Wide (A070VW01)",
+                .xres           = 480,
+                .yres           = 234,
+                .pixclock       = PIX_CLOCK,
+                .left_margin    = 30,
+                .right_margin   = 25,
+                .upper_margin   = 14,
+                .lower_margin   = 12,
+                .hsync_len      = 100,
+                .vsync_len      = 1,
+                .vmode          = FB_VMODE_NONINTERLACED,
+        },
+        .width          = -1,
+        .height         = -1,
+        .tim2           = TIM2_IPC | TIM2_IHS | TIM2_IVS
+                        | (PIX_CLOCK_DIVIDER - 2),
+        .cntl           = CNTL_LCDTFT | CNTL_WATERMARK,
+        .bpp            = 16,
+};
+
+#endif
+
+#undef NS_TO_CLOCK
+#undef CLOCK_TO_DIV
+
+#endif  /* __LCD_PANEL_H__ */
diff --git a/arch/arm/mach-lh7a40x/ssp-cpld.c b/arch/arm/mach-lh7a40x/ssp-cpld.c
new file mode 100644
index 000000000000..a10830186dac
--- /dev/null
+++ b/arch/arm/mach-lh7a40x/ssp-cpld.c
@@ -0,0 +1,343 @@
+/* arch/arm/mach-lh7a40x/ssp-cpld.c
+ *
+ *  Copyright (C) 2004,2005 Marc Singer
+ *
+ *  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.
+ *
+ * SSP/SPI driver for the CardEngine CPLD.
+ *
+ */
+
+/* NOTES
+   -----
+
+   o *** This driver is cribbed from the 7952x implementation.
+         Some comments may not apply.
+
+   o This driver contains sufficient logic to control either the
+     serial EEPROMs or the audio codec.  It is included in the kernel
+     to support the codec.  The EEPROMs are really the responsibility
+     of the boot loader and should probably be left alone.
+
+   o The code must be augmented to cope with multiple, simultaneous
+     clients.
+     o The audio codec writes to the codec chip whenever playback
+       starts.
+     o The touchscreen driver writes to the ads chip every time it
+       samples.
+     o The audio codec must write 16 bits, but the touch chip writes
+       are 8 bits long.
+     o We need to be able to keep these configurations separate while
+       simultaneously active.
+
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+//#include <linux/sched.h>
+#include <linux/errno.h>
+#include <linux/interrupt.h>
+//#include <linux/ioport.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/spinlock.h>
+
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/hardware.h>
+
+#include <asm/arch/ssp.h>
+
+//#define TALK
+
+#if defined (TALK)
+#define PRINTK(f...)            printk (f)
+#else
+#define PRINTK(f...)            do {} while (0)
+#endif
+
+#if defined (CONFIG_ARCH_LH7A400)
+# define CPLD_SPID              __REGP16(CPLD06_VIRT) /* SPI data */
+# define CPLD_SPIC              __REGP16(CPLD08_VIRT) /* SPI control */
+# define CPLD_SPIC_CS_CODEC     (1<<0)
+# define CPLD_SPIC_CS_TOUCH     (1<<1)
+# define CPLD_SPIC_WRITE        (0<<2)
+# define CPLD_SPIC_READ         (1<<2)
+# define CPLD_SPIC_DONE         (1<<3) /* r/o */
+# define CPLD_SPIC_LOAD         (1<<4)
+# define CPLD_SPIC_START        (1<<4)
+# define CPLD_SPIC_LOADED       (1<<5) /* r/o */
+#endif
+
+#define CPLD_SPI                __REGP16(CPLD0A_VIRT) /* SPI operation */
+#define CPLD_SPI_CS_EEPROM      (1<<3)
+#define CPLD_SPI_SCLK           (1<<2)
+#define CPLD_SPI_TX_SHIFT       (1)
+#define CPLD_SPI_TX             (1<<CPLD_SPI_TX_SHIFT)
+#define CPLD_SPI_RX_SHIFT       (0)
+#define CPLD_SPI_RX             (1<<CPLD_SPI_RX_SHIFT)
+
+/* *** FIXME: these timing values are substantially larger than the
+   *** chip requires. We may implement an nsleep () function. */
+#define T_SKH   1               /* Clock time high (us) */
+#define T_SKL   1               /* Clock time low (us) */
+#define T_CS    1               /* Minimum chip select low time (us)  */
+#define T_CSS   1               /* Minimum chip select setup time (us)  */
+#define T_DIS   1               /* Data setup time (us) */
+
+         /* EEPROM SPI bits */
+#define P_START         (1<<9)
+#define P_WRITE         (1<<7)
+#define P_READ          (2<<7)
+#define P_ERASE         (3<<7)
+#define P_EWDS          (0<<7)
+#define P_WRAL          (0<<7)
+#define P_ERAL          (0<<7)
+#define P_EWEN          (0<<7)
+#define P_A_EWDS        (0<<5)
+#define P_A_WRAL        (1<<5)
+#define P_A_ERAL        (2<<5)
+#define P_A_EWEN        (3<<5)
+
+struct ssp_configuration {
+        int device;
+        int mode;
+        int speed;
+        int frame_size_write;
+        int frame_size_read;
+};
+
+static struct ssp_configuration ssp_configuration;
+static spinlock_t ssp_lock;
+
+static void enable_cs (void)
+{
+        switch (ssp_configuration.device) {
+        case DEVICE_EEPROM:
+                CPLD_SPI |= CPLD_SPI_CS_EEPROM;
+                break;
+        }
+        udelay (T_CSS);
+}
+
+static void disable_cs (void)
+{
+        switch (ssp_configuration.device) {
+        case DEVICE_EEPROM:
+                CPLD_SPI &= ~CPLD_SPI_CS_EEPROM;
+                break;
+        }
+        udelay (T_CS);
+}
+
+static void pulse_clock (void)
+{
+        CPLD_SPI |=  CPLD_SPI_SCLK;
+        udelay (T_SKH);
+        CPLD_SPI &= ~CPLD_SPI_SCLK;
+        udelay (T_SKL);
+}
+
+
+/* execute_spi_command
+
+   sends an spi command to a device.  It first sends cwrite bits from
+   v.  If cread is greater than zero it will read cread bits
+   (discarding the leading 0 bit) and return them.  If cread is less
+   than zero it will check for completetion status and return 0 on
+   success or -1 on timeout.  If cread is zero it does nothing other
+   than sending the command.
+
+   On the LPD7A400, we can only read or write multiples of 8 bits on
+   the codec and the touch screen device.  Here, we round up.
+
+*/
+
+static int execute_spi_command (int v, int cwrite, int cread)
+{
+        unsigned long l = 0;
+
+#if defined (CONFIG_MACH_LPD7A400)
+        /* The codec and touch devices cannot be bit-banged.  Instead,
+         * the CPLD provides an eight-bit shift register and a crude
+         * interface.  */
+        if (   ssp_configuration.device == DEVICE_CODEC
+            || ssp_configuration.device == DEVICE_TOUCH) {
+                int select = 0;
+
+                PRINTK ("spi(%d %d.%d) 0x%04x",
+                        ssp_configuration.device, cwrite, cread,
+                        v);
+#if defined (TALK)
+                if (ssp_configuration.device == DEVICE_CODEC)
+                        PRINTK (" 0x%03x -> %2d", v & 0x1ff, (v >> 9) & 0x7f);
+#endif
+                PRINTK ("\n");
+
+                if (ssp_configuration.device == DEVICE_CODEC)
+                        select = CPLD_SPIC_CS_CODEC;
+                if (ssp_configuration.device == DEVICE_TOUCH)
+                        select = CPLD_SPIC_CS_TOUCH;
+                if (cwrite) {
+                        for (cwrite = (cwrite + 7)/8; cwrite-- > 0; ) {
+                                CPLD_SPID = (v >> (8*cwrite)) & 0xff;
+                                CPLD_SPIC = select | CPLD_SPIC_LOAD;
+                                while (!(CPLD_SPIC & CPLD_SPIC_LOADED))
+                                        ;
+                                CPLD_SPIC = select;
+                                while (!(CPLD_SPIC & CPLD_SPIC_DONE))
+                                        ;
+                        }
+                        v = 0;
+                }
+                if (cread) {
+                        mdelay (2);     /* *** FIXME: required by ads7843? */
+                        v = 0;
+                        for (cread = (cread + 7)/8; cread-- > 0;) {
+                                CPLD_SPID = 0;
+                                CPLD_SPIC = select | CPLD_SPIC_READ
+                                        | CPLD_SPIC_START;
+                                while (!(CPLD_SPIC & CPLD_SPIC_LOADED))
+                                        ;
+                                CPLD_SPIC = select | CPLD_SPIC_READ;
+                                while (!(CPLD_SPIC & CPLD_SPIC_DONE))
+                                        ;
+                                v = (v << 8) | CPLD_SPID;
+                        }
+                }
+                return v;
+        }
+#endif
+
+        PRINTK ("spi(%d) 0x%04x -> 0x%x\r\n", ssp_configuration.device,
+                v & 0x1ff, (v >> 9) & 0x7f);
+
+        enable_cs ();
+
+        v <<= CPLD_SPI_TX_SHIFT; /* Correction for position of SPI_TX bit */
+        while (cwrite--) {
+                CPLD_SPI
+                        = (CPLD_SPI & ~CPLD_SPI_TX)
+                        | ((v >> cwrite) & CPLD_SPI_TX);
+                udelay (T_DIS);
+                pulse_clock ();
+        }
+
+        if (cread < 0) {
+                int delay = 10;
+                disable_cs ();
+                udelay (1);
+                enable_cs ();
+
+                l = -1;
+                do {
+                        if (CPLD_SPI & CPLD_SPI_RX) {
+                                l = 0;
+                                break;
+                        }
+                } while (udelay (1), --delay);
+        }
+        else
+        /* We pulse the clock before the data to skip the leading zero. */
+                while (cread-- > 0) {
+                        pulse_clock ();
+                        l = (l<<1)
+                                | (((CPLD_SPI & CPLD_SPI_RX)
+                                    >> CPLD_SPI_RX_SHIFT) & 0x1);
+                }
+
+        disable_cs ();
+        return l;
+}
+
+static int ssp_init (void)
+{
+        spin_lock_init (&ssp_lock);
+        memset (&ssp_configuration, 0, sizeof (ssp_configuration));
+        return 0;
+}
+
+
+/* ssp_chip_select
+
+   drops the chip select line for the CPLD shift-register controlled
+   devices.  It doesn't enable chip
+
+*/
+
+static void ssp_chip_select (int enable)
+{
+#if defined (CONFIG_MACH_LPD7A400)
+        int select;
+
+        if (ssp_configuration.device == DEVICE_CODEC)
+                select = CPLD_SPIC_CS_CODEC;
+        else if (ssp_configuration.device == DEVICE_TOUCH)
+                select = CPLD_SPIC_CS_TOUCH;
+        else
+                return;
+
+        if (enable)
+                CPLD_SPIC = select;
+        else
+                CPLD_SPIC = 0;
+#endif
+}
+
+static void ssp_acquire (void)
+{
+        spin_lock (&ssp_lock);
+}
+
+static void ssp_release (void)
+{
+        ssp_chip_select (0);    /* just in case */
+        spin_unlock (&ssp_lock);
+}
+
+static int ssp_configure (int device, int mode, int speed,
+                           int frame_size_write, int frame_size_read)
+{
+        ssp_configuration.device                = device;
+        ssp_configuration.mode                  = mode;
+        ssp_configuration.speed                 = speed;
+        ssp_configuration.frame_size_write      = frame_size_write;
+        ssp_configuration.frame_size_read       = frame_size_read;
+
+        return 0;
+}
+
+static int ssp_read (void)
+{
+        return execute_spi_command (0, 0, ssp_configuration.frame_size_read);
+}
+
+static int ssp_write (u16 data)
+{
+        execute_spi_command (data, ssp_configuration.frame_size_write, 0);
+        return 0;
+}
+
+static int ssp_write_read (u16 data)
+{
+        return execute_spi_command (data, ssp_configuration.frame_size_write,
+                                    ssp_configuration.frame_size_read);
+}
+
+struct ssp_driver lh7a40x_cpld_ssp_driver = {
+        .init           = ssp_init,
+        .acquire        = ssp_acquire,
+        .release        = ssp_release,
+        .configure      = ssp_configure,
+        .chip_select    = ssp_chip_select,
+        .read           = ssp_read,
+        .write          = ssp_write,
+        .write_read     = ssp_write_read,
+};
+
+
+MODULE_AUTHOR("Marc Singer");
+MODULE_DESCRIPTION("LPD7A40X CPLD SPI driver");
+MODULE_LICENSE("GPL");
diff --git a/arch/arm/mach-lh7a40x/time.c b/arch/arm/mach-lh7a40x/time.c
index be377e331f25..ef9af375fcc4 100644
--- a/arch/arm/mach-lh7a40x/time.c
+++ b/arch/arm/mach-lh7a40x/time.c
@@ -1,4 +1,4 @@
-/* 
+/*
  *  arch/arm/mach-lh7a40x/time.c
  *
  *  Copyright (C) 2004 Logic Product Development
@@ -57,7 +57,7 @@ static struct irqaction lh7a40x_timer_irq = {
         .handler        = lh7a40x_timer_interrupt,
 };
 
-static void __init lh7a40x_timer_init(void)
+static void __init lh7a40x_timer_init (void)
 {
                                 /* Stop/disable all timers */
         TIMER_CONTROL1 = 0;
diff --git a/arch/arm/mach-pnx4008/Makefile b/arch/arm/mach-pnx4008/Makefile
new file mode 100644
index 000000000000..b457ca0a431a
--- /dev/null
+++ b/arch/arm/mach-pnx4008/Makefile
@@ -0,0 +1,12 @@
+#
+# Makefile for the linux kernel.
+#
+
+obj-y                   := core.o irq.o time.o clock.o gpio.o serial.o dma.o
+obj-m                   :=
+obj-n                   :=
+obj-                    :=
+
+# Power Management
+obj-$(CONFIG_PM) += pm.o sleep.o
+
diff --git a/arch/arm/mach-pnx4008/Makefile.boot b/arch/arm/mach-pnx4008/Makefile.boot
new file mode 100644
index 000000000000..44c7117e20dd
--- /dev/null
+++ b/arch/arm/mach-pnx4008/Makefile.boot
@@ -0,0 +1,4 @@
+   zreladdr-y           := 0x80008000
+params_phys-y           := 0x80000100
+initrd_phys-y           := 0x80800000
+
diff --git a/arch/arm/mach-pnx4008/clock.c b/arch/arm/mach-pnx4008/clock.c
new file mode 100644
index 000000000000..285b22f631e9
--- /dev/null
+++ b/arch/arm/mach-pnx4008/clock.c
@@ -0,0 +1,1010 @@
+/*
+ * arch/arm/mach-pnx4008/clock.c
+ *
+ * Clock control driver for PNX4008
+ *
+ * Authors: Vitaly Wool, Dmitry Chigirev <source@mvista.com>
+ * Generic clock management functions are partially based on:
+ *  linux/arch/arm/mach-omap/clock.c
+ *
+ * 2005-2006 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/errno.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+
+#include <asm/semaphore.h>
+#include <asm/hardware.h>
+#include <asm/io.h>
+
+#include <asm/arch/clock.h>
+#include "clock.h"
+
+/*forward declaration*/
+static struct clk per_ck;
+static struct clk hclk_ck;
+static struct clk ck_1MHz;
+static struct clk ck_13MHz;
+static struct clk ck_pll1;
+static int local_set_rate(struct clk *clk, u32 rate);
+
+static inline void clock_lock(void)
+{
+        local_irq_disable();
+}
+
+static inline void clock_unlock(void)
+{
+        local_irq_enable();
+}
+
+static void propagate_rate(struct clk *clk)
+{
+        struct clk *tmp_clk;
+
+        tmp_clk = clk;
+        while (tmp_clk->propagate_next) {
+                tmp_clk = tmp_clk->propagate_next;
+                local_set_rate(tmp_clk, tmp_clk->user_rate);
+        }
+}
+
+static inline void clk_reg_disable(struct clk *clk)
+{
+        if (clk->enable_reg)
+                __raw_writel(__raw_readl(clk->enable_reg) &
+                             ~(1 << clk->enable_shift), clk->enable_reg);
+}
+
+static inline void clk_reg_enable(struct clk *clk)
+{
+        if (clk->enable_reg)
+                __raw_writel(__raw_readl(clk->enable_reg) |
+                             (1 << clk->enable_shift), clk->enable_reg);
+}
+
+static inline void clk_reg_disable1(struct clk *clk)
+{
+        if (clk->enable_reg1)
+                __raw_writel(__raw_readl(clk->enable_reg1) &
+                             ~(1 << clk->enable_shift1), clk->enable_reg1);
+}
+
+static inline void clk_reg_enable1(struct clk *clk)
+{
+        if (clk->enable_reg1)
+                __raw_writel(__raw_readl(clk->enable_reg1) |
+                             (1 << clk->enable_shift1), clk->enable_reg1);
+}
+
+static int clk_wait_for_pll_lock(struct clk *clk)
+{
+        int i;
+        i = 0;
+        while (i++ < 0xFFF && !(__raw_readl(clk->scale_reg) & 1)) ;     /*wait for PLL to lock */
+
+        if (!(__raw_readl(clk->scale_reg) & 1)) {
+                printk(KERN_ERR
+                       "%s ERROR: failed to lock, scale reg data: %x\n",
+                       clk->name, __raw_readl(clk->scale_reg));
+                return -1;
+        }
+        return 0;
+}
+
+static int switch_to_dirty_13mhz(struct clk *clk)
+{
+        int i;
+        int ret;
+        u32 tmp_reg;
+
+        ret = 0;
+
+        if (!clk->rate)
+                clk_reg_enable1(clk);
+
+        tmp_reg = __raw_readl(clk->parent_switch_reg);
+        /*if 13Mhz clock selected, select 13'MHz (dirty) source from OSC */
+        if (!(tmp_reg & 1)) {
+                tmp_reg |= (1 << 1);    /* Trigger switch to 13'MHz (dirty) clock */
+                __raw_writel(tmp_reg, clk->parent_switch_reg);
+                i = 0;
+                while (i++ < 0xFFF && !(__raw_readl(clk->parent_switch_reg) & 1)) ;     /*wait for 13'MHz selection status */
+
+                if (!(__raw_readl(clk->parent_switch_reg) & 1)) {
+                        printk(KERN_ERR
+                               "%s ERROR: failed to select 13'MHz, parent sw reg data: %x\n",
+                               clk->name, __raw_readl(clk->parent_switch_reg));
+                        ret = -1;
+                }
+        }
+
+        if (!clk->rate)
+                clk_reg_disable1(clk);
+
+        return ret;
+}
+
+static int switch_to_clean_13mhz(struct clk *clk)
+{
+        int i;
+        int ret;
+        u32 tmp_reg;
+
+        ret = 0;
+
+        if (!clk->rate)
+                clk_reg_enable1(clk);
+
+        tmp_reg = __raw_readl(clk->parent_switch_reg);
+        /*if 13'Mhz clock selected, select 13MHz (clean) source from OSC */
+        if (tmp_reg & 1) {
+                tmp_reg &= ~(1 << 1);   /* Trigger switch to 13MHz (clean) clock */
+                __raw_writel(tmp_reg, clk->parent_switch_reg);
+                i = 0;
+                while (i++ < 0xFFF && (__raw_readl(clk->parent_switch_reg) & 1)) ;      /*wait for 13MHz selection status */
+
+                if (__raw_readl(clk->parent_switch_reg) & 1) {
+                        printk(KERN_ERR
+                               "%s ERROR: failed to select 13MHz, parent sw reg data: %x\n",
+                               clk->name, __raw_readl(clk->parent_switch_reg));
+                        ret = -1;
+                }
+        }
+
+        if (!clk->rate)
+                clk_reg_disable1(clk);
+
+        return ret;
+}
+
+static int set_13MHz_parent(struct clk *clk, struct clk *parent)
+{
+        int ret = -EINVAL;
+
+        if (parent == &ck_13MHz)
+                ret = switch_to_clean_13mhz(clk);
+        else if (parent == &ck_pll1)
+                ret = switch_to_dirty_13mhz(clk);
+
+        return ret;
+}
+
+#define PLL160_MIN_FCCO 156000
+#define PLL160_MAX_FCCO 320000
+
+/*
+ * Calculate pll160 settings.
+ * Possible input: up to 320MHz with step of clk->parent->rate.
+ * In PNX4008 parent rate for pll160s may be either 1 or 13MHz.
+ * Ignored paths: "feedback" (bit 13 set), "div-by-N".
+ * Setting ARM PLL4 rate to 0 will put CPU into direct run mode.
+ * Setting PLL5 and PLL3 rate to 0 will disable USB and DSP clock input.
+ * Please refer to PNX4008 IC manual for details.
+ */
+
+static int pll160_set_rate(struct clk *clk, u32 rate)
+{
+        u32 tmp_reg, tmp_m, tmp_2p, i;
+        u32 parent_rate;
+        int ret = -EINVAL;
+
+        parent_rate = clk->parent->rate;
+
+        if (!parent_rate)
+                goto out;
+
+        /* set direct run for ARM or disable output for others  */
+        clk_reg_disable(clk);
+
+        /* disable source input as well (ignored for ARM) */
+        clk_reg_disable1(clk);
+
+        tmp_reg = __raw_readl(clk->scale_reg);
+        tmp_reg &= ~0x1ffff;    /*clear all settings, power down */
+        __raw_writel(tmp_reg, clk->scale_reg);
+
+        rate -= rate % parent_rate;     /*round down the input */
+
+        if (rate > PLL160_MAX_FCCO)
+                rate = PLL160_MAX_FCCO;
+
+        if (!rate) {
+                clk->rate = 0;
+                ret = 0;
+                goto out;
+        }
+
+        clk_reg_enable1(clk);
+        tmp_reg = __raw_readl(clk->scale_reg);
+
+        if (rate == parent_rate) {
+                /*enter direct bypass mode */
+                tmp_reg |= ((1 << 14) | (1 << 15));
+                __raw_writel(tmp_reg, clk->scale_reg);
+                clk->rate = parent_rate;
+                clk_reg_enable(clk);
+                ret = 0;
+                goto out;
+        }
+
+        i = 0;
+        for (tmp_2p = 1; tmp_2p < 16; tmp_2p <<= 1) {
+                if (rate * tmp_2p >= PLL160_MIN_FCCO)
+                        break;
+                i++;
+        }
+
+        if (tmp_2p > 1)
+                tmp_reg |= ((i - 1) << 11);
+        else
+                tmp_reg |= (1 << 14);   /*direct mode, no divide */
+
+        tmp_m = rate * tmp_2p;
+        tmp_m /= parent_rate;
+
+        tmp_reg |= (tmp_m - 1) << 1;    /*calculate M */
+        tmp_reg |= (1 << 16);   /*power up PLL */
+        __raw_writel(tmp_reg, clk->scale_reg);
+
+        if (clk_wait_for_pll_lock(clk) < 0) {
+                clk_reg_disable(clk);
+                clk_reg_disable1(clk);
+
+                tmp_reg = __raw_readl(clk->scale_reg);
+                tmp_reg &= ~0x1ffff;    /*clear all settings, power down */
+                __raw_writel(tmp_reg, clk->scale_reg);
+                clk->rate = 0;
+                ret = -EFAULT;
+                goto out;
+        }
+
+        clk->rate = (tmp_m * parent_rate) / tmp_2p;
+
+        if (clk->flags & RATE_PROPAGATES)
+                propagate_rate(clk);
+
+        clk_reg_enable(clk);
+        ret = 0;
+
+out:
+        return ret;
+}
+
+/*configure PER_CLK*/
+static int per_clk_set_rate(struct clk *clk, u32 rate)
+{
+        u32 tmp;
+
+        tmp = __raw_readl(clk->scale_reg);
+        tmp &= ~(0x1f << 2);
+        tmp |= ((clk->parent->rate / clk->rate) - 1) << 2;
+        __raw_writel(tmp, clk->scale_reg);
+        clk->rate = rate;
+        return 0;
+}
+
+/*configure HCLK*/
+static int hclk_set_rate(struct clk *clk, u32 rate)
+{
+        u32 tmp;
+        tmp = __raw_readl(clk->scale_reg);
+        tmp = tmp & ~0x3;
+        switch (rate) {
+        case 1:
+                break;
+        case 2:
+                tmp |= 1;
+                break;
+        case 4:
+                tmp |= 2;
+                break;
+        }
+
+        __raw_writel(tmp, clk->scale_reg);
+        clk->rate = rate;
+        return 0;
+}
+
+static u32 hclk_round_rate(struct clk *clk, u32 rate)
+{
+        switch (rate) {
+        case 1:
+        case 4:
+                return rate;
+        }
+        return 2;
+}
+
+static u32 per_clk_round_rate(struct clk *clk, u32 rate)
+{
+        return CLK_RATE_13MHZ;
+}
+
+static int on_off_set_rate(struct clk *clk, u32 rate)
+{
+        if (rate) {
+                clk_reg_enable(clk);
+                clk->rate = 1;
+        } else {
+                clk_reg_disable(clk);
+                clk->rate = 0;
+        }
+        return 0;
+}
+
+static int on_off_inv_set_rate(struct clk *clk, u32 rate)
+{
+        if (rate) {
+                clk_reg_disable(clk);   /*enable bit is inverted */
+                clk->rate = 1;
+        } else {
+                clk_reg_enable(clk);
+                clk->rate = 0;
+        }
+        return 0;
+}
+
+static u32 on_off_round_rate(struct clk *clk, u32 rate)
+{
+        return (rate ? 1 : 0);
+}
+
+static u32 pll4_round_rate(struct clk *clk, u32 rate)
+{
+        if (rate > CLK_RATE_208MHZ)
+                rate = CLK_RATE_208MHZ;
+        if (rate == CLK_RATE_208MHZ && hclk_ck.user_rate == 1)
+                rate = CLK_RATE_208MHZ - CLK_RATE_13MHZ;
+        return (rate - (rate % (hclk_ck.user_rate * CLK_RATE_13MHZ)));
+}
+
+static u32 pll3_round_rate(struct clk *clk, u32 rate)
+{
+        if (rate > CLK_RATE_208MHZ)
+                rate = CLK_RATE_208MHZ;
+        return (rate - rate % CLK_RATE_13MHZ);
+}
+
+static u32 pll5_round_rate(struct clk *clk, u32 rate)
+{
+        return (rate ? CLK_RATE_48MHZ : 0);
+}
+
+static u32 ck_13MHz_round_rate(struct clk *clk, u32 rate)
+{
+        return (rate ? CLK_RATE_13MHZ : 0);
+}
+
+static int ck_13MHz_set_rate(struct clk *clk, u32 rate)
+{
+        if (rate) {
+                clk_reg_disable(clk);   /*enable bit is inverted */
+                udelay(500);
+                clk->rate = CLK_RATE_13MHZ;
+                ck_1MHz.rate = CLK_RATE_1MHZ;
+        } else {
+                clk_reg_enable(clk);
+                clk->rate = 0;
+                ck_1MHz.rate = 0;
+        }
+        return 0;
+}
+
+static int pll1_set_rate(struct clk *clk, u32 rate)
+{
+#if 0 /* doesn't work on some boards, probably a HW BUG */
+        if (rate) {
+                clk_reg_disable(clk);   /*enable bit is inverted */
+                if (!clk_wait_for_pll_lock(clk)) {
+                        clk->rate = CLK_RATE_13MHZ;
+                } else {
+                        clk_reg_enable(clk);
+                        clk->rate = 0;
+                }
+
+        } else {
+                clk_reg_enable(clk);
+                clk->rate = 0;
+        }
+#endif
+        return 0;
+}
+
+/* Clock sources */
+
+static struct clk osc_13MHz = {
+        .name = "osc_13MHz",
+        .flags = FIXED_RATE,
+        .rate = CLK_RATE_13MHZ,
+};
+
+static struct clk ck_13MHz = {
+        .name = "ck_13MHz",
+        .parent = &osc_13MHz,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &ck_13MHz_round_rate,
+        .set_rate = &ck_13MHz_set_rate,
+        .enable_reg = OSC13CTRL_REG,
+        .enable_shift = 0,
+        .rate = CLK_RATE_13MHZ,
+};
+
+static struct clk osc_32KHz = {
+        .name = "osc_32KHz",
+        .flags = FIXED_RATE,
+        .rate = CLK_RATE_32KHZ,
+};
+
+/*attached to PLL5*/
+static struct clk ck_1MHz = {
+        .name = "ck_1MHz",
+        .flags = FIXED_RATE | PARENT_SET_RATE,
+        .parent = &ck_13MHz,
+};
+
+/* PLL1 (397) - provides 13' MHz clock */
+static struct clk ck_pll1 = {
+        .name = "ck_pll1",
+        .parent = &osc_32KHz,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &ck_13MHz_round_rate,
+        .set_rate = &pll1_set_rate,
+        .enable_reg = PLLCTRL_REG,
+        .enable_shift = 1,
+        .scale_reg = PLLCTRL_REG,
+        .rate = CLK_RATE_13MHZ,
+};
+
+/* CPU/Bus PLL */
+static struct clk ck_pll4 = {
+        .name = "ck_pll4",
+        .parent = &ck_pll1,
+        .flags = RATE_PROPAGATES | NEEDS_INITIALIZATION,
+        .propagate_next = &per_ck,
+        .round_rate = &pll4_round_rate,
+        .set_rate = &pll160_set_rate,
+        .rate = CLK_RATE_208MHZ,
+        .scale_reg = HCLKPLLCTRL_REG,
+        .enable_reg = PWRCTRL_REG,
+        .enable_shift = 2,
+        .parent_switch_reg = SYSCLKCTRL_REG,
+        .set_parent = &set_13MHz_parent,
+};
+
+/* USB PLL */
+static struct clk ck_pll5 = {
+        .name = "ck_pll5",
+        .parent = &ck_1MHz,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &pll5_round_rate,
+        .set_rate = &pll160_set_rate,
+        .scale_reg = USBCTRL_REG,
+        .enable_reg = USBCTRL_REG,
+        .enable_shift = 18,
+        .enable_reg1 = USBCTRL_REG,
+        .enable_shift1 = 17,
+};
+
+/* XPERTTeak DSP PLL */
+static struct clk ck_pll3 = {
+        .name = "ck_pll3",
+        .parent = &ck_pll1,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &pll3_round_rate,
+        .set_rate = &pll160_set_rate,
+        .scale_reg = DSPPLLCTRL_REG,
+        .enable_reg = DSPCLKCTRL_REG,
+        .enable_shift = 3,
+        .enable_reg1 = DSPCLKCTRL_REG,
+        .enable_shift1 = 2,
+        .parent_switch_reg = DSPCLKCTRL_REG,
+        .set_parent = &set_13MHz_parent,
+};
+
+static struct clk hclk_ck = {
+        .name = "hclk_ck",
+        .parent = &ck_pll4,
+        .flags = PARENT_SET_RATE,
+        .set_rate = &hclk_set_rate,
+        .round_rate = &hclk_round_rate,
+        .scale_reg = HCLKDIVCTRL_REG,
+        .rate = 2,
+        .user_rate = 2,
+};
+
+static struct clk per_ck = {
+        .name = "per_ck",
+        .parent = &ck_pll4,
+        .flags = FIXED_RATE,
+        .propagate_next = &hclk_ck,
+        .set_rate = &per_clk_set_rate,
+        .round_rate = &per_clk_round_rate,
+        .scale_reg = HCLKDIVCTRL_REG,
+        .rate = CLK_RATE_13MHZ,
+        .user_rate = CLK_RATE_13MHZ,
+};
+
+static struct clk m2hclk_ck = {
+        .name = "m2hclk_ck",
+        .parent = &hclk_ck,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_inv_set_rate,
+        .rate = 1,
+        .enable_shift = 6,
+        .enable_reg = PWRCTRL_REG,
+};
+
+static struct clk vfp9_ck = {
+        .name = "vfp9_ck",
+        .parent = &ck_pll4,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .rate = 1,
+        .enable_shift = 4,
+        .enable_reg = VFP9CLKCTRL_REG,
+};
+
+static struct clk keyscan_ck = {
+        .name = "keyscan_ck",
+        .parent = &osc_32KHz,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 0,
+        .enable_reg = KEYCLKCTRL_REG,
+};
+
+static struct clk touch_ck = {
+        .name = "touch_ck",
+        .parent = &osc_32KHz,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 0,
+        .enable_reg = TSCLKCTRL_REG,
+};
+
+static struct clk pwm1_ck = {
+        .name = "pwm1_ck",
+        .parent = &osc_32KHz,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 0,
+        .enable_reg = PWMCLKCTRL_REG,
+};
+
+static struct clk pwm2_ck = {
+        .name = "pwm2_ck",
+        .parent = &osc_32KHz,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 2,
+        .enable_reg = PWMCLKCTRL_REG,
+};
+
+static struct clk jpeg_ck = {
+        .name = "jpeg_ck",
+        .parent = &hclk_ck,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 0,
+        .enable_reg = JPEGCLKCTRL_REG,
+};
+
+static struct clk ms_ck = {
+        .name = "ms_ck",
+        .parent = &ck_pll4,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 5,
+        .enable_reg = MSCTRL_REG,
+};
+
+static struct clk dum_ck = {
+        .name = "dum_ck",
+        .parent = &hclk_ck,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 0,
+        .enable_reg = DUMCLKCTRL_REG,
+};
+
+static struct clk flash_ck = {
+        .name = "flash_ck",
+        .parent = &hclk_ck,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 1,      /* Only MLC clock supported */
+        .enable_reg = FLASHCLKCTRL_REG,
+};
+
+static struct clk i2c0_ck = {
+        .name = "i2c0_ck",
+        .parent = &per_ck,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 0,
+        .enable_reg = I2CCLKCTRL_REG,
+};
+
+static struct clk i2c1_ck = {
+        .name = "i2c1_ck",
+        .parent = &per_ck,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 1,
+        .enable_reg = I2CCLKCTRL_REG,
+};
+
+static struct clk i2c2_ck = {
+        .name = "i2c2_ck",
+        .parent = &per_ck,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 2,
+        .enable_reg = USB_OTG_CLKCTRL_REG,
+};
+
+static struct clk spi0_ck = {
+        .name = "spi0_ck",
+        .parent = &hclk_ck,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 0,
+        .enable_reg = SPICTRL_REG,
+};
+
+static struct clk spi1_ck = {
+        .name = "spi1_ck",
+        .parent = &hclk_ck,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 4,
+        .enable_reg = SPICTRL_REG,
+};
+
+static struct clk dma_ck = {
+        .name = "dma_ck",
+        .parent = &hclk_ck,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 0,
+        .enable_reg = DMACLKCTRL_REG,
+};
+
+static struct clk uart3_ck = {
+        .name = "uart3_ck",
+        .parent = &per_ck,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .rate = 1,
+        .enable_shift = 0,
+        .enable_reg = UARTCLKCTRL_REG,
+};
+
+static struct clk uart4_ck = {
+        .name = "uart4_ck",
+        .parent = &per_ck,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 1,
+        .enable_reg = UARTCLKCTRL_REG,
+};
+
+static struct clk uart5_ck = {
+        .name = "uart5_ck",
+        .parent = &per_ck,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .rate = 1,
+        .enable_shift = 2,
+        .enable_reg = UARTCLKCTRL_REG,
+};
+
+static struct clk uart6_ck = {
+        .name = "uart6_ck",
+        .parent = &per_ck,
+        .flags = NEEDS_INITIALIZATION,
+        .round_rate = &on_off_round_rate,
+        .set_rate = &on_off_set_rate,
+        .enable_shift = 3,
+        .enable_reg = UARTCLKCTRL_REG,
+};
+
+/* These clocks are visible outside this module
+ * and can be initialized
+ */
+static struct clk *onchip_clks[] = {
+        &ck_13MHz,
+        &ck_pll1,
+        &ck_pll4,
+        &ck_pll5,
+        &ck_pll3,
+        &vfp9_ck,
+        &m2hclk_ck,
+        &hclk_ck,
+        &dma_ck,
+        &flash_ck,
+        &dum_ck,
+        &keyscan_ck,
+        &pwm1_ck,
+        &pwm2_ck,
+        &jpeg_ck,
+        &ms_ck,
+        &touch_ck,
+        &i2c0_ck,
+        &i2c1_ck,
+        &i2c2_ck,
+        &spi0_ck,
+        &spi1_ck,
+        &uart3_ck,
+        &uart4_ck,
+        &uart5_ck,
+        &uart6_ck,
+};
+
+static int local_set_rate(struct clk *clk, u32 rate)
+{
+        int ret = -EINVAL;
+        if (clk->set_rate) {
+
+                if (clk->user_rate == clk->rate && clk->parent->rate) {
+                        /* if clock enabled or rate not set */
+                        clk->user_rate = clk->round_rate(clk, rate);
+                        ret = clk->set_rate(clk, clk->user_rate);
+                } else
+                        clk->user_rate = clk->round_rate(clk, rate);
+                ret = 0;
+        }
+        return ret;
+}
+
+int clk_set_rate(struct clk *clk, unsigned long rate)
+{
+        int ret = -EINVAL;
+
+        if (clk->flags & FIXED_RATE)
+                goto out;
+
+        clock_lock();
+        if ((clk->flags & PARENT_SET_RATE) && clk->parent) {
+
+                clk->user_rate = clk->round_rate(clk, rate);
+                /* parent clock needs to be refreshed
+                   for the setting to take effect */
+        } else {
+                ret = local_set_rate(clk, rate);
+        }
+        ret = 0;
+        clock_unlock();
+
+out:
+        return ret;
+}
+
+EXPORT_SYMBOL(clk_set_rate);
+
+struct clk *clk_get(struct device *dev, const char *id)
+{
+        struct clk *clk = ERR_PTR(-ENOENT);
+        struct clk **clkp;
+
+        clock_lock();
+        for (clkp = onchip_clks; clkp < onchip_clks + ARRAY_SIZE(onchip_clks);
+             clkp++) {
+                if (strcmp(id, (*clkp)->name) == 0
+                    && try_module_get((*clkp)->owner)) {
+                        clk = (*clkp);
+                        break;
+                }
+        }
+        clock_unlock();
+
+        return clk;
+}
+EXPORT_SYMBOL(clk_get);
+
+void clk_put(struct clk *clk)
+{
+        clock_lock();
+        if (clk && !IS_ERR(clk))
+                module_put(clk->owner);
+        clock_unlock();
+}
+EXPORT_SYMBOL(clk_put);
+
+unsigned long clk_get_rate(struct clk *clk)
+{
+        unsigned long ret;
+        clock_lock();
+        ret = clk->rate;
+        clock_unlock();
+        return ret;
+}
+EXPORT_SYMBOL(clk_get_rate);
+
+static int local_clk_enable(struct clk *clk)
+{
+        int ret = 0;
+
+        if (!(clk->flags & FIXED_RATE) && !clk->rate && clk->set_rate
+            && clk->user_rate)
+                ret = clk->set_rate(clk, clk->user_rate);
+        return ret;
+}
+
+static void local_clk_disable(struct clk *clk)
+{
+        if (!(clk->flags & FIXED_RATE) && clk->rate && clk->set_rate)
+                clk->set_rate(clk, 0);
+}
+
+int clk_enable(struct clk *clk)
+{
+        int ret = 0;
+
+        clock_lock();
+        ret = local_clk_enable(clk);
+        clock_unlock();
+        return ret;
+}
+
+EXPORT_SYMBOL(clk_enable);
+
+void clk_disable(struct clk *clk)
+{
+        clock_lock();
+        local_clk_disable(clk);
+        clock_unlock();
+}
+
+EXPORT_SYMBOL(clk_disable);
+
+static void local_clk_unuse(struct clk *clk)
+{
+        if (clk->usecount > 0 && !(--clk->usecount)) {
+                local_clk_disable(clk);
+                if (clk->parent)
+                        local_clk_unuse(clk->parent);
+        }
+}
+
+static int local_clk_use(struct clk *clk)
+{
+        int ret = 0;
+        if (clk->usecount++ == 0) {
+                if (clk->parent)
+                        ret = local_clk_use(clk->parent);
+
+                if (ret != 0) {
+                        clk->usecount--;
+                        goto out;
+                }
+
+                ret = local_clk_enable(clk);
+
+                if (ret != 0 && clk->parent) {
+                        local_clk_unuse(clk->parent);
+                        clk->usecount--;
+                }
+        }
+out:
+        return ret;
+}
+
+/* The main purpose of clk_use ans clk_unuse functions
+ * is to control switching 13MHz oscillator and PLL1 (13'MHz),
+ * so that they are disabled whenever none of PLL2-5 is using them.
+ * Although in theory these functions should work with any clock,
+ * please use them only on PLL2 - PLL5 to avoid confusion.
+ */
+int clk_use(struct clk *clk)
+{
+        int ret = 0;
+
+        clock_lock();
+        ret = local_clk_use(clk);
+        clock_unlock();
+        return ret;
+}
+EXPORT_SYMBOL(clk_use);
+
+void clk_unuse(struct clk *clk)
+{
+
+        clock_lock();
+        local_clk_unuse(clk);
+        clock_unlock();
+}
+
+EXPORT_SYMBOL(clk_unuse);
+
+long clk_round_rate(struct clk *clk, unsigned long rate)
+{
+        long ret;
+        clock_lock();
+        if (clk->round_rate)
+                ret = clk->round_rate(clk, rate);
+        else
+                ret = clk->rate;
+        clock_unlock();
+        return ret;
+}
+
+EXPORT_SYMBOL(clk_round_rate);
+
+int clk_set_parent(struct clk *clk, struct clk *parent)
+{
+        int ret = -ENODEV;
+        if (!clk->set_parent)
+                goto out;
+
+        clock_lock();
+        ret = clk->set_parent(clk, parent);
+        if (!ret)
+                clk->parent = parent;
+        clock_unlock();
+
+out:
+        return ret;
+}
+
+EXPORT_SYMBOL(clk_set_parent);
+
+static int __init clk_init(void)
+{
+        struct clk **clkp;
+
+        /* Disable autoclocking, as it doesn't seem to work */
+        __raw_writel(0xff, AUTOCLK_CTRL);
+
+        for (clkp = onchip_clks; clkp < onchip_clks + ARRAY_SIZE(onchip_clks);
+             clkp++) {
+                if (((*clkp)->flags & NEEDS_INITIALIZATION)
+                    && ((*clkp)->set_rate)) {
+                        (*clkp)->user_rate = (*clkp)->rate;
+                        local_set_rate((*clkp), (*clkp)->user_rate);
+                        if ((*clkp)->set_parent)
+                                (*clkp)->set_parent((*clkp), (*clkp)->parent);
+                }
+                pr_debug("%s: clock %s, rate %ld\n",
+                        __FUNCTION__, (*clkp)->name, (*clkp)->rate);
+        }
+
+        clk_use(&ck_pll4);
+
+        /* if ck_13MHz is not used, disable it. */
+        if (ck_13MHz.usecount == 0)
+                local_clk_disable(&ck_13MHz);
+
+        /* Disable autoclocking */
+        __raw_writeb(0xff, AUTOCLK_CTRL);
+
+        return 0;
+}
+
+arch_initcall(clk_init);
diff --git a/arch/arm/mach-pnx4008/clock.h b/arch/arm/mach-pnx4008/clock.h
new file mode 100644
index 000000000000..cd58f372cfd0
--- /dev/null
+++ b/arch/arm/mach-pnx4008/clock.h
@@ -0,0 +1,43 @@
+/*
+ * arch/arm/mach-pnx4008/clock.h
+ *
+ * Clock control driver for PNX4008 - internal header file
+ *
+ * Author: Vitaly Wool <source@mvista.com>
+ *
+ * 2006 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+#ifndef __ARCH_ARM_PNX4008_CLOCK_H__
+#define __ARCH_ARM_PNX4008_CLOCK_H__
+
+struct clk {
+        struct list_head node;
+        struct module *owner;
+        const char *name;
+        struct clk *parent;
+        struct clk *propagate_next;
+        u32 rate;
+        u32 user_rate;
+        s8 usecount;
+        u32 flags;
+        u32 scale_reg;
+        u8 enable_shift;
+        u32 enable_reg;
+        u8 enable_shift1;
+        u32 enable_reg1;
+        u32 parent_switch_reg;
+         u32(*round_rate) (struct clk *, u32);
+        int (*set_rate) (struct clk *, u32);
+        int (*set_parent) (struct clk * clk, struct clk * parent);
+};
+
+/* Flags */
+#define RATE_PROPAGATES      (1<<0)
+#define NEEDS_INITIALIZATION (1<<1)
+#define PARENT_SET_RATE      (1<<2)
+#define FIXED_RATE           (1<<3)
+
+#endif
diff --git a/arch/arm/mach-pnx4008/core.c b/arch/arm/mach-pnx4008/core.c
new file mode 100644
index 000000000000..ba91daad64fb
--- /dev/null
+++ b/arch/arm/mach-pnx4008/core.c
@@ -0,0 +1,207 @@
+/*
+ * arch/arm/mach-pnx4008/core.c
+ *
+ * PNX4008 core startup code
+ *
+ * Authors: Vitaly Wool, Dmitry Chigirev,
+ * Grigory Tolstolytkin, Dmitry Pervushin <source@mvista.com>
+ *
+ * Based on reference code received from Philips:
+ * Copyright (C) 2003 Philips Semiconductors
+ *
+ * 2005 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/mm.h>
+#include <linux/interrupt.h>
+#include <linux/list.h>
+#include <linux/init.h>
+#include <linux/ioport.h>
+#include <linux/serial_8250.h>
+#include <linux/device.h>
+#include <linux/spi/spi.h>
+
+#include <asm/hardware.h>
+#include <asm/irq.h>
+#include <asm/io.h>
+#include <asm/setup.h>
+#include <asm/mach-types.h>
+#include <asm/pgtable.h>
+#include <asm/page.h>
+#include <asm/system.h>
+
+#include <asm/mach/arch.h>
+#include <asm/mach/irq.h>
+#include <asm/mach/map.h>
+#include <asm/mach/time.h>
+
+#include <asm/arch/irq.h>
+#include <asm/arch/clock.h>
+#include <asm/arch/dma.h>
+
+struct resource spipnx_0_resources[] = {
+        {
+                .start = PNX4008_SPI1_BASE,
+                .end = PNX4008_SPI1_BASE + SZ_4K,
+                .flags = IORESOURCE_MEM,
+        }, {
+                .start = PER_SPI1_REC_XMIT,
+                .flags = IORESOURCE_DMA,
+        }, {
+                .start = SPI1_INT,
+                .flags = IORESOURCE_IRQ,
+        }, {
+                .flags = 0,
+        },
+};
+
+struct resource spipnx_1_resources[] = {
+        {
+                .start = PNX4008_SPI2_BASE,
+                .end = PNX4008_SPI2_BASE + SZ_4K,
+                .flags = IORESOURCE_MEM,
+        }, {
+                .start = PER_SPI2_REC_XMIT,
+                .flags = IORESOURCE_DMA,
+        }, {
+                .start = SPI2_INT,
+                .flags = IORESOURCE_IRQ,
+        }, {
+                .flags = 0,
+        }
+};
+
+static struct spi_board_info spi_board_info[] __initdata = {
+        {
+                .modalias       = "m25p80",
+                .max_speed_hz   = 1000000,
+                .bus_num        = 1,
+                .chip_select    = 0,
+        },
+};
+
+static struct platform_device spipnx_1 = {
+        .name = "spipnx",
+        .id = 1,
+        .num_resources = ARRAY_SIZE(spipnx_0_resources),
+        .resource = spipnx_0_resources,
+        .dev = {
+                .coherent_dma_mask = 0xFFFFFFFF,
+                },
+};
+
+static struct platform_device spipnx_2 = {
+        .name = "spipnx",
+        .id = 2,
+        .num_resources = ARRAY_SIZE(spipnx_1_resources),
+        .resource = spipnx_1_resources,
+        .dev = {
+                .coherent_dma_mask = 0xFFFFFFFF,
+                },
+};
+
+static struct plat_serial8250_port platform_serial_ports[] = {
+        {
+                .membase = (void *)__iomem(IO_ADDRESS(PNX4008_UART5_BASE)),
+                .mapbase = (unsigned long)PNX4008_UART5_BASE,
+                .irq = IIR5_INT,
+                .uartclk = PNX4008_UART_CLK,
+                .regshift = 2,
+                .iotype = UPIO_MEM,
+                .flags = UPF_BOOT_AUTOCONF | UPF_BUGGY_UART | UPF_SKIP_TEST,
+        },
+        {
+                .membase = (void *)__iomem(IO_ADDRESS(PNX4008_UART3_BASE)),
+                .mapbase = (unsigned long)PNX4008_UART3_BASE,
+                .irq = IIR3_INT,
+                .uartclk = PNX4008_UART_CLK,
+                .regshift = 2,
+                .iotype = UPIO_MEM,
+                .flags = UPF_BOOT_AUTOCONF | UPF_BUGGY_UART | UPF_SKIP_TEST,
+         },
+        {}
+};
+
+static struct platform_device serial_device = {
+        .name = "serial8250",
+        .id = PLAT8250_DEV_PLATFORM,
+        .dev = {
+                .platform_data = &platform_serial_ports,
+        },
+};
+
+static struct platform_device *devices[] __initdata = {
+        &spipnx_1,
+        &spipnx_2,
+        &serial_device,
+};
+
+
+extern void pnx4008_uart_init(void);
+
+static void __init pnx4008_init(void)
+{
+        /*disable all START interrupt sources,
+           and clear all START interrupt flags */
+        __raw_writel(0, START_INT_ER_REG(SE_PIN_BASE_INT));
+        __raw_writel(0, START_INT_ER_REG(SE_INT_BASE_INT));
+        __raw_writel(0xffffffff, START_INT_RSR_REG(SE_PIN_BASE_INT));
+        __raw_writel(0xffffffff, START_INT_RSR_REG(SE_INT_BASE_INT));
+
+        platform_add_devices(devices, ARRAY_SIZE(devices));
+        spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info));
+        /* Switch on the UART clocks */
+        pnx4008_uart_init();
+}
+
+static struct map_desc pnx4008_io_desc[] __initdata = {
+        {
+                .virtual        = IO_ADDRESS(PNX4008_IRAM_BASE),
+                .pfn            = __phys_to_pfn(PNX4008_IRAM_BASE),
+                .length         = SZ_64K,
+                .type           = MT_DEVICE,
+        }, {
+                .virtual        = IO_ADDRESS(PNX4008_NDF_FLASH_BASE),
+                .pfn            = __phys_to_pfn(PNX4008_NDF_FLASH_BASE),
+                .length         = SZ_1M - SZ_128K,
+                .type           = MT_DEVICE,
+        }, {
+                .virtual        = IO_ADDRESS(PNX4008_JPEG_CONFIG_BASE),
+                .pfn            = __phys_to_pfn(PNX4008_JPEG_CONFIG_BASE),
+                .length         = SZ_128K * 3,
+                .type           = MT_DEVICE,
+        }, {
+                .virtual        = IO_ADDRESS(PNX4008_DMA_CONFIG_BASE),
+                .pfn            = __phys_to_pfn(PNX4008_DMA_CONFIG_BASE),
+                .length         = SZ_1M,
+                .type           = MT_DEVICE,
+        }, {
+                .virtual        = IO_ADDRESS(PNX4008_AHB2FAB_BASE),
+                .pfn            = __phys_to_pfn(PNX4008_AHB2FAB_BASE),
+                .length         = SZ_1M,
+                .type           = MT_DEVICE,
+        },
+};
+
+void __init pnx4008_map_io(void)
+{
+        iotable_init(pnx4008_io_desc, ARRAY_SIZE(pnx4008_io_desc));
+}
+
+extern struct sys_timer pnx4008_timer;
+
+MACHINE_START(PNX4008, "Philips PNX4008")
+        /* Maintainer: MontaVista Software Inc. */
+        .phys_io                = 0x40090000,
+        .io_pg_offst            = (0xf4090000 >> 18) & 0xfffc,
+        .boot_params            = 0x80000100,
+        .map_io                 = pnx4008_map_io,
+        .init_irq               = pnx4008_init_irq,
+        .init_machine           = pnx4008_init,
+        .timer                  = &pnx4008_timer,
+MACHINE_END
diff --git a/arch/arm/mach-pnx4008/dma.c b/arch/arm/mach-pnx4008/dma.c
new file mode 100644
index 000000000000..981aa9dcdede
--- /dev/null
+++ b/arch/arm/mach-pnx4008/dma.c
@@ -0,0 +1,1109 @@
+/*
+ *  linux/arch/arm/mach-pnx4008/dma.c
+ *
+ *  PNX4008 DMA registration and IRQ dispatching
+ *
+ *  Author:     Vitaly Wool
+ *  Copyright:  MontaVista Software Inc. (c) 2005
+ *
+ *  Based on the code from Nicolas Pitre
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/dma-mapping.h>
+#include <linux/clk.h>
+
+#include <asm/system.h>
+#include <asm/irq.h>
+#include <asm/hardware.h>
+#include <asm/dma.h>
+#include <asm/dma-mapping.h>
+#include <asm/io.h>
+#include <asm/mach/dma.h>
+#include <asm/arch/clock.h>
+
+static struct dma_channel {
+        char *name;
+        void (*irq_handler) (int, int, void *, struct pt_regs *);
+        void *data;
+        struct pnx4008_dma_ll *ll;
+        u32 ll_dma;
+        void *target_addr;
+        int target_id;
+} dma_channels[MAX_DMA_CHANNELS];
+
+static struct ll_pool {
+        void *vaddr;
+        void *cur;
+        dma_addr_t dma_addr;
+        int count;
+} ll_pool;
+
+static spinlock_t ll_lock = SPIN_LOCK_UNLOCKED;
+
+struct pnx4008_dma_ll *pnx4008_alloc_ll_entry(dma_addr_t * ll_dma)
+{
+        struct pnx4008_dma_ll *ll = NULL;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ll_lock, flags);
+        if (ll_pool.count > 4) { /* can give one more */
+                ll = *(struct pnx4008_dma_ll **) ll_pool.cur;
+                *ll_dma = ll_pool.dma_addr + ((void *)ll - ll_pool.vaddr);
+                *(void **)ll_pool.cur = **(void ***)ll_pool.cur;
+                memset(ll, 0, sizeof(*ll));
+                ll_pool.count--;
+        }
+        spin_unlock_irqrestore(&ll_lock, flags);
+
+        return ll;
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_alloc_ll_entry);
+
+void pnx4008_free_ll_entry(struct pnx4008_dma_ll * ll, dma_addr_t ll_dma)
+{
+        unsigned long flags;
+
+        if (ll) {
+                if ((unsigned long)((long)ll - (long)ll_pool.vaddr) > 0x4000) {
+                        printk(KERN_ERR "Trying to free entry not allocated by DMA\n");
+                        BUG();
+                }
+
+                if (ll->flags & DMA_BUFFER_ALLOCATED)
+                        ll->free(ll->alloc_data);
+
+                spin_lock_irqsave(&ll_lock, flags);
+                *(long *)ll = *(long *)ll_pool.cur;
+                *(long *)ll_pool.cur = (long)ll;
+                ll_pool.count++;
+                spin_unlock_irqrestore(&ll_lock, flags);
+        }
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_free_ll_entry);
+
+void pnx4008_free_ll(u32 ll_dma, struct pnx4008_dma_ll * ll)
+{
+        struct pnx4008_dma_ll *ptr;
+        u32 dma;
+
+        while (ll) {
+                dma = ll->next_dma;
+                ptr = ll->next;
+                pnx4008_free_ll_entry(ll, ll_dma);
+
+                ll_dma = dma;
+                ll = ptr;
+        }
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_free_ll);
+
+static int dma_channels_requested = 0;
+
+static inline void dma_increment_usage(void)
+{
+        if (!dma_channels_requested++) {
+                struct clk *clk = clk_get(0, "dma_ck");
+                if (!IS_ERR(clk)) {
+                        clk_set_rate(clk, 1);
+                        clk_put(clk);
+                }
+                pnx4008_config_dma(-1, -1, 1);
+        }
+}
+static inline void dma_decrement_usage(void)
+{
+        if (!--dma_channels_requested) {
+                struct clk *clk = clk_get(0, "dma_ck");
+                if (!IS_ERR(clk)) {
+                        clk_set_rate(clk, 0);
+                        clk_put(clk);
+                }
+                pnx4008_config_dma(-1, -1, 0);
+
+        }
+}
+
+static spinlock_t dma_lock = SPIN_LOCK_UNLOCKED;
+
+static inline void pnx4008_dma_lock(void)
+{
+        spin_lock_irq(&dma_lock);
+}
+
+static inline void pnx4008_dma_unlock(void)
+{
+        spin_unlock_irq(&dma_lock);
+}
+
+#define VALID_CHANNEL(c)        (((c) >= 0) && ((c) < MAX_DMA_CHANNELS))
+
+int pnx4008_request_channel(char *name, int ch,
+                            void (*irq_handler) (int, int, void *,
+                                                 struct pt_regs *), void *data)
+{
+        int i, found = 0;
+
+        /* basic sanity checks */
+        if (!name || (ch != -1 && !VALID_CHANNEL(ch)))
+                return -EINVAL;
+
+        pnx4008_dma_lock();
+
+        /* try grabbing a DMA channel with the requested priority */
+        for (i = MAX_DMA_CHANNELS - 1; i >= 0; i--) {
+                if (!dma_channels[i].name && (ch == -1 || ch == i)) {
+                        found = 1;
+                        break;
+                }
+        }
+
+        if (found) {
+                dma_increment_usage();
+                dma_channels[i].name = name;
+                dma_channels[i].irq_handler = irq_handler;
+                dma_channels[i].data = data;
+                dma_channels[i].ll = NULL;
+                dma_channels[i].ll_dma = 0;
+        } else {
+                printk(KERN_WARNING "No more available DMA channels for %s\n",
+                       name);
+                i = -ENODEV;
+        }
+
+        pnx4008_dma_unlock();
+        return i;
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_request_channel);
+
+void pnx4008_free_channel(int ch)
+{
+        if (!dma_channels[ch].name) {
+                printk(KERN_CRIT
+                       "%s: trying to free channel %d which is already freed\n",
+                       __FUNCTION__, ch);
+                return;
+        }
+
+        pnx4008_dma_lock();
+        pnx4008_free_ll(dma_channels[ch].ll_dma, dma_channels[ch].ll);
+        dma_channels[ch].ll = NULL;
+        dma_decrement_usage();
+
+        dma_channels[ch].name = NULL;
+        pnx4008_dma_unlock();
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_free_channel);
+
+int pnx4008_config_dma(int ahb_m1_be, int ahb_m2_be, int enable)
+{
+        unsigned long dma_cfg = __raw_readl(DMAC_CONFIG);
+
+        switch (ahb_m1_be) {
+        case 0:
+                dma_cfg &= ~(1 << 1);
+                break;
+        case 1:
+                dma_cfg |= (1 << 1);
+                break;
+        default:
+                break;
+        }
+
+        switch (ahb_m2_be) {
+        case 0:
+                dma_cfg &= ~(1 << 2);
+                break;
+        case 1:
+                dma_cfg |= (1 << 2);
+                break;
+        default:
+                break;
+        }
+
+        switch (enable) {
+        case 0:
+                dma_cfg &= ~(1 << 0);
+                break;
+        case 1:
+                dma_cfg |= (1 << 0);
+                break;
+        default:
+                break;
+        }
+
+        pnx4008_dma_lock();
+        __raw_writel(dma_cfg, DMAC_CONFIG);
+        pnx4008_dma_unlock();
+
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_config_dma);
+
+int pnx4008_dma_pack_control(const struct pnx4008_dma_ch_ctrl * ch_ctrl,
+                             unsigned long *ctrl)
+{
+        int i = 0, dbsize, sbsize, err = 0;
+
+        if (!ctrl || !ch_ctrl) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        *ctrl = 0;
+
+        switch (ch_ctrl->tc_mask) {
+        case 0:
+                break;
+        case 1:
+                *ctrl |= (1 << 31);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+
+        switch (ch_ctrl->cacheable) {
+        case 0:
+                break;
+        case 1:
+                *ctrl |= (1 << 30);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        switch (ch_ctrl->bufferable) {
+        case 0:
+                break;
+        case 1:
+                *ctrl |= (1 << 29);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        switch (ch_ctrl->priv_mode) {
+        case 0:
+                break;
+        case 1:
+                *ctrl |= (1 << 28);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        switch (ch_ctrl->di) {
+        case 0:
+                break;
+        case 1:
+                *ctrl |= (1 << 27);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        switch (ch_ctrl->si) {
+        case 0:
+                break;
+        case 1:
+                *ctrl |= (1 << 26);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        switch (ch_ctrl->dest_ahb1) {
+        case 0:
+                break;
+        case 1:
+                *ctrl |= (1 << 25);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        switch (ch_ctrl->src_ahb1) {
+        case 0:
+                break;
+        case 1:
+                *ctrl |= (1 << 24);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        switch (ch_ctrl->dwidth) {
+        case WIDTH_BYTE:
+                *ctrl &= ~(7 << 21);
+                break;
+        case WIDTH_HWORD:
+                *ctrl &= ~(7 << 21);
+                *ctrl |= (1 << 21);
+                break;
+        case WIDTH_WORD:
+                *ctrl &= ~(7 << 21);
+                *ctrl |= (2 << 21);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        switch (ch_ctrl->swidth) {
+        case WIDTH_BYTE:
+                *ctrl &= ~(7 << 18);
+                break;
+        case WIDTH_HWORD:
+                *ctrl &= ~(7 << 18);
+                *ctrl |= (1 << 18);
+                break;
+        case WIDTH_WORD:
+                *ctrl &= ~(7 << 18);
+                *ctrl |= (2 << 18);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        dbsize = ch_ctrl->dbsize;
+        while (!(dbsize & 1)) {
+                i++;
+                dbsize >>= 1;
+        }
+        if (ch_ctrl->dbsize != 1 || i > 8 || i == 1) {
+                err = -EINVAL;
+                goto out;
+        } else if (i > 1)
+                i--;
+        *ctrl &= ~(7 << 15);
+        *ctrl |= (i << 15);
+
+        sbsize = ch_ctrl->sbsize;
+        while (!(sbsize & 1)) {
+                i++;
+                sbsize >>= 1;
+        }
+        if (ch_ctrl->sbsize != 1 || i > 8 || i == 1) {
+                err = -EINVAL;
+                goto out;
+        } else if (i > 1)
+                i--;
+        *ctrl &= ~(7 << 12);
+        *ctrl |= (i << 12);
+
+        if (ch_ctrl->tr_size > 0x7ff) {
+                err = -E2BIG;
+                goto out;
+        }
+        *ctrl &= ~0x7ff;
+        *ctrl |= ch_ctrl->tr_size & 0x7ff;
+
+out:
+        return err;
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_dma_pack_control);
+
+int pnx4008_dma_parse_control(unsigned long ctrl,
+                              struct pnx4008_dma_ch_ctrl * ch_ctrl)
+{
+        int err = 0;
+
+        if (!ch_ctrl) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        ch_ctrl->tr_size = ctrl & 0x7ff;
+        ctrl >>= 12;
+
+        ch_ctrl->sbsize = 1 << (ctrl & 7);
+        if (ch_ctrl->sbsize > 1)
+                ch_ctrl->sbsize <<= 1;
+        ctrl >>= 3;
+
+        ch_ctrl->dbsize = 1 << (ctrl & 7);
+        if (ch_ctrl->dbsize > 1)
+                ch_ctrl->dbsize <<= 1;
+        ctrl >>= 3;
+
+        switch (ctrl & 7) {
+        case 0:
+                ch_ctrl->swidth = WIDTH_BYTE;
+                break;
+        case 1:
+                ch_ctrl->swidth = WIDTH_HWORD;
+                break;
+        case 2:
+                ch_ctrl->swidth = WIDTH_WORD;
+                break;
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        ctrl >>= 3;
+
+        switch (ctrl & 7) {
+        case 0:
+                ch_ctrl->dwidth = WIDTH_BYTE;
+                break;
+        case 1:
+                ch_ctrl->dwidth = WIDTH_HWORD;
+                break;
+        case 2:
+                ch_ctrl->dwidth = WIDTH_WORD;
+                break;
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        ctrl >>= 3;
+
+        ch_ctrl->src_ahb1 = ctrl & 1;
+        ctrl >>= 1;
+
+        ch_ctrl->dest_ahb1 = ctrl & 1;
+        ctrl >>= 1;
+
+        ch_ctrl->si = ctrl & 1;
+        ctrl >>= 1;
+
+        ch_ctrl->di = ctrl & 1;
+        ctrl >>= 1;
+
+        ch_ctrl->priv_mode = ctrl & 1;
+        ctrl >>= 1;
+
+        ch_ctrl->bufferable = ctrl & 1;
+        ctrl >>= 1;
+
+        ch_ctrl->cacheable = ctrl & 1;
+        ctrl >>= 1;
+
+        ch_ctrl->tc_mask = ctrl & 1;
+
+out:
+        return err;
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_dma_parse_control);
+
+int pnx4008_dma_pack_config(const struct pnx4008_dma_ch_config * ch_cfg,
+                            unsigned long *cfg)
+{
+        int err = 0;
+
+        if (!cfg || !ch_cfg) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        *cfg = 0;
+
+        switch (ch_cfg->halt) {
+        case 0:
+                break;
+        case 1:
+                *cfg |= (1 << 18);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        switch (ch_cfg->active) {
+        case 0:
+                break;
+        case 1:
+                *cfg |= (1 << 17);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        switch (ch_cfg->lock) {
+        case 0:
+                break;
+        case 1:
+                *cfg |= (1 << 16);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        switch (ch_cfg->itc) {
+        case 0:
+                break;
+        case 1:
+                *cfg |= (1 << 15);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        switch (ch_cfg->ie) {
+        case 0:
+                break;
+        case 1:
+                *cfg |= (1 << 14);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        switch (ch_cfg->flow_cntrl) {
+        case FC_MEM2MEM_DMA:
+                *cfg &= ~(7 << 11);
+                break;
+        case FC_MEM2PER_DMA:
+                *cfg &= ~(7 << 11);
+                *cfg |= (1 << 11);
+                break;
+        case FC_PER2MEM_DMA:
+                *cfg &= ~(7 << 11);
+                *cfg |= (2 << 11);
+                break;
+        case FC_PER2PER_DMA:
+                *cfg &= ~(7 << 11);
+                *cfg |= (3 << 11);
+                break;
+        case FC_PER2PER_DPER:
+                *cfg &= ~(7 << 11);
+                *cfg |= (4 << 11);
+                break;
+        case FC_MEM2PER_PER:
+                *cfg &= ~(7 << 11);
+                *cfg |= (5 << 11);
+                break;
+        case FC_PER2MEM_PER:
+                *cfg &= ~(7 << 11);
+                *cfg |= (6 << 11);
+                break;
+        case FC_PER2PER_SPER:
+                *cfg |= (7 << 11);
+                break;
+
+        default:
+                err = -EINVAL;
+                goto out;
+        }
+        *cfg &= ~(0x1f << 6);
+        *cfg |= ((ch_cfg->dest_per & 0x1f) << 6);
+
+        *cfg &= ~(0x1f << 1);
+        *cfg |= ((ch_cfg->src_per & 0x1f) << 1);
+
+out:
+        return err;
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_dma_pack_config);
+
+int pnx4008_dma_parse_config(unsigned long cfg,
+                             struct pnx4008_dma_ch_config * ch_cfg)
+{
+        int err = 0;
+
+        if (!ch_cfg) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        cfg >>= 1;
+
+        ch_cfg->src_per = cfg & 0x1f;
+        cfg >>= 5;
+
+        ch_cfg->dest_per = cfg & 0x1f;
+        cfg >>= 5;
+
+        switch (cfg & 7) {
+        case 0:
+                ch_cfg->flow_cntrl = FC_MEM2MEM_DMA;
+                break;
+        case 1:
+                ch_cfg->flow_cntrl = FC_MEM2PER_DMA;
+                break;
+        case 2:
+                ch_cfg->flow_cntrl = FC_PER2MEM_DMA;
+                break;
+        case 3:
+                ch_cfg->flow_cntrl = FC_PER2PER_DMA;
+                break;
+        case 4:
+                ch_cfg->flow_cntrl = FC_PER2PER_DPER;
+                break;
+        case 5:
+                ch_cfg->flow_cntrl = FC_MEM2PER_PER;
+                break;
+        case 6:
+                ch_cfg->flow_cntrl = FC_PER2MEM_PER;
+                break;
+        case 7:
+                ch_cfg->flow_cntrl = FC_PER2PER_SPER;
+        }
+        cfg >>= 3;
+
+        ch_cfg->ie = cfg & 1;
+        cfg >>= 1;
+
+        ch_cfg->itc = cfg & 1;
+        cfg >>= 1;
+
+        ch_cfg->lock = cfg & 1;
+        cfg >>= 1;
+
+        ch_cfg->active = cfg & 1;
+        cfg >>= 1;
+
+        ch_cfg->halt = cfg & 1;
+
+out:
+        return err;
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_dma_parse_config);
+
+void pnx4008_dma_split_head_entry(struct pnx4008_dma_config * config,
+                                  struct pnx4008_dma_ch_ctrl * ctrl)
+{
+        int new_len = ctrl->tr_size, num_entries = 0;
+        int old_len = new_len;
+        int src_width, dest_width, count = 1;
+
+        switch (ctrl->swidth) {
+        case WIDTH_BYTE:
+                src_width = 1;
+                break;
+        case WIDTH_HWORD:
+                src_width = 2;
+                break;
+        case WIDTH_WORD:
+                src_width = 4;
+                break;
+        default:
+                return;
+        }
+
+        switch (ctrl->dwidth) {
+        case WIDTH_BYTE:
+                dest_width = 1;
+                break;
+        case WIDTH_HWORD:
+                dest_width = 2;
+                break;
+        case WIDTH_WORD:
+                dest_width = 4;
+                break;
+        default:
+                return;
+        }
+
+        while (new_len > 0x7FF) {
+                num_entries++;
+                new_len = (ctrl->tr_size + num_entries) / (num_entries + 1);
+        }
+        if (num_entries != 0) {
+                struct pnx4008_dma_ll *ll = NULL;
+                config->ch_ctrl &= ~0x7ff;
+                config->ch_ctrl |= new_len;
+                if (!config->is_ll) {
+                        config->is_ll = 1;
+                        while (num_entries) {
+                                if (!ll) {
+                                        config->ll =
+                                            pnx4008_alloc_ll_entry(&config->
+                                                                   ll_dma);
+                                        ll = config->ll;
+                                } else {
+                                        ll->next =
+                                            pnx4008_alloc_ll_entry(&ll->
+                                                                   next_dma);
+                                        ll = ll->next;
+                                }
+
+                                if (ctrl->si)
+                                        ll->src_addr =
+                                            config->src_addr +
+                                            src_width * new_len * count;
+                                else
+                                        ll->src_addr = config->src_addr;
+                                if (ctrl->di)
+                                        ll->dest_addr =
+                                            config->dest_addr +
+                                            dest_width * new_len * count;
+                                else
+                                        ll->dest_addr = config->dest_addr;
+                                ll->ch_ctrl = config->ch_ctrl & 0x7fffffff;
+                                ll->next_dma = 0;
+                                ll->next = NULL;
+                                num_entries--;
+                                count++;
+                        }
+                } else {
+                        struct pnx4008_dma_ll *ll_old = config->ll;
+                        unsigned long ll_dma_old = config->ll_dma;
+                        while (num_entries) {
+                                if (!ll) {
+                                        config->ll =
+                                            pnx4008_alloc_ll_entry(&config->
+                                                                   ll_dma);
+                                        ll = config->ll;
+                                } else {
+                                        ll->next =
+                                            pnx4008_alloc_ll_entry(&ll->
+                                                                   next_dma);
+                                        ll = ll->next;
+                                }
+
+                                if (ctrl->si)
+                                        ll->src_addr =
+                                            config->src_addr +
+                                            src_width * new_len * count;
+                                else
+                                        ll->src_addr = config->src_addr;
+                                if (ctrl->di)
+                                        ll->dest_addr =
+                                            config->dest_addr +
+                                            dest_width * new_len * count;
+                                else
+                                        ll->dest_addr = config->dest_addr;
+                                ll->ch_ctrl = config->ch_ctrl & 0x7fffffff;
+                                ll->next_dma = 0;
+                                ll->next = NULL;
+                                num_entries--;
+                                count++;
+                        }
+                        ll->next_dma = ll_dma_old;
+                        ll->next = ll_old;
+                }
+                /* adjust last length/tc */
+                ll->ch_ctrl = config->ch_ctrl & (~0x7ff);
+                ll->ch_ctrl |= old_len - new_len * (count - 1);
+                config->ch_ctrl &= 0x7fffffff;
+        }
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_dma_split_head_entry);
+
+void pnx4008_dma_split_ll_entry(struct pnx4008_dma_ll * cur_ll,
+                                struct pnx4008_dma_ch_ctrl * ctrl)
+{
+        int new_len = ctrl->tr_size, num_entries = 0;
+        int old_len = new_len;
+        int src_width, dest_width, count = 1;
+
+        switch (ctrl->swidth) {
+        case WIDTH_BYTE:
+                src_width = 1;
+                break;
+        case WIDTH_HWORD:
+                src_width = 2;
+                break;
+        case WIDTH_WORD:
+                src_width = 4;
+                break;
+        default:
+                return;
+        }
+
+        switch (ctrl->dwidth) {
+        case WIDTH_BYTE:
+                dest_width = 1;
+                break;
+        case WIDTH_HWORD:
+                dest_width = 2;
+                break;
+        case WIDTH_WORD:
+                dest_width = 4;
+                break;
+        default:
+                return;
+        }
+
+        while (new_len > 0x7FF) {
+                num_entries++;
+                new_len = (ctrl->tr_size + num_entries) / (num_entries + 1);
+        }
+        if (num_entries != 0) {
+                struct pnx4008_dma_ll *ll = NULL;
+                cur_ll->ch_ctrl &= ~0x7ff;
+                cur_ll->ch_ctrl |= new_len;
+                if (!cur_ll->next) {
+                        while (num_entries) {
+                                if (!ll) {
+                                        cur_ll->next =
+                                            pnx4008_alloc_ll_entry(&cur_ll->
+                                                                   next_dma);
+                                        ll = cur_ll->next;
+                                } else {
+                                        ll->next =
+                                            pnx4008_alloc_ll_entry(&ll->
+                                                                   next_dma);
+                                        ll = ll->next;
+                                }
+
+                                if (ctrl->si)
+                                        ll->src_addr =
+                                            cur_ll->src_addr +
+                                            src_width * new_len * count;
+                                else
+                                        ll->src_addr = cur_ll->src_addr;
+                                if (ctrl->di)
+                                        ll->dest_addr =
+                                            cur_ll->dest_addr +
+                                            dest_width * new_len * count;
+                                else
+                                        ll->dest_addr = cur_ll->dest_addr;
+                                ll->ch_ctrl = cur_ll->ch_ctrl & 0x7fffffff;
+                                ll->next_dma = 0;
+                                ll->next = NULL;
+                                num_entries--;
+                                count++;
+                        }
+                } else {
+                        struct pnx4008_dma_ll *ll_old = cur_ll->next;
+                        unsigned long ll_dma_old = cur_ll->next_dma;
+                        while (num_entries) {
+                                if (!ll) {
+                                        cur_ll->next =
+                                            pnx4008_alloc_ll_entry(&cur_ll->
+                                                                   next_dma);
+                                        ll = cur_ll->next;
+                                } else {
+                                        ll->next =
+                                            pnx4008_alloc_ll_entry(&ll->
+                                                                   next_dma);
+                                        ll = ll->next;
+                                }
+
+                                if (ctrl->si)
+                                        ll->src_addr =
+                                            cur_ll->src_addr +
+                                            src_width * new_len * count;
+                                else
+                                        ll->src_addr = cur_ll->src_addr;
+                                if (ctrl->di)
+                                        ll->dest_addr =
+                                            cur_ll->dest_addr +
+                                            dest_width * new_len * count;
+                                else
+                                        ll->dest_addr = cur_ll->dest_addr;
+                                ll->ch_ctrl = cur_ll->ch_ctrl & 0x7fffffff;
+                                ll->next_dma = 0;
+                                ll->next = NULL;
+                                num_entries--;
+                                count++;
+                        }
+
+                        ll->next_dma = ll_dma_old;
+                        ll->next = ll_old;
+                }
+                /* adjust last length/tc */
+                ll->ch_ctrl = cur_ll->ch_ctrl & (~0x7ff);
+                ll->ch_ctrl |= old_len - new_len * (count - 1);
+                cur_ll->ch_ctrl &= 0x7fffffff;
+        }
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_dma_split_ll_entry);
+
+int pnx4008_config_channel(int ch, struct pnx4008_dma_config * config)
+{
+        if (!VALID_CHANNEL(ch) || !dma_channels[ch].name)
+                return -EINVAL;
+
+        pnx4008_dma_lock();
+        __raw_writel(config->src_addr, DMAC_Cx_SRC_ADDR(ch));
+        __raw_writel(config->dest_addr, DMAC_Cx_DEST_ADDR(ch));
+
+        if (config->is_ll)
+                __raw_writel(config->ll_dma, DMAC_Cx_LLI(ch));
+        else
+                __raw_writel(0, DMAC_Cx_LLI(ch));
+
+        __raw_writel(config->ch_ctrl, DMAC_Cx_CONTROL(ch));
+        __raw_writel(config->ch_cfg, DMAC_Cx_CONFIG(ch));
+        pnx4008_dma_unlock();
+
+        return 0;
+
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_config_channel);
+
+int pnx4008_channel_get_config(int ch, struct pnx4008_dma_config * config)
+{
+        if (!VALID_CHANNEL(ch) || !dma_channels[ch].name || !config)
+                return -EINVAL;
+
+        pnx4008_dma_lock();
+        config->ch_cfg = __raw_readl(DMAC_Cx_CONFIG(ch));
+        config->ch_ctrl = __raw_readl(DMAC_Cx_CONTROL(ch));
+
+        config->ll_dma = __raw_readl(DMAC_Cx_LLI(ch));
+        config->is_ll = config->ll_dma ? 1 : 0;
+
+        config->src_addr = __raw_readl(DMAC_Cx_SRC_ADDR(ch));
+        config->dest_addr = __raw_readl(DMAC_Cx_DEST_ADDR(ch));
+        pnx4008_dma_unlock();
+
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_channel_get_config);
+
+int pnx4008_dma_ch_enable(int ch)
+{
+        unsigned long ch_cfg;
+
+        if (!VALID_CHANNEL(ch) || !dma_channels[ch].name)
+                return -EINVAL;
+
+        pnx4008_dma_lock();
+        ch_cfg = __raw_readl(DMAC_Cx_CONFIG(ch));
+        ch_cfg |= 1;
+        __raw_writel(ch_cfg, DMAC_Cx_CONFIG(ch));
+        pnx4008_dma_unlock();
+
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_dma_ch_enable);
+
+int pnx4008_dma_ch_disable(int ch)
+{
+        unsigned long ch_cfg;
+
+        if (!VALID_CHANNEL(ch) || !dma_channels[ch].name)
+                return -EINVAL;
+
+        pnx4008_dma_lock();
+        ch_cfg = __raw_readl(DMAC_Cx_CONFIG(ch));
+        ch_cfg &= ~1;
+        __raw_writel(ch_cfg, DMAC_Cx_CONFIG(ch));
+        pnx4008_dma_unlock();
+
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_dma_ch_disable);
+
+int pnx4008_dma_ch_enabled(int ch)
+{
+        unsigned long ch_cfg;
+
+        if (!VALID_CHANNEL(ch) || !dma_channels[ch].name)
+                return -EINVAL;
+
+        pnx4008_dma_lock();
+        ch_cfg = __raw_readl(DMAC_Cx_CONFIG(ch));
+        pnx4008_dma_unlock();
+
+        return ch_cfg & 1;
+}
+
+EXPORT_SYMBOL_GPL(pnx4008_dma_ch_enabled);
+
+static irqreturn_t dma_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
+{
+        int i;
+        unsigned long dint = __raw_readl(DMAC_INT_STAT);
+        unsigned long tcint = __raw_readl(DMAC_INT_TC_STAT);
+        unsigned long eint = __raw_readl(DMAC_INT_ERR_STAT);
+        unsigned long i_bit;
+
+        for (i = MAX_DMA_CHANNELS - 1; i >= 0; i--) {
+                i_bit = 1 << i;
+                if (dint & i_bit) {
+                        struct dma_channel *channel = &dma_channels[i];
+
+                        if (channel->name && channel->irq_handler) {
+                                int cause = 0;
+
+                                if (eint & i_bit)
+                                        cause |= DMA_ERR_INT;
+                                if (tcint & i_bit)
+                                        cause |= DMA_TC_INT;
+                                channel->irq_handler(i, cause, channel->data,
+                                                     regs);
+                        } else {
+                                /*
+                                 * IRQ for an unregistered DMA channel
+                                 */
+                                printk(KERN_WARNING
+                                       "spurious IRQ for DMA channel %d\n", i);
+                        }
+                        if (tcint & i_bit)
+                                __raw_writel(i_bit, DMAC_INT_TC_CLEAR);
+                        if (eint & i_bit)
+                                __raw_writel(i_bit, DMAC_INT_ERR_CLEAR);
+                }
+        }
+        return IRQ_HANDLED;
+}
+
+static int __init pnx4008_dma_init(void)
+{
+        int ret, i;
+
+        ret = request_irq(DMA_INT, dma_irq_handler, 0, "DMA", NULL);
+        if (ret) {
+                printk(KERN_CRIT "Wow!  Can't register IRQ for DMA\n");
+                goto out;
+        }
+
+        ll_pool.count = 0x4000 / sizeof(struct pnx4008_dma_ll);
+        ll_pool.cur = ll_pool.vaddr =
+            dma_alloc_coherent(NULL, ll_pool.count * sizeof(struct pnx4008_dma_ll),
+                               &ll_pool.dma_addr, GFP_KERNEL);
+
+        if (!ll_pool.vaddr) {
+                ret = -ENOMEM;
+                free_irq(DMA_INT, NULL);
+                goto out;
+        }
+
+        for (i = 0; i < ll_pool.count - 1; i++) {
+                void **addr = ll_pool.vaddr + i * sizeof(struct pnx4008_dma_ll);
+                *addr = (void *)addr + sizeof(struct pnx4008_dma_ll);
+        }
+        *(long *)(ll_pool.vaddr +
+                  (ll_pool.count - 1) * sizeof(struct pnx4008_dma_ll)) =
+            (long)ll_pool.vaddr;
+
+        __raw_writel(1, DMAC_CONFIG);
+
+out:
+        return ret;
+}
+arch_initcall(pnx4008_dma_init);
diff --git a/arch/arm/mach-pnx4008/gpio.c b/arch/arm/mach-pnx4008/gpio.c
new file mode 100644
index 000000000000..e1ce050d8fe0
--- /dev/null
+++ b/arch/arm/mach-pnx4008/gpio.c
@@ -0,0 +1,330 @@
+/*
+ * arch/arm/mach-pnx4008/gpio.c
+ *
+ * PNX4008 GPIO driver
+ *
+ * Author: Dmitry Chigirev <source@mvista.com>
+ *
+ * Based on reference code by Iwo Mergler and Z.Tabaaloute from Philips:
+ * Copyright (c) 2005 Koninklijke Philips Electronics N.V.
+ *
+ * 2005 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <asm/semaphore.h>
+#include <asm/io.h>
+#include <asm/arch/platform.h>
+#include <asm/arch/gpio.h>
+
+/* register definitions */
+#define PIO_VA_BASE     IO_ADDRESS(PNX4008_PIO_BASE)
+
+#define PIO_INP_STATE   (0x00U)
+#define PIO_OUTP_SET    (0x04U)
+#define PIO_OUTP_CLR    (0x08U)
+#define PIO_OUTP_STATE  (0x0CU)
+#define PIO_DRV_SET     (0x10U)
+#define PIO_DRV_CLR     (0x14U)
+#define PIO_DRV_STATE   (0x18U)
+#define PIO_SDINP_STATE (0x1CU)
+#define PIO_SDOUTP_SET  (0x20U)
+#define PIO_SDOUTP_CLR  (0x24U)
+#define PIO_MUX_SET     (0x28U)
+#define PIO_MUX_CLR     (0x2CU)
+#define PIO_MUX_STATE   (0x30U)
+
+static inline void gpio_lock(void)
+{
+        local_irq_disable();
+}
+
+static inline void gpio_unlock(void)
+{
+        local_irq_enable();
+}
+
+/* Inline functions */
+static inline int gpio_read_bit(u32 reg, int gpio)
+{
+        u32 bit, val;
+        int ret = -EFAULT;
+
+        if (gpio < 0)
+                goto out;
+
+        bit = GPIO_BIT(gpio);
+        if (bit) {
+                val = __raw_readl(PIO_VA_BASE + reg);
+                ret = (val & bit) ? 1 : 0;
+        }
+out:
+        return ret;
+}
+
+static inline int gpio_set_bit(u32 reg, int gpio)
+{
+        u32 bit, val;
+        int ret = -EFAULT;
+
+        if (gpio < 0)
+                goto out;
+
+        bit = GPIO_BIT(gpio);
+        if (bit) {
+                val = __raw_readl(PIO_VA_BASE + reg);
+                val |= bit;
+                __raw_writel(val, PIO_VA_BASE + reg);
+                ret = 0;
+        }
+out:
+        return ret;
+}
+
+/* Very simple access control, bitmap for allocated/free */
+static unsigned long access_map[4];
+#define INP_INDEX       0
+#define OUTP_INDEX      1
+#define GPIO_INDEX      2
+#define MUX_INDEX       3
+
+/*GPIO to Input Mapping */
+static short gpio_to_inp_map[32] = {
+        -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, 10, 11, 12, 13, 14, 24, -1
+};
+
+/*GPIO to Mux Mapping */
+static short gpio_to_mux_map[32] = {
+        -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, 0, 1, 4, 5, -1
+};
+
+/*Output to Mux Mapping */
+static short outp_to_mux_map[32] = {
+        -1, -1, -1, 6, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, 2, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1
+};
+
+int pnx4008_gpio_register_pin(unsigned short pin)
+{
+        unsigned long bit = GPIO_BIT(pin);
+        int ret = -EBUSY;       /* Already in use */
+
+        gpio_lock();
+
+        if (GPIO_ISBID(pin)) {
+                if (access_map[GPIO_INDEX] & bit)
+                        goto out;
+                access_map[GPIO_INDEX] |= bit;
+
+        } else if (GPIO_ISRAM(pin)) {
+                if (access_map[GPIO_INDEX] & bit)
+                        goto out;
+                access_map[GPIO_INDEX] |= bit;
+
+        } else if (GPIO_ISMUX(pin)) {
+                if (access_map[MUX_INDEX] & bit)
+                        goto out;
+                access_map[MUX_INDEX] |= bit;
+
+        } else if (GPIO_ISOUT(pin)) {
+                if (access_map[OUTP_INDEX] & bit)
+                        goto out;
+                access_map[OUTP_INDEX] |= bit;
+
+        } else if (GPIO_ISIN(pin)) {
+                if (access_map[INP_INDEX] & bit)
+                        goto out;
+                access_map[INP_INDEX] |= bit;
+        } else
+                goto out;
+        ret = 0;
+
+out:
+        gpio_unlock();
+        return ret;
+}
+
+EXPORT_SYMBOL(pnx4008_gpio_register_pin);
+
+int pnx4008_gpio_unregister_pin(unsigned short pin)
+{
+        unsigned long bit = GPIO_BIT(pin);
+        int ret = -EFAULT;      /* Not registered */
+
+        gpio_lock();
+
+        if (GPIO_ISBID(pin)) {
+                if (~access_map[GPIO_INDEX] & bit)
+                        goto out;
+                access_map[GPIO_INDEX] &= ~bit;
+        } else if (GPIO_ISRAM(pin)) {
+                if (~access_map[GPIO_INDEX] & bit)
+                        goto out;
+                access_map[GPIO_INDEX] &= ~bit;
+        } else if (GPIO_ISMUX(pin)) {
+                if (~access_map[MUX_INDEX] & bit)
+                        goto out;
+                access_map[MUX_INDEX] &= ~bit;
+        } else if (GPIO_ISOUT(pin)) {
+                if (~access_map[OUTP_INDEX] & bit)
+                        goto out;
+                access_map[OUTP_INDEX] &= ~bit;
+        } else if (GPIO_ISIN(pin)) {
+                if (~access_map[INP_INDEX] & bit)
+                        goto out;
+                access_map[INP_INDEX] &= ~bit;
+        } else
+                goto out;
+        ret = 0;
+
+out:
+        gpio_unlock();
+        return ret;
+}
+
+EXPORT_SYMBOL(pnx4008_gpio_unregister_pin);
+
+unsigned long pnx4008_gpio_read_pin(unsigned short pin)
+{
+        unsigned long ret = -EFAULT;
+        int gpio = GPIO_BIT_MASK(pin);
+        gpio_lock();
+        if (GPIO_ISOUT(pin)) {
+                ret = gpio_read_bit(PIO_OUTP_STATE, gpio);
+        } else if (GPIO_ISRAM(pin)) {
+                if (gpio_read_bit(PIO_DRV_STATE, gpio) == 0) {
+                        ret = gpio_read_bit(PIO_SDINP_STATE, gpio);
+                }
+        } else if (GPIO_ISBID(pin)) {
+                ret = gpio_read_bit(PIO_DRV_STATE, gpio);
+                if (ret > 0)
+                        ret = gpio_read_bit(PIO_OUTP_STATE, gpio);
+                else if (ret == 0)
+                        ret =
+                            gpio_read_bit(PIO_INP_STATE, gpio_to_inp_map[gpio]);
+        } else if (GPIO_ISIN(pin)) {
+                ret = gpio_read_bit(PIO_INP_STATE, gpio);
+        }
+        gpio_unlock();
+        return ret;
+}
+
+EXPORT_SYMBOL(pnx4008_gpio_read_pin);
+
+/* Write Value to output */
+int pnx4008_gpio_write_pin(unsigned short pin, int output)
+{
+        int gpio = GPIO_BIT_MASK(pin);
+        int ret = -EFAULT;
+
+        gpio_lock();
+        if (GPIO_ISOUT(pin)) {
+                printk( "writing '%x' to '%x'\n",
+                                gpio, output ? PIO_OUTP_SET : PIO_OUTP_CLR );
+                ret = gpio_set_bit(output ? PIO_OUTP_SET : PIO_OUTP_CLR, gpio);
+        } else if (GPIO_ISRAM(pin)) {
+                if (gpio_read_bit(PIO_DRV_STATE, gpio) > 0)
+                        ret = gpio_set_bit(output ? PIO_SDOUTP_SET :
+                                           PIO_SDOUTP_CLR, gpio);
+        } else if (GPIO_ISBID(pin)) {
+                if (gpio_read_bit(PIO_DRV_STATE, gpio) > 0)
+                        ret = gpio_set_bit(output ? PIO_OUTP_SET :
+                                           PIO_OUTP_CLR, gpio);
+        }
+        gpio_unlock();
+        return ret;
+}
+
+EXPORT_SYMBOL(pnx4008_gpio_write_pin);
+
+/* Value = 1 : Set GPIO pin as output */
+/* Value = 0 : Set GPIO pin as input */
+int pnx4008_gpio_set_pin_direction(unsigned short pin, int output)
+{
+        int gpio = GPIO_BIT_MASK(pin);
+        int ret = -EFAULT;
+
+        gpio_lock();
+        if (GPIO_ISBID(pin) || GPIO_ISRAM(pin)) {
+                ret = gpio_set_bit(output ? PIO_DRV_SET : PIO_DRV_CLR, gpio);
+        }
+        gpio_unlock();
+        return ret;
+}
+
+EXPORT_SYMBOL(pnx4008_gpio_set_pin_direction);
+
+/* Read GPIO pin direction: 0= pin used as input, 1= pin used as output*/
+int pnx4008_gpio_read_pin_direction(unsigned short pin)
+{
+        int gpio = GPIO_BIT_MASK(pin);
+        int ret = -EFAULT;
+
+        gpio_lock();
+        if (GPIO_ISBID(pin) || GPIO_ISRAM(pin)) {
+                ret = gpio_read_bit(PIO_DRV_STATE, gpio);
+        }
+        gpio_unlock();
+        return ret;
+}
+
+EXPORT_SYMBOL(pnx4008_gpio_read_pin_direction);
+
+/* Value = 1 : Set pin to muxed function  */
+/* Value = 0 : Set pin as GPIO */
+int pnx4008_gpio_set_pin_mux(unsigned short pin, int output)
+{
+        int gpio = GPIO_BIT_MASK(pin);
+        int ret = -EFAULT;
+
+        gpio_lock();
+        if (GPIO_ISBID(pin)) {
+                ret =
+                    gpio_set_bit(output ? PIO_MUX_SET : PIO_MUX_CLR,
+                                 gpio_to_mux_map[gpio]);
+        } else if (GPIO_ISOUT(pin)) {
+                ret =
+                    gpio_set_bit(output ? PIO_MUX_SET : PIO_MUX_CLR,
+                                 outp_to_mux_map[gpio]);
+        } else if (GPIO_ISMUX(pin)) {
+                ret = gpio_set_bit(output ? PIO_MUX_SET : PIO_MUX_CLR, gpio);
+        }
+        gpio_unlock();
+        return ret;
+}
+
+EXPORT_SYMBOL(pnx4008_gpio_set_pin_mux);
+
+/* Read pin mux function: 0= pin used as GPIO, 1= pin used for muxed function*/
+int pnx4008_gpio_read_pin_mux(unsigned short pin)
+{
+        int gpio = GPIO_BIT_MASK(pin);
+        int ret = -EFAULT;
+
+        gpio_lock();
+        if (GPIO_ISBID(pin)) {
+                ret = gpio_read_bit(PIO_MUX_STATE, gpio_to_mux_map[gpio]);
+        } else if (GPIO_ISOUT(pin)) {
+                ret = gpio_read_bit(PIO_MUX_STATE, outp_to_mux_map[gpio]);
+        } else if (GPIO_ISMUX(pin)) {
+                ret = gpio_read_bit(PIO_MUX_STATE, gpio);
+        }
+        gpio_unlock();
+        return ret;
+}
+
+EXPORT_SYMBOL(pnx4008_gpio_read_pin_mux);
diff --git a/arch/arm/mach-pnx4008/irq.c b/arch/arm/mach-pnx4008/irq.c
new file mode 100644
index 000000000000..9b0a8e084e99
--- /dev/null
+++ b/arch/arm/mach-pnx4008/irq.c
@@ -0,0 +1,121 @@
+/*
+ * arch/arm/mach-pnx4008/irq.c
+ *
+ * PNX4008 IRQ controller driver
+ *
+ * Author: Dmitry Chigirev <source@mvista.com>
+ *
+ * Based on reference code received from Philips:
+ * Copyright (C) 2003 Philips Semiconductors
+ *
+ * 2005 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/mm.h>
+#include <linux/interrupt.h>
+#include <linux/list.h>
+#include <linux/init.h>
+#include <linux/ioport.h>
+#include <linux/device.h>
+#include <asm/hardware.h>
+#include <asm/irq.h>
+#include <asm/io.h>
+#include <asm/setup.h>
+#include <asm/mach-types.h>
+#include <asm/pgtable.h>
+#include <asm/page.h>
+#include <asm/system.h>
+#include <asm/mach/arch.h>
+#include <asm/mach/irq.h>
+#include <asm/mach/map.h>
+#include <asm/arch/irq.h>
+
+static u8 pnx4008_irq_type[NR_IRQS] = PNX4008_IRQ_TYPES;
+
+static void pnx4008_mask_irq(unsigned int irq)
+{
+        __raw_writel(__raw_readl(INTC_ER(irq)) & ~INTC_BIT(irq), INTC_ER(irq)); /* mask interrupt */
+}
+
+static void pnx4008_unmask_irq(unsigned int irq)
+{
+        __raw_writel(__raw_readl(INTC_ER(irq)) | INTC_BIT(irq), INTC_ER(irq));  /* unmask interrupt */
+}
+
+static void pnx4008_mask_ack_irq(unsigned int irq)
+{
+        __raw_writel(__raw_readl(INTC_ER(irq)) & ~INTC_BIT(irq), INTC_ER(irq)); /* mask interrupt */
+        __raw_writel(INTC_BIT(irq), INTC_SR(irq));      /* clear interrupt status */
+}
+
+static int pnx4008_set_irq_type(unsigned int irq, unsigned int type)
+{
+        switch (type) {
+        case IRQT_RISING:
+                __raw_writel(__raw_readl(INTC_ATR(irq)) | INTC_BIT(irq), INTC_ATR(irq));        /*edge sensitive */
+                __raw_writel(__raw_readl(INTC_APR(irq)) | INTC_BIT(irq), INTC_APR(irq));        /*rising edge */
+                set_irq_handler(irq, do_edge_IRQ);
+                break;
+        case IRQT_FALLING:
+                __raw_writel(__raw_readl(INTC_ATR(irq)) | INTC_BIT(irq), INTC_ATR(irq));        /*edge sensitive */
+                __raw_writel(__raw_readl(INTC_APR(irq)) & ~INTC_BIT(irq), INTC_APR(irq));       /*falling edge */
+                set_irq_handler(irq, do_edge_IRQ);
+                break;
+        case IRQT_LOW:
+                __raw_writel(__raw_readl(INTC_ATR(irq)) & ~INTC_BIT(irq), INTC_ATR(irq));       /*level sensitive */
+                __raw_writel(__raw_readl(INTC_APR(irq)) & ~INTC_BIT(irq), INTC_APR(irq));       /*low level */
+                set_irq_handler(irq, do_level_IRQ);
+                break;
+        case IRQT_HIGH:
+                __raw_writel(__raw_readl(INTC_ATR(irq)) & ~INTC_BIT(irq), INTC_ATR(irq));       /*level sensitive */
+                __raw_writel(__raw_readl(INTC_APR(irq)) | INTC_BIT(irq), INTC_APR(irq));        /* high level */
+                set_irq_handler(irq, do_level_IRQ);
+                break;
+
+        /* IRQT_BOTHEDGE is not supported */
+        default:
+                printk(KERN_ERR "PNX4008 IRQ: Unsupported irq type %d\n", type);
+                return -1;
+        }
+        return 0;
+}
+
+static struct irqchip pnx4008_irq_chip = {
+        .ack = pnx4008_mask_ack_irq,
+        .mask = pnx4008_mask_irq,
+        .unmask = pnx4008_unmask_irq,
+        .set_type = pnx4008_set_irq_type,
+};
+
+void __init pnx4008_init_irq(void)
+{
+        unsigned int i;
+
+        /* configure and enable IRQ 0,1,30,31 (cascade interrupts) mask all others */
+        pnx4008_set_irq_type(SUB1_IRQ_N, pnx4008_irq_type[SUB1_IRQ_N]);
+        pnx4008_set_irq_type(SUB2_IRQ_N, pnx4008_irq_type[SUB2_IRQ_N]);
+        pnx4008_set_irq_type(SUB1_FIQ_N, pnx4008_irq_type[SUB1_FIQ_N]);
+        pnx4008_set_irq_type(SUB2_FIQ_N, pnx4008_irq_type[SUB2_FIQ_N]);
+
+        __raw_writel((1 << SUB2_FIQ_N) | (1 << SUB1_FIQ_N) |
+                        (1 << SUB2_IRQ_N) | (1 << SUB1_IRQ_N),
+                INTC_ER(MAIN_BASE_INT));
+        __raw_writel(0, INTC_ER(SIC1_BASE_INT));
+        __raw_writel(0, INTC_ER(SIC2_BASE_INT));
+
+        /* configure all other IRQ's */
+        for (i = 0; i < NR_IRQS; i++) {
+                if (i == SUB2_FIQ_N || i == SUB1_FIQ_N ||
+                        i == SUB2_IRQ_N || i == SUB1_IRQ_N)
+                        continue;
+                set_irq_flags(i, IRQF_VALID);
+                set_irq_chip(i, &pnx4008_irq_chip);
+                pnx4008_set_irq_type(i, pnx4008_irq_type[i]);
+        }
+}
+
diff --git a/arch/arm/mach-pnx4008/pm.c b/arch/arm/mach-pnx4008/pm.c
new file mode 100644
index 000000000000..3649cd3dfc9a
--- /dev/null
+++ b/arch/arm/mach-pnx4008/pm.c
@@ -0,0 +1,184 @@
+/*
+ * arch/arm/mach-pnx4008/pm.c
+ *
+ * Power Management driver for PNX4008
+ *
+ * Authors: Vitaly Wool, Dmitry Chigirev <source@mvista.com>
+ *
+ * 2005 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+#include <linux/pm.h>
+#include <linux/rtc.h>
+#include <linux/sched.h>
+#include <linux/proc_fs.h>
+#include <linux/pm.h>
+#include <linux/delay.h>
+#include <linux/clk.h>
+
+#include <asm/io.h>
+#include <asm/mach-types.h>
+#include <asm/cacheflush.h>
+#include <asm/arch/pm.h>
+#include <asm/arch/clock.h>
+
+#define SRAM_VA IO_ADDRESS(PNX4008_IRAM_BASE)
+
+static void *saved_sram;
+
+static struct clk *pll4_clk;
+
+static inline void pnx4008_standby(void)
+{
+        void (*pnx4008_cpu_standby_ptr) (void);
+
+        local_irq_disable();
+        local_fiq_disable();
+
+        clk_disable(pll4_clk);
+
+        /*saving portion of SRAM to be used by suspend function. */
+        memcpy(saved_sram, (void *)SRAM_VA, pnx4008_cpu_standby_sz);
+
+        /*make sure SRAM copy gets physically written into SDRAM.
+           SDRAM will be placed into self-refresh during power down */
+        flush_cache_all();
+
+        /*copy suspend function into SRAM */
+        memcpy((void *)SRAM_VA, pnx4008_cpu_standby, pnx4008_cpu_standby_sz);
+
+        /*do suspend */
+        pnx4008_cpu_standby_ptr = (void *)SRAM_VA;
+        pnx4008_cpu_standby_ptr();
+
+        /*restoring portion of SRAM that was used by suspend function */
+        memcpy((void *)SRAM_VA, saved_sram, pnx4008_cpu_standby_sz);
+
+        clk_enable(pll4_clk);
+
+        local_fiq_enable();
+        local_irq_enable();
+}
+
+static inline void pnx4008_suspend(void)
+{
+        void (*pnx4008_cpu_suspend_ptr) (void);
+
+        local_irq_disable();
+        local_fiq_disable();
+
+        clk_disable(pll4_clk);
+
+        __raw_writel(0xffffffff, START_INT_RSR_REG(SE_PIN_BASE_INT));
+        __raw_writel(0xffffffff, START_INT_RSR_REG(SE_INT_BASE_INT));
+
+        /*saving portion of SRAM to be used by suspend function. */
+        memcpy(saved_sram, (void *)SRAM_VA, pnx4008_cpu_suspend_sz);
+
+        /*make sure SRAM copy gets physically written into SDRAM.
+           SDRAM will be placed into self-refresh during power down */
+        flush_cache_all();
+
+        /*copy suspend function into SRAM */
+        memcpy((void *)SRAM_VA, pnx4008_cpu_suspend, pnx4008_cpu_suspend_sz);
+
+        /*do suspend */
+        pnx4008_cpu_suspend_ptr = (void *)SRAM_VA;
+        pnx4008_cpu_suspend_ptr();
+
+        /*restoring portion of SRAM that was used by suspend function */
+        memcpy((void *)SRAM_VA, saved_sram, pnx4008_cpu_suspend_sz);
+
+        clk_enable(pll4_clk);
+
+        local_fiq_enable();
+        local_irq_enable();
+}
+
+static int pnx4008_pm_enter(suspend_state_t state)
+{
+        switch (state) {
+        case PM_SUSPEND_STANDBY:
+                pnx4008_standby();
+                break;
+        case PM_SUSPEND_MEM:
+                pnx4008_suspend();
+                break;
+        case PM_SUSPEND_DISK:
+                return -ENOTSUPP;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
+/*
+ * Called after processes are frozen, but before we shut down devices.
+ */
+static int pnx4008_pm_prepare(suspend_state_t state)
+{
+        switch (state) {
+        case PM_SUSPEND_STANDBY:
+        case PM_SUSPEND_MEM:
+                break;
+
+        case PM_SUSPEND_DISK:
+                return -ENOTSUPP;
+                break;
+
+        default:
+                return -EINVAL;
+                break;
+        }
+        return 0;
+}
+
+/*
+ * Called after devices are re-setup, but before processes are thawed.
+ */
+static int pnx4008_pm_finish(suspend_state_t state)
+{
+        return 0;
+}
+
+/*
+ * Set to PM_DISK_FIRMWARE so we can quickly veto suspend-to-disk.
+ */
+static struct pm_ops pnx4008_pm_ops = {
+        .prepare = pnx4008_pm_prepare,
+        .enter = pnx4008_pm_enter,
+        .finish = pnx4008_pm_finish,
+};
+
+static int __init pnx4008_pm_init(void)
+{
+        u32 sram_size_to_allocate;
+
+        pll4_clk = clk_get(0, "ck_pll4");
+        if (IS_ERR(pll4_clk)) {
+                printk(KERN_ERR
+                       "PM Suspend cannot acquire ARM(PLL4) clock control\n");
+                return PTR_ERR(pll4_clk);
+        }
+
+        if (pnx4008_cpu_standby_sz > pnx4008_cpu_suspend_sz)
+                sram_size_to_allocate = pnx4008_cpu_standby_sz;
+        else
+                sram_size_to_allocate = pnx4008_cpu_suspend_sz;
+
+        saved_sram = kmalloc(sram_size_to_allocate, GFP_ATOMIC);
+        if (!saved_sram) {
+                printk(KERN_ERR
+                       "PM Suspend: cannot allocate memory to save portion of SRAM\n");
+                clk_put(pll4_clk);
+                return -ENOMEM;
+        }
+
+        pm_set_ops(&pnx4008_pm_ops);
+        return 0;
+}
+
+late_initcall(pnx4008_pm_init);
diff --git a/arch/arm/mach-pnx4008/serial.c b/arch/arm/mach-pnx4008/serial.c
new file mode 100644
index 000000000000..2e1e04cc048c
--- /dev/null
+++ b/arch/arm/mach-pnx4008/serial.c
@@ -0,0 +1,69 @@
+/*
+ *  linux/arch/arm/mach-pnx4008/serial.c
+ *
+ *  PNX4008 UART initialization
+ *
+ *  Copyright:  MontaVista Software Inc. (c) 2005
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+
+#include <asm/io.h>
+
+#include <asm/arch/platform.h>
+#include <asm/arch/hardware.h>
+
+#include <linux/serial_core.h>
+#include <linux/serial_reg.h>
+#include <asm/arch/pm.h>
+
+#include <asm/arch/clock.h>
+
+#define UART_3          0
+#define UART_4          1
+#define UART_5          2
+#define UART_6          3
+#define UART_UNKNOWN    (-1)
+
+#define UART3_BASE_VA   IO_ADDRESS(PNX4008_UART3_BASE)
+#define UART4_BASE_VA   IO_ADDRESS(PNX4008_UART4_BASE)
+#define UART5_BASE_VA   IO_ADDRESS(PNX4008_UART5_BASE)
+#define UART6_BASE_VA   IO_ADDRESS(PNX4008_UART6_BASE)
+
+#define UART_FCR_OFFSET         8
+#define UART_FIFO_SIZE          64
+
+void pnx4008_uart_init(void)
+{
+        u32 tmp;
+        int i = UART_FIFO_SIZE;
+
+        __raw_writel(0xC1, UART5_BASE_VA + UART_FCR_OFFSET);
+        __raw_writel(0xC1, UART3_BASE_VA + UART_FCR_OFFSET);
+
+        /* Send a NULL to fix the UART HW bug */
+        __raw_writel(0x00, UART5_BASE_VA);
+        __raw_writel(0x00, UART3_BASE_VA);
+
+        while (i--) {
+                tmp = __raw_readl(UART5_BASE_VA);
+                tmp = __raw_readl(UART3_BASE_VA);
+        }
+        __raw_writel(0, UART5_BASE_VA + UART_FCR_OFFSET);
+        __raw_writel(0, UART3_BASE_VA + UART_FCR_OFFSET);
+
+        /* setup wakeup interrupt */
+        start_int_set_rising_edge(SE_U3_RX_INT);
+        start_int_ack(SE_U3_RX_INT);
+        start_int_umask(SE_U3_RX_INT);
+
+        start_int_set_rising_edge(SE_U5_RX_INT);
+        start_int_ack(SE_U5_RX_INT);
+        start_int_umask(SE_U5_RX_INT);
+}
+
diff --git a/arch/arm/mach-pnx4008/sleep.S b/arch/arm/mach-pnx4008/sleep.S
new file mode 100644
index 000000000000..93c802bac269
--- /dev/null
+++ b/arch/arm/mach-pnx4008/sleep.S
@@ -0,0 +1,196 @@
+/*
+ * linux/arch/arm/mach-pnx4008/sleep.S
+ *
+ * PNX4008 support for STOP mode and SDRAM self-refresh
+ *
+ * Authors: Dmitry Chigirev, Vitaly Wool <source@mvista.com>
+ *
+ * 2005 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+#include <linux/config.h>
+#include <linux/linkage.h>
+#include <asm/assembler.h>
+#include <asm/hardware.h>
+
+#define PWRMAN_VA_BASE IO_ADDRESS(PNX4008_PWRMAN_BASE)
+#define PWR_CTRL_REG_OFFS 0x44
+
+#define SDRAM_CFG_VA_BASE IO_ADDRESS(PNX4008_SDRAM_CFG_BASE)
+#define MPMC_STATUS_REG_OFFS 0x4
+
+                .text
+
+ENTRY(pnx4008_cpu_suspend)
+        @this function should be entered in Direct run mode.
+
+        @ save registers on stack
+        stmfd   sp!, {r0 - r6, lr}
+
+        @ setup Power Manager base address in r4
+        @ and put it's value in r5
+        mov     r4, #(PWRMAN_VA_BASE & 0xff000000)
+        orr     r4, r4, #(PWRMAN_VA_BASE & 0x00ff0000)
+        orr     r4, r4, #(PWRMAN_VA_BASE & 0x0000ff00)
+        orr     r4, r4, #(PWRMAN_VA_BASE & 0x000000ff)
+        ldr     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ setup SDRAM controller base address in r2
+        @ and put it's value in r3
+        mov     r2, #(SDRAM_CFG_VA_BASE & 0xff000000)
+        orr     r2, r2, #(SDRAM_CFG_VA_BASE & 0x00ff0000)
+        orr     r2, r2, #(SDRAM_CFG_VA_BASE & 0x0000ff00)
+        orr     r2, r2, #(SDRAM_CFG_VA_BASE & 0x000000ff)
+        ldr     r3, [r2, #MPMC_STATUS_REG_OFFS] @extra read - HW bug workaround
+
+        @ clear SDRAM self-refresh bit latch
+        and     r5, r5, #(~(1 << 8))
+        @ clear SDRAM self-refresh bit
+        and     r5, r5, #(~(1 << 9))
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ do save current bit settings in r1
+        mov     r1, r5
+
+        @ set SDRAM self-refresh bit
+        orr     r5, r5, #(1 << 9)
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ set SDRAM self-refresh bit latch
+        orr     r5, r5, #(1 << 8)
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ clear SDRAM self-refresh bit latch
+        and     r5, r5, #(~(1 << 8))
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ clear SDRAM self-refresh bit
+        and     r5, r5, #(~(1 << 9))
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ wait for SDRAM to get into self-refresh mode
+2:      ldr     r3, [r2, #MPMC_STATUS_REG_OFFS]
+        tst     r3, #(1 << 2)
+        beq     2b
+
+        @ to prepare SDRAM to get out of self-refresh mode after wakeup
+        orr     r5, r5, #(1 << 7)
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ do enter stop mode
+        orr     r5, r5, #(1 << 0)
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+        nop
+
+        @ sleeping now...
+
+        @ coming out of STOP mode into Direct Run mode
+        @ clear STOP mode and SDRAM self-refresh bits
+        str     r1, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ wait for SDRAM to get out self-refresh mode
+3:      ldr     r3, [r2, #MPMC_STATUS_REG_OFFS]
+        tst     r3, #5
+        bne     3b
+
+        @ restore regs and return
+        ldmfd   sp!, {r0 - r6, pc}
+
+ENTRY(pnx4008_cpu_suspend_sz)
+        .word   . - pnx4008_cpu_suspend
+
+ENTRY(pnx4008_cpu_standby)
+        @ save registers on stack
+        stmfd   sp!, {r0 - r6, lr}
+
+        @ setup Power Manager base address in r4
+        @ and put it's value in r5
+        mov     r4, #(PWRMAN_VA_BASE & 0xff000000)
+        orr     r4, r4, #(PWRMAN_VA_BASE & 0x00ff0000)
+        orr     r4, r4, #(PWRMAN_VA_BASE & 0x0000ff00)
+        orr     r4, r4, #(PWRMAN_VA_BASE & 0x000000ff)
+        ldr     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ setup SDRAM controller base address in r2
+        @ and put it's value in r3
+        mov     r2, #(SDRAM_CFG_VA_BASE & 0xff000000)
+        orr     r2, r2, #(SDRAM_CFG_VA_BASE & 0x00ff0000)
+        orr     r2, r2, #(SDRAM_CFG_VA_BASE & 0x0000ff00)
+        orr     r2, r2, #(SDRAM_CFG_VA_BASE & 0x000000ff)
+        ldr     r3, [r2, #MPMC_STATUS_REG_OFFS] @extra read - HW bug workaround
+
+        @ clear SDRAM self-refresh bit latch
+        and     r5, r5, #(~(1 << 8))
+        @ clear SDRAM self-refresh bit
+        and     r5, r5, #(~(1 << 9))
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ do save current bit settings in r1
+        mov     r1, r5
+
+        @ set SDRAM self-refresh bit
+        orr     r5, r5, #(1 << 9)
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ set SDRAM self-refresh bit latch
+        orr     r5, r5, #(1 << 8)
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ clear SDRAM self-refresh bit latch
+        and     r5, r5, #(~(1 << 8))
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ clear SDRAM self-refresh bit
+        and     r5, r5, #(~(1 << 9))
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ wait for SDRAM to get into self-refresh mode
+2:      ldr     r3, [r2, #MPMC_STATUS_REG_OFFS]
+        tst     r3, #(1 << 2)
+        beq     2b
+
+        @ set 'get out of self-refresh mode after wakeup' bit
+        orr     r5, r5, #(1 << 7)
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        mcr     p15, 0, r0, c7, c0, 4   @ kinda sleeping now...
+
+        @ set SDRAM self-refresh bit latch
+        orr     r5, r5, #(1 << 8)
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ clear SDRAM self-refresh bit latch
+        and     r5, r5, #(~(1 << 8))
+        str     r5, [r4, #PWR_CTRL_REG_OFFS]
+
+        @ wait for SDRAM to get out self-refresh mode
+3:      ldr     r3, [r2, #MPMC_STATUS_REG_OFFS]
+        tst     r3, #5
+        bne     3b
+
+        @ restore regs and return
+        ldmfd   sp!, {r0 - r6, pc}
+
+ENTRY(pnx4008_cpu_standby_sz)
+        .word   . - pnx4008_cpu_standby
+
+ENTRY(pnx4008_cache_clean_invalidate)
+        stmfd   sp!, {r0 - r6, lr}
+#ifdef CONFIG_CPU_DCACHE_WRITETHROUGH
+        mcr     p15, 0, ip, c7, c6, 0           @ invalidate D cache
+#else
+1:      mrc     p15, 0, r15, c7, c14, 3         @ test,clean,invalidate
+        bne     1b
+#endif
+        ldmfd   sp!, {r0 - r6, pc}
diff --git a/arch/arm/mach-pnx4008/time.c b/arch/arm/mach-pnx4008/time.c
new file mode 100644
index 000000000000..4ce680698529
--- /dev/null
+++ b/arch/arm/mach-pnx4008/time.c
@@ -0,0 +1,141 @@
+/*
+ * arch/arm/mach-pnx4008/time.c
+ *
+ * PNX4008 Timers
+ *
+ * Authors: Vitaly Wool, Dmitry Chigirev, Grigory Tolstolytkin <source@mvista.com>
+ *
+ * 2005 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+#include <linux/module.h>
+#include <linux/kallsyms.h>
+
+#include <asm/system.h>
+#include <asm/hardware.h>
+#include <asm/io.h>
+#include <asm/leds.h>
+#include <asm/irq.h>
+#include <asm/mach/irq.h>
+#include <asm/mach/time.h>
+
+#include <linux/time.h>
+#include <linux/timex.h>
+#include <asm/errno.h>
+
+/*! Note: all timers are UPCOUNTING */
+
+/*!
+ * Returns number of us since last clock interrupt.  Note that interrupts
+ * will have been disabled by do_gettimeoffset()
+ */
+static unsigned long pnx4008_gettimeoffset(void)
+{
+        u32 ticks_to_match =
+            __raw_readl(HSTIM_MATCH0) - __raw_readl(HSTIM_COUNTER);
+        u32 elapsed = LATCH - ticks_to_match;
+        return (elapsed * (tick_nsec / 1000)) / LATCH;
+}
+
+/*!
+ * IRQ handler for the timer
+ */
+static irqreturn_t pnx4008_timer_interrupt(int irq, void *dev_id,
+                                           struct pt_regs *regs)
+{
+        if (__raw_readl(HSTIM_INT) & MATCH0_INT) {
+
+                write_seqlock(&xtime_lock);
+
+                do {
+                        timer_tick(regs);
+
+                        /*
+                         * this algorithm takes care of possible delay
+                         * for this interrupt handling longer than a normal
+                         * timer period
+                         */
+                        __raw_writel(__raw_readl(HSTIM_MATCH0) + LATCH,
+                                     HSTIM_MATCH0);
+                        __raw_writel(MATCH0_INT, HSTIM_INT);    /* clear interrupt */
+
+                        /*
+                         * The goal is to keep incrementing HSTIM_MATCH0
+                         * register until HSTIM_MATCH0 indicates time after
+                         * what HSTIM_COUNTER indicates.
+                         */
+                } while ((signed)
+                         (__raw_readl(HSTIM_MATCH0) -
+                          __raw_readl(HSTIM_COUNTER)) < 0);
+
+                write_sequnlock(&xtime_lock);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static struct irqaction pnx4008_timer_irq = {
+        .name = "PNX4008 Tick Timer",
+        .flags = SA_INTERRUPT | SA_TIMER,
+        .handler = pnx4008_timer_interrupt
+};
+
+/*!
+ * Set up timer and timer interrupt.
+ */
+static __init void pnx4008_setup_timer(void)
+{
+        __raw_writel(RESET_COUNT, MSTIM_CTRL);
+        while (__raw_readl(MSTIM_COUNTER)) ;    /* wait for reset to complete. 100% guarantee event */
+        __raw_writel(0, MSTIM_CTRL);    /* stop the timer */
+        __raw_writel(0, MSTIM_MCTRL);
+
+        __raw_writel(RESET_COUNT, HSTIM_CTRL);
+        while (__raw_readl(HSTIM_COUNTER)) ;    /* wait for reset to complete. 100% guarantee event */
+        __raw_writel(0, HSTIM_CTRL);
+        __raw_writel(0, HSTIM_MCTRL);
+        __raw_writel(0, HSTIM_CCR);
+        __raw_writel(12, HSTIM_PMATCH); /* scale down to 1 MHZ */
+        __raw_writel(LATCH, HSTIM_MATCH0);
+        __raw_writel(MR0_INT, HSTIM_MCTRL);
+
+        setup_irq(HSTIMER_INT, &pnx4008_timer_irq);
+
+        __raw_writel(COUNT_ENAB | DEBUG_EN, HSTIM_CTRL);        /*start timer, stop when JTAG active */
+}
+
+/* Timer Clock Control in PM register */
+#define TIMCLK_CTRL_REG  IO_ADDRESS((PNX4008_PWRMAN_BASE + 0xBC))
+#define WATCHDOG_CLK_EN                   1
+#define TIMER_CLK_EN                      2     /* HS and MS timers? */
+
+static u32 timclk_ctrl_reg_save;
+
+void pnx4008_timer_suspend(void)
+{
+        timclk_ctrl_reg_save = __raw_readl(TIMCLK_CTRL_REG);
+        __raw_writel(0, TIMCLK_CTRL_REG);       /* disable timers */
+}
+
+void pnx4008_timer_resume(void)
+{
+        __raw_writel(timclk_ctrl_reg_save, TIMCLK_CTRL_REG);    /* enable timers */
+}
+
+struct sys_timer pnx4008_timer = {
+        .init = pnx4008_setup_timer,
+        .offset = pnx4008_gettimeoffset,
+        .suspend = pnx4008_timer_suspend,
+        .resume = pnx4008_timer_resume,
+};
+
diff --git a/arch/arm/mach-pxa/lubbock.c b/arch/arm/mach-pxa/lubbock.c
index 3e26d7ce5bb2..1ab26c6914f2 100644
--- a/arch/arm/mach-pxa/lubbock.c
+++ b/arch/arm/mach-pxa/lubbock.c
@@ -22,6 +22,10 @@
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/partitions.h>
 
+#include <linux/spi/spi.h>
+#include <linux/spi/ads7846.h>
+#include <asm/arch/pxa2xx_spi.h>
+
 #include <asm/setup.h>
 #include <asm/memory.h>
 #include <asm/mach-types.h>
@@ -196,6 +200,78 @@ static struct resource smc91x_resources[] = {
         },
 };
 
+/* ADS7846 is connected through SSP ... and if your board has J5 populated,
+ * you can select it to replace the ucb1400 by switching the touchscreen cable
+ * (to J5) and poking board registers (as done below).  Else it's only useful
+ * for the temperature sensors.
+ */
+static struct resource pxa_ssp_resources[] = {
+        [0] = {
+                .start  = __PREG(SSCR0_P(1)),
+                .end    = __PREG(SSCR0_P(1)) + 0x14,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = IRQ_SSP,
+                .end    = IRQ_SSP,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct pxa2xx_spi_master pxa_ssp_master_info = {
+        .ssp_type       = PXA25x_SSP,
+        .clock_enable   = CKEN3_SSP,
+        .num_chipselect = 0,
+};
+
+static struct platform_device pxa_ssp = {
+        .name           = "pxa2xx-spi",
+        .id             = 1,
+        .resource       = pxa_ssp_resources,
+        .num_resources  = ARRAY_SIZE(pxa_ssp_resources),
+        .dev = {
+                .platform_data  = &pxa_ssp_master_info,
+        },
+};
+
+static int lubbock_ads7846_pendown_state(void)
+{
+        /* TS_BUSY is bit 8 in LUB_MISC_RD, but pendown is irq-only */
+        return 0;
+}
+
+static struct ads7846_platform_data ads_info = {
+        .model                  = 7846,
+        .vref_delay_usecs       = 100,          /* internal, no cap */
+        .get_pendown_state      = lubbock_ads7846_pendown_state,
+        // .x_plate_ohms                = 500,  /* GUESS! */
+        // .y_plate_ohms                = 500,  /* GUESS! */
+};
+
+static void ads7846_cs(u32 command)
+{
+        static const unsigned   TS_nCS = 1 << 11;
+        lubbock_set_misc_wr(TS_nCS, (command == PXA2XX_CS_ASSERT) ? 0 : TS_nCS);
+}
+
+static struct pxa2xx_spi_chip ads_hw = {
+        .tx_threshold           = 1,
+        .rx_threshold           = 2,
+        .cs_control             = ads7846_cs,
+};
+
+static struct spi_board_info spi_board_info[] __initdata = { {
+        .modalias       = "ads7846",
+        .platform_data  = &ads_info,
+        .controller_data = &ads_hw,
+        .irq            = LUBBOCK_BB_IRQ,
+        .max_speed_hz   = 120000 /* max sample rate at 3V */
+                                * 26 /* command + data + overhead */,
+        .bus_num        = 1,
+        .chip_select    = 0,
+},
+};
+
 static struct platform_device smc91x_device = {
         .name           = "smc91x",
         .id             = -1,
@@ -272,6 +348,7 @@ static struct platform_device *devices[] __initdata = {
         &smc91x_device,
         &lubbock_flash_device[0],
         &lubbock_flash_device[1],
+        &pxa_ssp,
 };
 
 static struct pxafb_mach_info sharp_lm8v31 __initdata = {
@@ -400,6 +477,8 @@ static void __init lubbock_init(void)
         lubbock_flash_data[flashboot^1].name = "application-flash";
         lubbock_flash_data[flashboot].name = "boot-rom";
         (void) platform_add_devices(devices, ARRAY_SIZE(devices));
+
+        spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info));
 }
 
 static struct map_desc lubbock_io_desc[] __initdata = {
@@ -416,6 +495,11 @@ static void __init lubbock_map_io(void)
         pxa_map_io();
         iotable_init(lubbock_io_desc, ARRAY_SIZE(lubbock_io_desc));
 
+        /* SSP data pins */
+        pxa_gpio_mode(GPIO23_SCLK_MD);
+        pxa_gpio_mode(GPIO25_STXD_MD);
+        pxa_gpio_mode(GPIO26_SRXD_MD);
+
         /* This enables the BTUART */
         pxa_gpio_mode(GPIO42_BTRXD_MD);
         pxa_gpio_mode(GPIO43_BTTXD_MD);
diff --git a/arch/arm/mach-s3c2410/Kconfig b/arch/arm/mach-s3c2410/Kconfig
index 970f98dadffc..0c334136db7c 100644
--- a/arch/arm/mach-s3c2410/Kconfig
+++ b/arch/arm/mach-s3c2410/Kconfig
@@ -70,6 +70,18 @@ config ARCH_S3C2440
         help
           Say Y here if you are using the SMDK2440.
 
+config SMDK2440_CPU2440
+        bool "SMDK2440 with S3C2440 cpu module"
+        depends on ARCH_S3C2440
+        default y if ARCH_S3C2440
+        select CPU_S3C2440
+
+config SMDK2440_CPU2442
+        bool "SMDM2440 with S3C2442 cpu module"
+        depends on ARCH_S3C2440
+        select CPU_S3C2442
+
+
 config MACH_VR1000
         bool "Thorcom VR1000"
         select CPU_S3C2410
@@ -109,12 +121,26 @@ config CPU_S3C2410
           Support for S3C2410 and S3C2410A family from the S3C24XX line
           of Samsung Mobile CPUs.
 
+config CPU_S3C244X
+        bool
+        depends on ARCH_S3C2410 && (CPU_S3C2440 || CPU_S3C2442)
+        help
+          Support for S3C2440 and S3C2442 Samsung Mobile CPU based systems.
+
 config CPU_S3C2440
         bool
         depends on ARCH_S3C2410
+        select CPU_S3C244X
         help
           Support for S3C2440 Samsung Mobile CPU based systems.
 
+config CPU_S3C2442
+        bool
+        depends on ARCH_S3C2420
+        select CPU_S3C244X
+        help
+          Support for S3C2442 Samsung Mobile CPU based systems.
+
 comment "S3C2410 Boot"
 
 config S3C2410_BOOT_WATCHDOG
diff --git a/arch/arm/mach-s3c2410/Makefile b/arch/arm/mach-s3c2410/Makefile
index 3e5712db6b52..5e09355cd4f4 100644
--- a/arch/arm/mach-s3c2410/Makefile
+++ b/arch/arm/mach-s3c2410/Makefile
@@ -24,6 +24,11 @@ obj-$(CONFIG_S3C2410_DMA)  += dma.o
 obj-$(CONFIG_PM)           += pm.o sleep.o
 obj-$(CONFIG_PM_SIMTEC)    += pm-simtec.o
 
+# S3C244X support
+
+obj-$(CONFIG_CPU_S3C244X)  += s3c244x.o
+obj-$(CONFIG_CPU_S3C244X)  += s3c244x-irq.o
+
 # S3C2440 support
 
 obj-$(CONFIG_CPU_S3C2440)  += s3c2440.o s3c2440-dsc.o
@@ -31,6 +36,11 @@ obj-$(CONFIG_CPU_S3C2440)  += s3c2440-irq.o
 obj-$(CONFIG_CPU_S3C2440)  += s3c2440-clock.o
 obj-$(CONFIG_CPU_S3C2440)  += s3c2410-gpio.o
 
+# S3C2442 support
+
+obj-$(CONFIG_CPU_S3C2442)  += s3c2442.o
+obj-$(CONFIG_CPU_S3C2442)  += s3c2442-clock.o
+
 # bast extras
 
 obj-$(CONFIG_BAST_PC104_IRQ)    += bast-irq.o
diff --git a/arch/arm/mach-s3c2410/clock.c b/arch/arm/mach-s3c2410/clock.c
index 6de713ad319a..99d174612b53 100644
--- a/arch/arm/mach-s3c2410/clock.c
+++ b/arch/arm/mach-s3c2410/clock.c
@@ -70,7 +70,7 @@ void inline s3c24xx_clk_enable(unsigned int clocks, unsigned int enable)
                 clkcon &= ~clocks;
 
         /* ensure none of the special function bits set */
-        clkcon &= ~(S3C2410_CLKCON_IDLE|S3C2410_CLKCON_POWER);
+        clkcon &= ~(S3C2410_CLKCON_IDLE|S3C2410_CLKCON_POWER | 3);
 
         __raw_writel(clkcon, S3C2410_CLKCON);
 }
diff --git a/arch/arm/mach-s3c2410/common-smdk.c b/arch/arm/mach-s3c2410/common-smdk.c
index c940890f621f..a40eaa656177 100644
--- a/arch/arm/mach-s3c2410/common-smdk.c
+++ b/arch/arm/mach-s3c2410/common-smdk.c
@@ -34,6 +34,7 @@
 #include <asm/irq.h>
 
 #include <asm/arch/regs-gpio.h>
+#include <asm/arch/leds-gpio.h>
 
 #include <asm/arch/nand.h>
 
@@ -41,6 +42,66 @@
 #include "devs.h"
 #include "pm.h"
 
+/* LED devices */
+
+static struct s3c24xx_led_platdata smdk_pdata_led4 = {
+        .gpio           = S3C2410_GPF4,
+        .flags          = S3C24XX_LEDF_ACTLOW | S3C24XX_LEDF_TRISTATE,
+        .name           = "led4",
+        .def_trigger    = "timer",
+};
+
+static struct s3c24xx_led_platdata smdk_pdata_led5 = {
+        .gpio           = S3C2410_GPF5,
+        .flags          = S3C24XX_LEDF_ACTLOW | S3C24XX_LEDF_TRISTATE,
+        .name           = "led5",
+        .def_trigger    = "nand-disk",
+};
+
+static struct s3c24xx_led_platdata smdk_pdata_led6 = {
+        .gpio           = S3C2410_GPF6,
+        .flags          = S3C24XX_LEDF_ACTLOW | S3C24XX_LEDF_TRISTATE,
+        .name           = "led6",
+};
+
+static struct s3c24xx_led_platdata smdk_pdata_led7 = {
+        .gpio           = S3C2410_GPF7,
+        .flags          = S3C24XX_LEDF_ACTLOW | S3C24XX_LEDF_TRISTATE,
+        .name           = "led7",
+};
+
+static struct platform_device smdk_led4 = {
+        .name           = "s3c24xx_led",
+        .id             = 0,
+        .dev            = {
+                .platform_data = &smdk_pdata_led4,
+        },
+};
+
+static struct platform_device smdk_led5 = {
+        .name           = "s3c24xx_led",
+        .id             = 1,
+        .dev            = {
+                .platform_data = &smdk_pdata_led5,
+        },
+};
+
+static struct platform_device smdk_led6 = {
+        .name           = "s3c24xx_led",
+        .id             = 2,
+        .dev            = {
+                .platform_data = &smdk_pdata_led6,
+        },
+};
+
+static struct platform_device smdk_led7 = {
+        .name           = "s3c24xx_led",
+        .id             = 3,
+        .dev            = {
+                .platform_data = &smdk_pdata_led7,
+        },
+};
+
 /* NAND parititon from 2.4.18-swl5 */
 
 static struct mtd_partition smdk_default_nand_part[] = {
@@ -111,6 +172,10 @@ static struct s3c2410_platform_nand smdk_nand_info = {
 
 static struct platform_device __initdata *smdk_devs[] = {
         &s3c_device_nand,
+        &smdk_led4,
+        &smdk_led5,
+        &smdk_led6,
+        &smdk_led7,
 };
 
 void __init smdk_machine_init(void)
diff --git a/arch/arm/mach-s3c2410/cpu.c b/arch/arm/mach-s3c2410/cpu.c
index 70c34fcf7858..52842e6e86e6 100644
--- a/arch/arm/mach-s3c2410/cpu.c
+++ b/arch/arm/mach-s3c2410/cpu.c
@@ -37,12 +37,16 @@
 #include <asm/mach/map.h>
 
 #include <asm/arch/regs-gpio.h>
+#include <asm/arch/regs-serial.h>
 
 #include "cpu.h"
+#include "devs.h"
 #include "clock.h"
 #include "s3c2400.h"
 #include "s3c2410.h"
+#include "s3c244x.h"
 #include "s3c2440.h"
+#include "s3c2442.h"
 
 struct cpu_table {
         unsigned long   idcode;
@@ -59,6 +63,7 @@ struct cpu_table {
 static const char name_s3c2400[]  = "S3C2400";
 static const char name_s3c2410[]  = "S3C2410";
 static const char name_s3c2440[]  = "S3C2440";
+static const char name_s3c2442[]  = "S3C2442";
 static const char name_s3c2410a[] = "S3C2410A";
 static const char name_s3c2440a[] = "S3C2440A";
 
@@ -84,22 +89,31 @@ static struct cpu_table cpu_ids[] __initdata = {
         {
                 .idcode         = 0x32440000,
                 .idmask         = 0xffffffff,
-                .map_io         = s3c2440_map_io,
-                .init_clocks    = s3c2440_init_clocks,
-                .init_uarts     = s3c2440_init_uarts,
+                .map_io         = s3c244x_map_io,
+                .init_clocks    = s3c244x_init_clocks,
+                .init_uarts     = s3c244x_init_uarts,
                 .init           = s3c2440_init,
                 .name           = name_s3c2440
         },
         {
                 .idcode         = 0x32440001,
                 .idmask         = 0xffffffff,
-                .map_io         = s3c2440_map_io,
-                .init_clocks    = s3c2440_init_clocks,
-                .init_uarts     = s3c2440_init_uarts,
+                .map_io         = s3c244x_map_io,
+                .init_clocks    = s3c244x_init_clocks,
+                .init_uarts     = s3c244x_init_uarts,
                 .init           = s3c2440_init,
                 .name           = name_s3c2440a
         },
         {
+                .idcode         = 0x32440aaa,
+                .idmask         = 0xffffffff,
+                .map_io         = s3c244x_map_io,
+                .init_clocks    = s3c244x_init_clocks,
+                .init_uarts     = s3c244x_init_uarts,
+                .init           = s3c2442_init,
+                .name           = name_s3c2442
+        },
+        {
                 .idcode         = 0x0,   /* S3C2400 doesn't have an idcode */
                 .idmask         = 0xffffffff,
                 .map_io         = s3c2400_map_io,
@@ -175,13 +189,13 @@ void __init s3c24xx_init_io(struct map_desc *mach_desc, int size)
                 panic("Unknown S3C24XX CPU");
         }
 
+        printk("CPU %s (id 0x%08lx)\n", cpu->name, idcode);
+
         if (cpu->map_io == NULL || cpu->init == NULL) {
                 printk(KERN_ERR "CPU %s support not enabled\n", cpu->name);
                 panic("Unsupported S3C24XX CPU");
         }
 
-        printk("CPU %s (id 0x%08lx)\n", cpu->name, idcode);
-
         (cpu->map_io)(mach_desc, size);
 }
 
@@ -208,6 +222,49 @@ void __init s3c24xx_init_clocks(int xtal)
                 (cpu->init_clocks)(xtal);
 }
 
+/* uart management */
+
+static int nr_uarts __initdata = 0;
+
+static struct s3c2410_uartcfg uart_cfgs[3];
+
+/* s3c24xx_init_uartdevs
+ *
+ * copy the specified platform data and configuration into our central
+ * set of devices, before the data is thrown away after the init process.
+ *
+ * This also fills in the array passed to the serial driver for the
+ * early initialisation of the console.
+*/
+
+void __init s3c24xx_init_uartdevs(char *name,
+                                  struct s3c24xx_uart_resources *res,
+                                  struct s3c2410_uartcfg *cfg, int no)
+{
+        struct platform_device *platdev;
+        struct s3c2410_uartcfg *cfgptr = uart_cfgs;
+        struct s3c24xx_uart_resources *resp;
+        int uart;
+
+        memcpy(cfgptr, cfg, sizeof(struct s3c2410_uartcfg) * no);
+
+        for (uart = 0; uart < no; uart++, cfg++, cfgptr++) {
+                platdev = s3c24xx_uart_src[cfgptr->hwport];
+
+                resp = res + cfgptr->hwport;
+
+                s3c24xx_uart_devs[uart] = platdev;
+
+                platdev->name = name;
+                platdev->resource = resp->resources;
+                platdev->num_resources = resp->nr_resources;
+
+                platdev->dev.platform_data = cfgptr;
+        }
+
+        nr_uarts = no;
+}
+
 void __init s3c24xx_init_uarts(struct s3c2410_uartcfg *cfg, int no)
 {
         if (cpu == NULL)
@@ -232,6 +289,10 @@ static int __init s3c_arch_init(void)
         if (ret != 0)
                 return ret;
 
+        ret = platform_add_devices(s3c24xx_uart_devs, nr_uarts);
+        if (ret != 0)
+                return ret;
+
         if (board != NULL) {
                 struct platform_device **ptr = board->devices;
                 int i;
diff --git a/arch/arm/mach-s3c2410/cpu.h b/arch/arm/mach-s3c2410/cpu.h
index fc1067783f6d..40862899b2f1 100644
--- a/arch/arm/mach-s3c2410/cpu.h
+++ b/arch/arm/mach-s3c2410/cpu.h
@@ -31,6 +31,8 @@
 #define print_mhz(m) ((m) / MHZ), ((m / 1000) % 1000)
 
 /* forward declaration */
+struct s3c24xx_uart_resources;
+struct platform_device;
 struct s3c2410_uartcfg;
 struct map_desc;
 
@@ -44,6 +46,10 @@ extern void s3c24xx_init_uarts(struct s3c2410_uartcfg *cfg, int no);
 
 extern void s3c24xx_init_clocks(int xtal);
 
+extern void s3c24xx_init_uartdevs(char *name,
+                                  struct s3c24xx_uart_resources *res,
+                                  struct s3c2410_uartcfg *cfg, int no);
+
 /* the board structure is used at first initialsation time
  * to get info such as the devices to register for this
  * board. This is done because platfrom_add_devices() cannot
@@ -68,3 +74,4 @@ extern struct sys_timer s3c24xx_timer;
 /* system device classes */
 
 extern struct sysdev_class s3c2440_sysclass;
+extern struct sysdev_class s3c2442_sysclass;
diff --git a/arch/arm/mach-s3c2410/devs.c b/arch/arm/mach-s3c2410/devs.c
index ca09ba516e4c..ad3845e329ba 100644
--- a/arch/arm/mach-s3c2410/devs.c
+++ b/arch/arm/mach-s3c2410/devs.c
@@ -38,10 +38,86 @@
 #include <asm/arch/regs-serial.h>
 
 #include "devs.h"
+#include "cpu.h"
 
 /* Serial port registrations */
 
-struct platform_device *s3c24xx_uart_devs[3];
+static struct resource s3c2410_uart0_resource[] = {
+        [0] = {
+                .start = S3C2410_PA_UART0,
+                .end   = S3C2410_PA_UART0 + 0x3fff,
+                .flags = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start = IRQ_S3CUART_RX0,
+                .end   = IRQ_S3CUART_ERR0,
+                .flags = IORESOURCE_IRQ,
+        }
+};
+
+static struct resource s3c2410_uart1_resource[] = {
+        [0] = {
+                .start = S3C2410_PA_UART1,
+                .end   = S3C2410_PA_UART1 + 0x3fff,
+                .flags = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start = IRQ_S3CUART_RX1,
+                .end   = IRQ_S3CUART_ERR1,
+                .flags = IORESOURCE_IRQ,
+        }
+};
+
+static struct resource s3c2410_uart2_resource[] = {
+        [0] = {
+                .start = S3C2410_PA_UART2,
+                .end   = S3C2410_PA_UART2 + 0x3fff,
+                .flags = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start = IRQ_S3CUART_RX2,
+                .end   = IRQ_S3CUART_ERR2,
+                .flags = IORESOURCE_IRQ,
+        }
+};
+
+struct s3c24xx_uart_resources s3c2410_uart_resources[] __initdata = {
+        [0] = {
+                .resources      = s3c2410_uart0_resource,
+                .nr_resources   = ARRAY_SIZE(s3c2410_uart0_resource),
+        },
+        [1] = {
+                .resources      = s3c2410_uart1_resource,
+                .nr_resources   = ARRAY_SIZE(s3c2410_uart1_resource),
+        },
+        [2] = {
+                .resources      = s3c2410_uart2_resource,
+                .nr_resources   = ARRAY_SIZE(s3c2410_uart2_resource),
+        },
+};
+
+/* yart devices */
+
+static struct platform_device s3c24xx_uart_device0 = {
+        .id             = 0,
+};
+
+static struct platform_device s3c24xx_uart_device1 = {
+        .id             = 1,
+};
+
+static struct platform_device s3c24xx_uart_device2 = {
+        .id             = 2,
+};
+
+struct platform_device *s3c24xx_uart_src[3] = {
+        &s3c24xx_uart_device0,
+        &s3c24xx_uart_device1,
+        &s3c24xx_uart_device2,
+};
+
+struct platform_device *s3c24xx_uart_devs[3] = {
+};
 
 /* USB Host Controller */
 
diff --git a/arch/arm/mach-s3c2410/devs.h b/arch/arm/mach-s3c2410/devs.h
index 52c4bab5c761..fa124ed920e0 100644
--- a/arch/arm/mach-s3c2410/devs.h
+++ b/arch/arm/mach-s3c2410/devs.h
@@ -17,7 +17,15 @@
 #include <linux/config.h>
 #include <linux/platform_device.h>
 
+struct s3c24xx_uart_resources {
+        struct resource         *resources;
+        unsigned long            nr_resources;
+};
+
+extern struct s3c24xx_uart_resources s3c2410_uart_resources[];
+
 extern struct platform_device *s3c24xx_uart_devs[];
+extern struct platform_device *s3c24xx_uart_src[];
 
 extern struct platform_device s3c_device_usb;
 extern struct platform_device s3c_device_lcd;
diff --git a/arch/arm/mach-s3c2410/mach-anubis.c b/arch/arm/mach-s3c2410/mach-anubis.c
index cc97fbf66291..52bf718137d4 100644
--- a/arch/arm/mach-s3c2410/mach-anubis.c
+++ b/arch/arm/mach-s3c2410/mach-anubis.c
@@ -131,7 +131,7 @@ static struct s3c24xx_uart_clksrc anubis_serial_clocks[] = {
 };
 
 
-static struct s3c2410_uartcfg anubis_uartcfgs[] = {
+static struct s3c2410_uartcfg anubis_uartcfgs[] __initdata = {
         [0] = {
                 .hwport      = 0,
                 .flags       = 0,
diff --git a/arch/arm/mach-s3c2410/mach-bast.c b/arch/arm/mach-s3c2410/mach-bast.c
index 995bb8add331..947234df8160 100644
--- a/arch/arm/mach-s3c2410/mach-bast.c
+++ b/arch/arm/mach-s3c2410/mach-bast.c
@@ -208,7 +208,7 @@ static struct s3c24xx_uart_clksrc bast_serial_clocks[] = {
 };
 
 
-static struct s3c2410_uartcfg bast_uartcfgs[] = {
+static struct s3c2410_uartcfg bast_uartcfgs[] __initdata = {
         [0] = {
                 .hwport      = 0,
                 .flags       = 0,
diff --git a/arch/arm/mach-s3c2410/mach-h1940.c b/arch/arm/mach-s3c2410/mach-h1940.c
index 646a3a5d33a5..aec431b2830a 100644
--- a/arch/arm/mach-s3c2410/mach-h1940.c
+++ b/arch/arm/mach-s3c2410/mach-h1940.c
@@ -72,7 +72,7 @@ static struct map_desc h1940_iodesc[] __initdata = {
 #define ULCON S3C2410_LCON_CS8 | S3C2410_LCON_PNONE | S3C2410_LCON_STOPB
 #define UFCON S3C2410_UFCON_RXTRIG8 | S3C2410_UFCON_FIFOMODE
 
-static struct s3c2410_uartcfg h1940_uartcfgs[] = {
+static struct s3c2410_uartcfg h1940_uartcfgs[] __initdata = {
         [0] = {
                 .hwport      = 0,
                 .flags       = 0,
diff --git a/arch/arm/mach-s3c2410/mach-nexcoder.c b/arch/arm/mach-s3c2410/mach-nexcoder.c
index 07d09509a626..065a1d4e860b 100644
--- a/arch/arm/mach-s3c2410/mach-nexcoder.c
+++ b/arch/arm/mach-s3c2410/mach-nexcoder.c
@@ -51,7 +51,7 @@ static struct map_desc nexcoder_iodesc[] __initdata = {
 #define ULCON S3C2410_LCON_CS8 | S3C2410_LCON_PNONE | S3C2410_LCON_STOPB
 #define UFCON S3C2410_UFCON_RXTRIG12 | S3C2410_UFCON_FIFOMODE
 
-static struct s3c2410_uartcfg nexcoder_uartcfgs[] = {
+static struct s3c2410_uartcfg nexcoder_uartcfgs[] __initdata = {
         [0] = {
                 .hwport      = 0,
                 .flags       = 0,
diff --git a/arch/arm/mach-s3c2410/mach-osiris.c b/arch/arm/mach-s3c2410/mach-osiris.c
index ae0787557751..858fd03c6bc5 100644
--- a/arch/arm/mach-s3c2410/mach-osiris.c
+++ b/arch/arm/mach-s3c2410/mach-osiris.c
@@ -95,8 +95,7 @@ static struct s3c24xx_uart_clksrc osiris_serial_clocks[] = {
         }
 };
 
-
-static struct s3c2410_uartcfg osiris_uartcfgs[] = {
+static struct s3c2410_uartcfg osiris_uartcfgs[] __initdata = {
         [0] = {
                 .hwport      = 0,
                 .flags       = 0,
@@ -107,7 +106,7 @@ static struct s3c2410_uartcfg osiris_uartcfgs[] = {
                 .clocks_size = ARRAY_SIZE(osiris_serial_clocks)
         },
         [1] = {
-                .hwport      = 2,
+                .hwport      = 1,
                 .flags       = 0,
                 .ucon        = UCON,
                 .ulcon       = ULCON,
diff --git a/arch/arm/mach-s3c2410/mach-otom.c b/arch/arm/mach-s3c2410/mach-otom.c
index b39daedf93ca..c71673fd9955 100644
--- a/arch/arm/mach-s3c2410/mach-otom.c
+++ b/arch/arm/mach-s3c2410/mach-otom.c
@@ -45,7 +45,7 @@ static struct map_desc otom11_iodesc[] __initdata = {
 #define ULCON S3C2410_LCON_CS8 | S3C2410_LCON_PNONE | S3C2410_LCON_STOPB
 #define UFCON S3C2410_UFCON_RXTRIG12 | S3C2410_UFCON_FIFOMODE
 
-static struct s3c2410_uartcfg otom11_uartcfgs[] = {
+static struct s3c2410_uartcfg otom11_uartcfgs[] __initdata = {
         [0] = {
                 .hwport      = 0,
                 .flags       = 0,
diff --git a/arch/arm/mach-s3c2410/mach-smdk2410.c b/arch/arm/mach-s3c2410/mach-smdk2410.c
index 2db932d72c5a..25f7e9f4dcee 100644
--- a/arch/arm/mach-s3c2410/mach-smdk2410.c
+++ b/arch/arm/mach-s3c2410/mach-smdk2410.c
@@ -65,7 +65,7 @@ static struct map_desc smdk2410_iodesc[] __initdata = {
 #define ULCON S3C2410_LCON_CS8 | S3C2410_LCON_PNONE | S3C2410_LCON_STOPB
 #define UFCON S3C2410_UFCON_RXTRIG8 | S3C2410_UFCON_FIFOMODE
 
-static struct s3c2410_uartcfg smdk2410_uartcfgs[] = {
+static struct s3c2410_uartcfg smdk2410_uartcfgs[] __initdata = {
         [0] = {
                 .hwport      = 0,
                 .flags       = 0,
diff --git a/arch/arm/mach-s3c2410/mach-smdk2440.c b/arch/arm/mach-s3c2410/mach-smdk2440.c
index 5fffd1d51047..d661c6b7ff56 100644
--- a/arch/arm/mach-s3c2410/mach-smdk2440.c
+++ b/arch/arm/mach-s3c2410/mach-smdk2440.c
@@ -86,7 +86,7 @@ static struct map_desc smdk2440_iodesc[] __initdata = {
 #define ULCON S3C2410_LCON_CS8 | S3C2410_LCON_PNONE | S3C2410_LCON_STOPB
 #define UFCON S3C2410_UFCON_RXTRIG8 | S3C2410_UFCON_FIFOMODE
 
-static struct s3c2410_uartcfg smdk2440_uartcfgs[] = {
+static struct s3c2410_uartcfg smdk2440_uartcfgs[] __initdata = {
         [0] = {
                 .hwport      = 0,
                 .flags       = 0,
diff --git a/arch/arm/mach-s3c2410/mach-vr1000.c b/arch/arm/mach-s3c2410/mach-vr1000.c
index 785fc9cdcf7c..d18efb279d3d 100644
--- a/arch/arm/mach-s3c2410/mach-vr1000.c
+++ b/arch/arm/mach-s3c2410/mach-vr1000.c
@@ -166,7 +166,7 @@ static struct s3c24xx_uart_clksrc vr1000_serial_clocks[] = {
         }
 };
 
-static struct s3c2410_uartcfg vr1000_uartcfgs[] = {
+static struct s3c2410_uartcfg vr1000_uartcfgs[] __initdata = {
         [0] = {
                 .hwport      = 0,
                 .flags       = 0,
diff --git a/arch/arm/mach-s3c2410/pm.c b/arch/arm/mach-s3c2410/pm.c
index fe57d966a34d..43e9a550a203 100644
--- a/arch/arm/mach-s3c2410/pm.c
+++ b/arch/arm/mach-s3c2410/pm.c
@@ -58,7 +58,11 @@ unsigned long s3c_pm_flags;
 
 /* cache functions from arch/arm/mm/proc-arm920.S */
 
+#ifndef CONFIG_CPU_DCACHE_WRITETHROUGH
 extern void arm920_flush_kern_cache_all(void);
+#else
+static void arm920_flush_kern_cache_all(void) { }
+#endif
 
 #define PFX "s3c24xx-pm: "
 
diff --git a/arch/arm/mach-s3c2410/s3c2410.c b/arch/arm/mach-s3c2410/s3c2410.c
index 0a2013a76549..0852e87a79c4 100644
--- a/arch/arm/mach-s3c2410/s3c2410.c
+++ b/arch/arm/mach-s3c2410/s3c2410.c
@@ -42,6 +42,7 @@
 
 #include "s3c2410.h"
 #include "cpu.h"
+#include "devs.h"
 #include "clock.h"
 
 /* Initial IO mappings */
@@ -55,93 +56,13 @@ static struct map_desc s3c2410_iodesc[] __initdata = {
         IODESC_ENT(WATCHDOG),
 };
 
-static struct resource s3c_uart0_resource[] = {
-        [0] = {
-                .start = S3C2410_PA_UART0,
-                .end   = S3C2410_PA_UART0 + 0x3fff,
-                .flags = IORESOURCE_MEM,
-        },
-        [1] = {
-                .start = IRQ_S3CUART_RX0,
-                .end   = IRQ_S3CUART_ERR0,
-                .flags = IORESOURCE_IRQ,
-        }
-
-};
-
-static struct resource s3c_uart1_resource[] = {
-        [0] = {
-                .start = S3C2410_PA_UART1,
-                .end   = S3C2410_PA_UART1 + 0x3fff,
-                .flags = IORESOURCE_MEM,
-        },
-        [1] = {
-                .start = IRQ_S3CUART_RX1,
-                .end   = IRQ_S3CUART_ERR1,
-                .flags = IORESOURCE_IRQ,
-        }
-};
-
-static struct resource s3c_uart2_resource[] = {
-        [0] = {
-                .start = S3C2410_PA_UART2,
-                .end   = S3C2410_PA_UART2 + 0x3fff,
-                .flags = IORESOURCE_MEM,
-        },
-        [1] = {
-                .start = IRQ_S3CUART_RX2,
-                .end   = IRQ_S3CUART_ERR2,
-                .flags = IORESOURCE_IRQ,
-        }
-};
-
 /* our uart devices */
 
-static struct platform_device s3c_uart0 = {
-        .name             = "s3c2410-uart",
-        .id               = 0,
-        .num_resources    = ARRAY_SIZE(s3c_uart0_resource),
-        .resource         = s3c_uart0_resource,
-};
-
-
-static struct platform_device s3c_uart1 = {
-        .name             = "s3c2410-uart",
-        .id               = 1,
-        .num_resources    = ARRAY_SIZE(s3c_uart1_resource),
-        .resource         = s3c_uart1_resource,
-};
-
-static struct platform_device s3c_uart2 = {
-        .name             = "s3c2410-uart",
-        .id               = 2,
-        .num_resources    = ARRAY_SIZE(s3c_uart2_resource),
-        .resource         = s3c_uart2_resource,
-};
-
-static struct platform_device *uart_devices[] __initdata = {
-        &s3c_uart0,
-        &s3c_uart1,
-        &s3c_uart2
-};
-
-static int s3c2410_uart_count = 0;
-
 /* uart registration process */
 
 void __init s3c2410_init_uarts(struct s3c2410_uartcfg *cfg, int no)
 {
-        struct platform_device *platdev;
-        int uart;
-
-        for (uart = 0; uart < no; uart++, cfg++) {
-                platdev = uart_devices[cfg->hwport];
-
-                s3c24xx_uart_devs[uart] = platdev;
-                platdev->dev.platform_data = cfg;
-        }
-
-        s3c2410_uart_count = uart;
+        s3c24xx_init_uartdevs("s3c2410-uart", s3c2410_uart_resources, cfg, no);
 }
 
 /* s3c2410_map_io
@@ -193,5 +114,5 @@ int __init s3c2410_init(void)
 {
         printk("S3C2410: Initialising architecture\n");
 
-        return platform_add_devices(s3c24xx_uart_devs, s3c2410_uart_count);
+        return 0;
 }
diff --git a/arch/arm/mach-s3c2410/s3c2440-irq.c b/arch/arm/mach-s3c2410/s3c2440-irq.c
index 278d0044c85d..acfe3870727b 100644
--- a/arch/arm/mach-s3c2410/s3c2440-irq.c
+++ b/arch/arm/mach-s3c2410/s3c2440-irq.c
@@ -100,73 +100,12 @@ static struct irqchip s3c_irq_wdtac97 = {
         .ack        = s3c_irq_wdtac97_ack,
 };
 
-/* camera irq */
-
-static void s3c_irq_demux_cam(unsigned int irq,
-                              struct irqdesc *desc,
-                              struct pt_regs *regs)
-{
-        unsigned int subsrc, submsk;
-        struct irqdesc *mydesc;
-
-        /* read the current pending interrupts, and the mask
-         * for what it is available */
-
-        subsrc = __raw_readl(S3C2410_SUBSRCPND);
-        submsk = __raw_readl(S3C2410_INTSUBMSK);
-
-        subsrc &= ~submsk;
-        subsrc >>= 11;
-        subsrc &= 3;
-
-        if (subsrc != 0) {
-                if (subsrc & 1) {
-                        mydesc = irq_desc + IRQ_S3C2440_CAM_C;
-                        desc_handle_irq(IRQ_S3C2440_CAM_C, mydesc, regs);
-                }
-                if (subsrc & 2) {
-                        mydesc = irq_desc + IRQ_S3C2440_CAM_P;
-                        desc_handle_irq(IRQ_S3C2440_CAM_P, mydesc, regs);
-                }
-        }
-}
-
-#define INTMSK_CAM (1UL << (IRQ_CAM - IRQ_EINT0))
-
-static void
-s3c_irq_cam_mask(unsigned int irqno)
-{
-        s3c_irqsub_mask(irqno, INTMSK_CAM, 3<<11);
-}
-
-static void
-s3c_irq_cam_unmask(unsigned int irqno)
-{
-        s3c_irqsub_unmask(irqno, INTMSK_CAM);
-}
-
-static void
-s3c_irq_cam_ack(unsigned int irqno)
-{
-        s3c_irqsub_maskack(irqno, INTMSK_CAM, 3<<11);
-}
-
-static struct irqchip s3c_irq_cam = {
-        .mask       = s3c_irq_cam_mask,
-        .unmask     = s3c_irq_cam_unmask,
-        .ack        = s3c_irq_cam_ack,
-};
-
 static int s3c2440_irq_add(struct sys_device *sysdev)
 {
         unsigned int irqno;
 
         printk("S3C2440: IRQ Support\n");
 
-        set_irq_chip(IRQ_NFCON, &s3c_irq_level_chip);
-        set_irq_handler(IRQ_NFCON, do_level_IRQ);
-        set_irq_flags(IRQ_NFCON, IRQF_VALID);
-
         /* add new chained handler for wdt, ac7 */
 
         set_irq_chip(IRQ_WDT, &s3c_irq_level_chip);
@@ -179,18 +118,6 @@ static int s3c2440_irq_add(struct sys_device *sysdev)
                 set_irq_flags(irqno, IRQF_VALID);
         }
 
-        /* add chained handler for camera */
-
-        set_irq_chip(IRQ_CAM, &s3c_irq_level_chip);
-        set_irq_handler(IRQ_CAM, do_level_IRQ);
-        set_irq_chained_handler(IRQ_CAM, s3c_irq_demux_cam);
-
-        for (irqno = IRQ_S3C2440_CAM_C; irqno <= IRQ_S3C2440_CAM_P; irqno++) {
-                set_irq_chip(irqno, &s3c_irq_cam);
-                set_irq_handler(irqno, do_level_IRQ);
-                set_irq_flags(irqno, IRQF_VALID);
-        }
-
         return 0;
 }
 
@@ -198,10 +125,10 @@ static struct sysdev_driver s3c2440_irq_driver = {
         .add    = s3c2440_irq_add,
 };
 
-static int s3c24xx_irq_driver(void)
+static int s3c2440_irq_init(void)
 {
         return sysdev_driver_register(&s3c2440_sysclass, &s3c2440_irq_driver);
 }
 
-arch_initcall(s3c24xx_irq_driver);
+arch_initcall(s3c2440_irq_init);
 
diff --git a/arch/arm/mach-s3c2410/s3c2440.c b/arch/arm/mach-s3c2410/s3c2440.c
index b7fe6d9453fb..0ab50f44f318 100644
--- a/arch/arm/mach-s3c2410/s3c2440.c
+++ b/arch/arm/mach-s3c2410/s3c2440.c
@@ -1,6 +1,6 @@
 /* linux/arch/arm/mach-s3c2410/s3c2440.c
  *
- * Copyright (c) 2004-2005 Simtec Electronics
+ * Copyright (c) 2004-2006 Simtec Electronics
  *   Ben Dooks <ben@simtec.co.uk>
  *
  * Samsung S3C2440 Mobile CPU support
@@ -8,16 +8,6 @@
  * 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.
- *
- * Modifications:
- *      24-Aug-2004 BJD  Start of s3c2440 support
- *      12-Oct-2004 BJD  Moved clock info out to clock.c
- *      01-Nov-2004 BJD  Fixed clock build code
- *      09-Nov-2004 BJD  Added sysdev for power management
- *      04-Nov-2004 BJD  New serial registration
- *      15-Nov-2004 BJD  Rename the i2c device for the s3c2440
- *      14-Jan-2005 BJD  Moved clock init code into seperate function
- *      14-Jan-2005 BJD  Removed un-used clock bits
 */
 
 #include <linux/kernel.h>
@@ -50,234 +40,20 @@
 #include "cpu.h"
 #include "pm.h"
 
-
-static struct map_desc s3c2440_iodesc[] __initdata = {
-        IODESC_ENT(USBHOST),
-        IODESC_ENT(CLKPWR),
-        IODESC_ENT(LCD),
-        IODESC_ENT(TIMER),
-        IODESC_ENT(ADC),
-        IODESC_ENT(WATCHDOG),
-};
-
-static struct resource s3c_uart0_resource[] = {
-        [0] = {
-                .start = S3C2410_PA_UART0,
-                .end   = S3C2410_PA_UART0 + 0x3fff,
-                .flags = IORESOURCE_MEM,
-        },
-        [1] = {
-                .start = IRQ_S3CUART_RX0,
-                .end   = IRQ_S3CUART_ERR0,
-                .flags = IORESOURCE_IRQ,
-        }
-
-};
-
-static struct resource s3c_uart1_resource[] = {
-        [0] = {
-                .start = S3C2410_PA_UART1,
-                .end   = S3C2410_PA_UART1 + 0x3fff,
-                .flags = IORESOURCE_MEM,
-        },
-        [1] = {
-                .start = IRQ_S3CUART_RX1,
-                .end   = IRQ_S3CUART_ERR1,
-                .flags = IORESOURCE_IRQ,
-        }
-};
-
-static struct resource s3c_uart2_resource[] = {
-        [0] = {
-                .start = S3C2410_PA_UART2,
-                .end   = S3C2410_PA_UART2 + 0x3fff,
-                .flags = IORESOURCE_MEM,
-        },
-        [1] = {
-                .start = IRQ_S3CUART_RX2,
-                .end   = IRQ_S3CUART_ERR2,
-                .flags = IORESOURCE_IRQ,
-        }
-};
-
-/* our uart devices */
-
-static struct platform_device s3c_uart0 = {
-        .name             = "s3c2440-uart",
-        .id               = 0,
-        .num_resources    = ARRAY_SIZE(s3c_uart0_resource),
-        .resource         = s3c_uart0_resource,
-};
-
-static struct platform_device s3c_uart1 = {
-        .name             = "s3c2440-uart",
-        .id               = 1,
-        .num_resources    = ARRAY_SIZE(s3c_uart1_resource),
-        .resource         = s3c_uart1_resource,
-};
-
-static struct platform_device s3c_uart2 = {
-        .name             = "s3c2440-uart",
-        .id               = 2,
-        .num_resources    = ARRAY_SIZE(s3c_uart2_resource),
-        .resource         = s3c_uart2_resource,
-};
-
-static struct platform_device *uart_devices[] __initdata = {
-        &s3c_uart0,
-        &s3c_uart1,
-        &s3c_uart2
-};
-
-/* uart initialisation */
-
-static int __initdata s3c2440_uart_count;
-
-void __init s3c2440_init_uarts(struct s3c2410_uartcfg *cfg, int no)
-{
-        struct platform_device *platdev;
-        int uart;
-
-        for (uart = 0; uart < no; uart++, cfg++) {
-                platdev = uart_devices[cfg->hwport];
-
-                s3c24xx_uart_devs[uart] = platdev;
-                platdev->dev.platform_data = cfg;
-        }
-
-        s3c2440_uart_count = uart;
-}
-
-
-#ifdef CONFIG_PM
-
-static struct sleep_save s3c2440_sleep[] = {
-        SAVE_ITEM(S3C2440_DSC0),
-        SAVE_ITEM(S3C2440_DSC1),
-        SAVE_ITEM(S3C2440_GPJDAT),
-        SAVE_ITEM(S3C2440_GPJCON),
-        SAVE_ITEM(S3C2440_GPJUP)
-};
-
-static int s3c2440_suspend(struct sys_device *dev, pm_message_t state)
-{
-        s3c2410_pm_do_save(s3c2440_sleep, ARRAY_SIZE(s3c2440_sleep));
-        return 0;
-}
-
-static int s3c2440_resume(struct sys_device *dev)
-{
-        s3c2410_pm_do_restore(s3c2440_sleep, ARRAY_SIZE(s3c2440_sleep));
-        return 0;
-}
-
-#else
-#define s3c2440_suspend NULL
-#define s3c2440_resume  NULL
-#endif
-
-struct sysdev_class s3c2440_sysclass = {
-        set_kset_name("s3c2440-core"),
-        .suspend        = s3c2440_suspend,
-        .resume         = s3c2440_resume
-};
-
 static struct sys_device s3c2440_sysdev = {
         .cls            = &s3c2440_sysclass,
 };
 
-void __init s3c2440_map_io(struct map_desc *mach_desc, int size)
+int __init s3c2440_init(void)
 {
-        /* register our io-tables */
-
-        iotable_init(s3c2440_iodesc, ARRAY_SIZE(s3c2440_iodesc));
-        iotable_init(mach_desc, size);
-
-        /* rename any peripherals used differing from the s3c2410 */
-
-        s3c_device_i2c.name  = "s3c2440-i2c";
-        s3c_device_nand.name = "s3c2440-nand";
+        printk("S3C2440: Initialising architecture\n");
 
         /* change irq for watchdog */
 
         s3c_device_wdt.resource[1].start = IRQ_S3C2440_WDT;
         s3c_device_wdt.resource[1].end   = IRQ_S3C2440_WDT;
-}
-
-void __init s3c2440_init_clocks(int xtal)
-{
-        unsigned long clkdiv;
-        unsigned long camdiv;
-        unsigned long hclk, fclk, pclk;
-        int hdiv = 1;
-
-        /* now we've got our machine bits initialised, work out what
-         * clocks we've got */
-
-        fclk = s3c2410_get_pll(__raw_readl(S3C2410_MPLLCON), xtal) * 2;
-
-        clkdiv = __raw_readl(S3C2410_CLKDIVN);
-        camdiv = __raw_readl(S3C2440_CAMDIVN);
-
-        /* work out clock scalings */
-
-        switch (clkdiv & S3C2440_CLKDIVN_HDIVN_MASK) {
-        case S3C2440_CLKDIVN_HDIVN_1:
-                hdiv = 1;
-                break;
-
-        case S3C2440_CLKDIVN_HDIVN_2:
-                hdiv = 2;
-                break;
-
-        case S3C2440_CLKDIVN_HDIVN_4_8:
-                hdiv = (camdiv & S3C2440_CAMDIVN_HCLK4_HALF) ? 8 : 4;
-                break;
-
-        case S3C2440_CLKDIVN_HDIVN_3_6:
-                hdiv = (camdiv & S3C2440_CAMDIVN_HCLK3_HALF) ? 6 : 3;
-                break;
-        }
-
-        hclk = fclk / hdiv;
-        pclk = hclk / ((clkdiv & S3C2440_CLKDIVN_PDIVN)? 2:1);
-
-        /* print brief summary of clocks, etc */
-
-        printk("S3C2440: core %ld.%03ld MHz, memory %ld.%03ld MHz, peripheral %ld.%03ld MHz\n",
-               print_mhz(fclk), print_mhz(hclk), print_mhz(pclk));
-
-        /* initialise the clocks here, to allow other things like the
-         * console to use them, and to add new ones after the initialisation
-         */
-
-        s3c24xx_setup_clocks(xtal, fclk, hclk, pclk);
-}
-
-/* need to register class before we actually register the device, and
- * we also need to ensure that it has been initialised before any of the
- * drivers even try to use it (even if not on an s3c2440 based system)
- * as a driver which may support both 2410 and 2440 may try and use it.
-*/
-
-static int __init s3c2440_core_init(void)
-{
-        return sysdev_class_register(&s3c2440_sysclass);
-}
-
-core_initcall(s3c2440_core_init);
-
-int __init s3c2440_init(void)
-{
-        int ret;
-
-        printk("S3C2440: Initialising architecture\n");
 
-        ret = sysdev_register(&s3c2440_sysdev);
-        if (ret != 0)
-                printk(KERN_ERR "failed to register sysdev for s3c2440\n");
-        else
-                ret = platform_add_devices(s3c24xx_uart_devs, s3c2440_uart_count);
+        /* register our system device for everything else */
 
-        return ret;
+        return sysdev_register(&s3c2440_sysdev);
 }
diff --git a/arch/arm/mach-s3c2410/s3c2442-clock.c b/arch/arm/mach-s3c2410/s3c2442-clock.c
new file mode 100644
index 000000000000..5b7b301eb522
--- /dev/null
+++ b/arch/arm/mach-s3c2410/s3c2442-clock.c
@@ -0,0 +1,171 @@
+/* linux/arch/arm/mach-s3c2410/s3c2442-clock.c
+ *
+ * Copyright (c) 2004-2005 Simtec Electronics
+ *      http://armlinux.simtec.co.uk/
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * S3C2442 Clock support
+ *
+ * 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
+*/
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/device.h>
+#include <linux/sysdev.h>
+#include <linux/interrupt.h>
+#include <linux/ioport.h>
+#include <linux/mutex.h>
+#include <linux/clk.h>
+
+#include <asm/hardware.h>
+#include <asm/atomic.h>
+#include <asm/irq.h>
+#include <asm/io.h>
+
+#include <asm/arch/regs-clock.h>
+
+#include "clock.h"
+#include "cpu.h"
+
+/* S3C2442 extended clock support */
+
+static unsigned long s3c2442_camif_upll_round(struct clk *clk,
+                                              unsigned long rate)
+{
+        unsigned long parent_rate = clk_get_rate(clk->parent);
+        int div;
+
+        if (rate > parent_rate)
+                return parent_rate;
+
+        div = parent_rate / rate;
+
+        if (div == 3)
+                return parent_rate / 3;
+
+        /* note, we remove the +/- 1 calculations for the divisor */
+
+        div /= 2;
+
+        if (div < 1)
+                div = 1;
+        else if (div > 16)
+                div = 16;
+
+        return parent_rate / (div * 2);
+}
+
+static int s3c2442_camif_upll_setrate(struct clk *clk, unsigned long rate)
+{
+        unsigned long parent_rate = clk_get_rate(clk->parent);
+        unsigned long camdivn =  __raw_readl(S3C2440_CAMDIVN);
+
+        rate = s3c2442_camif_upll_round(clk, rate);
+
+        camdivn &= ~S3C2442_CAMDIVN_CAMCLK_DIV3;
+
+        if (rate == parent_rate) {
+                camdivn &= ~S3C2440_CAMDIVN_CAMCLK_SEL;
+        } else if ((parent_rate / rate) == 3) {
+                camdivn |= S3C2440_CAMDIVN_CAMCLK_SEL;
+                camdivn |= S3C2442_CAMDIVN_CAMCLK_DIV3;
+        } else {
+                camdivn &= ~S3C2440_CAMDIVN_CAMCLK_MASK;
+                camdivn |= S3C2440_CAMDIVN_CAMCLK_SEL;
+                camdivn |= (((parent_rate / rate) / 2) - 1);
+        }
+
+        __raw_writel(camdivn, S3C2440_CAMDIVN);
+
+        return 0;
+}
+
+/* Extra S3C2442 clocks */
+
+static struct clk s3c2442_clk_cam = {
+        .name           = "camif",
+        .id             = -1,
+        .enable         = s3c24xx_clkcon_enable,
+        .ctrlbit        = S3C2440_CLKCON_CAMERA,
+};
+
+static struct clk s3c2442_clk_cam_upll = {
+        .name           = "camif-upll",
+        .id             = -1,
+        .set_rate       = s3c2442_camif_upll_setrate,
+        .round_rate     = s3c2442_camif_upll_round,
+};
+
+static int s3c2442_clk_add(struct sys_device *sysdev)
+{
+        unsigned long camdivn = __raw_readl(S3C2440_CAMDIVN);
+        unsigned long clkdivn;
+        struct clk *clk_h;
+        struct clk *clk_p;
+        struct clk *clk_upll;
+
+        printk("S3C2442: Clock Support, DVS %s\n",
+               (camdivn & S3C2440_CAMDIVN_DVSEN) ? "on" : "off");
+
+        clk_p = clk_get(NULL, "pclk");
+        clk_h = clk_get(NULL, "hclk");
+        clk_upll = clk_get(NULL, "upll");
+
+        if (IS_ERR(clk_p) || IS_ERR(clk_h) || IS_ERR(clk_upll)) {
+                printk(KERN_ERR "S3C2442: Failed to get parent clocks\n");
+                return -EINVAL;
+        }
+
+        /* check rate of UPLL, and if it is near 96MHz, then change
+         * to using half the UPLL rate for the system */
+
+        if (clk_get_rate(clk_upll) > (94 * MHZ)) {
+                clk_usb_bus.rate = clk_get_rate(clk_upll) / 2;
+
+                mutex_lock(&clocks_mutex);
+
+                clkdivn = __raw_readl(S3C2410_CLKDIVN);
+                clkdivn |= S3C2440_CLKDIVN_UCLK;
+                __raw_writel(clkdivn, S3C2410_CLKDIVN);
+
+                mutex_unlock(&clocks_mutex);
+        }
+
+        s3c2442_clk_cam.parent = clk_h;
+        s3c2442_clk_cam_upll.parent = clk_upll;
+
+        s3c24xx_register_clock(&s3c2442_clk_cam);
+        s3c24xx_register_clock(&s3c2442_clk_cam_upll);
+
+        clk_disable(&s3c2442_clk_cam);
+
+        return 0;
+}
+
+static struct sysdev_driver s3c2442_clk_driver = {
+        .add    = s3c2442_clk_add,
+};
+
+static __init int s3c2442_clk_init(void)
+{
+        return sysdev_driver_register(&s3c2442_sysclass, &s3c2442_clk_driver);
+}
+
+arch_initcall(s3c2442_clk_init);
diff --git a/arch/arm/mach-s3c2410/s3c2442.c b/arch/arm/mach-s3c2410/s3c2442.c
new file mode 100644
index 000000000000..debae2430557
--- /dev/null
+++ b/arch/arm/mach-s3c2410/s3c2442.c
@@ -0,0 +1,52 @@
+/* linux/arch/arm/mach-s3c2410/s3c2440.c
+ *
+ * Copyright (c) 2006 Simtec Electronics
+ *   Ben Dooks <ben@simtec.co.uk>
+ *
+ * Samsung S3C2442 Mobile CPU support
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/interrupt.h>
+#include <linux/list.h>
+#include <linux/timer.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/sysdev.h>
+#include <linux/clk.h>
+
+#include <asm/mach/arch.h>
+#include <asm/mach/map.h>
+#include <asm/mach/irq.h>
+
+#include <asm/hardware.h>
+#include <asm/io.h>
+#include <asm/irq.h>
+
+#include <asm/arch/regs-clock.h>
+#include <asm/arch/regs-serial.h>
+#include <asm/arch/regs-gpio.h>
+#include <asm/arch/regs-gpioj.h>
+#include <asm/arch/regs-dsc.h>
+
+#include "s3c2442.h"
+#include "clock.h"
+#include "devs.h"
+#include "cpu.h"
+#include "pm.h"
+
+static struct sys_device s3c2442_sysdev = {
+        .cls            = &s3c2442_sysclass,
+};
+
+int __init s3c2442_init(void)
+{
+        printk("S3C2442: Initialising architecture\n");
+
+        return sysdev_register(&s3c2442_sysdev);
+}
diff --git a/arch/arm/mach-s3c2410/s3c2442.h b/arch/arm/mach-s3c2410/s3c2442.h
new file mode 100644
index 000000000000..0ae37d24866c
--- /dev/null
+++ b/arch/arm/mach-s3c2410/s3c2442.h
@@ -0,0 +1,17 @@
+/* arch/arm/mach-s3c2410/s3c2442.h
+ *
+ * Copyright (c) 2006 Simtec Electronics
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * Header file for s3c2442 cpu support
+ *
+ * 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.
+*/
+
+#ifdef CONFIG_CPU_S3C2442
+extern  int s3c2442_init(void);
+#else
+#define s3c2442_init NULL
+#endif
diff --git a/arch/arm/mach-s3c2410/s3c244x-irq.c b/arch/arm/mach-s3c2410/s3c244x-irq.c
new file mode 100644
index 000000000000..2aadca1ce7eb
--- /dev/null
+++ b/arch/arm/mach-s3c2410/s3c244x-irq.c
@@ -0,0 +1,142 @@
+/* linux/arch/arm/mach-s3c2410/s3c2440-irq.c
+ *
+ * Copyright (c) 2003,2004 Simtec Electronics
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * 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
+ *
+ * Changelog:
+ *      25-Jul-2005 BJD         Split from irq.c
+ *
+*/
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/ioport.h>
+#include <linux/ptrace.h>
+#include <linux/sysdev.h>
+
+#include <asm/hardware.h>
+#include <asm/irq.h>
+#include <asm/io.h>
+
+#include <asm/mach/irq.h>
+
+#include <asm/arch/regs-irq.h>
+#include <asm/arch/regs-gpio.h>
+
+#include "cpu.h"
+#include "pm.h"
+#include "irq.h"
+
+/* camera irq */
+
+static void s3c_irq_demux_cam(unsigned int irq,
+                              struct irqdesc *desc,
+                              struct pt_regs *regs)
+{
+        unsigned int subsrc, submsk;
+        struct irqdesc *mydesc;
+
+        /* read the current pending interrupts, and the mask
+         * for what it is available */
+
+        subsrc = __raw_readl(S3C2410_SUBSRCPND);
+        submsk = __raw_readl(S3C2410_INTSUBMSK);
+
+        subsrc &= ~submsk;
+        subsrc >>= 11;
+        subsrc &= 3;
+
+        if (subsrc != 0) {
+                if (subsrc & 1) {
+                        mydesc = irq_desc + IRQ_S3C2440_CAM_C;
+                        desc_handle_irq(IRQ_S3C2440_CAM_C, mydesc, regs);
+                }
+                if (subsrc & 2) {
+                        mydesc = irq_desc + IRQ_S3C2440_CAM_P;
+                        desc_handle_irq(IRQ_S3C2440_CAM_P, mydesc, regs);
+                }
+        }
+}
+
+#define INTMSK_CAM (1UL << (IRQ_CAM - IRQ_EINT0))
+
+static void
+s3c_irq_cam_mask(unsigned int irqno)
+{
+        s3c_irqsub_mask(irqno, INTMSK_CAM, 3<<11);
+}
+
+static void
+s3c_irq_cam_unmask(unsigned int irqno)
+{
+        s3c_irqsub_unmask(irqno, INTMSK_CAM);
+}
+
+static void
+s3c_irq_cam_ack(unsigned int irqno)
+{
+        s3c_irqsub_maskack(irqno, INTMSK_CAM, 3<<11);
+}
+
+static struct irqchip s3c_irq_cam = {
+        .mask       = s3c_irq_cam_mask,
+        .unmask     = s3c_irq_cam_unmask,
+        .ack        = s3c_irq_cam_ack,
+};
+
+static int s3c244x_irq_add(struct sys_device *sysdev)
+{
+        unsigned int irqno;
+
+        set_irq_chip(IRQ_NFCON, &s3c_irq_level_chip);
+        set_irq_handler(IRQ_NFCON, do_level_IRQ);
+        set_irq_flags(IRQ_NFCON, IRQF_VALID);
+
+        /* add chained handler for camera */
+
+        set_irq_chip(IRQ_CAM, &s3c_irq_level_chip);
+        set_irq_handler(IRQ_CAM, do_level_IRQ);
+        set_irq_chained_handler(IRQ_CAM, s3c_irq_demux_cam);
+
+        for (irqno = IRQ_S3C2440_CAM_C; irqno <= IRQ_S3C2440_CAM_P; irqno++) {
+                set_irq_chip(irqno, &s3c_irq_cam);
+                set_irq_handler(irqno, do_level_IRQ);
+                set_irq_flags(irqno, IRQF_VALID);
+        }
+
+        return 0;
+}
+
+static struct sysdev_driver s3c244x_irq_driver = {
+        .add    = s3c244x_irq_add,
+};
+
+static int s3c2440_irq_init(void)
+{
+        return sysdev_driver_register(&s3c2440_sysclass, &s3c244x_irq_driver);
+}
+
+arch_initcall(s3c2440_irq_init);
+
+
+static int s3c2442_irq_init(void)
+{
+        return sysdev_driver_register(&s3c2442_sysclass, &s3c244x_irq_driver);
+}
+
+arch_initcall(s3c2442_irq_init);
diff --git a/arch/arm/mach-s3c2410/s3c244x.c b/arch/arm/mach-s3c2410/s3c244x.c
new file mode 100644
index 000000000000..96852a7000db
--- /dev/null
+++ b/arch/arm/mach-s3c2410/s3c244x.c
@@ -0,0 +1,182 @@
+/* linux/arch/arm/mach-s3c2410/s3c244x.c
+ *
+ * Copyright (c) 2004-2006 Simtec Electronics
+ *   Ben Dooks <ben@simtec.co.uk>
+ *
+ * Samsung S3C2440 and S3C2442 Mobile CPU support
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/interrupt.h>
+#include <linux/list.h>
+#include <linux/timer.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/sysdev.h>
+#include <linux/clk.h>
+
+#include <asm/mach/arch.h>
+#include <asm/mach/map.h>
+#include <asm/mach/irq.h>
+
+#include <asm/hardware.h>
+#include <asm/io.h>
+#include <asm/irq.h>
+
+#include <asm/arch/regs-clock.h>
+#include <asm/arch/regs-serial.h>
+#include <asm/arch/regs-gpio.h>
+#include <asm/arch/regs-gpioj.h>
+#include <asm/arch/regs-dsc.h>
+
+#include "s3c2440.h"
+#include "s3c244x.h"
+#include "clock.h"
+#include "devs.h"
+#include "cpu.h"
+#include "pm.h"
+
+static struct map_desc s3c244x_iodesc[] __initdata = {
+        IODESC_ENT(CLKPWR),
+        IODESC_ENT(TIMER),
+        IODESC_ENT(WATCHDOG),
+        IODESC_ENT(LCD),
+        IODESC_ENT(ADC),
+        IODESC_ENT(USBHOST),
+};
+
+/* uart initialisation */
+
+void __init s3c244x_init_uarts(struct s3c2410_uartcfg *cfg, int no)
+{
+        s3c24xx_init_uartdevs("s3c2440-uart", s3c2410_uart_resources, cfg, no);
+}
+
+void __init s3c244x_map_io(struct map_desc *mach_desc, int size)
+{
+        /* register our io-tables */
+
+        iotable_init(s3c244x_iodesc, ARRAY_SIZE(s3c244x_iodesc));
+        iotable_init(mach_desc, size);
+
+        /* rename any peripherals used differing from the s3c2410 */
+
+        s3c_device_i2c.name  = "s3c2440-i2c";
+        s3c_device_nand.name = "s3c2440-nand";
+}
+
+void __init s3c244x_init_clocks(int xtal)
+{
+        unsigned long clkdiv;
+        unsigned long camdiv;
+        unsigned long hclk, fclk, pclk;
+        int hdiv = 1;
+
+        /* now we've got our machine bits initialised, work out what
+         * clocks we've got */
+
+        fclk = s3c2410_get_pll(__raw_readl(S3C2410_MPLLCON), xtal) * 2;
+
+        clkdiv = __raw_readl(S3C2410_CLKDIVN);
+        camdiv = __raw_readl(S3C2440_CAMDIVN);
+
+        /* work out clock scalings */
+
+        switch (clkdiv & S3C2440_CLKDIVN_HDIVN_MASK) {
+        case S3C2440_CLKDIVN_HDIVN_1:
+                hdiv = 1;
+                break;
+
+        case S3C2440_CLKDIVN_HDIVN_2:
+                hdiv = 2;
+                break;
+
+        case S3C2440_CLKDIVN_HDIVN_4_8:
+                hdiv = (camdiv & S3C2440_CAMDIVN_HCLK4_HALF) ? 8 : 4;
+                break;
+
+        case S3C2440_CLKDIVN_HDIVN_3_6:
+                hdiv = (camdiv & S3C2440_CAMDIVN_HCLK3_HALF) ? 6 : 3;
+                break;
+        }
+
+        hclk = fclk / hdiv;
+        pclk = hclk / ((clkdiv & S3C2440_CLKDIVN_PDIVN)? 2:1);
+
+        /* print brief summary of clocks, etc */
+
+        printk("S3C244X: core %ld.%03ld MHz, memory %ld.%03ld MHz, peripheral %ld.%03ld MHz\n",
+               print_mhz(fclk), print_mhz(hclk), print_mhz(pclk));
+
+        /* initialise the clocks here, to allow other things like the
+         * console to use them, and to add new ones after the initialisation
+         */
+
+        s3c24xx_setup_clocks(xtal, fclk, hclk, pclk);
+}
+
+#ifdef CONFIG_PM
+
+static struct sleep_save s3c244x_sleep[] = {
+        SAVE_ITEM(S3C2440_DSC0),
+        SAVE_ITEM(S3C2440_DSC1),
+        SAVE_ITEM(S3C2440_GPJDAT),
+        SAVE_ITEM(S3C2440_GPJCON),
+        SAVE_ITEM(S3C2440_GPJUP)
+};
+
+static int s3c244x_suspend(struct sys_device *dev, pm_message_t state)
+{
+        s3c2410_pm_do_save(s3c244x_sleep, ARRAY_SIZE(s3c244x_sleep));
+        return 0;
+}
+
+static int s3c244x_resume(struct sys_device *dev)
+{
+        s3c2410_pm_do_restore(s3c244x_sleep, ARRAY_SIZE(s3c244x_sleep));
+        return 0;
+}
+
+#else
+#define s3c244x_suspend NULL
+#define s3c244x_resume  NULL
+#endif
+
+/* Since the S3C2442 and S3C2440 share  items, put both sysclasses here */
+
+struct sysdev_class s3c2440_sysclass = {
+        set_kset_name("s3c2440-core"),
+        .suspend        = s3c244x_suspend,
+        .resume         = s3c244x_resume
+};
+
+struct sysdev_class s3c2442_sysclass = {
+        set_kset_name("s3c2442-core"),
+        .suspend        = s3c244x_suspend,
+        .resume         = s3c244x_resume
+};
+
+/* need to register class before we actually register the device, and
+ * we also need to ensure that it has been initialised before any of the
+ * drivers even try to use it (even if not on an s3c2440 based system)
+ * as a driver which may support both 2410 and 2440 may try and use it.
+*/
+
+static int __init s3c2440_core_init(void)
+{
+        return sysdev_class_register(&s3c2440_sysclass);
+}
+
+core_initcall(s3c2440_core_init);
+
+static int __init s3c2442_core_init(void)
+{
+        return sysdev_class_register(&s3c2442_sysclass);
+}
+
+core_initcall(s3c2442_core_init);
diff --git a/arch/arm/mach-s3c2410/s3c244x.h b/arch/arm/mach-s3c2410/s3c244x.h
new file mode 100644
index 000000000000..3e7f5f75134d
--- /dev/null
+++ b/arch/arm/mach-s3c2410/s3c244x.h
@@ -0,0 +1,25 @@
+/* arch/arm/mach-s3c2410/s3c2440.h
+ *
+ * Copyright (c) 2004-2005 Simtec Electronics
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * Header file for S3C2440 and S3C2442 cpu support
+ *
+ * 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.
+*/
+
+#if defined(CONFIG_CPU_S3C2440) || defined(CONFIG_CPU_S3C2442)
+
+extern void s3c244x_map_io(struct map_desc *mach_desc, int size);
+
+extern void s3c244x_init_uarts(struct s3c2410_uartcfg *cfg, int no);
+
+extern void s3c244x_init_clocks(int xtal);
+
+#else
+#define s3c244x_init_clocks NULL
+#define s3c244x_init_uarts NULL
+#define s3c244x_map_io NULL
+#endif
diff --git a/arch/arm/mach-s3c2410/sleep.S b/arch/arm/mach-s3c2410/sleep.S
index 73de2eaca22a..5f6761ed96b2 100644
--- a/arch/arm/mach-s3c2410/sleep.S
+++ b/arch/arm/mach-s3c2410/sleep.S
@@ -66,7 +66,9 @@ ENTRY(s3c2410_cpu_suspend)
         @@ flush the caches to ensure everything is back out to
         @@ SDRAM before the core powers down
 
+#ifndef CONFIG_CPU_DCACHE_WRITETHROUGH
         bl      arm920_flush_kern_cache_all
+#endif
 
         @@ prepare cpu to sleep
 
diff --git a/arch/arm/mm/Kconfig b/arch/arm/mm/Kconfig
index c55b739e10ba..1ff2f073a55d 100644
--- a/arch/arm/mm/Kconfig
+++ b/arch/arm/mm/Kconfig
@@ -121,8 +121,8 @@ config CPU_ARM925T
 # ARM926T
 config CPU_ARM926T
         bool "Support ARM926T processor"
-        depends on ARCH_INTEGRATOR || ARCH_VERSATILE_PB || MACH_VERSATILE_AB || ARCH_OMAP730 || ARCH_OMAP16XX || MACH_REALVIEW_EB
-        default y if ARCH_VERSATILE_PB || MACH_VERSATILE_AB || ARCH_OMAP730 || ARCH_OMAP16XX
+        depends on ARCH_INTEGRATOR || ARCH_VERSATILE_PB || MACH_VERSATILE_AB || ARCH_OMAP730 || ARCH_OMAP16XX || MACH_REALVIEW_EB || ARCH_PNX4008
+        default y if ARCH_VERSATILE_PB || MACH_VERSATILE_AB || ARCH_OMAP730 || ARCH_OMAP16XX || ARCH_PNX4008
         select CPU_32v5
         select CPU_ABRT_EV5TJ
         select CPU_CACHE_VIVT
diff --git a/arch/um/kernel/physmem.c b/arch/um/kernel/physmem.c
index fc0f0b085ca7..166cb09cae4c 100644
--- a/arch/um/kernel/physmem.c
+++ b/arch/um/kernel/physmem.c
@@ -69,7 +69,7 @@ static void insert_phys_mapping(struct phys_desc *desc)
                 panic("Physical remapping for %p already present",
                       desc->virt);
 
-        rb_link_node(&desc->rb, (*n)->rb_parent, n);
+        rb_link_node(&desc->rb, rb_parent(*n), n);
         rb_insert_color(&desc->rb, &phys_mappings);
 }
 
diff --git a/block/as-iosched.c b/block/as-iosched.c
index a7caf35ca0c2..0c750393be4a 100644
--- a/block/as-iosched.c
+++ b/block/as-iosched.c
@@ -353,10 +353,9 @@ static struct request *as_find_arq_hash(struct as_data *ad, sector_t offset)
 /*
  * rb tree support functions
  */
-#define RB_NONE         (2)
 #define RB_EMPTY(root)  ((root)->rb_node == NULL)
-#define ON_RB(node)     ((node)->rb_color != RB_NONE)
-#define RB_CLEAR(node)  ((node)->rb_color = RB_NONE)
+#define ON_RB(node)     (rb_parent(node) != node)
+#define RB_CLEAR(node)  (rb_set_parent(node, node))
 #define rb_entry_arq(node)      rb_entry((node), struct as_rq, rb_node)
 #define ARQ_RB_ROOT(ad, arq)    (&(ad)->sort_list[(arq)->is_sync])
 #define rq_rb_key(rq)           (rq)->sector
diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
index 052b17487625..6200d9b9af28 100644
--- a/block/cfq-iosched.c
+++ b/block/cfq-iosched.c
@@ -60,14 +60,9 @@ static DEFINE_SPINLOCK(cfq_exit_lock);
 /*
  * rb-tree defines
  */
-#define RB_NONE                 (2)
 #define RB_EMPTY(node)          ((node)->rb_node == NULL)
-#define RB_CLEAR_COLOR(node)    (node)->rb_color = RB_NONE
 #define RB_CLEAR(node)          do {    \
-        (node)->rb_parent = NULL;       \
-        RB_CLEAR_COLOR((node));         \
-        (node)->rb_right = NULL;        \
-        (node)->rb_left = NULL;         \
+                memset(node, 0, sizeof(*node)); \
 } while (0)
 #define RB_CLEAR_ROOT(root)     ((root)->rb_node = NULL)
 #define rb_entry_crq(node)      rb_entry((node), struct cfq_rq, rb_node)
@@ -567,7 +562,6 @@ static inline void cfq_del_crq_rb(struct cfq_rq *crq)
         cfq_update_next_crq(crq);
 
         rb_erase(&crq->rb_node, &cfqq->sort_list);
-        RB_CLEAR_COLOR(&crq->rb_node);
 
         if (cfq_cfqq_on_rr(cfqq) && RB_EMPTY(&cfqq->sort_list))
                 cfq_del_cfqq_rr(cfqd, cfqq);
diff --git a/block/deadline-iosched.c b/block/deadline-iosched.c
index 3bd0415a9828..c94de8e12fbf 100644
--- a/block/deadline-iosched.c
+++ b/block/deadline-iosched.c
@@ -165,10 +165,9 @@ deadline_find_drq_hash(struct deadline_data *dd, sector_t offset)
 /*
  * rb tree support functions
  */
-#define RB_NONE         (2)
 #define RB_EMPTY(root)  ((root)->rb_node == NULL)
-#define ON_RB(node)     ((node)->rb_color != RB_NONE)
-#define RB_CLEAR(node)  ((node)->rb_color = RB_NONE)
+#define ON_RB(node)     (rb_parent(node) != node)
+#define RB_CLEAR(node)  (rb_set_parent(node, node))
 #define rb_entry_drq(node)      rb_entry((node), struct deadline_rq, rb_node)
 #define DRQ_RB_ROOT(dd, drq)    (&(dd)->sort_list[rq_data_dir((drq)->request)])
 #define rq_rb_key(rq)           (rq)->sector
diff --git a/drivers/char/rio/daemon.h b/drivers/char/rio/daemon.h
index 5818a8aa46e0..6e63f8b2c479 100644
--- a/drivers/char/rio/daemon.h
+++ b/drivers/char/rio/daemon.h
@@ -51,7 +51,7 @@ struct Error {
 };
 
 struct DownLoad {
-        char *DataP;
+        char __user *DataP;
         unsigned int Count;
         unsigned int ProductCode;
 };
@@ -83,18 +83,18 @@ struct PortSetup {
 struct LpbReq {
         unsigned int Host;
         unsigned int Link;
-        struct LPB *LpbP;
+        struct LPB __user *LpbP;
 };
 
 struct RupReq {
         unsigned int HostNum;
         unsigned int RupNum;
-        struct RUP *RupP;
+        struct RUP __user *RupP;
 };
 
 struct PortReq {
         unsigned int SysPort;
-        struct Port *PortP;
+        struct Port __user *PortP;
 };
 
 struct StreamInfo {
@@ -105,12 +105,12 @@ struct StreamInfo {
 
 struct HostReq {
         unsigned int HostNum;
-        struct Host *HostP;
+        struct Host __user *HostP;
 };
 
 struct HostDpRam {
         unsigned int HostNum;
-        struct DpRam *DpRamP;
+        struct DpRam __user *DpRamP;
 };
 
 struct DebugCtrl {
diff --git a/drivers/char/rio/func.h b/drivers/char/rio/func.h
index e64fe9912394..6b039186856d 100644
--- a/drivers/char/rio/func.h
+++ b/drivers/char/rio/func.h
@@ -46,7 +46,7 @@ int RIOBootCodeRTA(struct rio_info *, struct DownLoad *);
 int RIOBootCodeHOST(struct rio_info *, struct DownLoad *);
 int RIOBootCodeUNKNOWN(struct rio_info *, struct DownLoad *);
 void msec_timeout(struct Host *);
-int RIOBootRup(struct rio_info *, unsigned int, struct Host *, struct PKT *);
+int RIOBootRup(struct rio_info *, unsigned int, struct Host *, struct PKT __iomem *);
 int RIOBootOk(struct rio_info *, struct Host *, unsigned long);
 int RIORtaBound(struct rio_info *, unsigned int);
 void rio_fill_host_slot(int, int, unsigned int, struct Host *);
@@ -55,8 +55,8 @@ void rio_fill_host_slot(int, int, unsigned int, struct Host *);
 int RIOFoadRta(struct Host *, struct Map *);
 int RIOZombieRta(struct Host *, struct Map *);
 int RIOCommandRta(struct rio_info *, unsigned long, int (*func) (struct Host *, struct Map *));
-int RIOIdentifyRta(struct rio_info *, void *);
-int RIOKillNeighbour(struct rio_info *, void *);
+int RIOIdentifyRta(struct rio_info *, void __user *);
+int RIOKillNeighbour(struct rio_info *, void __user *);
 int RIOSuspendBootRta(struct Host *, int, int);
 int RIOFoadWakeup(struct rio_info *);
 struct CmdBlk *RIOGetCmdBlk(void);
@@ -68,7 +68,8 @@ int RIORFlushEnable(unsigned long, struct CmdBlk *);
 int RIOUnUse(unsigned long, struct CmdBlk *);
 
 /* rioctrl.c */
-int riocontrol(struct rio_info *, dev_t, int, caddr_t, int);
+int riocontrol(struct rio_info *, dev_t, int, unsigned long, int);
+
 int RIOPreemptiveCmd(struct rio_info *, struct Port *, unsigned char);
 
 /* rioinit.c */
@@ -77,13 +78,13 @@ void RIOInitHosts(struct rio_info *, struct RioHostInfo *);
 void RIOISAinit(struct rio_info *, int);
 int RIODoAT(struct rio_info *, int, int);
 caddr_t RIOCheckForATCard(int);
-int RIOAssignAT(struct rio_info *, int, caddr_t, int);
-int RIOBoardTest(unsigned long, caddr_t, unsigned char, int);
+int RIOAssignAT(struct rio_info *, int, void __iomem *, int);
+int RIOBoardTest(unsigned long, void __iomem *, unsigned char, int);
 void RIOAllocDataStructs(struct rio_info *);
 void RIOSetupDataStructs(struct rio_info *);
 int RIODefaultName(struct rio_info *, struct Host *, unsigned int);
 struct rioVersion *RIOVersid(void);
-void RIOHostReset(unsigned int, struct DpRam *, unsigned int);
+void RIOHostReset(unsigned int, struct DpRam __iomem *, unsigned int);
 
 /* riointr.c */
 void RIOTxEnable(char *);
@@ -95,14 +96,14 @@ int RIOParam(struct Port *, int, int, int);
 int RIODelay(struct Port *PortP, int);
 int RIODelay_ni(struct Port *PortP, int);
 void ms_timeout(struct Port *);
-int can_add_transmit(struct PKT **, struct Port *);
+int can_add_transmit(struct PKT __iomem **, struct Port *);
 void add_transmit(struct Port *);
-void put_free_end(struct Host *, struct PKT *);
-int can_remove_receive(struct PKT **, struct Port *);
+void put_free_end(struct Host *, struct PKT __iomem *);
+int can_remove_receive(struct PKT __iomem **, struct Port *);
 void remove_receive(struct Port *);
 
 /* rioroute.c */
-int RIORouteRup(struct rio_info *, unsigned int, struct Host *, struct PKT *);
+int RIORouteRup(struct rio_info *, unsigned int, struct Host *, struct PKT __iomem *);
 void RIOFixPhbs(struct rio_info *, struct Host *, unsigned int);
 unsigned int GetUnitType(unsigned int);
 int RIOSetChange(struct rio_info *);
@@ -139,7 +140,7 @@ int rio_isr_thread(char *);
 struct rio_info *rio_info_store(int cmd, struct rio_info *p);
 #endif
 
-extern void rio_copy_to_card(void *to, void *from, int len);
+extern void rio_copy_to_card(void *from, void __iomem *to, int len);
 extern int rio_minor(struct tty_struct *tty);
 extern int rio_ismodem(struct tty_struct *tty);
 
diff --git a/drivers/char/rio/host.h b/drivers/char/rio/host.h
index 179cdbea712b..ee2ddea7a63a 100644
--- a/drivers/char/rio/host.h
+++ b/drivers/char/rio/host.h
@@ -48,8 +48,8 @@ struct Host {
         unsigned char Ivec;             /* POLLED or ivec number */
         unsigned char Mode;             /* Control stuff */
         unsigned char Slot;             /* Slot */
-        caddr_t Caddr;                  /* KV address of DPRAM */
-        struct DpRam *CardP;            /* KV address of DPRAM, with overlay */
+        void  __iomem *Caddr;           /* KV address of DPRAM */
+        struct DpRam __iomem *CardP;    /* KV address of DPRAM, with overlay */
         unsigned long PaddrP;           /* Phys. address of DPRAM */
         char Name[MAX_NAME_LEN];        /* The name of the host */
         unsigned int UniqueNum;         /* host unique number */
@@ -57,7 +57,7 @@ struct Host {
         unsigned int WorkToBeDone;      /* set to true each interrupt */
         unsigned int InIntr;            /* Being serviced? */
         unsigned int IntSrvDone;        /* host's interrupt has been serviced */
-        void (*Copy) (void *, void *, int);     /* copy func */
+        void (*Copy) (void *, void __iomem *, int);     /* copy func */
         struct timer_list timer;
         /*
          **               I M P O R T A N T !
@@ -83,11 +83,11 @@ struct Host {
 
         struct Top Topology[LINKS_PER_UNIT];    /* one per link */
         struct Map Mapping[MAX_RUP];            /* Mappings for host */
-        struct PHB *PhbP;                       /* Pointer to the PHB array */
-        unsigned short *PhbNumP;                /* Ptr to Number of PHB's */
-        struct LPB *LinkStrP;                   /* Link Structure Array */
-        struct RUP *RupP;                       /* Sixteen real rups here */
-        struct PARM_MAP *ParmMapP;              /* points to the parmmap */
+        struct PHB __iomem *PhbP;               /* Pointer to the PHB array */
+        unsigned short __iomem *PhbNumP;        /* Ptr to Number of PHB's */
+        struct LPB __iomem *LinkStrP;           /* Link Structure Array */
+        struct RUP __iomem *RupP;               /* Sixteen real rups here */
+        struct PARM_MAP __iomem *ParmMapP;      /* points to the parmmap */
         unsigned int ExtraUnits[MAX_EXTRA_UNITS];       /* unknown things */
         unsigned int NumExtraBooted;            /* how many of the above */
         /*
diff --git a/drivers/char/rio/port.h b/drivers/char/rio/port.h
index 9b5fa3eb0402..49cf6d15ee54 100644
--- a/drivers/char/rio/port.h
+++ b/drivers/char/rio/port.h
@@ -40,7 +40,7 @@ struct Port {
         struct gs_port gs;
         int PortNum;                    /* RIO port no., 0-511 */
         struct Host *HostP;
-        caddr_t Caddr;
+        void __iomem *Caddr;
         unsigned short HostPort;        /* Port number on host card */
         unsigned char RupNum;           /* Number of RUP for port */
         unsigned char ID2;              /* Second ID of RTA for port */
@@ -92,13 +92,13 @@ struct Port {
 #define RIO_RTSFLOW     0x0400          /* RIO's own RTSFLOW flag */
 
 
-        struct PHB *PhbP;               /* pointer to PHB for port */
-        u16 *TxAdd;                     /* Add packets here */
-        u16 *TxStart;                   /* Start of add array */
-        u16 *TxEnd;                     /* End of add array */
-        u16 *RxRemove;                  /* Remove packets here */
-        u16 *RxStart;                   /* Start of remove array */
-        u16 *RxEnd;                     /* End of remove array */
+        struct PHB __iomem *PhbP;       /* pointer to PHB for port */
+        u16 __iomem *TxAdd;             /* Add packets here */
+        u16 __iomem *TxStart;           /* Start of add array */
+        u16 __iomem *TxEnd;             /* End of add array */
+        u16 __iomem *RxRemove;          /* Remove packets here */
+        u16 __iomem *RxStart;           /* Start of remove array */
+        u16 __iomem *RxEnd;             /* End of remove array */
         unsigned int RtaUniqueNum;      /* Unique number of RTA */
         unsigned short PortState;       /* status of port */
         unsigned short ModemState;      /* status of modem lines */
diff --git a/drivers/char/rio/rio.h b/drivers/char/rio/rio.h
index b4c91871ba28..1bf36223a4e8 100644
--- a/drivers/char/rio/rio.h
+++ b/drivers/char/rio/rio.h
@@ -129,8 +129,8 @@
 **      RIO_OBJ takes hostp->Caddr and a UNIX pointer to an object and
 **      returns the offset into the DP RAM area.
 */
-#define RIO_PTR(C,O) (((unsigned char *)(C))+(0xFFFF&(O)))
-#define RIO_OFF(C,O) ((long)(O)-(long)(C))
+#define RIO_PTR(C,O) (((unsigned char __iomem *)(C))+(0xFFFF&(O)))
+#define RIO_OFF(C,O) ((unsigned char __iomem *)(O)-(unsigned char __iomem *)(C))
 
 /*
 **      How to convert from various different device number formats:
diff --git a/drivers/char/rio/rio_linux.c b/drivers/char/rio/rio_linux.c
index 78dd856534ce..aa43436d5d1b 100644
--- a/drivers/char/rio/rio_linux.c
+++ b/drivers/char/rio/rio_linux.c
@@ -333,9 +333,9 @@ int RIODelay_ni(struct Port *PortP, int njiffies)
         return !RIO_FAIL;
 }
 
-void rio_copy_to_card(void *to, void *from, int len)
+void rio_copy_to_card(void *from, void __iomem *to, int len)
 {
-        rio_memcpy_toio(NULL, to, from, len);
+        rio_copy_toio(to, from, len);
 }
 
 int rio_minor(struct tty_struct *tty)
@@ -573,7 +573,7 @@ static int rio_fw_ioctl(struct inode *inode, struct file *filp, unsigned int cmd
         func_enter();
 
         /* The "dev" argument isn't used. */
-        rc = riocontrol(p, 0, cmd, (void *) arg, capable(CAP_SYS_ADMIN));
+        rc = riocontrol(p, 0, cmd, arg, capable(CAP_SYS_ADMIN));
 
         func_exit();
         return rc;
@@ -583,6 +583,7 @@ extern int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command,
 
 static int rio_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd, unsigned long arg)
 {
+        void __user *argp = (void __user *)arg;
         int rc;
         struct Port *PortP;
         int ival;
@@ -594,14 +595,14 @@ static int rio_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd
         rc = 0;
         switch (cmd) {
         case TIOCSSOFTCAR:
-                if ((rc = get_user(ival, (unsigned int *) arg)) == 0) {
+                if ((rc = get_user(ival, (unsigned __user *) argp)) == 0) {
                         tty->termios->c_cflag = (tty->termios->c_cflag & ~CLOCAL) | (ival ? CLOCAL : 0);
                 }
                 break;
         case TIOCGSERIAL:
                 rc = -EFAULT;
-                if (access_ok(VERIFY_WRITE, (void *) arg, sizeof(struct serial_struct)))
-                        rc = gs_getserial(&PortP->gs, (struct serial_struct *) arg);
+                if (access_ok(VERIFY_WRITE, argp, sizeof(struct serial_struct)))
+                        rc = gs_getserial(&PortP->gs, argp);
                 break;
         case TCSBRK:
                 if (PortP->State & RIO_DELETED) {
@@ -631,8 +632,8 @@ static int rio_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd
                 break;
         case TIOCSSERIAL:
                 rc = -EFAULT;
-                if (access_ok(VERIFY_READ, (void *) arg, sizeof(struct serial_struct)))
-                        rc = gs_setserial(&PortP->gs, (struct serial_struct *) arg);
+                if (access_ok(VERIFY_READ, argp, sizeof(struct serial_struct)))
+                        rc = gs_setserial(&PortP->gs, argp);
                 break;
         default:
                 rc = -ENOIOCTLCMD;
@@ -919,7 +920,7 @@ static void __exit rio_release_drivers(void)
 static void fix_rio_pci(struct pci_dev *pdev)
 {
         unsigned long hwbase;
-        unsigned char *rebase;
+        unsigned char __iomem *rebase;
         unsigned int t;
 
 #define CNTRL_REG_OFFSET        0x50
@@ -999,7 +1000,7 @@ static int __init rio_init(void)
                 if (((1 << hp->Ivec) & rio_irqmask) == 0)
                         hp->Ivec = 0;
                 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
-                hp->CardP = (struct DpRam *) hp->Caddr;
+                hp->CardP = (struct DpRam __iomem *) hp->Caddr;
                 hp->Type = RIO_PCI;
                 hp->Copy = rio_copy_to_card;
                 hp->Mode = RIO_PCI_BOOT_FROM_RAM;
@@ -1021,7 +1022,7 @@ static int __init rio_init(void)
                         p->RIONumHosts++;
                         found++;
                 } else {
-                        iounmap((char *) (p->RIOHosts[p->RIONumHosts].Caddr));
+                        iounmap(p->RIOHosts[p->RIONumHosts].Caddr);
                 }
         }
 
@@ -1047,7 +1048,7 @@ static int __init rio_init(void)
                         hp->Ivec = 0;
                 hp->Ivec |= 0x8000;     /* Mark as non-sharable */
                 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
-                hp->CardP = (struct DpRam *) hp->Caddr;
+                hp->CardP = (struct DpRam __iomem *) hp->Caddr;
                 hp->Type = RIO_PCI;
                 hp->Copy = rio_copy_to_card;
                 hp->Mode = RIO_PCI_BOOT_FROM_RAM;
@@ -1070,7 +1071,7 @@ static int __init rio_init(void)
                         p->RIONumHosts++;
                         found++;
                 } else {
-                        iounmap((char *) (p->RIOHosts[p->RIONumHosts].Caddr));
+                        iounmap(p->RIOHosts[p->RIONumHosts].Caddr);
                 }
 #else
                 printk(KERN_ERR "Found an older RIO PCI card, but the driver is not " "compiled to support it.\n");
@@ -1085,7 +1086,7 @@ static int __init rio_init(void)
                 /* There was something about the IRQs of these cards. 'Forget what.--REW */
                 hp->Ivec = 0;
                 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
-                hp->CardP = (struct DpRam *) hp->Caddr;
+                hp->CardP = (struct DpRam __iomem *) hp->Caddr;
                 hp->Type = RIO_AT;
                 hp->Copy = rio_copy_to_card;    /* AT card PCI???? - PVDL
                                          * -- YES! this is now a normal copy. Only the
@@ -1111,7 +1112,7 @@ static int __init rio_init(void)
                         }
 
                         if (!okboard)
-                                iounmap((char *) (hp->Caddr));
+                                iounmap(hp->Caddr);
                 }
         }
 
diff --git a/drivers/char/rio/rio_linux.h b/drivers/char/rio/rio_linux.h
index 4ce77fb1fae5..55b9c97e8477 100644
--- a/drivers/char/rio/rio_linux.h
+++ b/drivers/char/rio/rio_linux.h
@@ -131,9 +131,9 @@ struct vpd_prom {
 
 
 #ifdef CONFIG_RIO_OLDPCI
-static inline void *rio_memcpy_toio(void *dummy, void *dest, void *source, int n)
+static inline void __iomem *rio_memcpy_toio(void __iomem *dummy, void __iomem *dest, void *source, int n)
 {
-        char *dst = dest;
+        char __iomem *dst = dest;
         char *src = source;
 
         while (n--) {
@@ -144,11 +144,22 @@ static inline void *rio_memcpy_toio(void *dummy, void *dest, void *source, int n
         return dest;
 }
 
+static inline void __iomem *rio_copy_toio(void __iomem *dest, void *source, int n)
+{
+        char __iomem *dst = dest;
+        char *src = source;
+
+        while (n--)
+                writeb(*src++, dst++);
 
-static inline void *rio_memcpy_fromio(void *dest, void *source, int n)
+        return dest;
+}
+
+
+static inline void *rio_memcpy_fromio(void *dest, void __iomem *source, int n)
 {
         char *dst = dest;
-        char *src = source;
+        char __iomem *src = source;
 
         while (n--)
                 *dst++ = readb(src++);
@@ -158,6 +169,7 @@ static inline void *rio_memcpy_fromio(void *dest, void *source, int n)
 
 #else
 #define rio_memcpy_toio(dummy,dest,source,n)   memcpy_toio(dest, source, n)
+#define rio_copy_toio                          memcpy_toio
 #define rio_memcpy_fromio                      memcpy_fromio
 #endif
 
diff --git a/drivers/char/rio/rioboot.c b/drivers/char/rio/rioboot.c
index 290143addd34..eca2b95343e2 100644
--- a/drivers/char/rio/rioboot.c
+++ b/drivers/char/rio/rioboot.c
@@ -71,7 +71,7 @@
 #include "cmdblk.h"
 #include "route.h"
 
-static int RIOBootComplete(struct rio_info *p, struct Host *HostP, unsigned int Rup, struct PktCmd *PktCmdP);
+static int RIOBootComplete(struct rio_info *p, struct Host *HostP, unsigned int Rup, struct PktCmd __iomem *PktCmdP);
 
 static const unsigned char RIOAtVec2Ctrl[] = {
         /* 0 */ INTERRUPT_DISABLE,
@@ -204,13 +204,13 @@ void rio_start_card_running(struct Host *HostP)
 int RIOBootCodeHOST(struct rio_info *p, struct DownLoad *rbp)
 {
         struct Host *HostP;
-        u8 *Cad;
-        PARM_MAP *ParmMapP;
+        u8 __iomem *Cad;
+        PARM_MAP __iomem *ParmMapP;
         int RupN;
         int PortN;
         unsigned int host;
-        u8 *StartP;
-        u8 *DestP;
+        u8 __iomem *StartP;
+        u8 __iomem *DestP;
         int wait_count;
         u16 OldParmMap;
         u16 offset;             /* It is very important that this is a u16 */
@@ -262,7 +262,7 @@ int RIOBootCodeHOST(struct rio_info *p, struct DownLoad *rbp)
                  ** Ensure that the host really is stopped.
                  ** Disable it's external bus & twang its reset line.
                  */
-                RIOHostReset(HostP->Type, (struct DpRam *) HostP->CardP, HostP->Slot);
+                RIOHostReset(HostP->Type, HostP->CardP, HostP->Slot);
 
                 /*
                  ** Copy the data directly from user space to the SRAM.
@@ -280,7 +280,7 @@ int RIOBootCodeHOST(struct rio_info *p, struct DownLoad *rbp)
                         func_exit();
                         return -ENOMEM;
                 }
-                if (copy_from_user(rbp->DataP, DownCode, rbp->Count)) {
+                if (copy_from_user(DownCode, rbp->DataP, rbp->Count)) {
                         kfree(DownCode);
                         p->RIOError.Error = COPYIN_FAILED;
                         func_exit();
@@ -366,7 +366,7 @@ int RIOBootCodeHOST(struct rio_info *p, struct DownLoad *rbp)
                  ** a short branch to 0x7FF8, where a long branch is coded.
                  */
 
-                DestP = (u8 *) &Cad[0x7FF8];    /* <<<---- READ THE ABOVE COMMENTS */
+                DestP = &Cad[0x7FF8];   /* <<<---- READ THE ABOVE COMMENTS */
 
 #define NFIX(N) (0x60 | (N))    /* .O  = (~(.O + N))<<4 */
 #define PFIX(N) (0x20 | (N))    /* .O  =   (.O + N)<<4  */
@@ -438,7 +438,7 @@ int RIOBootCodeHOST(struct rio_info *p, struct DownLoad *rbp)
                         rio_dprintk(RIO_DEBUG_BOOT, "RIO Mesg Run Fail\n");
                         HostP->Flags &= ~RUN_STATE;
                         HostP->Flags |= RC_STUFFED;
-                        RIOHostReset( HostP->Type, (struct DpRam *)HostP->CardP, HostP->Slot );
+                        RIOHostReset( HostP->Type, HostP->CardP, HostP->Slot );
                         continue;
                 }
 
@@ -453,9 +453,9 @@ int RIOBootCodeHOST(struct rio_info *p, struct DownLoad *rbp)
                 /*
                  ** Grab a 32 bit pointer to the parmmap structure
                  */
-                ParmMapP = (PARM_MAP *) RIO_PTR(Cad, readw(&HostP->__ParmMapR));
+                ParmMapP = (PARM_MAP __iomem *) RIO_PTR(Cad, readw(&HostP->__ParmMapR));
                 rio_dprintk(RIO_DEBUG_BOOT, "ParmMapP : %p\n", ParmMapP);
-                ParmMapP = (PARM_MAP *) ((unsigned long) Cad + readw(&HostP->__ParmMapR));
+                ParmMapP = (PARM_MAP __iomem *)(Cad + readw(&HostP->__ParmMapR));
                 rio_dprintk(RIO_DEBUG_BOOT, "ParmMapP : %p\n", ParmMapP);
 
                 /*
@@ -468,7 +468,7 @@ int RIOBootCodeHOST(struct rio_info *p, struct DownLoad *rbp)
                         rio_dprintk(RIO_DEBUG_BOOT, "Links = 0x%x\n", readw(&ParmMapP->links));
                         HostP->Flags &= ~RUN_STATE;
                         HostP->Flags |= RC_STUFFED;
-                        RIOHostReset( HostP->Type, (struct DpRam *)HostP->CardP, HostP->Slot );
+                        RIOHostReset( HostP->Type, HostP->CardP, HostP->Slot );
                         continue;
                 }
 
@@ -491,7 +491,7 @@ int RIOBootCodeHOST(struct rio_info *p, struct DownLoad *rbp)
                         rio_dprintk(RIO_DEBUG_BOOT, "Timedout waiting for init_done\n");
                         HostP->Flags &= ~RUN_STATE;
                         HostP->Flags |= RC_STUFFED;
-                        RIOHostReset( HostP->Type, (struct DpRam *)HostP->CardP, HostP->Slot );
+                        RIOHostReset( HostP->Type, HostP->CardP, HostP->Slot );
                         continue;
                 }
 
@@ -512,10 +512,10 @@ int RIOBootCodeHOST(struct rio_info *p, struct DownLoad *rbp)
                  ** 32 bit pointers for the driver in ioremap space.
                  */
                 HostP->ParmMapP = ParmMapP;
-                HostP->PhbP = (struct PHB *) RIO_PTR(Cad, readw(&ParmMapP->phb_ptr));
-                HostP->RupP = (struct RUP *) RIO_PTR(Cad, readw(&ParmMapP->rups));
-                HostP->PhbNumP = (unsigned short *) RIO_PTR(Cad, readw(&ParmMapP->phb_num_ptr));
-                HostP->LinkStrP = (struct LPB *) RIO_PTR(Cad, readw(&ParmMapP->link_str_ptr));
+                HostP->PhbP = (struct PHB __iomem *) RIO_PTR(Cad, readw(&ParmMapP->phb_ptr));
+                HostP->RupP = (struct RUP __iomem *) RIO_PTR(Cad, readw(&ParmMapP->rups));
+                HostP->PhbNumP = (unsigned short __iomem *) RIO_PTR(Cad, readw(&ParmMapP->phb_num_ptr));
+                HostP->LinkStrP = (struct LPB __iomem *) RIO_PTR(Cad, readw(&ParmMapP->link_str_ptr));
 
                 /*
                  ** point the UnixRups at the real Rups
@@ -540,7 +540,7 @@ int RIOBootCodeHOST(struct rio_info *p, struct DownLoad *rbp)
                 for (PortN = p->RIOFirstPortsMapped; PortN < p->RIOLastPortsMapped + PORTS_PER_RTA; PortN++) {
                         if (p->RIOPortp[PortN]->HostP == HostP) {
                                 struct Port *PortP = p->RIOPortp[PortN];
-                                struct PHB *PhbP;
+                                struct PHB __iomem *PhbP;
                                 /* int oldspl; */
 
                                 if (!PortP->Mapped)
@@ -551,12 +551,12 @@ int RIOBootCodeHOST(struct rio_info *p, struct DownLoad *rbp)
 
                                 PortP->PhbP = PhbP;
 
-                                PortP->TxAdd = (u16 *) RIO_PTR(Cad, readw(&PhbP->tx_add));
-                                PortP->TxStart = (u16 *) RIO_PTR(Cad, readw(&PhbP->tx_start));
-                                PortP->TxEnd = (u16 *) RIO_PTR(Cad, readw(&PhbP->tx_end));
-                                PortP->RxRemove = (u16 *) RIO_PTR(Cad, readw(&PhbP->rx_remove));
-                                PortP->RxStart = (u16 *) RIO_PTR(Cad, readw(&PhbP->rx_start));
-                                PortP->RxEnd = (u16 *) RIO_PTR(Cad, readw(&PhbP->rx_end));
+                                PortP->TxAdd = (u16 __iomem *) RIO_PTR(Cad, readw(&PhbP->tx_add));
+                                PortP->TxStart = (u16 __iomem *) RIO_PTR(Cad, readw(&PhbP->tx_start));
+                                PortP->TxEnd = (u16 __iomem *) RIO_PTR(Cad, readw(&PhbP->tx_end));
+                                PortP->RxRemove = (u16 __iomem *) RIO_PTR(Cad, readw(&PhbP->rx_remove));
+                                PortP->RxStart = (u16 __iomem *) RIO_PTR(Cad, readw(&PhbP->rx_start));
+                                PortP->RxEnd = (u16 __iomem *) RIO_PTR(Cad, readw(&PhbP->rx_end));
 
                                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                                 /*
@@ -601,9 +601,9 @@ int RIOBootCodeHOST(struct rio_info *p, struct DownLoad *rbp)
  *      return 1. If we havent, then return 0.
  */
 
-int RIOBootRup(struct rio_info *p, unsigned int Rup, struct Host *HostP, struct PKT *PacketP)
+int RIOBootRup(struct rio_info *p, unsigned int Rup, struct Host *HostP, struct PKT __iomem *PacketP)
 {
-        struct PktCmd *PktCmdP = (struct PktCmd *) PacketP->data;
+        struct PktCmd __iomem *PktCmdP = (struct PktCmd __iomem *) PacketP->data;
         struct PktCmd_M *PktReplyP;
         struct CmdBlk *CmdBlkP;
         unsigned int sequence;
@@ -722,7 +722,7 @@ int RIOBootRup(struct rio_info *p, unsigned int Rup, struct Host *HostP, struct
  *      RtaUniq is the booted RTA.
  */
 
-static int RIOBootComplete(struct rio_info *p, struct Host *HostP, unsigned int Rup, struct PktCmd *PktCmdP)
+static int RIOBootComplete(struct rio_info *p, struct Host *HostP, unsigned int Rup, struct PktCmd __iomem *PktCmdP)
 {
         struct Map *MapP = NULL;
         struct Map *MapP2 = NULL;
diff --git a/drivers/char/rio/riocmd.c b/drivers/char/rio/riocmd.c
index e6d2b14b5e65..4df6ab2206a1 100644
--- a/drivers/char/rio/riocmd.c
+++ b/drivers/char/rio/riocmd.c
@@ -180,7 +180,7 @@ int RIOCommandRta(struct rio_info *p, unsigned long RtaUnique, int (*func) (stru
 }
 
 
-int RIOIdentifyRta(struct rio_info *p, void * arg)
+int RIOIdentifyRta(struct rio_info *p, void __user * arg)
 {
         unsigned int Host;
 
@@ -245,7 +245,7 @@ int RIOIdentifyRta(struct rio_info *p, void * arg)
 }
 
 
-int RIOKillNeighbour(struct rio_info *p, void * arg)
+int RIOKillNeighbour(struct rio_info *p, void __user * arg)
 {
         uint Host;
         uint ID;
@@ -370,9 +370,9 @@ int RIOFoadWakeup(struct rio_info *p)
 /*
 ** Incoming command on the COMMAND_RUP to be processed.
 */
-static int RIOCommandRup(struct rio_info *p, uint Rup, struct Host *HostP, struct PKT * PacketP)
+static int RIOCommandRup(struct rio_info *p, uint Rup, struct Host *HostP, struct PKT __iomem *PacketP)
 {
-        struct PktCmd *PktCmdP = (struct PktCmd *) PacketP->data;
+        struct PktCmd __iomem *PktCmdP = (struct PktCmd __iomem *)PacketP->data;
         struct Port *PortP;
         struct UnixRup *UnixRupP;
         unsigned short SysPort;
@@ -407,12 +407,12 @@ static int RIOCommandRup(struct rio_info *p, uint Rup, struct Host *HostP, struc
                 } else
                         rio_dprintk(RIO_DEBUG_CMD, "CONTROL information: This is the RUP for link ``%c'' of host ``%s''\n", ('A' + Rup - MAX_RUP), HostP->Name);
 
-                rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Destination 0x%x:0x%x\n", PacketP->dest_unit, PacketP->dest_port);
-                rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Source    0x%x:0x%x\n", PacketP->src_unit, PacketP->src_port);
-                rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Length    0x%x (%d)\n", PacketP->len, PacketP->len);
-                rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Control  0x%x (%d)\n", PacketP->control, PacketP->control);
-                rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Check      0x%x (%d)\n", PacketP->csum, PacketP->csum);
-                rio_dprintk(RIO_DEBUG_CMD, "COMMAND information: Host Port Number 0x%x, " "Command Code 0x%x\n", PktCmdP->PhbNum, PktCmdP->Command);
+                rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Destination 0x%x:0x%x\n", readb(&PacketP->dest_unit), readb(&PacketP->dest_port));
+                rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Source    0x%x:0x%x\n", readb(&PacketP->src_unit), readb(&PacketP->src_port));
+                rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Length    0x%x (%d)\n", readb(&PacketP->len), readb(&PacketP->len));
+                rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Control  0x%x (%d)\n", readb(&PacketP->control), readb(&PacketP->control));
+                rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Check      0x%x (%d)\n", readw(&PacketP->csum), readw(&PacketP->csum));
+                rio_dprintk(RIO_DEBUG_CMD, "COMMAND information: Host Port Number 0x%x, " "Command Code 0x%x\n", readb(&PktCmdP->PhbNum), readb(&PktCmdP->Command));
                 return 1;
         }
         PortP = p->RIOPortp[SysPort];
@@ -601,7 +601,7 @@ int RIOQueueCmdBlk(struct Host *HostP, uint Rup, struct CmdBlk *CmdBlkP)
                 /*
                  ** Whammy! blat that pack!
                  */
-                HostP->Copy((caddr_t) & CmdBlkP->Packet, RIO_PTR(HostP->Caddr, UnixRupP->RupP->txpkt), sizeof(struct PKT));
+                HostP->Copy(&CmdBlkP->Packet, RIO_PTR(HostP->Caddr, readw(&UnixRupP->RupP->txpkt)), sizeof(struct PKT));
 
                 /*
                  ** place command packet on the pending position.
@@ -655,7 +655,7 @@ void RIOPollHostCommands(struct rio_info *p, struct Host *HostP)
 {
         struct CmdBlk *CmdBlkP;
         struct UnixRup *UnixRupP;
-        struct PKT *PacketP;
+        struct PKT __iomem *PacketP;
         unsigned short Rup;
         unsigned long flags;
 
@@ -676,7 +676,7 @@ void RIOPollHostCommands(struct rio_info *p, struct Host *HostP)
                 if (readw(&UnixRupP->RupP->rxcontrol) != RX_RUP_INACTIVE) {
                         int FreeMe;
 
-                        PacketP = (struct PKT *) RIO_PTR(HostP->Caddr, readw(&UnixRupP->RupP->rxpkt));
+                        PacketP = (struct PKT __iomem *) RIO_PTR(HostP->Caddr, readw(&UnixRupP->RupP->rxpkt));
 
                         switch (readb(&PacketP->dest_port)) {
                         case BOOT_RUP:
@@ -694,9 +694,9 @@ void RIOPollHostCommands(struct rio_info *p, struct Host *HostP)
                                  */
                                 rio_spin_unlock_irqrestore(&UnixRupP->RupLock, flags);
                                 FreeMe = RIOCommandRup(p, Rup, HostP, PacketP);
-                                if (PacketP->data[5] == MEMDUMP) {
-                                        rio_dprintk(RIO_DEBUG_CMD, "Memdump from 0x%x complete\n", *(unsigned short *) & (PacketP->data[6]));
-                                        HostP->Copy((caddr_t) & (PacketP->data[8]), (caddr_t) p->RIOMemDump, 32);
+                                if (readb(&PacketP->data[5]) == MEMDUMP) {
+                                        rio_dprintk(RIO_DEBUG_CMD, "Memdump from 0x%x complete\n", readw(&(PacketP->data[6])));
+                                        rio_memcpy_fromio(p->RIOMemDump, &(PacketP->data[8]), 32);
                                 }
                                 rio_spin_lock_irqsave(&UnixRupP->RupLock, flags);
                                 break;
@@ -782,7 +782,7 @@ void RIOPollHostCommands(struct rio_info *p, struct Host *HostP)
                                 /*
                                  ** Whammy! blat that pack!
                                  */
-                                HostP->Copy((caddr_t) & CmdBlkP->Packet, RIO_PTR(HostP->Caddr, UnixRupP->RupP->txpkt), sizeof(struct PKT));
+                                HostP->Copy(&CmdBlkP->Packet, RIO_PTR(HostP->Caddr, readw(&UnixRupP->RupP->txpkt)), sizeof(struct PKT));
 
                                 /*
                                  ** remove the command from the rup command queue...
@@ -824,7 +824,7 @@ int RIOWFlushMark(unsigned long iPortP, struct CmdBlk *CmdBlkP)
 int RIORFlushEnable(unsigned long iPortP, struct CmdBlk *CmdBlkP)
 {
         struct Port *PortP = (struct Port *) iPortP;
-        struct PKT *PacketP;
+        struct PKT __iomem *PacketP;
         unsigned long flags;
 
         rio_spin_lock_irqsave(&PortP->portSem, flags);
diff --git a/drivers/char/rio/rioctrl.c b/drivers/char/rio/rioctrl.c
index 75b2557c37ec..052e8120a471 100644
--- a/drivers/char/rio/rioctrl.c
+++ b/drivers/char/rio/rioctrl.c
@@ -80,7 +80,7 @@ static char *_rioctrl_c_sccs_ = "@(#)rioctrl.c	1.3";
 static struct LpbReq LpbReq;
 static struct RupReq RupReq;
 static struct PortReq PortReq;
-static struct HostReq HostReq;
+static struct HostReq HostReq;  /* oh really?  global?  and no locking? */
 static struct HostDpRam HostDpRam;
 static struct DebugCtrl DebugCtrl;
 static struct Map MapEnt;
@@ -126,12 +126,19 @@ static int
 
 #define drv_makedev(maj, min) ((((uint) maj & 0xff) << 8) | ((uint) min & 0xff))
 
-int riocontrol(p, dev, cmd, arg, su)
-struct rio_info *p;
-dev_t dev;
-int cmd;
-caddr_t arg;
-int su;
+static int copy_from_io(void __user *to, void __iomem *from, size_t size)
+{
+        void *buf = kmalloc(size, GFP_KERNEL);
+        int res = -ENOMEM;
+        if (buf) {
+                rio_memcpy_fromio(buf, from, size);
+                res = copy_to_user(to, buf, size);
+                kfree(buf);
+        }
+        return res;
+}
+
+int riocontrol(struct rio_info *p, dev_t dev, int cmd, unsigned long arg, int su)
 {
         uint Host;              /* leave me unsigned! */
         uint port;              /* and me! */
@@ -139,9 +146,10 @@ int su;
         ushort loop;
         int Entry;
         struct Port *PortP;
-        struct PKT *PacketP;
+        struct PKT __iomem *PacketP;
         int retval = 0;
         unsigned long flags;
+        void __user *argp = (void __user *)arg;
 
         func_enter();
 
@@ -149,7 +157,7 @@ int su;
         Host = 0;
         PortP = NULL;
 
-        rio_dprintk(RIO_DEBUG_CTRL, "control ioctl cmd: 0x%x arg: %p\n", cmd, arg);
+        rio_dprintk(RIO_DEBUG_CTRL, "control ioctl cmd: 0x%x arg: %p\n", cmd, argp);
 
         switch (cmd) {
                 /*
@@ -160,11 +168,11 @@ int su;
                  ** otherwise just the specified host card will be changed.
                  */
         case RIO_SET_TIMER:
-                rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET_TIMER to %ldms\n", (unsigned long)arg);
+                rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET_TIMER to %ldms\n", arg);
                 {
                         int host, value;
-                        host = ((unsigned long) arg >> 16) & 0x0000FFFF;
-                        value = (unsigned long) arg & 0x0000ffff;
+                        host = (arg >> 16) & 0x0000FFFF;
+                        value = arg & 0x0000ffff;
                         if (host == -1) {
                                 for (host = 0; host < p->RIONumHosts; host++) {
                                         if (p->RIOHosts[host].Flags == RC_RUNNING) {
@@ -183,26 +191,26 @@ int su;
 
         case RIO_FOAD_RTA:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_FOAD_RTA\n");
-                return RIOCommandRta(p, (unsigned long)arg, RIOFoadRta);
+                return RIOCommandRta(p, arg, RIOFoadRta);
 
         case RIO_ZOMBIE_RTA:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_ZOMBIE_RTA\n");
-                return RIOCommandRta(p, (unsigned long)arg, RIOZombieRta);
+                return RIOCommandRta(p, arg, RIOZombieRta);
 
         case RIO_IDENTIFY_RTA:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_IDENTIFY_RTA\n");
-                return RIOIdentifyRta(p, arg);
+                return RIOIdentifyRta(p, argp);
 
         case RIO_KILL_NEIGHBOUR:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_KILL_NEIGHBOUR\n");
-                return RIOKillNeighbour(p, arg);
+                return RIOKillNeighbour(p, argp);
 
         case SPECIAL_RUP_CMD:
                 {
                         struct CmdBlk *CmdBlkP;
 
                         rio_dprintk(RIO_DEBUG_CTRL, "SPECIAL_RUP_CMD\n");
-                        if (copy_from_user(&SpecialRupCmd, arg, sizeof(SpecialRupCmd))) {
+                        if (copy_from_user(&SpecialRupCmd, argp, sizeof(SpecialRupCmd))) {
                                 rio_dprintk(RIO_DEBUG_CTRL, "SPECIAL_RUP_CMD copy failed\n");
                                 p->RIOError.Error = COPYIN_FAILED;
                                 return -EFAULT;
@@ -239,7 +247,7 @@ int su;
                 if ((retval = RIOApel(p)) != 0)
                         return retval;
 
-                if (copy_to_user(arg, p->RIOConnectTable, TOTAL_MAP_ENTRIES * sizeof(struct Map))) {
+                if (copy_to_user(argp, p->RIOConnectTable, TOTAL_MAP_ENTRIES * sizeof(struct Map))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_TABLE copy failed\n");
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -284,7 +292,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copy_from_user(&p->RIOConnectTable[0], arg, TOTAL_MAP_ENTRIES * sizeof(struct Map))) {
+                if (copy_from_user(&p->RIOConnectTable[0], argp, TOTAL_MAP_ENTRIES * sizeof(struct Map))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_PUT_TABLE copy failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -330,7 +338,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copy_to_user(arg, p->RIOBindTab, (sizeof(ulong) * MAX_RTA_BINDINGS))) {
+                if (copy_to_user(argp, p->RIOBindTab, (sizeof(ulong) * MAX_RTA_BINDINGS))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_BINDINGS copy failed\n");
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -349,7 +357,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copy_from_user(&p->RIOBindTab[0], arg, (sizeof(ulong) * MAX_RTA_BINDINGS))) {
+                if (copy_from_user(&p->RIOBindTab[0], argp, (sizeof(ulong) * MAX_RTA_BINDINGS))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_PUT_BINDINGS copy failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -373,12 +381,12 @@ int su;
                         for (Entry = 0; Entry < MAX_RTA_BINDINGS; Entry++) {
                                 if ((EmptySlot == -1) && (p->RIOBindTab[Entry] == 0L))
                                         EmptySlot = Entry;
-                                else if (p->RIOBindTab[Entry] == (long)arg) {
+                                else if (p->RIOBindTab[Entry] == arg) {
                                         /*
                                          ** Already exists - delete
                                          */
                                         p->RIOBindTab[Entry] = 0L;
-                                        rio_dprintk(RIO_DEBUG_CTRL, "Removing Rta %ld from p->RIOBindTab\n", (unsigned long)arg);
+                                        rio_dprintk(RIO_DEBUG_CTRL, "Removing Rta %ld from p->RIOBindTab\n", arg);
                                         return 0;
                                 }
                         }
@@ -386,10 +394,10 @@ int su;
                          ** Dosen't exist - add
                          */
                         if (EmptySlot != -1) {
-                                p->RIOBindTab[EmptySlot] = (unsigned long)arg;
-                                rio_dprintk(RIO_DEBUG_CTRL, "Adding Rta %lx to p->RIOBindTab\n", (unsigned long) arg);
+                                p->RIOBindTab[EmptySlot] = arg;
+                                rio_dprintk(RIO_DEBUG_CTRL, "Adding Rta %lx to p->RIOBindTab\n", arg);
                         } else {
-                                rio_dprintk(RIO_DEBUG_CTRL, "p->RIOBindTab full! - Rta %lx not added\n", (unsigned long) arg);
+                                rio_dprintk(RIO_DEBUG_CTRL, "p->RIOBindTab full! - Rta %lx not added\n", arg);
                                 return -ENOMEM;
                         }
                         return 0;
@@ -397,7 +405,7 @@ int su;
 
         case RIO_RESUME:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_RESUME\n");
-                port = (unsigned long) arg;
+                port = arg;
                 if ((port < 0) || (port > 511)) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_RESUME: Bad port number %d\n", port);
                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
@@ -433,7 +441,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copy_from_user(&MapEnt, arg, sizeof(MapEnt))) {
+                if (copy_from_user(&MapEnt, argp, sizeof(MapEnt))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "Copy from user space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -447,7 +455,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copy_from_user(&MapEnt, arg, sizeof(MapEnt))) {
+                if (copy_from_user(&MapEnt, argp, sizeof(MapEnt))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "Copy from user space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -461,7 +469,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copy_from_user(&MapEnt, arg, sizeof(MapEnt))) {
+                if (copy_from_user(&MapEnt, argp, sizeof(MapEnt))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "Copy from data space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -469,14 +477,14 @@ int su;
                 return RIODeleteRta(p, &MapEnt);
 
         case RIO_QUICK_CHECK:
-                if (copy_to_user(arg, &p->RIORtaDisCons, sizeof(unsigned int))) {
+                if (copy_to_user(argp, &p->RIORtaDisCons, sizeof(unsigned int))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
                 return 0;
 
         case RIO_LAST_ERROR:
-                if (copy_to_user(arg, &p->RIOError, sizeof(struct Error)))
+                if (copy_to_user(argp, &p->RIOError, sizeof(struct Error)))
                         return -EFAULT;
                 return 0;
 
@@ -485,7 +493,7 @@ int su;
                 return -EINVAL;
 
         case RIO_GET_MODTYPE:
-                if (copy_from_user(&port, arg, sizeof(unsigned int))) {
+                if (copy_from_user(&port, argp, sizeof(unsigned int))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -505,7 +513,7 @@ int su;
                  ** Return module type of port
                  */
                 port = PortP->HostP->UnixRups[PortP->RupNum].ModTypes;
-                if (copy_to_user(arg, &port, sizeof(unsigned int))) {
+                if (copy_to_user(argp, &port, sizeof(unsigned int))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
@@ -521,7 +529,7 @@ int su;
 
         case RIO_SETUP_PORTS:
                 rio_dprintk(RIO_DEBUG_CTRL, "Setup ports\n");
-                if (copy_from_user(&PortSetup, arg, sizeof(PortSetup))) {
+                if (copy_from_user(&PortSetup, argp, sizeof(PortSetup))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         rio_dprintk(RIO_DEBUG_CTRL, "EFAULT");
                         return -EFAULT;
@@ -551,7 +559,7 @@ int su;
 
         case RIO_GET_PORT_SETUP:
                 rio_dprintk(RIO_DEBUG_CTRL, "Get port setup\n");
-                if (copy_from_user(&PortSetup, arg, sizeof(PortSetup))) {
+                if (copy_from_user(&PortSetup, argp, sizeof(PortSetup))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -572,7 +580,7 @@ int su;
                 PortSetup.XpOn[MAX_XP_CTRL_LEN - 1] = '\0';
                 PortSetup.XpOff[MAX_XP_CTRL_LEN - 1] = '\0';
 
-                if (copy_to_user(arg, &PortSetup, sizeof(PortSetup))) {
+                if (copy_to_user(argp, &PortSetup, sizeof(PortSetup))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
@@ -580,7 +588,7 @@ int su;
 
         case RIO_GET_PORT_PARAMS:
                 rio_dprintk(RIO_DEBUG_CTRL, "Get port params\n");
-                if (copy_from_user(&PortParams, arg, sizeof(struct PortParams))) {
+                if (copy_from_user(&PortParams, argp, sizeof(struct PortParams))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -593,7 +601,7 @@ int su;
                 PortParams.State = PortP->State;
                 rio_dprintk(RIO_DEBUG_CTRL, "Port %d\n", PortParams.Port);
 
-                if (copy_to_user(arg, &PortParams, sizeof(struct PortParams))) {
+                if (copy_to_user(argp, &PortParams, sizeof(struct PortParams))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
@@ -601,7 +609,7 @@ int su;
 
         case RIO_GET_PORT_TTY:
                 rio_dprintk(RIO_DEBUG_CTRL, "Get port tty\n");
-                if (copy_from_user(&PortTty, arg, sizeof(struct PortTty))) {
+                if (copy_from_user(&PortTty, argp, sizeof(struct PortTty))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -612,14 +620,14 @@ int su;
 
                 rio_dprintk(RIO_DEBUG_CTRL, "Port %d\n", PortTty.port);
                 PortP = (p->RIOPortp[PortTty.port]);
-                if (copy_to_user(arg, &PortTty, sizeof(struct PortTty))) {
+                if (copy_to_user(argp, &PortTty, sizeof(struct PortTty))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
                 return retval;
 
         case RIO_SET_PORT_TTY:
-                if (copy_from_user(&PortTty, arg, sizeof(struct PortTty))) {
+                if (copy_from_user(&PortTty, argp, sizeof(struct PortTty))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -634,7 +642,7 @@ int su;
 
         case RIO_SET_PORT_PARAMS:
                 rio_dprintk(RIO_DEBUG_CTRL, "Set port params\n");
-                if (copy_from_user(&PortParams, arg, sizeof(PortParams))) {
+                if (copy_from_user(&PortParams, argp, sizeof(PortParams))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -650,7 +658,7 @@ int su;
 
         case RIO_GET_PORT_STATS:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_PORT_STATS\n");
-                if (copy_from_user(&portStats, arg, sizeof(struct portStats))) {
+                if (copy_from_user(&portStats, argp, sizeof(struct portStats))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -665,14 +673,14 @@ int su;
                 portStats.opens = PortP->opens;
                 portStats.closes = PortP->closes;
                 portStats.ioctls = PortP->ioctls;
-                if (copy_to_user(arg, &portStats, sizeof(struct portStats))) {
+                if (copy_to_user(argp, &portStats, sizeof(struct portStats))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
                 return retval;
 
         case RIO_RESET_PORT_STATS:
-                port = (unsigned long) arg;
+                port = arg;
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_RESET_PORT_STATS\n");
                 if (port >= RIO_PORTS) {
                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
@@ -690,7 +698,7 @@ int su;
 
         case RIO_GATHER_PORT_STATS:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_GATHER_PORT_STATS\n");
-                if (copy_from_user(&portStats, arg, sizeof(struct portStats))) {
+                if (copy_from_user(&portStats, argp, sizeof(struct portStats))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -706,7 +714,7 @@ int su;
 
         case RIO_READ_CONFIG:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_READ_CONFIG\n");
-                if (copy_to_user(arg, &p->RIOConf, sizeof(struct Conf))) {
+                if (copy_to_user(argp, &p->RIOConf, sizeof(struct Conf))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
@@ -718,7 +726,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copy_from_user(&p->RIOConf, arg, sizeof(struct Conf))) {
+                if (copy_from_user(&p->RIOConf, argp, sizeof(struct Conf))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -746,7 +754,7 @@ int su;
         case RIO_SETDEBUG:
         case RIO_GETDEBUG:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_SETDEBUG/RIO_GETDEBUG\n");
-                if (copy_from_user(&DebugCtrl, arg, sizeof(DebugCtrl))) {
+                if (copy_from_user(&DebugCtrl, argp, sizeof(DebugCtrl))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -763,7 +771,7 @@ int su;
                                 rio_dprintk(RIO_DEBUG_CTRL, "Get global debug 0x%x wait 0x%x\n", p->rio_debug, p->RIODebugWait);
                                 DebugCtrl.Debug = p->rio_debug;
                                 DebugCtrl.Wait = p->RIODebugWait;
-                                if (copy_to_user(arg, &DebugCtrl, sizeof(DebugCtrl))) {
+                                if (copy_to_user(argp, &DebugCtrl, sizeof(DebugCtrl))) {
                                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET/GET DEBUG: bad port number %d\n", DebugCtrl.SysPort);
                                         p->RIOError.Error = COPYOUT_FAILED;
                                         return -EFAULT;
@@ -785,7 +793,7 @@ int su;
                 } else {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_GETDEBUG 0x%x\n", p->RIOPortp[DebugCtrl.SysPort]->Debug);
                         DebugCtrl.Debug = p->RIOPortp[DebugCtrl.SysPort]->Debug;
-                        if (copy_to_user(arg, &DebugCtrl, sizeof(DebugCtrl))) {
+                        if (copy_to_user(argp, &DebugCtrl, sizeof(DebugCtrl))) {
                                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_GETDEBUG: Bad copy to user space\n");
                                 p->RIOError.Error = COPYOUT_FAILED;
                                 return -EFAULT;
@@ -800,7 +808,7 @@ int su;
                  ** textual null terminated string.
                  */
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_VERSID\n");
-                if (copy_to_user(arg, RIOVersid(), sizeof(struct rioVersion))) {
+                if (copy_to_user(argp, RIOVersid(), sizeof(struct rioVersion))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_VERSID: Bad copy to user space (host=%d)\n", Host);
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -813,7 +821,7 @@ int su;
                  ** at init time.
                  */
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_NUM_HOSTS\n");
-                if (copy_to_user(arg, &p->RIONumHosts, sizeof(p->RIONumHosts))) {
+                if (copy_to_user(argp, &p->RIONumHosts, sizeof(p->RIONumHosts))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_NUM_HOSTS: Bad copy to user space\n");
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -824,7 +832,7 @@ int su;
                 /*
                  ** Kill host. This may not be in the final version...
                  */
-                rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_FOAD %ld\n", (unsigned long) arg);
+                rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_FOAD %ld\n", arg);
                 if (!su) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_FOAD: Not super user\n");
                         p->RIOError.Error = NOT_SUPER_USER;
@@ -858,7 +866,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copy_from_user(&DownLoad, arg, sizeof(DownLoad))) {
+                if (copy_from_user(&DownLoad, argp, sizeof(DownLoad))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_DOWNLOAD: Copy in from user space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -888,7 +896,7 @@ int su;
                 {
                         unsigned int host;
 
-                        if (copy_from_user(&host, arg, sizeof(host))) {
+                        if (copy_from_user(&host, argp, sizeof(host))) {
                                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_REQ: Copy in from user space failed\n");
                                 p->RIOError.Error = COPYIN_FAILED;
                                 return -EFAULT;
@@ -897,7 +905,7 @@ int su;
                          ** Fetch the parmmap
                          */
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_PARMS\n");
-                        if (copy_to_user(arg, p->RIOHosts[host].ParmMapP, sizeof(PARM_MAP))) {
+                        if (copy_from_io(argp, p->RIOHosts[host].ParmMapP, sizeof(PARM_MAP))) {
                                 p->RIOError.Error = COPYOUT_FAILED;
                                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_PARMS: Copy out to user space failed\n");
                                 return -EFAULT;
@@ -907,7 +915,7 @@ int su;
 
         case RIO_HOST_REQ:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_REQ\n");
-                if (copy_from_user(&HostReq, arg, sizeof(HostReq))) {
+                if (copy_from_user(&HostReq, argp, sizeof(HostReq))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_REQ: Copy in from user space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -928,7 +936,7 @@ int su;
 
         case RIO_HOST_DPRAM:
                 rio_dprintk(RIO_DEBUG_CTRL, "Request for DPRAM\n");
-                if (copy_from_user(&HostDpRam, arg, sizeof(HostDpRam))) {
+                if (copy_from_user(&HostDpRam, argp, sizeof(HostDpRam))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_DPRAM: Copy in from user space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -945,13 +953,13 @@ int su;
                         /* It's hardware like this that really gets on my tits. */
                         static unsigned char copy[sizeof(struct DpRam)];
                         for (off = 0; off < sizeof(struct DpRam); off++)
-                                copy[off] = readb(&p->RIOHosts[HostDpRam.HostNum].Caddr[off]);
+                                copy[off] = readb(p->RIOHosts[HostDpRam.HostNum].Caddr + off);
                         if (copy_to_user(HostDpRam.DpRamP, copy, sizeof(struct DpRam))) {
                                 p->RIOError.Error = COPYOUT_FAILED;
                                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_DPRAM: Bad copy to user space\n");
                                 return -EFAULT;
                         }
-                } else if (copy_to_user(HostDpRam.DpRamP, p->RIOHosts[HostDpRam.HostNum].Caddr, sizeof(struct DpRam))) {
+                } else if (copy_from_io(HostDpRam.DpRamP, p->RIOHosts[HostDpRam.HostNum].Caddr, sizeof(struct DpRam))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_DPRAM: Bad copy to user space\n");
                         return -EFAULT;
@@ -960,13 +968,13 @@ int su;
 
         case RIO_SET_BUSY:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET_BUSY\n");
-                if ((unsigned long) arg > 511) {
-                        rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET_BUSY: Bad port number %ld\n", (unsigned long) arg);
+                if (arg > 511) {
+                        rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET_BUSY: Bad port number %ld\n", arg);
                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
                         return -EINVAL;
                 }
                 rio_spin_lock_irqsave(&PortP->portSem, flags);
-                p->RIOPortp[(unsigned long) arg]->State |= RIO_BUSY;
+                p->RIOPortp[arg]->State |= RIO_BUSY;
                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                 return retval;
 
@@ -976,7 +984,7 @@ int su;
                  ** (probably for debug reasons)
                  */
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_PORT\n");
-                if (copy_from_user(&PortReq, arg, sizeof(PortReq))) {
+                if (copy_from_user(&PortReq, argp, sizeof(PortReq))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_PORT: Copy in from user space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -1001,7 +1009,7 @@ int su;
                  ** (probably for debug reasons)
                  */
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_RUP\n");
-                if (copy_from_user(&RupReq, arg, sizeof(RupReq))) {
+                if (copy_from_user(&RupReq, argp, sizeof(RupReq))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_RUP: Copy in from user space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -1025,7 +1033,7 @@ int su;
                 }
                 rio_dprintk(RIO_DEBUG_CTRL, "Request for rup %d from host %d\n", RupReq.RupNum, RupReq.HostNum);
 
-                if (copy_to_user(HostP->UnixRups[RupReq.RupNum].RupP, RupReq.RupP, sizeof(struct RUP))) {
+                if (copy_from_io(RupReq.RupP, HostP->UnixRups[RupReq.RupNum].RupP, sizeof(struct RUP))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_RUP: Bad copy to user space\n");
                         return -EFAULT;
@@ -1038,7 +1046,7 @@ int su;
                  ** (probably for debug reasons)
                  */
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_LPB\n");
-                if (copy_from_user(&LpbReq, arg, sizeof(LpbReq))) {
+                if (copy_from_user(&LpbReq, argp, sizeof(LpbReq))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_LPB: Bad copy from user space\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -1062,7 +1070,7 @@ int su;
                 }
                 rio_dprintk(RIO_DEBUG_CTRL, "Request for lpb %d from host %d\n", LpbReq.Link, LpbReq.Host);
 
-                if (copy_to_user(LpbReq.LpbP, &HostP->LinkStrP[LpbReq.Link], sizeof(struct LPB))) {
+                if (copy_from_io(LpbReq.LpbP, &HostP->LinkStrP[LpbReq.Link], sizeof(struct LPB))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_LPB: Bad copy to user space\n");
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -1136,7 +1144,7 @@ int su;
         case RIO_MAP_B110_TO_110:
         case RIO_MAP_B110_TO_115200:
                 rio_dprintk(RIO_DEBUG_CTRL, "Baud rate mapping\n");
-                port = (unsigned long) arg;
+                port = arg;
                 if (port < 0 || port > 511) {
                         rio_dprintk(RIO_DEBUG_CTRL, "Baud rate mapping: Bad port number %d\n", port);
                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
@@ -1166,7 +1174,7 @@ int su;
 
         case RIO_SEND_PACKET:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_SEND_PACKET\n");
-                if (copy_from_user(&SendPack, arg, sizeof(SendPack))) {
+                if (copy_from_user(&SendPack, argp, sizeof(SendPack))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_SEND_PACKET: Bad copy from user space\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -1210,7 +1218,7 @@ int su;
                 return su ? 0 : -EPERM;
 
         case RIO_WHAT_MESG:
-                if (copy_to_user(arg, &p->RIONoMessage, sizeof(p->RIONoMessage))) {
+                if (copy_to_user(argp, &p->RIONoMessage, sizeof(p->RIONoMessage))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_WHAT_MESG: Bad copy to user space\n");
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -1218,7 +1226,7 @@ int su;
                 return 0;
 
         case RIO_MEM_DUMP:
-                if (copy_from_user(&SubCmd, arg, sizeof(struct SubCmdStruct))) {
+                if (copy_from_user(&SubCmd, argp, sizeof(struct SubCmdStruct))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -1248,7 +1256,7 @@ int su;
                         PortP->State |= RIO_BUSY;
 
                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                if (copy_to_user(arg, p->RIOMemDump, MEMDUMP_SIZE)) {
+                if (copy_to_user(argp, p->RIOMemDump, MEMDUMP_SIZE)) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_MEM_DUMP copy failed\n");
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -1256,30 +1264,30 @@ int su;
                 return 0;
 
         case RIO_TICK:
-                if ((unsigned long) arg >= p->RIONumHosts)
+                if (arg >= p->RIONumHosts)
                         return -EINVAL;
-                rio_dprintk(RIO_DEBUG_CTRL, "Set interrupt for host %ld\n", (unsigned long) arg);
-                writeb(0xFF, &p->RIOHosts[(unsigned long) arg].SetInt);
+                rio_dprintk(RIO_DEBUG_CTRL, "Set interrupt for host %ld\n", arg);
+                writeb(0xFF, &p->RIOHosts[arg].SetInt);
                 return 0;
 
         case RIO_TOCK:
-                if ((unsigned long) arg >= p->RIONumHosts)
+                if (arg >= p->RIONumHosts)
                         return -EINVAL;
-                rio_dprintk(RIO_DEBUG_CTRL, "Clear interrupt for host %ld\n", (unsigned long) arg);
-                writeb(0xFF, &p->RIOHosts[(unsigned long) arg].ResetInt);
+                rio_dprintk(RIO_DEBUG_CTRL, "Clear interrupt for host %ld\n", arg);
+                writeb(0xFF, &p->RIOHosts[arg].ResetInt);
                 return 0;
 
         case RIO_READ_CHECK:
                 /* Check reads for pkts with data[0] the same */
                 p->RIOReadCheck = !p->RIOReadCheck;
-                if (copy_to_user(arg, &p->RIOReadCheck, sizeof(unsigned int))) {
+                if (copy_to_user(argp, &p->RIOReadCheck, sizeof(unsigned int))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
                 return 0;
 
         case RIO_READ_REGISTER:
-                if (copy_from_user(&SubCmd, arg, sizeof(struct SubCmdStruct))) {
+                if (copy_from_user(&SubCmd, argp, sizeof(struct SubCmdStruct))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -1314,7 +1322,7 @@ int su;
                         PortP->State |= RIO_BUSY;
 
                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                if (copy_to_user(arg, &p->CdRegister, sizeof(unsigned int))) {
+                if (copy_to_user(argp, &p->CdRegister, sizeof(unsigned int))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_READ_REGISTER copy failed\n");
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -1327,10 +1335,10 @@ int su;
                  */
         case RIO_MAKE_DEV:
                 {
-                        unsigned int port = (unsigned long) arg & RIO_MODEM_MASK;
+                        unsigned int port = arg & RIO_MODEM_MASK;
                         unsigned int ret;
 
-                        switch ((unsigned long) arg & RIO_DEV_MASK) {
+                        switch (arg & RIO_DEV_MASK) {
                         case RIO_DEV_DIRECT:
                                 ret = drv_makedev(MAJOR(dev), port);
                                 rio_dprintk(RIO_DEBUG_CTRL, "Makedev direct 0x%x is 0x%x\n", port, ret);
@@ -1358,7 +1366,7 @@ int su;
                         int mino;
                         unsigned long ret;
 
-                        dv = (dev_t) ((unsigned long) arg);
+                        dv = (dev_t) (arg);
                         mino = RIO_UNMODEM(dv);
 
                         if (RIO_ISMODEM(dv)) {
diff --git a/drivers/char/rio/rioinit.c b/drivers/char/rio/rioinit.c
index 24d2992154cc..12e34bc3f7ce 100644
--- a/drivers/char/rio/rioinit.c
+++ b/drivers/char/rio/rioinit.c
@@ -79,7 +79,7 @@ static char *_rioinit_c_sccs_ = "@(#)rioinit.c	1.3";
 
 int RIOPCIinit(struct rio_info *p, int Mode);
 
-static int RIOScrub(int, u8 *, int);
+static int RIOScrub(int, u8 __iomem *, int);
 
 
 /**
@@ -92,10 +92,10 @@ static int RIOScrub(int, u8 *, int);
 ** bits > 0 indicates 16 bit operation.
 */
 
-int RIOAssignAT(struct rio_info *p, int Base, caddr_t   virtAddr, int mode)
+int RIOAssignAT(struct rio_info *p, int Base, void __iomem *virtAddr, int mode)
 {
         int             bits;
-        struct DpRam *cardp = (struct DpRam *)virtAddr;
+        struct DpRam __iomem *cardp = (struct DpRam __iomem *)virtAddr;
 
         if ((Base < ONE_MEG) || (mode & BYTE_ACCESS_MODE))
                 bits = BYTE_OPERATION;
@@ -107,7 +107,7 @@ int RIOAssignAT(struct rio_info *p, int	Base, caddr_t	virtAddr, int mode)
         ** transient stuff.
         */
         p->RIOHosts[p->RIONumHosts].Caddr       = virtAddr;
-        p->RIOHosts[p->RIONumHosts].CardP       = (struct DpRam *)virtAddr;
+        p->RIOHosts[p->RIONumHosts].CardP       = virtAddr;
 
         /*
         ** Revision 01 AT host cards don't support WORD operations,
@@ -151,10 +151,10 @@ static	u8	val[] = {
 ** RAM test a board. 
 ** Nothing too complicated, just enough to check it out.
 */
-int RIOBoardTest(unsigned long paddr, caddr_t   caddr, unsigned char type, int slot)
+int RIOBoardTest(unsigned long paddr, void __iomem *caddr, unsigned char type, int slot)
 {
-        struct DpRam *DpRam = (struct DpRam *)caddr;
-        char *ram[4];
+        struct DpRam __iomem *DpRam = caddr;
+        void __iomem *ram[4];
         int  size[4];
         int  op, bank;
         int  nbanks;
@@ -179,12 +179,12 @@ int RIOBoardTest(unsigned long paddr, caddr_t	caddr, unsigned char type, int slo
         size[2] = DP_SRAM3_SIZE;
         size[3] = DP_SCRATCH_SIZE;
 
-        ram[0] = (char *)&DpRam->DpSram1[0];
-        ram[1] = (char *)&DpRam->DpSram2[0];
-        ram[2] = (char *)&DpRam->DpSram3[0];
+        ram[0] = DpRam->DpSram1;
+        ram[1] = DpRam->DpSram2;
+        ram[2] = DpRam->DpSram3;
         nbanks = (type == RIO_PCI) ? 3 : 4;
         if (nbanks == 4)
-                ram[3] = (char *)&DpRam->DpScratch[0];
+                ram[3] = DpRam->DpScratch;
 
 
         if (nbanks == 3) {
@@ -202,7 +202,7 @@ int RIOBoardTest(unsigned long paddr, caddr_t	caddr, unsigned char type, int slo
         */
         for (op=0; op<TEST_END; op++) {
                 for (bank=0; bank<nbanks; bank++) {
-                        if (RIOScrub(op, (u8 *)ram[bank], size[bank]) == RIO_FAIL) {
+                        if (RIOScrub(op, ram[bank], size[bank]) == RIO_FAIL) {
                                 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: RIOScrub band %d, op %d failed\n", 
                                                         bank, op);
                                 return RIO_FAIL;
@@ -227,7 +227,7 @@ int RIOBoardTest(unsigned long paddr, caddr_t	caddr, unsigned char type, int slo
 ** to check that the data from the previous phase was retained.
 */
 
-static int RIOScrub(int op, u8 *ram, int size)
+static int RIOScrub(int op, u8 __iomem *ram, int size)
 {
         int off;
         unsigned char   oldbyte;
@@ -393,7 +393,7 @@ struct rioVersion *RIOVersid(void)
     return &stVersion;
 }
 
-void RIOHostReset(unsigned int Type, struct DpRam *DpRamP, unsigned int Slot)
+void RIOHostReset(unsigned int Type, struct DpRam __iomem *DpRamP, unsigned int Slot)
 {
         /*
         ** Reset the Tpu
diff --git a/drivers/char/rio/riointr.c b/drivers/char/rio/riointr.c
index 97f0fa550652..eec1fea0cb92 100644
--- a/drivers/char/rio/riointr.c
+++ b/drivers/char/rio/riointr.c
@@ -102,7 +102,7 @@ void RIOTxEnable(char *en)
         struct rio_info *p;
         struct tty_struct *tty;
         int c;
-        struct PKT *PacketP;
+        struct PKT __iomem *PacketP;
         unsigned long flags;
 
         PortP = (struct Port *) en;
@@ -144,7 +144,7 @@ void RIOTxEnable(char *en)
                 if (c == 0)
                         break;
 
-                rio_memcpy_toio(PortP->HostP->Caddr, (caddr_t) PacketP->data, PortP->gs.xmit_buf + PortP->gs.xmit_tail, c);
+                rio_memcpy_toio(PortP->HostP->Caddr, PacketP->data, PortP->gs.xmit_buf + PortP->gs.xmit_tail, c);
                 /*    udelay (1); */
 
                 writeb(c, &(PacketP->len));
@@ -219,7 +219,7 @@ void RIOServiceHost(struct rio_info *p, struct Host *HostP, int From)
                 for (port = p->RIOFirstPortsBooted; port < p->RIOLastPortsBooted + PORTS_PER_RTA; port++) {
                         struct Port *PortP = p->RIOPortp[port];
                         struct tty_struct *ttyP;
-                        struct PKT *PacketP;
+                        struct PKT __iomem *PacketP;
 
                         /*
                          ** not mapped in - most of the RIOPortp[] information
@@ -298,7 +298,7 @@ void RIOServiceHost(struct rio_info *p, struct Host *HostP, int From)
                 for (port = p->RIOFirstPortsBooted; port < p->RIOLastPortsBooted + PORTS_PER_RTA; port++) {
                         struct Port *PortP = p->RIOPortp[port];
                         struct tty_struct *ttyP;
-                        struct PKT *PacketP;
+                        struct PKT __iomem *PacketP;
 
                         /*
                          ** not mapped in - most of the RIOPortp[] information
@@ -427,13 +427,13 @@ void RIOServiceHost(struct rio_info *p, struct Host *HostP, int From)
 
                                 while (PortP->WflushFlag && can_add_transmit(&PacketP, PortP) && (PortP->InUse == NOT_INUSE)) {
                                         int p;
-                                        struct PktCmd *PktCmdP;
+                                        struct PktCmd __iomem *PktCmdP;
 
                                         rio_dprintk(RIO_DEBUG_INTR, "Add WFLUSH marker to data queue\n");
                                         /*
                                          ** make it look just like a WFLUSH command
                                          */
-                                        PktCmdP = (struct PktCmd *) &PacketP->data[0];
+                                        PktCmdP = (struct PktCmd __iomem *) &PacketP->data[0];
 
                                         writeb(WFLUSH, &PktCmdP->Command);
 
@@ -525,9 +525,9 @@ static void RIOReceive(struct rio_info *p, struct Port *PortP)
 {
         struct tty_struct *TtyP;
         unsigned short transCount;
-        struct PKT *PacketP;
+        struct PKT __iomem *PacketP;
         register unsigned int DataCnt;
-        unsigned char *ptr;
+        unsigned char __iomem *ptr;
         unsigned char *buf;
         int copied = 0;
 
@@ -585,19 +585,19 @@ static void RIOReceive(struct rio_info *p, struct Port *PortP)
                         /*
                          ** check that it is not a command!
                          */
-                        if (PacketP->len & PKT_CMD_BIT) {
+                        if (readb(&PacketP->len) & PKT_CMD_BIT) {
                                 rio_dprintk(RIO_DEBUG_INTR, "RIO: unexpected command packet received on PHB\n");
                                 /*      rio_dprint(RIO_DEBUG_INTR, (" sysport   = %d\n", p->RIOPortp->PortNum)); */
-                                rio_dprintk(RIO_DEBUG_INTR, " dest_unit = %d\n", PacketP->dest_unit);
-                                rio_dprintk(RIO_DEBUG_INTR, " dest_port = %d\n", PacketP->dest_port);
-                                rio_dprintk(RIO_DEBUG_INTR, " src_unit  = %d\n", PacketP->src_unit);
-                                rio_dprintk(RIO_DEBUG_INTR, " src_port  = %d\n", PacketP->src_port);
-                                rio_dprintk(RIO_DEBUG_INTR, " len          = %d\n", PacketP->len);
-                                rio_dprintk(RIO_DEBUG_INTR, " control   = %d\n", PacketP->control);
-                                rio_dprintk(RIO_DEBUG_INTR, " csum         = %d\n", PacketP->csum);
+                                rio_dprintk(RIO_DEBUG_INTR, " dest_unit = %d\n", readb(&PacketP->dest_unit));
+                                rio_dprintk(RIO_DEBUG_INTR, " dest_port = %d\n", readb(&PacketP->dest_port));
+                                rio_dprintk(RIO_DEBUG_INTR, " src_unit  = %d\n", readb(&PacketP->src_unit));
+                                rio_dprintk(RIO_DEBUG_INTR, " src_port  = %d\n", readb(&PacketP->src_port));
+                                rio_dprintk(RIO_DEBUG_INTR, " len          = %d\n", readb(&PacketP->len));
+                                rio_dprintk(RIO_DEBUG_INTR, " control   = %d\n", readb(&PacketP->control));
+                                rio_dprintk(RIO_DEBUG_INTR, " csum         = %d\n", readw(&PacketP->csum));
                                 rio_dprintk(RIO_DEBUG_INTR, "    data bytes: ");
                                 for (DataCnt = 0; DataCnt < PKT_MAX_DATA_LEN; DataCnt++)
-                                        rio_dprintk(RIO_DEBUG_INTR, "%d\n", PacketP->data[DataCnt]);
+                                        rio_dprintk(RIO_DEBUG_INTR, "%d\n", readb(&PacketP->data[DataCnt]));
                                 remove_receive(PortP);
                                 put_free_end(PortP->HostP, PacketP);
                                 continue;       /* with next packet */
@@ -618,24 +618,24 @@ static void RIOReceive(struct rio_info *p, struct Port *PortP)
                          ** and available space.
                          */
 
-                        transCount = tty_buffer_request_room(TtyP, PacketP->len & PKT_LEN_MASK);
+                        transCount = tty_buffer_request_room(TtyP, readb(&PacketP->len) & PKT_LEN_MASK);
                         rio_dprintk(RIO_DEBUG_REC, "port %d: Copy %d bytes\n", PortP->PortNum, transCount);
                         /*
                          ** To use the following 'kkprintfs' for debugging - change the '#undef'
                          ** to '#define', (this is the only place ___DEBUG_IT___ occurs in the
                          ** driver).
                          */
-                        ptr = (unsigned char *) PacketP->data + PortP->RxDataStart;
+                        ptr = (unsigned char __iomem *) PacketP->data + PortP->RxDataStart;
 
                         tty_prepare_flip_string(TtyP, &buf, transCount);
                         rio_memcpy_fromio(buf, ptr, transCount);
                         PortP->RxDataStart += transCount;
-                        PacketP->len -= transCount;
+                        writeb(readb(&PacketP->len)-transCount, &PacketP->len);
                         copied += transCount;
 
 
 
-                        if (PacketP->len == 0) {
+                        if (readb(&PacketP->len) == 0) {
                                 /*
                                  ** If we have emptied the packet, then we can
                                  ** free it, and reset the start pointer for
diff --git a/drivers/char/rio/rioparam.c b/drivers/char/rio/rioparam.c
index d2e8092cdb29..1066d9760704 100644
--- a/drivers/char/rio/rioparam.c
+++ b/drivers/char/rio/rioparam.c
@@ -154,8 +154,8 @@ int RIOParam(struct Port *PortP, int cmd, int Modem, int SleepFlag)
 {
         struct tty_struct *TtyP;
         int retval;
-        struct phb_param *phb_param_ptr;
-        struct PKT *PacketP;
+        struct phb_param __iomem *phb_param_ptr;
+        struct PKT __iomem *PacketP;
         int res;
         u8 Cor1 = 0, Cor2 = 0, Cor4 = 0, Cor5 = 0;
         u8 TxXon = 0, TxXoff = 0, RxXon = 0, RxXoff = 0;
@@ -235,7 +235,7 @@ int RIOParam(struct Port *PortP, int cmd, int Modem, int SleepFlag)
         rio_dprintk(RIO_DEBUG_PARAM, "can_add_transmit() returns %x\n", res);
         rio_dprintk(RIO_DEBUG_PARAM, "Packet is %p\n", PacketP);
 
-        phb_param_ptr = (struct phb_param *) PacketP->data;
+        phb_param_ptr = (struct phb_param __iomem *) PacketP->data;
 
 
         switch (TtyP->termios->c_cflag & CSIZE) {
@@ -580,11 +580,11 @@ int RIOParam(struct Port *PortP, int cmd, int Modem, int SleepFlag)
 ** We can add another packet to a transmit queue if the packet pointer pointed
 ** to by the TxAdd pointer has PKT_IN_USE clear in its address.
 */
-int can_add_transmit(struct PKT **PktP, struct Port *PortP)
+int can_add_transmit(struct PKT __iomem **PktP, struct Port *PortP)
 {
-        struct PKT *tp;
+        struct PKT __iomem *tp;
 
-        *PktP = tp = (struct PKT *) RIO_PTR(PortP->Caddr, readw(PortP->TxAdd));
+        *PktP = tp = (struct PKT __iomem *) RIO_PTR(PortP->Caddr, readw(PortP->TxAdd));
 
         return !((unsigned long) tp & PKT_IN_USE);
 }
@@ -608,9 +608,9 @@ void add_transmit(struct Port *PortP)
  * Put a packet onto the end of the
  * free list
  ****************************************/
-void put_free_end(struct Host *HostP, struct PKT *PktP)
+void put_free_end(struct Host *HostP, struct PKT __iomem *PktP)
 {
-        struct rio_free_list *tmp_pointer;
+        struct rio_free_list __iomem *tmp_pointer;
         unsigned short old_end, new_end;
         unsigned long flags;
 
@@ -625,15 +625,15 @@ void put_free_end(struct Host *HostP, struct PKT *PktP)
 
         if ((old_end = readw(&HostP->ParmMapP->free_list_end)) != TPNULL) {
                 new_end = RIO_OFF(HostP->Caddr, PktP);
-                tmp_pointer = (struct rio_free_list *) RIO_PTR(HostP->Caddr, old_end);
+                tmp_pointer = (struct rio_free_list __iomem *) RIO_PTR(HostP->Caddr, old_end);
                 writew(new_end, &tmp_pointer->next);
-                writew(old_end, &((struct rio_free_list *) PktP)->prev);
-                writew(TPNULL, &((struct rio_free_list *) PktP)->next);
+                writew(old_end, &((struct rio_free_list __iomem *) PktP)->prev);
+                writew(TPNULL, &((struct rio_free_list __iomem *) PktP)->next);
                 writew(new_end, &HostP->ParmMapP->free_list_end);
         } else {                /* First packet on the free list this should never happen! */
                 rio_dprintk(RIO_DEBUG_PFE, "put_free_end(): This should never happen\n");
                 writew(RIO_OFF(HostP->Caddr, PktP), &HostP->ParmMapP->free_list_end);
-                tmp_pointer = (struct rio_free_list *) PktP;
+                tmp_pointer = (struct rio_free_list __iomem *) PktP;
                 writew(TPNULL, &tmp_pointer->prev);
                 writew(TPNULL, &tmp_pointer->next);
         }
@@ -647,10 +647,10 @@ void put_free_end(struct Host *HostP, struct PKT *PktP)
 ** relevant packet, [having cleared the PKT_IN_USE bit]. If PKT_IN_USE is clear,
 ** then can_remove_receive() returns 0.
 */
-int can_remove_receive(struct PKT **PktP, struct Port *PortP)
+int can_remove_receive(struct PKT __iomem **PktP, struct Port *PortP)
 {
         if (readw(PortP->RxRemove) & PKT_IN_USE) {
-                *PktP = (struct PKT *) RIO_PTR(PortP->Caddr, readw(PortP->RxRemove) & ~PKT_IN_USE);
+                *PktP = (struct PKT __iomem *) RIO_PTR(PortP->Caddr, readw(PortP->RxRemove) & ~PKT_IN_USE);
                 return 1;
         }
         return 0;
diff --git a/drivers/char/rio/rioroute.c b/drivers/char/rio/rioroute.c
index 357085337942..a99f3d9d7d65 100644
--- a/drivers/char/rio/rioroute.c
+++ b/drivers/char/rio/rioroute.c
@@ -86,9 +86,9 @@ static void RIOConCon(struct rio_info *, struct Host *, unsigned int, unsigned i
 ** Incoming on the ROUTE_RUP
 ** I wrote this while I was tired. Forgive me.
 */
-int RIORouteRup(struct rio_info *p, unsigned int Rup, struct Host *HostP, struct PKT * PacketP)
+int RIORouteRup(struct rio_info *p, unsigned int Rup, struct Host *HostP, struct PKT __iomem * PacketP)
 {
-        struct PktCmd *PktCmdP = (struct PktCmd *) PacketP->data;
+        struct PktCmd __iomem *PktCmdP = (struct PktCmd __iomem *) PacketP->data;
         struct PktCmd_M *PktReplyP;
         struct CmdBlk *CmdBlkP;
         struct Port *PortP;
@@ -307,7 +307,7 @@ int RIORouteRup(struct rio_info *p, unsigned int Rup, struct Host *HostP, struct
         if (!RIOBootOk(p, HostP, RtaUniq)) {
                 rio_dprintk(RIO_DEBUG_ROUTE, "RTA %x tried to get an ID, but does not belong - FOAD it!\n", RtaUniq);
                 PktReplyP->Command = ROUTE_FOAD;
-                HostP->Copy("RT_FOAD", PktReplyP->CommandText, 7);
+                memcpy(PktReplyP->CommandText, "RT_FOAD", 7);
                 RIOQueueCmdBlk(HostP, Rup, CmdBlkP);
                 return 1;
         }
@@ -341,7 +341,7 @@ int RIORouteRup(struct rio_info *p, unsigned int Rup, struct Host *HostP, struct
                                         HostP->Mapping[ThisUnit].Flags |= MSG_DONE;
                                 }
                                 PktReplyP->Command = ROUTE_FOAD;
-                                HostP->Copy("RT_FOAD", PktReplyP->CommandText, 7);
+                                memcpy(PktReplyP->CommandText, "RT_FOAD", 7);
                                 RIOQueueCmdBlk(HostP, Rup, CmdBlkP);
                                 return 1;
                         }
@@ -367,7 +367,7 @@ int RIORouteRup(struct rio_info *p, unsigned int Rup, struct Host *HostP, struct
                                 PktReplyP->IDNum2 = ROUTE_NO_ID;
                                 rio_dprintk(RIO_DEBUG_ROUTE, "RTA '%s' has been allocated ID %d\n", HostP->Mapping[ThisUnit].Name, PktReplyP->IDNum);
                         }
-                        HostP->Copy("RT_ALLOCAT", PktReplyP->CommandText, 10);
+                        memcpy(PktReplyP->CommandText, "RT_ALLOCAT", 10);
 
                         RIOQueueCmdBlk(HostP, Rup, CmdBlkP);
 
@@ -469,7 +469,7 @@ int RIORouteRup(struct rio_info *p, unsigned int Rup, struct Host *HostP, struct
                 }
 
                 PktReplyP->Command = ROUTE_FOAD;
-                HostP->Copy("RT_FOAD", PktReplyP->CommandText, 7);
+                memcpy(PktReplyP->CommandText, "RT_FOAD", 7);
         } else {
                 /*
                  ** we did boot it (as an extra), and there may now be a table
@@ -489,7 +489,7 @@ int RIORouteRup(struct rio_info *p, unsigned int Rup, struct Host *HostP, struct
                         }
                 }
                 PktReplyP->Command = ROUTE_USED;
-                HostP->Copy("RT_USED", PktReplyP->CommandText, 7);
+                memcpy(PktReplyP->CommandText, "RT_USED", 7);
         }
         RIOQueueCmdBlk(HostP, Rup, CmdBlkP);
         return 1;
@@ -517,8 +517,8 @@ void RIOFixPhbs(struct rio_info *p, struct Host *HostP, unsigned int unit)
 
                 for (port = 0; port < PORTS_PER_RTA; port++, PortN++) {
                         unsigned short dest_port = port + 8;
-                        u16 *TxPktP;
-                        struct PKT *Pkt;
+                        u16 __iomem *TxPktP;
+                        struct PKT __iomem *Pkt;
 
                         PortP = p->RIOPortp[PortN];
 
@@ -555,12 +555,12 @@ void RIOFixPhbs(struct rio_info *p, struct Host *HostP, unsigned int unit)
                                  ** card. This needs to be translated into a 32 bit pointer
                                  ** so it can be accessed from the driver.
                                  */
-                                Pkt = (struct PKT *) RIO_PTR(HostP->Caddr, readw(TxPktP));
+                                Pkt = (struct PKT __iomem *) RIO_PTR(HostP->Caddr, readw(TxPktP));
 
                                 /*
                                  ** If the packet is used, reset it.
                                  */
-                                Pkt = (struct PKT *) ((unsigned long) Pkt & ~PKT_IN_USE);
+                                Pkt = (struct PKT __iomem *) ((unsigned long) Pkt & ~PKT_IN_USE);
                                 writeb(dest_unit, &Pkt->dest_unit);
                                 writeb(dest_port, &Pkt->dest_port);
                         }
diff --git a/drivers/char/rio/riotable.c b/drivers/char/rio/riotable.c
index d3abe0d37d64..7e988357326e 100644
--- a/drivers/char/rio/riotable.c
+++ b/drivers/char/rio/riotable.c
@@ -534,8 +534,8 @@ int RIODeleteRta(struct rio_info *p, struct Map *MapP)
                                                 if (PortP->SecondBlock) {
                                                         u16 dest_unit = HostMapP->ID;
                                                         u16 dest_port = port - SysPort;
-                                                        u16 *TxPktP;
-                                                        struct PKT *Pkt;
+                                                        u16 __iomem *TxPktP;
+                                                        struct PKT __iomem *Pkt;
 
                                                         for (TxPktP = PortP->TxStart; TxPktP <= PortP->TxEnd; TxPktP++) {
                                                                 /*
@@ -545,12 +545,12 @@ int RIODeleteRta(struct rio_info *p, struct Map *MapP)
                                                                  ** a 32 bit pointer so it can be
                                                                  ** accessed from the driver.
                                                                  */
-                                                                Pkt = (struct PKT *) RIO_PTR(HostP->Caddr, readw(&*TxPktP));
-                                                                rio_dprintk(RIO_DEBUG_TABLE, "Tx packet (%x) destination: Old %x:%x New %x:%x\n", *TxPktP, Pkt->dest_unit, Pkt->dest_port, dest_unit, dest_port);
+                                                                Pkt = (struct PKT __iomem *) RIO_PTR(HostP->Caddr, readw(&*TxPktP));
+                                                                rio_dprintk(RIO_DEBUG_TABLE, "Tx packet (%x) destination: Old %x:%x New %x:%x\n", readw(TxPktP), readb(&Pkt->dest_unit), readb(&Pkt->dest_port), dest_unit, dest_port);
                                                                 writew(dest_unit, &Pkt->dest_unit);
                                                                 writew(dest_port, &Pkt->dest_port);
                                                         }
-                                                        rio_dprintk(RIO_DEBUG_TABLE, "Port %d phb destination: Old %x:%x New %x:%x\n", port, PortP->PhbP->destination & 0xff, (PortP->PhbP->destination >> 8) & 0xff, dest_unit, dest_port);
+                                                        rio_dprintk(RIO_DEBUG_TABLE, "Port %d phb destination: Old %x:%x New %x:%x\n", port, readb(&PortP->PhbP->destination) & 0xff, (readb(&PortP->PhbP->destination) >> 8) & 0xff, dest_unit, dest_port);
                                                         writew(dest_unit + (dest_port << 8), &PortP->PhbP->destination);
                                                 }
                                                 rio_spin_unlock_irqrestore(&PortP->portSem, sem_flags);
@@ -781,13 +781,13 @@ int RIOReMapPorts(struct rio_info *p, struct Host *HostP, struct Map *HostMapP)
                  ** unless the host has been booted
                  */
                 if ((HostP->Flags & RUN_STATE) == RC_RUNNING) {
-                        struct PHB *PhbP = PortP->PhbP = &HostP->PhbP[HostPort];
-                        PortP->TxAdd = (u16 *) RIO_PTR(HostP->Caddr, readw(&PhbP->tx_add));
-                        PortP->TxStart = (u16 *) RIO_PTR(HostP->Caddr, readw(&PhbP->tx_start));
-                        PortP->TxEnd = (u16 *) RIO_PTR(HostP->Caddr, readw(&PhbP->tx_end));
-                        PortP->RxRemove = (u16 *) RIO_PTR(HostP->Caddr, readw(&PhbP->rx_remove));
-                        PortP->RxStart = (u16 *) RIO_PTR(HostP->Caddr, readw(&PhbP->rx_start));
-                        PortP->RxEnd = (u16 *) RIO_PTR(HostP->Caddr, readw(&PhbP->rx_end));
+                        struct PHB __iomem *PhbP = PortP->PhbP = &HostP->PhbP[HostPort];
+                        PortP->TxAdd = (u16 __iomem *) RIO_PTR(HostP->Caddr, readw(&PhbP->tx_add));
+                        PortP->TxStart = (u16 __iomem *) RIO_PTR(HostP->Caddr, readw(&PhbP->tx_start));
+                        PortP->TxEnd = (u16 __iomem *) RIO_PTR(HostP->Caddr, readw(&PhbP->tx_end));
+                        PortP->RxRemove = (u16 __iomem *) RIO_PTR(HostP->Caddr, readw(&PhbP->rx_remove));
+                        PortP->RxStart = (u16 __iomem *) RIO_PTR(HostP->Caddr, readw(&PhbP->rx_start));
+                        PortP->RxEnd = (u16 __iomem *) RIO_PTR(HostP->Caddr, readw(&PhbP->rx_end));
                 } else
                         PortP->PhbP = NULL;
 
diff --git a/drivers/char/rio/riotty.c b/drivers/char/rio/riotty.c
index 204267613c9c..a4f0b1e3e7fa 100644
--- a/drivers/char/rio/riotty.c
+++ b/drivers/char/rio/riotty.c
@@ -576,7 +576,7 @@ static void RIOClearUp(struct Port *PortP)
 */
 int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg)
 {
-        struct PKT *PacketP;
+        struct PKT __iomem *PacketP;
         int retries = 20;       /* at 10 per second -> 2 seconds */
         unsigned long flags;
 
diff --git a/drivers/char/rio/unixrup.h b/drivers/char/rio/unixrup.h
index 4306e01dbf01..46bd532f7746 100644
--- a/drivers/char/rio/unixrup.h
+++ b/drivers/char/rio/unixrup.h
@@ -44,7 +44,7 @@ static char *_unixrup_h_sccs_ = "@(#)unixrup.h	1.2";
 struct UnixRup {
         struct CmdBlk *CmdsWaitingP;    /* Commands waiting to be done */
         struct CmdBlk *CmdPendingP;     /* The command currently being sent */
-        struct RUP *RupP;       /* the Rup to send it to */
+        struct RUP __iomem *RupP;       /* the Rup to send it to */
         unsigned int Id;                /* Id number */
         unsigned int BaseSysPort;       /* SysPort of first tty on this RTA */
         unsigned int ModTypes;          /* Modules on this RTA */
diff --git a/drivers/mmc/sdhci.c b/drivers/mmc/sdhci.c
index b0053280ff2d..6bfcdbc7491e 100644
--- a/drivers/mmc/sdhci.c
+++ b/drivers/mmc/sdhci.c
@@ -1073,7 +1073,7 @@ static int __devinit sdhci_probe_slot(struct pci_dev *pdev, int slot)
         tasklet_init(&host->finish_tasklet,
                 sdhci_tasklet_finish, (unsigned long)host);
 
-        setup_timer(&host->timer, sdhci_timeout_timer, (int)host);
+        setup_timer(&host->timer, sdhci_timeout_timer, (long)host);
 
         ret = request_irq(host->irq, sdhci_irq, SA_SHIRQ,
                 host->slot_descr, host);
diff --git a/drivers/mtd/Kconfig b/drivers/mtd/Kconfig
index f6b775e63ac8..5ac265dde423 100644
--- a/drivers/mtd/Kconfig
+++ b/drivers/mtd/Kconfig
@@ -78,7 +78,7 @@ config MTD_REDBOOT_DIRECTORY_BLOCK
           option.
 
           The option specifies which Flash sectors holds the RedBoot
-          partition table.  A zero or positive value gives an absolete
+          partition table.  A zero or positive value gives an absolute
           erase block number. A negative value specifies a number of
           sectors before the end of the device.
 
@@ -103,7 +103,7 @@ config MTD_CMDLINE_PARTS
         bool "Command line partition table parsing"
         depends on MTD_PARTITIONS = "y"
         ---help---
-          Allow generic configuration of the MTD paritition tables via the kernel
+          Allow generic configuration of the MTD partition tables via the kernel
           command line. Multiple flash resources are supported for hardware where
           different kinds of flash memory are available.
 
diff --git a/drivers/mtd/chips/Kconfig b/drivers/mtd/chips/Kconfig
index a7ec5954caf5..6d8f30deb868 100644
--- a/drivers/mtd/chips/Kconfig
+++ b/drivers/mtd/chips/Kconfig
@@ -30,7 +30,6 @@ config MTD_JEDECPROBE
 
 config MTD_GEN_PROBE
         tristate
-        select OBSOLETE_INTERMODULE
 
 config MTD_CFI_ADV_OPTIONS
         bool "Flash chip driver advanced configuration options"
diff --git a/drivers/mtd/chips/Makefile b/drivers/mtd/chips/Makefile
index 8afe3092c4e3..75bc1c2a0f43 100644
--- a/drivers/mtd/chips/Makefile
+++ b/drivers/mtd/chips/Makefile
@@ -3,13 +3,6 @@
 #
 # $Id: Makefile.common,v 1.5 2005/11/07 11:14:22 gleixner Exp $
 
-#                       *** BIG UGLY NOTE ***
-#
-# The removal of get_module_symbol() and replacement with
-# inter_module_register() et al has introduced a link order dependency
-# here where previously there was none.  We now have to ensure that
-# the CFI command set drivers are linked before gen_probe.o
-
 obj-$(CONFIG_MTD)               += chipreg.o
 obj-$(CONFIG_MTD_AMDSTD)        += amd_flash.o
 obj-$(CONFIG_MTD_CFI)           += cfi_probe.o
diff --git a/drivers/mtd/chips/amd_flash.c b/drivers/mtd/chips/amd_flash.c
index 57115618c496..16eaca69fb5a 100644
--- a/drivers/mtd/chips/amd_flash.c
+++ b/drivers/mtd/chips/amd_flash.c
@@ -97,7 +97,6 @@ struct amd_flash_private {
         int interleave;
         int numchips;
         unsigned long chipshift;
-//      const char *im_name;
         struct flchip chips[0];
 };
 
@@ -131,12 +130,6 @@ static struct mtd_chip_driver amd_flash_chipdrv = {
         .module = THIS_MODULE
 };
 
-
-
-static const char im_name[] = "amd_flash";
-
-
-
 static inline __u32 wide_read(struct map_info *map, __u32 addr)
 {
         if (map->buswidth == 1) {
@@ -737,6 +730,7 @@ static struct mtd_info *amd_flash_probe(struct map_info *map)
                 offset += dev_size;
         }
         mtd->type = MTD_NORFLASH;
+        mtd->writesize = 1;
         mtd->flags = MTD_CAP_NORFLASH;
         mtd->name = map->name;
         mtd->erase = amd_flash_erase;
diff --git a/drivers/mtd/chips/cfi_cmdset_0001.c b/drivers/mtd/chips/cfi_cmdset_0001.c
index 1c074d63ff3a..0d435814aaa1 100644
--- a/drivers/mtd/chips/cfi_cmdset_0001.c
+++ b/drivers/mtd/chips/cfi_cmdset_0001.c
@@ -331,13 +331,6 @@ read_pri_intelext(struct map_info *map, __u16 adr)
         return extp;
 }
 
-/* This routine is made available to other mtd code via
- * inter_module_register.  It must only be accessed through
- * inter_module_get which will bump the use count of this module.  The
- * addresses passed back in cfi are valid as long as the use count of
- * this module is non-zero, i.e. between inter_module_get and
- * inter_module_put.  Keith Owens <kaos@ocs.com.au> 29 Oct 2000.
- */
 struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary)
 {
         struct cfi_private *cfi = map->fldrv_priv;
@@ -406,7 +399,7 @@ struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary)
         for (i=0; i< cfi->numchips; i++) {
                 cfi->chips[i].word_write_time = 1<<cfi->cfiq->WordWriteTimeoutTyp;
                 cfi->chips[i].buffer_write_time = 1<<cfi->cfiq->BufWriteTimeoutTyp;
-                cfi->chips[i].erase_time = 1<<cfi->cfiq->BlockEraseTimeoutTyp;
+                cfi->chips[i].erase_time = 1000<<cfi->cfiq->BlockEraseTimeoutTyp;
                 cfi->chips[i].ref_point_counter = 0;
                 init_waitqueue_head(&(cfi->chips[i].wq));
         }
@@ -415,6 +408,11 @@ struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary)
 
         return cfi_intelext_setup(mtd);
 }
+struct mtd_info *cfi_cmdset_0003(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001")));
+struct mtd_info *cfi_cmdset_0200(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001")));
+EXPORT_SYMBOL_GPL(cfi_cmdset_0001);
+EXPORT_SYMBOL_GPL(cfi_cmdset_0003);
+EXPORT_SYMBOL_GPL(cfi_cmdset_0200);
 
 static struct mtd_info *cfi_intelext_setup(struct mtd_info *mtd)
 {
@@ -547,12 +545,12 @@ static int cfi_intelext_partition_fixup(struct mtd_info *mtd,
                 if (extp->MinorVersion >= '4') {
                         struct cfi_intelext_programming_regioninfo *prinfo;
                         prinfo = (struct cfi_intelext_programming_regioninfo *)&extp->extra[offs];
-                        MTD_PROGREGION_SIZE(mtd) = cfi->interleave << prinfo->ProgRegShift;
+                        mtd->writesize = cfi->interleave << prinfo->ProgRegShift;
                         MTD_PROGREGION_CTRLMODE_VALID(mtd) = cfi->interleave * prinfo->ControlValid;
                         MTD_PROGREGION_CTRLMODE_INVALID(mtd) = cfi->interleave * prinfo->ControlInvalid;
-                        mtd->flags |= MTD_PROGRAM_REGIONS;
+                        mtd->flags &= ~MTD_BIT_WRITEABLE;
                         printk(KERN_DEBUG "%s: program region size/ctrl_valid/ctrl_inval = %d/%d/%d\n",
-                               map->name, MTD_PROGREGION_SIZE(mtd),
+                               map->name, mtd->writesize,
                                MTD_PROGREGION_CTRLMODE_VALID(mtd),
                                MTD_PROGREGION_CTRLMODE_INVALID(mtd));
                 }
@@ -896,26 +894,33 @@ static void __xipram xip_enable(struct map_info *map, struct flchip *chip,
 
 /*
  * When a delay is required for the flash operation to complete, the
- * xip_udelay() function is polling for both the given timeout and pending
- * (but still masked) hardware interrupts.  Whenever there is an interrupt
- * pending then the flash erase or write operation is suspended, array mode
- * restored and interrupts unmasked.  Task scheduling might also happen at that
- * point.  The CPU eventually returns from the interrupt or the call to
- * schedule() and the suspended flash operation is resumed for the remaining
- * of the delay period.
+ * xip_wait_for_operation() function is polling for both the given timeout
+ * and pending (but still masked) hardware interrupts.  Whenever there is an
+ * interrupt pending then the flash erase or write operation is suspended,
+ * array mode restored and interrupts unmasked.  Task scheduling might also
+ * happen at that point.  The CPU eventually returns from the interrupt or
+ * the call to schedule() and the suspended flash operation is resumed for
+ * the remaining of the delay period.
  *
  * Warning: this function _will_ fool interrupt latency tracing tools.
  */
 
-static void __xipram xip_udelay(struct map_info *map, struct flchip *chip,
-                                unsigned long adr, int usec)
+static int __xipram xip_wait_for_operation(
+                struct map_info *map, struct flchip *chip,
+                unsigned long adr, int *chip_op_time )
 {
         struct cfi_private *cfi = map->fldrv_priv;
         struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
         map_word status, OK = CMD(0x80);
-        unsigned long suspended, start = xip_currtime();
+        unsigned long usec, suspended, start, done;
         flstate_t oldstate, newstate;
 
+        start = xip_currtime();
+        usec = *chip_op_time * 8;
+        if (usec == 0)
+                usec = 500000;
+        done = 0;
+
         do {
                 cpu_relax();
                 if (xip_irqpending() && cfip &&
@@ -932,9 +937,9 @@ static void __xipram xip_udelay(struct map_info *map, struct flchip *chip,
                          * we resume the whole thing at once).  Yes, it
                          * can happen!
                          */
+                        usec -= done;
                         map_write(map, CMD(0xb0), adr);
                         map_write(map, CMD(0x70), adr);
-                        usec -= xip_elapsed_since(start);
                         suspended = xip_currtime();
                         do {
                                 if (xip_elapsed_since(suspended) > 100000) {
@@ -944,7 +949,7 @@ static void __xipram xip_udelay(struct map_info *map, struct flchip *chip,
                                          * This is a critical error but there
                                          * is not much we can do here.
                                          */
-                                        return;
+                                        return -EIO;
                                 }
                                 status = map_read(map, adr);
                         } while (!map_word_andequal(map, status, OK, OK));
@@ -1004,65 +1009,107 @@ static void __xipram xip_udelay(struct map_info *map, struct flchip *chip,
                         xip_cpu_idle();
                 }
                 status = map_read(map, adr);
+                done = xip_elapsed_since(start);
         } while (!map_word_andequal(map, status, OK, OK)
-                 && xip_elapsed_since(start) < usec);
-}
+                 && done < usec);
 
-#define UDELAY(map, chip, adr, usec)  xip_udelay(map, chip, adr, usec)
+        return (done >= usec) ? -ETIME : 0;
+}
 
 /*
  * The INVALIDATE_CACHED_RANGE() macro is normally used in parallel while
  * the flash is actively programming or erasing since we have to poll for
  * the operation to complete anyway.  We can't do that in a generic way with
  * a XIP setup so do it before the actual flash operation in this case
- * and stub it out from INVALIDATE_CACHE_UDELAY.
+ * and stub it out from INVAL_CACHE_AND_WAIT.
  */
 #define XIP_INVAL_CACHED_RANGE(map, from, size)  \
         INVALIDATE_CACHED_RANGE(map, from, size)
 
-#define INVALIDATE_CACHE_UDELAY(map, chip, cmd_adr, adr, len, usec)  \
-        UDELAY(map, chip, cmd_adr, usec)
-
-/*
- * Extra notes:
- *
- * Activating this XIP support changes the way the code works a bit.  For
- * example the code to suspend the current process when concurrent access
- * happens is never executed because xip_udelay() will always return with the
- * same chip state as it was entered with.  This is why there is no care for
- * the presence of add_wait_queue() or schedule() calls from within a couple
- * xip_disable()'d  areas of code, like in do_erase_oneblock for example.
- * The queueing and scheduling are always happening within xip_udelay().
- *
- * Similarly, get_chip() and put_chip() just happen to always be executed
- * with chip->state set to FL_READY (or FL_XIP_WHILE_*) where flash state
- * is in array mode, therefore never executing many cases therein and not
- * causing any problem with XIP.
- */
+#define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, p_usec) \
+        xip_wait_for_operation(map, chip, cmd_adr, p_usec)
 
 #else
 
 #define xip_disable(map, chip, adr)
 #define xip_enable(map, chip, adr)
 #define XIP_INVAL_CACHED_RANGE(x...)
+#define INVAL_CACHE_AND_WAIT inval_cache_and_wait_for_operation
+
+static int inval_cache_and_wait_for_operation(
+                struct map_info *map, struct flchip *chip,
+                unsigned long cmd_adr, unsigned long inval_adr, int inval_len,
+                int *chip_op_time )
+{
+        struct cfi_private *cfi = map->fldrv_priv;
+        map_word status, status_OK = CMD(0x80);
+        int z, chip_state = chip->state;
+        unsigned long timeo;
+
+        spin_unlock(chip->mutex);
+        if (inval_len)
+                INVALIDATE_CACHED_RANGE(map, inval_adr, inval_len);
+        if (*chip_op_time)
+                cfi_udelay(*chip_op_time);
+        spin_lock(chip->mutex);
+
+        timeo = *chip_op_time * 8 * HZ / 1000000;
+        if (timeo < HZ/2)
+                timeo = HZ/2;
+        timeo += jiffies;
+
+        z = 0;
+        for (;;) {
+                if (chip->state != chip_state) {
+                        /* Someone's suspended the operation: sleep */
+                        DECLARE_WAITQUEUE(wait, current);
+
+                        set_current_state(TASK_UNINTERRUPTIBLE);
+                        add_wait_queue(&chip->wq, &wait);
+                        spin_unlock(chip->mutex);
+                        schedule();
+                        remove_wait_queue(&chip->wq, &wait);
+                        timeo = jiffies + (HZ / 2); /* FIXME */
+                        spin_lock(chip->mutex);
+                        continue;
+                }
 
-#define UDELAY(map, chip, adr, usec)  \
-do {  \
-        spin_unlock(chip->mutex);  \
-        cfi_udelay(usec);  \
-        spin_lock(chip->mutex);  \
-} while (0)
-
-#define INVALIDATE_CACHE_UDELAY(map, chip, cmd_adr, adr, len, usec)  \
-do {  \
-        spin_unlock(chip->mutex);  \
-        INVALIDATE_CACHED_RANGE(map, adr, len);  \
-        cfi_udelay(usec);  \
-        spin_lock(chip->mutex);  \
-} while (0)
+                status = map_read(map, cmd_adr);
+                if (map_word_andequal(map, status, status_OK, status_OK))
+                        break;
+
+                /* OK Still waiting */
+                if (time_after(jiffies, timeo)) {
+                        map_write(map, CMD(0x70), cmd_adr);
+                        chip->state = FL_STATUS;
+                        return -ETIME;
+                }
+
+                /* Latency issues. Drop the lock, wait a while and retry */
+                z++;
+                spin_unlock(chip->mutex);
+                cfi_udelay(1);
+                spin_lock(chip->mutex);
+        }
+
+        if (!z) {
+                if (!--(*chip_op_time))
+                        *chip_op_time = 1;
+        } else if (z > 1)
+                ++(*chip_op_time);
+
+        /* Done and happy. */
+        chip->state = FL_STATUS;
+        return 0;
+}
 
 #endif
 
+#define WAIT_TIMEOUT(map, chip, adr, udelay) \
+        ({ int __udelay = (udelay); \
+           INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, &__udelay); })
+
+
 static int do_point_onechip (struct map_info *map, struct flchip *chip, loff_t adr, size_t len)
 {
         unsigned long cmd_addr;
@@ -1252,14 +1299,11 @@ static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
                                      unsigned long adr, map_word datum, int mode)
 {
         struct cfi_private *cfi = map->fldrv_priv;
-        map_word status, status_OK, write_cmd;
-        unsigned long timeo;
-        int z, ret=0;
+        map_word status, write_cmd;
+        int ret=0;
 
         adr += chip->start;
 
-        /* Let's determine those according to the interleave only once */
-        status_OK = CMD(0x80);
         switch (mode) {
         case FL_WRITING:
                 write_cmd = (cfi->cfiq->P_ID != 0x0200) ? CMD(0x40) : CMD(0x41);
@@ -1285,57 +1329,17 @@ static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
         map_write(map, datum, adr);
         chip->state = mode;
 
-        INVALIDATE_CACHE_UDELAY(map, chip, adr,
-                                adr, map_bankwidth(map),
-                                chip->word_write_time);
-
-        timeo = jiffies + (HZ/2);
-        z = 0;
-        for (;;) {
-                if (chip->state != mode) {
-                        /* Someone's suspended the write. Sleep */
-                        DECLARE_WAITQUEUE(wait, current);
-
-                        set_current_state(TASK_UNINTERRUPTIBLE);
-                        add_wait_queue(&chip->wq, &wait);
-                        spin_unlock(chip->mutex);
-                        schedule();
-                        remove_wait_queue(&chip->wq, &wait);
-                        timeo = jiffies + (HZ / 2); /* FIXME */
-                        spin_lock(chip->mutex);
-                        continue;
-                }
-
-                status = map_read(map, adr);
-                if (map_word_andequal(map, status, status_OK, status_OK))
-                        break;
-
-                /* OK Still waiting */
-                if (time_after(jiffies, timeo)) {
-                        map_write(map, CMD(0x70), adr);
-                        chip->state = FL_STATUS;
-                        xip_enable(map, chip, adr);
-                        printk(KERN_ERR "%s: word write error (status timeout)\n", map->name);
-                        ret = -EIO;
-                        goto out;
-                }
-
-                /* Latency issues. Drop the lock, wait a while and retry */
-                z++;
-                UDELAY(map, chip, adr, 1);
-        }
-        if (!z) {
-                chip->word_write_time--;
-                if (!chip->word_write_time)
-                        chip->word_write_time = 1;
+        ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
+                                   adr, map_bankwidth(map),
+                                   &chip->word_write_time);
+        if (ret) {
+                xip_enable(map, chip, adr);
+                printk(KERN_ERR "%s: word write error (status timeout)\n", map->name);
+                goto out;
         }
-        if (z > 1)
-                chip->word_write_time++;
-
-        /* Done and happy. */
-        chip->state = FL_STATUS;
 
         /* check for errors */
+        status = map_read(map, adr);
         if (map_word_bitsset(map, status, CMD(0x1a))) {
                 unsigned long chipstatus = MERGESTATUS(status);
 
@@ -1452,9 +1456,9 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
                                     unsigned long *pvec_seek, int len)
 {
         struct cfi_private *cfi = map->fldrv_priv;
-        map_word status, status_OK, write_cmd, datum;
-        unsigned long cmd_adr, timeo;
-        int wbufsize, z, ret=0, word_gap, words;
+        map_word status, write_cmd, datum;
+        unsigned long cmd_adr;
+        int ret, wbufsize, word_gap, words;
         const struct kvec *vec;
         unsigned long vec_seek;
 
@@ -1463,7 +1467,6 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
         cmd_adr = adr & ~(wbufsize-1);
 
         /* Let's determine this according to the interleave only once */
-        status_OK = CMD(0x80);
         write_cmd = (cfi->cfiq->P_ID != 0x0200) ? CMD(0xe8) : CMD(0xe9);
 
         spin_lock(chip->mutex);
@@ -1477,12 +1480,14 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
         ENABLE_VPP(map);
         xip_disable(map, chip, cmd_adr);
 
-        /* §4.8 of the 28FxxxJ3A datasheet says "Any time SR.4 and/or SR.5 is set
+        /* §4.8 of the 28FxxxJ3A datasheet says "Any time SR.4 and/or SR.5 is set
            [...], the device will not accept any more Write to Buffer commands".
            So we must check here and reset those bits if they're set. Otherwise
            we're just pissing in the wind */
-        if (chip->state != FL_STATUS)
+        if (chip->state != FL_STATUS) {
                 map_write(map, CMD(0x70), cmd_adr);
+                chip->state = FL_STATUS;
+        }
         status = map_read(map, cmd_adr);
         if (map_word_bitsset(map, status, CMD(0x30))) {
                 xip_enable(map, chip, cmd_adr);
@@ -1493,32 +1498,20 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
         }
 
         chip->state = FL_WRITING_TO_BUFFER;
-
-        z = 0;
-        for (;;) {
-                map_write(map, write_cmd, cmd_adr);
-
+        map_write(map, write_cmd, cmd_adr);
+        ret = WAIT_TIMEOUT(map, chip, cmd_adr, 0);
+        if (ret) {
+                /* Argh. Not ready for write to buffer */
+                map_word Xstatus = map_read(map, cmd_adr);
+                map_write(map, CMD(0x70), cmd_adr);
+                chip->state = FL_STATUS;
                 status = map_read(map, cmd_adr);
-                if (map_word_andequal(map, status, status_OK, status_OK))
-                        break;
-
-                UDELAY(map, chip, cmd_adr, 1);
-
-                if (++z > 20) {
-                        /* Argh. Not ready for write to buffer */
-                        map_word Xstatus;
-                        map_write(map, CMD(0x70), cmd_adr);
-                        chip->state = FL_STATUS;
-                        Xstatus = map_read(map, cmd_adr);
-                        /* Odd. Clear status bits */
-                        map_write(map, CMD(0x50), cmd_adr);
-                        map_write(map, CMD(0x70), cmd_adr);
-                        xip_enable(map, chip, cmd_adr);
-                        printk(KERN_ERR "%s: Chip not ready for buffer write. status = %lx, Xstatus = %lx\n",
-                               map->name, status.x[0], Xstatus.x[0]);
-                        ret = -EIO;
-                        goto out;
-                }
+                map_write(map, CMD(0x50), cmd_adr);
+                map_write(map, CMD(0x70), cmd_adr);
+                xip_enable(map, chip, cmd_adr);
+                printk(KERN_ERR "%s: Chip not ready for buffer write. Xstatus = %lx, status = %lx\n",
+                                map->name, Xstatus.x[0], status.x[0]);
+                goto out;
         }
 
         /* Figure out the number of words to write */
@@ -1573,56 +1566,19 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
         map_write(map, CMD(0xd0), cmd_adr);
         chip->state = FL_WRITING;
 
-        INVALIDATE_CACHE_UDELAY(map, chip, cmd_adr,
-                                adr, len,
-                                chip->buffer_write_time);
-
-        timeo = jiffies + (HZ/2);
-        z = 0;
-        for (;;) {
-                if (chip->state != FL_WRITING) {
-                        /* Someone's suspended the write. Sleep */
-                        DECLARE_WAITQUEUE(wait, current);
-                        set_current_state(TASK_UNINTERRUPTIBLE);
-                        add_wait_queue(&chip->wq, &wait);
-                        spin_unlock(chip->mutex);
-                        schedule();
-                        remove_wait_queue(&chip->wq, &wait);
-                        timeo = jiffies + (HZ / 2); /* FIXME */
-                        spin_lock(chip->mutex);
-                        continue;
-                }
-
-                status = map_read(map, cmd_adr);
-                if (map_word_andequal(map, status, status_OK, status_OK))
-                        break;
-
-                /* OK Still waiting */
-                if (time_after(jiffies, timeo)) {
-                        map_write(map, CMD(0x70), cmd_adr);
-                        chip->state = FL_STATUS;
-                        xip_enable(map, chip, cmd_adr);
-                        printk(KERN_ERR "%s: buffer write error (status timeout)\n", map->name);
-                        ret = -EIO;
-                        goto out;
-                }
-
-                /* Latency issues. Drop the lock, wait a while and retry */
-                z++;
-                UDELAY(map, chip, cmd_adr, 1);
-        }
-        if (!z) {
-                chip->buffer_write_time--;
-                if (!chip->buffer_write_time)
-                        chip->buffer_write_time = 1;
+        ret = INVAL_CACHE_AND_WAIT(map, chip, cmd_adr,
+                                   adr, len,
+                                   &chip->buffer_write_time);
+        if (ret) {
+                map_write(map, CMD(0x70), cmd_adr);
+                chip->state = FL_STATUS;
+                xip_enable(map, chip, cmd_adr);
+                printk(KERN_ERR "%s: buffer write error (status timeout)\n", map->name);
+                goto out;
         }
-        if (z > 1)
-                chip->buffer_write_time++;
-
-        /* Done and happy. */
-        chip->state = FL_STATUS;
 
         /* check for errors */
+        status = map_read(map, cmd_adr);
         if (map_word_bitsset(map, status, CMD(0x1a))) {
                 unsigned long chipstatus = MERGESTATUS(status);
 
@@ -1693,6 +1649,11 @@ static int cfi_intelext_writev (struct mtd_info *mtd, const struct kvec *vecs,
                         if (chipnum == cfi->numchips)
                                 return 0;
                 }
+
+                /* Be nice and reschedule with the chip in a usable state for other
+                   processes. */
+                cond_resched();
+
         } while (len);
 
         return 0;
@@ -1713,17 +1674,12 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
                                       unsigned long adr, int len, void *thunk)
 {
         struct cfi_private *cfi = map->fldrv_priv;
-        map_word status, status_OK;
-        unsigned long timeo;
+        map_word status;
         int retries = 3;
-        DECLARE_WAITQUEUE(wait, current);
-        int ret = 0;
+        int ret;
 
         adr += chip->start;
 
-        /* Let's determine this according to the interleave only once */
-        status_OK = CMD(0x80);
-
  retry:
         spin_lock(chip->mutex);
         ret = get_chip(map, chip, adr, FL_ERASING);
@@ -1745,48 +1701,15 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
         chip->state = FL_ERASING;
         chip->erase_suspended = 0;
 
-        INVALIDATE_CACHE_UDELAY(map, chip, adr,
-                                adr, len,
-                                chip->erase_time*1000/2);
-
-        /* FIXME. Use a timer to check this, and return immediately. */
-        /* Once the state machine's known to be working I'll do that */
-
-        timeo = jiffies + (HZ*20);
-        for (;;) {
-                if (chip->state != FL_ERASING) {
-                        /* Someone's suspended the erase. Sleep */
-                        set_current_state(TASK_UNINTERRUPTIBLE);
-                        add_wait_queue(&chip->wq, &wait);
-                        spin_unlock(chip->mutex);
-                        schedule();
-                        remove_wait_queue(&chip->wq, &wait);
-                        spin_lock(chip->mutex);
-                        continue;
-                }
-                if (chip->erase_suspended) {
-                        /* This erase was suspended and resumed.
-                           Adjust the timeout */
-                        timeo = jiffies + (HZ*20); /* FIXME */
-                        chip->erase_suspended = 0;
-                }
-
-                status = map_read(map, adr);
-                if (map_word_andequal(map, status, status_OK, status_OK))
-                        break;
-
-                /* OK Still waiting */
-                if (time_after(jiffies, timeo)) {
-                        map_write(map, CMD(0x70), adr);
-                        chip->state = FL_STATUS;
-                        xip_enable(map, chip, adr);
-                        printk(KERN_ERR "%s: block erase error: (status timeout)\n", map->name);
-                        ret = -EIO;
-                        goto out;
-                }
-
-                /* Latency issues. Drop the lock, wait a while and retry */
-                UDELAY(map, chip, adr, 1000000/HZ);
+        ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
+                                   adr, len,
+                                   &chip->erase_time);
+        if (ret) {
+                map_write(map, CMD(0x70), adr);
+                chip->state = FL_STATUS;
+                xip_enable(map, chip, adr);
+                printk(KERN_ERR "%s: block erase error: (status timeout)\n", map->name);
+                goto out;
         }
 
         /* We've broken this before. It doesn't hurt to be safe */
@@ -1815,7 +1738,6 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
                         ret = -EIO;
                 } else if (chipstatus & 0x20 && retries--) {
                         printk(KERN_DEBUG "block erase failed at 0x%08lx: status 0x%lx. Retrying...\n", adr, chipstatus);
-                        timeo = jiffies + HZ;
                         put_chip(map, chip, adr);
                         spin_unlock(chip->mutex);
                         goto retry;
@@ -1921,15 +1843,11 @@ static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip
 {
         struct cfi_private *cfi = map->fldrv_priv;
         struct cfi_pri_intelext *extp = cfi->cmdset_priv;
-        map_word status, status_OK;
-        unsigned long timeo = jiffies + HZ;
+        int udelay;
         int ret;
 
         adr += chip->start;
 
-        /* Let's determine this according to the interleave only once */
-        status_OK = CMD(0x80);
-
         spin_lock(chip->mutex);
         ret = get_chip(map, chip, adr, FL_LOCKING);
         if (ret) {
@@ -1954,41 +1872,21 @@ static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip
          * If Instant Individual Block Locking supported then no need
          * to delay.
          */
+        udelay = (!extp || !(extp->FeatureSupport & (1 << 5))) ? 1000000/HZ : 0;
 
-        if (!extp || !(extp->FeatureSupport & (1 << 5)))
-                UDELAY(map, chip, adr, 1000000/HZ);
-
-        /* FIXME. Use a timer to check this, and return immediately. */
-        /* Once the state machine's known to be working I'll do that */
-
-        timeo = jiffies + (HZ*20);
-        for (;;) {
-
-                status = map_read(map, adr);
-                if (map_word_andequal(map, status, status_OK, status_OK))
-                        break;
-
-                /* OK Still waiting */
-                if (time_after(jiffies, timeo)) {
-                        map_write(map, CMD(0x70), adr);
-                        chip->state = FL_STATUS;
-                        xip_enable(map, chip, adr);
-                        printk(KERN_ERR "%s: block unlock error: (status timeout)\n", map->name);
-                        put_chip(map, chip, adr);
-                        spin_unlock(chip->mutex);
-                        return -EIO;
-                }
-
-                /* Latency issues. Drop the lock, wait a while and retry */
-                UDELAY(map, chip, adr, 1);
+        ret = WAIT_TIMEOUT(map, chip, adr, udelay);
+        if (ret) {
+                map_write(map, CMD(0x70), adr);
+                chip->state = FL_STATUS;
+                xip_enable(map, chip, adr);
+                printk(KERN_ERR "%s: block unlock error: (status timeout)\n", map->name);
+                goto out;
         }
 
-        /* Done and happy. */
-        chip->state = FL_STATUS;
         xip_enable(map, chip, adr);
-        put_chip(map, chip, adr);
+out:    put_chip(map, chip, adr);
         spin_unlock(chip->mutex);
-        return 0;
+        return ret;
 }
 
 static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, size_t len)
@@ -2445,28 +2343,8 @@ static void cfi_intelext_destroy(struct mtd_info *mtd)
         kfree(mtd->eraseregions);
 }
 
-static char im_name_0001[] = "cfi_cmdset_0001";
-static char im_name_0003[] = "cfi_cmdset_0003";
-static char im_name_0200[] = "cfi_cmdset_0200";
-
-static int __init cfi_intelext_init(void)
-{
-        inter_module_register(im_name_0001, THIS_MODULE, &cfi_cmdset_0001);
-        inter_module_register(im_name_0003, THIS_MODULE, &cfi_cmdset_0001);
-        inter_module_register(im_name_0200, THIS_MODULE, &cfi_cmdset_0001);
-        return 0;
-}
-
-static void __exit cfi_intelext_exit(void)
-{
-        inter_module_unregister(im_name_0001);
-        inter_module_unregister(im_name_0003);
-        inter_module_unregister(im_name_0200);
-}
-
-module_init(cfi_intelext_init);
-module_exit(cfi_intelext_exit);
-
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org> et al.");
 MODULE_DESCRIPTION("MTD chip driver for Intel/Sharp flash chips");
+MODULE_ALIAS("cfi_cmdset_0003");
+MODULE_ALIAS("cfi_cmdset_0200");
diff --git a/drivers/mtd/chips/cfi_cmdset_0002.c b/drivers/mtd/chips/cfi_cmdset_0002.c
index aed10bd5c3c3..1e01ad38b26e 100644
--- a/drivers/mtd/chips/cfi_cmdset_0002.c
+++ b/drivers/mtd/chips/cfi_cmdset_0002.c
@@ -236,6 +236,7 @@ struct mtd_info *cfi_cmdset_0002(struct map_info *map, int primary)
         mtd->resume  = cfi_amdstd_resume;
         mtd->flags   = MTD_CAP_NORFLASH;
         mtd->name    = map->name;
+        mtd->writesize = 1;
 
         if (cfi->cfi_mode==CFI_MODE_CFI){
                 unsigned char bootloc;
@@ -326,7 +327,7 @@ struct mtd_info *cfi_cmdset_0002(struct map_info *map, int primary)
 
         return cfi_amdstd_setup(mtd);
 }
-
+EXPORT_SYMBOL_GPL(cfi_cmdset_0002);
 
 static struct mtd_info *cfi_amdstd_setup(struct mtd_info *mtd)
 {
@@ -1758,25 +1759,6 @@ static void cfi_amdstd_destroy(struct mtd_info *mtd)
         kfree(mtd->eraseregions);
 }
 
-static char im_name[]="cfi_cmdset_0002";
-
-
-static int __init cfi_amdstd_init(void)
-{
-        inter_module_register(im_name, THIS_MODULE, &cfi_cmdset_0002);
-        return 0;
-}
-
-
-static void __exit cfi_amdstd_exit(void)
-{
-        inter_module_unregister(im_name);
-}
-
-
-module_init(cfi_amdstd_init);
-module_exit(cfi_amdstd_exit);
-
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Crossnet Co. <info@crossnet.co.jp> et al.");
 MODULE_DESCRIPTION("MTD chip driver for AMD/Fujitsu flash chips");
diff --git a/drivers/mtd/chips/cfi_cmdset_0020.c b/drivers/mtd/chips/cfi_cmdset_0020.c
index 0807c1c91e55..fae70a5db540 100644
--- a/drivers/mtd/chips/cfi_cmdset_0020.c
+++ b/drivers/mtd/chips/cfi_cmdset_0020.c
@@ -162,6 +162,7 @@ struct mtd_info *cfi_cmdset_0020(struct map_info *map, int primary)
 
         return cfi_staa_setup(map);
 }
+EXPORT_SYMBOL_GPL(cfi_cmdset_0020);
 
 static struct mtd_info *cfi_staa_setup(struct map_info *map)
 {
@@ -237,9 +238,8 @@ static struct mtd_info *cfi_staa_setup(struct map_info *map)
         mtd->unlock = cfi_staa_unlock;
         mtd->suspend = cfi_staa_suspend;
         mtd->resume = cfi_staa_resume;
-        mtd->flags = MTD_CAP_NORFLASH;
-        mtd->flags |= MTD_ECC; /* FIXME: Not all STMicro flashes have this */
-        mtd->eccsize = 8; /* FIXME: Should be 0 for STMicro flashes w/out ECC */
+        mtd->flags = MTD_CAP_NORFLASH & ~MTD_BIT_WRITEABLE;
+        mtd->writesize = 8; /* FIXME: Should be 0 for STMicro flashes w/out ECC */
         map->fldrv = &cfi_staa_chipdrv;
         __module_get(THIS_MODULE);
         mtd->name = map->name;
@@ -1410,20 +1410,4 @@ static void cfi_staa_destroy(struct mtd_info *mtd)
         kfree(cfi);
 }
 
-static char im_name[]="cfi_cmdset_0020";
-
-static int __init cfi_staa_init(void)
-{
-        inter_module_register(im_name, THIS_MODULE, &cfi_cmdset_0020);
-        return 0;
-}
-
-static void __exit cfi_staa_exit(void)
-{
-        inter_module_unregister(im_name);
-}
-
-module_init(cfi_staa_init);
-module_exit(cfi_staa_exit);
-
 MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/chips/cfi_probe.c b/drivers/mtd/chips/cfi_probe.c
index e636aa86bc24..4bf9f8cac0dd 100644
--- a/drivers/mtd/chips/cfi_probe.c
+++ b/drivers/mtd/chips/cfi_probe.c
@@ -349,12 +349,12 @@ static void print_cfi_ident(struct cfi_ident *cfip)
         else
                 printk("No Vpp line\n");
 
-        printk("Typical byte/word write timeout: %d µs\n", 1<<cfip->WordWriteTimeoutTyp);
-        printk("Maximum byte/word write timeout: %d µs\n", (1<<cfip->WordWriteTimeoutMax) * (1<<cfip->WordWriteTimeoutTyp));
+        printk("Typical byte/word write timeout: %d µs\n", 1<<cfip->WordWriteTimeoutTyp);
+        printk("Maximum byte/word write timeout: %d µs\n", (1<<cfip->WordWriteTimeoutMax) * (1<<cfip->WordWriteTimeoutTyp));
 
         if (cfip->BufWriteTimeoutTyp || cfip->BufWriteTimeoutMax) {
-                printk("Typical full buffer write timeout: %d µs\n", 1<<cfip->BufWriteTimeoutTyp);
-                printk("Maximum full buffer write timeout: %d µs\n", (1<<cfip->BufWriteTimeoutMax) * (1<<cfip->BufWriteTimeoutTyp));
+                printk("Typical full buffer write timeout: %d µs\n", 1<<cfip->BufWriteTimeoutTyp);
+                printk("Maximum full buffer write timeout: %d µs\n", (1<<cfip->BufWriteTimeoutMax) * (1<<cfip->BufWriteTimeoutTyp));
         }
         else
                 printk("Full buffer write not supported\n");
diff --git a/drivers/mtd/chips/gen_probe.c b/drivers/mtd/chips/gen_probe.c
index 41bd59d20d85..cdb0f590b40c 100644
--- a/drivers/mtd/chips/gen_probe.c
+++ b/drivers/mtd/chips/gen_probe.c
@@ -37,8 +37,15 @@ struct mtd_info *mtd_do_chip_probe(struct map_info *map, struct chip_probe *cp)
         if (!mtd)
                 mtd = check_cmd_set(map, 0); /* Then the secondary */
 
-        if (mtd)
+        if (mtd) {
+                if (mtd->size > map->size) {
+                        printk(KERN_WARNING "Reducing visibility of %ldKiB chip to %ldKiB\n",
+                               (unsigned long)mtd->size >> 10, 
+                               (unsigned long)map->size >> 10);
+                        mtd->size = map->size;
+                }
                 return mtd;
+        }
 
         printk(KERN_WARNING"gen_probe: No supported Vendor Command Set found\n");
 
@@ -100,7 +107,12 @@ static struct cfi_private *genprobe_ident_chips(struct map_info *map, struct chi
          * Align bitmap storage size to full byte.
          */
         max_chips = map->size >> cfi.chipshift;
-        mapsize = (max_chips / 8) + ((max_chips % 8) ? 1 : 0);
+        if (!max_chips) {
+                printk(KERN_WARNING "NOR chip too large to fit in mapping. Attempting to cope...\n");
+                max_chips = 1;
+        }
+
+        mapsize = (max_chips + BITS_PER_LONG-1) / BITS_PER_LONG;
         chip_map = kmalloc(mapsize, GFP_KERNEL);
         if (!chip_map) {
                 printk(KERN_WARNING "%s: kmalloc failed for CFI chip map\n", map->name);
@@ -194,25 +206,28 @@ static inline struct mtd_info *cfi_cmdset_unknown(struct map_info *map,
 {
         struct cfi_private *cfi = map->fldrv_priv;
         __u16 type = primary?cfi->cfiq->P_ID:cfi->cfiq->A_ID;
-#if defined(CONFIG_MODULES) && defined(HAVE_INTER_MODULE)
-        char probename[32];
+#ifdef CONFIG_MODULES
+        char probename[16+sizeof(MODULE_SYMBOL_PREFIX)];
         cfi_cmdset_fn_t *probe_function;
 
-        sprintf(probename, "cfi_cmdset_%4.4X", type);
+        sprintf(probename, MODULE_SYMBOL_PREFIX "cfi_cmdset_%4.4X", type);
 
-        probe_function = inter_module_get_request(probename, probename);
+        probe_function = __symbol_get(probename);
+        if (!probe_function) {
+                request_module(probename + sizeof(MODULE_SYMBOL_PREFIX) - 1);
+                probe_function = __symbol_get(probename);
+        }
 
         if (probe_function) {
                 struct mtd_info *mtd;
 
                 mtd = (*probe_function)(map, primary);
                 /* If it was happy, it'll have increased its own use count */
-                inter_module_put(probename);
+                symbol_put_addr(probe_function);
                 return mtd;
         }
 #endif
-        printk(KERN_NOTICE "Support for command set %04X not present\n",
-               type);
+        printk(KERN_NOTICE "Support for command set %04X not present\n", type);
 
         return NULL;
 }
@@ -226,12 +241,8 @@ static struct mtd_info *check_cmd_set(struct map_info *map, int primary)
                 return NULL;
 
         switch(type){
-                /* Urgh. Ifdefs. The version with weak symbols was
-                 * _much_ nicer. Shame it didn't seem to work on
-                 * anything but x86, really.
-                 * But we can't rely in inter_module_get() because
-                 * that'd mean we depend on link order.
-                 */
+                /* We need these for the !CONFIG_MODULES case,
+                   because symbol_get() doesn't work there */
 #ifdef CONFIG_MTD_CFI_INTELEXT
         case 0x0001:
         case 0x0003:
@@ -246,9 +257,9 @@ static struct mtd_info *check_cmd_set(struct map_info *map, int primary)
         case 0x0020:
                 return cfi_cmdset_0020(map, primary);
 #endif
+        default:
+                return cfi_cmdset_unknown(map, primary);
         }
-
-        return cfi_cmdset_unknown(map, primary);
 }
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/chips/map_ram.c b/drivers/mtd/chips/map_ram.c
index bd2e876a814b..763925747db6 100644
--- a/drivers/mtd/chips/map_ram.c
+++ b/drivers/mtd/chips/map_ram.c
@@ -70,7 +70,7 @@ static struct mtd_info *map_ram_probe(struct map_info *map)
         mtd->read = mapram_read;
         mtd->write = mapram_write;
         mtd->sync = mapram_nop;
-        mtd->flags = MTD_CAP_RAM | MTD_VOLATILE;
+        mtd->flags = MTD_CAP_RAM;
 
         mtd->erasesize = PAGE_SIZE;
         while(mtd->size & (mtd->erasesize - 1))
diff --git a/drivers/mtd/chips/map_rom.c b/drivers/mtd/chips/map_rom.c
index 624c12c232c8..bc6ee9ef8a31 100644
--- a/drivers/mtd/chips/map_rom.c
+++ b/drivers/mtd/chips/map_rom.c
@@ -46,9 +46,7 @@ static struct mtd_info *map_rom_probe(struct map_info *map)
         mtd->write = maprom_write;
         mtd->sync = maprom_nop;
         mtd->flags = MTD_CAP_ROM;
-        mtd->erasesize = 131072;
-        while(mtd->size & (mtd->erasesize - 1))
-                mtd->erasesize >>= 1;
+        mtd->erasesize = map->size;
 
         __module_get(THIS_MODULE);
         return mtd;
diff --git a/drivers/mtd/chips/sharp.c b/drivers/mtd/chips/sharp.c
index 3cc0b23c5865..967abbecdff9 100644
--- a/drivers/mtd/chips/sharp.c
+++ b/drivers/mtd/chips/sharp.c
@@ -140,6 +140,7 @@ static struct mtd_info *sharp_probe(struct map_info *map)
         mtd->suspend = sharp_suspend;
         mtd->resume = sharp_resume;
         mtd->flags = MTD_CAP_NORFLASH;
+        mtd->writesize = 1;
         mtd->name = map->name;
 
         memset(sharp, 0, sizeof(*sharp));
diff --git a/drivers/mtd/devices/Kconfig b/drivers/mtd/devices/Kconfig
index 7fac438b5c32..16c02b5ccf7e 100644
--- a/drivers/mtd/devices/Kconfig
+++ b/drivers/mtd/devices/Kconfig
@@ -47,6 +47,11 @@ config MTD_MS02NV
           accelerator.  Say Y here if you have a DECstation 5000/2x0 or a
           DECsystem 5900 equipped with such a module.
 
+          If you want to compile this driver as a module ( = code which can be
+          inserted in and removed from the running kernel whenever you want),
+          say M here and read <file:Documentation/modules.txt>.  The module will
+          be called ms02-nv.o.
+
 config MTD_DATAFLASH
         tristate "Support for AT45xxx DataFlash"
         depends on MTD && SPI_MASTER && EXPERIMENTAL
@@ -209,7 +214,6 @@ config MTD_DOC2001PLUS
 config MTD_DOCPROBE
         tristate
         select MTD_DOCECC
-        select OBSOLETE_INTERMODULE
 
 config MTD_DOCECC
         tristate
diff --git a/drivers/mtd/devices/Makefile b/drivers/mtd/devices/Makefile
index b6573670316f..0f788d5c4bf8 100644
--- a/drivers/mtd/devices/Makefile
+++ b/drivers/mtd/devices/Makefile
@@ -3,13 +3,6 @@
 #
 # $Id: Makefile.common,v 1.7 2004/12/22 17:51:15 joern Exp $
 
-#                       *** BIG UGLY NOTE ***
-#
-# The removal of get_module_symbol() and replacement with
-# inter_module_register() et al has introduced a link order dependency
-# here where previously there was none.  We now have to ensure that
-# doc200[01].o are linked before docprobe.o
-
 obj-$(CONFIG_MTD_DOC2000)       += doc2000.o
 obj-$(CONFIG_MTD_DOC2001)       += doc2001.o
 obj-$(CONFIG_MTD_DOC2001PLUS)   += doc2001plus.o
diff --git a/drivers/mtd/devices/block2mtd.c b/drivers/mtd/devices/block2mtd.c
index 4160b8334c53..0d98c223c5fc 100644
--- a/drivers/mtd/devices/block2mtd.c
+++ b/drivers/mtd/devices/block2mtd.c
@@ -4,7 +4,7 @@
  * block2mtd.c - create an mtd from a block device
  *
  * Copyright (C) 2001,2002      Simon Evans <spse@secret.org.uk>
- * Copyright (C) 2004,2005      Jörn Engel <joern@wh.fh-wedel.de>
+ * Copyright (C) 2004-2006      Jörn Engel <joern@wh.fh-wedel.de>
  *
  * Licence: GPL
  */
@@ -331,7 +331,6 @@ static struct block2mtd_dev *add_device(char *devname, int erase_size)
         dev->mtd.writev = default_mtd_writev;
         dev->mtd.sync = block2mtd_sync;
         dev->mtd.read = block2mtd_read;
-        dev->mtd.readv = default_mtd_readv;
         dev->mtd.priv = dev;
         dev->mtd.owner = THIS_MODULE;
 
@@ -351,6 +350,12 @@ devinit_err:
 }
 
 
+/* This function works similar to reguler strtoul.  In addition, it
+ * allows some suffixes for a more human-readable number format:
+ * ki, Ki, kiB, KiB     - multiply result with 1024
+ * Mi, MiB              - multiply result with 1024^2
+ * Gi, GiB              - multiply result with 1024^3
+ */
 static int ustrtoul(const char *cp, char **endp, unsigned int base)
 {
         unsigned long result = simple_strtoul(cp, endp, base);
@@ -359,11 +364,16 @@ static int ustrtoul(const char *cp, char **endp, unsigned int base)
                 result *= 1024;
         case 'M':
                 result *= 1024;
+        case 'K':
         case 'k':
                 result *= 1024;
         /* By dwmw2 editorial decree, "ki", "Mi" or "Gi" are to be used. */
-                if ((*endp)[1] == 'i')
-                        (*endp) += 2;
+                if ((*endp)[1] == 'i') {
+                        if ((*endp)[2] == 'B')
+                                (*endp) += 3;
+                        else
+                                (*endp) += 2;
+                }
         }
         return result;
 }
@@ -418,7 +428,8 @@ static inline void kill_final_newline(char *str)
 
 static int block2mtd_setup(const char *val, struct kernel_param *kp)
 {
-        char buf[80+12], *str=buf; /* 80 for device, 12 for erase size */
+        char buf[80+12]; /* 80 for device, 12 for erase size */
+        char *str = buf;
         char *token[2];
         char *name;
         size_t erase_size = PAGE_SIZE;
@@ -430,7 +441,7 @@ static int block2mtd_setup(const char *val, struct kernel_param *kp)
         strcpy(str, val);
         kill_final_newline(str);
 
-        for (i=0; i<2; i++)
+        for (i = 0; i < 2; i++)
                 token[i] = strsep(&str, ",");
 
         if (str)
@@ -449,8 +460,10 @@ static int block2mtd_setup(const char *val, struct kernel_param *kp)
 
         if (token[1]) {
                 ret = parse_num(&erase_size, token[1]);
-                if (ret)
+                if (ret) {
+                        kfree(name);
                         parse_err("illegal erase size");
+                }
         }
 
         add_device(name, erase_size);
diff --git a/drivers/mtd/devices/doc2000.c b/drivers/mtd/devices/doc2000.c
index 23e7a5c7d2c1..c54e40464d82 100644
--- a/drivers/mtd/devices/doc2000.c
+++ b/drivers/mtd/devices/doc2000.c
@@ -59,13 +59,10 @@ static int doc_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
                         size_t *retlen, u_char *buf, u_char *eccbuf, struct nand_oobinfo *oobsel);
 static int doc_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
                          size_t *retlen, const u_char *buf, u_char *eccbuf, struct nand_oobinfo *oobsel);
-static int doc_writev_ecc(struct mtd_info *mtd, const struct kvec *vecs,
-                          unsigned long count, loff_t to, size_t *retlen,
-                          u_char *eccbuf, struct nand_oobinfo *oobsel);
-static int doc_read_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
-                        size_t *retlen, u_char *buf);
-static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
-                         size_t *retlen, const u_char *buf);
+static int doc_read_oob(struct mtd_info *mtd, loff_t ofs,
+                        struct mtd_oob_ops *ops);
+static int doc_write_oob(struct mtd_info *mtd, loff_t ofs,
+                         struct mtd_oob_ops *ops);
 static int doc_write_oob_nolock(struct mtd_info *mtd, loff_t ofs, size_t len,
                          size_t *retlen, const u_char *buf);
 static int doc_erase (struct mtd_info *mtd, struct erase_info *instr);
@@ -517,16 +514,9 @@ static int DoC2k_is_alias(struct DiskOnChip *doc1, struct DiskOnChip *doc2)
         return retval;
 }
 
-static const char im_name[] = "DoC2k_init";
-
-/* This routine is made available to other mtd code via
- * inter_module_register.  It must only be accessed through
- * inter_module_get which will bump the use count of this module.  The
- * addresses passed back in mtd are valid as long as the use count of
- * this module is non-zero, i.e. between inter_module_get and
- * inter_module_put.  Keith Owens <kaos@ocs.com.au> 29 Oct 2000.
- */
-static void DoC2k_init(struct mtd_info *mtd)
+/* This routine is found from the docprobe code by symbol_get(),
+ * which will bump the use count of this module. */
+void DoC2k_init(struct mtd_info *mtd)
 {
         struct DiskOnChip *this = mtd->priv;
         struct DiskOnChip *old = NULL;
@@ -586,7 +576,7 @@ static void DoC2k_init(struct mtd_info *mtd)
         mtd->ecctype = MTD_ECC_RS_DiskOnChip;
         mtd->size = 0;
         mtd->erasesize = 0;
-        mtd->oobblock = 512;
+        mtd->writesize = 512;
         mtd->oobsize = 16;
         mtd->owner = THIS_MODULE;
         mtd->erase = doc_erase;
@@ -594,9 +584,6 @@ static void DoC2k_init(struct mtd_info *mtd)
         mtd->unpoint = NULL;
         mtd->read = doc_read;
         mtd->write = doc_write;
-        mtd->read_ecc = doc_read_ecc;
-        mtd->write_ecc = doc_write_ecc;
-        mtd->writev_ecc = doc_writev_ecc;
         mtd->read_oob = doc_read_oob;
         mtd->write_oob = doc_write_oob;
         mtd->sync = NULL;
@@ -623,6 +610,7 @@ static void DoC2k_init(struct mtd_info *mtd)
                 return;
         }
 }
+EXPORT_SYMBOL_GPL(DoC2k_init);
 
 static int doc_read(struct mtd_info *mtd, loff_t from, size_t len,
                     size_t * retlen, u_char * buf)
@@ -971,72 +959,18 @@ static int doc_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
         return 0;
 }
 
-static int doc_writev_ecc(struct mtd_info *mtd, const struct kvec *vecs,
-                          unsigned long count, loff_t to, size_t *retlen,
-                          u_char *eccbuf, struct nand_oobinfo *oobsel)
-{
-        static char static_buf[512];
-        static DEFINE_MUTEX(writev_buf_mutex);
-
-        size_t totretlen = 0;
-        size_t thisvecofs = 0;
-        int ret= 0;
-
-        mutex_lock(&writev_buf_mutex);
-
-        while(count) {
-                size_t thislen, thisretlen;
-                unsigned char *buf;
-
-                buf = vecs->iov_base + thisvecofs;
-                thislen = vecs->iov_len - thisvecofs;
-
-
-                if (thislen >= 512) {
-                        thislen = thislen & ~(512-1);
-                        thisvecofs += thislen;
-                } else {
-                        /* Not enough to fill a page. Copy into buf */
-                        memcpy(static_buf, buf, thislen);
-                        buf = &static_buf[thislen];
-
-                        while(count && thislen < 512) {
-                                vecs++;
-                                count--;
-                                thisvecofs = min((512-thislen), vecs->iov_len);
-                                memcpy(buf, vecs->iov_base, thisvecofs);
-                                thislen += thisvecofs;
-                                buf += thisvecofs;
-                        }
-                        buf = static_buf;
-                }
-                if (count && thisvecofs == vecs->iov_len) {
-                        thisvecofs = 0;
-                        vecs++;
-                        count--;
-                }
-                ret = doc_write_ecc(mtd, to, thislen, &thisretlen, buf, eccbuf, oobsel);
-
-                totretlen += thisretlen;
-
-                if (ret || thisretlen != thislen)
-                        break;
-
-                to += thislen;
-        }
-
-        mutex_unlock(&writev_buf_mutex);
-        *retlen = totretlen;
-        return ret;
-}
-
-
-static int doc_read_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
-                        size_t * retlen, u_char * buf)
+static int doc_read_oob(struct mtd_info *mtd, loff_t ofs,
+                        struct mtd_oob_ops *ops)
 {
         struct DiskOnChip *this = mtd->priv;
         int len256 = 0, ret;
         struct Nand *mychip;
+        uint8_t *buf = ops->oobbuf;
+        size_t len = ops->len;
+
+        BUG_ON(ops->mode != MTD_OOB_PLACE);
+
+        ofs += ops->ooboffs;
 
         mutex_lock(&this->lock);
 
@@ -1077,7 +1011,7 @@ static int doc_read_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
 
         DoC_ReadBuf(this, &buf[len256], len - len256);
 
-        *retlen = len;
+        ops->retlen = len;
         /* Reading the full OOB data drops us off of the end of the page,
          * causing the flash device to go into busy mode, so we need
          * to wait until ready 11.4.1 and Toshiba TC58256FT docs */
@@ -1192,17 +1126,20 @@ static int doc_write_oob_nolock(struct mtd_info *mtd, loff_t ofs, size_t len,
 
 }
 
-static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
-                         size_t * retlen, const u_char * buf)
+static int doc_write_oob(struct mtd_info *mtd, loff_t ofs,
+                         struct mtd_oob_ops *ops)
 {
-        struct DiskOnChip *this = mtd->priv;
-        int ret;
+        struct DiskOnChip *this = mtd->priv;
+        int ret;
 
-        mutex_lock(&this->lock);
-        ret = doc_write_oob_nolock(mtd, ofs, len, retlen, buf);
+        BUG_ON(ops->mode != MTD_OOB_PLACE);
+
+        mutex_lock(&this->lock);
+        ret = doc_write_oob_nolock(mtd, ofs + ops->ooboffs, ops->len,
+                                   &ops->retlen, ops->oobbuf);
 
-        mutex_unlock(&this->lock);
-        return ret;
+        mutex_unlock(&this->lock);
+        return ret;
 }
 
 static int doc_erase(struct mtd_info *mtd, struct erase_info *instr)
@@ -1277,12 +1214,6 @@ static int doc_erase(struct mtd_info *mtd, struct erase_info *instr)
  *
  ****************************************************************************/
 
-static int __init init_doc2000(void)
-{
-       inter_module_register(im_name, THIS_MODULE, &DoC2k_init);
-       return 0;
-}
-
 static void __exit cleanup_doc2000(void)
 {
         struct mtd_info *mtd;
@@ -1298,11 +1229,9 @@ static void __exit cleanup_doc2000(void)
                 kfree(this->chips);
                 kfree(mtd);
         }
-        inter_module_unregister(im_name);
 }
 
 module_exit(cleanup_doc2000);
-module_init(init_doc2000);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org> et al.");
diff --git a/drivers/mtd/devices/doc2001.c b/drivers/mtd/devices/doc2001.c
index 681a9c73a2a3..0cf022a69e65 100644
--- a/drivers/mtd/devices/doc2001.c
+++ b/drivers/mtd/devices/doc2001.c
@@ -43,10 +43,10 @@ static int doc_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
 static int doc_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
                          size_t *retlen, const u_char *buf, u_char *eccbuf,
                          struct nand_oobinfo *oobsel);
-static int doc_read_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
-                        size_t *retlen, u_char *buf);
-static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
-                         size_t *retlen, const u_char *buf);
+static int doc_read_oob(struct mtd_info *mtd, loff_t ofs,
+                        struct mtd_oob_ops *ops);
+static int doc_write_oob(struct mtd_info *mtd, loff_t ofs,
+                         struct mtd_oob_ops *ops);
 static int doc_erase (struct mtd_info *mtd, struct erase_info *instr);
 
 static struct mtd_info *docmillist = NULL;
@@ -324,16 +324,9 @@ static int DoCMil_is_alias(struct DiskOnChip *doc1, struct DiskOnChip *doc2)
         return retval;
 }
 
-static const char im_name[] = "DoCMil_init";
-
-/* This routine is made available to other mtd code via
- * inter_module_register.  It must only be accessed through
- * inter_module_get which will bump the use count of this module.  The
- * addresses passed back in mtd are valid as long as the use count of
- * this module is non-zero, i.e. between inter_module_get and
- * inter_module_put.  Keith Owens <kaos@ocs.com.au> 29 Oct 2000.
- */
-static void DoCMil_init(struct mtd_info *mtd)
+/* This routine is found from the docprobe code by symbol_get(),
+ * which will bump the use count of this module. */
+void DoCMil_init(struct mtd_info *mtd)
 {
         struct DiskOnChip *this = mtd->priv;
         struct DiskOnChip *old = NULL;
@@ -368,7 +361,7 @@ static void DoCMil_init(struct mtd_info *mtd)
         /* FIXME: erase size is not always 8KiB */
         mtd->erasesize = 0x2000;
 
-        mtd->oobblock = 512;
+        mtd->writesize = 512;
         mtd->oobsize = 16;
         mtd->owner = THIS_MODULE;
         mtd->erase = doc_erase;
@@ -376,8 +369,6 @@ static void DoCMil_init(struct mtd_info *mtd)
         mtd->unpoint = NULL;
         mtd->read = doc_read;
         mtd->write = doc_write;
-        mtd->read_ecc = doc_read_ecc;
-        mtd->write_ecc = doc_write_ecc;
         mtd->read_oob = doc_read_oob;
         mtd->write_oob = doc_write_oob;
         mtd->sync = NULL;
@@ -401,6 +392,7 @@ static void DoCMil_init(struct mtd_info *mtd)
                 return;
         }
 }
+EXPORT_SYMBOL_GPL(DoCMil_init);
 
 static int doc_read (struct mtd_info *mtd, loff_t from, size_t len,
                      size_t *retlen, u_char *buf)
@@ -670,8 +662,8 @@ static int doc_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
         return ret;
 }
 
-static int doc_read_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
-                        size_t *retlen, u_char *buf)
+static int doc_read_oob(struct mtd_info *mtd, loff_t ofs,
+                        struct mtd_oob_ops *ops)
 {
 #ifndef USE_MEMCPY
         int i;
@@ -680,6 +672,12 @@ static int doc_read_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
         struct DiskOnChip *this = mtd->priv;
         void __iomem *docptr = this->virtadr;
         struct Nand *mychip = &this->chips[ofs >> this->chipshift];
+        uint8_t *buf = ops->oobbuf;
+        size_t len = ops->len;
+
+        BUG_ON(ops->mode != MTD_OOB_PLACE);
+
+        ofs += ops->ooboffs;
 
         /* Find the chip which is to be used and select it */
         if (this->curfloor != mychip->floor) {
@@ -716,13 +714,13 @@ static int doc_read_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
 #endif
         buf[len - 1] = ReadDOC(docptr, LastDataRead);
 
-        *retlen = len;
+        ops->retlen = len;
 
         return 0;
 }
 
-static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
-                         size_t *retlen, const u_char *buf)
+static int doc_write_oob(struct mtd_info *mtd, loff_t ofs,
+                         struct mtd_oob_ops *ops)
 {
 #ifndef USE_MEMCPY
         int i;
@@ -732,6 +730,12 @@ static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
         struct DiskOnChip *this = mtd->priv;
         void __iomem *docptr = this->virtadr;
         struct Nand *mychip = &this->chips[ofs >> this->chipshift];
+        uint8_t *buf = ops->oobbuf;
+        size_t len = ops->len;
+
+        BUG_ON(ops->mode != MTD_OOB_PLACE);
+
+        ofs += ops->ooboffs;
 
         /* Find the chip which is to be used and select it */
         if (this->curfloor != mychip->floor) {
@@ -783,12 +787,12 @@ static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
         if (ReadDOC(docptr, Mil_CDSN_IO) & 1) {
                 printk("Error programming oob data\n");
                 /* FIXME: implement Bad Block Replacement (in nftl.c ??) */
-                *retlen = 0;
+                ops->retlen = 0;
                 ret = -EIO;
         }
         dummy = ReadDOC(docptr, LastDataRead);
 
-        *retlen = len;
+        ops->retlen = len;
 
         return ret;
 }
@@ -856,12 +860,6 @@ int doc_erase (struct mtd_info *mtd, struct erase_info *instr)
  *
  ****************************************************************************/
 
-static int __init init_doc2001(void)
-{
-        inter_module_register(im_name, THIS_MODULE, &DoCMil_init);
-        return 0;
-}
-
 static void __exit cleanup_doc2001(void)
 {
         struct mtd_info *mtd;
@@ -877,11 +875,9 @@ static void __exit cleanup_doc2001(void)
                 kfree(this->chips);
                 kfree(mtd);
         }
-        inter_module_unregister(im_name);
 }
 
 module_exit(cleanup_doc2001);
-module_init(init_doc2001);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org> et al.");
diff --git a/drivers/mtd/devices/doc2001plus.c b/drivers/mtd/devices/doc2001plus.c
index 5f57f29efee4..66cb1e50469a 100644
--- a/drivers/mtd/devices/doc2001plus.c
+++ b/drivers/mtd/devices/doc2001plus.c
@@ -47,10 +47,10 @@ static int doc_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
 static int doc_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
                 size_t *retlen, const u_char *buf, u_char *eccbuf,
                 struct nand_oobinfo *oobsel);
-static int doc_read_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
-                size_t *retlen, u_char *buf);
-static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
-                size_t *retlen, const u_char *buf);
+static int doc_read_oob(struct mtd_info *mtd, loff_t ofs,
+                        struct mtd_oob_ops *ops);
+static int doc_write_oob(struct mtd_info *mtd, loff_t ofs,
+                         struct mtd_oob_ops *ops);
 static int doc_erase (struct mtd_info *mtd, struct erase_info *instr);
 
 static struct mtd_info *docmilpluslist = NULL;
@@ -447,16 +447,9 @@ static int DoCMilPlus_is_alias(struct DiskOnChip *doc1, struct DiskOnChip *doc2)
         return retval;
 }
 
-static const char im_name[] = "DoCMilPlus_init";
-
-/* This routine is made available to other mtd code via
- * inter_module_register.  It must only be accessed through
- * inter_module_get which will bump the use count of this module.  The
- * addresses passed back in mtd are valid as long as the use count of
- * this module is non-zero, i.e. between inter_module_get and
- * inter_module_put.  Keith Owens <kaos@ocs.com.au> 29 Oct 2000.
- */
-static void DoCMilPlus_init(struct mtd_info *mtd)
+/* This routine is found from the docprobe code by symbol_get(),
+ * which will bump the use count of this module. */
+void DoCMilPlus_init(struct mtd_info *mtd)
 {
         struct DiskOnChip *this = mtd->priv;
         struct DiskOnChip *old = NULL;
@@ -490,7 +483,7 @@ static void DoCMilPlus_init(struct mtd_info *mtd)
         mtd->size = 0;
 
         mtd->erasesize = 0;
-        mtd->oobblock = 512;
+        mtd->writesize = 512;
         mtd->oobsize = 16;
         mtd->owner = THIS_MODULE;
         mtd->erase = doc_erase;
@@ -498,8 +491,6 @@ static void DoCMilPlus_init(struct mtd_info *mtd)
         mtd->unpoint = NULL;
         mtd->read = doc_read;
         mtd->write = doc_write;
-        mtd->read_ecc = doc_read_ecc;
-        mtd->write_ecc = doc_write_ecc;
         mtd->read_oob = doc_read_oob;
         mtd->write_oob = doc_write_oob;
         mtd->sync = NULL;
@@ -524,6 +515,7 @@ static void DoCMilPlus_init(struct mtd_info *mtd)
                 return;
         }
 }
+EXPORT_SYMBOL_GPL(DoCMilPlus_init);
 
 #if 0
 static int doc_dumpblk(struct mtd_info *mtd, loff_t from)
@@ -876,14 +868,20 @@ static int doc_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
         return ret;
 }
 
-static int doc_read_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
-                        size_t *retlen, u_char *buf)
+static int doc_read_oob(struct mtd_info *mtd, loff_t ofs,
+                        struct mtd_oob_ops *ops)
 {
         loff_t fofs, base;
         struct DiskOnChip *this = mtd->priv;
         void __iomem * docptr = this->virtadr;
         struct Nand *mychip = &this->chips[ofs >> this->chipshift];
         size_t i, size, got, want;
+        uint8_t *buf = ops->oobbuf;
+        size_t len = ops->len;
+
+        BUG_ON(ops->mode != MTD_OOB_PLACE);
+
+        ofs += ops->ooboffs;
 
         DoC_CheckASIC(docptr);
 
@@ -949,12 +947,12 @@ static int doc_read_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
         /* Disable flash internally */
         WriteDOC(0, docptr, Mplus_FlashSelect);
 
-        *retlen = len;
+        ops->retlen = len;
         return 0;
 }
 
-static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
-                         size_t *retlen, const u_char *buf)
+static int doc_write_oob(struct mtd_info *mtd, loff_t ofs,
+                         struct mtd_oob_ops *ops)
 {
         volatile char dummy;
         loff_t fofs, base;
@@ -963,6 +961,12 @@ static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
         struct Nand *mychip = &this->chips[ofs >> this->chipshift];
         size_t i, size, got, want;
         int ret = 0;
+        uint8_t *buf = ops->oobbuf;
+        size_t len = ops->len;
+
+        BUG_ON(ops->mode != MTD_OOB_PLACE);
+
+        ofs += ops->ooboffs;
 
         DoC_CheckASIC(docptr);
 
@@ -1038,7 +1042,7 @@ static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
                         printk("MTD: Error 0x%x programming oob at 0x%x\n",
                                 dummy, (int)ofs);
                         /* FIXME: implement Bad Block Replacement */
-                        *retlen = 0;
+                        ops->retlen = 0;
                         ret = -EIO;
                 }
                 dummy = ReadDOC(docptr, Mplus_LastDataRead);
@@ -1051,7 +1055,7 @@ static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, size_t len,
         /* Disable flash internally */
         WriteDOC(0, docptr, Mplus_FlashSelect);
 
-        *retlen = len;
+        ops->retlen = len;
         return ret;
 }
 
@@ -1122,12 +1126,6 @@ int doc_erase(struct mtd_info *mtd, struct erase_info *instr)
  *
  ****************************************************************************/
 
-static int __init init_doc2001plus(void)
-{
-        inter_module_register(im_name, THIS_MODULE, &DoCMilPlus_init);
-        return 0;
-}
-
 static void __exit cleanup_doc2001plus(void)
 {
         struct mtd_info *mtd;
@@ -1143,11 +1141,9 @@ static void __exit cleanup_doc2001plus(void)
                 kfree(this->chips);
                 kfree(mtd);
         }
-        inter_module_unregister(im_name);
 }
 
 module_exit(cleanup_doc2001plus);
-module_init(init_doc2001plus);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Greg Ungerer <gerg@snapgear.com> et al.");
diff --git a/drivers/mtd/devices/docprobe.c b/drivers/mtd/devices/docprobe.c
index 13178b9dd00a..593bb033a3fa 100644
--- a/drivers/mtd/devices/docprobe.c
+++ b/drivers/mtd/devices/docprobe.c
@@ -231,6 +231,10 @@ static inline int __init doccheck(void __iomem *potential, unsigned long physadr
 
 static int docfound;
 
+extern void DoC2k_init(struct mtd_info *);
+extern void DoCMil_init(struct mtd_info *);
+extern void DoCMilPlus_init(struct mtd_info *);
+
 static void __init DoC_Probe(unsigned long physadr)
 {
         void __iomem *docptr;
@@ -239,8 +243,6 @@ static void __init DoC_Probe(unsigned long physadr)
         int ChipID;
         char namebuf[15];
         char *name = namebuf;
-        char *im_funcname = NULL;
-        char *im_modname = NULL;
         void (*initroutine)(struct mtd_info *) = NULL;
 
         docptr = ioremap(physadr, DOC_IOREMAP_LEN);
@@ -278,41 +280,33 @@ static void __init DoC_Probe(unsigned long physadr)
                 switch(ChipID) {
                 case DOC_ChipID_Doc2kTSOP:
                         name="2000 TSOP";
-                        im_funcname = "DoC2k_init";
-                        im_modname = "doc2000";
+                        initroutine = symbol_request(DoC2k_init);
                         break;
 
                 case DOC_ChipID_Doc2k:
                         name="2000";
-                        im_funcname = "DoC2k_init";
-                        im_modname = "doc2000";
+                        initroutine = symbol_request(DoC2k_init);
                         break;
 
                 case DOC_ChipID_DocMil:
                         name="Millennium";
 #ifdef DOC_SINGLE_DRIVER
-                        im_funcname = "DoC2k_init";
-                        im_modname = "doc2000";
+                        initroutine = symbol_request(DoC2k_init);
 #else
-                        im_funcname = "DoCMil_init";
-                        im_modname = "doc2001";
+                        initroutine = symbol_request(DoCMil_init);
 #endif /* DOC_SINGLE_DRIVER */
                         break;
 
                 case DOC_ChipID_DocMilPlus16:
                 case DOC_ChipID_DocMilPlus32:
                         name="MillenniumPlus";
-                        im_funcname = "DoCMilPlus_init";
-                        im_modname = "doc2001plus";
+                        initroutine = symbol_request(DoCMilPlus_init);
                         break;
                 }
 
-                if (im_funcname)
-                        initroutine = inter_module_get_request(im_funcname, im_modname);
-
                 if (initroutine) {
                         (*initroutine)(mtd);
-                        inter_module_put(im_funcname);
+                        symbol_put_addr(initroutine);
                         return;
                 }
                 printk(KERN_NOTICE "Cannot find driver for DiskOnChip %s at 0x%lX\n", name, physadr);
diff --git a/drivers/mtd/devices/lart.c b/drivers/mtd/devices/lart.c
index 29b0ddaa324e..4ea50a1dda85 100644
--- a/drivers/mtd/devices/lart.c
+++ b/drivers/mtd/devices/lart.c
@@ -635,6 +635,7 @@ int __init lart_flash_init (void)
    printk ("%s: This looks like a LART board to me.\n",module_name);
    mtd.name = module_name;
    mtd.type = MTD_NORFLASH;
+   mtd.writesize = 1;
    mtd.flags = MTD_CAP_NORFLASH;
    mtd.size = FLASH_BLOCKSIZE_PARAM * FLASH_NUMBLOCKS_16m_PARAM + FLASH_BLOCKSIZE_MAIN * FLASH_NUMBLOCKS_16m_MAIN;
    mtd.erasesize = FLASH_BLOCKSIZE_MAIN;
diff --git a/drivers/mtd/devices/m25p80.c b/drivers/mtd/devices/m25p80.c
index 04e65d5dae00..a8466141e914 100644
--- a/drivers/mtd/devices/m25p80.c
+++ b/drivers/mtd/devices/m25p80.c
@@ -465,6 +465,7 @@ static int __devinit m25p_probe(struct spi_device *spi)
                 flash->mtd.name = spi->dev.bus_id;
 
         flash->mtd.type = MTD_NORFLASH;
+        flash->mtd.writesize = 1;
         flash->mtd.flags = MTD_CAP_NORFLASH;
         flash->mtd.size = info->sector_size * info->n_sectors;
         flash->mtd.erasesize = info->sector_size;
diff --git a/drivers/mtd/devices/ms02-nv.c b/drivers/mtd/devices/ms02-nv.c
index 485f663493d2..4ab7670770e4 100644
--- a/drivers/mtd/devices/ms02-nv.c
+++ b/drivers/mtd/devices/ms02-nv.c
@@ -219,7 +219,7 @@ static int __init ms02nv_init_one(ulong addr)
         mp->uaddr = phys_to_virt(fixaddr);
 
         mtd->type = MTD_RAM;
-        mtd->flags = MTD_CAP_RAM | MTD_XIP;
+        mtd->flags = MTD_CAP_RAM;
         mtd->size = fixsize;
         mtd->name = (char *)ms02nv_name;
         mtd->owner = THIS_MODULE;
diff --git a/drivers/mtd/devices/mtdram.c b/drivers/mtd/devices/mtdram.c
index 1443117fd8f4..b4438eacfd80 100644
--- a/drivers/mtd/devices/mtdram.c
+++ b/drivers/mtd/devices/mtdram.c
@@ -106,6 +106,7 @@ int mtdram_init_device(struct mtd_info *mtd, void *mapped_address,
         mtd->type = MTD_RAM;
         mtd->flags = MTD_CAP_RAM;
         mtd->size = size;
+        mtd->writesize = 1;
         mtd->erasesize = MTDRAM_ERASE_SIZE;
         mtd->priv = mapped_address;
 
diff --git a/drivers/mtd/devices/phram.c b/drivers/mtd/devices/phram.c
index e8685ee6c1e4..e09e416667d3 100644
--- a/drivers/mtd/devices/phram.c
+++ b/drivers/mtd/devices/phram.c
@@ -1,8 +1,8 @@
 /**
  * $Id: phram.c,v 1.16 2005/11/07 11:14:25 gleixner Exp $
  *
- * Copyright (c) ????           Jochen Schäuble <psionic@psionic.de>
- * Copyright (c) 2003-2004      Jörn Engel <joern@wh.fh-wedel.de>
+ * Copyright (c) ????           Jochen Schäuble <psionic@psionic.de>
+ * Copyright (c) 2003-2004      Jörn Engel <joern@wh.fh-wedel.de>
  *
  * Usage:
  *
@@ -142,7 +142,7 @@ static int register_device(char *name, unsigned long start, unsigned long len)
 
         new->mtd.name = name;
         new->mtd.size = len;
-        new->mtd.flags = MTD_CAP_RAM | MTD_ERASEABLE | MTD_VOLATILE;
+        new->mtd.flags = MTD_CAP_RAM;
         new->mtd.erase = phram_erase;
         new->mtd.point = phram_point;
         new->mtd.unpoint = phram_unpoint;
@@ -266,12 +266,16 @@ static int phram_setup(const char *val, struct kernel_param *kp)
                 return 0;
 
         ret = parse_num32(&start, token[1]);
-        if (ret)
+        if (ret) {
+                kfree(name);
                 parse_err("illegal start address\n");
+        }
 
         ret = parse_num32(&len, token[2]);
-        if (ret)
+        if (ret) {
+                kfree(name);
                 parse_err("illegal device length\n");
+        }
 
         register_device(name, start, len);
 
@@ -296,5 +300,5 @@ module_init(init_phram);
 module_exit(cleanup_phram);
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Jörn Engel <joern@wh.fh-wedel.de>");
+MODULE_AUTHOR("Jörn Engel <joern@wh.fh-wedel.de>");
 MODULE_DESCRIPTION("MTD driver for physical RAM");
diff --git a/drivers/mtd/devices/slram.c b/drivers/mtd/devices/slram.c
index 6faee6c6958c..b3f665e3c38b 100644
--- a/drivers/mtd/devices/slram.c
+++ b/drivers/mtd/devices/slram.c
@@ -200,8 +200,7 @@ static int register_device(char *name, unsigned long start, unsigned long length
 
         (*curmtd)->mtdinfo->name = name;
         (*curmtd)->mtdinfo->size = length;
-        (*curmtd)->mtdinfo->flags = MTD_CLEAR_BITS | MTD_SET_BITS |
-                                        MTD_WRITEB_WRITEABLE | MTD_VOLATILE | MTD_CAP_RAM;
+        (*curmtd)->mtdinfo->flags = MTD_CAP_RAM;
         (*curmtd)->mtdinfo->erase = slram_erase;
         (*curmtd)->mtdinfo->point = slram_point;
         (*curmtd)->mtdinfo->unpoint = slram_unpoint;
diff --git a/drivers/mtd/inftlcore.c b/drivers/mtd/inftlcore.c
index a3b92479719d..1e21a2c3dd29 100644
--- a/drivers/mtd/inftlcore.c
+++ b/drivers/mtd/inftlcore.c
@@ -36,6 +36,7 @@
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/nftl.h>
 #include <linux/mtd/inftl.h>
+#include <linux/mtd/nand.h>
 #include <asm/uaccess.h>
 #include <asm/errno.h>
 #include <asm/io.h>
@@ -79,14 +80,12 @@ static void inftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
         inftl->mbd.devnum = -1;
         inftl->mbd.blksize = 512;
         inftl->mbd.tr = tr;
-        memcpy(&inftl->oobinfo, &mtd->oobinfo, sizeof(struct nand_oobinfo));
-        inftl->oobinfo.useecc = MTD_NANDECC_PLACEONLY;
 
-        if (INFTL_mount(inftl) < 0) {
+        if (INFTL_mount(inftl) < 0) {
                 printk(KERN_WARNING "INFTL: could not mount device\n");
                 kfree(inftl);
                 return;
-        }
+        }
 
         /* OK, it's a new one. Set up all the data structures. */
 
@@ -152,6 +151,69 @@ static void inftl_remove_dev(struct mtd_blktrans_dev *dev)
  */
 
 /*
+ * Read oob data from flash
+ */
+int inftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len,
+                   size_t *retlen, uint8_t *buf)
+{
+        struct mtd_oob_ops ops;
+        int res;
+
+        ops.mode = MTD_OOB_PLACE;
+        ops.ooboffs = offs & (mtd->writesize - 1);
+        ops.ooblen = len;
+        ops.oobbuf = buf;
+        ops.datbuf = NULL;
+        ops.len = len;
+
+        res = mtd->read_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
+        *retlen = ops.retlen;
+        return res;
+}
+
+/*
+ * Write oob data to flash
+ */
+int inftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len,
+                    size_t *retlen, uint8_t *buf)
+{
+        struct mtd_oob_ops ops;
+        int res;
+
+        ops.mode = MTD_OOB_PLACE;
+        ops.ooboffs = offs & (mtd->writesize - 1);
+        ops.ooblen = len;
+        ops.oobbuf = buf;
+        ops.datbuf = NULL;
+        ops.len = len;
+
+        res = mtd->write_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
+        *retlen = ops.retlen;
+        return res;
+}
+
+/*
+ * Write data and oob to flash
+ */
+static int inftl_write(struct mtd_info *mtd, loff_t offs, size_t len,
+                       size_t *retlen, uint8_t *buf, uint8_t *oob)
+{
+        struct mtd_oob_ops ops;
+        int res;
+
+        ops.mode = MTD_OOB_PLACE;
+        ops.ooboffs = offs;
+        ops.ooblen = mtd->oobsize;
+        ops.oobbuf = oob;
+        ops.datbuf = buf;
+        ops.len = len;
+
+        res = mtd->write_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
+        *retlen = ops.retlen;
+        return res;
+}
+
+/*
  * INFTL_findfreeblock: Find a free Erase Unit on the INFTL partition.
  *      This function is used when the give Virtual Unit Chain.
  */
@@ -198,10 +260,11 @@ static u16 INFTL_foldchain(struct INFTLrecord *inftl, unsigned thisVUC, unsigned
         u16 BlockMap[MAX_SECTORS_PER_UNIT];
         unsigned char BlockDeleted[MAX_SECTORS_PER_UNIT];
         unsigned int thisEUN, prevEUN, status;
+        struct mtd_info *mtd = inftl->mbd.mtd;
         int block, silly;
         unsigned int targetEUN;
         struct inftl_oob oob;
-        size_t retlen;
+        size_t retlen;
 
         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: INFTL_foldchain(inftl=%p,thisVUC=%d,"
                 "pending=%d)\n", inftl, thisVUC, pendingblock);
@@ -221,18 +284,18 @@ static u16 INFTL_foldchain(struct INFTLrecord *inftl, unsigned thisVUC, unsigned
          * Scan to find the Erase Unit which holds the actual data for each
          * 512-byte block within the Chain.
          */
-        silly = MAX_LOOPS;
+        silly = MAX_LOOPS;
         while (thisEUN < inftl->nb_blocks) {
                 for (block = 0; block < inftl->EraseSize/SECTORSIZE; block ++) {
                         if ((BlockMap[block] != 0xffff) || BlockDeleted[block])
                                 continue;
 
-                        if (MTD_READOOB(inftl->mbd.mtd, (thisEUN * inftl->EraseSize)
-                             + (block * SECTORSIZE), 16 , &retlen,
-                             (char *)&oob) < 0)
+                        if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize)
+                                           + (block * SECTORSIZE), 16, &retlen,
+                                           (char *)&oob) < 0)
                                 status = SECTOR_IGNORE;
                         else
-                                status = oob.b.Status | oob.b.Status1;
+                                status = oob.b.Status | oob.b.Status1;
 
                         switch(status) {
                         case SECTOR_FREE:
@@ -282,29 +345,31 @@ static u16 INFTL_foldchain(struct INFTLrecord *inftl, unsigned thisVUC, unsigned
                         continue;
                 }
 
-                /*
+                /*
                  * Copy only in non free block (free blocks can only
                  * happen in case of media errors or deleted blocks).
                  */
-                if (BlockMap[block] == BLOCK_NIL)
-                        continue;
-
-                ret = MTD_READ(inftl->mbd.mtd, (inftl->EraseSize *
-                        BlockMap[block]) + (block * SECTORSIZE), SECTORSIZE,
-                        &retlen, movebuf);
-                if (ret < 0) {
-                        ret = MTD_READ(inftl->mbd.mtd, (inftl->EraseSize *
-                                BlockMap[block]) + (block * SECTORSIZE),
-                                SECTORSIZE, &retlen, movebuf);
+                if (BlockMap[block] == BLOCK_NIL)
+                        continue;
+
+                ret = mtd->read(mtd, (inftl->EraseSize * BlockMap[block]) +
+                                (block * SECTORSIZE), SECTORSIZE, &retlen,
+                                movebuf);
+                if (ret < 0 && ret != -EUCLEAN) {
+                        ret = mtd->read(mtd,
+                                        (inftl->EraseSize * BlockMap[block]) +
+                                        (block * SECTORSIZE), SECTORSIZE,
+                                        &retlen, movebuf);
                         if (ret != -EIO)
-                                DEBUG(MTD_DEBUG_LEVEL1, "INFTL: error went "
-                                        "away on retry?\n");
-                }
-                memset(&oob, 0xff, sizeof(struct inftl_oob));
-                oob.b.Status = oob.b.Status1 = SECTOR_USED;
-                MTD_WRITEECC(inftl->mbd.mtd, (inftl->EraseSize * targetEUN) +
-                        (block * SECTORSIZE), SECTORSIZE, &retlen,
-                        movebuf, (char *)&oob, &inftl->oobinfo);
+                                DEBUG(MTD_DEBUG_LEVEL1, "INFTL: error went "
+                                      "away on retry?\n");
+                }
+                memset(&oob, 0xff, sizeof(struct inftl_oob));
+                oob.b.Status = oob.b.Status1 = SECTOR_USED;
+
+                inftl_write(inftl->mbd.mtd, (inftl->EraseSize * targetEUN) +
+                            (block * SECTORSIZE), SECTORSIZE, &retlen,
+                            movebuf, (char *)&oob);
         }
 
         /*
@@ -329,17 +394,17 @@ static u16 INFTL_foldchain(struct INFTLrecord *inftl, unsigned thisVUC, unsigned
                 if (thisEUN == targetEUN)
                         break;
 
-                if (INFTL_formatblock(inftl, thisEUN) < 0) {
+                if (INFTL_formatblock(inftl, thisEUN) < 0) {
                         /*
                          * Could not erase : mark block as reserved.
                          */
                         inftl->PUtable[thisEUN] = BLOCK_RESERVED;
-                } else {
+                } else {
                         /* Correctly erased : mark it as free */
                         inftl->PUtable[thisEUN] = BLOCK_FREE;
                         inftl->PUtable[prevEUN] = BLOCK_NIL;
                         inftl->numfreeEUNs++;
-                }
+                }
         }
 
         return targetEUN;
@@ -415,6 +480,7 @@ static inline u16 INFTL_findwriteunit(struct INFTLrecord *inftl, unsigned block)
         unsigned int thisVUC = block / (inftl->EraseSize / SECTORSIZE);
         unsigned int thisEUN, writeEUN, prev_block, status;
         unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize -1);
+        struct mtd_info *mtd = inftl->mbd.mtd;
         struct inftl_oob oob;
         struct inftl_bci bci;
         unsigned char anac, nacs, parity;
@@ -434,10 +500,10 @@ static inline u16 INFTL_findwriteunit(struct INFTLrecord *inftl, unsigned block)
                 silly = MAX_LOOPS;
 
                 while (thisEUN <= inftl->lastEUN) {
-                        MTD_READOOB(inftl->mbd.mtd, (thisEUN * inftl->EraseSize) +
-                                blockofs, 8, &retlen, (char *)&bci);
+                        inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) +
+                                       blockofs, 8, &retlen, (char *)&bci);
 
-                        status = bci.Status | bci.Status1;
+                        status = bci.Status | bci.Status1;
                         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: status of block %d in "
                                 "EUN %d is %x\n", block , writeEUN, status);
 
@@ -522,8 +588,8 @@ hitused:
                 nacs = 0;
                 thisEUN = inftl->VUtable[thisVUC];
                 if (thisEUN != BLOCK_NIL) {
-                        MTD_READOOB(inftl->mbd.mtd, thisEUN * inftl->EraseSize
-                                + 8, 8, &retlen, (char *)&oob.u);
+                        inftl_read_oob(mtd, thisEUN * inftl->EraseSize
+                                       + 8, 8, &retlen, (char *)&oob.u);
                         anac = oob.u.a.ANAC + 1;
                         nacs = oob.u.a.NACs + 1;
                 }
@@ -544,8 +610,8 @@ hitused:
                 oob.u.a.parityPerField = parity;
                 oob.u.a.discarded = 0xaa;
 
-                MTD_WRITEOOB(inftl->mbd.mtd, writeEUN * inftl->EraseSize + 8, 8,
-                        &retlen, (char *)&oob.u);
+                inftl_write_oob(mtd, writeEUN * inftl->EraseSize + 8, 8,
+                                &retlen, (char *)&oob.u);
 
                 /* Also back up header... */
                 oob.u.b.virtualUnitNo = cpu_to_le16(thisVUC);
@@ -555,8 +621,8 @@ hitused:
                 oob.u.b.parityPerField = parity;
                 oob.u.b.discarded = 0xaa;
 
-                MTD_WRITEOOB(inftl->mbd.mtd, writeEUN * inftl->EraseSize +
-                        SECTORSIZE * 4 + 8, 8, &retlen, (char *)&oob.u);
+                inftl_write_oob(mtd, writeEUN * inftl->EraseSize +
+                                SECTORSIZE * 4 + 8, 8, &retlen, (char *)&oob.u);
 
                 inftl->PUtable[writeEUN] = inftl->VUtable[thisVUC];
                 inftl->VUtable[thisVUC] = writeEUN;
@@ -576,6 +642,7 @@ hitused:
  */
 static void INFTL_trydeletechain(struct INFTLrecord *inftl, unsigned thisVUC)
 {
+        struct mtd_info *mtd = inftl->mbd.mtd;
         unsigned char BlockUsed[MAX_SECTORS_PER_UNIT];
         unsigned char BlockDeleted[MAX_SECTORS_PER_UNIT];
         unsigned int thisEUN, status;
@@ -606,9 +673,9 @@ static void INFTL_trydeletechain(struct INFTLrecord *inftl, unsigned thisVUC)
                         if (BlockUsed[block] || BlockDeleted[block])
                                 continue;
 
-                        if (MTD_READOOB(inftl->mbd.mtd, (thisEUN * inftl->EraseSize)
-                            + (block * SECTORSIZE), 8 , &retlen,
-                            (char *)&bci) < 0)
+                        if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize)
+                                           + (block * SECTORSIZE), 8 , &retlen,
+                                          (char *)&bci) < 0)
                                 status = SECTOR_IGNORE;
                         else
                                 status = bci.Status | bci.Status1;
@@ -670,12 +737,12 @@ static void INFTL_trydeletechain(struct INFTLrecord *inftl, unsigned thisVUC)
                 DEBUG(MTD_DEBUG_LEVEL3, "Deleting EUN %d from VUC %d\n",
                       thisEUN, thisVUC);
 
-                if (INFTL_formatblock(inftl, thisEUN) < 0) {
+                if (INFTL_formatblock(inftl, thisEUN) < 0) {
                         /*
                          * Could not erase : mark block as reserved.
                          */
                         inftl->PUtable[thisEUN] = BLOCK_RESERVED;
-                } else {
+                } else {
                         /* Correctly erased : mark it as free */
                         inftl->PUtable[thisEUN] = BLOCK_FREE;
                         inftl->numfreeEUNs++;
@@ -697,6 +764,7 @@ static int INFTL_deleteblock(struct INFTLrecord *inftl, unsigned block)
 {
         unsigned int thisEUN = inftl->VUtable[block / (inftl->EraseSize / SECTORSIZE)];
         unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1);
+        struct mtd_info *mtd = inftl->mbd.mtd;
         unsigned int status;
         int silly = MAX_LOOPS;
         size_t retlen;
@@ -706,8 +774,8 @@ static int INFTL_deleteblock(struct INFTLrecord *inftl, unsigned block)
                 "block=%d)\n", inftl, block);
 
         while (thisEUN < inftl->nb_blocks) {
-                if (MTD_READOOB(inftl->mbd.mtd, (thisEUN * inftl->EraseSize) +
-                    blockofs, 8, &retlen, (char *)&bci) < 0)
+                if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) +
+                                   blockofs, 8, &retlen, (char *)&bci) < 0)
                         status = SECTOR_IGNORE;
                 else
                         status = bci.Status | bci.Status1;
@@ -741,10 +809,10 @@ foundit:
         if (thisEUN != BLOCK_NIL) {
                 loff_t ptr = (thisEUN * inftl->EraseSize) + blockofs;
 
-                if (MTD_READOOB(inftl->mbd.mtd, ptr, 8, &retlen, (char *)&bci) < 0)
+                if (inftl_read_oob(mtd, ptr, 8, &retlen, (char *)&bci) < 0)
                         return -EIO;
                 bci.Status = bci.Status1 = SECTOR_DELETED;
-                if (MTD_WRITEOOB(inftl->mbd.mtd, ptr, 8, &retlen, (char *)&bci) < 0)
+                if (inftl_write_oob(mtd, ptr, 8, &retlen, (char *)&bci) < 0)
                         return -EIO;
                 INFTL_trydeletechain(inftl, block / (inftl->EraseSize / SECTORSIZE));
         }
@@ -784,9 +852,10 @@ static int inftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block,
 
                 memset(&oob, 0xff, sizeof(struct inftl_oob));
                 oob.b.Status = oob.b.Status1 = SECTOR_USED;
-                MTD_WRITEECC(inftl->mbd.mtd, (writeEUN * inftl->EraseSize) +
-                        blockofs, SECTORSIZE, &retlen, (char *)buffer,
-                        (char *)&oob, &inftl->oobinfo);
+
+                inftl_write(inftl->mbd.mtd, (writeEUN * inftl->EraseSize) +
+                            blockofs, SECTORSIZE, &retlen, (char *)buffer,
+                            (char *)&oob);
                 /*
                  * need to write SECTOR_USED flags since they are not written
                  * in mtd_writeecc
@@ -804,17 +873,18 @@ static int inftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
         struct INFTLrecord *inftl = (void *)mbd;
         unsigned int thisEUN = inftl->VUtable[block / (inftl->EraseSize / SECTORSIZE)];
         unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1);
-        unsigned int status;
+        struct mtd_info *mtd = inftl->mbd.mtd;
+        unsigned int status;
         int silly = MAX_LOOPS;
-        struct inftl_bci bci;
+        struct inftl_bci bci;
         size_t retlen;
 
         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: inftl_readblock(inftl=%p,block=%ld,"
                 "buffer=%p)\n", inftl, block, buffer);
 
         while (thisEUN < inftl->nb_blocks) {
-                if (MTD_READOOB(inftl->mbd.mtd, (thisEUN * inftl->EraseSize) +
-                     blockofs, 8, &retlen, (char *)&bci) < 0)
+                if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) +
+                                  blockofs, 8, &retlen, (char *)&bci) < 0)
                         status = SECTOR_IGNORE;
                 else
                         status = bci.Status | bci.Status1;
@@ -850,10 +920,12 @@ foundit:
                 /* The requested block is not on the media, return all 0x00 */
                 memset(buffer, 0, SECTORSIZE);
         } else {
-                size_t retlen;
+                size_t retlen;
                 loff_t ptr = (thisEUN * inftl->EraseSize) + blockofs;
-                if (MTD_READ(inftl->mbd.mtd, ptr, SECTORSIZE, &retlen,
-                    buffer))
+                int ret = mtd->read(mtd, ptr, SECTORSIZE, &retlen, buffer);
+
+                /* Handle corrected bit flips gracefully */
+                if (ret < 0 && ret != -EUCLEAN)
                         return -EIO;
         }
         return 0;
diff --git a/drivers/mtd/inftlmount.c b/drivers/mtd/inftlmount.c
index 43fdc9433882..8f6006f1a519 100644
--- a/drivers/mtd/inftlmount.c
+++ b/drivers/mtd/inftlmount.c
@@ -43,6 +43,11 @@
 
 char inftlmountrev[]="$Revision: 1.18 $";
 
+extern int inftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len,
+                          size_t *retlen, uint8_t *buf);
+extern int inftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len,
+                           size_t *retlen, uint8_t *buf);
+
 /*
  * find_boot_record: Find the INFTL Media Header and its Spare copy which
  *      contains the various device information of the INFTL partition and
@@ -57,6 +62,7 @@ static int find_boot_record(struct INFTLrecord *inftl)
         unsigned int i, block;
         u8 buf[SECTORSIZE];
         struct INFTLMediaHeader *mh = &inftl->MediaHdr;
+        struct mtd_info *mtd = inftl->mbd.mtd;
         struct INFTLPartition *ip;
         size_t retlen;
 
@@ -80,8 +86,8 @@ static int find_boot_record(struct INFTLrecord *inftl)
                  * Check for BNAND header first. Then whinge if it's found
                  * but later checks fail.
                  */
-                ret = MTD_READ(inftl->mbd.mtd, block * inftl->EraseSize,
-                    SECTORSIZE, &retlen, buf);
+                ret = mtd->read(mtd, block * inftl->EraseSize,
+                                SECTORSIZE, &retlen, buf);
                 /* We ignore ret in case the ECC of the MediaHeader is invalid
                    (which is apparently acceptable) */
                 if (retlen != SECTORSIZE) {
@@ -106,8 +112,9 @@ static int find_boot_record(struct INFTLrecord *inftl)
                 }
 
                 /* To be safer with BIOS, also use erase mark as discriminant */
-                if ((ret = MTD_READOOB(inftl->mbd.mtd, block * inftl->EraseSize +
-                    SECTORSIZE + 8, 8, &retlen, (char *)&h1) < 0)) {
+                if ((ret = inftl_read_oob(mtd, block * inftl->EraseSize +
+                                          SECTORSIZE + 8, 8, &retlen,
+                                          (char *)&h1) < 0)) {
                         printk(KERN_WARNING "INFTL: ANAND header found at "
                                 "0x%x in mtd%d, but OOB data read failed "
                                 "(err %d)\n", block * inftl->EraseSize,
@@ -123,8 +130,8 @@ static int find_boot_record(struct INFTLrecord *inftl)
                 memcpy(mh, buf, sizeof(struct INFTLMediaHeader));
 
                 /* Read the spare media header at offset 4096 */
-                MTD_READ(inftl->mbd.mtd, block * inftl->EraseSize + 4096,
-                    SECTORSIZE, &retlen, buf);
+                mtd->read(mtd, block * inftl->EraseSize + 4096,
+                          SECTORSIZE, &retlen, buf);
                 if (retlen != SECTORSIZE) {
                         printk(KERN_WARNING "INFTL: Unable to read spare "
                                "Media Header\n");
@@ -233,7 +240,7 @@ static int find_boot_record(struct INFTLrecord *inftl)
                                  */
                                 instr->addr = ip->Reserved0 * inftl->EraseSize;
                                 instr->len = inftl->EraseSize;
-                                MTD_ERASE(inftl->mbd.mtd, instr);
+                                mtd->erase(mtd, instr);
                         }
                         if ((ip->lastUnit - ip->firstUnit + 1) < ip->virtualUnits) {
                                 printk(KERN_WARNING "INFTL: Media Header "
@@ -350,21 +357,21 @@ static int check_free_sectors(struct INFTLrecord *inftl, unsigned int address,
         int len, int check_oob)
 {
         u8 buf[SECTORSIZE + inftl->mbd.mtd->oobsize];
+        struct mtd_info *mtd = inftl->mbd.mtd;
         size_t retlen;
         int i;
 
-        DEBUG(MTD_DEBUG_LEVEL3, "INFTL: check_free_sectors(inftl=%p,"
-                "address=0x%x,len=%d,check_oob=%d)\n", inftl,
-                address, len, check_oob);
-
         for (i = 0; i < len; i += SECTORSIZE) {
-                if (MTD_READECC(inftl->mbd.mtd, address, SECTORSIZE, &retlen, buf, &buf[SECTORSIZE], &inftl->oobinfo) < 0)
+                if (mtd->read(mtd, address, SECTORSIZE, &retlen, buf))
                         return -1;
                 if (memcmpb(buf, 0xff, SECTORSIZE) != 0)
                         return -1;
 
                 if (check_oob) {
-                        if (memcmpb(buf + SECTORSIZE, 0xff, inftl->mbd.mtd->oobsize) != 0)
+                        if(inftl_read_oob(mtd, address, mtd->oobsize,
+                                          &retlen, &buf[SECTORSIZE]) < 0)
+                                return -1;
+                        if (memcmpb(buf + SECTORSIZE, 0xff, mtd->oobsize) != 0)
                                 return -1;
                 }
                 address += SECTORSIZE;
@@ -387,6 +394,7 @@ int INFTL_formatblock(struct INFTLrecord *inftl, int block)
         size_t retlen;
         struct inftl_unittail uci;
         struct erase_info *instr = &inftl->instr;
+        struct mtd_info *mtd = inftl->mbd.mtd;
         int physblock;
 
         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: INFTL_formatblock(inftl=%p,"
@@ -404,8 +412,9 @@ int INFTL_formatblock(struct INFTLrecord *inftl, int block)
         /* Erase one physical eraseblock at a time, even though the NAND api
            allows us to group them.  This way we if we have a failure, we can
            mark only the failed block in the bbt. */
-        for (physblock = 0; physblock < inftl->EraseSize; physblock += instr->len, instr->addr += instr->len) {
-                MTD_ERASE(inftl->mbd.mtd, instr);
+        for (physblock = 0; physblock < inftl->EraseSize;
+             physblock += instr->len, instr->addr += instr->len) {
+                mtd->erase(inftl->mbd.mtd, instr);
 
                 if (instr->state == MTD_ERASE_FAILED) {
                         printk(KERN_WARNING "INFTL: error while formatting block %d\n",
@@ -414,10 +423,10 @@ int INFTL_formatblock(struct INFTLrecord *inftl, int block)
                 }
 
                 /*
-                * Check the "freeness" of Erase Unit before updating metadata.
-                * FixMe: is this check really necessary? Since we have check the
-                *        return code after the erase operation.
-                */
+                 * Check the "freeness" of Erase Unit before updating metadata.
+                 * FixMe: is this check really necessary? Since we have check
+                 * the return code after the erase operation.
+                 */
                 if (check_free_sectors(inftl, instr->addr, instr->len, 1) != 0)
                         goto fail;
         }
@@ -429,8 +438,7 @@ int INFTL_formatblock(struct INFTLrecord *inftl, int block)
         uci.Reserved[2] = 0;
         uci.Reserved[3] = 0;
         instr->addr = block * inftl->EraseSize + SECTORSIZE * 2;
-        if (MTD_WRITEOOB(inftl->mbd.mtd, instr->addr +
-            8, 8, &retlen, (char *)&uci) < 0)
+        if (inftl_write_oob(mtd, instr->addr + 8, 8, &retlen, (char *)&uci) < 0)
                 goto fail;
         return 0;
 fail:
@@ -549,6 +557,7 @@ void INFTL_dumpVUchains(struct INFTLrecord *s)
 
 int INFTL_mount(struct INFTLrecord *s)
 {
+        struct mtd_info *mtd = s->mbd.mtd;
         unsigned int block, first_block, prev_block, last_block;
         unsigned int first_logical_block, logical_block, erase_mark;
         int chain_length, do_format_chain;
@@ -607,10 +616,11 @@ int INFTL_mount(struct INFTLrecord *s)
                                 break;
                         }
 
-                        if (MTD_READOOB(s->mbd.mtd, block * s->EraseSize + 8,
-                            8, &retlen, (char *)&h0) < 0 ||
-                            MTD_READOOB(s->mbd.mtd, block * s->EraseSize +
-                            2 * SECTORSIZE + 8, 8, &retlen, (char *)&h1) < 0) {
+                        if (inftl_read_oob(mtd, block * s->EraseSize + 8,
+                                           8, &retlen, (char *)&h0) < 0 ||
+                            inftl_read_oob(mtd, block * s->EraseSize +
+                                           2 * SECTORSIZE + 8, 8, &retlen,
+                                           (char *)&h1) < 0) {
                                 /* Should never happen? */
                                 do_format_chain++;
                                 break;
diff --git a/drivers/mtd/maps/Kconfig b/drivers/mtd/maps/Kconfig
index 7abd7fee0dda..6bdaacc6d6f9 100644
--- a/drivers/mtd/maps/Kconfig
+++ b/drivers/mtd/maps/Kconfig
@@ -37,7 +37,7 @@ config MTD_PHYSMAP_START
 config MTD_PHYSMAP_LEN
         hex "Physical length of flash mapping"
         depends on MTD_PHYSMAP
-        default "0x4000000"
+        default "0"
         help
           This is the total length of the mapping of the flash chips on
           your particular board. If there is space, or aliases, in the
@@ -78,7 +78,7 @@ config MTD_PNC2000
 
 config MTD_SC520CDP
         tristate "CFI Flash device mapped on AMD SC520 CDP"
-        depends on X86 && MTD_CFI
+        depends on X86 && MTD_CFI && MTD_CONCAT
         help
           The SC520 CDP board has two banks of CFI-compliant chips and one
           Dual-in-line JEDEC chip. This 'mapping' driver supports that
@@ -109,7 +109,7 @@ config MTD_TS5500
           mtd1 allows you to reprogram your BIOS. BE VERY CAREFUL.
 
           Note that jumper 3 ("Write Enable Drive A") must be set
-          otherwise detection won't succeeed.
+          otherwise detection won't succeed.
 
 config MTD_SBC_GXX
         tristate "CFI Flash device mapped on Arcom SBC-GXx boards"
@@ -200,8 +200,8 @@ config MTD_TSUNAMI
           Support for the flash chip on Tsunami TIG bus.
 
 config MTD_LASAT
-        tristate "Flash chips on LASAT board"
-        depends on LASAT
+        tristate "LASAT flash device"
+        depends on LASAT && MTD_CFI
         help
           Support for the flash chips on the Lasat 100 and 200 boards.
 
@@ -561,7 +561,6 @@ config MTD_PCMCIA
 config MTD_PCMCIA_ANONYMOUS
         bool "Use PCMCIA MTD drivers for anonymous PCMCIA cards"
         depends on MTD_PCMCIA
-        default N
         help
           If this option is enabled, PCMCIA cards which do not report
           anything about themselves are assumed to be MTD cards.
diff --git a/drivers/mtd/maps/cfi_flagadm.c b/drivers/mtd/maps/cfi_flagadm.c
index fd0f0d3187de..92b5d883d7b0 100644
--- a/drivers/mtd/maps/cfi_flagadm.c
+++ b/drivers/mtd/maps/cfi_flagadm.c
@@ -1,5 +1,5 @@
 /*
- *  Copyright © 2001 Flaga hf. Medical Devices, Kári Davíðsson <kd@flaga.is>
+ *  Copyright © 2001 Flaga hf. Medical Devices, Kári Davíðsson <kd@flaga.is>
  *
  *  $Id: cfi_flagadm.c,v 1.15 2005/11/07 11:14:26 gleixner Exp $
  *
@@ -135,5 +135,5 @@ module_exit(cleanup_flagadm);
 
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Kári Davíðsson <kd@flaga.is>");
+MODULE_AUTHOR("Kári Davíðsson <kd@flaga.is>");
 MODULE_DESCRIPTION("MTD map driver for Flaga digital module");
diff --git a/drivers/mtd/maps/dbox2-flash.c b/drivers/mtd/maps/dbox2-flash.c
index 652813cd6c2d..85c2a9e22b1e 100644
--- a/drivers/mtd/maps/dbox2-flash.c
+++ b/drivers/mtd/maps/dbox2-flash.c
@@ -122,5 +122,5 @@ module_exit(cleanup_dbox2_flash);
 
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Kári Davíðsson <kd@flaga.is>, Bastian Blank <waldi@tuxbox.org>, Alexander Wild <wild@te-elektronik.com>");
+MODULE_AUTHOR("Kári Davíðsson <kd@flaga.is>, Bastian Blank <waldi@tuxbox.org>, Alexander Wild <wild@te-elektronik.com>");
 MODULE_DESCRIPTION("MTD map driver for D-Box 2 board");
diff --git a/drivers/mtd/maps/mtx-1_flash.c b/drivers/mtd/maps/mtx-1_flash.c
index d1e66e186746..5c25d4e552c6 100644
--- a/drivers/mtd/maps/mtx-1_flash.c
+++ b/drivers/mtd/maps/mtx-1_flash.c
@@ -4,7 +4,7 @@
  * $Id: mtx-1_flash.c,v 1.2 2005/11/07 11:14:27 gleixner Exp $
  *
  * (C) 2005 Bruno Randolf <bruno.randolf@4g-systems.biz>
- * (C) 2005 Jörn Engel <joern@wohnheim.fh-wedel.de>
+ * (C) 2005 Jörn Engel <joern@wohnheim.fh-wedel.de>
  *
  */
 
diff --git a/drivers/mtd/maps/nettel.c b/drivers/mtd/maps/nettel.c
index 54a3102ab19a..0994b5b2e331 100644
--- a/drivers/mtd/maps/nettel.c
+++ b/drivers/mtd/maps/nettel.c
@@ -20,6 +20,8 @@
 #include <linux/mtd/partitions.h>
 #include <linux/mtd/cfi.h>
 #include <linux/reboot.h>
+#include <linux/kdev_t.h>
+#include <linux/root_dev.h>
 #include <asm/io.h>
 
 /****************************************************************************/
@@ -188,7 +190,7 @@ int nettel_eraseconfig(void)
                 set_current_state(TASK_INTERRUPTIBLE);
                 add_wait_queue(&wait_q, &wait);
 
-                ret = MTD_ERASE(mtd, &nettel_erase);
+                ret = mtd->erase(mtd, &nettel_erase);
                 if (ret) {
                         set_current_state(TASK_RUNNING);
                         remove_wait_queue(&wait_q, &wait);
diff --git a/drivers/mtd/maps/pcmciamtd.c b/drivers/mtd/maps/pcmciamtd.c
index d27f4129afd3..c861134cbc48 100644
--- a/drivers/mtd/maps/pcmciamtd.c
+++ b/drivers/mtd/maps/pcmciamtd.c
@@ -713,6 +713,7 @@ static void pcmciamtd_detach(struct pcmcia_device *link)
 
         if(dev->mtd_info) {
                 del_mtd_device(dev->mtd_info);
+                map_destroy(dev->mtd_info);
                 info("mtd%d: Removed", dev->mtd_info->index);
         }
 
diff --git a/drivers/mtd/maps/physmap.c b/drivers/mtd/maps/physmap.c
index f49ebc3c4606..433c3cac3ca9 100644
--- a/drivers/mtd/maps/physmap.c
+++ b/drivers/mtd/maps/physmap.c
@@ -14,112 +14,229 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/slab.h>
-#include <asm/io.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
 #include <linux/config.h>
 #include <linux/mtd/partitions.h>
 #include <linux/mtd/physmap.h>
+#include <asm/io.h>
 
-static struct mtd_info *mymtd;
-
-struct map_info physmap_map = {
-        .name = "phys_mapped_flash",
-        .phys = CONFIG_MTD_PHYSMAP_START,
-        .size = CONFIG_MTD_PHYSMAP_LEN,
-        .bankwidth = CONFIG_MTD_PHYSMAP_BANKWIDTH,
+struct physmap_flash_info {
+        struct mtd_info         *mtd;
+        struct map_info         map;
+        struct resource         *res;
+#ifdef CONFIG_MTD_PARTITIONS
+        int                     nr_parts;
+        struct mtd_partition    *parts;
+#endif
 };
 
+
+static int physmap_flash_remove(struct platform_device *dev)
+{
+        struct physmap_flash_info *info;
+        struct physmap_flash_data *physmap_data;
+
+        info = platform_get_drvdata(dev);
+        if (info == NULL)
+                return 0;
+        platform_set_drvdata(dev, NULL);
+
+        physmap_data = dev->dev.platform_data;
+
+        if (info->mtd != NULL) {
 #ifdef CONFIG_MTD_PARTITIONS
-static struct mtd_partition *mtd_parts;
-static int                   mtd_parts_nb;
+                if (info->nr_parts) {
+                        del_mtd_partitions(info->mtd);
+                        kfree(info->parts);
+                } else if (physmap_data->nr_parts) {
+                        del_mtd_partitions(info->mtd);
+                } else {
+                        del_mtd_device(info->mtd);
+                }
+#else
+                del_mtd_device(info->mtd);
+#endif
+                map_destroy(info->mtd);
+        }
 
-static int num_physmap_partitions;
-static struct mtd_partition *physmap_partitions;
+        if (info->map.virt != NULL)
+                iounmap((void *)info->map.virt);
 
-static const char *part_probes[] __initdata = {"cmdlinepart", "RedBoot", NULL};
+        if (info->res != NULL) {
+                release_resource(info->res);
+                kfree(info->res);
+        }
 
-void physmap_set_partitions(struct mtd_partition *parts, int num_parts)
-{
-        physmap_partitions=parts;
-        num_physmap_partitions=num_parts;
+        return 0;
 }
-#endif /* CONFIG_MTD_PARTITIONS */
 
-static int __init init_physmap(void)
+static const char *rom_probe_types[] = { "cfi_probe", "jedec_probe", "map_rom", NULL };
+#ifdef CONFIG_MTD_PARTITIONS
+static const char *part_probe_types[] = { "cmdlinepart", "RedBoot", NULL };
+#endif
+
+static int physmap_flash_probe(struct platform_device *dev)
 {
-        static const char *rom_probe_types[] = { "cfi_probe", "jedec_probe", "map_rom", NULL };
-        const char **type;
+        struct physmap_flash_data *physmap_data;
+        struct physmap_flash_info *info;
+        const char **probe_type;
+        int err;
+
+        physmap_data = dev->dev.platform_data;
+        if (physmap_data == NULL)
+                return -ENODEV;
+
+        printk(KERN_NOTICE "physmap platform flash device: %.8llx at %.8llx\n",
+            (unsigned long long)dev->resource->end - dev->resource->start + 1,
+            (unsigned long long)dev->resource->start);
+
+        info = kmalloc(sizeof(struct physmap_flash_info), GFP_KERNEL);
+        if (info == NULL) {
+                err = -ENOMEM;
+                goto err_out;
+        }
+        memset(info, 0, sizeof(*info));
 
-        printk(KERN_NOTICE "physmap flash device: %lx at %lx\n", physmap_map.size, physmap_map.phys);
-        physmap_map.virt = ioremap(physmap_map.phys, physmap_map.size);
+        platform_set_drvdata(dev, info);
 
-        if (!physmap_map.virt) {
-                printk("Failed to ioremap\n");
-                return -EIO;
+        info->res = request_mem_region(dev->resource->start,
+                        dev->resource->end - dev->resource->start + 1,
+                        dev->dev.bus_id);
+        if (info->res == NULL) {
+                dev_err(&dev->dev, "Could not reserve memory region\n");
+                err = -ENOMEM;
+                goto err_out;
         }
 
-        simple_map_init(&physmap_map);
+        info->map.name = dev->dev.bus_id;
+        info->map.phys = dev->resource->start;
+        info->map.size = dev->resource->end - dev->resource->start + 1;
+        info->map.bankwidth = physmap_data->width;
+        info->map.set_vpp = physmap_data->set_vpp;
+
+        info->map.virt = ioremap(info->map.phys, info->map.size);
+        if (info->map.virt == NULL) {
+                dev_err(&dev->dev, "Failed to ioremap flash region\n");
+                err = EIO;
+                goto err_out;
+        }
 
-        mymtd = NULL;
-        type = rom_probe_types;
-        for(; !mymtd && *type; type++) {
-                mymtd = do_map_probe(*type, &physmap_map);
+        simple_map_init(&info->map);
+
+        probe_type = rom_probe_types;
+        for (; info->mtd == NULL && *probe_type != NULL; probe_type++)
+                info->mtd = do_map_probe(*probe_type, &info->map);
+        if (info->mtd == NULL) {
+                dev_err(&dev->dev, "map_probe failed\n");
+                err = -ENXIO;
+                goto err_out;
         }
-        if (mymtd) {
-                mymtd->owner = THIS_MODULE;
+        info->mtd->owner = THIS_MODULE;
 
 #ifdef CONFIG_MTD_PARTITIONS
-                mtd_parts_nb = parse_mtd_partitions(mymtd, part_probes,
-                                                    &mtd_parts, 0);
+        err = parse_mtd_partitions(info->mtd, part_probe_types, &info->parts, 0);
+        if (err > 0) {
+                add_mtd_partitions(info->mtd, info->parts, err);
+                return 0;
+        }
 
-                if (mtd_parts_nb > 0)
-                {
-                        add_mtd_partitions (mymtd, mtd_parts, mtd_parts_nb);
-                        return 0;
-                }
+        if (physmap_data->nr_parts) {
+                printk(KERN_NOTICE "Using physmap partition information\n");
+                add_mtd_partitions(info->mtd, physmap_data->parts,
+                                                physmap_data->nr_parts);
+                return 0;
+        }
+#endif
+
+        add_mtd_device(info->mtd);
+        return 0;
+
+err_out:
+        physmap_flash_remove(dev);
+        return err;
+}
+
+static struct platform_driver physmap_flash_driver = {
+        .probe          = physmap_flash_probe,
+        .remove         = physmap_flash_remove,
+        .driver         = {
+                .name   = "physmap-flash",
+        },
+};
 
-                if (num_physmap_partitions != 0)
-                {
-                        printk(KERN_NOTICE
-                               "Using physmap partition definition\n");
-                        add_mtd_partitions (mymtd, physmap_partitions, num_physmap_partitions);
-                        return 0;
-                }
 
+#ifdef CONFIG_MTD_PHYSMAP_LEN
+#if CONFIG_MTD_PHYSMAP_LEN != 0
+#warning using PHYSMAP compat code
+#define PHYSMAP_COMPAT
+#endif
 #endif
-                add_mtd_device(mymtd);
 
-                return 0;
-        }
+#ifdef PHYSMAP_COMPAT
+static struct physmap_flash_data physmap_flash_data = {
+        .width          = CONFIG_MTD_PHYSMAP_BANKWIDTH,
+};
 
-        iounmap(physmap_map.virt);
-        return -ENXIO;
-}
+static struct resource physmap_flash_resource = {
+        .start          = CONFIG_MTD_PHYSMAP_START,
+        .end            = CONFIG_MTD_PHYSMAP_START + CONFIG_MTD_PHYSMAP_LEN,
+        .flags          = IORESOURCE_MEM,
+};
 
-static void __exit cleanup_physmap(void)
+static struct platform_device physmap_flash = {
+        .name           = "physmap-flash",
+        .id             = 0,
+        .dev            = {
+                .platform_data  = &physmap_flash_data,
+        },
+        .num_resources  = 1,
+        .resource       = &physmap_flash_resource,
+};
+
+void physmap_configure(unsigned long addr, unsigned long size,
+                int bankwidth, void (*set_vpp)(struct map_info *, int))
 {
+        physmap_flash_resource.start = addr;
+        physmap_flash_resource.end = addr + size - 1;
+        physmap_flash_data.width = bankwidth;
+        physmap_flash_data.set_vpp = set_vpp;
+}
+
 #ifdef CONFIG_MTD_PARTITIONS
-        if (mtd_parts_nb) {
-                del_mtd_partitions(mymtd);
-                kfree(mtd_parts);
-        } else if (num_physmap_partitions) {
-                del_mtd_partitions(mymtd);
-        } else {
-                del_mtd_device(mymtd);
-        }
-#else
-        del_mtd_device(mymtd);
+void physmap_set_partitions(struct mtd_partition *parts, int num_parts)
+{
+        physmap_flash_data.nr_parts = num_parts;
+        physmap_flash_data.parts = parts;
+}
+#endif
 #endif
-        map_destroy(mymtd);
 
-        iounmap(physmap_map.virt);
-        physmap_map.virt = NULL;
+static int __init physmap_init(void)
+{
+        int err;
+
+        err = platform_driver_register(&physmap_flash_driver);
+#ifdef PHYSMAP_COMPAT
+        if (err == 0)
+                platform_device_register(&physmap_flash);
+#endif
+
+        return err;
 }
 
-module_init(init_physmap);
-module_exit(cleanup_physmap);
+static void __exit physmap_exit(void)
+{
+#ifdef PHYSMAP_COMPAT
+        platform_device_unregister(&physmap_flash);
+#endif
+        platform_driver_unregister(&physmap_flash_driver);
+}
 
+module_init(physmap_init);
+module_exit(physmap_exit);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
diff --git a/drivers/mtd/mtdblock.c b/drivers/mtd/mtdblock.c
index 2cef280e388c..e5c78463ebfd 100644
--- a/drivers/mtd/mtdblock.c
+++ b/drivers/mtd/mtdblock.c
@@ -71,7 +71,7 @@ static int erase_write (struct mtd_info *mtd, unsigned long pos,
         set_current_state(TASK_INTERRUPTIBLE);
         add_wait_queue(&wait_q, &wait);
 
-        ret = MTD_ERASE(mtd, &erase);
+        ret = mtd->erase(mtd, &erase);
         if (ret) {
                 set_current_state(TASK_RUNNING);
                 remove_wait_queue(&wait_q, &wait);
@@ -88,7 +88,7 @@ static int erase_write (struct mtd_info *mtd, unsigned long pos,
          * Next, writhe data to flash.
          */
 
-        ret = MTD_WRITE (mtd, pos, len, &retlen, buf);
+        ret = mtd->write(mtd, pos, len, &retlen, buf);
         if (ret)
                 return ret;
         if (retlen != len)
@@ -138,7 +138,7 @@ static int do_cached_write (struct mtdblk_dev *mtdblk, unsigned long pos,
                 mtd->name, pos, len);
 
         if (!sect_size)
-                return MTD_WRITE (mtd, pos, len, &retlen, buf);
+                return mtd->write(mtd, pos, len, &retlen, buf);
 
         while (len > 0) {
                 unsigned long sect_start = (pos/sect_size)*sect_size;
@@ -170,7 +170,8 @@ static int do_cached_write (struct mtdblk_dev *mtdblk, unsigned long pos,
                             mtdblk->cache_offset != sect_start) {
                                 /* fill the cache with the current sector */
                                 mtdblk->cache_state = STATE_EMPTY;
-                                ret = MTD_READ(mtd, sect_start, sect_size, &retlen, mtdblk->cache_data);
+                                ret = mtd->read(mtd, sect_start, sect_size,
+                                                &retlen, mtdblk->cache_data);
                                 if (ret)
                                         return ret;
                                 if (retlen != sect_size)
@@ -207,7 +208,7 @@ static int do_cached_read (struct mtdblk_dev *mtdblk, unsigned long pos,
                         mtd->name, pos, len);
 
         if (!sect_size)
-                return MTD_READ (mtd, pos, len, &retlen, buf);
+                return mtd->read(mtd, pos, len, &retlen, buf);
 
         while (len > 0) {
                 unsigned long sect_start = (pos/sect_size)*sect_size;
@@ -226,7 +227,7 @@ static int do_cached_read (struct mtdblk_dev *mtdblk, unsigned long pos,
                     mtdblk->cache_offset == sect_start) {
                         memcpy (buf, mtdblk->cache_data + offset, size);
                 } else {
-                        ret = MTD_READ (mtd, pos, size, &retlen, buf);
+                        ret = mtd->read(mtd, pos, size, &retlen, buf);
                         if (ret)
                                 return ret;
                         if (retlen != size)
@@ -288,8 +289,7 @@ static int mtdblock_open(struct mtd_blktrans_dev *mbd)
 
         mutex_init(&mtdblk->cache_mutex);
         mtdblk->cache_state = STATE_EMPTY;
-        if ((mtdblk->mtd->flags & MTD_CAP_RAM) != MTD_CAP_RAM &&
-            mtdblk->mtd->erasesize) {
+        if ( !(mtdblk->mtd->flags & MTD_NO_ERASE) && mtdblk->mtd->erasesize) {
                 mtdblk->cache_size = mtdblk->mtd->erasesize;
                 mtdblk->cache_data = NULL;
         }
diff --git a/drivers/mtd/mtdblock_ro.c b/drivers/mtd/mtdblock_ro.c
index 0c830ba41ef0..29563ed258a4 100644
--- a/drivers/mtd/mtdblock_ro.c
+++ b/drivers/mtd/mtdblock_ro.c
@@ -45,9 +45,7 @@ static void mtdblock_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
         dev->blksize = 512;
         dev->size = mtd->size >> 9;
         dev->tr = tr;
-        if ((mtd->flags & (MTD_CLEAR_BITS|MTD_SET_BITS|MTD_WRITEABLE)) !=
-            (MTD_CLEAR_BITS|MTD_SET_BITS|MTD_WRITEABLE))
-                dev->readonly = 1;
+        dev->readonly = 1;
 
         add_mtd_blktrans_dev(dev);
 }
diff --git a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c
index 6f044584bdc6..aa18d45b264b 100644
--- a/drivers/mtd/mtdchar.c
+++ b/drivers/mtd/mtdchar.c
@@ -49,24 +49,18 @@ static struct mtd_notifier notifier = {
 };
 
 /*
- * We use file->private_data to store a pointer to the MTDdevice.
- * Since alighment is at least 32 bits, we have 2 bits free for OTP
- * modes as well.
+ * Data structure to hold the pointer to the mtd device as well
+ * as mode information ofr various use cases.
  */
-
-#define TO_MTD(file) (struct mtd_info *)((long)((file)->private_data) & ~3L)
-
-#define MTD_MODE_OTP_FACT       1
-#define MTD_MODE_OTP_USER       2
-#define MTD_MODE(file)          ((long)((file)->private_data) & 3)
-
-#define SET_MTD_MODE(file, mode) \
-        do { long __p = (long)((file)->private_data); \
-             (file)->private_data = (void *)((__p & ~3L) | mode); } while (0)
+struct mtd_file_info {
+        struct mtd_info *mtd;
+        enum mtd_file_modes mode;
+};
 
 static loff_t mtd_lseek (struct file *file, loff_t offset, int orig)
 {
-        struct mtd_info *mtd = TO_MTD(file);
+        struct mtd_file_info *mfi = file->private_data;
+        struct mtd_info *mtd = mfi->mtd;
 
         switch (orig) {
         case 0:
@@ -97,6 +91,7 @@ static int mtd_open(struct inode *inode, struct file *file)
         int minor = iminor(inode);
         int devnum = minor >> 1;
         struct mtd_info *mtd;
+        struct mtd_file_info *mfi;
 
         DEBUG(MTD_DEBUG_LEVEL0, "MTD_open\n");
 
@@ -117,14 +112,20 @@ static int mtd_open(struct inode *inode, struct file *file)
                 return -ENODEV;
         }
 
-        file->private_data = mtd;
-
         /* You can't open it RW if it's not a writeable device */
         if ((file->f_mode & 2) && !(mtd->flags & MTD_WRITEABLE)) {
                 put_mtd_device(mtd);
                 return -EACCES;
         }
 
+        mfi = kzalloc(sizeof(*mfi), GFP_KERNEL);
+        if (!mfi) {
+                put_mtd_device(mtd);
+                return -ENOMEM;
+        }
+        mfi->mtd = mtd;
+        file->private_data = mfi;
+
         return 0;
 } /* mtd_open */
 
@@ -132,16 +133,17 @@ static int mtd_open(struct inode *inode, struct file *file)
 
 static int mtd_close(struct inode *inode, struct file *file)
 {
-        struct mtd_info *mtd;
+        struct mtd_file_info *mfi = file->private_data;
+        struct mtd_info *mtd = mfi->mtd;
 
         DEBUG(MTD_DEBUG_LEVEL0, "MTD_close\n");
 
-        mtd = TO_MTD(file);
-
         if (mtd->sync)
                 mtd->sync(mtd);
 
         put_mtd_device(mtd);
+        file->private_data = NULL;
+        kfree(mfi);
 
         return 0;
 } /* mtd_close */
@@ -153,7 +155,8 @@ static int mtd_close(struct inode *inode, struct file *file)
 
 static ssize_t mtd_read(struct file *file, char __user *buf, size_t count,loff_t *ppos)
 {
-        struct mtd_info *mtd = TO_MTD(file);
+        struct mtd_file_info *mfi = file->private_data;
+        struct mtd_info *mtd = mfi->mtd;
         size_t retlen=0;
         size_t total_retlen=0;
         int ret=0;
@@ -170,36 +173,58 @@ static ssize_t mtd_read(struct file *file, char __user *buf, size_t count,loff_t
 
         /* FIXME: Use kiovec in 2.5 to lock down the user's buffers
            and pass them directly to the MTD functions */
+
+        if (count > MAX_KMALLOC_SIZE)
+                kbuf=kmalloc(MAX_KMALLOC_SIZE, GFP_KERNEL);
+        else
+                kbuf=kmalloc(count, GFP_KERNEL);
+
+        if (!kbuf)
+                return -ENOMEM;
+
         while (count) {
+
                 if (count > MAX_KMALLOC_SIZE)
                         len = MAX_KMALLOC_SIZE;
                 else
                         len = count;
 
-                kbuf=kmalloc(len,GFP_KERNEL);
-                if (!kbuf)
-                        return -ENOMEM;
-
-                switch (MTD_MODE(file)) {
-                case MTD_MODE_OTP_FACT:
+                switch (mfi->mode) {
+                case MTD_MODE_OTP_FACTORY:
                         ret = mtd->read_fact_prot_reg(mtd, *ppos, len, &retlen, kbuf);
                         break;
                 case MTD_MODE_OTP_USER:
                         ret = mtd->read_user_prot_reg(mtd, *ppos, len, &retlen, kbuf);
                         break;
+                case MTD_MODE_RAW:
+                {
+                        struct mtd_oob_ops ops;
+
+                        ops.mode = MTD_OOB_RAW;
+                        ops.datbuf = kbuf;
+                        ops.oobbuf = NULL;
+                        ops.len = len;
+
+                        ret = mtd->read_oob(mtd, *ppos, &ops);
+                        retlen = ops.retlen;
+                        break;
+                }
                 default:
-                        ret = MTD_READ(mtd, *ppos, len, &retlen, kbuf);
+                        ret = mtd->read(mtd, *ppos, len, &retlen, kbuf);
                 }
                 /* Nand returns -EBADMSG on ecc errors, but it returns
                  * the data. For our userspace tools it is important
                  * to dump areas with ecc errors !
+                 * For kernel internal usage it also might return -EUCLEAN
+                 * to signal the caller that a bitflip has occured and has
+                 * been corrected by the ECC algorithm.
                  * Userspace software which accesses NAND this way
                  * must be aware of the fact that it deals with NAND
                  */
-                if (!ret || (ret == -EBADMSG)) {
+                if (!ret || (ret == -EUCLEAN) || (ret == -EBADMSG)) {
                         *ppos += retlen;
                         if (copy_to_user(buf, kbuf, retlen)) {
-                                kfree(kbuf);
+                                kfree(kbuf);
                                 return -EFAULT;
                         }
                         else
@@ -215,15 +240,16 @@ static ssize_t mtd_read(struct file *file, char __user *buf, size_t count,loff_t
                         return ret;
                 }
 
-                kfree(kbuf);
         }
 
+        kfree(kbuf);
         return total_retlen;
 } /* mtd_read */
 
 static ssize_t mtd_write(struct file *file, const char __user *buf, size_t count,loff_t *ppos)
 {
-        struct mtd_info *mtd = TO_MTD(file);
+        struct mtd_file_info *mfi = file->private_data;
+        struct mtd_info *mtd = mfi->mtd;
         char *kbuf;
         size_t retlen;
         size_t total_retlen=0;
@@ -241,25 +267,28 @@ static ssize_t mtd_write(struct file *file, const char __user *buf, size_t count
         if (!count)
                 return 0;
 
+        if (count > MAX_KMALLOC_SIZE)
+                kbuf=kmalloc(MAX_KMALLOC_SIZE, GFP_KERNEL);
+        else
+                kbuf=kmalloc(count, GFP_KERNEL);
+
+        if (!kbuf)
+                return -ENOMEM;
+
         while (count) {
+
                 if (count > MAX_KMALLOC_SIZE)
                         len = MAX_KMALLOC_SIZE;
                 else
                         len = count;
 
-                kbuf=kmalloc(len,GFP_KERNEL);
-                if (!kbuf) {
-                        printk("kmalloc is null\n");
-                        return -ENOMEM;
-                }
-
                 if (copy_from_user(kbuf, buf, len)) {
                         kfree(kbuf);
                         return -EFAULT;
                 }
 
-                switch (MTD_MODE(file)) {
-                case MTD_MODE_OTP_FACT:
+                switch (mfi->mode) {
+                case MTD_MODE_OTP_FACTORY:
                         ret = -EROFS;
                         break;
                 case MTD_MODE_OTP_USER:
@@ -269,6 +298,21 @@ static ssize_t mtd_write(struct file *file, const char __user *buf, size_t count
                         }
                         ret = mtd->write_user_prot_reg(mtd, *ppos, len, &retlen, kbuf);
                         break;
+
+                case MTD_MODE_RAW:
+                {
+                        struct mtd_oob_ops ops;
+
+                        ops.mode = MTD_OOB_RAW;
+                        ops.datbuf = kbuf;
+                        ops.oobbuf = NULL;
+                        ops.len = len;
+
+                        ret = mtd->write_oob(mtd, *ppos, &ops);
+                        retlen = ops.retlen;
+                        break;
+                }
+
                 default:
                         ret = (*(mtd->write))(mtd, *ppos, len, &retlen, kbuf);
                 }
@@ -282,10 +326,9 @@ static ssize_t mtd_write(struct file *file, const char __user *buf, size_t count
                         kfree(kbuf);
                         return ret;
                 }
-
-                kfree(kbuf);
         }
 
+        kfree(kbuf);
         return total_retlen;
 } /* mtd_write */
 
@@ -299,13 +342,45 @@ static void mtdchar_erase_callback (struct erase_info *instr)
         wake_up((wait_queue_head_t *)instr->priv);
 }
 
+#if defined(CONFIG_MTD_OTP) || defined(CONFIG_MTD_ONENAND_OTP)
+static int otp_select_filemode(struct mtd_file_info *mfi, int mode)
+{
+        struct mtd_info *mtd = mfi->mtd;
+        int ret = 0;
+
+        switch (mode) {
+        case MTD_OTP_FACTORY:
+                if (!mtd->read_fact_prot_reg)
+                        ret = -EOPNOTSUPP;
+                else
+                        mfi->mode = MTD_MODE_OTP_FACTORY;
+                break;
+        case MTD_OTP_USER:
+                if (!mtd->read_fact_prot_reg)
+                        ret = -EOPNOTSUPP;
+                else
+                        mfi->mode = MTD_MODE_OTP_USER;
+                break;
+        default:
+                ret = -EINVAL;
+        case MTD_OTP_OFF:
+                break;
+        }
+        return ret;
+}
+#else
+# define otp_select_filemode(f,m)       -EOPNOTSUPP
+#endif
+
 static int mtd_ioctl(struct inode *inode, struct file *file,
                      u_int cmd, u_long arg)
 {
-        struct mtd_info *mtd = TO_MTD(file);
+        struct mtd_file_info *mfi = file->private_data;
+        struct mtd_info *mtd = mfi->mtd;
         void __user *argp = (void __user *)arg;
         int ret = 0;
         u_long size;
+        struct mtd_info_user info;
 
         DEBUG(MTD_DEBUG_LEVEL0, "MTD_ioctl\n");
 
@@ -341,7 +416,15 @@ static int mtd_ioctl(struct inode *inode, struct file *file,
         }
 
         case MEMGETINFO:
-                if (copy_to_user(argp, mtd, sizeof(struct mtd_info_user)))
+                info.type       = mtd->type;
+                info.flags      = mtd->flags;
+                info.size       = mtd->size;
+                info.erasesize  = mtd->erasesize;
+                info.writesize  = mtd->writesize;
+                info.oobsize    = mtd->oobsize;
+                info.ecctype    = mtd->ecctype;
+                info.eccsize    = mtd->eccsize;
+                if (copy_to_user(argp, &info, sizeof(struct mtd_info_user)))
                         return -EFAULT;
                 break;
 
@@ -400,8 +483,7 @@ static int mtd_ioctl(struct inode *inode, struct file *file,
         case MEMWRITEOOB:
         {
                 struct mtd_oob_buf buf;
-                void *databuf;
-                ssize_t retlen;
+                struct mtd_oob_ops ops;
 
                 if(!(file->f_mode & 2))
                         return -EPERM;
@@ -409,7 +491,7 @@ static int mtd_ioctl(struct inode *inode, struct file *file,
                 if (copy_from_user(&buf, argp, sizeof(struct mtd_oob_buf)))
                         return -EFAULT;
 
-                if (buf.length > 0x4096)
+                if (buf.length > 4096)
                         return -EINVAL;
 
                 if (!mtd->write_oob)
@@ -421,21 +503,32 @@ static int mtd_ioctl(struct inode *inode, struct file *file,
                 if (ret)
                         return ret;
 
-                databuf = kmalloc(buf.length, GFP_KERNEL);
-                if (!databuf)
+                ops.len = buf.length;
+                ops.ooblen = buf.length;
+                ops.ooboffs = buf.start & (mtd->oobsize - 1);
+                ops.datbuf = NULL;
+                ops.mode = MTD_OOB_PLACE;
+
+                if (ops.ooboffs && ops.len > (mtd->oobsize - ops.ooboffs))
+                        return -EINVAL;
+
+                ops.oobbuf = kmalloc(buf.length, GFP_KERNEL);
+                if (!ops.oobbuf)
                         return -ENOMEM;
 
-                if (copy_from_user(databuf, buf.ptr, buf.length)) {
-                        kfree(databuf);
+                if (copy_from_user(ops.oobbuf, buf.ptr, buf.length)) {
+                        kfree(ops.oobbuf);
                         return -EFAULT;
                 }
 
-                ret = (mtd->write_oob)(mtd, buf.start, buf.length, &retlen, databuf);
+                buf.start &= ~(mtd->oobsize - 1);
+                ret = mtd->write_oob(mtd, buf.start, &ops);
 
-                if (copy_to_user(argp + sizeof(uint32_t), &retlen, sizeof(uint32_t)))
+                if (copy_to_user(argp + sizeof(uint32_t), &ops.retlen,
+                                 sizeof(uint32_t)))
                         ret = -EFAULT;
 
-                kfree(databuf);
+                kfree(ops.oobbuf);
                 break;
 
         }
@@ -443,13 +536,12 @@ static int mtd_ioctl(struct inode *inode, struct file *file,
         case MEMREADOOB:
         {
                 struct mtd_oob_buf buf;
-                void *databuf;
-                ssize_t retlen;
+                struct mtd_oob_ops ops;
 
                 if (copy_from_user(&buf, argp, sizeof(struct mtd_oob_buf)))
                         return -EFAULT;
 
-                if (buf.length > 0x4096)
+                if (buf.length > 4096)
                         return -EINVAL;
 
                 if (!mtd->read_oob)
@@ -457,22 +549,32 @@ static int mtd_ioctl(struct inode *inode, struct file *file,
                 else
                         ret = access_ok(VERIFY_WRITE, buf.ptr,
                                         buf.length) ? 0 : -EFAULT;
-
                 if (ret)
                         return ret;
 
-                databuf = kmalloc(buf.length, GFP_KERNEL);
-                if (!databuf)
+                ops.len = buf.length;
+                ops.ooblen = buf.length;
+                ops.ooboffs = buf.start & (mtd->oobsize - 1);
+                ops.datbuf = NULL;
+                ops.mode = MTD_OOB_PLACE;
+
+                if (ops.ooboffs && ops.len > (mtd->oobsize - ops.ooboffs))
+                        return -EINVAL;
+
+                ops.oobbuf = kmalloc(buf.length, GFP_KERNEL);
+                if (!ops.oobbuf)
                         return -ENOMEM;
 
-                ret = (mtd->read_oob)(mtd, buf.start, buf.length, &retlen, databuf);
+                buf.start &= ~(mtd->oobsize - 1);
+                ret = mtd->read_oob(mtd, buf.start, &ops);
 
-                if (put_user(retlen, (uint32_t __user *)argp))
+                if (put_user(ops.retlen, (uint32_t __user *)argp))
                         ret = -EFAULT;
-                else if (retlen && copy_to_user(buf.ptr, databuf, retlen))
+                else if (ops.retlen && copy_to_user(buf.ptr, ops.oobbuf,
+                                                    ops.retlen))
                         ret = -EFAULT;
 
-                kfree(databuf);
+                kfree(ops.oobbuf);
                 break;
         }
 
@@ -504,16 +606,22 @@ static int mtd_ioctl(struct inode *inode, struct file *file,
                 break;
         }
 
-        case MEMSETOOBSEL:
-        {
-                if (copy_from_user(&mtd->oobinfo, argp, sizeof(struct nand_oobinfo)))
-                        return -EFAULT;
-                break;
-        }
-
+        /* Legacy interface */
         case MEMGETOOBSEL:
         {
-                if (copy_to_user(argp, &(mtd->oobinfo), sizeof(struct nand_oobinfo)))
+                struct nand_oobinfo oi;
+
+                if (!mtd->ecclayout)
+                        return -EOPNOTSUPP;
+                if (mtd->ecclayout->eccbytes > ARRAY_SIZE(oi.eccpos))
+                        return -EINVAL;
+
+                oi.useecc = MTD_NANDECC_AUTOPLACE;
+                memcpy(&oi.eccpos, mtd->ecclayout->eccpos, sizeof(oi.eccpos));
+                memcpy(&oi.oobfree, mtd->ecclayout->oobfree,
+                       sizeof(oi.oobfree));
+
+                if (copy_to_user(argp, &oi, sizeof(struct nand_oobinfo)))
                         return -EFAULT;
                 break;
         }
@@ -544,31 +652,17 @@ static int mtd_ioctl(struct inode *inode, struct file *file,
                 break;
         }
 
-#ifdef CONFIG_MTD_OTP
+#if defined(CONFIG_MTD_OTP) || defined(CONFIG_MTD_ONENAND_OTP)
         case OTPSELECT:
         {
                 int mode;
                 if (copy_from_user(&mode, argp, sizeof(int)))
                         return -EFAULT;
-                SET_MTD_MODE(file, 0);
-                switch (mode) {
-                case MTD_OTP_FACTORY:
-                        if (!mtd->read_fact_prot_reg)
-                                ret = -EOPNOTSUPP;
-                        else
-                                SET_MTD_MODE(file, MTD_MODE_OTP_FACT);
-                        break;
-                case MTD_OTP_USER:
-                        if (!mtd->read_fact_prot_reg)
-                                ret = -EOPNOTSUPP;
-                        else
-                                SET_MTD_MODE(file, MTD_MODE_OTP_USER);
-                        break;
-                default:
-                        ret = -EINVAL;
-                case MTD_OTP_OFF:
-                        break;
-                }
+
+                mfi->mode = MTD_MODE_NORMAL;
+
+                ret = otp_select_filemode(mfi, mode);
+
                 file->f_pos = 0;
                 break;
         }
@@ -580,8 +674,8 @@ static int mtd_ioctl(struct inode *inode, struct file *file,
                 if (!buf)
                         return -ENOMEM;
                 ret = -EOPNOTSUPP;
-                switch (MTD_MODE(file)) {
-                case MTD_MODE_OTP_FACT:
+                switch (mfi->mode) {
+                case MTD_MODE_OTP_FACTORY:
                         if (mtd->get_fact_prot_info)
                                 ret = mtd->get_fact_prot_info(mtd, buf, 4096);
                         break;
@@ -589,6 +683,8 @@ static int mtd_ioctl(struct inode *inode, struct file *file,
                         if (mtd->get_user_prot_info)
                                 ret = mtd->get_user_prot_info(mtd, buf, 4096);
                         break;
+                default:
+                        break;
                 }
                 if (ret >= 0) {
                         if (cmd == OTPGETREGIONCOUNT) {
@@ -607,7 +703,7 @@ static int mtd_ioctl(struct inode *inode, struct file *file,
         {
                 struct otp_info info;
 
-                if (MTD_MODE(file) != MTD_MODE_OTP_USER)
+                if (mfi->mode != MTD_MODE_OTP_USER)
                         return -EINVAL;
                 if (copy_from_user(&info, argp, sizeof(info)))
                         return -EFAULT;
@@ -618,6 +714,49 @@ static int mtd_ioctl(struct inode *inode, struct file *file,
         }
 #endif
 
+        case ECCGETLAYOUT:
+        {
+                if (!mtd->ecclayout)
+                        return -EOPNOTSUPP;
+
+                if (copy_to_user(argp, &mtd->ecclayout,
+                                 sizeof(struct nand_ecclayout)))
+                        return -EFAULT;
+                break;
+        }
+
+        case ECCGETSTATS:
+        {
+                if (copy_to_user(argp, &mtd->ecc_stats,
+                                 sizeof(struct mtd_ecc_stats)))
+                        return -EFAULT;
+                break;
+        }
+
+        case MTDFILEMODE:
+        {
+                mfi->mode = 0;
+
+                switch(arg) {
+                case MTD_MODE_OTP_FACTORY:
+                case MTD_MODE_OTP_USER:
+                        ret = otp_select_filemode(mfi, arg);
+                        break;
+
+                case MTD_MODE_RAW:
+                        if (!mtd->read_oob || !mtd->write_oob)
+                                return -EOPNOTSUPP;
+                        mfi->mode = arg;
+
+                case MTD_MODE_NORMAL:
+                        break;
+                default:
+                        ret = -EINVAL;
+                }
+                file->f_pos = 0;
+                break;
+        }
+
         default:
                 ret = -ENOTTY;
         }
diff --git a/drivers/mtd/mtdconcat.c b/drivers/mtd/mtdconcat.c
index 9af840364a74..1fea631b5852 100644
--- a/drivers/mtd/mtdconcat.c
+++ b/drivers/mtd/mtdconcat.c
@@ -19,6 +19,8 @@
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/concat.h>
 
+#include <asm/div64.h>
+
 /*
  * Our storage structure:
  * Subdev points to an array of pointers to struct mtd_info objects
@@ -54,7 +56,7 @@ concat_read(struct mtd_info *mtd, loff_t from, size_t len,
             size_t * retlen, u_char * buf)
 {
         struct mtd_concat *concat = CONCAT(mtd);
-        int err = -EINVAL;
+        int ret = 0, err;
         int i;
 
         *retlen = 0;
@@ -78,19 +80,29 @@ concat_read(struct mtd_info *mtd, loff_t from, size_t len,
 
                 err = subdev->read(subdev, from, size, &retsize, buf);
 
-                if (err)
-                        break;
+                /* Save information about bitflips! */
+                if (unlikely(err)) {
+                        if (err == -EBADMSG) {
+                                mtd->ecc_stats.failed++;
+                                ret = err;
+                        } else if (err == -EUCLEAN) {
+                                mtd->ecc_stats.corrected++;
+                                /* Do not overwrite -EBADMSG !! */
+                                if (!ret)
+                                        ret = err;
+                        } else
+                                return err;
+                }
 
                 *retlen += retsize;
                 len -= size;
                 if (len == 0)
-                        break;
+                        return ret;
 
-                err = -EINVAL;
                 buf += size;
                 from = 0;
         }
-        return err;
+        return -EINVAL;
 }
 
 static int
@@ -141,211 +153,185 @@ concat_write(struct mtd_info *mtd, loff_t to, size_t len,
 }
 
 static int
-concat_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
-                size_t * retlen, u_char * buf, u_char * eccbuf,
-                struct nand_oobinfo *oobsel)
+concat_writev(struct mtd_info *mtd, const struct kvec *vecs,
+                unsigned long count, loff_t to, size_t * retlen)
 {
         struct mtd_concat *concat = CONCAT(mtd);
-        int err = -EINVAL;
+        struct kvec *vecs_copy;
+        unsigned long entry_low, entry_high;
+        size_t total_len = 0;
         int i;
+        int err = -EINVAL;
 
-        *retlen = 0;
-
-        for (i = 0; i < concat->num_subdev; i++) {
-                struct mtd_info *subdev = concat->subdev[i];
-                size_t size, retsize;
-
-                if (from >= subdev->size) {
-                        /* Not destined for this subdev */
-                        size = 0;
-                        from -= subdev->size;
-                        continue;
-                }
-
-                if (from + len > subdev->size)
-                        /* First part goes into this subdev */
-                        size = subdev->size - from;
-                else
-                        /* Entire transaction goes into this subdev */
-                        size = len;
+        if (!(mtd->flags & MTD_WRITEABLE))
+                return -EROFS;
 
-                if (subdev->read_ecc)
-                        err = subdev->read_ecc(subdev, from, size,
-                                               &retsize, buf, eccbuf, oobsel);
-                else
-                        err = -EINVAL;
+        *retlen = 0;
 
-                if (err)
-                        break;
+        /* Calculate total length of data */
+        for (i = 0; i < count; i++)
+                total_len += vecs[i].iov_len;
 
-                *retlen += retsize;
-                len -= size;
-                if (len == 0)
-                        break;
+        /* Do not allow write past end of device */
+        if ((to + total_len) > mtd->size)
+                return -EINVAL;
 
-                err = -EINVAL;
-                buf += size;
-                if (eccbuf) {
-                        eccbuf += subdev->oobsize;
-                        /* in nand.c at least, eccbufs are
-                           tagged with 2 (int)eccstatus'; we
-                           must account for these */
-                        eccbuf += 2 * (sizeof (int));
-                }
-                from = 0;
+        /* Check alignment */
+        if (mtd->writesize > 1) {
+                loff_t __to = to;
+                if (do_div(__to, mtd->writesize) || (total_len % mtd->writesize))
+                        return -EINVAL;
         }
-        return err;
-}
 
-static int
-concat_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
-                 size_t * retlen, const u_char * buf, u_char * eccbuf,
-                 struct nand_oobinfo *oobsel)
-{
-        struct mtd_concat *concat = CONCAT(mtd);
-        int err = -EINVAL;
-        int i;
-
-        if (!(mtd->flags & MTD_WRITEABLE))
-                return -EROFS;
-
-        *retlen = 0;
+        /* make a copy of vecs */
+        vecs_copy = kmalloc(sizeof(struct kvec) * count, GFP_KERNEL);
+        if (!vecs_copy)
+                return -ENOMEM;
+        memcpy(vecs_copy, vecs, sizeof(struct kvec) * count);
 
+        entry_low = 0;
         for (i = 0; i < concat->num_subdev; i++) {
                 struct mtd_info *subdev = concat->subdev[i];
-                size_t size, retsize;
+                size_t size, wsize, retsize, old_iov_len;
 
                 if (to >= subdev->size) {
-                        size = 0;
                         to -= subdev->size;
                         continue;
                 }
-                if (to + len > subdev->size)
-                        size = subdev->size - to;
-                else
-                        size = len;
+
+                size = min(total_len, (size_t)(subdev->size - to));
+                wsize = size; /* store for future use */
+
+                entry_high = entry_low;
+                while (entry_high < count) {
+                        if (size <= vecs_copy[entry_high].iov_len)
+                                break;
+                        size -= vecs_copy[entry_high++].iov_len;
+                }
+
+                old_iov_len = vecs_copy[entry_high].iov_len;
+                vecs_copy[entry_high].iov_len = size;
 
                 if (!(subdev->flags & MTD_WRITEABLE))
                         err = -EROFS;
-                else if (subdev->write_ecc)
-                        err = subdev->write_ecc(subdev, to, size,
-                                                &retsize, buf, eccbuf, oobsel);
                 else
-                        err = -EINVAL;
+                        err = subdev->writev(subdev, &vecs_copy[entry_low],
+                                entry_high - entry_low + 1, to, &retsize);
+
+                vecs_copy[entry_high].iov_len = old_iov_len - size;
+                vecs_copy[entry_high].iov_base += size;
+
+                entry_low = entry_high;
 
                 if (err)
                         break;
 
                 *retlen += retsize;
-                len -= size;
-                if (len == 0)
+                total_len -= wsize;
+
+                if (total_len == 0)
                         break;
 
                 err = -EINVAL;
-                buf += size;
-                if (eccbuf)
-                        eccbuf += subdev->oobsize;
                 to = 0;
         }
+
+        kfree(vecs_copy);
         return err;
 }
 
 static int
-concat_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
-                size_t * retlen, u_char * buf)
+concat_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops)
 {
         struct mtd_concat *concat = CONCAT(mtd);
-        int err = -EINVAL;
-        int i;
+        struct mtd_oob_ops devops = *ops;
+        int i, err, ret = 0;
 
-        *retlen = 0;
+        ops->retlen = 0;
 
         for (i = 0; i < concat->num_subdev; i++) {
                 struct mtd_info *subdev = concat->subdev[i];
-                size_t size, retsize;
 
                 if (from >= subdev->size) {
-                        /* Not destined for this subdev */
-                        size = 0;
                         from -= subdev->size;
                         continue;
                 }
-                if (from + len > subdev->size)
-                        /* First part goes into this subdev */
-                        size = subdev->size - from;
-                else
-                        /* Entire transaction goes into this subdev */
-                        size = len;
 
-                if (subdev->read_oob)
-                        err = subdev->read_oob(subdev, from, size,
-                                               &retsize, buf);
-                else
-                        err = -EINVAL;
+                /* partial read ? */
+                if (from + devops.len > subdev->size)
+                        devops.len = subdev->size - from;
+
+                err = subdev->read_oob(subdev, from, &devops);
+                ops->retlen += devops.retlen;
+
+                /* Save information about bitflips! */
+                if (unlikely(err)) {
+                        if (err == -EBADMSG) {
+                                mtd->ecc_stats.failed++;
+                                ret = err;
+                        } else if (err == -EUCLEAN) {
+                                mtd->ecc_stats.corrected++;
+                                /* Do not overwrite -EBADMSG !! */
+                                if (!ret)
+                                        ret = err;
+                        } else
+                                return err;
+                }
 
-                if (err)
-                        break;
+                devops.len = ops->len - ops->retlen;
+                if (!devops.len)
+                        return ret;
 
-                *retlen += retsize;
-                len -= size;
-                if (len == 0)
-                        break;
+                if (devops.datbuf)
+                        devops.datbuf += devops.retlen;
+                if (devops.oobbuf)
+                        devops.oobbuf += devops.ooblen;
 
-                err = -EINVAL;
-                buf += size;
                 from = 0;
         }
-        return err;
+        return -EINVAL;
 }
 
 static int
-concat_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
-                 size_t * retlen, const u_char * buf)
+concat_write_oob(struct mtd_info *mtd, loff_t to, struct mtd_oob_ops *ops)
 {
         struct mtd_concat *concat = CONCAT(mtd);
-        int err = -EINVAL;
-        int i;
+        struct mtd_oob_ops devops = *ops;
+        int i, err;
 
         if (!(mtd->flags & MTD_WRITEABLE))
                 return -EROFS;
 
-        *retlen = 0;
+        ops->retlen = 0;
 
         for (i = 0; i < concat->num_subdev; i++) {
                 struct mtd_info *subdev = concat->subdev[i];
-                size_t size, retsize;
 
                 if (to >= subdev->size) {
-                        size = 0;
                         to -= subdev->size;
                         continue;
                 }
-                if (to + len > subdev->size)
-                        size = subdev->size - to;
-                else
-                        size = len;
 
-                if (!(subdev->flags & MTD_WRITEABLE))
-                        err = -EROFS;
-                else if (subdev->write_oob)
-                        err = subdev->write_oob(subdev, to, size, &retsize,
-                                                buf);
-                else
-                        err = -EINVAL;
+                /* partial write ? */
+                if (to + devops.len > subdev->size)
+                        devops.len = subdev->size - to;
 
+                err = subdev->write_oob(subdev, to, &devops);
+                ops->retlen += devops.retlen;
                 if (err)
-                        break;
+                        return err;
 
-                *retlen += retsize;
-                len -= size;
-                if (len == 0)
-                        break;
+                devops.len = ops->len - ops->retlen;
+                if (!devops.len)
+                        return 0;
 
-                err = -EINVAL;
-                buf += size;
+                if (devops.datbuf)
+                        devops.datbuf += devops.retlen;
+                if (devops.oobbuf)
+                        devops.oobbuf += devops.ooblen;
                 to = 0;
         }
-        return err;
+        return -EINVAL;
 }
 
 static void concat_erase_callback(struct erase_info *instr)
@@ -636,6 +622,60 @@ static void concat_resume(struct mtd_info *mtd)
         }
 }
 
+static int concat_block_isbad(struct mtd_info *mtd, loff_t ofs)
+{
+        struct mtd_concat *concat = CONCAT(mtd);
+        int i, res = 0;
+
+        if (!concat->subdev[0]->block_isbad)
+                return res;
+
+        if (ofs > mtd->size)
+                return -EINVAL;
+
+        for (i = 0; i < concat->num_subdev; i++) {
+                struct mtd_info *subdev = concat->subdev[i];
+
+                if (ofs >= subdev->size) {
+                        ofs -= subdev->size;
+                        continue;
+                }
+
+                res = subdev->block_isbad(subdev, ofs);
+                break;
+        }
+
+        return res;
+}
+
+static int concat_block_markbad(struct mtd_info *mtd, loff_t ofs)
+{
+        struct mtd_concat *concat = CONCAT(mtd);
+        int i, err = -EINVAL;
+
+        if (!concat->subdev[0]->block_markbad)
+                return 0;
+
+        if (ofs > mtd->size)
+                return -EINVAL;
+
+        for (i = 0; i < concat->num_subdev; i++) {
+                struct mtd_info *subdev = concat->subdev[i];
+
+                if (ofs >= subdev->size) {
+                        ofs -= subdev->size;
+                        continue;
+                }
+
+                err = subdev->block_markbad(subdev, ofs);
+                if (!err)
+                        mtd->ecc_stats.badblocks++;
+                break;
+        }
+
+        return err;
+}
+
 /*
  * This function constructs a virtual MTD device by concatenating
  * num_devs MTD devices. A pointer to the new device object is
@@ -677,18 +717,22 @@ struct mtd_info *mtd_concat_create(struct mtd_info *subdev[],	/* subdevices to c
         concat->mtd.flags = subdev[0]->flags;
         concat->mtd.size = subdev[0]->size;
         concat->mtd.erasesize = subdev[0]->erasesize;
-        concat->mtd.oobblock = subdev[0]->oobblock;
+        concat->mtd.writesize = subdev[0]->writesize;
         concat->mtd.oobsize = subdev[0]->oobsize;
         concat->mtd.ecctype = subdev[0]->ecctype;
         concat->mtd.eccsize = subdev[0]->eccsize;
-        if (subdev[0]->read_ecc)
-                concat->mtd.read_ecc = concat_read_ecc;
-        if (subdev[0]->write_ecc)
-                concat->mtd.write_ecc = concat_write_ecc;
+        if (subdev[0]->writev)
+                concat->mtd.writev = concat_writev;
         if (subdev[0]->read_oob)
                 concat->mtd.read_oob = concat_read_oob;
         if (subdev[0]->write_oob)
                 concat->mtd.write_oob = concat_write_oob;
+        if (subdev[0]->block_isbad)
+                concat->mtd.block_isbad = concat_block_isbad;
+        if (subdev[0]->block_markbad)
+                concat->mtd.block_markbad = concat_block_markbad;
+
+        concat->mtd.ecc_stats.badblocks = subdev[0]->ecc_stats.badblocks;
 
         concat->subdev[0] = subdev[0];
 
@@ -717,12 +761,12 @@ struct mtd_info *mtd_concat_create(struct mtd_info *subdev[],	/* subdevices to c
                                     subdev[i]->flags & MTD_WRITEABLE;
                 }
                 concat->mtd.size += subdev[i]->size;
-                if (concat->mtd.oobblock   !=  subdev[i]->oobblock ||
+                concat->mtd.ecc_stats.badblocks +=
+                        subdev[i]->ecc_stats.badblocks;
+                if (concat->mtd.writesize   !=  subdev[i]->writesize ||
                     concat->mtd.oobsize    !=  subdev[i]->oobsize ||
                     concat->mtd.ecctype    !=  subdev[i]->ecctype ||
                     concat->mtd.eccsize    !=  subdev[i]->eccsize ||
-                    !concat->mtd.read_ecc  != !subdev[i]->read_ecc ||
-                    !concat->mtd.write_ecc != !subdev[i]->write_ecc ||
                     !concat->mtd.read_oob  != !subdev[i]->read_oob ||
                     !concat->mtd.write_oob != !subdev[i]->write_oob) {
                         kfree(concat);
@@ -734,14 +778,11 @@ struct mtd_info *mtd_concat_create(struct mtd_info *subdev[],	/* subdevices to c
 
         }
 
+        concat->mtd.ecclayout = subdev[0]->ecclayout;
+
         concat->num_subdev = num_devs;
         concat->mtd.name = name;
 
-        /*
-         * NOTE: for now, we do not provide any readv()/writev() methods
-         *       because they are messy to implement and they are not
-         *       used to a great extent anyway.
-         */
         concat->mtd.erase = concat_erase;
         concat->mtd.read = concat_read;
         concat->mtd.write = concat_write;
diff --git a/drivers/mtd/mtdcore.c b/drivers/mtd/mtdcore.c
index 9905870f56e5..16a952dd486a 100644
--- a/drivers/mtd/mtdcore.c
+++ b/drivers/mtd/mtdcore.c
@@ -47,6 +47,7 @@ int add_mtd_device(struct mtd_info *mtd)
 {
         int i;
 
+        BUG_ON(mtd->writesize == 0);
         mutex_lock(&mtd_table_mutex);
 
         for (i=0; i < MAX_MTD_DEVICES; i++)
@@ -254,37 +255,6 @@ int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
         return ret;
 }
 
-
-/* default_mtd_readv - default mtd readv method for MTD devices that dont
- *                     implement their own
- */
-
-int default_mtd_readv(struct mtd_info *mtd, struct kvec *vecs,
-                      unsigned long count, loff_t from, size_t *retlen)
-{
-        unsigned long i;
-        size_t totlen = 0, thislen;
-        int ret = 0;
-
-        if(!mtd->read) {
-                ret = -EIO;
-        } else {
-                for (i=0; i<count; i++) {
-                        if (!vecs[i].iov_len)
-                                continue;
-                        ret = mtd->read(mtd, from, vecs[i].iov_len, &thislen, vecs[i].iov_base);
-                        totlen += thislen;
-                        if (ret || thislen != vecs[i].iov_len)
-                                break;
-                        from += vecs[i].iov_len;
-                }
-        }
-        if (retlen)
-                *retlen = totlen;
-        return ret;
-}
-
-
 EXPORT_SYMBOL(add_mtd_device);
 EXPORT_SYMBOL(del_mtd_device);
 EXPORT_SYMBOL(get_mtd_device);
@@ -292,7 +262,6 @@ EXPORT_SYMBOL(put_mtd_device);
 EXPORT_SYMBOL(register_mtd_user);
 EXPORT_SYMBOL(unregister_mtd_user);
 EXPORT_SYMBOL(default_mtd_writev);
-EXPORT_SYMBOL(default_mtd_readv);
 
 #ifdef CONFIG_PROC_FS
 
diff --git a/drivers/mtd/mtdpart.c b/drivers/mtd/mtdpart.c
index 99395911d26f..77a7123a5c56 100644
--- a/drivers/mtd/mtdpart.c
+++ b/drivers/mtd/mtdpart.c
@@ -51,16 +51,21 @@ static int part_read (struct mtd_info *mtd, loff_t from, size_t len,
                         size_t *retlen, u_char *buf)
 {
         struct mtd_part *part = PART(mtd);
+        int res;
+
         if (from >= mtd->size)
                 len = 0;
         else if (from + len > mtd->size)
                 len = mtd->size - from;
-        if (part->master->read_ecc == NULL)
-                return part->master->read (part->master, from + part->offset,
-                                        len, retlen, buf);
-        else
-                return part->master->read_ecc (part->master, from + part->offset,
-                                        len, retlen, buf, NULL, &mtd->oobinfo);
+        res = part->master->read (part->master, from + part->offset,
+                                   len, retlen, buf);
+        if (unlikely(res)) {
+                if (res == -EUCLEAN)
+                        mtd->ecc_stats.corrected++;
+                if (res == -EBADMSG)
+                        mtd->ecc_stats.failed++;
+        }
+        return res;
 }
 
 static int part_point (struct mtd_info *mtd, loff_t from, size_t len,
@@ -74,6 +79,7 @@ static int part_point (struct mtd_info *mtd, loff_t from, size_t len,
         return part->master->point (part->master, from + part->offset,
                                     len, retlen, buf);
 }
+
 static void part_unpoint (struct mtd_info *mtd, u_char *addr, loff_t from, size_t len)
 {
         struct mtd_part *part = PART(mtd);
@@ -81,31 +87,25 @@ static void part_unpoint (struct mtd_info *mtd, u_char *addr, loff_t from, size_
         part->master->unpoint (part->master, addr, from + part->offset, len);
 }
 
-
-static int part_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
-                        size_t *retlen, u_char *buf, u_char *eccbuf, struct nand_oobinfo *oobsel)
+static int part_read_oob(struct mtd_info *mtd, loff_t from,
+                         struct mtd_oob_ops *ops)
 {
         struct mtd_part *part = PART(mtd);
-        if (oobsel == NULL)
-                oobsel = &mtd->oobinfo;
-        if (from >= mtd->size)
-                len = 0;
-        else if (from + len > mtd->size)
-                len = mtd->size - from;
-        return part->master->read_ecc (part->master, from + part->offset,
-                                        len, retlen, buf, eccbuf, oobsel);
-}
+        int res;
 
-static int part_read_oob (struct mtd_info *mtd, loff_t from, size_t len,
-                        size_t *retlen, u_char *buf)
-{
-        struct mtd_part *part = PART(mtd);
         if (from >= mtd->size)
-                len = 0;
-        else if (from + len > mtd->size)
-                len = mtd->size - from;
-        return part->master->read_oob (part->master, from + part->offset,
-                                        len, retlen, buf);
+                return -EINVAL;
+        if (from + ops->len > mtd->size)
+                return -EINVAL;
+        res = part->master->read_oob(part->master, from + part->offset, ops);
+
+        if (unlikely(res)) {
+                if (res == -EUCLEAN)
+                        mtd->ecc_stats.corrected++;
+                if (res == -EBADMSG)
+                        mtd->ecc_stats.failed++;
+        }
+        return res;
 }
 
 static int part_read_user_prot_reg (struct mtd_info *mtd, loff_t from, size_t len,
@@ -148,44 +148,23 @@ static int part_write (struct mtd_info *mtd, loff_t to, size_t len,
                 len = 0;
         else if (to + len > mtd->size)
                 len = mtd->size - to;
-        if (part->master->write_ecc == NULL)
-                return part->master->write (part->master, to + part->offset,
-                                        len, retlen, buf);
-        else
-                return part->master->write_ecc (part->master, to + part->offset,
-                                        len, retlen, buf, NULL, &mtd->oobinfo);
-
+        return part->master->write (part->master, to + part->offset,
+                                    len, retlen, buf);
 }
 
-static int part_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
-                        size_t *retlen, const u_char *buf,
-                         u_char *eccbuf, struct nand_oobinfo *oobsel)
+static int part_write_oob(struct mtd_info *mtd, loff_t to,
+                         struct mtd_oob_ops *ops)
 {
         struct mtd_part *part = PART(mtd);
-        if (!(mtd->flags & MTD_WRITEABLE))
-                return -EROFS;
-        if (oobsel == NULL)
-                oobsel = &mtd->oobinfo;
-        if (to >= mtd->size)
-                len = 0;
-        else if (to + len > mtd->size)
-                len = mtd->size - to;
-        return part->master->write_ecc (part->master, to + part->offset,
-                                        len, retlen, buf, eccbuf, oobsel);
-}
 
-static int part_write_oob (struct mtd_info *mtd, loff_t to, size_t len,
-                        size_t *retlen, const u_char *buf)
-{
-        struct mtd_part *part = PART(mtd);
         if (!(mtd->flags & MTD_WRITEABLE))
                 return -EROFS;
+
         if (to >= mtd->size)
-                len = 0;
-        else if (to + len > mtd->size)
-                len = mtd->size - to;
-        return part->master->write_oob (part->master, to + part->offset,
-                                        len, retlen, buf);
+                return -EINVAL;
+        if (to + ops->len > mtd->size)
+                return -EINVAL;
+        return part->master->write_oob(part->master, to + part->offset, ops);
 }
 
 static int part_write_user_prot_reg (struct mtd_info *mtd, loff_t from, size_t len,
@@ -208,52 +187,8 @@ static int part_writev (struct mtd_info *mtd,  const struct kvec *vecs,
         struct mtd_part *part = PART(mtd);
         if (!(mtd->flags & MTD_WRITEABLE))
                 return -EROFS;
-        if (part->master->writev_ecc == NULL)
-                return part->master->writev (part->master, vecs, count,
+        return part->master->writev (part->master, vecs, count,
                                         to + part->offset, retlen);
-        else
-                return part->master->writev_ecc (part->master, vecs, count,
-                                        to + part->offset, retlen,
-                                        NULL, &mtd->oobinfo);
-}
-
-static int part_readv (struct mtd_info *mtd,  struct kvec *vecs,
-                         unsigned long count, loff_t from, size_t *retlen)
-{
-        struct mtd_part *part = PART(mtd);
-        if (part->master->readv_ecc == NULL)
-                return part->master->readv (part->master, vecs, count,
-                                        from + part->offset, retlen);
-        else
-                return part->master->readv_ecc (part->master, vecs, count,
-                                        from + part->offset, retlen,
-                                        NULL, &mtd->oobinfo);
-}
-
-static int part_writev_ecc (struct mtd_info *mtd,  const struct kvec *vecs,
-                         unsigned long count, loff_t to, size_t *retlen,
-                         u_char *eccbuf,  struct nand_oobinfo *oobsel)
-{
-        struct mtd_part *part = PART(mtd);
-        if (!(mtd->flags & MTD_WRITEABLE))
-                return -EROFS;
-        if (oobsel == NULL)
-                oobsel = &mtd->oobinfo;
-        return part->master->writev_ecc (part->master, vecs, count,
-                                        to + part->offset, retlen,
-                                        eccbuf, oobsel);
-}
-
-static int part_readv_ecc (struct mtd_info *mtd,  struct kvec *vecs,
-                         unsigned long count, loff_t from, size_t *retlen,
-                         u_char *eccbuf,  struct nand_oobinfo *oobsel)
-{
-        struct mtd_part *part = PART(mtd);
-        if (oobsel == NULL)
-                oobsel = &mtd->oobinfo;
-        return part->master->readv_ecc (part->master, vecs, count,
-                                        from + part->offset, retlen,
-                                        eccbuf, oobsel);
 }
 
 static int part_erase (struct mtd_info *mtd, struct erase_info *instr)
@@ -329,12 +264,17 @@ static int part_block_isbad (struct mtd_info *mtd, loff_t ofs)
 static int part_block_markbad (struct mtd_info *mtd, loff_t ofs)
 {
         struct mtd_part *part = PART(mtd);
+        int res;
+
         if (!(mtd->flags & MTD_WRITEABLE))
                 return -EROFS;
         if (ofs >= mtd->size)
                 return -EINVAL;
         ofs += part->offset;
-        return part->master->block_markbad(part->master, ofs);
+        res = part->master->block_markbad(part->master, ofs);
+        if (!res)
+                mtd->ecc_stats.badblocks++;
+        return res;
 }
 
 /*
@@ -398,7 +338,7 @@ int add_mtd_partitions(struct mtd_info *master,
                 slave->mtd.type = master->type;
                 slave->mtd.flags = master->flags & ~parts[i].mask_flags;
                 slave->mtd.size = parts[i].size;
-                slave->mtd.oobblock = master->oobblock;
+                slave->mtd.writesize = master->writesize;
                 slave->mtd.oobsize = master->oobsize;
                 slave->mtd.ecctype = master->ecctype;
                 slave->mtd.eccsize = master->eccsize;
@@ -415,10 +355,6 @@ int add_mtd_partitions(struct mtd_info *master,
                         slave->mtd.unpoint = part_unpoint;
                 }
 
-                if (master->read_ecc)
-                        slave->mtd.read_ecc = part_read_ecc;
-                if (master->write_ecc)
-                        slave->mtd.write_ecc = part_write_ecc;
                 if (master->read_oob)
                         slave->mtd.read_oob = part_read_oob;
                 if (master->write_oob)
@@ -443,12 +379,6 @@ int add_mtd_partitions(struct mtd_info *master,
                 }
                 if (master->writev)
                         slave->mtd.writev = part_writev;
-                if (master->readv)
-                        slave->mtd.readv = part_readv;
-                if (master->writev_ecc)
-                        slave->mtd.writev_ecc = part_writev_ecc;
-                if (master->readv_ecc)
-                        slave->mtd.readv_ecc = part_readv_ecc;
                 if (master->lock)
                         slave->mtd.lock = part_lock;
                 if (master->unlock)
@@ -528,8 +458,17 @@ int add_mtd_partitions(struct mtd_info *master,
                                 parts[i].name);
                 }
 
-                /* copy oobinfo from master */
-                memcpy(&slave->mtd.oobinfo, &master->oobinfo, sizeof(slave->mtd.oobinfo));
+                slave->mtd.ecclayout = master->ecclayout;
+                if (master->block_isbad) {
+                        uint32_t offs = 0;
+
+                        while(offs < slave->mtd.size) {
+                                if (master->block_isbad(master,
+                                                        offs + slave->offset))
+                                        slave->mtd.ecc_stats.badblocks++;
+                                offs += slave->mtd.erasesize;
+                        }
+                }
 
                 if(parts[i].mtdp)
                 {       /* store the object pointer (caller may or may not register it */
diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
index cfe288a6e853..3db77eec0ed2 100644
--- a/drivers/mtd/nand/Kconfig
+++ b/drivers/mtd/nand/Kconfig
@@ -23,6 +23,14 @@ config MTD_NAND_VERIFY_WRITE
           device thinks the write was successful, a bit could have been
           flipped accidentaly due to device wear or something else.
 
+config MTD_NAND_ECC_SMC
+        bool "NAND ECC Smart Media byte order"
+        depends on MTD_NAND
+        default n
+        help
+          Software ECC according to the Smart Media Specification.
+          The original Linux implementation had byte 0 and 1 swapped.
+
 config MTD_NAND_AUTCPU12
         tristate "SmartMediaCard on autronix autcpu12 board"
         depends on MTD_NAND && ARCH_AUTCPU12
@@ -49,12 +57,24 @@ config MTD_NAND_SPIA
         help
           If you had to ask, you don't have one. Say 'N'.
 
+config MTD_NAND_AMS_DELTA
+        tristate "NAND Flash device on Amstrad E3"
+        depends on MACH_AMS_DELTA && MTD_NAND
+        help
+          Support for NAND flash on Amstrad E3 (Delta).
+
 config MTD_NAND_TOTO
         tristate "NAND Flash device on TOTO board"
-        depends on ARCH_OMAP && MTD_NAND
+        depends on ARCH_OMAP && MTD_NAND && BROKEN
         help
           Support for NAND flash on Texas Instruments Toto platform.
 
+config MTD_NAND_TS7250
+        tristate "NAND Flash device on TS-7250 board"
+        depends on MACH_TS72XX && MTD_NAND
+        help
+          Support for NAND flash on Technologic Systems TS-7250 platform.
+
 config MTD_NAND_IDS
         tristate
 
@@ -76,7 +96,7 @@ config MTD_NAND_RTC_FROM4
 
 config MTD_NAND_PPCHAMELEONEVB
         tristate "NAND Flash device on PPChameleonEVB board"
-        depends on PPCHAMELEONEVB && MTD_NAND
+        depends on PPCHAMELEONEVB && MTD_NAND && BROKEN
         help
           This enables the NAND flash driver on the PPChameleon EVB Board.
 
@@ -87,7 +107,7 @@ config MTD_NAND_S3C2410
           This enables the NAND flash controller on the S3C2410 and S3C2440
           SoCs
 
-          No board specfic support is done by this driver, each board
+          No board specific support is done by this driver, each board
           must advertise a platform_device for the driver to attach.
 
 config MTD_NAND_S3C2410_DEBUG
@@ -109,6 +129,22 @@ config MTD_NAND_S3C2410_HWECC
           currently not be able to switch to software, as there is no
           implementation for ECC method used by the S3C2410
 
+config MTD_NAND_NDFC
+        tristate "NDFC NanD Flash Controller"
+        depends on MTD_NAND && 44x
+        help
+         NDFC Nand Flash Controllers are integrated in EP44x SoCs
+
+config MTD_NAND_S3C2410_CLKSTOP
+        bool "S3C2410 NAND IDLE clock stop"
+        depends on MTD_NAND_S3C2410
+        default n
+        help
+          Stop the clock to the NAND controller when there is no chip
+          selected to save power. This will mean there is a small delay
+          when the is NAND chip selected or released, but will save
+          approximately 5mA of power when there is nothing happening.
+
 config MTD_NAND_DISKONCHIP
         tristate "DiskOnChip 2000, Millennium and Millennium Plus (NAND reimplementation) (EXPERIMENTAL)"
         depends on MTD_NAND && EXPERIMENTAL
@@ -183,11 +219,24 @@ config MTD_NAND_SHARPSL
         tristate "Support for NAND Flash on Sharp SL Series (C7xx + others)"
         depends on MTD_NAND && ARCH_PXA
 
+config MTD_NAND_CS553X
+        tristate "NAND support for CS5535/CS5536 (AMD Geode companion chip)"
+        depends on MTD_NAND && X86_32 && (X86_PC || X86_GENERICARCH)
+        help
+          The CS553x companion chips for the AMD Geode processor
+          include NAND flash controllers with built-in hardware ECC
+          capabilities; enabling this option will allow you to use
+          these. The driver will check the MSRs to verify that the
+          controller is enabled for NAND, and currently requires that
+          the controller be in MMIO mode.
+
+          If you say "m", the module will be called "cs553x_nand.ko".
+
 config MTD_NAND_NANDSIM
         tristate "Support for NAND Flash Simulator"
         depends on MTD_NAND && MTD_PARTITIONS
         help
-          The simulator may simulate verious NAND flash chips for the
+          The simulator may simulate various NAND flash chips for the
           MTD nand layer.
 
 endmenu
diff --git a/drivers/mtd/nand/Makefile b/drivers/mtd/nand/Makefile
index 41742026a52e..f74759351c91 100644
--- a/drivers/mtd/nand/Makefile
+++ b/drivers/mtd/nand/Makefile
@@ -7,6 +7,7 @@ obj-$(CONFIG_MTD_NAND)			+= nand.o nand_ecc.o
 obj-$(CONFIG_MTD_NAND_IDS)              += nand_ids.o
 
 obj-$(CONFIG_MTD_NAND_SPIA)             += spia.o
+obj-$(CONFIG_MTD_NAND_AMS_DELTA)        += ams-delta.o
 obj-$(CONFIG_MTD_NAND_TOTO)             += toto.o
 obj-$(CONFIG_MTD_NAND_AUTCPU12)         += autcpu12.o
 obj-$(CONFIG_MTD_NAND_EDB7312)          += edb7312.o
@@ -17,6 +18,9 @@ obj-$(CONFIG_MTD_NAND_DISKONCHIP)	+= diskonchip.o
 obj-$(CONFIG_MTD_NAND_H1900)            += h1910.o
 obj-$(CONFIG_MTD_NAND_RTC_FROM4)        += rtc_from4.o
 obj-$(CONFIG_MTD_NAND_SHARPSL)          += sharpsl.o
+obj-$(CONFIG_MTD_NAND_TS7250)           += ts7250.o
 obj-$(CONFIG_MTD_NAND_NANDSIM)          += nandsim.o
+obj-$(CONFIG_MTD_NAND_CS553X)           += cs553x_nand.o
+obj-$(CONFIG_MTD_NAND_NDFC)             += ndfc.o
 
 nand-objs = nand_base.o nand_bbt.o
diff --git a/drivers/mtd/nand/ams-delta.c b/drivers/mtd/nand/ams-delta.c
new file mode 100644
index 000000000000..d7897dc6b3c8
--- /dev/null
+++ b/drivers/mtd/nand/ams-delta.c
@@ -0,0 +1,237 @@
+/*
+ *  drivers/mtd/nand/ams-delta.c
+ *
+ *  Copyright (C) 2006 Jonathan McDowell <noodles@earth.li>
+ *
+ *  Derived from drivers/mtd/toto.c
+ *
+ * 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.
+ *
+ *  Overview:
+ *   This is a device driver for the NAND flash device found on the
+ *   Amstrad E3 (Delta).
+ */
+
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/mtd/partitions.h>
+#include <asm/io.h>
+#include <asm/arch/hardware.h>
+#include <asm/sizes.h>
+#include <asm/arch/gpio.h>
+#include <asm/arch/board-ams-delta.h>
+
+/*
+ * MTD structure for E3 (Delta)
+ */
+static struct mtd_info *ams_delta_mtd = NULL;
+
+#define NAND_MASK (AMS_DELTA_LATCH2_NAND_NRE | AMS_DELTA_LATCH2_NAND_NWE | AMS_DELTA_LATCH2_NAND_CLE | AMS_DELTA_LATCH2_NAND_ALE | AMS_DELTA_LATCH2_NAND_NCE | AMS_DELTA_LATCH2_NAND_NWP)
+
+/*
+ * Define partitions for flash devices
+ */
+
+static struct mtd_partition partition_info[] = {
+        { .name         = "Kernel",
+          .offset       = 0,
+          .size         = 3 * SZ_1M + SZ_512K },
+        { .name         = "u-boot",
+          .offset       = 3 * SZ_1M + SZ_512K,
+          .size         = SZ_256K },
+        { .name         = "u-boot params",
+          .offset       = 3 * SZ_1M + SZ_512K + SZ_256K,
+          .size         = SZ_256K },
+        { .name         = "Amstrad LDR",
+          .offset       = 4 * SZ_1M,
+          .size         = SZ_256K },
+        { .name         = "File system",
+          .offset       = 4 * SZ_1M + 1 * SZ_256K,
+          .size         = 27 * SZ_1M },
+        { .name         = "PBL reserved",
+          .offset       = 32 * SZ_1M - 3 * SZ_256K,
+          .size         =  3 * SZ_256K },
+};
+
+static void ams_delta_write_byte(struct mtd_info *mtd, u_char byte)
+{
+        struct nand_chip *this = mtd->priv;
+
+        omap_writew(0, (OMAP_MPUIO_BASE + OMAP_MPUIO_IO_CNTL));
+        omap_writew(byte, this->IO_ADDR_W);
+        ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NWE, 0);
+        ndelay(40);
+        ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NWE,
+                               AMS_DELTA_LATCH2_NAND_NWE);
+}
+
+static u_char ams_delta_read_byte(struct mtd_info *mtd)
+{
+        u_char res;
+        struct nand_chip *this = mtd->priv;
+
+        ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NRE, 0);
+        ndelay(40);
+        omap_writew(~0, (OMAP_MPUIO_BASE + OMAP_MPUIO_IO_CNTL));
+        res = omap_readw(this->IO_ADDR_R);
+        ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NRE,
+                               AMS_DELTA_LATCH2_NAND_NRE);
+
+        return res;
+}
+
+static void ams_delta_write_buf(struct mtd_info *mtd, const u_char *buf,
+                                int len)
+{
+        int i;
+
+        for (i=0; i<len; i++)
+                ams_delta_write_byte(mtd, buf[i]);
+}
+
+static void ams_delta_read_buf(struct mtd_info *mtd, u_char *buf, int len)
+{
+        int i;
+
+        for (i=0; i<len; i++)
+                buf[i] = ams_delta_read_byte(mtd);
+}
+
+static int ams_delta_verify_buf(struct mtd_info *mtd, const u_char *buf,
+                                int len)
+{
+        int i;
+
+        for (i=0; i<len; i++)
+                if (buf[i] != ams_delta_read_byte(mtd))
+                        return -EFAULT;
+
+        return 0;
+}
+
+/*
+ * Command control function
+ *
+ * ctrl:
+ * NAND_NCE: bit 0 -> bit 2
+ * NAND_CLE: bit 1 -> bit 7
+ * NAND_ALE: bit 2 -> bit 6
+ */
+static void ams_delta_hwcontrol(struct mtd_info *mtd, int cmd,
+                                unsigned int ctrl)
+{
+
+        if (ctrl & NAND_CTRL_CHANGE) {
+                unsigned long bits;
+
+                bits = (~ctrl & NAND_NCE) << 2;
+                bits |= (ctrl & NAND_CLE) << 7;
+                bits |= (ctrl & NAND_ALE) << 6;
+
+                ams_delta_latch2_write(0xC2, bits);
+        }
+
+        if (cmd != NAND_CMD_NONE)
+                ams_delta_write_byte(mtd, cmd);
+}
+
+static int ams_delta_nand_ready(struct mtd_info *mtd)
+{
+        return omap_get_gpio_datain(AMS_DELTA_GPIO_PIN_NAND_RB);
+}
+
+/*
+ * Main initialization routine
+ */
+static int __init ams_delta_init(void)
+{
+        struct nand_chip *this;
+        int err = 0;
+
+        /* Allocate memory for MTD device structure and private data */
+        ams_delta_mtd = kmalloc(sizeof(struct mtd_info) +
+                                sizeof(struct nand_chip), GFP_KERNEL);
+        if (!ams_delta_mtd) {
+                printk (KERN_WARNING "Unable to allocate E3 NAND MTD device structure.\n");
+                err = -ENOMEM;
+                goto out;
+        }
+
+        ams_delta_mtd->owner = THIS_MODULE;
+
+        /* Get pointer to private data */
+        this = (struct nand_chip *) (&ams_delta_mtd[1]);
+
+        /* Initialize structures */
+        memset(ams_delta_mtd, 0, sizeof(struct mtd_info));
+        memset(this, 0, sizeof(struct nand_chip));
+
+        /* Link the private data with the MTD structure */
+        ams_delta_mtd->priv = this;
+
+        /* Set address of NAND IO lines */
+        this->IO_ADDR_R = (OMAP_MPUIO_BASE + OMAP_MPUIO_INPUT_LATCH);
+        this->IO_ADDR_W = (OMAP_MPUIO_BASE + OMAP_MPUIO_OUTPUT);
+        this->read_byte = ams_delta_read_byte;
+        this->write_buf = ams_delta_write_buf;
+        this->read_buf = ams_delta_read_buf;
+        this->verify_buf = ams_delta_verify_buf;
+        this->cmd_ctrl = ams_delta_hwcontrol;
+        if (!omap_request_gpio(AMS_DELTA_GPIO_PIN_NAND_RB)) {
+                this->dev_ready = ams_delta_nand_ready;
+        } else {
+                this->dev_ready = NULL;
+                printk(KERN_NOTICE "Couldn't request gpio for Delta NAND ready.\n");
+        }
+        /* 25 us command delay time */
+        this->chip_delay = 30;
+        this->ecc.mode = NAND_ECC_SOFT;
+
+        /* Set chip enabled, but  */
+        ams_delta_latch2_write(NAND_MASK, AMS_DELTA_LATCH2_NAND_NRE |
+                                          AMS_DELTA_LATCH2_NAND_NWE |
+                                          AMS_DELTA_LATCH2_NAND_NCE |
+                                          AMS_DELTA_LATCH2_NAND_NWP);
+
+        /* Scan to find existance of the device */
+        if (nand_scan(ams_delta_mtd, 1)) {
+                err = -ENXIO;
+                goto out_mtd;
+        }
+
+        /* Register the partitions */
+        add_mtd_partitions(ams_delta_mtd, partition_info,
+                           ARRAY_SIZE(partition_info));
+
+        goto out;
+
+ out_mtd:
+        kfree(ams_delta_mtd);
+ out:
+        return err;
+}
+
+module_init(ams_delta_init);
+
+/*
+ * Clean up routine
+ */
+static void __exit ams_delta_cleanup(void)
+{
+        /* Release resources, unregister device */
+        nand_release(ams_delta_mtd);
+
+        /* Free the MTD device structure */
+        kfree(ams_delta_mtd);
+}
+module_exit(ams_delta_cleanup);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jonathan McDowell <noodles@earth.li>");
+MODULE_DESCRIPTION("Glue layer for NAND flash on Amstrad E3 (Delta)");
diff --git a/drivers/mtd/nand/au1550nd.c b/drivers/mtd/nand/au1550nd.c
index bde3550910a2..31228334da12 100644
--- a/drivers/mtd/nand/au1550nd.c
+++ b/drivers/mtd/nand/au1550nd.c
@@ -14,6 +14,7 @@
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/interrupt.h>
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/nand.h>
 #include <linux/mtd/partitions.h>
@@ -38,22 +39,21 @@
  */
 static struct mtd_info *au1550_mtd = NULL;
 static void __iomem *p_nand;
-static int nand_width = 1; /* default x8*/
+static int nand_width = 1;      /* default x8 */
+static void (*au1550_write_byte)(struct mtd_info *, u_char);
 
 /*
  * Define partitions for flash device
  */
 static const struct mtd_partition partition_info[] = {
         {
-                .name   = "NAND FS 0",
-                .offset = 0,
-                .size   = 8*1024*1024
-        },
+         .name = "NAND FS 0",
+         .offset = 0,
+         .size = 8 * 1024 * 1024},
         {
-                .name   = "NAND FS 1",
-                .offset =  MTDPART_OFS_APPEND,
-                .size   =    MTDPART_SIZ_FULL
-        }
+         .name = "NAND FS 1",
+         .offset = MTDPART_OFS_APPEND,
+         .size = MTDPART_SIZ_FULL}
 };
 
 /**
@@ -130,21 +130,6 @@ static u16 au_read_word(struct mtd_info *mtd)
 }
 
 /**
- * au_write_word -  write one word to the chip
- * @mtd:        MTD device structure
- * @word:       data word to write
- *
- *  write function for 16bit buswith without
- * endianess conversion
- */
-static void au_write_word(struct mtd_info *mtd, u16 word)
-{
-        struct nand_chip *this = mtd->priv;
-        writew(word, this->IO_ADDR_W);
-        au_sync();
-}
-
-/**
  * au_write_buf -  write buffer to chip
  * @mtd:        MTD device structure
  * @buf:        data buffer
@@ -157,7 +142,7 @@ static void au_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
         int i;
         struct nand_chip *this = mtd->priv;
 
-        for (i=0; i<len; i++) {
+        for (i = 0; i < len; i++) {
                 writeb(buf[i], this->IO_ADDR_W);
                 au_sync();
         }
@@ -176,7 +161,7 @@ static void au_read_buf(struct mtd_info *mtd, u_char *buf, int len)
         int i;
         struct nand_chip *this = mtd->priv;
 
-        for (i=0; i<len; i++) {
+        for (i = 0; i < len; i++) {
                 buf[i] = readb(this->IO_ADDR_R);
                 au_sync();
         }
@@ -195,7 +180,7 @@ static int au_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
         int i;
         struct nand_chip *this = mtd->priv;
 
-        for (i=0; i<len; i++) {
+        for (i = 0; i < len; i++) {
                 if (buf[i] != readb(this->IO_ADDR_R))
                         return -EFAULT;
                 au_sync();
@@ -219,7 +204,7 @@ static void au_write_buf16(struct mtd_info *mtd, const u_char *buf, int len)
         u16 *p = (u16 *) buf;
         len >>= 1;
 
-        for (i=0; i<len; i++) {
+        for (i = 0; i < len; i++) {
                 writew(p[i], this->IO_ADDR_W);
                 au_sync();
         }
@@ -241,7 +226,7 @@ static void au_read_buf16(struct mtd_info *mtd, u_char *buf, int len)
         u16 *p = (u16 *) buf;
         len >>= 1;
 
-        for (i=0; i<len; i++) {
+        for (i = 0; i < len; i++) {
                 p[i] = readw(this->IO_ADDR_R);
                 au_sync();
         }
@@ -262,7 +247,7 @@ static int au_verify_buf16(struct mtd_info *mtd, const u_char *buf, int len)
         u16 *p = (u16 *) buf;
         len >>= 1;
 
-        for (i=0; i<len; i++) {
+        for (i = 0; i < len; i++) {
                 if (p[i] != readw(this->IO_ADDR_R))
                         return -EFAULT;
                 au_sync();
@@ -270,32 +255,52 @@ static int au_verify_buf16(struct mtd_info *mtd, const u_char *buf, int len)
         return 0;
 }
 
+/* Select the chip by setting nCE to low */
+#define NAND_CTL_SETNCE         1
+/* Deselect the chip by setting nCE to high */
+#define NAND_CTL_CLRNCE         2
+/* Select the command latch by setting CLE to high */
+#define NAND_CTL_SETCLE         3
+/* Deselect the command latch by setting CLE to low */
+#define NAND_CTL_CLRCLE         4
+/* Select the address latch by setting ALE to high */
+#define NAND_CTL_SETALE         5
+/* Deselect the address latch by setting ALE to low */
+#define NAND_CTL_CLRALE         6
 
 static void au1550_hwcontrol(struct mtd_info *mtd, int cmd)
 {
         register struct nand_chip *this = mtd->priv;
 
-        switch(cmd){
+        switch (cmd) {
 
-        case NAND_CTL_SETCLE: this->IO_ADDR_W = p_nand + MEM_STNAND_CMD; break;
-        case NAND_CTL_CLRCLE: this->IO_ADDR_W = p_nand + MEM_STNAND_DATA; break;
+        case NAND_CTL_SETCLE:
+                this->IO_ADDR_W = p_nand + MEM_STNAND_CMD;
+                break;
+
+        case NAND_CTL_CLRCLE:
+                this->IO_ADDR_W = p_nand + MEM_STNAND_DATA;
+                break;
+
+        case NAND_CTL_SETALE:
+                this->IO_ADDR_W = p_nand + MEM_STNAND_ADDR;
+                break;
 
-        case NAND_CTL_SETALE: this->IO_ADDR_W = p_nand + MEM_STNAND_ADDR; break;
         case NAND_CTL_CLRALE:
                 this->IO_ADDR_W = p_nand + MEM_STNAND_DATA;
-                /* FIXME: Nobody knows why this is neccecary,
+                /* FIXME: Nobody knows why this is necessary,
                  * but it works only that way */
                 udelay(1);
                 break;
 
         case NAND_CTL_SETNCE:
                 /* assert (force assert) chip enable */
-                au_writel((1<<(4+NAND_CS)) , MEM_STNDCTL); break;
+                au_writel((1 << (4 + NAND_CS)), MEM_STNDCTL);
                 break;
 
         case NAND_CTL_CLRNCE:
-                /* deassert chip enable */
-                au_writel(0, MEM_STNDCTL); break;
+                /* deassert chip enable */
+                au_writel(0, MEM_STNDCTL);
                 break;
         }
 
@@ -312,69 +317,200 @@ int au1550_device_ready(struct mtd_info *mtd)
         return ret;
 }
 
+/**
+ * au1550_select_chip - control -CE line
+ *      Forbid driving -CE manually permitting the NAND controller to do this.
+ *      Keeping -CE asserted during the whole sector reads interferes with the
+ *      NOR flash and PCMCIA drivers as it causes contention on the static bus.
+ *      We only have to hold -CE low for the NAND read commands since the flash
+ *      chip needs it to be asserted during chip not ready time but the NAND
+ *      controller keeps it released.
+ *
+ * @mtd:        MTD device structure
+ * @chip:       chipnumber to select, -1 for deselect
+ */
+static void au1550_select_chip(struct mtd_info *mtd, int chip)
+{
+}
+
+/**
+ * au1550_command - Send command to NAND device
+ * @mtd:        MTD device structure
+ * @command:    the command to be sent
+ * @column:     the column address for this command, -1 if none
+ * @page_addr:  the page address for this command, -1 if none
+ */
+static void au1550_command(struct mtd_info *mtd, unsigned command, int column, int page_addr)
+{
+        register struct nand_chip *this = mtd->priv;
+        int ce_override = 0, i;
+        ulong flags;
+
+        /* Begin command latch cycle */
+        au1550_hwcontrol(mtd, NAND_CTL_SETCLE);
+        /*
+         * Write out the command to the device.
+         */
+        if (command == NAND_CMD_SEQIN) {
+                int readcmd;
+
+                if (column >= mtd->writesize) {
+                        /* OOB area */
+                        column -= mtd->writesize;
+                        readcmd = NAND_CMD_READOOB;
+                } else if (column < 256) {
+                        /* First 256 bytes --> READ0 */
+                        readcmd = NAND_CMD_READ0;
+                } else {
+                        column -= 256;
+                        readcmd = NAND_CMD_READ1;
+                }
+                au1550_write_byte(mtd, readcmd);
+        }
+        au1550_write_byte(mtd, command);
+
+        /* Set ALE and clear CLE to start address cycle */
+        au1550_hwcontrol(mtd, NAND_CTL_CLRCLE);
+
+        if (column != -1 || page_addr != -1) {
+                au1550_hwcontrol(mtd, NAND_CTL_SETALE);
+
+                /* Serially input address */
+                if (column != -1) {
+                        /* Adjust columns for 16 bit buswidth */
+                        if (this->options & NAND_BUSWIDTH_16)
+                                column >>= 1;
+                        au1550_write_byte(mtd, column);
+                }
+                if (page_addr != -1) {
+                        au1550_write_byte(mtd, (u8)(page_addr & 0xff));
+
+                        if (command == NAND_CMD_READ0 ||
+                            command == NAND_CMD_READ1 ||
+                            command == NAND_CMD_READOOB) {
+                                /*
+                                 * NAND controller will release -CE after
+                                 * the last address byte is written, so we'll
+                                 * have to forcibly assert it. No interrupts
+                                 * are allowed while we do this as we don't
+                                 * want the NOR flash or PCMCIA drivers to
+                                 * steal our precious bytes of data...
+                                 */
+                                ce_override = 1;
+                                local_irq_save(flags);
+                                au1550_hwcontrol(mtd, NAND_CTL_SETNCE);
+                        }
+
+                        au1550_write_byte(mtd, (u8)(page_addr >> 8));
+
+                        /* One more address cycle for devices > 32MiB */
+                        if (this->chipsize > (32 << 20))
+                                au1550_write_byte(mtd, (u8)((page_addr >> 16) & 0x0f));
+                }
+                /* Latch in address */
+                au1550_hwcontrol(mtd, NAND_CTL_CLRALE);
+        }
+
+        /*
+         * Program and erase have their own busy handlers.
+         * Status and sequential in need no delay.
+         */
+        switch (command) {
+
+        case NAND_CMD_PAGEPROG:
+        case NAND_CMD_ERASE1:
+        case NAND_CMD_ERASE2:
+        case NAND_CMD_SEQIN:
+        case NAND_CMD_STATUS:
+                return;
+
+        case NAND_CMD_RESET:
+                break;
+
+        case NAND_CMD_READ0:
+        case NAND_CMD_READ1:
+        case NAND_CMD_READOOB:
+                /* Check if we're really driving -CE low (just in case) */
+                if (unlikely(!ce_override))
+                        break;
+
+                /* Apply a short delay always to ensure that we do wait tWB. */
+                ndelay(100);
+                /* Wait for a chip to become ready... */
+                for (i = this->chip_delay; !this->dev_ready(mtd) && i > 0; --i)
+                        udelay(1);
+
+                /* Release -CE and re-enable interrupts. */
+                au1550_hwcontrol(mtd, NAND_CTL_CLRNCE);
+                local_irq_restore(flags);
+                return;
+        }
+        /* Apply this short delay always to ensure that we do wait tWB. */
+        ndelay(100);
+
+        while(!this->dev_ready(mtd));
+}
+
+
 /*
  * Main initialization routine
  */
-int __init au1xxx_nand_init (void)
+static int __init au1xxx_nand_init(void)
 {
         struct nand_chip *this;
-        u16 boot_swapboot = 0; /* default value */
+        u16 boot_swapboot = 0;  /* default value */
         int retval;
         u32 mem_staddr;
         u32 nand_phys;
 
         /* Allocate memory for MTD device structure and private data */
-        au1550_mtd = kmalloc (sizeof(struct mtd_info) +
-                        sizeof (struct nand_chip), GFP_KERNEL);
+        au1550_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
         if (!au1550_mtd) {
-                printk ("Unable to allocate NAND MTD dev structure.\n");
+                printk("Unable to allocate NAND MTD dev structure.\n");
                 return -ENOMEM;
         }
 
         /* Get pointer to private data */
-        this = (struct nand_chip *) (&au1550_mtd[1]);
+        this = (struct nand_chip *)(&au1550_mtd[1]);
 
         /* Initialize structures */
-        memset((char *) au1550_mtd, 0, sizeof(struct mtd_info));
-        memset((char *) this, 0, sizeof(struct nand_chip));
+        memset(au1550_mtd, 0, sizeof(struct mtd_info));
+        memset(this, 0, sizeof(struct nand_chip));
 
         /* Link the private data with the MTD structure */
         au1550_mtd->priv = this;
+        au1550_mtd->owner = THIS_MODULE;
 
 
-        /* disable interrupts */
-        au_writel(au_readl(MEM_STNDCTL) & ~(1<<8), MEM_STNDCTL);
-
-        /* disable NAND boot */
-        au_writel(au_readl(MEM_STNDCTL) & ~(1<<0), MEM_STNDCTL);
+        /* MEM_STNDCTL: disable ints, disable nand boot */
+        au_writel(0, MEM_STNDCTL);
 
 #ifdef CONFIG_MIPS_PB1550
         /* set gpio206 high */
-        au_writel(au_readl(GPIO2_DIR) & ~(1<<6), GPIO2_DIR);
+        au_writel(au_readl(GPIO2_DIR) & ~(1 << 6), GPIO2_DIR);
 
-        boot_swapboot = (au_readl(MEM_STSTAT) & (0x7<<1)) |
-                ((bcsr->status >> 6)  & 0x1);
+        boot_swapboot = (au_readl(MEM_STSTAT) & (0x7 << 1)) | ((bcsr->status >> 6) & 0x1);
         switch (boot_swapboot) {
-                case 0:
-                case 2:
-                case 8:
-                case 0xC:
-                case 0xD:
-                        /* x16 NAND Flash */
-                        nand_width = 0;
-                        break;
-                case 1:
-                case 9:
-                case 3:
-                case 0xE:
-                case 0xF:
-                        /* x8 NAND Flash */
-                        nand_width = 1;
-                        break;
-                default:
-                        printk("Pb1550 NAND: bad boot:swap\n");
-                        retval = -EINVAL;
-                        goto outmem;
+        case 0:
+        case 2:
+        case 8:
+        case 0xC:
+        case 0xD:
+                /* x16 NAND Flash */
+                nand_width = 0;
+                break;
+        case 1:
+        case 9:
+        case 3:
+        case 0xE:
+        case 0xF:
+                /* x8 NAND Flash */
+                nand_width = 1;
+                break;
+        default:
+                printk("Pb1550 NAND: bad boot:swap\n");
+                retval = -EINVAL;
+                goto outmem;
         }
 #endif
 
@@ -424,21 +560,22 @@ int __init au1xxx_nand_init (void)
 
         /* make controller and MTD agree */
         if (NAND_CS == 0)
-                nand_width = au_readl(MEM_STCFG0) & (1<<22);
+                nand_width = au_readl(MEM_STCFG0) & (1 << 22);
         if (NAND_CS == 1)
-                nand_width = au_readl(MEM_STCFG1) & (1<<22);
+                nand_width = au_readl(MEM_STCFG1) & (1 << 22);
         if (NAND_CS == 2)
-                nand_width = au_readl(MEM_STCFG2) & (1<<22);
+                nand_width = au_readl(MEM_STCFG2) & (1 << 22);
         if (NAND_CS == 3)
-                nand_width = au_readl(MEM_STCFG3) & (1<<22);
-
+                nand_width = au_readl(MEM_STCFG3) & (1 << 22);
 
         /* Set address of hardware control function */
-        this->hwcontrol = au1550_hwcontrol;
         this->dev_ready = au1550_device_ready;
+        this->select_chip = au1550_select_chip;
+        this->cmdfunc = au1550_command;
+
         /* 30 us command delay time */
         this->chip_delay = 30;
-        this->eccmode = NAND_ECC_SOFT;
+        this->ecc.mode = NAND_ECC_SOFT;
 
         this->options = NAND_NO_AUTOINCR;
 
@@ -446,15 +583,14 @@ int __init au1xxx_nand_init (void)
                 this->options |= NAND_BUSWIDTH_16;
 
         this->read_byte = (!nand_width) ? au_read_byte16 : au_read_byte;
-        this->write_byte = (!nand_width) ? au_write_byte16 : au_write_byte;
-        this->write_word = au_write_word;
+        au1550_write_byte = (!nand_width) ? au_write_byte16 : au_write_byte;
         this->read_word = au_read_word;
         this->write_buf = (!nand_width) ? au_write_buf16 : au_write_buf;
         this->read_buf = (!nand_width) ? au_read_buf16 : au_read_buf;
         this->verify_buf = (!nand_width) ? au_verify_buf16 : au_verify_buf;
 
         /* Scan to find existence of the device */
-        if (nand_scan (au1550_mtd, 1)) {
+        if (nand_scan(au1550_mtd, 1)) {
                 retval = -ENXIO;
                 goto outio;
         }
@@ -465,10 +601,10 @@ int __init au1xxx_nand_init (void)
         return 0;
 
  outio:
-        iounmap ((void *)p_nand);
+        iounmap((void *)p_nand);
 
  outmem:
-        kfree (au1550_mtd);
+        kfree(au1550_mtd);
         return retval;
 }
 
@@ -477,22 +613,21 @@ module_init(au1xxx_nand_init);
 /*
  * Clean up routine
  */
-#ifdef MODULE
-static void __exit au1550_cleanup (void)
+static void __exit au1550_cleanup(void)
 {
-        struct nand_chip *this = (struct nand_chip *) &au1550_mtd[1];
+        struct nand_chip *this = (struct nand_chip *)&au1550_mtd[1];
 
         /* Release resources, unregister device */
-        nand_release (au1550_mtd);
+        nand_release(au1550_mtd);
 
         /* Free the MTD device structure */
-        kfree (au1550_mtd);
+        kfree(au1550_mtd);
 
         /* Unmap */
-        iounmap ((void *)p_nand);
+        iounmap((void *)p_nand);
 }
+
 module_exit(au1550_cleanup);
-#endif
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Embedded Edge, LLC");
diff --git a/drivers/mtd/nand/autcpu12.c b/drivers/mtd/nand/autcpu12.c
index a3c7fea404d0..fe94ae9ae1f2 100644
--- a/drivers/mtd/nand/autcpu12.c
+++ b/drivers/mtd/nand/autcpu12.c
@@ -4,7 +4,7 @@
  *  Copyright (c) 2002 Thomas Gleixner <tgxl@linutronix.de>
  *
  *  Derived from drivers/mtd/spia.c
- *       Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
+ *       Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
  *
  * $Id: autcpu12.c,v 1.23 2005/11/07 11:14:30 gleixner Exp $
  *
@@ -42,12 +42,7 @@
  * MTD structure for AUTCPU12 board
  */
 static struct mtd_info *autcpu12_mtd = NULL;
-
-static int autcpu12_io_base = CS89712_VIRT_BASE;
-static int autcpu12_fio_pbase = AUTCPU12_PHYS_SMC;
-static int autcpu12_fio_ctrl = AUTCPU12_SMC_SELECT_OFFSET;
-static int autcpu12_pedr = AUTCPU12_SMC_PORT_OFFSET;
-static void __iomem * autcpu12_fio_base;
+static void __iomem *autcpu12_fio_base;
 
 /*
  * Define partitions for flash devices
@@ -94,108 +89,131 @@ static struct mtd_partition partition_info128k[] = {
 #define NUM_PARTITIONS128K 2
 /*
  *      hardware specific access to control-lines
-*/
-static void autcpu12_hwcontrol(struct mtd_info *mtd, int cmd)
+ *
+ *      ALE bit 4 autcpu12_pedr
+ *      CLE bit 5 autcpu12_pedr
+ *      NCE bit 0 fio_ctrl
+ *
+ */
+static void autcpu12_hwcontrol(struct mtd_info *mtd, int cmd,
+                               unsigned int ctrl)
 {
+        struct nand_chip *chip = mtd->priv;
 
-        switch(cmd){
-
-                case NAND_CTL_SETCLE: (*(volatile unsigned char *) (autcpu12_io_base + autcpu12_pedr)) |=  AUTCPU12_SMC_CLE; break;
-                case NAND_CTL_CLRCLE: (*(volatile unsigned char *) (autcpu12_io_base + autcpu12_pedr)) &= ~AUTCPU12_SMC_CLE; break;
+        if (ctrl & NAND_CTRL_CHANGE) {
+                void __iomem *addr
+                unsigned char bits;
 
-                case NAND_CTL_SETALE: (*(volatile unsigned char *) (autcpu12_io_base + autcpu12_pedr)) |=  AUTCPU12_SMC_ALE; break;
-                case NAND_CTL_CLRALE: (*(volatile unsigned char *) (autcpu12_io_base + autcpu12_pedr)) &= ~AUTCPU12_SMC_ALE; break;
+                addr = CS89712_VIRT_BASE + AUTCPU12_SMC_PORT_OFFSET;
+                bits = (ctrl & NAND_CLE) << 4;
+                bits |= (ctrl & NAND_ALE) << 2;
+                writeb((readb(addr) & ~0x30) | bits, addr);
 
-                case NAND_CTL_SETNCE: (*(volatile unsigned char *) (autcpu12_fio_base + autcpu12_fio_ctrl)) = 0x01; break;
-                case NAND_CTL_CLRNCE: (*(volatile unsigned char *) (autcpu12_fio_base + autcpu12_fio_ctrl)) = 0x00; break;
+                addr = autcpu12_fio_base + AUTCPU12_SMC_SELECT_OFFSET;
+                writeb((readb(addr) & ~0x1) | (ctrl & NAND_NCE), addr);
         }
+
+        if (cmd != NAND_CMD_NONE)
+                writeb(cmd, chip->IO_ADDR_W);
 }
 
 /*
-*       read device ready pin
-*/
+ *      read device ready pin
+ */
 int autcpu12_device_ready(struct mtd_info *mtd)
 {
+        void __iomem *addr = CS89712_VIRT_BASE + AUTCPU12_SMC_PORT_OFFSET;
 
-        return ( (*(volatile unsigned char *) (autcpu12_io_base + autcpu12_pedr)) & AUTCPU12_SMC_RDY) ? 1 : 0;
-
+        return readb(addr) & AUTCPU12_SMC_RDY;
 }
 
 /*
  * Main initialization routine
  */
-int __init autcpu12_init (void)
+static int __init autcpu12_init(void)
 {
         struct nand_chip *this;
         int err = 0;
 
         /* Allocate memory for MTD device structure and private data */
-        autcpu12_mtd = kmalloc (sizeof(struct mtd_info) + sizeof (struct nand_chip),
-                                GFP_KERNEL);
+        autcpu12_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip),
+                               GFP_KERNEL);
         if (!autcpu12_mtd) {
-                printk ("Unable to allocate AUTCPU12 NAND MTD device structure.\n");
+                printk("Unable to allocate AUTCPU12 NAND MTD device structure.\n");
                 err = -ENOMEM;
                 goto out;
         }
 
         /* map physical adress */
-        autcpu12_fio_base = ioremap(autcpu12_fio_pbase,SZ_1K);
-        if(!autcpu12_fio_base){
+        autcpu12_fio_base = ioremap(AUTCPU12_PHYS_SMC, SZ_1K);
+        if (!autcpu12_fio_base) {
                 printk("Ioremap autcpu12 SmartMedia Card failed\n");
                 err = -EIO;
                 goto out_mtd;
         }
 
         /* Get pointer to private data */
-        this = (struct nand_chip *) (&autcpu12_mtd[1]);
+        this = (struct nand_chip *)(&autcpu12_mtd[1]);
 
         /* Initialize structures */
-        memset((char *) autcpu12_mtd, 0, sizeof(struct mtd_info));
-        memset((char *) this, 0, sizeof(struct nand_chip));
+        memset(autcpu12_mtd, 0, sizeof(struct mtd_info));
+        memset(this, 0, sizeof(struct nand_chip));
 
         /* Link the private data with the MTD structure */
         autcpu12_mtd->priv = this;
+        autcpu12_mtd->owner = THIS_MODULE;
 
         /* Set address of NAND IO lines */
         this->IO_ADDR_R = autcpu12_fio_base;
         this->IO_ADDR_W = autcpu12_fio_base;
-        this->hwcontrol = autcpu12_hwcontrol;
+        this->cmd_ctrl = autcpu12_hwcontrol;
         this->dev_ready = autcpu12_device_ready;
         /* 20 us command delay time */
         this->chip_delay = 20;
-        this->eccmode = NAND_ECC_SOFT;
+        this->ecc.mode = NAND_ECC_SOFT;
 
         /* Enable the following for a flash based bad block table */
         /*
-        this->options = NAND_USE_FLASH_BBT;
-        */
+           this->options = NAND_USE_FLASH_BBT;
+         */
         this->options = NAND_USE_FLASH_BBT;
 
         /* Scan to find existance of the device */
-        if (nand_scan (autcpu12_mtd, 1)) {
+        if (nand_scan(autcpu12_mtd, 1)) {
                 err = -ENXIO;
                 goto out_ior;
         }
 
         /* Register the partitions */
-        switch(autcpu12_mtd->size){
-                case SZ_16M: add_mtd_partitions(autcpu12_mtd, partition_info16k, NUM_PARTITIONS16K); break;
-                case SZ_32M: add_mtd_partitions(autcpu12_mtd, partition_info32k, NUM_PARTITIONS32K); break;
-                case SZ_64M: add_mtd_partitions(autcpu12_mtd, partition_info64k, NUM_PARTITIONS64K); break;
-                case SZ_128M: add_mtd_partitions(autcpu12_mtd, partition_info128k, NUM_PARTITIONS128K); break;
-                default: {
-                        printk ("Unsupported SmartMedia device\n");
+        switch (autcpu12_mtd->size) {
+                case SZ_16M:
+                        add_mtd_partitions(autcpu12_mtd, partition_info16k,
+                                           NUM_PARTITIONS16K);
+                        break;
+                case SZ_32M:
+                        add_mtd_partitions(autcpu12_mtd, partition_info32k,
+                                           NUM_PARTITIONS32K);
+                        break;
+                case SZ_64M:
+                        add_mtd_partitions(autcpu12_mtd, partition_info64k,
+                                           NUM_PARTITIONS64K);
+                        break;
+                case SZ_128M:
+                        add_mtd_partitions(autcpu12_mtd, partition_info128k,
+                                           NUM_PARTITIONS128K);
+                        break;
+                default:
+                        printk("Unsupported SmartMedia device\n");
                         err = -ENXIO;
                         goto out_ior;
-                }
         }
         goto out;
 
-out_ior:
-        iounmap((void *)autcpu12_fio_base);
-out_mtd:
-        kfree (autcpu12_mtd);
-out:
+ out_ior:
+        iounmap(autcpu12_fio_base);
+ out_mtd:
+        kfree(autcpu12_mtd);
+ out:
         return err;
 }
 
@@ -204,20 +222,19 @@ module_init(autcpu12_init);
 /*
  * Clean up routine
  */
-#ifdef MODULE
-static void __exit autcpu12_cleanup (void)
+static void __exit autcpu12_cleanup(void)
 {
         /* Release resources, unregister device */
-        nand_release (autcpu12_mtd);
+        nand_release(autcpu12_mtd);
 
         /* unmap physical adress */
-        iounmap((void *)autcpu12_fio_base);
+        iounmap(autcpu12_fio_base);
 
         /* Free the MTD device structure */
-        kfree (autcpu12_mtd);
+        kfree(autcpu12_mtd);
 }
+
 module_exit(autcpu12_cleanup);
-#endif
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Thomas Gleixner <tglx@linutronix.de>");
diff --git a/drivers/mtd/nand/cs553x_nand.c b/drivers/mtd/nand/cs553x_nand.c
new file mode 100644
index 000000000000..e0a1d386e581
--- /dev/null
+++ b/drivers/mtd/nand/cs553x_nand.c
@@ -0,0 +1,353 @@
+/*
+ * drivers/mtd/nand/cs553x_nand.c
+ *
+ * (C) 2005, 2006 Red Hat Inc.
+ *
+ * Author: David Woodhouse <dwmw2@infradead.org>
+ *         Tom Sylla <tom.sylla@amd.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ *  Overview:
+ *   This is a device driver for the NAND flash controller found on 
+ *   the AMD CS5535/CS5536 companion chipsets for the Geode processor.
+ *
+ */
+
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/mtd/nand_ecc.h>
+#include <linux/mtd/partitions.h>
+
+#include <asm/msr.h>
+#include <asm/io.h>
+
+#define NR_CS553X_CONTROLLERS   4
+
+#define MSR_DIVIL_GLD_CAP       0x51400000      /* DIVIL capabilitiies */
+#define CAP_CS5535              0x2df000ULL
+#define CAP_CS5536              0x5df500ULL
+
+/* NAND Timing MSRs */
+#define MSR_NANDF_DATA          0x5140001b      /* NAND Flash Data Timing MSR */
+#define MSR_NANDF_CTL           0x5140001c      /* NAND Flash Control Timing */
+#define MSR_NANDF_RSVD          0x5140001d      /* Reserved */
+
+/* NAND BAR MSRs */
+#define MSR_DIVIL_LBAR_FLSH0    0x51400010      /* Flash Chip Select 0 */
+#define MSR_DIVIL_LBAR_FLSH1    0x51400011      /* Flash Chip Select 1 */
+#define MSR_DIVIL_LBAR_FLSH2    0x51400012      /* Flash Chip Select 2 */
+#define MSR_DIVIL_LBAR_FLSH3    0x51400013      /* Flash Chip Select 3 */
+        /* Each made up of... */
+#define FLSH_LBAR_EN            (1ULL<<32)
+#define FLSH_NOR_NAND           (1ULL<<33)      /* 1 for NAND */
+#define FLSH_MEM_IO             (1ULL<<34)      /* 1 for MMIO */
+        /* I/O BARs have BASE_ADDR in bits 15:4, IO_MASK in 47:36 */
+        /* MMIO BARs have BASE_ADDR in bits 31:12, MEM_MASK in 63:44 */
+
+/* Pin function selection MSR (IDE vs. flash on the IDE pins) */
+#define MSR_DIVIL_BALL_OPTS     0x51400015
+#define PIN_OPT_IDE             (1<<0)  /* 0 for flash, 1 for IDE */
+
+/* Registers within the NAND flash controller BAR -- memory mapped */
+#define MM_NAND_DATA            0x00    /* 0 to 0x7ff, in fact */
+#define MM_NAND_CTL             0x800   /* Any even address 0x800-0x80e */
+#define MM_NAND_IO              0x801   /* Any odd address 0x801-0x80f */
+#define MM_NAND_STS             0x810
+#define MM_NAND_ECC_LSB         0x811
+#define MM_NAND_ECC_MSB         0x812
+#define MM_NAND_ECC_COL         0x813
+#define MM_NAND_LAC             0x814
+#define MM_NAND_ECC_CTL         0x815
+
+/* Registers within the NAND flash controller BAR -- I/O mapped */
+#define IO_NAND_DATA            0x00    /* 0 to 3, in fact */
+#define IO_NAND_CTL             0x04
+#define IO_NAND_IO              0x05
+#define IO_NAND_STS             0x06
+#define IO_NAND_ECC_CTL         0x08
+#define IO_NAND_ECC_LSB         0x09
+#define IO_NAND_ECC_MSB         0x0a
+#define IO_NAND_ECC_COL         0x0b
+#define IO_NAND_LAC             0x0c
+
+#define CS_NAND_CTL_DIST_EN     (1<<4)  /* Enable NAND Distract interrupt */
+#define CS_NAND_CTL_RDY_INT_MASK        (1<<3)  /* Enable RDY/BUSY# interrupt */
+#define CS_NAND_CTL_ALE         (1<<2)
+#define CS_NAND_CTL_CLE         (1<<1)
+#define CS_NAND_CTL_CE          (1<<0)  /* Keep low; 1 to reset */
+
+#define CS_NAND_STS_FLASH_RDY   (1<<3)
+#define CS_NAND_CTLR_BUSY       (1<<2)
+#define CS_NAND_CMD_COMP        (1<<1)
+#define CS_NAND_DIST_ST         (1<<0)
+
+#define CS_NAND_ECC_PARITY      (1<<2)
+#define CS_NAND_ECC_CLRECC      (1<<1)
+#define CS_NAND_ECC_ENECC       (1<<0)
+
+static void cs553x_read_buf(struct mtd_info *mtd, u_char *buf, int len)
+{
+        struct nand_chip *this = mtd->priv;
+
+        while (unlikely(len > 0x800)) {
+                memcpy_fromio(buf, this->IO_ADDR_R, 0x800);
+                buf += 0x800;
+                len -= 0x800;
+        }
+        memcpy_fromio(buf, this->IO_ADDR_R, len);
+}
+
+static void cs553x_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
+{
+        struct nand_chip *this = mtd->priv;
+
+        while (unlikely(len > 0x800)) {
+                memcpy_toio(this->IO_ADDR_R, buf, 0x800);
+                buf += 0x800;
+                len -= 0x800;
+        }
+        memcpy_toio(this->IO_ADDR_R, buf, len);
+}
+
+static unsigned char cs553x_read_byte(struct mtd_info *mtd)
+{
+        struct nand_chip *this = mtd->priv;
+        return readb(this->IO_ADDR_R);
+}
+
+static void cs553x_write_byte(struct mtd_info *mtd, u_char byte)
+{
+        struct nand_chip *this = mtd->priv;
+        int i = 100000;
+
+        while (i && readb(this->IO_ADDR_R + MM_NAND_STS) & CS_NAND_CTLR_BUSY) {
+                udelay(1);
+                i--;
+        }
+        writeb(byte, this->IO_ADDR_W + 0x801);
+}
+
+static void cs553x_hwcontrol(struct mtd_info *mtd, int cmd,
+                             unsigned int ctrl)
+{
+        struct nand_chip *this = mtd->priv;
+        void __iomem *mmio_base = this->IO_ADDR_R;
+        if (ctrl & NAND_CTRL_CHANGE) {
+                unsigned char ctl = (ctrl & ~NAND_CTRL_CHANGE ) ^ 0x01;
+                writeb(ctl, mmio_base + MM_NAND_CTL);
+        }
+        if (cmd != NAND_CMD_NONE)
+                cs553x_write_byte(mtd, cmd);
+}
+
+static int cs553x_device_ready(struct mtd_info *mtd)
+{
+        struct nand_chip *this = mtd->priv;
+        void __iomem *mmio_base = this->IO_ADDR_R;
+        unsigned char foo = readb(mmio_base + MM_NAND_STS);
+
+        return (foo & CS_NAND_STS_FLASH_RDY) && !(foo & CS_NAND_CTLR_BUSY);
+}
+
+static void cs_enable_hwecc(struct mtd_info *mtd, int mode)
+{
+        struct nand_chip *this = mtd->priv;
+        void __iomem *mmio_base = this->IO_ADDR_R;
+
+        writeb(0x07, mmio_base + MM_NAND_ECC_CTL);
+}
+
+static int cs_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code)
+{
+        uint32_t ecc;
+        struct nand_chip *this = mtd->priv;
+        void __iomem *mmio_base = this->IO_ADDR_R;
+
+        ecc = readl(mmio_base + MM_NAND_STS);
+
+        ecc_code[1] = ecc >> 8;
+        ecc_code[0] = ecc >> 16;
+        ecc_code[2] = ecc >> 24;
+        return 0;
+}
+
+static struct mtd_info *cs553x_mtd[4];
+
+static int __init cs553x_init_one(int cs, int mmio, unsigned long adr)
+{
+        int err = 0;
+        struct nand_chip *this;
+        struct mtd_info *new_mtd;
+
+        printk(KERN_NOTICE "Probing CS553x NAND controller CS#%d at %sIO 0x%08lx\n", cs, mmio?"MM":"P", adr);
+
+        if (!mmio) {
+                printk(KERN_NOTICE "PIO mode not yet implemented for CS553X NAND controller\n");
+                return -ENXIO;
+        }
+
+        /* Allocate memory for MTD device structure and private data */
+        new_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
+        if (!new_mtd) {
+                printk(KERN_WARNING "Unable to allocate CS553X NAND MTD device structure.\n");
+                err = -ENOMEM;
+                goto out;
+        }
+
+        /* Get pointer to private data */
+        this = (struct nand_chip *)(&new_mtd[1]);
+
+        /* Initialize structures */
+        memset(new_mtd, 0, sizeof(struct mtd_info));
+        memset(this, 0, sizeof(struct nand_chip));
+
+        /* Link the private data with the MTD structure */
+        new_mtd->priv = this;
+        new_mtd->owner = THIS_MODULE;
+
+        /* map physical address */
+        this->IO_ADDR_R = this->IO_ADDR_W = ioremap(adr, 4096);
+        if (!this->IO_ADDR_R) {
+                printk(KERN_WARNING "ioremap cs553x NAND @0x%08lx failed\n", adr);
+                err = -EIO;
+                goto out_mtd;
+        }
+
+        this->cmd_ctrl = cs553x_hwcontrol;
+        this->dev_ready = cs553x_device_ready;
+        this->read_byte = cs553x_read_byte;
+        this->read_buf = cs553x_read_buf;
+        this->write_buf = cs553x_write_buf;
+
+        this->chip_delay = 0;
+
+        this->ecc.mode = NAND_ECC_HW;
+        this->ecc.size = 256;
+        this->ecc.bytes = 3;
+        this->ecc.hwctl  = cs_enable_hwecc;
+        this->ecc.calculate = cs_calculate_ecc;
+        this->ecc.correct  = nand_correct_data;
+
+        /* Enable the following for a flash based bad block table */
+        this->options = NAND_USE_FLASH_BBT | NAND_NO_AUTOINCR;
+
+        /* Scan to find existance of the device */
+        if (nand_scan(new_mtd, 1)) {
+                err = -ENXIO;
+                goto out_ior;
+        }
+
+        cs553x_mtd[cs] = new_mtd;
+        goto out;
+
+out_ior:
+        iounmap((void *)this->IO_ADDR_R);
+out_mtd:
+        kfree(new_mtd);
+out:
+        return err;
+}
+
+static int is_geode(void)
+{
+        /* These are the CPUs which will have a CS553[56] companion chip */
+        if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
+            boot_cpu_data.x86 == 5 &&
+            boot_cpu_data.x86_model == 10)
+                return 1; /* Geode LX */
+
+        if ((boot_cpu_data.x86_vendor == X86_VENDOR_NSC ||
+             boot_cpu_data.x86_vendor == X86_VENDOR_CYRIX) &&
+            boot_cpu_data.x86 == 5 &&
+            boot_cpu_data.x86_model == 5)
+                return 1; /* Geode GX (née GX2) */
+
+        return 0;
+}
+
+static int __init cs553x_init(void)
+{
+        int err = -ENXIO;
+        int i;
+        uint64_t val;
+
+        /* If the CPU isn't a Geode GX or LX, abort */
+        if (!is_geode())
+                return -ENXIO;
+
+        /* If it doesn't have the CS553[56], abort */
+        rdmsrl(MSR_DIVIL_GLD_CAP, val);
+        val &= ~0xFFULL;
+        if (val != CAP_CS5535 && val != CAP_CS5536)
+                return -ENXIO;
+
+        /* If it doesn't have the NAND controller enabled, abort */
+        rdmsrl(MSR_DIVIL_BALL_OPTS, val);
+        if (val & 1) {
+                printk(KERN_INFO "CS553x NAND controller: Flash I/O not enabled in MSR_DIVIL_BALL_OPTS.\n");
+                return -ENXIO;
+        }
+
+        for (i = 0; i < NR_CS553X_CONTROLLERS; i++) {
+                rdmsrl(MSR_DIVIL_LBAR_FLSH0 + i, val);
+
+                if ((val & (FLSH_LBAR_EN|FLSH_NOR_NAND)) == (FLSH_LBAR_EN|FLSH_NOR_NAND))
+                        err = cs553x_init_one(i, !!(val & FLSH_MEM_IO), val & 0xFFFFFFFF);
+        }
+
+        /* Register all devices together here. This means we can easily hack it to 
+           do mtdconcat etc. if we want to. */
+        for (i = 0; i < NR_CS553X_CONTROLLERS; i++) {
+                if (cs553x_mtd[i]) {
+                        add_mtd_device(cs553x_mtd[i]);
+
+                        /* If any devices registered, return success. Else the last error. */
+                        err = 0;
+                }
+        }
+
+        return err;
+}
+
+module_init(cs553x_init);
+
+static void __exit cs553x_cleanup(void)
+{
+        int i;
+
+        for (i = 0; i < NR_CS553X_CONTROLLERS; i++) {
+                struct mtd_info *mtd = cs553x_mtd[i];
+                struct nand_chip *this;
+                void __iomem *mmio_base;
+
+                if (!mtd)
+                        break;
+
+                this = cs553x_mtd[i]->priv;
+                mmio_base = this->IO_ADDR_R;
+
+                /* Release resources, unregister device */
+                nand_release(cs553x_mtd[i]);
+                cs553x_mtd[i] = NULL;
+
+                /* unmap physical adress */
+                iounmap(mmio_base);
+
+                /* Free the MTD device structure */
+                kfree(mtd);
+        }
+}
+
+module_exit(cs553x_cleanup);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
+MODULE_DESCRIPTION("NAND controller driver for AMD CS5535/CS5536 companion chip");
diff --git a/drivers/mtd/nand/diskonchip.c b/drivers/mtd/nand/diskonchip.c
index ec5e45e4e4ef..6107f532855b 100644
--- a/drivers/mtd/nand/diskonchip.c
+++ b/drivers/mtd/nand/diskonchip.c
@@ -58,10 +58,10 @@ static unsigned long __initdata doc_locations[] = {
         0xe4000000,
 #elif defined(CONFIG_MOMENCO_OCELOT)
         0x2f000000,
-        0xff000000,
+        0xff000000,
 #elif defined(CONFIG_MOMENCO_OCELOT_G) || defined (CONFIG_MOMENCO_OCELOT_C)
-        0xff000000,
-##else
+        0xff000000,
+#else
 #warning Unknown architecture for DiskOnChip. No default probe locations defined
 #endif
         0xffffffff };
@@ -73,7 +73,7 @@ struct doc_priv {
         unsigned long physadr;
         u_char ChipID;
         u_char CDSNControl;
-        int chips_per_floor; /* The number of chips detected on each floor */
+        int chips_per_floor;    /* The number of chips detected on each floor */
         int curfloor;
         int curchip;
         int mh0_page;
@@ -84,6 +84,7 @@ struct doc_priv {
 /* This is the syndrome computed by the HW ecc generator upon reading an empty
    page, one with all 0xff for data and stored ecc code. */
 static u_char empty_read_syndrome[6] = { 0x26, 0xff, 0x6d, 0x47, 0x73, 0x7a };
+
 /* This is the ecc value computed by the HW ecc generator upon writing an empty
    page, one with all 0xff for data. */
 static u_char empty_write_ecc[6] = { 0x4b, 0x00, 0xe2, 0x0e, 0x93, 0xf7 };
@@ -94,28 +95,29 @@ static u_char empty_write_ecc[6] = { 0x4b, 0x00, 0xe2, 0x0e, 0x93, 0xf7 };
 #define DoC_is_Millennium(doc) ((doc)->ChipID == DOC_ChipID_DocMil)
 #define DoC_is_2000(doc) ((doc)->ChipID == DOC_ChipID_Doc2k)
 
-static void doc200x_hwcontrol(struct mtd_info *mtd, int cmd);
+static void doc200x_hwcontrol(struct mtd_info *mtd, int cmd,
+                              unsigned int bitmask);
 static void doc200x_select_chip(struct mtd_info *mtd, int chip);
 
-static int debug=0;
+static int debug = 0;
 module_param(debug, int, 0);
 
-static int try_dword=1;
+static int try_dword = 1;
 module_param(try_dword, int, 0);
 
-static int no_ecc_failures=0;
+static int no_ecc_failures = 0;
 module_param(no_ecc_failures, int, 0);
 
-static int no_autopart=0;
+static int no_autopart = 0;
 module_param(no_autopart, int, 0);
 
-static int show_firmware_partition=0;
+static int show_firmware_partition = 0;
 module_param(show_firmware_partition, int, 0);
 
 #ifdef MTD_NAND_DISKONCHIP_BBTWRITE
-static int inftl_bbt_write=1;
+static int inftl_bbt_write = 1;
 #else
-static int inftl_bbt_write=0;
+static int inftl_bbt_write = 0;
 #endif
 module_param(inftl_bbt_write, int, 0);
 
@@ -123,7 +125,6 @@ static unsigned long doc_config_location = CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDR
 module_param(doc_config_location, ulong, 0);
 MODULE_PARM_DESC(doc_config_location, "Physical memory address at which to probe for DiskOnChip");
 
-
 /* Sector size for HW ECC */
 #define SECTOR_SIZE 512
 /* The sector bytes are packed into NB_DATA 10 bit words */
@@ -147,7 +148,7 @@ static struct rs_control *rs_decoder;
  * some comments, improved a minor bit and converted it to make use
  * of the generic Reed-Solomon libary. tglx
  */
-static int doc_ecc_decode (struct rs_control *rs, uint8_t *data, uint8_t *ecc)
+static int doc_ecc_decode(struct rs_control *rs, uint8_t *data, uint8_t *ecc)
 {
         int i, j, nerr, errpos[8];
         uint8_t parity;
@@ -168,18 +169,18 @@ static int doc_ecc_decode (struct rs_control *rs, uint8_t *data, uint8_t *ecc)
          *  s[i] = ds[3]x^3 + ds[2]x^2 + ds[1]x^1 + ds[0]
          *  where x = alpha^(FCR + i)
          */
-        for(j = 1; j < NROOTS; j++) {
-                if(ds[j] == 0)
+        for (j = 1; j < NROOTS; j++) {
+                if (ds[j] == 0)
                         continue;
                 tmp = rs->index_of[ds[j]];
-                for(i = 0; i < NROOTS; i++)
+                for (i = 0; i < NROOTS; i++)
                         s[i] ^= rs->alpha_to[rs_modnn(rs, tmp + (FCR + i) * j)];
         }
 
         /* Calc s[i] = s[i] / alpha^(v + i) */
         for (i = 0; i < NROOTS; i++) {
                 if (syn[i])
-                        syn[i] = rs_modnn(rs, rs->index_of[s[i]] + (NN - FCR - i));
+                        syn[i] = rs_modnn(rs, rs->index_of[s[i]] + (NN - FCR - i));
         }
         /* Call the decoder library */
         nerr = decode_rs16(rs, NULL, NULL, 1019, syn, 0, errpos, 0, errval);
@@ -193,7 +194,7 @@ static int doc_ecc_decode (struct rs_control *rs, uint8_t *data, uint8_t *ecc)
          * but they are given by the design of the de/encoder circuit
          * in the DoC ASIC's.
          */
-        for(i = 0;i < nerr; i++) {
+        for (i = 0; i < nerr; i++) {
                 int index, bitpos, pos = 1015 - errpos[i];
                 uint8_t val;
                 if (pos >= NB_DATA && pos < 1019)
@@ -205,8 +206,7 @@ static int doc_ecc_decode (struct rs_control *rs, uint8_t *data, uint8_t *ecc)
                            can be modified since pos is even */
                         index = (pos >> 3) ^ 1;
                         bitpos = pos & 7;
-                        if ((index >= 0 && index < SECTOR_SIZE) ||
-                            index == (SECTOR_SIZE + 1)) {
+                        if ((index >= 0 && index < SECTOR_SIZE) || index == (SECTOR_SIZE + 1)) {
                                 val = (uint8_t) (errval[i] >> (2 + bitpos));
                                 parity ^= val;
                                 if (index < SECTOR_SIZE)
@@ -216,9 +216,8 @@ static int doc_ecc_decode (struct rs_control *rs, uint8_t *data, uint8_t *ecc)
                         bitpos = (bitpos + 10) & 7;
                         if (bitpos == 0)
                                 bitpos = 8;
-                        if ((index >= 0 && index < SECTOR_SIZE) ||
-                            index == (SECTOR_SIZE + 1)) {
-                                val = (uint8_t)(errval[i] << (8 - bitpos));
+                        if ((index >= 0 && index < SECTOR_SIZE) || index == (SECTOR_SIZE + 1)) {
+                                val = (uint8_t) (errval[i] << (8 - bitpos));
                                 parity ^= val;
                                 if (index < SECTOR_SIZE)
                                         data[index] ^= val;
@@ -250,10 +249,11 @@ static void DoC_Delay(struct doc_priv *doc, unsigned short cycles)
 /* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */
 static int _DoC_WaitReady(struct doc_priv *doc)
 {
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         unsigned long timeo = jiffies + (HZ * 10);
 
-        if(debug) printk("_DoC_WaitReady...\n");
+        if (debug)
+                printk("_DoC_WaitReady...\n");
         /* Out-of-line routine to wait for chip response */
         if (DoC_is_MillenniumPlus(doc)) {
                 while ((ReadDOC(docptr, Mplus_FlashControl) & CDSN_CTRL_FR_B_MASK) != CDSN_CTRL_FR_B_MASK) {
@@ -280,7 +280,7 @@ static int _DoC_WaitReady(struct doc_priv *doc)
 
 static inline int DoC_WaitReady(struct doc_priv *doc)
 {
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         int ret = 0;
 
         if (DoC_is_MillenniumPlus(doc)) {
@@ -298,7 +298,8 @@ static inline int DoC_WaitReady(struct doc_priv *doc)
                 DoC_Delay(doc, 2);
         }
 
-        if(debug) printk("DoC_WaitReady OK\n");
+        if (debug)
+                printk("DoC_WaitReady OK\n");
         return ret;
 }
 
@@ -306,9 +307,10 @@ static void doc2000_write_byte(struct mtd_info *mtd, u_char datum)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
 
-        if(debug)printk("write_byte %02x\n", datum);
+        if (debug)
+                printk("write_byte %02x\n", datum);
         WriteDOC(datum, docptr, CDSNSlowIO);
         WriteDOC(datum, docptr, 2k_CDSN_IO);
 }
@@ -317,77 +319,78 @@ static u_char doc2000_read_byte(struct mtd_info *mtd)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         u_char ret;
 
         ReadDOC(docptr, CDSNSlowIO);
         DoC_Delay(doc, 2);
         ret = ReadDOC(docptr, 2k_CDSN_IO);
-        if (debug) printk("read_byte returns %02x\n", ret);
+        if (debug)
+                printk("read_byte returns %02x\n", ret);
         return ret;
 }
 
-static void doc2000_writebuf(struct mtd_info *mtd,
-                             const u_char *buf, int len)
+static void doc2000_writebuf(struct mtd_info *mtd, const u_char *buf, int len)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         int i;
-        if (debug)printk("writebuf of %d bytes: ", len);
-        for (i=0; i < len; i++) {
+        if (debug)
+                printk("writebuf of %d bytes: ", len);
+        for (i = 0; i < len; i++) {
                 WriteDOC_(buf[i], docptr, DoC_2k_CDSN_IO + i);
                 if (debug && i < 16)
                         printk("%02x ", buf[i]);
         }
-        if (debug) printk("\n");
+        if (debug)
+                printk("\n");
 }
 
-static void doc2000_readbuf(struct mtd_info *mtd,
-                            u_char *buf, int len)
+static void doc2000_readbuf(struct mtd_info *mtd, u_char *buf, int len)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
-        int i;
+        void __iomem *docptr = doc->virtadr;
+        int i;
 
-        if (debug)printk("readbuf of %d bytes: ", len);
+        if (debug)
+                printk("readbuf of %d bytes: ", len);
 
-        for (i=0; i < len; i++) {
+        for (i = 0; i < len; i++) {
                 buf[i] = ReadDOC(docptr, 2k_CDSN_IO + i);
         }
 }
 
-static void doc2000_readbuf_dword(struct mtd_info *mtd,
-                            u_char *buf, int len)
+static void doc2000_readbuf_dword(struct mtd_info *mtd, u_char *buf, int len)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
-        int i;
+        void __iomem *docptr = doc->virtadr;
+        int i;
 
-        if (debug) printk("readbuf_dword of %d bytes: ", len);
+        if (debug)
+                printk("readbuf_dword of %d bytes: ", len);
 
-        if (unlikely((((unsigned long)buf)|len) & 3)) {
-                for (i=0; i < len; i++) {
-                        *(uint8_t *)(&buf[i]) = ReadDOC(docptr, 2k_CDSN_IO + i);
+        if (unlikely((((unsigned long)buf) | len) & 3)) {
+                for (i = 0; i < len; i++) {
+                        *(uint8_t *) (&buf[i]) = ReadDOC(docptr, 2k_CDSN_IO + i);
                 }
         } else {
-                for (i=0; i < len; i+=4) {
-                        *(uint32_t*)(&buf[i]) = readl(docptr + DoC_2k_CDSN_IO + i);
+                for (i = 0; i < len; i += 4) {
+                        *(uint32_t *) (&buf[i]) = readl(docptr + DoC_2k_CDSN_IO + i);
                 }
         }
 }
 
-static int doc2000_verifybuf(struct mtd_info *mtd,
-                              const u_char *buf, int len)
+static int doc2000_verifybuf(struct mtd_info *mtd, const u_char *buf, int len)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         int i;
 
-        for (i=0; i < len; i++)
+        for (i = 0; i < len; i++)
                 if (buf[i] != ReadDOC(docptr, 2k_CDSN_IO))
                         return -EFAULT;
         return 0;
@@ -400,12 +403,10 @@ static uint16_t __init doc200x_ident_chip(struct mtd_info *mtd, int nr)
         uint16_t ret;
 
         doc200x_select_chip(mtd, nr);
-        doc200x_hwcontrol(mtd, NAND_CTL_SETCLE);
-        this->write_byte(mtd, NAND_CMD_READID);
-        doc200x_hwcontrol(mtd, NAND_CTL_CLRCLE);
-        doc200x_hwcontrol(mtd, NAND_CTL_SETALE);
-        this->write_byte(mtd, 0);
-        doc200x_hwcontrol(mtd, NAND_CTL_CLRALE);
+        doc200x_hwcontrol(mtd, NAND_CMD_READID,
+                          NAND_CTRL_CLE | NAND_CTRL_CHANGE);
+        doc200x_hwcontrol(mtd, 0, NAND_CTRL_ALE | NAND_CTRL_CHANGE);
+        doc200x_hwcontrol(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
 
         /* We cant' use dev_ready here, but at least we wait for the
          * command to complete
@@ -423,12 +424,11 @@ static uint16_t __init doc200x_ident_chip(struct mtd_info *mtd, int nr)
                 } ident;
                 void __iomem *docptr = doc->virtadr;
 
-                doc200x_hwcontrol(mtd, NAND_CTL_SETCLE);
-                doc2000_write_byte(mtd, NAND_CMD_READID);
-                doc200x_hwcontrol(mtd, NAND_CTL_CLRCLE);
-                doc200x_hwcontrol(mtd, NAND_CTL_SETALE);
-                doc2000_write_byte(mtd, 0);
-                doc200x_hwcontrol(mtd, NAND_CTL_CLRALE);
+                doc200x_hwcontrol(mtd, NAND_CMD_READID,
+                                  NAND_CTRL_CLE | NAND_CTRL_CHANGE);
+                doc200x_hwcontrol(mtd, 0, NAND_CTRL_ALE | NAND_CTRL_CHANGE);
+                doc200x_hwcontrol(mtd, NAND_CMD_NONE,
+                                  NAND_NCE | NAND_CTRL_CHANGE);
 
                 udelay(50);
 
@@ -464,7 +464,7 @@ static void __init doc2000_count_chips(struct mtd_info *mtd)
         printk(KERN_DEBUG "Detected %d chips per floor.\n", i);
 }
 
-static int doc200x_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
+static int doc200x_wait(struct mtd_info *mtd, struct nand_chip *this)
 {
         struct doc_priv *doc = this->priv;
 
@@ -482,7 +482,7 @@ static void doc2001_write_byte(struct mtd_info *mtd, u_char datum)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
 
         WriteDOC(datum, docptr, CDSNSlowIO);
         WriteDOC(datum, docptr, Mil_CDSN_IO);
@@ -493,7 +493,7 @@ static u_char doc2001_read_byte(struct mtd_info *mtd)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
 
         //ReadDOC(docptr, CDSNSlowIO);
         /* 11.4.5 -- delay twice to allow extended length cycle */
@@ -503,50 +503,47 @@ static u_char doc2001_read_byte(struct mtd_info *mtd)
         return ReadDOC(docptr, LastDataRead);
 }
 
-static void doc2001_writebuf(struct mtd_info *mtd,
-                             const u_char *buf, int len)
+static void doc2001_writebuf(struct mtd_info *mtd, const u_char *buf, int len)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         int i;
 
-        for (i=0; i < len; i++)
+        for (i = 0; i < len; i++)
                 WriteDOC_(buf[i], docptr, DoC_Mil_CDSN_IO + i);
         /* Terminate write pipeline */
         WriteDOC(0x00, docptr, WritePipeTerm);
 }
 
-static void doc2001_readbuf(struct mtd_info *mtd,
-                            u_char *buf, int len)
+static void doc2001_readbuf(struct mtd_info *mtd, u_char *buf, int len)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         int i;
 
         /* Start read pipeline */
         ReadDOC(docptr, ReadPipeInit);
 
-        for (i=0; i < len-1; i++)
+        for (i = 0; i < len - 1; i++)
                 buf[i] = ReadDOC(docptr, Mil_CDSN_IO + (i & 0xff));
 
         /* Terminate read pipeline */
         buf[i] = ReadDOC(docptr, LastDataRead);
 }
 
-static int doc2001_verifybuf(struct mtd_info *mtd,
-                             const u_char *buf, int len)
+static int doc2001_verifybuf(struct mtd_info *mtd, const u_char *buf, int len)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         int i;
 
         /* Start read pipeline */
         ReadDOC(docptr, ReadPipeInit);
 
-        for (i=0; i < len-1; i++)
+        for (i = 0; i < len - 1; i++)
                 if (buf[i] != ReadDOC(docptr, Mil_CDSN_IO)) {
                         ReadDOC(docptr, LastDataRead);
                         return i;
@@ -560,87 +557,90 @@ static u_char doc2001plus_read_byte(struct mtd_info *mtd)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         u_char ret;
 
-        ReadDOC(docptr, Mplus_ReadPipeInit);
-        ReadDOC(docptr, Mplus_ReadPipeInit);
-        ret = ReadDOC(docptr, Mplus_LastDataRead);
-        if (debug) printk("read_byte returns %02x\n", ret);
+        ReadDOC(docptr, Mplus_ReadPipeInit);
+        ReadDOC(docptr, Mplus_ReadPipeInit);
+        ret = ReadDOC(docptr, Mplus_LastDataRead);
+        if (debug)
+                printk("read_byte returns %02x\n", ret);
         return ret;
 }
 
-static void doc2001plus_writebuf(struct mtd_info *mtd,
-                             const u_char *buf, int len)
+static void doc2001plus_writebuf(struct mtd_info *mtd, const u_char *buf, int len)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         int i;
 
-        if (debug)printk("writebuf of %d bytes: ", len);
-        for (i=0; i < len; i++) {
+        if (debug)
+                printk("writebuf of %d bytes: ", len);
+        for (i = 0; i < len; i++) {
                 WriteDOC_(buf[i], docptr, DoC_Mil_CDSN_IO + i);
                 if (debug && i < 16)
                         printk("%02x ", buf[i]);
         }
-        if (debug) printk("\n");
+        if (debug)
+                printk("\n");
 }
 
-static void doc2001plus_readbuf(struct mtd_info *mtd,
-                            u_char *buf, int len)
+static void doc2001plus_readbuf(struct mtd_info *mtd, u_char *buf, int len)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         int i;
 
-        if (debug)printk("readbuf of %d bytes: ", len);
+        if (debug)
+                printk("readbuf of %d bytes: ", len);
 
         /* Start read pipeline */
         ReadDOC(docptr, Mplus_ReadPipeInit);
         ReadDOC(docptr, Mplus_ReadPipeInit);
 
-        for (i=0; i < len-2; i++) {
+        for (i = 0; i < len - 2; i++) {
                 buf[i] = ReadDOC(docptr, Mil_CDSN_IO);
                 if (debug && i < 16)
                         printk("%02x ", buf[i]);
         }
 
         /* Terminate read pipeline */
-        buf[len-2] = ReadDOC(docptr, Mplus_LastDataRead);
+        buf[len - 2] = ReadDOC(docptr, Mplus_LastDataRead);
         if (debug && i < 16)
-                printk("%02x ", buf[len-2]);
-        buf[len-1] = ReadDOC(docptr, Mplus_LastDataRead);
+                printk("%02x ", buf[len - 2]);
+        buf[len - 1] = ReadDOC(docptr, Mplus_LastDataRead);
         if (debug && i < 16)
-                printk("%02x ", buf[len-1]);
-        if (debug) printk("\n");
+                printk("%02x ", buf[len - 1]);
+        if (debug)
+                printk("\n");
 }
 
-static int doc2001plus_verifybuf(struct mtd_info *mtd,
-                             const u_char *buf, int len)
+static int doc2001plus_verifybuf(struct mtd_info *mtd, const u_char *buf, int len)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         int i;
 
-        if (debug)printk("verifybuf of %d bytes: ", len);
+        if (debug)
+                printk("verifybuf of %d bytes: ", len);
 
         /* Start read pipeline */
         ReadDOC(docptr, Mplus_ReadPipeInit);
         ReadDOC(docptr, Mplus_ReadPipeInit);
 
-        for (i=0; i < len-2; i++)
+        for (i = 0; i < len - 2; i++)
                 if (buf[i] != ReadDOC(docptr, Mil_CDSN_IO)) {
                         ReadDOC(docptr, Mplus_LastDataRead);
                         ReadDOC(docptr, Mplus_LastDataRead);
                         return i;
                 }
-        if (buf[len-2] != ReadDOC(docptr, Mplus_LastDataRead))
-                return len-2;
-        if (buf[len-1] != ReadDOC(docptr, Mplus_LastDataRead))
-                return len-1;
+        if (buf[len - 2] != ReadDOC(docptr, Mplus_LastDataRead))
+                return len - 2;
+        if (buf[len - 1] != ReadDOC(docptr, Mplus_LastDataRead))
+                return len - 1;
         return 0;
 }
 
@@ -648,10 +648,11 @@ static void doc2001plus_select_chip(struct mtd_info *mtd, int chip)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         int floor = 0;
 
-        if(debug)printk("select chip (%d)\n", chip);
+        if (debug)
+                printk("select chip (%d)\n", chip);
 
         if (chip == -1) {
                 /* Disable flash internally */
@@ -660,7 +661,7 @@ static void doc2001plus_select_chip(struct mtd_info *mtd, int chip)
         }
 
         floor = chip / doc->chips_per_floor;
-        chip -= (floor *  doc->chips_per_floor);
+        chip -= (floor * doc->chips_per_floor);
 
         /* Assert ChipEnable and deassert WriteProtect */
         WriteDOC((DOC_FLASH_CE), docptr, Mplus_FlashSelect);
@@ -674,72 +675,61 @@ static void doc200x_select_chip(struct mtd_info *mtd, int chip)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         int floor = 0;
 
-        if(debug)printk("select chip (%d)\n", chip);
+        if (debug)
+                printk("select chip (%d)\n", chip);
 
         if (chip == -1)
                 return;
 
         floor = chip / doc->chips_per_floor;
-        chip -= (floor *  doc->chips_per_floor);
+        chip -= (floor * doc->chips_per_floor);
 
         /* 11.4.4 -- deassert CE before changing chip */
-        doc200x_hwcontrol(mtd, NAND_CTL_CLRNCE);
+        doc200x_hwcontrol(mtd, NAND_CMD_NONE, 0 | NAND_CTRL_CHANGE);
 
         WriteDOC(floor, docptr, FloorSelect);
         WriteDOC(chip, docptr, CDSNDeviceSelect);
 
-        doc200x_hwcontrol(mtd, NAND_CTL_SETNCE);
+        doc200x_hwcontrol(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
 
         doc->curchip = chip;
         doc->curfloor = floor;
 }
 
-static void doc200x_hwcontrol(struct mtd_info *mtd, int cmd)
+#define CDSN_CTRL_MSK (CDSN_CTRL_CE | CDSN_CTRL_CLE | CDSN_CTRL_ALE)
+
+static void doc200x_hwcontrol(struct mtd_info *mtd, int cmd,
+                              unsigned int ctrl)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
 
-        switch(cmd) {
-        case NAND_CTL_SETNCE:
-                doc->CDSNControl |= CDSN_CTRL_CE;
-                break;
-        case NAND_CTL_CLRNCE:
-                doc->CDSNControl &= ~CDSN_CTRL_CE;
-                break;
-        case NAND_CTL_SETCLE:
-                doc->CDSNControl |= CDSN_CTRL_CLE;
-                break;
-        case NAND_CTL_CLRCLE:
-                doc->CDSNControl &= ~CDSN_CTRL_CLE;
-                break;
-        case NAND_CTL_SETALE:
-                doc->CDSNControl |= CDSN_CTRL_ALE;
-                break;
-        case NAND_CTL_CLRALE:
-                doc->CDSNControl &= ~CDSN_CTRL_ALE;
-                break;
-        case NAND_CTL_SETWP:
-                doc->CDSNControl |= CDSN_CTRL_WP;
-                break;
-        case NAND_CTL_CLRWP:
-                doc->CDSNControl &= ~CDSN_CTRL_WP;
-                break;
+        if (ctrl & NAND_CTRL_CHANGE) {
+                doc->CDSNControl &= ~CDSN_CTRL_MSK;
+                doc->CDSNControl |= ctrl & CDSN_CTRL_MSK;
+                if (debug)
+                        printk("hwcontrol(%d): %02x\n", cmd, doc->CDSNControl);
+                WriteDOC(doc->CDSNControl, docptr, CDSNControl);
+                /* 11.4.3 -- 4 NOPs after CSDNControl write */
+                DoC_Delay(doc, 4);
+        }
+        if (cmd != NAND_CMD_NONE) {
+                if (DoC_is_2000(doc))
+                        doc2000_write_byte(mtd, cmd);
+                else
+                        doc2001_write_byte(mtd, cmd);
         }
-        if (debug)printk("hwcontrol(%d): %02x\n", cmd, doc->CDSNControl);
-        WriteDOC(doc->CDSNControl, docptr, CDSNControl);
-        /* 11.4.3 -- 4 NOPs after CSDNControl write */
-        DoC_Delay(doc, 4);
 }
 
-static void doc2001plus_command (struct mtd_info *mtd, unsigned command, int column, int page_addr)
+static void doc2001plus_command(struct mtd_info *mtd, unsigned command, int column, int page_addr)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
 
         /*
          * Must terminate write pipeline before sending any commands
@@ -756,9 +746,9 @@ static void doc2001plus_command (struct mtd_info *mtd, unsigned command, int col
         if (command == NAND_CMD_SEQIN) {
                 int readcmd;
 
-                if (column >= mtd->oobblock) {
+                if (column >= mtd->writesize) {
                         /* OOB area */
-                        column -= mtd->oobblock;
+                        column -= mtd->writesize;
                         readcmd = NAND_CMD_READOOB;
                 } else if (column < 256) {
                         /* First 256 bytes --> READ0 */
@@ -782,25 +772,26 @@ static void doc2001plus_command (struct mtd_info *mtd, unsigned command, int col
                         WriteDOC(column, docptr, Mplus_FlashAddress);
                 }
                 if (page_addr != -1) {
-                        WriteDOC((unsigned char) (page_addr & 0xff), docptr, Mplus_FlashAddress);
-                        WriteDOC((unsigned char) ((page_addr >> 8) & 0xff), docptr, Mplus_FlashAddress);
+                        WriteDOC((unsigned char)(page_addr & 0xff), docptr, Mplus_FlashAddress);
+                        WriteDOC((unsigned char)((page_addr >> 8) & 0xff), docptr, Mplus_FlashAddress);
                         /* One more address cycle for higher density devices */
                         if (this->chipsize & 0x0c000000) {
-                                WriteDOC((unsigned char) ((page_addr >> 16) & 0x0f), docptr, Mplus_FlashAddress);
+                                WriteDOC((unsigned char)((page_addr >> 16) & 0x0f), docptr, Mplus_FlashAddress);
                                 printk("high density\n");
                         }
                 }
                 WriteDOC(0, docptr, Mplus_WritePipeTerm);
                 WriteDOC(0, docptr, Mplus_WritePipeTerm);
                 /* deassert ALE */
-                if (command == NAND_CMD_READ0 || command == NAND_CMD_READ1 || command == NAND_CMD_READOOB || command == NAND_CMD_READID)
+                if (command == NAND_CMD_READ0 || command == NAND_CMD_READ1 ||
+                    command == NAND_CMD_READOOB || command == NAND_CMD_READID)
                         WriteDOC(0, docptr, Mplus_FlashControl);
         }
 
         /*
          * program and erase have their own busy handlers
          * status and sequential in needs no delay
-        */
+         */
         switch (command) {
 
         case NAND_CMD_PAGEPROG:
@@ -817,55 +808,57 @@ static void doc2001plus_command (struct mtd_info *mtd, unsigned command, int col
                 WriteDOC(NAND_CMD_STATUS, docptr, Mplus_FlashCmd);
                 WriteDOC(0, docptr, Mplus_WritePipeTerm);
                 WriteDOC(0, docptr, Mplus_WritePipeTerm);
-                while ( !(this->read_byte(mtd) & 0x40));
+                while (!(this->read_byte(mtd) & 0x40)) ;
                 return;
 
-        /* This applies to read commands */
+                /* This applies to read commands */
         default:
                 /*
                  * If we don't have access to the busy pin, we apply the given
                  * command delay
-                */
+                 */
                 if (!this->dev_ready) {
-                        udelay (this->chip_delay);
+                        udelay(this->chip_delay);
                         return;
                 }
         }
 
         /* Apply this short delay always to ensure that we do wait tWB in
          * any case on any machine. */
-        ndelay (100);
+        ndelay(100);
         /* wait until command is processed */
-        while (!this->dev_ready(mtd));
+        while (!this->dev_ready(mtd)) ;
 }
 
 static int doc200x_dev_ready(struct mtd_info *mtd)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
 
         if (DoC_is_MillenniumPlus(doc)) {
                 /* 11.4.2 -- must NOP four times before checking FR/B# */
                 DoC_Delay(doc, 4);
                 if ((ReadDOC(docptr, Mplus_FlashControl) & CDSN_CTRL_FR_B_MASK) != CDSN_CTRL_FR_B_MASK) {
-                        if(debug)
+                        if (debug)
                                 printk("not ready\n");
                         return 0;
                 }
-                if (debug)printk("was ready\n");
+                if (debug)
+                        printk("was ready\n");
                 return 1;
         } else {
                 /* 11.4.2 -- must NOP four times before checking FR/B# */
                 DoC_Delay(doc, 4);
                 if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
-                        if(debug)
+                        if (debug)
                                 printk("not ready\n");
                         return 0;
                 }
                 /* 11.4.2 -- Must NOP twice if it's ready */
                 DoC_Delay(doc, 2);
-                if (debug)printk("was ready\n");
+                if (debug)
+                        printk("was ready\n");
                 return 1;
         }
 }
@@ -881,10 +874,10 @@ static void doc200x_enable_hwecc(struct mtd_info *mtd, int mode)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
 
         /* Prime the ECC engine */
-        switch(mode) {
+        switch (mode) {
         case NAND_ECC_READ:
                 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
                 WriteDOC(DOC_ECC_EN, docptr, ECCConf);
@@ -900,10 +893,10 @@ static void doc2001plus_enable_hwecc(struct mtd_info *mtd, int mode)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
 
         /* Prime the ECC engine */
-        switch(mode) {
+        switch (mode) {
         case NAND_ECC_READ:
                 WriteDOC(DOC_ECC_RESET, docptr, Mplus_ECCConf);
                 WriteDOC(DOC_ECC_EN, docptr, Mplus_ECCConf);
@@ -916,12 +909,11 @@ static void doc2001plus_enable_hwecc(struct mtd_info *mtd, int mode)
 }
 
 /* This code is only called on write */
-static int doc200x_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
-                                 unsigned char *ecc_code)
+static int doc200x_calculate_ecc(struct mtd_info *mtd, const u_char *dat, unsigned char *ecc_code)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
         int i;
         int emptymatch = 1;
 
@@ -961,7 +953,8 @@ static int doc200x_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
                    often.  It could be optimized away by examining the data in
                    the writebuf routine, and remembering the result. */
                 for (i = 0; i < 512; i++) {
-                        if (dat[i] == 0xff) continue;
+                        if (dat[i] == 0xff)
+                                continue;
                         emptymatch = 0;
                         break;
                 }
@@ -969,17 +962,20 @@ static int doc200x_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
         /* If emptymatch still =1, we do have an all-0xff data buffer.
            Return all-0xff ecc value instead of the computed one, so
            it'll look just like a freshly-erased page. */
-        if (emptymatch) memset(ecc_code, 0xff, 6);
+        if (emptymatch)
+                memset(ecc_code, 0xff, 6);
 #endif
         return 0;
 }
 
-static int doc200x_correct_data(struct mtd_info *mtd, u_char *dat, u_char *read_ecc, u_char *calc_ecc)
+static int doc200x_correct_data(struct mtd_info *mtd, u_char *dat,
+                                u_char *read_ecc, u_char *isnull)
 {
         int i, ret = 0;
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
+        void __iomem *docptr = doc->virtadr;
+        uint8_t calc_ecc[6];
         volatile u_char dummy;
         int emptymatch = 1;
 
@@ -1012,18 +1008,20 @@ static int doc200x_correct_data(struct mtd_info *mtd, u_char *dat, u_char *read_
                    all-0xff data and stored ecc block.  Check the stored ecc. */
                 if (emptymatch) {
                         for (i = 0; i < 6; i++) {
-                                if (read_ecc[i] == 0xff) continue;
+                                if (read_ecc[i] == 0xff)
+                                        continue;
                                 emptymatch = 0;
                                 break;
                         }
                 }
                 /* If emptymatch still =1, check the data block. */
                 if (emptymatch) {
-                /* Note: this somewhat expensive test should not be triggered
-                   often.  It could be optimized away by examining the data in
-                   the readbuf routine, and remembering the result. */
+                        /* Note: this somewhat expensive test should not be triggered
+                           often.  It could be optimized away by examining the data in
+                           the readbuf routine, and remembering the result. */
                         for (i = 0; i < 512; i++) {
-                                if (dat[i] == 0xff) continue;
+                                if (dat[i] == 0xff)
+                                        continue;
                                 emptymatch = 0;
                                 break;
                         }
@@ -1032,7 +1030,8 @@ static int doc200x_correct_data(struct mtd_info *mtd, u_char *dat, u_char *read_
                    erased block, in which case the ECC will not come out right.
                    We'll suppress the error and tell the caller everything's
                    OK.  Because it is. */
-                if (!emptymatch) ret = doc_ecc_decode (rs_decoder, dat, calc_ecc);
+                if (!emptymatch)
+                        ret = doc_ecc_decode(rs_decoder, dat, calc_ecc);
                 if (ret > 0)
                         printk(KERN_ERR "doc200x_correct_data corrected %d errors\n", ret);
         }
@@ -1059,11 +1058,10 @@ static int doc200x_correct_data(struct mtd_info *mtd, u_char *dat, u_char *read_
  * safer.  The only problem with it is that any code that parses oobfree must
  * be able to handle out-of-order segments.
  */
-static struct nand_oobinfo doc200x_oobinfo = {
-        .useecc = MTD_NANDECC_AUTOPLACE,
-        .eccbytes = 6,
-        .eccpos = {0, 1, 2, 3, 4, 5},
-        .oobfree = { {8, 8}, {6, 2} }
+static struct nand_ecclayout doc200x_oobinfo = {
+        .eccbytes = 6,
+        .eccpos = {0, 1, 2, 3, 4, 5},
+        .oobfree = {{8, 8}, {6, 2}}
 };
 
 /* Find the (I)NFTL Media Header, and optionally also the mirror media header.
@@ -1072,8 +1070,7 @@ static struct nand_oobinfo doc200x_oobinfo = {
    either "ANAND" or "BNAND".  If findmirror=1, also look for the mirror media
    header.  The page #s of the found media headers are placed in mh0_page and
    mh1_page in the DOC private structure. */
-static int __init find_media_headers(struct mtd_info *mtd, u_char *buf,
-                                     const char *id, int findmirror)
+static int __init find_media_headers(struct mtd_info *mtd, u_char *buf, const char *id, int findmirror)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
@@ -1082,17 +1079,19 @@ static int __init find_media_headers(struct mtd_info *mtd, u_char *buf,
         size_t retlen;
 
         for (offs = 0; offs < mtd->size; offs += mtd->erasesize) {
-                ret = mtd->read(mtd, offs, mtd->oobblock, &retlen, buf);
-                if (retlen != mtd->oobblock) continue;
+                ret = mtd->read(mtd, offs, mtd->writesize, &retlen, buf);
+                if (retlen != mtd->writesize)
+                        continue;
                 if (ret) {
-                        printk(KERN_WARNING "ECC error scanning DOC at 0x%x\n",
-                                offs);
+                        printk(KERN_WARNING "ECC error scanning DOC at 0x%x\n", offs);
                 }
-                if (memcmp(buf, id, 6)) continue;
+                if (memcmp(buf, id, 6))
+                        continue;
                 printk(KERN_INFO "Found DiskOnChip %s Media Header at 0x%x\n", id, offs);
                 if (doc->mh0_page == -1) {
                         doc->mh0_page = offs >> this->page_shift;
-                        if (!findmirror) return 1;
+                        if (!findmirror)
+                                return 1;
                         continue;
                 }
                 doc->mh1_page = offs >> this->page_shift;
@@ -1105,8 +1104,8 @@ static int __init find_media_headers(struct mtd_info *mtd, u_char *buf,
         /* Only one mediaheader was found.  We want buf to contain a
            mediaheader on return, so we'll have to re-read the one we found. */
         offs = doc->mh0_page << this->page_shift;
-        ret = mtd->read(mtd, offs, mtd->oobblock, &retlen, buf);
-        if (retlen != mtd->oobblock) {
+        ret = mtd->read(mtd, offs, mtd->writesize, &retlen, buf);
+        if (retlen != mtd->writesize) {
                 /* Insanity.  Give up. */
                 printk(KERN_ERR "Read DiskOnChip Media Header once, but can't reread it???\n");
                 return 0;
@@ -1114,8 +1113,7 @@ static int __init find_media_headers(struct mtd_info *mtd, u_char *buf,
         return 1;
 }
 
-static inline int __init nftl_partscan(struct mtd_info *mtd,
-                                struct mtd_partition *parts)
+static inline int __init nftl_partscan(struct mtd_info *mtd, struct mtd_partition *parts)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
@@ -1127,13 +1125,14 @@ static inline int __init nftl_partscan(struct mtd_info *mtd,
         unsigned blocks, maxblocks;
         int offs, numheaders;
 
-        buf = kmalloc(mtd->oobblock, GFP_KERNEL);
+        buf = kmalloc(mtd->writesize, GFP_KERNEL);
         if (!buf) {
                 printk(KERN_ERR "DiskOnChip mediaheader kmalloc failed!\n");
                 return 0;
         }
-        if (!(numheaders=find_media_headers(mtd, buf, "ANAND", 1))) goto out;
-        mh = (struct NFTLMediaHeader *) buf;
+        if (!(numheaders = find_media_headers(mtd, buf, "ANAND", 1)))
+                goto out;
+        mh = (struct NFTLMediaHeader *)buf;
 
         mh->NumEraseUnits = le16_to_cpu(mh->NumEraseUnits);
         mh->FirstPhysicalEUN = le16_to_cpu(mh->FirstPhysicalEUN);
@@ -1155,8 +1154,8 @@ static inline int __init nftl_partscan(struct mtd_info *mtd,
                 /* Auto-determine UnitSizeFactor.  The constraints are:
                    - There can be at most 32768 virtual blocks.
                    - There can be at most (virtual block size - page size)
-                     virtual blocks (because MediaHeader+BBT must fit in 1).
-                */
+                   virtual blocks (because MediaHeader+BBT must fit in 1).
+                 */
                 mh->UnitSizeFactor = 0xff;
                 while (blocks > maxblocks) {
                         blocks >>= 1;
@@ -1211,14 +1210,13 @@ static inline int __init nftl_partscan(struct mtd_info *mtd,
         }
 
         ret = numparts;
-out:
+ out:
         kfree(buf);
         return ret;
 }
 
 /* This is a stripped-down copy of the code in inftlmount.c */
-static inline int __init inftl_partscan(struct mtd_info *mtd,
-                                 struct mtd_partition *parts)
+static inline int __init inftl_partscan(struct mtd_info *mtd, struct mtd_partition *parts)
 {
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
@@ -1235,15 +1233,16 @@ static inline int __init inftl_partscan(struct mtd_info *mtd,
         if (inftl_bbt_write)
                 end -= (INFTL_BBT_RESERVED_BLOCKS << this->phys_erase_shift);
 
-        buf = kmalloc(mtd->oobblock, GFP_KERNEL);
+        buf = kmalloc(mtd->writesize, GFP_KERNEL);
         if (!buf) {
                 printk(KERN_ERR "DiskOnChip mediaheader kmalloc failed!\n");
                 return 0;
         }
 
-        if (!find_media_headers(mtd, buf, "BNAND", 0)) goto out;
+        if (!find_media_headers(mtd, buf, "BNAND", 0))
+                goto out;
         doc->mh1_page = doc->mh0_page + (4096 >> this->page_shift);
-        mh = (struct INFTLMediaHeader *) buf;
+        mh = (struct INFTLMediaHeader *)buf;
 
         mh->NoOfBootImageBlocks = le32_to_cpu(mh->NoOfBootImageBlocks);
         mh->NoOfBinaryPartitions = le32_to_cpu(mh->NoOfBinaryPartitions);
@@ -1319,8 +1318,10 @@ static inline int __init inftl_partscan(struct mtd_info *mtd,
                 parts[numparts].offset = ip->firstUnit << vshift;
                 parts[numparts].size = (1 + ip->lastUnit - ip->firstUnit) << vshift;
                 numparts++;
-                if (ip->lastUnit > lastvunit) lastvunit = ip->lastUnit;
-                if (ip->flags & INFTL_LAST) break;
+                if (ip->lastUnit > lastvunit)
+                        lastvunit = ip->lastUnit;
+                if (ip->flags & INFTL_LAST)
+                        break;
         }
         lastvunit++;
         if ((lastvunit << vshift) < end) {
@@ -1330,7 +1331,7 @@ static inline int __init inftl_partscan(struct mtd_info *mtd,
                 numparts++;
         }
         ret = numparts;
-out:
+ out:
         kfree(buf);
         return ret;
 }
@@ -1342,11 +1343,12 @@ static int __init nftl_scan_bbt(struct mtd_info *mtd)
         struct doc_priv *doc = this->priv;
         struct mtd_partition parts[2];
 
-        memset((char *) parts, 0, sizeof(parts));
+        memset((char *)parts, 0, sizeof(parts));
         /* On NFTL, we have to find the media headers before we can read the
            BBTs, since they're stored in the media header eraseblocks. */
         numparts = nftl_partscan(mtd, parts);
-        if (!numparts) return -EIO;
+        if (!numparts)
+                return -EIO;
         this->bbt_td->options = NAND_BBT_ABSPAGE | NAND_BBT_8BIT |
                                 NAND_BBT_SAVECONTENT | NAND_BBT_WRITE |
                                 NAND_BBT_VERSION;
@@ -1393,8 +1395,7 @@ static int __init inftl_scan_bbt(struct mtd_info *mtd)
                 this->bbt_td->pages[0] = 2;
                 this->bbt_md = NULL;
         } else {
-                this->bbt_td->options = NAND_BBT_LASTBLOCK | NAND_BBT_8BIT |
-                                        NAND_BBT_VERSION;
+                this->bbt_td->options = NAND_BBT_LASTBLOCK | NAND_BBT_8BIT | NAND_BBT_VERSION;
                 if (inftl_bbt_write)
                         this->bbt_td->options |= NAND_BBT_WRITE;
                 this->bbt_td->offs = 8;
@@ -1404,8 +1405,7 @@ static int __init inftl_scan_bbt(struct mtd_info *mtd)
                 this->bbt_td->reserved_block_code = 0x01;
                 this->bbt_td->pattern = "MSYS_BBT";
 
-                this->bbt_md->options = NAND_BBT_LASTBLOCK | NAND_BBT_8BIT |
-                                        NAND_BBT_VERSION;
+                this->bbt_md->options = NAND_BBT_LASTBLOCK | NAND_BBT_8BIT | NAND_BBT_VERSION;
                 if (inftl_bbt_write)
                         this->bbt_md->options |= NAND_BBT_WRITE;
                 this->bbt_md->offs = 8;
@@ -1420,12 +1420,13 @@ static int __init inftl_scan_bbt(struct mtd_info *mtd)
            At least as nand_bbt.c is currently written. */
         if ((ret = nand_scan_bbt(mtd, NULL)))
                 return ret;
-        memset((char *) parts, 0, sizeof(parts));
+        memset((char *)parts, 0, sizeof(parts));
         numparts = inftl_partscan(mtd, parts);
         /* At least for now, require the INFTL Media Header.  We could probably
            do without it for non-INFTL use, since all it gives us is
            autopartitioning, but I want to give it more thought. */
-        if (!numparts) return -EIO;
+        if (!numparts)
+                return -EIO;
         add_mtd_device(mtd);
 #ifdef CONFIG_MTD_PARTITIONS
         if (!no_autopart)
@@ -1439,7 +1440,6 @@ static inline int __init doc2000_init(struct mtd_info *mtd)
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
 
-        this->write_byte = doc2000_write_byte;
         this->read_byte = doc2000_read_byte;
         this->write_buf = doc2000_writebuf;
         this->read_buf = doc2000_readbuf;
@@ -1457,7 +1457,6 @@ static inline int __init doc2001_init(struct mtd_info *mtd)
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
 
-        this->write_byte = doc2001_write_byte;
         this->read_byte = doc2001_read_byte;
         this->write_buf = doc2001_writebuf;
         this->read_buf = doc2001_readbuf;
@@ -1489,16 +1488,15 @@ static inline int __init doc2001plus_init(struct mtd_info *mtd)
         struct nand_chip *this = mtd->priv;
         struct doc_priv *doc = this->priv;
 
-        this->write_byte = NULL;
         this->read_byte = doc2001plus_read_byte;
         this->write_buf = doc2001plus_writebuf;
         this->read_buf = doc2001plus_readbuf;
         this->verify_buf = doc2001plus_verifybuf;
         this->scan_bbt = inftl_scan_bbt;
-        this->hwcontrol = NULL;
+        this->cmd_ctrl = NULL;
         this->select_chip = doc2001plus_select_chip;
         this->cmdfunc = doc2001plus_command;
-        this->enable_hwecc = doc2001plus_enable_hwecc;
+        this->ecc.hwctl = doc2001plus_enable_hwecc;
 
         doc->chips_per_floor = 1;
         mtd->name = "DiskOnChip Millennium Plus";
@@ -1535,20 +1533,16 @@ static int __init doc_probe(unsigned long physadr)
         save_control = ReadDOC(virtadr, DOCControl);
 
         /* Reset the DiskOnChip ASIC */
-        WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
-                 virtadr, DOCControl);
-        WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
-                 virtadr, DOCControl);
+        WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET, virtadr, DOCControl);
+        WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET, virtadr, DOCControl);
 
         /* Enable the DiskOnChip ASIC */
-        WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
-                 virtadr, DOCControl);
-        WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
-                 virtadr, DOCControl);
+        WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL, virtadr, DOCControl);
+        WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL, virtadr, DOCControl);
 
         ChipID = ReadDOC(virtadr, ChipID);
 
-        switch(ChipID) {
+        switch (ChipID) {
         case DOC_ChipID_Doc2k:
                 reg = DoC_2k_ECCStatus;
                 break;
@@ -1564,15 +1558,13 @@ static int __init doc_probe(unsigned long physadr)
                         ReadDOC(virtadr, Mplus_Power);
 
                 /* Reset the Millennium Plus ASIC */
-                tmp = DOC_MODE_RESET | DOC_MODE_MDWREN | DOC_MODE_RST_LAT |
-                        DOC_MODE_BDECT;
+                tmp = DOC_MODE_RESET | DOC_MODE_MDWREN | DOC_MODE_RST_LAT | DOC_MODE_BDECT;
                 WriteDOC(tmp, virtadr, Mplus_DOCControl);
                 WriteDOC(~tmp, virtadr, Mplus_CtrlConfirm);
 
                 mdelay(1);
                 /* Enable the Millennium Plus ASIC */
-                tmp = DOC_MODE_NORMAL | DOC_MODE_MDWREN | DOC_MODE_RST_LAT |
-                        DOC_MODE_BDECT;
+                tmp = DOC_MODE_NORMAL | DOC_MODE_MDWREN | DOC_MODE_RST_LAT | DOC_MODE_BDECT;
                 WriteDOC(tmp, virtadr, Mplus_DOCControl);
                 WriteDOC(~tmp, virtadr, Mplus_CtrlConfirm);
                 mdelay(1);
@@ -1596,7 +1588,7 @@ static int __init doc_probe(unsigned long physadr)
                 goto notfound;
         }
         /* Check the TOGGLE bit in the ECC register */
-        tmp  = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
+        tmp = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
         tmpb = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
         tmpc = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
         if ((tmp == tmpb) || (tmp != tmpc)) {
@@ -1626,11 +1618,11 @@ static int __init doc_probe(unsigned long physadr)
                 if (ChipID == DOC_ChipID_DocMilPlus16) {
                         WriteDOC(~newval, virtadr, Mplus_AliasResolution);
                         oldval = ReadDOC(doc->virtadr, Mplus_AliasResolution);
-                        WriteDOC(newval, virtadr, Mplus_AliasResolution); // restore it
+                        WriteDOC(newval, virtadr, Mplus_AliasResolution);       // restore it
                 } else {
                         WriteDOC(~newval, virtadr, AliasResolution);
                         oldval = ReadDOC(doc->virtadr, AliasResolution);
-                        WriteDOC(newval, virtadr, AliasResolution); // restore it
+                        WriteDOC(newval, virtadr, AliasResolution);     // restore it
                 }
                 newval = ~newval;
                 if (oldval == newval) {
@@ -1642,10 +1634,8 @@ static int __init doc_probe(unsigned long physadr)
         printk(KERN_NOTICE "DiskOnChip found at 0x%lx\n", physadr);
 
         len = sizeof(struct mtd_info) +
-              sizeof(struct nand_chip) +
-              sizeof(struct doc_priv) +
-              (2 * sizeof(struct nand_bbt_descr));
-        mtd =  kmalloc(len, GFP_KERNEL);
+            sizeof(struct nand_chip) + sizeof(struct doc_priv) + (2 * sizeof(struct nand_bbt_descr));
+        mtd = kmalloc(len, GFP_KERNEL);
         if (!mtd) {
                 printk(KERN_ERR "DiskOnChip kmalloc (%d bytes) failed!\n", len);
                 ret = -ENOMEM;
@@ -1663,17 +1653,19 @@ static int __init doc_probe(unsigned long physadr)
 
         nand->priv              = doc;
         nand->select_chip       = doc200x_select_chip;
-        nand->hwcontrol         = doc200x_hwcontrol;
+        nand->cmd_ctrl          = doc200x_hwcontrol;
         nand->dev_ready         = doc200x_dev_ready;
         nand->waitfunc          = doc200x_wait;
         nand->block_bad         = doc200x_block_bad;
-        nand->enable_hwecc      = doc200x_enable_hwecc;
-        nand->calculate_ecc     = doc200x_calculate_ecc;
-        nand->correct_data      = doc200x_correct_data;
+        nand->ecc.hwctl         = doc200x_enable_hwecc;
+        nand->ecc.calculate     = doc200x_calculate_ecc;
+        nand->ecc.correct       = doc200x_correct_data;
 
-        nand->autooob           = &doc200x_oobinfo;
-        nand->eccmode           = NAND_ECC_HW6_512;
-        nand->options           = NAND_USE_FLASH_BBT | NAND_HWECC_SYNDROME;
+        nand->ecc.layout        = &doc200x_oobinfo;
+        nand->ecc.mode          = NAND_ECC_HW_SYNDROME;
+        nand->ecc.size          = 512;
+        nand->ecc.bytes         = 6;
+        nand->options           = NAND_USE_FLASH_BBT;
 
         doc->physadr            = physadr;
         doc->virtadr            = virtadr;
@@ -1707,18 +1699,18 @@ static int __init doc_probe(unsigned long physadr)
         doclist = mtd;
         return 0;
 
-notfound:
+ notfound:
         /* Put back the contents of the DOCControl register, in case it's not
            actually a DiskOnChip.  */
         WriteDOC(save_control, virtadr, DOCControl);
-fail:
+ fail:
         iounmap(virtadr);
         return ret;
 }
 
 static void release_nanddoc(void)
 {
-        struct mtd_info *mtd, *nextmtd;
+        struct mtd_info *mtd, *nextmtd;
         struct nand_chip *nand;
         struct doc_priv *doc;
 
@@ -1747,8 +1739,8 @@ static int __init init_nanddoc(void)
          * generator polinomial degree = 4
          */
         rs_decoder = init_rs(10, 0x409, FCR, 1, NROOTS);
-        if (!rs_decoder) {
-                printk (KERN_ERR "DiskOnChip: Could not create a RS decoder\n");
+        if (!rs_decoder) {
+                printk(KERN_ERR "DiskOnChip: Could not create a RS decoder\n");
                 return -ENOMEM;
         }
 
@@ -1758,7 +1750,7 @@ static int __init init_nanddoc(void)
                 if (ret < 0)
                         goto outerr;
         } else {
-                for (i=0; (doc_locations[i] != 0xffffffff); i++) {
+                for (i = 0; (doc_locations[i] != 0xffffffff); i++) {
                         doc_probe(doc_locations[i]);
                 }
         }
@@ -1770,7 +1762,7 @@ static int __init init_nanddoc(void)
                 goto outerr;
         }
         return 0;
-outerr:
+ outerr:
         free_rs(rs_decoder);
         return ret;
 }
diff --git a/drivers/mtd/nand/edb7312.c b/drivers/mtd/nand/edb7312.c
index 9b1fd2f387fa..516c0e5e564c 100644
--- a/drivers/mtd/nand/edb7312.c
+++ b/drivers/mtd/nand/edb7312.c
@@ -1,7 +1,7 @@
 /*
  *  drivers/mtd/nand/edb7312.c
  *
- *  Copyright (C) 2002 Marius Gröger (mag@sysgo.de)
+ *  Copyright (C) 2002 Marius Gröger (mag@sysgo.de)
  *
  *  Derived from drivers/mtd/nand/autcpu12.c
  *       Copyright (c) 2001 Thomas Gleixner (gleixner@autronix.de)
@@ -25,7 +25,7 @@
 #include <linux/mtd/nand.h>
 #include <linux/mtd/partitions.h>
 #include <asm/io.h>
-#include <asm/arch/hardware.h> /* for CLPS7111_VIRT_BASE */
+#include <asm/arch/hardware.h>  /* for CLPS7111_VIRT_BASE */
 #include <asm/sizes.h>
 #include <asm/hardware/clps7111.h>
 
@@ -54,51 +54,45 @@ static struct mtd_info *ep7312_mtd = NULL;
  */
 
 static unsigned long ep7312_fio_pbase = EP7312_FIO_PBASE;
-static void __iomem * ep7312_pxdr = (void __iomem *) EP7312_PXDR;
-static void __iomem * ep7312_pxddr = (void __iomem *) EP7312_PXDDR;
+static void __iomem *ep7312_pxdr = (void __iomem *)EP7312_PXDR;
+static void __iomem *ep7312_pxddr = (void __iomem *)EP7312_PXDDR;
 
 #ifdef CONFIG_MTD_PARTITIONS
 /*
  * Define static partitions for flash device
  */
 static struct mtd_partition partition_info[] = {
-        { .name = "EP7312 Nand Flash",
-                  .offset = 0,
-                  .size = 8*1024*1024 }
+        {.name = "EP7312 Nand Flash",
+         .offset = 0,
+         .size = 8 * 1024 * 1024}
 };
+
 #define NUM_PARTITIONS 1
 
 #endif
 
-
 /*
  *      hardware specific access to control-lines
+ *
+ *      NAND_NCE: bit 0 -> bit 7
+ *      NAND_CLE: bit 1 -> bit 4
+ *      NAND_ALE: bit 2 -> bit 5
  */
-static void ep7312_hwcontrol(struct mtd_info *mtd, int cmd)
+static void ep7312_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl)
 {
-        switch(cmd) {
-
-        case NAND_CTL_SETCLE:
-                clps_writeb(clps_readb(ep7312_pxdr) | 0x10, ep7312_pxdr);
-                break;
-        case NAND_CTL_CLRCLE:
-                clps_writeb(clps_readb(ep7312_pxdr) & ~0x10, ep7312_pxdr);
-                break;
-
-        case NAND_CTL_SETALE:
-                clps_writeb(clps_readb(ep7312_pxdr) | 0x20, ep7312_pxdr);
-                break;
-        case NAND_CTL_CLRALE:
-                clps_writeb(clps_readb(ep7312_pxdr) & ~0x20, ep7312_pxdr);
-                break;
-
-        case NAND_CTL_SETNCE:
-                clps_writeb((clps_readb(ep7312_pxdr) | 0x80) & ~0x40, ep7312_pxdr);
-                break;
-        case NAND_CTL_CLRNCE:
-                clps_writeb((clps_readb(ep7312_pxdr) | 0x80) | 0x40, ep7312_pxdr);
-                break;
+        struct nand_chip *chip = mtd->priv;
+
+        if (ctrl & NAND_CTRL_CHANGE) {
+                unsigned char bits;
+
+                bits = (ctrl & (NAND_CLE | NAND_ALE)) << 3;
+                bits = (ctrl & NAND_NCE) << 7;
+
+                clps_writeb((clps_readb(ep7312_pxdr)  & 0xB0) | 0x10,
+                            ep7312_pxdr);
         }
+        if (cmd != NAND_CMD_NONE)
+                writeb(cmd, chip->IO_ADDR_W);
 }
 
 /*
@@ -108,6 +102,7 @@ static int ep7312_device_ready(struct mtd_info *mtd)
 {
         return 1;
 }
+
 #ifdef CONFIG_MTD_PARTITIONS
 const char *part_probes[] = { "cmdlinepart", NULL };
 #endif
@@ -115,18 +110,16 @@ const char *part_probes[] = { "cmdlinepart", NULL };
 /*
  * Main initialization routine
  */
-static int __init ep7312_init (void)
+static int __init ep7312_init(void)
 {
         struct nand_chip *this;
         const char *part_type = 0;
         int mtd_parts_nb = 0;
         struct mtd_partition *mtd_parts = 0;
-        void __iomem * ep7312_fio_base;
+        void __iomem *ep7312_fio_base;
 
         /* Allocate memory for MTD device structure and private data */
-        ep7312_mtd = kmalloc(sizeof(struct mtd_info) +
-                             sizeof(struct nand_chip),
-                             GFP_KERNEL);
+        ep7312_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
         if (!ep7312_mtd) {
                 printk("Unable to allocate EDB7312 NAND MTD device structure.\n");
                 return -ENOMEM;
@@ -134,21 +127,22 @@ static int __init ep7312_init (void)
 
         /* map physical adress */
         ep7312_fio_base = ioremap(ep7312_fio_pbase, SZ_1K);
-        if(!ep7312_fio_base) {
+        if (!ep7312_fio_base) {
                 printk("ioremap EDB7312 NAND flash failed\n");
                 kfree(ep7312_mtd);
                 return -EIO;
         }
 
         /* Get pointer to private data */
-        this = (struct nand_chip *) (&ep7312_mtd[1]);
+        this = (struct nand_chip *)(&ep7312_mtd[1]);
 
         /* Initialize structures */
-        memset((char *) ep7312_mtd, 0, sizeof(struct mtd_info));
-        memset((char *) this, 0, sizeof(struct nand_chip));
+        memset(ep7312_mtd, 0, sizeof(struct mtd_info));
+        memset(this, 0, sizeof(struct nand_chip));
 
         /* Link the private data with the MTD structure */
         ep7312_mtd->priv = this;
+        ep7312_mtd->owner = THIS_MODULE;
 
         /*
          * Set GPIO Port B control register so that the pins are configured
@@ -159,22 +153,20 @@ static int __init ep7312_init (void)
         /* insert callbacks */
         this->IO_ADDR_R = ep7312_fio_base;
         this->IO_ADDR_W = ep7312_fio_base;
-        this->hwcontrol = ep7312_hwcontrol;
+        this->cmd_ctrl = ep7312_hwcontrol;
         this->dev_ready = ep7312_device_ready;
         /* 15 us command delay time */
         this->chip_delay = 15;
 
         /* Scan to find existence of the device */
-        if (nand_scan (ep7312_mtd, 1)) {
+        if (nand_scan(ep7312_mtd, 1)) {
                 iounmap((void *)ep7312_fio_base);
-                kfree (ep7312_mtd);
+                kfree(ep7312_mtd);
                 return -ENXIO;
         }
-
 #ifdef CONFIG_MTD_PARTITIONS
         ep7312_mtd->name = "edb7312-nand";
-        mtd_parts_nb = parse_mtd_partitions(ep7312_mtd, part_probes,
-                                            &mtd_parts, 0);
+        mtd_parts_nb = parse_mtd_partitions(ep7312_mtd, part_probes, &mtd_parts, 0);
         if (mtd_parts_nb > 0)
                 part_type = "command line";
         else
@@ -193,24 +185,23 @@ static int __init ep7312_init (void)
         /* Return happy */
         return 0;
 }
+
 module_init(ep7312_init);
 
 /*
  * Clean up routine
  */
-static void __exit ep7312_cleanup (void)
+static void __exit ep7312_cleanup(void)
 {
-        struct nand_chip *this = (struct nand_chip *) &ep7312_mtd[1];
+        struct nand_chip *this = (struct nand_chip *)&ep7312_mtd[1];
 
         /* Release resources, unregister device */
-        nand_release (ap7312_mtd);
-
-        /* Free internal data buffer */
-        kfree (this->data_buf);
+        nand_release(ap7312_mtd);
 
         /* Free the MTD device structure */
-        kfree (ep7312_mtd);
+        kfree(ep7312_mtd);
 }
+
 module_exit(ep7312_cleanup);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/nand/h1910.c b/drivers/mtd/nand/h1910.c
index f68f7a99a630..2d585d2d090c 100644
--- a/drivers/mtd/nand/h1910.c
+++ b/drivers/mtd/nand/h1910.c
@@ -4,7 +4,7 @@
  *  Copyright (C) 2003 Joshua Wise (joshua@joshuawise.com)
  *
  *  Derived from drivers/mtd/nand/edb7312.c
- *       Copyright (C) 2002 Marius Gröger (mag@sysgo.de)
+ *       Copyright (C) 2002 Marius Gröger (mag@sysgo.de)
  *       Copyright (c) 2001 Thomas Gleixner (gleixner@autronix.de)
  *
  * $Id: h1910.c,v 1.6 2005/11/07 11:14:30 gleixner Exp $
@@ -26,7 +26,7 @@
 #include <linux/mtd/nand.h>
 #include <linux/mtd/partitions.h>
 #include <asm/io.h>
-#include <asm/arch/hardware.h> /* for CLPS7111_VIRT_BASE */
+#include <asm/arch/hardware.h>  /* for CLPS7111_VIRT_BASE */
 #include <asm/sizes.h>
 #include <asm/arch/h1900-gpio.h>
 #include <asm/arch/ipaq.h>
@@ -45,47 +45,29 @@ static struct mtd_info *h1910_nand_mtd = NULL;
  * Define static partitions for flash device
  */
 static struct mtd_partition partition_info[] = {
-        { name: "h1910 NAND Flash",
-                  offset: 0,
-                  size: 16*1024*1024 }
+      {name:"h1910 NAND Flash",
+              offset:0,
+      size:16 * 1024 * 1024}
 };
+
 #define NUM_PARTITIONS 1
 
 #endif
 
-
 /*
  *      hardware specific access to control-lines
+ *
+ *      NAND_NCE: bit 0 - don't care
+ *      NAND_CLE: bit 1 - address bit 2
+ *      NAND_ALE: bit 2 - address bit 3
  */
-static void h1910_hwcontrol(struct mtd_info *mtd, int cmd)
+static void h1910_hwcontrol(struct mtd_info *mtd, int cmd,
+                            unsigned int ctrl)
 {
-        struct nand_chip* this = (struct nand_chip *) (mtd->priv);
-
-        switch(cmd) {
-
-        case NAND_CTL_SETCLE:
-                this->IO_ADDR_R |= (1 << 2);
-                this->IO_ADDR_W |= (1 << 2);
-                break;
-        case NAND_CTL_CLRCLE:
-                this->IO_ADDR_R &= ~(1 << 2);
-                this->IO_ADDR_W &= ~(1 << 2);
-                break;
-
-        case NAND_CTL_SETALE:
-                this->IO_ADDR_R |= (1 << 3);
-                this->IO_ADDR_W |= (1 << 3);
-                break;
-        case NAND_CTL_CLRALE:
-                this->IO_ADDR_R &= ~(1 << 3);
-                this->IO_ADDR_W &= ~(1 << 3);
-                break;
-
-        case NAND_CTL_SETNCE:
-                break;
-        case NAND_CTL_CLRNCE:
-                break;
-        }
+        struct nand_chip *chip = mtd->priv;
+
+        if (cmd != NAND_CMD_NONE)
+                writeb(cmd, chip->IO_ADDR_W | ((ctrl & 0x6) << 1));
 }
 
 /*
@@ -101,7 +83,7 @@ static int h1910_device_ready(struct mtd_info *mtd)
 /*
  * Main initialization routine
  */
-static int __init h1910_init (void)
+static int __init h1910_init(void)
 {
         struct nand_chip *this;
         const char *part_type = 0;
@@ -119,24 +101,23 @@ static int __init h1910_init (void)
         }
 
         /* Allocate memory for MTD device structure and private data */
-        h1910_nand_mtd = kmalloc(sizeof(struct mtd_info) +
-                             sizeof(struct nand_chip),
-                             GFP_KERNEL);
+        h1910_nand_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
         if (!h1910_nand_mtd) {
                 printk("Unable to allocate h1910 NAND MTD device structure.\n");
-                iounmap ((void *) nandaddr);
+                iounmap((void *)nandaddr);
                 return -ENOMEM;
         }
 
         /* Get pointer to private data */
-        this = (struct nand_chip *) (&h1910_nand_mtd[1]);
+        this = (struct nand_chip *)(&h1910_nand_mtd[1]);
 
         /* Initialize structures */
-        memset((char *) h1910_nand_mtd, 0, sizeof(struct mtd_info));
-        memset((char *) this, 0, sizeof(struct nand_chip));
+        memset(h1910_nand_mtd, 0, sizeof(struct mtd_info));
+        memset(this, 0, sizeof(struct nand_chip));
 
         /* Link the private data with the MTD structure */
         h1910_nand_mtd->priv = this;
+        h1910_nand_mtd->owner = THIS_MODULE;
 
         /*
          * Enable VPEN
@@ -146,31 +127,28 @@ static int __init h1910_init (void)
         /* insert callbacks */
         this->IO_ADDR_R = nandaddr;
         this->IO_ADDR_W = nandaddr;
-        this->hwcontrol = h1910_hwcontrol;
+        this->cmd_ctrl = h1910_hwcontrol;
         this->dev_ready = NULL; /* unknown whether that was correct or not so we will just do it like this */
         /* 15 us command delay time */
         this->chip_delay = 50;
-        this->eccmode = NAND_ECC_SOFT;
+        this->ecc.mode = NAND_ECC_SOFT;
         this->options = NAND_NO_AUTOINCR;
 
         /* Scan to find existence of the device */
-        if (nand_scan (h1910_nand_mtd, 1)) {
+        if (nand_scan(h1910_nand_mtd, 1)) {
                 printk(KERN_NOTICE "No NAND device - returning -ENXIO\n");
-                kfree (h1910_nand_mtd);
-                iounmap ((void *) nandaddr);
+                kfree(h1910_nand_mtd);
+                iounmap((void *)nandaddr);
                 return -ENXIO;
         }
-
 #ifdef CONFIG_MTD_CMDLINE_PARTS
-        mtd_parts_nb = parse_cmdline_partitions(h1910_nand_mtd, &mtd_parts,
-                                                "h1910-nand");
+        mtd_parts_nb = parse_cmdline_partitions(h1910_nand_mtd, &mtd_parts, "h1910-nand");
         if (mtd_parts_nb > 0)
-          part_type = "command line";
+                part_type = "command line";
         else
-          mtd_parts_nb = 0;
+                mtd_parts_nb = 0;
 #endif
-        if (mtd_parts_nb == 0)
-        {
+        if (mtd_parts_nb == 0) {
                 mtd_parts = partition_info;
                 mtd_parts_nb = NUM_PARTITIONS;
                 part_type = "static";
@@ -183,24 +161,26 @@ static int __init h1910_init (void)
         /* Return happy */
         return 0;
 }
+
 module_init(h1910_init);
 
 /*
  * Clean up routine
  */
-static void __exit h1910_cleanup (void)
+static void __exit h1910_cleanup(void)
 {
-        struct nand_chip *this = (struct nand_chip *) &h1910_nand_mtd[1];
+        struct nand_chip *this = (struct nand_chip *)&h1910_nand_mtd[1];
 
         /* Release resources, unregister device */
-        nand_release (h1910_nand_mtd);
+        nand_release(h1910_nand_mtd);
 
         /* Release io resource */
-        iounmap ((void *) this->IO_ADDR_W);
+        iounmap((void *)this->IO_ADDR_W);
 
         /* Free the MTD device structure */
-        kfree (h1910_nand_mtd);
+        kfree(h1910_nand_mtd);
 }
+
 module_exit(h1910_cleanup);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index 95e96fa1fceb..27083ed0a017 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -10,67 +10,31 @@
  *      http://www.linux-mtd.infradead.org/tech/nand.html
  *
  *  Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
- *                2002 Thomas Gleixner (tglx@linutronix.de)
+ *                2002-2006 Thomas Gleixner (tglx@linutronix.de)
  *
- *  02-08-2004  tglx: support for strange chips, which cannot auto increment
- *              pages on read / read_oob
- *
- *  03-17-2004  tglx: Check ready before auto increment check. Simon Bayes
- *              pointed this out, as he marked an auto increment capable chip
- *              as NOAUTOINCR in the board driver.
- *              Make reads over block boundaries work too
- *
- *  04-14-2004  tglx: first working version for 2k page size chips
- *
- *  05-19-2004  tglx: Basic support for Renesas AG-AND chips
- *
- *  09-24-2004  tglx: add support for hardware controllers (e.g. ECC) shared
- *              among multiple independend devices. Suggestions and initial patch
- *              from Ben Dooks <ben-mtd@fluff.org>
- *
- *  12-05-2004  dmarlin: add workaround for Renesas AG-AND chips "disturb" issue.
- *              Basically, any block not rewritten may lose data when surrounding blocks
- *              are rewritten many times.  JFFS2 ensures this doesn't happen for blocks
- *              it uses, but the Bad Block Table(s) may not be rewritten.  To ensure they
- *              do not lose data, force them to be rewritten when some of the surrounding
- *              blocks are erased.  Rather than tracking a specific nearby block (which
- *              could itself go bad), use a page address 'mask' to select several blocks
- *              in the same area, and rewrite the BBT when any of them are erased.
- *
- *  01-03-2005  dmarlin: added support for the device recovery command sequence for Renesas
- *              AG-AND chips.  If there was a sudden loss of power during an erase operation,
- *              a "device recovery" operation must be performed when power is restored
- *              to ensure correct operation.
- *
- *  01-20-2005  dmarlin: added support for optional hardware specific callback routine to
- *              perform extra error status checks on erase and write failures.  This required
- *              adding a wrapper function for nand_read_ecc.
- *
- * 08-20-2005   vwool: suspend/resume added
- *
- * Credits:
+ *  Credits:
  *      David Woodhouse for adding multichip support
  *
  *      Aleph One Ltd. and Toby Churchill Ltd. for supporting the
  *      rework for 2K page size chips
  *
- * TODO:
+ *  TODO:
  *      Enable cached programming for 2k page size chips
  *      Check, if mtd->ecctype should be set to MTD_ECC_HW
  *      if we have HW ecc support.
  *      The AG-AND chips have nice features for speed improvement,
  *      which are not supported yet. Read / program 4 pages in one go.
  *
- * $Id: nand_base.c,v 1.150 2005/09/15 13:58:48 vwool Exp $
- *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  */
 
+#include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/errno.h>
+#include <linux/err.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/types.h>
@@ -88,75 +52,46 @@
 #endif
 
 /* Define default oob placement schemes for large and small page devices */
-static struct nand_oobinfo nand_oob_8 = {
-        .useecc = MTD_NANDECC_AUTOPLACE,
+static struct nand_ecclayout nand_oob_8 = {
         .eccbytes = 3,
         .eccpos = {0, 1, 2},
-        .oobfree = { {3, 2}, {6, 2} }
+        .oobfree = {
+                {.offset = 3,
+                 .length = 2},
+                {.offset = 6,
+                 .length = 2}}
 };
 
-static struct nand_oobinfo nand_oob_16 = {
-        .useecc = MTD_NANDECC_AUTOPLACE,
+static struct nand_ecclayout nand_oob_16 = {
         .eccbytes = 6,
         .eccpos = {0, 1, 2, 3, 6, 7},
-        .oobfree = { {8, 8} }
+        .oobfree = {
+                {.offset = 8,
+                 . length = 8}}
 };
 
-static struct nand_oobinfo nand_oob_64 = {
-        .useecc = MTD_NANDECC_AUTOPLACE,
+static struct nand_ecclayout nand_oob_64 = {
         .eccbytes = 24,
         .eccpos = {
-                40, 41, 42, 43, 44, 45, 46, 47,
-                48, 49, 50, 51, 52, 53, 54, 55,
-                56, 57, 58, 59, 60, 61, 62, 63},
-        .oobfree = { {2, 38} }
+                   40, 41, 42, 43, 44, 45, 46, 47,
+                   48, 49, 50, 51, 52, 53, 54, 55,
+                   56, 57, 58, 59, 60, 61, 62, 63},
+        .oobfree = {
+                {.offset = 2,
+                 .length = 38}}
 };
 
-/* This is used for padding purposes in nand_write_oob */
-static u_char ffchars[] = {
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-};
+static int nand_get_device(struct nand_chip *chip, struct mtd_info *mtd,
+                           int new_state);
+
+static int nand_do_write_oob(struct mtd_info *mtd, loff_t to,
+                             struct mtd_oob_ops *ops);
 
 /*
- * NAND low-level MTD interface functions
+ * For devices which display every fart in the system on a seperate LED. Is
+ * compiled away when LED support is disabled.
  */
-static void nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len);
-static void nand_read_buf(struct mtd_info *mtd, u_char *buf, int len);
-static int nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len);
-
-static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf);
-static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
-                          size_t * retlen, u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel);
-static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf);
-static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf);
-static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
-                           size_t * retlen, const u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel);
-static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char *buf);
-static int nand_writev (struct mtd_info *mtd, const struct kvec *vecs,
-                        unsigned long count, loff_t to, size_t * retlen);
-static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs,
-                        unsigned long count, loff_t to, size_t * retlen, u_char *eccbuf, struct nand_oobinfo *oobsel);
-static int nand_erase (struct mtd_info *mtd, struct erase_info *instr);
-static void nand_sync (struct mtd_info *mtd);
-
-/* Some internal functions */
-static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int page, u_char *oob_buf,
-                struct nand_oobinfo *oobsel, int mode);
-#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
-static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
-        u_char *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode);
-#else
-#define nand_verify_pages(...) (0)
-#endif
-
-static int nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int new_state);
+DEFINE_LED_TRIGGER(nand_led_trigger);
 
 /**
  * nand_release_device - [GENERIC] release chip
@@ -164,27 +99,19 @@ static int nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int ne
  *
  * Deselect, release chip lock and wake up anyone waiting on the device
  */
-static void nand_release_device (struct mtd_info *mtd)
+static void nand_release_device(struct mtd_info *mtd)
 {
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
 
         /* De-select the NAND device */
-        this->select_chip(mtd, -1);
-
-        if (this->controller) {
-                /* Release the controller and the chip */
-                spin_lock(&this->controller->lock);
-                this->controller->active = NULL;
-                this->state = FL_READY;
-                wake_up(&this->controller->wq);
-                spin_unlock(&this->controller->lock);
-        } else {
-                /* Release the chip */
-                spin_lock(&this->chip_lock);
-                this->state = FL_READY;
-                wake_up(&this->wq);
-                spin_unlock(&this->chip_lock);
-        }
+        chip->select_chip(mtd, -1);
+
+        /* Release the controller and the chip */
+        spin_lock(&chip->controller->lock);
+        chip->controller->active = NULL;
+        chip->state = FL_READY;
+        wake_up(&chip->controller->wq);
+        spin_unlock(&chip->controller->lock);
 }
 
 /**
@@ -193,23 +120,10 @@ static void nand_release_device (struct mtd_info *mtd)
  *
  * Default read function for 8bit buswith
  */
-static u_char nand_read_byte(struct mtd_info *mtd)
-{
-        struct nand_chip *this = mtd->priv;
-        return readb(this->IO_ADDR_R);
-}
-
-/**
- * nand_write_byte - [DEFAULT] write one byte to the chip
- * @mtd:        MTD device structure
- * @byte:       pointer to data byte to write
- *
- * Default write function for 8it buswith
- */
-static void nand_write_byte(struct mtd_info *mtd, u_char byte)
+static uint8_t nand_read_byte(struct mtd_info *mtd)
 {
-        struct nand_chip *this = mtd->priv;
-        writeb(byte, this->IO_ADDR_W);
+        struct nand_chip *chip = mtd->priv;
+        return readb(chip->IO_ADDR_R);
 }
 
 /**
@@ -219,24 +133,10 @@ static void nand_write_byte(struct mtd_info *mtd, u_char byte)
  * Default read function for 16bit buswith with
  * endianess conversion
  */
-static u_char nand_read_byte16(struct mtd_info *mtd)
+static uint8_t nand_read_byte16(struct mtd_info *mtd)
 {
-        struct nand_chip *this = mtd->priv;
-        return (u_char) cpu_to_le16(readw(this->IO_ADDR_R));
-}
-
-/**
- * nand_write_byte16 - [DEFAULT] write one byte endianess aware to the chip
- * @mtd:        MTD device structure
- * @byte:       pointer to data byte to write
- *
- * Default write function for 16bit buswith with
- * endianess conversion
- */
-static void nand_write_byte16(struct mtd_info *mtd, u_char byte)
-{
-        struct nand_chip *this = mtd->priv;
-        writew(le16_to_cpu((u16) byte), this->IO_ADDR_W);
+        struct nand_chip *chip = mtd->priv;
+        return (uint8_t) cpu_to_le16(readw(chip->IO_ADDR_R));
 }
 
 /**
@@ -248,22 +148,8 @@ static void nand_write_byte16(struct mtd_info *mtd, u_char byte)
  */
 static u16 nand_read_word(struct mtd_info *mtd)
 {
-        struct nand_chip *this = mtd->priv;
-        return readw(this->IO_ADDR_R);
-}
-
-/**
- * nand_write_word - [DEFAULT] write one word to the chip
- * @mtd:        MTD device structure
- * @word:       data word to write
- *
- * Default write function for 16bit buswith without
- * endianess conversion
- */
-static void nand_write_word(struct mtd_info *mtd, u16 word)
-{
-        struct nand_chip *this = mtd->priv;
-        writew(word, this->IO_ADDR_W);
+        struct nand_chip *chip = mtd->priv;
+        return readw(chip->IO_ADDR_R);
 }
 
 /**
@@ -273,15 +159,15 @@ static void nand_write_word(struct mtd_info *mtd, u16 word)
  *
  * Default select function for 1 chip devices.
  */
-static void nand_select_chip(struct mtd_info *mtd, int chip)
+static void nand_select_chip(struct mtd_info *mtd, int chipnr)
 {
-        struct nand_chip *this = mtd->priv;
-        switch(chip) {
+        struct nand_chip *chip = mtd->priv;
+
+        switch (chipnr) {
         case -1:
-                this->hwcontrol(mtd, NAND_CTL_CLRNCE);
+                chip->cmd_ctrl(mtd, NAND_CMD_NONE, 0 | NAND_CTRL_CHANGE);
                 break;
         case 0:
-                this->hwcontrol(mtd, NAND_CTL_SETNCE);
                 break;
 
         default:
@@ -297,13 +183,13 @@ static void nand_select_chip(struct mtd_info *mtd, int chip)
  *
  * Default write function for 8bit buswith
  */
-static void nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
+static void nand_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 {
         int i;
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
 
-        for (i=0; i<len; i++)
-                writeb(buf[i], this->IO_ADDR_W);
+        for (i = 0; i < len; i++)
+                writeb(buf[i], chip->IO_ADDR_W);
 }
 
 /**
@@ -314,13 +200,13 @@ static void nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
  *
  * Default read function for 8bit buswith
  */
-static void nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
+static void nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
         int i;
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
 
-        for (i=0; i<len; i++)
-                buf[i] = readb(this->IO_ADDR_R);
+        for (i = 0; i < len; i++)
+                buf[i] = readb(chip->IO_ADDR_R);
 }
 
 /**
@@ -331,15 +217,14 @@ static void nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
  *
  * Default verify function for 8bit buswith
  */
-static int nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
+static int nand_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 {
         int i;
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
 
-        for (i=0; i<len; i++)
-                if (buf[i] != readb(this->IO_ADDR_R))
+        for (i = 0; i < len; i++)
+                if (buf[i] != readb(chip->IO_ADDR_R))
                         return -EFAULT;
-
         return 0;
 }
 
@@ -351,15 +236,15 @@ static int nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
  *
  * Default write function for 16bit buswith
  */
-static void nand_write_buf16(struct mtd_info *mtd, const u_char *buf, int len)
+static void nand_write_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
 {
         int i;
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
         u16 *p = (u16 *) buf;
         len >>= 1;
 
-        for (i=0; i<len; i++)
-                writew(p[i], this->IO_ADDR_W);
+        for (i = 0; i < len; i++)
+                writew(p[i], chip->IO_ADDR_W);
 
 }
 
@@ -371,15 +256,15 @@ static void nand_write_buf16(struct mtd_info *mtd, const u_char *buf, int len)
  *
  * Default read function for 16bit buswith
  */
-static void nand_read_buf16(struct mtd_info *mtd, u_char *buf, int len)
+static void nand_read_buf16(struct mtd_info *mtd, uint8_t *buf, int len)
 {
         int i;
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
         u16 *p = (u16 *) buf;
         len >>= 1;
 
-        for (i=0; i<len; i++)
-                p[i] = readw(this->IO_ADDR_R);
+        for (i = 0; i < len; i++)
+                p[i] = readw(chip->IO_ADDR_R);
 }
 
 /**
@@ -390,15 +275,15 @@ static void nand_read_buf16(struct mtd_info *mtd, u_char *buf, int len)
  *
  * Default verify function for 16bit buswith
  */
-static int nand_verify_buf16(struct mtd_info *mtd, const u_char *buf, int len)
+static int nand_verify_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
 {
         int i;
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
         u16 *p = (u16 *) buf;
         len >>= 1;
 
-        for (i=0; i<len; i++)
-                if (p[i] != readw(this->IO_ADDR_R))
+        for (i = 0; i < len; i++)
+                if (p[i] != readw(chip->IO_ADDR_R))
                         return -EFAULT;
 
         return 0;
@@ -415,38 +300,37 @@ static int nand_verify_buf16(struct mtd_info *mtd, const u_char *buf, int len)
 static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
 {
         int page, chipnr, res = 0;
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
         u16 bad;
 
         if (getchip) {
-                page = (int)(ofs >> this->page_shift);
-                chipnr = (int)(ofs >> this->chip_shift);
+                page = (int)(ofs >> chip->page_shift);
+                chipnr = (int)(ofs >> chip->chip_shift);
 
-                /* Grab the lock and see if the device is available */
-                nand_get_device (this, mtd, FL_READING);
+                nand_get_device(chip, mtd, FL_READING);
 
                 /* Select the NAND device */
-                this->select_chip(mtd, chipnr);
+                chip->select_chip(mtd, chipnr);
         } else
-                page = (int) ofs;
+                page = (int)ofs;
 
-        if (this->options & NAND_BUSWIDTH_16) {
-                this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos & 0xFE, page & this->pagemask);
-                bad = cpu_to_le16(this->read_word(mtd));
-                if (this->badblockpos & 0x1)
+        if (chip->options & NAND_BUSWIDTH_16) {
+                chip->cmdfunc(mtd, NAND_CMD_READOOB, chip->badblockpos & 0xFE,
+                              page & chip->pagemask);
+                bad = cpu_to_le16(chip->read_word(mtd));
+                if (chip->badblockpos & 0x1)
                         bad >>= 8;
                 if ((bad & 0xFF) != 0xff)
                         res = 1;
         } else {
-                this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos, page & this->pagemask);
-                if (this->read_byte(mtd) != 0xff)
+                chip->cmdfunc(mtd, NAND_CMD_READOOB, chip->badblockpos,
+                              page & chip->pagemask);
+                if (chip->read_byte(mtd) != 0xff)
                         res = 1;
         }
 
-        if (getchip) {
-                /* Deselect and wake up anyone waiting on the device */
+        if (getchip)
                 nand_release_device(mtd);
-        }
 
         return res;
 }
@@ -461,23 +345,33 @@ static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
 */
 static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
 {
-        struct nand_chip *this = mtd->priv;
-        u_char buf[2] = {0, 0};
-        size_t  retlen;
-        int block;
+        struct nand_chip *chip = mtd->priv;
+        uint8_t buf[2] = { 0, 0 };
+        int block, ret;
 
         /* Get block number */
-        block = ((int) ofs) >> this->bbt_erase_shift;
-        if (this->bbt)
-                this->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
+        block = ((int)ofs) >> chip->bbt_erase_shift;
+        if (chip->bbt)
+                chip->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
 
         /* Do we have a flash based bad block table ? */
-        if (this->options & NAND_USE_FLASH_BBT)
-                return nand_update_bbt (mtd, ofs);
+        if (chip->options & NAND_USE_FLASH_BBT)
+                ret = nand_update_bbt(mtd, ofs);
+        else {
+                /* We write two bytes, so we dont have to mess with 16 bit
+                 * access
+                 */
+                ofs += mtd->oobsize;
+                chip->ops.len = 2;
+                chip->ops.datbuf = NULL;
+                chip->ops.oobbuf = buf;
+                chip->ops.ooboffs = chip->badblockpos & ~0x01;
 
-        /* We write two bytes, so we dont have to mess with 16 bit access */
-        ofs += mtd->oobsize + (this->badblockpos & ~0x01);
-        return nand_write_oob (mtd, ofs , 2, &retlen, buf);
+                ret = nand_do_write_oob(mtd, ofs, &chip->ops);
+        }
+        if (!ret)
+                mtd->ecc_stats.badblocks++;
+        return ret;
 }
 
 /**
@@ -487,12 +381,12 @@ static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
  *
  * The function expects, that the device is already selected
  */
-static int nand_check_wp (struct mtd_info *mtd)
+static int nand_check_wp(struct mtd_info *mtd)
 {
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
         /* Check the WP bit */
-        this->cmdfunc (mtd, NAND_CMD_STATUS, -1, -1);
-        return (this->read_byte(mtd) & NAND_STATUS_WP) ? 0 : 1;
+        chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
+        return (chip->read_byte(mtd) & NAND_STATUS_WP) ? 0 : 1;
 }
 
 /**
@@ -505,32 +399,31 @@ static int nand_check_wp (struct mtd_info *mtd)
  * Check, if the block is bad. Either by reading the bad block table or
  * calling of the scan function.
  */
-static int nand_block_checkbad (struct mtd_info *mtd, loff_t ofs, int getchip, int allowbbt)
+static int nand_block_checkbad(struct mtd_info *mtd, loff_t ofs, int getchip,
+                               int allowbbt)
 {
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
 
-        if (!this->bbt)
-                return this->block_bad(mtd, ofs, getchip);
+        if (!chip->bbt)
+                return chip->block_bad(mtd, ofs, getchip);
 
         /* Return info from the table */
-        return nand_isbad_bbt (mtd, ofs, allowbbt);
+        return nand_isbad_bbt(mtd, ofs, allowbbt);
 }
 
-DEFINE_LED_TRIGGER(nand_led_trigger);
-
 /*
  * Wait for the ready pin, after a command
  * The timeout is catched later.
  */
 static void nand_wait_ready(struct mtd_info *mtd)
 {
-        struct nand_chip *this = mtd->priv;
-        unsigned long   timeo = jiffies + 2;
+        struct nand_chip *chip = mtd->priv;
+        unsigned long timeo = jiffies + 2;
 
         led_trigger_event(nand_led_trigger, LED_FULL);
         /* wait until command is processed or timeout occures */
         do {
-                if (this->dev_ready(mtd))
+                if (chip->dev_ready(mtd))
                         break;
                 touch_softlockup_watchdog();
         } while (time_before(jiffies, timeo));
@@ -547,21 +440,21 @@ static void nand_wait_ready(struct mtd_info *mtd)
  * Send command to NAND device. This function is used for small page
  * devices (256/512 Bytes per page)
  */
-static void nand_command (struct mtd_info *mtd, unsigned command, int column, int page_addr)
+static void nand_command(struct mtd_info *mtd, unsigned int command,
+                         int column, int page_addr)
 {
-        register struct nand_chip *this = mtd->priv;
+        register struct nand_chip *chip = mtd->priv;
+        int ctrl = NAND_CTRL_CLE | NAND_CTRL_CHANGE;
 
-        /* Begin command latch cycle */
-        this->hwcontrol(mtd, NAND_CTL_SETCLE);
         /*
          * Write out the command to the device.
          */
         if (command == NAND_CMD_SEQIN) {
                 int readcmd;
 
-                if (column >= mtd->oobblock) {
+                if (column >= mtd->writesize) {
                         /* OOB area */
-                        column -= mtd->oobblock;
+                        column -= mtd->writesize;
                         readcmd = NAND_CMD_READOOB;
                 } else if (column < 256) {
                         /* First 256 bytes --> READ0 */
@@ -570,38 +463,37 @@ static void nand_command (struct mtd_info *mtd, unsigned command, int column, in
                         column -= 256;
                         readcmd = NAND_CMD_READ1;
                 }
-                this->write_byte(mtd, readcmd);
+                chip->cmd_ctrl(mtd, readcmd, ctrl);
+                ctrl &= ~NAND_CTRL_CHANGE;
         }
-        this->write_byte(mtd, command);
-
-        /* Set ALE and clear CLE to start address cycle */
-        this->hwcontrol(mtd, NAND_CTL_CLRCLE);
+        chip->cmd_ctrl(mtd, command, ctrl);
 
-        if (column != -1 || page_addr != -1) {
-                this->hwcontrol(mtd, NAND_CTL_SETALE);
-
-                /* Serially input address */
-                if (column != -1) {
-                        /* Adjust columns for 16 bit buswidth */
-                        if (this->options & NAND_BUSWIDTH_16)
-                                column >>= 1;
-                        this->write_byte(mtd, column);
-                }
-                if (page_addr != -1) {
-                        this->write_byte(mtd, (unsigned char) (page_addr & 0xff));
-                        this->write_byte(mtd, (unsigned char) ((page_addr >> 8) & 0xff));
-                        /* One more address cycle for devices > 32MiB */
-                        if (this->chipsize > (32 << 20))
-                                this->write_byte(mtd, (unsigned char) ((page_addr >> 16) & 0x0f));
-                }
-                /* Latch in address */
-                this->hwcontrol(mtd, NAND_CTL_CLRALE);
+        /*
+         * Address cycle, when necessary
+         */
+        ctrl = NAND_CTRL_ALE | NAND_CTRL_CHANGE;
+        /* Serially input address */
+        if (column != -1) {
+                /* Adjust columns for 16 bit buswidth */
+                if (chip->options & NAND_BUSWIDTH_16)
+                        column >>= 1;
+                chip->cmd_ctrl(mtd, column, ctrl);
+                ctrl &= ~NAND_CTRL_CHANGE;
+        }
+        if (page_addr != -1) {
+                chip->cmd_ctrl(mtd, page_addr, ctrl);
+                ctrl &= ~NAND_CTRL_CHANGE;
+                chip->cmd_ctrl(mtd, page_addr >> 8, ctrl);
+                /* One more address cycle for devices > 32MiB */
+                if (chip->chipsize > (32 << 20))
+                        chip->cmd_ctrl(mtd, page_addr >> 16, ctrl);
         }
+        chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
 
         /*
          * program and erase have their own busy handlers
          * status and sequential in needs no delay
-        */
+         */
         switch (command) {
 
         case NAND_CMD_PAGEPROG:
@@ -612,29 +504,30 @@ static void nand_command (struct mtd_info *mtd, unsigned command, int column, in
                 return;
 
         case NAND_CMD_RESET:
-                if (this->dev_ready)
+                if (chip->dev_ready)
                         break;
-                udelay(this->chip_delay);
-                this->hwcontrol(mtd, NAND_CTL_SETCLE);
-                this->write_byte(mtd, NAND_CMD_STATUS);
-                this->hwcontrol(mtd, NAND_CTL_CLRCLE);
-                while ( !(this->read_byte(mtd) & NAND_STATUS_READY));
+                udelay(chip->chip_delay);
+                chip->cmd_ctrl(mtd, NAND_CMD_STATUS,
+                               NAND_CTRL_CLE | NAND_CTRL_CHANGE);
+                chip->cmd_ctrl(mtd,
+                               NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
+                while (!(chip->read_byte(mtd) & NAND_STATUS_READY)) ;
                 return;
 
-        /* This applies to read commands */
+                /* This applies to read commands */
         default:
                 /*
                  * If we don't have access to the busy pin, we apply the given
                  * command delay
-                */
-                if (!this->dev_ready) {
-                        udelay (this->chip_delay);
+                 */
+                if (!chip->dev_ready) {
+                        udelay(chip->chip_delay);
                         return;
                 }
         }
         /* Apply this short delay always to ensure that we do wait tWB in
          * any case on any machine. */
-        ndelay (100);
+        ndelay(100);
 
         nand_wait_ready(mtd);
 }
@@ -646,50 +539,49 @@ static void nand_command (struct mtd_info *mtd, unsigned command, int column, in
  * @column:     the column address for this command, -1 if none
  * @page_addr:  the page address for this command, -1 if none
  *
- * Send command to NAND device. This is the version for the new large page devices
- * We dont have the seperate regions as we have in the small page devices.
- * We must emulate NAND_CMD_READOOB to keep the code compatible.
+ * Send command to NAND device. This is the version for the new large page
+ * devices We dont have the separate regions as we have in the small page
+ * devices.  We must emulate NAND_CMD_READOOB to keep the code compatible.
  *
  */
-static void nand_command_lp (struct mtd_info *mtd, unsigned command, int column, int page_addr)
+static void nand_command_lp(struct mtd_info *mtd, unsigned int command,
+                            int column, int page_addr)
 {
-        register struct nand_chip *this = mtd->priv;
+        register struct nand_chip *chip = mtd->priv;
 
         /* Emulate NAND_CMD_READOOB */
         if (command == NAND_CMD_READOOB) {
-                column += mtd->oobblock;
+                column += mtd->writesize;
                 command = NAND_CMD_READ0;
         }
 
-
-        /* Begin command latch cycle */
-        this->hwcontrol(mtd, NAND_CTL_SETCLE);
-        /* Write out the command to the device. */
-        this->write_byte(mtd, (command & 0xff));
-        /* End command latch cycle */
-        this->hwcontrol(mtd, NAND_CTL_CLRCLE);
+        /* Command latch cycle */
+        chip->cmd_ctrl(mtd, command & 0xff,
+                       NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
 
         if (column != -1 || page_addr != -1) {
-                this->hwcontrol(mtd, NAND_CTL_SETALE);
+                int ctrl = NAND_CTRL_CHANGE | NAND_NCE | NAND_ALE;
 
                 /* Serially input address */
                 if (column != -1) {
                         /* Adjust columns for 16 bit buswidth */
-                        if (this->options & NAND_BUSWIDTH_16)
+                        if (chip->options & NAND_BUSWIDTH_16)
                                 column >>= 1;
-                        this->write_byte(mtd, column & 0xff);
-                        this->write_byte(mtd, column >> 8);
+                        chip->cmd_ctrl(mtd, column, ctrl);
+                        ctrl &= ~NAND_CTRL_CHANGE;
+                        chip->cmd_ctrl(mtd, column >> 8, ctrl);
                 }
                 if (page_addr != -1) {
-                        this->write_byte(mtd, (unsigned char) (page_addr & 0xff));
-                        this->write_byte(mtd, (unsigned char) ((page_addr >> 8) & 0xff));
+                        chip->cmd_ctrl(mtd, page_addr, ctrl);
+                        chip->cmd_ctrl(mtd, page_addr >> 8,
+                                       NAND_NCE | NAND_ALE);
                         /* One more address cycle for devices > 128MiB */
-                        if (this->chipsize > (128 << 20))
-                                this->write_byte(mtd, (unsigned char) ((page_addr >> 16) & 0xff));
+                        if (chip->chipsize > (128 << 20))
+                                chip->cmd_ctrl(mtd, page_addr >> 16,
+                                               NAND_NCE | NAND_ALE);
                 }
-                /* Latch in address */
-                this->hwcontrol(mtd, NAND_CTL_CLRALE);
         }
+        chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
 
         /*
          * program and erase have their own busy handlers
@@ -702,55 +594,62 @@ static void nand_command_lp (struct mtd_info *mtd, unsigned command, int column,
         case NAND_CMD_ERASE1:
         case NAND_CMD_ERASE2:
         case NAND_CMD_SEQIN:
+        case NAND_CMD_RNDIN:
         case NAND_CMD_STATUS:
         case NAND_CMD_DEPLETE1:
                 return;
 
-        /*
-         * read error status commands require only a short delay
-         */
+                /*
+                 * read error status commands require only a short delay
+                 */
         case NAND_CMD_STATUS_ERROR:
         case NAND_CMD_STATUS_ERROR0:
         case NAND_CMD_STATUS_ERROR1:
         case NAND_CMD_STATUS_ERROR2:
         case NAND_CMD_STATUS_ERROR3:
-                udelay(this->chip_delay);
+                udelay(chip->chip_delay);
                 return;
 
         case NAND_CMD_RESET:
-                if (this->dev_ready)
+                if (chip->dev_ready)
                         break;
-                udelay(this->chip_delay);
-                this->hwcontrol(mtd, NAND_CTL_SETCLE);
-                this->write_byte(mtd, NAND_CMD_STATUS);
-                this->hwcontrol(mtd, NAND_CTL_CLRCLE);
-                while ( !(this->read_byte(mtd) & NAND_STATUS_READY));
+                udelay(chip->chip_delay);
+                chip->cmd_ctrl(mtd, NAND_CMD_STATUS,
+                               NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
+                chip->cmd_ctrl(mtd, NAND_CMD_NONE,
+                               NAND_NCE | NAND_CTRL_CHANGE);
+                while (!(chip->read_byte(mtd) & NAND_STATUS_READY)) ;
+                return;
+
+        case NAND_CMD_RNDOUT:
+                /* No ready / busy check necessary */
+                chip->cmd_ctrl(mtd, NAND_CMD_RNDOUTSTART,
+                               NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
+                chip->cmd_ctrl(mtd, NAND_CMD_NONE,
+                               NAND_NCE | NAND_CTRL_CHANGE);
                 return;
 
         case NAND_CMD_READ0:
-                /* Begin command latch cycle */
-                this->hwcontrol(mtd, NAND_CTL_SETCLE);
-                /* Write out the start read command */
-                this->write_byte(mtd, NAND_CMD_READSTART);
-                /* End command latch cycle */
-                this->hwcontrol(mtd, NAND_CTL_CLRCLE);
-                /* Fall through into ready check */
-
-        /* This applies to read commands */
+                chip->cmd_ctrl(mtd, NAND_CMD_READSTART,
+                               NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
+                chip->cmd_ctrl(mtd, NAND_CMD_NONE,
+                               NAND_NCE | NAND_CTRL_CHANGE);
+
+                /* This applies to read commands */
         default:
                 /*
                  * If we don't have access to the busy pin, we apply the given
                  * command delay
-                */
-                if (!this->dev_ready) {
-                        udelay (this->chip_delay);
+                 */
+                if (!chip->dev_ready) {
+                        udelay(chip->chip_delay);
                         return;
                 }
         }
 
         /* Apply this short delay always to ensure that we do wait tWB in
          * any case on any machine. */
-        ndelay (100);
+        ndelay(100);
 
         nand_wait_ready(mtd);
 }
@@ -763,34 +662,28 @@ static void nand_command_lp (struct mtd_info *mtd, unsigned command, int column,
  *
  * Get the device and lock it for exclusive access
  */
-static int nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int new_state)
+static int
+nand_get_device(struct nand_chip *chip, struct mtd_info *mtd, int new_state)
 {
-        struct nand_chip *active;
-        spinlock_t *lock;
-        wait_queue_head_t *wq;
-        DECLARE_WAITQUEUE (wait, current);
-
-        lock = (this->controller) ? &this->controller->lock : &this->chip_lock;
-        wq = (this->controller) ? &this->controller->wq : &this->wq;
-retry:
-        active = this;
+        spinlock_t *lock = &chip->controller->lock;
+        wait_queue_head_t *wq = &chip->controller->wq;
+        DECLARE_WAITQUEUE(wait, current);
+ retry:
         spin_lock(lock);
 
         /* Hardware controller shared among independend devices */
-        if (this->controller) {
-                if (this->controller->active)
-                        active = this->controller->active;
-                else
-                        this->controller->active = this;
-        }
-        if (active == this && this->state == FL_READY) {
-                this->state = new_state;
+        /* Hardware controller shared among independend devices */
+        if (!chip->controller->active)
+                chip->controller->active = chip;
+
+        if (chip->controller->active == chip && chip->state == FL_READY) {
+                chip->state = new_state;
                 spin_unlock(lock);
                 return 0;
         }
         if (new_state == FL_PM_SUSPENDED) {
                 spin_unlock(lock);
-                return (this->state == FL_PM_SUSPENDED) ? 0 : -EAGAIN;
+                return (chip->state == FL_PM_SUSPENDED) ? 0 : -EAGAIN;
         }
         set_current_state(TASK_UNINTERRUPTIBLE);
         add_wait_queue(wq, &wait);
@@ -804,540 +697,339 @@ retry:
  * nand_wait - [DEFAULT]  wait until the command is done
  * @mtd:        MTD device structure
  * @this:       NAND chip structure
- * @state:      state to select the max. timeout value
  *
  * Wait for command done. This applies to erase and program only
  * Erase can take up to 400ms and program up to 20ms according to
  * general NAND and SmartMedia specs
  *
 */
-static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
+static int nand_wait(struct mtd_info *mtd, struct nand_chip *chip)
 {
 
-        unsigned long   timeo = jiffies;
-        int     status;
+        unsigned long timeo = jiffies;
+        int status, state = chip->state;
 
         if (state == FL_ERASING)
-                 timeo += (HZ * 400) / 1000;
+                timeo += (HZ * 400) / 1000;
         else
-                 timeo += (HZ * 20) / 1000;
+                timeo += (HZ * 20) / 1000;
 
         led_trigger_event(nand_led_trigger, LED_FULL);
 
         /* Apply this short delay always to ensure that we do wait tWB in
          * any case on any machine. */
-        ndelay (100);
+        ndelay(100);
 
-        if ((state == FL_ERASING) && (this->options & NAND_IS_AND))
-                this->cmdfunc (mtd, NAND_CMD_STATUS_MULTI, -1, -1);
+        if ((state == FL_ERASING) && (chip->options & NAND_IS_AND))
+                chip->cmdfunc(mtd, NAND_CMD_STATUS_MULTI, -1, -1);
         else
-                this->cmdfunc (mtd, NAND_CMD_STATUS, -1, -1);
+                chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
 
         while (time_before(jiffies, timeo)) {
-                /* Check, if we were interrupted */
-                if (this->state != state)
-                        return 0;
-
-                if (this->dev_ready) {
-                        if (this->dev_ready(mtd))
+                if (chip->dev_ready) {
+                        if (chip->dev_ready(mtd))
                                 break;
                 } else {
-                        if (this->read_byte(mtd) & NAND_STATUS_READY)
+                        if (chip->read_byte(mtd) & NAND_STATUS_READY)
                                 break;
                 }
                 cond_resched();
         }
         led_trigger_event(nand_led_trigger, LED_OFF);
 
-        status = (int) this->read_byte(mtd);
+        status = (int)chip->read_byte(mtd);
         return status;
 }
 
 /**
- * nand_write_page - [GENERIC] write one page
- * @mtd:        MTD device structure
- * @this:       NAND chip structure
- * @page:       startpage inside the chip, must be called with (page & this->pagemask)
- * @oob_buf:    out of band data buffer
- * @oobsel:     out of band selecttion structre
- * @cached:     1 = enable cached programming if supported by chip
- *
- * Nand_page_program function is used for write and writev !
- * This function will always program a full page of data
- * If you call it with a non page aligned buffer, you're lost :)
- *
- * Cached programming is not supported yet.
+ * nand_read_page_raw - [Intern] read raw page data without ecc
+ * @mtd:        mtd info structure
+ * @chip:       nand chip info structure
+ * @buf:        buffer to store read data
  */
-static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int page,
-        u_char *oob_buf,  struct nand_oobinfo *oobsel, int cached)
+static int nand_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
+                              uint8_t *buf)
 {
-        int     i, status;
-        u_char  ecc_code[32];
-        int     eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
-        int     *oob_config = oobsel->eccpos;
-        int     datidx = 0, eccidx = 0, eccsteps = this->eccsteps;
-        int     eccbytes = 0;
-
-        /* FIXME: Enable cached programming */
-        cached = 0;
+        chip->read_buf(mtd, buf, mtd->writesize);
+        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
+        return 0;
+}
 
-        /* Send command to begin auto page programming */
-        this->cmdfunc (mtd, NAND_CMD_SEQIN, 0x00, page);
+/**
+ * nand_read_page_swecc - {REPLACABLE] software ecc based page read function
+ * @mtd:        mtd info structure
+ * @chip:       nand chip info structure
+ * @buf:        buffer to store read data
+ */
+static int nand_read_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
+                                uint8_t *buf)
+{
+        int i, eccsize = chip->ecc.size;
+        int eccbytes = chip->ecc.bytes;
+        int eccsteps = chip->ecc.steps;
+        uint8_t *p = buf;
+        uint8_t *ecc_calc = chip->buffers.ecccalc;
+        uint8_t *ecc_code = chip->buffers.ecccode;
+        int *eccpos = chip->ecc.layout->eccpos;
 
-        /* Write out complete page of data, take care of eccmode */
-        switch (eccmode) {
-        /* No ecc, write all */
-        case NAND_ECC_NONE:
-                printk (KERN_WARNING "Writing data without ECC to NAND-FLASH is not recommended\n");
-                this->write_buf(mtd, this->data_poi, mtd->oobblock);
-                break;
+        nand_read_page_raw(mtd, chip, buf);
 
-        /* Software ecc 3/256, write all */
-        case NAND_ECC_SOFT:
-                for (; eccsteps; eccsteps--) {
-                        this->calculate_ecc(mtd, &this->data_poi[datidx], ecc_code);
-                        for (i = 0; i < 3; i++, eccidx++)
-                                oob_buf[oob_config[eccidx]] = ecc_code[i];
-                        datidx += this->eccsize;
-                }
-                this->write_buf(mtd, this->data_poi, mtd->oobblock);
-                break;
-        default:
-                eccbytes = this->eccbytes;
-                for (; eccsteps; eccsteps--) {
-                        /* enable hardware ecc logic for write */
-                        this->enable_hwecc(mtd, NAND_ECC_WRITE);
-                        this->write_buf(mtd, &this->data_poi[datidx], this->eccsize);
-                        this->calculate_ecc(mtd, &this->data_poi[datidx], ecc_code);
-                        for (i = 0; i < eccbytes; i++, eccidx++)
-                                oob_buf[oob_config[eccidx]] = ecc_code[i];
-                        /* If the hardware ecc provides syndromes then
-                         * the ecc code must be written immidiately after
-                         * the data bytes (words) */
-                        if (this->options & NAND_HWECC_SYNDROME)
-                                this->write_buf(mtd, ecc_code, eccbytes);
-                        datidx += this->eccsize;
-                }
-                break;
-        }
+        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)
+                chip->ecc.calculate(mtd, p, &ecc_calc[i]);
 
-        /* Write out OOB data */
-        if (this->options & NAND_HWECC_SYNDROME)
-                this->write_buf(mtd, &oob_buf[oobsel->eccbytes], mtd->oobsize - oobsel->eccbytes);
-        else
-                this->write_buf(mtd, oob_buf, mtd->oobsize);
+        for (i = 0; i < chip->ecc.total; i++)
+                ecc_code[i] = chip->oob_poi[eccpos[i]];
 
-        /* Send command to actually program the data */
-        this->cmdfunc (mtd, cached ? NAND_CMD_CACHEDPROG : NAND_CMD_PAGEPROG, -1, -1);
+        eccsteps = chip->ecc.steps;
+        p = buf;
 
-        if (!cached) {
-                /* call wait ready function */
-                status = this->waitfunc (mtd, this, FL_WRITING);
+        for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
+                int stat;
 
-                /* See if operation failed and additional status checks are available */
-                if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
-                        status = this->errstat(mtd, this, FL_WRITING, status, page);
-                }
-
-                /* See if device thinks it succeeded */
-                if (status & NAND_STATUS_FAIL) {
-                        DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write, page 0x%08x, ", __FUNCTION__, page);
-                        return -EIO;
-                }
-        } else {
-                /* FIXME: Implement cached programming ! */
-                /* wait until cache is ready*/
-                // status = this->waitfunc (mtd, this, FL_CACHEDRPG);
+                stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);
+                if (stat == -1)
+                        mtd->ecc_stats.failed++;
+                else
+                        mtd->ecc_stats.corrected += stat;
         }
         return 0;
 }
 
-#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
 /**
- * nand_verify_pages - [GENERIC] verify the chip contents after a write
- * @mtd:        MTD device structure
- * @this:       NAND chip structure
- * @page:       startpage inside the chip, must be called with (page & this->pagemask)
- * @numpages:   number of pages to verify
- * @oob_buf:    out of band data buffer
- * @oobsel:     out of band selecttion structre
- * @chipnr:     number of the current chip
- * @oobmode:    1 = full buffer verify, 0 = ecc only
+ * nand_read_page_hwecc - {REPLACABLE] hardware ecc based page read function
+ * @mtd:        mtd info structure
+ * @chip:       nand chip info structure
+ * @buf:        buffer to store read data
  *
- * The NAND device assumes that it is always writing to a cleanly erased page.
- * Hence, it performs its internal write verification only on bits that
- * transitioned from 1 to 0. The device does NOT verify the whole page on a
- * byte by byte basis. It is possible that the page was not completely erased
- * or the page is becoming unusable due to wear. The read with ECC would catch
- * the error later when the ECC page check fails, but we would rather catch
- * it early in the page write stage. Better to write no data than invalid data.
+ * Not for syndrome calculating ecc controllers which need a special oob layout
  */
-static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
-        u_char *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode)
+static int nand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
+                                uint8_t *buf)
 {
-        int     i, j, datidx = 0, oobofs = 0, res = -EIO;
-        int     eccsteps = this->eccsteps;
-        int     hweccbytes;
-        u_char  oobdata[64];
-
-        hweccbytes = (this->options & NAND_HWECC_SYNDROME) ? (oobsel->eccbytes / eccsteps) : 0;
-
-        /* Send command to read back the first page */
-        this->cmdfunc (mtd, NAND_CMD_READ0, 0, page);
-
-        for(;;) {
-                for (j = 0; j < eccsteps; j++) {
-                        /* Loop through and verify the data */
-                        if (this->verify_buf(mtd, &this->data_poi[datidx], mtd->eccsize)) {
-                                DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
-                                goto out;
-                        }
-                        datidx += mtd->eccsize;
-                        /* Have we a hw generator layout ? */
-                        if (!hweccbytes)
-                                continue;
-                        if (this->verify_buf(mtd, &this->oob_buf[oobofs], hweccbytes)) {
-                                DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
-                                goto out;
-                        }
-                        oobofs += hweccbytes;
-                }
+        int i, eccsize = chip->ecc.size;
+        int eccbytes = chip->ecc.bytes;
+        int eccsteps = chip->ecc.steps;
+        uint8_t *p = buf;
+        uint8_t *ecc_calc = chip->buffers.ecccalc;
+        uint8_t *ecc_code = chip->buffers.ecccode;
+        int *eccpos = chip->ecc.layout->eccpos;
+
+        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
+                chip->ecc.hwctl(mtd, NAND_ECC_READ);
+                chip->read_buf(mtd, p, eccsize);
+                chip->ecc.calculate(mtd, p, &ecc_calc[i]);
+        }
+        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
 
-                /* check, if we must compare all data or if we just have to
-                 * compare the ecc bytes
-                 */
-                if (oobmode) {
-                        if (this->verify_buf(mtd, &oob_buf[oobofs], mtd->oobsize - hweccbytes * eccsteps)) {
-                                DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
-                                goto out;
-                        }
-                } else {
-                        /* Read always, else autoincrement fails */
-                        this->read_buf(mtd, oobdata, mtd->oobsize - hweccbytes * eccsteps);
-
-                        if (oobsel->useecc != MTD_NANDECC_OFF && !hweccbytes) {
-                                int ecccnt = oobsel->eccbytes;
-
-                                for (i = 0; i < ecccnt; i++) {
-                                        int idx = oobsel->eccpos[i];
-                                        if (oobdata[idx] != oob_buf[oobofs + idx] ) {
-                                                DEBUG (MTD_DEBUG_LEVEL0,
-                                                "%s: Failed ECC write "
-                                                "verify, page 0x%08x, " "%6i bytes were succesful\n", __FUNCTION__, page, i);
-                                                goto out;
-                                        }
-                                }
-                        }
-                }
-                oobofs += mtd->oobsize - hweccbytes * eccsteps;
-                page++;
-                numpages--;
-
-                /* Apply delay or wait for ready/busy pin
-                 * Do this before the AUTOINCR check, so no problems
-                 * arise if a chip which does auto increment
-                 * is marked as NOAUTOINCR by the board driver.
-                 * Do this also before returning, so the chip is
-                 * ready for the next command.
-                */
-                if (!this->dev_ready)
-                        udelay (this->chip_delay);
-                else
-                        nand_wait_ready(mtd);
+        for (i = 0; i < chip->ecc.total; i++)
+                ecc_code[i] = chip->oob_poi[eccpos[i]];
 
-                /* All done, return happy */
-                if (!numpages)
-                        return 0;
+        eccsteps = chip->ecc.steps;
+        p = buf;
 
+        for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
+                int stat;
 
-                /* Check, if the chip supports auto page increment */
-                if (!NAND_CANAUTOINCR(this))
-                        this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page);
+                stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);
+                if (stat == -1)
+                        mtd->ecc_stats.failed++;
+                else
+                        mtd->ecc_stats.corrected += stat;
         }
-        /*
-         * Terminate the read command. We come here in case of an error
-         * So we must issue a reset command.
-         */
-out:
-        this->cmdfunc (mtd, NAND_CMD_RESET, -1, -1);
-        return res;
+        return 0;
 }
-#endif
 
 /**
- * nand_read - [MTD Interface] MTD compability function for nand_do_read_ecc
- * @mtd:        MTD device structure
- * @from:       offset to read from
- * @len:        number of bytes to read
- * @retlen:     pointer to variable to store the number of read bytes
- * @buf:        the databuffer to put data
+ * nand_read_page_syndrome - {REPLACABLE] hardware ecc syndrom based page read
+ * @mtd:        mtd info structure
+ * @chip:       nand chip info structure
+ * @buf:        buffer to store read data
  *
- * This function simply calls nand_do_read_ecc with oob buffer and oobsel = NULL
- * and flags = 0xff
+ * The hw generator calculates the error syndrome automatically. Therefor
+ * we need a special oob layout and handling.
  */
-static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf)
+static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
+                                   uint8_t *buf)
 {
-        return nand_do_read_ecc (mtd, from, len, retlen, buf, NULL, &mtd->oobinfo, 0xff);
-}
+        int i, eccsize = chip->ecc.size;
+        int eccbytes = chip->ecc.bytes;
+        int eccsteps = chip->ecc.steps;
+        uint8_t *p = buf;
+        uint8_t *oob = chip->oob_poi;
+
+        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
+                int stat;
+
+                chip->ecc.hwctl(mtd, NAND_ECC_READ);
+                chip->read_buf(mtd, p, eccsize);
+
+                if (chip->ecc.prepad) {
+                        chip->read_buf(mtd, oob, chip->ecc.prepad);
+                        oob += chip->ecc.prepad;
+                }
+
+                chip->ecc.hwctl(mtd, NAND_ECC_READSYN);
+                chip->read_buf(mtd, oob, eccbytes);
+                stat = chip->ecc.correct(mtd, p, oob, NULL);
+
+                if (stat == -1)
+                        mtd->ecc_stats.failed++;
+                else
+                        mtd->ecc_stats.corrected += stat;
+
+                oob += eccbytes;
+
+                if (chip->ecc.postpad) {
+                        chip->read_buf(mtd, oob, chip->ecc.postpad);
+                        oob += chip->ecc.postpad;
+                }
+        }
+
+        /* Calculate remaining oob bytes */
+        i = mtd->oobsize - (oob - chip->oob_poi);
+        if (i)
+                chip->read_buf(mtd, oob, i);
 
+        return 0;
+}
 
 /**
- * nand_read_ecc - [MTD Interface] MTD compability function for nand_do_read_ecc
- * @mtd:        MTD device structure
- * @from:       offset to read from
- * @len:        number of bytes to read
- * @retlen:     pointer to variable to store the number of read bytes
- * @buf:        the databuffer to put data
- * @oob_buf:    filesystem supplied oob data buffer
- * @oobsel:     oob selection structure
- *
- * This function simply calls nand_do_read_ecc with flags = 0xff
+ * nand_transfer_oob - [Internal] Transfer oob to client buffer
+ * @chip:       nand chip structure
+ * @ops:        oob ops structure
  */
-static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
-                          size_t * retlen, u_char * buf, u_char * oob_buf, struct nand_oobinfo *oobsel)
+static uint8_t *nand_transfer_oob(struct nand_chip *chip, uint8_t *oob,
+                                  struct mtd_oob_ops *ops)
 {
-        /* use userspace supplied oobinfo, if zero */
-        if (oobsel == NULL)
-                oobsel = &mtd->oobinfo;
-        return nand_do_read_ecc(mtd, from, len, retlen, buf, oob_buf, oobsel, 0xff);
+        size_t len = ops->ooblen;
+
+        switch(ops->mode) {
+
+        case MTD_OOB_PLACE:
+        case MTD_OOB_RAW:
+                memcpy(oob, chip->oob_poi + ops->ooboffs, len);
+                return oob + len;
+
+        case MTD_OOB_AUTO: {
+                struct nand_oobfree *free = chip->ecc.layout->oobfree;
+                uint32_t boffs = 0, roffs = ops->ooboffs;
+                size_t bytes = 0;
+
+                for(; free->length && len; free++, len -= bytes) {
+                        /* Read request not from offset 0 ? */
+                        if (unlikely(roffs)) {
+                                if (roffs >= free->length) {
+                                        roffs -= free->length;
+                                        continue;
+                                }
+                                boffs = free->offset + roffs;
+                                bytes = min_t(size_t, len,
+                                              (free->length - roffs));
+                                roffs = 0;
+                        } else {
+                                bytes = min_t(size_t, len, free->length);
+                                boffs = free->offset;
+                        }
+                        memcpy(oob, chip->oob_poi + boffs, bytes);
+                        oob += bytes;
+                }
+                return oob;
+        }
+        default:
+                BUG();
+        }
+        return NULL;
 }
 
-
 /**
- * nand_do_read_ecc - [MTD Interface] Read data with ECC
+ * nand_do_read_ops - [Internal] Read data with ECC
+ *
  * @mtd:        MTD device structure
  * @from:       offset to read from
- * @len:        number of bytes to read
- * @retlen:     pointer to variable to store the number of read bytes
- * @buf:        the databuffer to put data
- * @oob_buf:    filesystem supplied oob data buffer (can be NULL)
- * @oobsel:     oob selection structure
- * @flags:      flag to indicate if nand_get_device/nand_release_device should be preformed
- *              and how many corrected error bits are acceptable:
- *                bits 0..7 - number of tolerable errors
- *                bit  8    - 0 == do not get/release chip, 1 == get/release chip
  *
- * NAND read with ECC
+ * Internal function. Called with chip held.
  */
-int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
-                             size_t * retlen, u_char * buf, u_char * oob_buf,
-                             struct nand_oobinfo *oobsel, int flags)
+static int nand_do_read_ops(struct mtd_info *mtd, loff_t from,
+                            struct mtd_oob_ops *ops)
 {
+        int chipnr, page, realpage, col, bytes, aligned;
+        struct nand_chip *chip = mtd->priv;
+        struct mtd_ecc_stats stats;
+        int blkcheck = (1 << (chip->phys_erase_shift - chip->page_shift)) - 1;
+        int sndcmd = 1;
+        int ret = 0;
+        uint32_t readlen = ops->len;
+        uint8_t *bufpoi, *oob, *buf;
 
-        int i, j, col, realpage, page, end, ecc, chipnr, sndcmd = 1;
-        int read = 0, oob = 0, ecc_status = 0, ecc_failed = 0;
-        struct nand_chip *this = mtd->priv;
-        u_char *data_poi, *oob_data = oob_buf;
-        u_char ecc_calc[32];
-        u_char ecc_code[32];
-        int eccmode, eccsteps;
-        int     *oob_config, datidx;
-        int     blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
-        int     eccbytes;
-        int     compareecc = 1;
-        int     oobreadlen;
-
-
-        DEBUG (MTD_DEBUG_LEVEL3, "nand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
-
-        /* Do not allow reads past end of device */
-        if ((from + len) > mtd->size) {
-                DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: Attempt read beyond end of device\n");
-                *retlen = 0;
-                return -EINVAL;
-        }
-
-        /* Grab the lock and see if the device is available */
-        if (flags & NAND_GET_DEVICE)
-                nand_get_device (this, mtd, FL_READING);
-
-        /* Autoplace of oob data ? Use the default placement scheme */
-        if (oobsel->useecc == MTD_NANDECC_AUTOPLACE)
-                oobsel = this->autooob;
-
-        eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
-        oob_config = oobsel->eccpos;
-
-        /* Select the NAND device */
-        chipnr = (int)(from >> this->chip_shift);
-        this->select_chip(mtd, chipnr);
-
-        /* First we calculate the starting page */
-        realpage = (int) (from >> this->page_shift);
-        page = realpage & this->pagemask;
-
-        /* Get raw starting column */
-        col = from & (mtd->oobblock - 1);
-
-        end = mtd->oobblock;
-        ecc = this->eccsize;
-        eccbytes = this->eccbytes;
-
-        if ((eccmode == NAND_ECC_NONE) || (this->options & NAND_HWECC_SYNDROME))
-                compareecc = 0;
-
-        oobreadlen = mtd->oobsize;
-        if (this->options & NAND_HWECC_SYNDROME)
-                oobreadlen -= oobsel->eccbytes;
+        stats = mtd->ecc_stats;
 
-        /* Loop until all data read */
-        while (read < len) {
+        chipnr = (int)(from >> chip->chip_shift);
+        chip->select_chip(mtd, chipnr);
 
-                int aligned = (!col && (len - read) >= end);
-                /*
-                 * If the read is not page aligned, we have to read into data buffer
-                 * due to ecc, else we read into return buffer direct
-                 */
-                if (aligned)
-                        data_poi = &buf[read];
-                else
-                        data_poi = this->data_buf;
+        realpage = (int)(from >> chip->page_shift);
+        page = realpage & chip->pagemask;
 
-                /* Check, if we have this page in the buffer
-                 *
-                 * FIXME: Make it work when we must provide oob data too,
-                 * check the usage of data_buf oob field
-                 */
-                if (realpage == this->pagebuf && !oob_buf) {
-                        /* aligned read ? */
-                        if (aligned)
-                                memcpy (data_poi, this->data_buf, end);
-                        goto readdata;
-                }
+        col = (int)(from & (mtd->writesize - 1));
+        chip->oob_poi = chip->buffers.oobrbuf;
 
-                /* Check, if we must send the read command */
-                if (sndcmd) {
-                        this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page);
-                        sndcmd = 0;
-                }
+        buf = ops->datbuf;
+        oob = ops->oobbuf;
 
-                /* get oob area, if we have no oob buffer from fs-driver */
-                if (!oob_buf || oobsel->useecc == MTD_NANDECC_AUTOPLACE ||
-                        oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
-                        oob_data = &this->data_buf[end];
+        while(1) {
+                bytes = min(mtd->writesize - col, readlen);
+                aligned = (bytes == mtd->writesize);
 
-                eccsteps = this->eccsteps;
+                /* Is the current page in the buffer ? */
+                if (realpage != chip->pagebuf || oob) {
+                        bufpoi = aligned ? buf : chip->buffers.databuf;
 
-                switch (eccmode) {
-                case NAND_ECC_NONE: {   /* No ECC, Read in a page */
-                        static unsigned long lastwhinge = 0;
-                        if ((lastwhinge / HZ) != (jiffies / HZ)) {
-                                printk (KERN_WARNING "Reading data from NAND FLASH without ECC is not recommended\n");
-                                lastwhinge = jiffies;
+                        if (likely(sndcmd)) {
+                                chip->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
+                                sndcmd = 0;
                         }
-                        this->read_buf(mtd, data_poi, end);
-                        break;
-                }
 
-                case NAND_ECC_SOFT:     /* Software ECC 3/256: Read in a page + oob data */
-                        this->read_buf(mtd, data_poi, end);
-                        for (i = 0, datidx = 0; eccsteps; eccsteps--, i+=3, datidx += ecc)
-                                this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]);
-                        break;
+                        /* Now read the page into the buffer */
+                        ret = chip->ecc.read_page(mtd, chip, bufpoi);
+                        if (ret < 0)
+                                break;
 
-                default:
-                        for (i = 0, datidx = 0; eccsteps; eccsteps--, i+=eccbytes, datidx += ecc) {
-                                this->enable_hwecc(mtd, NAND_ECC_READ);
-                                this->read_buf(mtd, &data_poi[datidx], ecc);
-
-                                /* HW ecc with syndrome calculation must read the
-                                 * syndrome from flash immidiately after the data */
-                                if (!compareecc) {
-                                        /* Some hw ecc generators need to know when the
-                                         * syndrome is read from flash */
-                                        this->enable_hwecc(mtd, NAND_ECC_READSYN);
-                                        this->read_buf(mtd, &oob_data[i], eccbytes);
-                                        /* We calc error correction directly, it checks the hw
-                                         * generator for an error, reads back the syndrome and
-                                         * does the error correction on the fly */
-                                        ecc_status = this->correct_data(mtd, &data_poi[datidx], &oob_data[i], &ecc_code[i]);
-                                        if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
-                                                DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: "
-                                                        "Failed ECC read, page 0x%08x on chip %d\n", page, chipnr);
-                                                ecc_failed++;
-                                        }
-                                } else {
-                                        this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]);
-                                }
+                        /* Transfer not aligned data */
+                        if (!aligned) {
+                                chip->pagebuf = realpage;
+                                memcpy(buf, chip->buffers.databuf + col, bytes);
                         }
-                        break;
-                }
-
-                /* read oobdata */
-                this->read_buf(mtd, &oob_data[mtd->oobsize - oobreadlen], oobreadlen);
-
-                /* Skip ECC check, if not requested (ECC_NONE or HW_ECC with syndromes) */
-                if (!compareecc)
-                        goto readoob;
-
-                /* Pick the ECC bytes out of the oob data */
-                for (j = 0; j < oobsel->eccbytes; j++)
-                        ecc_code[j] = oob_data[oob_config[j]];
 
-                /* correct data, if neccecary */
-                for (i = 0, j = 0, datidx = 0; i < this->eccsteps; i++, datidx += ecc) {
-                        ecc_status = this->correct_data(mtd, &data_poi[datidx], &ecc_code[j], &ecc_calc[j]);
+                        buf += bytes;
 
-                        /* Get next chunk of ecc bytes */
-                        j += eccbytes;
-
-                        /* Check, if we have a fs supplied oob-buffer,
-                         * This is the legacy mode. Used by YAFFS1
-                         * Should go away some day
-                         */
-                        if (oob_buf && oobsel->useecc == MTD_NANDECC_PLACE) {
-                                int *p = (int *)(&oob_data[mtd->oobsize]);
-                                p[i] = ecc_status;
+                        if (unlikely(oob)) {
+                                /* Raw mode does data:oob:data:oob */
+                                if (ops->mode != MTD_OOB_RAW)
+                                        oob = nand_transfer_oob(chip, oob, ops);
+                                else
+                                        buf = nand_transfer_oob(chip, buf, ops);
                         }
 
-                        if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
-                                DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: " "Failed ECC read, page 0x%08x\n", page);
-                                ecc_failed++;
+                        if (!(chip->options & NAND_NO_READRDY)) {
+                                /*
+                                 * Apply delay or wait for ready/busy pin. Do
+                                 * this before the AUTOINCR check, so no
+                                 * problems arise if a chip which does auto
+                                 * increment is marked as NOAUTOINCR by the
+                                 * board driver.
+                                 */
+                                if (!chip->dev_ready)
+                                        udelay(chip->chip_delay);
+                                else
+                                        nand_wait_ready(mtd);
                         }
+                } else {
+                        memcpy(buf, chip->buffers.databuf + col, bytes);
+                        buf += bytes;
                 }
 
-        readoob:
-                /* check, if we have a fs supplied oob-buffer */
-                if (oob_buf) {
-                        /* without autoplace. Legacy mode used by YAFFS1 */
-                        switch(oobsel->useecc) {
-                        case MTD_NANDECC_AUTOPLACE:
-                        case MTD_NANDECC_AUTOPL_USR:
-                                /* Walk through the autoplace chunks */
-                                for (i = 0; oobsel->oobfree[i][1]; i++) {
-                                        int from = oobsel->oobfree[i][0];
-                                        int num = oobsel->oobfree[i][1];
-                                        memcpy(&oob_buf[oob], &oob_data[from], num);
-                                        oob += num;
-                                }
-                                break;
-                        case MTD_NANDECC_PLACE:
-                                /* YAFFS1 legacy mode */
-                                oob_data += this->eccsteps * sizeof (int);
-                        default:
-                                oob_data += mtd->oobsize;
-                        }
-                }
-        readdata:
-                /* Partial page read, transfer data into fs buffer */
-                if (!aligned) {
-                        for (j = col; j < end && read < len; j++)
-                                buf[read++] = data_poi[j];
-                        this->pagebuf = realpage;
-                } else
-                        read += mtd->oobblock;
-
-                /* Apply delay or wait for ready/busy pin
-                 * Do this before the AUTOINCR check, so no problems
-                 * arise if a chip which does auto increment
-                 * is marked as NOAUTOINCR by the board driver.
-                */
-                if (!this->dev_ready)
-                        udelay (this->chip_delay);
-                else
-                        nand_wait_ready(mtd);
+                readlen -= bytes;
 
-                if (read == len)
+                if (!readlen)
                         break;
 
                 /* For subsequent reads align to page boundary. */
@@ -1345,701 +1037,775 @@ int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
                 /* Increment page address */
                 realpage++;
 
-                page = realpage & this->pagemask;
+                page = realpage & chip->pagemask;
                 /* Check, if we cross a chip boundary */
                 if (!page) {
                         chipnr++;
-                        this->select_chip(mtd, -1);
-                        this->select_chip(mtd, chipnr);
+                        chip->select_chip(mtd, -1);
+                        chip->select_chip(mtd, chipnr);
                 }
+
                 /* Check, if the chip supports auto page increment
                  * or if we have hit a block boundary.
-                */
-                if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
+                 */
+                if (!NAND_CANAUTOINCR(chip) || !(page & blkcheck))
                         sndcmd = 1;
         }
 
-        /* Deselect and wake up anyone waiting on the device */
-        if (flags & NAND_GET_DEVICE)
-                nand_release_device(mtd);
+        ops->retlen = ops->len - (size_t) readlen;
 
-        /*
-         * Return success, if no ECC failures, else -EBADMSG
-         * fs driver will take care of that, because
-         * retlen == desired len and result == -EBADMSG
-         */
-        *retlen = read;
-        return ecc_failed ? -EBADMSG : 0;
+        if (ret)
+                return ret;
+
+        if (mtd->ecc_stats.failed - stats.failed)
+                return -EBADMSG;
+
+        return  mtd->ecc_stats.corrected - stats.corrected ? -EUCLEAN : 0;
 }
 
 /**
- * nand_read_oob - [MTD Interface] NAND read out-of-band
+ * nand_read - [MTD Interface] MTD compability function for nand_do_read_ecc
  * @mtd:        MTD device structure
  * @from:       offset to read from
  * @len:        number of bytes to read
  * @retlen:     pointer to variable to store the number of read bytes
  * @buf:        the databuffer to put data
  *
- * NAND read out-of-band data from the spare area
+ * Get hold of the chip and call nand_do_read
  */
-static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf)
+static int nand_read(struct mtd_info *mtd, loff_t from, size_t len,
+                     size_t *retlen, uint8_t *buf)
 {
-        int i, col, page, chipnr;
-        struct nand_chip *this = mtd->priv;
-        int     blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
+        struct nand_chip *chip = mtd->priv;
+        int ret;
 
-        DEBUG (MTD_DEBUG_LEVEL3, "nand_read_oob: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
+        /* Do not allow reads past end of device */
+        if ((from + len) > mtd->size)
+                return -EINVAL;
+        if (!len)
+                return 0;
 
-        /* Shift to get page */
-        page = (int)(from >> this->page_shift);
-        chipnr = (int)(from >> this->chip_shift);
+        nand_get_device(chip, mtd, FL_READING);
 
-        /* Mask to get column */
-        col = from & (mtd->oobsize - 1);
+        chip->ops.len = len;
+        chip->ops.datbuf = buf;
+        chip->ops.oobbuf = NULL;
 
-        /* Initialize return length value */
-        *retlen = 0;
+        ret = nand_do_read_ops(mtd, from, &chip->ops);
 
-        /* Do not allow reads past end of device */
-        if ((from + len) > mtd->size) {
-                DEBUG (MTD_DEBUG_LEVEL0, "nand_read_oob: Attempt read beyond end of device\n");
-                *retlen = 0;
-                return -EINVAL;
+        nand_release_device(mtd);
+
+        *retlen = chip->ops.retlen;
+        return ret;
+}
+
+/**
+ * nand_read_oob_std - [REPLACABLE] the most common OOB data read function
+ * @mtd:        mtd info structure
+ * @chip:       nand chip info structure
+ * @page:       page number to read
+ * @sndcmd:     flag whether to issue read command or not
+ */
+static int nand_read_oob_std(struct mtd_info *mtd, struct nand_chip *chip,
+                             int page, int sndcmd)
+{
+        if (sndcmd) {
+                chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
+                sndcmd = 0;
         }
+        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
+        return sndcmd;
+}
 
-        /* Grab the lock and see if the device is available */
-        nand_get_device (this, mtd , FL_READING);
+/**
+ * nand_read_oob_syndrome - [REPLACABLE] OOB data read function for HW ECC
+ *                          with syndromes
+ * @mtd:        mtd info structure
+ * @chip:       nand chip info structure
+ * @page:       page number to read
+ * @sndcmd:     flag whether to issue read command or not
+ */
+static int nand_read_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
+                                  int page, int sndcmd)
+{
+        uint8_t *buf = chip->oob_poi;
+        int length = mtd->oobsize;
+        int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
+        int eccsize = chip->ecc.size;
+        uint8_t *bufpoi = buf;
+        int i, toread, sndrnd = 0, pos;
+
+        chip->cmdfunc(mtd, NAND_CMD_READ0, chip->ecc.size, page);
+        for (i = 0; i < chip->ecc.steps; i++) {
+                if (sndrnd) {
+                        pos = eccsize + i * (eccsize + chunk);
+                        if (mtd->writesize > 512)
+                                chip->cmdfunc(mtd, NAND_CMD_RNDOUT, pos, -1);
+                        else
+                                chip->cmdfunc(mtd, NAND_CMD_READ0, pos, page);
+                } else
+                        sndrnd = 1;
+                toread = min_t(int, length, chunk);
+                chip->read_buf(mtd, bufpoi, toread);
+                bufpoi += toread;
+                length -= toread;
+        }
+        if (length > 0)
+                chip->read_buf(mtd, bufpoi, length);
 
-        /* Select the NAND device */
-        this->select_chip(mtd, chipnr);
+        return 1;
+}
+
+/**
+ * nand_write_oob_std - [REPLACABLE] the most common OOB data write function
+ * @mtd:        mtd info structure
+ * @chip:       nand chip info structure
+ * @page:       page number to write
+ */
+static int nand_write_oob_std(struct mtd_info *mtd, struct nand_chip *chip,
+                              int page)
+{
+        int status = 0;
+        const uint8_t *buf = chip->oob_poi;
+        int length = mtd->oobsize;
+
+        chip->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize, page);
+        chip->write_buf(mtd, buf, length);
+        /* Send command to program the OOB data */
+        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+
+        status = chip->waitfunc(mtd, chip);
+
+        return status;
+}
+
+/**
+ * nand_write_oob_syndrome - [REPLACABLE] OOB data write function for HW ECC
+ *                           with syndrome - only for large page flash !
+ * @mtd:        mtd info structure
+ * @chip:       nand chip info structure
+ * @page:       page number to write
+ */
+static int nand_write_oob_syndrome(struct mtd_info *mtd,
+                                   struct nand_chip *chip, int page)
+{
+        int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
+        int eccsize = chip->ecc.size, length = mtd->oobsize;
+        int i, len, pos, status = 0, sndcmd = 0, steps = chip->ecc.steps;
+        const uint8_t *bufpoi = chip->oob_poi;
 
-        /* Send the read command */
-        this->cmdfunc (mtd, NAND_CMD_READOOB, col, page & this->pagemask);
         /*
-         * Read the data, if we read more than one page
-         * oob data, let the device transfer the data !
+         * data-ecc-data-ecc ... ecc-oob
+         * or
+         * data-pad-ecc-pad-data-pad .... ecc-pad-oob
          */
-        i = 0;
-        while (i < len) {
-                int thislen = mtd->oobsize - col;
-                thislen = min_t(int, thislen, len);
-                this->read_buf(mtd, &buf[i], thislen);
-                i += thislen;
-
-                /* Read more ? */
-                if (i < len) {
-                        page++;
-                        col = 0;
-
-                        /* Check, if we cross a chip boundary */
-                        if (!(page & this->pagemask)) {
-                                chipnr++;
-                                this->select_chip(mtd, -1);
-                                this->select_chip(mtd, chipnr);
-                        }
-
-                        /* Apply delay or wait for ready/busy pin
-                         * Do this before the AUTOINCR check, so no problems
-                         * arise if a chip which does auto increment
-                         * is marked as NOAUTOINCR by the board driver.
-                         */
-                        if (!this->dev_ready)
-                                udelay (this->chip_delay);
-                        else
-                                nand_wait_ready(mtd);
+        if (!chip->ecc.prepad && !chip->ecc.postpad) {
+                pos = steps * (eccsize + chunk);
+                steps = 0;
+        } else
+                pos = eccsize + chunk;
 
-                        /* Check, if the chip supports auto page increment
-                         * or if we have hit a block boundary.
-                        */
-                        if (!NAND_CANAUTOINCR(this) || !(page & blockcheck)) {
-                                /* For subsequent page reads set offset to 0 */
-                                this->cmdfunc (mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
+        chip->cmdfunc(mtd, NAND_CMD_SEQIN, pos, page);
+        for (i = 0; i < steps; i++) {
+                if (sndcmd) {
+                        if (mtd->writesize <= 512) {
+                                uint32_t fill = 0xFFFFFFFF;
+
+                                len = eccsize;
+                                while (len > 0) {
+                                        int num = min_t(int, len, 4);
+                                        chip->write_buf(mtd, (uint8_t *)&fill,
+                                                        num);
+                                        len -= num;
+                                }
+                        } else {
+                                pos = eccsize + i * (eccsize + chunk);
+                                chip->cmdfunc(mtd, NAND_CMD_RNDIN, pos, -1);
                         }
-                }
+                } else
+                        sndcmd = 1;
+                len = min_t(int, length, chunk);
+                chip->write_buf(mtd, bufpoi, len);
+                bufpoi += len;
+                length -= len;
         }
+        if (length > 0)
+                chip->write_buf(mtd, bufpoi, length);
 
-        /* Deselect and wake up anyone waiting on the device */
-        nand_release_device(mtd);
+        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+        status = chip->waitfunc(mtd, chip);
 
-        /* Return happy */
-        *retlen = len;
-        return 0;
+        return status & NAND_STATUS_FAIL ? -EIO : 0;
 }
 
 /**
- * nand_read_raw - [GENERIC] Read raw data including oob into buffer
+ * nand_do_read_oob - [Intern] NAND read out-of-band
  * @mtd:        MTD device structure
- * @buf:        temporary buffer
  * @from:       offset to read from
- * @len:        number of bytes to read
- * @ooblen:     number of oob data bytes to read
+ * @ops:        oob operations description structure
  *
- * Read raw data including oob into buffer
+ * NAND read out-of-band data from the spare area
  */
-int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len, size_t ooblen)
+static int nand_do_read_oob(struct mtd_info *mtd, loff_t from,
+                            struct mtd_oob_ops *ops)
 {
-        struct nand_chip *this = mtd->priv;
-        int page = (int) (from >> this->page_shift);
-        int chip = (int) (from >> this->chip_shift);
-        int sndcmd = 1;
-        int cnt = 0;
-        int pagesize = mtd->oobblock + mtd->oobsize;
-        int     blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
+        int page, realpage, chipnr, sndcmd = 1;
+        struct nand_chip *chip = mtd->priv;
+        int blkcheck = (1 << (chip->phys_erase_shift - chip->page_shift)) - 1;
+        int readlen = ops->len;
+        uint8_t *buf = ops->oobbuf;
 
-        /* Do not allow reads past end of device */
-        if ((from + len) > mtd->size) {
-                DEBUG (MTD_DEBUG_LEVEL0, "nand_read_raw: Attempt read beyond end of device\n");
-                return -EINVAL;
-        }
+        DEBUG(MTD_DEBUG_LEVEL3, "nand_read_oob: from = 0x%08Lx, len = %i\n",
+              (unsigned long long)from, readlen);
 
-        /* Grab the lock and see if the device is available */
-        nand_get_device (this, mtd , FL_READING);
+        chipnr = (int)(from >> chip->chip_shift);
+        chip->select_chip(mtd, chipnr);
 
-        this->select_chip (mtd, chip);
+        /* Shift to get page */
+        realpage = (int)(from >> chip->page_shift);
+        page = realpage & chip->pagemask;
 
-        /* Add requested oob length */
-        len += ooblen;
+        chip->oob_poi = chip->buffers.oobrbuf;
 
-        while (len) {
-                if (sndcmd)
-                        this->cmdfunc (mtd, NAND_CMD_READ0, 0, page & this->pagemask);
-                sndcmd = 0;
+        while(1) {
+                sndcmd = chip->ecc.read_oob(mtd, chip, page, sndcmd);
+                buf = nand_transfer_oob(chip, buf, ops);
 
-                this->read_buf (mtd, &buf[cnt], pagesize);
+                readlen -= ops->ooblen;
+                if (!readlen)
+                        break;
 
-                len -= pagesize;
-                cnt += pagesize;
-                page++;
+                if (!(chip->options & NAND_NO_READRDY)) {
+                        /*
+                         * Apply delay or wait for ready/busy pin. Do this
+                         * before the AUTOINCR check, so no problems arise if a
+                         * chip which does auto increment is marked as
+                         * NOAUTOINCR by the board driver.
+                         */
+                        if (!chip->dev_ready)
+                                udelay(chip->chip_delay);
+                        else
+                                nand_wait_ready(mtd);
+                }
 
-                if (!this->dev_ready)
-                        udelay (this->chip_delay);
-                else
-                        nand_wait_ready(mtd);
+                /* Increment page address */
+                realpage++;
 
-                /* Check, if the chip supports auto page increment */
-                if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
+                page = realpage & chip->pagemask;
+                /* Check, if we cross a chip boundary */
+                if (!page) {
+                        chipnr++;
+                        chip->select_chip(mtd, -1);
+                        chip->select_chip(mtd, chipnr);
+                }
+
+                /* Check, if the chip supports auto page increment
+                 * or if we have hit a block boundary.
+                 */
+                if (!NAND_CANAUTOINCR(chip) || !(page & blkcheck))
                         sndcmd = 1;
         }
 
-        /* Deselect and wake up anyone waiting on the device */
-        nand_release_device(mtd);
+        ops->retlen = ops->len;
         return 0;
 }
 
-
 /**
- * nand_prepare_oobbuf - [GENERIC] Prepare the out of band buffer
+ * nand_read_oob - [MTD Interface] NAND read data and/or out-of-band
  * @mtd:        MTD device structure
- * @fsbuf:      buffer given by fs driver
- * @oobsel:     out of band selection structre
- * @autoplace:  1 = place given buffer into the oob bytes
- * @numpages:   number of pages to prepare
- *
- * Return:
- * 1. Filesystem buffer available and autoplacement is off,
- *    return filesystem buffer
- * 2. No filesystem buffer or autoplace is off, return internal
- *    buffer
- * 3. Filesystem buffer is given and autoplace selected
- *    put data from fs buffer into internal buffer and
- *    retrun internal buffer
- *
- * Note: The internal buffer is filled with 0xff. This must
- * be done only once, when no autoplacement happens
- * Autoplacement sets the buffer dirty flag, which
- * forces the 0xff fill before using the buffer again.
+ * @from:       offset to read from
+ * @ops:        oob operation description structure
  *
-*/
-static u_char * nand_prepare_oobbuf (struct mtd_info *mtd, u_char *fsbuf, struct nand_oobinfo *oobsel,
-                int autoplace, int numpages)
+ * NAND read data and/or out-of-band data
+ */
+static int nand_read_oob(struct mtd_info *mtd, loff_t from,
+                         struct mtd_oob_ops *ops)
 {
-        struct nand_chip *this = mtd->priv;
-        int i, len, ofs;
-
-        /* Zero copy fs supplied buffer */
-        if (fsbuf && !autoplace)
-                return fsbuf;
-
-        /* Check, if the buffer must be filled with ff again */
-        if (this->oobdirty) {
-                memset (this->oob_buf, 0xff,
-                        mtd->oobsize << (this->phys_erase_shift - this->page_shift));
-                this->oobdirty = 0;
+        int (*read_page)(struct mtd_info *mtd, struct nand_chip *chip,
+                         uint8_t *buf) = NULL;
+        struct nand_chip *chip = mtd->priv;
+        int ret = -ENOTSUPP;
+
+        ops->retlen = 0;
+
+        /* Do not allow reads past end of device */
+        if ((from + ops->len) > mtd->size) {
+                DEBUG(MTD_DEBUG_LEVEL0, "nand_read_oob: "
+                      "Attempt read beyond end of device\n");
+                return -EINVAL;
         }
 
-        /* If we have no autoplacement or no fs buffer use the internal one */
-        if (!autoplace || !fsbuf)
-                return this->oob_buf;
-
-        /* Walk through the pages and place the data */
-        this->oobdirty = 1;
-        ofs = 0;
-        while (numpages--) {
-                for (i = 0, len = 0; len < mtd->oobavail; i++) {
-                        int to = ofs + oobsel->oobfree[i][0];
-                        int num = oobsel->oobfree[i][1];
-                        memcpy (&this->oob_buf[to], fsbuf, num);
-                        len += num;
-                        fsbuf += num;
-                }
-                ofs += mtd->oobavail;
+        nand_get_device(chip, mtd, FL_READING);
+
+        switch(ops->mode) {
+        case MTD_OOB_PLACE:
+        case MTD_OOB_AUTO:
+                break;
+
+        case MTD_OOB_RAW:
+                /* Replace the read_page algorithm temporary */
+                read_page = chip->ecc.read_page;
+                chip->ecc.read_page = nand_read_page_raw;
+                break;
+
+        default:
+                goto out;
         }
-        return this->oob_buf;
+
+        if (!ops->datbuf)
+                ret = nand_do_read_oob(mtd, from, ops);
+        else
+                ret = nand_do_read_ops(mtd, from, ops);
+
+        if (unlikely(ops->mode == MTD_OOB_RAW))
+                chip->ecc.read_page = read_page;
+ out:
+        nand_release_device(mtd);
+        return ret;
 }
 
-#define NOTALIGNED(x) (x & (mtd->oobblock-1)) != 0
 
 /**
- * nand_write - [MTD Interface] compability function for nand_write_ecc
- * @mtd:        MTD device structure
- * @to:         offset to write to
- * @len:        number of bytes to write
- * @retlen:     pointer to variable to store the number of written bytes
- * @buf:        the data to write
- *
- * This function simply calls nand_write_ecc with oob buffer and oobsel = NULL
- *
-*/
-static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf)
+ * nand_write_page_raw - [Intern] raw page write function
+ * @mtd:        mtd info structure
+ * @chip:       nand chip info structure
+ * @buf:        data buffer
+ */
+static void nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
+                                const uint8_t *buf)
 {
-        return (nand_write_ecc (mtd, to, len, retlen, buf, NULL, NULL));
+        chip->write_buf(mtd, buf, mtd->writesize);
+        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
 }
 
 /**
- * nand_write_ecc - [MTD Interface] NAND write with ECC
- * @mtd:        MTD device structure
- * @to:         offset to write to
- * @len:        number of bytes to write
- * @retlen:     pointer to variable to store the number of written bytes
- * @buf:        the data to write
- * @eccbuf:     filesystem supplied oob data buffer
- * @oobsel:     oob selection structure
- *
- * NAND write with ECC
+ * nand_write_page_swecc - {REPLACABLE] software ecc based page write function
+ * @mtd:        mtd info structure
+ * @chip:       nand chip info structure
+ * @buf:        data buffer
  */
-static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
-                           size_t * retlen, const u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel)
+static void nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
+                                  const uint8_t *buf)
 {
-        int startpage, page, ret = -EIO, oob = 0, written = 0, chipnr;
-        int autoplace = 0, numpages, totalpages;
-        struct nand_chip *this = mtd->priv;
-        u_char *oobbuf, *bufstart;
-        int     ppblock = (1 << (this->phys_erase_shift - this->page_shift));
+        int i, eccsize = chip->ecc.size;
+        int eccbytes = chip->ecc.bytes;
+        int eccsteps = chip->ecc.steps;
+        uint8_t *ecc_calc = chip->buffers.ecccalc;
+        const uint8_t *p = buf;
+        int *eccpos = chip->ecc.layout->eccpos;
 
-        DEBUG (MTD_DEBUG_LEVEL3, "nand_write_ecc: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
+        /* Software ecc calculation */
+        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)
+                chip->ecc.calculate(mtd, p, &ecc_calc[i]);
 
-        /* Initialize retlen, in case of early exit */
-        *retlen = 0;
+        for (i = 0; i < chip->ecc.total; i++)
+                chip->oob_poi[eccpos[i]] = ecc_calc[i];
 
-        /* Do not allow write past end of device */
-        if ((to + len) > mtd->size) {
-                DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: Attempt to write past end of page\n");
-                return -EINVAL;
-        }
+        nand_write_page_raw(mtd, chip, buf);
+}
 
-        /* reject writes, which are not page aligned */
-        if (NOTALIGNED (to) || NOTALIGNED(len)) {
-                printk (KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");
-                return -EINVAL;
+/**
+ * nand_write_page_hwecc - {REPLACABLE] hardware ecc based page write function
+ * @mtd:        mtd info structure
+ * @chip:       nand chip info structure
+ * @buf:        data buffer
+ */
+static void nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
+                                  const uint8_t *buf)
+{
+        int i, eccsize = chip->ecc.size;
+        int eccbytes = chip->ecc.bytes;
+        int eccsteps = chip->ecc.steps;
+        uint8_t *ecc_calc = chip->buffers.ecccalc;
+        const uint8_t *p = buf;
+        int *eccpos = chip->ecc.layout->eccpos;
+
+        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
+                chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
+                chip->write_buf(mtd, p, eccsize);
+                chip->ecc.calculate(mtd, p, &ecc_calc[i]);
         }
 
-        /* Grab the lock and see if the device is available */
-        nand_get_device (this, mtd, FL_WRITING);
+        for (i = 0; i < chip->ecc.total; i++)
+                chip->oob_poi[eccpos[i]] = ecc_calc[i];
 
-        /* Calculate chipnr */
-        chipnr = (int)(to >> this->chip_shift);
-        /* Select the NAND device */
-        this->select_chip(mtd, chipnr);
+        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
+}
 
-        /* Check, if it is write protected */
-        if (nand_check_wp(mtd))
-                goto out;
+/**
+ * nand_write_page_syndrome - {REPLACABLE] hardware ecc syndrom based page write
+ * @mtd:        mtd info structure
+ * @chip:       nand chip info structure
+ * @buf:        data buffer
+ *
+ * The hw generator calculates the error syndrome automatically. Therefor
+ * we need a special oob layout and handling.
+ */
+static void nand_write_page_syndrome(struct mtd_info *mtd,
+                                    struct nand_chip *chip, const uint8_t *buf)
+{
+        int i, eccsize = chip->ecc.size;
+        int eccbytes = chip->ecc.bytes;
+        int eccsteps = chip->ecc.steps;
+        const uint8_t *p = buf;
+        uint8_t *oob = chip->oob_poi;
 
-        /* if oobsel is NULL, use chip defaults */
-        if (oobsel == NULL)
-                oobsel = &mtd->oobinfo;
+        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
 
-        /* Autoplace of oob data ? Use the default placement scheme */
-        if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
-                oobsel = this->autooob;
-                autoplace = 1;
-        }
-        if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
-                autoplace = 1;
+                chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
+                chip->write_buf(mtd, p, eccsize);
 
-        /* Setup variables and oob buffer */
-        totalpages = len >> this->page_shift;
-        page = (int) (to >> this->page_shift);
-        /* Invalidate the page cache, if we write to the cached page */
-        if (page <= this->pagebuf && this->pagebuf < (page + totalpages))
-                this->pagebuf = -1;
-
-        /* Set it relative to chip */
-        page &= this->pagemask;
-        startpage = page;
-        /* Calc number of pages we can write in one go */
-        numpages = min (ppblock - (startpage  & (ppblock - 1)), totalpages);
-        oobbuf = nand_prepare_oobbuf (mtd, eccbuf, oobsel, autoplace, numpages);
-        bufstart = (u_char *)buf;
-
-        /* Loop until all data is written */
-        while (written < len) {
-
-                this->data_poi = (u_char*) &buf[written];
-                /* Write one page. If this is the last page to write
-                 * or the last page in this block, then use the
-                 * real pageprogram command, else select cached programming
-                 * if supported by the chip.
-                 */
-                ret = nand_write_page (mtd, this, page, &oobbuf[oob], oobsel, (--numpages > 0));
-                if (ret) {
-                        DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: write_page failed %d\n", ret);
-                        goto out;
+                if (chip->ecc.prepad) {
+                        chip->write_buf(mtd, oob, chip->ecc.prepad);
+                        oob += chip->ecc.prepad;
                 }
-                /* Next oob page */
-                oob += mtd->oobsize;
-                /* Update written bytes count */
-                written += mtd->oobblock;
-                if (written == len)
-                        goto cmp;
 
-                /* Increment page address */
-                page++;
-
-                /* Have we hit a block boundary ? Then we have to verify and
-                 * if verify is ok, we have to setup the oob buffer for
-                 * the next pages.
-                */
-                if (!(page & (ppblock - 1))){
-                        int ofs;
-                        this->data_poi = bufstart;
-                        ret = nand_verify_pages (mtd, this, startpage,
-                                page - startpage,
-                                oobbuf, oobsel, chipnr, (eccbuf != NULL));
-                        if (ret) {
-                                DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
-                                goto out;
-                        }
-                        *retlen = written;
-
-                        ofs = autoplace ? mtd->oobavail : mtd->oobsize;
-                        if (eccbuf)
-                                eccbuf += (page - startpage) * ofs;
-                        totalpages -= page - startpage;
-                        numpages = min (totalpages, ppblock);
-                        page &= this->pagemask;
-                        startpage = page;
-                        oobbuf = nand_prepare_oobbuf (mtd, eccbuf, oobsel,
-                                        autoplace, numpages);
-                        oob = 0;
-                        /* Check, if we cross a chip boundary */
-                        if (!page) {
-                                chipnr++;
-                                this->select_chip(mtd, -1);
-                                this->select_chip(mtd, chipnr);
-                        }
+                chip->ecc.calculate(mtd, p, oob);
+                chip->write_buf(mtd, oob, eccbytes);
+                oob += eccbytes;
+
+                if (chip->ecc.postpad) {
+                        chip->write_buf(mtd, oob, chip->ecc.postpad);
+                        oob += chip->ecc.postpad;
                 }
         }
-        /* Verify the remaining pages */
-cmp:
-        this->data_poi = bufstart;
-        ret = nand_verify_pages (mtd, this, startpage, totalpages,
-                oobbuf, oobsel, chipnr, (eccbuf != NULL));
-        if (!ret)
-                *retlen = written;
-        else
-                DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
 
-out:
-        /* Deselect and wake up anyone waiting on the device */
-        nand_release_device(mtd);
-
-        return ret;
+        /* Calculate remaining oob bytes */
+        i = mtd->oobsize - (oob - chip->oob_poi);
+        if (i)
+                chip->write_buf(mtd, oob, i);
 }
 
-
 /**
- * nand_write_oob - [MTD Interface] NAND write out-of-band
+ * nand_write_page - [INTERNAL] write one page
  * @mtd:        MTD device structure
- * @to:         offset to write to
- * @len:        number of bytes to write
- * @retlen:     pointer to variable to store the number of written bytes
+ * @chip:       NAND chip descriptor
  * @buf:        the data to write
- *
- * NAND write out-of-band
+ * @page:       page number to write
+ * @cached:     cached programming
  */
-static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf)
+static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
+                           const uint8_t *buf, int page, int cached)
 {
-        int column, page, status, ret = -EIO, chipnr;
-        struct nand_chip *this = mtd->priv;
+        int status;
 
-        DEBUG (MTD_DEBUG_LEVEL3, "nand_write_oob: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
+        chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
 
-        /* Shift to get page */
-        page = (int) (to >> this->page_shift);
-        chipnr = (int) (to >> this->chip_shift);
+        chip->ecc.write_page(mtd, chip, buf);
 
-        /* Mask to get column */
-        column = to & (mtd->oobsize - 1);
+        /*
+         * Cached progamming disabled for now, Not sure if its worth the
+         * trouble. The speed gain is not very impressive. (2.3->2.6Mib/s)
+         */
+        cached = 0;
 
-        /* Initialize return length value */
-        *retlen = 0;
+        if (!cached || !(chip->options & NAND_CACHEPRG)) {
 
-        /* Do not allow write past end of page */
-        if ((column + len) > mtd->oobsize) {
-                DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: Attempt to write past end of page\n");
-                return -EINVAL;
+                chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+                status = chip->waitfunc(mtd, chip);
+                /*
+                 * See if operation failed and additional status checks are
+                 * available
+                 */
+                if ((status & NAND_STATUS_FAIL) && (chip->errstat))
+                        status = chip->errstat(mtd, chip, FL_WRITING, status,
+                                               page);
+
+                if (status & NAND_STATUS_FAIL)
+                        return -EIO;
+        } else {
+                chip->cmdfunc(mtd, NAND_CMD_CACHEDPROG, -1, -1);
+                status = chip->waitfunc(mtd, chip);
         }
 
-        /* Grab the lock and see if the device is available */
-        nand_get_device (this, mtd, FL_WRITING);
+#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
+        /* Send command to read back the data */
+        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
 
-        /* Select the NAND device */
-        this->select_chip(mtd, chipnr);
+        if (chip->verify_buf(mtd, buf, mtd->writesize))
+                return -EIO;
+#endif
+        return 0;
+}
+
+/**
+ * nand_fill_oob - [Internal] Transfer client buffer to oob
+ * @chip:       nand chip structure
+ * @oob:        oob data buffer
+ * @ops:        oob ops structure
+ */
+static uint8_t *nand_fill_oob(struct nand_chip *chip, uint8_t *oob,
+                                  struct mtd_oob_ops *ops)
+{
+        size_t len = ops->ooblen;
+
+        switch(ops->mode) {
+
+        case MTD_OOB_PLACE:
+        case MTD_OOB_RAW:
+                memcpy(chip->oob_poi + ops->ooboffs, oob, len);
+                return oob + len;
+
+        case MTD_OOB_AUTO: {
+                struct nand_oobfree *free = chip->ecc.layout->oobfree;
+                uint32_t boffs = 0, woffs = ops->ooboffs;
+                size_t bytes = 0;
+
+                for(; free->length && len; free++, len -= bytes) {
+                        /* Write request not from offset 0 ? */
+                        if (unlikely(woffs)) {
+                                if (woffs >= free->length) {
+                                        woffs -= free->length;
+                                        continue;
+                                }
+                                boffs = free->offset + woffs;
+                                bytes = min_t(size_t, len,
+                                              (free->length - woffs));
+                                woffs = 0;
+                        } else {
+                                bytes = min_t(size_t, len, free->length);
+                                boffs = free->offset;
+                        }
+                        memcpy(chip->oob_poi + woffs, oob, bytes);
+                        oob += bytes;
+                }
+                return oob;
+        }
+        default:
+                BUG();
+        }
+        return NULL;
+}
+
+#define NOTALIGNED(x) (x & (mtd->writesize-1)) != 0
+
+/**
+ * nand_do_write_ops - [Internal] NAND write with ECC
+ * @mtd:        MTD device structure
+ * @to:         offset to write to
+ * @ops:        oob operations description structure
+ *
+ * NAND write with ECC
+ */
+static int nand_do_write_ops(struct mtd_info *mtd, loff_t to,
+                             struct mtd_oob_ops *ops)
+{
+        int chipnr, realpage, page, blockmask;
+        struct nand_chip *chip = mtd->priv;
+        uint32_t writelen = ops->len;
+        uint8_t *oob = ops->oobbuf;
+        uint8_t *buf = ops->datbuf;
+        int bytes = mtd->writesize;
+        int ret;
 
-        /* Reset the chip. Some chips (like the Toshiba TC5832DC found
-           in one of my DiskOnChip 2000 test units) will clear the whole
-           data page too if we don't do this. I have no clue why, but
-           I seem to have 'fixed' it in the doc2000 driver in
-           August 1999.  dwmw2. */
-        this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
+        ops->retlen = 0;
+
+        /* reject writes, which are not page aligned */
+        if (NOTALIGNED(to) || NOTALIGNED(ops->len)) {
+                printk(KERN_NOTICE "nand_write: "
+                       "Attempt to write not page aligned data\n");
+                return -EINVAL;
+        }
+
+        if (!writelen)
+                return 0;
 
         /* Check, if it is write protected */
         if (nand_check_wp(mtd))
-                goto out;
+                return -EIO;
 
-        /* Invalidate the page cache, if we write to the cached page */
-        if (page == this->pagebuf)
-                this->pagebuf = -1;
-
-        if (NAND_MUST_PAD(this)) {
-                /* Write out desired data */
-                this->cmdfunc (mtd, NAND_CMD_SEQIN, mtd->oobblock, page & this->pagemask);
-                /* prepad 0xff for partial programming */
-                this->write_buf(mtd, ffchars, column);
-                /* write data */
-                this->write_buf(mtd, buf, len);
-                /* postpad 0xff for partial programming */
-                this->write_buf(mtd, ffchars, mtd->oobsize - (len+column));
-        } else {
-                /* Write out desired data */
-                this->cmdfunc (mtd, NAND_CMD_SEQIN, mtd->oobblock + column, page & this->pagemask);
-                /* write data */
-                this->write_buf(mtd, buf, len);
-        }
-        /* Send command to program the OOB data */
-        this->cmdfunc (mtd, NAND_CMD_PAGEPROG, -1, -1);
+        chipnr = (int)(to >> chip->chip_shift);
+        chip->select_chip(mtd, chipnr);
 
-        status = this->waitfunc (mtd, this, FL_WRITING);
+        realpage = (int)(to >> chip->page_shift);
+        page = realpage & chip->pagemask;
+        blockmask = (1 << (chip->phys_erase_shift - chip->page_shift)) - 1;
 
-        /* See if device thinks it succeeded */
-        if (status & NAND_STATUS_FAIL) {
-                DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write, page 0x%08x\n", page);
-                ret = -EIO;
-                goto out;
-        }
-        /* Return happy */
-        *retlen = len;
+        /* Invalidate the page cache, when we write to the cached page */
+        if (to <= (chip->pagebuf << chip->page_shift) &&
+            (chip->pagebuf << chip->page_shift) < (to + ops->len))
+                chip->pagebuf = -1;
 
-#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
-        /* Send command to read back the data */
-        this->cmdfunc (mtd, NAND_CMD_READOOB, column, page & this->pagemask);
+        chip->oob_poi = chip->buffers.oobwbuf;
 
-        if (this->verify_buf(mtd, buf, len)) {
-                DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write verify, page 0x%08x\n", page);
-                ret = -EIO;
-                goto out;
+        while(1) {
+                int cached = writelen > bytes && page != blockmask;
+
+                if (unlikely(oob))
+                        oob = nand_fill_oob(chip, oob, ops);
+
+                ret = nand_write_page(mtd, chip, buf, page, cached);
+                if (ret)
+                        break;
+
+                writelen -= bytes;
+                if (!writelen)
+                        break;
+
+                buf += bytes;
+                realpage++;
+
+                page = realpage & chip->pagemask;
+                /* Check, if we cross a chip boundary */
+                if (!page) {
+                        chipnr++;
+                        chip->select_chip(mtd, -1);
+                        chip->select_chip(mtd, chipnr);
+                }
         }
-#endif
-        ret = 0;
-out:
-        /* Deselect and wake up anyone waiting on the device */
-        nand_release_device(mtd);
 
+        if (unlikely(oob))
+                memset(chip->oob_poi, 0xff, mtd->oobsize);
+
+        ops->retlen = ops->len - writelen;
         return ret;
 }
 
-
 /**
- * nand_writev - [MTD Interface] compabilty function for nand_writev_ecc
+ * nand_write - [MTD Interface] NAND write with ECC
  * @mtd:        MTD device structure
- * @vecs:       the iovectors to write
- * @count:      number of vectors
  * @to:         offset to write to
+ * @len:        number of bytes to write
  * @retlen:     pointer to variable to store the number of written bytes
+ * @buf:        the data to write
  *
- * NAND write with kvec. This just calls the ecc function
+ * NAND write with ECC
  */
-static int nand_writev (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,
-                loff_t to, size_t * retlen)
+static int nand_write(struct mtd_info *mtd, loff_t to, size_t len,
+                          size_t *retlen, const uint8_t *buf)
 {
-        return (nand_writev_ecc (mtd, vecs, count, to, retlen, NULL, NULL));
+        struct nand_chip *chip = mtd->priv;
+        int ret;
+
+        /* Do not allow reads past end of device */
+        if ((to + len) > mtd->size)
+                return -EINVAL;
+        if (!len)
+                return 0;
+
+        nand_get_device(chip, mtd, FL_WRITING);
+
+        chip->ops.len = len;
+        chip->ops.datbuf = (uint8_t *)buf;
+        chip->ops.oobbuf = NULL;
+
+        ret = nand_do_write_ops(mtd, to, &chip->ops);
+
+        nand_release_device(mtd);
+
+        *retlen = chip->ops.retlen;
+        return ret;
 }
 
 /**
- * nand_writev_ecc - [MTD Interface] write with iovec with ecc
+ * nand_do_write_oob - [MTD Interface] NAND write out-of-band
  * @mtd:        MTD device structure
- * @vecs:       the iovectors to write
- * @count:      number of vectors
  * @to:         offset to write to
- * @retlen:     pointer to variable to store the number of written bytes
- * @eccbuf:     filesystem supplied oob data buffer
- * @oobsel:     oob selection structure
+ * @ops:        oob operation description structure
  *
- * NAND write with iovec with ecc
+ * NAND write out-of-band
  */
-static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,
-                loff_t to, size_t * retlen, u_char *eccbuf, struct nand_oobinfo *oobsel)
+static int nand_do_write_oob(struct mtd_info *mtd, loff_t to,
+                             struct mtd_oob_ops *ops)
 {
-        int i, page, len, total_len, ret = -EIO, written = 0, chipnr;
-        int oob, numpages, autoplace = 0, startpage;
-        struct nand_chip *this = mtd->priv;
-        int     ppblock = (1 << (this->phys_erase_shift - this->page_shift));
-        u_char *oobbuf, *bufstart;
-
-        /* Preset written len for early exit */
-        *retlen = 0;
-
-        /* Calculate total length of data */
-        total_len = 0;
-        for (i = 0; i < count; i++)
-                total_len += (int) vecs[i].iov_len;
+        int chipnr, page, status;
+        struct nand_chip *chip = mtd->priv;
 
-        DEBUG (MTD_DEBUG_LEVEL3,
-               "nand_writev: to = 0x%08x, len = %i, count = %ld\n", (unsigned int) to, (unsigned int) total_len, count);
+        DEBUG(MTD_DEBUG_LEVEL3, "nand_write_oob: to = 0x%08x, len = %i\n",
+              (unsigned int)to, (int)ops->len);
 
         /* Do not allow write past end of page */
-        if ((to + total_len) > mtd->size) {
-                DEBUG (MTD_DEBUG_LEVEL0, "nand_writev: Attempted write past end of device\n");
+        if ((ops->ooboffs + ops->len) > mtd->oobsize) {
+                DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: "
+                      "Attempt to write past end of page\n");
                 return -EINVAL;
         }
 
-        /* reject writes, which are not page aligned */
-        if (NOTALIGNED (to) || NOTALIGNED(total_len)) {
-                printk (KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");
-                return -EINVAL;
-        }
+        chipnr = (int)(to >> chip->chip_shift);
+        chip->select_chip(mtd, chipnr);
 
-        /* Grab the lock and see if the device is available */
-        nand_get_device (this, mtd, FL_WRITING);
+        /* Shift to get page */
+        page = (int)(to >> chip->page_shift);
 
-        /* Get the current chip-nr */
-        chipnr = (int) (to >> this->chip_shift);
-        /* Select the NAND device */
-        this->select_chip(mtd, chipnr);
+        /*
+         * Reset the chip. Some chips (like the Toshiba TC5832DC found in one
+         * of my DiskOnChip 2000 test units) will clear the whole data page too
+         * if we don't do this. I have no clue why, but I seem to have 'fixed'
+         * it in the doc2000 driver in August 1999.  dwmw2.
+         */
+        chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
 
         /* Check, if it is write protected */
         if (nand_check_wp(mtd))
-                goto out;
+                return -EROFS;
 
-        /* if oobsel is NULL, use chip defaults */
-        if (oobsel == NULL)
-                oobsel = &mtd->oobinfo;
+        /* Invalidate the page cache, if we write to the cached page */
+        if (page == chip->pagebuf)
+                chip->pagebuf = -1;
 
-        /* Autoplace of oob data ? Use the default placement scheme */
-        if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
-                oobsel = this->autooob;
-                autoplace = 1;
-        }
-        if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
-                autoplace = 1;
+        chip->oob_poi = chip->buffers.oobwbuf;
+        memset(chip->oob_poi, 0xff, mtd->oobsize);
+        nand_fill_oob(chip, ops->oobbuf, ops);
+        status = chip->ecc.write_oob(mtd, chip, page & chip->pagemask);
+        memset(chip->oob_poi, 0xff, mtd->oobsize);
 
-        /* Setup start page */
-        page = (int) (to >> this->page_shift);
-        /* Invalidate the page cache, if we write to the cached page */
-        if (page <= this->pagebuf && this->pagebuf < ((to + total_len) >> this->page_shift))
-                this->pagebuf = -1;
+        if (status)
+                return status;
 
-        startpage = page & this->pagemask;
+        ops->retlen = ops->len;
 
-        /* Loop until all kvec' data has been written */
-        len = 0;
-        while (count) {
-                /* If the given tuple is >= pagesize then
-                 * write it out from the iov
-                 */
-                if ((vecs->iov_len - len) >= mtd->oobblock) {
-                        /* Calc number of pages we can write
-                         * out of this iov in one go */
-                        numpages = (vecs->iov_len - len) >> this->page_shift;
-                        /* Do not cross block boundaries */
-                        numpages = min (ppblock - (startpage & (ppblock - 1)), numpages);
-                        oobbuf = nand_prepare_oobbuf (mtd, NULL, oobsel, autoplace, numpages);
-                        bufstart = (u_char *)vecs->iov_base;
-                        bufstart += len;
-                        this->data_poi = bufstart;
-                        oob = 0;
-                        for (i = 1; i <= numpages; i++) {
-                                /* Write one page. If this is the last page to write
-                                 * then use the real pageprogram command, else select
-                                 * cached programming if supported by the chip.
-                                 */
-                                ret = nand_write_page (mtd, this, page & this->pagemask,
-                                        &oobbuf[oob], oobsel, i != numpages);
-                                if (ret)
-                                        goto out;
-                                this->data_poi += mtd->oobblock;
-                                len += mtd->oobblock;
-                                oob += mtd->oobsize;
-                                page++;
-                        }
-                        /* Check, if we have to switch to the next tuple */
-                        if (len >= (int) vecs->iov_len) {
-                                vecs++;
-                                len = 0;
-                                count--;
-                        }
-                } else {
-                        /* We must use the internal buffer, read data out of each
-                         * tuple until we have a full page to write
-                         */
-                        int cnt = 0;
-                        while (cnt < mtd->oobblock) {
-                                if (vecs->iov_base != NULL && vecs->iov_len)
-                                        this->data_buf[cnt++] = ((u_char *) vecs->iov_base)[len++];
-                                /* Check, if we have to switch to the next tuple */
-                                if (len >= (int) vecs->iov_len) {
-                                        vecs++;
-                                        len = 0;
-                                        count--;
-                                }
-                        }
-                        this->pagebuf = page;
-                        this->data_poi = this->data_buf;
-                        bufstart = this->data_poi;
-                        numpages = 1;
-                        oobbuf = nand_prepare_oobbuf (mtd, NULL, oobsel, autoplace, numpages);
-                        ret = nand_write_page (mtd, this, page & this->pagemask,
-                                oobbuf, oobsel, 0);
-                        if (ret)
-                                goto out;
-                        page++;
-                }
+        return 0;
+}
 
-                this->data_poi = bufstart;
-                ret = nand_verify_pages (mtd, this, startpage, numpages, oobbuf, oobsel, chipnr, 0);
-                if (ret)
-                        goto out;
+/**
+ * nand_write_oob - [MTD Interface] NAND write data and/or out-of-band
+ * @mtd:        MTD device structure
+ * @from:       offset to read from
+ * @ops:        oob operation description structure
+ */
+static int nand_write_oob(struct mtd_info *mtd, loff_t to,
+                          struct mtd_oob_ops *ops)
+{
+        void (*write_page)(struct mtd_info *mtd, struct nand_chip *chip,
+                          const uint8_t *buf) = NULL;
+        struct nand_chip *chip = mtd->priv;
+        int ret = -ENOTSUPP;
 
-                written += mtd->oobblock * numpages;
-                /* All done ? */
-                if (!count)
-                        break;
+        ops->retlen = 0;
 
-                startpage = page & this->pagemask;
-                /* Check, if we cross a chip boundary */
-                if (!startpage) {
-                        chipnr++;
-                        this->select_chip(mtd, -1);
-                        this->select_chip(mtd, chipnr);
-                }
+        /* Do not allow writes past end of device */
+        if ((to + ops->len) > mtd->size) {
+                DEBUG(MTD_DEBUG_LEVEL0, "nand_read_oob: "
+                      "Attempt read beyond end of device\n");
+                return -EINVAL;
         }
-        ret = 0;
-out:
-        /* Deselect and wake up anyone waiting on the device */
-        nand_release_device(mtd);
 
-        *retlen = written;
+        nand_get_device(chip, mtd, FL_WRITING);
+
+        switch(ops->mode) {
+        case MTD_OOB_PLACE:
+        case MTD_OOB_AUTO:
+                break;
+
+        case MTD_OOB_RAW:
+                /* Replace the write_page algorithm temporary */
+                write_page = chip->ecc.write_page;
+                chip->ecc.write_page = nand_write_page_raw;
+                break;
+
+        default:
+                goto out;
+        }
+
+        if (!ops->datbuf)
+                ret = nand_do_write_oob(mtd, to, ops);
+        else
+                ret = nand_do_write_ops(mtd, to, ops);
+
+        if (unlikely(ops->mode == MTD_OOB_RAW))
+                chip->ecc.write_page = write_page;
+ out:
+        nand_release_device(mtd);
         return ret;
 }
 
@@ -2050,12 +1816,12 @@ out:
  *
  * Standard erase command for NAND chips
  */
-static void single_erase_cmd (struct mtd_info *mtd, int page)
+static void single_erase_cmd(struct mtd_info *mtd, int page)
 {
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
         /* Send commands to erase a block */
-        this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page);
-        this->cmdfunc (mtd, NAND_CMD_ERASE2, -1, -1);
+        chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
+        chip->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
 }
 
 /**
@@ -2066,15 +1832,15 @@ static void single_erase_cmd (struct mtd_info *mtd, int page)
  * AND multi block erase command function
  * Erase 4 consecutive blocks
  */
-static void multi_erase_cmd (struct mtd_info *mtd, int page)
+static void multi_erase_cmd(struct mtd_info *mtd, int page)
 {
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
         /* Send commands to erase a block */
-        this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);
-        this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);
-        this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);
-        this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page);
-        this->cmdfunc (mtd, NAND_CMD_ERASE2, -1, -1);
+        chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
+        chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
+        chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
+        chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
+        chip->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
 }
 
 /**
@@ -2084,79 +1850,82 @@ static void multi_erase_cmd (struct mtd_info *mtd, int page)
  *
  * Erase one ore more blocks
  */
-static int nand_erase (struct mtd_info *mtd, struct erase_info *instr)
+static int nand_erase(struct mtd_info *mtd, struct erase_info *instr)
 {
-        return nand_erase_nand (mtd, instr, 0);
+        return nand_erase_nand(mtd, instr, 0);
 }
 
 #define BBT_PAGE_MASK   0xffffff3f
 /**
- * nand_erase_intern - [NAND Interface] erase block(s)
+ * nand_erase_nand - [Internal] erase block(s)
  * @mtd:        MTD device structure
  * @instr:      erase instruction
  * @allowbbt:   allow erasing the bbt area
  *
  * Erase one ore more blocks
  */
-int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbbt)
+int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr,
+                    int allowbbt)
 {
         int page, len, status, pages_per_block, ret, chipnr;
-        struct nand_chip *this = mtd->priv;
-        int rewrite_bbt[NAND_MAX_CHIPS]={0};    /* flags to indicate the page, if bbt needs to be rewritten. */
-        unsigned int bbt_masked_page;           /* bbt mask to compare to page being erased. */
-                                                /* It is used to see if the current page is in the same */
-                                                /*   256 block group and the same bank as the bbt. */
+        struct nand_chip *chip = mtd->priv;
+        int rewrite_bbt[NAND_MAX_CHIPS]={0};
+        unsigned int bbt_masked_page = 0xffffffff;
 
-        DEBUG (MTD_DEBUG_LEVEL3,
-               "nand_erase: start = 0x%08x, len = %i\n", (unsigned int) instr->addr, (unsigned int) instr->len);
+        DEBUG(MTD_DEBUG_LEVEL3, "nand_erase: start = 0x%08x, len = %i\n",
+              (unsigned int)instr->addr, (unsigned int)instr->len);
 
         /* Start address must align on block boundary */
-        if (instr->addr & ((1 << this->phys_erase_shift) - 1)) {
-                DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Unaligned address\n");
+        if (instr->addr & ((1 << chip->phys_erase_shift) - 1)) {
+                DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Unaligned address\n");
                 return -EINVAL;
         }
 
         /* Length must align on block boundary */
-        if (instr->len & ((1 << this->phys_erase_shift) - 1)) {
-                DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Length not block aligned\n");
+        if (instr->len & ((1 << chip->phys_erase_shift) - 1)) {
+                DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: "
+                      "Length not block aligned\n");
                 return -EINVAL;
         }
 
         /* Do not allow erase past end of device */
         if ((instr->len + instr->addr) > mtd->size) {
-                DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Erase past end of device\n");
+                DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: "
+                      "Erase past end of device\n");
                 return -EINVAL;
         }
 
         instr->fail_addr = 0xffffffff;
 
         /* Grab the lock and see if the device is available */
-        nand_get_device (this, mtd, FL_ERASING);
+        nand_get_device(chip, mtd, FL_ERASING);
 
         /* Shift to get first page */
-        page = (int) (instr->addr >> this->page_shift);
-        chipnr = (int) (instr->addr >> this->chip_shift);
+        page = (int)(instr->addr >> chip->page_shift);
+        chipnr = (int)(instr->addr >> chip->chip_shift);
 
         /* Calculate pages in each block */
-        pages_per_block = 1 << (this->phys_erase_shift - this->page_shift);
+        pages_per_block = 1 << (chip->phys_erase_shift - chip->page_shift);
 
         /* Select the NAND device */
-        this->select_chip(mtd, chipnr);
+        chip->select_chip(mtd, chipnr);
 
-        /* Check the WP bit */
         /* Check, if it is write protected */
         if (nand_check_wp(mtd)) {
-                DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Device is write protected!!!\n");
+                DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: "
+                      "Device is write protected!!!\n");
                 instr->state = MTD_ERASE_FAILED;
                 goto erase_exit;
         }
 
-        /* if BBT requires refresh, set the BBT page mask to see if the BBT should be rewritten */
-        if (this->options & BBT_AUTO_REFRESH) {
-                bbt_masked_page = this->bbt_td->pages[chipnr] & BBT_PAGE_MASK;
-        } else {
-                bbt_masked_page = 0xffffffff;   /* should not match anything */
-        }
+        /*
+         * If BBT requires refresh, set the BBT page mask to see if the BBT
+         * should be rewritten. Otherwise the mask is set to 0xffffffff which
+         * can not be matched. This is also done when the bbt is actually
+         * erased to avoid recusrsive updates
+         */
+        if (chip->options & BBT_AUTO_REFRESH && !allowbbt)
+                bbt_masked_page = chip->bbt_td->pages[chipnr] & BBT_PAGE_MASK;
 
         /* Loop through the pages */
         len = instr->len;
@@ -2164,64 +1933,77 @@ int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbb
         instr->state = MTD_ERASING;
 
         while (len) {
-                /* Check if we have a bad block, we do not erase bad blocks ! */
-                if (nand_block_checkbad(mtd, ((loff_t) page) << this->page_shift, 0, allowbbt)) {
-                        printk (KERN_WARNING "nand_erase: attempt to erase a bad block at page 0x%08x\n", page);
+                /*
+                 * heck if we have a bad block, we do not erase bad blocks !
+                 */
+                if (nand_block_checkbad(mtd, ((loff_t) page) <<
+                                        chip->page_shift, 0, allowbbt)) {
+                        printk(KERN_WARNING "nand_erase: attempt to erase a "
+                               "bad block at page 0x%08x\n", page);
                         instr->state = MTD_ERASE_FAILED;
                         goto erase_exit;
                 }
 
-                /* Invalidate the page cache, if we erase the block which contains
-                   the current cached page */
-                if (page <= this->pagebuf && this->pagebuf < (page + pages_per_block))
-                        this->pagebuf = -1;
+                /*
+                 * Invalidate the page cache, if we erase the block which
+                 * contains the current cached page
+                 */
+                if (page <= chip->pagebuf && chip->pagebuf <
+                    (page + pages_per_block))
+                        chip->pagebuf = -1;
 
-                this->erase_cmd (mtd, page & this->pagemask);
+                chip->erase_cmd(mtd, page & chip->pagemask);
 
-                status = this->waitfunc (mtd, this, FL_ERASING);
+                status = chip->waitfunc(mtd, chip);
 
-                /* See if operation failed and additional status checks are available */
-                if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
-                        status = this->errstat(mtd, this, FL_ERASING, status, page);
-                }
+                /*
+                 * See if operation failed and additional status checks are
+                 * available
+                 */
+                if ((status & NAND_STATUS_FAIL) && (chip->errstat))
+                        status = chip->errstat(mtd, chip, FL_ERASING,
+                                               status, page);
 
                 /* See if block erase succeeded */
                 if (status & NAND_STATUS_FAIL) {
-                        DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: " "Failed erase, page 0x%08x\n", page);
+                        DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: "
+                              "Failed erase, page 0x%08x\n", page);
                         instr->state = MTD_ERASE_FAILED;
-                        instr->fail_addr = (page << this->page_shift);
+                        instr->fail_addr = (page << chip->page_shift);
                         goto erase_exit;
                 }
 
-                /* if BBT requires refresh, set the BBT rewrite flag to the page being erased */
-                if (this->options & BBT_AUTO_REFRESH) {
-                        if (((page & BBT_PAGE_MASK) == bbt_masked_page) &&
-                             (page != this->bbt_td->pages[chipnr])) {
-                                rewrite_bbt[chipnr] = (page << this->page_shift);
-                        }
-                }
+                /*
+                 * If BBT requires refresh, set the BBT rewrite flag to the
+                 * page being erased
+                 */
+                if (bbt_masked_page != 0xffffffff &&
+                    (page & BBT_PAGE_MASK) == bbt_masked_page)
+                            rewrite_bbt[chipnr] = (page << chip->page_shift);
 
                 /* Increment page address and decrement length */
-                len -= (1 << this->phys_erase_shift);
+                len -= (1 << chip->phys_erase_shift);
                 page += pages_per_block;
 
                 /* Check, if we cross a chip boundary */
-                if (len && !(page & this->pagemask)) {
+                if (len && !(page & chip->pagemask)) {
                         chipnr++;
-                        this->select_chip(mtd, -1);
-                        this->select_chip(mtd, chipnr);
-
-                        /* if BBT requires refresh and BBT-PERCHIP,
-                         *   set the BBT page mask to see if this BBT should be rewritten */
-                        if ((this->options & BBT_AUTO_REFRESH) && (this->bbt_td->options & NAND_BBT_PERCHIP)) {
-                                bbt_masked_page = this->bbt_td->pages[chipnr] & BBT_PAGE_MASK;
-                        }
+                        chip->select_chip(mtd, -1);
+                        chip->select_chip(mtd, chipnr);
 
+                        /*
+                         * If BBT requires refresh and BBT-PERCHIP, set the BBT
+                         * page mask to see if this BBT should be rewritten
+                         */
+                        if (bbt_masked_page != 0xffffffff &&
+                            (chip->bbt_td->options & NAND_BBT_PERCHIP))
+                                bbt_masked_page = chip->bbt_td->pages[chipnr] &
+                                        BBT_PAGE_MASK;
                 }
         }
         instr->state = MTD_ERASE_DONE;
 
-erase_exit:
+ erase_exit:
 
         ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
         /* Do call back function */
@@ -2231,16 +2013,21 @@ erase_exit:
         /* Deselect and wake up anyone waiting on the device */
         nand_release_device(mtd);
 
-        /* if BBT requires refresh and erase was successful, rewrite any selected bad block tables */
-        if ((this->options & BBT_AUTO_REFRESH) && (!ret)) {
-                for (chipnr = 0; chipnr < this->numchips; chipnr++) {
-                        if (rewrite_bbt[chipnr]) {
-                                /* update the BBT for chip */
-                                DEBUG (MTD_DEBUG_LEVEL0, "nand_erase_nand: nand_update_bbt (%d:0x%0x 0x%0x)\n",
-                                        chipnr, rewrite_bbt[chipnr], this->bbt_td->pages[chipnr]);
-                                nand_update_bbt (mtd, rewrite_bbt[chipnr]);
-                        }
-                }
+        /*
+         * If BBT requires refresh and erase was successful, rewrite any
+         * selected bad block tables
+         */
+        if (bbt_masked_page == 0xffffffff || ret)
+                return ret;
+
+        for (chipnr = 0; chipnr < chip->numchips; chipnr++) {
+                if (!rewrite_bbt[chipnr])
+                        continue;
+                /* update the BBT for chip */
+                DEBUG(MTD_DEBUG_LEVEL0, "nand_erase_nand: nand_update_bbt "
+                      "(%d:0x%0x 0x%0x)\n", chipnr, rewrite_bbt[chipnr],
+                      chip->bbt_td->pages[chipnr]);
+                nand_update_bbt(mtd, rewrite_bbt[chipnr]);
         }
 
         /* Return more or less happy */
@@ -2253,51 +2040,50 @@ erase_exit:
  *
  * Sync is actually a wait for chip ready function
  */
-static void nand_sync (struct mtd_info *mtd)
+static void nand_sync(struct mtd_info *mtd)
 {
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
 
-        DEBUG (MTD_DEBUG_LEVEL3, "nand_sync: called\n");
+        DEBUG(MTD_DEBUG_LEVEL3, "nand_sync: called\n");
 
         /* Grab the lock and see if the device is available */
-        nand_get_device (this, mtd, FL_SYNCING);
+        nand_get_device(chip, mtd, FL_SYNCING);
         /* Release it and go back */
-        nand_release_device (mtd);
+        nand_release_device(mtd);
 }
 
-
 /**
- * nand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad
+ * nand_block_isbad - [MTD Interface] Check if block at offset is bad
  * @mtd:        MTD device structure
  * @ofs:        offset relative to mtd start
  */
-static int nand_block_isbad (struct mtd_info *mtd, loff_t ofs)
+static int nand_block_isbad(struct mtd_info *mtd, loff_t offs)
 {
         /* Check for invalid offset */
-        if (ofs > mtd->size)
+        if (offs > mtd->size)
                 return -EINVAL;
 
-        return nand_block_checkbad (mtd, ofs, 1, 0);
+        return nand_block_checkbad(mtd, offs, 1, 0);
 }
 
 /**
- * nand_block_markbad - [MTD Interface] Mark the block at the given offset as bad
+ * nand_block_markbad - [MTD Interface] Mark block at the given offset as bad
  * @mtd:        MTD device structure
  * @ofs:        offset relative to mtd start
  */
-static int nand_block_markbad (struct mtd_info *mtd, loff_t ofs)
+static int nand_block_markbad(struct mtd_info *mtd, loff_t ofs)
 {
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
         int ret;
 
-        if ((ret = nand_block_isbad(mtd, ofs))) {
-                /* If it was bad already, return success and do nothing. */
+        if ((ret = nand_block_isbad(mtd, ofs))) {
+                /* If it was bad already, return success and do nothing. */
                 if (ret > 0)
                         return 0;
-                return ret;
-        }
+                return ret;
+        }
 
-        return this->block_markbad(mtd, ofs);
+        return chip->block_markbad(mtd, ofs);
 }
 
 /**
@@ -2306,9 +2092,9 @@ static int nand_block_markbad (struct mtd_info *mtd, loff_t ofs)
  */
 static int nand_suspend(struct mtd_info *mtd)
 {
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
 
-        return nand_get_device (this, mtd, FL_PM_SUSPENDED);
+        return nand_get_device(chip, mtd, FL_PM_SUSPENDED);
 }
 
 /**
@@ -2317,373 +2103,385 @@ static int nand_suspend(struct mtd_info *mtd)
  */
 static void nand_resume(struct mtd_info *mtd)
 {
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
 
-        if (this->state == FL_PM_SUSPENDED)
+        if (chip->state == FL_PM_SUSPENDED)
                 nand_release_device(mtd);
         else
-                printk(KERN_ERR "resume() called for the chip which is not "
-                                "in suspended state\n");
-
+                printk(KERN_ERR "nand_resume() called for a chip which is not "
+                       "in suspended state\n");
 }
 
-
-/**
- * nand_scan - [NAND Interface] Scan for the NAND device
- * @mtd:        MTD device structure
- * @maxchips:   Number of chips to scan for
- *
- * This fills out all the not initialized function pointers
- * with the defaults.
- * The flash ID is read and the mtd/chip structures are
- * filled with the appropriate values. Buffers are allocated if
- * they are not provided by the board driver
- *
+/*
+ * Set default functions
  */
-int nand_scan (struct mtd_info *mtd, int maxchips)
+static void nand_set_defaults(struct nand_chip *chip, int busw)
 {
-        int i, nand_maf_id, nand_dev_id, busw, maf_id;
-        struct nand_chip *this = mtd->priv;
-
-        /* Get buswidth to select the correct functions*/
-        busw = this->options & NAND_BUSWIDTH_16;
-
         /* check for proper chip_delay setup, set 20us if not */
-        if (!this->chip_delay)
-                this->chip_delay = 20;
+        if (!chip->chip_delay)
+                chip->chip_delay = 20;
 
         /* check, if a user supplied command function given */
-        if (this->cmdfunc == NULL)
-                this->cmdfunc = nand_command;
+        if (chip->cmdfunc == NULL)
+                chip->cmdfunc = nand_command;
 
         /* check, if a user supplied wait function given */
-        if (this->waitfunc == NULL)
-                this->waitfunc = nand_wait;
-
-        if (!this->select_chip)
-                this->select_chip = nand_select_chip;
-        if (!this->write_byte)
-                this->write_byte = busw ? nand_write_byte16 : nand_write_byte;
-        if (!this->read_byte)
-                this->read_byte = busw ? nand_read_byte16 : nand_read_byte;
-        if (!this->write_word)
-                this->write_word = nand_write_word;
-        if (!this->read_word)
-                this->read_word = nand_read_word;
-        if (!this->block_bad)
-                this->block_bad = nand_block_bad;
-        if (!this->block_markbad)
-                this->block_markbad = nand_default_block_markbad;
-        if (!this->write_buf)
-                this->write_buf = busw ? nand_write_buf16 : nand_write_buf;
-        if (!this->read_buf)
-                this->read_buf = busw ? nand_read_buf16 : nand_read_buf;
-        if (!this->verify_buf)
-                this->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
-        if (!this->scan_bbt)
-                this->scan_bbt = nand_default_bbt;
+        if (chip->waitfunc == NULL)
+                chip->waitfunc = nand_wait;
+
+        if (!chip->select_chip)
+                chip->select_chip = nand_select_chip;
+        if (!chip->read_byte)
+                chip->read_byte = busw ? nand_read_byte16 : nand_read_byte;
+        if (!chip->read_word)
+                chip->read_word = nand_read_word;
+        if (!chip->block_bad)
+                chip->block_bad = nand_block_bad;
+        if (!chip->block_markbad)
+                chip->block_markbad = nand_default_block_markbad;
+        if (!chip->write_buf)
+                chip->write_buf = busw ? nand_write_buf16 : nand_write_buf;
+        if (!chip->read_buf)
+                chip->read_buf = busw ? nand_read_buf16 : nand_read_buf;
+        if (!chip->verify_buf)
+                chip->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
+        if (!chip->scan_bbt)
+                chip->scan_bbt = nand_default_bbt;
+
+        if (!chip->controller) {
+                chip->controller = &chip->hwcontrol;
+                spin_lock_init(&chip->controller->lock);
+                init_waitqueue_head(&chip->controller->wq);
+        }
+
+}
+
+/*
+ * Get the flash and manufacturer id and lookup if the type is supported
+ */
+static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,
+                                                  struct nand_chip *chip,
+                                                  int busw, int *maf_id)
+{
+        struct nand_flash_dev *type = NULL;
+        int i, dev_id, maf_idx;
 
         /* Select the device */
-        this->select_chip(mtd, 0);
+        chip->select_chip(mtd, 0);
 
         /* Send the command for reading device ID */
-        this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1);
+        chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
 
         /* Read manufacturer and device IDs */
-        nand_maf_id = this->read_byte(mtd);
-        nand_dev_id = this->read_byte(mtd);
+        *maf_id = chip->read_byte(mtd);
+        dev_id = chip->read_byte(mtd);
 
-        /* Print and store flash device information */
+        /* Lookup the flash id */
         for (i = 0; nand_flash_ids[i].name != NULL; i++) {
+                if (dev_id == nand_flash_ids[i].id) {
+                        type =  &nand_flash_ids[i];
+                        break;
+                }
+        }
 
-                if (nand_dev_id != nand_flash_ids[i].id)
-                        continue;
+        if (!type)
+                return ERR_PTR(-ENODEV);
+
+        if (!mtd->name)
+                mtd->name = type->name;
+
+        chip->chipsize = type->chipsize << 20;
+
+        /* Newer devices have all the information in additional id bytes */
+        if (!type->pagesize) {
+                int extid;
+                /* The 3rd id byte contains non relevant data ATM */
+                extid = chip->read_byte(mtd);
+                /* The 4th id byte is the important one */
+                extid = chip->read_byte(mtd);
+                /* Calc pagesize */
+                mtd->writesize = 1024 << (extid & 0x3);
+                extid >>= 2;
+                /* Calc oobsize */
+                mtd->oobsize = (8 << (extid & 0x01)) * (mtd->writesize >> 9);
+                extid >>= 2;
+                /* Calc blocksize. Blocksize is multiples of 64KiB */
+                mtd->erasesize = (64 * 1024) << (extid & 0x03);
+                extid >>= 2;
+                /* Get buswidth information */
+                busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
 
-                if (!mtd->name) mtd->name = nand_flash_ids[i].name;
-                this->chipsize = nand_flash_ids[i].chipsize << 20;
-
-                /* New devices have all the information in additional id bytes */
-                if (!nand_flash_ids[i].pagesize) {
-                        int extid;
-                        /* The 3rd id byte contains non relevant data ATM */
-                        extid = this->read_byte(mtd);
-                        /* The 4th id byte is the important one */
-                        extid = this->read_byte(mtd);
-                        /* Calc pagesize */
-                        mtd->oobblock = 1024 << (extid & 0x3);
-                        extid >>= 2;
-                        /* Calc oobsize */
-                        mtd->oobsize = (8 << (extid & 0x01)) * (mtd->oobblock >> 9);
-                        extid >>= 2;
-                        /* Calc blocksize. Blocksize is multiples of 64KiB */
-                        mtd->erasesize = (64 * 1024)  << (extid & 0x03);
-                        extid >>= 2;
-                        /* Get buswidth information */
-                        busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
+        } else {
+                /*
+                 * Old devices have chip data hardcoded in the device id table
+                 */
+                mtd->erasesize = type->erasesize;
+                mtd->writesize = type->pagesize;
+                mtd->oobsize = mtd->writesize / 32;
+                busw = type->options & NAND_BUSWIDTH_16;
+        }
 
-                } else {
-                        /* Old devices have this data hardcoded in the
-                         * device id table */
-                        mtd->erasesize = nand_flash_ids[i].erasesize;
-                        mtd->oobblock = nand_flash_ids[i].pagesize;
-                        mtd->oobsize = mtd->oobblock / 32;
-                        busw = nand_flash_ids[i].options & NAND_BUSWIDTH_16;
-                }
+        /* Try to identify manufacturer */
+        for (maf_idx = 0; nand_manuf_ids[maf_idx].id != 0x0; maf_id++) {
+                if (nand_manuf_ids[maf_idx].id == *maf_id)
+                        break;
+        }
 
-                /* Try to identify manufacturer */
-                for (maf_id = 0; nand_manuf_ids[maf_id].id != 0x0; maf_id++) {
-                        if (nand_manuf_ids[maf_id].id == nand_maf_id)
-                                break;
-                }
+        /*
+         * Check, if buswidth is correct. Hardware drivers should set
+         * chip correct !
+         */
+        if (busw != (chip->options & NAND_BUSWIDTH_16)) {
+                printk(KERN_INFO "NAND device: Manufacturer ID:"
+                       " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id,
+                       dev_id, nand_manuf_ids[maf_idx].name, mtd->name);
+                printk(KERN_WARNING "NAND bus width %d instead %d bit\n",
+                       (chip->options & NAND_BUSWIDTH_16) ? 16 : 8,
+                       busw ? 16 : 8);
+                return ERR_PTR(-EINVAL);
+        }
 
-                /* Check, if buswidth is correct. Hardware drivers should set
-                 * this correct ! */
-                if (busw != (this->options & NAND_BUSWIDTH_16)) {
-                        printk (KERN_INFO "NAND device: Manufacturer ID:"
-                                " 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id,
-                                nand_manuf_ids[maf_id].name , mtd->name);
-                        printk (KERN_WARNING
-                                "NAND bus width %d instead %d bit\n",
-                                        (this->options & NAND_BUSWIDTH_16) ? 16 : 8,
-                                        busw ? 16 : 8);
-                        this->select_chip(mtd, -1);
-                        return 1;
-                }
+        /* Calculate the address shift from the page size */
+        chip->page_shift = ffs(mtd->writesize) - 1;
+        /* Convert chipsize to number of pages per chip -1. */
+        chip->pagemask = (chip->chipsize >> chip->page_shift) - 1;
 
-                /* Calculate the address shift from the page size */
-                this->page_shift = ffs(mtd->oobblock) - 1;
-                this->bbt_erase_shift = this->phys_erase_shift = ffs(mtd->erasesize) - 1;
-                this->chip_shift = ffs(this->chipsize) - 1;
-
-                /* Set the bad block position */
-                this->badblockpos = mtd->oobblock > 512 ?
-                        NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;
-
-                /* Get chip options, preserve non chip based options */
-                this->options &= ~NAND_CHIPOPTIONS_MSK;
-                this->options |= nand_flash_ids[i].options & NAND_CHIPOPTIONS_MSK;
-                /* Set this as a default. Board drivers can override it, if neccecary */
-                this->options |= NAND_NO_AUTOINCR;
-                /* Check if this is a not a samsung device. Do not clear the options
-                 * for chips which are not having an extended id.
-                 */
-                if (nand_maf_id != NAND_MFR_SAMSUNG && !nand_flash_ids[i].pagesize)
-                        this->options &= ~NAND_SAMSUNG_LP_OPTIONS;
+        chip->bbt_erase_shift = chip->phys_erase_shift =
+                ffs(mtd->erasesize) - 1;
+        chip->chip_shift = ffs(chip->chipsize) - 1;
 
-                /* Check for AND chips with 4 page planes */
-                if (this->options & NAND_4PAGE_ARRAY)
-                        this->erase_cmd = multi_erase_cmd;
-                else
-                        this->erase_cmd = single_erase_cmd;
+        /* Set the bad block position */
+        chip->badblockpos = mtd->writesize > 512 ?
+                NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;
 
-                /* Do not replace user supplied command function ! */
-                if (mtd->oobblock > 512 && this->cmdfunc == nand_command)
-                        this->cmdfunc = nand_command_lp;
+        /* Get chip options, preserve non chip based options */
+        chip->options &= ~NAND_CHIPOPTIONS_MSK;
+        chip->options |= type->options & NAND_CHIPOPTIONS_MSK;
 
-                printk (KERN_INFO "NAND device: Manufacturer ID:"
-                        " 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id,
-                        nand_manuf_ids[maf_id].name , nand_flash_ids[i].name);
-                break;
-        }
+        /*
+         * Set chip as a default. Board drivers can override it, if necessary
+         */
+        chip->options |= NAND_NO_AUTOINCR;
+
+        /* Check if chip is a not a samsung device. Do not clear the
+         * options for chips which are not having an extended id.
+         */
+        if (*maf_id != NAND_MFR_SAMSUNG && !type->pagesize)
+                chip->options &= ~NAND_SAMSUNG_LP_OPTIONS;
+
+        /* Check for AND chips with 4 page planes */
+        if (chip->options & NAND_4PAGE_ARRAY)
+                chip->erase_cmd = multi_erase_cmd;
+        else
+                chip->erase_cmd = single_erase_cmd;
+
+        /* Do not replace user supplied command function ! */
+        if (mtd->writesize > 512 && chip->cmdfunc == nand_command)
+                chip->cmdfunc = nand_command_lp;
+
+        printk(KERN_INFO "NAND device: Manufacturer ID:"
+               " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id, dev_id,
+               nand_manuf_ids[maf_idx].name, type->name);
+
+        return type;
+}
+
+/* module_text_address() isn't exported, and it's mostly a pointless
+   test if this is a module _anyway_ -- they'd have to try _really_ hard
+   to call us from in-kernel code if the core NAND support is modular. */
+#ifdef MODULE
+#define caller_is_module() (1)
+#else
+#define caller_is_module() \
+        module_text_address((unsigned long)__builtin_return_address(0))
+#endif
 
-        if (!nand_flash_ids[i].name) {
-                printk (KERN_WARNING "No NAND device found!!!\n");
-                this->select_chip(mtd, -1);
-                return 1;
+/**
+ * nand_scan - [NAND Interface] Scan for the NAND device
+ * @mtd:        MTD device structure
+ * @maxchips:   Number of chips to scan for
+ *
+ * This fills out all the uninitialized function pointers
+ * with the defaults.
+ * The flash ID is read and the mtd/chip structures are
+ * filled with the appropriate values.
+ * The mtd->owner field must be set to the module of the caller
+ *
+ */
+int nand_scan(struct mtd_info *mtd, int maxchips)
+{
+        int i, busw, nand_maf_id;
+        struct nand_chip *chip = mtd->priv;
+        struct nand_flash_dev *type;
+
+        /* Many callers got this wrong, so check for it for a while... */
+        if (!mtd->owner && caller_is_module()) {
+                printk(KERN_CRIT "nand_scan() called with NULL mtd->owner!\n");
+                BUG();
         }
 
-        for (i=1; i < maxchips; i++) {
-                this->select_chip(mtd, i);
+        /* Get buswidth to select the correct functions */
+        busw = chip->options & NAND_BUSWIDTH_16;
+        /* Set the default functions */
+        nand_set_defaults(chip, busw);
 
-                /* Send the command for reading device ID */
-                this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1);
+        /* Read the flash type */
+        type = nand_get_flash_type(mtd, chip, busw, &nand_maf_id);
+
+        if (IS_ERR(type)) {
+                printk(KERN_WARNING "No NAND device found!!!\n");
+                chip->select_chip(mtd, -1);
+                return PTR_ERR(type);
+        }
 
+        /* Check for a chip array */
+        for (i = 1; i < maxchips; i++) {
+                chip->select_chip(mtd, i);
+                /* Send the command for reading device ID */
+                chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
                 /* Read manufacturer and device IDs */
-                if (nand_maf_id != this->read_byte(mtd) ||
-                    nand_dev_id != this->read_byte(mtd))
+                if (nand_maf_id != chip->read_byte(mtd) ||
+                    type->id != chip->read_byte(mtd))
                         break;
         }
         if (i > 1)
                 printk(KERN_INFO "%d NAND chips detected\n", i);
 
-        /* Allocate buffers, if neccecary */
-        if (!this->oob_buf) {
-                size_t len;
-                len = mtd->oobsize << (this->phys_erase_shift - this->page_shift);
-                this->oob_buf = kmalloc (len, GFP_KERNEL);
-                if (!this->oob_buf) {
-                        printk (KERN_ERR "nand_scan(): Cannot allocate oob_buf\n");
-                        return -ENOMEM;
-                }
-                this->options |= NAND_OOBBUF_ALLOC;
-        }
+        /* Store the number of chips and calc total size for mtd */
+        chip->numchips = i;
+        mtd->size = i * chip->chipsize;
 
-        if (!this->data_buf) {
-                size_t len;
-                len = mtd->oobblock + mtd->oobsize;
-                this->data_buf = kmalloc (len, GFP_KERNEL);
-                if (!this->data_buf) {
-                        if (this->options & NAND_OOBBUF_ALLOC)
-                                kfree (this->oob_buf);
-                        printk (KERN_ERR "nand_scan(): Cannot allocate data_buf\n");
-                        return -ENOMEM;
-                }
-                this->options |= NAND_DATABUF_ALLOC;
-        }
+        /* Preset the internal oob write buffer */
+        memset(chip->buffers.oobwbuf, 0xff, mtd->oobsize);
 
-        /* Store the number of chips and calc total size for mtd */
-        this->numchips = i;
-        mtd->size = i * this->chipsize;
-        /* Convert chipsize to number of pages per chip -1. */
-        this->pagemask = (this->chipsize >> this->page_shift) - 1;
-        /* Preset the internal oob buffer */
-        memset(this->oob_buf, 0xff, mtd->oobsize << (this->phys_erase_shift - this->page_shift));
-
-        /* If no default placement scheme is given, select an
-         * appropriate one */
-        if (!this->autooob) {
-                /* Select the appropriate default oob placement scheme for
-                 * placement agnostic filesystems */
+        /*
+         * If no default placement scheme is given, select an appropriate one
+         */
+        if (!chip->ecc.layout) {
                 switch (mtd->oobsize) {
                 case 8:
-                        this->autooob = &nand_oob_8;
+                        chip->ecc.layout = &nand_oob_8;
                         break;
                 case 16:
-                        this->autooob = &nand_oob_16;
+                        chip->ecc.layout = &nand_oob_16;
                         break;
                 case 64:
-                        this->autooob = &nand_oob_64;
+                        chip->ecc.layout = &nand_oob_64;
                         break;
                 default:
-                        printk (KERN_WARNING "No oob scheme defined for oobsize %d\n",
-                                mtd->oobsize);
+                        printk(KERN_WARNING "No oob scheme defined for "
+                               "oobsize %d\n", mtd->oobsize);
                         BUG();
                 }
         }
 
-        /* The number of bytes available for the filesystem to place fs dependend
-         * oob data */
-        mtd->oobavail = 0;
-        for (i = 0; this->autooob->oobfree[i][1]; i++)
-                mtd->oobavail += this->autooob->oobfree[i][1];
-
         /*
-         * check ECC mode, default to software
-         * if 3byte/512byte hardware ECC is selected and we have 256 byte pagesize
-         * fallback to software ECC
-        */
-        this->eccsize = 256;    /* set default eccsize */
-        this->eccbytes = 3;
-
-        switch (this->eccmode) {
-        case NAND_ECC_HW12_2048:
-                if (mtd->oobblock < 2048) {
-                        printk(KERN_WARNING "2048 byte HW ECC not possible on %d byte page size, fallback to SW ECC\n",
-                               mtd->oobblock);
-                        this->eccmode = NAND_ECC_SOFT;
-                        this->calculate_ecc = nand_calculate_ecc;
-                        this->correct_data = nand_correct_data;
-                } else
-                        this->eccsize = 2048;
-                break;
-
-        case NAND_ECC_HW3_512:
-        case NAND_ECC_HW6_512:
-        case NAND_ECC_HW8_512:
-                if (mtd->oobblock == 256) {
-                        printk (KERN_WARNING "512 byte HW ECC not possible on 256 Byte pagesize, fallback to SW ECC \n");
-                        this->eccmode = NAND_ECC_SOFT;
-                        this->calculate_ecc = nand_calculate_ecc;
-                        this->correct_data = nand_correct_data;
-                } else
-                        this->eccsize = 512; /* set eccsize to 512 */
-                break;
+         * check ECC mode, default to software if 3byte/512byte hardware ECC is
+         * selected and we have 256 byte pagesize fallback to software ECC
+         */
+        switch (chip->ecc.mode) {
+        case NAND_ECC_HW:
+                /* Use standard hwecc read page function ? */
+                if (!chip->ecc.read_page)
+                        chip->ecc.read_page = nand_read_page_hwecc;
+                if (!chip->ecc.write_page)
+                        chip->ecc.write_page = nand_write_page_hwecc;
+                if (!chip->ecc.read_oob)
+                        chip->ecc.read_oob = nand_read_oob_std;
+                if (!chip->ecc.write_oob)
+                        chip->ecc.write_oob = nand_write_oob_std;
+
+        case NAND_ECC_HW_SYNDROME:
+                if (!chip->ecc.calculate || !chip->ecc.correct ||
+                    !chip->ecc.hwctl) {
+                        printk(KERN_WARNING "No ECC functions supplied, "
+                               "Hardware ECC not possible\n");
+                        BUG();
+                }
+                /* Use standard syndrome read/write page function ? */
+                if (!chip->ecc.read_page)
+                        chip->ecc.read_page = nand_read_page_syndrome;
+                if (!chip->ecc.write_page)
+                        chip->ecc.write_page = nand_write_page_syndrome;
+                if (!chip->ecc.read_oob)
+                        chip->ecc.read_oob = nand_read_oob_syndrome;
+                if (!chip->ecc.write_oob)
+                        chip->ecc.write_oob = nand_write_oob_syndrome;
+
+                if (mtd->writesize >= chip->ecc.size)
+                        break;
+                printk(KERN_WARNING "%d byte HW ECC not possible on "
+                       "%d byte page size, fallback to SW ECC\n",
+                       chip->ecc.size, mtd->writesize);
+                chip->ecc.mode = NAND_ECC_SOFT;
 
-        case NAND_ECC_HW3_256:
+        case NAND_ECC_SOFT:
+                chip->ecc.calculate = nand_calculate_ecc;
+                chip->ecc.correct = nand_correct_data;
+                chip->ecc.read_page = nand_read_page_swecc;
+                chip->ecc.write_page = nand_write_page_swecc;
+                chip->ecc.read_oob = nand_read_oob_std;
+                chip->ecc.write_oob = nand_write_oob_std;
+                chip->ecc.size = 256;
+                chip->ecc.bytes = 3;
                 break;
 
         case NAND_ECC_NONE:
-                printk (KERN_WARNING "NAND_ECC_NONE selected by board driver. This is not recommended !!\n");
-                this->eccmode = NAND_ECC_NONE;
+                printk(KERN_WARNING "NAND_ECC_NONE selected by board driver. "
+                       "This is not recommended !!\n");
+                chip->ecc.read_page = nand_read_page_raw;
+                chip->ecc.write_page = nand_write_page_raw;
+                chip->ecc.read_oob = nand_read_oob_std;
+                chip->ecc.write_oob = nand_write_oob_std;
+                chip->ecc.size = mtd->writesize;
+                chip->ecc.bytes = 0;
                 break;
-
-        case NAND_ECC_SOFT:
-                this->calculate_ecc = nand_calculate_ecc;
-                this->correct_data = nand_correct_data;
-                break;
-
         default:
-                printk (KERN_WARNING "Invalid NAND_ECC_MODE %d\n", this->eccmode);
-                BUG();
-        }
-
-        /* Check hardware ecc function availability and adjust number of ecc bytes per
-         * calculation step
-        */
-        switch (this->eccmode) {
-        case NAND_ECC_HW12_2048:
-                this->eccbytes += 4;
-        case NAND_ECC_HW8_512:
-                this->eccbytes += 2;
-        case NAND_ECC_HW6_512:
-                this->eccbytes += 3;
-        case NAND_ECC_HW3_512:
-        case NAND_ECC_HW3_256:
-                if (this->calculate_ecc && this->correct_data && this->enable_hwecc)
-                        break;
-                printk (KERN_WARNING "No ECC functions supplied, Hardware ECC not possible\n");
+                printk(KERN_WARNING "Invalid NAND_ECC_MODE %d\n",
+                       chip->ecc.mode);
                 BUG();
         }
 
-        mtd->eccsize = this->eccsize;
-
-        /* Set the number of read / write steps for one page to ensure ECC generation */
-        switch (this->eccmode) {
-        case NAND_ECC_HW12_2048:
-                this->eccsteps = mtd->oobblock / 2048;
-                break;
-        case NAND_ECC_HW3_512:
-        case NAND_ECC_HW6_512:
-        case NAND_ECC_HW8_512:
-                this->eccsteps = mtd->oobblock / 512;
-                break;
-        case NAND_ECC_HW3_256:
-        case NAND_ECC_SOFT:
-                this->eccsteps = mtd->oobblock / 256;
-                break;
+        /*
+         * The number of bytes available for a client to place data into
+         * the out of band area
+         */
+        chip->ecc.layout->oobavail = 0;
+        for (i = 0; chip->ecc.layout->oobfree[i].length; i++)
+                chip->ecc.layout->oobavail +=
+                        chip->ecc.layout->oobfree[i].length;
 
-        case NAND_ECC_NONE:
-                this->eccsteps = 1;
-                break;
+        /*
+         * Set the number of read / write steps for one page depending on ECC
+         * mode
+         */
+        chip->ecc.steps = mtd->writesize / chip->ecc.size;
+        if(chip->ecc.steps * chip->ecc.size != mtd->writesize) {
+                printk(KERN_WARNING "Invalid ecc parameters\n");
+                BUG();
         }
+        chip->ecc.total = chip->ecc.steps * chip->ecc.bytes;
 
-        /* Initialize state, waitqueue and spinlock */
-        this->state = FL_READY;
-        init_waitqueue_head (&this->wq);
-        spin_lock_init (&this->chip_lock);
+        /* Initialize state */
+        chip->state = FL_READY;
 
         /* De-select the device */
-        this->select_chip(mtd, -1);
+        chip->select_chip(mtd, -1);
 
         /* Invalidate the pagebuffer reference */
-        this->pagebuf = -1;
+        chip->pagebuf = -1;
 
         /* Fill in remaining MTD driver data */
         mtd->type = MTD_NANDFLASH;
-        mtd->flags = MTD_CAP_NANDFLASH | MTD_ECC;
+        mtd->flags = MTD_CAP_NANDFLASH;
         mtd->ecctype = MTD_ECC_SW;
         mtd->erase = nand_erase;
         mtd->point = NULL;
         mtd->unpoint = NULL;
         mtd->read = nand_read;
         mtd->write = nand_write;
-        mtd->read_ecc = nand_read_ecc;
-        mtd->write_ecc = nand_write_ecc;
         mtd->read_oob = nand_read_oob;
         mtd->write_oob = nand_write_oob;
-        mtd->readv = NULL;
-        mtd->writev = nand_writev;
-        mtd->writev_ecc = nand_writev_ecc;
         mtd->sync = nand_sync;
         mtd->lock = NULL;
         mtd->unlock = NULL;
@@ -2692,47 +2490,38 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
         mtd->block_isbad = nand_block_isbad;
         mtd->block_markbad = nand_block_markbad;
 
-        /* and make the autooob the default one */
-        memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo));
-
-        mtd->owner = THIS_MODULE;
+        /* propagate ecc.layout to mtd_info */
+        mtd->ecclayout = chip->ecc.layout;
 
         /* Check, if we should skip the bad block table scan */
-        if (this->options & NAND_SKIP_BBTSCAN)
+        if (chip->options & NAND_SKIP_BBTSCAN)
                 return 0;
 
         /* Build bad block table */
-        return this->scan_bbt (mtd);
+        return chip->scan_bbt(mtd);
 }
 
 /**
  * nand_release - [NAND Interface] Free resources held by the NAND device
  * @mtd:        MTD device structure
 */
-void nand_release (struct mtd_info *mtd)
+void nand_release(struct mtd_info *mtd)
 {
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *chip = mtd->priv;
 
 #ifdef CONFIG_MTD_PARTITIONS
         /* Deregister partitions */
-        del_mtd_partitions (mtd);
+        del_mtd_partitions(mtd);
 #endif
         /* Deregister the device */
-        del_mtd_device (mtd);
+        del_mtd_device(mtd);
 
         /* Free bad block table memory */
-        kfree (this->bbt);
-        /* Buffer allocated by nand_scan ? */
-        if (this->options & NAND_OOBBUF_ALLOC)
-                kfree (this->oob_buf);
-        /* Buffer allocated by nand_scan ? */
-        if (this->options & NAND_DATABUF_ALLOC)
-                kfree (this->data_buf);
+        kfree(chip->bbt);
 }
 
-EXPORT_SYMBOL_GPL (nand_scan);
-EXPORT_SYMBOL_GPL (nand_release);
-
+EXPORT_SYMBOL_GPL(nand_scan);
+EXPORT_SYMBOL_GPL(nand_release);
 
 static int __init nand_base_init(void)
 {
@@ -2748,6 +2537,6 @@ static void __exit nand_base_exit(void)
 module_init(nand_base_init);
 module_exit(nand_base_exit);
 
-MODULE_LICENSE ("GPL");
-MODULE_AUTHOR ("Steven J. Hill <sjhill@realitydiluted.com>, Thomas Gleixner <tglx@linutronix.de>");
-MODULE_DESCRIPTION ("Generic NAND flash driver code");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Steven J. Hill <sjhill@realitydiluted.com>, Thomas Gleixner <tglx@linutronix.de>");
+MODULE_DESCRIPTION("Generic NAND flash driver code");
diff --git a/drivers/mtd/nand/nand_bbt.c b/drivers/mtd/nand/nand_bbt.c
index ca286999fe08..a612c4ea8194 100644
--- a/drivers/mtd/nand/nand_bbt.c
+++ b/drivers/mtd/nand/nand_bbt.c
@@ -48,7 +48,7 @@
  *
  * Following assumptions are made:
  * - bbts start at a page boundary, if autolocated on a block boundary
- * - the space neccecary for a bbt in FLASH does not exceed a block boundary
+ * - the space necessary for a bbt in FLASH does not exceed a block boundary
  *
  */
 
@@ -60,7 +60,7 @@
 #include <linux/mtd/compatmac.h>
 #include <linux/bitops.h>
 #include <linux/delay.h>
-
+#include <linux/vmalloc.h>
 
 /**
  * check_pattern - [GENERIC] check if a pattern is in the buffer
@@ -75,7 +75,7 @@
  * pattern area contain 0xff
  *
 */
-static int check_pattern (uint8_t *buf, int len, int paglen, struct nand_bbt_descr *td)
+static int check_pattern(uint8_t *buf, int len, int paglen, struct nand_bbt_descr *td)
 {
         int i, end = 0;
         uint8_t *p = buf;
@@ -116,7 +116,7 @@ static int check_pattern (uint8_t *buf, int len, int paglen, struct nand_bbt_des
  * no optional empty check
  *
 */
-static int check_short_pattern (uint8_t *buf, struct nand_bbt_descr *td)
+static int check_short_pattern(uint8_t *buf, struct nand_bbt_descr *td)
 {
         int i;
         uint8_t *p = buf;
@@ -142,8 +142,8 @@ static int check_short_pattern (uint8_t *buf, struct nand_bbt_descr *td)
  * Read the bad block table starting from page.
  *
  */
-static int read_bbt (struct mtd_info *mtd, uint8_t *buf, int page, int num,
-        int bits, int offs, int reserved_block_code)
+static int read_bbt(struct mtd_info *mtd, uint8_t *buf, int page, int num,
+                    int bits, int offs, int reserved_block_code)
 {
         int res, i, j, act = 0;
         struct nand_chip *this = mtd->priv;
@@ -152,17 +152,17 @@ static int read_bbt (struct mtd_info *mtd, uint8_t *buf, int page, int num,
         uint8_t msk = (uint8_t) ((1 << bits) - 1);
 
         totlen = (num * bits) >> 3;
-        from = ((loff_t)page) << this->page_shift;
+        from = ((loff_t) page) << this->page_shift;
 
         while (totlen) {
-                len = min (totlen, (size_t) (1 << this->bbt_erase_shift));
-                res = mtd->read_ecc (mtd, from, len, &retlen, buf, NULL, this->autooob);
+                len = min(totlen, (size_t) (1 << this->bbt_erase_shift));
+                res = mtd->read(mtd, from, len, &retlen, buf);
                 if (res < 0) {
                         if (retlen != len) {
-                                printk (KERN_INFO "nand_bbt: Error reading bad block table\n");
+                                printk(KERN_INFO "nand_bbt: Error reading bad block table\n");
                                 return res;
                         }
-                        printk (KERN_WARNING "nand_bbt: ECC error while reading bad block table\n");
+                        printk(KERN_WARNING "nand_bbt: ECC error while reading bad block table\n");
                 }
 
                 /* Analyse data */
@@ -172,22 +172,23 @@ static int read_bbt (struct mtd_info *mtd, uint8_t *buf, int page, int num,
                                 uint8_t tmp = (dat >> j) & msk;
                                 if (tmp == msk)
                                         continue;
-                                if (reserved_block_code &&
-                                    (tmp == reserved_block_code)) {
-                                        printk (KERN_DEBUG "nand_read_bbt: Reserved block at 0x%08x\n",
-                                                ((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
+                                if (reserved_block_code && (tmp == reserved_block_code)) {
+                                        printk(KERN_DEBUG "nand_read_bbt: Reserved block at 0x%08x\n",
+                                               ((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
                                         this->bbt[offs + (act >> 3)] |= 0x2 << (act & 0x06);
+                                        mtd->ecc_stats.bbtblocks++;
                                         continue;
                                 }
                                 /* Leave it for now, if its matured we can move this
                                  * message to MTD_DEBUG_LEVEL0 */
-                                printk (KERN_DEBUG "nand_read_bbt: Bad block at 0x%08x\n",
-                                        ((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
+                                printk(KERN_DEBUG "nand_read_bbt: Bad block at 0x%08x\n",
+                                       ((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
                                 /* Factory marked bad or worn out ? */
                                 if (tmp == 0)
                                         this->bbt[offs + (act >> 3)] |= 0x3 << (act & 0x06);
                                 else
                                         this->bbt[offs + (act >> 3)] |= 0x1 << (act & 0x06);
+                                mtd->ecc_stats.badblocks++;
                         }
                 }
                 totlen -= len;
@@ -207,7 +208,7 @@ static int read_bbt (struct mtd_info *mtd, uint8_t *buf, int page, int num,
  * Read the bad block table for all chips starting at a given page
  * We assume that the bbt bits are in consecutive order.
 */
-static int read_abs_bbt (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td, int chip)
+static int read_abs_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td, int chip)
 {
         struct nand_chip *this = mtd->priv;
         int res = 0, i;
@@ -231,6 +232,42 @@ static int read_abs_bbt (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_des
         return 0;
 }
 
+/*
+ * Scan read raw data from flash
+ */
+static int scan_read_raw(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
+                         size_t len)
+{
+        struct mtd_oob_ops ops;
+
+        ops.mode = MTD_OOB_RAW;
+        ops.ooboffs = 0;
+        ops.ooblen = mtd->oobsize;
+        ops.oobbuf = buf;
+        ops.datbuf = buf;
+        ops.len = len;
+
+        return mtd->read_oob(mtd, offs, &ops);
+}
+
+/*
+ * Scan write data with oob to flash
+ */
+static int scan_write_bbt(struct mtd_info *mtd, loff_t offs, size_t len,
+                          uint8_t *buf, uint8_t *oob)
+{
+        struct mtd_oob_ops ops;
+
+        ops.mode = MTD_OOB_PLACE;
+        ops.ooboffs = 0;
+        ops.ooblen = mtd->oobsize;
+        ops.datbuf = buf;
+        ops.oobbuf = oob;
+        ops.len = len;
+
+        return mtd->write_oob(mtd, offs, &ops);
+}
+
 /**
  * read_abs_bbts - [GENERIC] Read the bad block table(s) for all chips starting at a given page
  * @mtd:        MTD device structure
@@ -242,28 +279,85 @@ static int read_abs_bbt (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_des
  * We assume that the bbt bits are in consecutive order.
  *
 */
-static int read_abs_bbts (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td,
-        struct nand_bbt_descr *md)
+static int read_abs_bbts(struct mtd_info *mtd, uint8_t *buf,
+                         struct nand_bbt_descr *td, struct nand_bbt_descr *md)
 {
         struct nand_chip *this = mtd->priv;
 
         /* Read the primary version, if available */
         if (td->options & NAND_BBT_VERSION) {
-                nand_read_raw (mtd, buf, td->pages[0] << this->page_shift, mtd->oobblock, mtd->oobsize);
-                td->version[0] = buf[mtd->oobblock + td->veroffs];
-                printk (KERN_DEBUG "Bad block table at page %d, version 0x%02X\n", td->pages[0], td->version[0]);
+                scan_read_raw(mtd, buf, td->pages[0] << this->page_shift,
+                              mtd->writesize);
+                td->version[0] = buf[mtd->writesize + td->veroffs];
+                printk(KERN_DEBUG "Bad block table at page %d, version 0x%02X\n",
+                       td->pages[0], td->version[0]);
         }
 
         /* Read the mirror version, if available */
         if (md && (md->options & NAND_BBT_VERSION)) {
-                nand_read_raw (mtd, buf, md->pages[0] << this->page_shift, mtd->oobblock, mtd->oobsize);
-                md->version[0] = buf[mtd->oobblock + md->veroffs];
-                printk (KERN_DEBUG "Bad block table at page %d, version 0x%02X\n", md->pages[0], md->version[0]);
+                scan_read_raw(mtd, buf, md->pages[0] << this->page_shift,
+                              mtd->writesize);
+                md->version[0] = buf[mtd->writesize + md->veroffs];
+                printk(KERN_DEBUG "Bad block table at page %d, version 0x%02X\n",
+                       md->pages[0], md->version[0]);
         }
-
         return 1;
 }
 
+/*
+ * Scan a given block full
+ */
+static int scan_block_full(struct mtd_info *mtd, struct nand_bbt_descr *bd,
+                           loff_t offs, uint8_t *buf, size_t readlen,
+                           int scanlen, int len)
+{
+        int ret, j;
+
+        ret = scan_read_raw(mtd, buf, offs, readlen);
+        if (ret)
+                return ret;
+
+        for (j = 0; j < len; j++, buf += scanlen) {
+                if (check_pattern(buf, scanlen, mtd->writesize, bd))
+                        return 1;
+        }
+        return 0;
+}
+
+/*
+ * Scan a given block partially
+ */
+static int scan_block_fast(struct mtd_info *mtd, struct nand_bbt_descr *bd,
+                           loff_t offs, uint8_t *buf, int len)
+{
+        struct mtd_oob_ops ops;
+        int j, ret;
+
+        ops.len = mtd->oobsize;
+        ops.ooblen = mtd->oobsize;
+        ops.oobbuf = buf;
+        ops.ooboffs = 0;
+        ops.datbuf = NULL;
+        ops.mode = MTD_OOB_PLACE;
+
+        for (j = 0; j < len; j++) {
+                /*
+                 * Read the full oob until read_oob is fixed to
+                 * handle single byte reads for 16 bit
+                 * buswidth
+                 */
+                ret = mtd->read_oob(mtd, offs, &ops);
+                if (ret)
+                        return ret;
+
+                if (check_short_pattern(buf, bd))
+                        return 1;
+
+                offs += mtd->writesize;
+        }
+        return 0;
+}
+
 /**
  * create_bbt - [GENERIC] Create a bad block table by scanning the device
  * @mtd:        MTD device structure
@@ -275,15 +369,16 @@ static int read_abs_bbts (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_de
  * Create a bad block table by scanning the device
  * for the given good/bad block identify pattern
  */
-static int create_bbt (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *bd, int chip)
+static int create_bbt(struct mtd_info *mtd, uint8_t *buf,
+        struct nand_bbt_descr *bd, int chip)
 {
         struct nand_chip *this = mtd->priv;
-        int i, j, numblocks, len, scanlen;
+        int i, numblocks, len, scanlen;
         int startblock;
         loff_t from;
-        size_t readlen, ooblen;
+        size_t readlen;
 
-        printk (KERN_INFO "Scanning device for bad blocks\n");
+        printk(KERN_INFO "Scanning device for bad blocks\n");
 
         if (bd->options & NAND_BBT_SCANALLPAGES)
                 len = 1 << (this->bbt_erase_shift - this->page_shift);
@@ -296,25 +391,24 @@ static int create_bbt (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr
 
         if (!(bd->options & NAND_BBT_SCANEMPTY)) {
                 /* We need only read few bytes from the OOB area */
-                scanlen = ooblen = 0;
+                scanlen = 0;
                 readlen = bd->len;
         } else {
                 /* Full page content should be read */
-                scanlen = mtd->oobblock + mtd->oobsize;
-                readlen = len * mtd->oobblock;
-                ooblen = len * mtd->oobsize;
+                scanlen = mtd->writesize + mtd->oobsize;
+                readlen = len * mtd->writesize;
         }
 
         if (chip == -1) {
-                /* Note that numblocks is 2 * (real numblocks) here, see i+=2 below as it
-                 * makes shifting and masking less painful */
+                /* Note that numblocks is 2 * (real numblocks) here, see i+=2
+                 * below as it makes shifting and masking less painful */
                 numblocks = mtd->size >> (this->bbt_erase_shift - 1);
                 startblock = 0;
                 from = 0;
         } else {
                 if (chip >= this->numchips) {
-                        printk (KERN_WARNING "create_bbt(): chipnr (%d) > available chips (%d)\n",
-                                chip + 1, this->numchips);
+                        printk(KERN_WARNING "create_bbt(): chipnr (%d) > available chips (%d)\n",
+                               chip + 1, this->numchips);
                         return -EINVAL;
                 }
                 numblocks = this->chipsize >> (this->bbt_erase_shift - 1);
@@ -326,36 +420,22 @@ static int create_bbt (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr
         for (i = startblock; i < numblocks;) {
                 int ret;
 
-                if (bd->options & NAND_BBT_SCANEMPTY)
-                        if ((ret = nand_read_raw (mtd, buf, from, readlen, ooblen)))
-                                return ret;
-
-                for (j = 0; j < len; j++) {
-                        if (!(bd->options & NAND_BBT_SCANEMPTY)) {
-                                size_t retlen;
-
-                                /* Read the full oob until read_oob is fixed to
-                                 * handle single byte reads for 16 bit buswidth */
-                                ret = mtd->read_oob(mtd, from + j * mtd->oobblock,
-                                                        mtd->oobsize, &retlen, buf);
-                                if (ret)
-                                        return ret;
-
-                                if (check_short_pattern (buf, bd)) {
-                                        this->bbt[i >> 3] |= 0x03 << (i & 0x6);
-                                        printk (KERN_WARNING "Bad eraseblock %d at 0x%08x\n",
-                                                i >> 1, (unsigned int) from);
-                                        break;
-                                }
-                        } else {
-                                if (check_pattern (&buf[j * scanlen], scanlen, mtd->oobblock, bd)) {
-                                        this->bbt[i >> 3] |= 0x03 << (i & 0x6);
-                                        printk (KERN_WARNING "Bad eraseblock %d at 0x%08x\n",
-                                                i >> 1, (unsigned int) from);
-                                        break;
-                                }
-                        }
+                if (bd->options & NAND_BBT_SCANALLPAGES)
+                        ret = scan_block_full(mtd, bd, from, buf, readlen,
+                                              scanlen, len);
+                else
+                        ret = scan_block_fast(mtd, bd, from, buf, len);
+
+                if (ret < 0)
+                        return ret;
+
+                if (ret) {
+                        this->bbt[i >> 3] |= 0x03 << (i & 0x6);
+                        printk(KERN_WARNING "Bad eraseblock %d at 0x%08x\n",
+                               i >> 1, (unsigned int)from);
+                        mtd->ecc_stats.badblocks++;
                 }
+
                 i += 2;
                 from += (1 << this->bbt_erase_shift);
         }
@@ -374,22 +454,23 @@ static int create_bbt (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr
  * block.
  * If the option NAND_BBT_PERCHIP is given, each chip is searched
  * for a bbt, which contains the bad block information of this chip.
- * This is neccecary to provide support for certain DOC devices.
+ * This is necessary to provide support for certain DOC devices.
  *
  * The bbt ident pattern resides in the oob area of the first page
  * in a block.
  */
-static int search_bbt (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td)
+static int search_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td)
 {
         struct nand_chip *this = mtd->priv;
         int i, chips;
         int bits, startblock, block, dir;
-        int scanlen = mtd->oobblock + mtd->oobsize;
+        int scanlen = mtd->writesize + mtd->oobsize;
         int bbtblocks;
+        int blocktopage = this->bbt_erase_shift - this->page_shift;
 
         /* Search direction top -> down ? */
         if (td->options & NAND_BBT_LASTBLOCK) {
-                startblock = (mtd->size >> this->bbt_erase_shift) -1;
+                startblock = (mtd->size >> this->bbt_erase_shift) - 1;
                 dir = -1;
         } else {
                 startblock = 0;
@@ -415,13 +496,16 @@ static int search_bbt (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr
                 td->pages[i] = -1;
                 /* Scan the maximum number of blocks */
                 for (block = 0; block < td->maxblocks; block++) {
+
                         int actblock = startblock + dir * block;
+                        loff_t offs = actblock << this->bbt_erase_shift;
+
                         /* Read first page */
-                        nand_read_raw (mtd, buf, actblock << this->bbt_erase_shift, mtd->oobblock, mtd->oobsize);
-                        if (!check_pattern(buf, scanlen, mtd->oobblock, td)) {
-                                td->pages[i] = actblock << (this->bbt_erase_shift - this->page_shift);
+                        scan_read_raw(mtd, buf, offs, mtd->writesize);
+                        if (!check_pattern(buf, scanlen, mtd->writesize, td)) {
+                                td->pages[i] = actblock << blocktopage;
                                 if (td->options & NAND_BBT_VERSION) {
-                                        td->version[i] = buf[mtd->oobblock + td->veroffs];
+                                        td->version[i] = buf[mtd->writesize + td->veroffs];
                                 }
                                 break;
                         }
@@ -431,9 +515,10 @@ static int search_bbt (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr
         /* Check, if we found a bbt for each requested chip */
         for (i = 0; i < chips; i++) {
                 if (td->pages[i] == -1)
-                        printk (KERN_WARNING "Bad block table not found for chip %d\n", i);
+                        printk(KERN_WARNING "Bad block table not found for chip %d\n", i);
                 else
-                        printk (KERN_DEBUG "Bad block table found at page %d, version 0x%02X\n", td->pages[i], td->version[i]);
+                        printk(KERN_DEBUG "Bad block table found at page %d, version 0x%02X\n", td->pages[i],
+                               td->version[i]);
         }
         return 0;
 }
@@ -447,21 +532,19 @@ static int search_bbt (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr
  *
  * Search and read the bad block table(s)
 */
-static int search_read_bbts (struct mtd_info *mtd, uint8_t *buf,
-        struct nand_bbt_descr *td, struct nand_bbt_descr *md)
+static int search_read_bbts(struct mtd_info *mtd, uint8_t * buf, struct nand_bbt_descr *td, struct nand_bbt_descr *md)
 {
         /* Search the primary table */
-        search_bbt (mtd, buf, td);
+        search_bbt(mtd, buf, td);
 
         /* Search the mirror table */
         if (md)
-                search_bbt (mtd, buf, md);
+                search_bbt(mtd, buf, md);
 
         /* Force result check */
         return 1;
 }
 
-
 /**
  * write_bbt - [GENERIC] (Re)write the bad block table
  *
@@ -474,25 +557,31 @@ static int search_read_bbts (struct mtd_info *mtd, uint8_t *buf,
  * (Re)write the bad block table
  *
 */
-static int write_bbt (struct mtd_info *mtd, uint8_t *buf,
-        struct nand_bbt_descr *td, struct nand_bbt_descr *md, int chipsel)
+static int write_bbt(struct mtd_info *mtd, uint8_t *buf,
+                     struct nand_bbt_descr *td, struct nand_bbt_descr *md,
+                     int chipsel)
 {
         struct nand_chip *this = mtd->priv;
-        struct nand_oobinfo oobinfo;
         struct erase_info einfo;
         int i, j, res, chip = 0;
         int bits, startblock, dir, page, offs, numblocks, sft, sftmsk;
-        int nrchips, bbtoffs, pageoffs;
+        int nrchips, bbtoffs, pageoffs, ooboffs;
         uint8_t msk[4];
         uint8_t rcode = td->reserved_block_code;
         size_t retlen, len = 0;
         loff_t to;
+        struct mtd_oob_ops ops;
+
+        ops.ooblen = mtd->oobsize;
+        ops.ooboffs = 0;
+        ops.datbuf = NULL;
+        ops.mode = MTD_OOB_PLACE;
 
         if (!rcode)
                 rcode = 0xff;
         /* Write bad block table per chip rather than per device ? */
         if (td->options & NAND_BBT_PERCHIP) {
-                numblocks = (int) (this->chipsize >> this->bbt_erase_shift);
+                numblocks = (int)(this->chipsize >> this->bbt_erase_shift);
                 /* Full device write or specific chip ? */
                 if (chipsel == -1) {
                         nrchips = this->numchips;
@@ -501,7 +590,7 @@ static int write_bbt (struct mtd_info *mtd, uint8_t *buf,
                         chip = chipsel;
                 }
         } else {
-                numblocks = (int) (mtd->size >> this->bbt_erase_shift);
+                numblocks = (int)(mtd->size >> this->bbt_erase_shift);
                 nrchips = 1;
         }
 
@@ -530,27 +619,38 @@ static int write_bbt (struct mtd_info *mtd, uint8_t *buf,
                 for (i = 0; i < td->maxblocks; i++) {
                         int block = startblock + dir * i;
                         /* Check, if the block is bad */
-                        switch ((this->bbt[block >> 2] >> (2 * (block & 0x03))) & 0x03) {
+                        switch ((this->bbt[block >> 2] >>
+                                 (2 * (block & 0x03))) & 0x03) {
                         case 0x01:
                         case 0x03:
                                 continue;
                         }
-                        page = block << (this->bbt_erase_shift - this->page_shift);
+                        page = block <<
+                                (this->bbt_erase_shift - this->page_shift);
                         /* Check, if the block is used by the mirror table */
                         if (!md || md->pages[chip] != page)
                                 goto write;
                 }
-                printk (KERN_ERR "No space left to write bad block table\n");
+                printk(KERN_ERR "No space left to write bad block table\n");
                 return -ENOSPC;
-write:
+        write:
 
                 /* Set up shift count and masks for the flash table */
                 bits = td->options & NAND_BBT_NRBITS_MSK;
+                msk[2] = ~rcode;
                 switch (bits) {
-                case 1: sft = 3; sftmsk = 0x07; msk[0] = 0x00; msk[1] = 0x01; msk[2] = ~rcode; msk[3] = 0x01; break;
-                case 2: sft = 2; sftmsk = 0x06; msk[0] = 0x00; msk[1] = 0x01; msk[2] = ~rcode; msk[3] = 0x03; break;
-                case 4: sft = 1; sftmsk = 0x04; msk[0] = 0x00; msk[1] = 0x0C; msk[2] = ~rcode; msk[3] = 0x0f; break;
-                case 8: sft = 0; sftmsk = 0x00; msk[0] = 0x00; msk[1] = 0x0F; msk[2] = ~rcode; msk[3] = 0xff; break;
+                case 1: sft = 3; sftmsk = 0x07; msk[0] = 0x00; msk[1] = 0x01;
+                        msk[3] = 0x01;
+                        break;
+                case 2: sft = 2; sftmsk = 0x06; msk[0] = 0x00; msk[1] = 0x01;
+                        msk[3] = 0x03;
+                        break;
+                case 4: sft = 1; sftmsk = 0x04; msk[0] = 0x00; msk[1] = 0x0C;
+                        msk[3] = 0x0f;
+                        break;
+                case 8: sft = 0; sftmsk = 0x00; msk[0] = 0x00; msk[1] = 0x0F;
+                        msk[3] = 0xff;
+                        break;
                 default: return -EINVAL;
                 }
 
@@ -558,82 +658,92 @@ write:
 
                 to = ((loff_t) page) << this->page_shift;
 
-                memcpy (&oobinfo, this->autooob, sizeof(oobinfo));
-                oobinfo.useecc = MTD_NANDECC_PLACEONLY;
-
                 /* Must we save the block contents ? */
                 if (td->options & NAND_BBT_SAVECONTENT) {
                         /* Make it block aligned */
                         to &= ~((loff_t) ((1 << this->bbt_erase_shift) - 1));
                         len = 1 << this->bbt_erase_shift;
-                        res = mtd->read_ecc (mtd, to, len, &retlen, buf, &buf[len], &oobinfo);
+                        res = mtd->read(mtd, to, len, &retlen, buf);
                         if (res < 0) {
                                 if (retlen != len) {
-                                        printk (KERN_INFO "nand_bbt: Error reading block for writing the bad block table\n");
+                                        printk(KERN_INFO "nand_bbt: Error "
+                                               "reading block for writing "
+                                               "the bad block table\n");
                                         return res;
                                 }
-                                printk (KERN_WARNING "nand_bbt: ECC error while reading block for writing bad block table\n");
+                                printk(KERN_WARNING "nand_bbt: ECC error "
+                                       "while reading block for writing "
+                                       "bad block table\n");
                         }
+                        /* Read oob data */
+                        ops.len = (len >> this->page_shift) * mtd->oobsize;
+                        ops.oobbuf = &buf[len];
+                        res = mtd->read_oob(mtd, to + mtd->writesize, &ops);
+                        if (res < 0 || ops.retlen != ops.len)
+                                goto outerr;
+
                         /* Calc the byte offset in the buffer */
                         pageoffs = page - (int)(to >> this->page_shift);
                         offs = pageoffs << this->page_shift;
                         /* Preset the bbt area with 0xff */
-                        memset (&buf[offs], 0xff, (size_t)(numblocks >> sft));
-                        /* Preset the bbt's oob area with 0xff */
-                        memset (&buf[len + pageoffs * mtd->oobsize], 0xff,
-                                ((len >> this->page_shift) - pageoffs) * mtd->oobsize);
-                        if (td->options & NAND_BBT_VERSION) {
-                                buf[len + (pageoffs * mtd->oobsize) + td->veroffs] = td->version[chip];
-                        }
+                        memset(&buf[offs], 0xff, (size_t) (numblocks >> sft));
+                        ooboffs = len + (pageoffs * mtd->oobsize);
+
                 } else {
                         /* Calc length */
                         len = (size_t) (numblocks >> sft);
                         /* Make it page aligned ! */
-                        len = (len + (mtd->oobblock-1)) & ~(mtd->oobblock-1);
+                        len = (len + (mtd->writesize - 1)) &
+                                ~(mtd->writesize - 1);
                         /* Preset the buffer with 0xff */
-                        memset (buf, 0xff, len + (len >> this->page_shift) * mtd->oobsize);
+                        memset(buf, 0xff, len +
+                               (len >> this->page_shift)* mtd->oobsize);
                         offs = 0;
+                        ooboffs = len;
                         /* Pattern is located in oob area of first page */
-                        memcpy (&buf[len + td->offs], td->pattern, td->len);
-                        if (td->options & NAND_BBT_VERSION) {
-                                buf[len + td->veroffs] = td->version[chip];
-                        }
+                        memcpy(&buf[ooboffs + td->offs], td->pattern, td->len);
                 }
 
+                if (td->options & NAND_BBT_VERSION)
+                        buf[ooboffs + td->veroffs] = td->version[chip];
+
                 /* walk through the memory table */
-                for (i = 0; i < numblocks; ) {
+                for (i = 0; i < numblocks;) {
                         uint8_t dat;
                         dat = this->bbt[bbtoffs + (i >> 2)];
-                        for (j = 0; j < 4; j++ , i++) {
+                        for (j = 0; j < 4; j++, i++) {
                                 int sftcnt = (i << (3 - sft)) & sftmsk;
                                 /* Do not store the reserved bbt blocks ! */
-                                buf[offs + (i >> sft)] &= ~(msk[dat & 0x03] << sftcnt);
+                                buf[offs + (i >> sft)] &=
+                                        ~(msk[dat & 0x03] << sftcnt);
                                 dat >>= 2;
                         }
                 }
 
-                memset (&einfo, 0, sizeof (einfo));
+                memset(&einfo, 0, sizeof(einfo));
                 einfo.mtd = mtd;
-                einfo.addr = (unsigned long) to;
+                einfo.addr = (unsigned long)to;
                 einfo.len = 1 << this->bbt_erase_shift;
-                res = nand_erase_nand (mtd, &einfo, 1);
-                if (res < 0) {
-                        printk (KERN_WARNING "nand_bbt: Error during block erase: %d\n", res);
-                        return res;
-                }
+                res = nand_erase_nand(mtd, &einfo, 1);
+                if (res < 0)
+                        goto outerr;
 
-                res = mtd->write_ecc (mtd, to, len, &retlen, buf, &buf[len], &oobinfo);
-                if (res < 0) {
-                        printk (KERN_WARNING "nand_bbt: Error while writing bad block table %d\n", res);
-                        return res;
-                }
-                printk (KERN_DEBUG "Bad block table written to 0x%08x, version 0x%02X\n",
-                        (unsigned int) to, td->version[chip]);
+                res = scan_write_bbt(mtd, to, len, buf, &buf[len]);
+                if (res < 0)
+                        goto outerr;
+
+                printk(KERN_DEBUG "Bad block table written to 0x%08x, version "
+                       "0x%02X\n", (unsigned int)to, td->version[chip]);
 
                 /* Mark it as used */
                 td->pages[chip] = page;
         }
         return 0;
+
+ outerr:
+        printk(KERN_WARNING
+               "nand_bbt: Error while writing bad block table %d\n", res);
+        return res;
 }
 
 /**
@@ -644,27 +754,27 @@ write:
  * The function creates a memory based bbt by scanning the device
  * for manufacturer / software marked good / bad blocks
 */
-static inline int nand_memory_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd)
+static inline int nand_memory_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
 {
         struct nand_chip *this = mtd->priv;
 
         bd->options &= ~NAND_BBT_SCANEMPTY;
-        return create_bbt (mtd, this->data_buf, bd, -1);
+        return create_bbt(mtd, this->buffers.databuf, bd, -1);
 }
 
 /**
- * check_create - [GENERIC] create and write bbt(s) if neccecary
+ * check_create - [GENERIC] create and write bbt(s) if necessary
  * @mtd:        MTD device structure
  * @buf:        temporary buffer
  * @bd:         descriptor for the good/bad block search pattern
  *
  * The function checks the results of the previous call to read_bbt
- * and creates / updates the bbt(s) if neccecary
- * Creation is neccecary if no bbt was found for the chip/device
- * Update is neccecary if one of the tables is missing or the
+ * and creates / updates the bbt(s) if necessary
+ * Creation is necessary if no bbt was found for the chip/device
+ * Update is necessary if one of the tables is missing or the
  * version nr. of one table is less than the other
 */
-static int check_create (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *bd)
+static int check_create(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *bd)
 {
         int i, chips, writeops, chipsel, res;
         struct nand_chip *this = mtd->priv;
@@ -732,35 +842,35 @@ static int check_create (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_des
                         rd = td;
                         goto writecheck;
                 }
-create:
+        create:
                 /* Create the bad block table by scanning the device ? */
                 if (!(td->options & NAND_BBT_CREATE))
                         continue;
 
                 /* Create the table in memory by scanning the chip(s) */
-                create_bbt (mtd, buf, bd, chipsel);
+                create_bbt(mtd, buf, bd, chipsel);
 
                 td->version[i] = 1;
                 if (md)
                         md->version[i] = 1;
-writecheck:
+        writecheck:
                 /* read back first ? */
                 if (rd)
-                        read_abs_bbt (mtd, buf, rd, chipsel);
+                        read_abs_bbt(mtd, buf, rd, chipsel);
                 /* If they weren't versioned, read both. */
                 if (rd2)
-                        read_abs_bbt (mtd, buf, rd2, chipsel);
+                        read_abs_bbt(mtd, buf, rd2, chipsel);
 
                 /* Write the bad block table to the device ? */
                 if ((writeops & 0x01) && (td->options & NAND_BBT_WRITE)) {
-                        res = write_bbt (mtd, buf, td, md, chipsel);
+                        res = write_bbt(mtd, buf, td, md, chipsel);
                         if (res < 0)
                                 return res;
                 }
 
                 /* Write the mirror bad block table to the device ? */
                 if ((writeops & 0x02) && md && (md->options & NAND_BBT_WRITE)) {
-                        res = write_bbt (mtd, buf, md, td, chipsel);
+                        res = write_bbt(mtd, buf, md, td, chipsel);
                         if (res < 0)
                                 return res;
                 }
@@ -777,7 +887,7 @@ writecheck:
  * accidental erasures / writes. The regions are identified by
  * the mark 0x02.
 */
-static void mark_bbt_region (struct mtd_info *mtd, struct nand_bbt_descr *td)
+static void mark_bbt_region(struct mtd_info *mtd, struct nand_bbt_descr *td)
 {
         struct nand_chip *this = mtd->priv;
         int i, j, chips, block, nrblocks, update;
@@ -795,7 +905,8 @@ static void mark_bbt_region (struct mtd_info *mtd, struct nand_bbt_descr *td)
         for (i = 0; i < chips; i++) {
                 if ((td->options & NAND_BBT_ABSPAGE) ||
                     !(td->options & NAND_BBT_WRITE)) {
-                        if (td->pages[i] == -1) continue;
+                        if (td->pages[i] == -1)
+                                continue;
                         block = td->pages[i] >> (this->bbt_erase_shift - this->page_shift);
                         block <<= 1;
                         oldval = this->bbt[(block >> 3)];
@@ -815,7 +926,8 @@ static void mark_bbt_region (struct mtd_info *mtd, struct nand_bbt_descr *td)
                         oldval = this->bbt[(block >> 3)];
                         newval = oldval | (0x2 << (block & 0x06));
                         this->bbt[(block >> 3)] = newval;
-                        if (oldval != newval) update = 1;
+                        if (oldval != newval)
+                                update = 1;
                         block += 2;
                 }
                 /* If we want reserved blocks to be recorded to flash, and some
@@ -840,7 +952,7 @@ static void mark_bbt_region (struct mtd_info *mtd, struct nand_bbt_descr *td)
  * by calling the nand_free_bbt function.
  *
 */
-int nand_scan_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd)
+int nand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
 {
         struct nand_chip *this = mtd->priv;
         int len, res = 0;
@@ -850,21 +962,21 @@ int nand_scan_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd)
 
         len = mtd->size >> (this->bbt_erase_shift + 2);
         /* Allocate memory (2bit per block) */
-        this->bbt = kmalloc (len, GFP_KERNEL);
+        this->bbt = kmalloc(len, GFP_KERNEL);
         if (!this->bbt) {
-                printk (KERN_ERR "nand_scan_bbt: Out of memory\n");
+                printk(KERN_ERR "nand_scan_bbt: Out of memory\n");
                 return -ENOMEM;
         }
         /* Clear the memory bad block table */
-        memset (this->bbt, 0x00, len);
+        memset(this->bbt, 0x00, len);
 
         /* If no primary table decriptor is given, scan the device
          * to build a memory based bad block table
          */
         if (!td) {
                 if ((res = nand_memory_bbt(mtd, bd))) {
-                        printk (KERN_ERR "nand_bbt: Can't scan flash and build the RAM-based BBT\n");
-                        kfree (this->bbt);
+                        printk(KERN_ERR "nand_bbt: Can't scan flash and build the RAM-based BBT\n");
+                        kfree(this->bbt);
                         this->bbt = NULL;
                 }
                 return res;
@@ -873,35 +985,34 @@ int nand_scan_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd)
         /* Allocate a temporary buffer for one eraseblock incl. oob */
         len = (1 << this->bbt_erase_shift);
         len += (len >> this->page_shift) * mtd->oobsize;
-        buf = kmalloc (len, GFP_KERNEL);
+        buf = vmalloc(len);
         if (!buf) {
-                printk (KERN_ERR "nand_bbt: Out of memory\n");
-                kfree (this->bbt);
+                printk(KERN_ERR "nand_bbt: Out of memory\n");
+                kfree(this->bbt);
                 this->bbt = NULL;
                 return -ENOMEM;
         }
 
         /* Is the bbt at a given page ? */
         if (td->options & NAND_BBT_ABSPAGE) {
-                res = read_abs_bbts (mtd, buf, td, md);
+                res = read_abs_bbts(mtd, buf, td, md);
         } else {
                 /* Search the bad block table using a pattern in oob */
-                res = search_read_bbts (mtd, buf, td, md);
+                res = search_read_bbts(mtd, buf, td, md);
         }
 
         if (res)
-                res = check_create (mtd, buf, bd);
+                res = check_create(mtd, buf, bd);
 
         /* Prevent the bbt regions from erasing / writing */
-        mark_bbt_region (mtd, td);
+        mark_bbt_region(mtd, td);
         if (md)
-                mark_bbt_region (mtd, md);
+                mark_bbt_region(mtd, md);
 
-        kfree (buf);
+        vfree(buf);
         return res;
 }
 
-
 /**
  * nand_update_bbt - [NAND Interface] update bad block table(s)
  * @mtd:        MTD device structure
@@ -909,7 +1020,7 @@ int nand_scan_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd)
  *
  * The function updates the bad block table(s)
 */
-int nand_update_bbt (struct mtd_info *mtd, loff_t offs)
+int nand_update_bbt(struct mtd_info *mtd, loff_t offs)
 {
         struct nand_chip *this = mtd->priv;
         int len, res = 0, writeops = 0;
@@ -925,9 +1036,9 @@ int nand_update_bbt (struct mtd_info *mtd, loff_t offs)
         /* Allocate a temporary buffer for one eraseblock incl. oob */
         len = (1 << this->bbt_erase_shift);
         len += (len >> this->page_shift) * mtd->oobsize;
-        buf = kmalloc (len, GFP_KERNEL);
+        buf = kmalloc(len, GFP_KERNEL);
         if (!buf) {
-                printk (KERN_ERR "nand_update_bbt: Out of memory\n");
+                printk(KERN_ERR "nand_update_bbt: Out of memory\n");
                 return -ENOMEM;
         }
 
@@ -935,7 +1046,7 @@ int nand_update_bbt (struct mtd_info *mtd, loff_t offs)
 
         /* Do we have a bbt per chip ? */
         if (td->options & NAND_BBT_PERCHIP) {
-                chip = (int) (offs >> this->chip_shift);
+                chip = (int)(offs >> this->chip_shift);
                 chipsel = chip;
         } else {
                 chip = 0;
@@ -948,17 +1059,17 @@ int nand_update_bbt (struct mtd_info *mtd, loff_t offs)
 
         /* Write the bad block table to the device ? */
         if ((writeops & 0x01) && (td->options & NAND_BBT_WRITE)) {
-                res = write_bbt (mtd, buf, td, md, chipsel);
+                res = write_bbt(mtd, buf, td, md, chipsel);
                 if (res < 0)
                         goto out;
         }
         /* Write the mirror bad block table to the device ? */
         if ((writeops & 0x02) && md && (md->options & NAND_BBT_WRITE)) {
-                res = write_bbt (mtd, buf, md, td, chipsel);
+                res = write_bbt(mtd, buf, md, td, chipsel);
         }
 
-out:
-        kfree (buf);
+ out:
+        kfree(buf);
         return res;
 }
 
@@ -981,14 +1092,14 @@ static struct nand_bbt_descr largepage_memorybased = {
 };
 
 static struct nand_bbt_descr smallpage_flashbased = {
-        .options = NAND_BBT_SCANEMPTY | NAND_BBT_SCANALLPAGES,
+        .options = NAND_BBT_SCAN2NDPAGE,
         .offs = 5,
         .len = 1,
         .pattern = scan_ff_pattern
 };
 
 static struct nand_bbt_descr largepage_flashbased = {
-        .options = NAND_BBT_SCANEMPTY | NAND_BBT_SCANALLPAGES,
+        .options = NAND_BBT_SCAN2NDPAGE,
         .offs = 0,
         .len = 2,
         .pattern = scan_ff_pattern
@@ -1036,7 +1147,7 @@ static struct nand_bbt_descr bbt_mirror_descr = {
  * support for the device and calls the nand_scan_bbt function
  *
 */
-int nand_default_bbt (struct mtd_info *mtd)
+int nand_default_bbt(struct mtd_info *mtd)
 {
         struct nand_chip *this = mtd->priv;
 
@@ -1046,7 +1157,7 @@ int nand_default_bbt (struct mtd_info *mtd)
          * of the good / bad information, so we _must_ store
          * this information in a good / bad table during
          * startup
-        */
+         */
         if (this->options & NAND_IS_AND) {
                 /* Use the default pattern descriptors */
                 if (!this->bbt_td) {
@@ -1054,10 +1165,9 @@ int nand_default_bbt (struct mtd_info *mtd)
                         this->bbt_md = &bbt_mirror_descr;
                 }
                 this->options |= NAND_USE_FLASH_BBT;
-                return nand_scan_bbt (mtd, &agand_flashbased);
+                return nand_scan_bbt(mtd, &agand_flashbased);
         }
 
-
         /* Is a flash based bad block table requested ? */
         if (this->options & NAND_USE_FLASH_BBT) {
                 /* Use the default pattern descriptors */
@@ -1066,18 +1176,17 @@ int nand_default_bbt (struct mtd_info *mtd)
                         this->bbt_md = &bbt_mirror_descr;
                 }
                 if (!this->badblock_pattern) {
-                        this->badblock_pattern = (mtd->oobblock > 512) ?
-                                &largepage_flashbased : &smallpage_flashbased;
+                        this->badblock_pattern = (mtd->writesize > 512) ? &largepage_flashbased : &smallpage_flashbased;
                 }
         } else {
                 this->bbt_td = NULL;
                 this->bbt_md = NULL;
                 if (!this->badblock_pattern) {
-                        this->badblock_pattern = (mtd->oobblock > 512) ?
-                                &largepage_memorybased : &smallpage_memorybased;
+                        this->badblock_pattern = (mtd->writesize > 512) ?
+                            &largepage_memorybased : &smallpage_memorybased;
                 }
         }
-        return nand_scan_bbt (mtd, this->badblock_pattern);
+        return nand_scan_bbt(mtd, this->badblock_pattern);
 }
 
 /**
@@ -1087,26 +1196,29 @@ int nand_default_bbt (struct mtd_info *mtd)
  * @allowbbt:   allow access to bad block table region
  *
 */
-int nand_isbad_bbt (struct mtd_info *mtd, loff_t offs, int allowbbt)
+int nand_isbad_bbt(struct mtd_info *mtd, loff_t offs, int allowbbt)
 {
         struct nand_chip *this = mtd->priv;
         int block;
-        uint8_t res;
+        uint8_t res;
 
         /* Get block number * 2 */
-        block = (int) (offs >> (this->bbt_erase_shift - 1));
+        block = (int)(offs >> (this->bbt_erase_shift - 1));
         res = (this->bbt[block >> 3] >> (block & 0x06)) & 0x03;
 
-        DEBUG (MTD_DEBUG_LEVEL2, "nand_isbad_bbt(): bbt info for offs 0x%08x: (block %d) 0x%02x\n",
-                (unsigned int)offs, block >> 1, res);
+        DEBUG(MTD_DEBUG_LEVEL2, "nand_isbad_bbt(): bbt info for offs 0x%08x: (block %d) 0x%02x\n",
+              (unsigned int)offs, block >> 1, res);
 
         switch ((int)res) {
-        case 0x00:      return 0;
-        case 0x01:      return 1;
-        case 0x02:      return allowbbt ? 0 : 1;
+        case 0x00:
+                return 0;
+        case 0x01:
+                return 1;
+        case 0x02:
+                return allowbbt ? 0 : 1;
         }
         return 1;
 }
 
-EXPORT_SYMBOL (nand_scan_bbt);
-EXPORT_SYMBOL (nand_default_bbt);
+EXPORT_SYMBOL(nand_scan_bbt);
+EXPORT_SYMBOL(nand_default_bbt);
diff --git a/drivers/mtd/nand/nand_ecc.c b/drivers/mtd/nand/nand_ecc.c
index 40ac909150a3..2a163e4084df 100644
--- a/drivers/mtd/nand/nand_ecc.c
+++ b/drivers/mtd/nand/nand_ecc.c
@@ -7,6 +7,8 @@
  * Copyright (C) 2000-2004 Steven J. Hill (sjhill@realitydiluted.com)
  *                         Toshiba America Electronics Components, Inc.
  *
+ * Copyright (C) 2006 Thomas Gleixner <tglx@linutronix.de>
+ *
  * $Id: nand_ecc.c,v 1.15 2005/11/07 11:14:30 gleixner Exp $
  *
  * This file is free software; you can redistribute it and/or modify it
@@ -62,90 +64,76 @@ static const u_char nand_ecc_precalc_table[] = {
         0x00, 0x55, 0x56, 0x03, 0x59, 0x0c, 0x0f, 0x5a, 0x5a, 0x0f, 0x0c, 0x59, 0x03, 0x56, 0x55, 0x00
 };
 
-
 /**
- * nand_trans_result - [GENERIC] create non-inverted ECC
- * @reg2:       line parity reg 2
- * @reg3:       line parity reg 3
- * @ecc_code:   ecc
- *
- * Creates non-inverted ECC code from line parity
- */
-static void nand_trans_result(u_char reg2, u_char reg3,
-        u_char *ecc_code)
-{
-        u_char a, b, i, tmp1, tmp2;
-
-        /* Initialize variables */
-        a = b = 0x80;
-        tmp1 = tmp2 = 0;
-
-        /* Calculate first ECC byte */
-        for (i = 0; i < 4; i++) {
-                if (reg3 & a)           /* LP15,13,11,9 --> ecc_code[0] */
-                        tmp1 |= b;
-                b >>= 1;
-                if (reg2 & a)           /* LP14,12,10,8 --> ecc_code[0] */
-                        tmp1 |= b;
-                b >>= 1;
-                a >>= 1;
-        }
-
-        /* Calculate second ECC byte */
-        b = 0x80;
-        for (i = 0; i < 4; i++) {
-                if (reg3 & a)           /* LP7,5,3,1 --> ecc_code[1] */
-                        tmp2 |= b;
-                b >>= 1;
-                if (reg2 & a)           /* LP6,4,2,0 --> ecc_code[1] */
-                        tmp2 |= b;
-                b >>= 1;
-                a >>= 1;
-        }
-
-        /* Store two of the ECC bytes */
-        ecc_code[0] = tmp1;
-        ecc_code[1] = tmp2;
-}
-
-/**
- * nand_calculate_ecc - [NAND Interface] Calculate 3 byte ECC code for 256 byte block
+ * nand_calculate_ecc - [NAND Interface] Calculate 3 byte ECC code
+ *                      for 256 byte block
  * @mtd:        MTD block structure
  * @dat:        raw data
  * @ecc_code:   buffer for ECC
  */
-int nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code)
+int nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
+                       u_char *ecc_code)
 {
-        u_char idx, reg1, reg2, reg3;
-        int j;
+        uint8_t idx, reg1, reg2, reg3, tmp1, tmp2;
+        int i;
 
         /* Initialize variables */
         reg1 = reg2 = reg3 = 0;
-        ecc_code[0] = ecc_code[1] = ecc_code[2] = 0;
 
         /* Build up column parity */
-        for(j = 0; j < 256; j++) {
-
+        for(i = 0; i < 256; i++) {
                 /* Get CP0 - CP5 from table */
-                idx = nand_ecc_precalc_table[dat[j]];
+                idx = nand_ecc_precalc_table[*dat++];
                 reg1 ^= (idx & 0x3f);
 
                 /* All bit XOR = 1 ? */
                 if (idx & 0x40) {
-                        reg3 ^= (u_char) j;
-                        reg2 ^= ~((u_char) j);
+                        reg3 ^= (uint8_t) i;
+                        reg2 ^= ~((uint8_t) i);
                 }
         }
 
         /* Create non-inverted ECC code from line parity */
-        nand_trans_result(reg2, reg3, ecc_code);
+        tmp1  = (reg3 & 0x80) >> 0; /* B7 -> B7 */
+        tmp1 |= (reg2 & 0x80) >> 1; /* B7 -> B6 */
+        tmp1 |= (reg3 & 0x40) >> 1; /* B6 -> B5 */
+        tmp1 |= (reg2 & 0x40) >> 2; /* B6 -> B4 */
+        tmp1 |= (reg3 & 0x20) >> 2; /* B5 -> B3 */
+        tmp1 |= (reg2 & 0x20) >> 3; /* B5 -> B2 */
+        tmp1 |= (reg3 & 0x10) >> 3; /* B4 -> B1 */
+        tmp1 |= (reg2 & 0x10) >> 4; /* B4 -> B0 */
+
+        tmp2  = (reg3 & 0x08) << 4; /* B3 -> B7 */
+        tmp2 |= (reg2 & 0x08) << 3; /* B3 -> B6 */
+        tmp2 |= (reg3 & 0x04) << 3; /* B2 -> B5 */
+        tmp2 |= (reg2 & 0x04) << 2; /* B2 -> B4 */
+        tmp2 |= (reg3 & 0x02) << 2; /* B1 -> B3 */
+        tmp2 |= (reg2 & 0x02) << 1; /* B1 -> B2 */
+        tmp2 |= (reg3 & 0x01) << 1; /* B0 -> B1 */
+        tmp2 |= (reg2 & 0x01) << 0; /* B7 -> B0 */
 
         /* Calculate final ECC code */
-        ecc_code[0] = ~ecc_code[0];
-        ecc_code[1] = ~ecc_code[1];
+#ifdef CONFIG_NAND_ECC_SMC
+        ecc_code[0] = ~tmp2;
+        ecc_code[1] = ~tmp1;
+#else
+        ecc_code[0] = ~tmp1;
+        ecc_code[1] = ~tmp2;
+#endif
         ecc_code[2] = ((~reg1) << 2) | 0x03;
+
         return 0;
 }
+EXPORT_SYMBOL(nand_calculate_ecc);
+
+static inline int countbits(uint32_t byte)
+{
+        int res = 0;
+
+        for (;byte; byte >>= 1)
+                res += byte & 0x01;
+        return res;
+}
 
 /**
  * nand_correct_data - [NAND Interface] Detect and correct bit error(s)
@@ -156,93 +144,54 @@ int nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code
  *
  * Detect and correct a 1 bit error for 256 byte block
  */
-int nand_correct_data(struct mtd_info *mtd, u_char *dat, u_char *read_ecc, u_char *calc_ecc)
+int nand_correct_data(struct mtd_info *mtd, u_char *dat,
+                      u_char *read_ecc, u_char *calc_ecc)
 {
-        u_char a, b, c, d1, d2, d3, add, bit, i;
+        uint8_t s0, s1, s2;
+
+#ifdef CONFIG_NAND_ECC_SMC
+        s0 = calc_ecc[0] ^ read_ecc[0];
+        s1 = calc_ecc[1] ^ read_ecc[1];
+        s2 = calc_ecc[2] ^ read_ecc[2];
+#else
+        s1 = calc_ecc[0] ^ read_ecc[0];
+        s0 = calc_ecc[1] ^ read_ecc[1];
+        s2 = calc_ecc[2] ^ read_ecc[2];
+#endif
+        if ((s0 | s1 | s2) == 0)
+                return 0;
 
-        /* Do error detection */
-        d1 = calc_ecc[0] ^ read_ecc[0];
-        d2 = calc_ecc[1] ^ read_ecc[1];
-        d3 = calc_ecc[2] ^ read_ecc[2];
+        /* Check for a single bit error */
+        if( ((s0 ^ (s0 >> 1)) & 0x55) == 0x55 &&
+            ((s1 ^ (s1 >> 1)) & 0x55) == 0x55 &&
+            ((s2 ^ (s2 >> 1)) & 0x54) == 0x54) {
 
-        if ((d1 | d2 | d3) == 0) {
-                /* No errors */
-                return 0;
-        }
-        else {
-                a = (d1 ^ (d1 >> 1)) & 0x55;
-                b = (d2 ^ (d2 >> 1)) & 0x55;
-                c = (d3 ^ (d3 >> 1)) & 0x54;
-
-                /* Found and will correct single bit error in the data */
-                if ((a == 0x55) && (b == 0x55) && (c == 0x54)) {
-                        c = 0x80;
-                        add = 0;
-                        a = 0x80;
-                        for (i=0; i<4; i++) {
-                                if (d1 & c)
-                                        add |= a;
-                                c >>= 2;
-                                a >>= 1;
-                        }
-                        c = 0x80;
-                        for (i=0; i<4; i++) {
-                                if (d2 & c)
-                                        add |= a;
-                                c >>= 2;
-                                a >>= 1;
-                        }
-                        bit = 0;
-                        b = 0x04;
-                        c = 0x80;
-                        for (i=0; i<3; i++) {
-                                if (d3 & c)
-                                        bit |= b;
-                                c >>= 2;
-                                b >>= 1;
-                        }
-                        b = 0x01;
-                        a = dat[add];
-                        a ^= (b << bit);
-                        dat[add] = a;
-                        return 1;
-                }
-                else {
-                        i = 0;
-                        while (d1) {
-                                if (d1 & 0x01)
-                                        ++i;
-                                d1 >>= 1;
-                        }
-                        while (d2) {
-                                if (d2 & 0x01)
-                                        ++i;
-                                d2 >>= 1;
-                        }
-                        while (d3) {
-                                if (d3 & 0x01)
-                                        ++i;
-                                d3 >>= 1;
-                        }
-                        if (i == 1) {
-                                /* ECC Code Error Correction */
-                                read_ecc[0] = calc_ecc[0];
-                                read_ecc[1] = calc_ecc[1];
-                                read_ecc[2] = calc_ecc[2];
-                                return 2;
-                        }
-                        else {
-                                /* Uncorrectable Error */
-                                return -1;
-                        }
-                }
+                uint32_t byteoffs, bitnum;
+
+                byteoffs = (s1 << 0) & 0x80;
+                byteoffs |= (s1 << 1) & 0x40;
+                byteoffs |= (s1 << 2) & 0x20;
+                byteoffs |= (s1 << 3) & 0x10;
+
+                byteoffs |= (s0 >> 4) & 0x08;
+                byteoffs |= (s0 >> 3) & 0x04;
+                byteoffs |= (s0 >> 2) & 0x02;
+                byteoffs |= (s0 >> 1) & 0x01;
+
+                bitnum = (s2 >> 5) & 0x04;
+                bitnum |= (s2 >> 4) & 0x02;
+                bitnum |= (s2 >> 3) & 0x01;
+
+                dat[byteoffs] ^= (1 << bitnum);
+
+                return 1;
         }
 
-        /* Should never happen */
+        if(countbits(s0 | ((uint32_t)s1 << 8) | ((uint32_t)s2 <<16)) == 1)
+                return 1;
+
         return -1;
 }
-
-EXPORT_SYMBOL(nand_calculate_ecc);
 EXPORT_SYMBOL(nand_correct_data);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/nand/nand_ids.c b/drivers/mtd/nand/nand_ids.c
index dbc7e55a4247..2e2cdf2fc91d 100644
--- a/drivers/mtd/nand/nand_ids.c
+++ b/drivers/mtd/nand/nand_ids.c
@@ -18,99 +18,110 @@
 *       Name. ID code, pagesize, chipsize in MegaByte, eraseblock size,
 *       options
 *
-*       Pagesize; 0, 256, 512
-*       0       get this information from the extended chip ID
+*       Pagesize; 0, 256, 512
+*       0       get this information from the extended chip ID
 +       256     256 Byte page size
 *       512     512 Byte page size
 */
 struct nand_flash_dev nand_flash_ids[] = {
-        {"NAND 1MiB 5V 8-bit",          0x6e, 256, 1, 0x1000, 0},
-        {"NAND 2MiB 5V 8-bit",          0x64, 256, 2, 0x1000, 0},
-        {"NAND 4MiB 5V 8-bit",          0x6b, 512, 4, 0x2000, 0},
-        {"NAND 1MiB 3,3V 8-bit",        0xe8, 256, 1, 0x1000, 0},
-        {"NAND 1MiB 3,3V 8-bit",        0xec, 256, 1, 0x1000, 0},
-        {"NAND 2MiB 3,3V 8-bit",        0xea, 256, 2, 0x1000, 0},
-        {"NAND 4MiB 3,3V 8-bit",        0xd5, 512, 4, 0x2000, 0},
-        {"NAND 4MiB 3,3V 8-bit",        0xe3, 512, 4, 0x2000, 0},
-        {"NAND 4MiB 3,3V 8-bit",        0xe5, 512, 4, 0x2000, 0},
-        {"NAND 8MiB 3,3V 8-bit",        0xd6, 512, 8, 0x2000, 0},
-
-        {"NAND 8MiB 1,8V 8-bit",        0x39, 512, 8, 0x2000, 0},
-        {"NAND 8MiB 3,3V 8-bit",        0xe6, 512, 8, 0x2000, 0},
-        {"NAND 8MiB 1,8V 16-bit",       0x49, 512, 8, 0x2000, NAND_BUSWIDTH_16},
-        {"NAND 8MiB 3,3V 16-bit",       0x59, 512, 8, 0x2000, NAND_BUSWIDTH_16},
-
-        {"NAND 16MiB 1,8V 8-bit",       0x33, 512, 16, 0x4000, 0},
-        {"NAND 16MiB 3,3V 8-bit",       0x73, 512, 16, 0x4000, 0},
-        {"NAND 16MiB 1,8V 16-bit",      0x43, 512, 16, 0x4000, NAND_BUSWIDTH_16},
-        {"NAND 16MiB 3,3V 16-bit",      0x53, 512, 16, 0x4000, NAND_BUSWIDTH_16},
-
-        {"NAND 32MiB 1,8V 8-bit",       0x35, 512, 32, 0x4000, 0},
-        {"NAND 32MiB 3,3V 8-bit",       0x75, 512, 32, 0x4000, 0},
-        {"NAND 32MiB 1,8V 16-bit",      0x45, 512, 32, 0x4000, NAND_BUSWIDTH_16},
-        {"NAND 32MiB 3,3V 16-bit",      0x55, 512, 32, 0x4000, NAND_BUSWIDTH_16},
-
-        {"NAND 64MiB 1,8V 8-bit",       0x36, 512, 64, 0x4000, 0},
-        {"NAND 64MiB 3,3V 8-bit",       0x76, 512, 64, 0x4000, 0},
-        {"NAND 64MiB 1,8V 16-bit",      0x46, 512, 64, 0x4000, NAND_BUSWIDTH_16},
-        {"NAND 64MiB 3,3V 16-bit",      0x56, 512, 64, 0x4000, NAND_BUSWIDTH_16},
-
-        {"NAND 128MiB 1,8V 8-bit",      0x78, 512, 128, 0x4000, 0},
-        {"NAND 128MiB 1,8V 8-bit",      0x39, 512, 128, 0x4000, 0},
-        {"NAND 128MiB 3,3V 8-bit",      0x79, 512, 128, 0x4000, 0},
-        {"NAND 128MiB 1,8V 16-bit",     0x72, 512, 128, 0x4000, NAND_BUSWIDTH_16},
-        {"NAND 128MiB 1,8V 16-bit",     0x49, 512, 128, 0x4000, NAND_BUSWIDTH_16},
-        {"NAND 128MiB 3,3V 16-bit",     0x74, 512, 128, 0x4000, NAND_BUSWIDTH_16},
-        {"NAND 128MiB 3,3V 16-bit",     0x59, 512, 128, 0x4000, NAND_BUSWIDTH_16},
-
-        {"NAND 256MiB 3,3V 8-bit",      0x71, 512, 256, 0x4000, 0},
-
-        /* These are the new chips with large page size. The pagesize
-        * and the erasesize is determined from the extended id bytes
-        */
+        {"NAND 1MiB 5V 8-bit",          0x6e, 256, 1, 0x1000, 0},
+        {"NAND 2MiB 5V 8-bit",          0x64, 256, 2, 0x1000, 0},
+        {"NAND 4MiB 5V 8-bit",          0x6b, 512, 4, 0x2000, 0},
+        {"NAND 1MiB 3,3V 8-bit",        0xe8, 256, 1, 0x1000, 0},
+        {"NAND 1MiB 3,3V 8-bit",        0xec, 256, 1, 0x1000, 0},
+        {"NAND 2MiB 3,3V 8-bit",        0xea, 256, 2, 0x1000, 0},
+        {"NAND 4MiB 3,3V 8-bit",        0xd5, 512, 4, 0x2000, 0},
+        {"NAND 4MiB 3,3V 8-bit",        0xe3, 512, 4, 0x2000, 0},
+        {"NAND 4MiB 3,3V 8-bit",        0xe5, 512, 4, 0x2000, 0},
+        {"NAND 8MiB 3,3V 8-bit",        0xd6, 512, 8, 0x2000, 0},
+
+        {"NAND 8MiB 1,8V 8-bit",        0x39, 512, 8, 0x2000, 0},
+        {"NAND 8MiB 3,3V 8-bit",        0xe6, 512, 8, 0x2000, 0},
+        {"NAND 8MiB 1,8V 16-bit",       0x49, 512, 8, 0x2000, NAND_BUSWIDTH_16},
+        {"NAND 8MiB 3,3V 16-bit",       0x59, 512, 8, 0x2000, NAND_BUSWIDTH_16},
+
+        {"NAND 16MiB 1,8V 8-bit",       0x33, 512, 16, 0x4000, 0},
+        {"NAND 16MiB 3,3V 8-bit",       0x73, 512, 16, 0x4000, 0},
+        {"NAND 16MiB 1,8V 16-bit",      0x43, 512, 16, 0x4000, NAND_BUSWIDTH_16},
+        {"NAND 16MiB 3,3V 16-bit",      0x53, 512, 16, 0x4000, NAND_BUSWIDTH_16},
+
+        {"NAND 32MiB 1,8V 8-bit",       0x35, 512, 32, 0x4000, 0},
+        {"NAND 32MiB 3,3V 8-bit",       0x75, 512, 32, 0x4000, 0},
+        {"NAND 32MiB 1,8V 16-bit",      0x45, 512, 32, 0x4000, NAND_BUSWIDTH_16},
+        {"NAND 32MiB 3,3V 16-bit",      0x55, 512, 32, 0x4000, NAND_BUSWIDTH_16},
+
+        {"NAND 64MiB 1,8V 8-bit",       0x36, 512, 64, 0x4000, 0},
+        {"NAND 64MiB 3,3V 8-bit",       0x76, 512, 64, 0x4000, 0},
+        {"NAND 64MiB 1,8V 16-bit",      0x46, 512, 64, 0x4000, NAND_BUSWIDTH_16},
+        {"NAND 64MiB 3,3V 16-bit",      0x56, 512, 64, 0x4000, NAND_BUSWIDTH_16},
+
+        {"NAND 128MiB 1,8V 8-bit",      0x78, 512, 128, 0x4000, 0},
+        {"NAND 128MiB 1,8V 8-bit",      0x39, 512, 128, 0x4000, 0},
+        {"NAND 128MiB 3,3V 8-bit",      0x79, 512, 128, 0x4000, 0},
+        {"NAND 128MiB 1,8V 16-bit",     0x72, 512, 128, 0x4000, NAND_BUSWIDTH_16},
+        {"NAND 128MiB 1,8V 16-bit",     0x49, 512, 128, 0x4000, NAND_BUSWIDTH_16},
+        {"NAND 128MiB 3,3V 16-bit",     0x74, 512, 128, 0x4000, NAND_BUSWIDTH_16},
+        {"NAND 128MiB 3,3V 16-bit",     0x59, 512, 128, 0x4000, NAND_BUSWIDTH_16},
+
+        {"NAND 256MiB 3,3V 8-bit",      0x71, 512, 256, 0x4000, 0},
+
+        /*
+         * These are the new chips with large page size. The pagesize and the
+         * erasesize is determined from the extended id bytes
+         */
+#define LP_OPTIONS (NAND_SAMSUNG_LP_OPTIONS | NAND_NO_READRDY | NAND_NO_AUTOINCR)
+#define LP_OPTIONS16 (LP_OPTIONS | NAND_BUSWIDTH_16)
+
         /*512 Megabit */
-        {"NAND 64MiB 1,8V 8-bit",       0xA2, 0,  64, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_NO_AUTOINCR},
-        {"NAND 64MiB 3,3V 8-bit",       0xF2, 0,  64, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_NO_AUTOINCR},
-        {"NAND 64MiB 1,8V 16-bit",      0xB2, 0,  64, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_BUSWIDTH_16 | NAND_NO_AUTOINCR},
-        {"NAND 64MiB 3,3V 16-bit",      0xC2, 0,  64, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_BUSWIDTH_16 | NAND_NO_AUTOINCR},
+        {"NAND 64MiB 1,8V 8-bit",       0xA2, 0,  64, 0, LP_OPTIONS},
+        {"NAND 64MiB 3,3V 8-bit",       0xF2, 0,  64, 0, LP_OPTIONS},
+        {"NAND 64MiB 1,8V 16-bit",      0xB2, 0,  64, 0, LP_OPTIONS16},
+        {"NAND 64MiB 3,3V 16-bit",      0xC2, 0,  64, 0, LP_OPTIONS16},
 
         /* 1 Gigabit */
-        {"NAND 128MiB 1,8V 8-bit",      0xA1, 0, 128, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_NO_AUTOINCR},
-        {"NAND 128MiB 3,3V 8-bit",      0xF1, 0, 128, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_NO_AUTOINCR},
-        {"NAND 128MiB 1,8V 16-bit",     0xB1, 0, 128, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_BUSWIDTH_16 | NAND_NO_AUTOINCR},
-        {"NAND 128MiB 3,3V 16-bit",     0xC1, 0, 128, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_BUSWIDTH_16 | NAND_NO_AUTOINCR},
+        {"NAND 128MiB 1,8V 8-bit",      0xA1, 0, 128, 0, LP_OPTIONS},
+        {"NAND 128MiB 3,3V 8-bit",      0xF1, 0, 128, 0, LP_OPTIONS},
+        {"NAND 128MiB 1,8V 16-bit",     0xB1, 0, 128, 0, LP_OPTIONS16},
+        {"NAND 128MiB 3,3V 16-bit",     0xC1, 0, 128, 0, LP_OPTIONS16},
 
         /* 2 Gigabit */
-        {"NAND 256MiB 1,8V 8-bit",      0xAA, 0, 256, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_NO_AUTOINCR},
-        {"NAND 256MiB 3,3V 8-bit",      0xDA, 0, 256, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_NO_AUTOINCR},
-        {"NAND 256MiB 1,8V 16-bit",     0xBA, 0, 256, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_BUSWIDTH_16 | NAND_NO_AUTOINCR},
-        {"NAND 256MiB 3,3V 16-bit",     0xCA, 0, 256, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_BUSWIDTH_16 | NAND_NO_AUTOINCR},
+        {"NAND 256MiB 1,8V 8-bit",      0xAA, 0, 256, 0, LP_OPTIONS},
+        {"NAND 256MiB 3,3V 8-bit",      0xDA, 0, 256, 0, LP_OPTIONS},
+        {"NAND 256MiB 1,8V 16-bit",     0xBA, 0, 256, 0, LP_OPTIONS16},
+        {"NAND 256MiB 3,3V 16-bit",     0xCA, 0, 256, 0, LP_OPTIONS16},
 
         /* 4 Gigabit */
-        {"NAND 512MiB 1,8V 8-bit",      0xAC, 0, 512, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_NO_AUTOINCR},
-        {"NAND 512MiB 3,3V 8-bit",      0xDC, 0, 512, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_NO_AUTOINCR},
-        {"NAND 512MiB 1,8V 16-bit",     0xBC, 0, 512, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_BUSWIDTH_16 | NAND_NO_AUTOINCR},
-        {"NAND 512MiB 3,3V 16-bit",     0xCC, 0, 512, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_BUSWIDTH_16 | NAND_NO_AUTOINCR},
+        {"NAND 512MiB 1,8V 8-bit",      0xAC, 0, 512, 0, LP_OPTIONS},
+        {"NAND 512MiB 3,3V 8-bit",      0xDC, 0, 512, 0, LP_OPTIONS},
+        {"NAND 512MiB 1,8V 16-bit",     0xBC, 0, 512, 0, LP_OPTIONS16},
+        {"NAND 512MiB 3,3V 16-bit",     0xCC, 0, 512, 0, LP_OPTIONS16},
 
         /* 8 Gigabit */
-        {"NAND 1GiB 1,8V 8-bit",        0xA3, 0, 1024, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_NO_AUTOINCR},
-        {"NAND 1GiB 3,3V 8-bit",        0xD3, 0, 1024, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_NO_AUTOINCR},
-        {"NAND 1GiB 1,8V 16-bit",       0xB3, 0, 1024, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_BUSWIDTH_16 | NAND_NO_AUTOINCR},
-        {"NAND 1GiB 3,3V 16-bit",       0xC3, 0, 1024, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_BUSWIDTH_16 | NAND_NO_AUTOINCR},
+        {"NAND 1GiB 1,8V 8-bit",        0xA3, 0, 1024, 0, LP_OPTIONS},
+        {"NAND 1GiB 3,3V 8-bit",        0xD3, 0, 1024, 0, LP_OPTIONS},
+        {"NAND 1GiB 1,8V 16-bit",       0xB3, 0, 1024, 0, LP_OPTIONS16},
+        {"NAND 1GiB 3,3V 16-bit",       0xC3, 0, 1024, 0, LP_OPTIONS16},
 
         /* 16 Gigabit */
-        {"NAND 2GiB 1,8V 8-bit",        0xA5, 0, 2048, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_NO_AUTOINCR},
-        {"NAND 2GiB 3,3V 8-bit",        0xD5, 0, 2048, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_NO_AUTOINCR},
-        {"NAND 2GiB 1,8V 16-bit",       0xB5, 0, 2048, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_BUSWIDTH_16 | NAND_NO_AUTOINCR},
-        {"NAND 2GiB 3,3V 16-bit",       0xC5, 0, 2048, 0, NAND_SAMSUNG_LP_OPTIONS | NAND_BUSWIDTH_16 | NAND_NO_AUTOINCR},
-
-        /* Renesas AND 1 Gigabit. Those chips do not support extended id and have a strange page/block layout !
-         * The chosen minimum erasesize is 4 * 2 * 2048 = 16384 Byte, as those chips have an array of 4 page planes
-         * 1 block = 2 pages, but due to plane arrangement the blocks 0-3 consists of page 0 + 4,1 + 5, 2 + 6, 3 + 7
-         * Anyway JFFS2 would increase the eraseblock size so we chose a combined one which can be erased in one go
-         * There are more speed improvements for reads and writes possible, but not implemented now
+        {"NAND 2GiB 1,8V 8-bit",        0xA5, 0, 2048, 0, LP_OPTIONS},
+        {"NAND 2GiB 3,3V 8-bit",        0xD5, 0, 2048, 0, LP_OPTIONS},
+        {"NAND 2GiB 1,8V 16-bit",       0xB5, 0, 2048, 0, LP_OPTIONS16},
+        {"NAND 2GiB 3,3V 16-bit",       0xC5, 0, 2048, 0, LP_OPTIONS16},
+
+        /*
+         * Renesas AND 1 Gigabit. Those chips do not support extended id and
+         * have a strange page/block layout !  The chosen minimum erasesize is
+         * 4 * 2 * 2048 = 16384 Byte, as those chips have an array of 4 page
+         * planes 1 block = 2 pages, but due to plane arrangement the blocks
+         * 0-3 consists of page 0 + 4,1 + 5, 2 + 6, 3 + 7 Anyway JFFS2 would
+         * increase the eraseblock size so we chose a combined one which can be
+         * erased in one go There are more speed improvements for reads and
+         * writes possible, but not implemented now
          */
-        {"AND 128MiB 3,3V 8-bit",       0x01, 2048, 128, 0x4000, NAND_IS_AND | NAND_NO_AUTOINCR | NAND_4PAGE_ARRAY | BBT_AUTO_REFRESH},
+        {"AND 128MiB 3,3V 8-bit",       0x01, 2048, 128, 0x4000,
+         NAND_IS_AND | NAND_NO_AUTOINCR |NAND_NO_READRDY | NAND_4PAGE_ARRAY |
+         BBT_AUTO_REFRESH
+        },
 
         {NULL,}
 };
@@ -125,13 +136,13 @@ struct nand_manufacturers nand_manuf_ids[] = {
         {NAND_MFR_NATIONAL, "National"},
         {NAND_MFR_RENESAS, "Renesas"},
         {NAND_MFR_STMICRO, "ST Micro"},
-        {NAND_MFR_HYNIX, "Hynix"},
+        {NAND_MFR_HYNIX, "Hynix"},
         {0x0, "Unknown"}
 };
 
-EXPORT_SYMBOL (nand_manuf_ids);
-EXPORT_SYMBOL (nand_flash_ids);
+EXPORT_SYMBOL(nand_manuf_ids);
+EXPORT_SYMBOL(nand_flash_ids);
 
-MODULE_LICENSE ("GPL");
-MODULE_AUTHOR ("Thomas Gleixner <tglx@linutronix.de>");
-MODULE_DESCRIPTION ("Nand device & manufacturer ID's");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Thomas Gleixner <tglx@linutronix.de>");
+MODULE_DESCRIPTION("Nand device & manufacturer IDs");
diff --git a/drivers/mtd/nand/nandsim.c b/drivers/mtd/nand/nandsim.c
index a0af92cc7efd..ebd64abc8be8 100644
--- a/drivers/mtd/nand/nandsim.c
+++ b/drivers/mtd/nand/nandsim.c
@@ -369,7 +369,7 @@ init_nandsim(struct mtd_info *mtd)
         /* Initialize the NAND flash parameters */
         ns->busw = chip->options & NAND_BUSWIDTH_16 ? 16 : 8;
         ns->geom.totsz    = mtd->size;
-        ns->geom.pgsz     = mtd->oobblock;
+        ns->geom.pgsz     = mtd->writesize;
         ns->geom.oobsz    = mtd->oobsize;
         ns->geom.secsz    = mtd->erasesize;
         ns->geom.pgszoob  = ns->geom.pgsz + ns->geom.oobsz;
@@ -1071,68 +1071,6 @@ switch_state(struct nandsim *ns)
         }
 }
 
-static void
-ns_hwcontrol(struct mtd_info *mtd, int cmd)
-{
-        struct nandsim *ns = (struct nandsim *)((struct nand_chip *)mtd->priv)->priv;
-
-        switch (cmd) {
-
-        /* set CLE line high */
-        case NAND_CTL_SETCLE:
-                NS_DBG("ns_hwcontrol: start command latch cycles\n");
-                ns->lines.cle  = 1;
-                break;
-
-        /* set CLE line low */
-        case NAND_CTL_CLRCLE:
-                NS_DBG("ns_hwcontrol: stop command latch cycles\n");
-                ns->lines.cle  = 0;
-                break;
-
-        /* set ALE line high */
-        case NAND_CTL_SETALE:
-                NS_DBG("ns_hwcontrol: start address latch cycles\n");
-                ns->lines.ale   = 1;
-                break;
-
-        /* set ALE line low */
-        case NAND_CTL_CLRALE:
-                NS_DBG("ns_hwcontrol: stop address latch cycles\n");
-                ns->lines.ale  = 0;
-                break;
-
-        /* set WP line high */
-        case NAND_CTL_SETWP:
-                NS_DBG("ns_hwcontrol: enable write protection\n");
-                ns->lines.wp = 1;
-                break;
-
-        /* set WP line low */
-        case NAND_CTL_CLRWP:
-                NS_DBG("ns_hwcontrol: disable write protection\n");
-                ns->lines.wp = 0;
-                break;
-
-        /* set CE line low */
-        case NAND_CTL_SETNCE:
-                NS_DBG("ns_hwcontrol: enable chip\n");
-                ns->lines.ce = 1;
-                break;
-
-        /* set CE line high */
-        case NAND_CTL_CLRNCE:
-                NS_DBG("ns_hwcontrol: disable chip\n");
-                ns->lines.ce = 0;
-                break;
-
-        default:
-                NS_ERR("hwcontrol: unknown command\n");
-        }
-
-        return;
-}
-
 static u_char
 ns_nand_read_byte(struct mtd_info *mtd)
 {
@@ -1359,6 +1297,18 @@ ns_nand_write_byte(struct mtd_info *mtd, u_char byte)
         return;
 }
 
+static void ns_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int bitmask)
+{
+        struct nandsim *ns = ((struct nand_chip *)mtd->priv)->priv;
+
+        ns->lines.cle = bitmask & NAND_CLE ? 1 : 0;
+        ns->lines.ale = bitmask & NAND_ALE ? 1 : 0;
+        ns->lines.ce = bitmask & NAND_NCE ? 1 : 0;
+
+        if (cmd != NAND_CMD_NONE)
+                ns_nand_write_byte(mtd, cmd);
+}
+
 static int
 ns_device_ready(struct mtd_info *mtd)
 {
@@ -1377,17 +1327,6 @@ ns_nand_read_word(struct mtd_info *mtd)
 }
 
 static void
-ns_nand_write_word(struct mtd_info *mtd, uint16_t word)
-{
-        struct nand_chip *chip = (struct nand_chip *)mtd->priv;
-
-        NS_DBG("write_word\n");
-
-        chip->write_byte(mtd, word & 0xFF);
-        chip->write_byte(mtd, word >> 8);
-}
-
-static void
 ns_nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
 {
         struct nandsim *ns = (struct nandsim *)((struct nand_chip *)mtd->priv)->priv;
@@ -1514,16 +1453,14 @@ static int __init ns_init_module(void)
         /*
          * Register simulator's callbacks.
          */
-        chip->hwcontrol  = ns_hwcontrol;
+        chip->cmd_ctrl   = ns_hwcontrol;
         chip->read_byte  = ns_nand_read_byte;
         chip->dev_ready  = ns_device_ready;
-        chip->write_byte = ns_nand_write_byte;
         chip->write_buf  = ns_nand_write_buf;
         chip->read_buf   = ns_nand_read_buf;
         chip->verify_buf = ns_nand_verify_buf;
-        chip->write_word = ns_nand_write_word;
         chip->read_word  = ns_nand_read_word;
-        chip->eccmode    = NAND_ECC_SOFT;
+        chip->ecc.mode   = NAND_ECC_SOFT;
         chip->options   |= NAND_SKIP_BBTSCAN;
 
         /*
@@ -1546,6 +1483,8 @@ static int __init ns_init_module(void)
                 chip->options |= NAND_BUSWIDTH_16;
         }
 
+        nsmtd->owner = THIS_MODULE;
+
         if ((retval = nand_scan(nsmtd, 1)) != 0) {
                 NS_ERR("can't register NAND Simulator\n");
                 if (retval > 0)
diff --git a/drivers/mtd/nand/ndfc.c b/drivers/mtd/nand/ndfc.c
new file mode 100644
index 000000000000..fe8d38514ba6
--- /dev/null
+++ b/drivers/mtd/nand/ndfc.c
@@ -0,0 +1,311 @@
+/*
+ *  drivers/mtd/ndfc.c
+ *
+ *  Overview:
+ *   Platform independend driver for NDFC (NanD Flash Controller)
+ *   integrated into EP440 cores
+ *
+ *  Author: Thomas Gleixner
+ *
+ *  Copyright 2006 IBM
+ *
+ *  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.
+ *
+ */
+#include <linux/module.h>
+#include <linux/mtd/nand.h>
+#include <linux/mtd/nand_ecc.h>
+#include <linux/mtd/partitions.h>
+#include <linux/mtd/ndfc.h>
+#include <linux/mtd/mtd.h>
+#include <linux/platform_device.h>
+
+#include <asm/io.h>
+#include <asm/ibm44x.h>
+
+struct ndfc_nand_mtd {
+        struct mtd_info                 mtd;
+        struct nand_chip                chip;
+        struct platform_nand_chip       *pl_chip;
+};
+
+static struct ndfc_nand_mtd ndfc_mtd[NDFC_MAX_BANKS];
+
+struct ndfc_controller {
+        void __iomem            *ndfcbase;
+        struct nand_hw_control  ndfc_control;
+        atomic_t                childs_active;
+};
+
+static struct ndfc_controller ndfc_ctrl;
+
+static void ndfc_select_chip(struct mtd_info *mtd, int chip)
+{
+        uint32_t ccr;
+        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        struct nand_chip *nandchip = mtd->priv;
+        struct ndfc_nand_mtd *nandmtd = nandchip->priv;
+        struct platform_nand_chip *pchip = nandmtd->pl_chip;
+
+        ccr = __raw_readl(ndfc->ndfcbase + NDFC_CCR);
+        if (chip >= 0) {
+                ccr &= ~NDFC_CCR_BS_MASK;
+                ccr |= NDFC_CCR_BS(chip + pchip->chip_offset);
+        } else
+                ccr |= NDFC_CCR_RESET_CE;
+        writel(ccr, ndfc->ndfcbase + NDFC_CCR);
+}
+
+static void ndfc_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl)
+{
+        struct nand_chip *chip = mtd->priv;
+
+        if (cmd == NAND_CMD_NONE)
+                return;
+
+        if (ctrl & NAND_CLE)
+                writel(cmd & 0xFF, chip->IO_ADDR_W + NDFC_CMD);
+        else
+                writel(cmd & 0xFF, chip->IO_ADDR_W + NDFC_ALE);
+}
+
+static int ndfc_ready(struct mtd_info *mtd)
+{
+        struct ndfc_controller *ndfc = &ndfc_ctrl;
+
+        return __raw_readl(ndfc->ndfcbase + NDFC_STAT) & NDFC_STAT_IS_READY;
+}
+
+static void ndfc_enable_hwecc(struct mtd_info *mtd, int mode)
+{
+        uint32_t ccr;
+        struct ndfc_controller *ndfc = &ndfc_ctrl;
+
+        ccr = __raw_readl(ndfc->ndfcbase + NDFC_CCR);
+        ccr |= NDFC_CCR_RESET_ECC;
+        __raw_writel(ccr, ndfc->ndfcbase + NDFC_CCR);
+        wmb();
+}
+
+static int ndfc_calculate_ecc(struct mtd_info *mtd,
+                              const u_char *dat, u_char *ecc_code)
+{
+        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        uint32_t ecc;
+        uint8_t *p = (uint8_t *)&ecc;
+
+        wmb();
+        ecc = __raw_readl(ndfc->ndfcbase + NDFC_ECC);
+        ecc_code[0] = p[1];
+        ecc_code[1] = p[2];
+        ecc_code[2] = p[3];
+
+        return 0;
+}
+
+/*
+ * Speedups for buffer read/write/verify
+ *
+ * NDFC allows 32bit read/write of data. So we can speed up the buffer
+ * functions. No further checking, as nand_base will always read/write
+ * page aligned.
+ */
+static void ndfc_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
+{
+        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        uint32_t *p = (uint32_t *) buf;
+
+        for(;len > 0; len -= 4)
+                *p++ = __raw_readl(ndfc->ndfcbase + NDFC_DATA);
+}
+
+static void ndfc_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
+{
+        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        uint32_t *p = (uint32_t *) buf;
+
+        for(;len > 0; len -= 4)
+                __raw_writel(*p++, ndfc->ndfcbase + NDFC_DATA);
+}
+
+static int ndfc_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
+{
+        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        uint32_t *p = (uint32_t *) buf;
+
+        for(;len > 0; len -= 4)
+                if (*p++ != __raw_readl(ndfc->ndfcbase + NDFC_DATA))
+                        return -EFAULT;
+        return 0;
+}
+
+/*
+ * Initialize chip structure
+ */
+static void ndfc_chip_init(struct ndfc_nand_mtd *mtd)
+{
+        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        struct nand_chip *chip = &mtd->chip;
+
+        chip->IO_ADDR_R = ndfc->ndfcbase + NDFC_DATA;
+        chip->IO_ADDR_W = ndfc->ndfcbase + NDFC_DATA;
+        chip->cmd_ctrl = ndfc_hwcontrol;
+        chip->dev_ready = ndfc_ready;
+        chip->select_chip = ndfc_select_chip;
+        chip->chip_delay = 50;
+        chip->priv = mtd;
+        chip->options = mtd->pl_chip->options;
+        chip->controller = &ndfc->ndfc_control;
+        chip->read_buf = ndfc_read_buf;
+        chip->write_buf = ndfc_write_buf;
+        chip->verify_buf = ndfc_verify_buf;
+        chip->ecc.correct = nand_correct_data;
+        chip->ecc.hwctl = ndfc_enable_hwecc;
+        chip->ecc.calculate = ndfc_calculate_ecc;
+        chip->ecc.mode = NAND_ECC_HW;
+        chip->ecc.size = 256;
+        chip->ecc.bytes = 3;
+        chip->ecclayout = mtd->pl_chip->ecclayout;
+        mtd->mtd.priv = chip;
+        mtd->mtd.owner = THIS_MODULE;
+}
+
+static int ndfc_chip_probe(struct platform_device *pdev)
+{
+        struct platform_nand_chip *nc = pdev->dev.platform_data;
+        struct ndfc_chip_settings *settings = nc->priv;
+        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        struct ndfc_nand_mtd *nandmtd;
+
+        if (nc->chip_offset >= NDFC_MAX_BANKS || nc->nr_chips > NDFC_MAX_BANKS)
+                return -EINVAL;
+
+        /* Set the bank settings */
+        __raw_writel(settings->bank_settings,
+                     ndfc->ndfcbase + NDFC_BCFG0 + (nc->chip_offset << 2));
+
+        nandmtd = &ndfc_mtd[pdev->id];
+        if (nandmtd->pl_chip)
+                return -EBUSY;
+
+        nandmtd->pl_chip = nc;
+        ndfc_chip_init(nandmtd);
+
+        /* Scan for chips */
+        if (nand_scan(&nandmtd->mtd, nc->nr_chips)) {
+                nandmtd->pl_chip = NULL;
+                return -ENODEV;
+        }
+
+#ifdef CONFIG_MTD_PARTITIONS
+        printk("Number of partitions %d\n", nc->nr_partitions);
+        if (nc->nr_partitions) {
+                /* Add the full device, so complete dumps can be made */
+                add_mtd_device(&nandmtd->mtd);
+                add_mtd_partitions(&nandmtd->mtd, nc->partitions,
+                                   nc->nr_partitions);
+
+        } else
+#else
+                add_mtd_device(&nandmtd->mtd);
+#endif
+
+        atomic_inc(&ndfc->childs_active);
+        return 0;
+}
+
+static int ndfc_chip_remove(struct platform_device *pdev)
+{
+        return 0;
+}
+
+static int ndfc_nand_probe(struct platform_device *pdev)
+{
+        struct platform_nand_ctrl *nc = pdev->dev.platform_data;
+        struct ndfc_controller_settings *settings = nc->priv;
+        struct resource *res = pdev->resource;
+        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        unsigned long long phys = settings->ndfc_erpn | res->start;
+
+        ndfc->ndfcbase = ioremap64(phys, res->end - res->start + 1);
+        if (!ndfc->ndfcbase) {
+                printk(KERN_ERR "NDFC: ioremap failed\n");
+                return -EIO;
+        }
+
+        __raw_writel(settings->ccr_settings, ndfc->ndfcbase + NDFC_CCR);
+
+        spin_lock_init(&ndfc->ndfc_control.lock);
+        init_waitqueue_head(&ndfc->ndfc_control.wq);
+
+        platform_set_drvdata(pdev, ndfc);
+
+        printk("NDFC NAND Driver initialized. Chip-Rev: 0x%08x\n",
+               __raw_readl(ndfc->ndfcbase + NDFC_REVID));
+
+        return 0;
+}
+
+static int ndfc_nand_remove(struct platform_device *pdev)
+{
+        struct ndfc_controller *ndfc = platform_get_drvdata(pdev);
+
+        if (atomic_read(&ndfc->childs_active))
+                return -EBUSY;
+
+        if (ndfc) {
+                platform_set_drvdata(pdev, NULL);
+                iounmap(ndfc_ctrl.ndfcbase);
+                ndfc_ctrl.ndfcbase = NULL;
+        }
+        return 0;
+}
+
+/* driver device registration */
+
+static struct platform_driver ndfc_chip_driver = {
+        .probe          = ndfc_chip_probe,
+        .remove         = ndfc_chip_remove,
+        .driver         = {
+                .name   = "ndfc-chip",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static struct platform_driver ndfc_nand_driver = {
+        .probe          = ndfc_nand_probe,
+        .remove         = ndfc_nand_remove,
+        .driver         = {
+                .name   = "ndfc-nand",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init ndfc_nand_init(void)
+{
+        int ret;
+
+        spin_lock_init(&ndfc_ctrl.ndfc_control.lock);
+        init_waitqueue_head(&ndfc_ctrl.ndfc_control.wq);
+
+        ret = platform_driver_register(&ndfc_nand_driver);
+        if (!ret)
+                ret = platform_driver_register(&ndfc_chip_driver);
+        return ret;
+}
+
+static void __exit ndfc_nand_exit(void)
+{
+        platform_driver_unregister(&ndfc_chip_driver);
+        platform_driver_unregister(&ndfc_nand_driver);
+}
+
+module_init(ndfc_nand_init);
+module_exit(ndfc_nand_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Thomas Gleixner <tglx@linutronix.de>");
+MODULE_DESCRIPTION("Platform driver for NDFC");
diff --git a/drivers/mtd/nand/ppchameleonevb.c b/drivers/mtd/nand/ppchameleonevb.c
index 91a95f34a6ee..22fa65c12ab9 100644
--- a/drivers/mtd/nand/ppchameleonevb.c
+++ b/drivers/mtd/nand/ppchameleonevb.c
@@ -58,21 +58,21 @@
 /*
  * MTD structure for PPChameleonEVB board
  */
-static struct mtd_info *ppchameleon_mtd         = NULL;
+static struct mtd_info *ppchameleon_mtd = NULL;
 static struct mtd_info *ppchameleonevb_mtd = NULL;
 
 /*
  * Module stuff
  */
-static unsigned long ppchameleon_fio_pbase      = CFG_NAND0_PADDR;
+static unsigned long ppchameleon_fio_pbase = CFG_NAND0_PADDR;
 static unsigned long ppchameleonevb_fio_pbase = CFG_NAND1_PADDR;
 
 #ifdef MODULE
 module_param(ppchameleon_fio_pbase, ulong, 0);
 module_param(ppchameleonevb_fio_pbase, ulong, 0);
 #else
-__setup("ppchameleon_fio_pbase=",ppchameleon_fio_pbase);
-__setup("ppchameleonevb_fio_pbase=",ppchameleonevb_fio_pbase);
+__setup("ppchameleon_fio_pbase=", ppchameleon_fio_pbase);
+__setup("ppchameleonevb_fio_pbase=", ppchameleonevb_fio_pbase);
 #endif
 
 #ifdef CONFIG_MTD_PARTITIONS
@@ -80,82 +80,96 @@ __setup("ppchameleonevb_fio_pbase=",ppchameleonevb_fio_pbase);
  * Define static partitions for flash devices
  */
 static struct mtd_partition partition_info_hi[] = {
-        { name: "PPChameleon HI Nand Flash",
-                  offset: 0,
-                  size: 128*1024*1024 }
+      { .name = "PPChameleon HI Nand Flash",
+        offset = 0,
+        .size = 128 * 1024 * 1024
+      }
 };
 
 static struct mtd_partition partition_info_me[] = {
-        { name: "PPChameleon ME Nand Flash",
-                  offset: 0,
-                  size: 32*1024*1024 }
+      { .name = "PPChameleon ME Nand Flash",
+        .offset = 0,
+        .size = 32 * 1024 * 1024
+      }
 };
 
 static struct mtd_partition partition_info_evb[] = {
-        { name: "PPChameleonEVB Nand Flash",
-                  offset: 0,
-                  size: 32*1024*1024 }
+      { .name = "PPChameleonEVB Nand Flash",
+        .offset = 0,
+        .size = 32 * 1024 * 1024
+      }
 };
 
 #define NUM_PARTITIONS 1
 
-extern int parse_cmdline_partitions(struct mtd_info *master,
-                                    struct mtd_partition **pparts,
-                                    const char *mtd_id);
+extern int parse_cmdline_partitions(struct mtd_info *master, struct mtd_partition **pparts, const char *mtd_id);
 #endif
 
-
 /*
  *      hardware specific access to control-lines
  */
-static void ppchameleon_hwcontrol(struct mtd_info *mtdinfo, int cmd)
+static void ppchameleon_hwcontrol(struct mtd_info *mtdinfo, int cmd,
+                                  unsigned int ctrl)
 {
-        switch(cmd) {
-
-        case NAND_CTL_SETCLE:
-                MACRO_NAND_CTL_SETCLE((unsigned long)CFG_NAND0_PADDR);
-                break;
-        case NAND_CTL_CLRCLE:
-                MACRO_NAND_CTL_CLRCLE((unsigned long)CFG_NAND0_PADDR);
-                break;
-        case NAND_CTL_SETALE:
-                MACRO_NAND_CTL_SETALE((unsigned long)CFG_NAND0_PADDR);
-                break;
-        case NAND_CTL_CLRALE:
-                MACRO_NAND_CTL_CLRALE((unsigned long)CFG_NAND0_PADDR);
-                break;
-        case NAND_CTL_SETNCE:
+        struct nand_chip *chip = mtd->priv;
+
+        if (ctrl & NAND_CTRL_CHANGE) {
+#error Missing headerfiles. No way to fix this. -tglx
+                switch (cmd) {
+                case NAND_CTL_SETCLE:
+                        MACRO_NAND_CTL_SETCLE((unsigned long)CFG_NAND0_PADDR);
+                        break;
+                case NAND_CTL_CLRCLE:
+                        MACRO_NAND_CTL_CLRCLE((unsigned long)CFG_NAND0_PADDR);
+                        break;
+                case NAND_CTL_SETALE:
+                        MACRO_NAND_CTL_SETALE((unsigned long)CFG_NAND0_PADDR);
+                        break;
+                case NAND_CTL_CLRALE:
+                        MACRO_NAND_CTL_CLRALE((unsigned long)CFG_NAND0_PADDR);
+                        break;
+                case NAND_CTL_SETNCE:
                         MACRO_NAND_ENABLE_CE((unsigned long)CFG_NAND0_PADDR);
-                break;
-        case NAND_CTL_CLRNCE:
+                        break;
+                case NAND_CTL_CLRNCE:
                         MACRO_NAND_DISABLE_CE((unsigned long)CFG_NAND0_PADDR);
-                break;
+                        break;
+                }
         }
+        if (cmd != NAND_CMD_NONE)
+                writeb(cmd, chip->IO_ADDR_W);
 }
 
-static void ppchameleonevb_hwcontrol(struct mtd_info *mtdinfo, int cmd)
+static void ppchameleonevb_hwcontrol(struct mtd_info *mtdinfo, int cmd,
+                                     unsigned int ctrl)
 {
-        switch(cmd) {
-
-        case NAND_CTL_SETCLE:
-                MACRO_NAND_CTL_SETCLE((unsigned long)CFG_NAND1_PADDR);
-                break;
-        case NAND_CTL_CLRCLE:
-                MACRO_NAND_CTL_CLRCLE((unsigned long)CFG_NAND1_PADDR);
-                break;
-        case NAND_CTL_SETALE:
-                MACRO_NAND_CTL_SETALE((unsigned long)CFG_NAND1_PADDR);
-                break;
-        case NAND_CTL_CLRALE:
-                MACRO_NAND_CTL_CLRALE((unsigned long)CFG_NAND1_PADDR);
-                break;
-        case NAND_CTL_SETNCE:
-                MACRO_NAND_ENABLE_CE((unsigned long)CFG_NAND1_PADDR);
-                break;
-        case NAND_CTL_CLRNCE:
-                MACRO_NAND_DISABLE_CE((unsigned long)CFG_NAND1_PADDR);
-                break;
+        struct nand_chip *chip = mtd->priv;
+
+        if (ctrl & NAND_CTRL_CHANGE) {
+#error Missing headerfiles. No way to fix this. -tglx
+                switch (cmd) {
+                case NAND_CTL_SETCLE:
+                        MACRO_NAND_CTL_SETCLE((unsigned long)CFG_NAND1_PADDR);
+                        break;
+                case NAND_CTL_CLRCLE:
+                        MACRO_NAND_CTL_CLRCLE((unsigned long)CFG_NAND1_PADDR);
+                        break;
+                case NAND_CTL_SETALE:
+                        MACRO_NAND_CTL_SETALE((unsigned long)CFG_NAND1_PADDR);
+                        break;
+                case NAND_CTL_CLRALE:
+                        MACRO_NAND_CTL_CLRALE((unsigned long)CFG_NAND1_PADDR);
+                        break;
+                case NAND_CTL_SETNCE:
+                        MACRO_NAND_ENABLE_CE((unsigned long)CFG_NAND1_PADDR);
+                        break;
+                case NAND_CTL_CLRNCE:
+                        MACRO_NAND_DISABLE_CE((unsigned long)CFG_NAND1_PADDR);
+                        break;
+                }
         }
+        if (cmd != NAND_CMD_NONE)
+                writeb(cmd, chip->IO_ADDR_W);
 }
 
 #ifdef USE_READY_BUSY_PIN
@@ -164,15 +178,15 @@ static void ppchameleonevb_hwcontrol(struct mtd_info *mtdinfo, int cmd)
  */
 static int ppchameleon_device_ready(struct mtd_info *minfo)
 {
-        if (in_be32((volatile unsigned*)GPIO0_IR) & NAND_RB_GPIO_PIN)
+        if (in_be32((volatile unsigned *)GPIO0_IR) & NAND_RB_GPIO_PIN)
                 return 1;
         return 0;
 }
 
 static int ppchameleonevb_device_ready(struct mtd_info *minfo)
 {
-        if (in_be32((volatile unsigned*)GPIO0_IR) & NAND_EVB_RB_GPIO_PIN)
-        return 1;
+        if (in_be32((volatile unsigned *)GPIO0_IR) & NAND_EVB_RB_GPIO_PIN)
+                return 1;
         return 0;
 }
 #endif
@@ -185,7 +199,7 @@ const char *part_probes_evb[] = { "cmdlinepart", NULL };
 /*
  * Main initialization routine
  */
-static int __init ppchameleonevb_init (void)
+static int __init ppchameleonevb_init(void)
 {
         struct nand_chip *this;
         const char *part_type = 0;
@@ -194,13 +208,11 @@ static int __init ppchameleonevb_init (void)
         void __iomem *ppchameleon_fio_base;
         void __iomem *ppchameleonevb_fio_base;
 
-
         /*********************************
         * Processor module NAND (if any) *
         *********************************/
         /* Allocate memory for MTD device structure and private data */
-        ppchameleon_mtd = kmalloc(sizeof(struct mtd_info) +
-                                                      sizeof(struct nand_chip), GFP_KERNEL);
+        ppchameleon_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
         if (!ppchameleon_mtd) {
                 printk("Unable to allocate PPChameleon NAND MTD device structure.\n");
                 return -ENOMEM;
@@ -208,63 +220,65 @@ static int __init ppchameleonevb_init (void)
 
         /* map physical address */
         ppchameleon_fio_base = ioremap(ppchameleon_fio_pbase, SZ_4M);
-        if(!ppchameleon_fio_base) {
+        if (!ppchameleon_fio_base) {
                 printk("ioremap PPChameleon NAND flash failed\n");
                 kfree(ppchameleon_mtd);
                 return -EIO;
         }
 
         /* Get pointer to private data */
-        this = (struct nand_chip *) (&ppchameleon_mtd[1]);
+        this = (struct nand_chip *)(&ppchameleon_mtd[1]);
 
         /* Initialize structures */
-        memset((char *) ppchameleon_mtd, 0, sizeof(struct mtd_info));
-        memset((char *) this, 0, sizeof(struct nand_chip));
+        memset(ppchameleon_mtd, 0, sizeof(struct mtd_info));
+        memset(this, 0, sizeof(struct nand_chip));
 
         /* Link the private data with the MTD structure */
         ppchameleon_mtd->priv = this;
+        ppchameleon_mtd->owner = THIS_MODULE;
 
-        /* Initialize GPIOs */
+        /* Initialize GPIOs */
         /* Pin mapping for NAND chip */
         /*
-                CE      GPIO_01
-                CLE     GPIO_02
-                ALE     GPIO_03
-                R/B     GPIO_04
-        */
+           CE   GPIO_01
+           CLE  GPIO_02
+           ALE  GPIO_03
+           R/B  GPIO_04
+         */
         /* output select */
-        out_be32((volatile unsigned*)GPIO0_OSRH, in_be32((volatile unsigned*)GPIO0_OSRH) & 0xC0FFFFFF);
+        out_be32((volatile unsigned *)GPIO0_OSRH, in_be32((volatile unsigned *)GPIO0_OSRH) & 0xC0FFFFFF);
         /* three-state select */
-        out_be32((volatile unsigned*)GPIO0_TSRH, in_be32((volatile unsigned*)GPIO0_TSRH) & 0xC0FFFFFF);
+        out_be32((volatile unsigned *)GPIO0_TSRH, in_be32((volatile unsigned *)GPIO0_TSRH) & 0xC0FFFFFF);
         /* enable output driver */
-        out_be32((volatile unsigned*)GPIO0_TCR, in_be32((volatile unsigned*)GPIO0_TCR) | NAND_nCE_GPIO_PIN | NAND_CLE_GPIO_PIN | NAND_ALE_GPIO_PIN);
+        out_be32((volatile unsigned *)GPIO0_TCR,
+                 in_be32((volatile unsigned *)GPIO0_TCR) | NAND_nCE_GPIO_PIN | NAND_CLE_GPIO_PIN | NAND_ALE_GPIO_PIN);
 #ifdef USE_READY_BUSY_PIN
         /* three-state select */
-        out_be32((volatile unsigned*)GPIO0_TSRH, in_be32((volatile unsigned*)GPIO0_TSRH) & 0xFF3FFFFF);
+        out_be32((volatile unsigned *)GPIO0_TSRH, in_be32((volatile unsigned *)GPIO0_TSRH) & 0xFF3FFFFF);
         /* high-impedecence */
-        out_be32((volatile unsigned*)GPIO0_TCR, in_be32((volatile unsigned*)GPIO0_TCR) & (~NAND_RB_GPIO_PIN));
+        out_be32((volatile unsigned *)GPIO0_TCR, in_be32((volatile unsigned *)GPIO0_TCR) & (~NAND_RB_GPIO_PIN));
         /* input select */
-        out_be32((volatile unsigned*)GPIO0_ISR1H, (in_be32((volatile unsigned*)GPIO0_ISR1H) & 0xFF3FFFFF) | 0x00400000);
+        out_be32((volatile unsigned *)GPIO0_ISR1H,
+                 (in_be32((volatile unsigned *)GPIO0_ISR1H) & 0xFF3FFFFF) | 0x00400000);
 #endif
 
         /* insert callbacks */
         this->IO_ADDR_R = ppchameleon_fio_base;
         this->IO_ADDR_W = ppchameleon_fio_base;
-        this->hwcontrol = ppchameleon_hwcontrol;
+        this->cmd_ctrl = ppchameleon_hwcontrol;
 #ifdef USE_READY_BUSY_PIN
         this->dev_ready = ppchameleon_device_ready;
 #endif
         this->chip_delay = NAND_BIG_DELAY_US;
         /* ECC mode */
-        this->eccmode = NAND_ECC_SOFT;
+        this->ecc.mode = NAND_ECC_SOFT;
 
         /* Scan to find existence of the device (it could not be mounted) */
-        if (nand_scan (ppchameleon_mtd, 1)) {
+        if (nand_scan(ppchameleon_mtd, 1)) {
                 iounmap((void *)ppchameleon_fio_base);
-                kfree (ppchameleon_mtd);
+                kfree(ppchameleon_mtd);
                 goto nand_evb_init;
         }
-
 #ifndef USE_READY_BUSY_PIN
         /* Adjust delay if necessary */
         if (ppchameleon_mtd->size == NAND_SMALL_SIZE)
@@ -275,12 +289,11 @@ static int __init ppchameleonevb_init (void)
         ppchameleon_mtd->name = "ppchameleon-nand";
         mtd_parts_nb = parse_mtd_partitions(ppchameleon_mtd, part_probes, &mtd_parts, 0);
         if (mtd_parts_nb > 0)
-          part_type = "command line";
+                part_type = "command line";
         else
-          mtd_parts_nb = 0;
+                mtd_parts_nb = 0;
 #endif
-        if (mtd_parts_nb == 0)
-        {
+        if (mtd_parts_nb == 0) {
                 if (ppchameleon_mtd->size == NAND_SMALL_SIZE)
                         mtd_parts = partition_info_me;
                 else
@@ -293,13 +306,12 @@ static int __init ppchameleonevb_init (void)
         printk(KERN_NOTICE "Using %s partition definition\n", part_type);
         add_mtd_partitions(ppchameleon_mtd, mtd_parts, mtd_parts_nb);
 
-nand_evb_init:
+ nand_evb_init:
         /****************************
         * EVB NAND (always present) *
         ****************************/
         /* Allocate memory for MTD device structure and private data */
-        ppchameleonevb_mtd = kmalloc(sizeof(struct mtd_info) +
-                                                         sizeof(struct nand_chip), GFP_KERNEL);
+        ppchameleonevb_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
         if (!ppchameleonevb_mtd) {
                 printk("Unable to allocate PPChameleonEVB NAND MTD device structure.\n");
                 return -ENOMEM;
@@ -307,77 +319,76 @@ nand_evb_init:
 
         /* map physical address */
         ppchameleonevb_fio_base = ioremap(ppchameleonevb_fio_pbase, SZ_4M);
-        if(!ppchameleonevb_fio_base) {
+        if (!ppchameleonevb_fio_base) {
                 printk("ioremap PPChameleonEVB NAND flash failed\n");
                 kfree(ppchameleonevb_mtd);
                 return -EIO;
         }
 
         /* Get pointer to private data */
-        this = (struct nand_chip *) (&ppchameleonevb_mtd[1]);
+        this = (struct nand_chip *)(&ppchameleonevb_mtd[1]);
 
         /* Initialize structures */
-        memset((char *) ppchameleonevb_mtd, 0, sizeof(struct mtd_info));
-        memset((char *) this, 0, sizeof(struct nand_chip));
+        memset(ppchameleonevb_mtd, 0, sizeof(struct mtd_info));
+        memset(this, 0, sizeof(struct nand_chip));
 
         /* Link the private data with the MTD structure */
         ppchameleonevb_mtd->priv = this;
 
-        /* Initialize GPIOs */
+        /* Initialize GPIOs */
         /* Pin mapping for NAND chip */
         /*
-                CE      GPIO_14
-                CLE     GPIO_15
-                ALE     GPIO_16
-                R/B     GPIO_31
-        */
+           CE   GPIO_14
+           CLE  GPIO_15
+           ALE  GPIO_16
+           R/B  GPIO_31
+         */
         /* output select */
-        out_be32((volatile unsigned*)GPIO0_OSRH, in_be32((volatile unsigned*)GPIO0_OSRH) & 0xFFFFFFF0);
-        out_be32((volatile unsigned*)GPIO0_OSRL, in_be32((volatile unsigned*)GPIO0_OSRL) & 0x3FFFFFFF);
+        out_be32((volatile unsigned *)GPIO0_OSRH, in_be32((volatile unsigned *)GPIO0_OSRH) & 0xFFFFFFF0);
+        out_be32((volatile unsigned *)GPIO0_OSRL, in_be32((volatile unsigned *)GPIO0_OSRL) & 0x3FFFFFFF);
         /* three-state select */
-        out_be32((volatile unsigned*)GPIO0_TSRH, in_be32((volatile unsigned*)GPIO0_TSRH) & 0xFFFFFFF0);
-        out_be32((volatile unsigned*)GPIO0_TSRL, in_be32((volatile unsigned*)GPIO0_TSRL) & 0x3FFFFFFF);
+        out_be32((volatile unsigned *)GPIO0_TSRH, in_be32((volatile unsigned *)GPIO0_TSRH) & 0xFFFFFFF0);
+        out_be32((volatile unsigned *)GPIO0_TSRL, in_be32((volatile unsigned *)GPIO0_TSRL) & 0x3FFFFFFF);
         /* enable output driver */
-        out_be32((volatile unsigned*)GPIO0_TCR, in_be32((volatile unsigned*)GPIO0_TCR) | NAND_EVB_nCE_GPIO_PIN |
+        out_be32((volatile unsigned *)GPIO0_TCR, in_be32((volatile unsigned *)GPIO0_TCR) | NAND_EVB_nCE_GPIO_PIN |
                  NAND_EVB_CLE_GPIO_PIN | NAND_EVB_ALE_GPIO_PIN);
 #ifdef USE_READY_BUSY_PIN
         /* three-state select */
-        out_be32((volatile unsigned*)GPIO0_TSRL, in_be32((volatile unsigned*)GPIO0_TSRL) & 0xFFFFFFFC);
+        out_be32((volatile unsigned *)GPIO0_TSRL, in_be32((volatile unsigned *)GPIO0_TSRL) & 0xFFFFFFFC);
         /* high-impedecence */
-        out_be32((volatile unsigned*)GPIO0_TCR, in_be32((volatile unsigned*)GPIO0_TCR) & (~NAND_EVB_RB_GPIO_PIN));
+        out_be32((volatile unsigned *)GPIO0_TCR, in_be32((volatile unsigned *)GPIO0_TCR) & (~NAND_EVB_RB_GPIO_PIN));
         /* input select */
-        out_be32((volatile unsigned*)GPIO0_ISR1L, (in_be32((volatile unsigned*)GPIO0_ISR1L) & 0xFFFFFFFC) | 0x00000001);
+        out_be32((volatile unsigned *)GPIO0_ISR1L,
+                 (in_be32((volatile unsigned *)GPIO0_ISR1L) & 0xFFFFFFFC) | 0x00000001);
 #endif
 
         /* insert callbacks */
         this->IO_ADDR_R = ppchameleonevb_fio_base;
         this->IO_ADDR_W = ppchameleonevb_fio_base;
-        this->hwcontrol = ppchameleonevb_hwcontrol;
+        this->cmd_ctrl = ppchameleonevb_hwcontrol;
 #ifdef USE_READY_BUSY_PIN
         this->dev_ready = ppchameleonevb_device_ready;
 #endif
         this->chip_delay = NAND_SMALL_DELAY_US;
 
         /* ECC mode */
-        this->eccmode = NAND_ECC_SOFT;
+        this->ecc.mode = NAND_ECC_SOFT;
 
         /* Scan to find existence of the device */
-        if (nand_scan (ppchameleonevb_mtd, 1)) {
+        if (nand_scan(ppchameleonevb_mtd, 1)) {
                 iounmap((void *)ppchameleonevb_fio_base);
-                kfree (ppchameleonevb_mtd);
+                kfree(ppchameleonevb_mtd);
                 return -ENXIO;
         }
-
 #ifdef CONFIG_MTD_PARTITIONS
         ppchameleonevb_mtd->name = NAND_EVB_MTD_NAME;
         mtd_parts_nb = parse_mtd_partitions(ppchameleonevb_mtd, part_probes_evb, &mtd_parts, 0);
         if (mtd_parts_nb > 0)
-          part_type = "command line";
+                part_type = "command line";
         else
-          mtd_parts_nb = 0;
+                mtd_parts_nb = 0;
 #endif
-        if (mtd_parts_nb == 0)
-        {
+        if (mtd_parts_nb == 0) {
                 mtd_parts = partition_info_evb;
                 mtd_parts_nb = NUM_PARTITIONS;
                 part_type = "static";
@@ -390,18 +401,19 @@ nand_evb_init:
         /* Return happy */
         return 0;
 }
+
 module_init(ppchameleonevb_init);
 
 /*
  * Clean up routine
  */
-static void __exit ppchameleonevb_cleanup (void)
+static void __exit ppchameleonevb_cleanup(void)
 {
         struct nand_chip *this;
 
         /* Release resources, unregister device(s) */
-        nand_release (ppchameleon_mtd);
-        nand_release (ppchameleonevb_mtd);
+        nand_release(ppchameleon_mtd);
+        nand_release(ppchameleonevb_mtd);
 
         /* Release iomaps */
         this = (struct nand_chip *) &ppchameleon_mtd[1];
diff --git a/drivers/mtd/nand/rtc_from4.c b/drivers/mtd/nand/rtc_from4.c
index 4129c03dfd90..f8c49645324d 100644
--- a/drivers/mtd/nand/rtc_from4.c
+++ b/drivers/mtd/nand/rtc_from4.c
@@ -97,12 +97,12 @@ static struct mtd_info *rtc_from4_mtd = NULL;
 static void __iomem *rtc_from4_fio_base = (void *)P2SEGADDR(RTC_FROM4_FIO_BASE);
 
 static const struct mtd_partition partition_info[] = {
-        {
-                .name   = "Renesas flash partition 1",
-                .offset = 0,
-                .size   = MTDPART_SIZ_FULL
-        },
+        {
+         .name = "Renesas flash partition 1",
+         .offset = 0,
+         .size = MTDPART_SIZ_FULL},
 };
+
 #define NUM_PARTITIONS 1
 
 /*
@@ -111,8 +111,8 @@ static const struct mtd_partition partition_info[] = {
  *              NAND_BBT_CREATE and/or NAND_BBT_WRITE
  *
  */
-static uint8_t bbt_pattern[] = {'B', 'b', 't', '0' };
-static uint8_t mirror_pattern[] = {'1', 't', 'b', 'B' };
+static uint8_t bbt_pattern[] = { 'B', 'b', 't', '0' };
+static uint8_t mirror_pattern[] = { '1', 't', 'b', 'B' };
 
 static struct nand_bbt_descr rtc_from4_bbt_main_descr = {
         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
@@ -134,8 +134,6 @@ static struct nand_bbt_descr rtc_from4_bbt_mirror_descr = {
         .pattern = mirror_pattern
 };
 
-
-
 #ifdef RTC_FROM4_HWECC
 
 /* the Reed Solomon control structure */
@@ -144,15 +142,14 @@ static struct rs_control *rs_decoder;
 /*
  *      hardware specific Out Of Band information
  */
-static struct nand_oobinfo rtc_from4_nand_oobinfo = {
-        .useecc = MTD_NANDECC_AUTOPLACE,
+static struct nand_ecclayout rtc_from4_nand_oobinfo = {
         .eccbytes = 32,
         .eccpos = {
-                 0,  1,  2,  3,  4,  5,  6,  7,
-                 8,  9, 10, 11, 12, 13, 14, 15,
-                16, 17, 18, 19, 20, 21, 22, 23,
-                24, 25, 26, 27, 28, 29, 30, 31},
-        .oobfree = { {32, 32} }
+                   0, 1, 2, 3, 4, 5, 6, 7,
+                   8, 9, 10, 11, 12, 13, 14, 15,
+                   16, 17, 18, 19, 20, 21, 22, 23,
+                   24, 25, 26, 27, 28, 29, 30, 31},
+        .oobfree = {{32, 32}}
 };
 
 /* Aargh. I missed the reversed bit order, when I
@@ -162,44 +159,42 @@ static struct nand_oobinfo rtc_from4_nand_oobinfo = {
  * of the ecc byte which we get from the FPGA
  */
 static uint8_t revbits[256] = {
-        0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
-        0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
-        0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
-        0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
-        0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
-        0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
-        0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
-        0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
-        0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
-        0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
-        0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
-        0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
-        0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
-        0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
-        0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
-        0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
-        0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
-        0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
-        0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
-        0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
-        0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
-        0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
-        0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
-        0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
-        0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
-        0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
-        0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
-        0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
-        0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
-        0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
-        0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
-        0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
+        0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
+        0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
+        0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
+        0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
+        0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
+        0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
+        0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
+        0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
+        0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
+        0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
+        0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
+        0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
+        0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
+        0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
+        0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
+        0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
+        0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
+        0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
+        0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
+        0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
+        0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
+        0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
+        0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
+        0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
+        0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
+        0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
+        0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
+        0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
+        0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
+        0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
+        0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
+        0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
 };
 
 #endif
 
-
-
 /*
  * rtc_from4_hwcontrol - hardware specific access to control-lines
  * @mtd:        MTD device structure
@@ -212,35 +207,20 @@ static uint8_t revbits[256] = {
  * Address lines (A24-A22), so no action is required here.
  *
  */
-static void rtc_from4_hwcontrol(struct mtd_info *mtd, int cmd)
+static void rtc_from4_hwcontrol(struct mtd_info *mtd, int cmd,
+                                unsigned int ctrl)
 {
-        struct nand_chip* this = (struct nand_chip *) (mtd->priv);
-
-        switch(cmd) {
+        struct nand_chip *chip = (mtd->priv);
 
-        case NAND_CTL_SETCLE:
-                this->IO_ADDR_W = (void __iomem *)((unsigned long)this->IO_ADDR_W | RTC_FROM4_CLE);
-                break;
-        case NAND_CTL_CLRCLE:
-                this->IO_ADDR_W = (void __iomem *)((unsigned long)this->IO_ADDR_W & ~RTC_FROM4_CLE);
-                break;
-
-        case NAND_CTL_SETALE:
-                this->IO_ADDR_W = (void __iomem *)((unsigned long)this->IO_ADDR_W | RTC_FROM4_ALE);
-                break;
-        case NAND_CTL_CLRALE:
-                this->IO_ADDR_W = (void __iomem *)((unsigned long)this->IO_ADDR_W & ~RTC_FROM4_ALE);
-                break;
+        if (cmd == NAND_CMD_NONE)
+                return;
 
-        case NAND_CTL_SETNCE:
-                break;
-        case NAND_CTL_CLRNCE:
-                break;
-
-        }
+        if (ctrl & NAND_CLE)
+                writeb(cmd, chip->IO_ADDR_W | RTC_FROM4_CLE);
+        else
+                writeb(cmd, chip->IO_ADDR_W | RTC_FROM4_ALE);
 }
 
-
 /*
  * rtc_from4_nand_select_chip - hardware specific chip select
  * @mtd:        MTD device structure
@@ -252,26 +232,25 @@ static void rtc_from4_hwcontrol(struct mtd_info *mtd, int cmd)
  */
 static void rtc_from4_nand_select_chip(struct mtd_info *mtd, int chip)
 {
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *this = mtd->priv;
 
         this->IO_ADDR_R = (void __iomem *)((unsigned long)this->IO_ADDR_R & ~RTC_FROM4_NAND_ADDR_MASK);
         this->IO_ADDR_W = (void __iomem *)((unsigned long)this->IO_ADDR_W & ~RTC_FROM4_NAND_ADDR_MASK);
 
-        switch(chip) {
+        switch (chip) {
 
-        case 0:         /* select slot 3 chip */
+        case 0:         /* select slot 3 chip */
                 this->IO_ADDR_R = (void __iomem *)((unsigned long)this->IO_ADDR_R | RTC_FROM4_NAND_ADDR_SLOT3);
                 this->IO_ADDR_W = (void __iomem *)((unsigned long)this->IO_ADDR_W | RTC_FROM4_NAND_ADDR_SLOT3);
-                break;
-        case 1:         /* select slot 4 chip */
+                break;
+        case 1:         /* select slot 4 chip */
                 this->IO_ADDR_R = (void __iomem *)((unsigned long)this->IO_ADDR_R | RTC_FROM4_NAND_ADDR_SLOT4);
                 this->IO_ADDR_W = (void __iomem *)((unsigned long)this->IO_ADDR_W | RTC_FROM4_NAND_ADDR_SLOT4);
-                break;
+                break;
 
-        }
+        }
 }
 
-
 /*
  * rtc_from4_nand_device_ready - hardware specific ready/busy check
  * @mtd:        MTD device structure
@@ -290,7 +269,6 @@ static int rtc_from4_nand_device_ready(struct mtd_info *mtd)
 
 }
 
-
 /*
  * deplete - code to perform device recovery in case there was a power loss
  * @mtd:        MTD device structure
@@ -306,24 +284,23 @@ static int rtc_from4_nand_device_ready(struct mtd_info *mtd)
  */
 static void deplete(struct mtd_info *mtd, int chip)
 {
-        struct nand_chip *this = mtd->priv;
+        struct nand_chip *this = mtd->priv;
 
-        /* wait until device is ready */
-        while (!this->dev_ready(mtd));
+        /* wait until device is ready */
+        while (!this->dev_ready(mtd)) ;
 
         this->select_chip(mtd, chip);
 
         /* Send the commands for device recovery, phase 1 */
-        this->cmdfunc (mtd, NAND_CMD_DEPLETE1, 0x0000, 0x0000);
-        this->cmdfunc (mtd, NAND_CMD_DEPLETE2, -1, -1);
+        this->cmdfunc(mtd, NAND_CMD_DEPLETE1, 0x0000, 0x0000);
+        this->cmdfunc(mtd, NAND_CMD_DEPLETE2, -1, -1);
 
         /* Send the commands for device recovery, phase 2 */
-        this->cmdfunc (mtd, NAND_CMD_DEPLETE1, 0x0000, 0x0004);
-        this->cmdfunc (mtd, NAND_CMD_DEPLETE2, -1, -1);
+        this->cmdfunc(mtd, NAND_CMD_DEPLETE1, 0x0000, 0x0004);
+        this->cmdfunc(mtd, NAND_CMD_DEPLETE2, -1, -1);
 
 }
 
-
 #ifdef RTC_FROM4_HWECC
 /*
  * rtc_from4_enable_hwecc - hardware specific hardware ECC enable function
@@ -335,39 +312,35 @@ static void deplete(struct mtd_info *mtd, int chip)
  */
 static void rtc_from4_enable_hwecc(struct mtd_info *mtd, int mode)
 {
-        volatile unsigned short * rs_ecc_ctl = (volatile unsigned short *)(rtc_from4_fio_base + RTC_FROM4_RS_ECC_CTL);
+        volatile unsigned short *rs_ecc_ctl = (volatile unsigned short *)(rtc_from4_fio_base + RTC_FROM4_RS_ECC_CTL);
         unsigned short status;
 
         switch (mode) {
-            case NAND_ECC_READ :
-                status =  RTC_FROM4_RS_ECC_CTL_CLR
-                        | RTC_FROM4_RS_ECC_CTL_FD_E;
+        case NAND_ECC_READ:
+                status = RTC_FROM4_RS_ECC_CTL_CLR | RTC_FROM4_RS_ECC_CTL_FD_E;
 
                 *rs_ecc_ctl = status;
                 break;
 
-            case NAND_ECC_READSYN :
-                status =  0x00;
+        case NAND_ECC_READSYN:
+                status = 0x00;
 
                 *rs_ecc_ctl = status;
                 break;
 
-            case NAND_ECC_WRITE :
-                status =  RTC_FROM4_RS_ECC_CTL_CLR
-                        | RTC_FROM4_RS_ECC_CTL_GEN
-                        | RTC_FROM4_RS_ECC_CTL_FD_E;
+        case NAND_ECC_WRITE:
+                status = RTC_FROM4_RS_ECC_CTL_CLR | RTC_FROM4_RS_ECC_CTL_GEN | RTC_FROM4_RS_ECC_CTL_FD_E;
 
                 *rs_ecc_ctl = status;
                 break;
 
-            default:
+        default:
                 BUG();
                 break;
         }
 
 }
 
-
 /*
  * rtc_from4_calculate_ecc - hardware specific code to read ECC code
  * @mtd:        MTD device structure
@@ -383,7 +356,7 @@ static void rtc_from4_enable_hwecc(struct mtd_info *mtd, int mode)
  */
 static void rtc_from4_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code)
 {
-        volatile unsigned short * rs_eccn = (volatile unsigned short *)(rtc_from4_fio_base + RTC_FROM4_RS_ECCN);
+        volatile unsigned short *rs_eccn = (volatile unsigned short *)(rtc_from4_fio_base + RTC_FROM4_RS_ECCN);
         unsigned short value;
         int i;
 
@@ -395,7 +368,6 @@ static void rtc_from4_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_c
         ecc_code[7] |= 0x0f;    /* set the last four bits (not used) */
 }
 
-
 /*
  * rtc_from4_correct_data - hardware specific code to correct data using ECC code
  * @mtd:        MTD device structure
@@ -414,7 +386,7 @@ static int rtc_from4_correct_data(struct mtd_info *mtd, const u_char *buf, u_cha
         unsigned short status;
         uint16_t par[6], syn[6];
         uint8_t ecc[8];
-        volatile unsigned short *rs_ecc;
+        volatile unsigned short *rs_ecc;
 
         status = *((volatile unsigned short *)(rtc_from4_fio_base + RTC_FROM4_RS_ECC_CHK));
 
@@ -424,23 +396,18 @@ static int rtc_from4_correct_data(struct mtd_info *mtd, const u_char *buf, u_cha
 
         /* Read the syndrom pattern from the FPGA and correct the bitorder */
         rs_ecc = (volatile unsigned short *)(rtc_from4_fio_base + RTC_FROM4_RS_ECC);
-        for (i = 0; i < 8; i++) {
-                ecc[i] = revbits[(*rs_ecc) & 0xFF];
-                rs_ecc++;
-        }
+        for (i = 0; i < 8; i++) {
+                ecc[i] = revbits[(*rs_ecc) & 0xFF];
+                rs_ecc++;
+        }
 
         /* convert into 6 10bit syndrome fields */
-        par[5] = rs_decoder->index_of[(((uint16_t)ecc[0] >> 0) & 0x0ff) |
-                                      (((uint16_t)ecc[1] << 8) & 0x300)];
-        par[4] = rs_decoder->index_of[(((uint16_t)ecc[1] >> 2) & 0x03f) |
-                                      (((uint16_t)ecc[2] << 6) & 0x3c0)];
-        par[3] = rs_decoder->index_of[(((uint16_t)ecc[2] >> 4) & 0x00f) |
-                                      (((uint16_t)ecc[3] << 4) & 0x3f0)];
-        par[2] = rs_decoder->index_of[(((uint16_t)ecc[3] >> 6) & 0x003) |
-                                      (((uint16_t)ecc[4] << 2) & 0x3fc)];
-        par[1] = rs_decoder->index_of[(((uint16_t)ecc[5] >> 0) & 0x0ff) |
-                                      (((uint16_t)ecc[6] << 8) & 0x300)];
-        par[0] = (((uint16_t)ecc[6] >> 2) & 0x03f) | (((uint16_t)ecc[7] << 6) & 0x3c0);
+        par[5] = rs_decoder->index_of[(((uint16_t) ecc[0] >> 0) & 0x0ff) | (((uint16_t) ecc[1] << 8) & 0x300)];
+        par[4] = rs_decoder->index_of[(((uint16_t) ecc[1] >> 2) & 0x03f) | (((uint16_t) ecc[2] << 6) & 0x3c0)];
+        par[3] = rs_decoder->index_of[(((uint16_t) ecc[2] >> 4) & 0x00f) | (((uint16_t) ecc[3] << 4) & 0x3f0)];
+        par[2] = rs_decoder->index_of[(((uint16_t) ecc[3] >> 6) & 0x003) | (((uint16_t) ecc[4] << 2) & 0x3fc)];
+        par[1] = rs_decoder->index_of[(((uint16_t) ecc[5] >> 0) & 0x0ff) | (((uint16_t) ecc[6] << 8) & 0x300)];
+        par[0] = (((uint16_t) ecc[6] >> 2) & 0x03f) | (((uint16_t) ecc[7] << 6) & 0x3c0);
 
         /* Convert to computable syndrome */
         for (i = 0; i < 6; i++) {
@@ -453,16 +420,14 @@ static int rtc_from4_correct_data(struct mtd_info *mtd, const u_char *buf, u_cha
                 syn[i] = rs_decoder->index_of[syn[i]];
         }
 
-        /* Let the library code do its magic.*/
-        res = decode_rs8(rs_decoder, (uint8_t *)buf, par, 512, syn, 0, NULL, 0xff, NULL);
+        /* Let the library code do its magic. */
+        res = decode_rs8(rs_decoder, (uint8_t *) buf, par, 512, syn, 0, NULL, 0xff, NULL);
         if (res > 0) {
-                DEBUG (MTD_DEBUG_LEVEL0, "rtc_from4_correct_data: "
-                        "ECC corrected %d errors on read\n", res);
+                DEBUG(MTD_DEBUG_LEVEL0, "rtc_from4_correct_data: " "ECC corrected %d errors on read\n", res);
         }
         return res;
 }
 
-
 /**
  * rtc_from4_errstat - perform additional error status checks
  * @mtd:        MTD device structure
@@ -478,54 +443,66 @@ static int rtc_from4_correct_data(struct mtd_info *mtd, const u_char *buf, u_cha
  * note: see pages 34..37 of data sheet for details.
  *
  */
-static int rtc_from4_errstat(struct mtd_info *mtd, struct nand_chip *this, int state, int status, int page)
+static int rtc_from4_errstat(struct mtd_info *mtd, struct nand_chip *this,
+                             int state, int status, int page)
 {
-        int     er_stat=0;
-        int     rtn, retlen;
-        size_t  len;
+        int er_stat = 0;
+        int rtn, retlen;
+        size_t len;
         uint8_t *buf;
-        int     i;
-
-        this->cmdfunc (mtd, NAND_CMD_STATUS_CLEAR, -1, -1);
-
-        if (state == FL_ERASING) {
-                for (i=0; i<4; i++) {
-                        if (status & 1<<(i+1)) {
-                                this->cmdfunc (mtd, (NAND_CMD_STATUS_ERROR + i + 1), -1, -1);
-                                rtn = this->read_byte(mtd);
-                                this->cmdfunc (mtd, NAND_CMD_STATUS_RESET, -1, -1);
-                                if (!(rtn & ERR_STAT_ECC_AVAILABLE)) {
-                                        er_stat |= 1<<(i+1);    /* err_ecc_not_avail */
-                                }
-                        }
+        int i;
+
+        this->cmdfunc(mtd, NAND_CMD_STATUS_CLEAR, -1, -1);
+
+        if (state == FL_ERASING) {
+
+                for (i = 0; i < 4; i++) {
+                        if (!(status & 1 << (i + 1)))
+                                continue;
+                        this->cmdfunc(mtd, (NAND_CMD_STATUS_ERROR + i + 1),
+                                      -1, -1);
+                        rtn = this->read_byte(mtd);
+                        this->cmdfunc(mtd, NAND_CMD_STATUS_RESET, -1, -1);
+
+                        /* err_ecc_not_avail */
+                        if (!(rtn & ERR_STAT_ECC_AVAILABLE))
+                                er_stat |= 1 << (i + 1);
                 }
+
         } else if (state == FL_WRITING) {
+
+                unsigned long corrected = mtd->ecc_stats.corrected;
+
                 /* single bank write logic */
-                this->cmdfunc (mtd, NAND_CMD_STATUS_ERROR, -1, -1);
+                this->cmdfunc(mtd, NAND_CMD_STATUS_ERROR, -1, -1);
                 rtn = this->read_byte(mtd);
-                this->cmdfunc (mtd, NAND_CMD_STATUS_RESET, -1, -1);
+                this->cmdfunc(mtd, NAND_CMD_STATUS_RESET, -1, -1);
+
                 if (!(rtn & ERR_STAT_ECC_AVAILABLE)) {
-                        er_stat |= 1<<1;        /* err_ecc_not_avail */
-                } else {
-                        len = mtd->oobblock;
-                        buf = kmalloc (len, GFP_KERNEL);
-                        if (!buf) {
-                                printk (KERN_ERR "rtc_from4_errstat: Out of memory!\n");
-                                er_stat = 1;                    /* if we can't check, assume failed */
-                        } else {
-                                /* recovery read */
-                                /* page read */
-                                rtn = nand_do_read_ecc (mtd, page, len, &retlen, buf, NULL, this->autooob, 1);
-                                if (rtn) {      /* if read failed or > 1-bit error corrected */
-                                        er_stat |= 1<<1;        /* ECC read failed */
-                                }
-                                kfree(buf);
-                        }
+                        /* err_ecc_not_avail */
+                        er_stat |= 1 << 1;
+                        goto out;
+                }
+
+                len = mtd->writesize;
+                buf = kmalloc(len, GFP_KERNEL);
+                if (!buf) {
+                        printk(KERN_ERR "rtc_from4_errstat: Out of memory!\n");
+                        er_stat = 1;
+                        goto out;
                 }
+
+                /* recovery read */
+                rtn = nand_do_read(mtd, page, len, &retlen, buf);
+
+                /* if read failed or > 1-bit error corrected */
+                if (rtn || (mtd->ecc_stats.corrected - corrected) > 1) {
+                        er_stat |= 1 << 1;
+                kfree(buf);
         }
 
         rtn = status;
-        if (er_stat == 0) {                             /* if ECC is available   */
+        if (er_stat == 0) {     /* if ECC is available   */
                 rtn = (status & ~NAND_STATUS_FAIL);     /*   clear the error bit */
         }
 
@@ -533,33 +510,32 @@ static int rtc_from4_errstat(struct mtd_info *mtd, struct nand_chip *this, int s
 }
 #endif
 
-
 /*
  * Main initialization routine
  */
-int __init rtc_from4_init (void)
+static int __init rtc_from4_init(void)
 {
         struct nand_chip *this;
         unsigned short bcr1, bcr2, wcr2;
         int i;
 
         /* Allocate memory for MTD device structure and private data */
-        rtc_from4_mtd = kmalloc(sizeof(struct mtd_info) + sizeof (struct nand_chip),
-                                GFP_KERNEL);
+        rtc_from4_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
         if (!rtc_from4_mtd) {
-                printk ("Unable to allocate Renesas NAND MTD device structure.\n");
+                printk("Unable to allocate Renesas NAND MTD device structure.\n");
                 return -ENOMEM;
         }
 
         /* Get pointer to private data */
-        this = (struct nand_chip *) (&rtc_from4_mtd[1]);
+        this = (struct nand_chip *)(&rtc_from4_mtd[1]);
 
         /* Initialize structures */
-        memset((char *) rtc_from4_mtd, 0, sizeof(struct mtd_info));
-        memset((char *) this, 0, sizeof(struct nand_chip));
+        memset(rtc_from4_mtd, 0, sizeof(struct mtd_info));
+        memset(this, 0, sizeof(struct nand_chip));
 
         /* Link the private data with the MTD structure */
         rtc_from4_mtd->priv = this;
+        rtc_from4_mtd->owner = THIS_MODULE;
 
         /* set area 5 as PCMCIA mode to clear the spec of tDH(Data hold time;9ns min) */
         bcr1 = *SH77X9_BCR1 & ~0x0002;
@@ -580,9 +556,9 @@ int __init rtc_from4_init (void)
         this->IO_ADDR_R = rtc_from4_fio_base;
         this->IO_ADDR_W = rtc_from4_fio_base;
         /* Set address of hardware control function */
-        this->hwcontrol = rtc_from4_hwcontrol;
+        this->cmd_ctrl = rtc_from4_hwcontrol;
         /* Set address of chip select function */
-        this->select_chip = rtc_from4_nand_select_chip;
+        this->select_chip = rtc_from4_nand_select_chip;
         /* command delay time (in us) */
         this->chip_delay = 100;
         /* return the status of the Ready/Busy line */
@@ -591,19 +567,20 @@ int __init rtc_from4_init (void)
 #ifdef RTC_FROM4_HWECC
         printk(KERN_INFO "rtc_from4_init: using hardware ECC detection.\n");
 
-        this->eccmode = NAND_ECC_HW8_512;
-        this->options |= NAND_HWECC_SYNDROME;
+        this->ecc.mode = NAND_ECC_HW_SYNDROME;
+        this->ecc.size = 512;
+        this->ecc.bytes = 8;
         /* return the status of extra status and ECC checks */
         this->errstat = rtc_from4_errstat;
         /* set the nand_oobinfo to support FPGA H/W error detection */
-        this->autooob = &rtc_from4_nand_oobinfo;
-        this->enable_hwecc = rtc_from4_enable_hwecc;
-        this->calculate_ecc = rtc_from4_calculate_ecc;
-        this->correct_data = rtc_from4_correct_data;
+        this->ecc.layout = &rtc_from4_nand_oobinfo;
+        this->ecc.hwctl = rtc_from4_enable_hwecc;
+        this->ecc.calculate = rtc_from4_calculate_ecc;
+        this->ecc.correct = rtc_from4_correct_data;
 #else
         printk(KERN_INFO "rtc_from4_init: using software ECC detection.\n");
 
-        this->eccmode = NAND_ECC_SOFT;
+        this->ecc.mode = NAND_ECC_SOFT;
 #endif
 
         /* set the bad block tables to support debugging */
@@ -617,7 +594,7 @@ int __init rtc_from4_init (void)
         }
 
         /* Perform 'device recovery' for each chip in case there was a power loss. */
-        for (i=0; i < this->numchips; i++) {
+        for (i = 0; i < this->numchips; i++) {
                 deplete(rtc_from4_mtd, i);
         }
 
@@ -643,7 +620,7 @@ int __init rtc_from4_init (void)
          */
         rs_decoder = init_rs(10, 0x409, 0, 1, 6);
         if (!rs_decoder) {
-                printk (KERN_ERR "Could not create a RS decoder\n");
+                printk(KERN_ERR "Could not create a RS decoder\n");
                 nand_release(rtc_from4_mtd);
                 kfree(rtc_from4_mtd);
                 return -ENOMEM;
@@ -652,20 +629,19 @@ int __init rtc_from4_init (void)
         /* Return happy */
         return 0;
 }
-module_init(rtc_from4_init);
 
+module_init(rtc_from4_init);
 
 /*
  * Clean up routine
  */
-#ifdef MODULE
-static void __exit rtc_from4_cleanup (void)
+static void __exit rtc_from4_cleanup(void)
 {
         /* Release resource, unregister partitions */
         nand_release(rtc_from4_mtd);
 
         /* Free the MTD device structure */
-        kfree (rtc_from4_mtd);
+        kfree(rtc_from4_mtd);
 
 #ifdef RTC_FROM4_HWECC
         /* Free the reed solomon resources */
@@ -674,10 +650,9 @@ static void __exit rtc_from4_cleanup (void)
         }
 #endif
 }
+
 module_exit(rtc_from4_cleanup);
-#endif
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("d.marlin <dmarlin@redhat.com");
 MODULE_DESCRIPTION("Board-specific glue layer for AG-AND flash on Renesas FROM_BOARD4");
-
diff --git a/drivers/mtd/nand/s3c2410.c b/drivers/mtd/nand/s3c2410.c
index 5b55599739f3..2c262fe03d8a 100644
--- a/drivers/mtd/nand/s3c2410.c
+++ b/drivers/mtd/nand/s3c2410.c
@@ -18,8 +18,9 @@
  *      20-Jun-2005  BJD  Updated s3c2440 support, fixed timing bug
  *      08-Jul-2005  BJD  Fix OOPS when no platform data supplied
  *      20-Oct-2005  BJD  Fix timing calculation bug
+ *      14-Jan-2006  BJD  Allow clock to be stopped when idle
  *
- * $Id: s3c2410.c,v 1.20 2005/11/07 11:14:31 gleixner Exp $
+ * $Id: s3c2410.c,v 1.23 2006/04/01 18:06:29 bjd Exp $
  *
  * 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
@@ -36,9 +37,6 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
-#include <config/mtd/nand/s3c2410/hwecc.h>
-#include <config/mtd/nand/s3c2410/debug.h>
-
 #ifdef CONFIG_MTD_NAND_S3C2410_DEBUG
 #define DEBUG
 #endif
@@ -73,14 +71,20 @@ static int hardware_ecc = 1;
 static int hardware_ecc = 0;
 #endif
 
+#ifdef CONFIG_MTD_NAND_S3C2410_CLKSTOP
+static int clock_stop = 1;
+#else
+static const int clock_stop = 0;
+#endif
+
+
 /* new oob placement block for use with hardware ecc generation
  */
 
-static struct nand_oobinfo nand_hw_eccoob = {
-        .useecc         = MTD_NANDECC_AUTOPLACE,
-        .eccbytes       = 3,
-        .eccpos         = {0, 1, 2 },
-        .oobfree        = { {8, 8} }
+static struct nand_ecclayout nand_hw_eccoob = {
+        .eccbytes = 3,
+        .eccpos = {0, 1, 2},
+        .oobfree = {{8, 8}}
 };
 
 /* controller and mtd information */
@@ -135,6 +139,11 @@ static struct s3c2410_platform_nand *to_nand_plat(struct platform_device *dev)
         return dev->dev.platform_data;
 }
 
+static inline int allow_clk_stop(struct s3c2410_nand_info *info)
+{
+        return clock_stop;
+}
+
 /* timing calculations */
 
 #define NS_IN_KHZ 1000000
@@ -149,8 +158,7 @@ static int s3c2410_nand_calc_rate(int wanted, unsigned long clk, int max)
         pr_debug("result %d from %ld, %d\n", result, clk, wanted);
 
         if (result > max) {
-                printk("%d ns is too big for current clock rate %ld\n",
-                       wanted, clk);
+                printk("%d ns is too big for current clock rate %ld\n", wanted, clk);
                 return -1;
         }
 
@@ -164,8 +172,7 @@ static int s3c2410_nand_calc_rate(int wanted, unsigned long clk, int max)
 
 /* controller setup */
 
-static int s3c2410_nand_inithw(struct s3c2410_nand_info *info,
-                               struct platform_device *pdev)
+static int s3c2410_nand_inithw(struct s3c2410_nand_info *info, struct platform_device *pdev)
 {
         struct s3c2410_platform_nand *plat = to_nand_plat(pdev);
         unsigned long clkrate = clk_get_rate(info->clk);
@@ -177,7 +184,7 @@ static int s3c2410_nand_inithw(struct s3c2410_nand_info *info,
         clkrate /= 1000;        /* turn clock into kHz for ease of use */
 
         if (plat != NULL) {
-                tacls  = s3c2410_nand_calc_rate(plat->tacls, clkrate, 4);
+                tacls = s3c2410_nand_calc_rate(plat->tacls, clkrate, 4);
                 twrph0 = s3c2410_nand_calc_rate(plat->twrph0, clkrate, 8);
                 twrph1 = s3c2410_nand_calc_rate(plat->twrph1, clkrate, 8);
         } else {
@@ -193,19 +200,22 @@ static int s3c2410_nand_inithw(struct s3c2410_nand_info *info,
         }
 
         printk(KERN_INFO PFX "Tacls=%d, %dns Twrph0=%d %dns, Twrph1=%d %dns\n",
-               tacls, to_ns(tacls, clkrate),
-               twrph0, to_ns(twrph0, clkrate),
-               twrph1, to_ns(twrph1, clkrate));
+               tacls, to_ns(tacls, clkrate), twrph0, to_ns(twrph0, clkrate), twrph1, to_ns(twrph1, clkrate));
 
         if (!info->is_s3c2440) {
-                cfg  = S3C2410_NFCONF_EN;
-                cfg |= S3C2410_NFCONF_TACLS(tacls-1);
-                cfg |= S3C2410_NFCONF_TWRPH0(twrph0-1);
-                cfg |= S3C2410_NFCONF_TWRPH1(twrph1-1);
+                cfg = S3C2410_NFCONF_EN;
+                cfg |= S3C2410_NFCONF_TACLS(tacls - 1);
+                cfg |= S3C2410_NFCONF_TWRPH0(twrph0 - 1);
+                cfg |= S3C2410_NFCONF_TWRPH1(twrph1 - 1);
         } else {
-                cfg   = S3C2440_NFCONF_TACLS(tacls-1);
-                cfg  |= S3C2440_NFCONF_TWRPH0(twrph0-1);
-                cfg  |= S3C2440_NFCONF_TWRPH1(twrph1-1);
+                cfg = S3C2440_NFCONF_TACLS(tacls - 1);
+                cfg |= S3C2440_NFCONF_TWRPH0(twrph0 - 1);
+                cfg |= S3C2440_NFCONF_TWRPH1(twrph1 - 1);
+
+                /* enable the controller and de-assert nFCE */
+
+                writel(S3C2440_NFCONT_ENABLE | S3C2440_NFCONT_ENABLE,
+                       info->regs + S3C2440_NFCONT);
         }
 
         pr_debug(PFX "NF_CONF is 0x%lx\n", cfg);
@@ -229,7 +239,10 @@ static void s3c2410_nand_select_chip(struct mtd_info *mtd, int chip)
         info = nmtd->info;
 
         bit = (info->is_s3c2440) ? S3C2440_NFCONT_nFCE : S3C2410_NFCONF_nFCE;
-        reg = info->regs+((info->is_s3c2440) ? S3C2440_NFCONT:S3C2410_NFCONF);
+        reg = info->regs + ((info->is_s3c2440) ? S3C2440_NFCONT : S3C2410_NFCONF);
+
+        if (chip != -1 && allow_clk_stop(info))
+                clk_enable(info->clk);
 
         cur = readl(reg);
 
@@ -243,77 +256,51 @@ static void s3c2410_nand_select_chip(struct mtd_info *mtd, int chip)
 
                 if (info->platform != NULL) {
                         if (info->platform->select_chip != NULL)
-                                (info->platform->select_chip)(nmtd->set, chip);
+                                (info->platform->select_chip) (nmtd->set, chip);
                 }
 
                 cur &= ~bit;
         }
 
         writel(cur, reg);
+
+        if (chip == -1 && allow_clk_stop(info))
+                clk_disable(info->clk);
 }
 
-/* command and control functions
- *
- * Note, these all use tglx's method of changing the IO_ADDR_W field
- * to make the code simpler, and use the nand layer's code to issue the
- * command and address sequences via the proper IO ports.
+/* s3c2410_nand_hwcontrol
  *
+ * Issue command and address cycles to the chip
 */
 
-static void s3c2410_nand_hwcontrol(struct mtd_info *mtd, int cmd)
+static void s3c2410_nand_hwcontrol(struct mtd_info *mtd, int cmd,
+                                   unsigned int ctrl)
 {
         struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
-        struct nand_chip *chip = mtd->priv;
-
-        switch (cmd) {
-        case NAND_CTL_SETNCE:
-        case NAND_CTL_CLRNCE:
-                printk(KERN_ERR "%s: called for NCE\n", __FUNCTION__);
-                break;
-
-        case NAND_CTL_SETCLE:
-                chip->IO_ADDR_W = info->regs + S3C2410_NFCMD;
-                break;
-
-        case NAND_CTL_SETALE:
-                chip->IO_ADDR_W = info->regs + S3C2410_NFADDR;
-                break;
-
-                /* NAND_CTL_CLRCLE: */
-                /* NAND_CTL_CLRALE: */
-        default:
-                chip->IO_ADDR_W = info->regs + S3C2410_NFDATA;
-                break;
-        }
+        
+        if (cmd == NAND_CMD_NONE)
+                return;
+
+        if (ctrl & NAND_CLE)
+                writeb(cmd, info->regs + S3C2410_NFCMD);
+        else
+                writeb(cmd, info->regs + S3C2410_NFADDR);
 }
 
 /* command and control functions */
 
-static void s3c2440_nand_hwcontrol(struct mtd_info *mtd, int cmd)
+static void s3c2440_nand_hwcontrol(struct mtd_info *mtd, int cmd,
+                                   unsigned int ctrl)
 {
         struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
-        struct nand_chip *chip = mtd->priv;
-
-        switch (cmd) {
-        case NAND_CTL_SETNCE:
-        case NAND_CTL_CLRNCE:
-                printk(KERN_ERR "%s: called for NCE\n", __FUNCTION__);
-                break;
-
-        case NAND_CTL_SETCLE:
-                chip->IO_ADDR_W = info->regs + S3C2440_NFCMD;
-                break;
-
-        case NAND_CTL_SETALE:
-                chip->IO_ADDR_W = info->regs + S3C2440_NFADDR;
-                break;
-
-                /* NAND_CTL_CLRCLE: */
-                /* NAND_CTL_CLRALE: */
-        default:
-                chip->IO_ADDR_W = info->regs + S3C2440_NFDATA;
-                break;
-        }
+
+        if (cmd == NAND_CMD_NONE)
+                return;
+
+        if (ctrl & NAND_CLE)
+                writeb(cmd, info->regs + S3C2440_NFCMD);
+        else
+                writeb(cmd, info->regs + S3C2440_NFADDR);
 }
 
 /* s3c2410_nand_devready()
@@ -330,22 +317,16 @@ static int s3c2410_nand_devready(struct mtd_info *mtd)
         return readb(info->regs + S3C2410_NFSTAT) & S3C2410_NFSTAT_BUSY;
 }
 
-
 /* ECC handling functions */
 
-static int s3c2410_nand_correct_data(struct mtd_info *mtd, u_char *dat,
-                                     u_char *read_ecc, u_char *calc_ecc)
+static int s3c2410_nand_correct_data(struct mtd_info *mtd, u_char *dat, u_char *read_ecc, u_char *calc_ecc)
 {
-        pr_debug("s3c2410_nand_correct_data(%p,%p,%p,%p)\n",
-                 mtd, dat, read_ecc, calc_ecc);
+        pr_debug("s3c2410_nand_correct_data(%p,%p,%p,%p)\n", mtd, dat, read_ecc, calc_ecc);
 
         pr_debug("eccs: read %02x,%02x,%02x vs calc %02x,%02x,%02x\n",
-                 read_ecc[0], read_ecc[1], read_ecc[2],
-                 calc_ecc[0], calc_ecc[1], calc_ecc[2]);
+                 read_ecc[0], read_ecc[1], read_ecc[2], calc_ecc[0], calc_ecc[1], calc_ecc[2]);
 
-        if (read_ecc[0] == calc_ecc[0] &&
-            read_ecc[1] == calc_ecc[1] &&
-            read_ecc[2] == calc_ecc[2])
+        if (read_ecc[0] == calc_ecc[0] && read_ecc[1] == calc_ecc[1] && read_ecc[2] == calc_ecc[2])
                 return 0;
 
         /* we curently have no method for correcting the error */
@@ -378,8 +359,7 @@ static void s3c2440_nand_enable_hwecc(struct mtd_info *mtd, int mode)
         writel(ctrl | S3C2440_NFCONT_INITECC, info->regs + S3C2440_NFCONT);
 }
 
-static int s3c2410_nand_calculate_ecc(struct mtd_info *mtd,
-                                      const u_char *dat, u_char *ecc_code)
+static int s3c2410_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code)
 {
         struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
 
@@ -387,15 +367,12 @@ static int s3c2410_nand_calculate_ecc(struct mtd_info *mtd,
         ecc_code[1] = readb(info->regs + S3C2410_NFECC + 1);
         ecc_code[2] = readb(info->regs + S3C2410_NFECC + 2);
 
-        pr_debug("calculate_ecc: returning ecc %02x,%02x,%02x\n",
-                 ecc_code[0], ecc_code[1], ecc_code[2]);
+        pr_debug("calculate_ecc: returning ecc %02x,%02x,%02x\n", ecc_code[0], ecc_code[1], ecc_code[2]);
 
         return 0;
 }
 
-
-static int s3c2440_nand_calculate_ecc(struct mtd_info *mtd,
-                                      const u_char *dat, u_char *ecc_code)
+static int s3c2440_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code)
 {
         struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
         unsigned long ecc = readl(info->regs + S3C2440_NFMECC0);
@@ -404,13 +381,11 @@ static int s3c2440_nand_calculate_ecc(struct mtd_info *mtd,
         ecc_code[1] = ecc >> 8;
         ecc_code[2] = ecc >> 16;
 
-        pr_debug("calculate_ecc: returning ecc %02x,%02x,%02x\n",
-                 ecc_code[0], ecc_code[1], ecc_code[2]);
+        pr_debug("calculate_ecc: returning ecc %02x,%02x,%02x\n", ecc_code[0], ecc_code[1], ecc_code[2]);
 
         return 0;
 }
 
-
 /* over-ride the standard functions for a little more speed. We can
  * use read/write block to move the data buffers to/from the controller
 */
@@ -421,8 +396,7 @@ static void s3c2410_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
         readsb(this->IO_ADDR_R, buf, len);
 }
 
-static void s3c2410_nand_write_buf(struct mtd_info *mtd,
-                                   const u_char *buf, int len)
+static void s3c2410_nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
 {
         struct nand_chip *this = mtd->priv;
         writesb(this->IO_ADDR_W, buf, len);
@@ -459,7 +433,8 @@ static int s3c2410_nand_remove(struct platform_device *pdev)
         /* free the common resources */
 
         if (info->clk != NULL && !IS_ERR(info->clk)) {
-                clk_disable(info->clk);
+                if (!allow_clk_stop(info))
+                        clk_disable(info->clk);
                 clk_put(info->clk);
         }
 
@@ -488,9 +463,7 @@ static int s3c2410_nand_add_partition(struct s3c2410_nand_info *info,
                 return add_mtd_device(&mtd->mtd);
 
         if (set->nr_partitions > 0 && set->partitions != NULL) {
-                return add_mtd_partitions(&mtd->mtd,
-                                          set->partitions,
-                                          set->nr_partitions);
+                return add_mtd_partitions(&mtd->mtd, set->partitions, set->nr_partitions);
         }
 
         return add_mtd_device(&mtd->mtd);
@@ -517,7 +490,7 @@ static void s3c2410_nand_init_chip(struct s3c2410_nand_info *info,
 
         chip->IO_ADDR_R    = info->regs + S3C2410_NFDATA;
         chip->IO_ADDR_W    = info->regs + S3C2410_NFDATA;
-        chip->hwcontrol    = s3c2410_nand_hwcontrol;
+        chip->cmd_ctrl     = s3c2410_nand_hwcontrol;
         chip->dev_ready    = s3c2410_nand_devready;
         chip->write_buf    = s3c2410_nand_write_buf;
         chip->read_buf     = s3c2410_nand_read_buf;
@@ -530,26 +503,29 @@ static void s3c2410_nand_init_chip(struct s3c2410_nand_info *info,
         if (info->is_s3c2440) {
                 chip->IO_ADDR_R  = info->regs + S3C2440_NFDATA;
                 chip->IO_ADDR_W  = info->regs + S3C2440_NFDATA;
-                chip->hwcontrol  = s3c2440_nand_hwcontrol;
+                chip->cmd_ctrl   = s3c2440_nand_hwcontrol;
         }
 
         nmtd->info         = info;
         nmtd->mtd.priv     = chip;
+        nmtd->mtd.owner    = THIS_MODULE;
         nmtd->set          = set;
 
         if (hardware_ecc) {
-                chip->correct_data  = s3c2410_nand_correct_data;
-                chip->enable_hwecc  = s3c2410_nand_enable_hwecc;
-                chip->calculate_ecc = s3c2410_nand_calculate_ecc;
-                chip->eccmode       = NAND_ECC_HW3_512;
-                chip->autooob       = &nand_hw_eccoob;
+                chip->ecc.correct   = s3c2410_nand_correct_data;
+                chip->ecc.hwctl     = s3c2410_nand_enable_hwecc;
+                chip->ecc.calculate = s3c2410_nand_calculate_ecc;
+                chip->ecc.mode      = NAND_ECC_HW;
+                chip->ecc.size      = 512;
+                chip->ecc.bytes     = 3;
+                chip->ecc.layout    = &nand_hw_eccoob;
 
                 if (info->is_s3c2440) {
-                        chip->enable_hwecc  = s3c2440_nand_enable_hwecc;
-                        chip->calculate_ecc = s3c2440_nand_calculate_ecc;
+                        chip->ecc.hwctl     = s3c2440_nand_enable_hwecc;
+                        chip->ecc.calculate = s3c2440_nand_calculate_ecc;
                 }
         } else {
-                chip->eccmode       = NAND_ECC_SOFT;
+                chip->ecc.mode      = NAND_ECC_SOFT;
         }
 }
 
@@ -654,13 +630,11 @@ static int s3c24xx_nand_probe(struct platform_device *pdev, int is_s3c2440)
         nmtd = info->mtds;
 
         for (setno = 0; setno < nr_sets; setno++, nmtd++) {
-                pr_debug("initialising set %d (%p, info %p)\n",
-                         setno, nmtd, info);
+                pr_debug("initialising set %d (%p, info %p)\n", setno, nmtd, info);
 
                 s3c2410_nand_init_chip(info, nmtd, sets);
 
-                nmtd->scan_res = nand_scan(&nmtd->mtd,
-                                           (sets) ? sets->nr_chips : 1);
+                nmtd->scan_res = nand_scan(&nmtd->mtd, (sets) ? sets->nr_chips : 1);
 
                 if (nmtd->scan_res == 0) {
                         s3c2410_nand_add_partition(info, nmtd, sets);
@@ -670,6 +644,11 @@ static int s3c24xx_nand_probe(struct platform_device *pdev, int is_s3c2440)
                         sets++;
         }
 
+        if (allow_clk_stop(info)) {
+                dev_info(&pdev->dev, "clock idle support enabled\n");
+                clk_disable(info->clk);
+        }
+
         pr_debug("initialised ok\n");
         return 0;
 
@@ -681,6 +660,41 @@ static int s3c24xx_nand_probe(struct platform_device *pdev, int is_s3c2440)
         return err;
 }
 
+/* PM Support */
+#ifdef CONFIG_PM
+
+static int s3c24xx_nand_suspend(struct platform_device *dev, pm_message_t pm)
+{
+        struct s3c2410_nand_info *info = platform_get_drvdata(dev);
+
+        if (info) {
+                if (!allow_clk_stop(info))
+                        clk_disable(info->clk);
+        }
+
+        return 0;
+}
+
+static int s3c24xx_nand_resume(struct platform_device *dev)
+{
+        struct s3c2410_nand_info *info = platform_get_drvdata(dev);
+
+        if (info) {
+                clk_enable(info->clk);
+                s3c2410_nand_inithw(info, dev);
+
+                if (allow_clk_stop(info))
+                        clk_disable(info->clk);
+        }
+
+        return 0;
+}
+
+#else
+#define s3c24xx_nand_suspend NULL
+#define s3c24xx_nand_resume NULL
+#endif
+
 /* driver device registration */
 
 static int s3c2410_nand_probe(struct platform_device *dev)
@@ -696,6 +710,8 @@ static int s3c2440_nand_probe(struct platform_device *dev)
 static struct platform_driver s3c2410_nand_driver = {
         .probe          = s3c2410_nand_probe,
         .remove         = s3c2410_nand_remove,
+        .suspend        = s3c24xx_nand_suspend,
+        .resume         = s3c24xx_nand_resume,
         .driver         = {
                 .name   = "s3c2410-nand",
                 .owner  = THIS_MODULE,
@@ -705,6 +721,8 @@ static struct platform_driver s3c2410_nand_driver = {
 static struct platform_driver s3c2440_nand_driver = {
         .probe          = s3c2440_nand_probe,
         .remove         = s3c2410_nand_remove,
+        .suspend        = s3c24xx_nand_suspend,
+        .resume         = s3c24xx_nand_resume,
         .driver         = {
                 .name   = "s3c2440-nand",
                 .owner  = THIS_MODULE,
diff --git a/drivers/mtd/nand/sharpsl.c b/drivers/mtd/nand/sharpsl.c
index 1924a4f137c7..21743658d150 100644
--- a/drivers/mtd/nand/sharpsl.c
+++ b/drivers/mtd/nand/sharpsl.c
@@ -46,7 +46,6 @@ static int sharpsl_phys_base = 0x0C000000;
 #define FLCLE           (1 << 1)
 #define FLCE0           (1 << 0)
 
-
 /*
  * MTD structure for SharpSL
  */
@@ -60,50 +59,44 @@ static struct mtd_info *sharpsl_mtd = NULL;
 static int nr_partitions;
 static struct mtd_partition sharpsl_nand_default_partition_info[] = {
         {
-        .name = "System Area",
-        .offset = 0,
-        .size = 7 * 1024 * 1024,
-        },
+         .name = "System Area",
+         .offset = 0,
+         .size = 7 * 1024 * 1024,
+         },
         {
-        .name = "Root Filesystem",
-        .offset = 7 * 1024 * 1024,
-        .size = 30 * 1024 * 1024,
-        },
+         .name = "Root Filesystem",
+         .offset = 7 * 1024 * 1024,
+         .size = 30 * 1024 * 1024,
+         },
         {
-        .name = "Home Filesystem",
-        .offset = MTDPART_OFS_APPEND ,
-        .size = MTDPART_SIZ_FULL ,
-        },
+         .name = "Home Filesystem",
+         .offset = MTDPART_OFS_APPEND,
+         .size = MTDPART_SIZ_FULL,
+         },
 };
 
 /*
  *      hardware specific access to control-lines
+ *      ctrl:
+ *      NAND_CNE: bit 0 -> bit 0 & 4
+ *      NAND_CLE: bit 1 -> bit 1
+ *      NAND_ALE: bit 2 -> bit 2
+ *
  */
-static void
-sharpsl_nand_hwcontrol(struct mtd_info* mtd, int cmd)
+static void sharpsl_nand_hwcontrol(struct mtd_info *mtd, int cmd,
+                                   unsigned int ctrl)
 {
-        switch (cmd) {
-        case NAND_CTL_SETCLE:
-                writeb(readb(FLASHCTL) | FLCLE, FLASHCTL);
-                break;
-        case NAND_CTL_CLRCLE:
-                writeb(readb(FLASHCTL) & ~FLCLE, FLASHCTL);
-                break;
-
-        case NAND_CTL_SETALE:
-                writeb(readb(FLASHCTL) | FLALE, FLASHCTL);
-                break;
-        case NAND_CTL_CLRALE:
-                writeb(readb(FLASHCTL) & ~FLALE, FLASHCTL);
-                break;
-
-        case NAND_CTL_SETNCE:
-                writeb(readb(FLASHCTL) & ~(FLCE0|FLCE1), FLASHCTL);
-                break;
-        case NAND_CTL_CLRNCE:
-                writeb(readb(FLASHCTL) | (FLCE0|FLCE1), FLASHCTL);
-                break;
+        struct nand_chip *chip = mtd->priv;
+
+        if (ctrl & NAND_CTRL_CHANGE) {
+                unsigned char bits = ctrl & 0x07;
+
+                bits |= (ctrl & 0x01) << 4;
+                writeb((readb(FLASHCTL) & 0x17) | bits, FLASHCTL);
         }
+
+        if (cmd != NAND_CMD_NONE)
+                writeb(cmd, chip->IO_ADDR_W);
 }
 
 static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
@@ -122,31 +115,26 @@ static struct nand_bbt_descr sharpsl_akita_bbt = {
         .pattern = scan_ff_pattern
 };
 
-static struct nand_oobinfo akita_oobinfo = {
-        .useecc = MTD_NANDECC_AUTOPLACE,
+static struct nand_ecclayout akita_oobinfo = {
         .eccbytes = 24,
         .eccpos = {
-                0x5,  0x1,  0x2,  0x3,  0x6,  0x7,  0x15, 0x11,
-                0x12, 0x13, 0x16, 0x17, 0x25, 0x21, 0x22, 0x23,
-                0x26, 0x27, 0x35, 0x31, 0x32, 0x33, 0x36, 0x37},
-        .oobfree = { {0x08, 0x09} }
+                   0x5, 0x1, 0x2, 0x3, 0x6, 0x7, 0x15, 0x11,
+                   0x12, 0x13, 0x16, 0x17, 0x25, 0x21, 0x22, 0x23,
+                   0x26, 0x27, 0x35, 0x31, 0x32, 0x33, 0x36, 0x37},
+        .oobfree = {{0x08, 0x09}}
 };
 
-static int
-sharpsl_nand_dev_ready(struct mtd_info* mtd)
+static int sharpsl_nand_dev_ready(struct mtd_info *mtd)
 {
         return !((readb(FLASHCTL) & FLRYBY) == 0);
 }
 
-static void
-sharpsl_nand_enable_hwecc(struct mtd_info* mtd, int mode)
+static void sharpsl_nand_enable_hwecc(struct mtd_info *mtd, int mode)
 {
-        writeb(0 ,ECCCLRR);
+        writeb(0, ECCCLRR);
 }
 
-static int
-sharpsl_nand_calculate_ecc(struct mtd_info* mtd, const u_char* dat,
-                                u_char* ecc_code)
+static int sharpsl_nand_calculate_ecc(struct mtd_info *mtd, const u_char * dat, u_char * ecc_code)
 {
         ecc_code[0] = ~readb(ECCLPUB);
         ecc_code[1] = ~readb(ECCLPLB);
@@ -154,47 +142,44 @@ sharpsl_nand_calculate_ecc(struct mtd_info* mtd, const u_char* dat,
         return readb(ECCCNTR) != 0;
 }
 
-
 #ifdef CONFIG_MTD_PARTITIONS
 const char *part_probes[] = { "cmdlinepart", NULL };
 #endif
 
-
 /*
  * Main initialization routine
  */
-int __init
-sharpsl_nand_init(void)
+static int __init sharpsl_nand_init(void)
 {
         struct nand_chip *this;
-        struct mtd_partition* sharpsl_partition_info;
+        struct mtd_partition *sharpsl_partition_info;
         int err = 0;
 
         /* Allocate memory for MTD device structure and private data */
-        sharpsl_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip),
-                                GFP_KERNEL);
+        sharpsl_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
         if (!sharpsl_mtd) {
-                printk ("Unable to allocate SharpSL NAND MTD device structure.\n");
+                printk("Unable to allocate SharpSL NAND MTD device structure.\n");
                 return -ENOMEM;
         }
 
         /* map physical adress */
         sharpsl_io_base = ioremap(sharpsl_phys_base, 0x1000);
-        if(!sharpsl_io_base){
+        if (!sharpsl_io_base) {
                 printk("ioremap to access Sharp SL NAND chip failed\n");
                 kfree(sharpsl_mtd);
                 return -EIO;
         }
 
         /* Get pointer to private data */
-        this = (struct nand_chip *) (&sharpsl_mtd[1]);
+        this = (struct nand_chip *)(&sharpsl_mtd[1]);
 
         /* Initialize structures */
-        memset((char *) sharpsl_mtd, 0, sizeof(struct mtd_info));
-        memset((char *) this, 0, sizeof(struct nand_chip));
+        memset(sharpsl_mtd, 0, sizeof(struct mtd_info));
+        memset(this, 0, sizeof(struct nand_chip));
 
         /* Link the private data with the MTD structure */
         sharpsl_mtd->priv = this;
+        sharpsl_mtd->owner = THIS_MODULE;
 
         /*
          * PXA initialize
@@ -205,23 +190,25 @@ sharpsl_nand_init(void)
         this->IO_ADDR_R = FLASHIO;
         this->IO_ADDR_W = FLASHIO;
         /* Set address of hardware control function */
-        this->hwcontrol = sharpsl_nand_hwcontrol;
+        this->cmd_ctrl = sharpsl_nand_hwcontrol;
         this->dev_ready = sharpsl_nand_dev_ready;
         /* 15 us command delay time */
         this->chip_delay = 15;
         /* set eccmode using hardware ECC */
-        this->eccmode = NAND_ECC_HW3_256;
+        this->ecc.mode = NAND_ECC_HW;
+        this->ecc.size = 256;
+        this->ecc.bytes = 3;
         this->badblock_pattern = &sharpsl_bbt;
         if (machine_is_akita() || machine_is_borzoi()) {
                 this->badblock_pattern = &sharpsl_akita_bbt;
-                this->autooob = &akita_oobinfo;
+                this->ecc.layout = &akita_oobinfo;
         }
-        this->enable_hwecc = sharpsl_nand_enable_hwecc;
-        this->calculate_ecc = sharpsl_nand_calculate_ecc;
-        this->correct_data = nand_correct_data;
+        this->ecc.hwctl = sharpsl_nand_enable_hwecc;
+        this->ecc.calculate = sharpsl_nand_calculate_ecc;
+        this->ecc.correct = nand_correct_data;
 
         /* Scan to find existence of the device */
-        err=nand_scan(sharpsl_mtd,1);
+        err = nand_scan(sharpsl_mtd, 1);
         if (err) {
                 iounmap(sharpsl_io_base);
                 kfree(sharpsl_mtd);
@@ -230,24 +217,23 @@ sharpsl_nand_init(void)
 
         /* Register the partitions */
         sharpsl_mtd->name = "sharpsl-nand";
-        nr_partitions = parse_mtd_partitions(sharpsl_mtd, part_probes,
-                                                &sharpsl_partition_info, 0);
+        nr_partitions = parse_mtd_partitions(sharpsl_mtd, part_probes, &sharpsl_partition_info, 0);
 
         if (nr_partitions <= 0) {
                 nr_partitions = DEFAULT_NUM_PARTITIONS;
                 sharpsl_partition_info = sharpsl_nand_default_partition_info;
                 if (machine_is_poodle()) {
-                        sharpsl_partition_info[1].size=30 * 1024 * 1024;
+                        sharpsl_partition_info[1].size = 22 * 1024 * 1024;
                 } else if (machine_is_corgi() || machine_is_shepherd()) {
-                        sharpsl_partition_info[1].size=25 * 1024 * 1024;
+                        sharpsl_partition_info[1].size = 25 * 1024 * 1024;
                 } else if (machine_is_husky()) {
-                        sharpsl_partition_info[1].size=53 * 1024 * 1024;
+                        sharpsl_partition_info[1].size = 53 * 1024 * 1024;
                 } else if (machine_is_spitz()) {
-                        sharpsl_partition_info[1].size=5 * 1024 * 1024;
+                        sharpsl_partition_info[1].size = 5 * 1024 * 1024;
                 } else if (machine_is_akita()) {
-                        sharpsl_partition_info[1].size=58 * 1024 * 1024;
+                        sharpsl_partition_info[1].size = 58 * 1024 * 1024;
                 } else if (machine_is_borzoi()) {
-                        sharpsl_partition_info[1].size=32 * 1024 * 1024;
+                        sharpsl_partition_info[1].size = 32 * 1024 * 1024;
                 }
         }
 
@@ -261,15 +247,15 @@ sharpsl_nand_init(void)
         /* Return happy */
         return 0;
 }
+
 module_init(sharpsl_nand_init);
 
 /*
  * Clean up routine
  */
-#ifdef MODULE
 static void __exit sharpsl_nand_cleanup(void)
 {
-        struct nand_chip *this = (struct nand_chip *) &sharpsl_mtd[1];
+        struct nand_chip *this = (struct nand_chip *)&sharpsl_mtd[1];
 
         /* Release resources, unregister device */
         nand_release(sharpsl_mtd);
@@ -279,8 +265,8 @@ static void __exit sharpsl_nand_cleanup(void)
         /* Free the MTD device structure */
         kfree(sharpsl_mtd);
 }
+
 module_exit(sharpsl_nand_cleanup);
-#endif
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
diff --git a/drivers/mtd/nand/spia.c b/drivers/mtd/nand/spia.c
index 9cf1ce718ec1..1f6d429b1583 100644
--- a/drivers/mtd/nand/spia.c
+++ b/drivers/mtd/nand/spia.c
@@ -39,16 +39,16 @@ static struct mtd_info *spia_mtd = NULL;
  */
 #define SPIA_IO_BASE    0xd0000000      /* Start of EP7212 IO address space */
 #define SPIA_FIO_BASE   0xf0000000      /* Address where flash is mapped */
-#define SPIA_PEDR       0x0080          /*
-                                         * IO offset to Port E data register
-                                         * where the CLE, ALE and NCE pins
-                                         * are wired to.
-                                         */
-#define SPIA_PEDDR      0x00c0          /*
-                                         * IO offset to Port E data direction
-                                         * register so we can control the IO
-                                         * lines.
-                                         */
+#define SPIA_PEDR       0x0080  /*
+                                 * IO offset to Port E data register
+                                 * where the CLE, ALE and NCE pins
+                                 * are wired to.
+                                 */
+#define SPIA_PEDDR      0x00c0  /*
+                                 * IO offset to Port E data direction
+                                 * register so we can control the IO
+                                 * lines.
+                                 */
 
 /*
  * Module stuff
@@ -69,79 +69,84 @@ module_param(spia_peddr, int, 0);
  */
 static const struct mtd_partition partition_info[] = {
         {
-                .name   = "SPIA flash partition 1",
-                .offset = 0,
-                .size   = 2*1024*1024
-        },
+         .name = "SPIA flash partition 1",
+         .offset = 0,
+         .size = 2 * 1024 * 1024},
         {
-                .name   = "SPIA flash partition 2",
-                .offset = 2*1024*1024,
-                .size   = 6*1024*1024
-        }
+         .name = "SPIA flash partition 2",
+         .offset = 2 * 1024 * 1024,
+         .size = 6 * 1024 * 1024}
 };
-#define NUM_PARTITIONS 2
 
+#define NUM_PARTITIONS 2
 
 /*
  *      hardware specific access to control-lines
-*/
-static void spia_hwcontrol(struct mtd_info *mtd, int cmd){
-
-    switch(cmd){
+ *
+ *      ctrl:
+ *      NAND_CNE: bit 0 -> bit 2
+ *      NAND_CLE: bit 1 -> bit 0
+ *      NAND_ALE: bit 2 -> bit 1
+ */
+static void spia_hwcontrol(struct mtd_info *mtd, int cmd)
+{
+        struct nand_chip *chip = mtd->priv;
 
-        case NAND_CTL_SETCLE: (*(volatile unsigned char *) (spia_io_base + spia_pedr)) |=  0x01; break;
-        case NAND_CTL_CLRCLE: (*(volatile unsigned char *) (spia_io_base + spia_pedr)) &= ~0x01; break;
+        if (ctrl & NAND_CTRL_CHANGE) {
+                void __iomem *addr = spia_io_base + spia_pedr;
+                unsigned char bits;
 
-        case NAND_CTL_SETALE: (*(volatile unsigned char *) (spia_io_base + spia_pedr)) |=  0x02; break;
-        case NAND_CTL_CLRALE: (*(volatile unsigned char *) (spia_io_base + spia_pedr)) &= ~0x02; break;
+                bits = (ctrl & NAND_CNE) << 2;
+                bits |= (ctrl & NAND_CLE | NAND_ALE) >> 1;
+                writeb((readb(addr) & ~0x7) | bits, addr);
+        }
 
-        case NAND_CTL_SETNCE: (*(volatile unsigned char *) (spia_io_base + spia_pedr)) &= ~0x04; break;
-        case NAND_CTL_CLRNCE: (*(volatile unsigned char *) (spia_io_base + spia_pedr)) |=  0x04; break;
-    }
+        if (cmd != NAND_CMD_NONE)
+                writeb(cmd, chip->IO_ADDR_W);
 }
 
 /*
  * Main initialization routine
  */
-int __init spia_init (void)
+static int __init spia_init(void)
 {
         struct nand_chip *this;
 
         /* Allocate memory for MTD device structure and private data */
-        spia_mtd = kmalloc (sizeof(struct mtd_info) + sizeof (struct nand_chip),
-                                GFP_KERNEL);
+        spia_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
         if (!spia_mtd) {
-                printk ("Unable to allocate SPIA NAND MTD device structure.\n");
+                printk("Unable to allocate SPIA NAND MTD device structure.\n");
                 return -ENOMEM;
         }
 
         /* Get pointer to private data */
-        this = (struct nand_chip *) (&spia_mtd[1]);
+        this = (struct nand_chip *)(&spia_mtd[1]);
 
         /* Initialize structures */
-        memset((char *) spia_mtd, 0, sizeof(struct mtd_info));
-        memset((char *) this, 0, sizeof(struct nand_chip));
+        memset(spia_mtd, 0, sizeof(struct mtd_info));
+        memset(this, 0, sizeof(struct nand_chip));
 
         /* Link the private data with the MTD structure */
         spia_mtd->priv = this;
+        spia_mtd->owner = THIS_MODULE;
 
         /*
          * Set GPIO Port E control register so that the pins are configured
          * to be outputs for controlling the NAND flash.
          */
-        (*(volatile unsigned char *) (spia_io_base + spia_peddr)) = 0x07;
+        (*(volatile unsigned char *)(spia_io_base + spia_peddr)) = 0x07;
 
         /* Set address of NAND IO lines */
-        this->IO_ADDR_R = (void __iomem *) spia_fio_base;
-        this->IO_ADDR_W = (void __iomem *) spia_fio_base;
+        this->IO_ADDR_R = (void __iomem *)spia_fio_base;
+        this->IO_ADDR_W = (void __iomem *)spia_fio_base;
         /* Set address of hardware control function */
-        this->hwcontrol = spia_hwcontrol;
+        this->cmd_ctrl = spia_hwcontrol;
         /* 15 us command delay time */
         this->chip_delay = 15;
 
         /* Scan to find existence of the device */
-        if (nand_scan (spia_mtd, 1)) {
-                kfree (spia_mtd);
+        if (nand_scan(spia_mtd, 1)) {
+                kfree(spia_mtd);
                 return -ENXIO;
         }
 
@@ -151,22 +156,22 @@ int __init spia_init (void)
         /* Return happy */
         return 0;
 }
+
 module_init(spia_init);
 
 /*
  * Clean up routine
  */
-#ifdef MODULE
-static void __exit spia_cleanup (void)
+static void __exit spia_cleanup(void)
 {
         /* Release resources, unregister device */
-        nand_release (spia_mtd);
+        nand_release(spia_mtd);
 
         /* Free the MTD device structure */
-        kfree (spia_mtd);
+        kfree(spia_mtd);
 }
+
 module_exit(spia_cleanup);
-#endif
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Steven J. Hill <sjhill@realitydiluted.com");
diff --git a/drivers/mtd/nand/toto.c b/drivers/mtd/nand/toto.c
index 7609c43cb3ec..f9e2d4a0ab8c 100644
--- a/drivers/mtd/nand/toto.c
+++ b/drivers/mtd/nand/toto.c
@@ -32,6 +32,8 @@
 #include <asm/arch-omap1510/hardware.h>
 #include <asm/arch/gpio.h>
 
+#define CONFIG_NAND_WORKAROUND 1
+
 /*
  * MTD structure for TOTO board
  */
@@ -39,25 +41,6 @@ static struct mtd_info *toto_mtd = NULL;
 
 static unsigned long toto_io_base = OMAP_FLASH_1_BASE;
 
-#define CONFIG_NAND_WORKAROUND 1
-
-#define NAND_NCE 0x4000
-#define NAND_CLE 0x1000
-#define NAND_ALE 0x0002
-#define NAND_MASK (NAND_CLE | NAND_ALE | NAND_NCE)
-
-#define T_NAND_CTL_CLRALE(iob)  gpiosetout(NAND_ALE, 0)
-#define T_NAND_CTL_SETALE(iob)  gpiosetout(NAND_ALE, NAND_ALE)
-#ifdef CONFIG_NAND_WORKAROUND     /* "some" dev boards busted, blue wired to rts2 :( */
-#define T_NAND_CTL_CLRCLE(iob)  gpiosetout(NAND_CLE, 0); rts2setout(2, 2)
-#define T_NAND_CTL_SETCLE(iob)  gpiosetout(NAND_CLE, NAND_CLE); rts2setout(2, 0)
-#else
-#define T_NAND_CTL_CLRCLE(iob)  gpiosetout(NAND_CLE, 0)
-#define T_NAND_CTL_SETCLE(iob)  gpiosetout(NAND_CLE, NAND_CLE)
-#endif
-#define T_NAND_CTL_SETNCE(iob)  gpiosetout(NAND_NCE, 0)
-#define T_NAND_CTL_CLRNCE(iob)  gpiosetout(NAND_NCE, NAND_NCE)
-
 /*
  * Define partitions for flash devices
  */
@@ -91,91 +74,110 @@ static struct mtd_partition partition_info32M[] = {
 
 #define NUM_PARTITIONS32M 3
 #define NUM_PARTITIONS64M 4
+
 /*
  *      hardware specific access to control-lines
-*/
-
-static void toto_hwcontrol(struct mtd_info *mtd, int cmd)
+ *
+ *      ctrl:
+ *      NAND_NCE: bit 0 -> bit 14 (0x4000)
+ *      NAND_CLE: bit 1 -> bit 12 (0x1000)
+ *      NAND_ALE: bit 2 -> bit 1  (0x0002)
+ */
+static void toto_hwcontrol(struct mtd_info *mtd, int cmd,
+                           unsigned int ctrl)
 {
+        struct nand_chip *chip = mtd->priv;
+
+        if (ctrl & NAND_CTRL_CHANGE) {
+                unsigned long bits;
 
-        udelay(1); /* hopefully enough time for tc make proceding write to clear */
-        switch(cmd){
+                /* hopefully enough time for tc make proceding write to clear */
+                udelay(1);
 
-                case NAND_CTL_SETCLE: T_NAND_CTL_SETCLE(cmd); break;
-                case NAND_CTL_CLRCLE: T_NAND_CTL_CLRCLE(cmd); break;
+                bits = (~ctrl & NAND_NCE) << 14;
+                bits |= (ctrl & NAND_CLE) << 12;
+                bits |= (ctrl & NAND_ALE) >> 1;
 
-                case NAND_CTL_SETALE: T_NAND_CTL_SETALE(cmd); break;
-                case NAND_CTL_CLRALE: T_NAND_CTL_CLRALE(cmd); break;
+#warning Wild guess as gpiosetout() is nowhere defined in the kernel source - tglx
+                gpiosetout(0x5002, bits);
 
-                case NAND_CTL_SETNCE: T_NAND_CTL_SETNCE(cmd); break;
-                case NAND_CTL_CLRNCE: T_NAND_CTL_CLRNCE(cmd); break;
+#ifdef CONFIG_NAND_WORKAROUND
+                /* "some" dev boards busted, blue wired to rts2 :( */
+                rts2setout(2, (ctrl & NAND_CLE) << 1);
+#endif
+                /* allow time to ensure gpio state to over take memory write */
+                udelay(1);
         }
-        udelay(1); /* allow time to ensure gpio state to over take memory write */
+
+        if (cmd != NAND_CMD_NONE)
+                writeb(cmd, chip->IO_ADDR_W);
 }
 
 /*
  * Main initialization routine
  */
-int __init toto_init (void)
+static int __init toto_init(void)
 {
         struct nand_chip *this;
         int err = 0;
 
         /* Allocate memory for MTD device structure and private data */
-        toto_mtd = kmalloc (sizeof(struct mtd_info) + sizeof (struct nand_chip),
-                                GFP_KERNEL);
+        toto_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
         if (!toto_mtd) {
-                printk (KERN_WARNING "Unable to allocate toto NAND MTD device structure.\n");
+                printk(KERN_WARNING "Unable to allocate toto NAND MTD device structure.\n");
                 err = -ENOMEM;
                 goto out;
         }
 
         /* Get pointer to private data */
-        this = (struct nand_chip *) (&toto_mtd[1]);
+        this = (struct nand_chip *)(&toto_mtd[1]);
 
         /* Initialize structures */
-        memset((char *) toto_mtd, 0, sizeof(struct mtd_info));
-        memset((char *) this, 0, sizeof(struct nand_chip));
+        memset(toto_mtd, 0, sizeof(struct mtd_info));
+        memset(this, 0, sizeof(struct nand_chip));
 
         /* Link the private data with the MTD structure */
         toto_mtd->priv = this;
+        toto_mtd->owner = THIS_MODULE;
 
         /* Set address of NAND IO lines */
         this->IO_ADDR_R = toto_io_base;
         this->IO_ADDR_W = toto_io_base;
-        this->hwcontrol = toto_hwcontrol;
+        this->cmd_ctrl = toto_hwcontrol;
         this->dev_ready = NULL;
         /* 25 us command delay time */
         this->chip_delay = 30;
-        this->eccmode = NAND_ECC_SOFT;
+        this->ecc.mode = NAND_ECC_SOFT;
 
-        /* Scan to find existance of the device */
-        if (nand_scan (toto_mtd, 1)) {
+        /* Scan to find existance of the device */
+        if (nand_scan(toto_mtd, 1)) {
                 err = -ENXIO;
                 goto out_mtd;
         }
 
         /* Register the partitions */
-        switch(toto_mtd->size){
-                case SZ_64M: add_mtd_partitions(toto_mtd, partition_info64M, NUM_PARTITIONS64M); break;
-                case SZ_32M: add_mtd_partitions(toto_mtd, partition_info32M, NUM_PARTITIONS32M); break;
-                default: {
-                        printk (KERN_WARNING "Unsupported Nand device\n");
+        switch (toto_mtd->size) {
+        case SZ_64M:
+                add_mtd_partitions(toto_mtd, partition_info64M, NUM_PARTITIONS64M);
+                break;
+        case SZ_32M:
+                add_mtd_partitions(toto_mtd, partition_info32M, NUM_PARTITIONS32M);
+                break;
+        default:{
+                        printk(KERN_WARNING "Unsupported Nand device\n");
                         err = -ENXIO;
                         goto out_buf;
                 }
         }
 
-        gpioreserve(NAND_MASK);  /* claim our gpios */
-        archflashwp(0,0);        /* open up flash for writing */
+        gpioreserve(NAND_MASK); /* claim our gpios */
+        archflashwp(0, 0);      /* open up flash for writing */
 
         goto out;
 
-out_buf:
-        kfree (this->data_buf);
-out_mtd:
-        kfree (toto_mtd);
-out:
+ out_mtd:
+        kfree(toto_mtd);
+ out:
         return err;
 }
 
@@ -184,20 +186,21 @@ module_init(toto_init);
 /*
  * Clean up routine
  */
-static void __exit toto_cleanup (void)
+static void __exit toto_cleanup(void)
 {
         /* Release resources, unregister device */
-        nand_release (toto_mtd);
+        nand_release(toto_mtd);
 
         /* Free the MTD device structure */
-        kfree (toto_mtd);
+        kfree(toto_mtd);
 
         /* stop flash writes */
-         archflashwp(0,1);
+        archflashwp(0, 1);
 
         /* release gpios to system */
-         gpiorelease(NAND_MASK);
+        gpiorelease(NAND_MASK);
 }
+
 module_exit(toto_cleanup);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/nand/ts7250.c b/drivers/mtd/nand/ts7250.c
new file mode 100644
index 000000000000..a0b4b1edcb0d
--- /dev/null
+++ b/drivers/mtd/nand/ts7250.c
@@ -0,0 +1,206 @@
+/*
+ * drivers/mtd/nand/ts7250.c
+ *
+ * Copyright (C) 2004 Technologic Systems (support@embeddedARM.com)
+ *
+ * Derived from drivers/mtd/nand/edb7312.c
+ *   Copyright (C) 2004 Marius Gröger (mag@sysgo.de)
+ *
+ * Derived from drivers/mtd/nand/autcpu12.c
+ *   Copyright (c) 2001 Thomas Gleixner (gleixner@autronix.de)
+ *
+ * $Id: ts7250.c,v 1.4 2004/12/30 22:02:07 joff Exp $
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Overview:
+ *   This is a device driver for the NAND flash device found on the
+ *   TS-7250 board which utilizes a Samsung 32 Mbyte part.
+ */
+
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/mtd/partitions.h>
+#include <asm/io.h>
+#include <asm/arch/hardware.h>
+#include <asm/sizes.h>
+#include <asm/mach-types.h>
+
+/*
+ * MTD structure for TS7250 board
+ */
+static struct mtd_info *ts7250_mtd = NULL;
+
+#ifdef CONFIG_MTD_PARTITIONS
+static const char *part_probes[] = { "cmdlinepart", NULL };
+
+#define NUM_PARTITIONS 3
+
+/*
+ * Define static partitions for flash device
+ */
+static struct mtd_partition partition_info32[] = {
+        {
+                .name           = "TS-BOOTROM",
+                .offset         = 0x00000000,
+                .size           = 0x00004000,
+        }, {
+                .name           = "Linux",
+                .offset         = 0x00004000,
+                .size           = 0x01d00000,
+        }, {
+                .name           = "RedBoot",
+                .offset         = 0x01d04000,
+                .size           = 0x002fc000,
+        },
+};
+
+/*
+ * Define static partitions for flash device
+ */
+static struct mtd_partition partition_info128[] = {
+        {
+                .name           = "TS-BOOTROM",
+                .offset         = 0x00000000,
+                .size           = 0x00004000,
+        }, {
+                .name           = "Linux",
+                .offset         = 0x00004000,
+                .size           = 0x07d00000,
+        }, {
+                .name           = "RedBoot",
+                .offset         = 0x07d04000,
+                .size           = 0x002fc000,
+        },
+};
+#endif
+
+
+/*
+ *      hardware specific access to control-lines
+ *
+ *      ctrl:
+ *      NAND_NCE: bit 0 -> bit 2
+ *      NAND_CLE: bit 1 -> bit 1
+ *      NAND_ALE: bit 2 -> bit 0
+ */
+static void ts7250_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl)
+{
+        struct nand_chip *chip = mtd->priv;
+
+        if (ctrl & NAND_CTRL_CHANGE) {
+                unsigned long addr = TS72XX_NAND_CONTROL_VIRT_BASE;
+                unsigned char bits;
+
+                bits = (ctrl & NAND_CNE) << 2;
+                bits |= ctrl & NAND_CLE;
+                bits |= (ctrl & NAND_ALE) >> 2;
+
+                __raw_writeb((__raw_readb(addr) & ~0x7) | bits, addr);
+        }
+
+        if (cmd != NAND_CMD_NONE)
+                writeb(cmd, chip->IO_ADDR_W);
+}
+
+/*
+ *      read device ready pin
+ */
+static int ts7250_device_ready(struct mtd_info *mtd)
+{
+        return __raw_readb(TS72XX_NAND_BUSY_VIRT_BASE) & 0x20;
+}
+
+/*
+ * Main initialization routine
+ */
+static int __init ts7250_init(void)
+{
+        struct nand_chip *this;
+        const char *part_type = 0;
+        int mtd_parts_nb = 0;
+        struct mtd_partition *mtd_parts = 0;
+
+        if (!machine_is_ts72xx() || board_is_ts7200())
+                return -ENXIO;
+
+        /* Allocate memory for MTD device structure and private data */
+        ts7250_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
+        if (!ts7250_mtd) {
+                printk("Unable to allocate TS7250 NAND MTD device structure.\n");
+                return -ENOMEM;
+        }
+
+        /* Get pointer to private data */
+        this = (struct nand_chip *)(&ts7250_mtd[1]);
+
+        /* Initialize structures */
+        memset(ts7250_mtd, 0, sizeof(struct mtd_info));
+        memset(this, 0, sizeof(struct nand_chip));
+
+        /* Link the private data with the MTD structure */
+        ts7250_mtd->priv = this;
+        ts7250_mtd->owner = THIS_MODULE;
+
+        /* insert callbacks */
+        this->IO_ADDR_R = (void *)TS72XX_NAND_DATA_VIRT_BASE;
+        this->IO_ADDR_W = (void *)TS72XX_NAND_DATA_VIRT_BASE;
+        this->cmd_ctrl = ts7250_hwcontrol;
+        this->dev_ready = ts7250_device_ready;
+        this->chip_delay = 15;
+        this->ecc.mode = NAND_ECC_SOFT;
+
+        printk("Searching for NAND flash...\n");
+        /* Scan to find existence of the device */
+        if (nand_scan(ts7250_mtd, 1)) {
+                kfree(ts7250_mtd);
+                return -ENXIO;
+        }
+#ifdef CONFIG_MTD_PARTITIONS
+        ts7250_mtd->name = "ts7250-nand";
+        mtd_parts_nb = parse_mtd_partitions(ts7250_mtd, part_probes, &mtd_parts, 0);
+        if (mtd_parts_nb > 0)
+                part_type = "command line";
+        else
+                mtd_parts_nb = 0;
+#endif
+        if (mtd_parts_nb == 0) {
+                mtd_parts = partition_info32;
+                if (ts7250_mtd->size >= (128 * 0x100000))
+                        mtd_parts = partition_info128;
+                mtd_parts_nb = NUM_PARTITIONS;
+                part_type = "static";
+        }
+
+        /* Register the partitions */
+        printk(KERN_NOTICE "Using %s partition definition\n", part_type);
+        add_mtd_partitions(ts7250_mtd, mtd_parts, mtd_parts_nb);
+
+        /* Return happy */
+        return 0;
+}
+
+module_init(ts7250_init);
+
+/*
+ * Clean up routine
+ */
+static void __exit ts7250_cleanup(void)
+{
+        /* Unregister the device */
+        del_mtd_device(ts7250_mtd);
+
+        /* Free the MTD device structure */
+        kfree(ts7250_mtd);
+}
+
+module_exit(ts7250_cleanup);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jesse Off <joff@embeddedARM.com>");
+MODULE_DESCRIPTION("MTD map driver for Technologic Systems TS-7250 board");
diff --git a/drivers/mtd/nftlcore.c b/drivers/mtd/nftlcore.c
index d7cd5fa16ba4..dc7573501d8c 100644
--- a/drivers/mtd/nftlcore.c
+++ b/drivers/mtd/nftlcore.c
@@ -70,8 +70,6 @@ static void nftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
         nftl->mbd.devnum = -1;
         nftl->mbd.blksize = 512;
         nftl->mbd.tr = tr;
-        memcpy(&nftl->oobinfo, &mtd->oobinfo, sizeof(struct nand_oobinfo));
-        nftl->oobinfo.useecc = MTD_NANDECC_PLACEONLY;
 
         if (NFTL_mount(nftl) < 0) {
                 printk(KERN_WARNING "NFTL: could not mount device\n");
@@ -136,6 +134,69 @@ static void nftl_remove_dev(struct mtd_blktrans_dev *dev)
         kfree(nftl);
 }
 
+/*
+ * Read oob data from flash
+ */
+int nftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len,
+                  size_t *retlen, uint8_t *buf)
+{
+        struct mtd_oob_ops ops;
+        int res;
+
+        ops.mode = MTD_OOB_PLACE;
+        ops.ooboffs = offs & (mtd->writesize - 1);
+        ops.ooblen = len;
+        ops.oobbuf = buf;
+        ops.datbuf = NULL;
+        ops.len = len;
+
+        res = mtd->read_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
+        *retlen = ops.retlen;
+        return res;
+}
+
+/*
+ * Write oob data to flash
+ */
+int nftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len,
+                   size_t *retlen, uint8_t *buf)
+{
+        struct mtd_oob_ops ops;
+        int res;
+
+        ops.mode = MTD_OOB_PLACE;
+        ops.ooboffs = offs & (mtd->writesize - 1);
+        ops.ooblen = len;
+        ops.oobbuf = buf;
+        ops.datbuf = NULL;
+        ops.len = len;
+
+        res = mtd->write_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
+        *retlen = ops.retlen;
+        return res;
+}
+
+/*
+ * Write data and oob to flash
+ */
+static int nftl_write(struct mtd_info *mtd, loff_t offs, size_t len,
+                      size_t *retlen, uint8_t *buf, uint8_t *oob)
+{
+        struct mtd_oob_ops ops;
+        int res;
+
+        ops.mode = MTD_OOB_PLACE;
+        ops.ooboffs = offs;
+        ops.ooblen = mtd->oobsize;
+        ops.oobbuf = oob;
+        ops.datbuf = buf;
+        ops.len = len;
+
+        res = mtd->write_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
+        *retlen = ops.retlen;
+        return res;
+}
+
 #ifdef CONFIG_NFTL_RW
 
 /* Actual NFTL access routines */
@@ -185,6 +246,7 @@ static u16 NFTL_findfreeblock(struct NFTLrecord *nftl, int desperate )
 
 static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned pendingblock )
 {
+        struct mtd_info *mtd = nftl->mbd.mtd;
         u16 BlockMap[MAX_SECTORS_PER_UNIT];
         unsigned char BlockLastState[MAX_SECTORS_PER_UNIT];
         unsigned char BlockFreeFound[MAX_SECTORS_PER_UNIT];
@@ -194,7 +256,7 @@ static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned p
         unsigned int targetEUN;
         struct nftl_oob oob;
         int inplace = 1;
-        size_t retlen;
+        size_t retlen;
 
         memset(BlockMap, 0xff, sizeof(BlockMap));
         memset(BlockFreeFound, 0, sizeof(BlockFreeFound));
@@ -210,21 +272,21 @@ static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned p
         /* Scan to find the Erase Unit which holds the actual data for each
            512-byte block within the Chain.
         */
-        silly = MAX_LOOPS;
+        silly = MAX_LOOPS;
         targetEUN = BLOCK_NIL;
         while (thisEUN <= nftl->lastEUN ) {
-                unsigned int status, foldmark;
+                unsigned int status, foldmark;
 
                 targetEUN = thisEUN;
                 for (block = 0; block < nftl->EraseSize / 512; block ++) {
-                        MTD_READOOB(nftl->mbd.mtd,
-                                    (thisEUN * nftl->EraseSize) + (block * 512),
-                                    16 , &retlen, (char *)&oob);
+                        nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
+                                      (block * 512), 16 , &retlen,
+                                      (char *)&oob);
                         if (block == 2) {
-                                foldmark = oob.u.c.FoldMark | oob.u.c.FoldMark1;
-                                if (foldmark == FOLD_MARK_IN_PROGRESS) {
-                                        DEBUG(MTD_DEBUG_LEVEL1,
-                                              "Write Inhibited on EUN %d\n", thisEUN);
+                                foldmark = oob.u.c.FoldMark | oob.u.c.FoldMark1;
+                                if (foldmark == FOLD_MARK_IN_PROGRESS) {
+                                        DEBUG(MTD_DEBUG_LEVEL1,
+                                              "Write Inhibited on EUN %d\n", thisEUN);
                                         inplace = 0;
                                 } else {
                                         /* There's no other reason not to do inplace,
@@ -233,7 +295,7 @@ static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned p
                                         inplace = 1;
                                 }
                         }
-                        status = oob.b.Status | oob.b.Status1;
+                        status = oob.b.Status | oob.b.Status1;
                         BlockLastState[block] = status;
 
                         switch(status) {
@@ -328,15 +390,15 @@ static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned p
                         return BLOCK_NIL;
                 }
         } else {
-            /* We put a fold mark in the chain we are folding only if
-               we fold in place to help the mount check code. If we do
-               not fold in place, it is possible to find the valid
-               chain by selecting the longer one */
-            oob.u.c.FoldMark = oob.u.c.FoldMark1 = cpu_to_le16(FOLD_MARK_IN_PROGRESS);
-            oob.u.c.unused = 0xffffffff;
-            MTD_WRITEOOB(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) + 2 * 512 + 8,
-                         8, &retlen, (char *)&oob.u);
-        }
+                /* We put a fold mark in the chain we are folding only if we
+               fold in place to help the mount check code. If we do not fold in
+               place, it is possible to find the valid chain by selecting the
+               longer one */
+                oob.u.c.FoldMark = oob.u.c.FoldMark1 = cpu_to_le16(FOLD_MARK_IN_PROGRESS);
+                oob.u.c.unused = 0xffffffff;
+                nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 2 * 512 + 8,
+                               8, &retlen, (char *)&oob.u);
+        }
 
         /* OK. We now know the location of every block in the Virtual Unit Chain,
            and the Erase Unit into which we are supposed to be copying.
@@ -353,33 +415,33 @@ static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned p
                         continue;
                 }
 
-                /* copy only in non free block (free blocks can only
+                /* copy only in non free block (free blocks can only
                    happen in case of media errors or deleted blocks) */
-                if (BlockMap[block] == BLOCK_NIL)
-                        continue;
-
-                ret = MTD_READ(nftl->mbd.mtd, (nftl->EraseSize * BlockMap[block]) + (block * 512),
-                                  512, &retlen, movebuf);
-                if (ret < 0) {
-                    ret = MTD_READ(nftl->mbd.mtd, (nftl->EraseSize * BlockMap[block])
-                                      + (block * 512), 512, &retlen,
-                                      movebuf);
-                    if (ret != -EIO)
-                        printk("Error went away on retry.\n");
-                }
+                if (BlockMap[block] == BLOCK_NIL)
+                        continue;
+
+                ret = mtd->read(mtd, (nftl->EraseSize * BlockMap[block]) + (block * 512),
+                                512, &retlen, movebuf);
+                if (ret < 0 && ret != -EUCLEAN) {
+                        ret = mtd->read(mtd, (nftl->EraseSize * BlockMap[block])
+                                        + (block * 512), 512, &retlen,
+                                        movebuf);
+                        if (ret != -EIO)
+                                printk("Error went away on retry.\n");
+                }
                 memset(&oob, 0xff, sizeof(struct nftl_oob));
                 oob.b.Status = oob.b.Status1 = SECTOR_USED;
-                MTD_WRITEECC(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) + (block * 512),
-                             512, &retlen, movebuf, (char *)&oob, &nftl->oobinfo);
+
+                nftl_write(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) +
+                           (block * 512), 512, &retlen, movebuf, (char *)&oob);
         }
 
-        /* add the header so that it is now a valid chain */
-        oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum
-                = cpu_to_le16(thisVUC);
-        oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum = 0xffff;
+        /* add the header so that it is now a valid chain */
+        oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
+        oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum = 0xffff;
 
-        MTD_WRITEOOB(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) + 8,
-                     8, &retlen, (char *)&oob.u);
+        nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 8,
+                       8, &retlen, (char *)&oob.u);
 
         /* OK. We've moved the whole lot into the new block. Now we have to free the original blocks. */
 
@@ -396,18 +458,18 @@ static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned p
         while (thisEUN <= nftl->lastEUN && thisEUN != targetEUN) {
                 unsigned int EUNtmp;
 
-                EUNtmp = nftl->ReplUnitTable[thisEUN];
+                EUNtmp = nftl->ReplUnitTable[thisEUN];
 
-                if (NFTL_formatblock(nftl, thisEUN) < 0) {
+                if (NFTL_formatblock(nftl, thisEUN) < 0) {
                         /* could not erase : mark block as reserved
                          */
                         nftl->ReplUnitTable[thisEUN] = BLOCK_RESERVED;
-                } else {
+                } else {
                         /* correctly erased : mark it as free */
                         nftl->ReplUnitTable[thisEUN] = BLOCK_FREE;
                         nftl->numfreeEUNs++;
-                }
-                thisEUN = EUNtmp;
+                }
+                thisEUN = EUNtmp;
         }
 
         /* Make this the new start of chain for thisVUC */
@@ -473,6 +535,7 @@ static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
 {
         u16 lastEUN;
         u16 thisVUC = block / (nftl->EraseSize / 512);
+        struct mtd_info *mtd = nftl->mbd.mtd;
         unsigned int writeEUN;
         unsigned long blockofs = (block * 512) & (nftl->EraseSize -1);
         size_t retlen;
@@ -489,21 +552,22 @@ static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
                 */
                 lastEUN = BLOCK_NIL;
                 writeEUN = nftl->EUNtable[thisVUC];
-                silly = MAX_LOOPS;
+                silly = MAX_LOOPS;
                 while (writeEUN <= nftl->lastEUN) {
                         struct nftl_bci bci;
                         size_t retlen;
-                        unsigned int status;
+                        unsigned int status;
 
                         lastEUN = writeEUN;
 
-                        MTD_READOOB(nftl->mbd.mtd, (writeEUN * nftl->EraseSize) + blockofs,
-                                    8, &retlen, (char *)&bci);
+                        nftl_read_oob(mtd,
+                                      (writeEUN * nftl->EraseSize) + blockofs,
+                                      8, &retlen, (char *)&bci);
 
                         DEBUG(MTD_DEBUG_LEVEL2, "Status of block %d in EUN %d is %x\n",
                               block , writeEUN, le16_to_cpu(bci.Status));
 
-                        status = bci.Status | bci.Status1;
+                        status = bci.Status | bci.Status1;
                         switch(status) {
                         case SECTOR_FREE:
                                 return writeEUN;
@@ -574,10 +638,10 @@ static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
                 /* We've found a free block. Insert it into the chain. */
 
                 if (lastEUN != BLOCK_NIL) {
-                    thisVUC |= 0x8000; /* It's a replacement block */
+                        thisVUC |= 0x8000; /* It's a replacement block */
                 } else {
-                    /* The first block in a new chain */
-                    nftl->EUNtable[thisVUC] = writeEUN;
+                        /* The first block in a new chain */
+                        nftl->EUNtable[thisVUC] = writeEUN;
                 }
 
                 /* set up the actual EUN we're writing into */
@@ -585,29 +649,29 @@ static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
                 nftl->ReplUnitTable[writeEUN] = BLOCK_NIL;
 
                 /* ... and on the flash itself */
-                MTD_READOOB(nftl->mbd.mtd, writeEUN * nftl->EraseSize + 8, 8,
-                            &retlen, (char *)&oob.u);
+                nftl_read_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
+                              &retlen, (char *)&oob.u);
 
                 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
 
-                MTD_WRITEOOB(nftl->mbd.mtd, writeEUN * nftl->EraseSize + 8, 8,
-                             &retlen, (char *)&oob.u);
+                nftl_write_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
+                               &retlen, (char *)&oob.u);
 
-                /* we link the new block to the chain only after the
+                /* we link the new block to the chain only after the
                    block is ready. It avoids the case where the chain
                    could point to a free block */
-                if (lastEUN != BLOCK_NIL) {
+                if (lastEUN != BLOCK_NIL) {
                         /* Both in our cache... */
                         nftl->ReplUnitTable[lastEUN] = writeEUN;
                         /* ... and on the flash itself */
-                        MTD_READOOB(nftl->mbd.mtd, (lastEUN * nftl->EraseSize) + 8,
-                                    8, &retlen, (char *)&oob.u);
+                        nftl_read_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
+                                      8, &retlen, (char *)&oob.u);
 
                         oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum
                                 = cpu_to_le16(writeEUN);
 
-                        MTD_WRITEOOB(nftl->mbd.mtd, (lastEUN * nftl->EraseSize) + 8,
-                                     8, &retlen, (char *)&oob.u);
+                        nftl_write_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
+                                       8, &retlen, (char *)&oob.u);
                 }
 
                 return writeEUN;
@@ -639,10 +703,9 @@ static int nftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block,
 
         memset(&oob, 0xff, sizeof(struct nftl_oob));
         oob.b.Status = oob.b.Status1 = SECTOR_USED;
-        MTD_WRITEECC(nftl->mbd.mtd, (writeEUN * nftl->EraseSize) + blockofs,
-                     512, &retlen, (char *)buffer, (char *)&oob, &nftl->oobinfo);
-        /* need to write SECTOR_USED flags since they are not written in mtd_writeecc */
 
+        nftl_write(nftl->mbd.mtd, (writeEUN * nftl->EraseSize) + blockofs,
+                   512, &retlen, (char *)buffer, (char *)&oob);
         return 0;
 }
 #endif /* CONFIG_NFTL_RW */
@@ -651,20 +714,22 @@ static int nftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
                           char *buffer)
 {
         struct NFTLrecord *nftl = (void *)mbd;
+        struct mtd_info *mtd = nftl->mbd.mtd;
         u16 lastgoodEUN;
         u16 thisEUN = nftl->EUNtable[block / (nftl->EraseSize / 512)];
         unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
-        unsigned int status;
+        unsigned int status;
         int silly = MAX_LOOPS;
-        size_t retlen;
-        struct nftl_bci bci;
+        size_t retlen;
+        struct nftl_bci bci;
 
         lastgoodEUN = BLOCK_NIL;
 
-        if (thisEUN != BLOCK_NIL) {
+        if (thisEUN != BLOCK_NIL) {
                 while (thisEUN < nftl->nb_blocks) {
-                        if (MTD_READOOB(nftl->mbd.mtd, (thisEUN * nftl->EraseSize) + blockofs,
-                                        8, &retlen, (char *)&bci) < 0)
+                        if (nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
+                                          blockofs, 8, &retlen,
+                                          (char *)&bci) < 0)
                                 status = SECTOR_IGNORE;
                         else
                                 status = bci.Status | bci.Status1;
@@ -694,7 +759,7 @@ static int nftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
                         }
                         thisEUN = nftl->ReplUnitTable[thisEUN];
                 }
-        }
+        }
 
  the_end:
         if (lastgoodEUN == BLOCK_NIL) {
@@ -703,7 +768,9 @@ static int nftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
         } else {
                 loff_t ptr = (lastgoodEUN * nftl->EraseSize) + blockofs;
                 size_t retlen;
-                if (MTD_READ(nftl->mbd.mtd, ptr, 512, &retlen, buffer))
+                int res = mtd->read(mtd, ptr, 512, &retlen, buffer);
+
+                if (res < 0 && res != -EUCLEAN)
                         return -EIO;
         }
         return 0;
diff --git a/drivers/mtd/nftlmount.c b/drivers/mtd/nftlmount.c
index 3b104ebb219a..067262ee8df0 100644
--- a/drivers/mtd/nftlmount.c
+++ b/drivers/mtd/nftlmount.c
@@ -33,6 +33,11 @@
 
 char nftlmountrev[]="$Revision: 1.41 $";
 
+extern int nftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len,
+                         size_t *retlen, uint8_t *buf);
+extern int nftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len,
+                          size_t *retlen, uint8_t *buf);
+
 /* find_boot_record: Find the NFTL Media Header and its Spare copy which contains the
  *      various device information of the NFTL partition and Bad Unit Table. Update
  *      the ReplUnitTable[] table accroding to the Bad Unit Table. ReplUnitTable[]
@@ -45,6 +50,7 @@ static int find_boot_record(struct NFTLrecord *nftl)
         size_t retlen;
         u8 buf[SECTORSIZE];
         struct NFTLMediaHeader *mh = &nftl->MediaHdr;
+        struct mtd_info *mtd = nftl->mbd.mtd;
         unsigned int i;
 
         /* Assume logical EraseSize == physical erasesize for starting the scan.
@@ -65,7 +71,8 @@ static int find_boot_record(struct NFTLrecord *nftl)
 
                 /* Check for ANAND header first. Then can whinge if it's found but later
                    checks fail */
-                ret = MTD_READ(nftl->mbd.mtd, block * nftl->EraseSize, SECTORSIZE, &retlen, buf);
+                ret = mtd->read(mtd, block * nftl->EraseSize, SECTORSIZE,
+                                &retlen, buf);
                 /* We ignore ret in case the ECC of the MediaHeader is invalid
                    (which is apparently acceptable) */
                 if (retlen != SECTORSIZE) {
@@ -90,8 +97,9 @@ static int find_boot_record(struct NFTLrecord *nftl)
                 }
 
                 /* To be safer with BIOS, also use erase mark as discriminant */
-                if ((ret = MTD_READOOB(nftl->mbd.mtd, block * nftl->EraseSize + SECTORSIZE + 8,
-                                8, &retlen, (char *)&h1) < 0)) {
+                if ((ret = nftl_read_oob(mtd, block * nftl->EraseSize +
+                                         SECTORSIZE + 8, 8, &retlen,
+                                         (char *)&h1) < 0)) {
                         printk(KERN_WARNING "ANAND header found at 0x%x in mtd%d, but OOB data read failed (err %d)\n",
                                block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
                         continue;
@@ -109,8 +117,8 @@ static int find_boot_record(struct NFTLrecord *nftl)
                 }
 
                 /* Finally reread to check ECC */
-                if ((ret = MTD_READECC(nftl->mbd.mtd, block * nftl->EraseSize, SECTORSIZE,
-                                &retlen, buf, (char *)&oob, NULL) < 0)) {
+                if ((ret = mtd->read(mtd, block * nftl->EraseSize, SECTORSIZE,
+                                     &retlen, buf) < 0)) {
                         printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but ECC read failed (err %d)\n",
                                block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
                         continue;
@@ -228,9 +236,9 @@ device is already correct.
 The new DiskOnChip driver already scanned the bad block table.  Just query it.
                         if ((i & (SECTORSIZE - 1)) == 0) {
                                 /* read one sector for every SECTORSIZE of blocks */
-                                if ((ret = MTD_READECC(nftl->mbd.mtd, block * nftl->EraseSize +
-                                                       i + SECTORSIZE, SECTORSIZE, &retlen, buf,
-                                                       (char *)&oob, NULL)) < 0) {
+                                if ((ret = mtd->read(nftl->mbd.mtd, block * nftl->EraseSize +
+                                                     i + SECTORSIZE, SECTORSIZE, &retlen,
+                                                     buf)) < 0) {
                                         printk(KERN_NOTICE "Read of bad sector table failed (err %d)\n",
                                                ret);
                                         kfree(nftl->ReplUnitTable);
@@ -268,18 +276,22 @@ static int memcmpb(void *a, int c, int n)
 static int check_free_sectors(struct NFTLrecord *nftl, unsigned int address, int len,
                               int check_oob)
 {
-        int i;
-        size_t retlen;
         u8 buf[SECTORSIZE + nftl->mbd.mtd->oobsize];
+        struct mtd_info *mtd = nftl->mbd.mtd;
+        size_t retlen;
+        int i;
 
         for (i = 0; i < len; i += SECTORSIZE) {
-                if (MTD_READECC(nftl->mbd.mtd, address, SECTORSIZE, &retlen, buf, &buf[SECTORSIZE], &nftl->oobinfo) < 0)
+                if (mtd->read(mtd, address, SECTORSIZE, &retlen, buf))
                         return -1;
                 if (memcmpb(buf, 0xff, SECTORSIZE) != 0)
                         return -1;
 
                 if (check_oob) {
-                        if (memcmpb(buf + SECTORSIZE, 0xff, nftl->mbd.mtd->oobsize) != 0)
+                        if(nftl_read_oob(mtd, address, mtd->oobsize,
+                                         &retlen, &buf[SECTORSIZE]) < 0)
+                                return -1;
+                        if (memcmpb(buf + SECTORSIZE, 0xff, mtd->oobsize) != 0)
                                 return -1;
                 }
                 address += SECTORSIZE;
@@ -301,10 +313,11 @@ int NFTL_formatblock(struct NFTLrecord *nftl, int block)
         unsigned int nb_erases, erase_mark;
         struct nftl_uci1 uci;
         struct erase_info *instr = &nftl->instr;
+        struct mtd_info *mtd = nftl->mbd.mtd;
 
         /* Read the Unit Control Information #1 for Wear-Leveling */
-        if (MTD_READOOB(nftl->mbd.mtd, block * nftl->EraseSize + SECTORSIZE + 8,
-                        8, &retlen, (char *)&uci) < 0)
+        if (nftl_read_oob(mtd, block * nftl->EraseSize + SECTORSIZE + 8,
+                          8, &retlen, (char *)&uci) < 0)
                 goto default_uci1;
 
         erase_mark = le16_to_cpu ((uci.EraseMark | uci.EraseMark1));
@@ -321,7 +334,7 @@ int NFTL_formatblock(struct NFTLrecord *nftl, int block)
         instr->mtd = nftl->mbd.mtd;
         instr->addr = block * nftl->EraseSize;
         instr->len = nftl->EraseSize;
-        MTD_ERASE(nftl->mbd.mtd, instr);
+        mtd->erase(mtd, instr);
 
         if (instr->state == MTD_ERASE_FAILED) {
                 printk("Error while formatting block %d\n", block);
@@ -343,8 +356,8 @@ int NFTL_formatblock(struct NFTLrecord *nftl, int block)
                         goto fail;
 
                 uci.WearInfo = le32_to_cpu(nb_erases);
-                if (MTD_WRITEOOB(nftl->mbd.mtd, block * nftl->EraseSize + SECTORSIZE + 8, 8,
-                                 &retlen, (char *)&uci) < 0)
+                if (nftl_write_oob(mtd, block * nftl->EraseSize + SECTORSIZE +
+                                   8, 8, &retlen, (char *)&uci) < 0)
                         goto fail;
                 return 0;
 fail:
@@ -365,6 +378,7 @@ fail:
  *      case. */
 static void check_sectors_in_chain(struct NFTLrecord *nftl, unsigned int first_block)
 {
+        struct mtd_info *mtd = nftl->mbd.mtd;
         unsigned int block, i, status;
         struct nftl_bci bci;
         int sectors_per_block;
@@ -374,8 +388,9 @@ static void check_sectors_in_chain(struct NFTLrecord *nftl, unsigned int first_b
         block = first_block;
         for (;;) {
                 for (i = 0; i < sectors_per_block; i++) {
-                        if (MTD_READOOB(nftl->mbd.mtd, block * nftl->EraseSize + i * SECTORSIZE,
-                                        8, &retlen, (char *)&bci) < 0)
+                        if (nftl_read_oob(mtd,
+                                          block * nftl->EraseSize + i * SECTORSIZE,
+                                          8, &retlen, (char *)&bci) < 0)
                                 status = SECTOR_IGNORE;
                         else
                                 status = bci.Status | bci.Status1;
@@ -394,9 +409,10 @@ static void check_sectors_in_chain(struct NFTLrecord *nftl, unsigned int first_b
                                         /* sector not free actually : mark it as SECTOR_IGNORE  */
                                         bci.Status = SECTOR_IGNORE;
                                         bci.Status1 = SECTOR_IGNORE;
-                                        MTD_WRITEOOB(nftl->mbd.mtd,
-                                                     block * nftl->EraseSize + i * SECTORSIZE,
-                                                     8, &retlen, (char *)&bci);
+                                        nftl_write_oob(mtd, block *
+                                                       nftl->EraseSize +
+                                                       i * SECTORSIZE, 8,
+                                                       &retlen, (char *)&bci);
                                 }
                                 break;
                         default:
@@ -481,13 +497,14 @@ static void format_chain(struct NFTLrecord *nftl, unsigned int first_block)
  *      1. */
 static int check_and_mark_free_block(struct NFTLrecord *nftl, int block)
 {
+        struct mtd_info *mtd = nftl->mbd.mtd;
         struct nftl_uci1 h1;
         unsigned int erase_mark;
         size_t retlen;
 
         /* check erase mark. */
-        if (MTD_READOOB(nftl->mbd.mtd, block * nftl->EraseSize + SECTORSIZE + 8, 8,
-                        &retlen, (char *)&h1) < 0)
+        if (nftl_read_oob(mtd, block * nftl->EraseSize + SECTORSIZE + 8, 8,
+                          &retlen, (char *)&h1) < 0)
                 return -1;
 
         erase_mark = le16_to_cpu ((h1.EraseMark | h1.EraseMark1));
@@ -501,8 +518,9 @@ static int check_and_mark_free_block(struct NFTLrecord *nftl, int block)
                 h1.EraseMark = cpu_to_le16(ERASE_MARK);
                 h1.EraseMark1 = cpu_to_le16(ERASE_MARK);
                 h1.WearInfo = cpu_to_le32(0);
-                if (MTD_WRITEOOB(nftl->mbd.mtd, block * nftl->EraseSize + SECTORSIZE + 8, 8,
-                                 &retlen, (char *)&h1) < 0)
+                if (nftl_write_oob(mtd,
+                                   block * nftl->EraseSize + SECTORSIZE + 8, 8,
+                                   &retlen, (char *)&h1) < 0)
                         return -1;
         } else {
 #if 0
@@ -513,8 +531,8 @@ static int check_and_mark_free_block(struct NFTLrecord *nftl, int block)
                                                 SECTORSIZE, 0) != 0)
                                 return -1;
 
-                        if (MTD_READOOB(nftl->mbd.mtd, block * nftl->EraseSize + i,
-                                        16, &retlen, buf) < 0)
+                        if (nftl_read_oob(mtd, block * nftl->EraseSize + i,
+                                          16, &retlen, buf) < 0)
                                 return -1;
                         if (i == SECTORSIZE) {
                                 /* skip erase mark */
@@ -540,11 +558,12 @@ static int check_and_mark_free_block(struct NFTLrecord *nftl, int block)
  */
 static int get_fold_mark(struct NFTLrecord *nftl, unsigned int block)
 {
+        struct mtd_info *mtd = nftl->mbd.mtd;
         struct nftl_uci2 uci;
         size_t retlen;
 
-        if (MTD_READOOB(nftl->mbd.mtd, block * nftl->EraseSize + 2 * SECTORSIZE + 8,
-                        8, &retlen, (char *)&uci) < 0)
+        if (nftl_read_oob(mtd, block * nftl->EraseSize + 2 * SECTORSIZE + 8,
+                          8, &retlen, (char *)&uci) < 0)
                 return 0;
 
         return le16_to_cpu((uci.FoldMark | uci.FoldMark1));
@@ -558,6 +577,7 @@ int NFTL_mount(struct NFTLrecord *s)
         int chain_length, do_format_chain;
         struct nftl_uci0 h0;
         struct nftl_uci1 h1;
+        struct mtd_info *mtd = s->mbd.mtd;
         size_t retlen;
 
         /* search for NFTL MediaHeader and Spare NFTL Media Header */
@@ -582,10 +602,13 @@ int NFTL_mount(struct NFTLrecord *s)
 
                         for (;;) {
                                 /* read the block header. If error, we format the chain */
-                                if (MTD_READOOB(s->mbd.mtd, block * s->EraseSize + 8, 8,
-                                                &retlen, (char *)&h0) < 0 ||
-                                    MTD_READOOB(s->mbd.mtd, block * s->EraseSize + SECTORSIZE + 8, 8,
-                                                &retlen, (char *)&h1) < 0) {
+                                if (nftl_read_oob(mtd,
+                                                  block * s->EraseSize + 8, 8,
+                                                  &retlen, (char *)&h0) < 0 ||
+                                    nftl_read_oob(mtd,
+                                                  block * s->EraseSize +
+                                                  SECTORSIZE + 8, 8,
+                                                  &retlen, (char *)&h1) < 0) {
                                         s->ReplUnitTable[block] = BLOCK_NIL;
                                         do_format_chain = 1;
                                         break;
diff --git a/drivers/mtd/onenand/Kconfig b/drivers/mtd/onenand/Kconfig
index 126ff6bf63d5..5930a03736d7 100644
--- a/drivers/mtd/onenand/Kconfig
+++ b/drivers/mtd/onenand/Kconfig
@@ -29,6 +29,20 @@ config MTD_ONENAND_GENERIC
         help
           Support for OneNAND flash via platform device driver.
 
+config MTD_ONENAND_OTP
+        bool "OneNAND OTP Support"
+        depends on MTD_ONENAND
+        help
+          One Block of the NAND Flash Array memory is reserved as
+          a One-Time Programmable Block memory area.
+          Also, 1st Block of NAND Flash Array can be used as OTP.
+
+          The OTP block can be read, programmed and locked using the same
+          operations as any other NAND Flash Array memory block.
+          OTP block cannot be erased.
+
+          OTP block is fully-guaranteed to be a valid block.
+
 config MTD_ONENAND_SYNC_READ
         bool "OneNAND Sync. Burst Read Support"
         depends on ARCH_OMAP
diff --git a/drivers/mtd/onenand/onenand_base.c b/drivers/mtd/onenand/onenand_base.c
index a53a73fc2a5a..84ec40d25438 100644
--- a/drivers/mtd/onenand/onenand_base.c
+++ b/drivers/mtd/onenand/onenand_base.c
@@ -23,8 +23,7 @@
 /**
  * onenand_oob_64 - oob info for large (2KB) page
  */
-static struct nand_oobinfo onenand_oob_64 = {
-        .useecc         = MTD_NANDECC_AUTOPLACE,
+static struct nand_ecclayout onenand_oob_64 = {
         .eccbytes       = 20,
         .eccpos         = {
                 8, 9, 10, 11, 12,
@@ -34,14 +33,14 @@ static struct nand_oobinfo onenand_oob_64 = {
                 },
         .oobfree        = {
                 {2, 3}, {14, 2}, {18, 3}, {30, 2},
-                {24, 3}, {46, 2}, {40, 3}, {62, 2} }
+                {34, 3}, {46, 2}, {50, 3}, {62, 2}
+        }
 };
 
 /**
  * onenand_oob_32 - oob info for middle (1KB) page
  */
-static struct nand_oobinfo onenand_oob_32 = {
-        .useecc         = MTD_NANDECC_AUTOPLACE,
+static struct nand_ecclayout onenand_oob_32 = {
         .eccbytes       = 10,
         .eccpos         = {
                 8, 9, 10, 11, 12,
@@ -190,7 +189,7 @@ static int onenand_buffer_address(int dataram1, int sectors, int count)
 static int onenand_command(struct mtd_info *mtd, int cmd, loff_t addr, size_t len)
 {
         struct onenand_chip *this = mtd->priv;
-        int value, readcmd = 0;
+        int value, readcmd = 0, block_cmd = 0;
         int block, page;
         /* Now we use page size operation */
         int sectors = 4, count = 4;
@@ -206,6 +205,8 @@ static int onenand_command(struct mtd_info *mtd, int cmd, loff_t addr, size_t le
 
         case ONENAND_CMD_ERASE:
         case ONENAND_CMD_BUFFERRAM:
+        case ONENAND_CMD_OTP_ACCESS:
+                block_cmd = 1;
                 block = (int) (addr >> this->erase_shift);
                 page = -1;
                 break;
@@ -233,6 +234,12 @@ static int onenand_command(struct mtd_info *mtd, int cmd, loff_t addr, size_t le
                 /* Write 'DFS, FBA' of Flash */
                 value = onenand_block_address(this, block);
                 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS1);
+
+                if (block_cmd) {
+                        /* Select DataRAM for DDP */
+                        value = onenand_bufferram_address(this, block);
+                        this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
+                }
         }
 
         if (page != -1) {
@@ -301,6 +308,7 @@ static int onenand_wait(struct mtd_info *mtd, int state)
 
                 if (state != FL_READING)
                         cond_resched();
+                touch_softlockup_watchdog();
         }
         /* To get correct interrupt status in timeout case */
         interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
@@ -344,7 +352,7 @@ static inline int onenand_bufferram_offset(struct mtd_info *mtd, int area)
 
         if (ONENAND_CURRENT_BUFFERRAM(this)) {
                 if (area == ONENAND_DATARAM)
-                        return mtd->oobblock;
+                        return mtd->writesize;
                 if (area == ONENAND_SPARERAM)
                         return mtd->oobsize;
         }
@@ -372,6 +380,17 @@ static int onenand_read_bufferram(struct mtd_info *mtd, int area,
 
         bufferram += onenand_bufferram_offset(mtd, area);
 
+        if (ONENAND_CHECK_BYTE_ACCESS(count)) {
+                unsigned short word;
+
+                /* Align with word(16-bit) size */
+                count--;
+
+                /* Read word and save byte */
+                word = this->read_word(bufferram + offset + count);
+                buffer[count] = (word & 0xff);
+        }
+
         memcpy(buffer, bufferram + offset, count);
 
         return 0;
@@ -399,6 +418,17 @@ static int onenand_sync_read_bufferram(struct mtd_info *mtd, int area,
 
         this->mmcontrol(mtd, ONENAND_SYS_CFG1_SYNC_READ);
 
+        if (ONENAND_CHECK_BYTE_ACCESS(count)) {
+                unsigned short word;
+
+                /* Align with word(16-bit) size */
+                count--;
+
+                /* Read word and save byte */
+                word = this->read_word(bufferram + offset + count);
+                buffer[count] = (word & 0xff);
+        }
+
         memcpy(buffer, bufferram + offset, count);
 
         this->mmcontrol(mtd, 0);
@@ -426,6 +456,22 @@ static int onenand_write_bufferram(struct mtd_info *mtd, int area,
 
         bufferram += onenand_bufferram_offset(mtd, area);
 
+        if (ONENAND_CHECK_BYTE_ACCESS(count)) {
+                unsigned short word;
+                int byte_offset;
+
+                /* Align with word(16-bit) size */
+                count--;
+
+                /* Calculate byte access offset */
+                byte_offset = offset + count;
+
+                /* Read word and save byte */
+                word = this->read_word(bufferram + byte_offset);
+                word = (word & ~0xff) | buffer[count];
+                this->write_word(word, bufferram + byte_offset);
+        }
+
         memcpy(bufferram + offset, buffer, count);
 
         return 0;
@@ -549,31 +595,28 @@ static void onenand_release_device(struct mtd_info *mtd)
 }
 
 /**
- * onenand_read_ecc - [MTD Interface] Read data with ECC
+ * onenand_read - [MTD Interface] Read data from flash
  * @param mtd           MTD device structure
  * @param from          offset to read from
  * @param len           number of bytes to read
  * @param retlen        pointer to variable to store the number of read bytes
  * @param buf           the databuffer to put data
- * @param oob_buf       filesystem supplied oob data buffer
- * @param oobsel        oob selection structure
  *
- * OneNAND read with ECC
- */
-static int onenand_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
-        size_t *retlen, u_char *buf,
-        u_char *oob_buf, struct nand_oobinfo *oobsel)
+ * Read with ecc
+*/
+static int onenand_read(struct mtd_info *mtd, loff_t from, size_t len,
+        size_t *retlen, u_char *buf)
 {
         struct onenand_chip *this = mtd->priv;
         int read = 0, column;
         int thislen;
         int ret = 0;
 
-        DEBUG(MTD_DEBUG_LEVEL3, "onenand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
+        DEBUG(MTD_DEBUG_LEVEL3, "onenand_read: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
 
         /* Do not allow reads past end of device */
         if ((from + len) > mtd->size) {
-                DEBUG(MTD_DEBUG_LEVEL0, "onenand_read_ecc: Attempt read beyond end of device\n");
+                DEBUG(MTD_DEBUG_LEVEL0, "onenand_read: Attempt read beyond end of device\n");
                 *retlen = 0;
                 return -EINVAL;
         }
@@ -584,14 +627,14 @@ static int onenand_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
         /* TODO handling oob */
 
         while (read < len) {
-                thislen = min_t(int, mtd->oobblock, len - read);
+                thislen = min_t(int, mtd->writesize, len - read);
 
-                column = from & (mtd->oobblock - 1);
-                if (column + thislen > mtd->oobblock)
-                        thislen = mtd->oobblock - column;
+                column = from & (mtd->writesize - 1);
+                if (column + thislen > mtd->writesize)
+                        thislen = mtd->writesize - column;
 
                 if (!onenand_check_bufferram(mtd, from)) {
-                        this->command(mtd, ONENAND_CMD_READ, from, mtd->oobblock);
+                        this->command(mtd, ONENAND_CMD_READ, from, mtd->writesize);
 
                         ret = this->wait(mtd, FL_READING);
                         /* First copy data and check return value for ECC handling */
@@ -606,7 +649,7 @@ static int onenand_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
                         break;
 
                 if (ret) {
-                        DEBUG(MTD_DEBUG_LEVEL0, "onenand_read_ecc: read failed = %d\n", ret);
+                        DEBUG(MTD_DEBUG_LEVEL0, "onenand_read: read failed = %d\n", ret);
                         goto out;
                 }
 
@@ -628,23 +671,7 @@ out:
 }
 
 /**
- * onenand_read - [MTD Interface] MTD compability function for onenand_read_ecc
- * @param mtd           MTD device structure
- * @param from          offset to read from
- * @param len           number of bytes to read
- * @param retlen        pointer to variable to store the number of read bytes
- * @param buf           the databuffer to put data
- *
- * This function simply calls onenand_read_ecc with oob buffer and oobsel = NULL
-*/
-static int onenand_read(struct mtd_info *mtd, loff_t from, size_t len,
-        size_t *retlen, u_char *buf)
-{
-        return onenand_read_ecc(mtd, from, len, retlen, buf, NULL, NULL);
-}
-
-/**
- * onenand_read_oob - [MTD Interface] OneNAND read out-of-band
+ * onenand_do_read_oob - [MTD Interface] OneNAND read out-of-band
  * @param mtd           MTD device structure
  * @param from          offset to read from
  * @param len           number of bytes to read
@@ -653,8 +680,8 @@ static int onenand_read(struct mtd_info *mtd, loff_t from, size_t len,
  *
  * OneNAND read out-of-band data from the spare area
  */
-static int onenand_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
-        size_t *retlen, u_char *buf)
+int onenand_do_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
+                        size_t *retlen, u_char *buf)
 {
         struct onenand_chip *this = mtd->priv;
         int read = 0, thislen, column;
@@ -704,7 +731,7 @@ static int onenand_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
                 /* Read more? */
                 if (read < len) {
                         /* Page size */
-                        from += mtd->oobblock;
+                        from += mtd->writesize;
                         column = 0;
                 }
         }
@@ -717,8 +744,53 @@ out:
         return ret;
 }
 
+/**
+ * onenand_read_oob - [MTD Interface] NAND write data and/or out-of-band
+ * @mtd:        MTD device structure
+ * @from:       offset to read from
+ * @ops:        oob operation description structure
+ */
+static int onenand_read_oob(struct mtd_info *mtd, loff_t from,
+                            struct mtd_oob_ops *ops)
+{
+        BUG_ON(ops->mode != MTD_OOB_PLACE);
+
+        return onenand_do_read_oob(mtd, from + ops->ooboffs, ops->len,
+                                   &ops->retlen, ops->oobbuf);
+}
+
 #ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE
 /**
+ * onenand_verify_oob - [GENERIC] verify the oob contents after a write
+ * @param mtd           MTD device structure
+ * @param buf           the databuffer to verify
+ * @param to            offset to read from
+ * @param len           number of bytes to read and compare
+ *
+ */
+static int onenand_verify_oob(struct mtd_info *mtd, const u_char *buf, loff_t to, int len)
+{
+        struct onenand_chip *this = mtd->priv;
+        char *readp = this->page_buf;
+        int column = to & (mtd->oobsize - 1);
+        int status, i;
+
+        this->command(mtd, ONENAND_CMD_READOOB, to, mtd->oobsize);
+        onenand_update_bufferram(mtd, to, 0);
+        status = this->wait(mtd, FL_READING);
+        if (status)
+                return status;
+
+        this->read_bufferram(mtd, ONENAND_SPARERAM, readp, column, len);
+
+        for(i = 0; i < len; i++)
+                if (buf[i] != 0xFF && buf[i] != readp[i])
+                        return -EBADMSG;
+
+        return 0;
+}
+
+/**
  * onenand_verify_page - [GENERIC] verify the chip contents after a write
  * @param mtd           MTD device structure
  * @param buf           the databuffer to verify
@@ -731,7 +803,7 @@ static int onenand_verify_page(struct mtd_info *mtd, u_char *buf, loff_t addr)
         void __iomem *dataram0, *dataram1;
         int ret = 0;
 
-        this->command(mtd, ONENAND_CMD_READ, addr, mtd->oobblock);
+        this->command(mtd, ONENAND_CMD_READ, addr, mtd->writesize);
 
         ret = this->wait(mtd, FL_READING);
         if (ret)
@@ -741,53 +813,51 @@ static int onenand_verify_page(struct mtd_info *mtd, u_char *buf, loff_t addr)
 
         /* Check, if the two dataram areas are same */
         dataram0 = this->base + ONENAND_DATARAM;
-        dataram1 = dataram0 + mtd->oobblock;
+        dataram1 = dataram0 + mtd->writesize;
 
-        if (memcmp(dataram0, dataram1, mtd->oobblock))
+        if (memcmp(dataram0, dataram1, mtd->writesize))
                 return -EBADMSG;
 
         return 0;
 }
 #else
 #define onenand_verify_page(...)        (0)
+#define onenand_verify_oob(...)         (0)
 #endif
 
-#define NOTALIGNED(x)   ((x & (mtd->oobblock - 1)) != 0)
+#define NOTALIGNED(x)   ((x & (mtd->writesize - 1)) != 0)
 
 /**
- * onenand_write_ecc - [MTD Interface] OneNAND write with ECC
+ * onenand_write - [MTD Interface] write buffer to FLASH
  * @param mtd           MTD device structure
  * @param to            offset to write to
  * @param len           number of bytes to write
  * @param retlen        pointer to variable to store the number of written bytes
  * @param buf           the data to write
- * @param eccbuf        filesystem supplied oob data buffer
- * @param oobsel        oob selection structure
  *
- * OneNAND write with ECC
+ * Write with ECC
  */
-static int onenand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
-        size_t *retlen, const u_char *buf,
-        u_char *eccbuf, struct nand_oobinfo *oobsel)
+static int onenand_write(struct mtd_info *mtd, loff_t to, size_t len,
+        size_t *retlen, const u_char *buf)
 {
         struct onenand_chip *this = mtd->priv;
         int written = 0;
         int ret = 0;
 
-        DEBUG(MTD_DEBUG_LEVEL3, "onenand_write_ecc: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
+        DEBUG(MTD_DEBUG_LEVEL3, "onenand_write: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
 
         /* Initialize retlen, in case of early exit */
         *retlen = 0;
 
         /* Do not allow writes past end of device */
         if (unlikely((to + len) > mtd->size)) {
-                DEBUG(MTD_DEBUG_LEVEL0, "onenand_write_ecc: Attempt write to past end of device\n");
+                DEBUG(MTD_DEBUG_LEVEL0, "onenand_write: Attempt write to past end of device\n");
                 return -EINVAL;
         }
 
         /* Reject writes, which are not page aligned */
         if (unlikely(NOTALIGNED(to)) || unlikely(NOTALIGNED(len))) {
-                DEBUG(MTD_DEBUG_LEVEL0, "onenand_write_ecc: Attempt to write not page aligned data\n");
+                DEBUG(MTD_DEBUG_LEVEL0, "onenand_write: Attempt to write not page aligned data\n");
                 return -EINVAL;
         }
 
@@ -796,20 +866,20 @@ static int onenand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
 
         /* Loop until all data write */
         while (written < len) {
-                int thislen = min_t(int, mtd->oobblock, len - written);
+                int thislen = min_t(int, mtd->writesize, len - written);
 
-                this->command(mtd, ONENAND_CMD_BUFFERRAM, to, mtd->oobblock);
+                this->command(mtd, ONENAND_CMD_BUFFERRAM, to, mtd->writesize);
 
                 this->write_bufferram(mtd, ONENAND_DATARAM, buf, 0, thislen);
                 this->write_bufferram(mtd, ONENAND_SPARERAM, ffchars, 0, mtd->oobsize);
 
-                this->command(mtd, ONENAND_CMD_PROG, to, mtd->oobblock);
+                this->command(mtd, ONENAND_CMD_PROG, to, mtd->writesize);
 
                 onenand_update_bufferram(mtd, to, 1);
 
                 ret = this->wait(mtd, FL_WRITING);
                 if (ret) {
-                        DEBUG(MTD_DEBUG_LEVEL0, "onenand_write_ecc: write filaed %d\n", ret);
+                        DEBUG(MTD_DEBUG_LEVEL0, "onenand_write: write filaed %d\n", ret);
                         goto out;
                 }
 
@@ -818,7 +888,7 @@ static int onenand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
                 /* Only check verify write turn on */
                 ret = onenand_verify_page(mtd, (u_char *) buf, to);
                 if (ret) {
-                        DEBUG(MTD_DEBUG_LEVEL0, "onenand_write_ecc: verify failed %d\n", ret);
+                        DEBUG(MTD_DEBUG_LEVEL0, "onenand_write: verify failed %d\n", ret);
                         goto out;
                 }
 
@@ -839,24 +909,7 @@ out:
 }
 
 /**
- * onenand_write - [MTD Interface] compability function for onenand_write_ecc
- * @param mtd           MTD device structure
- * @param to            offset to write to
- * @param len           number of bytes to write
- * @param retlen        pointer to variable to store the number of written bytes
- * @param buf           the data to write
- *
- * This function simply calls onenand_write_ecc
- * with oob buffer and oobsel = NULL
- */
-static int onenand_write(struct mtd_info *mtd, loff_t to, size_t len,
-        size_t *retlen, const u_char *buf)
-{
-        return onenand_write_ecc(mtd, to, len, retlen, buf, NULL, NULL);
-}
-
-/**
- * onenand_write_oob - [MTD Interface] OneNAND write out-of-band
+ * onenand_do_write_oob - [Internal] OneNAND write out-of-band
  * @param mtd           MTD device structure
  * @param to            offset to write to
  * @param len           number of bytes to write
@@ -865,11 +918,11 @@ static int onenand_write(struct mtd_info *mtd, loff_t to, size_t len,
  *
  * OneNAND write out-of-band
  */
-static int onenand_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
-        size_t *retlen, const u_char *buf)
+static int onenand_do_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
+                                size_t *retlen, const u_char *buf)
 {
         struct onenand_chip *this = mtd->priv;
-        int column, status;
+        int column, ret = 0;
         int written = 0;
 
         DEBUG(MTD_DEBUG_LEVEL3, "onenand_write_oob: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
@@ -894,16 +947,27 @@ static int onenand_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
 
                 this->command(mtd, ONENAND_CMD_BUFFERRAM, to, mtd->oobsize);
 
-                this->write_bufferram(mtd, ONENAND_SPARERAM, ffchars, 0, mtd->oobsize);
-                this->write_bufferram(mtd, ONENAND_SPARERAM, buf, column, thislen);
+                /* We send data to spare ram with oobsize
+                 * to prevent byte access */
+                memset(this->page_buf, 0xff, mtd->oobsize);
+                memcpy(this->page_buf + column, buf, thislen);
+                this->write_bufferram(mtd, ONENAND_SPARERAM, this->page_buf, 0, mtd->oobsize);
 
                 this->command(mtd, ONENAND_CMD_PROGOOB, to, mtd->oobsize);
 
                 onenand_update_bufferram(mtd, to, 0);
 
-                status = this->wait(mtd, FL_WRITING);
-                if (status)
+                ret = this->wait(mtd, FL_WRITING);
+                if (ret) {
+                        DEBUG(MTD_DEBUG_LEVEL0, "onenand_write_oob: write filaed %d\n", ret);
+                        goto out;
+                }
+
+                ret = onenand_verify_oob(mtd, buf, to, thislen);
+                if (ret) {
+                        DEBUG(MTD_DEBUG_LEVEL0, "onenand_write_oob: verify failed %d\n", ret);
                         goto out;
+                }
 
                 written += thislen;
 
@@ -920,145 +984,22 @@ out:
 
         *retlen = written;
 
-        return 0;
+        return ret;
 }
 
 /**
- * onenand_writev_ecc - [MTD Interface] write with iovec with ecc
- * @param mtd           MTD device structure
- * @param vecs          the iovectors to write
- * @param count         number of vectors
- * @param to            offset to write to
- * @param retlen        pointer to variable to store the number of written bytes
- * @param eccbuf        filesystem supplied oob data buffer
- * @param oobsel        oob selection structure
- *
- * OneNAND write with iovec with ecc
+ * onenand_write_oob - [MTD Interface] NAND write data and/or out-of-band
+ * @mtd:        MTD device structure
+ * @from:       offset to read from
+ * @ops:        oob operation description structure
  */
-static int onenand_writev_ecc(struct mtd_info *mtd, const struct kvec *vecs,
-        unsigned long count, loff_t to, size_t *retlen,
-        u_char *eccbuf, struct nand_oobinfo *oobsel)
+static int onenand_write_oob(struct mtd_info *mtd, loff_t to,
+                             struct mtd_oob_ops *ops)
 {
-        struct onenand_chip *this = mtd->priv;
-        unsigned char *pbuf;
-        size_t total_len, len;
-        int i, written = 0;
-        int ret = 0;
-
-        /* Preset written len for early exit */
-        *retlen = 0;
-
-        /* Calculate total length of data */
-        total_len = 0;
-        for (i = 0; i < count; i++)
-                total_len += vecs[i].iov_len;
-
-        DEBUG(MTD_DEBUG_LEVEL3, "onenand_writev_ecc: to = 0x%08x, len = %i, count = %ld\n", (unsigned int) to, (unsigned int) total_len, count);
-
-        /* Do not allow write past end of the device */
-        if (unlikely((to + total_len) > mtd->size)) {
-                DEBUG(MTD_DEBUG_LEVEL0, "onenand_writev_ecc: Attempted write past end of device\n");
-                return -EINVAL;
-        }
-
-        /* Reject writes, which are not page aligned */
-        if (unlikely(NOTALIGNED(to)) || unlikely(NOTALIGNED(total_len))) {
-                DEBUG(MTD_DEBUG_LEVEL0, "onenand_writev_ecc: Attempt to write not page aligned data\n");
-                return -EINVAL;
-        }
-
-        /* Grab the lock and see if the device is available */
-        onenand_get_device(mtd, FL_WRITING);
-
-        /* TODO handling oob */
-
-        /* Loop until all keve's data has been written */
-        len = 0;
-        while (count) {
-                pbuf = this->page_buf;
-                /*
-                 * If the given tuple is >= pagesize then
-                 * write it out from the iov
-                 */
-                if ((vecs->iov_len - len) >= mtd->oobblock) {
-                        pbuf = vecs->iov_base + len;
-
-                        len += mtd->oobblock;
-
-                        /* Check, if we have to switch to the next tuple */
-                        if (len >= (int) vecs->iov_len) {
-                                vecs++;
-                                len = 0;
-                                count--;
-                        }
-                } else {
-                        int cnt = 0, thislen;
-                        while (cnt < mtd->oobblock) {
-                                thislen = min_t(int, mtd->oobblock - cnt, vecs->iov_len - len);
-                                memcpy(this->page_buf + cnt, vecs->iov_base + len, thislen);
-                                cnt += thislen;
-                                len += thislen;
-
-                                /* Check, if we have to switch to the next tuple */
-                                if (len >= (int) vecs->iov_len) {
-                                        vecs++;
-                                        len = 0;
-                                        count--;
-                                }
-                        }
-                }
-
-                this->command(mtd, ONENAND_CMD_BUFFERRAM, to, mtd->oobblock);
+        BUG_ON(ops->mode != MTD_OOB_PLACE);
 
-                this->write_bufferram(mtd, ONENAND_DATARAM, pbuf, 0, mtd->oobblock);
-                this->write_bufferram(mtd, ONENAND_SPARERAM, ffchars, 0, mtd->oobsize);
-
-                this->command(mtd, ONENAND_CMD_PROG, to, mtd->oobblock);
-
-                onenand_update_bufferram(mtd, to, 1);
-
-                ret = this->wait(mtd, FL_WRITING);
-                if (ret) {
-                        DEBUG(MTD_DEBUG_LEVEL0, "onenand_writev_ecc: write failed %d\n", ret);
-                        goto out;
-                }
-
-
-                /* Only check verify write turn on */
-                ret = onenand_verify_page(mtd, (u_char *) pbuf, to);
-                if (ret) {
-                        DEBUG(MTD_DEBUG_LEVEL0, "onenand_writev_ecc: verify failed %d\n", ret);
-                        goto out;
-                }
-
-                written += mtd->oobblock;
-
-                to += mtd->oobblock;
-        }
-
-out:
-        /* Deselect and wakt up anyone waiting on the device */
-        onenand_release_device(mtd);
-
-        *retlen = written;
-
-        return 0;
-}
-
-/**
- * onenand_writev - [MTD Interface] compabilty function for onenand_writev_ecc
- * @param mtd           MTD device structure
- * @param vecs          the iovectors to write
- * @param count         number of vectors
- * @param to            offset to write to
- * @param retlen        pointer to variable to store the number of written bytes
- *
- * OneNAND write with kvec. This just calls the ecc function
- */
-static int onenand_writev(struct mtd_info *mtd, const struct kvec *vecs,
-        unsigned long count, loff_t to, size_t *retlen)
-{
-        return onenand_writev_ecc(mtd, vecs, count, to, retlen, NULL, NULL);
+        return onenand_do_write_oob(mtd, to + ops->ooboffs, ops->len,
+                                    &ops->retlen, ops->oobbuf);
 }
 
 /**
@@ -1227,7 +1168,7 @@ static int onenand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
 
         /* We write two bytes, so we dont have to mess with 16 bit access */
         ofs += mtd->oobsize + (bbm->badblockpos & ~0x01);
-        return mtd->write_oob(mtd, ofs , 2, &retlen, buf);
+        return onenand_do_write_oob(mtd, ofs , 2, &retlen, buf);
 }
 
 /**
@@ -1324,6 +1265,304 @@ static int onenand_unlock(struct mtd_info *mtd, loff_t ofs, size_t len)
         return 0;
 }
 
+#ifdef CONFIG_MTD_ONENAND_OTP
+
+/* Interal OTP operation */
+typedef int (*otp_op_t)(struct mtd_info *mtd, loff_t form, size_t len,
+                size_t *retlen, u_char *buf);
+
+/**
+ * do_otp_read - [DEFAULT] Read OTP block area
+ * @param mtd           MTD device structure
+ * @param from          The offset to read
+ * @param len           number of bytes to read
+ * @param retlen        pointer to variable to store the number of readbytes
+ * @param buf           the databuffer to put/get data
+ *
+ * Read OTP block area.
+ */
+static int do_otp_read(struct mtd_info *mtd, loff_t from, size_t len,
+                size_t *retlen, u_char *buf)
+{
+        struct onenand_chip *this = mtd->priv;
+        int ret;
+
+        /* Enter OTP access mode */
+        this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
+        this->wait(mtd, FL_OTPING);
+
+        ret = mtd->read(mtd, from, len, retlen, buf);
+
+        /* Exit OTP access mode */
+        this->command(mtd, ONENAND_CMD_RESET, 0, 0);
+        this->wait(mtd, FL_RESETING);
+
+        return ret;
+}
+
+/**
+ * do_otp_write - [DEFAULT] Write OTP block area
+ * @param mtd           MTD device structure
+ * @param from          The offset to write
+ * @param len           number of bytes to write
+ * @param retlen        pointer to variable to store the number of write bytes
+ * @param buf           the databuffer to put/get data
+ *
+ * Write OTP block area.
+ */
+static int do_otp_write(struct mtd_info *mtd, loff_t from, size_t len,
+                size_t *retlen, u_char *buf)
+{
+        struct onenand_chip *this = mtd->priv;
+        unsigned char *pbuf = buf;
+        int ret;
+
+        /* Force buffer page aligned */
+        if (len < mtd->writesize) {
+                memcpy(this->page_buf, buf, len);
+                memset(this->page_buf + len, 0xff, mtd->writesize - len);
+                pbuf = this->page_buf;
+                len = mtd->writesize;
+        }
+
+        /* Enter OTP access mode */
+        this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
+        this->wait(mtd, FL_OTPING);
+
+        ret = mtd->write(mtd, from, len, retlen, pbuf);
+
+        /* Exit OTP access mode */
+        this->command(mtd, ONENAND_CMD_RESET, 0, 0);
+        this->wait(mtd, FL_RESETING);
+
+        return ret;
+}
+
+/**
+ * do_otp_lock - [DEFAULT] Lock OTP block area
+ * @param mtd           MTD device structure
+ * @param from          The offset to lock
+ * @param len           number of bytes to lock
+ * @param retlen        pointer to variable to store the number of lock bytes
+ * @param buf           the databuffer to put/get data
+ *
+ * Lock OTP block area.
+ */
+static int do_otp_lock(struct mtd_info *mtd, loff_t from, size_t len,
+                size_t *retlen, u_char *buf)
+{
+        struct onenand_chip *this = mtd->priv;
+        int ret;
+
+        /* Enter OTP access mode */
+        this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
+        this->wait(mtd, FL_OTPING);
+
+        ret = onenand_do_write_oob(mtd, from, len, retlen, buf);
+
+        /* Exit OTP access mode */
+        this->command(mtd, ONENAND_CMD_RESET, 0, 0);
+        this->wait(mtd, FL_RESETING);
+
+        return ret;
+}
+
+/**
+ * onenand_otp_walk - [DEFAULT] Handle OTP operation
+ * @param mtd           MTD device structure
+ * @param from          The offset to read/write
+ * @param len           number of bytes to read/write
+ * @param retlen        pointer to variable to store the number of read bytes
+ * @param buf           the databuffer to put/get data
+ * @param action        do given action
+ * @param mode          specify user and factory
+ *
+ * Handle OTP operation.
+ */
+static int onenand_otp_walk(struct mtd_info *mtd, loff_t from, size_t len,
+                        size_t *retlen, u_char *buf,
+                        otp_op_t action, int mode)
+{
+        struct onenand_chip *this = mtd->priv;
+        int otp_pages;
+        int density;
+        int ret = 0;
+
+        *retlen = 0;
+
+        density = this->device_id >> ONENAND_DEVICE_DENSITY_SHIFT;
+        if (density < ONENAND_DEVICE_DENSITY_512Mb)
+                otp_pages = 20;
+        else
+                otp_pages = 10;
+
+        if (mode == MTD_OTP_FACTORY) {
+                from += mtd->writesize * otp_pages;
+                otp_pages = 64 - otp_pages;
+        }
+
+        /* Check User/Factory boundary */
+        if (((mtd->writesize * otp_pages) - (from + len)) < 0)
+                return 0;
+
+        while (len > 0 && otp_pages > 0) {
+                if (!action) {  /* OTP Info functions */
+                        struct otp_info *otpinfo;
+
+                        len -= sizeof(struct otp_info);
+                        if (len <= 0)
+                                return -ENOSPC;
+
+                        otpinfo = (struct otp_info *) buf;
+                        otpinfo->start = from;
+                        otpinfo->length = mtd->writesize;
+                        otpinfo->locked = 0;
+
+                        from += mtd->writesize;
+                        buf += sizeof(struct otp_info);
+                        *retlen += sizeof(struct otp_info);
+                } else {
+                        size_t tmp_retlen;
+                        int size = len;
+
+                        ret = action(mtd, from, len, &tmp_retlen, buf);
+
+                        buf += size;
+                        len -= size;
+                        *retlen += size;
+
+                        if (ret < 0)
+                                return ret;
+                }
+                otp_pages--;
+        }
+
+        return 0;
+}
+
+/**
+ * onenand_get_fact_prot_info - [MTD Interface] Read factory OTP info
+ * @param mtd           MTD device structure
+ * @param buf           the databuffer to put/get data
+ * @param len           number of bytes to read
+ *
+ * Read factory OTP info.
+ */
+static int onenand_get_fact_prot_info(struct mtd_info *mtd,
+                        struct otp_info *buf, size_t len)
+{
+        size_t retlen;
+        int ret;
+
+        ret = onenand_otp_walk(mtd, 0, len, &retlen, (u_char *) buf, NULL, MTD_OTP_FACTORY);
+
+        return ret ? : retlen;
+}
+
+/**
+ * onenand_read_fact_prot_reg - [MTD Interface] Read factory OTP area
+ * @param mtd           MTD device structure
+ * @param from          The offset to read
+ * @param len           number of bytes to read
+ * @param retlen        pointer to variable to store the number of read bytes
+ * @param buf           the databuffer to put/get data
+ *
+ * Read factory OTP area.
+ */
+static int onenand_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
+                        size_t len, size_t *retlen, u_char *buf)
+{
+        return onenand_otp_walk(mtd, from, len, retlen, buf, do_otp_read, MTD_OTP_FACTORY);
+}
+
+/**
+ * onenand_get_user_prot_info - [MTD Interface] Read user OTP info
+ * @param mtd           MTD device structure
+ * @param buf           the databuffer to put/get data
+ * @param len           number of bytes to read
+ *
+ * Read user OTP info.
+ */
+static int onenand_get_user_prot_info(struct mtd_info *mtd,
+                        struct otp_info *buf, size_t len)
+{
+        size_t retlen;
+        int ret;
+
+        ret = onenand_otp_walk(mtd, 0, len, &retlen, (u_char *) buf, NULL, MTD_OTP_USER);
+
+        return ret ? : retlen;
+}
+
+/**
+ * onenand_read_user_prot_reg - [MTD Interface] Read user OTP area
+ * @param mtd           MTD device structure
+ * @param from          The offset to read
+ * @param len           number of bytes to read
+ * @param retlen        pointer to variable to store the number of read bytes
+ * @param buf           the databuffer to put/get data
+ *
+ * Read user OTP area.
+ */
+static int onenand_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
+                        size_t len, size_t *retlen, u_char *buf)
+{
+        return onenand_otp_walk(mtd, from, len, retlen, buf, do_otp_read, MTD_OTP_USER);
+}
+
+/**
+ * onenand_write_user_prot_reg - [MTD Interface] Write user OTP area
+ * @param mtd           MTD device structure
+ * @param from          The offset to write
+ * @param len           number of bytes to write
+ * @param retlen        pointer to variable to store the number of write bytes
+ * @param buf           the databuffer to put/get data
+ *
+ * Write user OTP area.
+ */
+static int onenand_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
+                        size_t len, size_t *retlen, u_char *buf)
+{
+        return onenand_otp_walk(mtd, from, len, retlen, buf, do_otp_write, MTD_OTP_USER);
+}
+
+/**
+ * onenand_lock_user_prot_reg - [MTD Interface] Lock user OTP area
+ * @param mtd           MTD device structure
+ * @param from          The offset to lock
+ * @param len           number of bytes to unlock
+ *
+ * Write lock mark on spare area in page 0 in OTP block
+ */
+static int onenand_lock_user_prot_reg(struct mtd_info *mtd, loff_t from,
+                        size_t len)
+{
+        unsigned char oob_buf[64];
+        size_t retlen;
+        int ret;
+
+        memset(oob_buf, 0xff, mtd->oobsize);
+        /*
+         * Note: OTP lock operation
+         *       OTP block : 0xXXFC
+         *       1st block : 0xXXF3 (If chip support)
+         *       Both      : 0xXXF0 (If chip support)
+         */
+        oob_buf[ONENAND_OTP_LOCK_OFFSET] = 0xFC;
+
+        /*
+         * Write lock mark to 8th word of sector0 of page0 of the spare0.
+         * We write 16 bytes spare area instead of 2 bytes.
+         */
+        from = 0;
+        len = 16;
+
+        ret = onenand_otp_walk(mtd, from, len, &retlen, oob_buf, do_otp_lock, MTD_OTP_USER);
+
+        return ret ? : retlen;
+}
+#endif  /* CONFIG_MTD_ONENAND_OTP */
+
 /**
  * onenand_print_device_info - Print device ID
  * @param device        device ID
@@ -1423,15 +1662,15 @@ static int onenand_probe(struct mtd_info *mtd)
 
         /* OneNAND page size & block size */
         /* The data buffer size is equal to page size */
-        mtd->oobblock = this->read_word(this->base + ONENAND_REG_DATA_BUFFER_SIZE);
-        mtd->oobsize = mtd->oobblock >> 5;
+        mtd->writesize = this->read_word(this->base + ONENAND_REG_DATA_BUFFER_SIZE);
+        mtd->oobsize = mtd->writesize >> 5;
         /* Pagers per block is always 64 in OneNAND */
-        mtd->erasesize = mtd->oobblock << 6;
+        mtd->erasesize = mtd->writesize << 6;
 
         this->erase_shift = ffs(mtd->erasesize) - 1;
-        this->page_shift = ffs(mtd->oobblock) - 1;
+        this->page_shift = ffs(mtd->writesize) - 1;
         this->ppb_shift = (this->erase_shift - this->page_shift);
-        this->page_mask = (mtd->erasesize / mtd->oobblock) - 1;
+        this->page_mask = (mtd->erasesize / mtd->writesize) - 1;
 
         /* REVIST: Multichip handling */
 
@@ -1475,7 +1714,6 @@ static void onenand_resume(struct mtd_info *mtd)
                                 "in suspended state\n");
 }
 
-
 /**
  * onenand_scan - [OneNAND Interface] Scan for the OneNAND device
  * @param mtd           MTD device structure
@@ -1522,7 +1760,7 @@ int onenand_scan(struct mtd_info *mtd, int maxchips)
         /* Allocate buffers, if necessary */
         if (!this->page_buf) {
                 size_t len;
-                len = mtd->oobblock + mtd->oobsize;
+                len = mtd->writesize + mtd->oobsize;
                 this->page_buf = kmalloc(len, GFP_KERNEL);
                 if (!this->page_buf) {
                         printk(KERN_ERR "onenand_scan(): Can't allocate page_buf\n");
@@ -1537,40 +1775,42 @@ int onenand_scan(struct mtd_info *mtd, int maxchips)
 
         switch (mtd->oobsize) {
         case 64:
-                this->autooob = &onenand_oob_64;
+                this->ecclayout = &onenand_oob_64;
                 break;
 
         case 32:
-                this->autooob = &onenand_oob_32;
+                this->ecclayout = &onenand_oob_32;
                 break;
 
         default:
                 printk(KERN_WARNING "No OOB scheme defined for oobsize %d\n",
                         mtd->oobsize);
                 /* To prevent kernel oops */
-                this->autooob = &onenand_oob_32;
+                this->ecclayout = &onenand_oob_32;
                 break;
         }
 
-        memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo));
+        mtd->ecclayout = this->ecclayout;
 
         /* Fill in remaining MTD driver data */
         mtd->type = MTD_NANDFLASH;
-        mtd->flags = MTD_CAP_NANDFLASH | MTD_ECC;
+        mtd->flags = MTD_CAP_NANDFLASH;
         mtd->ecctype = MTD_ECC_SW;
         mtd->erase = onenand_erase;
         mtd->point = NULL;
         mtd->unpoint = NULL;
         mtd->read = onenand_read;
         mtd->write = onenand_write;
-        mtd->read_ecc = onenand_read_ecc;
-        mtd->write_ecc = onenand_write_ecc;
         mtd->read_oob = onenand_read_oob;
         mtd->write_oob = onenand_write_oob;
-        mtd->readv = NULL;
-        mtd->readv_ecc = NULL;
-        mtd->writev = onenand_writev;
-        mtd->writev_ecc = onenand_writev_ecc;
+#ifdef CONFIG_MTD_ONENAND_OTP
+        mtd->get_fact_prot_info = onenand_get_fact_prot_info;
+        mtd->read_fact_prot_reg = onenand_read_fact_prot_reg;
+        mtd->get_user_prot_info = onenand_get_user_prot_info;
+        mtd->read_user_prot_reg = onenand_read_user_prot_reg;
+        mtd->write_user_prot_reg = onenand_write_user_prot_reg;
+        mtd->lock_user_prot_reg = onenand_lock_user_prot_reg;
+#endif
         mtd->sync = onenand_sync;
         mtd->lock = NULL;
         mtd->unlock = onenand_unlock;
diff --git a/drivers/mtd/onenand/onenand_bbt.c b/drivers/mtd/onenand/onenand_bbt.c
index 4510d3361eaa..1b00dac3d7d6 100644
--- a/drivers/mtd/onenand/onenand_bbt.c
+++ b/drivers/mtd/onenand/onenand_bbt.c
@@ -17,6 +17,9 @@
 #include <linux/mtd/onenand.h>
 #include <linux/mtd/compatmac.h>
 
+extern int onenand_do_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
+                               size_t *retlen, u_char *buf);
+
 /**
  * check_short_pattern - [GENERIC] check if a pattern is in the buffer
  * @param buf           the buffer to search
@@ -87,13 +90,13 @@ static int create_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr
 
                         /* No need to read pages fully,
                          * just read required OOB bytes */
-                        ret = mtd->read_oob(mtd, from + j * mtd->oobblock + bd->offs,
-                                                readlen, &retlen, &buf[0]);
+                        ret = onenand_do_read_oob(mtd, from + j * mtd->writesize + bd->offs,
+                                                  readlen, &retlen, &buf[0]);
 
                         if (ret)
                                 return ret;
 
-                        if (check_short_pattern(&buf[j * scanlen], scanlen, mtd->oobblock, bd)) {
+                        if (check_short_pattern(&buf[j * scanlen], scanlen, mtd->writesize, bd)) {
                                 bbm->bbt[i >> 3] |= 0x03 << (i & 0x6);
                                 printk(KERN_WARNING "Bad eraseblock %d at 0x%08x\n",
                                         i >> 1, (unsigned int) from);
diff --git a/drivers/mtd/redboot.c b/drivers/mtd/redboot.c
index c077d2ec9cdd..5b58523e4d4e 100644
--- a/drivers/mtd/redboot.c
+++ b/drivers/mtd/redboot.c
@@ -1,5 +1,5 @@
 /*
- * $Id: redboot.c,v 1.19 2005/12/01 10:03:51 dwmw2 Exp $
+ * $Id: redboot.c,v 1.21 2006/03/30 18:34:37 bjd Exp $
  *
  * Parse RedBoot-style Flash Image System (FIS) tables and
  * produce a Linux partition array to match.
@@ -15,14 +15,14 @@
 
 struct fis_image_desc {
     unsigned char name[16];      // Null terminated name
-    unsigned long flash_base;    // Address within FLASH of image
-    unsigned long mem_base;      // Address in memory where it executes
-    unsigned long size;          // Length of image
-    unsigned long entry_point;   // Execution entry point
-    unsigned long data_length;   // Length of actual data
-    unsigned char _pad[256-(16+7*sizeof(unsigned long))];
-    unsigned long desc_cksum;    // Checksum over image descriptor
-    unsigned long file_cksum;    // Checksum over image data
+    uint32_t      flash_base;    // Address within FLASH of image
+    uint32_t      mem_base;      // Address in memory where it executes
+    uint32_t      size;          // Length of image
+    uint32_t      entry_point;   // Execution entry point
+    uint32_t      data_length;   // Length of actual data
+    unsigned char _pad[256-(16+7*sizeof(uint32_t))];
+    uint32_t      desc_cksum;    // Checksum over image descriptor
+    uint32_t      file_cksum;    // Checksum over image data
 };
 
 struct fis_list {
diff --git a/drivers/mtd/rfd_ftl.c b/drivers/mtd/rfd_ftl.c
index a3e00a4635a5..fa4362fb4dd8 100644
--- a/drivers/mtd/rfd_ftl.c
+++ b/drivers/mtd/rfd_ftl.c
@@ -3,7 +3,7 @@
  *
  * Copyright (C) 2005  Sean Young <sean@mess.org>
  *
- * $Id: rfd_ftl.c,v 1.5 2005/11/07 11:14:21 gleixner Exp $
+ * $Id: rfd_ftl.c,v 1.8 2006/01/15 12:51:44 sean Exp $
  *
  * This type of flash translation layer (FTL) is used by the Embedded BIOS
  * by General Software. It is known as the Resident Flash Disk (RFD), see:
@@ -61,6 +61,7 @@ struct block {
                 BLOCK_OK,
                 BLOCK_ERASING,
                 BLOCK_ERASED,
+                BLOCK_UNUSED,
                 BLOCK_FAILED
         } state;
         int free_sectors;
@@ -99,10 +100,8 @@ static int build_block_map(struct partition *part, int block_no)
         block->offset = part->block_size * block_no;
 
         if (le16_to_cpu(part->header_cache[0]) != RFD_MAGIC) {
-                block->state = BLOCK_ERASED; /* assumption */
-                block->free_sectors = part->data_sectors_per_block;
-                part->reserved_block = block_no;
-                return 1;
+                block->state = BLOCK_UNUSED;
+                return -ENOENT;
         }
 
         block->state = BLOCK_OK;
@@ -124,7 +123,7 @@ static int build_block_map(struct partition *part, int block_no)
                         entry = 0;
 
                 if (entry >= part->sector_count) {
-                        printk(KERN_NOTICE PREFIX
+                        printk(KERN_WARNING PREFIX
                                 "'%s': unit #%d: entry %d corrupt, "
                                 "sector %d out of range\n",
                                 part->mbd.mtd->name, block_no, i, entry);
@@ -132,7 +131,7 @@ static int build_block_map(struct partition *part, int block_no)
                 }
 
                 if (part->sector_map[entry] != -1) {
-                        printk(KERN_NOTICE PREFIX
+                        printk(KERN_WARNING PREFIX
                                 "'%s': more than one entry for sector %d\n",
                                 part->mbd.mtd->name, entry);
                         part->errors = 1;
@@ -167,7 +166,7 @@ static int scan_header(struct partition *part)
         /* each erase block has three bytes header, followed by the map */
         part->header_sectors_per_block =
                         ((HEADER_MAP_OFFSET + sectors_per_block) *
-                        sizeof(u16) + SECTOR_SIZE - 1) / SECTOR_SIZE;
+                        sizeof(u16) + SECTOR_SIZE - 1) / SECTOR_SIZE;
 
         part->data_sectors_per_block = sectors_per_block -
                         part->header_sectors_per_block;
@@ -226,7 +225,7 @@ static int scan_header(struct partition *part)
         }
 
         if (part->reserved_block == -1) {
-                printk(KERN_NOTICE PREFIX "'%s': no empty erase unit found\n",
+                printk(KERN_WARNING PREFIX "'%s': no empty erase unit found\n",
                                 part->mbd.mtd->name);
 
                 part->errors = 1;
@@ -315,7 +314,7 @@ static void erase_callback(struct erase_info *erase)
                 rc = -EIO;
 
         if (rc) {
-                printk(KERN_NOTICE PREFIX "'%s': unable to write RFD "
+                printk(KERN_ERR PREFIX "'%s': unable to write RFD "
                                 "header at 0x%lx\n",
                                 part->mbd.mtd->name,
                                 part->blocks[i].offset);
@@ -348,7 +347,7 @@ static int erase_block(struct partition *part, int block)
         rc = part->mbd.mtd->erase(part->mbd.mtd, erase);
 
         if (rc) {
-                printk(KERN_WARNING PREFIX "erase of region %x,%x on '%s' "
+                printk(KERN_ERR PREFIX "erase of region %x,%x on '%s' "
                                 "failed\n", erase->addr, erase->len,
                                 part->mbd.mtd->name);
                 kfree(erase);
@@ -383,7 +382,7 @@ static int move_block_contents(struct partition *part, int block_no, u_long *old
                 rc = -EIO;
 
         if (rc) {
-                printk(KERN_NOTICE PREFIX "error reading '%s' at "
+                printk(KERN_ERR PREFIX "error reading '%s' at "
                         "0x%lx\n", part->mbd.mtd->name,
                         part->blocks[block_no].offset);
 
@@ -423,7 +422,7 @@ static int move_block_contents(struct partition *part, int block_no, u_long *old
                         rc = -EIO;
 
                 if (rc) {
-                        printk(KERN_NOTICE PREFIX "'%s': Unable to "
+                        printk(KERN_ERR PREFIX "'%s': Unable to "
                                 "read sector for relocation\n",
                                 part->mbd.mtd->name);
 
@@ -520,7 +519,7 @@ static int reclaim_block(struct partition *part, u_long *old_sector)
  * because if we fill that one up first it'll have the most chance of having
  * the least live sectors at reclaim.
  */
-static int find_free_block(const struct partition *part)
+static int find_free_block(struct partition *part)
 {
         int block, stop;
 
@@ -533,6 +532,9 @@ static int find_free_block(const struct partition *part)
                                 block != part->reserved_block)
                         return block;
 
+                if (part->blocks[block].state == BLOCK_UNUSED)
+                        erase_block(part, block);
+
                 if (++block >= part->total_blocks)
                         block = 0;
 
@@ -541,7 +543,7 @@ static int find_free_block(const struct partition *part)
         return -1;
 }
 
-static int find_writeable_block(struct partition *part, u_long *old_sector)
+static int find_writable_block(struct partition *part, u_long *old_sector)
 {
         int rc, block;
         size_t retlen;
@@ -570,7 +572,7 @@ static int find_writeable_block(struct partition *part, u_long *old_sector)
                 rc = -EIO;
 
         if (rc) {
-                printk(KERN_NOTICE PREFIX "'%s': unable to read header at "
+                printk(KERN_ERR PREFIX "'%s': unable to read header at "
                                 "0x%lx\n", part->mbd.mtd->name,
                                 part->blocks[block].offset);
                 goto err;
@@ -602,7 +604,7 @@ static int mark_sector_deleted(struct partition *part, u_long old_addr)
                 rc = -EIO;
 
         if (rc) {
-                printk(KERN_WARNING PREFIX "error writing '%s' at "
+                printk(KERN_ERR PREFIX "error writing '%s' at "
                         "0x%lx\n", part->mbd.mtd->name, addr);
                 if (rc)
                         goto err;
@@ -652,7 +654,7 @@ static int do_writesect(struct mtd_blktrans_dev *dev, u_long sector, char *buf,
         if (part->current_block == -1 ||
                 !part->blocks[part->current_block].free_sectors) {
 
-                rc = find_writeable_block(part, old_addr);
+                rc = find_writable_block(part, old_addr);
                 if (rc)
                         goto err;
         }
@@ -675,7 +677,7 @@ static int do_writesect(struct mtd_blktrans_dev *dev, u_long sector, char *buf,
                 rc = -EIO;
 
         if (rc) {
-                printk(KERN_WARNING PREFIX "error writing '%s' at 0x%lx\n",
+                printk(KERN_ERR PREFIX "error writing '%s' at 0x%lx\n",
                                 part->mbd.mtd->name, addr);
                 if (rc)
                         goto err;
@@ -695,7 +697,7 @@ static int do_writesect(struct mtd_blktrans_dev *dev, u_long sector, char *buf,
                 rc = -EIO;
 
         if (rc) {
-                printk(KERN_WARNING PREFIX "error writing '%s' at 0x%lx\n",
+                printk(KERN_ERR PREFIX "error writing '%s' at 0x%lx\n",
                                 part->mbd.mtd->name, addr);
                 if (rc)
                         goto err;
@@ -776,7 +778,7 @@ static void rfd_ftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
                 part->block_size = block_size;
         else {
                 if (!mtd->erasesize) {
-                        printk(KERN_NOTICE PREFIX "please provide block_size");
+                        printk(KERN_WARNING PREFIX "please provide block_size");
                         return;
                 }
                 else
@@ -791,8 +793,8 @@ static void rfd_ftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
                 if (!(mtd->flags & MTD_WRITEABLE))
                         part->mbd.readonly = 1;
                 else if (part->errors) {
-                        printk(KERN_NOTICE PREFIX "'%s': errors found, "
-                                        "setting read-only", mtd->name);
+                        printk(KERN_WARNING PREFIX "'%s': errors found, "
+                                        "setting read-only\n", mtd->name);
                         part->mbd.readonly = 1;
                 }
 
diff --git a/drivers/net/smc91x.h b/drivers/net/smc91x.h
index f72a4f57905a..bf776125ca38 100644
--- a/drivers/net/smc91x.h
+++ b/drivers/net/smc91x.h
@@ -260,15 +260,17 @@ SMC_outw(u16 val, void __iomem *ioaddr, int reg)
 #define RPC_LSA_DEFAULT         RPC_LED_TX_RX
 #define RPC_LSB_DEFAULT         RPC_LED_100_10
 
-#elif   defined(CONFIG_MACH_LPD7A400) || defined(CONFIG_MACH_LPD7A404)
+#elif   defined(CONFIG_MACH_LPD79520) \
+     || defined(CONFIG_MACH_LPD7A400) \
+     || defined(CONFIG_MACH_LPD7A404)
 
-/* The LPD7A40X_IOBARRIER is necessary to overcome a mismatch between
- * the way that the CPU handles chip selects and the way that the SMC
- * chip expects the chip select to operate.  Refer to
+/* The LPD7X_IOBARRIER is necessary to overcome a mismatch between the
+ * way that the CPU handles chip selects and the way that the SMC chip
+ * expects the chip select to operate.  Refer to
  * Documentation/arm/Sharp-LH/IOBarrier for details.  The read from
- * IOBARRIER is a byte as a least-common denominator of possible
- * regions to use as the barrier.  It would be wasteful to read 32
- * bits from a byte oriented region.
+ * IOBARRIER is a byte, in order that we read the least-common
+ * denominator.  It would be wasteful to read 32 bits from an 8-bit
+ * accessible region.
  *
  * There is no explicit protection against interrupts intervening
  * between the writew and the IOBARRIER.  In SMC ISR there is a
@@ -287,25 +289,35 @@ SMC_outw(u16 val, void __iomem *ioaddr, int reg)
 #define SMC_CAN_USE_16BIT       1
 #define SMC_CAN_USE_32BIT       0
 #define SMC_NOWAIT              0
-#define LPD7A40X_IOBARRIER      readb (IOBARRIER_VIRT)
+#define LPD7X_IOBARRIER         readb (IOBARRIER_VIRT)
 
-#define SMC_inw(a,r)            readw ((void*) ((a) + (r)))
-#define SMC_insw(a,r,p,l)       readsw ((void*) ((a) + (r)), p, l)
-#define SMC_outw(v,a,r)      ({ writew ((v), (a) + (r)); LPD7A40X_IOBARRIER; })
+#define SMC_inw(a,r)\
+   ({ unsigned short v = readw ((void*) ((a) + (r))); LPD7X_IOBARRIER; v; })
+#define SMC_outw(v,a,r)   ({ writew ((v), (a) + (r)); LPD7X_IOBARRIER; })
 
-#define SMC_outsw               LPD7A40X_SMC_outsw
+#define SMC_insw                LPD7_SMC_insw
+static inline void LPD7_SMC_insw (unsigned char* a, int r,
+                                  unsigned char* p, int l)
+{
+        unsigned short* ps = (unsigned short*) p;
+        while (l-- > 0) {
+                *ps++ = readw (a + r);
+                LPD7X_IOBARRIER;
+        }
+}
 
-static inline void LPD7A40X_SMC_outsw(unsigned long a, int r,
-                                     unsigned char* p, int l)
+#define SMC_outsw               LPD7_SMC_outsw
+static inline void LPD7_SMC_outsw (unsigned char* a, int r,
+                                   unsigned char* p, int l)
 {
         unsigned short* ps = (unsigned short*) p;
         while (l-- > 0) {
                 writew (*ps++, a + r);
-                LPD7A40X_IOBARRIER;
+                LPD7X_IOBARRIER;
         }
 }
 
-#define SMC_INTERRUPT_PREAMBLE  LPD7A40X_IOBARRIER
+#define SMC_INTERRUPT_PREAMBLE  LPD7X_IOBARRIER
 
 #define RPC_LSA_DEFAULT         RPC_LED_TX_RX
 #define RPC_LSB_DEFAULT         RPC_LED_100_10
diff --git a/drivers/parport/Kconfig b/drivers/parport/Kconfig
index f63c387976cf..6c8452ede0e1 100644
--- a/drivers/parport/Kconfig
+++ b/drivers/parport/Kconfig
@@ -48,7 +48,7 @@ config PARPORT_PC
 
 config PARPORT_SERIAL
         tristate "Multi-IO cards (parallel and serial)"
-        depends on SERIAL_8250 && PARPORT_PC && PCI
+        depends on SERIAL_8250_PCI && PARPORT_PC && PCI
         help
           This adds support for multi-IO PCI cards that have parallel and
           serial ports.  You should say Y or M here.  If you say M, the module
diff --git a/drivers/s390/crypto/z90crypt.h b/drivers/s390/crypto/z90crypt.h
index 5e6b1f535f62..0ca1d126ccb6 100644
--- a/drivers/s390/crypto/z90crypt.h
+++ b/drivers/s390/crypto/z90crypt.h
@@ -1,7 +1,7 @@
 /*
  *  linux/drivers/s390/crypto/z90crypt.h
  *
- *  z90crypt 1.3.3
+ *  z90crypt 1.3.3 (kernel-private header)
  *
  *  Copyright (C)  2001, 2005 IBM Corporation
  *  Author(s): Robert Burroughs (burrough@us.ibm.com)
@@ -27,188 +27,7 @@
 #ifndef _Z90CRYPT_H_
 #define _Z90CRYPT_H_
 
-#include <linux/ioctl.h>
-
-#define z90crypt_VERSION 1
-#define z90crypt_RELEASE 3      // 2 = PCIXCC, 3 = rewrite for coding standards
-#define z90crypt_VARIANT 3      // 3 = CEX2A support
-
-/**
- * struct ica_rsa_modexpo
- *
- * Requirements:
- * - outputdatalength is at least as large as inputdatalength.
- * - All key parts are right justified in their fields, padded on
- *   the left with zeroes.
- * - length(b_key) = inputdatalength
- * - length(n_modulus) = inputdatalength
- */
-struct ica_rsa_modexpo {
-        char __user *   inputdata;
-        unsigned int    inputdatalength;
-        char __user *   outputdata;
-        unsigned int    outputdatalength;
-        char __user *   b_key;
-        char __user *   n_modulus;
-};
-
-/**
- * struct ica_rsa_modexpo_crt
- *
- * Requirements:
- * - inputdatalength is even.
- * - outputdatalength is at least as large as inputdatalength.
- * - All key parts are right justified in their fields, padded on
- *   the left with zeroes.
- * - length(bp_key)     = inputdatalength/2 + 8
- * - length(bq_key)     = inputdatalength/2
- * - length(np_key)     = inputdatalength/2 + 8
- * - length(nq_key)     = inputdatalength/2
- * - length(u_mult_inv) = inputdatalength/2 + 8
- */
-struct ica_rsa_modexpo_crt {
-        char __user *   inputdata;
-        unsigned int    inputdatalength;
-        char __user *   outputdata;
-        unsigned int    outputdatalength;
-        char __user *   bp_key;
-        char __user *   bq_key;
-        char __user *   np_prime;
-        char __user *   nq_prime;
-        char __user *   u_mult_inv;
-};
-
-#define Z90_IOCTL_MAGIC 'z'  // NOTE:  Need to allocate from linux folks
-
-/**
- * Interface notes:
- *
- * The ioctl()s which are implemented (along with relevant details)
- * are:
- *
- *   ICARSAMODEXPO
- *     Perform an RSA operation using a Modulus-Exponent pair
- *     This takes an ica_rsa_modexpo struct as its arg.
- *
- *     NOTE: please refer to the comments preceding this structure
- *           for the implementation details for the contents of the
- *           block
- *
- *   ICARSACRT
- *     Perform an RSA operation using a Chinese-Remainder Theorem key
- *     This takes an ica_rsa_modexpo_crt struct as its arg.
- *
- *     NOTE: please refer to the comments preceding this structure
- *           for the implementation details for the contents of the
- *           block
- *
- *   Z90STAT_TOTALCOUNT
- *     Return an integer count of all device types together.
- *
- *   Z90STAT_PCICACOUNT
- *     Return an integer count of all PCICAs.
- *
- *   Z90STAT_PCICCCOUNT
- *     Return an integer count of all PCICCs.
- *
- *   Z90STAT_PCIXCCMCL2COUNT
- *     Return an integer count of all MCL2 PCIXCCs.
- *
- *   Z90STAT_PCIXCCMCL3COUNT
- *     Return an integer count of all MCL3 PCIXCCs.
- *
- *   Z90STAT_CEX2CCOUNT
- *     Return an integer count of all CEX2Cs.
- *
- *   Z90STAT_CEX2ACOUNT
- *     Return an integer count of all CEX2As.
- *
- *   Z90STAT_REQUESTQ_COUNT
- *     Return an integer count of the number of entries waiting to be
- *     sent to a device.
- *
- *   Z90STAT_PENDINGQ_COUNT
- *     Return an integer count of the number of entries sent to a
- *     device awaiting the reply.
- *
- *   Z90STAT_TOTALOPEN_COUNT
- *     Return an integer count of the number of open file handles.
- *
- *   Z90STAT_DOMAIN_INDEX
- *     Return the integer value of the Cryptographic Domain.
- *
- *   Z90STAT_STATUS_MASK
- *     Return an 64 element array of unsigned chars for the status of
- *     all devices.
- *       0x01: PCICA
- *       0x02: PCICC
- *       0x03: PCIXCC_MCL2
- *       0x04: PCIXCC_MCL3
- *       0x05: CEX2C
- *       0x06: CEX2A
- *       0x0d: device is disabled via the proc filesystem
- *
- *   Z90STAT_QDEPTH_MASK
- *     Return an 64 element array of unsigned chars for the queue
- *     depth of all devices.
- *
- *   Z90STAT_PERDEV_REQCNT
- *     Return an 64 element array of unsigned integers for the number
- *     of successfully completed requests per device since the device
- *     was detected and made available.
- *
- *   ICAZ90STATUS (deprecated)
- *     Return some device driver status in a ica_z90_status struct
- *     This takes an ica_z90_status struct as its arg.
- *
- *     NOTE: this ioctl() is deprecated, and has been replaced with
- *           single ioctl()s for each type of status being requested
- *
- *   Z90STAT_PCIXCCCOUNT (deprecated)
- *     Return an integer count of all PCIXCCs (MCL2 + MCL3).
- *     This is DEPRECATED now that MCL3 PCIXCCs are treated differently from
- *     MCL2 PCIXCCs.
- *
- *   Z90QUIESCE (not recommended)
- *     Quiesce the driver.  This is intended to stop all new
- *     requests from being processed.  Its use is NOT recommended,
- *     except in circumstances where there is no other way to stop
- *     callers from accessing the driver.  Its original use was to
- *     allow the driver to be "drained" of work in preparation for
- *     a system shutdown.
- *
- *     NOTE: once issued, this ban on new work cannot be undone
- *           except by unloading and reloading the driver.
- */
-
-/**
- * Supported ioctl calls
- */
-#define ICARSAMODEXPO   _IOC(_IOC_READ|_IOC_WRITE, Z90_IOCTL_MAGIC, 0x05, 0)
-#define ICARSACRT       _IOC(_IOC_READ|_IOC_WRITE, Z90_IOCTL_MAGIC, 0x06, 0)
-
-/* DEPRECATED status calls (bound for removal at some point) */
-#define ICAZ90STATUS    _IOR(Z90_IOCTL_MAGIC, 0x10, struct ica_z90_status)
-#define Z90STAT_PCIXCCCOUNT     _IOR(Z90_IOCTL_MAGIC, 0x43, int)
-
-/* unrelated to ICA callers */
-#define Z90QUIESCE      _IO(Z90_IOCTL_MAGIC, 0x11)
-
-/* New status calls */
-#define Z90STAT_TOTALCOUNT      _IOR(Z90_IOCTL_MAGIC, 0x40, int)
-#define Z90STAT_PCICACOUNT      _IOR(Z90_IOCTL_MAGIC, 0x41, int)
-#define Z90STAT_PCICCCOUNT      _IOR(Z90_IOCTL_MAGIC, 0x42, int)
-#define Z90STAT_PCIXCCMCL2COUNT _IOR(Z90_IOCTL_MAGIC, 0x4b, int)
-#define Z90STAT_PCIXCCMCL3COUNT _IOR(Z90_IOCTL_MAGIC, 0x4c, int)
-#define Z90STAT_CEX2CCOUNT      _IOR(Z90_IOCTL_MAGIC, 0x4d, int)
-#define Z90STAT_CEX2ACOUNT      _IOR(Z90_IOCTL_MAGIC, 0x4e, int)
-#define Z90STAT_REQUESTQ_COUNT  _IOR(Z90_IOCTL_MAGIC, 0x44, int)
-#define Z90STAT_PENDINGQ_COUNT  _IOR(Z90_IOCTL_MAGIC, 0x45, int)
-#define Z90STAT_TOTALOPEN_COUNT _IOR(Z90_IOCTL_MAGIC, 0x46, int)
-#define Z90STAT_DOMAIN_INDEX    _IOR(Z90_IOCTL_MAGIC, 0x47, int)
-#define Z90STAT_STATUS_MASK     _IOR(Z90_IOCTL_MAGIC, 0x48, char[64])
-#define Z90STAT_QDEPTH_MASK     _IOR(Z90_IOCTL_MAGIC, 0x49, char[64])
-#define Z90STAT_PERDEV_REQCNT   _IOR(Z90_IOCTL_MAGIC, 0x4a, int[64])
+#include <asm/z90crypt.h>
 
 /**
  * local errno definitions
diff --git a/drivers/serial/s3c2410.c b/drivers/serial/s3c2410.c
index f5aac92fb798..53c2465bad2d 100644
--- a/drivers/serial/s3c2410.c
+++ b/drivers/serial/s3c2410.c
@@ -1365,7 +1365,7 @@ static inline void s3c2410_serial_exit(void)
 
 #endif /* CONFIG_CPU_S3C2410 */
 
-#ifdef CONFIG_CPU_S3C2440
+#if defined(CONFIG_CPU_S3C2440) || defined(CONFIG_CPU_S3C2442)
 
 static int s3c2440_serial_setsource(struct uart_port *port,
                                      struct s3c24xx_uart_clksrc *clk)
diff --git a/drivers/serial/serial_lh7a40x.c b/drivers/serial/serial_lh7a40x.c
index aa521b8e0d4e..776d4ff06084 100644
--- a/drivers/serial/serial_lh7a40x.c
+++ b/drivers/serial/serial_lh7a40x.c
@@ -145,14 +145,15 @@ lh7a40xuart_rx_chars (struct uart_port* port)
 {
         struct tty_struct* tty = port->info->tty;
         int cbRxMax = 256;      /* (Gross) limit on receive */
-        unsigned int data, flag;/* Received data and status */
+        unsigned int data;      /* Received data and status */
+        unsigned int flag;
 
         while (!(UR (port, UART_R_STATUS) & nRxRdy) && --cbRxMax) {
                 data = UR (port, UART_R_DATA);
                 flag = TTY_NORMAL;
                 ++port->icount.rx;
 
-                if (unlikely(data & RxError)) { /* Quick check, short-circuit */
+                if (unlikely(data & RxError)) {
                         if (data & RxBreak) {
                                 data &= ~(RxFramingError | RxParityError);
                                 ++port->icount.brk;
@@ -303,7 +304,7 @@ static void lh7a40xuart_set_mctrl (struct uart_port* port, unsigned int mctrl)
         /* Note, kernel appears to be setting DTR and RTS on console. */
 
         /* *** FIXME: this deserves more work.  There's some work in
-               tracing all of the IO pins. */
+               tracing all of the IO pins. */
 #if 0
         if( port->mapbase == UART1_PHYS) {
                 gpioRegs_t *gpio = (gpioRegs_t *)IO_ADDRESS(GPIO_PHYS);
@@ -662,9 +663,13 @@ static int __init lh7a40xuart_init(void)
         if (ret == 0) {
                 int i;
 
-                for (i = 0; i < DEV_NR; i++)
+                for (i = 0; i < DEV_NR; i++) {
+                        /* UART3, when used, requires GPIO pin reallocation */
+                        if (lh7a40x_ports[i].port.mapbase == UART3_PHYS)
+                                GPIO_PINMUX |= 1<<3;
                         uart_add_one_port (&lh7a40x_reg,
                                            &lh7a40x_ports[i].port);
+                }
         }
         return ret;
 }
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 5641498725d0..5a2840aeb547 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -167,6 +167,69 @@ config FB_ARMCLCD
           here and read <file:Documentation/modules.txt>.  The module
           will be called amba-clcd.
 
+choice
+
+        depends on FB_ARMCLCD && (ARCH_LH7A40X || ARCH_LH7952X)
+        prompt "LCD Panel"
+        default FB_ARMCLCD_SHARP_LQ035Q7DB02
+
+config FB_ARMCLCD_SHARP_LQ035Q7DB02_HRTFT
+        bool "LogicPD LCD 3.5\" QVGA w/HRTFT IC"
+        help
+          This is an implementation of the Sharp LQ035Q7DB02, a 3.5"
+          color QVGA, HRTFT panel.  The LogicPD device includes an
+          an integrated HRTFT controller IC.
+          The native resolution is 240x320.
+
+config FB_ARMCLCD_SHARP_LQ057Q3DC02
+        bool "LogicPD LCD 5.7\" QVGA"
+        help
+          This is an implementation of the Sharp LQ057Q3DC02, a 5.7"
+          color QVGA, TFT panel.  The LogicPD device includes an
+          The native resolution is 320x240.
+
+config FB_ARMCLCD_SHARP_LQ64D343
+        bool "LogicPD LCD 6.4\" VGA"
+        help
+          This is an implementation of the Sharp LQ64D343, a 6.4"
+          color VGA, TFT panel.  The LogicPD device includes an
+          The native resolution is 640x480.
+
+config FB_ARMCLCD_SHARP_LQ10D368
+        bool "LogicPD LCD 10.4\" VGA"
+        help
+          This is an implementation of the Sharp LQ10D368, a 10.4"
+          color VGA, TFT panel.  The LogicPD device includes an
+          The native resolution is 640x480.
+
+
+config FB_ARMCLCD_SHARP_LQ121S1DG41
+        bool "LogicPD LCD 12.1\" SVGA"
+        help
+          This is an implementation of the Sharp LQ121S1DG41, a 12.1"
+          color SVGA, TFT panel.  The LogicPD device includes an
+          The native resolution is 800x600.
+
+          This panel requires a clock rate may be an integer fraction
+          of the base LCDCLK frequency.  The driver will select the
+          highest frequency available that is lower than the maximum
+          allowed.  The panel may flicker if the clock rate is
+          slower than the recommended minimum.
+
+config FB_ARMCLCD_AUO_A070VW01_WIDE
+        bool "AU Optronics A070VW01 LCD 7.0\" WIDE"
+        help
+          This is an implementation of the AU Optronics, a 7.0"
+          WIDE Color.  The native resolution is 234x480.
+
+config FB_ARMCLCD_HITACHI
+        bool "Hitachi Wide Screen 800x480"
+        help
+          This is an implementation of the Hitachi 800x480.
+
+endchoice
+
+
 config FB_ACORN
         bool "Acorn VIDC support"
         depends on (FB = y) && ARM && (ARCH_ACORN || ARCH_CLPS7500)
diff --git a/fs/Kconfig b/fs/Kconfig
index f9b5842c8d2d..20f9b557732d 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -393,18 +393,30 @@ config INOTIFY
         bool "Inotify file change notification support"
         default y
         ---help---
-          Say Y here to enable inotify support and the associated system
-          calls.  Inotify is a file change notification system and a
-          replacement for dnotify.  Inotify fixes numerous shortcomings in
-          dnotify and introduces several new features.  It allows monitoring
-          of both files and directories via a single open fd.  Other features
-          include multiple file events, one-shot support, and unmount
+          Say Y here to enable inotify support.  Inotify is a file change
+          notification system and a replacement for dnotify.  Inotify fixes
+          numerous shortcomings in dnotify and introduces several new features
+          including multiple file events, one-shot support, and unmount
           notification.
 
           For more information, see Documentation/filesystems/inotify.txt
 
           If unsure, say Y.
 
+config INOTIFY_USER
+        bool "Inotify support for userspace"
+        depends on INOTIFY
+        default y
+        ---help---
+          Say Y here to enable inotify support for userspace, including the
+          associated system calls.  Inotify allows monitoring of both files and
+          directories via a single open fd.  Events are read from the file
+          descriptor, which is also select()- and poll()-able.
+
+          For more information, see Documentation/filesystems/inotify.txt
+
+          If unsure, say Y.
+
 config QUOTA
         bool "Quota support"
         help
@@ -1101,6 +1113,44 @@ config JFFS2_SUMMARY
 
           If unsure, say 'N'.
 
+config JFFS2_FS_XATTR
+        bool "JFFS2 XATTR support (EXPERIMENTAL)"
+        depends on JFFS2_FS && EXPERIMENTAL && !JFFS2_FS_WRITEBUFFER
+        default n
+        help
+          Extended attributes are name:value pairs associated with inodes by
+          the kernel or by users (see the attr(5) manual page, or visit
+          <http://acl.bestbits.at/> for details).
+          
+          If unsure, say N.
+
+config JFFS2_FS_POSIX_ACL
+        bool "JFFS2 POSIX Access Control Lists"
+        depends on JFFS2_FS_XATTR
+        default y
+        select FS_POSIX_ACL
+        help
+          Posix Access Control Lists (ACLs) support permissions for users and
+          groups beyond the owner/group/world scheme.
+          
+          To learn more about Access Control Lists, visit the Posix ACLs for
+          Linux website <http://acl.bestbits.at/>.
+          
+          If you don't know what Access Control Lists are, say N
+
+config JFFS2_FS_SECURITY
+        bool "JFFS2 Security Labels"
+        depends on JFFS2_FS_XATTR
+        default y
+        help
+          Security labels support alternative access control models
+          implemented by security modules like SELinux.  This option
+          enables an extended attribute handler for file security
+          labels in the jffs2 filesystem.
+          
+          If you are not using a security module that requires using
+          extended attributes for file security labels, say N.
+
 config JFFS2_COMPRESSION_OPTIONS
         bool "Advanced compression options for JFFS2"
         depends on JFFS2_FS
diff --git a/fs/Makefile b/fs/Makefile
index 078d3d1191a5..d0ea6bfccf29 100644
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -13,6 +13,7 @@ obj-y :=	open.o read_write.o file_table.o buffer.o  bio.o super.o \
                 ioprio.o pnode.o drop_caches.o splice.o sync.o
 
 obj-$(CONFIG_INOTIFY)           += inotify.o
+obj-$(CONFIG_INOTIFY_USER)      += inotify_user.o
 obj-$(CONFIG_EPOLL)             += eventpoll.o
 obj-$(CONFIG_COMPAT)            += compat.o compat_ioctl.o
 
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 1b4491cdd115..2695337d4d64 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -337,20 +337,20 @@ static inline int ep_cmp_ffd(struct epoll_filefd *p1,
 /* Special initialization for the rb-tree node to detect linkage */
 static inline void ep_rb_initnode(struct rb_node *n)
 {
-        n->rb_parent = n;
+        rb_set_parent(n, n);
 }
 
 /* Removes a node from the rb-tree and marks it for a fast is-linked check */
 static inline void ep_rb_erase(struct rb_node *n, struct rb_root *r)
 {
         rb_erase(n, r);
-        n->rb_parent = n;
+        rb_set_parent(n, n);
 }
 
 /* Fast check to verify that the item is linked to the main rb-tree */
 static inline int ep_rb_linked(struct rb_node *n)
 {
-        return n->rb_parent != n;
+        return rb_parent(n) != n;
 }
 
 /*
diff --git a/fs/exec.c b/fs/exec.c
index 3a79d97ac234..d07858c0b7c4 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -49,6 +49,7 @@
 #include <linux/rmap.h>
 #include <linux/acct.h>
 #include <linux/cn_proc.h>
+#include <linux/audit.h>
 
 #include <asm/uaccess.h>
 #include <asm/mmu_context.h>
@@ -1085,6 +1086,11 @@ int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
         /* kernel module loader fixup */
         /* so we don't try to load run modprobe in kernel space. */
         set_fs(USER_DS);
+
+        retval = audit_bprm(bprm);
+        if (retval)
+                return retval;
+
         retval = -ENOENT;
         for (try=0; try<2; try++) {
                 read_lock(&binfmt_lock);
diff --git a/fs/ext3/dir.c b/fs/ext3/dir.c
index f37528ed222e..fbb0d4ed07d4 100644
--- a/fs/ext3/dir.c
+++ b/fs/ext3/dir.c
@@ -284,7 +284,7 @@ static void free_rb_tree_fname(struct rb_root *root)
                  * beginning of the loop and try to free the parent
                  * node.
                  */
-                parent = n->rb_parent;
+                parent = rb_parent(n);
                 fname = rb_entry(n, struct fname, rb_hash);
                 while (fname) {
                         struct fname * old = fname;
diff --git a/fs/inotify.c b/fs/inotify.c
index 732ec4bd5774..723836a1f718 100644
--- a/fs/inotify.c
+++ b/fs/inotify.c
@@ -5,7 +5,10 @@
  *      John McCutchan  <ttb@tentacle.dhs.org>
  *      Robert Love     <rml@novell.com>
  *
+ * Kernel API added by: Amy Griffis <amy.griffis@hp.com>
+ *
  * Copyright (C) 2005 John McCutchan
+ * Copyright 2006 Hewlett-Packard Development Company, L.P.
  *
  * 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
@@ -20,35 +23,17 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/spinlock.h>
 #include <linux/idr.h>
 #include <linux/slab.h>
 #include <linux/fs.h>
-#include <linux/file.h>
-#include <linux/mount.h>
-#include <linux/namei.h>
-#include <linux/poll.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/writeback.h>
 #include <linux/inotify.h>
-#include <linux/syscalls.h>
-
-#include <asm/ioctls.h>
 
 static atomic_t inotify_cookie;
 
-static kmem_cache_t *watch_cachep __read_mostly;
-static kmem_cache_t *event_cachep __read_mostly;
-
-static struct vfsmount *inotify_mnt __read_mostly;
-
-/* these are configurable via /proc/sys/fs/inotify/ */
-int inotify_max_user_instances __read_mostly;
-int inotify_max_user_watches __read_mostly;
-int inotify_max_queued_events __read_mostly;
-
 /*
  * Lock ordering:
  *
@@ -56,327 +41,108 @@ int inotify_max_queued_events __read_mostly;
  * iprune_mutex (synchronize shrink_icache_memory())
  *      inode_lock (protects the super_block->s_inodes list)
  *      inode->inotify_mutex (protects inode->inotify_watches and watches->i_list)
- *              inotify_dev->mutex (protects inotify_device and watches->d_list)
+ *              inotify_handle->mutex (protects inotify_handle and watches->h_list)
+ *
+ * The inode->inotify_mutex and inotify_handle->mutex and held during execution
+ * of a caller's event handler.  Thus, the caller must not hold any locks
+ * taken in their event handler while calling any of the published inotify
+ * interfaces.
  */
 
 /*
- * Lifetimes of the three main data structures--inotify_device, inode, and
+ * Lifetimes of the three main data structures--inotify_handle, inode, and
  * inotify_watch--are managed by reference count.
  *
- * inotify_device: Lifetime is from inotify_init() until release.  Additional
- * references can bump the count via get_inotify_dev() and drop the count via
- * put_inotify_dev().
+ * inotify_handle: Lifetime is from inotify_init() to inotify_destroy().
+ * Additional references can bump the count via get_inotify_handle() and drop
+ * the count via put_inotify_handle().
  *
- * inotify_watch: Lifetime is from create_watch() to destory_watch().
- * Additional references can bump the count via get_inotify_watch() and drop
- * the count via put_inotify_watch().
+ * inotify_watch: for inotify's purposes, lifetime is from inotify_add_watch()
+ * to remove_watch_no_event().  Additional references can bump the count via
+ * get_inotify_watch() and drop the count via put_inotify_watch().  The caller
+ * is reponsible for the final put after receiving IN_IGNORED, or when using
+ * IN_ONESHOT after receiving the first event.  Inotify does the final put if
+ * inotify_destroy() is called.
  *
  * inode: Pinned so long as the inode is associated with a watch, from
- * create_watch() to put_inotify_watch().
+ * inotify_add_watch() to the final put_inotify_watch().
  */
 
 /*
- * struct inotify_device - represents an inotify instance
+ * struct inotify_handle - represents an inotify instance
  *
  * This structure is protected by the mutex 'mutex'.
  */
-struct inotify_device {
-        wait_queue_head_t       wq;             /* wait queue for i/o */
+struct inotify_handle {
         struct idr              idr;            /* idr mapping wd -> watch */
         struct mutex            mutex;          /* protects this bad boy */
-        struct list_head        events;         /* list of queued events */
         struct list_head        watches;        /* list of watches */
         atomic_t                count;          /* reference count */
-        struct user_struct      *user;          /* user who opened this dev */
-        unsigned int            queue_size;     /* size of the queue (bytes) */
-        unsigned int            event_count;    /* number of pending events */
-        unsigned int            max_events;     /* maximum number of events */
         u32                     last_wd;        /* the last wd allocated */
+        const struct inotify_operations *in_ops; /* inotify caller operations */
 };
 
-/*
- * struct inotify_kernel_event - An inotify event, originating from a watch and
- * queued for user-space.  A list of these is attached to each instance of the
- * device.  In read(), this list is walked and all events that can fit in the
- * buffer are returned.
- *
- * Protected by dev->mutex of the device in which we are queued.
- */
-struct inotify_kernel_event {
-        struct inotify_event    event;  /* the user-space event */
-        struct list_head        list;   /* entry in inotify_device's list */
-        char                    *name;  /* filename, if any */
-};
-
-/*
- * struct inotify_watch - represents a watch request on a specific inode
- *
- * d_list is protected by dev->mutex of the associated watch->dev.
- * i_list and mask are protected by inode->inotify_mutex of the associated inode.
- * dev, inode, and wd are never written to once the watch is created.
- */
-struct inotify_watch {
-        struct list_head        d_list; /* entry in inotify_device's list */
-        struct list_head        i_list; /* entry in inode's list */
-        atomic_t                count;  /* reference count */
-        struct inotify_device   *dev;   /* associated device */
-        struct inode            *inode; /* associated inode */
-        s32                     wd;     /* watch descriptor */
-        u32                     mask;   /* event mask for this watch */
-};
-
-#ifdef CONFIG_SYSCTL
-
-#include <linux/sysctl.h>
-
-static int zero;
-
-ctl_table inotify_table[] = {
-        {
-                .ctl_name       = INOTIFY_MAX_USER_INSTANCES,
-                .procname       = "max_user_instances",
-                .data           = &inotify_max_user_instances,
-                .maxlen         = sizeof(int),
-                .mode           = 0644,
-                .proc_handler   = &proc_dointvec_minmax,
-                .strategy       = &sysctl_intvec,
-                .extra1         = &zero,
-        },
-        {
-                .ctl_name       = INOTIFY_MAX_USER_WATCHES,
-                .procname       = "max_user_watches",
-                .data           = &inotify_max_user_watches,
-                .maxlen         = sizeof(int),
-                .mode           = 0644,
-                .proc_handler   = &proc_dointvec_minmax,
-                .strategy       = &sysctl_intvec,
-                .extra1         = &zero, 
-        },
-        {
-                .ctl_name       = INOTIFY_MAX_QUEUED_EVENTS,
-                .procname       = "max_queued_events",
-                .data           = &inotify_max_queued_events,
-                .maxlen         = sizeof(int),
-                .mode           = 0644, 
-                .proc_handler   = &proc_dointvec_minmax,
-                .strategy       = &sysctl_intvec, 
-                .extra1         = &zero
-        },
-        { .ctl_name = 0 }
-};
-#endif /* CONFIG_SYSCTL */
-
-static inline void get_inotify_dev(struct inotify_device *dev)
+static inline void get_inotify_handle(struct inotify_handle *ih)
 {
-        atomic_inc(&dev->count);
+        atomic_inc(&ih->count);
 }
 
-static inline void put_inotify_dev(struct inotify_device *dev)
+static inline void put_inotify_handle(struct inotify_handle *ih)
 {
-        if (atomic_dec_and_test(&dev->count)) {
-                atomic_dec(&dev->user->inotify_devs);
-                free_uid(dev->user);
-                idr_destroy(&dev->idr);
-                kfree(dev);
+        if (atomic_dec_and_test(&ih->count)) {
+                idr_destroy(&ih->idr);
+                kfree(ih);
         }
 }
 
-static inline void get_inotify_watch(struct inotify_watch *watch)
+/**
+ * get_inotify_watch - grab a reference to an inotify_watch
+ * @watch: watch to grab
+ */
+void get_inotify_watch(struct inotify_watch *watch)
 {
         atomic_inc(&watch->count);
 }
+EXPORT_SYMBOL_GPL(get_inotify_watch);
 
-/*
+/**
  * put_inotify_watch - decrements the ref count on a given watch.  cleans up
- * the watch and its references if the count reaches zero.
+ * watch references if the count reaches zero.  inotify_watch is freed by
+ * inotify callers via the destroy_watch() op.
+ * @watch: watch to release
  */
-static inline void put_inotify_watch(struct inotify_watch *watch)
+void put_inotify_watch(struct inotify_watch *watch)
 {
         if (atomic_dec_and_test(&watch->count)) {
-                put_inotify_dev(watch->dev);
-                iput(watch->inode);
-                kmem_cache_free(watch_cachep, watch);
-        }
-}
-
-/*
- * kernel_event - create a new kernel event with the given parameters
- *
- * This function can sleep.
- */
-static struct inotify_kernel_event * kernel_event(s32 wd, u32 mask, u32 cookie,
-                                                  const char *name)
-{
-        struct inotify_kernel_event *kevent;
-
-        kevent = kmem_cache_alloc(event_cachep, GFP_KERNEL);
-        if (unlikely(!kevent))
-                return NULL;
-
-        /* we hand this out to user-space, so zero it just in case */
-        memset(&kevent->event, 0, sizeof(struct inotify_event));
-
-        kevent->event.wd = wd;
-        kevent->event.mask = mask;
-        kevent->event.cookie = cookie;
-
-        INIT_LIST_HEAD(&kevent->list);
-
-        if (name) {
-                size_t len, rem, event_size = sizeof(struct inotify_event);
-
-                /*
-                 * We need to pad the filename so as to properly align an
-                 * array of inotify_event structures.  Because the structure is
-                 * small and the common case is a small filename, we just round
-                 * up to the next multiple of the structure's sizeof.  This is
-                 * simple and safe for all architectures.
-                 */
-                len = strlen(name) + 1;
-                rem = event_size - len;
-                if (len > event_size) {
-                        rem = event_size - (len % event_size);
-                        if (len % event_size == 0)
-                                rem = 0;
-                }
-
-                kevent->name = kmalloc(len + rem, GFP_KERNEL);
-                if (unlikely(!kevent->name)) {
-                        kmem_cache_free(event_cachep, kevent);
-                        return NULL;
-                }
-                memcpy(kevent->name, name, len);
-                if (rem)
-                        memset(kevent->name + len, 0, rem);             
-                kevent->event.len = len + rem;
-        } else {
-                kevent->event.len = 0;
-                kevent->name = NULL;
-        }
-
-        return kevent;
-}
-
-/*
- * inotify_dev_get_event - return the next event in the given dev's queue
- *
- * Caller must hold dev->mutex.
- */
-static inline struct inotify_kernel_event *
-inotify_dev_get_event(struct inotify_device *dev)
-{
-        return list_entry(dev->events.next, struct inotify_kernel_event, list);
-}
-
-/*
- * inotify_dev_queue_event - add a new event to the given device
- *
- * Caller must hold dev->mutex.  Can sleep (calls kernel_event()).
- */
-static void inotify_dev_queue_event(struct inotify_device *dev,
-                                    struct inotify_watch *watch, u32 mask,
-                                    u32 cookie, const char *name)
-{
-        struct inotify_kernel_event *kevent, *last;
-
-        /* coalescing: drop this event if it is a dupe of the previous */
-        last = inotify_dev_get_event(dev);
-        if (last && last->event.mask == mask && last->event.wd == watch->wd &&
-                        last->event.cookie == cookie) {
-                const char *lastname = last->name;
-
-                if (!name && !lastname)
-                        return;
-                if (name && lastname && !strcmp(lastname, name))
-                        return;
-        }
-
-        /* the queue overflowed and we already sent the Q_OVERFLOW event */
-        if (unlikely(dev->event_count > dev->max_events))
-                return;
-
-        /* if the queue overflows, we need to notify user space */
-        if (unlikely(dev->event_count == dev->max_events))
-                kevent = kernel_event(-1, IN_Q_OVERFLOW, cookie, NULL);
-        else
-                kevent = kernel_event(watch->wd, mask, cookie, name);
-
-        if (unlikely(!kevent))
-                return;
-
-        /* queue the event and wake up anyone waiting */
-        dev->event_count++;
-        dev->queue_size += sizeof(struct inotify_event) + kevent->event.len;
-        list_add_tail(&kevent->list, &dev->events);
-        wake_up_interruptible(&dev->wq);
-}
-
-/*
- * remove_kevent - cleans up and ultimately frees the given kevent
- *
- * Caller must hold dev->mutex.
- */
-static void remove_kevent(struct inotify_device *dev,
-                          struct inotify_kernel_event *kevent)
-{
-        list_del(&kevent->list);
-
-        dev->event_count--;
-        dev->queue_size -= sizeof(struct inotify_event) + kevent->event.len;
-
-        kfree(kevent->name);
-        kmem_cache_free(event_cachep, kevent);
-}
+                struct inotify_handle *ih = watch->ih;
 
-/*
- * inotify_dev_event_dequeue - destroy an event on the given device
- *
- * Caller must hold dev->mutex.
- */
-static void inotify_dev_event_dequeue(struct inotify_device *dev)
-{
-        if (!list_empty(&dev->events)) {
-                struct inotify_kernel_event *kevent;
-                kevent = inotify_dev_get_event(dev);
-                remove_kevent(dev, kevent);
+                iput(watch->inode);
+                ih->in_ops->destroy_watch(watch);
+                put_inotify_handle(ih);
         }
 }
+EXPORT_SYMBOL_GPL(put_inotify_watch);
 
 /*
- * inotify_dev_get_wd - returns the next WD for use by the given dev
+ * inotify_handle_get_wd - returns the next WD for use by the given handle
  *
- * Callers must hold dev->mutex.  This function can sleep.
+ * Callers must hold ih->mutex.  This function can sleep.
  */
-static int inotify_dev_get_wd(struct inotify_device *dev,
-                              struct inotify_watch *watch)
+static int inotify_handle_get_wd(struct inotify_handle *ih,
+                                 struct inotify_watch *watch)
 {
         int ret;
 
         do {
-                if (unlikely(!idr_pre_get(&dev->idr, GFP_KERNEL)))
+                if (unlikely(!idr_pre_get(&ih->idr, GFP_KERNEL)))
                         return -ENOSPC;
-                ret = idr_get_new_above(&dev->idr, watch, dev->last_wd+1, &watch->wd);
+                ret = idr_get_new_above(&ih->idr, watch, ih->last_wd+1, &watch->wd);
         } while (ret == -EAGAIN);
 
-        return ret;
-}
+        if (likely(!ret))
+                ih->last_wd = watch->wd;
 
-/*
- * find_inode - resolve a user-given path to a specific inode and return a nd
- */
-static int find_inode(const char __user *dirname, struct nameidata *nd,
-                      unsigned flags)
-{
-        int error;
-
-        error = __user_walk(dirname, flags, nd);
-        if (error)
-                return error;
-        /* you can only watch an inode if you have read permissions on it */
-        error = vfs_permission(nd, MAY_READ);
-        if (error) 
-                path_release(nd);
-        return error;
+        return ret;
 }
 
 /*
@@ -422,67 +188,18 @@ static void set_dentry_child_flags(struct inode *inode, int watched)
 }
 
 /*
- * create_watch - creates a watch on the given device.
- *
- * Callers must hold dev->mutex.  Calls inotify_dev_get_wd() so may sleep.
- * Both 'dev' and 'inode' (by way of nameidata) need to be pinned.
- */
-static struct inotify_watch *create_watch(struct inotify_device *dev,
-                                          u32 mask, struct inode *inode)
-{
-        struct inotify_watch *watch;
-        int ret;
-
-        if (atomic_read(&dev->user->inotify_watches) >=
-                        inotify_max_user_watches)
-                return ERR_PTR(-ENOSPC);
-
-        watch = kmem_cache_alloc(watch_cachep, GFP_KERNEL);
-        if (unlikely(!watch))
-                return ERR_PTR(-ENOMEM);
-
-        ret = inotify_dev_get_wd(dev, watch);
-        if (unlikely(ret)) {
-                kmem_cache_free(watch_cachep, watch);
-                return ERR_PTR(ret);
-        }
-
-        dev->last_wd = watch->wd;
-        watch->mask = mask;
-        atomic_set(&watch->count, 0);
-        INIT_LIST_HEAD(&watch->d_list);
-        INIT_LIST_HEAD(&watch->i_list);
-
-        /* save a reference to device and bump the count to make it official */
-        get_inotify_dev(dev);
-        watch->dev = dev;
-
-        /*
-         * Save a reference to the inode and bump the ref count to make it
-         * official.  We hold a reference to nameidata, which makes this safe.
-         */
-        watch->inode = igrab(inode);
-
-        /* bump our own count, corresponding to our entry in dev->watches */
-        get_inotify_watch(watch);
-
-        atomic_inc(&dev->user->inotify_watches);
-
-        return watch;
-}
-
-/*
- * inotify_find_dev - find the watch associated with the given inode and dev
+ * inotify_find_handle - find the watch associated with the given inode and
+ * handle
  *
  * Callers must hold inode->inotify_mutex.
  */
-static struct inotify_watch *inode_find_dev(struct inode *inode,
-                                            struct inotify_device *dev)
+static struct inotify_watch *inode_find_handle(struct inode *inode,
+                                               struct inotify_handle *ih)
 {
         struct inotify_watch *watch;
 
         list_for_each_entry(watch, &inode->inotify_watches, i_list) {
-                if (watch->dev == dev)
+                if (watch->ih == ih)
                         return watch;
         }
 
@@ -490,40 +207,40 @@ static struct inotify_watch *inode_find_dev(struct inode *inode,
 }
 
 /*
- * remove_watch_no_event - remove_watch() without the IN_IGNORED event.
+ * remove_watch_no_event - remove watch without the IN_IGNORED event.
+ *
+ * Callers must hold both inode->inotify_mutex and ih->mutex.
  */
 static void remove_watch_no_event(struct inotify_watch *watch,
-                                  struct inotify_device *dev)
+                                  struct inotify_handle *ih)
 {
         list_del(&watch->i_list);
-        list_del(&watch->d_list);
+        list_del(&watch->h_list);
 
         if (!inotify_inode_watched(watch->inode))
                 set_dentry_child_flags(watch->inode, 0);
 
-        atomic_dec(&dev->user->inotify_watches);
-        idr_remove(&dev->idr, watch->wd);
-        put_inotify_watch(watch);
+        idr_remove(&ih->idr, watch->wd);
 }
 
-/*
- * remove_watch - Remove a watch from both the device and the inode.  Sends
- * the IN_IGNORED event to the given device signifying that the inode is no
- * longer watched.
- *
- * Callers must hold both inode->inotify_mutex and dev->mutex.  We drop a
- * reference to the inode before returning.
+/**
+ * inotify_remove_watch_locked - Remove a watch from both the handle and the
+ * inode.  Sends the IN_IGNORED event signifying that the inode is no longer
+ * watched.  May be invoked from a caller's event handler.
+ * @ih: inotify handle associated with watch
+ * @watch: watch to remove
  *
- * The inode is not iput() so as to remain atomic.  If the inode needs to be
- * iput(), the call returns one.  Otherwise, it returns zero.
+ * Callers must hold both inode->inotify_mutex and ih->mutex.
  */
-static void remove_watch(struct inotify_watch *watch,struct inotify_device *dev)
+void inotify_remove_watch_locked(struct inotify_handle *ih,
+                                 struct inotify_watch *watch)
 {
-        inotify_dev_queue_event(dev, watch, IN_IGNORED, 0, NULL);
-        remove_watch_no_event(watch, dev);
+        remove_watch_no_event(watch, ih);
+        ih->in_ops->handle_event(watch, watch->wd, IN_IGNORED, 0, NULL, NULL);
 }
+EXPORT_SYMBOL_GPL(inotify_remove_watch_locked);
 
-/* Kernel API */
+/* Kernel API for producing events */
 
 /*
  * inotify_d_instantiate - instantiate dcache entry for inode
@@ -563,9 +280,10 @@ void inotify_d_move(struct dentry *entry)
  * @mask: event mask describing this event
  * @cookie: cookie for synchronization, or zero
  * @name: filename, if any
+ * @n_inode: inode associated with name
  */
 void inotify_inode_queue_event(struct inode *inode, u32 mask, u32 cookie,
-                               const char *name)
+                               const char *name, struct inode *n_inode)
 {
         struct inotify_watch *watch, *next;
 
@@ -576,14 +294,13 @@ void inotify_inode_queue_event(struct inode *inode, u32 mask, u32 cookie,
         list_for_each_entry_safe(watch, next, &inode->inotify_watches, i_list) {
                 u32 watch_mask = watch->mask;
                 if (watch_mask & mask) {
-                        struct inotify_device *dev = watch->dev;
-                        get_inotify_watch(watch);
-                        mutex_lock(&dev->mutex);
-                        inotify_dev_queue_event(dev, watch, mask, cookie, name);
+                        struct inotify_handle *ih= watch->ih;
+                        mutex_lock(&ih->mutex);
                         if (watch_mask & IN_ONESHOT)
-                                remove_watch_no_event(watch, dev);
-                        mutex_unlock(&dev->mutex);
-                        put_inotify_watch(watch);
+                                remove_watch_no_event(watch, ih);
+                        ih->in_ops->handle_event(watch, watch->wd, mask, cookie,
+                                                 name, n_inode);
+                        mutex_unlock(&ih->mutex);
                 }
         }
         mutex_unlock(&inode->inotify_mutex);
@@ -613,7 +330,8 @@ void inotify_dentry_parent_queue_event(struct dentry *dentry, u32 mask,
         if (inotify_inode_watched(inode)) {
                 dget(parent);
                 spin_unlock(&dentry->d_lock);
-                inotify_inode_queue_event(inode, mask, cookie, name);
+                inotify_inode_queue_event(inode, mask, cookie, name,
+                                          dentry->d_inode);
                 dput(parent);
         } else
                 spin_unlock(&dentry->d_lock);
@@ -665,7 +383,7 @@ void inotify_unmount_inodes(struct list_head *list)
 
                 need_iput_tmp = need_iput;
                 need_iput = NULL;
-                /* In case the remove_watch() drops a reference. */
+                /* In case inotify_remove_watch_locked() drops a reference. */
                 if (inode != need_iput_tmp)
                         __iget(inode);
                 else
@@ -694,11 +412,12 @@ void inotify_unmount_inodes(struct list_head *list)
                 mutex_lock(&inode->inotify_mutex);
                 watches = &inode->inotify_watches;
                 list_for_each_entry_safe(watch, next_w, watches, i_list) {
-                        struct inotify_device *dev = watch->dev;
-                        mutex_lock(&dev->mutex);
-                        inotify_dev_queue_event(dev, watch, IN_UNMOUNT,0,NULL);
-                        remove_watch(watch, dev);
-                        mutex_unlock(&dev->mutex);
+                        struct inotify_handle *ih= watch->ih;
+                        mutex_lock(&ih->mutex);
+                        ih->in_ops->handle_event(watch, watch->wd, IN_UNMOUNT, 0,
+                                                 NULL, NULL);
+                        inotify_remove_watch_locked(ih, watch);
+                        mutex_unlock(&ih->mutex);
                 }
                 mutex_unlock(&inode->inotify_mutex);
                 iput(inode);            
@@ -718,432 +437,292 @@ void inotify_inode_is_dead(struct inode *inode)
 
         mutex_lock(&inode->inotify_mutex);
         list_for_each_entry_safe(watch, next, &inode->inotify_watches, i_list) {
-                struct inotify_device *dev = watch->dev;
-                mutex_lock(&dev->mutex);
-                remove_watch(watch, dev);
-                mutex_unlock(&dev->mutex);
+                struct inotify_handle *ih = watch->ih;
+                mutex_lock(&ih->mutex);
+                inotify_remove_watch_locked(ih, watch);
+                mutex_unlock(&ih->mutex);
         }
         mutex_unlock(&inode->inotify_mutex);
 }
 EXPORT_SYMBOL_GPL(inotify_inode_is_dead);
 
-/* Device Interface */
+/* Kernel Consumer API */
 
-static unsigned int inotify_poll(struct file *file, poll_table *wait)
+/**
+ * inotify_init - allocate and initialize an inotify instance
+ * @ops: caller's inotify operations
+ */
+struct inotify_handle *inotify_init(const struct inotify_operations *ops)
 {
-        struct inotify_device *dev = file->private_data;
-        int ret = 0;
+        struct inotify_handle *ih;
 
-        poll_wait(file, &dev->wq, wait);
-        mutex_lock(&dev->mutex);
-        if (!list_empty(&dev->events))
-                ret = POLLIN | POLLRDNORM;
-        mutex_unlock(&dev->mutex);
+        ih = kmalloc(sizeof(struct inotify_handle), GFP_KERNEL);
+        if (unlikely(!ih))
+                return ERR_PTR(-ENOMEM);
 
-        return ret;
+        idr_init(&ih->idr);
+        INIT_LIST_HEAD(&ih->watches);
+        mutex_init(&ih->mutex);
+        ih->last_wd = 0;
+        ih->in_ops = ops;
+        atomic_set(&ih->count, 0);
+        get_inotify_handle(ih);
+
+        return ih;
 }
+EXPORT_SYMBOL_GPL(inotify_init);
 
-static ssize_t inotify_read(struct file *file, char __user *buf,
-                            size_t count, loff_t *pos)
+/**
+ * inotify_init_watch - initialize an inotify watch
+ * @watch: watch to initialize
+ */
+void inotify_init_watch(struct inotify_watch *watch)
 {
-        size_t event_size = sizeof (struct inotify_event);
-        struct inotify_device *dev;
-        char __user *start;
-        int ret;
-        DEFINE_WAIT(wait);
-
-        start = buf;
-        dev = file->private_data;
-
-        while (1) {
-                int events;
-
-                prepare_to_wait(&dev->wq, &wait, TASK_INTERRUPTIBLE);
-
-                mutex_lock(&dev->mutex);
-                events = !list_empty(&dev->events);
-                mutex_unlock(&dev->mutex);
-                if (events) {
-                        ret = 0;
-                        break;
-                }
-
-                if (file->f_flags & O_NONBLOCK) {
-                        ret = -EAGAIN;
-                        break;
-                }
-
-                if (signal_pending(current)) {
-                        ret = -EINTR;
-                        break;
-                }
-
-                schedule();
-        }
-
-        finish_wait(&dev->wq, &wait);
-        if (ret)
-                return ret;
-
-        mutex_lock(&dev->mutex);
-        while (1) {
-                struct inotify_kernel_event *kevent;
-
-                ret = buf - start;
-                if (list_empty(&dev->events))
-                        break;
-
-                kevent = inotify_dev_get_event(dev);
-                if (event_size + kevent->event.len > count)
-                        break;
-
-                if (copy_to_user(buf, &kevent->event, event_size)) {
-                        ret = -EFAULT;
-                        break;
-                }
-                buf += event_size;
-                count -= event_size;
-
-                if (kevent->name) {
-                        if (copy_to_user(buf, kevent->name, kevent->event.len)){
-                                ret = -EFAULT;
-                                break;
-                        }
-                        buf += kevent->event.len;
-                        count -= kevent->event.len;
-                }
-
-                remove_kevent(dev, kevent);
-        }
-        mutex_unlock(&dev->mutex);
-
-        return ret;
+        INIT_LIST_HEAD(&watch->h_list);
+        INIT_LIST_HEAD(&watch->i_list);
+        atomic_set(&watch->count, 0);
+        get_inotify_watch(watch); /* initial get */
 }
+EXPORT_SYMBOL_GPL(inotify_init_watch);
 
-static int inotify_release(struct inode *ignored, struct file *file)
+/**
+ * inotify_destroy - clean up and destroy an inotify instance
+ * @ih: inotify handle
+ */
+void inotify_destroy(struct inotify_handle *ih)
 {
-        struct inotify_device *dev = file->private_data;
-
         /*
-         * Destroy all of the watches on this device.  Unfortunately, not very
+         * Destroy all of the watches for this handle. Unfortunately, not very
          * pretty.  We cannot do a simple iteration over the list, because we
          * do not know the inode until we iterate to the watch.  But we need to
-         * hold inode->inotify_mutex before dev->mutex.  The following works.
+         * hold inode->inotify_mutex before ih->mutex.  The following works.
          */
         while (1) {
                 struct inotify_watch *watch;
                 struct list_head *watches;
                 struct inode *inode;
 
-                mutex_lock(&dev->mutex);
-                watches = &dev->watches;
+                mutex_lock(&ih->mutex);
+                watches = &ih->watches;
                 if (list_empty(watches)) {
-                        mutex_unlock(&dev->mutex);
+                        mutex_unlock(&ih->mutex);
                         break;
                 }
-                watch = list_entry(watches->next, struct inotify_watch, d_list);
+                watch = list_entry(watches->next, struct inotify_watch, h_list);
                 get_inotify_watch(watch);
-                mutex_unlock(&dev->mutex);
+                mutex_unlock(&ih->mutex);
 
                 inode = watch->inode;
                 mutex_lock(&inode->inotify_mutex);
-                mutex_lock(&dev->mutex);
+                mutex_lock(&ih->mutex);
 
                 /* make sure we didn't race with another list removal */
-                if (likely(idr_find(&dev->idr, watch->wd)))
-                        remove_watch_no_event(watch, dev);
+                if (likely(idr_find(&ih->idr, watch->wd))) {
+                        remove_watch_no_event(watch, ih);
+                        put_inotify_watch(watch);
+                }
 
-                mutex_unlock(&dev->mutex);
+                mutex_unlock(&ih->mutex);
                 mutex_unlock(&inode->inotify_mutex);
                 put_inotify_watch(watch);
         }
 
-        /* destroy all of the events on this device */
-        mutex_lock(&dev->mutex);
-        while (!list_empty(&dev->events))
-                inotify_dev_event_dequeue(dev);
-        mutex_unlock(&dev->mutex);
-
-        /* free this device: the put matching the get in inotify_init() */
-        put_inotify_dev(dev);
-
-        return 0;
+        /* free this handle: the put matching the get in inotify_init() */
+        put_inotify_handle(ih);
 }
+EXPORT_SYMBOL_GPL(inotify_destroy);
 
-/*
- * inotify_ignore - remove a given wd from this inotify instance.
+/**
+ * inotify_find_watch - find an existing watch for an (ih,inode) pair
+ * @ih: inotify handle
+ * @inode: inode to watch
+ * @watchp: pointer to existing inotify_watch
  *
- * Can sleep.
+ * Caller must pin given inode (via nameidata).
  */
-static int inotify_ignore(struct inotify_device *dev, s32 wd)
+s32 inotify_find_watch(struct inotify_handle *ih, struct inode *inode,
+                       struct inotify_watch **watchp)
 {
-        struct inotify_watch *watch;
-        struct inode *inode;
-
-        mutex_lock(&dev->mutex);
-        watch = idr_find(&dev->idr, wd);
-        if (unlikely(!watch)) {
-                mutex_unlock(&dev->mutex);
-                return -EINVAL;
-        }
-        get_inotify_watch(watch);
-        inode = watch->inode;
-        mutex_unlock(&dev->mutex);
+        struct inotify_watch *old;
+        int ret = -ENOENT;
 
         mutex_lock(&inode->inotify_mutex);
-        mutex_lock(&dev->mutex);
+        mutex_lock(&ih->mutex);
 
-        /* make sure that we did not race */
-        if (likely(idr_find(&dev->idr, wd) == watch))
-                remove_watch(watch, dev);
+        old = inode_find_handle(inode, ih);
+        if (unlikely(old)) {
+                get_inotify_watch(old); /* caller must put watch */
+                *watchp = old;
+                ret = old->wd;
+        }
 
-        mutex_unlock(&dev->mutex);
+        mutex_unlock(&ih->mutex);
         mutex_unlock(&inode->inotify_mutex);
-        put_inotify_watch(watch);
 
-        return 0;
+        return ret;
 }
+EXPORT_SYMBOL_GPL(inotify_find_watch);
 
-static long inotify_ioctl(struct file *file, unsigned int cmd,
-                          unsigned long arg)
+/**
+ * inotify_find_update_watch - find and update the mask of an existing watch
+ * @ih: inotify handle
+ * @inode: inode's watch to update
+ * @mask: mask of events to watch
+ *
+ * Caller must pin given inode (via nameidata).
+ */
+s32 inotify_find_update_watch(struct inotify_handle *ih, struct inode *inode,
+                              u32 mask)
 {
-        struct inotify_device *dev;
-        void __user *p;
-        int ret = -ENOTTY;
-
-        dev = file->private_data;
-        p = (void __user *) arg;
-
-        switch (cmd) {
-        case FIONREAD:
-                ret = put_user(dev->queue_size, (int __user *) p);
-                break;
-        }
-
-        return ret;
-}
+        struct inotify_watch *old;
+        int mask_add = 0;
+        int ret;
 
-static const struct file_operations inotify_fops = {
-        .poll           = inotify_poll,
-        .read           = inotify_read,
-        .release        = inotify_release,
-        .unlocked_ioctl = inotify_ioctl,
-        .compat_ioctl   = inotify_ioctl,
-};
+        if (mask & IN_MASK_ADD)
+                mask_add = 1;
 
-asmlinkage long sys_inotify_init(void)
-{
-        struct inotify_device *dev;
-        struct user_struct *user;
-        struct file *filp;      
-        int fd, ret;
-
-        fd = get_unused_fd();
-        if (fd < 0)
-                return fd;
-
-        filp = get_empty_filp();
-        if (!filp) {
-                ret = -ENFILE;
-                goto out_put_fd;
-        }
+        /* don't allow invalid bits: we don't want flags set */
+        mask &= IN_ALL_EVENTS | IN_ONESHOT;
+        if (unlikely(!mask))
+                return -EINVAL;
 
-        user = get_uid(current->user);
-        if (unlikely(atomic_read(&user->inotify_devs) >=
-                        inotify_max_user_instances)) {
-                ret = -EMFILE;
-                goto out_free_uid;
-        }
+        mutex_lock(&inode->inotify_mutex);
+        mutex_lock(&ih->mutex);
 
-        dev = kmalloc(sizeof(struct inotify_device), GFP_KERNEL);
-        if (unlikely(!dev)) {
-                ret = -ENOMEM;
-                goto out_free_uid;
+        /*
+         * Handle the case of re-adding a watch on an (inode,ih) pair that we
+         * are already watching.  We just update the mask and return its wd.
+         */
+        old = inode_find_handle(inode, ih);
+        if (unlikely(!old)) {
+                ret = -ENOENT;
+                goto out;
         }
 
-        filp->f_op = &inotify_fops;
-        filp->f_vfsmnt = mntget(inotify_mnt);
-        filp->f_dentry = dget(inotify_mnt->mnt_root);
-        filp->f_mapping = filp->f_dentry->d_inode->i_mapping;
-        filp->f_mode = FMODE_READ;
-        filp->f_flags = O_RDONLY;
-        filp->private_data = dev;
-
-        idr_init(&dev->idr);
-        INIT_LIST_HEAD(&dev->events);
-        INIT_LIST_HEAD(&dev->watches);
-        init_waitqueue_head(&dev->wq);
-        mutex_init(&dev->mutex);
-        dev->event_count = 0;
-        dev->queue_size = 0;
-        dev->max_events = inotify_max_queued_events;
-        dev->user = user;
-        dev->last_wd = 0;
-        atomic_set(&dev->count, 0);
-
-        get_inotify_dev(dev);
-        atomic_inc(&user->inotify_devs);
-        fd_install(fd, filp);
-
-        return fd;
-out_free_uid:
-        free_uid(user);
-        put_filp(filp);
-out_put_fd:
-        put_unused_fd(fd);
+        if (mask_add)
+                old->mask |= mask;
+        else
+                old->mask = mask;
+        ret = old->wd;
+out:
+        mutex_unlock(&ih->mutex);
+        mutex_unlock(&inode->inotify_mutex);
         return ret;
 }
+EXPORT_SYMBOL_GPL(inotify_find_update_watch);
 
-asmlinkage long sys_inotify_add_watch(int fd, const char __user *path, u32 mask)
+/**
+ * inotify_add_watch - add a watch to an inotify instance
+ * @ih: inotify handle
+ * @watch: caller allocated watch structure
+ * @inode: inode to watch
+ * @mask: mask of events to watch
+ *
+ * Caller must pin given inode (via nameidata).
+ * Caller must ensure it only calls inotify_add_watch() once per watch.
+ * Calls inotify_handle_get_wd() so may sleep.
+ */
+s32 inotify_add_watch(struct inotify_handle *ih, struct inotify_watch *watch,
+                      struct inode *inode, u32 mask)
 {
-        struct inotify_watch *watch, *old;
-        struct inode *inode;
-        struct inotify_device *dev;
-        struct nameidata nd;
-        struct file *filp;
-        int ret, fput_needed;
-        int mask_add = 0;
-        unsigned flags = 0;
-
-        filp = fget_light(fd, &fput_needed);
-        if (unlikely(!filp))
-                return -EBADF;
-
-        /* verify that this is indeed an inotify instance */
-        if (unlikely(filp->f_op != &inotify_fops)) {
-                ret = -EINVAL;
-                goto fput_and_out;
-        }
-
-        if (!(mask & IN_DONT_FOLLOW))
-                flags |= LOOKUP_FOLLOW;
-        if (mask & IN_ONLYDIR)
-                flags |= LOOKUP_DIRECTORY;
-
-        ret = find_inode(path, &nd, flags);
-        if (unlikely(ret))
-                goto fput_and_out;
+        int ret = 0;
 
-        /* inode held in place by reference to nd; dev by fget on fd */
-        inode = nd.dentry->d_inode;
-        dev = filp->private_data;
+        /* don't allow invalid bits: we don't want flags set */
+        mask &= IN_ALL_EVENTS | IN_ONESHOT;
+        if (unlikely(!mask))
+                return -EINVAL;
+        watch->mask = mask;
 
         mutex_lock(&inode->inotify_mutex);
-        mutex_lock(&dev->mutex);
-
-        if (mask & IN_MASK_ADD)
-                mask_add = 1;
+        mutex_lock(&ih->mutex);
 
-        /* don't let user-space set invalid bits: we don't want flags set */
-        mask &= IN_ALL_EVENTS | IN_ONESHOT;
-        if (unlikely(!mask)) {
-                ret = -EINVAL;
+        /* Initialize a new watch */
+        ret = inotify_handle_get_wd(ih, watch);
+        if (unlikely(ret))
                 goto out;
-        }
+        ret = watch->wd;
+
+        /* save a reference to handle and bump the count to make it official */
+        get_inotify_handle(ih);
+        watch->ih = ih;
 
         /*
-         * Handle the case of re-adding a watch on an (inode,dev) pair that we
-         * are already watching.  We just update the mask and return its wd.
+         * Save a reference to the inode and bump the ref count to make it
+         * official.  We hold a reference to nameidata, which makes this safe.
          */
-        old = inode_find_dev(inode, dev);
-        if (unlikely(old)) {
-                if (mask_add)
-                        old->mask |= mask;
-                else
-                        old->mask = mask;
-                ret = old->wd;
-                goto out;
-        }
-
-        watch = create_watch(dev, mask, inode);
-        if (unlikely(IS_ERR(watch))) {
-                ret = PTR_ERR(watch);
-                goto out;
-        }
+        watch->inode = igrab(inode);
 
         if (!inotify_inode_watched(inode))
                 set_dentry_child_flags(inode, 1);
 
-        /* Add the watch to the device's and the inode's list */
-        list_add(&watch->d_list, &dev->watches);
+        /* Add the watch to the handle's and the inode's list */
+        list_add(&watch->h_list, &ih->watches);
         list_add(&watch->i_list, &inode->inotify_watches);
-        ret = watch->wd;
 out:
-        mutex_unlock(&dev->mutex);
+        mutex_unlock(&ih->mutex);
         mutex_unlock(&inode->inotify_mutex);
-        path_release(&nd);
-fput_and_out:
-        fput_light(filp, fput_needed);
         return ret;
 }
+EXPORT_SYMBOL_GPL(inotify_add_watch);
 
-asmlinkage long sys_inotify_rm_watch(int fd, u32 wd)
+/**
+ * inotify_rm_wd - remove a watch from an inotify instance
+ * @ih: inotify handle
+ * @wd: watch descriptor to remove
+ *
+ * Can sleep.
+ */
+int inotify_rm_wd(struct inotify_handle *ih, u32 wd)
 {
-        struct file *filp;
-        struct inotify_device *dev;
-        int ret, fput_needed;
-
-        filp = fget_light(fd, &fput_needed);
-        if (unlikely(!filp))
-                return -EBADF;
+        struct inotify_watch *watch;
+        struct inode *inode;
 
-        /* verify that this is indeed an inotify instance */
-        if (unlikely(filp->f_op != &inotify_fops)) {
-                ret = -EINVAL;
-                goto out;
+        mutex_lock(&ih->mutex);
+        watch = idr_find(&ih->idr, wd);
+        if (unlikely(!watch)) {
+                mutex_unlock(&ih->mutex);
+                return -EINVAL;
         }
+        get_inotify_watch(watch);
+        inode = watch->inode;
+        mutex_unlock(&ih->mutex);
 
-        dev = filp->private_data;
-        ret = inotify_ignore(dev, wd);
+        mutex_lock(&inode->inotify_mutex);
+        mutex_lock(&ih->mutex);
 
-out:
-        fput_light(filp, fput_needed);
-        return ret;
+        /* make sure that we did not race */
+        if (likely(idr_find(&ih->idr, wd) == watch))
+                inotify_remove_watch_locked(ih, watch);
+
+        mutex_unlock(&ih->mutex);
+        mutex_unlock(&inode->inotify_mutex);
+        put_inotify_watch(watch);
+
+        return 0;
 }
+EXPORT_SYMBOL_GPL(inotify_rm_wd);
 
-static struct super_block *
-inotify_get_sb(struct file_system_type *fs_type, int flags,
-               const char *dev_name, void *data)
+/**
+ * inotify_rm_watch - remove a watch from an inotify instance
+ * @ih: inotify handle
+ * @watch: watch to remove
+ *
+ * Can sleep.
+ */
+int inotify_rm_watch(struct inotify_handle *ih,
+                     struct inotify_watch *watch)
 {
-    return get_sb_pseudo(fs_type, "inotify", NULL, 0xBAD1DEA);
+        return inotify_rm_wd(ih, watch->wd);
 }
-
-static struct file_system_type inotify_fs_type = {
-    .name           = "inotifyfs",
-    .get_sb         = inotify_get_sb,
-    .kill_sb        = kill_anon_super,
-};
+EXPORT_SYMBOL_GPL(inotify_rm_watch);
 
 /*
- * inotify_setup - Our initialization function.  Note that we cannnot return
- * error because we have compiled-in VFS hooks.  So an (unlikely) failure here
- * must result in panic().
+ * inotify_setup - core initialization function
  */
 static int __init inotify_setup(void)
 {
-        int ret;
-
-        ret = register_filesystem(&inotify_fs_type);
-        if (unlikely(ret))
-                panic("inotify: register_filesystem returned %d!\n", ret);
-
-        inotify_mnt = kern_mount(&inotify_fs_type);
-        if (IS_ERR(inotify_mnt))
-                panic("inotify: kern_mount ret %ld!\n", PTR_ERR(inotify_mnt));
-
-        inotify_max_queued_events = 16384;
-        inotify_max_user_instances = 128;
-        inotify_max_user_watches = 8192;
-
         atomic_set(&inotify_cookie, 0);
 
-        watch_cachep = kmem_cache_create("inotify_watch_cache",
-                                         sizeof(struct inotify_watch),
-                                         0, SLAB_PANIC, NULL, NULL);
-        event_cachep = kmem_cache_create("inotify_event_cache",
-                                         sizeof(struct inotify_kernel_event),
-                                         0, SLAB_PANIC, NULL, NULL);
-
         return 0;
 }
 
diff --git a/fs/inotify_user.c b/fs/inotify_user.c
new file mode 100644
index 000000000000..9e9931e2badd
--- /dev/null
+++ b/fs/inotify_user.c
@@ -0,0 +1,719 @@
+/*
+ * fs/inotify_user.c - inotify support for userspace
+ *
+ * Authors:
+ *      John McCutchan  <ttb@tentacle.dhs.org>
+ *      Robert Love     <rml@novell.com>
+ *
+ * Copyright (C) 2005 John McCutchan
+ * Copyright 2006 Hewlett-Packard Development Company, L.P.
+ *
+ * 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, 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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/file.h>
+#include <linux/mount.h>
+#include <linux/namei.h>
+#include <linux/poll.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/inotify.h>
+#include <linux/syscalls.h>
+
+#include <asm/ioctls.h>
+
+static kmem_cache_t *watch_cachep __read_mostly;
+static kmem_cache_t *event_cachep __read_mostly;
+
+static struct vfsmount *inotify_mnt __read_mostly;
+
+/* these are configurable via /proc/sys/fs/inotify/ */
+int inotify_max_user_instances __read_mostly;
+int inotify_max_user_watches __read_mostly;
+int inotify_max_queued_events __read_mostly;
+
+/*
+ * Lock ordering:
+ *
+ * inotify_dev->up_mutex (ensures we don't re-add the same watch)
+ *      inode->inotify_mutex (protects inode's watch list)
+ *              inotify_handle->mutex (protects inotify_handle's watch list)
+ *                      inotify_dev->ev_mutex (protects device's event queue)
+ */
+
+/*
+ * Lifetimes of the main data structures:
+ *
+ * inotify_device: Lifetime is managed by reference count, from
+ * sys_inotify_init() until release.  Additional references can bump the count
+ * via get_inotify_dev() and drop the count via put_inotify_dev().
+ *
+ * inotify_user_watch: Lifetime is from create_watch() to the receipt of an
+ * IN_IGNORED event from inotify, or when using IN_ONESHOT, to receipt of the
+ * first event, or to inotify_destroy().
+ */
+
+/*
+ * struct inotify_device - represents an inotify instance
+ *
+ * This structure is protected by the mutex 'mutex'.
+ */
+struct inotify_device {
+        wait_queue_head_t       wq;             /* wait queue for i/o */
+        struct mutex            ev_mutex;       /* protects event queue */
+        struct mutex            up_mutex;       /* synchronizes watch updates */
+        struct list_head        events;         /* list of queued events */
+        atomic_t                count;          /* reference count */
+        struct user_struct      *user;          /* user who opened this dev */
+        struct inotify_handle   *ih;            /* inotify handle */
+        unsigned int            queue_size;     /* size of the queue (bytes) */
+        unsigned int            event_count;    /* number of pending events */
+        unsigned int            max_events;     /* maximum number of events */
+};
+
+/*
+ * struct inotify_kernel_event - An inotify event, originating from a watch and
+ * queued for user-space.  A list of these is attached to each instance of the
+ * device.  In read(), this list is walked and all events that can fit in the
+ * buffer are returned.
+ *
+ * Protected by dev->ev_mutex of the device in which we are queued.
+ */
+struct inotify_kernel_event {
+        struct inotify_event    event;  /* the user-space event */
+        struct list_head        list;   /* entry in inotify_device's list */
+        char                    *name;  /* filename, if any */
+};
+
+/*
+ * struct inotify_user_watch - our version of an inotify_watch, we add
+ * a reference to the associated inotify_device.
+ */
+struct inotify_user_watch {
+        struct inotify_device   *dev;   /* associated device */
+        struct inotify_watch    wdata;  /* inotify watch data */
+};
+
+#ifdef CONFIG_SYSCTL
+
+#include <linux/sysctl.h>
+
+static int zero;
+
+ctl_table inotify_table[] = {
+        {
+                .ctl_name       = INOTIFY_MAX_USER_INSTANCES,
+                .procname       = "max_user_instances",
+                .data           = &inotify_max_user_instances,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec_minmax,
+                .strategy       = &sysctl_intvec,
+                .extra1         = &zero,
+        },
+        {
+                .ctl_name       = INOTIFY_MAX_USER_WATCHES,
+                .procname       = "max_user_watches",
+                .data           = &inotify_max_user_watches,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec_minmax,
+                .strategy       = &sysctl_intvec,
+                .extra1         = &zero,
+        },
+        {
+                .ctl_name       = INOTIFY_MAX_QUEUED_EVENTS,
+                .procname       = "max_queued_events",
+                .data           = &inotify_max_queued_events,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec_minmax,
+                .strategy       = &sysctl_intvec,
+                .extra1         = &zero
+        },
+        { .ctl_name = 0 }
+};
+#endif /* CONFIG_SYSCTL */
+
+static inline void get_inotify_dev(struct inotify_device *dev)
+{
+        atomic_inc(&dev->count);
+}
+
+static inline void put_inotify_dev(struct inotify_device *dev)
+{
+        if (atomic_dec_and_test(&dev->count)) {
+                atomic_dec(&dev->user->inotify_devs);
+                free_uid(dev->user);
+                kfree(dev);
+        }
+}
+
+/*
+ * free_inotify_user_watch - cleans up the watch and its references
+ */
+static void free_inotify_user_watch(struct inotify_watch *w)
+{
+        struct inotify_user_watch *watch;
+        struct inotify_device *dev;
+
+        watch = container_of(w, struct inotify_user_watch, wdata);
+        dev = watch->dev;
+
+        atomic_dec(&dev->user->inotify_watches);
+        put_inotify_dev(dev);
+        kmem_cache_free(watch_cachep, watch);
+}
+
+/*
+ * kernel_event - create a new kernel event with the given parameters
+ *
+ * This function can sleep.
+ */
+static struct inotify_kernel_event * kernel_event(s32 wd, u32 mask, u32 cookie,
+                                                  const char *name)
+{
+        struct inotify_kernel_event *kevent;
+
+        kevent = kmem_cache_alloc(event_cachep, GFP_KERNEL);
+        if (unlikely(!kevent))
+                return NULL;
+
+        /* we hand this out to user-space, so zero it just in case */
+        memset(&kevent->event, 0, sizeof(struct inotify_event));
+
+        kevent->event.wd = wd;
+        kevent->event.mask = mask;
+        kevent->event.cookie = cookie;
+
+        INIT_LIST_HEAD(&kevent->list);
+
+        if (name) {
+                size_t len, rem, event_size = sizeof(struct inotify_event);
+
+                /*
+                 * We need to pad the filename so as to properly align an
+                 * array of inotify_event structures.  Because the structure is
+                 * small and the common case is a small filename, we just round
+                 * up to the next multiple of the structure's sizeof.  This is
+                 * simple and safe for all architectures.
+                 */
+                len = strlen(name) + 1;
+                rem = event_size - len;
+                if (len > event_size) {
+                        rem = event_size - (len % event_size);
+                        if (len % event_size == 0)
+                                rem = 0;
+                }
+
+                kevent->name = kmalloc(len + rem, GFP_KERNEL);
+                if (unlikely(!kevent->name)) {
+                        kmem_cache_free(event_cachep, kevent);
+                        return NULL;
+                }
+                memcpy(kevent->name, name, len);
+                if (rem)
+                        memset(kevent->name + len, 0, rem);
+                kevent->event.len = len + rem;
+        } else {
+                kevent->event.len = 0;
+                kevent->name = NULL;
+        }
+
+        return kevent;
+}
+
+/*
+ * inotify_dev_get_event - return the next event in the given dev's queue
+ *
+ * Caller must hold dev->ev_mutex.
+ */
+static inline struct inotify_kernel_event *
+inotify_dev_get_event(struct inotify_device *dev)
+{
+        return list_entry(dev->events.next, struct inotify_kernel_event, list);
+}
+
+/*
+ * inotify_dev_queue_event - event handler registered with core inotify, adds
+ * a new event to the given device
+ *
+ * Can sleep (calls kernel_event()).
+ */
+static void inotify_dev_queue_event(struct inotify_watch *w, u32 wd, u32 mask,
+                                    u32 cookie, const char *name,
+                                    struct inode *ignored)
+{
+        struct inotify_user_watch *watch;
+        struct inotify_device *dev;
+        struct inotify_kernel_event *kevent, *last;
+
+        watch = container_of(w, struct inotify_user_watch, wdata);
+        dev = watch->dev;
+
+        mutex_lock(&dev->ev_mutex);
+
+        /* we can safely put the watch as we don't reference it while
+         * generating the event
+         */
+        if (mask & IN_IGNORED || mask & IN_ONESHOT)
+                put_inotify_watch(w); /* final put */
+
+        /* coalescing: drop this event if it is a dupe of the previous */
+        last = inotify_dev_get_event(dev);
+        if (last && last->event.mask == mask && last->event.wd == wd &&
+                        last->event.cookie == cookie) {
+                const char *lastname = last->name;
+
+                if (!name && !lastname)
+                        goto out;
+                if (name && lastname && !strcmp(lastname, name))
+                        goto out;
+        }
+
+        /* the queue overflowed and we already sent the Q_OVERFLOW event */
+        if (unlikely(dev->event_count > dev->max_events))
+                goto out;
+
+        /* if the queue overflows, we need to notify user space */
+        if (unlikely(dev->event_count == dev->max_events))
+                kevent = kernel_event(-1, IN_Q_OVERFLOW, cookie, NULL);
+        else
+                kevent = kernel_event(wd, mask, cookie, name);
+
+        if (unlikely(!kevent))
+                goto out;
+
+        /* queue the event and wake up anyone waiting */
+        dev->event_count++;
+        dev->queue_size += sizeof(struct inotify_event) + kevent->event.len;
+        list_add_tail(&kevent->list, &dev->events);
+        wake_up_interruptible(&dev->wq);
+
+out:
+        mutex_unlock(&dev->ev_mutex);
+}
+
+/*
+ * remove_kevent - cleans up and ultimately frees the given kevent
+ *
+ * Caller must hold dev->ev_mutex.
+ */
+static void remove_kevent(struct inotify_device *dev,
+                          struct inotify_kernel_event *kevent)
+{
+        list_del(&kevent->list);
+
+        dev->event_count--;
+        dev->queue_size -= sizeof(struct inotify_event) + kevent->event.len;
+
+        kfree(kevent->name);
+        kmem_cache_free(event_cachep, kevent);
+}
+
+/*
+ * inotify_dev_event_dequeue - destroy an event on the given device
+ *
+ * Caller must hold dev->ev_mutex.
+ */
+static void inotify_dev_event_dequeue(struct inotify_device *dev)
+{
+        if (!list_empty(&dev->events)) {
+                struct inotify_kernel_event *kevent;
+                kevent = inotify_dev_get_event(dev);
+                remove_kevent(dev, kevent);
+        }
+}
+
+/*
+ * find_inode - resolve a user-given path to a specific inode and return a nd
+ */
+static int find_inode(const char __user *dirname, struct nameidata *nd,
+                      unsigned flags)
+{
+        int error;
+
+        error = __user_walk(dirname, flags, nd);
+        if (error)
+                return error;
+        /* you can only watch an inode if you have read permissions on it */
+        error = vfs_permission(nd, MAY_READ);
+        if (error)
+                path_release(nd);
+        return error;
+}
+
+/*
+ * create_watch - creates a watch on the given device.
+ *
+ * Callers must hold dev->up_mutex.
+ */
+static int create_watch(struct inotify_device *dev, struct inode *inode,
+                        u32 mask)
+{
+        struct inotify_user_watch *watch;
+        int ret;
+
+        if (atomic_read(&dev->user->inotify_watches) >=
+                        inotify_max_user_watches)
+                return -ENOSPC;
+
+        watch = kmem_cache_alloc(watch_cachep, GFP_KERNEL);
+        if (unlikely(!watch))
+                return -ENOMEM;
+
+        /* save a reference to device and bump the count to make it official */
+        get_inotify_dev(dev);
+        watch->dev = dev;
+
+        atomic_inc(&dev->user->inotify_watches);
+
+        inotify_init_watch(&watch->wdata);
+        ret = inotify_add_watch(dev->ih, &watch->wdata, inode, mask);
+        if (ret < 0)
+                free_inotify_user_watch(&watch->wdata);
+
+        return ret;
+}
+
+/* Device Interface */
+
+static unsigned int inotify_poll(struct file *file, poll_table *wait)
+{
+        struct inotify_device *dev = file->private_data;
+        int ret = 0;
+
+        poll_wait(file, &dev->wq, wait);
+        mutex_lock(&dev->ev_mutex);
+        if (!list_empty(&dev->events))
+                ret = POLLIN | POLLRDNORM;
+        mutex_unlock(&dev->ev_mutex);
+
+        return ret;
+}
+
+static ssize_t inotify_read(struct file *file, char __user *buf,
+                            size_t count, loff_t *pos)
+{
+        size_t event_size = sizeof (struct inotify_event);
+        struct inotify_device *dev;
+        char __user *start;
+        int ret;
+        DEFINE_WAIT(wait);
+
+        start = buf;
+        dev = file->private_data;
+
+        while (1) {
+                int events;
+
+                prepare_to_wait(&dev->wq, &wait, TASK_INTERRUPTIBLE);
+
+                mutex_lock(&dev->ev_mutex);
+                events = !list_empty(&dev->events);
+                mutex_unlock(&dev->ev_mutex);
+                if (events) {
+                        ret = 0;
+                        break;
+                }
+
+                if (file->f_flags & O_NONBLOCK) {
+                        ret = -EAGAIN;
+                        break;
+                }
+
+                if (signal_pending(current)) {
+                        ret = -EINTR;
+                        break;
+                }
+
+                schedule();
+        }
+
+        finish_wait(&dev->wq, &wait);
+        if (ret)
+                return ret;
+
+        mutex_lock(&dev->ev_mutex);
+        while (1) {
+                struct inotify_kernel_event *kevent;
+
+                ret = buf - start;
+                if (list_empty(&dev->events))
+                        break;
+
+                kevent = inotify_dev_get_event(dev);
+                if (event_size + kevent->event.len > count)
+                        break;
+
+                if (copy_to_user(buf, &kevent->event, event_size)) {
+                        ret = -EFAULT;
+                        break;
+                }
+                buf += event_size;
+                count -= event_size;
+
+                if (kevent->name) {
+                        if (copy_to_user(buf, kevent->name, kevent->event.len)){
+                                ret = -EFAULT;
+                                break;
+                        }
+                        buf += kevent->event.len;
+                        count -= kevent->event.len;
+                }
+
+                remove_kevent(dev, kevent);
+        }
+        mutex_unlock(&dev->ev_mutex);
+
+        return ret;
+}
+
+static int inotify_release(struct inode *ignored, struct file *file)
+{
+        struct inotify_device *dev = file->private_data;
+
+        inotify_destroy(dev->ih);
+
+        /* destroy all of the events on this device */
+        mutex_lock(&dev->ev_mutex);
+        while (!list_empty(&dev->events))
+                inotify_dev_event_dequeue(dev);
+        mutex_unlock(&dev->ev_mutex);
+
+        /* free this device: the put matching the get in inotify_init() */
+        put_inotify_dev(dev);
+
+        return 0;
+}
+
+static long inotify_ioctl(struct file *file, unsigned int cmd,
+                          unsigned long arg)
+{
+        struct inotify_device *dev;
+        void __user *p;
+        int ret = -ENOTTY;
+
+        dev = file->private_data;
+        p = (void __user *) arg;
+
+        switch (cmd) {
+        case FIONREAD:
+                ret = put_user(dev->queue_size, (int __user *) p);
+                break;
+        }
+
+        return ret;
+}
+
+static const struct file_operations inotify_fops = {
+        .poll           = inotify_poll,
+        .read           = inotify_read,
+        .release        = inotify_release,
+        .unlocked_ioctl = inotify_ioctl,
+        .compat_ioctl   = inotify_ioctl,
+};
+
+static const struct inotify_operations inotify_user_ops = {
+        .handle_event   = inotify_dev_queue_event,
+        .destroy_watch  = free_inotify_user_watch,
+};
+
+asmlinkage long sys_inotify_init(void)
+{
+        struct inotify_device *dev;
+        struct inotify_handle *ih;
+        struct user_struct *user;
+        struct file *filp;
+        int fd, ret;
+
+        fd = get_unused_fd();
+        if (fd < 0)
+                return fd;
+
+        filp = get_empty_filp();
+        if (!filp) {
+                ret = -ENFILE;
+                goto out_put_fd;
+        }
+
+        user = get_uid(current->user);
+        if (unlikely(atomic_read(&user->inotify_devs) >=
+                        inotify_max_user_instances)) {
+                ret = -EMFILE;
+                goto out_free_uid;
+        }
+
+        dev = kmalloc(sizeof(struct inotify_device), GFP_KERNEL);
+        if (unlikely(!dev)) {
+                ret = -ENOMEM;
+                goto out_free_uid;
+        }
+
+        ih = inotify_init(&inotify_user_ops);
+        if (unlikely(IS_ERR(ih))) {
+                ret = PTR_ERR(ih);
+                goto out_free_dev;
+        }
+        dev->ih = ih;
+
+        filp->f_op = &inotify_fops;
+        filp->f_vfsmnt = mntget(inotify_mnt);
+        filp->f_dentry = dget(inotify_mnt->mnt_root);
+        filp->f_mapping = filp->f_dentry->d_inode->i_mapping;
+        filp->f_mode = FMODE_READ;
+        filp->f_flags = O_RDONLY;
+        filp->private_data = dev;
+
+        INIT_LIST_HEAD(&dev->events);
+        init_waitqueue_head(&dev->wq);
+        mutex_init(&dev->ev_mutex);
+        mutex_init(&dev->up_mutex);
+        dev->event_count = 0;
+        dev->queue_size = 0;
+        dev->max_events = inotify_max_queued_events;
+        dev->user = user;
+        atomic_set(&dev->count, 0);
+
+        get_inotify_dev(dev);
+        atomic_inc(&user->inotify_devs);
+        fd_install(fd, filp);
+
+        return fd;
+out_free_dev:
+        kfree(dev);
+out_free_uid:
+        free_uid(user);
+        put_filp(filp);
+out_put_fd:
+        put_unused_fd(fd);
+        return ret;
+}
+
+asmlinkage long sys_inotify_add_watch(int fd, const char __user *path, u32 mask)
+{
+        struct inode *inode;
+        struct inotify_device *dev;
+        struct nameidata nd;
+        struct file *filp;
+        int ret, fput_needed;
+        unsigned flags = 0;
+
+        filp = fget_light(fd, &fput_needed);
+        if (unlikely(!filp))
+                return -EBADF;
+
+        /* verify that this is indeed an inotify instance */
+        if (unlikely(filp->f_op != &inotify_fops)) {
+                ret = -EINVAL;
+                goto fput_and_out;
+        }
+
+        if (!(mask & IN_DONT_FOLLOW))
+                flags |= LOOKUP_FOLLOW;
+        if (mask & IN_ONLYDIR)
+                flags |= LOOKUP_DIRECTORY;
+
+        ret = find_inode(path, &nd, flags);
+        if (unlikely(ret))
+                goto fput_and_out;
+
+        /* inode held in place by reference to nd; dev by fget on fd */
+        inode = nd.dentry->d_inode;
+        dev = filp->private_data;
+
+        mutex_lock(&dev->up_mutex);
+        ret = inotify_find_update_watch(dev->ih, inode, mask);
+        if (ret == -ENOENT)
+                ret = create_watch(dev, inode, mask);
+        mutex_unlock(&dev->up_mutex);
+
+        path_release(&nd);
+fput_and_out:
+        fput_light(filp, fput_needed);
+        return ret;
+}
+
+asmlinkage long sys_inotify_rm_watch(int fd, u32 wd)
+{
+        struct file *filp;
+        struct inotify_device *dev;
+        int ret, fput_needed;
+
+        filp = fget_light(fd, &fput_needed);
+        if (unlikely(!filp))
+                return -EBADF;
+
+        /* verify that this is indeed an inotify instance */
+        if (unlikely(filp->f_op != &inotify_fops)) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        dev = filp->private_data;
+
+        /* we free our watch data when we get IN_IGNORED */
+        ret = inotify_rm_wd(dev->ih, wd);
+
+out:
+        fput_light(filp, fput_needed);
+        return ret;
+}
+
+static struct super_block *
+inotify_get_sb(struct file_system_type *fs_type, int flags,
+               const char *dev_name, void *data)
+{
+    return get_sb_pseudo(fs_type, "inotify", NULL, 0xBAD1DEA);
+}
+
+static struct file_system_type inotify_fs_type = {
+    .name           = "inotifyfs",
+    .get_sb         = inotify_get_sb,
+    .kill_sb        = kill_anon_super,
+};
+
+/*
+ * inotify_user_setup - Our initialization function.  Note that we cannnot return
+ * error because we have compiled-in VFS hooks.  So an (unlikely) failure here
+ * must result in panic().
+ */
+static int __init inotify_user_setup(void)
+{
+        int ret;
+
+        ret = register_filesystem(&inotify_fs_type);
+        if (unlikely(ret))
+                panic("inotify: register_filesystem returned %d!\n", ret);
+
+        inotify_mnt = kern_mount(&inotify_fs_type);
+        if (IS_ERR(inotify_mnt))
+                panic("inotify: kern_mount ret %ld!\n", PTR_ERR(inotify_mnt));
+
+        inotify_max_queued_events = 16384;
+        inotify_max_user_instances = 128;
+        inotify_max_user_watches = 8192;
+
+        watch_cachep = kmem_cache_create("inotify_watch_cache",
+                                         sizeof(struct inotify_user_watch),
+                                         0, SLAB_PANIC, NULL, NULL);
+        event_cachep = kmem_cache_create("inotify_event_cache",
+                                         sizeof(struct inotify_kernel_event),
+                                         0, SLAB_PANIC, NULL, NULL);
+
+        return 0;
+}
+
+module_init(inotify_user_setup);
diff --git a/fs/jffs/intrep.c b/fs/jffs/intrep.c
index 0ef207dfaf6f..5371a403130a 100644
--- a/fs/jffs/intrep.c
+++ b/fs/jffs/intrep.c
@@ -247,7 +247,7 @@ flash_safe_read(struct mtd_info *mtd, loff_t from,
         D3(printk(KERN_NOTICE "flash_safe_read(%p, %08x, %p, %08x)\n",
                   mtd, (unsigned int) from, buf, count));
 
-        res = MTD_READ(mtd, from, count, &retlen, buf);
+        res = mtd->read(mtd, from, count, &retlen, buf);
         if (retlen != count) {
                 panic("Didn't read all bytes in flash_safe_read(). Returned %d\n", res);
         }
@@ -262,7 +262,7 @@ flash_read_u32(struct mtd_info *mtd, loff_t from)
         __u32 ret;
         int res;
 
-        res = MTD_READ(mtd, from, 4, &retlen, (unsigned char *)&ret);
+        res = mtd->read(mtd, from, 4, &retlen, (unsigned char *)&ret);
         if (retlen != 4) {
                 printk("Didn't read all bytes in flash_read_u32(). Returned %d\n", res);
                 return 0;
@@ -282,7 +282,7 @@ flash_safe_write(struct mtd_info *mtd, loff_t to,
         D3(printk(KERN_NOTICE "flash_safe_write(%p, %08x, %p, %08x)\n",
                   mtd, (unsigned int) to, buf, count));
 
-        res = MTD_WRITE(mtd, to, count, &retlen, buf);
+        res = mtd->write(mtd, to, count, &retlen, buf);
         if (retlen != count) {
                 printk("Didn't write all bytes in flash_safe_write(). Returned %d\n", res);
         }
@@ -300,9 +300,9 @@ flash_safe_writev(struct mtd_info *mtd, const struct kvec *vecs,
 
         D3(printk(KERN_NOTICE "flash_safe_writev(%p, %08x, %p)\n",
                   mtd, (unsigned int) to, vecs));
-        
+
         if (mtd->writev) {
-                res = MTD_WRITEV(mtd, vecs, iovec_cnt, to, &retlen);
+                res = mtd->writev(mtd, vecs, iovec_cnt, to, &retlen);
                 return res ? res : retlen;
         }
         /* Not implemented writev. Repeatedly use write - on the not so
@@ -312,7 +312,8 @@ flash_safe_writev(struct mtd_info *mtd, const struct kvec *vecs,
         retlen=0;
 
         for (i=0; !res && i<iovec_cnt; i++) {
-                res = MTD_WRITE(mtd, to, vecs[i].iov_len, &retlen_a, vecs[i].iov_base);
+                res = mtd->write(mtd, to, vecs[i].iov_len, &retlen_a,
+                                 vecs[i].iov_base);
                 if (retlen_a != vecs[i].iov_len) {
                         printk("Didn't write all bytes in flash_safe_writev(). Returned %d\n", res);
                         if (i != iovec_cnt-1)
@@ -393,7 +394,7 @@ flash_erase_region(struct mtd_info *mtd, loff_t start,
         set_current_state(TASK_UNINTERRUPTIBLE);
         add_wait_queue(&wait_q, &wait);
 
-        if (MTD_ERASE(mtd, erase) < 0) {
+        if (mtd->erase(mtd, erase) < 0) {
                 set_current_state(TASK_RUNNING);
                 remove_wait_queue(&wait_q, &wait);
                 kfree(erase);
diff --git a/fs/jffs2/Makefile b/fs/jffs2/Makefile
index 77dc5561a04e..7f28ee0bd132 100644
--- a/fs/jffs2/Makefile
+++ b/fs/jffs2/Makefile
@@ -12,6 +12,9 @@ jffs2-y	+= symlink.o build.o erase.o background.o fs.o writev.o
 jffs2-y += super.o debug.o
 
 jffs2-$(CONFIG_JFFS2_FS_WRITEBUFFER)    += wbuf.o
+jffs2-$(CONFIG_JFFS2_FS_XATTR)          += xattr.o xattr_trusted.o xattr_user.o
+jffs2-$(CONFIG_JFFS2_FS_SECURITY)       += security.o
+jffs2-$(CONFIG_JFFS2_FS_POSIX_ACL)      += acl.o
 jffs2-$(CONFIG_JFFS2_RUBIN)     += compr_rubin.o
 jffs2-$(CONFIG_JFFS2_RTIME)     += compr_rtime.o
 jffs2-$(CONFIG_JFFS2_ZLIB)      += compr_zlib.o
diff --git a/fs/jffs2/README.Locking b/fs/jffs2/README.Locking
index b7943439b6ec..c8f0bd64e53e 100644
--- a/fs/jffs2/README.Locking
+++ b/fs/jffs2/README.Locking
@@ -150,3 +150,24 @@ the buffer.
 
 Ordering constraints:
         Lock wbuf_sem last, after the alloc_sem or and f->sem.
+
+
+        c->xattr_sem
+        ------------
+
+This read/write semaphore protects against concurrent access to the
+xattr related objects which include stuff in superblock and ic->xref.
+In read-only path, write-semaphore is too much exclusion. It's enough
+by read-semaphore. But you must hold write-semaphore when updating,
+creating or deleting any xattr related object.
+
+Once xattr_sem released, there would be no assurance for the existence
+of those objects. Thus, a series of processes is often required to retry,
+when updating such a object is necessary under holding read semaphore.
+For example, do_jffs2_getxattr() holds read-semaphore to scan xref and
+xdatum at first. But it retries this process with holding write-semaphore
+after release read-semaphore, if it's necessary to load name/value pair
+from medium.
+
+Ordering constraints:
+        Lock xattr_sem last, after the alloc_sem.
diff --git a/fs/jffs2/acl.c b/fs/jffs2/acl.c
new file mode 100644
index 000000000000..320dd48b834e
--- /dev/null
+++ b/fs/jffs2/acl.c
@@ -0,0 +1,485 @@
+/*
+ * JFFS2 -- Journalling Flash File System, Version 2.
+ *
+ * Copyright (C) 2006  NEC Corporation
+ *
+ * Created by KaiGai Kohei <kaigai@ak.jp.nec.com>
+ *
+ * For licensing information, see the file 'LICENCE' in this directory.
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/time.h>
+#include <linux/crc32.h>
+#include <linux/jffs2.h>
+#include <linux/xattr.h>
+#include <linux/posix_acl_xattr.h>
+#include <linux/mtd/mtd.h>
+#include "nodelist.h"
+
+static size_t jffs2_acl_size(int count)
+{
+        if (count <= 4) {
+                return sizeof(struct jffs2_acl_header)
+                       + count * sizeof(struct jffs2_acl_entry_short);
+        } else {
+                return sizeof(struct jffs2_acl_header)
+                       + 4 * sizeof(struct jffs2_acl_entry_short)
+                       + (count - 4) * sizeof(struct jffs2_acl_entry);
+        }
+}
+
+static int jffs2_acl_count(size_t size)
+{
+        size_t s;
+
+        size -= sizeof(struct jffs2_acl_header);
+        s = size - 4 * sizeof(struct jffs2_acl_entry_short);
+        if (s < 0) {
+                if (size % sizeof(struct jffs2_acl_entry_short))
+                        return -1;
+                return size / sizeof(struct jffs2_acl_entry_short);
+        } else {
+                if (s % sizeof(struct jffs2_acl_entry))
+                        return -1;
+                return s / sizeof(struct jffs2_acl_entry) + 4;
+        }
+}
+
+static struct posix_acl *jffs2_acl_from_medium(void *value, size_t size)
+{
+        void *end = value + size;
+        struct jffs2_acl_header *header = value;
+        struct jffs2_acl_entry *entry;
+        struct posix_acl *acl;
+        uint32_t ver;
+        int i, count;
+
+        if (!value)
+                return NULL;
+        if (size < sizeof(struct jffs2_acl_header))
+                return ERR_PTR(-EINVAL);
+        ver = je32_to_cpu(header->a_version);
+        if (ver != JFFS2_ACL_VERSION) {
+                JFFS2_WARNING("Invalid ACL version. (=%u)\n", ver);
+                return ERR_PTR(-EINVAL);
+        }
+
+        value += sizeof(struct jffs2_acl_header);
+        count = jffs2_acl_count(size);
+        if (count < 0)
+                return ERR_PTR(-EINVAL);
+        if (count == 0)
+                return NULL;
+
+        acl = posix_acl_alloc(count, GFP_KERNEL);
+        if (!acl)
+                return ERR_PTR(-ENOMEM);
+
+        for (i=0; i < count; i++) {
+                entry = value;
+                if (value + sizeof(struct jffs2_acl_entry_short) > end)
+                        goto fail;
+                acl->a_entries[i].e_tag = je16_to_cpu(entry->e_tag);
+                acl->a_entries[i].e_perm = je16_to_cpu(entry->e_perm);
+                switch (acl->a_entries[i].e_tag) {
+                        case ACL_USER_OBJ:
+                        case ACL_GROUP_OBJ:
+                        case ACL_MASK:
+                        case ACL_OTHER:
+                                value += sizeof(struct jffs2_acl_entry_short);
+                                acl->a_entries[i].e_id = ACL_UNDEFINED_ID;
+                                break;
+
+                        case ACL_USER:
+                        case ACL_GROUP:
+                                value += sizeof(struct jffs2_acl_entry);
+                                if (value > end)
+                                        goto fail;
+                                acl->a_entries[i].e_id = je32_to_cpu(entry->e_id);
+                                break;
+
+                        default:
+                                goto fail;
+                }
+        }
+        if (value != end)
+                goto fail;
+        return acl;
+ fail:
+        posix_acl_release(acl);
+        return ERR_PTR(-EINVAL);
+}
+
+static void *jffs2_acl_to_medium(const struct posix_acl *acl, size_t *size)
+{
+        struct jffs2_acl_header *header;
+        struct jffs2_acl_entry *entry;
+        void *e;
+        size_t i;
+
+        *size = jffs2_acl_size(acl->a_count);
+        header = kmalloc(sizeof(*header) + acl->a_count * sizeof(*entry), GFP_KERNEL);
+        if (!header)
+                return ERR_PTR(-ENOMEM);
+        header->a_version = cpu_to_je32(JFFS2_ACL_VERSION);
+        e = header + 1;
+        for (i=0; i < acl->a_count; i++) {
+                entry = e;
+                entry->e_tag = cpu_to_je16(acl->a_entries[i].e_tag);
+                entry->e_perm = cpu_to_je16(acl->a_entries[i].e_perm);
+                switch(acl->a_entries[i].e_tag) {
+                        case ACL_USER:
+                        case ACL_GROUP:
+                                entry->e_id = cpu_to_je32(acl->a_entries[i].e_id);
+                                e += sizeof(struct jffs2_acl_entry);
+                                break;
+
+                        case ACL_USER_OBJ:
+                        case ACL_GROUP_OBJ:
+                        case ACL_MASK:
+                        case ACL_OTHER:
+                                e += sizeof(struct jffs2_acl_entry_short);
+                                break;
+
+                        default:
+                                goto fail;
+                }
+        }
+        return header;
+ fail:
+        kfree(header);
+        return ERR_PTR(-EINVAL);
+}
+
+static struct posix_acl *jffs2_iget_acl(struct inode *inode, struct posix_acl **i_acl)
+{
+        struct posix_acl *acl = JFFS2_ACL_NOT_CACHED;
+
+        spin_lock(&inode->i_lock);
+        if (*i_acl != JFFS2_ACL_NOT_CACHED)
+                acl = posix_acl_dup(*i_acl);
+        spin_unlock(&inode->i_lock);
+        return acl;
+}
+
+static void jffs2_iset_acl(struct inode *inode, struct posix_acl **i_acl, struct posix_acl *acl)
+{
+        spin_lock(&inode->i_lock);
+        if (*i_acl != JFFS2_ACL_NOT_CACHED)
+                posix_acl_release(*i_acl);
+        *i_acl = posix_acl_dup(acl);
+        spin_unlock(&inode->i_lock);
+}
+
+static struct posix_acl *jffs2_get_acl(struct inode *inode, int type)
+{
+        struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
+        struct posix_acl *acl;
+        char *value = NULL;
+        int rc, xprefix;
+
+        switch (type) {
+        case ACL_TYPE_ACCESS:
+                acl = jffs2_iget_acl(inode, &f->i_acl_access);
+                if (acl != JFFS2_ACL_NOT_CACHED)
+                        return acl;
+                xprefix = JFFS2_XPREFIX_ACL_ACCESS;
+                break;
+        case ACL_TYPE_DEFAULT:
+                acl = jffs2_iget_acl(inode, &f->i_acl_default);
+                if (acl != JFFS2_ACL_NOT_CACHED)
+                        return acl;
+                xprefix = JFFS2_XPREFIX_ACL_DEFAULT;
+                break;
+        default:
+                return ERR_PTR(-EINVAL);
+        }
+        rc = do_jffs2_getxattr(inode, xprefix, "", NULL, 0);
+        if (rc > 0) {
+                value = kmalloc(rc, GFP_KERNEL);
+                if (!value)
+                        return ERR_PTR(-ENOMEM);
+                rc = do_jffs2_getxattr(inode, xprefix, "", value, rc);
+        }
+        if (rc > 0) {
+                acl = jffs2_acl_from_medium(value, rc);
+        } else if (rc == -ENODATA || rc == -ENOSYS) {
+                acl = NULL;
+        } else {
+                acl = ERR_PTR(rc);
+        }
+        if (value)
+                kfree(value);
+        if (!IS_ERR(acl)) {
+                switch (type) {
+                case ACL_TYPE_ACCESS:
+                        jffs2_iset_acl(inode, &f->i_acl_access, acl);
+                        break;
+                case ACL_TYPE_DEFAULT:
+                        jffs2_iset_acl(inode, &f->i_acl_default, acl);
+                        break;
+                }
+        }
+        return acl;
+}
+
+static int jffs2_set_acl(struct inode *inode, int type, struct posix_acl *acl)
+{
+        struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
+        size_t size = 0;
+        char *value = NULL;
+        int rc, xprefix;
+
+        if (S_ISLNK(inode->i_mode))
+                return -EOPNOTSUPP;
+
+        switch (type) {
+        case ACL_TYPE_ACCESS:
+                xprefix = JFFS2_XPREFIX_ACL_ACCESS;
+                if (acl) {
+                        mode_t mode = inode->i_mode;
+                        rc = posix_acl_equiv_mode(acl, &mode);
+                        if (rc < 0)
+                                return rc;
+                        if (inode->i_mode != mode) {
+                                inode->i_mode = mode;
+                                jffs2_dirty_inode(inode);
+                        }
+                        if (rc == 0)
+                                acl = NULL;
+                }
+                break;
+        case ACL_TYPE_DEFAULT:
+                xprefix = JFFS2_XPREFIX_ACL_DEFAULT;
+                if (!S_ISDIR(inode->i_mode))
+                        return acl ? -EACCES : 0;
+                break;
+        default:
+                return -EINVAL;
+        }
+        if (acl) {
+                value = jffs2_acl_to_medium(acl, &size);
+                if (IS_ERR(value))
+                        return PTR_ERR(value);
+        }
+
+        rc = do_jffs2_setxattr(inode, xprefix, "", value, size, 0);
+        if (value)
+                kfree(value);
+        if (!rc) {
+                switch(type) {
+                case ACL_TYPE_ACCESS:
+                        jffs2_iset_acl(inode, &f->i_acl_access, acl);
+                        break;
+                case ACL_TYPE_DEFAULT:
+                        jffs2_iset_acl(inode, &f->i_acl_default, acl);
+                        break;
+                }
+        }
+        return rc;
+}
+
+static int jffs2_check_acl(struct inode *inode, int mask)
+{
+        struct posix_acl *acl;
+        int rc;
+
+        acl = jffs2_get_acl(inode, ACL_TYPE_ACCESS);
+        if (IS_ERR(acl))
+                return PTR_ERR(acl);
+        if (acl) {
+                rc = posix_acl_permission(inode, acl, mask);
+                posix_acl_release(acl);
+                return rc;
+        }
+        return -EAGAIN;
+}
+
+int jffs2_permission(struct inode *inode, int mask, struct nameidata *nd)
+{
+        return generic_permission(inode, mask, jffs2_check_acl);
+}
+
+int jffs2_init_acl(struct inode *inode, struct inode *dir)
+{
+        struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
+        struct posix_acl *acl = NULL, *clone;
+        mode_t mode;
+        int rc = 0;
+
+        f->i_acl_access = JFFS2_ACL_NOT_CACHED;
+        f->i_acl_default = JFFS2_ACL_NOT_CACHED;
+        if (!S_ISLNK(inode->i_mode)) {
+                acl = jffs2_get_acl(dir, ACL_TYPE_DEFAULT);
+                if (IS_ERR(acl))
+                        return PTR_ERR(acl);
+                if (!acl)
+                        inode->i_mode &= ~current->fs->umask;
+        }
+        if (acl) {
+                if (S_ISDIR(inode->i_mode)) {
+                        rc = jffs2_set_acl(inode, ACL_TYPE_DEFAULT, acl);
+                        if (rc)
+                                goto cleanup;
+                }
+                clone = posix_acl_clone(acl, GFP_KERNEL);
+                rc = -ENOMEM;
+                if (!clone)
+                        goto cleanup;
+                mode = inode->i_mode;
+                rc = posix_acl_create_masq(clone, &mode);
+                if (rc >= 0) {
+                        inode->i_mode = mode;
+                        if (rc > 0)
+                                rc = jffs2_set_acl(inode, ACL_TYPE_ACCESS, clone);
+                }
+                posix_acl_release(clone);
+        }
+ cleanup:
+        posix_acl_release(acl);
+        return rc;
+}
+
+void jffs2_clear_acl(struct inode *inode)
+{
+        struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
+
+        if (f->i_acl_access && f->i_acl_access != JFFS2_ACL_NOT_CACHED) {
+                posix_acl_release(f->i_acl_access);
+                f->i_acl_access = JFFS2_ACL_NOT_CACHED;
+        }
+        if (f->i_acl_default && f->i_acl_default != JFFS2_ACL_NOT_CACHED) {
+                posix_acl_release(f->i_acl_default);
+                f->i_acl_default = JFFS2_ACL_NOT_CACHED;
+        }
+}
+
+int jffs2_acl_chmod(struct inode *inode)
+{
+        struct posix_acl *acl, *clone;
+        int rc;
+
+        if (S_ISLNK(inode->i_mode))
+                return -EOPNOTSUPP;
+        acl = jffs2_get_acl(inode, ACL_TYPE_ACCESS);
+        if (IS_ERR(acl) || !acl)
+                return PTR_ERR(acl);
+        clone = posix_acl_clone(acl, GFP_KERNEL);
+        posix_acl_release(acl);
+        if (!clone)
+                return -ENOMEM;
+        rc = posix_acl_chmod_masq(clone, inode->i_mode);
+        if (!rc)
+                rc = jffs2_set_acl(inode, ACL_TYPE_ACCESS, clone);
+        posix_acl_release(clone);
+        return rc;
+}
+
+static size_t jffs2_acl_access_listxattr(struct inode *inode, char *list, size_t list_size,
+                                         const char *name, size_t name_len)
+{
+        const int retlen = sizeof(POSIX_ACL_XATTR_ACCESS);
+
+        if (list && retlen <= list_size)
+                strcpy(list, POSIX_ACL_XATTR_ACCESS);
+        return retlen;
+}
+
+static size_t jffs2_acl_default_listxattr(struct inode *inode, char *list, size_t list_size,
+                                          const char *name, size_t name_len)
+{
+        const int retlen = sizeof(POSIX_ACL_XATTR_DEFAULT);
+
+        if (list && retlen <= list_size)
+                strcpy(list, POSIX_ACL_XATTR_DEFAULT);
+        return retlen;
+}
+
+static int jffs2_acl_getxattr(struct inode *inode, int type, void *buffer, size_t size)
+{
+        struct posix_acl *acl;
+        int rc;
+
+        acl = jffs2_get_acl(inode, type);
+        if (IS_ERR(acl))
+                return PTR_ERR(acl);
+        if (!acl)
+                return -ENODATA;
+        rc = posix_acl_to_xattr(acl, buffer, size);
+        posix_acl_release(acl);
+
+        return rc;
+}
+
+static int jffs2_acl_access_getxattr(struct inode *inode, const char *name, void *buffer, size_t size)
+{
+        if (name[0] != '\0')
+                return -EINVAL;
+        return jffs2_acl_getxattr(inode, ACL_TYPE_ACCESS, buffer, size);
+}
+
+static int jffs2_acl_default_getxattr(struct inode *inode, const char *name, void *buffer, size_t size)
+{
+        if (name[0] != '\0')
+                return -EINVAL;
+        return jffs2_acl_getxattr(inode, ACL_TYPE_DEFAULT, buffer, size);
+}
+
+static int jffs2_acl_setxattr(struct inode *inode, int type, const void *value, size_t size)
+{
+        struct posix_acl *acl;
+        int rc;
+
+        if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
+                return -EPERM;
+
+        if (value) {
+                acl = posix_acl_from_xattr(value, size);
+                if (IS_ERR(acl))
+                        return PTR_ERR(acl);
+                if (acl) {
+                        rc = posix_acl_valid(acl);
+                        if (rc)
+                                goto out;
+                }
+        } else {
+                acl = NULL;
+        }
+        rc = jffs2_set_acl(inode, type, acl);
+ out:
+        posix_acl_release(acl);
+        return rc;
+}
+
+static int jffs2_acl_access_setxattr(struct inode *inode, const char *name,
+                                     const void *buffer, size_t size, int flags)
+{
+        if (name[0] != '\0')
+                return -EINVAL;
+        return jffs2_acl_setxattr(inode, ACL_TYPE_ACCESS, buffer, size);
+}
+
+static int jffs2_acl_default_setxattr(struct inode *inode, const char *name,
+                                      const void *buffer, size_t size, int flags)
+{
+        if (name[0] != '\0')
+                return -EINVAL;
+        return jffs2_acl_setxattr(inode, ACL_TYPE_DEFAULT, buffer, size);
+}
+
+struct xattr_handler jffs2_acl_access_xattr_handler = {
+        .prefix = POSIX_ACL_XATTR_ACCESS,
+        .list   = jffs2_acl_access_listxattr,
+        .get    = jffs2_acl_access_getxattr,
+        .set    = jffs2_acl_access_setxattr,
+};
+
+struct xattr_handler jffs2_acl_default_xattr_handler = {
+        .prefix = POSIX_ACL_XATTR_DEFAULT,
+        .list   = jffs2_acl_default_listxattr,
+        .get    = jffs2_acl_default_getxattr,
+        .set    = jffs2_acl_default_setxattr,
+};
diff --git a/fs/jffs2/acl.h b/fs/jffs2/acl.h
new file mode 100644
index 000000000000..8893bd1a6ba7
--- /dev/null
+++ b/fs/jffs2/acl.h
@@ -0,0 +1,45 @@
+/*
+ * JFFS2 -- Journalling Flash File System, Version 2.
+ *
+ * Copyright (C) 2006  NEC Corporation
+ *
+ * Created by KaiGai Kohei <kaigai@ak.jp.nec.com>
+ *
+ * For licensing information, see the file 'LICENCE' in this directory.
+ *
+ */
+struct jffs2_acl_entry {
+        jint16_t        e_tag;
+        jint16_t        e_perm;
+        jint32_t        e_id;
+};
+
+struct jffs2_acl_entry_short {
+        jint16_t        e_tag;
+        jint16_t        e_perm;
+};
+
+struct jffs2_acl_header {
+        jint32_t        a_version;
+};
+
+#ifdef CONFIG_JFFS2_FS_POSIX_ACL
+
+#define JFFS2_ACL_NOT_CACHED ((void *)-1)
+
+extern int jffs2_permission(struct inode *, int, struct nameidata *);
+extern int jffs2_acl_chmod(struct inode *);
+extern int jffs2_init_acl(struct inode *, struct inode *);
+extern void jffs2_clear_acl(struct inode *);
+
+extern struct xattr_handler jffs2_acl_access_xattr_handler;
+extern struct xattr_handler jffs2_acl_default_xattr_handler;
+
+#else
+
+#define jffs2_permission NULL
+#define jffs2_acl_chmod(inode)          (0)
+#define jffs2_init_acl(inode,dir)       (0)
+#define jffs2_clear_acl(inode)
+
+#endif  /* CONFIG_JFFS2_FS_POSIX_ACL */
diff --git a/fs/jffs2/build.c b/fs/jffs2/build.c
index 70f7a896c04a..02826967ab58 100644
--- a/fs/jffs2/build.c
+++ b/fs/jffs2/build.c
@@ -160,6 +160,7 @@ static int jffs2_build_filesystem(struct jffs2_sb_info *c)
                 ic->scan_dents = NULL;
                 cond_resched();
         }
+        jffs2_build_xattr_subsystem(c);
         c->flags &= ~JFFS2_SB_FLAG_BUILDING;
 
         dbg_fsbuild("FS build complete\n");
@@ -178,6 +179,7 @@ exit:
                                 jffs2_free_full_dirent(fd);
                         }
                 }
+                jffs2_clear_xattr_subsystem(c);
         }
 
         return ret;
diff --git a/fs/jffs2/compr.c b/fs/jffs2/compr.c
index e7944e665b9f..7001ba26c067 100644
--- a/fs/jffs2/compr.c
+++ b/fs/jffs2/compr.c
@@ -412,7 +412,7 @@ void jffs2_free_comprbuf(unsigned char *comprbuf, unsigned char *orig)
                 kfree(comprbuf);
 }
 
-int jffs2_compressors_init(void)
+int __init jffs2_compressors_init(void)
 {
 /* Registering compressors */
 #ifdef CONFIG_JFFS2_ZLIB
diff --git a/fs/jffs2/compr.h b/fs/jffs2/compr.h
index a77e830d85c5..509b8b1c0811 100644
--- a/fs/jffs2/compr.h
+++ b/fs/jffs2/compr.h
@@ -23,8 +23,8 @@
 #include <linux/errno.h>
 #include <linux/fs.h>
 #include <linux/jffs2.h>
-#include <linux/jffs2_fs_i.h>
-#include <linux/jffs2_fs_sb.h>
+#include "jffs2_fs_i.h"
+#include "jffs2_fs_sb.h"
 #include "nodelist.h"
 
 #define JFFS2_RUBINMIPS_PRIORITY 10
diff --git a/fs/jffs2/debug.c b/fs/jffs2/debug.c
index 1fe17de713e8..72b4fc13a106 100644
--- a/fs/jffs2/debug.c
+++ b/fs/jffs2/debug.c
@@ -192,13 +192,13 @@ __jffs2_dbg_acct_paranoia_check_nolock(struct jffs2_sb_info *c,
                 else
                         my_dirty_size += totlen;
 
-                if ((!ref2->next_phys) != (ref2 == jeb->last_node)) {
-                        JFFS2_ERROR("node_ref for node at %#08x (mem %p) has next_phys at %#08x (mem %p), last_node is at %#08x (mem %p).\n",
-                                ref_offset(ref2), ref2, ref_offset(ref2->next_phys), ref2->next_phys,
-                                ref_offset(jeb->last_node), jeb->last_node);
+                if ((!ref_next(ref2)) != (ref2 == jeb->last_node)) {
+                        JFFS2_ERROR("node_ref for node at %#08x (mem %p) has next at %#08x (mem %p), last_node is at %#08x (mem %p).\n",
+                                    ref_offset(ref2), ref2, ref_offset(ref_next(ref2)), ref_next(ref2),
+                                    ref_offset(jeb->last_node), jeb->last_node);
                         goto error;
                 }
-                ref2 = ref2->next_phys;
+                ref2 = ref_next(ref2);
         }
 
         if (my_used_size != jeb->used_size) {
@@ -268,9 +268,9 @@ __jffs2_dbg_dump_node_refs_nolock(struct jffs2_sb_info *c,
         }
 
         printk(JFFS2_DBG);
-        for (ref = jeb->first_node; ; ref = ref->next_phys) {
+        for (ref = jeb->first_node; ; ref = ref_next(ref)) {
                 printk("%#08x(%#x)", ref_offset(ref), ref->__totlen);
-                if (ref->next_phys)
+                if (ref_next(ref))
                         printk("->");
                 else
                         break;
diff --git a/fs/jffs2/debug.h b/fs/jffs2/debug.h
index 162af6dfe292..5fa494a792b2 100644
--- a/fs/jffs2/debug.h
+++ b/fs/jffs2/debug.h
@@ -171,6 +171,12 @@
 #define dbg_memalloc(fmt, ...)
 #endif
 
+/* Watch the XATTR subsystem */
+#ifdef JFFS2_DBG_XATTR_MESSAGES
+#define dbg_xattr(fmt, ...)  JFFS2_DEBUG(fmt, ##__VA_ARGS__)
+#else
+#define dbg_xattr(fmt, ...)
+#endif 
 
 /* "Sanity" checks */
 void
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index 8bc7a5018e40..edd8371fc6a5 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -17,8 +17,8 @@
 #include <linux/fs.h>
 #include <linux/crc32.h>
 #include <linux/jffs2.h>
-#include <linux/jffs2_fs_i.h>
-#include <linux/jffs2_fs_sb.h>
+#include "jffs2_fs_i.h"
+#include "jffs2_fs_sb.h"
 #include <linux/time.h>
 #include "nodelist.h"
 
@@ -57,7 +57,12 @@ struct inode_operations jffs2_dir_inode_operations =
         .rmdir =        jffs2_rmdir,
         .mknod =        jffs2_mknod,
         .rename =       jffs2_rename,
+        .permission =   jffs2_permission,
         .setattr =      jffs2_setattr,
+        .setxattr =     jffs2_setxattr,
+        .getxattr =     jffs2_getxattr,
+        .listxattr =    jffs2_listxattr,
+        .removexattr =  jffs2_removexattr
 };
 
 /***********************************************************************/
@@ -78,6 +83,9 @@ static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target,
 
         D1(printk(KERN_DEBUG "jffs2_lookup()\n"));
 
+        if (target->d_name.len > JFFS2_MAX_NAME_LEN)
+                return ERR_PTR(-ENAMETOOLONG);
+
         dir_f = JFFS2_INODE_INFO(dir_i);
         c = JFFS2_SB_INFO(dir_i->i_sb);
 
@@ -206,12 +214,15 @@ static int jffs2_create(struct inode *dir_i, struct dentry *dentry, int mode,
         ret = jffs2_do_create(c, dir_f, f, ri,
                               dentry->d_name.name, dentry->d_name.len);
 
-        if (ret) {
-                make_bad_inode(inode);
-                iput(inode);
-                jffs2_free_raw_inode(ri);
-                return ret;
-        }
+        if (ret)
+                goto fail;
+
+        ret = jffs2_init_security(inode, dir_i);
+        if (ret)
+                goto fail;
+        ret = jffs2_init_acl(inode, dir_i);
+        if (ret)
+                goto fail;
 
         dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(ri->ctime));
 
@@ -221,6 +232,12 @@ static int jffs2_create(struct inode *dir_i, struct dentry *dentry, int mode,
         D1(printk(KERN_DEBUG "jffs2_create: Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n",
                   inode->i_ino, inode->i_mode, inode->i_nlink, f->inocache->nlink, inode->i_mapping->nrpages));
         return 0;
+
+ fail:
+        make_bad_inode(inode);
+        iput(inode);
+        jffs2_free_raw_inode(ri);
+        return ret;
 }
 
 /***********************************************************************/
@@ -291,7 +308,7 @@ static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char
         struct jffs2_full_dnode *fn;
         struct jffs2_full_dirent *fd;
         int namelen;
-        uint32_t alloclen, phys_ofs;
+        uint32_t alloclen;
         int ret, targetlen = strlen(target);
 
         /* FIXME: If you care. We'd need to use frags for the target
@@ -310,8 +327,8 @@ static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char
          * Just the node will do for now, though
          */
         namelen = dentry->d_name.len;
-        ret = jffs2_reserve_space(c, sizeof(*ri) + targetlen, &phys_ofs, &alloclen,
-                                ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
+        ret = jffs2_reserve_space(c, sizeof(*ri) + targetlen, &alloclen,
+                                  ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
 
         if (ret) {
                 jffs2_free_raw_inode(ri);
@@ -339,7 +356,7 @@ static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char
         ri->data_crc = cpu_to_je32(crc32(0, target, targetlen));
         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 
-        fn = jffs2_write_dnode(c, f, ri, target, targetlen, phys_ofs, ALLOC_NORMAL);
+        fn = jffs2_write_dnode(c, f, ri, target, targetlen, ALLOC_NORMAL);
 
         jffs2_free_raw_inode(ri);
 
@@ -371,8 +388,20 @@ static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char
         up(&f->sem);
 
         jffs2_complete_reservation(c);
-        ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen,
-                                ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
+
+        ret = jffs2_init_security(inode, dir_i);
+        if (ret) {
+                jffs2_clear_inode(inode);
+                return ret;
+        }
+        ret = jffs2_init_acl(inode, dir_i);
+        if (ret) {
+                jffs2_clear_inode(inode);
+                return ret;
+        }
+
+        ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
+                                  ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
         if (ret) {
                 /* Eep. */
                 jffs2_clear_inode(inode);
@@ -404,7 +433,7 @@ static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char
         rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
         rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
 
-        fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, phys_ofs, ALLOC_NORMAL);
+        fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
 
         if (IS_ERR(fd)) {
                 /* dirent failed to write. Delete the inode normally
@@ -442,7 +471,7 @@ static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, int mode)
         struct jffs2_full_dnode *fn;
         struct jffs2_full_dirent *fd;
         int namelen;
-        uint32_t alloclen, phys_ofs;
+        uint32_t alloclen;
         int ret;
 
         mode |= S_IFDIR;
@@ -457,8 +486,8 @@ static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, int mode)
          * Just the node will do for now, though
          */
         namelen = dentry->d_name.len;
-        ret = jffs2_reserve_space(c, sizeof(*ri), &phys_ofs, &alloclen, ALLOC_NORMAL,
-                                JFFS2_SUMMARY_INODE_SIZE);
+        ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
+                                  JFFS2_SUMMARY_INODE_SIZE);
 
         if (ret) {
                 jffs2_free_raw_inode(ri);
@@ -483,7 +512,7 @@ static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, int mode)
         ri->data_crc = cpu_to_je32(0);
         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 
-        fn = jffs2_write_dnode(c, f, ri, NULL, 0, phys_ofs, ALLOC_NORMAL);
+        fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
 
         jffs2_free_raw_inode(ri);
 
@@ -501,8 +530,20 @@ static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, int mode)
         up(&f->sem);
 
         jffs2_complete_reservation(c);
-        ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen,
-                                ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
+
+        ret = jffs2_init_security(inode, dir_i);
+        if (ret) {
+                jffs2_clear_inode(inode);
+                return ret;
+        }
+        ret = jffs2_init_acl(inode, dir_i);
+        if (ret) {
+                jffs2_clear_inode(inode);
+                return ret;
+        }
+
+        ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
+                                  ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
         if (ret) {
                 /* Eep. */
                 jffs2_clear_inode(inode);
@@ -534,7 +575,7 @@ static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, int mode)
         rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
         rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
 
-        fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, phys_ofs, ALLOC_NORMAL);
+        fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
 
         if (IS_ERR(fd)) {
                 /* dirent failed to write. Delete the inode normally
@@ -588,12 +629,12 @@ static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, int mode, de
         struct jffs2_full_dnode *fn;
         struct jffs2_full_dirent *fd;
         int namelen;
-        jint16_t dev;
+        union jffs2_device_node dev;
         int devlen = 0;
-        uint32_t alloclen, phys_ofs;
+        uint32_t alloclen;
         int ret;
 
-        if (!old_valid_dev(rdev))
+        if (!new_valid_dev(rdev))
                 return -EINVAL;
 
         ri = jffs2_alloc_raw_inode();
@@ -602,17 +643,15 @@ static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, int mode, de
 
         c = JFFS2_SB_INFO(dir_i->i_sb);
 
-        if (S_ISBLK(mode) || S_ISCHR(mode)) {
-                dev = cpu_to_je16(old_encode_dev(rdev));
-                devlen = sizeof(dev);
-        }
+        if (S_ISBLK(mode) || S_ISCHR(mode))
+                devlen = jffs2_encode_dev(&dev, rdev);
 
         /* Try to reserve enough space for both node and dirent.
          * Just the node will do for now, though
          */
         namelen = dentry->d_name.len;
-        ret = jffs2_reserve_space(c, sizeof(*ri) + devlen, &phys_ofs, &alloclen,
-                                ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
+        ret = jffs2_reserve_space(c, sizeof(*ri) + devlen, &alloclen,
+                                  ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
 
         if (ret) {
                 jffs2_free_raw_inode(ri);
@@ -639,7 +678,7 @@ static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, int mode, de
         ri->data_crc = cpu_to_je32(crc32(0, &dev, devlen));
         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 
-        fn = jffs2_write_dnode(c, f, ri, (char *)&dev, devlen, phys_ofs, ALLOC_NORMAL);
+        fn = jffs2_write_dnode(c, f, ri, (char *)&dev, devlen, ALLOC_NORMAL);
 
         jffs2_free_raw_inode(ri);
 
@@ -657,8 +696,20 @@ static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, int mode, de
         up(&f->sem);
 
         jffs2_complete_reservation(c);
-        ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen,
-                                ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
+
+        ret = jffs2_init_security(inode, dir_i);
+        if (ret) {
+                jffs2_clear_inode(inode);
+                return ret;
+        }
+        ret = jffs2_init_acl(inode, dir_i);
+        if (ret) {
+                jffs2_clear_inode(inode);
+                return ret;
+        }
+
+        ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
+                                  ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
         if (ret) {
                 /* Eep. */
                 jffs2_clear_inode(inode);
@@ -693,7 +744,7 @@ static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, int mode, de
         rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
         rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
 
-        fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, phys_ofs, ALLOC_NORMAL);
+        fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
 
         if (IS_ERR(fd)) {
                 /* dirent failed to write. Delete the inode normally
diff --git a/fs/jffs2/erase.c b/fs/jffs2/erase.c
index dad68fdffe9e..1862e8bc101d 100644
--- a/fs/jffs2/erase.c
+++ b/fs/jffs2/erase.c
@@ -30,7 +30,6 @@ static void jffs2_erase_callback(struct erase_info *);
 #endif
 static void jffs2_erase_failed(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset);
 static void jffs2_erase_succeeded(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
-static void jffs2_free_all_node_refs(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
 static void jffs2_mark_erased_block(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
 
 static void jffs2_erase_block(struct jffs2_sb_info *c,
@@ -136,7 +135,7 @@ void jffs2_erase_pending_blocks(struct jffs2_sb_info *c, int count)
                         c->used_size -= jeb->used_size;
                         c->dirty_size -= jeb->dirty_size;
                         jeb->wasted_size = jeb->used_size = jeb->dirty_size = jeb->free_size = 0;
-                        jffs2_free_all_node_refs(c, jeb);
+                        jffs2_free_jeb_node_refs(c, jeb);
                         list_add(&jeb->list, &c->erasing_list);
                         spin_unlock(&c->erase_completion_lock);
 
@@ -231,6 +230,7 @@ static inline void jffs2_remove_node_refs_from_ino_list(struct jffs2_sb_info *c,
                            at the end of the linked list. Stash it and continue
                            from the beginning of the list */
                         ic = (struct jffs2_inode_cache *)(*prev);
+                        BUG_ON(ic->class != RAWNODE_CLASS_INODE_CACHE);
                         prev = &ic->nodes;
                         continue;
                 }
@@ -283,22 +283,27 @@ static inline void jffs2_remove_node_refs_from_ino_list(struct jffs2_sb_info *c,
                 jffs2_del_ino_cache(c, ic);
 }
 
-static void jffs2_free_all_node_refs(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
+void jffs2_free_jeb_node_refs(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
 {
-        struct jffs2_raw_node_ref *ref;
+        struct jffs2_raw_node_ref *block, *ref;
         D1(printk(KERN_DEBUG "Freeing all node refs for eraseblock offset 0x%08x\n", jeb->offset));
-        while(jeb->first_node) {
-                ref = jeb->first_node;
-                jeb->first_node = ref->next_phys;
 
-                /* Remove from the inode-list */
-                if (ref->next_in_ino)
+        block = ref = jeb->first_node;
+
+        while (ref) {
+                if (ref->flash_offset == REF_LINK_NODE) {
+                        ref = ref->next_in_ino;
+                        jffs2_free_refblock(block);
+                        block = ref;
+                        continue;
+                }
+                if (ref->flash_offset != REF_EMPTY_NODE && ref->next_in_ino)
                         jffs2_remove_node_refs_from_ino_list(c, ref, jeb);
                 /* else it was a non-inode node or already removed, so don't bother */
 
-                jffs2_free_raw_node_ref(ref);
+                ref++;
         }
-        jeb->last_node = NULL;
+        jeb->first_node = jeb->last_node = NULL;
 }
 
 static int jffs2_block_check_erase(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t *bad_offset)
@@ -351,7 +356,6 @@ fail:
 
 static void jffs2_mark_erased_block(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
 {
-        struct jffs2_raw_node_ref *marker_ref = NULL;
         size_t retlen;
         int ret;
         uint32_t bad_offset;
@@ -373,12 +377,8 @@ static void jffs2_mark_erased_block(struct jffs2_sb_info *c, struct jffs2_eraseb
                                 goto filebad;
                 }
 
-                jeb->first_node = jeb->last_node = NULL;
+                /* Everything else got zeroed before the erase */
                 jeb->free_size = c->sector_size;
-                jeb->used_size = 0;
-                jeb->dirty_size = 0;
-                jeb->wasted_size = 0;
-
         } else {
 
                 struct kvec vecs[1];
@@ -388,11 +388,7 @@ static void jffs2_mark_erased_block(struct jffs2_sb_info *c, struct jffs2_eraseb
                         .totlen =       cpu_to_je32(c->cleanmarker_size)
                 };
 
-                marker_ref = jffs2_alloc_raw_node_ref();
-                if (!marker_ref) {
-                        printk(KERN_WARNING "Failed to allocate raw node ref for clean marker. Refiling\n");
-                        goto refile;
-                }
+                jffs2_prealloc_raw_node_refs(c, jeb, 1);
 
                 marker.hdr_crc = cpu_to_je32(crc32(0, &marker, sizeof(struct jffs2_unknown_node)-4));
 
@@ -408,21 +404,13 @@ static void jffs2_mark_erased_block(struct jffs2_sb_info *c, struct jffs2_eraseb
                                 printk(KERN_WARNING "Short write to newly-erased block at 0x%08x: Wanted %zd, got %zd\n",
                                        jeb->offset, sizeof(marker), retlen);
 
-                        jffs2_free_raw_node_ref(marker_ref);
                         goto filebad;
                 }
 
-                marker_ref->next_in_ino = NULL;
-                marker_ref->next_phys = NULL;
-                marker_ref->flash_offset = jeb->offset | REF_NORMAL;
-                marker_ref->__totlen = c->cleanmarker_size;
-
-                jeb->first_node = jeb->last_node = marker_ref;
-
-                jeb->free_size = c->sector_size - c->cleanmarker_size;
-                jeb->used_size = c->cleanmarker_size;
-                jeb->dirty_size = 0;
-                jeb->wasted_size = 0;
+                /* Everything else got zeroed before the erase */
+                jeb->free_size = c->sector_size;
+                /* FIXME Special case for cleanmarker in empty block */
+                jffs2_link_node_ref(c, jeb, jeb->offset | REF_NORMAL, c->cleanmarker_size, NULL);
         }
 
         spin_lock(&c->erase_completion_lock);
diff --git a/fs/jffs2/file.c b/fs/jffs2/file.c
index 9f4171213e58..bb8844f40e48 100644
--- a/fs/jffs2/file.c
+++ b/fs/jffs2/file.c
@@ -54,7 +54,12 @@ const struct file_operations jffs2_file_operations =
 
 struct inode_operations jffs2_file_inode_operations =
 {
-        .setattr =      jffs2_setattr
+        .permission =   jffs2_permission,
+        .setattr =      jffs2_setattr,
+        .setxattr =     jffs2_setxattr,
+        .getxattr =     jffs2_getxattr,
+        .listxattr =    jffs2_listxattr,
+        .removexattr =  jffs2_removexattr
 };
 
 struct address_space_operations jffs2_file_address_operations =
@@ -129,13 +134,13 @@ static int jffs2_prepare_write (struct file *filp, struct page *pg,
                 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
                 struct jffs2_raw_inode ri;
                 struct jffs2_full_dnode *fn;
-                uint32_t phys_ofs, alloc_len;
+                uint32_t alloc_len;
 
                 D1(printk(KERN_DEBUG "Writing new hole frag 0x%x-0x%x between current EOF and new page\n",
                           (unsigned int)inode->i_size, pageofs));
 
-                ret = jffs2_reserve_space(c, sizeof(ri), &phys_ofs, &alloc_len,
-                                        ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
+                ret = jffs2_reserve_space(c, sizeof(ri), &alloc_len,
+                                          ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
                 if (ret)
                         return ret;
 
@@ -161,7 +166,7 @@ static int jffs2_prepare_write (struct file *filp, struct page *pg,
                 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
                 ri.data_crc = cpu_to_je32(0);
 
-                fn = jffs2_write_dnode(c, f, &ri, NULL, 0, phys_ofs, ALLOC_NORMAL);
+                fn = jffs2_write_dnode(c, f, &ri, NULL, 0, ALLOC_NORMAL);
 
                 if (IS_ERR(fn)) {
                         ret = PTR_ERR(fn);
@@ -215,12 +220,20 @@ static int jffs2_commit_write (struct file *filp, struct page *pg,
         D1(printk(KERN_DEBUG "jffs2_commit_write(): ino #%lu, page at 0x%lx, range %d-%d, flags %lx\n",
                   inode->i_ino, pg->index << PAGE_CACHE_SHIFT, start, end, pg->flags));
 
-        if (!start && end == PAGE_CACHE_SIZE) {
-                /* We need to avoid deadlock with page_cache_read() in
-                   jffs2_garbage_collect_pass(). So we have to mark the
-                   page up to date, to prevent page_cache_read() from
-                   trying to re-lock it. */
-                SetPageUptodate(pg);
+        if (end == PAGE_CACHE_SIZE) {
+                if (!start) {
+                        /* We need to avoid deadlock with page_cache_read() in
+                           jffs2_garbage_collect_pass(). So we have to mark the
+                           page up to date, to prevent page_cache_read() from
+                           trying to re-lock it. */
+                        SetPageUptodate(pg);
+                } else {
+                        /* When writing out the end of a page, write out the 
+                           _whole_ page. This helps to reduce the number of
+                           nodes in files which have many short writes, like
+                           syslog files. */
+                        start = aligned_start = 0;
+                }
         }
 
         ri = jffs2_alloc_raw_inode();
diff --git a/fs/jffs2/fs.c b/fs/jffs2/fs.c
index 09e5d10b8840..7b6c24b14f85 100644
--- a/fs/jffs2/fs.c
+++ b/fs/jffs2/fs.c
@@ -33,11 +33,11 @@ static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
         struct jffs2_raw_inode *ri;
-        unsigned short dev;
+        union jffs2_device_node dev;
         unsigned char *mdata = NULL;
         int mdatalen = 0;
         unsigned int ivalid;
-        uint32_t phys_ofs, alloclen;
+        uint32_t alloclen;
         int ret;
         D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
         ret = inode_change_ok(inode, iattr);
@@ -51,20 +51,24 @@ static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
            it out again with the appropriate data attached */
         if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
                 /* For these, we don't actually need to read the old node */
-                dev = old_encode_dev(inode->i_rdev);
+                mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
                 mdata = (char *)&dev;
-                mdatalen = sizeof(dev);
                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
         } else if (S_ISLNK(inode->i_mode)) {
+                down(&f->sem);
                 mdatalen = f->metadata->size;
                 mdata = kmalloc(f->metadata->size, GFP_USER);
-                if (!mdata)
+                if (!mdata) {
+                        up(&f->sem);
                         return -ENOMEM;
+                }
                 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
                 if (ret) {
+                        up(&f->sem);
                         kfree(mdata);
                         return ret;
                 }
+                up(&f->sem);
                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
         }
 
@@ -75,8 +79,8 @@ static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
                 return -ENOMEM;
         }
 
-        ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &phys_ofs, &alloclen,
-                                ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
+        ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
+                                  ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
         if (ret) {
                 jffs2_free_raw_inode(ri);
                 if (S_ISLNK(inode->i_mode & S_IFMT))
@@ -127,7 +131,7 @@ static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
         else
                 ri->data_crc = cpu_to_je32(0);
 
-        new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, phys_ofs, ALLOC_NORMAL);
+        new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, ALLOC_NORMAL);
         if (S_ISLNK(inode->i_mode))
                 kfree(mdata);
 
@@ -180,7 +184,12 @@ static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
 
 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-        return jffs2_do_setattr(dentry->d_inode, iattr);
+        int rc;
+
+        rc = jffs2_do_setattr(dentry->d_inode, iattr);
+        if (!rc && (iattr->ia_valid & ATTR_MODE))
+                rc = jffs2_acl_chmod(dentry->d_inode);
+        return rc;
 }
 
 int jffs2_statfs(struct super_block *sb, struct kstatfs *buf)
@@ -219,6 +228,7 @@ void jffs2_clear_inode (struct inode *inode)
 
         D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
 
+        jffs2_xattr_delete_inode(c, f->inocache);
         jffs2_do_clear_inode(c, f);
 }
 
@@ -227,6 +237,8 @@ void jffs2_read_inode (struct inode *inode)
         struct jffs2_inode_info *f;
         struct jffs2_sb_info *c;
         struct jffs2_raw_inode latest_node;
+        union jffs2_device_node jdev;
+        dev_t rdev = 0;
         int ret;
 
         D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
@@ -258,7 +270,6 @@ void jffs2_read_inode (struct inode *inode)
         inode->i_blocks = (inode->i_size + 511) >> 9;
 
         switch (inode->i_mode & S_IFMT) {
-                jint16_t rdev;
 
         case S_IFLNK:
                 inode->i_op = &jffs2_symlink_inode_operations;
@@ -292,8 +303,16 @@ void jffs2_read_inode (struct inode *inode)
         case S_IFBLK:
         case S_IFCHR:
                 /* Read the device numbers from the media */
+                if (f->metadata->size != sizeof(jdev.old) &&
+                    f->metadata->size != sizeof(jdev.new)) {
+                        printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
+                        up(&f->sem);
+                        jffs2_do_clear_inode(c, f);
+                        make_bad_inode(inode);
+                        return;
+                }
                 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
-                if (jffs2_read_dnode(c, f, f->metadata, (char *)&rdev, 0, sizeof(rdev)) < 0) {
+                if (jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size) < 0) {
                         /* Eep */
                         printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
                         up(&f->sem);
@@ -301,12 +320,15 @@ void jffs2_read_inode (struct inode *inode)
                         make_bad_inode(inode);
                         return;
                 }
+                if (f->metadata->size == sizeof(jdev.old))
+                        rdev = old_decode_dev(je16_to_cpu(jdev.old));
+                else
+                        rdev = new_decode_dev(je32_to_cpu(jdev.new));
 
         case S_IFSOCK:
         case S_IFIFO:
                 inode->i_op = &jffs2_file_inode_operations;
-                init_special_inode(inode, inode->i_mode,
-                                   old_decode_dev((je16_to_cpu(rdev))));
+                init_special_inode(inode, inode->i_mode, rdev);
                 break;
 
         default:
@@ -492,6 +514,8 @@ int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
         }
         memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
 
+        jffs2_init_xattr_subsystem(c);
+
         if ((ret = jffs2_do_mount_fs(c)))
                 goto out_inohash;
 
@@ -526,6 +550,7 @@ int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
         else
                 kfree(c->blocks);
  out_inohash:
+        jffs2_clear_xattr_subsystem(c);
         kfree(c->inocache_list);
  out_wbuf:
         jffs2_flash_cleanup(c);
@@ -639,13 +664,6 @@ static int jffs2_flash_setup(struct jffs2_sb_info *c) {
                         return ret;
         }
 
-        /* add setups for other bizarre flashes here... */
-        if (jffs2_nor_ecc(c)) {
-                ret = jffs2_nor_ecc_flash_setup(c);
-                if (ret)
-                        return ret;
-        }
-
         /* and Dataflash */
         if (jffs2_dataflash(c)) {
                 ret = jffs2_dataflash_setup(c);
@@ -669,11 +687,6 @@ void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
                 jffs2_nand_flash_cleanup(c);
         }
 
-        /* add cleanups for other bizarre flashes here... */
-        if (jffs2_nor_ecc(c)) {
-                jffs2_nor_ecc_flash_cleanup(c);
-        }
-
         /* and DataFlash */
         if (jffs2_dataflash(c)) {
                 jffs2_dataflash_cleanup(c);
diff --git a/fs/jffs2/gc.c b/fs/jffs2/gc.c
index f9ffece453a3..477c526d638b 100644
--- a/fs/jffs2/gc.c
+++ b/fs/jffs2/gc.c
@@ -125,6 +125,7 @@ int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
         struct jffs2_eraseblock *jeb;
         struct jffs2_raw_node_ref *raw;
         int ret = 0, inum, nlink;
+        int xattr = 0;
 
         if (down_interruptible(&c->alloc_sem))
                 return -EINTR;
@@ -138,7 +139,7 @@ int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
                    the node CRCs etc. Do it now. */
 
                 /* checked_ino is protected by the alloc_sem */
-                if (c->checked_ino > c->highest_ino) {
+                if (c->checked_ino > c->highest_ino && xattr) {
                         printk(KERN_CRIT "Checked all inodes but still 0x%x bytes of unchecked space?\n",
                                c->unchecked_size);
                         jffs2_dbg_dump_block_lists_nolock(c);
@@ -148,6 +149,9 @@ int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
 
                 spin_unlock(&c->erase_completion_lock);
 
+                if (!xattr)
+                        xattr = jffs2_verify_xattr(c);
+
                 spin_lock(&c->inocache_lock);
 
                 ic = jffs2_get_ino_cache(c, c->checked_ino++);
@@ -181,6 +185,10 @@ int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
                            and trigger the BUG() above while we haven't yet
                            finished checking all its nodes */
                         D1(printk(KERN_DEBUG "Waiting for ino #%u to finish reading\n", ic->ino));
+                        /* We need to come back again for the _same_ inode. We've
+                         made no progress in this case, but that should be OK */
+                        c->checked_ino--;
+
                         up(&c->alloc_sem);
                         sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
                         return 0;
@@ -231,7 +239,7 @@ int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
 
         while(ref_obsolete(raw)) {
                 D1(printk(KERN_DEBUG "Node at 0x%08x is obsolete... skipping\n", ref_offset(raw)));
-                raw = raw->next_phys;
+                raw = ref_next(raw);
                 if (unlikely(!raw)) {
                         printk(KERN_WARNING "eep. End of raw list while still supposedly nodes to GC\n");
                         printk(KERN_WARNING "erase block at 0x%08x. free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x\n",
@@ -248,16 +256,37 @@ int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
 
         if (!raw->next_in_ino) {
                 /* Inode-less node. Clean marker, snapshot or something like that */
-                /* FIXME: If it's something that needs to be copied, including something
-                   we don't grok that has JFFS2_NODETYPE_RWCOMPAT_COPY, we should do so */
                 spin_unlock(&c->erase_completion_lock);
-                jffs2_mark_node_obsolete(c, raw);
+                if (ref_flags(raw) == REF_PRISTINE) {
+                        /* It's an unknown node with JFFS2_FEATURE_RWCOMPAT_COPY */
+                        jffs2_garbage_collect_pristine(c, NULL, raw);
+                } else {
+                        /* Just mark it obsolete */
+                        jffs2_mark_node_obsolete(c, raw);
+                }
                 up(&c->alloc_sem);
                 goto eraseit_lock;
         }
 
         ic = jffs2_raw_ref_to_ic(raw);
 
+#ifdef CONFIG_JFFS2_FS_XATTR
+        /* When 'ic' refers xattr_datum/xattr_ref, this node is GCed as xattr.
+         * We can decide whether this node is inode or xattr by ic->class.     */
+        if (ic->class == RAWNODE_CLASS_XATTR_DATUM
+            || ic->class == RAWNODE_CLASS_XATTR_REF) {
+                BUG_ON(raw->next_in_ino != (void *)ic);
+                spin_unlock(&c->erase_completion_lock);
+
+                if (ic->class == RAWNODE_CLASS_XATTR_DATUM) {
+                        ret = jffs2_garbage_collect_xattr_datum(c, (struct jffs2_xattr_datum *)ic);
+                } else {
+                        ret = jffs2_garbage_collect_xattr_ref(c, (struct jffs2_xattr_ref *)ic);
+                }
+                goto release_sem;
+        }
+#endif
+
         /* We need to hold the inocache. Either the erase_completion_lock or
            the inocache_lock are sufficient; we trade down since the inocache_lock
            causes less contention. */
@@ -499,7 +528,6 @@ static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
                                           struct jffs2_raw_node_ref *raw)
 {
         union jffs2_node_union *node;
-        struct jffs2_raw_node_ref *nraw;
         size_t retlen;
         int ret;
         uint32_t phys_ofs, alloclen;
@@ -508,15 +536,16 @@ static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
 
         D1(printk(KERN_DEBUG "Going to GC REF_PRISTINE node at 0x%08x\n", ref_offset(raw)));
 
-        rawlen = ref_totlen(c, c->gcblock, raw);
+        alloclen = rawlen = ref_totlen(c, c->gcblock, raw);
 
         /* Ask for a small amount of space (or the totlen if smaller) because we
            don't want to force wastage of the end of a block if splitting would
            work. */
-        ret = jffs2_reserve_space_gc(c, min_t(uint32_t, sizeof(struct jffs2_raw_inode) +
-                                JFFS2_MIN_DATA_LEN, rawlen), &phys_ofs, &alloclen, rawlen);
-                                /* this is not the exact summary size of it,
-                                        it is only an upper estimation */
+        if (ic && alloclen > sizeof(struct jffs2_raw_inode) + JFFS2_MIN_DATA_LEN)
+                alloclen = sizeof(struct jffs2_raw_inode) + JFFS2_MIN_DATA_LEN;
+
+        ret = jffs2_reserve_space_gc(c, alloclen, &alloclen, rawlen);
+        /* 'rawlen' is not the exact summary size; it is only an upper estimation */
 
         if (ret)
                 return ret;
@@ -580,22 +609,17 @@ static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
                 }
                 break;
         default:
-                printk(KERN_WARNING "Unknown node type for REF_PRISTINE node at 0x%08x: 0x%04x\n",
-                       ref_offset(raw), je16_to_cpu(node->u.nodetype));
-                goto bail;
-        }
-
-        nraw = jffs2_alloc_raw_node_ref();
-        if (!nraw) {
-                ret = -ENOMEM;
-                goto out_node;
+                /* If it's inode-less, we don't _know_ what it is. Just copy it intact */
+                if (ic) {
+                        printk(KERN_WARNING "Unknown node type for REF_PRISTINE node at 0x%08x: 0x%04x\n",
+                               ref_offset(raw), je16_to_cpu(node->u.nodetype));
+                        goto bail;
+                }
         }
 
         /* OK, all the CRCs are good; this node can just be copied as-is. */
  retry:
-        nraw->flash_offset = phys_ofs;
-        nraw->__totlen = rawlen;
-        nraw->next_phys = NULL;
+        phys_ofs = write_ofs(c);
 
         ret = jffs2_flash_write(c, phys_ofs, rawlen, &retlen, (char *)node);
 
@@ -603,17 +627,11 @@ static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
                 printk(KERN_NOTICE "Write of %d bytes at 0x%08x failed. returned %d, retlen %zd\n",
                        rawlen, phys_ofs, ret, retlen);
                 if (retlen) {
-                        /* Doesn't belong to any inode */
-                        nraw->next_in_ino = NULL;
-
-                        nraw->flash_offset |= REF_OBSOLETE;
-                        jffs2_add_physical_node_ref(c, nraw);
-                        jffs2_mark_node_obsolete(c, nraw);
+                        jffs2_add_physical_node_ref(c, phys_ofs | REF_OBSOLETE, rawlen, NULL);
                 } else {
-                        printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", nraw->flash_offset);
-                        jffs2_free_raw_node_ref(nraw);
+                        printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", phys_ofs);
                 }
-                if (!retried && (nraw = jffs2_alloc_raw_node_ref())) {
+                if (!retried) {
                         /* Try to reallocate space and retry */
                         uint32_t dummy;
                         struct jffs2_eraseblock *jeb = &c->blocks[phys_ofs / c->sector_size];
@@ -625,7 +643,7 @@ static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
                         jffs2_dbg_acct_sanity_check(c,jeb);
                         jffs2_dbg_acct_paranoia_check(c, jeb);
 
-                        ret = jffs2_reserve_space_gc(c, rawlen, &phys_ofs, &dummy, rawlen);
+                        ret = jffs2_reserve_space_gc(c, rawlen, &dummy, rawlen);
                                                 /* this is not the exact summary size of it,
                                                         it is only an upper estimation */
 
@@ -638,25 +656,13 @@ static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
                                 goto retry;
                         }
                         D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
-                        jffs2_free_raw_node_ref(nraw);
                 }
 
-                jffs2_free_raw_node_ref(nraw);
                 if (!ret)
                         ret = -EIO;
                 goto out_node;
         }
-        nraw->flash_offset |= REF_PRISTINE;
-        jffs2_add_physical_node_ref(c, nraw);
-
-        /* Link into per-inode list. This is safe because of the ic
-           state being INO_STATE_GC. Note that if we're doing this
-           for an inode which is in-core, the 'nraw' pointer is then
-           going to be fetched from ic->nodes by our caller. */
-        spin_lock(&c->erase_completion_lock);
-        nraw->next_in_ino = ic->nodes;
-        ic->nodes = nraw;
-        spin_unlock(&c->erase_completion_lock);
+        jffs2_add_physical_node_ref(c, phys_ofs | REF_PRISTINE, rawlen, ic);
 
         jffs2_mark_node_obsolete(c, raw);
         D1(printk(KERN_DEBUG "WHEEE! GC REF_PRISTINE node at 0x%08x succeeded\n", ref_offset(raw)));
@@ -675,19 +681,16 @@ static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_
         struct jffs2_full_dnode *new_fn;
         struct jffs2_raw_inode ri;
         struct jffs2_node_frag *last_frag;
-        jint16_t dev;
+        union jffs2_device_node dev;
         char *mdata = NULL, mdatalen = 0;
-        uint32_t alloclen, phys_ofs, ilen;
+        uint32_t alloclen, ilen;
         int ret;
 
         if (S_ISBLK(JFFS2_F_I_MODE(f)) ||
             S_ISCHR(JFFS2_F_I_MODE(f)) ) {
                 /* For these, we don't actually need to read the old node */
-                /* FIXME: for minor or major > 255. */
-                dev = cpu_to_je16(((JFFS2_F_I_RDEV_MAJ(f) << 8) |
-                        JFFS2_F_I_RDEV_MIN(f)));
+                mdatalen = jffs2_encode_dev(&dev, JFFS2_F_I_RDEV(f));
                 mdata = (char *)&dev;
-                mdatalen = sizeof(dev);
                 D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bytes of kdev_t\n", mdatalen));
         } else if (S_ISLNK(JFFS2_F_I_MODE(f))) {
                 mdatalen = fn->size;
@@ -706,7 +709,7 @@ static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_
 
         }
 
-        ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &phys_ofs, &alloclen,
+        ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &alloclen,
                                 JFFS2_SUMMARY_INODE_SIZE);
         if (ret) {
                 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_metadata failed: %d\n",
@@ -744,7 +747,7 @@ static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_
         ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
         ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
 
-        new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, phys_ofs, ALLOC_GC);
+        new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, ALLOC_GC);
 
         if (IS_ERR(new_fn)) {
                 printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn));
@@ -765,7 +768,7 @@ static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_er
 {
         struct jffs2_full_dirent *new_fd;
         struct jffs2_raw_dirent rd;
-        uint32_t alloclen, phys_ofs;
+        uint32_t alloclen;
         int ret;
 
         rd.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
@@ -787,14 +790,14 @@ static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_er
         rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8));
         rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize));
 
-        ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &phys_ofs, &alloclen,
+        ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &alloclen,
                                 JFFS2_SUMMARY_DIRENT_SIZE(rd.nsize));
         if (ret) {
                 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dirent failed: %d\n",
                        sizeof(rd)+rd.nsize, ret);
                 return ret;
         }
-        new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, phys_ofs, ALLOC_GC);
+        new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, ALLOC_GC);
 
         if (IS_ERR(new_fd)) {
                 printk(KERN_WARNING "jffs2_write_dirent in garbage_collect_dirent failed: %ld\n", PTR_ERR(new_fd));
@@ -922,7 +925,7 @@ static int jffs2_garbage_collect_hole(struct jffs2_sb_info *c, struct jffs2_eras
         struct jffs2_raw_inode ri;
         struct jffs2_node_frag *frag;
         struct jffs2_full_dnode *new_fn;
-        uint32_t alloclen, phys_ofs, ilen;
+        uint32_t alloclen, ilen;
         int ret;
 
         D1(printk(KERN_DEBUG "Writing replacement hole node for ino #%u from offset 0x%x to 0x%x\n",
@@ -1001,14 +1004,14 @@ static int jffs2_garbage_collect_hole(struct jffs2_sb_info *c, struct jffs2_eras
         ri.data_crc = cpu_to_je32(0);
         ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
 
-        ret = jffs2_reserve_space_gc(c, sizeof(ri), &phys_ofs, &alloclen,
-                                JFFS2_SUMMARY_INODE_SIZE);
+        ret = jffs2_reserve_space_gc(c, sizeof(ri), &alloclen,
+                                     JFFS2_SUMMARY_INODE_SIZE);
         if (ret) {
                 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_hole failed: %d\n",
                        sizeof(ri), ret);
                 return ret;
         }
-        new_fn = jffs2_write_dnode(c, f, &ri, NULL, 0, phys_ofs, ALLOC_GC);
+        new_fn = jffs2_write_dnode(c, f, &ri, NULL, 0, ALLOC_GC);
 
         if (IS_ERR(new_fn)) {
                 printk(KERN_WARNING "Error writing new hole node: %ld\n", PTR_ERR(new_fn));
@@ -1070,7 +1073,7 @@ static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_era
 {
         struct jffs2_full_dnode *new_fn;
         struct jffs2_raw_inode ri;
-        uint32_t alloclen, phys_ofs, offset, orig_end, orig_start;
+        uint32_t alloclen, offset, orig_end, orig_start;
         int ret = 0;
         unsigned char *comprbuf = NULL, *writebuf;
         unsigned long pg;
@@ -1227,7 +1230,7 @@ static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_era
                 uint32_t cdatalen;
                 uint16_t comprtype = JFFS2_COMPR_NONE;
 
-                ret = jffs2_reserve_space_gc(c, sizeof(ri) + JFFS2_MIN_DATA_LEN, &phys_ofs,
+                ret = jffs2_reserve_space_gc(c, sizeof(ri) + JFFS2_MIN_DATA_LEN,
                                         &alloclen, JFFS2_SUMMARY_INODE_SIZE);
 
                 if (ret) {
@@ -1264,7 +1267,7 @@ static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_era
                 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
                 ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
 
-                new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, phys_ofs, ALLOC_GC);
+                new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, ALLOC_GC);
 
                 jffs2_free_comprbuf(comprbuf, writebuf);
 
diff --git a/fs/jffs2/histo.h b/fs/jffs2/histo.h
deleted file mode 100644
index 22a93a08210c..000000000000
--- a/fs/jffs2/histo.h
+++ /dev/null
@@ -1,3 +0,0 @@
-/* This file provides the bit-probabilities for the input file */
-#define BIT_DIVIDER 629
-static int bits[9] = { 179,167,183,165,159,198,178,119,}; /* ia32 .so files */
diff --git a/include/linux/jffs2_fs_i.h b/fs/jffs2/jffs2_fs_i.h
index ad565bf9dcc1..2e0cc8e00b85 100644
--- a/include/linux/jffs2_fs_i.h
+++ b/fs/jffs2/jffs2_fs_i.h
@@ -5,6 +5,7 @@
 
 #include <linux/version.h>
 #include <linux/rbtree.h>
+#include <linux/posix_acl.h>
 #include <asm/semaphore.h>
 
 struct jffs2_inode_info {
@@ -45,6 +46,10 @@ struct jffs2_inode_info {
         struct inode vfs_inode;
 #endif
 #endif
+#ifdef CONFIG_JFFS2_FS_POSIX_ACL
+        struct posix_acl *i_acl_access;
+        struct posix_acl *i_acl_default;
+#endif
 };
 
 #endif /* _JFFS2_FS_I */
diff --git a/include/linux/jffs2_fs_sb.h b/fs/jffs2/jffs2_fs_sb.h
index 4bcfb5570221..935fec1b1201 100644
--- a/include/linux/jffs2_fs_sb.h
+++ b/fs/jffs2/jffs2_fs_sb.h
@@ -100,6 +100,7 @@ struct jffs2_sb_info {
 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
         /* Write-behind buffer for NAND flash */
         unsigned char *wbuf;
+        unsigned char *oobbuf;
         uint32_t wbuf_ofs;
         uint32_t wbuf_len;
         struct jffs2_inodirty *wbuf_inodes;
@@ -107,7 +108,7 @@ struct jffs2_sb_info {
         struct rw_semaphore wbuf_sem;   /* Protects the write buffer */
 
         /* Information about out-of-band area usage... */
-        struct nand_oobinfo *oobinfo;
+        struct nand_ecclayout *ecclayout;
         uint32_t badblock_pos;
         uint32_t fsdata_pos;
         uint32_t fsdata_len;
@@ -115,6 +116,16 @@ struct jffs2_sb_info {
 
         struct jffs2_summary *summary;          /* Summary information */
 
+#ifdef CONFIG_JFFS2_FS_XATTR
+#define XATTRINDEX_HASHSIZE     (57)
+        uint32_t highest_xid;
+        struct list_head xattrindex[XATTRINDEX_HASHSIZE];
+        struct list_head xattr_unchecked;
+        struct jffs2_xattr_ref *xref_temp;
+        struct rw_semaphore xattr_sem;
+        uint32_t xdatum_mem_usage;
+        uint32_t xdatum_mem_threshold;
+#endif
         /* OS-private pointer for getting back to master superblock info */
         void *os_priv;
 };
diff --git a/fs/jffs2/malloc.c b/fs/jffs2/malloc.c
index 036cbd11c004..4889d0700c0e 100644
--- a/fs/jffs2/malloc.c
+++ b/fs/jffs2/malloc.c
@@ -26,6 +26,10 @@ static kmem_cache_t *tmp_dnode_info_slab;
 static kmem_cache_t *raw_node_ref_slab;
 static kmem_cache_t *node_frag_slab;
 static kmem_cache_t *inode_cache_slab;
+#ifdef CONFIG_JFFS2_FS_XATTR
+static kmem_cache_t *xattr_datum_cache;
+static kmem_cache_t *xattr_ref_cache;
+#endif
 
 int __init jffs2_create_slab_caches(void)
 {
@@ -53,8 +57,8 @@ int __init jffs2_create_slab_caches(void)
         if (!tmp_dnode_info_slab)
                 goto err;
 
-        raw_node_ref_slab = kmem_cache_create("jffs2_raw_node_ref",
-                                              sizeof(struct jffs2_raw_node_ref),
+        raw_node_ref_slab = kmem_cache_create("jffs2_refblock",
+                                              sizeof(struct jffs2_raw_node_ref) * (REFS_PER_BLOCK + 1),
                                               0, 0, NULL, NULL);
         if (!raw_node_ref_slab)
                 goto err;
@@ -68,8 +72,24 @@ int __init jffs2_create_slab_caches(void)
         inode_cache_slab = kmem_cache_create("jffs2_inode_cache",
                                              sizeof(struct jffs2_inode_cache),
                                              0, 0, NULL, NULL);
-        if (inode_cache_slab)
-                return 0;
+        if (!inode_cache_slab)
+                goto err;
+
+#ifdef CONFIG_JFFS2_FS_XATTR
+        xattr_datum_cache = kmem_cache_create("jffs2_xattr_datum",
+                                             sizeof(struct jffs2_xattr_datum),
+                                             0, 0, NULL, NULL);
+        if (!xattr_datum_cache)
+                goto err;
+
+        xattr_ref_cache = kmem_cache_create("jffs2_xattr_ref",
+                                           sizeof(struct jffs2_xattr_ref),
+                                           0, 0, NULL, NULL);
+        if (!xattr_ref_cache)
+                goto err;
+#endif
+
+        return 0;
  err:
         jffs2_destroy_slab_caches();
         return -ENOMEM;
@@ -91,6 +111,12 @@ void jffs2_destroy_slab_caches(void)
                 kmem_cache_destroy(node_frag_slab);
         if(inode_cache_slab)
                 kmem_cache_destroy(inode_cache_slab);
+#ifdef CONFIG_JFFS2_FS_XATTR
+        if (xattr_datum_cache)
+                kmem_cache_destroy(xattr_datum_cache);
+        if (xattr_ref_cache)
+                kmem_cache_destroy(xattr_ref_cache);
+#endif
 }
 
 struct jffs2_full_dirent *jffs2_alloc_full_dirent(int namesize)
@@ -164,15 +190,65 @@ void jffs2_free_tmp_dnode_info(struct jffs2_tmp_dnode_info *x)
         kmem_cache_free(tmp_dnode_info_slab, x);
 }
 
-struct jffs2_raw_node_ref *jffs2_alloc_raw_node_ref(void)
+struct jffs2_raw_node_ref *jffs2_alloc_refblock(void)
 {
         struct jffs2_raw_node_ref *ret;
+
         ret = kmem_cache_alloc(raw_node_ref_slab, GFP_KERNEL);
-        dbg_memalloc("%p\n", ret);
+        if (ret) {
+                int i = 0;
+                for (i=0; i < REFS_PER_BLOCK; i++) {
+                        ret[i].flash_offset = REF_EMPTY_NODE;
+                        ret[i].next_in_ino = NULL;
+                }
+                ret[i].flash_offset = REF_LINK_NODE;
+                ret[i].next_in_ino = NULL;
+        }
         return ret;
 }
 
-void jffs2_free_raw_node_ref(struct jffs2_raw_node_ref *x)
+int jffs2_prealloc_raw_node_refs(struct jffs2_sb_info *c,
+                                 struct jffs2_eraseblock *jeb, int nr)
+{
+        struct jffs2_raw_node_ref **p, *ref;
+        int i = nr;
+
+        dbg_memalloc("%d\n", nr);
+
+        p = &jeb->last_node;
+        ref = *p;
+
+        dbg_memalloc("Reserving %d refs for block @0x%08x\n", nr, jeb->offset);
+
+        /* If jeb->last_node is really a valid node then skip over it */
+        if (ref && ref->flash_offset != REF_EMPTY_NODE)
+                ref++;
+
+        while (i) {
+                if (!ref) {
+                        dbg_memalloc("Allocating new refblock linked from %p\n", p);
+                        ref = *p = jffs2_alloc_refblock();
+                        if (!ref)
+                                return -ENOMEM;
+                }
+                if (ref->flash_offset == REF_LINK_NODE) {
+                        p = &ref->next_in_ino;
+                        ref = *p;
+                        continue;
+                }
+                i--;
+                ref++;
+        }
+        jeb->allocated_refs = nr;
+
+        dbg_memalloc("Reserved %d refs for block @0x%08x, last_node is %p (%08x,%p)\n",
+                  nr, jeb->offset, jeb->last_node, jeb->last_node->flash_offset,
+                  jeb->last_node->next_in_ino);
+
+        return 0;
+}
+
+void jffs2_free_refblock(struct jffs2_raw_node_ref *x)
 {
         dbg_memalloc("%p\n", x);
         kmem_cache_free(raw_node_ref_slab, x);
@@ -205,3 +281,40 @@ void jffs2_free_inode_cache(struct jffs2_inode_cache *x)
         dbg_memalloc("%p\n", x);
         kmem_cache_free(inode_cache_slab, x);
 }
+
+#ifdef CONFIG_JFFS2_FS_XATTR
+struct jffs2_xattr_datum *jffs2_alloc_xattr_datum(void)
+{
+        struct jffs2_xattr_datum *xd;
+        xd = kmem_cache_alloc(xattr_datum_cache, GFP_KERNEL);
+        dbg_memalloc("%p\n", xd);
+
+        memset(xd, 0, sizeof(struct jffs2_xattr_datum));
+        xd->class = RAWNODE_CLASS_XATTR_DATUM;
+        INIT_LIST_HEAD(&xd->xindex);
+        return xd;
+}
+
+void jffs2_free_xattr_datum(struct jffs2_xattr_datum *xd)
+{
+        dbg_memalloc("%p\n", xd);
+        kmem_cache_free(xattr_datum_cache, xd);
+}
+
+struct jffs2_xattr_ref *jffs2_alloc_xattr_ref(void)
+{
+        struct jffs2_xattr_ref *ref;
+        ref = kmem_cache_alloc(xattr_ref_cache, GFP_KERNEL);
+        dbg_memalloc("%p\n", ref);
+
+        memset(ref, 0, sizeof(struct jffs2_xattr_ref));
+        ref->class = RAWNODE_CLASS_XATTR_REF;
+        return ref;
+}
+
+void jffs2_free_xattr_ref(struct jffs2_xattr_ref *ref)
+{
+        dbg_memalloc("%p\n", ref);
+        kmem_cache_free(xattr_ref_cache, ref);
+}
+#endif
diff --git a/fs/jffs2/nodelist.c b/fs/jffs2/nodelist.c
index 1d46677afd17..927dfe42ba76 100644
--- a/fs/jffs2/nodelist.c
+++ b/fs/jffs2/nodelist.c
@@ -438,8 +438,7 @@ static int check_node_data(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info
         if (c->mtd->point) {
                 err = c->mtd->point(c->mtd, ofs, len, &retlen, &buffer);
                 if (!err && retlen < tn->csize) {
-                        JFFS2_WARNING("MTD point returned len too short: %zu "
-                                        "instead of %u.\n", retlen, tn->csize);
+                        JFFS2_WARNING("MTD point returned len too short: %zu instead of %u.\n", retlen, tn->csize);
                         c->mtd->unpoint(c->mtd, buffer, ofs, len);
                 } else if (err)
                         JFFS2_WARNING("MTD point failed: error code %d.\n", err);
@@ -462,8 +461,7 @@ static int check_node_data(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info
                 }
 
                 if (retlen != len) {
-                        JFFS2_ERROR("short read at %#08x: %zd instead of %d.\n",
-                                        ofs, retlen, len);
+                        JFFS2_ERROR("short read at %#08x: %zd instead of %d.\n", ofs, retlen, len);
                         err = -EIO;
                         goto free_out;
                 }
@@ -940,6 +938,7 @@ void jffs2_free_ino_caches(struct jffs2_sb_info *c)
                 this = c->inocache_list[i];
                 while (this) {
                         next = this->next;
+                        jffs2_xattr_free_inode(c, this);
                         jffs2_free_inode_cache(this);
                         this = next;
                 }
@@ -954,9 +953,13 @@ void jffs2_free_raw_node_refs(struct jffs2_sb_info *c)
 
         for (i=0; i<c->nr_blocks; i++) {
                 this = c->blocks[i].first_node;
-                while(this) {
-                        next = this->next_phys;
-                        jffs2_free_raw_node_ref(this);
+                while (this) {
+                        if (this[REFS_PER_BLOCK].flash_offset == REF_LINK_NODE)
+                                next = this[REFS_PER_BLOCK].next_in_ino;
+                        else
+                                next = NULL;
+
+                        jffs2_free_refblock(this);
                         this = next;
                 }
                 c->blocks[i].first_node = c->blocks[i].last_node = NULL;
@@ -1047,3 +1050,169 @@ void jffs2_kill_fragtree(struct rb_root *root, struct jffs2_sb_info *c)
                 cond_resched();
         }
 }
+
+struct jffs2_raw_node_ref *jffs2_link_node_ref(struct jffs2_sb_info *c,
+                                               struct jffs2_eraseblock *jeb,
+                                               uint32_t ofs, uint32_t len,
+                                               struct jffs2_inode_cache *ic)
+{
+        struct jffs2_raw_node_ref *ref;
+
+        BUG_ON(!jeb->allocated_refs);
+        jeb->allocated_refs--;
+
+        ref = jeb->last_node;
+
+        dbg_noderef("Last node at %p is (%08x,%p)\n", ref, ref->flash_offset,
+                    ref->next_in_ino);
+
+        while (ref->flash_offset != REF_EMPTY_NODE) {
+                if (ref->flash_offset == REF_LINK_NODE)
+                        ref = ref->next_in_ino;
+                else
+                        ref++;
+        }
+
+        dbg_noderef("New ref is %p (%08x becomes %08x,%p) len 0x%x\n", ref, 
+                    ref->flash_offset, ofs, ref->next_in_ino, len);
+
+        ref->flash_offset = ofs;
+
+        if (!jeb->first_node) {
+                jeb->first_node = ref;
+                BUG_ON(ref_offset(ref) != jeb->offset);
+        } else if (unlikely(ref_offset(ref) != jeb->offset + c->sector_size - jeb->free_size)) {
+                uint32_t last_len = ref_totlen(c, jeb, jeb->last_node);
+
+                JFFS2_ERROR("Adding new ref %p at (0x%08x-0x%08x) not immediately after previous (0x%08x-0x%08x)\n",
+                            ref, ref_offset(ref), ref_offset(ref)+len,
+                            ref_offset(jeb->last_node), 
+                            ref_offset(jeb->last_node)+last_len);
+                BUG();
+        }
+        jeb->last_node = ref;
+
+        if (ic) {
+                ref->next_in_ino = ic->nodes;
+                ic->nodes = ref;
+        } else {
+                ref->next_in_ino = NULL;
+        }
+
+        switch(ref_flags(ref)) {
+        case REF_UNCHECKED:
+                c->unchecked_size += len;
+                jeb->unchecked_size += len;
+                break;
+
+        case REF_NORMAL:
+        case REF_PRISTINE:
+                c->used_size += len;
+                jeb->used_size += len;
+                break;
+
+        case REF_OBSOLETE:
+                c->dirty_size += len;
+                jeb->dirty_size += len;
+                break;
+        }
+        c->free_size -= len;
+        jeb->free_size -= len;
+
+#ifdef TEST_TOTLEN
+        /* Set (and test) __totlen field... for now */
+        ref->__totlen = len;
+        ref_totlen(c, jeb, ref);
+#endif
+        return ref;
+}
+
+/* No locking, no reservation of 'ref'. Do not use on a live file system */
+int jffs2_scan_dirty_space(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
+                           uint32_t size)
+{
+        if (!size)
+                return 0;
+        if (unlikely(size > jeb->free_size)) {
+                printk(KERN_CRIT "Dirty space 0x%x larger then free_size 0x%x (wasted 0x%x)\n",
+                       size, jeb->free_size, jeb->wasted_size);
+                BUG();
+        }
+        /* REF_EMPTY_NODE is !obsolete, so that works OK */
+        if (jeb->last_node && ref_obsolete(jeb->last_node)) {
+#ifdef TEST_TOTLEN
+                jeb->last_node->__totlen += size;
+#endif
+                c->dirty_size += size;
+                c->free_size -= size;
+                jeb->dirty_size += size;
+                jeb->free_size -= size;
+        } else {
+                uint32_t ofs = jeb->offset + c->sector_size - jeb->free_size;
+                ofs |= REF_OBSOLETE;
+
+                jffs2_link_node_ref(c, jeb, ofs, size, NULL);
+        }
+
+        return 0;
+}
+
+/* Calculate totlen from surrounding nodes or eraseblock */
+static inline uint32_t __ref_totlen(struct jffs2_sb_info *c,
+                                    struct jffs2_eraseblock *jeb,
+                                    struct jffs2_raw_node_ref *ref)
+{
+        uint32_t ref_end;
+        struct jffs2_raw_node_ref *next_ref = ref_next(ref);
+
+        if (next_ref)
+                ref_end = ref_offset(next_ref);
+        else {
+                if (!jeb)
+                        jeb = &c->blocks[ref->flash_offset / c->sector_size];
+
+                /* Last node in block. Use free_space */
+                if (unlikely(ref != jeb->last_node)) {
+                        printk(KERN_CRIT "ref %p @0x%08x is not jeb->last_node (%p @0x%08x)\n",
+                               ref, ref_offset(ref), jeb->last_node, jeb->last_node?ref_offset(jeb->last_node):0);
+                        BUG();
+                }
+                ref_end = jeb->offset + c->sector_size - jeb->free_size;
+        }
+        return ref_end - ref_offset(ref);
+}
+
+uint32_t __jffs2_ref_totlen(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
+                            struct jffs2_raw_node_ref *ref)
+{
+        uint32_t ret;
+
+        ret = __ref_totlen(c, jeb, ref);
+
+#ifdef TEST_TOTLEN
+        if (unlikely(ret != ref->__totlen)) {
+                if (!jeb)
+                        jeb = &c->blocks[ref->flash_offset / c->sector_size];
+
+                printk(KERN_CRIT "Totlen for ref at %p (0x%08x-0x%08x) miscalculated as 0x%x instead of %x\n",
+                       ref, ref_offset(ref), ref_offset(ref)+ref->__totlen,
+                       ret, ref->__totlen);
+                if (ref_next(ref)) {
+                        printk(KERN_CRIT "next %p (0x%08x-0x%08x)\n", ref_next(ref), ref_offset(ref_next(ref)),
+                               ref_offset(ref_next(ref))+ref->__totlen);
+                } else 
+                        printk(KERN_CRIT "No next ref. jeb->last_node is %p\n", jeb->last_node);
+
+                printk(KERN_CRIT "jeb->wasted_size %x, dirty_size %x, used_size %x, free_size %x\n", jeb->wasted_size, jeb->dirty_size, jeb->used_size, jeb->free_size);
+
+#if defined(JFFS2_DBG_DUMPS) || defined(JFFS2_DBG_PARANOIA_CHECKS)
+                __jffs2_dbg_dump_node_refs_nolock(c, jeb);
+#endif
+
+                WARN_ON(1);
+
+                ret = ref->__totlen;
+        }
+#endif /* TEST_TOTLEN */
+        return ret;
+}
diff --git a/fs/jffs2/nodelist.h b/fs/jffs2/nodelist.h
index 23a67bb3052f..b16c60bbcf6e 100644
--- a/fs/jffs2/nodelist.h
+++ b/fs/jffs2/nodelist.h
@@ -18,8 +18,10 @@
 #include <linux/fs.h>
 #include <linux/types.h>
 #include <linux/jffs2.h>
-#include <linux/jffs2_fs_sb.h>
-#include <linux/jffs2_fs_i.h>
+#include "jffs2_fs_sb.h"
+#include "jffs2_fs_i.h"
+#include "xattr.h"
+#include "acl.h"
 #include "summary.h"
 
 #ifdef __ECOS
@@ -75,14 +77,50 @@
 struct jffs2_raw_node_ref
 {
         struct jffs2_raw_node_ref *next_in_ino; /* Points to the next raw_node_ref
-                for this inode. If this is the last, it points to the inode_cache
-                for this inode instead. The inode_cache will have NULL in the first
-                word so you know when you've got there :) */
-        struct jffs2_raw_node_ref *next_phys;
+                for this object. If this _is_ the last, it points to the inode_cache,
+                xattr_ref or xattr_datum instead. The common part of those structures
+                has NULL in the first word. See jffs2_raw_ref_to_ic() below */
         uint32_t flash_offset;
+#define TEST_TOTLEN
+#ifdef TEST_TOTLEN
         uint32_t __totlen; /* This may die; use ref_totlen(c, jeb, ) below */
+#endif
 };
 
+#define REF_LINK_NODE ((int32_t)-1)
+#define REF_EMPTY_NODE ((int32_t)-2)
+
+/* Use blocks of about 256 bytes */
+#define REFS_PER_BLOCK ((255/sizeof(struct jffs2_raw_node_ref))-1)
+
+static inline struct jffs2_raw_node_ref *ref_next(struct jffs2_raw_node_ref *ref)
+{
+        ref++;
+
+        /* Link to another block of refs */
+        if (ref->flash_offset == REF_LINK_NODE) {
+                ref = ref->next_in_ino;
+                if (!ref)
+                        return ref;
+        }
+
+        /* End of chain */
+        if (ref->flash_offset == REF_EMPTY_NODE)
+                return NULL;
+
+        return ref;
+}
+
+static inline struct jffs2_inode_cache *jffs2_raw_ref_to_ic(struct jffs2_raw_node_ref *raw)
+{
+        while(raw->next_in_ino)
+                raw = raw->next_in_ino;
+
+        /* NB. This can be a jffs2_xattr_datum or jffs2_xattr_ref and
+           not actually a jffs2_inode_cache. Check ->class */
+        return ((struct jffs2_inode_cache *)raw);
+}
+
         /* flash_offset & 3 always has to be zero, because nodes are
            always aligned at 4 bytes. So we have a couple of extra bits
            to play with, which indicate the node's status; see below: */
@@ -95,6 +133,11 @@ struct jffs2_raw_node_ref
 #define ref_obsolete(ref)       (((ref)->flash_offset & 3) == REF_OBSOLETE)
 #define mark_ref_normal(ref)    do { (ref)->flash_offset = ref_offset(ref) | REF_NORMAL; } while(0)
 
+/* NB: REF_PRISTINE for an inode-less node (ref->next_in_ino == NULL) indicates
+   it is an unknown node of type JFFS2_NODETYPE_RWCOMPAT_COPY, so it'll get
+   copied. If you need to do anything different to GC inode-less nodes, then
+   you need to modify gc.c accordingly. */
+
 /* For each inode in the filesystem, we need to keep a record of
    nlink, because it would be a PITA to scan the whole directory tree
    at read_inode() time to calculate it, and to keep sufficient information
@@ -103,15 +146,27 @@ struct jffs2_raw_node_ref
    a pointer to the first physical node which is part of this inode, too.
 */
 struct jffs2_inode_cache {
+        /* First part of structure is shared with other objects which
+           can terminate the raw node refs' next_in_ino list -- which
+           currently struct jffs2_xattr_datum and struct jffs2_xattr_ref. */
+
         struct jffs2_full_dirent *scan_dents; /* Used during scan to hold
                 temporary lists of dirents, and later must be set to
                 NULL to mark the end of the raw_node_ref->next_in_ino
                 chain. */
-        struct jffs2_inode_cache *next;
         struct jffs2_raw_node_ref *nodes;
+        uint8_t class;  /* It's used for identification */
+
+        /* end of shared structure */
+
+        uint8_t flags;
+        uint16_t state;
         uint32_t ino;
+        struct jffs2_inode_cache *next;
+#ifdef CONFIG_JFFS2_FS_XATTR
+        struct jffs2_xattr_ref *xref;
+#endif
         int nlink;
-        int state;
 };
 
 /* Inode states for 'state' above. We need the 'GC' state to prevent
@@ -125,8 +180,16 @@ struct jffs2_inode_cache {
 #define INO_STATE_READING       5       /* In read_inode() */
 #define INO_STATE_CLEARING      6       /* In clear_inode() */
 
+#define INO_FLAGS_XATTR_CHECKED 0x01    /* has no duplicate xattr_ref */
+
+#define RAWNODE_CLASS_INODE_CACHE       0
+#define RAWNODE_CLASS_XATTR_DATUM       1
+#define RAWNODE_CLASS_XATTR_REF         2
+
 #define INOCACHE_HASHSIZE 128
 
+#define write_ofs(c) ((c)->nextblock->offset + (c)->sector_size - (c)->nextblock->free_size)
+
 /*
   Larger representation of a raw node, kept in-core only when the
   struct inode for this particular ino is instantiated.
@@ -192,6 +255,7 @@ struct jffs2_eraseblock
         uint32_t wasted_size;
         uint32_t free_size;     /* Note that sector_size - free_size
                                    is the address of the first free space */
+        uint32_t allocated_refs;
         struct jffs2_raw_node_ref *first_node;
         struct jffs2_raw_node_ref *last_node;
 
@@ -203,57 +267,7 @@ static inline int jffs2_blocks_use_vmalloc(struct jffs2_sb_info *c)
         return ((c->flash_size / c->sector_size) * sizeof (struct jffs2_eraseblock)) > (128 * 1024);
 }
 
-/* Calculate totlen from surrounding nodes or eraseblock */
-static inline uint32_t __ref_totlen(struct jffs2_sb_info *c,
-                                    struct jffs2_eraseblock *jeb,
-                                    struct jffs2_raw_node_ref *ref)
-{
-        uint32_t ref_end;
-
-        if (ref->next_phys)
-                ref_end = ref_offset(ref->next_phys);
-        else {
-                if (!jeb)
-                        jeb = &c->blocks[ref->flash_offset / c->sector_size];
-
-                /* Last node in block. Use free_space */
-                BUG_ON(ref != jeb->last_node);
-                ref_end = jeb->offset + c->sector_size - jeb->free_size;
-        }
-        return ref_end - ref_offset(ref);
-}
-
-static inline uint32_t ref_totlen(struct jffs2_sb_info *c,
-                                  struct jffs2_eraseblock *jeb,
-                                  struct jffs2_raw_node_ref *ref)
-{
-        uint32_t ret;
-
-#if CONFIG_JFFS2_FS_DEBUG > 0
-        if (jeb && jeb != &c->blocks[ref->flash_offset / c->sector_size]) {
-                printk(KERN_CRIT "ref_totlen called with wrong block -- at 0x%08x instead of 0x%08x; ref 0x%08x\n",
-                       jeb->offset, c->blocks[ref->flash_offset / c->sector_size].offset, ref_offset(ref));
-                BUG();
-        }
-#endif
-
-#if 1
-        ret = ref->__totlen;
-#else
-        /* This doesn't actually work yet */
-        ret = __ref_totlen(c, jeb, ref);
-        if (ret != ref->__totlen) {
-                printk(KERN_CRIT "Totlen for ref at %p (0x%08x-0x%08x) miscalculated as 0x%x instead of %x\n",
-                       ref, ref_offset(ref), ref_offset(ref)+ref->__totlen,
-                       ret, ref->__totlen);
-                if (!jeb)
-                        jeb = &c->blocks[ref->flash_offset / c->sector_size];
-                jffs2_dbg_dump_node_refs_nolock(c, jeb);
-                BUG();
-        }
-#endif
-        return ret;
-}
+#define ref_totlen(a, b, c) __jffs2_ref_totlen((a), (b), (c))
 
 #define ALLOC_NORMAL    0       /* Normal allocation */
 #define ALLOC_DELETION  1       /* Deletion node. Best to allow it */
@@ -268,13 +282,15 @@ static inline uint32_t ref_totlen(struct jffs2_sb_info *c,
 
 #define PAD(x) (((x)+3)&~3)
 
-static inline struct jffs2_inode_cache *jffs2_raw_ref_to_ic(struct jffs2_raw_node_ref *raw)
+static inline int jffs2_encode_dev(union jffs2_device_node *jdev, dev_t rdev)
 {
-        while(raw->next_in_ino) {
-                raw = raw->next_in_ino;
+        if (old_valid_dev(rdev)) {
+                jdev->old = cpu_to_je16(old_encode_dev(rdev));
+                return sizeof(jdev->old);
+        } else {
+                jdev->new = cpu_to_je32(new_encode_dev(rdev));
+                return sizeof(jdev->new);
         }
-
-        return ((struct jffs2_inode_cache *)raw);
 }
 
 static inline struct jffs2_node_frag *frag_first(struct rb_root *root)
@@ -299,7 +315,6 @@ static inline struct jffs2_node_frag *frag_last(struct rb_root *root)
         return rb_entry(node, struct jffs2_node_frag, rb);
 }
 
-#define rb_parent(rb) ((rb)->rb_parent)
 #define frag_next(frag) rb_entry(rb_next(&(frag)->rb), struct jffs2_node_frag, rb)
 #define frag_prev(frag) rb_entry(rb_prev(&(frag)->rb), struct jffs2_node_frag, rb)
 #define frag_parent(frag) rb_entry(rb_parent(&(frag)->rb), struct jffs2_node_frag, rb)
@@ -324,28 +339,44 @@ void jffs2_obsolete_node_frag(struct jffs2_sb_info *c, struct jffs2_node_frag *t
 int jffs2_add_full_dnode_to_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_full_dnode *fn);
 void jffs2_truncate_fragtree (struct jffs2_sb_info *c, struct rb_root *list, uint32_t size);
 int jffs2_add_older_frag_to_fragtree(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_tmp_dnode_info *tn);
+struct jffs2_raw_node_ref *jffs2_link_node_ref(struct jffs2_sb_info *c,
+                                               struct jffs2_eraseblock *jeb,
+                                               uint32_t ofs, uint32_t len,
+                                               struct jffs2_inode_cache *ic);
+extern uint32_t __jffs2_ref_totlen(struct jffs2_sb_info *c,
+                                   struct jffs2_eraseblock *jeb,
+                                   struct jffs2_raw_node_ref *ref);
 
 /* nodemgmt.c */
 int jffs2_thread_should_wake(struct jffs2_sb_info *c);
-int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, uint32_t *ofs,
+int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
                         uint32_t *len, int prio, uint32_t sumsize);
-int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize, uint32_t *ofs,
+int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize,
                         uint32_t *len, uint32_t sumsize);
-int jffs2_add_physical_node_ref(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *new);
+struct jffs2_raw_node_ref *jffs2_add_physical_node_ref(struct jffs2_sb_info *c, 
+                                                       uint32_t ofs, uint32_t len,
+                                                       struct jffs2_inode_cache *ic);
 void jffs2_complete_reservation(struct jffs2_sb_info *c);
 void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *raw);
 
 /* write.c */
 int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint32_t mode, struct jffs2_raw_inode *ri);
 
-struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_raw_inode *ri, const unsigned char *data, uint32_t datalen, uint32_t flash_ofs, int alloc_mode);
-struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_raw_dirent *rd, const unsigned char *name, uint32_t namelen, uint32_t flash_ofs, int alloc_mode);
+struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
+                                           struct jffs2_raw_inode *ri, const unsigned char *data,
+                                           uint32_t datalen, int alloc_mode);
+struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
+                                             struct jffs2_raw_dirent *rd, const unsigned char *name,
+                                             uint32_t namelen, int alloc_mode);
 int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
                             struct jffs2_raw_inode *ri, unsigned char *buf,
                             uint32_t offset, uint32_t writelen, uint32_t *retlen);
-int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, struct jffs2_inode_info *f, struct jffs2_raw_inode *ri, const char *name, int namelen);
-int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, const char *name, int namelen, struct jffs2_inode_info *dead_f, uint32_t time);
-int jffs2_do_link (struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, uint32_t ino, uint8_t type, const char *name, int namelen, uint32_t time);
+int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, struct jffs2_inode_info *f,
+                    struct jffs2_raw_inode *ri, const char *name, int namelen);
+int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, const char *name,
+                    int namelen, struct jffs2_inode_info *dead_f, uint32_t time);
+int jffs2_do_link(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, uint32_t ino,
+                   uint8_t type, const char *name, int namelen, uint32_t time);
 
 
 /* readinode.c */
@@ -368,12 +399,19 @@ struct jffs2_raw_inode *jffs2_alloc_raw_inode(void);
 void jffs2_free_raw_inode(struct jffs2_raw_inode *);
 struct jffs2_tmp_dnode_info *jffs2_alloc_tmp_dnode_info(void);
 void jffs2_free_tmp_dnode_info(struct jffs2_tmp_dnode_info *);
-struct jffs2_raw_node_ref *jffs2_alloc_raw_node_ref(void);
-void jffs2_free_raw_node_ref(struct jffs2_raw_node_ref *);
+int jffs2_prealloc_raw_node_refs(struct jffs2_sb_info *c,
+                                 struct jffs2_eraseblock *jeb, int nr);
+void jffs2_free_refblock(struct jffs2_raw_node_ref *);
 struct jffs2_node_frag *jffs2_alloc_node_frag(void);
 void jffs2_free_node_frag(struct jffs2_node_frag *);
 struct jffs2_inode_cache *jffs2_alloc_inode_cache(void);
 void jffs2_free_inode_cache(struct jffs2_inode_cache *);
+#ifdef CONFIG_JFFS2_FS_XATTR
+struct jffs2_xattr_datum *jffs2_alloc_xattr_datum(void);
+void jffs2_free_xattr_datum(struct jffs2_xattr_datum *);
+struct jffs2_xattr_ref *jffs2_alloc_xattr_ref(void);
+void jffs2_free_xattr_ref(struct jffs2_xattr_ref *);
+#endif
 
 /* gc.c */
 int jffs2_garbage_collect_pass(struct jffs2_sb_info *c);
@@ -393,12 +431,14 @@ int jffs2_fill_scan_buf(struct jffs2_sb_info *c, void *buf,
                                 uint32_t ofs, uint32_t len);
 struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uint32_t ino);
 int jffs2_scan_classify_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
+int jffs2_scan_dirty_space(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t size);
 
 /* build.c */
 int jffs2_do_mount_fs(struct jffs2_sb_info *c);
 
 /* erase.c */
 void jffs2_erase_pending_blocks(struct jffs2_sb_info *c, int count);
+void jffs2_free_jeb_node_refs(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
 
 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
 /* wbuf.c */
diff --git a/fs/jffs2/nodemgmt.c b/fs/jffs2/nodemgmt.c
index 49127a1f0458..8bedfd2ff689 100644
--- a/fs/jffs2/nodemgmt.c
+++ b/fs/jffs2/nodemgmt.c
@@ -23,13 +23,12 @@
  *      jffs2_reserve_space - request physical space to write nodes to flash
  *      @c: superblock info
  *      @minsize: Minimum acceptable size of allocation
- *      @ofs: Returned value of node offset
  *      @len: Returned value of allocation length
  *      @prio: Allocation type - ALLOC_{NORMAL,DELETION}
  *
  *      Requests a block of physical space on the flash. Returns zero for success
- *      and puts 'ofs' and 'len' into the appriopriate place, or returns -ENOSPC
- *      or other error if appropriate.
+ *      and puts 'len' into the appropriate place, or returns -ENOSPC or other 
+ *      error if appropriate. Doesn't return len since that's 
  *
  *      If it returns zero, jffs2_reserve_space() also downs the per-filesystem
  *      allocation semaphore, to prevent more than one allocation from being
@@ -40,9 +39,9 @@
  */
 
 static int jffs2_do_reserve_space(struct jffs2_sb_info *c,  uint32_t minsize,
-                                        uint32_t *ofs, uint32_t *len, uint32_t sumsize);
+                                  uint32_t *len, uint32_t sumsize);
 
-int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, uint32_t *ofs,
+int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
                         uint32_t *len, int prio, uint32_t sumsize)
 {
         int ret = -EAGAIN;
@@ -132,19 +131,21 @@ int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, uint32_t *ofs
                         spin_lock(&c->erase_completion_lock);
                 }
 
-                ret = jffs2_do_reserve_space(c, minsize, ofs, len, sumsize);
+                ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
                 if (ret) {
                         D1(printk(KERN_DEBUG "jffs2_reserve_space: ret is %d\n", ret));
                 }
         }
         spin_unlock(&c->erase_completion_lock);
+        if (!ret)
+                ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
         if (ret)
                 up(&c->alloc_sem);
         return ret;
 }
 
-int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize, uint32_t *ofs,
-                        uint32_t *len, uint32_t sumsize)
+int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize,
+                           uint32_t *len, uint32_t sumsize)
 {
         int ret = -EAGAIN;
         minsize = PAD(minsize);
@@ -153,12 +154,15 @@ int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize, uint32_t *
 
         spin_lock(&c->erase_completion_lock);
         while(ret == -EAGAIN) {
-                ret = jffs2_do_reserve_space(c, minsize, ofs, len, sumsize);
+                ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
                 if (ret) {
                         D1(printk(KERN_DEBUG "jffs2_reserve_space_gc: looping, ret is %d\n", ret));
                 }
         }
         spin_unlock(&c->erase_completion_lock);
+        if (!ret)
+                ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
+
         return ret;
 }
 
@@ -259,10 +263,11 @@ static int jffs2_find_nextblock(struct jffs2_sb_info *c)
 }
 
 /* Called with alloc sem _and_ erase_completion_lock */
-static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, uint32_t *ofs, uint32_t *len, uint32_t sumsize)
+static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
+                                  uint32_t *len, uint32_t sumsize)
 {
         struct jffs2_eraseblock *jeb = c->nextblock;
-        uint32_t reserved_size;                         /* for summary information at the end of the jeb */
+        uint32_t reserved_size;                         /* for summary information at the end of the jeb */
         int ret;
 
  restart:
@@ -312,6 +317,8 @@ static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, uin
                 }
         } else {
                 if (jeb && minsize > jeb->free_size) {
+                        uint32_t waste;
+
                         /* Skip the end of this block and file it as having some dirty space */
                         /* If there's a pending write to it, flush now */
 
@@ -324,10 +331,26 @@ static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, uin
                                 goto restart;
                         }
 
-                        c->wasted_size += jeb->free_size;
-                        c->free_size -= jeb->free_size;
-                        jeb->wasted_size += jeb->free_size;
-                        jeb->free_size = 0;
+                        spin_unlock(&c->erase_completion_lock);
+
+                        ret = jffs2_prealloc_raw_node_refs(c, jeb, 1);
+                        if (ret)
+                                return ret;
+                        /* Just lock it again and continue. Nothing much can change because
+                           we hold c->alloc_sem anyway. In fact, it's not entirely clear why
+                           we hold c->erase_completion_lock in the majority of this function...
+                           but that's a question for another (more caffeine-rich) day. */
+                        spin_lock(&c->erase_completion_lock);
+
+                        waste = jeb->free_size;
+                        jffs2_link_node_ref(c, jeb,
+                                            (jeb->offset + c->sector_size - waste) | REF_OBSOLETE,
+                                            waste, NULL);
+                        /* FIXME: that made it count as dirty. Convert to wasted */
+                        jeb->dirty_size -= waste;
+                        c->dirty_size -= waste;
+                        jeb->wasted_size += waste;
+                        c->wasted_size += waste;
 
                         jffs2_close_nextblock(c, jeb);
                         jeb = NULL;
@@ -349,7 +372,6 @@ static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, uin
         }
         /* OK, jeb (==c->nextblock) is now pointing at a block which definitely has
            enough space */
-        *ofs = jeb->offset + (c->sector_size - jeb->free_size);
         *len = jeb->free_size - reserved_size;
 
         if (c->cleanmarker_size && jeb->used_size == c->cleanmarker_size &&
@@ -365,7 +387,8 @@ static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, uin
                 spin_lock(&c->erase_completion_lock);
         }
 
-        D1(printk(KERN_DEBUG "jffs2_do_reserve_space(): Giving 0x%x bytes at 0x%x\n", *len, *ofs));
+        D1(printk(KERN_DEBUG "jffs2_do_reserve_space(): Giving 0x%x bytes at 0x%x\n",
+                  *len, jeb->offset + (c->sector_size - jeb->free_size)));
         return 0;
 }
 
@@ -374,7 +397,6 @@ static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, uin
  *      @c: superblock info
  *      @new: new node reference to add
  *      @len: length of this physical node
- *      @dirty: dirty flag for new node
  *
  *      Should only be used to report nodes for which space has been allocated
  *      by jffs2_reserve_space.
@@ -382,42 +404,30 @@ static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, uin
  *      Must be called with the alloc_sem held.
  */
 
-int jffs2_add_physical_node_ref(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *new)
+struct jffs2_raw_node_ref *jffs2_add_physical_node_ref(struct jffs2_sb_info *c,
+                                                       uint32_t ofs, uint32_t len,
+                                                       struct jffs2_inode_cache *ic)
 {
         struct jffs2_eraseblock *jeb;
-        uint32_t len;
+        struct jffs2_raw_node_ref *new;
 
-        jeb = &c->blocks[new->flash_offset / c->sector_size];
-        len = ref_totlen(c, jeb, new);
+        jeb = &c->blocks[ofs / c->sector_size];
 
-        D1(printk(KERN_DEBUG "jffs2_add_physical_node_ref(): Node at 0x%x(%d), size 0x%x\n", ref_offset(new), ref_flags(new), len));
+        D1(printk(KERN_DEBUG "jffs2_add_physical_node_ref(): Node at 0x%x(%d), size 0x%x\n",
+                  ofs & ~3, ofs & 3, len));
 #if 1
-        /* we could get some obsolete nodes after nextblock was refiled
-           in wbuf.c */
-        if ((c->nextblock || !ref_obsolete(new))
-            &&(jeb != c->nextblock || ref_offset(new) != jeb->offset + (c->sector_size - jeb->free_size))) {
+        /* Allow non-obsolete nodes only to be added at the end of c->nextblock, 
+           if c->nextblock is set. Note that wbuf.c will file obsolete nodes
+           even after refiling c->nextblock */
+        if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE))
+            && (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) {
                 printk(KERN_WARNING "argh. node added in wrong place\n");
-                jffs2_free_raw_node_ref(new);
-                return -EINVAL;
+                return ERR_PTR(-EINVAL);
         }
 #endif
         spin_lock(&c->erase_completion_lock);
 
-        if (!jeb->first_node)
-                jeb->first_node = new;
-        if (jeb->last_node)
-                jeb->last_node->next_phys = new;
-        jeb->last_node = new;
-
-        jeb->free_size -= len;
-        c->free_size -= len;
-        if (ref_obsolete(new)) {
-                jeb->dirty_size += len;
-                c->dirty_size += len;
-        } else {
-                jeb->used_size += len;
-                c->used_size += len;
-        }
+        new = jffs2_link_node_ref(c, jeb, ofs, len, ic);
 
         if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) {
                 /* If it lives on the dirty_list, jffs2_reserve_space will put it there */
@@ -438,7 +448,7 @@ int jffs2_add_physical_node_ref(struct jffs2_sb_info *c, struct jffs2_raw_node_r
 
         spin_unlock(&c->erase_completion_lock);
 
-        return 0;
+        return new;
 }
 
 
@@ -470,8 +480,9 @@ void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
         struct jffs2_unknown_node n;
         int ret, addedsize;
         size_t retlen;
+        uint32_t freed_len;
 
-        if(!ref) {
+        if(unlikely(!ref)) {
                 printk(KERN_NOTICE "EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
                 return;
         }
@@ -499,32 +510,34 @@ void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
 
         spin_lock(&c->erase_completion_lock);
 
+        freed_len = ref_totlen(c, jeb, ref);
+
         if (ref_flags(ref) == REF_UNCHECKED) {
-                D1(if (unlikely(jeb->unchecked_size < ref_totlen(c, jeb, ref))) {
+                D1(if (unlikely(jeb->unchecked_size < freed_len)) {
                         printk(KERN_NOTICE "raw unchecked node of size 0x%08x freed from erase block %d at 0x%08x, but unchecked_size was already 0x%08x\n",
-                               ref_totlen(c, jeb, ref), blocknr, ref->flash_offset, jeb->used_size);
+                               freed_len, blocknr, ref->flash_offset, jeb->used_size);
                         BUG();
                 })
-                D1(printk(KERN_DEBUG "Obsoleting previously unchecked node at 0x%08x of len %x: ", ref_offset(ref), ref_totlen(c, jeb, ref)));
-                jeb->unchecked_size -= ref_totlen(c, jeb, ref);
-                c->unchecked_size -= ref_totlen(c, jeb, ref);
+                D1(printk(KERN_DEBUG "Obsoleting previously unchecked node at 0x%08x of len %x: ", ref_offset(ref), freed_len));
+                jeb->unchecked_size -= freed_len;
+                c->unchecked_size -= freed_len;
         } else {
-                D1(if (unlikely(jeb->used_size < ref_totlen(c, jeb, ref))) {
+                D1(if (unlikely(jeb->used_size < freed_len)) {
                         printk(KERN_NOTICE "raw node of size 0x%08x freed from erase block %d at 0x%08x, but used_size was already 0x%08x\n",
-                               ref_totlen(c, jeb, ref), blocknr, ref->flash_offset, jeb->used_size);
+                               freed_len, blocknr, ref->flash_offset, jeb->used_size);
                         BUG();
                 })
-                D1(printk(KERN_DEBUG "Obsoleting node at 0x%08x of len %#x: ", ref_offset(ref), ref_totlen(c, jeb, ref)));
-                jeb->used_size -= ref_totlen(c, jeb, ref);
-                c->used_size -= ref_totlen(c, jeb, ref);
+                D1(printk(KERN_DEBUG "Obsoleting node at 0x%08x of len %#x: ", ref_offset(ref), freed_len));
+                jeb->used_size -= freed_len;
+                c->used_size -= freed_len;
         }
 
         // Take care, that wasted size is taken into concern
-        if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + ref_totlen(c, jeb, ref))) && jeb != c->nextblock) {
-                D1(printk(KERN_DEBUG "Dirtying\n"));
-                addedsize = ref_totlen(c, jeb, ref);
-                jeb->dirty_size += ref_totlen(c, jeb, ref);
-                c->dirty_size += ref_totlen(c, jeb, ref);
+        if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) {
+                D1(printk("Dirtying\n"));
+                addedsize = freed_len;
+                jeb->dirty_size += freed_len;
+                c->dirty_size += freed_len;
 
                 /* Convert wasted space to dirty, if not a bad block */
                 if (jeb->wasted_size) {
@@ -543,10 +556,10 @@ void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
                         }
                 }
         } else {
-                D1(printk(KERN_DEBUG "Wasting\n"));
+                D1(printk("Wasting\n"));
                 addedsize = 0;
-                jeb->wasted_size += ref_totlen(c, jeb, ref);
-                c->wasted_size += ref_totlen(c, jeb, ref);
+                jeb->wasted_size += freed_len;
+                c->wasted_size += freed_len;
         }
         ref->flash_offset = ref_offset(ref) | REF_OBSOLETE;
 
@@ -622,7 +635,7 @@ void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
         /* The erase_free_sem is locked, and has been since before we marked the node obsolete
            and potentially put its eraseblock onto the erase_pending_list. Thus, we know that
            the block hasn't _already_ been erased, and that 'ref' itself hasn't been freed yet
-           by jffs2_free_all_node_refs() in erase.c. Which is nice. */
+           by jffs2_free_jeb_node_refs() in erase.c. Which is nice. */
 
         D1(printk(KERN_DEBUG "obliterating obsoleted node at 0x%08x\n", ref_offset(ref)));
         ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
@@ -634,8 +647,8 @@ void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
                 printk(KERN_WARNING "Short read from obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen);
                 goto out_erase_sem;
         }
-        if (PAD(je32_to_cpu(n.totlen)) != PAD(ref_totlen(c, jeb, ref))) {
-                printk(KERN_WARNING "Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n", je32_to_cpu(n.totlen), ref_totlen(c, jeb, ref));
+        if (PAD(je32_to_cpu(n.totlen)) != PAD(freed_len)) {
+                printk(KERN_WARNING "Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n", je32_to_cpu(n.totlen), freed_len);
                 goto out_erase_sem;
         }
         if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) {
@@ -671,6 +684,10 @@ void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
                 spin_lock(&c->erase_completion_lock);
 
                 ic = jffs2_raw_ref_to_ic(ref);
+                /* It seems we should never call jffs2_mark_node_obsolete() for
+                   XATTR nodes.... yet. Make sure we notice if/when we change
+                   that :) */
+                BUG_ON(ic->class != RAWNODE_CLASS_INODE_CACHE);
                 for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino))
                         ;
 
@@ -683,51 +700,6 @@ void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
                 spin_unlock(&c->erase_completion_lock);
         }
 
-
-        /* Merge with the next node in the physical list, if there is one
-           and if it's also obsolete and if it doesn't belong to any inode */
-        if (ref->next_phys && ref_obsolete(ref->next_phys) &&
-            !ref->next_phys->next_in_ino) {
-                struct jffs2_raw_node_ref *n = ref->next_phys;
-
-                spin_lock(&c->erase_completion_lock);
-
-                ref->__totlen += n->__totlen;
-                ref->next_phys = n->next_phys;
-                if (jeb->last_node == n) jeb->last_node = ref;
-                if (jeb->gc_node == n) {
-                        /* gc will be happy continuing gc on this node */
-                        jeb->gc_node=ref;
-                }
-                spin_unlock(&c->erase_completion_lock);
-
-                jffs2_free_raw_node_ref(n);
-        }
-
-        /* Also merge with the previous node in the list, if there is one
-           and that one is obsolete */
-        if (ref != jeb->first_node ) {
-                struct jffs2_raw_node_ref *p = jeb->first_node;
-
-                spin_lock(&c->erase_completion_lock);
-
-                while (p->next_phys != ref)
-                        p = p->next_phys;
-
-                if (ref_obsolete(p) && !ref->next_in_ino) {
-                        p->__totlen += ref->__totlen;
-                        if (jeb->last_node == ref) {
-                                jeb->last_node = p;
-                        }
-                        if (jeb->gc_node == ref) {
-                                /* gc will be happy continuing gc on this node */
-                                jeb->gc_node=p;
-                        }
-                        p->next_phys = ref->next_phys;
-                        jffs2_free_raw_node_ref(ref);
-                }
-                spin_unlock(&c->erase_completion_lock);
-        }
  out_erase_sem:
         up(&c->erase_free_sem);
 }
diff --git a/fs/jffs2/os-linux.h b/fs/jffs2/os-linux.h
index d307cf548625..cd4021bcb944 100644
--- a/fs/jffs2/os-linux.h
+++ b/fs/jffs2/os-linux.h
@@ -31,9 +31,7 @@ struct kvec;
 #define JFFS2_F_I_MODE(f) (OFNI_EDONI_2SFFJ(f)->i_mode)
 #define JFFS2_F_I_UID(f) (OFNI_EDONI_2SFFJ(f)->i_uid)
 #define JFFS2_F_I_GID(f) (OFNI_EDONI_2SFFJ(f)->i_gid)
-
-#define JFFS2_F_I_RDEV_MIN(f) (iminor(OFNI_EDONI_2SFFJ(f)))
-#define JFFS2_F_I_RDEV_MAJ(f) (imajor(OFNI_EDONI_2SFFJ(f)))
+#define JFFS2_F_I_RDEV(f) (OFNI_EDONI_2SFFJ(f)->i_rdev)
 
 #define ITIME(sec) ((struct timespec){sec, 0})
 #define I_SEC(tv) ((tv).tv_sec)
@@ -60,6 +58,10 @@ static inline void jffs2_init_inode_info(struct jffs2_inode_info *f)
         f->target = NULL;
         f->flags = 0;
         f->usercompr = 0;
+#ifdef CONFIG_JFFS2_FS_POSIX_ACL
+        f->i_acl_access = JFFS2_ACL_NOT_CACHED;
+        f->i_acl_default = JFFS2_ACL_NOT_CACHED;
+#endif
 }
 
 
@@ -90,13 +92,10 @@ static inline void jffs2_init_inode_info(struct jffs2_inode_info *f)
 #define jffs2_flash_writev(a,b,c,d,e,f) jffs2_flash_direct_writev(a,b,c,d,e)
 #define jffs2_wbuf_timeout NULL
 #define jffs2_wbuf_process NULL
-#define jffs2_nor_ecc(c) (0)
 #define jffs2_dataflash(c) (0)
-#define jffs2_nor_wbuf_flash(c) (0)
-#define jffs2_nor_ecc_flash_setup(c) (0)
-#define jffs2_nor_ecc_flash_cleanup(c) do {} while (0)
 #define jffs2_dataflash_setup(c) (0)
 #define jffs2_dataflash_cleanup(c) do {} while (0)
+#define jffs2_nor_wbuf_flash(c) (0)
 #define jffs2_nor_wbuf_flash_setup(c) (0)
 #define jffs2_nor_wbuf_flash_cleanup(c) do {} while (0)
 
@@ -107,9 +106,7 @@ static inline void jffs2_init_inode_info(struct jffs2_inode_info *f)
 #ifdef CONFIG_JFFS2_SUMMARY
 #define jffs2_can_mark_obsolete(c) (0)
 #else
-#define jffs2_can_mark_obsolete(c) \
-  ((c->mtd->type == MTD_NORFLASH && !(c->mtd->flags & (MTD_ECC|MTD_PROGRAM_REGIONS))) || \
-   c->mtd->type == MTD_RAM)
+#define jffs2_can_mark_obsolete(c) (c->mtd->flags & (MTD_BIT_WRITEABLE))
 #endif
 
 #define jffs2_cleanmarker_oob(c) (c->mtd->type == MTD_NANDFLASH)
@@ -133,15 +130,11 @@ int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c);
 int jffs2_nand_flash_setup(struct jffs2_sb_info *c);
 void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c);
 
-#define jffs2_nor_ecc(c) (c->mtd->type == MTD_NORFLASH && (c->mtd->flags & MTD_ECC))
-int jffs2_nor_ecc_flash_setup(struct jffs2_sb_info *c);
-void jffs2_nor_ecc_flash_cleanup(struct jffs2_sb_info *c);
-
 #define jffs2_dataflash(c) (c->mtd->type == MTD_DATAFLASH)
 int jffs2_dataflash_setup(struct jffs2_sb_info *c);
 void jffs2_dataflash_cleanup(struct jffs2_sb_info *c);
 
-#define jffs2_nor_wbuf_flash(c) (c->mtd->type == MTD_NORFLASH && (c->mtd->flags & MTD_PROGRAM_REGIONS))
+#define jffs2_nor_wbuf_flash(c) (c->mtd->type == MTD_NORFLASH && ! (c->mtd->flags & MTD_BIT_WRITEABLE))
 int jffs2_nor_wbuf_flash_setup(struct jffs2_sb_info *c);
 void jffs2_nor_wbuf_flash_cleanup(struct jffs2_sb_info *c);
 
diff --git a/fs/jffs2/readinode.c b/fs/jffs2/readinode.c
index f1695642d0f7..5fec012b02ed 100644
--- a/fs/jffs2/readinode.c
+++ b/fs/jffs2/readinode.c
@@ -66,7 +66,7 @@ static void jffs2_free_tmp_dnode_info_list(struct rb_root *list)
                         jffs2_free_full_dnode(tn->fn);
                         jffs2_free_tmp_dnode_info(tn);
 
-                        this = this->rb_parent;
+                        this = rb_parent(this);
                         if (!this)
                                 break;
 
@@ -116,19 +116,42 @@ static inline int read_direntry(struct jffs2_sb_info *c, struct jffs2_raw_node_r
                                 uint32_t *latest_mctime, uint32_t *mctime_ver)
 {
         struct jffs2_full_dirent *fd;
+        uint32_t crc;
 
-        /* The direntry nodes are checked during the flash scanning */
-        BUG_ON(ref_flags(ref) == REF_UNCHECKED);
         /* Obsoleted. This cannot happen, surely? dwmw2 20020308 */
         BUG_ON(ref_obsolete(ref));
 
-        /* Sanity check */
-        if (unlikely(PAD((rd->nsize + sizeof(*rd))) != PAD(je32_to_cpu(rd->totlen)))) {
-                JFFS2_ERROR("illegal nsize in node at %#08x: nsize %#02x, totlen %#04x\n",
-                       ref_offset(ref), rd->nsize, je32_to_cpu(rd->totlen));
+        crc = crc32(0, rd, sizeof(*rd) - 8);
+        if (unlikely(crc != je32_to_cpu(rd->node_crc))) {
+                JFFS2_NOTICE("header CRC failed on dirent node at %#08x: read %#08x, calculated %#08x\n",
+                             ref_offset(ref), je32_to_cpu(rd->node_crc), crc);
                 return 1;
         }
 
+        /* If we've never checked the CRCs on this node, check them now */
+        if (ref_flags(ref) == REF_UNCHECKED) {
+                struct jffs2_eraseblock *jeb;
+                int len;
+
+                /* Sanity check */
+                if (unlikely(PAD((rd->nsize + sizeof(*rd))) != PAD(je32_to_cpu(rd->totlen)))) {
+                        JFFS2_ERROR("illegal nsize in node at %#08x: nsize %#02x, totlen %#04x\n",
+                                    ref_offset(ref), rd->nsize, je32_to_cpu(rd->totlen));
+                        return 1;
+                }
+
+                jeb = &c->blocks[ref->flash_offset / c->sector_size];
+                len = ref_totlen(c, jeb, ref);
+
+                spin_lock(&c->erase_completion_lock);
+                jeb->used_size += len;
+                jeb->unchecked_size -= len;
+                c->used_size += len;
+                c->unchecked_size -= len;
+                ref->flash_offset = ref_offset(ref) | REF_PRISTINE;
+                spin_unlock(&c->erase_completion_lock);
+        }
+
         fd = jffs2_alloc_full_dirent(rd->nsize + 1);
         if (unlikely(!fd))
                 return -ENOMEM;
@@ -198,13 +221,21 @@ static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
         struct jffs2_tmp_dnode_info *tn;
         uint32_t len, csize;
         int ret = 1;
+        uint32_t crc;
 
         /* Obsoleted. This cannot happen, surely? dwmw2 20020308 */
         BUG_ON(ref_obsolete(ref));
 
+        crc = crc32(0, rd, sizeof(*rd) - 8);
+        if (unlikely(crc != je32_to_cpu(rd->node_crc))) {
+                JFFS2_NOTICE("node CRC failed on dnode at %#08x: read %#08x, calculated %#08x\n",
+                             ref_offset(ref), je32_to_cpu(rd->node_crc), crc);
+                return 1;
+        }
+
         tn = jffs2_alloc_tmp_dnode_info();
         if (!tn) {
-                JFFS2_ERROR("failed to allocate tn (%d bytes).\n", sizeof(*tn));
+                JFFS2_ERROR("failed to allocate tn (%zu bytes).\n", sizeof(*tn));
                 return -ENOMEM;
         }
 
@@ -213,14 +244,6 @@ static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
 
         /* If we've never checked the CRCs on this node, check them now */
         if (ref_flags(ref) == REF_UNCHECKED) {
-                uint32_t crc;
-
-                crc = crc32(0, rd, sizeof(*rd) - 8);
-                if (unlikely(crc != je32_to_cpu(rd->node_crc))) {
-                        JFFS2_NOTICE("header CRC failed on node at %#08x: read %#08x, calculated %#08x\n",
-                                        ref_offset(ref), je32_to_cpu(rd->node_crc), crc);
-                        goto free_out;
-                }
 
                 /* Sanity checks */
                 if (unlikely(je32_to_cpu(rd->offset) > je32_to_cpu(rd->isize)) ||
@@ -343,7 +366,7 @@ free_out:
  * Helper function for jffs2_get_inode_nodes().
  * It is called every time an unknown node is found.
  *
- * Returns: 0 on succes;
+ * Returns: 0 on success;
  *          1 if the node should be marked obsolete;
  *          negative error code on failure.
  */
@@ -354,37 +377,30 @@ static inline int read_unknown(struct jffs2_sb_info *c, struct jffs2_raw_node_re
 
         un->nodetype = cpu_to_je16(JFFS2_NODE_ACCURATE | je16_to_cpu(un->nodetype));
 
-        if (crc32(0, un, sizeof(struct jffs2_unknown_node) - 4) != je32_to_cpu(un->hdr_crc)) {
-                /* Hmmm. This should have been caught at scan time. */
-                JFFS2_NOTICE("node header CRC failed at %#08x. But it must have been OK earlier.\n", ref_offset(ref));
-                jffs2_dbg_dump_node(c, ref_offset(ref));
-                return 1;
-        } else {
-                switch(je16_to_cpu(un->nodetype) & JFFS2_COMPAT_MASK) {
+        switch(je16_to_cpu(un->nodetype) & JFFS2_COMPAT_MASK) {
 
-                case JFFS2_FEATURE_INCOMPAT:
-                        JFFS2_ERROR("unknown INCOMPAT nodetype %#04X at %#08x\n",
-                                je16_to_cpu(un->nodetype), ref_offset(ref));
-                        /* EEP */
-                        BUG();
-                        break;
+        case JFFS2_FEATURE_INCOMPAT:
+                JFFS2_ERROR("unknown INCOMPAT nodetype %#04X at %#08x\n",
+                            je16_to_cpu(un->nodetype), ref_offset(ref));
+                /* EEP */
+                BUG();
+                break;
 
-                case JFFS2_FEATURE_ROCOMPAT:
-                        JFFS2_ERROR("unknown ROCOMPAT nodetype %#04X at %#08x\n",
-                                        je16_to_cpu(un->nodetype), ref_offset(ref));
-                        BUG_ON(!(c->flags & JFFS2_SB_FLAG_RO));
-                        break;
+        case JFFS2_FEATURE_ROCOMPAT:
+                JFFS2_ERROR("unknown ROCOMPAT nodetype %#04X at %#08x\n",
+                            je16_to_cpu(un->nodetype), ref_offset(ref));
+                BUG_ON(!(c->flags & JFFS2_SB_FLAG_RO));
+                break;
 
-                case JFFS2_FEATURE_RWCOMPAT_COPY:
-                        JFFS2_NOTICE("unknown RWCOMPAT_COPY nodetype %#04X at %#08x\n",
-                                        je16_to_cpu(un->nodetype), ref_offset(ref));
-                        break;
+        case JFFS2_FEATURE_RWCOMPAT_COPY:
+                JFFS2_NOTICE("unknown RWCOMPAT_COPY nodetype %#04X at %#08x\n",
+                             je16_to_cpu(un->nodetype), ref_offset(ref));
+                break;
 
-                case JFFS2_FEATURE_RWCOMPAT_DELETE:
-                        JFFS2_NOTICE("unknown RWCOMPAT_DELETE nodetype %#04X at %#08x\n",
-                                        je16_to_cpu(un->nodetype), ref_offset(ref));
-                        return 1;
-                }
+        case JFFS2_FEATURE_RWCOMPAT_DELETE:
+                JFFS2_NOTICE("unknown RWCOMPAT_DELETE nodetype %#04X at %#08x\n",
+                             je16_to_cpu(un->nodetype), ref_offset(ref));
+                return 1;
         }
 
         return 0;
@@ -434,7 +450,7 @@ static int read_more(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
         }
 
         if (retlen < len) {
-                JFFS2_ERROR("short read at %#08x: %d instead of %d.\n",
+                JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n",
                                 offs, retlen, len);
                 return -EIO;
         }
@@ -542,13 +558,25 @@ static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_inf
                 }
 
                 if (retlen < len) {
-                        JFFS2_ERROR("short read at %#08x: %d instead of %d.\n", ref_offset(ref), retlen, len);
+                        JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n", ref_offset(ref), retlen, len);
                         err = -EIO;
                         goto free_out;
                 }
 
                 node = (union jffs2_node_union *)bufstart;
 
+                /* No need to mask in the valid bit; it shouldn't be invalid */
+                if (je32_to_cpu(node->u.hdr_crc) != crc32(0, node, sizeof(node->u)-4)) {
+                        JFFS2_NOTICE("Node header CRC failed at %#08x. {%04x,%04x,%08x,%08x}\n",
+                                     ref_offset(ref), je16_to_cpu(node->u.magic),
+                                     je16_to_cpu(node->u.nodetype),
+                                     je32_to_cpu(node->u.totlen),
+                                     je32_to_cpu(node->u.hdr_crc));
+                        jffs2_dbg_dump_node(c, ref_offset(ref));
+                        jffs2_mark_node_obsolete(c, ref);
+                        goto cont;
+                }
+
                 switch (je16_to_cpu(node->u.nodetype)) {
 
                 case JFFS2_NODETYPE_DIRENT:
@@ -606,6 +634,7 @@ static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_inf
                                 goto free_out;
 
                 }
+        cont:
                 spin_lock(&c->erase_completion_lock);
         }
 
@@ -679,12 +708,12 @@ static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
                         jffs2_mark_node_obsolete(c, fn->raw);
 
                 BUG_ON(rb->rb_left);
-                if (rb->rb_parent && rb->rb_parent->rb_left == rb) {
+                if (rb_parent(rb) && rb_parent(rb)->rb_left == rb) {
                         /* We were then left-hand child of our parent. We need
                          * to move our own right-hand child into our place. */
                         repl_rb = rb->rb_right;
                         if (repl_rb)
-                                repl_rb->rb_parent = rb->rb_parent;
+                                rb_set_parent(repl_rb, rb_parent(rb));
                 } else
                         repl_rb = NULL;
 
@@ -692,14 +721,14 @@ static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
 
                 /* Remove the spent tn from the tree; don't bother rebalancing
                  * but put our right-hand child in our own place. */
-                if (tn->rb.rb_parent) {
-                        if (tn->rb.rb_parent->rb_left == &tn->rb)
-                                tn->rb.rb_parent->rb_left = repl_rb;
-                        else if (tn->rb.rb_parent->rb_right == &tn->rb)
-                                tn->rb.rb_parent->rb_right = repl_rb;
+                if (rb_parent(&tn->rb)) {
+                        if (rb_parent(&tn->rb)->rb_left == &tn->rb)
+                                rb_parent(&tn->rb)->rb_left = repl_rb;
+                        else if (rb_parent(&tn->rb)->rb_right == &tn->rb)
+                                rb_parent(&tn->rb)->rb_right = repl_rb;
                         else BUG();
                 } else if (tn->rb.rb_right)
-                        tn->rb.rb_right->rb_parent = NULL;
+                        rb_set_parent(tn->rb.rb_right, NULL);
 
                 jffs2_free_tmp_dnode_info(tn);
                 if (ret) {
diff --git a/fs/jffs2/scan.c b/fs/jffs2/scan.c
index cf55b221fc2b..61618080b86f 100644
--- a/fs/jffs2/scan.c
+++ b/fs/jffs2/scan.c
@@ -65,6 +65,28 @@ static inline uint32_t EMPTY_SCAN_SIZE(uint32_t sector_size) {
                 return DEFAULT_EMPTY_SCAN_SIZE;
 }
 
+static int file_dirty(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
+{
+        int ret;
+
+        if ((ret = jffs2_prealloc_raw_node_refs(c, jeb, 1)))
+                return ret;
+        if ((ret = jffs2_scan_dirty_space(c, jeb, jeb->free_size)))
+                return ret;
+        /* Turned wasted size into dirty, since we apparently 
+           think it's recoverable now. */
+        jeb->dirty_size += jeb->wasted_size;
+        c->dirty_size += jeb->wasted_size;
+        c->wasted_size -= jeb->wasted_size;
+        jeb->wasted_size = 0;
+        if (VERYDIRTY(c, jeb->dirty_size)) {
+                list_add(&jeb->list, &c->very_dirty_list);
+        } else {
+                list_add(&jeb->list, &c->dirty_list);
+        }
+        return 0;
+}
+
 int jffs2_scan_medium(struct jffs2_sb_info *c)
 {
         int i, ret;
@@ -170,34 +192,20 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
                                         (!c->nextblock || c->nextblock->free_size < jeb->free_size)) {
                                 /* Better candidate for the next writes to go to */
                                 if (c->nextblock) {
-                                        c->nextblock->dirty_size += c->nextblock->free_size + c->nextblock->wasted_size;
-                                        c->dirty_size += c->nextblock->free_size + c->nextblock->wasted_size;
-                                        c->free_size -= c->nextblock->free_size;
-                                        c->wasted_size -= c->nextblock->wasted_size;
-                                        c->nextblock->free_size = c->nextblock->wasted_size = 0;
-                                        if (VERYDIRTY(c, c->nextblock->dirty_size)) {
-                                                list_add(&c->nextblock->list, &c->very_dirty_list);
-                                        } else {
-                                                list_add(&c->nextblock->list, &c->dirty_list);
-                                        }
+                                        ret = file_dirty(c, c->nextblock);
+                                        if (ret)
+                                                return ret;
                                         /* deleting summary information of the old nextblock */
                                         jffs2_sum_reset_collected(c->summary);
                                 }
-                                /* update collected summary infromation for the current nextblock */
+                                /* update collected summary information for the current nextblock */
                                 jffs2_sum_move_collected(c, s);
                                 D1(printk(KERN_DEBUG "jffs2_scan_medium(): new nextblock = 0x%08x\n", jeb->offset));
                                 c->nextblock = jeb;
                         } else {
-                                jeb->dirty_size += jeb->free_size + jeb->wasted_size;
-                                c->dirty_size += jeb->free_size + jeb->wasted_size;
-                                c->free_size -= jeb->free_size;
-                                c->wasted_size -= jeb->wasted_size;
-                                jeb->free_size = jeb->wasted_size = 0;
-                                if (VERYDIRTY(c, jeb->dirty_size)) {
-                                        list_add(&jeb->list, &c->very_dirty_list);
-                                } else {
-                                        list_add(&jeb->list, &c->dirty_list);
-                                }
+                                ret = file_dirty(c, jeb);
+                                if (ret)
+                                        return ret;
                         }
                         break;
 
@@ -222,9 +230,6 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
                 }
         }
 
-        if (jffs2_sum_active() && s)
-                kfree(s);
-
         /* Nextblock dirty is always seen as wasted, because we cannot recycle it now */
         if (c->nextblock && (c->nextblock->dirty_size)) {
                 c->nextblock->wasted_size += c->nextblock->dirty_size;
@@ -242,11 +247,8 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
 
                 D1(printk(KERN_DEBUG "jffs2_scan_medium(): Skipping %d bytes in nextblock to ensure page alignment\n",
                           skip));
-                c->nextblock->wasted_size += skip;
-                c->wasted_size += skip;
-
-                c->nextblock->free_size -= skip;
-                c->free_size -= skip;
+                jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
+                jffs2_scan_dirty_space(c, c->nextblock, skip);
         }
 #endif
         if (c->nr_erasing_blocks) {
@@ -266,6 +268,9 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
         else
                 c->mtd->unpoint(c->mtd, flashbuf, 0, c->mtd->size);
 #endif
+        if (s)
+                kfree(s);
+
         return ret;
 }
 
@@ -290,7 +295,7 @@ int jffs2_fill_scan_buf (struct jffs2_sb_info *c, void *buf,
 int jffs2_scan_classify_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
 {
         if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size
-                && (!jeb->first_node || !jeb->first_node->next_phys) )
+            && (!jeb->first_node || !ref_next(jeb->first_node)) )
                 return BLK_STATE_CLEANMARKER;
 
         /* move blocks with max 4 byte dirty space to cleanlist */
@@ -306,11 +311,119 @@ int jffs2_scan_classify_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *je
                 return BLK_STATE_ALLDIRTY;
 }
 
+#ifdef CONFIG_JFFS2_FS_XATTR
+static int jffs2_scan_xattr_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
+                                 struct jffs2_raw_xattr *rx, uint32_t ofs,
+                                 struct jffs2_summary *s)
+{
+        struct jffs2_xattr_datum *xd;
+        uint32_t totlen, crc;
+        int err;
+
+        crc = crc32(0, rx, sizeof(struct jffs2_raw_xattr) - 4);
+        if (crc != je32_to_cpu(rx->node_crc)) {
+                if (je32_to_cpu(rx->node_crc) != 0xffffffff)
+                        JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n",
+                                      ofs, je32_to_cpu(rx->node_crc), crc);
+                if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rx->totlen))))
+                        return err;
+                return 0;
+        }
+
+        totlen = PAD(sizeof(*rx) + rx->name_len + 1 + je16_to_cpu(rx->value_len));
+        if (totlen != je32_to_cpu(rx->totlen)) {
+                JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%u\n",
+                              ofs, je32_to_cpu(rx->totlen), totlen);
+                if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rx->totlen))))
+                        return err;
+                return 0;
+        }
+
+        xd = jffs2_setup_xattr_datum(c, je32_to_cpu(rx->xid), je32_to_cpu(rx->version));
+        if (IS_ERR(xd)) {
+                if (PTR_ERR(xd) == -EEXIST) {
+                        if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rx->totlen)))))
+                                return err;
+                        return 0;
+                }
+                return PTR_ERR(xd);
+        }
+        xd->xprefix = rx->xprefix;
+        xd->name_len = rx->name_len;
+        xd->value_len = je16_to_cpu(rx->value_len);
+        xd->data_crc = je32_to_cpu(rx->data_crc);
+
+        xd->node = jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, totlen, NULL);
+        /* FIXME */ xd->node->next_in_ino = (void *)xd;
+
+        if (jffs2_sum_active())
+                jffs2_sum_add_xattr_mem(s, rx, ofs - jeb->offset);
+        dbg_xattr("scaning xdatum at %#08x (xid=%u, version=%u)\n",
+                  ofs, xd->xid, xd->version);
+        return 0;
+}
+
+static int jffs2_scan_xref_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
+                                struct jffs2_raw_xref *rr, uint32_t ofs,
+                                struct jffs2_summary *s)
+{
+        struct jffs2_xattr_ref *ref;
+        uint32_t crc;
+        int err;
+
+        crc = crc32(0, rr, sizeof(*rr) - 4);
+        if (crc != je32_to_cpu(rr->node_crc)) {
+                if (je32_to_cpu(rr->node_crc) != 0xffffffff)
+                        JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n",
+                                      ofs, je32_to_cpu(rr->node_crc), crc);
+                if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rr->totlen)))))
+                        return err;
+                return 0;
+        }
+
+        if (PAD(sizeof(struct jffs2_raw_xref)) != je32_to_cpu(rr->totlen)) {
+                JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%zd\n",
+                              ofs, je32_to_cpu(rr->totlen),
+                              PAD(sizeof(struct jffs2_raw_xref)));
+                if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rr->totlen))))
+                        return err;
+                return 0;
+        }
+
+        ref = jffs2_alloc_xattr_ref();
+        if (!ref)
+                return -ENOMEM;
+
+        /* BEFORE jffs2_build_xattr_subsystem() called, 
+         * ref->xid is used to store 32bit xid, xd is not used
+         * ref->ino is used to store 32bit inode-number, ic is not used
+         * Thoes variables are declared as union, thus using those
+         * are exclusive. In a similar way, ref->next is temporarily
+         * used to chain all xattr_ref object. It's re-chained to
+         * jffs2_inode_cache in jffs2_build_xattr_subsystem() correctly.
+         */
+        ref->ino = je32_to_cpu(rr->ino);
+        ref->xid = je32_to_cpu(rr->xid);
+        ref->next = c->xref_temp;
+        c->xref_temp = ref;
+
+        ref->node = jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(rr->totlen)), NULL);
+        /* FIXME */ ref->node->next_in_ino = (void *)ref;
+
+        if (jffs2_sum_active())
+                jffs2_sum_add_xref_mem(s, rr, ofs - jeb->offset);
+        dbg_xattr("scan xref at %#08x (xid=%u, ino=%u)\n",
+                  ofs, ref->xid, ref->ino);
+        return 0;
+}
+#endif
+
+/* Called with 'buf_size == 0' if buf is in fact a pointer _directly_ into
+   the flash, XIP-style */
 static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
-                                unsigned char *buf, uint32_t buf_size, struct jffs2_summary *s) {
+                                  unsigned char *buf, uint32_t buf_size, struct jffs2_summary *s) {
         struct jffs2_unknown_node *node;
         struct jffs2_unknown_node crcnode;
-        struct jffs2_sum_marker *sm;
         uint32_t ofs, prevofs;
         uint32_t hdr_crc, buf_ofs, buf_len;
         int err;
@@ -344,44 +457,75 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
 #endif
 
         if (jffs2_sum_active()) {
-                sm = kmalloc(sizeof(struct jffs2_sum_marker), GFP_KERNEL);
-                if (!sm) {
-                        return -ENOMEM;
-                }
-
-                err = jffs2_fill_scan_buf(c, (unsigned char *) sm, jeb->offset + c->sector_size -
-                                        sizeof(struct jffs2_sum_marker), sizeof(struct jffs2_sum_marker));
-                if (err) {
-                        kfree(sm);
-                        return err;
-                }
-
-                if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC ) {
-                        err = jffs2_sum_scan_sumnode(c, jeb, je32_to_cpu(sm->offset), &pseudo_random);
-                        if (err) {
-                                kfree(sm);
+                struct jffs2_sum_marker *sm;
+                void *sumptr = NULL;
+                uint32_t sumlen;
+              
+                if (!buf_size) {
+                        /* XIP case. Just look, point at the summary if it's there */
+                        sm = (void *)buf + c->sector_size - sizeof(*sm);
+                        if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) {
+                                sumptr = buf + je32_to_cpu(sm->offset);
+                                sumlen = c->sector_size - je32_to_cpu(sm->offset);
+                        }
+                } else {
+                        /* If NAND flash, read a whole page of it. Else just the end */
+                        if (c->wbuf_pagesize)
+                                buf_len = c->wbuf_pagesize;
+                        else
+                                buf_len = sizeof(*sm);
+
+                        /* Read as much as we want into the _end_ of the preallocated buffer */
+                        err = jffs2_fill_scan_buf(c, buf + buf_size - buf_len, 
+                                                  jeb->offset + c->sector_size - buf_len,
+                                                  buf_len);                             
+                        if (err)
                                 return err;
+
+                        sm = (void *)buf + buf_size - sizeof(*sm);
+                        if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) {
+                                sumlen = c->sector_size - je32_to_cpu(sm->offset);
+                                sumptr = buf + buf_size - sumlen;
+
+                                /* Now, make sure the summary itself is available */
+                                if (sumlen > buf_size) {
+                                        /* Need to kmalloc for this. */
+                                        sumptr = kmalloc(sumlen, GFP_KERNEL);
+                                        if (!sumptr)
+                                                return -ENOMEM;
+                                        memcpy(sumptr + sumlen - buf_len, buf + buf_size - buf_len, buf_len);
+                                }
+                                if (buf_len < sumlen) {
+                                        /* Need to read more so that the entire summary node is present */
+                                        err = jffs2_fill_scan_buf(c, sumptr, 
+                                                                  jeb->offset + c->sector_size - sumlen,
+                                                                  sumlen - buf_len);                            
+                                        if (err)
+                                                return err;
+                                }
                         }
+
                 }
 
-                kfree(sm);
+                if (sumptr) {
+                        err = jffs2_sum_scan_sumnode(c, jeb, sumptr, sumlen, &pseudo_random);
 
-                ofs = jeb->offset;
-                prevofs = jeb->offset - 1;
+                        if (buf_size && sumlen > buf_size)
+                                kfree(sumptr);
+                        /* If it returns with a real error, bail. 
+                           If it returns positive, that's a block classification
+                           (i.e. BLK_STATE_xxx) so return that too.
+                           If it returns zero, fall through to full scan. */
+                        if (err)
+                                return err;
+                }
         }
 
         buf_ofs = jeb->offset;
 
         if (!buf_size) {
+                /* This is the XIP case -- we're reading _directly_ from the flash chip */
                 buf_len = c->sector_size;
-
-                if (jffs2_sum_active()) {
-                        /* must reread because of summary test */
-                        err = jffs2_fill_scan_buf(c, buf, buf_ofs, buf_len);
-                        if (err)
-                                return err;
-                }
-
         } else {
                 buf_len = EMPTY_SCAN_SIZE(c->sector_size);
                 err = jffs2_fill_scan_buf(c, buf, buf_ofs, buf_len);
@@ -418,7 +562,10 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
         if (ofs) {
                 D1(printk(KERN_DEBUG "Free space at %08x ends at %08x\n", jeb->offset,
                           jeb->offset + ofs));
-                DIRTY_SPACE(ofs);
+                if ((err = jffs2_prealloc_raw_node_refs(c, jeb, 1)))
+                        return err;
+                if ((err = jffs2_scan_dirty_space(c, jeb, ofs)))
+                        return err;
         }
 
         /* Now ofs is a complete physical flash offset as it always was... */
@@ -433,6 +580,11 @@ scan_more:
 
                 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
 
+                /* Make sure there are node refs available for use */
+                err = jffs2_prealloc_raw_node_refs(c, jeb, 2);
+                if (err)
+                        return err;
+
                 cond_resched();
 
                 if (ofs & 3) {
@@ -442,7 +594,8 @@ scan_more:
                 }
                 if (ofs == prevofs) {
                         printk(KERN_WARNING "ofs 0x%08x has already been seen. Skipping\n", ofs);
-                        DIRTY_SPACE(4);
+                        if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
+                                return err;
                         ofs += 4;
                         continue;
                 }
@@ -451,7 +604,8 @@ scan_more:
                 if (jeb->offset + c->sector_size < ofs + sizeof(*node)) {
                         D1(printk(KERN_DEBUG "Fewer than %zd bytes left to end of block. (%x+%x<%x+%zx) Not reading\n", sizeof(struct jffs2_unknown_node),
                                   jeb->offset, c->sector_size, ofs, sizeof(*node)));
-                        DIRTY_SPACE((jeb->offset + c->sector_size)-ofs);
+                        if ((err = jffs2_scan_dirty_space(c, jeb, (jeb->offset + c->sector_size)-ofs)))
+                                return err;
                         break;
                 }
 
@@ -481,7 +635,8 @@ scan_more:
                                 if (*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff) {
                                         printk(KERN_WARNING "Empty flash at 0x%08x ends at 0x%08x\n",
                                                empty_start, ofs);
-                                        DIRTY_SPACE(ofs-empty_start);
+                                        if ((err = jffs2_scan_dirty_space(c, jeb, ofs-empty_start)))
+                                                return err;
                                         goto scan_more;
                                 }
 
@@ -494,7 +649,7 @@ scan_more:
                         /* If we're only checking the beginning of a block with a cleanmarker,
                            bail now */
                         if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) &&
-                            c->cleanmarker_size && !jeb->dirty_size && !jeb->first_node->next_phys) {
+                            c->cleanmarker_size && !jeb->dirty_size && !ref_next(jeb->first_node)) {
                                 D1(printk(KERN_DEBUG "%d bytes at start of block seems clean... assuming all clean\n", EMPTY_SCAN_SIZE(c->sector_size)));
                                 return BLK_STATE_CLEANMARKER;
                         }
@@ -518,20 +673,23 @@ scan_more:
 
                 if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) {
                         printk(KERN_WARNING "Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n", ofs);
-                        DIRTY_SPACE(4);
+                        if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
+                                return err;
                         ofs += 4;
                         continue;
                 }
                 if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) {
                         D1(printk(KERN_DEBUG "Dirty bitmask at 0x%08x\n", ofs));
-                        DIRTY_SPACE(4);
+                        if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
+                                return err;
                         ofs += 4;
                         continue;
                 }
                 if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) {
                         printk(KERN_WARNING "Old JFFS2 bitmask found at 0x%08x\n", ofs);
                         printk(KERN_WARNING "You cannot use older JFFS2 filesystems with newer kernels\n");
-                        DIRTY_SPACE(4);
+                        if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
+                                return err;
                         ofs += 4;
                         continue;
                 }
@@ -540,7 +698,8 @@ scan_more:
                         noisy_printk(&noise, "jffs2_scan_eraseblock(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
                                      JFFS2_MAGIC_BITMASK, ofs,
                                      je16_to_cpu(node->magic));
-                        DIRTY_SPACE(4);
+                        if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
+                                return err;
                         ofs += 4;
                         continue;
                 }
@@ -557,7 +716,8 @@ scan_more:
                                      je32_to_cpu(node->totlen),
                                      je32_to_cpu(node->hdr_crc),
                                      hdr_crc);
-                        DIRTY_SPACE(4);
+                        if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
+                                return err;
                         ofs += 4;
                         continue;
                 }
@@ -568,7 +728,8 @@ scan_more:
                         printk(KERN_WARNING "Node at 0x%08x with length 0x%08x would run over the end of the erase block\n",
                                ofs, je32_to_cpu(node->totlen));
                         printk(KERN_WARNING "Perhaps the file system was created with the wrong erase size?\n");
-                        DIRTY_SPACE(4);
+                        if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
+                                return err;
                         ofs += 4;
                         continue;
                 }
@@ -576,7 +737,8 @@ scan_more:
                 if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) {
                         /* Wheee. This is an obsoleted node */
                         D2(printk(KERN_DEBUG "Node at 0x%08x is obsolete. Skipping\n", ofs));
-                        DIRTY_SPACE(PAD(je32_to_cpu(node->totlen)));
+                        if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
+                                return err;
                         ofs += PAD(je32_to_cpu(node->totlen));
                         continue;
                 }
@@ -614,30 +776,59 @@ scan_more:
                         ofs += PAD(je32_to_cpu(node->totlen));
                         break;
 
+#ifdef CONFIG_JFFS2_FS_XATTR
+                case JFFS2_NODETYPE_XATTR:
+                        if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
+                                buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
+                                D1(printk(KERN_DEBUG "Fewer than %d bytes (xattr node)"
+                                          " left to end of buf. Reading 0x%x at 0x%08x\n",
+                                          je32_to_cpu(node->totlen), buf_len, ofs));
+                                err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
+                                if (err)
+                                        return err;
+                                buf_ofs = ofs;
+                                node = (void *)buf;
+                        }
+                        err = jffs2_scan_xattr_node(c, jeb, (void *)node, ofs, s);
+                        if (err)
+                                return err;
+                        ofs += PAD(je32_to_cpu(node->totlen));
+                        break;
+                case JFFS2_NODETYPE_XREF:
+                        if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
+                                buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
+                                D1(printk(KERN_DEBUG "Fewer than %d bytes (xref node)"
+                                          " left to end of buf. Reading 0x%x at 0x%08x\n",
+                                          je32_to_cpu(node->totlen), buf_len, ofs));
+                                err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
+                                if (err)
+                                        return err;
+                                buf_ofs = ofs;
+                                node = (void *)buf;
+                        }
+                        err = jffs2_scan_xref_node(c, jeb, (void *)node, ofs, s);
+                        if (err)
+                                return err;
+                        ofs += PAD(je32_to_cpu(node->totlen));
+                        break;
+#endif  /* CONFIG_JFFS2_FS_XATTR */
+
                 case JFFS2_NODETYPE_CLEANMARKER:
                         D1(printk(KERN_DEBUG "CLEANMARKER node found at 0x%08x\n", ofs));
                         if (je32_to_cpu(node->totlen) != c->cleanmarker_size) {
                                 printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n",
                                        ofs, je32_to_cpu(node->totlen), c->cleanmarker_size);
-                                DIRTY_SPACE(PAD(sizeof(struct jffs2_unknown_node)));
+                                if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node)))))
+                                        return err;
                                 ofs += PAD(sizeof(struct jffs2_unknown_node));
                         } else if (jeb->first_node) {
                                 printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n", ofs, jeb->offset);
-                                DIRTY_SPACE(PAD(sizeof(struct jffs2_unknown_node)));
+                                if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node)))))
+                                        return err;
                                 ofs += PAD(sizeof(struct jffs2_unknown_node));
                         } else {
-                                struct jffs2_raw_node_ref *marker_ref = jffs2_alloc_raw_node_ref();
-                                if (!marker_ref) {
-                                        printk(KERN_NOTICE "Failed to allocate node ref for clean marker\n");
-                                        return -ENOMEM;
-                                }
-                                marker_ref->next_in_ino = NULL;
-                                marker_ref->next_phys = NULL;
-                                marker_ref->flash_offset = ofs | REF_NORMAL;
-                                marker_ref->__totlen = c->cleanmarker_size;
-                                jeb->first_node = jeb->last_node = marker_ref;
+                                jffs2_link_node_ref(c, jeb, ofs | REF_NORMAL, c->cleanmarker_size, NULL);
 
-                                USED_SPACE(PAD(c->cleanmarker_size));
                                 ofs += PAD(c->cleanmarker_size);
                         }
                         break;
@@ -645,7 +836,8 @@ scan_more:
                 case JFFS2_NODETYPE_PADDING:
                         if (jffs2_sum_active())
                                 jffs2_sum_add_padding_mem(s, je32_to_cpu(node->totlen));
-                        DIRTY_SPACE(PAD(je32_to_cpu(node->totlen)));
+                        if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
+                                return err;
                         ofs += PAD(je32_to_cpu(node->totlen));
                         break;
 
@@ -656,7 +848,8 @@ scan_more:
                                 c->flags |= JFFS2_SB_FLAG_RO;
                                 if (!(jffs2_is_readonly(c)))
                                         return -EROFS;
-                                DIRTY_SPACE(PAD(je32_to_cpu(node->totlen)));
+                                if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
+                                        return err;
                                 ofs += PAD(je32_to_cpu(node->totlen));
                                 break;
 
@@ -666,15 +859,21 @@ scan_more:
 
                         case JFFS2_FEATURE_RWCOMPAT_DELETE:
                                 D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs));
-                                DIRTY_SPACE(PAD(je32_to_cpu(node->totlen)));
+                                if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
+                                        return err;
                                 ofs += PAD(je32_to_cpu(node->totlen));
                                 break;
 
-                        case JFFS2_FEATURE_RWCOMPAT_COPY:
+                        case JFFS2_FEATURE_RWCOMPAT_COPY: {
                                 D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs));
-                                USED_SPACE(PAD(je32_to_cpu(node->totlen)));
+
+                                jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(node->totlen)), NULL);
+
+                                /* We can't summarise nodes we don't grok */
+                                jffs2_sum_disable_collecting(s);
                                 ofs += PAD(je32_to_cpu(node->totlen));
                                 break;
+                                }
                         }
                 }
         }
@@ -687,9 +886,9 @@ scan_more:
                 }
         }
 
-        D1(printk(KERN_DEBUG "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x\n", jeb->offset,
-                  jeb->free_size, jeb->dirty_size, jeb->unchecked_size, jeb->used_size));
-
+        D1(printk(KERN_DEBUG "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x, wasted 0x%08x\n",
+                  jeb->offset,jeb->free_size, jeb->dirty_size, jeb->unchecked_size, jeb->used_size, jeb->wasted_size));
+        
         /* mark_node_obsolete can add to wasted !! */
         if (jeb->wasted_size) {
                 jeb->dirty_size += jeb->wasted_size;
@@ -730,9 +929,9 @@ struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uin
 static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
                                  struct jffs2_raw_inode *ri, uint32_t ofs, struct jffs2_summary *s)
 {
-        struct jffs2_raw_node_ref *raw;
         struct jffs2_inode_cache *ic;
         uint32_t ino = je32_to_cpu(ri->ino);
+        int err;
 
         D1(printk(KERN_DEBUG "jffs2_scan_inode_node(): Node at 0x%08x\n", ofs));
 
@@ -745,12 +944,6 @@ static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_erasebloc
            Which means that the _full_ amount of time to get to proper write mode with GC
            operational may actually be _longer_ than before. Sucks to be me. */
 
-        raw = jffs2_alloc_raw_node_ref();
-        if (!raw) {
-                printk(KERN_NOTICE "jffs2_scan_inode_node(): allocation of node reference failed\n");
-                return -ENOMEM;
-        }
-
         ic = jffs2_get_ino_cache(c, ino);
         if (!ic) {
                 /* Inocache get failed. Either we read a bogus ino# or it's just genuinely the
@@ -762,30 +955,17 @@ static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_erasebloc
                         printk(KERN_NOTICE "jffs2_scan_inode_node(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
                                ofs, je32_to_cpu(ri->node_crc), crc);
                         /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */
-                        DIRTY_SPACE(PAD(je32_to_cpu(ri->totlen)));
-                        jffs2_free_raw_node_ref(raw);
+                        if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(ri->totlen)))))
+                                return err;
                         return 0;
                 }
                 ic = jffs2_scan_make_ino_cache(c, ino);
-                if (!ic) {
-                        jffs2_free_raw_node_ref(raw);
+                if (!ic)
                         return -ENOMEM;
-                }
         }
 
         /* Wheee. It worked */
-
-        raw->flash_offset = ofs | REF_UNCHECKED;
-        raw->__totlen = PAD(je32_to_cpu(ri->totlen));
-        raw->next_phys = NULL;
-        raw->next_in_ino = ic->nodes;
-
-        ic->nodes = raw;
-        if (!jeb->first_node)
-                jeb->first_node = raw;
-        if (jeb->last_node)
-                jeb->last_node->next_phys = raw;
-        jeb->last_node = raw;
+        jffs2_link_node_ref(c, jeb, ofs | REF_UNCHECKED, PAD(je32_to_cpu(ri->totlen)), ic);
 
         D1(printk(KERN_DEBUG "Node is ino #%u, version %d. Range 0x%x-0x%x\n",
                   je32_to_cpu(ri->ino), je32_to_cpu(ri->version),
@@ -794,8 +974,6 @@ static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_erasebloc
 
         pseudo_random += je32_to_cpu(ri->version);
 
-        UNCHECKED_SPACE(PAD(je32_to_cpu(ri->totlen)));
-
         if (jffs2_sum_active()) {
                 jffs2_sum_add_inode_mem(s, ri, ofs - jeb->offset);
         }
@@ -806,10 +984,10 @@ static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_erasebloc
 static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
                                   struct jffs2_raw_dirent *rd, uint32_t ofs, struct jffs2_summary *s)
 {
-        struct jffs2_raw_node_ref *raw;
         struct jffs2_full_dirent *fd;
         struct jffs2_inode_cache *ic;
         uint32_t crc;
+        int err;
 
         D1(printk(KERN_DEBUG "jffs2_scan_dirent_node(): Node at 0x%08x\n", ofs));
 
@@ -821,7 +999,8 @@ static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblo
                 printk(KERN_NOTICE "jffs2_scan_dirent_node(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
                        ofs, je32_to_cpu(rd->node_crc), crc);
                 /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */
-                DIRTY_SPACE(PAD(je32_to_cpu(rd->totlen)));
+                if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen)))))
+                        return err;
                 return 0;
         }
 
@@ -842,40 +1021,23 @@ static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblo
                 jffs2_free_full_dirent(fd);
                 /* FIXME: Why do we believe totlen? */
                 /* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */
-                DIRTY_SPACE(PAD(je32_to_cpu(rd->totlen)));
+                if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen)))))
+                        return err;
                 return 0;
         }
-        raw = jffs2_alloc_raw_node_ref();
-        if (!raw) {
-                jffs2_free_full_dirent(fd);
-                printk(KERN_NOTICE "jffs2_scan_dirent_node(): allocation of node reference failed\n");
-                return -ENOMEM;
-        }
         ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino));
         if (!ic) {
                 jffs2_free_full_dirent(fd);
-                jffs2_free_raw_node_ref(raw);
                 return -ENOMEM;
         }
 
-        raw->__totlen = PAD(je32_to_cpu(rd->totlen));
-        raw->flash_offset = ofs | REF_PRISTINE;
-        raw->next_phys = NULL;
-        raw->next_in_ino = ic->nodes;
-        ic->nodes = raw;
-        if (!jeb->first_node)
-                jeb->first_node = raw;
-        if (jeb->last_node)
-                jeb->last_node->next_phys = raw;
-        jeb->last_node = raw;
+        fd->raw = jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(rd->totlen)), ic);
 
-        fd->raw = raw;
         fd->next = NULL;
         fd->version = je32_to_cpu(rd->version);
         fd->ino = je32_to_cpu(rd->ino);
         fd->nhash = full_name_hash(fd->name, rd->nsize);
         fd->type = rd->type;
-        USED_SPACE(PAD(je32_to_cpu(rd->totlen)));
         jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
 
         if (jffs2_sum_active()) {
diff --git a/fs/jffs2/security.c b/fs/jffs2/security.c
new file mode 100644
index 000000000000..52a9894a6364
--- /dev/null
+++ b/fs/jffs2/security.c
@@ -0,0 +1,82 @@
+/*
+ * JFFS2 -- Journalling Flash File System, Version 2.
+ *
+ * Copyright (C) 2006  NEC Corporation
+ *
+ * Created by KaiGai Kohei <kaigai@ak.jp.nec.com>
+ *
+ * For licensing information, see the file 'LICENCE' in this directory.
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/time.h>
+#include <linux/pagemap.h>
+#include <linux/highmem.h>
+#include <linux/crc32.h>
+#include <linux/jffs2.h>
+#include <linux/xattr.h>
+#include <linux/mtd/mtd.h>
+#include <linux/security.h>
+#include "nodelist.h"
+
+/* ---- Initial Security Label Attachment -------------- */
+int jffs2_init_security(struct inode *inode, struct inode *dir)
+{
+        int rc;
+        size_t len;
+        void *value;
+        char *name;
+
+        rc = security_inode_init_security(inode, dir, &name, &value, &len);
+        if (rc) {
+                if (rc == -EOPNOTSUPP)
+                        return 0;
+                return rc;
+        }
+        rc = do_jffs2_setxattr(inode, JFFS2_XPREFIX_SECURITY, name, value, len, 0);
+
+        kfree(name);
+        kfree(value);
+        return rc;
+}
+
+/* ---- XATTR Handler for "security.*" ----------------- */
+static int jffs2_security_getxattr(struct inode *inode, const char *name,
+                                   void *buffer, size_t size)
+{
+        if (!strcmp(name, ""))
+                return -EINVAL;
+
+        return do_jffs2_getxattr(inode, JFFS2_XPREFIX_SECURITY, name, buffer, size);
+}
+
+static int jffs2_security_setxattr(struct inode *inode, const char *name, const void *buffer,
+                                   size_t size, int flags)
+{
+        if (!strcmp(name, ""))
+                return -EINVAL;
+
+        return do_jffs2_setxattr(inode, JFFS2_XPREFIX_SECURITY, name, buffer, size, flags);
+}
+
+static size_t jffs2_security_listxattr(struct inode *inode, char *list, size_t list_size,
+                                       const char *name, size_t name_len)
+{
+        size_t retlen = XATTR_SECURITY_PREFIX_LEN + name_len + 1;
+
+        if (list && retlen <= list_size) {
+                strcpy(list, XATTR_SECURITY_PREFIX);
+                strcpy(list + XATTR_SECURITY_PREFIX_LEN, name);
+        }
+
+        return retlen;
+}
+
+struct xattr_handler jffs2_security_xattr_handler = {
+        .prefix = XATTR_SECURITY_PREFIX,
+        .list = jffs2_security_listxattr,
+        .set = jffs2_security_setxattr,
+        .get = jffs2_security_getxattr
+};
diff --git a/fs/jffs2/summary.c b/fs/jffs2/summary.c
index fb9cec61fcf2..0b02fc79e4d1 100644
--- a/fs/jffs2/summary.c
+++ b/fs/jffs2/summary.c
@@ -5,6 +5,7 @@
  *                     Zoltan Sogor <weth@inf.u-szeged.hu>,
  *                     Patrik Kluba <pajko@halom.u-szeged.hu>,
  *                     University of Szeged, Hungary
+ *               2005  KaiGai Kohei <kaigai@ak.jp.nec.com>
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
@@ -81,6 +82,19 @@ static int jffs2_sum_add_mem(struct jffs2_summary *s, union jffs2_sum_mem *item)
                         dbg_summary("dirent (%u) added to summary\n",
                                                 je32_to_cpu(item->d.ino));
                         break;
+#ifdef CONFIG_JFFS2_FS_XATTR
+                case JFFS2_NODETYPE_XATTR:
+                        s->sum_size += JFFS2_SUMMARY_XATTR_SIZE;
+                        s->sum_num++;
+                        dbg_summary("xattr (xid=%u, version=%u) added to summary\n",
+                                    je32_to_cpu(item->x.xid), je32_to_cpu(item->x.version));
+                        break;
+                case JFFS2_NODETYPE_XREF:
+                        s->sum_size += JFFS2_SUMMARY_XREF_SIZE;
+                        s->sum_num++;
+                        dbg_summary("xref added to summary\n");
+                        break;
+#endif
                 default:
                         JFFS2_WARNING("UNKNOWN node type %u\n",
                                             je16_to_cpu(item->u.nodetype));
@@ -141,6 +155,40 @@ int jffs2_sum_add_dirent_mem(struct jffs2_summary *s, struct jffs2_raw_dirent *r
         return jffs2_sum_add_mem(s, (union jffs2_sum_mem *)temp);
 }
 
+#ifdef CONFIG_JFFS2_FS_XATTR
+int jffs2_sum_add_xattr_mem(struct jffs2_summary *s, struct jffs2_raw_xattr *rx, uint32_t ofs)
+{
+        struct jffs2_sum_xattr_mem *temp;
+
+        temp = kmalloc(sizeof(struct jffs2_sum_xattr_mem), GFP_KERNEL);
+        if (!temp)
+                return -ENOMEM;
+
+        temp->nodetype = rx->nodetype;
+        temp->xid = rx->xid;
+        temp->version = rx->version;
+        temp->offset = cpu_to_je32(ofs);
+        temp->totlen = rx->totlen;
+        temp->next = NULL;
+
+        return jffs2_sum_add_mem(s, (union jffs2_sum_mem *)temp);
+}
+
+int jffs2_sum_add_xref_mem(struct jffs2_summary *s, struct jffs2_raw_xref *rr, uint32_t ofs)
+{
+        struct jffs2_sum_xref_mem *temp;
+
+        temp = kmalloc(sizeof(struct jffs2_sum_xref_mem), GFP_KERNEL);
+        if (!temp)
+                return -ENOMEM;
+
+        temp->nodetype = rr->nodetype;
+        temp->offset = cpu_to_je32(ofs);
+        temp->next = NULL;
+
+        return jffs2_sum_add_mem(s, (union jffs2_sum_mem *)temp);
+}
+#endif
 /* Cleanup every collected summary information */
 
 static void jffs2_sum_clean_collected(struct jffs2_summary *s)
@@ -259,7 +307,40 @@ int jffs2_sum_add_kvec(struct jffs2_sb_info *c, const struct kvec *invecs,
 
                         return jffs2_sum_add_mem(c->summary, (union jffs2_sum_mem *)temp);
                 }
+#ifdef CONFIG_JFFS2_FS_XATTR
+                case JFFS2_NODETYPE_XATTR: {
+                        struct jffs2_sum_xattr_mem *temp;
+                        if (je32_to_cpu(node->x.version) == 0xffffffff)
+                                return 0;
+                        temp = kmalloc(sizeof(struct jffs2_sum_xattr_mem), GFP_KERNEL);
+                        if (!temp)
+                                goto no_mem;
+
+                        temp->nodetype = node->x.nodetype;
+                        temp->xid = node->x.xid;
+                        temp->version = node->x.version;
+                        temp->totlen = node->x.totlen;
+                        temp->offset = cpu_to_je32(ofs);
+                        temp->next = NULL;
+
+                        return jffs2_sum_add_mem(c->summary, (union jffs2_sum_mem *)temp);
+                }
+                case JFFS2_NODETYPE_XREF: {
+                        struct jffs2_sum_xref_mem *temp;
+
+                        if (je32_to_cpu(node->r.ino) == 0xffffffff
+                            && je32_to_cpu(node->r.xid) == 0xffffffff)
+                                return 0;
+                        temp = kmalloc(sizeof(struct jffs2_sum_xref_mem), GFP_KERNEL);
+                        if (!temp)
+                                goto no_mem;
+                        temp->nodetype = node->r.nodetype;
+                        temp->offset = cpu_to_je32(ofs);
+                        temp->next = NULL;
 
+                        return jffs2_sum_add_mem(c->summary, (union jffs2_sum_mem *)temp);
+                }
+#endif
                 case JFFS2_NODETYPE_PADDING:
                         dbg_summary("node PADDING\n");
                         c->summary->sum_padded += je32_to_cpu(node->u.totlen);
@@ -288,23 +369,41 @@ no_mem:
         return -ENOMEM;
 }
 
+static struct jffs2_raw_node_ref *sum_link_node_ref(struct jffs2_sb_info *c,
+                                                    struct jffs2_eraseblock *jeb,
+                                                    uint32_t ofs, uint32_t len,
+                                                    struct jffs2_inode_cache *ic)
+{
+        /* If there was a gap, mark it dirty */
+        if ((ofs & ~3) > c->sector_size - jeb->free_size) {
+                /* Ew. Summary doesn't actually tell us explicitly about dirty space */
+                jffs2_scan_dirty_space(c, jeb, (ofs & ~3) - (c->sector_size - jeb->free_size));
+        }
+
+        return jffs2_link_node_ref(c, jeb, jeb->offset + ofs, len, ic);
+}
 
 /* Process the stored summary information - helper function for jffs2_sum_scan_sumnode() */
 
 static int jffs2_sum_process_sum_data(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
                                 struct jffs2_raw_summary *summary, uint32_t *pseudo_random)
 {
-        struct jffs2_raw_node_ref *raw;
         struct jffs2_inode_cache *ic;
         struct jffs2_full_dirent *fd;
         void *sp;
         int i, ino;
+        int err;
 
         sp = summary->sum;
 
         for (i=0; i<je32_to_cpu(summary->sum_num); i++) {
                 dbg_summary("processing summary index %d\n", i);
 
+                /* Make sure there's a spare ref for dirty space */
+                err = jffs2_prealloc_raw_node_refs(c, jeb, 2);
+                if (err)
+                        return err;
+
                 switch (je16_to_cpu(((struct jffs2_sum_unknown_flash *)sp)->nodetype)) {
                         case JFFS2_NODETYPE_INODE: {
                                 struct jffs2_sum_inode_flash *spi;
@@ -312,38 +411,20 @@ static int jffs2_sum_process_sum_data(struct jffs2_sb_info *c, struct jffs2_eras
 
                                 ino = je32_to_cpu(spi->inode);
 
-                                dbg_summary("Inode at 0x%08x\n",
-                                                        jeb->offset + je32_to_cpu(spi->offset));
-
-                                raw = jffs2_alloc_raw_node_ref();
-                                if (!raw) {
-                                        JFFS2_NOTICE("allocation of node reference failed\n");
-                                        kfree(summary);
-                                        return -ENOMEM;
-                                }
+                                dbg_summary("Inode at 0x%08x-0x%08x\n",
+                                            jeb->offset + je32_to_cpu(spi->offset),
+                                            jeb->offset + je32_to_cpu(spi->offset) + je32_to_cpu(spi->totlen));
 
                                 ic = jffs2_scan_make_ino_cache(c, ino);
                                 if (!ic) {
                                         JFFS2_NOTICE("scan_make_ino_cache failed\n");
-                                        jffs2_free_raw_node_ref(raw);
-                                        kfree(summary);
                                         return -ENOMEM;
                                 }
 
-                                raw->flash_offset = (jeb->offset + je32_to_cpu(spi->offset)) | REF_UNCHECKED;
-                                raw->__totlen = PAD(je32_to_cpu(spi->totlen));
-                                raw->next_phys = NULL;
-                                raw->next_in_ino = ic->nodes;
-
-                                ic->nodes = raw;
-                                if (!jeb->first_node)
-                                        jeb->first_node = raw;
-                                if (jeb->last_node)
-                                        jeb->last_node->next_phys = raw;
-                                jeb->last_node = raw;
-                                *pseudo_random += je32_to_cpu(spi->version);
+                                sum_link_node_ref(c, jeb, je32_to_cpu(spi->offset) | REF_UNCHECKED,
+                                                  PAD(je32_to_cpu(spi->totlen)), ic);
 
-                                UNCHECKED_SPACE(PAD(je32_to_cpu(spi->totlen)));
+                                *pseudo_random += je32_to_cpu(spi->version);
 
                                 sp += JFFS2_SUMMARY_INODE_SIZE;
 
@@ -354,52 +435,33 @@ static int jffs2_sum_process_sum_data(struct jffs2_sb_info *c, struct jffs2_eras
                                 struct jffs2_sum_dirent_flash *spd;
                                 spd = sp;
 
-                                dbg_summary("Dirent at 0x%08x\n",
-                                                        jeb->offset + je32_to_cpu(spd->offset));
+                                dbg_summary("Dirent at 0x%08x-0x%08x\n",
+                                            jeb->offset + je32_to_cpu(spd->offset),
+                                            jeb->offset + je32_to_cpu(spd->offset) + je32_to_cpu(spd->totlen));
+
 
                                 fd = jffs2_alloc_full_dirent(spd->nsize+1);
-                                if (!fd) {
-                                        kfree(summary);
+                                if (!fd)
                                         return -ENOMEM;
-                                }
 
                                 memcpy(&fd->name, spd->name, spd->nsize);
                                 fd->name[spd->nsize] = 0;
 
-                                raw = jffs2_alloc_raw_node_ref();
-                                if (!raw) {
-                                        jffs2_free_full_dirent(fd);
-                                        JFFS2_NOTICE("allocation of node reference failed\n");
-                                        kfree(summary);
-                                        return -ENOMEM;
-                                }
-
                                 ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(spd->pino));
                                 if (!ic) {
                                         jffs2_free_full_dirent(fd);
-                                        jffs2_free_raw_node_ref(raw);
-                                        kfree(summary);
                                         return -ENOMEM;
                                 }
 
-                                raw->__totlen = PAD(je32_to_cpu(spd->totlen));
-                                raw->flash_offset = (jeb->offset + je32_to_cpu(spd->offset)) | REF_PRISTINE;
-                                raw->next_phys = NULL;
-                                raw->next_in_ino = ic->nodes;
-                                ic->nodes = raw;
-                                if (!jeb->first_node)
-                                        jeb->first_node = raw;
-                                if (jeb->last_node)
-                                        jeb->last_node->next_phys = raw;
-                                jeb->last_node = raw;
-
-                                fd->raw = raw;
+                                fd->raw = sum_link_node_ref(c, jeb,  je32_to_cpu(spd->offset) | REF_UNCHECKED,
+                                                            PAD(je32_to_cpu(spd->totlen)), ic);
+
                                 fd->next = NULL;
                                 fd->version = je32_to_cpu(spd->version);
                                 fd->ino = je32_to_cpu(spd->ino);
                                 fd->nhash = full_name_hash(fd->name, spd->nsize);
                                 fd->type = spd->type;
-                                USED_SPACE(PAD(je32_to_cpu(spd->totlen)));
+
                                 jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
 
                                 *pseudo_random += je32_to_cpu(spd->version);
@@ -408,48 +470,105 @@ static int jffs2_sum_process_sum_data(struct jffs2_sb_info *c, struct jffs2_eras
 
                                 break;
                         }
+#ifdef CONFIG_JFFS2_FS_XATTR
+                        case JFFS2_NODETYPE_XATTR: {
+                                struct jffs2_xattr_datum *xd;
+                                struct jffs2_sum_xattr_flash *spx;
+
+                                spx = (struct jffs2_sum_xattr_flash *)sp;
+                                dbg_summary("xattr at %#08x-%#08x (xid=%u, version=%u)\n", 
+                                            jeb->offset + je32_to_cpu(spx->offset),
+                                            jeb->offset + je32_to_cpu(spx->offset) + je32_to_cpu(spx->totlen),
+                                            je32_to_cpu(spx->xid), je32_to_cpu(spx->version));
+
+                                xd = jffs2_setup_xattr_datum(c, je32_to_cpu(spx->xid),
+                                                                je32_to_cpu(spx->version));
+                                if (IS_ERR(xd)) {
+                                        if (PTR_ERR(xd) == -EEXIST) {
+                                                /* a newer version of xd exists */
+                                                if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(spx->totlen))))
+                                                        return err;
+                                                sp += JFFS2_SUMMARY_XATTR_SIZE;
+                                                break;
+                                        }
+                                        JFFS2_NOTICE("allocation of xattr_datum failed\n");
+                                        return PTR_ERR(xd);
+                                }
+
+                                xd->node = sum_link_node_ref(c, jeb, je32_to_cpu(spx->offset) | REF_UNCHECKED,
+                                                             PAD(je32_to_cpu(spx->totlen)), NULL);
+                                /* FIXME */ xd->node->next_in_ino = (void *)xd;
+
+                                *pseudo_random += je32_to_cpu(spx->xid);
+                                sp += JFFS2_SUMMARY_XATTR_SIZE;
+
+                                break;
+                        }
+                        case JFFS2_NODETYPE_XREF: {
+                                struct jffs2_xattr_ref *ref;
+                                struct jffs2_sum_xref_flash *spr;
+
+                                spr = (struct jffs2_sum_xref_flash *)sp;
+                                dbg_summary("xref at %#08x-%#08x\n",
+                                            jeb->offset + je32_to_cpu(spr->offset),
+                                            jeb->offset + je32_to_cpu(spr->offset) + 
+                                            (uint32_t)PAD(sizeof(struct jffs2_raw_xref)));
+
+                                ref = jffs2_alloc_xattr_ref();
+                                if (!ref) {
+                                        JFFS2_NOTICE("allocation of xattr_datum failed\n");
+                                        return -ENOMEM;
+                                }
+                                ref->ino = 0xfffffffe;
+                                ref->xid = 0xfffffffd;
+                                ref->next = c->xref_temp;
+                                c->xref_temp = ref;
 
+                                ref->node = sum_link_node_ref(c, jeb, je32_to_cpu(spr->offset) | REF_UNCHECKED,
+                                                              PAD(sizeof(struct jffs2_raw_xref)), NULL);
+                                /* FIXME */ ref->node->next_in_ino = (void *)ref;
+
+                                *pseudo_random += ref->node->flash_offset;
+                                sp += JFFS2_SUMMARY_XREF_SIZE;
+
+                                break;
+                        }
+#endif
                         default : {
-                                JFFS2_WARNING("Unsupported node type found in summary! Exiting...");
-                                kfree(summary);
-                                return -EIO;
+                                uint16_t nodetype = je16_to_cpu(((struct jffs2_sum_unknown_flash *)sp)->nodetype);
+                                JFFS2_WARNING("Unsupported node type %x found in summary! Exiting...\n", nodetype);
+                                if ((nodetype & JFFS2_COMPAT_MASK) == JFFS2_FEATURE_INCOMPAT)
+                                        return -EIO;
+
+                                /* For compatible node types, just fall back to the full scan */
+                                c->wasted_size -= jeb->wasted_size;
+                                c->free_size += c->sector_size - jeb->free_size;
+                                c->used_size -= jeb->used_size;
+                                c->dirty_size -= jeb->dirty_size;
+                                jeb->wasted_size = jeb->used_size = jeb->dirty_size = 0;
+                                jeb->free_size = c->sector_size;
+
+                                jffs2_free_jeb_node_refs(c, jeb);
+                                return -ENOTRECOVERABLE;
                         }
                 }
         }
-
-        kfree(summary);
         return 0;
 }
 
 /* Process the summary node - called from jffs2_scan_eraseblock() */
-
 int jffs2_sum_scan_sumnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
-                                uint32_t ofs, uint32_t *pseudo_random)
+                           struct jffs2_raw_summary *summary, uint32_t sumsize,
+                           uint32_t *pseudo_random)
 {
         struct jffs2_unknown_node crcnode;
-        struct jffs2_raw_node_ref *cache_ref;
-        struct jffs2_raw_summary *summary;
-        int ret, sumsize;
+        int ret, ofs;
         uint32_t crc;
 
-        sumsize = c->sector_size - ofs;
-        ofs += jeb->offset;
+        ofs = c->sector_size - sumsize;
 
         dbg_summary("summary found for 0x%08x at 0x%08x (0x%x bytes)\n",
-                                jeb->offset, ofs, sumsize);
-
-        summary = kmalloc(sumsize, GFP_KERNEL);
-
-        if (!summary) {
-                return -ENOMEM;
-        }
-
-        ret = jffs2_fill_scan_buf(c, (unsigned char *)summary, ofs, sumsize);
-
-        if (ret) {
-                kfree(summary);
-                return ret;
-        }
+                    jeb->offset, jeb->offset + ofs, sumsize);
 
         /* OK, now check for node validity and CRC */
         crcnode.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
@@ -486,66 +605,49 @@ int jffs2_sum_scan_sumnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb
 
                 dbg_summary("Summary : CLEANMARKER node \n");
 
+                ret = jffs2_prealloc_raw_node_refs(c, jeb, 1);
+                if (ret)
+                        return ret;
+
                 if (je32_to_cpu(summary->cln_mkr) != c->cleanmarker_size) {
                         dbg_summary("CLEANMARKER node has totlen 0x%x != normal 0x%x\n",
                                 je32_to_cpu(summary->cln_mkr), c->cleanmarker_size);
-                        UNCHECKED_SPACE(PAD(je32_to_cpu(summary->cln_mkr)));
+                        if ((ret = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(summary->cln_mkr)))))
+                                return ret;
                 } else if (jeb->first_node) {
                         dbg_summary("CLEANMARKER node not first node in block "
                                         "(0x%08x)\n", jeb->offset);
-                        UNCHECKED_SPACE(PAD(je32_to_cpu(summary->cln_mkr)));
+                        if ((ret = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(summary->cln_mkr)))))
+                                return ret;
                 } else {
-                        struct jffs2_raw_node_ref *marker_ref = jffs2_alloc_raw_node_ref();
-
-                        if (!marker_ref) {
-                                JFFS2_NOTICE("Failed to allocate node ref for clean marker\n");
-                                kfree(summary);
-                                return -ENOMEM;
-                        }
-
-                        marker_ref->next_in_ino = NULL;
-                        marker_ref->next_phys = NULL;
-                        marker_ref->flash_offset = jeb->offset | REF_NORMAL;
-                        marker_ref->__totlen = je32_to_cpu(summary->cln_mkr);
-                        jeb->first_node = jeb->last_node = marker_ref;
-
-                        USED_SPACE( PAD(je32_to_cpu(summary->cln_mkr)) );
+                        jffs2_link_node_ref(c, jeb, jeb->offset | REF_NORMAL,
+                                            je32_to_cpu(summary->cln_mkr), NULL);
                 }
         }
 
-        if (je32_to_cpu(summary->padded)) {
-                DIRTY_SPACE(je32_to_cpu(summary->padded));
-        }
-
         ret = jffs2_sum_process_sum_data(c, jeb, summary, pseudo_random);
+        /* -ENOTRECOVERABLE isn't a fatal error -- it means we should do a full
+           scan of this eraseblock. So return zero */
+        if (ret == -ENOTRECOVERABLE)
+                return 0;
         if (ret)
-                return ret;
+                return ret;             /* real error */
 
         /* for PARANOIA_CHECK */
-        cache_ref = jffs2_alloc_raw_node_ref();
-
-        if (!cache_ref) {
-                JFFS2_NOTICE("Failed to allocate node ref for cache\n");
-                return -ENOMEM;
-        }
-
-        cache_ref->next_in_ino = NULL;
-        cache_ref->next_phys = NULL;
-        cache_ref->flash_offset = ofs | REF_NORMAL;
-        cache_ref->__totlen = sumsize;
-
-        if (!jeb->first_node)
-                jeb->first_node = cache_ref;
-        if (jeb->last_node)
-                jeb->last_node->next_phys = cache_ref;
-        jeb->last_node = cache_ref;
+        ret = jffs2_prealloc_raw_node_refs(c, jeb, 2);
+        if (ret)
+                return ret;
 
-        USED_SPACE(sumsize);
+        sum_link_node_ref(c, jeb, ofs | REF_NORMAL, sumsize, NULL);
 
-        jeb->wasted_size += jeb->free_size;
-        c->wasted_size += jeb->free_size;
-        c->free_size -= jeb->free_size;
-        jeb->free_size = 0;
+        if (unlikely(jeb->free_size)) {
+                JFFS2_WARNING("Free size 0x%x bytes in eraseblock @0x%08x with summary?\n",
+                              jeb->free_size, jeb->offset);
+                jeb->wasted_size += jeb->free_size;
+                c->wasted_size += jeb->free_size;
+                c->free_size -= jeb->free_size;
+                jeb->free_size = 0;
+        }
 
         return jffs2_scan_classify_jeb(c, jeb);
 
@@ -564,6 +666,7 @@ static int jffs2_sum_write_data(struct jffs2_sb_info *c, struct jffs2_eraseblock
         union jffs2_sum_mem *temp;
         struct jffs2_sum_marker *sm;
         struct kvec vecs[2];
+        uint32_t sum_ofs;
         void *wpage;
         int ret;
         size_t retlen;
@@ -581,16 +684,17 @@ static int jffs2_sum_write_data(struct jffs2_sb_info *c, struct jffs2_eraseblock
         wpage = c->summary->sum_buf;
 
         while (c->summary->sum_num) {
+                temp = c->summary->sum_list_head;
 
-                switch (je16_to_cpu(c->summary->sum_list_head->u.nodetype)) {
+                switch (je16_to_cpu(temp->u.nodetype)) {
                         case JFFS2_NODETYPE_INODE: {
                                 struct jffs2_sum_inode_flash *sino_ptr = wpage;
 
-                                sino_ptr->nodetype = c->summary->sum_list_head->i.nodetype;
-                                sino_ptr->inode = c->summary->sum_list_head->i.inode;
-                                sino_ptr->version = c->summary->sum_list_head->i.version;
-                                sino_ptr->offset = c->summary->sum_list_head->i.offset;
-                                sino_ptr->totlen = c->summary->sum_list_head->i.totlen;
+                                sino_ptr->nodetype = temp->i.nodetype;
+                                sino_ptr->inode = temp->i.inode;
+                                sino_ptr->version = temp->i.version;
+                                sino_ptr->offset = temp->i.offset;
+                                sino_ptr->totlen = temp->i.totlen;
 
                                 wpage += JFFS2_SUMMARY_INODE_SIZE;
 
@@ -600,30 +704,60 @@ static int jffs2_sum_write_data(struct jffs2_sb_info *c, struct jffs2_eraseblock
                         case JFFS2_NODETYPE_DIRENT: {
                                 struct jffs2_sum_dirent_flash *sdrnt_ptr = wpage;
 
-                                sdrnt_ptr->nodetype = c->summary->sum_list_head->d.nodetype;
-                                sdrnt_ptr->totlen = c->summary->sum_list_head->d.totlen;
-                                sdrnt_ptr->offset = c->summary->sum_list_head->d.offset;
-                                sdrnt_ptr->pino = c->summary->sum_list_head->d.pino;
-                                sdrnt_ptr->version = c->summary->sum_list_head->d.version;
-                                sdrnt_ptr->ino = c->summary->sum_list_head->d.ino;
-                                sdrnt_ptr->nsize = c->summary->sum_list_head->d.nsize;
-                                sdrnt_ptr->type = c->summary->sum_list_head->d.type;
+                                sdrnt_ptr->nodetype = temp->d.nodetype;
+                                sdrnt_ptr->totlen = temp->d.totlen;
+                                sdrnt_ptr->offset = temp->d.offset;
+                                sdrnt_ptr->pino = temp->d.pino;
+                                sdrnt_ptr->version = temp->d.version;
+                                sdrnt_ptr->ino = temp->d.ino;
+                                sdrnt_ptr->nsize = temp->d.nsize;
+                                sdrnt_ptr->type = temp->d.type;
 
-                                memcpy(sdrnt_ptr->name, c->summary->sum_list_head->d.name,
-                                                        c->summary->sum_list_head->d.nsize);
+                                memcpy(sdrnt_ptr->name, temp->d.name,
+                                                        temp->d.nsize);
 
-                                wpage += JFFS2_SUMMARY_DIRENT_SIZE(c->summary->sum_list_head->d.nsize);
+                                wpage += JFFS2_SUMMARY_DIRENT_SIZE(temp->d.nsize);
 
                                 break;
                         }
+#ifdef CONFIG_JFFS2_FS_XATTR
+                        case JFFS2_NODETYPE_XATTR: {
+                                struct jffs2_sum_xattr_flash *sxattr_ptr = wpage;
+
+                                temp = c->summary->sum_list_head;
+                                sxattr_ptr->nodetype = temp->x.nodetype;
+                                sxattr_ptr->xid = temp->x.xid;
+                                sxattr_ptr->version = temp->x.version;
+                                sxattr_ptr->offset = temp->x.offset;
+                                sxattr_ptr->totlen = temp->x.totlen;
+
+                                wpage += JFFS2_SUMMARY_XATTR_SIZE;
+                                break;
+                        }
+                        case JFFS2_NODETYPE_XREF: {
+                                struct jffs2_sum_xref_flash *sxref_ptr = wpage;
 
+                                temp = c->summary->sum_list_head;
+                                sxref_ptr->nodetype = temp->r.nodetype;
+                                sxref_ptr->offset = temp->r.offset;
+
+                                wpage += JFFS2_SUMMARY_XREF_SIZE;
+                                break;
+                        }
+#endif
                         default : {
-                                BUG();  /* unknown node in summary information */
+                                if ((je16_to_cpu(temp->u.nodetype) & JFFS2_COMPAT_MASK)
+                                    == JFFS2_FEATURE_RWCOMPAT_COPY) {
+                                        dbg_summary("Writing unknown RWCOMPAT_COPY node type %x\n",
+                                                    je16_to_cpu(temp->u.nodetype));
+                                        jffs2_sum_disable_collecting(c->summary);
+                                } else {
+                                        BUG();  /* unknown node in summary information */
+                                }
                         }
                 }
 
-                temp = c->summary->sum_list_head;
-                c->summary->sum_list_head = c->summary->sum_list_head->u.next;
+                c->summary->sum_list_head = temp->u.next;
                 kfree(temp);
 
                 c->summary->sum_num--;
@@ -645,25 +779,34 @@ static int jffs2_sum_write_data(struct jffs2_sb_info *c, struct jffs2_eraseblock
         vecs[1].iov_base = c->summary->sum_buf;
         vecs[1].iov_len = datasize;
 
-        dbg_summary("JFFS2: writing out data to flash to pos : 0x%08x\n",
-                        jeb->offset + c->sector_size - jeb->free_size);
+        sum_ofs = jeb->offset + c->sector_size - jeb->free_size;
 
-        spin_unlock(&c->erase_completion_lock);
-        ret = jffs2_flash_writev(c, vecs, 2, jeb->offset + c->sector_size -
-                                jeb->free_size, &retlen, 0);
-        spin_lock(&c->erase_completion_lock);
+        dbg_summary("JFFS2: writing out data to flash to pos : 0x%08x\n",
+                    sum_ofs);
 
+        ret = jffs2_flash_writev(c, vecs, 2, sum_ofs, &retlen, 0);
 
         if (ret || (retlen != infosize)) {
-                JFFS2_WARNING("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
-                        infosize, jeb->offset + c->sector_size - jeb->free_size, ret, retlen);
+
+                JFFS2_WARNING("Write of %u bytes at 0x%08x failed. returned %d, retlen %zd\n",
+                              infosize, sum_ofs, ret, retlen);
+
+                if (retlen) {
+                        /* Waste remaining space */
+                        spin_lock(&c->erase_completion_lock);
+                        jffs2_link_node_ref(c, jeb, sum_ofs | REF_OBSOLETE, infosize, NULL);
+                        spin_unlock(&c->erase_completion_lock);
+                }
 
                 c->summary->sum_size = JFFS2_SUMMARY_NOSUM_SIZE;
-                WASTED_SPACE(infosize);
 
-                return 1;
+                return 0;
         }
 
+        spin_lock(&c->erase_completion_lock);
+        jffs2_link_node_ref(c, jeb, sum_ofs | REF_NORMAL, infosize, NULL);
+        spin_unlock(&c->erase_completion_lock);
+
         return 0;
 }
 
@@ -671,13 +814,16 @@ static int jffs2_sum_write_data(struct jffs2_sb_info *c, struct jffs2_eraseblock
 
 int jffs2_sum_write_sumnode(struct jffs2_sb_info *c)
 {
-        struct jffs2_raw_node_ref *summary_ref;
-        int datasize, infosize, padsize, ret;
+        int datasize, infosize, padsize;
         struct jffs2_eraseblock *jeb;
+        int ret;
 
         dbg_summary("called\n");
 
+        spin_unlock(&c->erase_completion_lock);
+
         jeb = c->nextblock;
+        jffs2_prealloc_raw_node_refs(c, jeb, 1);
 
         if (!c->summary->sum_num || !c->summary->sum_list_head) {
                 JFFS2_WARNING("Empty summary info!!!\n");
@@ -696,35 +842,11 @@ int jffs2_sum_write_sumnode(struct jffs2_sb_info *c)
                 jffs2_sum_disable_collecting(c->summary);
 
                 JFFS2_WARNING("Not enough space for summary, padsize = %d\n", padsize);
+                spin_lock(&c->erase_completion_lock);
                 return 0;
         }
 
         ret = jffs2_sum_write_data(c, jeb, infosize, datasize, padsize);
-        if (ret)
-                return 0; /* can't write out summary, block is marked as NOSUM_SIZE */
-
-        /* for ACCT_PARANOIA_CHECK */
-        spin_unlock(&c->erase_completion_lock);
-        summary_ref = jffs2_alloc_raw_node_ref();
         spin_lock(&c->erase_completion_lock);
-
-        if (!summary_ref) {
-                JFFS2_NOTICE("Failed to allocate node ref for summary\n");
-                return -ENOMEM;
-        }
-
-        summary_ref->next_in_ino = NULL;
-        summary_ref->next_phys = NULL;
-        summary_ref->flash_offset = (jeb->offset + c->sector_size - jeb->free_size) | REF_NORMAL;
-        summary_ref->__totlen = infosize;
-
-        if (!jeb->first_node)
-                jeb->first_node = summary_ref;
-        if (jeb->last_node)
-                jeb->last_node->next_phys = summary_ref;
-        jeb->last_node = summary_ref;
-
-        USED_SPACE(infosize);
-
-        return 0;
+        return ret;
 }
diff --git a/fs/jffs2/summary.h b/fs/jffs2/summary.h
index b7a678be1709..6bf1f6aa4552 100644
--- a/fs/jffs2/summary.h
+++ b/fs/jffs2/summary.h
@@ -18,23 +18,6 @@
 #include <linux/uio.h>
 #include <linux/jffs2.h>
 
-#define DIRTY_SPACE(x) do { typeof(x) _x = (x); \
-                c->free_size -= _x; c->dirty_size += _x; \
-                jeb->free_size -= _x ; jeb->dirty_size += _x; \
-                }while(0)
-#define USED_SPACE(x) do { typeof(x) _x = (x); \
-                c->free_size -= _x; c->used_size += _x; \
-                jeb->free_size -= _x ; jeb->used_size += _x; \
-                }while(0)
-#define WASTED_SPACE(x) do { typeof(x) _x = (x); \
-                c->free_size -= _x; c->wasted_size += _x; \
-                jeb->free_size -= _x ; jeb->wasted_size += _x; \
-                }while(0)
-#define UNCHECKED_SPACE(x) do { typeof(x) _x = (x); \
-                c->free_size -= _x; c->unchecked_size += _x; \
-                jeb->free_size -= _x ; jeb->unchecked_size += _x; \
-                }while(0)
-
 #define BLK_STATE_ALLFF         0
 #define BLK_STATE_CLEAN         1
 #define BLK_STATE_PARTDIRTY     2
@@ -45,6 +28,8 @@
 #define JFFS2_SUMMARY_NOSUM_SIZE 0xffffffff
 #define JFFS2_SUMMARY_INODE_SIZE (sizeof(struct jffs2_sum_inode_flash))
 #define JFFS2_SUMMARY_DIRENT_SIZE(x) (sizeof(struct jffs2_sum_dirent_flash) + (x))
+#define JFFS2_SUMMARY_XATTR_SIZE (sizeof(struct jffs2_sum_xattr_flash))
+#define JFFS2_SUMMARY_XREF_SIZE (sizeof(struct jffs2_sum_xref_flash))
 
 /* Summary structures used on flash */
 
@@ -75,11 +60,28 @@ struct jffs2_sum_dirent_flash
         uint8_t name[0];        /* dirent name */
 } __attribute__((packed));
 
+struct jffs2_sum_xattr_flash
+{
+        jint16_t nodetype;      /* == JFFS2_NODETYPE_XATR */
+        jint32_t xid;           /* xattr identifier */
+        jint32_t version;       /* version number */
+        jint32_t offset;        /* offset on jeb */
+        jint32_t totlen;        /* node length */
+} __attribute__((packed));
+
+struct jffs2_sum_xref_flash
+{
+        jint16_t nodetype;      /* == JFFS2_NODETYPE_XREF */
+        jint32_t offset;        /* offset on jeb */
+} __attribute__((packed));
+
 union jffs2_sum_flash
 {
         struct jffs2_sum_unknown_flash u;
         struct jffs2_sum_inode_flash i;
         struct jffs2_sum_dirent_flash d;
+        struct jffs2_sum_xattr_flash x;
+        struct jffs2_sum_xref_flash r;
 };
 
 /* Summary structures used in the memory */
@@ -114,11 +116,30 @@ struct jffs2_sum_dirent_mem
         uint8_t name[0];        /* dirent name */
 } __attribute__((packed));
 
+struct jffs2_sum_xattr_mem
+{
+        union jffs2_sum_mem *next;
+        jint16_t nodetype;
+        jint32_t xid;
+        jint32_t version;
+        jint32_t offset;
+        jint32_t totlen;
+} __attribute__((packed));
+
+struct jffs2_sum_xref_mem
+{
+        union jffs2_sum_mem *next;
+        jint16_t nodetype;
+        jint32_t offset;
+} __attribute__((packed));
+
 union jffs2_sum_mem
 {
         struct jffs2_sum_unknown_mem u;
         struct jffs2_sum_inode_mem i;
         struct jffs2_sum_dirent_mem d;
+        struct jffs2_sum_xattr_mem x;
+        struct jffs2_sum_xref_mem r;
 };
 
 /* Summary related information stored in superblock */
@@ -159,8 +180,11 @@ int jffs2_sum_write_sumnode(struct jffs2_sb_info *c);
 int jffs2_sum_add_padding_mem(struct jffs2_summary *s, uint32_t size);
 int jffs2_sum_add_inode_mem(struct jffs2_summary *s, struct jffs2_raw_inode *ri, uint32_t ofs);
 int jffs2_sum_add_dirent_mem(struct jffs2_summary *s, struct jffs2_raw_dirent *rd, uint32_t ofs);
+int jffs2_sum_add_xattr_mem(struct jffs2_summary *s, struct jffs2_raw_xattr *rx, uint32_t ofs);
+int jffs2_sum_add_xref_mem(struct jffs2_summary *s, struct jffs2_raw_xref *rr, uint32_t ofs);
 int jffs2_sum_scan_sumnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
-                        uint32_t ofs, uint32_t *pseudo_random);
+                           struct jffs2_raw_summary *summary, uint32_t sumlen,
+                           uint32_t *pseudo_random);
 
 #else                           /* SUMMARY DISABLED */
 
@@ -176,7 +200,9 @@ int jffs2_sum_scan_sumnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb
 #define jffs2_sum_add_padding_mem(a,b)
 #define jffs2_sum_add_inode_mem(a,b,c)
 #define jffs2_sum_add_dirent_mem(a,b,c)
-#define jffs2_sum_scan_sumnode(a,b,c,d) (0)
+#define jffs2_sum_add_xattr_mem(a,b,c)
+#define jffs2_sum_add_xref_mem(a,b,c)
+#define jffs2_sum_scan_sumnode(a,b,c,d,e) (0)
 
 #endif /* CONFIG_JFFS2_SUMMARY */
 
diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index ffd8e84b22cc..9d0521451f59 100644
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -151,7 +151,10 @@ static struct super_block *jffs2_get_sb_mtd(struct file_system_type *fs_type,
 
         sb->s_op = &jffs2_super_operations;
         sb->s_flags = flags | MS_NOATIME;
-
+        sb->s_xattr = jffs2_xattr_handlers;
+#ifdef CONFIG_JFFS2_FS_POSIX_ACL
+        sb->s_flags |= MS_POSIXACL;
+#endif
         ret = jffs2_do_fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
 
         if (ret) {
@@ -293,6 +296,7 @@ static void jffs2_put_super (struct super_block *sb)
                 kfree(c->blocks);
         jffs2_flash_cleanup(c);
         kfree(c->inocache_list);
+        jffs2_clear_xattr_subsystem(c);
         if (c->mtd->sync)
                 c->mtd->sync(c->mtd);
 
@@ -320,6 +324,18 @@ static int __init init_jffs2_fs(void)
 {
         int ret;
 
+        /* Paranoia checks for on-medium structures. If we ask GCC
+           to pack them with __attribute__((packed)) then it _also_
+           assumes that they're not aligned -- so it emits crappy
+           code on some architectures. Ideally we want an attribute
+           which means just 'no padding', without the alignment
+           thing. But GCC doesn't have that -- we have to just
+           hope the structs are the right sizes, instead. */
+        BUG_ON(sizeof(struct jffs2_unknown_node) != 12);
+        BUG_ON(sizeof(struct jffs2_raw_dirent) != 40);
+        BUG_ON(sizeof(struct jffs2_raw_inode) != 68);
+        BUG_ON(sizeof(struct jffs2_raw_summary) != 32);
+
         printk(KERN_INFO "JFFS2 version 2.2."
 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
                " (NAND)"
@@ -327,7 +343,7 @@ static int __init init_jffs2_fs(void)
 #ifdef CONFIG_JFFS2_SUMMARY
                " (SUMMARY) "
 #endif
-               " (C) 2001-2003 Red Hat, Inc.\n");
+               " (C) 2001-2006 Red Hat, Inc.\n");
 
         jffs2_inode_cachep = kmem_cache_create("jffs2_i",
                                              sizeof(struct jffs2_inode_info),
diff --git a/fs/jffs2/symlink.c b/fs/jffs2/symlink.c
index d55754fe8925..fc211b6e9b03 100644
--- a/fs/jffs2/symlink.c
+++ b/fs/jffs2/symlink.c
@@ -24,7 +24,12 @@ struct inode_operations jffs2_symlink_inode_operations =
 {
         .readlink =     generic_readlink,
         .follow_link =  jffs2_follow_link,
-        .setattr =      jffs2_setattr
+        .permission =   jffs2_permission,
+        .setattr =      jffs2_setattr,
+        .setxattr =     jffs2_setxattr,
+        .getxattr =     jffs2_getxattr,
+        .listxattr =    jffs2_listxattr,
+        .removexattr =  jffs2_removexattr
 };
 
 static void *jffs2_follow_link(struct dentry *dentry, struct nameidata *nd)
diff --git a/fs/jffs2/wbuf.c b/fs/jffs2/wbuf.c
index 4cebf0e57c46..a7f153f79ecb 100644
--- a/fs/jffs2/wbuf.c
+++ b/fs/jffs2/wbuf.c
@@ -156,69 +156,130 @@ static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock
                 jffs2_erase_pending_trigger(c);
         }
 
-        /* Adjust its size counts accordingly */
-        c->wasted_size += jeb->free_size;
-        c->free_size -= jeb->free_size;
-        jeb->wasted_size += jeb->free_size;
-        jeb->free_size = 0;
+        if (!jffs2_prealloc_raw_node_refs(c, jeb, 1)) {
+                uint32_t oldfree = jeb->free_size;
+
+                jffs2_link_node_ref(c, jeb, 
+                                    (jeb->offset+c->sector_size-oldfree) | REF_OBSOLETE,
+                                    oldfree, NULL);
+                /* convert to wasted */
+                c->wasted_size += oldfree;
+                jeb->wasted_size += oldfree;
+                c->dirty_size -= oldfree;
+                jeb->dirty_size -= oldfree;
+        }
 
         jffs2_dbg_dump_block_lists_nolock(c);
         jffs2_dbg_acct_sanity_check_nolock(c,jeb);
         jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
 }
 
+static struct jffs2_raw_node_ref **jffs2_incore_replace_raw(struct jffs2_sb_info *c,
+                                                            struct jffs2_inode_info *f,
+                                                            struct jffs2_raw_node_ref *raw,
+                                                            union jffs2_node_union *node)
+{
+        struct jffs2_node_frag *frag;
+        struct jffs2_full_dirent *fd;
+
+        dbg_noderef("incore_replace_raw: node at %p is {%04x,%04x}\n",
+                    node, je16_to_cpu(node->u.magic), je16_to_cpu(node->u.nodetype));
+
+        BUG_ON(je16_to_cpu(node->u.magic) != 0x1985 &&
+               je16_to_cpu(node->u.magic) != 0);
+
+        switch (je16_to_cpu(node->u.nodetype)) {
+        case JFFS2_NODETYPE_INODE:
+                if (f->metadata && f->metadata->raw == raw) {
+                        dbg_noderef("Will replace ->raw in f->metadata at %p\n", f->metadata);
+                        return &f->metadata->raw;
+                }
+                frag = jffs2_lookup_node_frag(&f->fragtree, je32_to_cpu(node->i.offset));
+                BUG_ON(!frag);
+                /* Find a frag which refers to the full_dnode we want to modify */
+                while (!frag->node || frag->node->raw != raw) {
+                        frag = frag_next(frag);
+                        BUG_ON(!frag);
+                }
+                dbg_noderef("Will replace ->raw in full_dnode at %p\n", frag->node);
+                return &frag->node->raw;
+
+        case JFFS2_NODETYPE_DIRENT:
+                for (fd = f->dents; fd; fd = fd->next) {
+                        if (fd->raw == raw) {
+                                dbg_noderef("Will replace ->raw in full_dirent at %p\n", fd);
+                                return &fd->raw;
+                        }
+                }
+                BUG();
+
+        default:
+                dbg_noderef("Don't care about replacing raw for nodetype %x\n",
+                            je16_to_cpu(node->u.nodetype));
+                break;
+        }
+        return NULL;
+}
+
 /* Recover from failure to write wbuf. Recover the nodes up to the
  * wbuf, not the one which we were starting to try to write. */
 
 static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
 {
         struct jffs2_eraseblock *jeb, *new_jeb;
-        struct jffs2_raw_node_ref **first_raw, **raw;
+        struct jffs2_raw_node_ref *raw, *next, *first_raw = NULL;
         size_t retlen;
         int ret;
+        int nr_refile = 0;
         unsigned char *buf;
         uint32_t start, end, ofs, len;
 
-        spin_lock(&c->erase_completion_lock);
-
         jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
 
+        spin_lock(&c->erase_completion_lock);
         jffs2_block_refile(c, jeb, REFILE_NOTEMPTY);
+        spin_unlock(&c->erase_completion_lock);
+
+        BUG_ON(!ref_obsolete(jeb->last_node));
 
         /* Find the first node to be recovered, by skipping over every
            node which ends before the wbuf starts, or which is obsolete. */
-        first_raw = &jeb->first_node;
-        while (*first_raw &&
-               (ref_obsolete(*first_raw) ||
-                (ref_offset(*first_raw)+ref_totlen(c, jeb, *first_raw)) < c->wbuf_ofs)) {
-                D1(printk(KERN_DEBUG "Skipping node at 0x%08x(%d)-0x%08x which is either before 0x%08x or obsolete\n",
-                          ref_offset(*first_raw), ref_flags(*first_raw),
-                          (ref_offset(*first_raw) + ref_totlen(c, jeb, *first_raw)),
-                          c->wbuf_ofs));
-                first_raw = &(*first_raw)->next_phys;
+        for (next = raw = jeb->first_node; next; raw = next) {
+                next = ref_next(raw);
+
+                if (ref_obsolete(raw) || 
+                    (next && ref_offset(next) <= c->wbuf_ofs)) {
+                        dbg_noderef("Skipping node at 0x%08x(%d)-0x%08x which is either before 0x%08x or obsolete\n",
+                                    ref_offset(raw), ref_flags(raw),
+                                    (ref_offset(raw) + ref_totlen(c, jeb, raw)),
+                                    c->wbuf_ofs);
+                        continue;
+                }
+                dbg_noderef("First node to be recovered is at 0x%08x(%d)-0x%08x\n",
+                            ref_offset(raw), ref_flags(raw),
+                            (ref_offset(raw) + ref_totlen(c, jeb, raw)));
+
+                first_raw = raw;
+                break;
         }
 
-        if (!*first_raw) {
+        if (!first_raw) {
                 /* All nodes were obsolete. Nothing to recover. */
                 D1(printk(KERN_DEBUG "No non-obsolete nodes to be recovered. Just filing block bad\n"));
-                spin_unlock(&c->erase_completion_lock);
+                c->wbuf_len = 0;
                 return;
         }
 
-        start = ref_offset(*first_raw);
-        end = ref_offset(*first_raw) + ref_totlen(c, jeb, *first_raw);
-
-        /* Find the last node to be recovered */
-        raw = first_raw;
-        while ((*raw)) {
-                if (!ref_obsolete(*raw))
-                        end = ref_offset(*raw) + ref_totlen(c, jeb, *raw);
+        start = ref_offset(first_raw);
+        end = ref_offset(jeb->last_node);
+        nr_refile = 1;
 
-                raw = &(*raw)->next_phys;
-        }
-        spin_unlock(&c->erase_completion_lock);
+        /* Count the number of refs which need to be copied */
+        while ((raw = ref_next(raw)) != jeb->last_node)
+                nr_refile++;
 
-        D1(printk(KERN_DEBUG "wbuf recover %08x-%08x\n", start, end));
+        dbg_noderef("wbuf recover %08x-%08x (%d bytes in %d nodes)\n",
+                    start, end, end - start, nr_refile);
 
         buf = NULL;
         if (start < c->wbuf_ofs) {
@@ -233,28 +294,37 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
                 }
 
                 /* Do the read... */
-                if (jffs2_cleanmarker_oob(c))
-                        ret = c->mtd->read_ecc(c->mtd, start, c->wbuf_ofs - start, &retlen, buf, NULL, c->oobinfo);
-                else
-                        ret = c->mtd->read(c->mtd, start, c->wbuf_ofs - start, &retlen, buf);
+                ret = c->mtd->read(c->mtd, start, c->wbuf_ofs - start, &retlen, buf);
 
-                if (ret == -EBADMSG && retlen == c->wbuf_ofs - start) {
-                        /* ECC recovered */
+                /* ECC recovered ? */
+                if ((ret == -EUCLEAN || ret == -EBADMSG) &&
+                    (retlen == c->wbuf_ofs - start))
                         ret = 0;
-                }
+
                 if (ret || retlen != c->wbuf_ofs - start) {
                         printk(KERN_CRIT "Old data are already lost in wbuf recovery. Data loss ensues.\n");
 
                         kfree(buf);
                         buf = NULL;
                 read_failed:
-                        first_raw = &(*first_raw)->next_phys;
+                        first_raw = ref_next(first_raw);
+                        nr_refile--;
+                        while (first_raw && ref_obsolete(first_raw)) {
+                                first_raw = ref_next(first_raw);
+                                nr_refile--;
+                        }
+
                         /* If this was the only node to be recovered, give up */
-                        if (!(*first_raw))
+                        if (!first_raw) {
+                                c->wbuf_len = 0;
                                 return;
+                        }
 
                         /* It wasn't. Go on and try to recover nodes complete in the wbuf */
-                        start = ref_offset(*first_raw);
+                        start = ref_offset(first_raw);
+                        dbg_noderef("wbuf now recover %08x-%08x (%d bytes in %d nodes)\n",
+                                    start, end, end - start, nr_refile);
+
                 } else {
                         /* Read succeeded. Copy the remaining data from the wbuf */
                         memcpy(buf + (c->wbuf_ofs - start), c->wbuf, end - c->wbuf_ofs);
@@ -263,14 +333,23 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
         /* OK... we're to rewrite (end-start) bytes of data from first_raw onwards.
            Either 'buf' contains the data, or we find it in the wbuf */
 
-
         /* ... and get an allocation of space from a shiny new block instead */
-        ret = jffs2_reserve_space_gc(c, end-start, &ofs, &len, JFFS2_SUMMARY_NOSUM_SIZE);
+        ret = jffs2_reserve_space_gc(c, end-start, &len, JFFS2_SUMMARY_NOSUM_SIZE);
         if (ret) {
                 printk(KERN_WARNING "Failed to allocate space for wbuf recovery. Data loss ensues.\n");
                 kfree(buf);
                 return;
         }
+
+        ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, nr_refile);
+        if (ret) {
+                printk(KERN_WARNING "Failed to allocate node refs for wbuf recovery. Data loss ensues.\n");
+                kfree(buf);
+                return;
+        }
+
+        ofs = write_ofs(c);
+
         if (end-start >= c->wbuf_pagesize) {
                 /* Need to do another write immediately, but it's possible
                    that this is just because the wbuf itself is completely
@@ -288,36 +367,22 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
                 if (breakme++ == 20) {
                         printk(KERN_NOTICE "Faking write error at 0x%08x\n", ofs);
                         breakme = 0;
-                        c->mtd->write_ecc(c->mtd, ofs, towrite, &retlen,
-                                          brokenbuf, NULL, c->oobinfo);
+                        c->mtd->write(c->mtd, ofs, towrite, &retlen,
+                                      brokenbuf);
                         ret = -EIO;
                 } else
 #endif
-                if (jffs2_cleanmarker_oob(c))
-                        ret = c->mtd->write_ecc(c->mtd, ofs, towrite, &retlen,
-                                                rewrite_buf, NULL, c->oobinfo);
-                else
-                        ret = c->mtd->write(c->mtd, ofs, towrite, &retlen, rewrite_buf);
+                        ret = c->mtd->write(c->mtd, ofs, towrite, &retlen,
+                                            rewrite_buf);
 
                 if (ret || retlen != towrite) {
                         /* Argh. We tried. Really we did. */
                         printk(KERN_CRIT "Recovery of wbuf failed due to a second write error\n");
                         kfree(buf);
 
-                        if (retlen) {
-                                struct jffs2_raw_node_ref *raw2;
-
-                                raw2 = jffs2_alloc_raw_node_ref();
-                                if (!raw2)
-                                        return;
+                        if (retlen)
+                                jffs2_add_physical_node_ref(c, ofs | REF_OBSOLETE, ref_totlen(c, jeb, first_raw), NULL);
 
-                                raw2->flash_offset = ofs | REF_OBSOLETE;
-                                raw2->__totlen = ref_totlen(c, jeb, *first_raw);
-                                raw2->next_phys = NULL;
-                                raw2->next_in_ino = NULL;
-
-                                jffs2_add_physical_node_ref(c, raw2);
-                        }
                         return;
                 }
                 printk(KERN_NOTICE "Recovery of wbuf succeeded to %08x\n", ofs);
@@ -326,12 +391,10 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
                 c->wbuf_ofs = ofs + towrite;
                 memmove(c->wbuf, rewrite_buf + towrite, c->wbuf_len);
                 /* Don't muck about with c->wbuf_inodes. False positives are harmless. */
-                kfree(buf);
         } else {
                 /* OK, now we're left with the dregs in whichever buffer we're using */
                 if (buf) {
                         memcpy(c->wbuf, buf, end-start);
-                        kfree(buf);
                 } else {
                         memmove(c->wbuf, c->wbuf + (start - c->wbuf_ofs), end - start);
                 }
@@ -343,62 +406,111 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
         new_jeb = &c->blocks[ofs / c->sector_size];
 
         spin_lock(&c->erase_completion_lock);
-        if (new_jeb->first_node) {
-                /* Odd, but possible with ST flash later maybe */
-                new_jeb->last_node->next_phys = *first_raw;
-        } else {
-                new_jeb->first_node = *first_raw;
-        }
-
-        raw = first_raw;
-        while (*raw) {
-                uint32_t rawlen = ref_totlen(c, jeb, *raw);
+        for (raw = first_raw; raw != jeb->last_node; raw = ref_next(raw)) {
+                uint32_t rawlen = ref_totlen(c, jeb, raw);
+                struct jffs2_inode_cache *ic;
+                struct jffs2_raw_node_ref *new_ref;
+                struct jffs2_raw_node_ref **adjust_ref = NULL;
+                struct jffs2_inode_info *f = NULL;
 
                 D1(printk(KERN_DEBUG "Refiling block of %08x at %08x(%d) to %08x\n",
-                          rawlen, ref_offset(*raw), ref_flags(*raw), ofs));
+                          rawlen, ref_offset(raw), ref_flags(raw), ofs));
+
+                ic = jffs2_raw_ref_to_ic(raw);
+
+                /* Ick. This XATTR mess should be fixed shortly... */
+                if (ic && ic->class == RAWNODE_CLASS_XATTR_DATUM) {
+                        struct jffs2_xattr_datum *xd = (void *)ic;
+                        BUG_ON(xd->node != raw);
+                        adjust_ref = &xd->node;
+                        raw->next_in_ino = NULL;
+                        ic = NULL;
+                } else if (ic && ic->class == RAWNODE_CLASS_XATTR_REF) {
+                        struct jffs2_xattr_datum *xr = (void *)ic;
+                        BUG_ON(xr->node != raw);
+                        adjust_ref = &xr->node;
+                        raw->next_in_ino = NULL;
+                        ic = NULL;
+                } else if (ic && ic->class == RAWNODE_CLASS_INODE_CACHE) {
+                        struct jffs2_raw_node_ref **p = &ic->nodes;
+
+                        /* Remove the old node from the per-inode list */
+                        while (*p && *p != (void *)ic) {
+                                if (*p == raw) {
+                                        (*p) = (raw->next_in_ino);
+                                        raw->next_in_ino = NULL;
+                                        break;
+                                }
+                                p = &((*p)->next_in_ino);
+                        }
 
-                if (ref_obsolete(*raw)) {
-                        /* Shouldn't really happen much */
-                        new_jeb->dirty_size += rawlen;
-                        new_jeb->free_size -= rawlen;
-                        c->dirty_size += rawlen;
-                } else {
-                        new_jeb->used_size += rawlen;
-                        new_jeb->free_size -= rawlen;
+                        if (ic->state == INO_STATE_PRESENT && !ref_obsolete(raw)) {
+                                /* If it's an in-core inode, then we have to adjust any
+                                   full_dirent or full_dnode structure to point to the
+                                   new version instead of the old */
+                                f = jffs2_gc_fetch_inode(c, ic->ino, ic->nlink);
+                                if (IS_ERR(f)) {
+                                        /* Should never happen; it _must_ be present */
+                                        JFFS2_ERROR("Failed to iget() ino #%u, err %ld\n",
+                                                    ic->ino, PTR_ERR(f));
+                                        BUG();
+                                }
+                                /* We don't lock f->sem. There's a number of ways we could
+                                   end up in here with it already being locked, and nobody's
+                                   going to modify it on us anyway because we hold the
+                                   alloc_sem. We're only changing one ->raw pointer too,
+                                   which we can get away with without upsetting readers. */
+                                adjust_ref = jffs2_incore_replace_raw(c, f, raw,
+                                                                      (void *)(buf?:c->wbuf) + (ref_offset(raw) - start));
+                        } else if (unlikely(ic->state != INO_STATE_PRESENT &&
+                                            ic->state != INO_STATE_CHECKEDABSENT &&
+                                            ic->state != INO_STATE_GC)) {
+                                JFFS2_ERROR("Inode #%u is in strange state %d!\n", ic->ino, ic->state);
+                                BUG();
+                        }
+                }
+
+                new_ref = jffs2_link_node_ref(c, new_jeb, ofs | ref_flags(raw), rawlen, ic);
+
+                if (adjust_ref) {
+                        BUG_ON(*adjust_ref != raw);
+                        *adjust_ref = new_ref;
+                }
+                if (f)
+                        jffs2_gc_release_inode(c, f);
+
+                if (!ref_obsolete(raw)) {
                         jeb->dirty_size += rawlen;
                         jeb->used_size  -= rawlen;
                         c->dirty_size += rawlen;
+                        c->used_size -= rawlen;
+                        raw->flash_offset = ref_offset(raw) | REF_OBSOLETE;
+                        BUG_ON(raw->next_in_ino);
                 }
-                c->free_size -= rawlen;
-                (*raw)->flash_offset = ofs | ref_flags(*raw);
                 ofs += rawlen;
-                new_jeb->last_node = *raw;
-
-                raw = &(*raw)->next_phys;
         }
 
+        kfree(buf);
+
         /* Fix up the original jeb now it's on the bad_list */
-        *first_raw = NULL;
-        if (first_raw == &jeb->first_node) {
-                jeb->last_node = NULL;
+        if (first_raw == jeb->first_node) {
                 D1(printk(KERN_DEBUG "Failing block at %08x is now empty. Moving to erase_pending_list\n", jeb->offset));
                 list_del(&jeb->list);
                 list_add(&jeb->list, &c->erase_pending_list);
                 c->nr_erasing_blocks++;
                 jffs2_erase_pending_trigger(c);
         }
-        else
-                jeb->last_node = container_of(first_raw, struct jffs2_raw_node_ref, next_phys);
 
         jffs2_dbg_acct_sanity_check_nolock(c, jeb);
-        jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
+        jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
 
         jffs2_dbg_acct_sanity_check_nolock(c, new_jeb);
-        jffs2_dbg_acct_paranoia_check_nolock(c, new_jeb);
+        jffs2_dbg_acct_paranoia_check_nolock(c, new_jeb);
 
         spin_unlock(&c->erase_completion_lock);
 
-        D1(printk(KERN_DEBUG "wbuf recovery completed OK\n"));
+        D1(printk(KERN_DEBUG "wbuf recovery completed OK. wbuf_ofs 0x%08x, len 0x%x\n", c->wbuf_ofs, c->wbuf_len));
+
 }
 
 /* Meaning of pad argument:
@@ -412,6 +524,7 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
 
 static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
 {
+        struct jffs2_eraseblock *wbuf_jeb;
         int ret;
         size_t retlen;
 
@@ -429,6 +542,10 @@ static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
         if (!c->wbuf_len)       /* already checked c->wbuf above */
                 return 0;
 
+        wbuf_jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
+        if (jffs2_prealloc_raw_node_refs(c, wbuf_jeb, c->nextblock->allocated_refs + 1))
+                return -ENOMEM;
+
         /* claim remaining space on the page
            this happens, if we have a change to a new block,
            or if fsync forces us to flush the writebuffer.
@@ -458,15 +575,12 @@ static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
         if (breakme++ == 20) {
                 printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs);
                 breakme = 0;
-                c->mtd->write_ecc(c->mtd, c->wbuf_ofs, c->wbuf_pagesize,
-                                        &retlen, brokenbuf, NULL, c->oobinfo);
+                c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen,
+                              brokenbuf);
                 ret = -EIO;
         } else
 #endif
 
-        if (jffs2_cleanmarker_oob(c))
-                ret = c->mtd->write_ecc(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf, NULL, c->oobinfo);
-        else
                 ret = c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf);
 
         if (ret || retlen != c->wbuf_pagesize) {
@@ -483,32 +597,34 @@ static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
                 return ret;
         }
 
-        spin_lock(&c->erase_completion_lock);
-
         /* Adjust free size of the block if we padded. */
         if (pad) {
-                struct jffs2_eraseblock *jeb;
-
-                jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
+                uint32_t waste = c->wbuf_pagesize - c->wbuf_len;
 
                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
-                          (jeb==c->nextblock)?"next":"", jeb->offset));
+                          (wbuf_jeb==c->nextblock)?"next":"", wbuf_jeb->offset));
 
                 /* wbuf_pagesize - wbuf_len is the amount of space that's to be
                    padded. If there is less free space in the block than that,
                    something screwed up */
-                if (jeb->free_size < (c->wbuf_pagesize - c->wbuf_len)) {
+                if (wbuf_jeb->free_size < waste) {
                         printk(KERN_CRIT "jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
-                               c->wbuf_ofs, c->wbuf_len, c->wbuf_pagesize-c->wbuf_len);
+                               c->wbuf_ofs, c->wbuf_len, waste);
                         printk(KERN_CRIT "jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
-                               jeb->offset, jeb->free_size);
+                               wbuf_jeb->offset, wbuf_jeb->free_size);
                         BUG();
                 }
-                jeb->free_size -= (c->wbuf_pagesize - c->wbuf_len);
-                c->free_size -= (c->wbuf_pagesize - c->wbuf_len);
-                jeb->wasted_size += (c->wbuf_pagesize - c->wbuf_len);
-                c->wasted_size += (c->wbuf_pagesize - c->wbuf_len);
-        }
+
+                spin_lock(&c->erase_completion_lock);
+
+                jffs2_link_node_ref(c, wbuf_jeb, (c->wbuf_ofs + c->wbuf_len) | REF_OBSOLETE, waste, NULL);
+                /* FIXME: that made it count as dirty. Convert to wasted */
+                wbuf_jeb->dirty_size -= waste;
+                c->dirty_size -= waste;
+                wbuf_jeb->wasted_size += waste;
+                c->wasted_size += waste;
+        } else
+                spin_lock(&c->erase_completion_lock);
 
         /* Stick any now-obsoleted blocks on the erase_pending_list */
         jffs2_refile_wbuf_blocks(c);
@@ -603,20 +719,30 @@ int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c)
 
         return ret;
 }
-int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs, unsigned long count, loff_t to, size_t *retlen, uint32_t ino)
+
+static size_t jffs2_fill_wbuf(struct jffs2_sb_info *c, const uint8_t *buf,
+                              size_t len)
 {
-        struct kvec outvecs[3];
-        uint32_t totlen = 0;
-        uint32_t split_ofs = 0;
-        uint32_t old_totlen;
-        int ret, splitvec = -1;
-        int invec, outvec;
-        size_t wbuf_retlen;
-        unsigned char *wbuf_ptr;
-        size_t donelen = 0;
+        if (len && !c->wbuf_len && (len >= c->wbuf_pagesize))
+                return 0;
+
+        if (len > (c->wbuf_pagesize - c->wbuf_len))
+                len = c->wbuf_pagesize - c->wbuf_len;
+        memcpy(c->wbuf + c->wbuf_len, buf, len);
+        c->wbuf_len += (uint32_t) len;
+        return len;
+}
+
+int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs,
+                       unsigned long count, loff_t to, size_t *retlen,
+                       uint32_t ino)
+{
+        struct jffs2_eraseblock *jeb;
+        size_t wbuf_retlen, donelen = 0;
         uint32_t outvec_to = to;
+        int ret, invec;
 
-        /* If not NAND flash, don't bother */
+        /* If not writebuffered flash, don't bother */
         if (!jffs2_is_writebuffered(c))
                 return jffs2_flash_direct_writev(c, invecs, count, to, retlen);
 
@@ -629,34 +755,22 @@ int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs, unsig
                 memset(c->wbuf,0xff,c->wbuf_pagesize);
         }
 
-        /* Fixup the wbuf if we are moving to a new eraseblock.  The checks below
-           fail for ECC'd NOR because cleanmarker == 16, so a block starts at
-           xxx0010.  */
-        if (jffs2_nor_ecc(c)) {
-                if (((c->wbuf_ofs % c->sector_size) == 0) && !c->wbuf_len) {
-                        c->wbuf_ofs = PAGE_DIV(to);
-                        c->wbuf_len = PAGE_MOD(to);
-                        memset(c->wbuf,0xff,c->wbuf_pagesize);
-                }
-        }
-
-        /* Sanity checks on target address.
-           It's permitted to write at PAD(c->wbuf_len+c->wbuf_ofs),
-           and it's permitted to write at the beginning of a new
-           erase block. Anything else, and you die.
-           New block starts at xxx000c (0-b = block header)
-        */
+        /*
+         * Sanity checks on target address.  It's permitted to write
+         * at PAD(c->wbuf_len+c->wbuf_ofs), and it's permitted to
+         * write at the beginning of a new erase block. Anything else,
+         * and you die.  New block starts at xxx000c (0-b = block
+         * header)
+         */
         if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) {
                 /* It's a write to a new block */
                 if (c->wbuf_len) {
-                        D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx causes flush of wbuf at 0x%08x\n", (unsigned long)to, c->wbuf_ofs));
+                        D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx "
+                                  "causes flush of wbuf at 0x%08x\n",
+                                  (unsigned long)to, c->wbuf_ofs));
                         ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
-                        if (ret) {
-                                /* the underlying layer has to check wbuf_len to do the cleanup */
-                                D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret));
-                                *retlen = 0;
-                                goto exit;
-                        }
+                        if (ret)
+                                goto outerr;
                 }
                 /* set pointer to new block */
                 c->wbuf_ofs = PAGE_DIV(to);
@@ -665,165 +779,70 @@ int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs, unsig
 
         if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
                 /* We're not writing immediately after the writebuffer. Bad. */
-                printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write to %08lx\n", (unsigned long)to);
+                printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write "
+                       "to %08lx\n", (unsigned long)to);
                 if (c->wbuf_len)
                         printk(KERN_CRIT "wbuf was previously %08x-%08x\n",
-                                          c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
+                               c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
                 BUG();
         }
 
-        /* Note outvecs[3] above. We know count is never greater than 2 */
-        if (count > 2) {
-                printk(KERN_CRIT "jffs2_flash_writev(): count is %ld\n", count);
-                BUG();
-        }
-
-        invec = 0;
-        outvec = 0;
-
-        /* Fill writebuffer first, if already in use */
-        if (c->wbuf_len) {
-                uint32_t invec_ofs = 0;
-
-                /* adjust alignment offset */
-                if (c->wbuf_len != PAGE_MOD(to)) {
-                        c->wbuf_len = PAGE_MOD(to);
-                        /* take care of alignment to next page */
-                        if (!c->wbuf_len)
-                                c->wbuf_len = c->wbuf_pagesize;
-                }
-
-                while(c->wbuf_len < c->wbuf_pagesize) {
-                        uint32_t thislen;
-
-                        if (invec == count)
-                                goto alldone;
-
-                        thislen = c->wbuf_pagesize - c->wbuf_len;
-
-                        if (thislen >= invecs[invec].iov_len)
-                                thislen = invecs[invec].iov_len;
-
-                        invec_ofs = thislen;
-
-                        memcpy(c->wbuf + c->wbuf_len, invecs[invec].iov_base, thislen);
-                        c->wbuf_len += thislen;
-                        donelen += thislen;
-                        /* Get next invec, if actual did not fill the buffer */
-                        if (c->wbuf_len < c->wbuf_pagesize)
-                                invec++;
-                }
-
-                /* write buffer is full, flush buffer */
-                ret = __jffs2_flush_wbuf(c, NOPAD);
-                if (ret) {
-                        /* the underlying layer has to check wbuf_len to do the cleanup */
-                        D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret));
-                        /* Retlen zero to make sure our caller doesn't mark the space dirty.
-                           We've already done everything that's necessary */
-                        *retlen = 0;
-                        goto exit;
-                }
-                outvec_to += donelen;
-                c->wbuf_ofs = outvec_to;
-
-                /* All invecs done ? */
-                if (invec == count)
-                        goto alldone;
-
-                /* Set up the first outvec, containing the remainder of the
-                   invec we partially used */
-                if (invecs[invec].iov_len > invec_ofs) {
-                        outvecs[0].iov_base = invecs[invec].iov_base+invec_ofs;
-                        totlen = outvecs[0].iov_len = invecs[invec].iov_len-invec_ofs;
-                        if (totlen > c->wbuf_pagesize) {
-                                splitvec = outvec;
-                                split_ofs = outvecs[0].iov_len - PAGE_MOD(totlen);
-                        }
-                        outvec++;
-                }
-                invec++;
-        }
-
-        /* OK, now we've flushed the wbuf and the start of the bits
-           we have been asked to write, now to write the rest.... */
-
-        /* totlen holds the amount of data still to be written */
-        old_totlen = totlen;
-        for ( ; invec < count; invec++,outvec++ ) {
-                outvecs[outvec].iov_base = invecs[invec].iov_base;
-                totlen += outvecs[outvec].iov_len = invecs[invec].iov_len;
-                if (PAGE_DIV(totlen) != PAGE_DIV(old_totlen)) {
-                        splitvec = outvec;
-                        split_ofs = outvecs[outvec].iov_len - PAGE_MOD(totlen);
-                        old_totlen = totlen;
+        /* adjust alignment offset */
+        if (c->wbuf_len != PAGE_MOD(to)) {
+                c->wbuf_len = PAGE_MOD(to);
+                /* take care of alignment to next page */
+                if (!c->wbuf_len) {
+                        c->wbuf_len = c->wbuf_pagesize;
+                        ret = __jffs2_flush_wbuf(c, NOPAD);
+                        if (ret)
+                                goto outerr;
                 }
         }
 
-        /* Now the outvecs array holds all the remaining data to write */
-        /* Up to splitvec,split_ofs is to be written immediately. The rest
-           goes into the (now-empty) wbuf */
-
-        if (splitvec != -1) {
-                uint32_t remainder;
-
-                remainder = outvecs[splitvec].iov_len - split_ofs;
-                outvecs[splitvec].iov_len = split_ofs;
-
-                /* We did cross a page boundary, so we write some now */
-                if (jffs2_cleanmarker_oob(c))
-                        ret = c->mtd->writev_ecc(c->mtd, outvecs, splitvec+1, outvec_to, &wbuf_retlen, NULL, c->oobinfo);
-                else
-                        ret = jffs2_flash_direct_writev(c, outvecs, splitvec+1, outvec_to, &wbuf_retlen);
-
-                if (ret < 0 || wbuf_retlen != PAGE_DIV(totlen)) {
-                        /* At this point we have no problem,
-                           c->wbuf is empty. However refile nextblock to avoid
-                           writing again to same address.
-                        */
-                        struct jffs2_eraseblock *jeb;
+        for (invec = 0; invec < count; invec++) {
+                int vlen = invecs[invec].iov_len;
+                uint8_t *v = invecs[invec].iov_base;
 
-                        spin_lock(&c->erase_completion_lock);
+                wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
 
-                        jeb = &c->blocks[outvec_to / c->sector_size];
-                        jffs2_block_refile(c, jeb, REFILE_ANYWAY);
-
-                        *retlen = 0;
-                        spin_unlock(&c->erase_completion_lock);
-                        goto exit;
+                if (c->wbuf_len == c->wbuf_pagesize) {
+                        ret = __jffs2_flush_wbuf(c, NOPAD);
+                        if (ret)
+                                goto outerr;
                 }
-
+                vlen -= wbuf_retlen;
+                outvec_to += wbuf_retlen;
                 donelen += wbuf_retlen;
-                c->wbuf_ofs = PAGE_DIV(outvec_to) + PAGE_DIV(totlen);
-
-                if (remainder) {
-                        outvecs[splitvec].iov_base += split_ofs;
-                        outvecs[splitvec].iov_len = remainder;
-                } else {
-                        splitvec++;
+                v += wbuf_retlen;
+
+                if (vlen >= c->wbuf_pagesize) {
+                        ret = c->mtd->write(c->mtd, outvec_to, PAGE_DIV(vlen),
+                                            &wbuf_retlen, v);
+                        if (ret < 0 || wbuf_retlen != PAGE_DIV(vlen))
+                                goto outfile;
+
+                        vlen -= wbuf_retlen;
+                        outvec_to += wbuf_retlen;
+                        c->wbuf_ofs = outvec_to;
+                        donelen += wbuf_retlen;
+                        v += wbuf_retlen;
                 }
 
-        } else {
-                splitvec = 0;
-        }
-
-        /* Now splitvec points to the start of the bits we have to copy
-           into the wbuf */
-        wbuf_ptr = c->wbuf;
+                wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
+                if (c->wbuf_len == c->wbuf_pagesize) {
+                        ret = __jffs2_flush_wbuf(c, NOPAD);
+                        if (ret)
+                                goto outerr;
+                }
 
-        for ( ; splitvec < outvec; splitvec++) {
-                /* Don't copy the wbuf into itself */
-                if (outvecs[splitvec].iov_base == c->wbuf)
-                        continue;
-                memcpy(wbuf_ptr, outvecs[splitvec].iov_base, outvecs[splitvec].iov_len);
-                wbuf_ptr += outvecs[splitvec].iov_len;
-                donelen += outvecs[splitvec].iov_len;
+                outvec_to += wbuf_retlen;
+                donelen += wbuf_retlen;
         }
-        c->wbuf_len = wbuf_ptr - c->wbuf;
 
-        /* If there's a remainder in the wbuf and it's a non-GC write,
-           remember that the wbuf affects this ino */
-alldone:
+        /*
+         * If there's a remainder in the wbuf and it's a non-GC write,
+         * remember that the wbuf affects this ino
+         */
         *retlen = donelen;
 
         if (jffs2_sum_active()) {
@@ -836,8 +855,24 @@ alldone:
                 jffs2_wbuf_dirties_inode(c, ino);
 
         ret = 0;
+        up_write(&c->wbuf_sem);
+        return ret;
 
-exit:
+outfile:
+        /*
+         * At this point we have no problem, c->wbuf is empty. However
+         * refile nextblock to avoid writing again to same address.
+         */
+
+        spin_lock(&c->erase_completion_lock);
+
+        jeb = &c->blocks[outvec_to / c->sector_size];
+        jffs2_block_refile(c, jeb, REFILE_ANYWAY);
+
+        spin_unlock(&c->erase_completion_lock);
+
+outerr:
+        *retlen = 0;
         up_write(&c->wbuf_sem);
         return ret;
 }
@@ -846,7 +881,8 @@ exit:
  *      This is the entry for flash write.
  *      Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
 */
-int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, const u_char *buf)
+int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len,
+                      size_t *retlen, const u_char *buf)
 {
         struct kvec vecs[1];
 
@@ -871,25 +907,23 @@ int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *re
 
         /* Read flash */
         down_read(&c->wbuf_sem);
-        if (jffs2_cleanmarker_oob(c))
-                ret = c->mtd->read_ecc(c->mtd, ofs, len, retlen, buf, NULL, c->oobinfo);
-        else
-                ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
-
-        if ( (ret == -EBADMSG) && (*retlen == len) ) {
-                printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx) returned ECC error\n",
-                       len, ofs);
+        ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
+
+        if ( (ret == -EBADMSG || ret == -EUCLEAN) && (*retlen == len) ) {
+                if (ret == -EBADMSG)
+                        printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx)"
+                               " returned ECC error\n", len, ofs);
                 /*
-                 * We have the raw data without ECC correction in the buffer, maybe
-                 * we are lucky and all data or parts are correct. We check the node.
-                 * If data are corrupted node check will sort it out.
-                 * We keep this block, it will fail on write or erase and the we
-                 * mark it bad. Or should we do that now? But we should give him a chance.
-                 * Maybe we had a system crash or power loss before the ecc write or
-                 * a erase was completed.
+                 * We have the raw data without ECC correction in the buffer,
+                 * maybe we are lucky and all data or parts are correct. We
+                 * check the node.  If data are corrupted node check will sort
+                 * it out.  We keep this block, it will fail on write or erase
+                 * and the we mark it bad. Or should we do that now? But we
+                 * should give him a chance.  Maybe we had a system crash or
+                 * power loss before the ecc write or a erase was completed.
                  * So we return success. :)
                  */
-                ret = 0;
+                ret = 0;
         }
 
         /* if no writebuffer available or write buffer empty, return */
@@ -911,7 +945,7 @@ int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *re
                 orbf = (c->wbuf_ofs - ofs);     /* offset in read buffer */
                 if (orbf > len)                 /* is write beyond write buffer ? */
                         goto exit;
-                lwbf = len - orbf;              /* number of bytes to copy */
+                lwbf = len - orbf;              /* number of bytes to copy */
                 if (lwbf > c->wbuf_len)
                         lwbf = c->wbuf_len;
         }
@@ -923,158 +957,159 @@ exit:
         return ret;
 }
 
+#define NR_OOB_SCAN_PAGES       4
+
 /*
- *      Check, if the out of band area is empty
+ * Check, if the out of band area is empty
  */
-int jffs2_check_oob_empty( struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int mode)
+int jffs2_check_oob_empty(struct jffs2_sb_info *c,
+                          struct jffs2_eraseblock *jeb, int mode)
 {
-        unsigned char *buf;
-        int     ret = 0;
-        int     i,len,page;
-        size_t  retlen;
-        int     oob_size;
-
-        /* allocate a buffer for all oob data in this sector */
-        oob_size = c->mtd->oobsize;
-        len = 4 * oob_size;
-        buf = kmalloc(len, GFP_KERNEL);
-        if (!buf) {
-                printk(KERN_NOTICE "jffs2_check_oob_empty(): allocation of temporary data buffer for oob check failed\n");
-                return -ENOMEM;
-        }
-        /*
-         * if mode = 0, we scan for a total empty oob area, else we have
-         * to take care of the cleanmarker in the first page of the block
-        */
-        ret = jffs2_flash_read_oob(c, jeb->offset, len , &retlen, buf);
+        int i, page, ret;
+        int oobsize = c->mtd->oobsize;
+        struct mtd_oob_ops ops;
+
+        ops.len = NR_OOB_SCAN_PAGES * oobsize;
+        ops.ooblen = oobsize;
+        ops.oobbuf = c->oobbuf;
+        ops.ooboffs = 0;
+        ops.datbuf = NULL;
+        ops.mode = MTD_OOB_PLACE;
+
+        ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
         if (ret) {
-                D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB failed %d for block at %08x\n", ret, jeb->offset));
-                goto out;
+                D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB "
+                          "failed %d for block at %08x\n", ret, jeb->offset));
+                return ret;
         }
 
-        if (retlen < len) {
-                D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB return short read "
-                          "(%zd bytes not %d) for block at %08x\n", retlen, len, jeb->offset));
-                ret = -EIO;
-                goto out;
+        if (ops.retlen < ops.len) {
+                D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB "
+                          "returned short read (%zd bytes not %d) for block "
+                          "at %08x\n", ops.retlen, ops.len, jeb->offset));
+                return -EIO;
         }
 
         /* Special check for first page */
-        for(i = 0; i < oob_size ; i++) {
+        for(i = 0; i < oobsize ; i++) {
                 /* Yeah, we know about the cleanmarker. */
                 if (mode && i >= c->fsdata_pos &&
                     i < c->fsdata_pos + c->fsdata_len)
                         continue;
 
-                if (buf[i] != 0xFF) {
-                        D2(printk(KERN_DEBUG "Found %02x at %x in OOB for %08x\n",
-                                  buf[i], i, jeb->offset));
-                        ret = 1;
-                        goto out;
+                if (ops.oobbuf[i] != 0xFF) {
+                        D2(printk(KERN_DEBUG "Found %02x at %x in OOB for "
+                                  "%08x\n", ops.oobbuf[i], i, jeb->offset));
+                        return 1;
                 }
         }
 
         /* we know, we are aligned :) */
-        for (page = oob_size; page < len; page += sizeof(long)) {
-                unsigned long dat = *(unsigned long *)(&buf[page]);
-                if(dat != -1) {
-                        ret = 1;
-                        goto out;
-                }
+        for (page = oobsize; page < ops.len; page += sizeof(long)) {
+                long dat = *(long *)(&ops.oobbuf[page]);
+                if(dat != -1)
+                        return 1;
         }
-
-out:
-        kfree(buf);
-
-        return ret;
+        return 0;
 }
 
 /*
-*       Scan for a valid cleanmarker and for bad blocks
-*       For virtual blocks (concatenated physical blocks) check the cleanmarker
-*       only in the first page of the first physical block, but scan for bad blocks in all
-*       physical blocks
-*/
-int jffs2_check_nand_cleanmarker (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
+ * Scan for a valid cleanmarker and for bad blocks
+ */
+int jffs2_check_nand_cleanmarker (struct jffs2_sb_info *c,
+                                  struct jffs2_eraseblock *jeb)
 {
         struct jffs2_unknown_node n;
-        unsigned char buf[2 * NAND_MAX_OOBSIZE];
-        unsigned char *p;
-        int ret, i, cnt, retval = 0;
-        size_t retlen, offset;
-        int oob_size;
-
-        offset = jeb->offset;
-        oob_size = c->mtd->oobsize;
-
-        /* Loop through the physical blocks */
-        for (cnt = 0; cnt < (c->sector_size / c->mtd->erasesize); cnt++) {
-                /* Check first if the block is bad. */
-                if (c->mtd->block_isbad (c->mtd, offset)) {
-                        D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Bad block at %08x\n", jeb->offset));
-                        return 2;
-                }
-                /*
-                   *    We read oob data from page 0 and 1 of the block.
-                   *    page 0 contains cleanmarker and badblock info
-                   *    page 1 contains failure count of this block
-                 */
-                ret = c->mtd->read_oob (c->mtd, offset, oob_size << 1, &retlen, buf);
+        struct mtd_oob_ops ops;
+        int oobsize = c->mtd->oobsize;
+        unsigned char *p,*b;
+        int i, ret;
+        size_t offset = jeb->offset;
+
+        /* Check first if the block is bad. */
+        if (c->mtd->block_isbad(c->mtd, offset)) {
+                D1 (printk(KERN_WARNING "jffs2_check_nand_cleanmarker()"
+                           ": Bad block at %08x\n", jeb->offset));
+                return 2;
+        }
 
-                if (ret) {
-                        D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Read OOB failed %d for block at %08x\n", ret, jeb->offset));
-                        return ret;
-                }
-                if (retlen < (oob_size << 1)) {
-                        D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Read OOB return short read (%zd bytes not %d) for block at %08x\n", retlen, oob_size << 1, jeb->offset));
-                        return -EIO;
-                }
+        ops.len = oobsize;
+        ops.ooblen = oobsize;
+        ops.oobbuf = c->oobbuf;
+        ops.ooboffs = 0;
+        ops.datbuf = NULL;
+        ops.mode = MTD_OOB_PLACE;
 
-                /* Check cleanmarker only on the first physical block */
-                if (!cnt) {
-                        n.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK);
-                        n.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER);
-                        n.totlen = cpu_to_je32 (8);
-                        p = (unsigned char *) &n;
+        ret = c->mtd->read_oob(c->mtd, offset, &ops);
+        if (ret) {
+                D1 (printk(KERN_WARNING "jffs2_check_nand_cleanmarker(): "
+                           "Read OOB failed %d for block at %08x\n",
+                           ret, jeb->offset));
+                return ret;
+        }
 
-                        for (i = 0; i < c->fsdata_len; i++) {
-                                if (buf[c->fsdata_pos + i] != p[i]) {
-                                        retval = 1;
-                                }
-                        }
-                        D1(if (retval == 1) {
-                                printk(KERN_WARNING "jffs2_check_nand_cleanmarker(): Cleanmarker node not detected in block at %08x\n", jeb->offset);
-                                printk(KERN_WARNING "OOB at %08x was ", offset);
-                                for (i=0; i < oob_size; i++) {
-                                        printk("%02x ", buf[i]);
-                                }
-                                printk("\n");
-                        })
-                }
-                offset += c->mtd->erasesize;
+        if (ops.retlen < ops.len) {
+                D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): "
+                            "Read OOB return short read (%zd bytes not %d) "
+                            "for block at %08x\n", ops.retlen, ops.len,
+                            jeb->offset));
+                return -EIO;
         }
-        return retval;
+
+        n.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK);
+        n.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER);
+        n.totlen = cpu_to_je32 (8);
+        p = (unsigned char *) &n;
+        b = c->oobbuf + c->fsdata_pos;
+
+        for (i = c->fsdata_len; i; i--) {
+                if (*b++ != *p++)
+                        ret = 1;
+        }
+
+        D1(if (ret == 1) {
+                printk(KERN_WARNING "jffs2_check_nand_cleanmarker(): "
+                       "Cleanmarker node not detected in block at %08x\n",
+                       offset);
+                printk(KERN_WARNING "OOB at %08zx was ", offset);
+                for (i=0; i < oobsize; i++)
+                        printk("%02x ", c->oobbuf[i]);
+                printk("\n");
+        });
+        return ret;
 }
 
-int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
+int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c,
+                                 struct jffs2_eraseblock *jeb)
 {
-        struct  jffs2_unknown_node n;
-        int     ret;
-        size_t  retlen;
+        struct jffs2_unknown_node n;
+        int     ret;
+        struct mtd_oob_ops ops;
 
         n.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
         n.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER);
         n.totlen = cpu_to_je32(8);
 
-        ret = jffs2_flash_write_oob(c, jeb->offset + c->fsdata_pos, c->fsdata_len, &retlen, (unsigned char *)&n);
+        ops.len = c->fsdata_len;
+        ops.ooblen = c->fsdata_len;;
+        ops.oobbuf = (uint8_t *)&n;
+        ops.ooboffs = c->fsdata_pos;
+        ops.datbuf = NULL;
+        ops.mode = MTD_OOB_PLACE;
+
+        ret = c->mtd->write_oob(c->mtd, jeb->offset, &ops);
 
         if (ret) {
-                D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
+                D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): "
+                          "Write failed for block at %08x: error %d\n",
+                          jeb->offset, ret));
                 return ret;
         }
-        if (retlen != c->fsdata_len) {
-                D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Short write for block at %08x: %zd not %d\n", jeb->offset, retlen, c->fsdata_len));
-                return ret;
+        if (ops.retlen != ops.len) {
+                D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): "
+                          "Short write for block at %08x: %zd not %d\n",
+                          jeb->offset, ops.retlen, ops.len));
+                return -EIO;
         }
         return 0;
 }
@@ -1108,18 +1143,9 @@ int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *
         return 1;
 }
 
-#define NAND_JFFS2_OOB16_FSDALEN        8
-
-static struct nand_oobinfo jffs2_oobinfo_docecc = {
-        .useecc = MTD_NANDECC_PLACE,
-        .eccbytes = 6,
-        .eccpos = {0,1,2,3,4,5}
-};
-
-
 static int jffs2_nand_set_oobinfo(struct jffs2_sb_info *c)
 {
-        struct nand_oobinfo *oinfo = &c->mtd->oobinfo;
+        struct nand_ecclayout *oinfo = c->mtd->ecclayout;
 
         /* Do this only, if we have an oob buffer */
         if (!c->mtd->oobsize)
@@ -1129,33 +1155,23 @@ static int jffs2_nand_set_oobinfo(struct jffs2_sb_info *c)
         c->cleanmarker_size = 0;
 
         /* Should we use autoplacement ? */
-        if (oinfo && oinfo->useecc == MTD_NANDECC_AUTOPLACE) {
-                D1(printk(KERN_DEBUG "JFFS2 using autoplace on NAND\n"));
-                /* Get the position of the free bytes */
-                if (!oinfo->oobfree[0][1]) {
-                        printk (KERN_WARNING "jffs2_nand_set_oobinfo(): Eeep. Autoplacement selected and no empty space in oob\n");
-                        return -ENOSPC;
-                }
-                c->fsdata_pos = oinfo->oobfree[0][0];
-                c->fsdata_len = oinfo->oobfree[0][1];
-                if (c->fsdata_len > 8)
-                        c->fsdata_len = 8;
-        } else {
-                /* This is just a legacy fallback and should go away soon */
-                switch(c->mtd->ecctype) {
-                case MTD_ECC_RS_DiskOnChip:
-                        printk(KERN_WARNING "JFFS2 using DiskOnChip hardware ECC without autoplacement. Fix it!\n");
-                        c->oobinfo = &jffs2_oobinfo_docecc;
-                        c->fsdata_pos = 6;
-                        c->fsdata_len = NAND_JFFS2_OOB16_FSDALEN;
-                        c->badblock_pos = 15;
-                        break;
+        if (!oinfo) {
+                D1(printk(KERN_DEBUG "JFFS2 on NAND. No autoplacment info found\n"));
+                return -EINVAL;
+        }
 
-                default:
-                        D1(printk(KERN_DEBUG "JFFS2 on NAND. No autoplacment info found\n"));
-                        return -EINVAL;
-                }
+        D1(printk(KERN_DEBUG "JFFS2 using autoplace on NAND\n"));
+        /* Get the position of the free bytes */
+        if (!oinfo->oobfree[0].length) {
+                printk (KERN_WARNING "jffs2_nand_set_oobinfo(): Eeep."
+                        " Autoplacement selected and no empty space in oob\n");
+                return -ENOSPC;
         }
+        c->fsdata_pos = oinfo->oobfree[0].offset;
+        c->fsdata_len = oinfo->oobfree[0].length;
+        if (c->fsdata_len > 8)
+                c->fsdata_len = 8;
+
         return 0;
 }
 
@@ -1165,13 +1181,17 @@ int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
 
         /* Initialise write buffer */
         init_rwsem(&c->wbuf_sem);
-        c->wbuf_pagesize = c->mtd->oobblock;
+        c->wbuf_pagesize = c->mtd->writesize;
         c->wbuf_ofs = 0xFFFFFFFF;
 
         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
         if (!c->wbuf)
                 return -ENOMEM;
 
+        c->oobbuf = kmalloc(NR_OOB_SCAN_PAGES * c->mtd->oobsize, GFP_KERNEL);
+        if (!c->oobbuf)
+                return -ENOMEM;
+
         res = jffs2_nand_set_oobinfo(c);
 
 #ifdef BREAKME
@@ -1189,6 +1209,7 @@ int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
 void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
 {
         kfree(c->wbuf);
+        kfree(c->oobbuf);
 }
 
 int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
@@ -1236,33 +1257,14 @@ void jffs2_dataflash_cleanup(struct jffs2_sb_info *c) {
         kfree(c->wbuf);
 }
 
-int jffs2_nor_ecc_flash_setup(struct jffs2_sb_info *c) {
-        /* Cleanmarker is actually larger on the flashes */
-        c->cleanmarker_size = 16;
-
-        /* Initialize write buffer */
-        init_rwsem(&c->wbuf_sem);
-        c->wbuf_pagesize = c->mtd->eccsize;
-        c->wbuf_ofs = 0xFFFFFFFF;
-
-        c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
-        if (!c->wbuf)
-                return -ENOMEM;
-
-        return 0;
-}
-
-void jffs2_nor_ecc_flash_cleanup(struct jffs2_sb_info *c) {
-        kfree(c->wbuf);
-}
-
 int jffs2_nor_wbuf_flash_setup(struct jffs2_sb_info *c) {
-        /* Cleanmarker currently occupies a whole programming region */
-        c->cleanmarker_size = MTD_PROGREGION_SIZE(c->mtd);
+        /* Cleanmarker currently occupies whole programming regions,
+         * either one or 2 for 8Byte STMicro flashes. */
+        c->cleanmarker_size = max(16u, c->mtd->writesize);
 
         /* Initialize write buffer */
         init_rwsem(&c->wbuf_sem);
-        c->wbuf_pagesize = MTD_PROGREGION_SIZE(c->mtd);
+        c->wbuf_pagesize = c->mtd->writesize;
         c->wbuf_ofs = 0xFFFFFFFF;
 
         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
diff --git a/fs/jffs2/write.c b/fs/jffs2/write.c
index 1342f0158e9b..67176792e138 100644
--- a/fs/jffs2/write.c
+++ b/fs/jffs2/write.c
@@ -37,7 +37,6 @@ int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint
         f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
         f->inocache->state = INO_STATE_PRESENT;
 
-
         jffs2_add_ino_cache(c, f->inocache);
         D1(printk(KERN_DEBUG "jffs2_do_new_inode(): Assigned ino# %d\n", f->inocache->ino));
         ri->ino = cpu_to_je32(f->inocache->ino);
@@ -57,12 +56,14 @@ int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint
 /* jffs2_write_dnode - given a raw_inode, allocate a full_dnode for it,
    write it to the flash, link it into the existing inode/fragment list */
 
-struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_raw_inode *ri, const unsigned char *data, uint32_t datalen, uint32_t flash_ofs, int alloc_mode)
+struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
+                                           struct jffs2_raw_inode *ri, const unsigned char *data,
+                                           uint32_t datalen, int alloc_mode)
 
 {
-        struct jffs2_raw_node_ref *raw;
         struct jffs2_full_dnode *fn;
         size_t retlen;
+        uint32_t flash_ofs;
         struct kvec vecs[2];
         int ret;
         int retried = 0;
@@ -78,34 +79,21 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
         vecs[1].iov_base = (unsigned char *)data;
         vecs[1].iov_len = datalen;
 
-        jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
-
         if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) {
                 printk(KERN_WARNING "jffs2_write_dnode: ri->totlen (0x%08x) != sizeof(*ri) (0x%08zx) + datalen (0x%08x)\n", je32_to_cpu(ri->totlen), sizeof(*ri), datalen);
         }
-        raw = jffs2_alloc_raw_node_ref();
-        if (!raw)
-                return ERR_PTR(-ENOMEM);
 
         fn = jffs2_alloc_full_dnode();
-        if (!fn) {
-                jffs2_free_raw_node_ref(raw);
+        if (!fn)
                 return ERR_PTR(-ENOMEM);
-        }
-
-        fn->ofs = je32_to_cpu(ri->offset);
-        fn->size = je32_to_cpu(ri->dsize);
-        fn->frags = 0;
 
         /* check number of valid vecs */
         if (!datalen || !data)
                 cnt = 1;
  retry:
-        fn->raw = raw;
+        flash_ofs = write_ofs(c);
 
-        raw->flash_offset = flash_ofs;
-        raw->__totlen = PAD(sizeof(*ri)+datalen);
-        raw->next_phys = NULL;
+        jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
 
         if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) {
                 BUG_ON(!retried);
@@ -125,22 +113,16 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
 
                 /* Mark the space as dirtied */
                 if (retlen) {
-                        /* Doesn't belong to any inode */
-                        raw->next_in_ino = NULL;
-
                         /* Don't change raw->size to match retlen. We may have
                            written the node header already, and only the data will
                            seem corrupted, in which case the scan would skip over
                            any node we write before the original intended end of
                            this node */
-                        raw->flash_offset |= REF_OBSOLETE;
-                        jffs2_add_physical_node_ref(c, raw);
-                        jffs2_mark_node_obsolete(c, raw);
+                        jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL);
                 } else {
-                        printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", raw->flash_offset);
-                        jffs2_free_raw_node_ref(raw);
+                        printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs);
                 }
-                if (!retried && alloc_mode != ALLOC_NORETRY && (raw = jffs2_alloc_raw_node_ref())) {
+                if (!retried && alloc_mode != ALLOC_NORETRY) {
                         /* Try to reallocate space and retry */
                         uint32_t dummy;
                         struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
@@ -153,19 +135,20 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
                         jffs2_dbg_acct_paranoia_check(c, jeb);
 
                         if (alloc_mode == ALLOC_GC) {
-                                ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &flash_ofs,
-                                                        &dummy, JFFS2_SUMMARY_INODE_SIZE);
+                                ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &dummy,
+                                                             JFFS2_SUMMARY_INODE_SIZE);
                         } else {
                                 /* Locking pain */
                                 up(&f->sem);
                                 jffs2_complete_reservation(c);
 
-                                ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &flash_ofs,
-                                                        &dummy, alloc_mode, JFFS2_SUMMARY_INODE_SIZE);
+                                ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &dummy,
+                                                          alloc_mode, JFFS2_SUMMARY_INODE_SIZE);
                                 down(&f->sem);
                         }
 
                         if (!ret) {
+                                flash_ofs = write_ofs(c);
                                 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
 
                                 jffs2_dbg_acct_sanity_check(c,jeb);
@@ -174,7 +157,6 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
                                 goto retry;
                         }
                         D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
-                        jffs2_free_raw_node_ref(raw);
                 }
                 /* Release the full_dnode which is now useless, and return */
                 jffs2_free_full_dnode(fn);
@@ -188,20 +170,17 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
         if ((je32_to_cpu(ri->dsize) >= PAGE_CACHE_SIZE) ||
             ( ((je32_to_cpu(ri->offset)&(PAGE_CACHE_SIZE-1))==0) &&
               (je32_to_cpu(ri->dsize)+je32_to_cpu(ri->offset) ==  je32_to_cpu(ri->isize)))) {
-                raw->flash_offset |= REF_PRISTINE;
+                flash_ofs |= REF_PRISTINE;
         } else {
-                raw->flash_offset |= REF_NORMAL;
+                flash_ofs |= REF_NORMAL;
         }
-        jffs2_add_physical_node_ref(c, raw);
-
-        /* Link into per-inode list */
-        spin_lock(&c->erase_completion_lock);
-        raw->next_in_ino = f->inocache->nodes;
-        f->inocache->nodes = raw;
-        spin_unlock(&c->erase_completion_lock);
+        fn->raw = jffs2_add_physical_node_ref(c, flash_ofs, PAD(sizeof(*ri)+datalen), f->inocache);
+        fn->ofs = je32_to_cpu(ri->offset);
+        fn->size = je32_to_cpu(ri->dsize);
+        fn->frags = 0;
 
         D1(printk(KERN_DEBUG "jffs2_write_dnode wrote node at 0x%08x(%d) with dsize 0x%x, csize 0x%x, node_crc 0x%08x, data_crc 0x%08x, totlen 0x%08x\n",
-                  flash_ofs, ref_flags(raw), je32_to_cpu(ri->dsize),
+                  flash_ofs & ~3, flash_ofs & 3, je32_to_cpu(ri->dsize),
                   je32_to_cpu(ri->csize), je32_to_cpu(ri->node_crc),
                   je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen)));
 
@@ -212,12 +191,14 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
         return fn;
 }
 
-struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_raw_dirent *rd, const unsigned char *name, uint32_t namelen, uint32_t flash_ofs, int alloc_mode)
+struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
+                                             struct jffs2_raw_dirent *rd, const unsigned char *name,
+                                             uint32_t namelen, int alloc_mode)
 {
-        struct jffs2_raw_node_ref *raw;
         struct jffs2_full_dirent *fd;
         size_t retlen;
         struct kvec vecs[2];
+        uint32_t flash_ofs;
         int retried = 0;
         int ret;
 
@@ -228,26 +209,16 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
         D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) {
                 printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n");
                 BUG();
-        }
-           );
+           });
 
         vecs[0].iov_base = rd;
         vecs[0].iov_len = sizeof(*rd);
         vecs[1].iov_base = (unsigned char *)name;
         vecs[1].iov_len = namelen;
 
-        jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
-
-        raw = jffs2_alloc_raw_node_ref();
-
-        if (!raw)
-                return ERR_PTR(-ENOMEM);
-
         fd = jffs2_alloc_full_dirent(namelen+1);
-        if (!fd) {
-                jffs2_free_raw_node_ref(raw);
+        if (!fd)
                 return ERR_PTR(-ENOMEM);
-        }
 
         fd->version = je32_to_cpu(rd->version);
         fd->ino = je32_to_cpu(rd->ino);
@@ -257,11 +228,9 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
         fd->name[namelen]=0;
 
  retry:
-        fd->raw = raw;
+        flash_ofs = write_ofs(c);
 
-        raw->flash_offset = flash_ofs;
-        raw->__totlen = PAD(sizeof(*rd)+namelen);
-        raw->next_phys = NULL;
+        jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
 
         if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
                 BUG_ON(!retried);
@@ -280,15 +249,11 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
                                sizeof(*rd)+namelen, flash_ofs, ret, retlen);
                 /* Mark the space as dirtied */
                 if (retlen) {
-                        raw->next_in_ino = NULL;
-                        raw->flash_offset |= REF_OBSOLETE;
-                        jffs2_add_physical_node_ref(c, raw);
-                        jffs2_mark_node_obsolete(c, raw);
+                        jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
                 } else {
-                        printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", raw->flash_offset);
-                        jffs2_free_raw_node_ref(raw);
+                        printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs);
                 }
-                if (!retried && (raw = jffs2_alloc_raw_node_ref())) {
+                if (!retried) {
                         /* Try to reallocate space and retry */
                         uint32_t dummy;
                         struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
@@ -301,39 +266,33 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
                         jffs2_dbg_acct_paranoia_check(c, jeb);
 
                         if (alloc_mode == ALLOC_GC) {
-                                ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &flash_ofs,
-                                                        &dummy, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
+                                ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy,
+                                                             JFFS2_SUMMARY_DIRENT_SIZE(namelen));
                         } else {
                                 /* Locking pain */
                                 up(&f->sem);
                                 jffs2_complete_reservation(c);
 
-                                ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &flash_ofs,
-                                                        &dummy, alloc_mode, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
+                                ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &dummy,
+                                                          alloc_mode, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
                                 down(&f->sem);
                         }
 
                         if (!ret) {
+                                flash_ofs = write_ofs(c);
                                 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
                                 jffs2_dbg_acct_sanity_check(c,jeb);
                                 jffs2_dbg_acct_paranoia_check(c, jeb);
                                 goto retry;
                         }
                         D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
-                        jffs2_free_raw_node_ref(raw);
                 }
                 /* Release the full_dnode which is now useless, and return */
                 jffs2_free_full_dirent(fd);
                 return ERR_PTR(ret?ret:-EIO);
         }
         /* Mark the space used */
-        raw->flash_offset |= REF_PRISTINE;
-        jffs2_add_physical_node_ref(c, raw);
-
-        spin_lock(&c->erase_completion_lock);
-        raw->next_in_ino = f->inocache->nodes;
-        f->inocache->nodes = raw;
-        spin_unlock(&c->erase_completion_lock);
+        fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | REF_PRISTINE, PAD(sizeof(*rd)+namelen), f->inocache);
 
         if (retried) {
                 jffs2_dbg_acct_sanity_check(c,NULL);
@@ -359,14 +318,14 @@ int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
                 struct jffs2_full_dnode *fn;
                 unsigned char *comprbuf = NULL;
                 uint16_t comprtype = JFFS2_COMPR_NONE;
-                uint32_t phys_ofs, alloclen;
+                uint32_t alloclen;
                 uint32_t datalen, cdatalen;
                 int retried = 0;
 
         retry:
                 D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset));
 
-                ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN, &phys_ofs,
+                ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN,
                                         &alloclen, ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
                 if (ret) {
                         D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret));
@@ -394,7 +353,7 @@ int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
                 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
                 ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
 
-                fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, phys_ofs, ALLOC_NORETRY);
+                fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
 
                 jffs2_free_comprbuf(comprbuf, buf);
 
@@ -448,13 +407,13 @@ int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, str
         struct jffs2_raw_dirent *rd;
         struct jffs2_full_dnode *fn;
         struct jffs2_full_dirent *fd;
-        uint32_t alloclen, phys_ofs;
+        uint32_t alloclen;
         int ret;
 
         /* Try to reserve enough space for both node and dirent.
          * Just the node will do for now, though
          */
-        ret = jffs2_reserve_space(c, sizeof(*ri), &phys_ofs, &alloclen, ALLOC_NORMAL,
+        ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
                                 JFFS2_SUMMARY_INODE_SIZE);
         D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen));
         if (ret) {
@@ -465,7 +424,7 @@ int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, str
         ri->data_crc = cpu_to_je32(0);
         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 
-        fn = jffs2_write_dnode(c, f, ri, NULL, 0, phys_ofs, ALLOC_NORMAL);
+        fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
 
         D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n",
                   jemode_to_cpu(ri->mode)));
@@ -484,7 +443,7 @@ int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, str
 
         up(&f->sem);
         jffs2_complete_reservation(c);
-        ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen,
+        ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
                                 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
 
         if (ret) {
@@ -516,7 +475,7 @@ int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, str
         rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
         rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
 
-        fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_NORMAL);
+        fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
 
         jffs2_free_raw_dirent(rd);
 
@@ -545,7 +504,7 @@ int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
 {
         struct jffs2_raw_dirent *rd;
         struct jffs2_full_dirent *fd;
-        uint32_t alloclen, phys_ofs;
+        uint32_t alloclen;
         int ret;
 
         if (1 /* alternative branch needs testing */ ||
@@ -556,7 +515,7 @@ int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
                 if (!rd)
                         return -ENOMEM;
 
-                ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen,
+                ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
                                         ALLOC_DELETION, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
                 if (ret) {
                         jffs2_free_raw_dirent(rd);
@@ -580,7 +539,7 @@ int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
                 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
                 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
 
-                fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_DELETION);
+                fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_DELETION);
 
                 jffs2_free_raw_dirent(rd);
 
@@ -659,14 +618,14 @@ int jffs2_do_link (struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, uint
 {
         struct jffs2_raw_dirent *rd;
         struct jffs2_full_dirent *fd;
-        uint32_t alloclen, phys_ofs;
+        uint32_t alloclen;
         int ret;
 
         rd = jffs2_alloc_raw_dirent();
         if (!rd)
                 return -ENOMEM;
 
-        ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen,
+        ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
                                 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
         if (ret) {
                 jffs2_free_raw_dirent(rd);
@@ -692,7 +651,7 @@ int jffs2_do_link (struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, uint
         rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
         rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
 
-        fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_NORMAL);
+        fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
 
         jffs2_free_raw_dirent(rd);
 
diff --git a/fs/jffs2/xattr.c b/fs/jffs2/xattr.c
new file mode 100644
index 000000000000..2d82e250be34
--- /dev/null
+++ b/fs/jffs2/xattr.c
@@ -0,0 +1,1238 @@
+/*
+ * JFFS2 -- Journalling Flash File System, Version 2.
+ *
+ * Copyright (C) 2006  NEC Corporation
+ *
+ * Created by KaiGai Kohei <kaigai@ak.jp.nec.com>
+ *
+ * For licensing information, see the file 'LICENCE' in this directory.
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/time.h>
+#include <linux/pagemap.h>
+#include <linux/highmem.h>
+#include <linux/crc32.h>
+#include <linux/jffs2.h>
+#include <linux/xattr.h>
+#include <linux/mtd/mtd.h>
+#include "nodelist.h"
+/* -------- xdatum related functions ----------------
+ * xattr_datum_hashkey(xprefix, xname, xvalue, xsize)
+ *   is used to calcurate xdatum hashkey. The reminder of hashkey into XATTRINDEX_HASHSIZE is
+ *   the index of the xattr name/value pair cache (c->xattrindex).
+ * unload_xattr_datum(c, xd)
+ *   is used to release xattr name/value pair and detach from c->xattrindex.
+ * reclaim_xattr_datum(c)
+ *   is used to reclaim xattr name/value pairs on the xattr name/value pair cache when
+ *   memory usage by cache is over c->xdatum_mem_threshold. Currentry, this threshold 
+ *   is hard coded as 32KiB.
+ * delete_xattr_datum_node(c, xd)
+ *   is used to delete a jffs2 node is dominated by xdatum. When EBS(Erase Block Summary) is
+ *   enabled, it overwrites the obsolete node by myself.
+ * delete_xattr_datum(c, xd)
+ *   is used to delete jffs2_xattr_datum object. It must be called with 0-value of reference
+ *   counter. (It means how many jffs2_xattr_ref object refers this xdatum.)
+ * do_verify_xattr_datum(c, xd)
+ *   is used to load the xdatum informations without name/value pair from the medium.
+ *   It's necessary once, because those informations are not collected during mounting
+ *   process when EBS is enabled.
+ *   0 will be returned, if success. An negative return value means recoverable error, and
+ *   positive return value means unrecoverable error. Thus, caller must remove this xdatum
+ *   and xref when it returned positive value.
+ * do_load_xattr_datum(c, xd)
+ *   is used to load name/value pair from the medium.
+ *   The meanings of return value is same as do_verify_xattr_datum().
+ * load_xattr_datum(c, xd)
+ *   is used to be as a wrapper of do_verify_xattr_datum() and do_load_xattr_datum().
+ *   If xd need to call do_verify_xattr_datum() at first, it's called before calling
+ *   do_load_xattr_datum(). The meanings of return value is same as do_verify_xattr_datum().
+ * save_xattr_datum(c, xd)
+ *   is used to write xdatum to medium. xd->version will be incremented.
+ * create_xattr_datum(c, xprefix, xname, xvalue, xsize)
+ *   is used to create new xdatum and write to medium.
+ * -------------------------------------------------- */
+
+static uint32_t xattr_datum_hashkey(int xprefix, const char *xname, const char *xvalue, int xsize)
+{
+        int name_len = strlen(xname);
+
+        return crc32(xprefix, xname, name_len) ^ crc32(xprefix, xvalue, xsize);
+}
+
+static void unload_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd)
+{
+        /* must be called under down_write(xattr_sem) */
+        D1(dbg_xattr("%s: xid=%u, version=%u\n", __FUNCTION__, xd->xid, xd->version));
+        if (xd->xname) {
+                c->xdatum_mem_usage -= (xd->name_len + 1 + xd->value_len);
+                kfree(xd->xname);
+        }
+
+        list_del_init(&xd->xindex);
+        xd->hashkey = 0;
+        xd->xname = NULL;
+        xd->xvalue = NULL;
+}
+
+static void reclaim_xattr_datum(struct jffs2_sb_info *c)
+{
+        /* must be called under down_write(xattr_sem) */
+        struct jffs2_xattr_datum *xd, *_xd;
+        uint32_t target, before;
+        static int index = 0;
+        int count;
+
+        if (c->xdatum_mem_threshold > c->xdatum_mem_usage)
+                return;
+
+        before = c->xdatum_mem_usage;
+        target = c->xdatum_mem_usage * 4 / 5; /* 20% reduction */
+        for (count = 0; count < XATTRINDEX_HASHSIZE; count++) {
+                list_for_each_entry_safe(xd, _xd, &c->xattrindex[index], xindex) {
+                        if (xd->flags & JFFS2_XFLAGS_HOT) {
+                                xd->flags &= ~JFFS2_XFLAGS_HOT;
+                        } else if (!(xd->flags & JFFS2_XFLAGS_BIND)) {
+                                unload_xattr_datum(c, xd);
+                        }
+                        if (c->xdatum_mem_usage <= target)
+                                goto out;
+                }
+                index = (index+1) % XATTRINDEX_HASHSIZE;
+        }
+ out:
+        JFFS2_NOTICE("xdatum_mem_usage from %u byte to %u byte (%u byte reclaimed)\n",
+                     before, c->xdatum_mem_usage, before - c->xdatum_mem_usage);
+}
+
+static void delete_xattr_datum_node(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd)
+{
+        /* must be called under down_write(xattr_sem) */
+        struct jffs2_raw_xattr rx;
+        size_t length;
+        int rc;
+
+        if (!xd->node) {
+                JFFS2_WARNING("xdatum (xid=%u) is removed twice.\n", xd->xid);
+                return;
+        }
+        if (jffs2_sum_active()) {
+                memset(&rx, 0xff, sizeof(struct jffs2_raw_xattr));
+                rc = jffs2_flash_read(c, ref_offset(xd->node),
+                                      sizeof(struct jffs2_unknown_node),
+                                      &length, (char *)&rx);
+                if (rc || length != sizeof(struct jffs2_unknown_node)) {
+                        JFFS2_ERROR("jffs2_flash_read()=%d, req=%zu, read=%zu at %#08x\n",
+                                    rc, sizeof(struct jffs2_unknown_node),
+                                    length, ref_offset(xd->node));
+                }
+                rc = jffs2_flash_write(c, ref_offset(xd->node), sizeof(rx),
+                                       &length, (char *)&rx);
+                if (rc || length != sizeof(struct jffs2_raw_xattr)) {
+                        JFFS2_ERROR("jffs2_flash_write()=%d, req=%zu, wrote=%zu ar %#08x\n",
+                                    rc, sizeof(rx), length, ref_offset(xd->node));
+                }
+        }
+        spin_lock(&c->erase_completion_lock);
+        xd->node->next_in_ino = NULL;
+        spin_unlock(&c->erase_completion_lock);
+        jffs2_mark_node_obsolete(c, xd->node);
+        xd->node = NULL;
+}
+
+static void delete_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd)
+{
+        /* must be called under down_write(xattr_sem) */
+        BUG_ON(xd->refcnt);
+
+        unload_xattr_datum(c, xd);
+        if (xd->node) {
+                delete_xattr_datum_node(c, xd);
+                xd->node = NULL;
+        }
+        jffs2_free_xattr_datum(xd);
+}
+
+static int do_verify_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd)
+{
+        /* must be called under down_write(xattr_sem) */
+        struct jffs2_eraseblock *jeb;
+        struct jffs2_raw_xattr rx;
+        size_t readlen;
+        uint32_t crc, totlen;
+        int rc;
+
+        BUG_ON(!xd->node);
+        BUG_ON(ref_flags(xd->node) != REF_UNCHECKED);
+
+        rc = jffs2_flash_read(c, ref_offset(xd->node), sizeof(rx), &readlen, (char *)&rx);
+        if (rc || readlen != sizeof(rx)) {
+                JFFS2_WARNING("jffs2_flash_read()=%d, req=%zu, read=%zu at %#08x\n",
+                              rc, sizeof(rx), readlen, ref_offset(xd->node));
+                return rc ? rc : -EIO;
+        }
+        crc = crc32(0, &rx, sizeof(rx) - 4);
+        if (crc != je32_to_cpu(rx.node_crc)) {
+                if (je32_to_cpu(rx.node_crc) != 0xffffffff)
+                        JFFS2_ERROR("node CRC failed at %#08x, read=%#08x, calc=%#08x\n",
+                                    ref_offset(xd->node), je32_to_cpu(rx.hdr_crc), crc);
+                return EIO;
+        }
+        totlen = PAD(sizeof(rx) + rx.name_len + 1 + je16_to_cpu(rx.value_len));
+        if (je16_to_cpu(rx.magic) != JFFS2_MAGIC_BITMASK
+            || je16_to_cpu(rx.nodetype) != JFFS2_NODETYPE_XATTR
+            || je32_to_cpu(rx.totlen) != totlen
+            || je32_to_cpu(rx.xid) != xd->xid
+            || je32_to_cpu(rx.version) != xd->version) {
+                JFFS2_ERROR("inconsistent xdatum at %#08x, magic=%#04x/%#04x, "
+                            "nodetype=%#04x/%#04x, totlen=%u/%u, xid=%u/%u, version=%u/%u\n",
+                            ref_offset(xd->node), je16_to_cpu(rx.magic), JFFS2_MAGIC_BITMASK,
+                            je16_to_cpu(rx.nodetype), JFFS2_NODETYPE_XATTR,
+                            je32_to_cpu(rx.totlen), totlen,
+                            je32_to_cpu(rx.xid), xd->xid,
+                            je32_to_cpu(rx.version), xd->version);
+                return EIO;
+        }
+        xd->xprefix = rx.xprefix;
+        xd->name_len = rx.name_len;
+        xd->value_len = je16_to_cpu(rx.value_len);
+        xd->data_crc = je32_to_cpu(rx.data_crc);
+
+        /* This JFFS2_NODETYPE_XATTR node is checked */
+        jeb = &c->blocks[ref_offset(xd->node) / c->sector_size];
+        totlen = PAD(je32_to_cpu(rx.totlen));
+
+        spin_lock(&c->erase_completion_lock);
+        c->unchecked_size -= totlen; c->used_size += totlen;
+        jeb->unchecked_size -= totlen; jeb->used_size += totlen;
+        xd->node->flash_offset = ref_offset(xd->node) | REF_PRISTINE;
+        spin_unlock(&c->erase_completion_lock);
+
+        /* unchecked xdatum is chained with c->xattr_unchecked */
+        list_del_init(&xd->xindex);
+
+        dbg_xattr("success on verfying xdatum (xid=%u, version=%u)\n",
+                  xd->xid, xd->version);
+
+        return 0;
+}
+
+static int do_load_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd)
+{
+        /* must be called under down_write(xattr_sem) */
+        char *data;
+        size_t readlen;
+        uint32_t crc, length;
+        int i, ret, retry = 0;
+
+        BUG_ON(!xd->node);
+        BUG_ON(ref_flags(xd->node) != REF_PRISTINE);
+        BUG_ON(!list_empty(&xd->xindex));
+ retry:
+        length = xd->name_len + 1 + xd->value_len;
+        data = kmalloc(length, GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        ret = jffs2_flash_read(c, ref_offset(xd->node)+sizeof(struct jffs2_raw_xattr),
+                               length, &readlen, data);
+
+        if (ret || length!=readlen) {
+                JFFS2_WARNING("jffs2_flash_read() returned %d, request=%d, readlen=%zu, at %#08x\n",
+                              ret, length, readlen, ref_offset(xd->node));
+                kfree(data);
+                return ret ? ret : -EIO;
+        }
+
+        data[xd->name_len] = '\0';
+        crc = crc32(0, data, length);
+        if (crc != xd->data_crc) {
+                JFFS2_WARNING("node CRC failed (JFFS2_NODETYPE_XREF)"
+                              " at %#08x, read: 0x%08x calculated: 0x%08x\n",
+                              ref_offset(xd->node), xd->data_crc, crc);
+                kfree(data);
+                return EIO;
+        }
+
+        xd->flags |= JFFS2_XFLAGS_HOT;
+        xd->xname = data;
+        xd->xvalue = data + xd->name_len+1;
+
+        c->xdatum_mem_usage += length;
+
+        xd->hashkey = xattr_datum_hashkey(xd->xprefix, xd->xname, xd->xvalue, xd->value_len);
+        i = xd->hashkey % XATTRINDEX_HASHSIZE;
+        list_add(&xd->xindex, &c->xattrindex[i]);
+        if (!retry) {
+                retry = 1;
+                reclaim_xattr_datum(c);
+                if (!xd->xname)
+                        goto retry;
+        }
+
+        dbg_xattr("success on loading xdatum (xid=%u, xprefix=%u, xname='%s')\n",
+                  xd->xid, xd->xprefix, xd->xname);
+
+        return 0;
+}
+
+static int load_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd)
+{
+        /* must be called under down_write(xattr_sem);
+         * rc < 0 : recoverable error, try again
+         * rc = 0 : success
+         * rc > 0 : Unrecoverable error, this node should be deleted.
+         */
+        int rc = 0;
+        BUG_ON(xd->xname);
+        if (!xd->node)
+                return EIO;
+        if (unlikely(ref_flags(xd->node) != REF_PRISTINE)) {
+                rc = do_verify_xattr_datum(c, xd);
+                if (rc > 0) {
+                        list_del_init(&xd->xindex);
+                        delete_xattr_datum_node(c, xd);
+                }
+        }
+        if (!rc)
+                rc = do_load_xattr_datum(c, xd);
+        return rc;
+}
+
+static int save_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd)
+{
+        /* must be called under down_write(xattr_sem) */
+        struct jffs2_raw_node_ref *raw;
+        struct jffs2_raw_xattr rx;
+        struct kvec vecs[2];
+        size_t length;
+        int rc, totlen;
+        uint32_t phys_ofs = write_ofs(c);
+
+        BUG_ON(!xd->xname);
+
+        vecs[0].iov_base = &rx;
+        vecs[0].iov_len = PAD(sizeof(rx));
+        vecs[1].iov_base = xd->xname;
+        vecs[1].iov_len = xd->name_len + 1 + xd->value_len;
+        totlen = vecs[0].iov_len + vecs[1].iov_len;
+
+        /* Setup raw-xattr */
+        rx.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
+        rx.nodetype = cpu_to_je16(JFFS2_NODETYPE_XATTR);
+        rx.totlen = cpu_to_je32(PAD(totlen));
+        rx.hdr_crc = cpu_to_je32(crc32(0, &rx, sizeof(struct jffs2_unknown_node) - 4));
+
+        rx.xid = cpu_to_je32(xd->xid);
+        rx.version = cpu_to_je32(++xd->version);
+        rx.xprefix = xd->xprefix;
+        rx.name_len = xd->name_len;
+        rx.value_len = cpu_to_je16(xd->value_len);
+        rx.data_crc = cpu_to_je32(crc32(0, vecs[1].iov_base, vecs[1].iov_len));
+        rx.node_crc = cpu_to_je32(crc32(0, &rx, sizeof(struct jffs2_raw_xattr) - 4));
+
+        rc = jffs2_flash_writev(c, vecs, 2, phys_ofs, &length, 0);
+        if (rc || totlen != length) {
+                JFFS2_WARNING("jffs2_flash_writev()=%d, req=%u, wrote=%zu, at %#08x\n",
+                              rc, totlen, length, phys_ofs);
+                rc = rc ? rc : -EIO;
+                if (length)
+                        jffs2_add_physical_node_ref(c, phys_ofs | REF_OBSOLETE, PAD(totlen), NULL);
+
+                return rc;
+        }
+
+        /* success */
+        raw = jffs2_add_physical_node_ref(c, phys_ofs | REF_PRISTINE, PAD(totlen), NULL);
+        /* FIXME */ raw->next_in_ino = (void *)xd;
+
+        if (xd->node)
+                delete_xattr_datum_node(c, xd);
+        xd->node = raw;
+
+        dbg_xattr("success on saving xdatum (xid=%u, version=%u, xprefix=%u, xname='%s')\n",
+                  xd->xid, xd->version, xd->xprefix, xd->xname);
+
+        return 0;
+}
+
+static struct jffs2_xattr_datum *create_xattr_datum(struct jffs2_sb_info *c,
+                                                    int xprefix, const char *xname,
+                                                    const char *xvalue, int xsize)
+{
+        /* must be called under down_write(xattr_sem) */
+        struct jffs2_xattr_datum *xd;
+        uint32_t hashkey, name_len;
+        char *data;
+        int i, rc;
+
+        /* Search xattr_datum has same xname/xvalue by index */
+        hashkey = xattr_datum_hashkey(xprefix, xname, xvalue, xsize);
+        i = hashkey % XATTRINDEX_HASHSIZE;
+        list_for_each_entry(xd, &c->xattrindex[i], xindex) {
+                if (xd->hashkey==hashkey
+                    && xd->xprefix==xprefix
+                    && xd->value_len==xsize
+                    && !strcmp(xd->xname, xname)
+                    && !memcmp(xd->xvalue, xvalue, xsize)) {
+                        xd->refcnt++;
+                        return xd;
+                }
+        }
+
+        /* Not found, Create NEW XATTR-Cache */
+        name_len = strlen(xname);
+
+        xd = jffs2_alloc_xattr_datum();
+        if (!xd)
+                return ERR_PTR(-ENOMEM);
+
+        data = kmalloc(name_len + 1 + xsize, GFP_KERNEL);
+        if (!data) {
+                jffs2_free_xattr_datum(xd);
+                return ERR_PTR(-ENOMEM);
+        }
+        strcpy(data, xname);
+        memcpy(data + name_len + 1, xvalue, xsize);
+
+        xd->refcnt = 1;
+        xd->xid = ++c->highest_xid;
+        xd->flags |= JFFS2_XFLAGS_HOT;
+        xd->xprefix = xprefix;
+
+        xd->hashkey = hashkey;
+        xd->xname = data;
+        xd->xvalue = data + name_len + 1;
+        xd->name_len = name_len;
+        xd->value_len = xsize;
+        xd->data_crc = crc32(0, data, xd->name_len + 1 + xd->value_len);
+
+        rc = save_xattr_datum(c, xd);
+        if (rc) {
+                kfree(xd->xname);
+                jffs2_free_xattr_datum(xd);
+                return ERR_PTR(rc);
+        }
+
+        /* Insert Hash Index */
+        i = hashkey % XATTRINDEX_HASHSIZE;
+        list_add(&xd->xindex, &c->xattrindex[i]);
+
+        c->xdatum_mem_usage += (xd->name_len + 1 + xd->value_len);
+        reclaim_xattr_datum(c);
+
+        return xd;
+}
+
+/* -------- xref related functions ------------------
+ * verify_xattr_ref(c, ref)
+ *   is used to load xref information from medium. Because summary data does not
+ *   contain xid/ino, it's necessary to verify once while mounting process.
+ * delete_xattr_ref_node(c, ref)
+ *   is used to delete a jffs2 node is dominated by xref. When EBS is enabled,
+ *   it overwrites the obsolete node by myself. 
+ * delete_xattr_ref(c, ref)
+ *   is used to delete jffs2_xattr_ref object. If the reference counter of xdatum
+ *   is refered by this xref become 0, delete_xattr_datum() is called later.
+ * save_xattr_ref(c, ref)
+ *   is used to write xref to medium.
+ * create_xattr_ref(c, ic, xd)
+ *   is used to create a new xref and write to medium.
+ * jffs2_xattr_delete_inode(c, ic)
+ *   is called to remove xrefs related to obsolete inode when inode is unlinked.
+ * jffs2_xattr_free_inode(c, ic)
+ *   is called to release xattr related objects when unmounting. 
+ * check_xattr_ref_inode(c, ic)
+ *   is used to confirm inode does not have duplicate xattr name/value pair.
+ * -------------------------------------------------- */
+static int verify_xattr_ref(struct jffs2_sb_info *c, struct jffs2_xattr_ref *ref)
+{
+        struct jffs2_eraseblock *jeb;
+        struct jffs2_raw_xref rr;
+        size_t readlen;
+        uint32_t crc, totlen;
+        int rc;
+
+        BUG_ON(ref_flags(ref->node) != REF_UNCHECKED);
+
+        rc = jffs2_flash_read(c, ref_offset(ref->node), sizeof(rr), &readlen, (char *)&rr);
+        if (rc || sizeof(rr) != readlen) {
+                JFFS2_WARNING("jffs2_flash_read()=%d, req=%zu, read=%zu, at %#08x\n",
+                              rc, sizeof(rr), readlen, ref_offset(ref->node));
+                return rc ? rc : -EIO;
+        }
+        /* obsolete node */
+        crc = crc32(0, &rr, sizeof(rr) - 4);
+        if (crc != je32_to_cpu(rr.node_crc)) {
+                if (je32_to_cpu(rr.node_crc) != 0xffffffff)
+                        JFFS2_ERROR("node CRC failed at %#08x, read=%#08x, calc=%#08x\n",
+                                    ref_offset(ref->node), je32_to_cpu(rr.node_crc), crc);
+                return EIO;
+        }
+        if (je16_to_cpu(rr.magic) != JFFS2_MAGIC_BITMASK
+            || je16_to_cpu(rr.nodetype) != JFFS2_NODETYPE_XREF
+            || je32_to_cpu(rr.totlen) != PAD(sizeof(rr))) {
+                JFFS2_ERROR("inconsistent xref at %#08x, magic=%#04x/%#04x, "
+                            "nodetype=%#04x/%#04x, totlen=%u/%zu\n",
+                            ref_offset(ref->node), je16_to_cpu(rr.magic), JFFS2_MAGIC_BITMASK,
+                            je16_to_cpu(rr.nodetype), JFFS2_NODETYPE_XREF,
+                            je32_to_cpu(rr.totlen), PAD(sizeof(rr)));
+                return EIO;
+        }
+        ref->ino = je32_to_cpu(rr.ino);
+        ref->xid = je32_to_cpu(rr.xid);
+
+        /* fixup superblock/eraseblock info */
+        jeb = &c->blocks[ref_offset(ref->node) / c->sector_size];
+        totlen = PAD(sizeof(rr));
+
+        spin_lock(&c->erase_completion_lock);
+        c->unchecked_size -= totlen; c->used_size += totlen;
+        jeb->unchecked_size -= totlen; jeb->used_size += totlen;
+        ref->node->flash_offset = ref_offset(ref->node) | REF_PRISTINE;
+        spin_unlock(&c->erase_completion_lock);
+
+        dbg_xattr("success on verifying xref (ino=%u, xid=%u) at %#08x\n",
+                  ref->ino, ref->xid, ref_offset(ref->node));
+        return 0;
+}
+
+static void delete_xattr_ref_node(struct jffs2_sb_info *c, struct jffs2_xattr_ref *ref)
+{
+        struct jffs2_raw_xref rr;
+        size_t length;
+        int rc;
+
+        if (jffs2_sum_active()) {
+                memset(&rr, 0xff, sizeof(rr));
+                rc = jffs2_flash_read(c, ref_offset(ref->node),
+                                      sizeof(struct jffs2_unknown_node),
+                                      &length, (char *)&rr);
+                if (rc || length != sizeof(struct jffs2_unknown_node)) {
+                        JFFS2_ERROR("jffs2_flash_read()=%d, req=%zu, read=%zu at %#08x\n",
+                                    rc, sizeof(struct jffs2_unknown_node),
+                                    length, ref_offset(ref->node));
+                }
+                rc = jffs2_flash_write(c, ref_offset(ref->node), sizeof(rr),
+                                       &length, (char *)&rr);
+                if (rc || length != sizeof(struct jffs2_raw_xref)) {
+                        JFFS2_ERROR("jffs2_flash_write()=%d, req=%zu, wrote=%zu at %#08x\n",
+                                    rc, sizeof(rr), length, ref_offset(ref->node));
+                }
+        }
+        spin_lock(&c->erase_completion_lock);
+        ref->node->next_in_ino = NULL;
+        spin_unlock(&c->erase_completion_lock);
+        jffs2_mark_node_obsolete(c, ref->node);
+        ref->node = NULL;
+}
+
+static void delete_xattr_ref(struct jffs2_sb_info *c, struct jffs2_xattr_ref *ref)
+{
+        /* must be called under down_write(xattr_sem) */
+        struct jffs2_xattr_datum *xd;
+
+        BUG_ON(!ref->node);
+        delete_xattr_ref_node(c, ref);
+
+        xd = ref->xd;
+        xd->refcnt--;
+        if (!xd->refcnt)
+                delete_xattr_datum(c, xd);
+        jffs2_free_xattr_ref(ref);
+}
+
+static int save_xattr_ref(struct jffs2_sb_info *c, struct jffs2_xattr_ref *ref)
+{
+        /* must be called under down_write(xattr_sem) */
+        struct jffs2_raw_node_ref *raw;
+        struct jffs2_raw_xref rr;
+        size_t length;
+        uint32_t phys_ofs = write_ofs(c);
+        int ret;
+
+        rr.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
+        rr.nodetype = cpu_to_je16(JFFS2_NODETYPE_XREF);
+        rr.totlen = cpu_to_je32(PAD(sizeof(rr)));
+        rr.hdr_crc = cpu_to_je32(crc32(0, &rr, sizeof(struct jffs2_unknown_node) - 4));
+
+        rr.ino = cpu_to_je32(ref->ic->ino);
+        rr.xid = cpu_to_je32(ref->xd->xid);
+        rr.node_crc = cpu_to_je32(crc32(0, &rr, sizeof(rr) - 4));
+
+        ret = jffs2_flash_write(c, phys_ofs, sizeof(rr), &length, (char *)&rr);
+        if (ret || sizeof(rr) != length) {
+                JFFS2_WARNING("jffs2_flash_write() returned %d, request=%zu, retlen=%zu, at %#08x\n",
+                              ret, sizeof(rr), length, phys_ofs);
+                ret = ret ? ret : -EIO;
+                if (length)
+                        jffs2_add_physical_node_ref(c, phys_ofs | REF_OBSOLETE, PAD(sizeof(rr)), NULL);
+
+                return ret;
+        }
+
+        raw = jffs2_add_physical_node_ref(c, phys_ofs | REF_PRISTINE, PAD(sizeof(rr)), NULL);
+        /* FIXME */ raw->next_in_ino = (void *)ref;
+        if (ref->node)
+                delete_xattr_ref_node(c, ref);
+        ref->node = raw;
+
+        dbg_xattr("success on saving xref (ino=%u, xid=%u)\n", ref->ic->ino, ref->xd->xid);
+
+        return 0;
+}
+
+static struct jffs2_xattr_ref *create_xattr_ref(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic,
+                                                struct jffs2_xattr_datum *xd)
+{
+        /* must be called under down_write(xattr_sem) */
+        struct jffs2_xattr_ref *ref;
+        int ret;
+
+        ref = jffs2_alloc_xattr_ref();
+        if (!ref)
+                return ERR_PTR(-ENOMEM);
+        ref->ic = ic;
+        ref->xd = xd;
+
+        ret = save_xattr_ref(c, ref);
+        if (ret) {
+                jffs2_free_xattr_ref(ref);
+                return ERR_PTR(ret);
+        }
+
+        /* Chain to inode */
+        ref->next = ic->xref;
+        ic->xref = ref;
+
+        return ref; /* success */
+}
+
+void jffs2_xattr_delete_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic)
+{
+        /* It's called from jffs2_clear_inode() on inode removing.
+           When an inode with XATTR is removed, those XATTRs must be removed. */
+        struct jffs2_xattr_ref *ref, *_ref;
+
+        if (!ic || ic->nlink > 0)
+                return;
+
+        down_write(&c->xattr_sem);
+        for (ref = ic->xref; ref; ref = _ref) {
+                _ref = ref->next;
+                delete_xattr_ref(c, ref);
+        }
+        ic->xref = NULL;
+        up_write(&c->xattr_sem);
+}
+
+void jffs2_xattr_free_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic)
+{
+        /* It's called from jffs2_free_ino_caches() until unmounting FS. */
+        struct jffs2_xattr_datum *xd;
+        struct jffs2_xattr_ref *ref, *_ref;
+
+        down_write(&c->xattr_sem);
+        for (ref = ic->xref; ref; ref = _ref) {
+                _ref = ref->next;
+                xd = ref->xd;
+                xd->refcnt--;
+                if (!xd->refcnt) {
+                        unload_xattr_datum(c, xd);
+                        jffs2_free_xattr_datum(xd);
+                }
+                jffs2_free_xattr_ref(ref);
+        }
+        ic->xref = NULL;
+        up_write(&c->xattr_sem);
+}
+
+static int check_xattr_ref_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic)
+{
+        /* success of check_xattr_ref_inode() means taht inode (ic) dose not have
+         * duplicate name/value pairs. If duplicate name/value pair would be found,
+         * one will be removed.
+         */
+        struct jffs2_xattr_ref *ref, *cmp, **pref;
+        int rc = 0;
+
+        if (likely(ic->flags & INO_FLAGS_XATTR_CHECKED))
+                return 0;
+        down_write(&c->xattr_sem);
+ retry:
+        rc = 0;
+        for (ref=ic->xref, pref=&ic->xref; ref; pref=&ref->next, ref=ref->next) {
+                if (!ref->xd->xname) {
+                        rc = load_xattr_datum(c, ref->xd);
+                        if (unlikely(rc > 0)) {
+                                *pref = ref->next;
+                                delete_xattr_ref(c, ref);
+                                goto retry;
+                        } else if (unlikely(rc < 0))
+                                goto out;
+                }
+                for (cmp=ref->next, pref=&ref->next; cmp; pref=&cmp->next, cmp=cmp->next) {
+                        if (!cmp->xd->xname) {
+                                ref->xd->flags |= JFFS2_XFLAGS_BIND;
+                                rc = load_xattr_datum(c, cmp->xd);
+                                ref->xd->flags &= ~JFFS2_XFLAGS_BIND;
+                                if (unlikely(rc > 0)) {
+                                        *pref = cmp->next;
+                                        delete_xattr_ref(c, cmp);
+                                        goto retry;
+                                } else if (unlikely(rc < 0))
+                                        goto out;
+                        }
+                        if (ref->xd->xprefix == cmp->xd->xprefix
+                            && !strcmp(ref->xd->xname, cmp->xd->xname)) {
+                                *pref = cmp->next;
+                                delete_xattr_ref(c, cmp);
+                                goto retry;
+                        }
+                }
+        }
+        ic->flags |= INO_FLAGS_XATTR_CHECKED;
+ out:
+        up_write(&c->xattr_sem);
+
+        return rc;
+}
+
+/* -------- xattr subsystem functions ---------------
+ * jffs2_init_xattr_subsystem(c)
+ *   is used to initialize semaphore and list_head, and some variables.
+ * jffs2_find_xattr_datum(c, xid)
+ *   is used to lookup xdatum while scanning process.
+ * jffs2_clear_xattr_subsystem(c)
+ *   is used to release any xattr related objects.
+ * jffs2_build_xattr_subsystem(c)
+ *   is used to associate xdatum and xref while super block building process.
+ * jffs2_setup_xattr_datum(c, xid, version)
+ *   is used to insert xdatum while scanning process.
+ * -------------------------------------------------- */
+void jffs2_init_xattr_subsystem(struct jffs2_sb_info *c)
+{
+        int i;
+
+        for (i=0; i < XATTRINDEX_HASHSIZE; i++)
+                INIT_LIST_HEAD(&c->xattrindex[i]);
+        INIT_LIST_HEAD(&c->xattr_unchecked);
+        c->xref_temp = NULL;
+
+        init_rwsem(&c->xattr_sem);
+        c->xdatum_mem_usage = 0;
+        c->xdatum_mem_threshold = 32 * 1024;    /* Default 32KB */
+}
+
+static struct jffs2_xattr_datum *jffs2_find_xattr_datum(struct jffs2_sb_info *c, uint32_t xid)
+{
+        struct jffs2_xattr_datum *xd;
+        int i = xid % XATTRINDEX_HASHSIZE;
+
+        /* It's only used in scanning/building process. */
+        BUG_ON(!(c->flags & (JFFS2_SB_FLAG_SCANNING|JFFS2_SB_FLAG_BUILDING)));
+
+        list_for_each_entry(xd, &c->xattrindex[i], xindex) {
+                if (xd->xid==xid)
+                        return xd;
+        }
+        return NULL;
+}
+
+void jffs2_clear_xattr_subsystem(struct jffs2_sb_info *c)
+{
+        struct jffs2_xattr_datum *xd, *_xd;
+        struct jffs2_xattr_ref *ref, *_ref;
+        int i;
+
+        for (ref=c->xref_temp; ref; ref = _ref) {
+                _ref = ref->next;
+                jffs2_free_xattr_ref(ref);
+        }
+        c->xref_temp = NULL;
+
+        for (i=0; i < XATTRINDEX_HASHSIZE; i++) {
+                list_for_each_entry_safe(xd, _xd, &c->xattrindex[i], xindex) {
+                        list_del(&xd->xindex);
+                        if (xd->xname)
+                                kfree(xd->xname);
+                        jffs2_free_xattr_datum(xd);
+                }
+        }
+}
+
+void jffs2_build_xattr_subsystem(struct jffs2_sb_info *c)
+{
+        struct jffs2_xattr_ref *ref, *_ref;
+        struct jffs2_xattr_datum *xd, *_xd;
+        struct jffs2_inode_cache *ic;
+        int i, xdatum_count =0, xdatum_unchecked_count = 0, xref_count = 0;
+
+        BUG_ON(!(c->flags & JFFS2_SB_FLAG_BUILDING));
+
+        /* Phase.1 */
+        for (ref=c->xref_temp; ref; ref=_ref) {
+                _ref = ref->next;
+                /* checking REF_UNCHECKED nodes */
+                if (ref_flags(ref->node) != REF_PRISTINE) {
+                        if (verify_xattr_ref(c, ref)) {
+                                delete_xattr_ref_node(c, ref);
+                                jffs2_free_xattr_ref(ref);
+                                continue;
+                        }
+                }
+                /* At this point, ref->xid and ref->ino contain XID and inode number.
+                   ref->xd and ref->ic are not valid yet. */
+                xd = jffs2_find_xattr_datum(c, ref->xid);
+                ic = jffs2_get_ino_cache(c, ref->ino);
+                if (!xd || !ic) {
+                        if (ref_flags(ref->node) != REF_UNCHECKED)
+                                JFFS2_WARNING("xref(ino=%u, xid=%u) is orphan. \n",
+                                              ref->ino, ref->xid);
+                        delete_xattr_ref_node(c, ref);
+                        jffs2_free_xattr_ref(ref);
+                        continue;
+                }
+                ref->xd = xd;
+                ref->ic = ic;
+                xd->refcnt++;
+                ref->next = ic->xref;
+                ic->xref = ref;
+                xref_count++;
+        }
+        c->xref_temp = NULL;
+        /* After this, ref->xid/ino are NEVER used. */
+
+        /* Phase.2 */
+        for (i=0; i < XATTRINDEX_HASHSIZE; i++) {
+                list_for_each_entry_safe(xd, _xd, &c->xattrindex[i], xindex) {
+                        list_del_init(&xd->xindex);
+                        if (!xd->refcnt) {
+                                if (ref_flags(xd->node) != REF_UNCHECKED)
+                                        JFFS2_WARNING("orphan xdatum(xid=%u, version=%u) at %#08x\n",
+                                                      xd->xid, xd->version, ref_offset(xd->node));
+                                delete_xattr_datum(c, xd);
+                                continue;
+                        }
+                        if (ref_flags(xd->node) != REF_PRISTINE) {
+                                dbg_xattr("unchecked xdatum(xid=%u) at %#08x\n",
+                                          xd->xid, ref_offset(xd->node));
+                                list_add(&xd->xindex, &c->xattr_unchecked);
+                                xdatum_unchecked_count++;
+                        }
+                        xdatum_count++;
+                }
+        }
+        /* build complete */
+        JFFS2_NOTICE("complete building xattr subsystem, %u of xdatum (%u unchecked) and "
+                     "%u of xref found.\n", xdatum_count, xdatum_unchecked_count, xref_count);
+}
+
+struct jffs2_xattr_datum *jffs2_setup_xattr_datum(struct jffs2_sb_info *c,
+                                                  uint32_t xid, uint32_t version)
+{
+        struct jffs2_xattr_datum *xd, *_xd;
+
+        _xd = jffs2_find_xattr_datum(c, xid);
+        if (_xd) {
+                dbg_xattr("duplicate xdatum (xid=%u, version=%u/%u) at %#08x\n",
+                          xid, version, _xd->version, ref_offset(_xd->node));
+                if (version < _xd->version)
+                        return ERR_PTR(-EEXIST);
+        }
+        xd = jffs2_alloc_xattr_datum();
+        if (!xd)
+                return ERR_PTR(-ENOMEM);
+        xd->xid = xid;
+        xd->version = version;
+        if (xd->xid > c->highest_xid)
+                c->highest_xid = xd->xid;
+        list_add_tail(&xd->xindex, &c->xattrindex[xid % XATTRINDEX_HASHSIZE]);
+
+        if (_xd) {
+                list_del_init(&_xd->xindex);
+                delete_xattr_datum_node(c, _xd);
+                jffs2_free_xattr_datum(_xd);
+        }
+        return xd;
+}
+
+/* -------- xattr subsystem functions ---------------
+ * xprefix_to_handler(xprefix)
+ *   is used to translate xprefix into xattr_handler.
+ * jffs2_listxattr(dentry, buffer, size)
+ *   is an implementation of listxattr handler on jffs2.
+ * do_jffs2_getxattr(inode, xprefix, xname, buffer, size)
+ *   is an implementation of getxattr handler on jffs2.
+ * do_jffs2_setxattr(inode, xprefix, xname, buffer, size, flags)
+ *   is an implementation of setxattr handler on jffs2.
+ * -------------------------------------------------- */
+struct xattr_handler *jffs2_xattr_handlers[] = {
+        &jffs2_user_xattr_handler,
+#ifdef CONFIG_JFFS2_FS_SECURITY
+        &jffs2_security_xattr_handler,
+#endif
+#ifdef CONFIG_JFFS2_FS_POSIX_ACL
+        &jffs2_acl_access_xattr_handler,
+        &jffs2_acl_default_xattr_handler,
+#endif
+        &jffs2_trusted_xattr_handler,
+        NULL
+};
+
+static struct xattr_handler *xprefix_to_handler(int xprefix) {
+        struct xattr_handler *ret;
+
+        switch (xprefix) {
+        case JFFS2_XPREFIX_USER:
+                ret = &jffs2_user_xattr_handler;
+                break;
+#ifdef CONFIG_JFFS2_FS_SECURITY
+        case JFFS2_XPREFIX_SECURITY:
+                ret = &jffs2_security_xattr_handler;
+                break;
+#endif
+#ifdef CONFIG_JFFS2_FS_POSIX_ACL
+        case JFFS2_XPREFIX_ACL_ACCESS:
+                ret = &jffs2_acl_access_xattr_handler;
+                break;
+        case JFFS2_XPREFIX_ACL_DEFAULT:
+                ret = &jffs2_acl_default_xattr_handler;
+                break;
+#endif
+        case JFFS2_XPREFIX_TRUSTED:
+                ret = &jffs2_trusted_xattr_handler;
+                break;
+        default:
+                ret = NULL;
+                break;
+        }
+        return ret;
+}
+
+ssize_t jffs2_listxattr(struct dentry *dentry, char *buffer, size_t size)
+{
+        struct inode *inode = dentry->d_inode;
+        struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
+        struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
+        struct jffs2_inode_cache *ic = f->inocache;
+        struct jffs2_xattr_ref *ref, **pref;
+        struct jffs2_xattr_datum *xd;
+        struct xattr_handler *xhandle;
+        ssize_t len, rc;
+        int retry = 0;
+
+        rc = check_xattr_ref_inode(c, ic);
+        if (unlikely(rc))
+                return rc;
+
+        down_read(&c->xattr_sem);
+ retry:
+        len = 0;
+        for (ref=ic->xref, pref=&ic->xref; ref; pref=&ref->next, ref=ref->next) {
+                BUG_ON(ref->ic != ic);
+                xd = ref->xd;
+                if (!xd->xname) {
+                        /* xdatum is unchached */
+                        if (!retry) {
+                                retry = 1;
+                                up_read(&c->xattr_sem);
+                                down_write(&c->xattr_sem);
+                                goto retry;
+                        } else {
+                                rc = load_xattr_datum(c, xd);
+                                if (unlikely(rc > 0)) {
+                                        *pref = ref->next;
+                                        delete_xattr_ref(c, ref);
+                                        goto retry;
+                                } else if (unlikely(rc < 0))
+                                        goto out;
+                        }
+                }
+                xhandle = xprefix_to_handler(xd->xprefix);
+                if (!xhandle)
+                        continue;
+                if (buffer) {
+                        rc = xhandle->list(inode, buffer+len, size-len, xd->xname, xd->name_len);
+                } else {
+                        rc = xhandle->list(inode, NULL, 0, xd->xname, xd->name_len);
+                }
+                if (rc < 0)
+                        goto out;
+                len += rc;
+        }
+        rc = len;
+ out:
+        if (!retry) {
+                up_read(&c->xattr_sem);
+        } else {
+                up_write(&c->xattr_sem);
+        }
+        return rc;
+}
+
+int do_jffs2_getxattr(struct inode *inode, int xprefix, const char *xname,
+                      char *buffer, size_t size)
+{
+        struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
+        struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
+        struct jffs2_inode_cache *ic = f->inocache;
+        struct jffs2_xattr_datum *xd;
+        struct jffs2_xattr_ref *ref, **pref;
+        int rc, retry = 0;
+
+        rc = check_xattr_ref_inode(c, ic);
+        if (unlikely(rc))
+                return rc;
+
+        down_read(&c->xattr_sem);
+ retry:
+        for (ref=ic->xref, pref=&ic->xref; ref; pref=&ref->next, ref=ref->next) {
+                BUG_ON(ref->ic!=ic);
+
+                xd = ref->xd;
+                if (xd->xprefix != xprefix)
+                        continue;
+                if (!xd->xname) {
+                        /* xdatum is unchached */
+                        if (!retry) {
+                                retry = 1;
+                                up_read(&c->xattr_sem);
+                                down_write(&c->xattr_sem);
+                                goto retry;
+                        } else {
+                                rc = load_xattr_datum(c, xd);
+                                if (unlikely(rc > 0)) {
+                                        *pref = ref->next;
+                                        delete_xattr_ref(c, ref);
+                                        goto retry;
+                                } else if (unlikely(rc < 0)) {
+                                        goto out;
+                                }
+                        }
+                }
+                if (!strcmp(xname, xd->xname)) {
+                        rc = xd->value_len;
+                        if (buffer) {
+                                if (size < rc) {
+                                        rc = -ERANGE;
+                                } else {
+                                        memcpy(buffer, xd->xvalue, rc);
+                                }
+                        }
+                        goto out;
+                }
+        }
+        rc = -ENODATA;
+ out:
+        if (!retry) {
+                up_read(&c->xattr_sem);
+        } else {
+                up_write(&c->xattr_sem);
+        }
+        return rc;
+}
+
+int do_jffs2_setxattr(struct inode *inode, int xprefix, const char *xname,
+                      const char *buffer, size_t size, int flags)
+{
+        struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
+        struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
+        struct jffs2_inode_cache *ic = f->inocache;
+        struct jffs2_xattr_datum *xd;
+        struct jffs2_xattr_ref *ref, *newref, **pref;
+        uint32_t length, request;
+        int rc;
+
+        rc = check_xattr_ref_inode(c, ic);
+        if (unlikely(rc))
+                return rc;
+
+        request = PAD(sizeof(struct jffs2_raw_xattr) + strlen(xname) + 1 + size);
+        rc = jffs2_reserve_space(c, request, &length,
+                                 ALLOC_NORMAL, JFFS2_SUMMARY_XATTR_SIZE);
+        if (rc) {
+                JFFS2_WARNING("jffs2_reserve_space()=%d, request=%u\n", rc, request);
+                return rc;
+        }
+
+        /* Find existing xattr */
+        down_write(&c->xattr_sem);
+ retry:
+        for (ref=ic->xref, pref=&ic->xref; ref; pref=&ref->next, ref=ref->next) {
+                xd = ref->xd;
+                if (xd->xprefix != xprefix)
+                        continue;
+                if (!xd->xname) {
+                        rc = load_xattr_datum(c, xd);
+                        if (unlikely(rc > 0)) {
+                                *pref = ref->next;
+                                delete_xattr_ref(c, ref);
+                                goto retry;
+                        } else if (unlikely(rc < 0))
+                                goto out;
+                }
+                if (!strcmp(xd->xname, xname)) {
+                        if (flags & XATTR_CREATE) {
+                                rc = -EEXIST;
+                                goto out;
+                        }
+                        if (!buffer) {
+                                *pref = ref->next;
+                                delete_xattr_ref(c, ref);
+                                rc = 0;
+                                goto out;
+                        }
+                        goto found;
+                }
+        }
+        /* not found */
+        if (flags & XATTR_REPLACE) {
+                rc = -ENODATA;
+                goto out;
+        }
+        if (!buffer) {
+                rc = -EINVAL;
+                goto out;
+        }
+ found:
+        xd = create_xattr_datum(c, xprefix, xname, buffer, size);
+        if (IS_ERR(xd)) {
+                rc = PTR_ERR(xd);
+                goto out;
+        }
+        up_write(&c->xattr_sem);
+        jffs2_complete_reservation(c);
+
+        /* create xattr_ref */
+        request = PAD(sizeof(struct jffs2_raw_xref));
+        rc = jffs2_reserve_space(c, request, &length,
+                                 ALLOC_NORMAL, JFFS2_SUMMARY_XREF_SIZE);
+        if (rc) {
+                JFFS2_WARNING("jffs2_reserve_space()=%d, request=%u\n", rc, request);
+                down_write(&c->xattr_sem);
+                xd->refcnt--;
+                if (!xd->refcnt)
+                        delete_xattr_datum(c, xd);
+                up_write(&c->xattr_sem);
+                return rc;
+        }
+        down_write(&c->xattr_sem);
+        if (ref)
+                *pref = ref->next;
+        newref = create_xattr_ref(c, ic, xd);
+        if (IS_ERR(newref)) {
+                if (ref) {
+                        ref->next = ic->xref;
+                        ic->xref = ref;
+                }
+                rc = PTR_ERR(newref);
+                xd->refcnt--;
+                if (!xd->refcnt)
+                        delete_xattr_datum(c, xd);
+        } else if (ref) {
+                delete_xattr_ref(c, ref);
+        }
+ out:
+        up_write(&c->xattr_sem);
+        jffs2_complete_reservation(c);
+        return rc;
+}
+
+/* -------- garbage collector functions -------------
+ * jffs2_garbage_collect_xattr_datum(c, xd)
+ *   is used to move xdatum into new node.
+ * jffs2_garbage_collect_xattr_ref(c, ref)
+ *   is used to move xref into new node.
+ * jffs2_verify_xattr(c)
+ *   is used to call do_verify_xattr_datum() before garbage collecting.
+ * -------------------------------------------------- */
+int jffs2_garbage_collect_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd)
+{
+        uint32_t totlen, length, old_ofs;
+        int rc = -EINVAL;
+
+        down_write(&c->xattr_sem);
+        BUG_ON(!xd->node);
+
+        old_ofs = ref_offset(xd->node);
+        totlen = ref_totlen(c, c->gcblock, xd->node);
+        if (totlen < sizeof(struct jffs2_raw_xattr))
+                goto out;
+
+        if (!xd->xname) {
+                rc = load_xattr_datum(c, xd);
+                if (unlikely(rc > 0)) {
+                        delete_xattr_datum_node(c, xd);
+                        rc = 0;
+                        goto out;
+                } else if (unlikely(rc < 0))
+                        goto out;
+        }
+        rc = jffs2_reserve_space_gc(c, totlen, &length, JFFS2_SUMMARY_XATTR_SIZE);
+        if (rc || length < totlen) {
+                JFFS2_WARNING("jffs2_reserve_space()=%d, request=%u\n", rc, totlen);
+                rc = rc ? rc : -EBADFD;
+                goto out;
+        }
+        rc = save_xattr_datum(c, xd);
+        if (!rc)
+                dbg_xattr("xdatum (xid=%u, version=%u) GC'ed from %#08x to %08x\n",
+                          xd->xid, xd->version, old_ofs, ref_offset(xd->node));
+ out:
+        up_write(&c->xattr_sem);
+        return rc;
+}
+
+
+int jffs2_garbage_collect_xattr_ref(struct jffs2_sb_info *c, struct jffs2_xattr_ref *ref)
+{
+        uint32_t totlen, length, old_ofs;
+        int rc = -EINVAL;
+
+        down_write(&c->xattr_sem);
+        BUG_ON(!ref->node);
+
+        old_ofs = ref_offset(ref->node);
+        totlen = ref_totlen(c, c->gcblock, ref->node);
+        if (totlen != sizeof(struct jffs2_raw_xref))
+                goto out;
+
+        rc = jffs2_reserve_space_gc(c, totlen, &length, JFFS2_SUMMARY_XREF_SIZE);
+        if (rc || length < totlen) {
+                JFFS2_WARNING("%s: jffs2_reserve_space() = %d, request = %u\n",
+                              __FUNCTION__, rc, totlen);
+                rc = rc ? rc : -EBADFD;
+                goto out;
+        }
+        rc = save_xattr_ref(c, ref);
+        if (!rc)
+                dbg_xattr("xref (ino=%u, xid=%u) GC'ed from %#08x to %08x\n",
+                          ref->ic->ino, ref->xd->xid, old_ofs, ref_offset(ref->node));
+ out:
+        up_write(&c->xattr_sem);
+        return rc;
+}
+
+int jffs2_verify_xattr(struct jffs2_sb_info *c)
+{
+        struct jffs2_xattr_datum *xd, *_xd;
+        int rc;
+
+        down_write(&c->xattr_sem);
+        list_for_each_entry_safe(xd, _xd, &c->xattr_unchecked, xindex) {
+                rc = do_verify_xattr_datum(c, xd);
+                if (rc == 0) {
+                        list_del_init(&xd->xindex);
+                        break;
+                } else if (rc > 0) {
+                        list_del_init(&xd->xindex);
+                        delete_xattr_datum_node(c, xd);
+                }
+        }
+        up_write(&c->xattr_sem);
+
+        return list_empty(&c->xattr_unchecked) ? 1 : 0;
+}
diff --git a/fs/jffs2/xattr.h b/fs/jffs2/xattr.h
new file mode 100644
index 000000000000..2c199856c582
--- /dev/null
+++ b/fs/jffs2/xattr.h
@@ -0,0 +1,116 @@
+/*
+ * JFFS2 -- Journalling Flash File System, Version 2.
+ *
+ * Copyright (C) 2006  NEC Corporation
+ *
+ * Created by KaiGai Kohei <kaigai@ak.jp.nec.com>
+ *
+ * For licensing information, see the file 'LICENCE' in this directory.
+ *
+ */
+#ifndef _JFFS2_FS_XATTR_H_
+#define _JFFS2_FS_XATTR_H_
+
+#include <linux/xattr.h>
+#include <linux/list.h>
+
+#define JFFS2_XFLAGS_HOT        (0x01)  /* This datum is HOT */
+#define JFFS2_XFLAGS_BIND       (0x02)  /* This datum is not reclaimed */
+
+struct jffs2_xattr_datum
+{
+        void *always_null;
+        struct jffs2_raw_node_ref *node;
+        uint8_t class;
+        uint8_t flags;
+        uint16_t xprefix;                       /* see JFFS2_XATTR_PREFIX_* */
+
+        struct list_head xindex;        /* chained from c->xattrindex[n] */
+        uint32_t refcnt;                /* # of xattr_ref refers this */
+        uint32_t xid;
+        uint32_t version;
+
+        uint32_t data_crc;
+        uint32_t hashkey;
+        char *xname;            /* XATTR name without prefix */
+        uint32_t name_len;      /* length of xname */
+        char *xvalue;           /* XATTR value */
+        uint32_t value_len;     /* length of xvalue */
+};
+
+struct jffs2_inode_cache;
+struct jffs2_xattr_ref
+{
+        void *always_null;
+        struct jffs2_raw_node_ref *node;
+        uint8_t class;
+        uint8_t flags;          /* Currently unused */
+        u16 unused;
+
+        union {
+                struct jffs2_inode_cache *ic;   /* reference to jffs2_inode_cache */
+                uint32_t ino;                   /* only used in scanning/building  */
+        };
+        union {
+                struct jffs2_xattr_datum *xd;   /* reference to jffs2_xattr_datum */
+                uint32_t xid;                   /* only used in sccanning/building */
+        };
+        struct jffs2_xattr_ref *next;           /* chained from ic->xref_list */
+};
+
+#ifdef CONFIG_JFFS2_FS_XATTR
+
+extern void jffs2_init_xattr_subsystem(struct jffs2_sb_info *c);
+extern void jffs2_build_xattr_subsystem(struct jffs2_sb_info *c);
+extern void jffs2_clear_xattr_subsystem(struct jffs2_sb_info *c);
+
+extern struct jffs2_xattr_datum *jffs2_setup_xattr_datum(struct jffs2_sb_info *c,
+                                                  uint32_t xid, uint32_t version);
+
+extern void jffs2_xattr_delete_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic);
+extern void jffs2_xattr_free_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic);
+
+extern int jffs2_garbage_collect_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd);
+extern int jffs2_garbage_collect_xattr_ref(struct jffs2_sb_info *c, struct jffs2_xattr_ref *ref);
+extern int jffs2_verify_xattr(struct jffs2_sb_info *c);
+
+extern int do_jffs2_getxattr(struct inode *inode, int xprefix, const char *xname,
+                             char *buffer, size_t size);
+extern int do_jffs2_setxattr(struct inode *inode, int xprefix, const char *xname,
+                             const char *buffer, size_t size, int flags);
+
+extern struct xattr_handler *jffs2_xattr_handlers[];
+extern struct xattr_handler jffs2_user_xattr_handler;
+extern struct xattr_handler jffs2_trusted_xattr_handler;
+
+extern ssize_t jffs2_listxattr(struct dentry *, char *, size_t);
+#define jffs2_getxattr          generic_getxattr
+#define jffs2_setxattr          generic_setxattr
+#define jffs2_removexattr       generic_removexattr
+
+#else
+
+#define jffs2_init_xattr_subsystem(c)
+#define jffs2_build_xattr_subsystem(c)
+#define jffs2_clear_xattr_subsystem(c)
+
+#define jffs2_xattr_delete_inode(c, ic)
+#define jffs2_xattr_free_inode(c, ic)
+#define jffs2_verify_xattr(c)                   (1)
+
+#define jffs2_xattr_handlers    NULL
+#define jffs2_listxattr         NULL
+#define jffs2_getxattr          NULL
+#define jffs2_setxattr          NULL
+#define jffs2_removexattr       NULL
+
+#endif /* CONFIG_JFFS2_FS_XATTR */
+
+#ifdef CONFIG_JFFS2_FS_SECURITY
+extern int jffs2_init_security(struct inode *inode, struct inode *dir);
+extern struct xattr_handler jffs2_security_xattr_handler;
+#else
+#define jffs2_init_security(inode,dir)  (0)
+#endif /* CONFIG_JFFS2_FS_SECURITY */
+
+#endif /* _JFFS2_FS_XATTR_H_ */
diff --git a/fs/jffs2/xattr_trusted.c b/fs/jffs2/xattr_trusted.c
new file mode 100644
index 000000000000..ed046e19dbfa
--- /dev/null
+++ b/fs/jffs2/xattr_trusted.c
@@ -0,0 +1,52 @@
+/*
+ * JFFS2 -- Journalling Flash File System, Version 2.
+ *
+ * Copyright (C) 2006  NEC Corporation
+ *
+ * Created by KaiGai Kohei <kaigai@ak.jp.nec.com>
+ *
+ * For licensing information, see the file 'LICENCE' in this directory.
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/jffs2.h>
+#include <linux/xattr.h>
+#include <linux/mtd/mtd.h>
+#include "nodelist.h"
+
+static int jffs2_trusted_getxattr(struct inode *inode, const char *name,
+                                  void *buffer, size_t size)
+{
+        if (!strcmp(name, ""))
+                return -EINVAL;
+        return do_jffs2_getxattr(inode, JFFS2_XPREFIX_TRUSTED, name, buffer, size);
+}
+
+static int jffs2_trusted_setxattr(struct inode *inode, const char *name, const void *buffer,
+                                  size_t size, int flags)
+{
+        if (!strcmp(name, ""))
+                return -EINVAL;
+        return do_jffs2_setxattr(inode, JFFS2_XPREFIX_TRUSTED, name, buffer, size, flags);
+}
+
+static size_t jffs2_trusted_listxattr(struct inode *inode, char *list, size_t list_size,
+                                      const char *name, size_t name_len)
+{
+        size_t retlen = XATTR_TRUSTED_PREFIX_LEN + name_len + 1;
+
+        if (list && retlen<=list_size) {
+                strcpy(list, XATTR_TRUSTED_PREFIX);
+                strcpy(list + XATTR_TRUSTED_PREFIX_LEN, name);
+        }
+
+        return retlen;
+}
+
+struct xattr_handler jffs2_trusted_xattr_handler = {
+        .prefix = XATTR_TRUSTED_PREFIX,
+        .list = jffs2_trusted_listxattr,
+        .set = jffs2_trusted_setxattr,
+        .get = jffs2_trusted_getxattr
+};
diff --git a/fs/jffs2/xattr_user.c b/fs/jffs2/xattr_user.c
new file mode 100644
index 000000000000..2f8e9aa01ea0
--- /dev/null
+++ b/fs/jffs2/xattr_user.c
@@ -0,0 +1,52 @@
+/*
+ * JFFS2 -- Journalling Flash File System, Version 2.
+ *
+ * Copyright (C) 2006  NEC Corporation
+ *
+ * Created by KaiGai Kohei <kaigai@ak.jp.nec.com>
+ *
+ * For licensing information, see the file 'LICENCE' in this directory.
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/jffs2.h>
+#include <linux/xattr.h>
+#include <linux/mtd/mtd.h>
+#include "nodelist.h"
+
+static int jffs2_user_getxattr(struct inode *inode, const char *name,
+                               void *buffer, size_t size)
+{
+        if (!strcmp(name, ""))
+                return -EINVAL;
+        return do_jffs2_getxattr(inode, JFFS2_XPREFIX_USER, name, buffer, size);
+}
+
+static int jffs2_user_setxattr(struct inode *inode, const char *name, const void *buffer,
+                               size_t size, int flags)
+{
+        if (!strcmp(name, ""))
+                return -EINVAL;
+        return do_jffs2_setxattr(inode, JFFS2_XPREFIX_USER, name, buffer, size, flags);
+}
+
+static size_t jffs2_user_listxattr(struct inode *inode, char *list, size_t list_size,
+                                   const char *name, size_t name_len)
+{
+        size_t retlen = XATTR_USER_PREFIX_LEN + name_len + 1;
+
+        if (list && retlen <= list_size) {
+                strcpy(list, XATTR_USER_PREFIX);
+                strcpy(list + XATTR_USER_PREFIX_LEN, name);
+        }
+
+        return retlen;
+}
+
+struct xattr_handler jffs2_user_xattr_handler = {
+        .prefix = XATTR_USER_PREFIX,
+        .list = jffs2_user_listxattr,
+        .set = jffs2_user_setxattr,
+        .get = jffs2_user_getxattr
+};
diff --git a/fs/namei.c b/fs/namei.c
index d6e2ee251736..184fe4acf824 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1127,7 +1127,7 @@ out:
         if (likely(retval == 0)) {
                 if (unlikely(current->audit_context && nd && nd->dentry &&
                                 nd->dentry->d_inode))
-                audit_inode(name, nd->dentry->d_inode, flags);
+                audit_inode(name, nd->dentry->d_inode);
         }
 out_fail:
         return retval;
diff --git a/fs/open.c b/fs/open.c
index 317b7c7f38a7..4f178acd4c09 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -633,7 +633,7 @@ asmlinkage long sys_fchmod(unsigned int fd, mode_t mode)
         dentry = file->f_dentry;
         inode = dentry->d_inode;
 
-        audit_inode(NULL, inode, 0);
+        audit_inode(NULL, inode);
 
         err = -EROFS;
         if (IS_RDONLY(inode))
@@ -786,7 +786,7 @@ asmlinkage long sys_fchown(unsigned int fd, uid_t user, gid_t group)
         if (file) {
                 struct dentry * dentry;
                 dentry = file->f_dentry;
-                audit_inode(NULL, dentry->d_inode, 0);
+                audit_inode(NULL, dentry->d_inode);
                 error = chown_common(dentry, user, group);
                 fput(file);
         }
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 6cc77dc3f3ff..6afff725a8c9 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -1019,8 +1019,8 @@ static ssize_t proc_loginuid_write(struct file * file, const char __user * buf,
         if (current != task)
                 return -EPERM;
 
-        if (count > PAGE_SIZE)
-                count = PAGE_SIZE;
+        if (count >= PAGE_SIZE)
+                count = PAGE_SIZE - 1;
 
         if (*ppos != 0) {
                 /* No partial writes. */
@@ -1033,6 +1033,7 @@ static ssize_t proc_loginuid_write(struct file * file, const char __user * buf,
         if (copy_from_user(page, buf, count))
                 goto out_free_page;
 
+        page[count] = '\0';
         loginuid = simple_strtoul(page, &tmp, 10);
         if (tmp == page) {
                 length = -EINVAL;
diff --git a/fs/xattr.c b/fs/xattr.c
index e416190f5e9c..c32f15b5f60f 100644
--- a/fs/xattr.c
+++ b/fs/xattr.c
@@ -242,7 +242,7 @@ sys_fsetxattr(int fd, char __user *name, void __user *value,
         if (!f)
                 return error;
         dentry = f->f_dentry;
-        audit_inode(NULL, dentry->d_inode, 0);
+        audit_inode(NULL, dentry->d_inode);
         error = setxattr(dentry, name, value, size, flags);
         fput(f);
         return error;
@@ -469,7 +469,7 @@ sys_fremovexattr(int fd, char __user *name)
         if (!f)
                 return error;
         dentry = f->f_dentry;
-        audit_inode(NULL, dentry->d_inode, 0);
+        audit_inode(NULL, dentry->d_inode);
         error = removexattr(dentry, name);
         fput(f);
         return error;
diff --git a/include/acpi/platform/aclinux.h b/include/acpi/platform/aclinux.h
index 2e6d54569ee8..3c6a6205853a 100644
--- a/include/acpi/platform/aclinux.h
+++ b/include/acpi/platform/aclinux.h
@@ -49,7 +49,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
 #include <linux/ctype.h>
diff --git a/include/acpi/processor.h b/include/acpi/processor.h
index badf0277b1be..ef7d83a41470 100644
--- a/include/acpi/processor.h
+++ b/include/acpi/processor.h
@@ -2,7 +2,6 @@
 #define __ACPI_PROCESSOR_H
 
 #include <linux/kernel.h>
-#include <linux/config.h>
 
 #include <asm/acpi.h>
 
diff --git a/include/asm-alpha/bitops.h b/include/asm-alpha/bitops.h
index 3f88715e811e..4b6ef7f21b93 100644
--- a/include/asm-alpha/bitops.h
+++ b/include/asm-alpha/bitops.h
@@ -1,7 +1,6 @@
 #ifndef _ALPHA_BITOPS_H
 #define _ALPHA_BITOPS_H
 
-#include <linux/config.h>
 #include <asm/compiler.h>
 
 /*
diff --git a/include/asm-alpha/cache.h b/include/asm-alpha/cache.h
index e6d4d1695e25..f199e69a5d0b 100644
--- a/include/asm-alpha/cache.h
+++ b/include/asm-alpha/cache.h
@@ -4,7 +4,6 @@
 #ifndef __ARCH_ALPHA_CACHE_H
 #define __ARCH_ALPHA_CACHE_H
 
-#include <linux/config.h>
 
 /* Bytes per L1 (data) cache line. */
 #if defined(CONFIG_ALPHA_GENERIC) || defined(CONFIG_ALPHA_EV6)
diff --git a/include/asm-alpha/cacheflush.h b/include/asm-alpha/cacheflush.h
index 3fc6ef726d8c..805640b41078 100644
--- a/include/asm-alpha/cacheflush.h
+++ b/include/asm-alpha/cacheflush.h
@@ -1,7 +1,6 @@
 #ifndef _ALPHA_CACHEFLUSH_H
 #define _ALPHA_CACHEFLUSH_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 
 /* Caches aren't brain-dead on the Alpha. */
diff --git a/include/asm-alpha/core_cia.h b/include/asm-alpha/core_cia.h
index 3a70d68bfce8..9e0516c0ca27 100644
--- a/include/asm-alpha/core_cia.h
+++ b/include/asm-alpha/core_cia.h
@@ -4,7 +4,6 @@
 /* Define to experiment with fitting everything into one 512MB HAE window.  */
 #define CIA_ONE_HAE_WINDOW 1
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <asm/compiler.h>
 
diff --git a/include/asm-alpha/core_t2.h b/include/asm-alpha/core_t2.h
index 5c1c40338c82..dba70c62a16c 100644
--- a/include/asm-alpha/core_t2.h
+++ b/include/asm-alpha/core_t2.h
@@ -1,7 +1,6 @@
 #ifndef __ALPHA_T2__H__
 #define __ALPHA_T2__H__
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/spinlock.h>
 #include <asm/compiler.h>
diff --git a/include/asm-alpha/dma-mapping.h b/include/asm-alpha/dma-mapping.h
index 62d0d6681aa9..b9ff4d8cb33a 100644
--- a/include/asm-alpha/dma-mapping.h
+++ b/include/asm-alpha/dma-mapping.h
@@ -1,7 +1,6 @@
 #ifndef _ALPHA_DMA_MAPPING_H
 #define _ALPHA_DMA_MAPPING_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_PCI
 
diff --git a/include/asm-alpha/dma.h b/include/asm-alpha/dma.h
index 683afaa3deed..87cfdbdf08fc 100644
--- a/include/asm-alpha/dma.h
+++ b/include/asm-alpha/dma.h
@@ -18,7 +18,6 @@
 #ifndef _ASM_DMA_H
 #define _ASM_DMA_H
 
-#include <linux/config.h>
 #include <linux/spinlock.h>
 #include <asm/io.h>
 
diff --git a/include/asm-alpha/floppy.h b/include/asm-alpha/floppy.h
index 289a00d51a90..e177d4180f83 100644
--- a/include/asm-alpha/floppy.h
+++ b/include/asm-alpha/floppy.h
@@ -10,7 +10,6 @@
 #ifndef __ASM_ALPHA_FLOPPY_H
 #define __ASM_ALPHA_FLOPPY_H
 
-#include <linux/config.h>
 
 #define fd_inb(port)                    inb_p(port)
 #define fd_outb(value,port)             outb_p(value,port)
diff --git a/include/asm-alpha/hardirq.h b/include/asm-alpha/hardirq.h
index 7bb6a36c96a1..d953e234daa8 100644
--- a/include/asm-alpha/hardirq.h
+++ b/include/asm-alpha/hardirq.h
@@ -1,7 +1,6 @@
 #ifndef _ALPHA_HARDIRQ_H
 #define _ALPHA_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/cache.h>
 
diff --git a/include/asm-alpha/hw_irq.h b/include/asm-alpha/hw_irq.h
index a310b9efc906..ca9d43b63502 100644
--- a/include/asm-alpha/hw_irq.h
+++ b/include/asm-alpha/hw_irq.h
@@ -1,7 +1,6 @@
 #ifndef _ALPHA_HW_IRQ_H
 #define _ALPHA_HW_IRQ_H
 
-#include <linux/config.h>
 
 static inline void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i) {}
 
diff --git a/include/asm-alpha/ide.h b/include/asm-alpha/ide.h
index 6126afe27380..2a5cc0b367ab 100644
--- a/include/asm-alpha/ide.h
+++ b/include/asm-alpha/ide.h
@@ -13,7 +13,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #define IDE_ARCH_OBSOLETE_DEFAULTS
 
diff --git a/include/asm-alpha/io.h b/include/asm-alpha/io.h
index 3ebbeee753e9..f5ae98c25d1f 100644
--- a/include/asm-alpha/io.h
+++ b/include/asm-alpha/io.h
@@ -3,7 +3,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <asm/compiler.h>
 #include <asm/system.h>
diff --git a/include/asm-alpha/irq.h b/include/asm-alpha/irq.h
index 566db720000a..f6de033718a0 100644
--- a/include/asm-alpha/irq.h
+++ b/include/asm-alpha/irq.h
@@ -8,7 +8,6 @@
  */
 
 #include <linux/linkage.h>
-#include <linux/config.h>
 
 #if   defined(CONFIG_ALPHA_GENERIC)
 
diff --git a/include/asm-alpha/kmap_types.h b/include/asm-alpha/kmap_types.h
index 3d10cd3ea75f..3e6735a34c57 100644
--- a/include/asm-alpha/kmap_types.h
+++ b/include/asm-alpha/kmap_types.h
@@ -3,7 +3,6 @@
 
 /* Dummy header just to define km_type. */
 
-#include <linux/config.h>
 
 #ifdef CONFIG_DEBUG_HIGHMEM
 # define D(n) __KM_FENCE_##n ,
diff --git a/include/asm-alpha/machvec.h b/include/asm-alpha/machvec.h
index ece166a203ec..aced22f91752 100644
--- a/include/asm-alpha/machvec.h
+++ b/include/asm-alpha/machvec.h
@@ -1,7 +1,6 @@
 #ifndef __ALPHA_MACHVEC_H
 #define __ALPHA_MACHVEC_H 1
 
-#include <linux/config.h>
 #include <linux/types.h>
 
 /*
diff --git a/include/asm-alpha/mmu_context.h b/include/asm-alpha/mmu_context.h
index 0c017fc181c1..fe249e9d3360 100644
--- a/include/asm-alpha/mmu_context.h
+++ b/include/asm-alpha/mmu_context.h
@@ -7,7 +7,6 @@
  * Copyright (C) 1996, Linus Torvalds
  */
 
-#include <linux/config.h>
 #include <asm/system.h>
 #include <asm/machvec.h>
 #include <asm/compiler.h>
diff --git a/include/asm-alpha/mmzone.h b/include/asm-alpha/mmzone.h
index 192d80c875b0..64d0ab98fcd8 100644
--- a/include/asm-alpha/mmzone.h
+++ b/include/asm-alpha/mmzone.h
@@ -5,7 +5,6 @@
 #ifndef _ASM_MMZONE_H_
 #define _ASM_MMZONE_H_
 
-#include <linux/config.h>
 #include <asm/smp.h>
 
 struct bootmem_data_t; /* stupid forward decl. */
diff --git a/include/asm-alpha/page.h b/include/asm-alpha/page.h
index 61bcf70b5eac..8c7cd50d4eae 100644
--- a/include/asm-alpha/page.h
+++ b/include/asm-alpha/page.h
@@ -1,7 +1,6 @@
 #ifndef _ALPHA_PAGE_H
 #define _ALPHA_PAGE_H
 
-#include <linux/config.h>
 #include <asm/pal.h>
 
 /* PAGE_SHIFT determines the page size */
diff --git a/include/asm-alpha/param.h b/include/asm-alpha/param.h
index 3ed0b3b02e52..214e7996346f 100644
--- a/include/asm-alpha/param.h
+++ b/include/asm-alpha/param.h
@@ -5,7 +5,6 @@
    hardware ignores reprogramming.  We also need userland buy-in to the 
    change in HZ, since this is visible in the wait4 resources etc.  */
 
-#include <linux/config.h>
 
 #ifndef HZ
 # ifndef CONFIG_ALPHA_RAWHIDE
diff --git a/include/asm-alpha/pgalloc.h b/include/asm-alpha/pgalloc.h
index 308475642913..471864e8d4c3 100644
--- a/include/asm-alpha/pgalloc.h
+++ b/include/asm-alpha/pgalloc.h
@@ -1,7 +1,6 @@
 #ifndef _ALPHA_PGALLOC_H
 #define _ALPHA_PGALLOC_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <linux/mmzone.h>
 
diff --git a/include/asm-alpha/pgtable.h b/include/asm-alpha/pgtable.h
index a985cd29b6db..93eaa58b7961 100644
--- a/include/asm-alpha/pgtable.h
+++ b/include/asm-alpha/pgtable.h
@@ -10,7 +10,6 @@
  * This hopefully works with any standard Alpha page-size, as defined
  * in <asm/page.h> (currently 8192).
  */
-#include <linux/config.h>
 #include <linux/mmzone.h>
 
 #include <asm/page.h>
diff --git a/include/asm-alpha/serial.h b/include/asm-alpha/serial.h
index 7e4b2987d453..9d263e8d8ccc 100644
--- a/include/asm-alpha/serial.h
+++ b/include/asm-alpha/serial.h
@@ -2,7 +2,6 @@
  * include/asm-alpha/serial.h
  */
 
-#include <linux/config.h>
 
 /*
  * This assumes you have a 1.8432 MHz clock for your UART.
diff --git a/include/asm-alpha/smp.h b/include/asm-alpha/smp.h
index e1432102be05..a1a1eca6be45 100644
--- a/include/asm-alpha/smp.h
+++ b/include/asm-alpha/smp.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_SMP_H
 #define __ASM_SMP_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/cpumask.h>
 #include <linux/bitops.h>
diff --git a/include/asm-alpha/spinlock.h b/include/asm-alpha/spinlock.h
index 8197c69eff44..0c294c9b0c55 100644
--- a/include/asm-alpha/spinlock.h
+++ b/include/asm-alpha/spinlock.h
@@ -1,7 +1,6 @@
 #ifndef _ALPHA_SPINLOCK_H
 #define _ALPHA_SPINLOCK_H
 
-#include <linux/config.h>
 #include <asm/system.h>
 #include <linux/kernel.h>
 #include <asm/current.h>
diff --git a/include/asm-alpha/system.h b/include/asm-alpha/system.h
index f3b7b1a59c56..03e9c0e5ed74 100644
--- a/include/asm-alpha/system.h
+++ b/include/asm-alpha/system.h
@@ -1,7 +1,6 @@
 #ifndef __ALPHA_SYSTEM_H
 #define __ALPHA_SYSTEM_H
 
-#include <linux/config.h>
 #include <asm/pal.h>
 #include <asm/page.h>
 #include <asm/barrier.h>
diff --git a/include/asm-alpha/tlbflush.h b/include/asm-alpha/tlbflush.h
index 9d484c1fdc82..1ca3ed3bd6d3 100644
--- a/include/asm-alpha/tlbflush.h
+++ b/include/asm-alpha/tlbflush.h
@@ -1,7 +1,6 @@
 #ifndef _ALPHA_TLBFLUSH_H
 #define _ALPHA_TLBFLUSH_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <asm/compiler.h>
 
diff --git a/include/asm-alpha/unistd.h b/include/asm-alpha/unistd.h
index ef25b6585119..bc6e6a9259dc 100644
--- a/include/asm-alpha/unistd.h
+++ b/include/asm-alpha/unistd.h
@@ -383,6 +383,8 @@
 #define __NR_inotify_add_watch          445
 #define __NR_inotify_rm_watch           446
 
+#ifdef __KERNEL__
+
 #define NR_SYSCALLS                     447
 
 #if defined(__GNUC__)
@@ -565,9 +567,8 @@ type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, type6 arg6)\
         _syscall_return(type);                                          \
 }
 
-#endif /* __LIBRARY__ && __GNUC__ */
+#endif /* __GNUC__ */
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_STAT64
@@ -578,7 +579,6 @@ type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, type6 arg6)\
 #define __ARCH_WANT_SYS_OLD_GETRLIMIT
 #define __ARCH_WANT_SYS_OLDUMOUNT
 #define __ARCH_WANT_SYS_SIGPENDING
-#endif
 
 #ifdef __KERNEL_SYSCALLS__
 
@@ -661,4 +661,5 @@ asmlinkage long sys_rt_sigaction(int sig,
 
 #define cond_syscall(x)  asm(".weak\t" #x "\n" #x " = sys_ni_syscall")
 
+#endif /* __KERNEL__ */
 #endif /* _ALPHA_UNISTD_H */
diff --git a/include/asm-arm/apm.h b/include/asm-arm/apm.h
index 3a50eb759c28..d09113b37e4a 100644
--- a/include/asm-arm/apm.h
+++ b/include/asm-arm/apm.h
@@ -13,7 +13,6 @@
 #ifndef ARM_ASM_SA1100_APM_H
 #define ARM_ASM_SA1100_APM_H
 
-#include <linux/config.h>
 #include <linux/apm_bios.h>
 
 /*
diff --git a/include/asm-arm/arch-aaec2000/memory.h b/include/asm-arm/arch-aaec2000/memory.h
index d8209f8911d6..24b51cccde8f 100644
--- a/include/asm-arm/arch-aaec2000/memory.h
+++ b/include/asm-arm/arch-aaec2000/memory.h
@@ -11,7 +11,6 @@
 #ifndef __ASM_ARCH_MEMORY_H
 #define __ASM_ARCH_MEMORY_H
 
-#include <linux/config.h>
 
 #define PHYS_OFFSET     UL(0xf0000000)
 
diff --git a/include/asm-arm/arch-cl7500/acornfb.h b/include/asm-arm/arch-cl7500/acornfb.h
index 3867231a4470..aea6330c9745 100644
--- a/include/asm-arm/arch-cl7500/acornfb.h
+++ b/include/asm-arm/arch-cl7500/acornfb.h
@@ -1,4 +1,3 @@
-#include <linux/config.h>
 #define acornfb_valid_pixrate(var) (var->pixclock >= 39325 && var->pixclock <= 40119)
 
 static inline void
diff --git a/include/asm-arm/arch-clps711x/hardware.h b/include/asm-arm/arch-clps711x/hardware.h
index 1386871e1a5a..0fdbe72fff2a 100644
--- a/include/asm-arm/arch-clps711x/hardware.h
+++ b/include/asm-arm/arch-clps711x/hardware.h
@@ -22,7 +22,6 @@
 #ifndef __ASM_ARCH_HARDWARE_H
 #define __ASM_ARCH_HARDWARE_H
 
-#include <linux/config.h>
 
 #define CLPS7111_VIRT_BASE      0xff000000
 #define CLPS7111_BASE           CLPS7111_VIRT_BASE
diff --git a/include/asm-arm/arch-clps711x/memory.h b/include/asm-arm/arch-clps711x/memory.h
index 61d8717406ce..c6e8dcf674de 100644
--- a/include/asm-arm/arch-clps711x/memory.h
+++ b/include/asm-arm/arch-clps711x/memory.h
@@ -20,7 +20,6 @@
 #ifndef __ASM_ARCH_MEMORY_H
 #define __ASM_ARCH_MEMORY_H
 
-#include <linux/config.h>
 
 /*
  * Physical DRAM offset.
diff --git a/include/asm-arm/arch-clps711x/uncompress.h b/include/asm-arm/arch-clps711x/uncompress.h
index 07157b7e4b20..03d233ae87ce 100644
--- a/include/asm-arm/arch-clps711x/uncompress.h
+++ b/include/asm-arm/arch-clps711x/uncompress.h
@@ -17,7 +17,6 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
-#include <linux/config.h>
 #include <asm/arch/io.h>
 #include <asm/hardware.h>
 #include <asm/hardware/clps7111.h>
diff --git a/include/asm-arm/arch-ebsa285/hardware.h b/include/asm-arm/arch-ebsa285/hardware.h
index ec51fe92483b..daad8ee2d194 100644
--- a/include/asm-arm/arch-ebsa285/hardware.h
+++ b/include/asm-arm/arch-ebsa285/hardware.h
@@ -12,7 +12,6 @@
 #ifndef __ASM_ARCH_HARDWARE_H
 #define __ASM_ARCH_HARDWARE_H
 
-#include <linux/config.h>
 #include <asm/arch/memory.h>
 
 #ifdef CONFIG_ARCH_FOOTBRIDGE
diff --git a/include/asm-arm/arch-ebsa285/memory.h b/include/asm-arm/arch-ebsa285/memory.h
index 99181ffc7e27..cbd7ae64bcc9 100644
--- a/include/asm-arm/arch-ebsa285/memory.h
+++ b/include/asm-arm/arch-ebsa285/memory.h
@@ -19,7 +19,6 @@
 #ifndef __ASM_ARCH_MEMORY_H
 #define __ASM_ARCH_MEMORY_H
 
-#include <linux/config.h>
 
 #if defined(CONFIG_FOOTBRIDGE_ADDIN)
 /*
diff --git a/include/asm-arm/arch-ebsa285/vmalloc.h b/include/asm-arm/arch-ebsa285/vmalloc.h
index d1ca955ce434..02598200997d 100644
--- a/include/asm-arm/arch-ebsa285/vmalloc.h
+++ b/include/asm-arm/arch-ebsa285/vmalloc.h
@@ -6,7 +6,6 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/config.h>
 
 #ifdef CONFIG_ARCH_FOOTBRIDGE
 #define VMALLOC_END       (PAGE_OFFSET + 0x30000000)
diff --git a/include/asm-arm/arch-integrator/smp.h b/include/asm-arm/arch-integrator/smp.h
index da6981efdc39..ab2c79bb9505 100644
--- a/include/asm-arm/arch-integrator/smp.h
+++ b/include/asm-arm/arch-integrator/smp.h
@@ -1,7 +1,6 @@
 #ifndef ASMARM_ARCH_SMP_H
 #define ASMARM_ARCH_SMP_H
 
-#include <linux/config.h>
 
 #include <asm/hardware.h>
 #include <asm/io.h>
diff --git a/include/asm-arm/arch-iop3xx/memory.h b/include/asm-arm/arch-iop3xx/memory.h
index bc62f4b13235..e43ebd984745 100644
--- a/include/asm-arm/arch-iop3xx/memory.h
+++ b/include/asm-arm/arch-iop3xx/memory.h
@@ -5,7 +5,6 @@
 #ifndef __ASM_ARCH_MEMORY_H
 #define __ASM_ARCH_MEMORY_H
 
-#include <linux/config.h>
 #include <asm/hardware.h>
 
 /*
diff --git a/include/asm-arm/arch-iop3xx/timex.h b/include/asm-arm/arch-iop3xx/timex.h
index 472badb451c4..14ca8d0f7b29 100644
--- a/include/asm-arm/arch-iop3xx/timex.h
+++ b/include/asm-arm/arch-iop3xx/timex.h
@@ -3,7 +3,6 @@
  *
  * IOP3xx architecture timex specifications
  */
-#include <linux/config.h>
 #include <asm/hardware.h>
 
 #if defined(CONFIG_ARCH_IQ80321) || defined(CONFIG_ARCH_IQ31244)
diff --git a/include/asm-arm/arch-iop3xx/uncompress.h b/include/asm-arm/arch-iop3xx/uncompress.h
index c98eb6254b1f..fbdd5af644fe 100644
--- a/include/asm-arm/arch-iop3xx/uncompress.h
+++ b/include/asm-arm/arch-iop3xx/uncompress.h
@@ -1,7 +1,6 @@
 /*
  *  linux/include/asm-arm/arch-iop3xx/uncompress.h
  */
-#include <linux/config.h>
 #include <asm/types.h>
 #include <asm/mach-types.h>
 #include <linux/serial_reg.h>
diff --git a/include/asm-arm/arch-ixp4xx/dma.h b/include/asm-arm/arch-ixp4xx/dma.h
index b1a071ecebc8..789f7f53c357 100644
--- a/include/asm-arm/arch-ixp4xx/dma.h
+++ b/include/asm-arm/arch-ixp4xx/dma.h
@@ -11,7 +11,6 @@
 #ifndef __ASM_ARCH_DMA_H
 #define __ASM_ARCH_DMA_H
 
-#include <linux/config.h>
 #include <linux/device.h>
 #include <linux/pci.h>
 #include <asm/page.h>
diff --git a/include/asm-arm/arch-lh7a40x/clocks.h b/include/asm-arm/arch-lh7a40x/clocks.h
new file mode 100644
index 000000000000..bee02fd8dab1
--- /dev/null
+++ b/include/asm-arm/arch-lh7a40x/clocks.h
@@ -0,0 +1,20 @@
+/* include/asm-arm/arch-lh7a40x/clocks.h
+ *
+ *  Copyright (C) 2004 Marc Singer
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  version 2 as published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/config.h>
+
+#ifndef __ASM_ARCH_CLOCKS_H
+#define __ASM_ARCH_CLOCKS_H
+
+unsigned int fclkfreq_get (void);
+unsigned int hclkfreq_get (void);
+unsigned int pclkfreq_get (void);
+
+#endif  /* _ASM_ARCH_CLOCKS_H */
diff --git a/include/asm-arm/arch-lh7a40x/constants.h b/include/asm-arm/arch-lh7a40x/constants.h
index 52c1cb9c39c6..51de96e87faf 100644
--- a/include/asm-arm/arch-lh7a40x/constants.h
+++ b/include/asm-arm/arch-lh7a40x/constants.h
@@ -12,7 +12,6 @@
 #ifndef __ASM_ARCH_CONSTANTS_H
 #define __ASM_ARCH_CONSTANTS_H
 
-#include <linux/config.h>
 
 /* Addressing constants */
 
@@ -29,8 +28,7 @@
 
 #if defined (CONFIG_MACH_LPD7A400) || defined (CONFIG_MACH_LPD7A404)
 
-# define IOBARRIER_PHYS         0xc0000000 /* Start of SDRAM */
-/*# define IOBARRIER_PHYS               0x00000000 */ /* Start of flash */
+# define IOBARRIER_PHYS         0x10000000 /* Second bank, fastest timing */
 # define IOBARRIER_VIRT         0xf0000000
 # define IOBARRIER_SIZE         PAGE_SIZE
 
@@ -53,6 +51,9 @@
 # define CPLD08_PHYS            CPLDX_PHYS (0x08)
 # define CPLD08_VIRT            CPLDX_VIRT (0x08)
 # define CPLD08_SIZE            PAGE_SIZE
+# define CPLD0A_PHYS            CPLDX_PHYS (0x0a)
+# define CPLD0A_VIRT            CPLDX_VIRT (0x0a)
+# define CPLD0A_SIZE            PAGE_SIZE
 # define CPLD0C_PHYS            CPLDX_PHYS (0x0c)
 # define CPLD0C_VIRT            CPLDX_VIRT (0x0c)
 # define CPLD0C_SIZE            PAGE_SIZE
@@ -84,5 +85,7 @@
 #define XTAL_IN                 14745600        /* 14.7456 MHz crystal */
 #define PLL_CLOCK               (XTAL_IN * 21)  /* 309 MHz PLL clock */
 #define MAX_HCLK_KHZ            100000          /* HCLK max limit ~100MHz */
+#define HCLK                    (99993600)
+//#define HCLK                  (119808000)
 
 #endif /* __ASM_ARCH_CONSTANTS_H */
diff --git a/include/asm-arm/arch-lh7a40x/dma.h b/include/asm-arm/arch-lh7a40x/dma.h
index 15492e3253f6..a8cbd14bbf9d 100644
--- a/include/asm-arm/arch-lh7a40x/dma.h
+++ b/include/asm-arm/arch-lh7a40x/dma.h
@@ -1,9 +1,86 @@
 /* include/asm-arm/arch-lh7a40x/dma.h
  *
- *  Copyright (C) 2003 Coastal Environmental Systems
+ *  Copyright (C) 2005 Marc Singer
  *
  *  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.
  *
  */
+
+typedef enum {
+        DMA_M2M0        = 0,
+        DMA_M2M1        = 1,
+        DMA_M2P0        = 2,    /* Tx */
+        DMA_M2P1        = 3,    /* Rx */
+        DMA_M2P2        = 4,    /* Tx */
+        DMA_M2P3        = 5,    /* Rx */
+        DMA_M2P4        = 6,    /* Tx - AC97 */
+        DMA_M2P5        = 7,    /* Rx - AC97 */
+        DMA_M2P6        = 8,    /* Tx */
+        DMA_M2P7        = 9,    /* Rx */
+} dma_device_t;
+
+#define DMA_LENGTH_MAX          ((64*1024) - 4) /* bytes */
+
+#define DMAC_GCA                __REG(DMAC_PHYS + 0x2b80)
+#define DMAC_GIR                __REG(DMAC_PHYS + 0x2bc0)
+
+#define DMAC_GIR_MMI1           (1<<11)
+#define DMAC_GIR_MMI0           (1<<10)
+#define DMAC_GIR_MPI8           (1<<9)
+#define DMAC_GIR_MPI9           (1<<8)
+#define DMAC_GIR_MPI6           (1<<7)
+#define DMAC_GIR_MPI7           (1<<6)
+#define DMAC_GIR_MPI4           (1<<5)
+#define DMAC_GIR_MPI5           (1<<4)
+#define DMAC_GIR_MPI2           (1<<3)
+#define DMAC_GIR_MPI3           (1<<2)
+#define DMAC_GIR_MPI0           (1<<1)
+#define DMAC_GIR_MPI1           (1<<0)
+
+#define DMAC_M2P0               0x0000
+#define DMAC_M2P1               0x0040
+#define DMAC_M2P2               0x0080
+#define DMAC_M2P3               0x00c0
+#define DMAC_M2P4               0x0240
+#define DMAC_M2P5               0x0200
+#define DMAC_M2P6               0x02c0
+#define DMAC_M2P7               0x0280
+#define DMAC_M2P8               0x0340
+#define DMAC_M2P9               0x0300
+#define DMAC_M2M0               0x0100
+#define DMAC_M2M1               0x0140
+
+#define DMAC_P_PCONTROL(c)      __REG(DMAC_PHYS + (c) + 0x00)
+#define DMAC_P_PINTERRUPT(c)    __REG(DMAC_PHYS + (c) + 0x04)
+#define DMAC_P_PPALLOC(c)       __REG(DMAC_PHYS + (c) + 0x08)
+#define DMAC_P_PSTATUS(c)       __REG(DMAC_PHYS + (c) + 0x0c)
+#define DMAC_P_REMAIN(c)        __REG(DMAC_PHYS + (c) + 0x14)
+#define DMAC_P_MAXCNT0(c)       __REG(DMAC_PHYS + (c) + 0x20)
+#define DMAC_P_BASE0(c)         __REG(DMAC_PHYS + (c) + 0x24)
+#define DMAC_P_CURRENT0(c)      __REG(DMAC_PHYS + (c) + 0x28)
+#define DMAC_P_MAXCNT1(c)       __REG(DMAC_PHYS + (c) + 0x30)
+#define DMAC_P_BASE1(c)         __REG(DMAC_PHYS + (c) + 0x34)
+#define DMAC_P_CURRENT1(c)      __REG(DMAC_PHYS + (c) + 0x38)
+
+#define DMAC_PCONTROL_ENABLE    (1<<4)
+
+#define DMAC_PORT_USB           0
+#define DMAC_PORT_SDMMC         1
+#define DMAC_PORT_AC97_1        2
+#define DMAC_PORT_AC97_2        3
+#define DMAC_PORT_AC97_3        4
+#define DMAC_PORT_UART1         6
+#define DMAC_PORT_UART2         7
+#define DMAC_PORT_UART3         8
+
+#define DMAC_PSTATUS_CURRSTATE_SHIFT    4
+#define DMAC_PSTATUS_CURRSTATE_MASK     0x3
+
+#define DMAC_PSTATUS_NEXTBUF     (1<<6)
+#define DMAC_PSTATUS_STALLRINT   (1<<0)
+
+#define DMAC_INT_CHE             (1<<3)
+#define DMAC_INT_NFB             (1<<1)
+#define DMAC_INT_STALL           (1<<0)
diff --git a/include/asm-arm/arch-lh7a40x/entry-macro.S b/include/asm-arm/arch-lh7a40x/entry-macro.S
index a2f67c06d9c9..9fc7f4988124 100644
--- a/include/asm-arm/arch-lh7a40x/entry-macro.S
+++ b/include/asm-arm/arch-lh7a40x/entry-macro.S
@@ -10,11 +10,73 @@
 #include <asm/hardware.h>
 #include <asm/arch/irqs.h>
 
-# if defined (CONFIG_ARCH_LH7A400) && defined (CONFIG_ARCH_LH7A404)
-#  error "LH7A400 and LH7A404 are mutually exclusive"
-# endif
+/* In order to allow there to be support for both of the processor
+   classes at the same time, we make a hack here that isn't very
+   pretty.  At startup, the link pointed to with the
+   branch_irq_lh7a400 symbol is replaced with a NOP when the CPU is
+   detected as a lh7a404.
 
-# if defined (CONFIG_ARCH_LH7A400)
+   *** FIXME: we should clean this up so that there is only one
+              implementation for each CPU's design.
+
+*/
+
+#if defined (CONFIG_ARCH_LH7A400) && defined (CONFIG_ARCH_LH7A404)
+
+                .macro  disable_fiq
+                .endm
+
+                .macro  get_irqnr_and_base, irqnr, irqstat, base, tmp
+
+branch_irq_lh7a400: b 1000f
+
+@ Implementation of the LH7A404 get_irqnr_and_base.
+
+                mov     \irqnr, #0                      @ VIC1 irq base
+                mov     \base, #io_p2v(0x80000000)      @ APB registers
+                add     \base, \base, #0x8000
+                ldr     \tmp, [\base, #0x0030]          @ VIC1_VECTADDR
+                tst     \tmp, #VA_VECTORED              @ Direct vectored
+                bne     1002f
+                tst     \tmp, #VA_VIC1DEFAULT           @ Default vectored VIC1
+                ldrne   \irqstat, [\base, #0]           @ VIC1_IRQSTATUS
+                bne     1001f
+                add     \base, \base, #(0xa000 - 0x8000)
+                ldr     \tmp, [\base, #0x0030]          @ VIC2_VECTADDR
+                tst     \tmp, #VA_VECTORED              @ Direct vectored
+                bne     1002f
+                ldr     \irqstat, [\base, #0]           @ VIC2_IRQSTATUS
+                mov     \irqnr, #32                     @ VIC2 irq base
+
+1001:           movs    \irqstat, \irqstat, lsr #1      @ Shift into carry
+                bcs     1008f                           @ Bit set; irq found
+                add     \irqnr, \irqnr, #1
+                bne     1001b                           @ Until no bits
+                b       1009f                           @ Nothing?  Hmm.
+1002:           and     \irqnr, \tmp, #0x3f             @ Mask for valid bits
+1008:           movs    \irqstat, #1                    @ Force !Z
+                str     \tmp, [\base, #0x0030]          @ Clear vector
+                b       1009f
+
+@ Implementation of the LH7A400 get_irqnr_and_base.
+
+1000:           mov     \irqnr, #0
+                mov     \base, #io_p2v(0x80000000)      @ APB registers
+                ldr     \irqstat, [\base, #0x500]       @ PIC INTSR
+
+1001:           movs    \irqstat, \irqstat, lsr #1      @ Shift into carry
+                bcs     1008f                           @ Bit set; irq found
+                add     \irqnr, \irqnr, #1
+                bne     1001b                           @ Until no bits
+                b       1009f                           @ Nothing?  Hmm.
+1008:           movs    \irqstat, #1                    @ Force !Z
+
+1009:
+               .endm
+
+
+
+#elif defined (CONFIG_ARCH_LH7A400)
                 .macro  disable_fiq
                 .endm
 
diff --git a/include/asm-arm/arch-lh7a40x/hardware.h b/include/asm-arm/arch-lh7a40x/hardware.h
index aeb07c162e25..e9ff74fd7939 100644
--- a/include/asm-arm/arch-lh7a40x/hardware.h
+++ b/include/asm-arm/arch-lh7a40x/hardware.h
@@ -13,6 +13,8 @@
 #ifndef __ASM_ARCH_HARDWARE_H
 #define __ASM_ARCH_HARDWARE_H
 
+#include <asm/sizes.h>          /* Added for the sake of amba-clcd driver */
+
 #define io_p2v(x) (0xf0000000 | (((x) & 0xfff00000) >> 4) | ((x) & 0x0000ffff))
 #define io_v2p(x) (             (((x) & 0x0fff0000) << 4) | ((x) & 0x0000ffff))
 
@@ -53,6 +55,8 @@ typedef struct { volatile u8 offset[4096]; } __regbase8;
 
 #endif
 
+#define MASK_AND_SET(v,m,s)     (v) = ((v)&~(m))|(s)
+
 #include "registers.h"
 
 #endif  /* _ASM_ARCH_HARDWARE_H */
diff --git a/include/asm-arm/arch-lh7a40x/irqs.h b/include/asm-arm/arch-lh7a40x/irqs.h
index f91f3e59f3ab..afe8c7cbad6a 100644
--- a/include/asm-arm/arch-lh7a40x/irqs.h
+++ b/include/asm-arm/arch-lh7a40x/irqs.h
@@ -18,7 +18,6 @@
 #ifndef __ASM_ARCH_IRQS_H
 #define __ASM_ARCH_IRQS_H
 
-#include <linux/config.h>
 
 #define FIQ_START       80
 
@@ -154,9 +153,10 @@
 #if !defined (IRQ_GPIO0INTR)
 # define IRQ_GPIO0INTR  IRQ_GPIO0FIQ
 #endif
-#define IRQ_TICK        IRQ_TINTR
+#define IRQ_TICK        IRQ_TINTR
 #define IRQ_PCC1_RDY    IRQ_GPIO6INTR   /* PCCard 1 ready */
 #define IRQ_PCC2_RDY    IRQ_GPIO7INTR   /* PCCard 2 ready */
+#define IRQ_USB         IRQ_USBINTR     /* USB device */
 
 #ifdef CONFIG_MACH_KEV7A400
 # define IRQ_TS         IRQ_GPIOFIQ     /* Touchscreen */
@@ -191,6 +191,10 @@
 # define IRQ_LPD7A400_TS        IRQ_LPD7A40X_CPLD + 1   /* Touch screen */
 #endif
 
+#if defined (CONFIG_MACH_LPD7A400)
+# define IRQ_TOUCH              IRQ_LPD7A400_TS
+#endif
+
 #define NR_IRQS         (NR_IRQ_CPU + NR_IRQ_BOARD)
 
 #endif
diff --git a/include/asm-arm/arch-lh7a40x/registers.h b/include/asm-arm/arch-lh7a40x/registers.h
index 2edb22e35450..b4f09b3e2d03 100644
--- a/include/asm-arm/arch-lh7a40x/registers.h
+++ b/include/asm-arm/arch-lh7a40x/registers.h
@@ -9,7 +9,6 @@
  *
  */
 
-#include <linux/config.h>
 #include <asm/arch/constants.h>
 
 #ifndef __ASM_ARCH_REGISTERS_H
@@ -18,7 +17,7 @@
 
         /* Physical register base addresses */
 
-#define AC97_PHYS       (0x80000000)    /* AC97 Controller */
+#define AC97C_PHYS      (0x80000000)    /* AC97 Controller */
 #define MMC_PHYS        (0x80000100)    /* Multimedia Card Controller */
 #define USB_PHYS        (0x80000200)    /* USB Client */
 #define SCI_PHYS        (0x80000300)    /* Secure Card Interface */
@@ -35,6 +34,8 @@
 #define RTC_PHYS        (0x80000d00)    /* Real-time Clock */
 #define GPIO_PHYS       (0x80000e00)    /* General Purpose IO */
 #define BMI_PHYS        (0x80000f00)    /* Battery Monitor Interface */
+#define HRTFTC_PHYS     (0x80001000)    /* High-res TFT Controller (LH7A400) */
+#define ALI_PHYS        (0x80001000)    /* Advanced LCD Interface (LH7A404) */
 #define WDT_PHYS        (0x80001400)    /* Watchdog Timer */
 #define SMC_PHYS        (0x80002000)    /* Static Memory Controller */
 #define SDRC_PHYS       (0x80002400)    /* SDRAM Controller */
@@ -43,6 +44,7 @@
 
         /* Physical registers of the LH7A404 */
 
+#define ADC_PHYS        (0x80001300)    /* A/D & Touchscreen Controller */
 #define VIC1_PHYS       (0x80008000)    /* Vectored Interrupt Controller 1 */
 #define USBH_PHYS       (0x80009000)    /* USB OHCI host controller */
 #define VIC2_PHYS       (0x8000a000)    /* Vectored Interrupt Controller 2 */
@@ -53,10 +55,32 @@
 
         /* Clock/State Controller register */
 
+#define CSC_PWRSR       __REG(CSC_PHYS + 0x00) /* Reset register & ID */
 #define CSC_PWRCNT      __REG(CSC_PHYS + 0x04) /* Power control */
+#define CSC_CLKSET      __REG(CSC_PHYS + 0x20) /* Clock speed control */
+#define CSC_USBDRESET   __REG(CSC_PHYS + 0x4c) /* USB Device resets */
 
 #define CSC_PWRCNT_USBH_EN      (1<<28) /* USB Host power enable */
-
+#define CSC_PWRCNT_DMAC_M2M1_EN (1<<27)
+#define CSC_PWRCNT_DMAC_M2M0_EN (1<<26)
+#define CSC_PWRCNT_DMAC_M2P8_EN (1<<25)
+#define CSC_PWRCNT_DMAC_M2P9_EN (1<<24)
+#define CSC_PWRCNT_DMAC_M2P6_EN (1<<23)
+#define CSC_PWRCNT_DMAC_M2P7_EN (1<<22)
+#define CSC_PWRCNT_DMAC_M2P4_EN (1<<21)
+#define CSC_PWRCNT_DMAC_M2P5_EN (1<<20)
+#define CSC_PWRCNT_DMAC_M2P2_EN (1<<19)
+#define CSC_PWRCNT_DMAC_M2P3_EN (1<<18)
+#define CSC_PWRCNT_DMAC_M2P0_EN (1<<17)
+#define CSC_PWRCNT_DMAC_M2P1_EN (1<<16)
+
+#define CSC_PWRSR_CHIPMAN_SHIFT (24)
+#define CSC_PWRSR_CHIPMAN_MASK  (0xff)
+#define CSC_PWRSR_CHIPID_SHIFT  (16)
+#define CSC_PWRSR_CHIPID_MASK   (0xff)
+
+#define CSC_USBDRESET_APBRESETREG       (1<<1)
+#define CSC_USBDRESET_IORESETREG        (1<<0)
 
         /* Interrupt Controller registers */
 
@@ -109,6 +133,13 @@
 #define GPIO_GPIOFEOI   __REG(GPIO_PHYS + 0x54) /* GPIO End-of-Interrupt */
 #define GPIO_GPIOINTEN  __REG(GPIO_PHYS + 0x58) /* GPIO Interrupt Enable */
 #define GPIO_INTSTATUS  __REG(GPIO_PHYS + 0x5c) /* GPIO Interrupt Status */
+#define GPIO_PINMUX     __REG(GPIO_PHYS + 0x2c)
+#define GPIO_PADD       __REG(GPIO_PHYS + 0x10)
+#define GPIO_PAD        __REG(GPIO_PHYS + 0x00)
+#define GPIO_PCD        __REG(GPIO_PHYS + 0x08)
+#define GPIO_PCDD       __REG(GPIO_PHYS + 0x18)
+#define GPIO_PEDD       __REG(GPIO_PHYS + 0x24)
+#define GPIO_PED        __REG(GPIO_PHYS + 0x20)
 
 
         /* Static Memory Controller registers */
@@ -138,20 +169,21 @@
 #endif
 
 #if defined (CONFIG_MACH_LPD7A400) || defined (CONFIG_MACH_LPD7A404)
-# define CPLD_CONTROL           __REG8(CPLD02_PHYS)
-# define CPLD_SPI_DATA          __REG8(CPLD06_PHYS)
-# define CPLD_SPI_CONTROL       __REG8(CPLD08_PHYS)
-# define CPLD_SPI_EEPROM        __REG8(CPLD0A_PHYS)
-# define CPLD_INTERRUPTS        __REG8(CPLD0C_PHYS) /* IRQ mask/status */
-# define CPLD_BOOT_MODE         __REG8(CPLD0E_PHYS)
-# define CPLD_FLASH             __REG8(CPLD10_PHYS)
-# define CPLD_POWER_MGMT        __REG8(CPLD12_PHYS)
-# define CPLD_REVISION          __REG8(CPLD14_PHYS)
-# define CPLD_GPIO_EXT          __REG8(CPLD16_PHYS)
-# define CPLD_GPIO_DATA         __REG8(CPLD18_PHYS)
-# define CPLD_GPIO_DIR          __REG8(CPLD1A_PHYS)
-#endif
 
+# define CPLD_CONTROL           __REG16(CPLD02_PHYS)
+# define CPLD_SPI_DATA          __REG16(CPLD06_PHYS)
+# define CPLD_SPI_CONTROL       __REG16(CPLD08_PHYS)
+# define CPLD_SPI_EEPROM        __REG16(CPLD0A_PHYS)
+# define CPLD_INTERRUPTS        __REG16(CPLD0C_PHYS) /* IRQ mask/status */
+# define CPLD_BOOT_MODE         __REG16(CPLD0E_PHYS)
+# define CPLD_FLASH             __REG16(CPLD10_PHYS)
+# define CPLD_POWER_MGMT        __REG16(CPLD12_PHYS)
+# define CPLD_REVISION          __REG16(CPLD14_PHYS)
+# define CPLD_GPIO_EXT          __REG16(CPLD16_PHYS)
+# define CPLD_GPIO_DATA         __REG16(CPLD18_PHYS)
+# define CPLD_GPIO_DIR          __REG16(CPLD1A_PHYS)
+
+#endif
 
         /* Timer registers */
 
@@ -190,4 +222,3 @@
 
 
 #endif  /* _ASM_ARCH_REGISTERS_H */
-
diff --git a/include/asm-arm/arch-lh7a40x/ssp.h b/include/asm-arm/arch-lh7a40x/ssp.h
new file mode 100644
index 000000000000..132b1c4d5ce6
--- /dev/null
+++ b/include/asm-arm/arch-lh7a40x/ssp.h
@@ -0,0 +1,71 @@
+/* ssp.h
+     $Id$
+
+   written by Marc Singer
+   6 Dec 2004
+
+   Copyright (C) 2004 Marc Singer
+
+   -----------
+   DESCRIPTION
+   -----------
+
+   This SSP header is available throughout the kernel, for this
+   machine/architecture, because drivers that use it may be dispersed.
+
+   This file was cloned from the 7952x implementation.  It would be
+   better to share them, but we're taking an easier approach for the
+   time being.
+
+*/
+
+#if !defined (__SSP_H__)
+#    define   __SSP_H__
+
+/* ----- Includes */
+
+/* ----- Types */
+
+struct ssp_driver {
+        int  (*init)            (void);
+        void (*exit)            (void);
+        void (*acquire)         (void);
+        void (*release)         (void);
+        int  (*configure)       (int device, int mode, int speed,
+                                 int frame_size_write, int frame_size_read);
+        void (*chip_select)     (int enable);
+        void (*set_callbacks)   (void* handle,
+                                 irqreturn_t (*callback_tx)(void*),
+                                 irqreturn_t (*callback_rx)(void*));
+        void (*enable)          (void);
+        void (*disable)         (void);
+//      int  (*save_state)      (void*);
+//      void (*restore_state)   (void*);
+        int  (*read)            (void);
+        int  (*write)           (u16 data);
+        int  (*write_read)      (u16 data);
+        void (*flush)           (void);
+        void (*write_async)     (void* pv, size_t cb);
+        size_t (*write_pos)     (void);
+};
+
+        /* These modes are only available on the LH79524 */
+#define SSP_MODE_SPI            (1)
+#define SSP_MODE_SSI            (2)
+#define SSP_MODE_MICROWIRE      (3)
+#define SSP_MODE_I2S            (4)
+
+        /* CPLD SPI devices */
+#define DEVICE_EEPROM   0       /* Configuration eeprom */
+#define DEVICE_MAC      1       /* MAC eeprom (LPD79524) */
+#define DEVICE_CODEC    2       /* Audio codec */
+#define DEVICE_TOUCH    3       /* Touch screen (LPD79520) */
+
+/* ----- Globals */
+
+/* ----- Prototypes */
+
+//extern struct ssp_driver lh79520_i2s_driver;
+extern struct ssp_driver lh7a400_cpld_ssp_driver;
+
+#endif  /* __SSP_H__ */
diff --git a/include/asm-arm/arch-lh7a40x/uncompress.h b/include/asm-arm/arch-lh7a40x/uncompress.h
index f8053346f608..3d1ce0426a33 100644
--- a/include/asm-arm/arch-lh7a40x/uncompress.h
+++ b/include/asm-arm/arch-lh7a40x/uncompress.h
@@ -16,7 +16,7 @@
 #ifndef UART_R_STATUS
 # define UART_R_STATUS  (0x10)
 #endif
-#define nTxRdy          (0x20)  /* Not TxReady (literally Tx FIFO full) */
+#define nTxRdy          (0x20)  /* Not TxReady (literally Tx FIFO full) */
 
         /* Access UART with physical addresses before MMU is setup */
 #define UART_STATUS (*(volatile unsigned long*) (UART2_PHYS + UART_R_STATUS))
diff --git a/include/asm-arm/arch-omap/board.h b/include/asm-arm/arch-omap/board.h
index 6d6240a4681c..dfdbf06fd646 100644
--- a/include/asm-arm/arch-omap/board.h
+++ b/include/asm-arm/arch-omap/board.h
@@ -10,7 +10,6 @@
 #ifndef _OMAP_BOARD_H
 #define _OMAP_BOARD_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 
 /* Different peripheral ids */
diff --git a/include/asm-arm/arch-omap/hardware.h b/include/asm-arm/arch-omap/hardware.h
index 7909b729826c..c7d9e857795d 100644
--- a/include/asm-arm/arch-omap/hardware.h
+++ b/include/asm-arm/arch-omap/hardware.h
@@ -37,7 +37,6 @@
 #define __ASM_ARCH_OMAP_HARDWARE_H
 
 #include <asm/sizes.h>
-#include <linux/config.h>
 #ifndef __ASSEMBLER__
 #include <asm/types.h>
 #include <asm/arch/cpu.h>
diff --git a/include/asm-arm/arch-omap/system.h b/include/asm-arm/arch-omap/system.h
index 67970d1a2020..ac2bfa433f06 100644
--- a/include/asm-arm/arch-omap/system.h
+++ b/include/asm-arm/arch-omap/system.h
@@ -4,7 +4,6 @@
  */
 #ifndef __ASM_ARCH_SYSTEM_H
 #define __ASM_ARCH_SYSTEM_H
-#include <linux/config.h>
 #include <linux/clk.h>
 
 #include <asm/mach-types.h>
diff --git a/include/asm-arm/arch-omap/uncompress.h b/include/asm-arm/arch-omap/uncompress.h
index ca2c8bec82e7..aca0adfef1b8 100644
--- a/include/asm-arm/arch-omap/uncompress.h
+++ b/include/asm-arm/arch-omap/uncompress.h
@@ -17,7 +17,6 @@
  * kind, whether express or implied.
  */
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/serial_reg.h>
 #include <asm/arch/serial.h>
diff --git a/include/asm-arm/arch-pnx4008/clock.h b/include/asm-arm/arch-pnx4008/clock.h
new file mode 100644
index 000000000000..91ae0030fdf2
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/clock.h
@@ -0,0 +1,61 @@
+/*
+ * include/asm-arm/arch-pnx4008/clock.h
+ *
+ * Clock control driver for PNX4008 - header file
+ *
+ * Authors: Vitaly Wool, Dmitry Chigirev <source@mvista.com>
+ *
+ * 2005 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+#ifndef __PNX4008_CLOCK_H__
+#define __PNX4008_CLOCK_H__
+
+struct module;
+struct clk;
+
+#define PWRMAN_VA_BASE          IO_ADDRESS(PNX4008_PWRMAN_BASE)
+#define HCLKDIVCTRL_REG         (PWRMAN_VA_BASE + 0x40)
+#define PWRCTRL_REG             (PWRMAN_VA_BASE + 0x44)
+#define PLLCTRL_REG             (PWRMAN_VA_BASE + 0x48)
+#define OSC13CTRL_REG           (PWRMAN_VA_BASE + 0x4c)
+#define SYSCLKCTRL_REG          (PWRMAN_VA_BASE + 0x50)
+#define HCLKPLLCTRL_REG         (PWRMAN_VA_BASE + 0x58)
+#define USBCTRL_REG             (PWRMAN_VA_BASE + 0x64)
+#define SDRAMCLKCTRL_REG        (PWRMAN_VA_BASE + 0x68)
+#define MSCTRL_REG              (PWRMAN_VA_BASE + 0x80)
+#define BTCLKCTRL               (PWRMAN_VA_BASE + 0x84)
+#define DUMCLKCTRL_REG          (PWRMAN_VA_BASE + 0x90)
+#define I2CCLKCTRL_REG          (PWRMAN_VA_BASE + 0xac)
+#define KEYCLKCTRL_REG          (PWRMAN_VA_BASE + 0xb0)
+#define TSCLKCTRL_REG           (PWRMAN_VA_BASE + 0xb4)
+#define PWMCLKCTRL_REG          (PWRMAN_VA_BASE + 0xb8)
+#define SPICTRL_REG             (PWRMAN_VA_BASE + 0xc4)
+#define FLASHCLKCTRL_REG        (PWRMAN_VA_BASE + 0xc8)
+#define UART3CLK_REG            (PWRMAN_VA_BASE + 0xd0)
+#define UARTCLKCTRL_REG         (PWRMAN_VA_BASE + 0xe4)
+#define DMACLKCTRL_REG          (PWRMAN_VA_BASE + 0xe8)
+#define AUTOCLK_CTRL            (PWRMAN_VA_BASE + 0xec)
+#define JPEGCLKCTRL_REG         (PWRMAN_VA_BASE + 0xfc)
+
+#define AUDIOCONFIG_VA_BASE     IO_ADDRESS(PNX4008_AUDIOCONFIG_BASE)
+#define DSPPLLCTRL_REG          (AUDIOCONFIG_VA_BASE + 0x60)
+#define DSPCLKCTRL_REG          (AUDIOCONFIG_VA_BASE + 0x64)
+#define AUDIOCLKCTRL_REG        (AUDIOCONFIG_VA_BASE + 0x68)
+#define AUDIOPLLCTRL_REG        (AUDIOCONFIG_VA_BASE + 0x6C)
+
+#define USB_OTG_CLKCTRL_REG     IO_ADDRESS(PNX4008_USB_CONFIG_BASE + 0xff4)
+
+#define VFP9CLKCTRL_REG         IO_ADDRESS(PNX4008_DEBUG_BASE)
+
+#define CLK_RATE_13MHZ 13000
+#define CLK_RATE_1MHZ 1000
+#define CLK_RATE_208MHZ 208000
+#define CLK_RATE_48MHZ 48000
+#define CLK_RATE_32KHZ 32
+
+#define PNX4008_UART_CLK CLK_RATE_13MHZ * 1000 /* in MHz */
+
+#endif
diff --git a/include/asm-arm/arch-pnx4008/debug-macro.S b/include/asm-arm/arch-pnx4008/debug-macro.S
new file mode 100644
index 000000000000..eb3839de389a
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/debug-macro.S
@@ -0,0 +1,27 @@
+/* linux/include/asm-arm/arch-pnx4008/debug-macro.S
+ *
+ * Debugging macro include header
+ *
+ *  Copyright (C) 1994-1999 Russell King
+ *  Moved from linux/arch/arm/kernel/debug.S by Ben Dooks
+ *
+ * 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.
+ *
+*/
+
+                .macro  addruart,rx
+                mrc     p15, 0, \rx, c1, c0
+                tst     \rx, #1                 @ MMU enabled?
+                mov     \rx, #0x00090000
+                addeq   \rx, \rx, #0x40000000
+                addne   \rx, \rx, #0xf4000000
+                .endm
+
+                .macro  senduart,rd,rx
+                strb    \rd, [\rx, #0x0]
+                .endm
+
+#define UART_SHIFT      2
+#include <asm/hardware/debug-8250.S>
diff --git a/include/asm-arm/arch-pnx4008/dma.h b/include/asm-arm/arch-pnx4008/dma.h
new file mode 100644
index 000000000000..3aee1204795b
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/dma.h
@@ -0,0 +1,162 @@
+/*
+ *  linux/include/asm-arm/arch-pnx4008/dma.h
+ *
+ *  PNX4008 DMA header file
+ *
+ *  Author:     Vitaly Wool
+ *  Copyright:  MontaVista Software Inc. (c) 2005
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ */
+
+#ifndef __ASM_ARCH_DMA_H
+#define __ASM_ARCH_DMA_H
+
+#include "platform.h"
+
+#define MAX_DMA_ADDRESS         0xffffffff
+
+#define MAX_DMA_CHANNELS        8
+
+#define DMAC_BASE               IO_ADDRESS(PNX4008_DMA_CONFIG_BASE)
+#define DMAC_INT_STAT           (DMAC_BASE + 0x0000)
+#define DMAC_INT_TC_STAT        (DMAC_BASE + 0x0004)
+#define DMAC_INT_TC_CLEAR       (DMAC_BASE + 0x0008)
+#define DMAC_INT_ERR_STAT       (DMAC_BASE + 0x000c)
+#define DMAC_INT_ERR_CLEAR      (DMAC_BASE + 0x0010)
+#define DMAC_SOFT_SREQ          (DMAC_BASE + 0x0024)
+#define DMAC_CONFIG             (DMAC_BASE + 0x0030)
+#define DMAC_Cx_SRC_ADDR(c)     (DMAC_BASE + 0x0100 + (c) * 0x20)
+#define DMAC_Cx_DEST_ADDR(c)    (DMAC_BASE + 0x0104 + (c) * 0x20)
+#define DMAC_Cx_LLI(c)          (DMAC_BASE + 0x0108 + (c) * 0x20)
+#define DMAC_Cx_CONTROL(c)      (DMAC_BASE + 0x010c + (c) * 0x20)
+#define DMAC_Cx_CONFIG(c)       (DMAC_BASE + 0x0110 + (c) * 0x20)
+
+enum {
+        WIDTH_BYTE = 0,
+        WIDTH_HWORD,
+        WIDTH_WORD
+};
+
+enum {
+        FC_MEM2MEM_DMA,
+        FC_MEM2PER_DMA,
+        FC_PER2MEM_DMA,
+        FC_PER2PER_DMA,
+        FC_PER2PER_DPER,
+        FC_MEM2PER_PER,
+        FC_PER2MEM_PER,
+        FC_PER2PER_SPER
+};
+
+enum {
+        DMA_INT_UNKNOWN = 0,
+        DMA_ERR_INT = 1,
+        DMA_TC_INT = 2,
+};
+
+enum {
+        DMA_BUFFER_ALLOCATED = 1,
+        DMA_HAS_LL = 2,
+};
+
+enum {
+        PER_CAM_DMA_1 = 0,
+        PER_NDF_FLASH = 1,
+        PER_MBX_SLAVE_FIFO = 2,
+        PER_SPI2_REC_XMIT = 3,
+        PER_MS_SD_RX_XMIT = 4,
+        PER_HS_UART_1_XMIT = 5,
+        PER_HS_UART_1_RX = 6,
+        PER_HS_UART_2_XMIT = 7,
+        PER_HS_UART_2_RX = 8,
+        PER_HS_UART_7_XMIT = 9,
+        PER_HS_UART_7_RX = 10,
+        PER_SPI1_REC_XMIT = 11,
+        PER_MLC_NDF_SREC = 12,
+        PER_CAM_DMA_2 = 13,
+        PER_PRNG_INFIFO = 14,
+        PER_PRNG_OUTFIFO = 15,
+};
+
+struct pnx4008_dma_ch_ctrl {
+        int tc_mask;
+        int cacheable;
+        int bufferable;
+        int priv_mode;
+        int di;
+        int si;
+        int dest_ahb1;
+        int src_ahb1;
+        int dwidth;
+        int swidth;
+        int dbsize;
+        int sbsize;
+        int tr_size;
+};
+
+struct pnx4008_dma_ch_config {
+        int halt;
+        int active;
+        int lock;
+        int itc;
+        int ie;
+        int flow_cntrl;
+        int dest_per;
+        int src_per;
+};
+
+struct pnx4008_dma_ll {
+        unsigned long src_addr;
+        unsigned long dest_addr;
+        u32 next_dma;
+        unsigned long ch_ctrl;
+        struct pnx4008_dma_ll *next;
+        int flags;
+        void *alloc_data;
+        int (*free) (void *);
+};
+
+struct pnx4008_dma_config {
+        int is_ll;
+        unsigned long src_addr;
+        unsigned long dest_addr;
+        unsigned long ch_ctrl;
+        unsigned long ch_cfg;
+        struct pnx4008_dma_ll *ll;
+        u32 ll_dma;
+        int flags;
+        void *alloc_data;
+        int (*free) (void *);
+};
+
+extern struct pnx4008_dma_ll *pnx4008_alloc_ll_entry(dma_addr_t *);
+extern void pnx4008_free_ll_entry(struct pnx4008_dma_ll *, dma_addr_t);
+extern void pnx4008_free_ll(u32 ll_dma, struct pnx4008_dma_ll *);
+
+extern int pnx4008_request_channel(char *, int,
+                                   void (*)(int, int, void *, struct pt_regs *),
+                                   void *);
+extern void pnx4008_free_channel(int);
+extern int pnx4008_config_dma(int, int, int);
+extern int pnx4008_dma_pack_control(const struct pnx4008_dma_ch_ctrl *,
+                                    unsigned long *);
+extern int pnx4008_dma_parse_control(unsigned long,
+                                     struct pnx4008_dma_ch_ctrl *);
+extern int pnx4008_dma_pack_config(const struct pnx4008_dma_ch_config *,
+                                   unsigned long *);
+extern int pnx4008_dma_parse_config(unsigned long,
+                                    struct pnx4008_dma_ch_config *);
+extern int pnx4008_config_channel(int, struct pnx4008_dma_config *);
+extern int pnx4008_channel_get_config(int, struct pnx4008_dma_config *);
+extern int pnx4008_dma_ch_enable(int);
+extern int pnx4008_dma_ch_disable(int);
+extern int pnx4008_dma_ch_enabled(int);
+extern void pnx4008_dma_split_head_entry(struct pnx4008_dma_config *,
+                                         struct pnx4008_dma_ch_ctrl *);
+extern void pnx4008_dma_split_ll_entry(struct pnx4008_dma_ll *,
+                                       struct pnx4008_dma_ch_ctrl *);
+
+#endif                          /* _ASM_ARCH_DMA_H */
diff --git a/include/asm-arm/arch-pnx4008/entry-macro.S b/include/asm-arm/arch-pnx4008/entry-macro.S
new file mode 100644
index 000000000000..c1c198e3680b
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/entry-macro.S
@@ -0,0 +1,121 @@
+/*
+ * include/asm-arm/arch-pnx4008/entry-macro.S
+ *
+ * Low-level IRQ helper macros for PNX4008-based platforms
+ *
+ * 2005-2006 (c) MontaVista Software, Inc.
+ * Author: Vitaly Wool <vwool@ru.mvista.com>
+ * This file is licensed under  the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include "platform.h"
+
+#define IO_BASE         0xF0000000
+#define IO_ADDRESS(x)  (((((x) & 0xff000000) >> 4) | ((x) & 0xfffff)) | IO_BASE)
+
+#define INTRC_MASK                      0x00
+#define INTRC_RAW_STAT                  0x04
+#define INTRC_STAT                      0x08
+#define INTRC_POLAR                     0x0C
+#define INTRC_ACT_TYPE                  0x10
+#define INTRC_TYPE                      0x14
+
+#define SIC1_BASE_INT   32
+#define SIC2_BASE_INT   64
+
+                .macro  disable_fiq
+                .endm
+
+                .macro  get_irqnr_and_base, irqnr, irqstat, base, tmp
+/* decode the MIC interrupt numbers */
+                ldr     \base, =IO_ADDRESS(PNX4008_INTCTRLMIC_BASE)
+                ldr     \irqstat, [\base, #INTRC_STAT]
+
+                cmp     \irqstat,#1<<16
+                movhs   \irqnr,#16
+                movlo   \irqnr,#0
+                movhs   \irqstat,\irqstat,lsr#16
+                cmp     \irqstat,#1<<8
+                addhs   \irqnr,\irqnr,#8
+                movhs   \irqstat,\irqstat,lsr#8
+                cmp     \irqstat,#1<<4
+                addhs   \irqnr,\irqnr,#4
+                movhs   \irqstat,\irqstat,lsr#4
+                cmp     \irqstat,#1<<2
+                addhs   \irqnr,\irqnr,#2
+                movhs   \irqstat,\irqstat,lsr#2
+                cmp     \irqstat,#1<<1
+                addhs   \irqnr,\irqnr,#1
+
+/* was there an interrupt ? if not then drop out with EQ status */
+                teq     \irqstat,#0
+                beq     1003f
+
+/* and now check for extended IRQ reasons */
+                cmp     \irqnr,#1
+                bls     1003f
+                cmp     \irqnr,#30
+                blo     1002f
+
+/* IRQ 31,30  : High priority cascade IRQ handle */
+/* read the correct SIC */
+/* decoding status after compare : eq is 30 (SIC1) , ne is 31 (SIC2) */
+/* set the base IRQ number */
+                ldreq   \base, =IO_ADDRESS(PNX4008_INTCTRLSIC1_BASE)
+                moveq  \irqnr,#SIC1_BASE_INT
+                ldrne   \base, =IO_ADDRESS(PNX4008_INTCTRLSIC2_BASE)
+                movne   \irqnr,#SIC2_BASE_INT
+                ldr     \irqstat, [\base, #INTRC_STAT]
+                ldr     \tmp,     [\base, #INTRC_TYPE]
+/* and with inverted mask : low priority interrupts  */
+                and     \irqstat,\irqstat,\tmp
+                b       1004f
+
+1003:
+/* IRQ 1,0  : Low priority cascade IRQ handle */
+/* read the correct SIC */
+/* decoding status after compare : eq is 1 (SIC2) , ne is 0 (SIC1)*/
+/* read the correct SIC */
+/* set the base IRQ number  */
+                ldrne   \base, =IO_ADDRESS(PNX4008_INTCTRLSIC1_BASE)
+                movne   \irqnr,#SIC1_BASE_INT
+                ldreq   \base, =IO_ADDRESS(PNX4008_INTCTRLSIC2_BASE)
+                moveq   \irqnr,#SIC2_BASE_INT
+                ldr     \irqstat, [\base, #INTRC_STAT]
+                ldr     \tmp,     [\base, #INTRC_TYPE]
+/* and with inverted mask : low priority interrupts  */
+                bic     \irqstat,\irqstat,\tmp
+
+1004:
+
+                cmp     \irqstat,#1<<16
+                addhs   \irqnr,\irqnr,#16
+                movhs   \irqstat,\irqstat,lsr#16
+                cmp     \irqstat,#1<<8
+                addhs   \irqnr,\irqnr,#8
+                movhs   \irqstat,\irqstat,lsr#8
+                cmp     \irqstat,#1<<4
+                addhs   \irqnr,\irqnr,#4
+                movhs   \irqstat,\irqstat,lsr#4
+                cmp     \irqstat,#1<<2
+                addhs   \irqnr,\irqnr,#2
+                movhs   \irqstat,\irqstat,lsr#2
+                cmp     \irqstat,#1<<1
+                addhs   \irqnr,\irqnr,#1
+
+
+/* is irqstat not zero */
+
+1002:
+/* we assert that irqstat is not equal to zero and return ne status if true*/
+                teq     \irqstat,#0
+1003:
+                .endm
+
+
+                .macro  irq_prio_table
+                .endm
+
+
diff --git a/include/asm-arm/arch-pnx4008/gpio.h b/include/asm-arm/arch-pnx4008/gpio.h
new file mode 100644
index 000000000000..1fa5a77c3010
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/gpio.h
@@ -0,0 +1,139 @@
+/*
+ * include/asm-arm/arch-pnx4008/gpio.h
+ *
+ * PNX4008 GPIO driver - header file
+ *
+ * Author: Dmitry Chigirev <source@mvista.com>
+ *
+ * Based on reference code by Iwo Mergler and Z.Tabaaloute from Philips:
+ * Copyright (c) 2005 Koninklijke Philips Electronics N.V.
+ *
+ * 2005 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+#ifndef _PNX4008_GPIO_H_
+#define _PNX4008_GPIO_H_
+
+
+/* Block numbers */
+#define GPIO_IN         (0)
+#define GPIO_OUT                (0x100)
+#define GPIO_BID                (0x200)
+#define GPIO_RAM                (0x300)
+#define GPIO_MUX                (0x400)
+
+#define GPIO_TYPE_MASK(K) ((K) & 0x700)
+
+/* INPUT GPIOs */
+/* GPI */
+#define GPI_00          (GPIO_IN | 0)
+#define GPI_01          (GPIO_IN | 1)
+#define GPI_02          (GPIO_IN | 2)
+#define GPI_03          (GPIO_IN | 3)
+#define GPI_04          (GPIO_IN | 4)
+#define GPI_05          (GPIO_IN | 5)
+#define GPI_06          (GPIO_IN | 6)
+#define GPI_07          (GPIO_IN | 7)
+#define GPI_08          (GPIO_IN | 8)
+#define GPI_09          (GPIO_IN | 9)
+#define U1_RX           (GPIO_IN | 15)
+#define U2_HTCS         (GPIO_IN | 16)
+#define U2_RX           (GPIO_IN | 17)
+#define U3_RX           (GPIO_IN | 18)
+#define U4_RX           (GPIO_IN | 19)
+#define U5_RX           (GPIO_IN | 20)
+#define U6_IRRX         (GPIO_IN | 21)
+#define U7_HCTS         (GPIO_IN | 22)
+#define U7_RX           (GPIO_IN | 23)
+/* MISC IN */
+#define SPI1_DATIN      (GPIO_IN | 25)
+#define DISP_SYNC       (GPIO_IN | 26)
+#define SPI2_DATIN      (GPIO_IN | 27)
+#define GPI_11          (GPIO_IN | 28)
+
+#define GPIO_IN_MASK   0x1eff83ff
+
+/* OUTPUT GPIOs */
+/* GPO */
+#define GPO_00          (GPIO_OUT | 0)
+#define GPO_01          (GPIO_OUT | 1)
+#define GPO_02          (GPIO_OUT | 2)
+#define GPO_03          (GPIO_OUT | 3)
+#define GPO_04          (GPIO_OUT | 4)
+#define GPO_05          (GPIO_OUT | 5)
+#define GPO_06          (GPIO_OUT | 6)
+#define GPO_07          (GPIO_OUT | 7)
+#define GPO_08          (GPIO_OUT | 8)
+#define GPO_09          (GPIO_OUT | 9)
+#define GPO_10          (GPIO_OUT | 10)
+#define GPO_11          (GPIO_OUT | 11)
+#define GPO_12          (GPIO_OUT | 12)
+#define GPO_13          (GPIO_OUT | 13)
+#define GPO_14          (GPIO_OUT | 14)
+#define GPO_15          (GPIO_OUT | 15)
+#define GPO_16          (GPIO_OUT | 16)
+#define GPO_17          (GPIO_OUT | 17)
+#define GPO_18          (GPIO_OUT | 18)
+#define GPO_19          (GPIO_OUT | 19)
+#define GPO_20          (GPIO_OUT | 20)
+#define GPO_21          (GPIO_OUT | 21)
+#define GPO_22          (GPIO_OUT | 22)
+#define GPO_23          (GPIO_OUT | 23)
+
+#define GPIO_OUT_MASK   0xffffff
+
+/* BIDIRECTIONAL GPIOs */
+/* RAM pins */
+#define RAM_D19         (GPIO_RAM | 0)
+#define RAM_D20         (GPIO_RAM | 1)
+#define RAM_D21         (GPIO_RAM | 2)
+#define RAM_D22         (GPIO_RAM | 3)
+#define RAM_D23         (GPIO_RAM | 4)
+#define RAM_D24         (GPIO_RAM | 5)
+#define RAM_D25         (GPIO_RAM | 6)
+#define RAM_D26         (GPIO_RAM | 7)
+#define RAM_D27         (GPIO_RAM | 8)
+#define RAM_D28         (GPIO_RAM | 9)
+#define RAM_D29         (GPIO_RAM | 10)
+#define RAM_D30         (GPIO_RAM | 11)
+#define RAM_D31         (GPIO_RAM | 12)
+
+#define GPIO_RAM_MASK   0x1fff
+
+/* I/O pins */
+#define GPIO_00         (GPIO_BID | 25)
+#define GPIO_01         (GPIO_BID | 26)
+#define GPIO_02         (GPIO_BID | 27)
+#define GPIO_03         (GPIO_BID | 28)
+#define GPIO_04         (GPIO_BID | 29)
+#define GPIO_05         (GPIO_BID | 30)
+
+#define GPIO_BID_MASK   0x7e000000
+
+/* Non-GPIO multiplexed PIOs. For multiplexing with GPIO, please use GPIO macros */
+#define GPIO_SDRAM_SEL  (GPIO_MUX | 3)
+
+#define GPIO_MUX_MASK   0x8
+
+/* Extraction/assembly macros */
+#define GPIO_BIT_MASK(K) ((K) & 0x1F)
+#define GPIO_BIT(K) (1 << GPIO_BIT_MASK(K))
+#define GPIO_ISMUX(K) ((GPIO_TYPE_MASK(K) == GPIO_MUX) && (GPIO_BIT(K) & GPIO_MUX_MASK))
+#define GPIO_ISRAM(K) ((GPIO_TYPE_MASK(K) == GPIO_RAM) && (GPIO_BIT(K) & GPIO_RAM_MASK))
+#define GPIO_ISBID(K) ((GPIO_TYPE_MASK(K) == GPIO_BID) && (GPIO_BIT(K) & GPIO_BID_MASK))
+#define GPIO_ISOUT(K) ((GPIO_TYPE_MASK(K) == GPIO_OUT) && (GPIO_BIT(K) & GPIO_OUT_MASK))
+#define GPIO_ISIN(K)  ((GPIO_TYPE_MASK(K) == GPIO_IN) && (GPIO_BIT(K) & GPIO_IN_MASK))
+
+extern int pnx4008_gpio_register_pin(unsigned short pin);
+extern int pnx4008_gpio_unregister_pin(unsigned short pin);
+extern unsigned long pnx4008_gpio_read_pin(unsigned short pin);
+extern int pnx4008_gpio_write_pin(unsigned short pin, int output);
+extern int pnx4008_gpio_set_pin_direction(unsigned short pin, int output);
+extern int pnx4008_gpio_read_pin_direction(unsigned short pin);
+extern int pnx4008_gpio_set_pin_mux(unsigned short pin, int output);
+extern int pnx4008_gpio_read_pin_mux(unsigned short pin);
+
+#endif                          /* _PNX4008_GPIO_H_ */
diff --git a/include/asm-arm/arch-pnx4008/hardware.h b/include/asm-arm/arch-pnx4008/hardware.h
new file mode 100644
index 000000000000..a4410397a921
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/hardware.h
@@ -0,0 +1,32 @@
+/*
+ * linux/include/asm-arm/arch-pnx4008/hardware.h
+ *
+ * Copyright (c) 2005 MontaVista Software, Inc. <source@mvista.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#ifndef __ASM_ARCH_HARDWARE_H
+#define __ASM_ARCH_HARDWARE_H
+
+#include <asm/sizes.h>
+#include <asm/arch/platform.h>
+
+/* Start of virtual addresses for IO devices */
+#define IO_BASE         0xF0000000
+
+/* This macro relies on fact that for all HW i/o addresses bits 20-23 are 0 */
+#define IO_ADDRESS(x)  (((((x) & 0xff000000) >> 4) | ((x) & 0xfffff)) | IO_BASE)
+
+#endif
diff --git a/include/asm-arm/arch-pnx4008/io.h b/include/asm-arm/arch-pnx4008/io.h
new file mode 100644
index 000000000000..29ee43955c52
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/io.h
@@ -0,0 +1,21 @@
+
+/*
+ *  include/asm-arm/arch-pnx4008/io.h
+ *
+ * Author: Dmitry Chigirev <chigirev@ru.mvista.com>
+ *
+ * 2005 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+#ifndef __ASM_ARM_ARCH_IO_H
+#define __ASM_ARM_ARCH_IO_H
+
+#define IO_SPACE_LIMIT 0xffffffff
+
+#define __io(a)                 ((void __iomem *)(a))
+#define __mem_pci(a)            (a)
+
+#endif
diff --git a/include/asm-arm/arch-pnx4008/irq.h b/include/asm-arm/arch-pnx4008/irq.h
new file mode 100644
index 000000000000..fabff5dc337f
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/irq.h
@@ -0,0 +1,42 @@
+/*
+ * include/asm-arm/arch-pnx4008/irq.h
+ *
+ * PNX4008 IRQ controller driver - header file
+ * this one is used in entry-arnv.S as well so it cannot contain C code
+ *
+ * Copyright (c) 2005 Philips Semiconductors
+ * Copyright (c) 2005 MontaVista Software, Inc.
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+#ifndef __PNX4008_IRQ_H__
+#define __PNX4008_IRQ_H__
+
+#define MIC_VA_BASE             IO_ADDRESS(PNX4008_INTCTRLMIC_BASE)
+#define SIC1_VA_BASE            IO_ADDRESS(PNX4008_INTCTRLSIC1_BASE)
+#define SIC2_VA_BASE            IO_ADDRESS(PNX4008_INTCTRLSIC2_BASE)
+
+/* Manual: Chapter 20, page 195 */
+
+#define INTC_BIT(irq) (1<< ((irq) & 0x1F))
+
+#define INTC_ER(irq)    IO_ADDRESS((PNX4008_INTCTRLMIC_BASE + 0x0 + (((irq)&(0x3<<5))<<9)))
+#define INTC_RSR(irq)   IO_ADDRESS((PNX4008_INTCTRLMIC_BASE + 0x4 + (((irq)&(0x3<<5))<<9)))
+#define INTC_SR(irq)    IO_ADDRESS((PNX4008_INTCTRLMIC_BASE + 0x8 + (((irq)&(0x3<<5))<<9)))
+#define INTC_APR(irq)   IO_ADDRESS((PNX4008_INTCTRLMIC_BASE + 0xC + (((irq)&(0x3<<5))<<9)))
+#define INTC_ATR(irq)   IO_ADDRESS((PNX4008_INTCTRLMIC_BASE + 0x10 + (((irq)&(0x3<<5))<<9)))
+#define INTC_ITR(irq)   IO_ADDRESS((PNX4008_INTCTRLMIC_BASE + 0x14 + (((irq)&(0x3<<5))<<9)))
+
+#define START_INT_REG_BIT(irq) (1<<((irq)&0x1F))
+
+#define START_INT_ER_REG(irq)     IO_ADDRESS((PNX4008_PWRMAN_BASE + 0x20 + (((irq)&(0x1<<5))>>1)))
+#define START_INT_RSR_REG(irq)    IO_ADDRESS((PNX4008_PWRMAN_BASE + 0x24 + (((irq)&(0x1<<5))>>1)))
+#define START_INT_SR_REG(irq)     IO_ADDRESS((PNX4008_PWRMAN_BASE + 0x28 + (((irq)&(0x1<<5))>>1)))
+#define START_INT_APR_REG(irq)    IO_ADDRESS((PNX4008_PWRMAN_BASE + 0x2C + (((irq)&(0x1<<5))>>1)))
+
+extern void __init pnx4008_init_irq(void);
+
+#endif /* __PNX4008_IRQ_H__ */
diff --git a/include/asm-arm/arch-pnx4008/irqs.h b/include/asm-arm/arch-pnx4008/irqs.h
new file mode 100644
index 000000000000..13ec7ed0f501
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/irqs.h
@@ -0,0 +1,215 @@
+/*
+ * include/asm-arm/arch-pnx4008/irqs.h
+ *
+ * PNX4008 IRQ controller driver - header file
+ *
+ * Author: Dmitry Chigirev <source@mvista.com>
+ *
+ * 2005 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+#ifndef __PNX4008_IRQS_h__
+#define __PNX4008_IRQS_h__
+
+#define NR_IRQS         96
+
+/*Manual: table 259, page 199*/
+
+/*SUB2 Interrupt Routing (SIC2)*/
+
+#define SIC2_BASE_INT   64
+
+#define CLK_SWITCH_ARM_INT 95   /*manual: Clkswitch ARM  */
+#define CLK_SWITCH_DSP_INT 94   /*manual: ClkSwitch DSP  */
+#define CLK_SWITCH_AUD_INT 93   /*manual: Clkswitch AUD  */
+#define GPI_06_INT         92
+#define GPI_05_INT         91
+#define GPI_04_INT         90
+#define GPI_03_INT         89
+#define GPI_02_INT         88
+#define GPI_01_INT         87
+#define GPI_00_INT         86
+#define BT_CLKREQ_INT      85
+#define SPI1_DATIN_INT     84
+#define U5_RX_INT          83
+#define SDIO_INT_N         82
+#define CAM_HS_INT         81
+#define CAM_VS_INT         80
+#define GPI_07_INT         79
+#define DISP_SYNC_INT      78
+#define DSP_INT8           77
+#define U7_HCTS_INT        76
+#define GPI_10_INT         75
+#define GPI_09_INT         74
+#define GPI_08_INT         73
+#define DSP_INT7           72
+#define U2_HCTS_INT        71
+#define SPI2_DATIN_INT     70
+#define GPIO_05_INT        69
+#define GPIO_04_INT        68
+#define GPIO_03_INT        67
+#define GPIO_02_INT        66
+#define GPIO_01_INT        65
+#define GPIO_00_INT        64
+
+/*Manual: table 258, page 198*/
+
+/*SUB1 Interrupt Routing (SIC1)*/
+
+#define SIC1_BASE_INT   32
+
+#define USB_I2C_INT        63
+#define USB_DEV_HP_INT     62
+#define USB_DEV_LP_INT     61
+#define USB_DEV_DMA_INT    60
+#define USB_HOST_INT       59
+#define USB_OTG_ATX_INT_N  58
+#define USB_OTG_TIMER_INT  57
+#define SW_INT             56
+#define SPI1_INT           55
+#define KEY_IRQ            54
+#define DSP_M_INT          53
+#define RTC_INT            52
+#define I2C_1_INT          51
+#define I2C_2_INT          50
+#define PLL1_LOCK_INT      49
+#define PLL2_LOCK_INT      48
+#define PLL3_LOCK_INT      47
+#define PLL4_LOCK_INT      46
+#define PLL5_LOCK_INT      45
+#define SPI2_INT           44
+#define DSP_INT1           43
+#define DSP_INT2           42
+#define DSP_TDM_INT2       41
+#define TS_AUX_INT         40
+#define TS_IRQ             39
+#define TS_P_INT           38
+#define UOUT1_TO_PAD_INT   37
+#define GPI_11_INT         36
+#define DSP_INT4           35
+#define JTAG_COMM_RX_INT   34
+#define JTAG_COMM_TX_INT   33
+#define DSP_INT3           32
+
+/*Manual: table 257, page 197*/
+
+/*MAIN Interrupt Routing*/
+
+#define MAIN_BASE_INT   0
+
+#define SUB2_FIQ_N         31   /*active low */
+#define SUB1_FIQ_N         30   /*active low */
+#define JPEG_INT           29
+#define DMA_INT            28
+#define MSTIMER_INT        27
+#define IIR1_INT           26
+#define IIR2_INT           25
+#define IIR7_INT           24
+#define DSP_TDM_INT0       23
+#define DSP_TDM_INT1       22
+#define DSP_P_INT          21
+#define DSP_INT0           20
+#define DUM_INT            19
+#define UOUT0_TO_PAD_INT   18
+#define MP4_ENC_INT        17
+#define MP4_DEC_INT        16
+#define SD0_INT            15
+#define MBX_INT            14
+#define SD1_INT            13
+#define MS_INT_N           12
+#define FLASH_INT          11 /*NAND*/
+#define IIR6_INT           10
+#define IIR5_INT           9
+#define IIR4_INT           8
+#define IIR3_INT           7
+#define WATCH_INT          6
+#define HSTIMER_INT        5
+#define ARCH_TIMER_IRQ     HSTIMER_INT
+#define CAM_INT            4
+#define PRNG_INT           3
+#define CRYPTO_INT         2
+#define SUB2_IRQ_N         1    /*active low */
+#define SUB1_IRQ_N         0    /*active low */
+
+#define PNX4008_IRQ_TYPES \
+{                                           /*IRQ #'s: */         \
+IRQT_LOW,  IRQT_LOW,  IRQT_LOW,  IRQT_HIGH, /*  0, 1, 2, 3 */     \
+IRQT_LOW,  IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /*  4, 5, 6, 7 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /*  8, 9,10,11 */     \
+IRQT_LOW,  IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 12,13,14,15 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 16,17,18,19 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 20,21,22,23 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 24,25,26,27 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_LOW,  IRQT_LOW,  /* 28,29,30,31 */     \
+IRQT_HIGH, IRQT_LOW,  IRQT_HIGH, IRQT_HIGH, /* 32,33,34,35 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_FALLING, IRQT_HIGH, /* 36,37,38,39 */  \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 40,41,42,43 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 44,45,46,47 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_LOW,  IRQT_LOW,  /* 48,49,50,51 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 52,53,54,55 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_LOW,  IRQT_HIGH, /* 56,57,58,59 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 60,61,62,63 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 64,65,66,67 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 68,69,70,71 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 72,73,74,75 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 76,77,78,79 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 80,81,82,83 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 84,85,86,87 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 88,89,90,91 */     \
+IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, IRQT_HIGH, /* 92,93,94,95 */     \
+}
+
+/* Start Enable Pin Interrupts - table 58 page 66 */
+
+#define SE_PIN_BASE_INT   32
+
+#define SE_U7_RX_INT            63
+#define SE_U7_HCTS_INT          62
+#define SE_BT_CLKREQ_INT        61
+#define SE_U6_IRRX_INT          60
+/*59 unused*/
+#define SE_U5_RX_INT            58
+#define SE_GPI_11_INT           57
+#define SE_U3_RX_INT            56
+#define SE_U2_HCTS_INT          55
+#define SE_U2_RX_INT            54
+#define SE_U1_RX_INT            53
+#define SE_DISP_SYNC_INT        52
+/*51 unused*/
+#define SE_SDIO_INT_N           50
+#define SE_MSDIO_START_INT      49
+#define SE_GPI_06_INT           48
+#define SE_GPI_05_INT           47
+#define SE_GPI_04_INT           46
+#define SE_GPI_03_INT           45
+#define SE_GPI_02_INT           44
+#define SE_GPI_01_INT           43
+#define SE_GPI_00_INT           42
+#define SE_SYSCLKEN_PIN_INT     41
+#define SE_SPI1_DATAIN_INT      40
+#define SE_GPI_07_INT           39
+#define SE_SPI2_DATAIN_INT      38
+#define SE_GPI_10_INT           37
+#define SE_GPI_09_INT           36
+#define SE_GPI_08_INT           35
+/*34-32 unused*/
+
+/* Start Enable Internal Interrupts - table 57 page 65 */
+
+#define SE_INT_BASE_INT   0
+
+#define SE_TS_IRQ               31
+#define SE_TS_P_INT             30
+#define SE_TS_AUX_INT           29
+/*27-28 unused*/
+#define SE_USB_AHB_NEED_CLK_INT 26
+#define SE_MSTIMER_INT          25
+#define SE_RTC_INT              24
+#define SE_USB_NEED_CLK_INT     23
+#define SE_USB_INT              22
+#define SE_USB_I2C_INT          21
+#define SE_USB_OTG_TIMER_INT    20
+
+#endif /* __PNX4008_IRQS_h__ */
diff --git a/include/asm-arm/arch-pnx4008/memory.h b/include/asm-arm/arch-pnx4008/memory.h
new file mode 100644
index 000000000000..0d8268a95261
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/memory.h
@@ -0,0 +1,24 @@
+/*
+ * linux/include/asm-arm/arch-pnx4008/memory.h
+ *
+ * Copyright (c) 2005 Philips Semiconductors
+ * Copyright (c) 2005 MontaVista Software, Inc.
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#ifndef __ASM_ARCH_MEMORY_H
+#define __ASM_ARCH_MEMORY_H
+
+/*
+ * Physical DRAM offset.
+ */
+#define PHYS_OFFSET     (0x80000000)
+
+#define __virt_to_bus(x) ((x) - PAGE_OFFSET + PHYS_OFFSET)
+#define __bus_to_virt(x) ((x) + PAGE_OFFSET - PHYS_OFFSET)
+
+#endif
diff --git a/include/asm-arm/arch-pnx4008/param.h b/include/asm-arm/arch-pnx4008/param.h
new file mode 100644
index 000000000000..95d5f547b416
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/param.h
@@ -0,0 +1,21 @@
+/*
+ *  linux/include/asm-arm/arch-pnx4008/param.h
+ *
+ *  Copyright (C) 1999 ARM Limited
+ *
+ * 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
+ */
+
+#define HZ 100
diff --git a/include/asm-arm/arch-pnx4008/platform.h b/include/asm-arm/arch-pnx4008/platform.h
new file mode 100644
index 000000000000..485a3651b4d7
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/platform.h
@@ -0,0 +1,69 @@
+/*
+ * include/asm-arm/arch-pnx4008/platfrom.h
+ *
+ * PNX4008 Base addresses - header file
+ *
+ * Author: Dmitry Chigirev <source@mvista.com>
+ *
+ * Based on reference code received from Philips:
+ * Copyright (C) 2003 Philips Semiconductors
+ *
+ * 2005 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+
+#ifndef __ASM_ARCH_PLATFORM_H__
+#define __ASM_ARCH_PLATFORM_H__
+
+#define PNX4008_IRAM_BASE               0x08000000
+#define PNX4008_IRAM_SIZE               0x00010000
+#define PNX4008_YUV_SLAVE_BASE          0x10000000
+#define PNX4008_DUM_SLAVE_BASE          0x18000000
+#define PNX4008_NDF_FLASH_BASE          0x20020000
+#define PNX4008_SPI1_BASE               0x20088000
+#define PNX4008_SPI2_BASE               0x20090000
+#define PNX4008_SD_CONFIG_BASE          0x20098000
+#define PNX4008_FLASH_DATA              0x200B0000
+#define PNX4008_MLC_FLASH_BASE          0x200B8000
+#define PNX4008_JPEG_CONFIG_BASE        0x300A0000
+#define PNX4008_DMA_CONFIG_BASE         0x31000000
+#define PNX4008_USB_CONFIG_BASE         0x31020000
+#define PNX4008_SDRAM_CFG_BASE          0x31080000
+#define PNX4008_AHB2FAB_BASE            0x40000000
+#define PNX4008_PWRMAN_BASE             0x40004000
+#define PNX4008_INTCTRLMIC_BASE         0x40008000
+#define PNX4008_INTCTRLSIC1_BASE        0x4000C000
+#define PNX4008_INTCTRLSIC2_BASE        0x40010000
+#define PNX4008_HSUART1_BASE            0x40014000
+#define PNX4008_HSUART2_BASE            0x40018000
+#define PNX4008_HSUART7_BASE            0x4001C000
+#define PNX4008_RTC_BASE                0x40024000
+#define PNX4008_PIO_BASE                0x40028000
+#define PNX4008_MSTIMER_BASE            0x40034000
+#define PNX4008_HSTIMER_BASE            0x40038000
+#define PNX4008_WDOG_BASE               0x4003C000
+#define PNX4008_DEBUG_BASE              0x40040000
+#define PNX4008_TOUCH1_BASE             0x40048000
+#define PNX4008_KEYSCAN_BASE            0x40050000
+#define PNX4008_UARTCTRL_BASE           0x40054000
+#define PNX4008_PWM_BASE                0x4005C000
+#define PNX4008_UART3_BASE              0x40080000
+#define PNX4008_UART4_BASE              0x40088000
+#define PNX4008_UART5_BASE              0x40090000
+#define PNX4008_UART6_BASE              0x40098000
+#define PNX4008_I2C1_BASE               0x400A0000
+#define PNX4008_I2C2_BASE               0x400A8000
+#define PNX4008_MAGICGATE_BASE          0x400B0000
+#define PNX4008_DUMCONF_BASE            0x400B8000
+#define PNX4008_DUM_MAINCFG_BASE        0x400BC000
+#define PNX4008_DSP_BASE                0x400C0000
+#define PNX4008_PROFCOUNTER_BASE        0x400C8000
+#define PNX4008_CRYPTO_BASE             0x400D0000
+#define PNX4008_CAMIFCONF_BASE          0x400D8000
+#define PNX4008_YUV2RGB_BASE            0x400E0000
+#define PNX4008_AUDIOCONFIG_BASE        0x400E8000
+
+#endif
diff --git a/include/asm-arm/arch-pnx4008/pm.h b/include/asm-arm/arch-pnx4008/pm.h
new file mode 100644
index 000000000000..c660486670fb
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/pm.h
@@ -0,0 +1,62 @@
+/*
+ * include/asm-arm/arch-pnx4008/pm.h
+ *
+ * PNX4008 Power Management Routiness - header file
+ *
+ * Authors: Vitaly Wool, Dmitry Chigirev <source@mvista.com>
+ *
+ * 2005 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+#ifndef __ASM_ARCH_PNX4008_PM_H
+#define __ASM_ARCH_PNX4008_PM_H
+
+#ifndef __ASSEMBLER__
+#include "irq.h"
+#include "irqs.h"
+#include "clock.h"
+
+extern void pnx4008_pm_idle(void);
+extern void pnx4008_pm_suspend(void);
+extern unsigned int pnx4008_cpu_suspend_sz;
+extern void pnx4008_cpu_suspend(void);
+extern unsigned int pnx4008_cpu_standby_sz;
+extern void pnx4008_cpu_standby(void);
+
+extern int pnx4008_startup_pll(struct clk *);
+extern int pnx4008_shutdown_pll(struct clk *);
+
+static inline void start_int_umask(u8 irq)
+{
+        __raw_writel(__raw_readl(START_INT_ER_REG(irq)) |
+                     START_INT_REG_BIT(irq), START_INT_ER_REG(irq));
+}
+
+static inline void start_int_mask(u8 irq)
+{
+        __raw_writel(__raw_readl(START_INT_ER_REG(irq)) &
+                     ~START_INT_REG_BIT(irq), START_INT_ER_REG(irq));
+}
+
+static inline void start_int_ack(u8 irq)
+{
+        __raw_writel(START_INT_REG_BIT(irq), START_INT_RSR_REG(irq));
+}
+
+static inline void start_int_set_falling_edge(u8 irq)
+{
+        __raw_writel(__raw_readl(START_INT_APR_REG(irq)) &
+                     ~START_INT_REG_BIT(irq), START_INT_APR_REG(irq));
+}
+
+static inline void start_int_set_rising_edge(u8 irq)
+{
+        __raw_writel(__raw_readl(START_INT_APR_REG(irq)) |
+                     START_INT_REG_BIT(irq), START_INT_APR_REG(irq));
+}
+
+#endif                          /* ASSEMBLER */
+#endif                          /* __ASM_ARCH_PNX4008_PM_H */
diff --git a/include/asm-arm/arch-pnx4008/system.h b/include/asm-arm/arch-pnx4008/system.h
new file mode 100644
index 000000000000..6e3da70ab107
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/system.h
@@ -0,0 +1,38 @@
+/*
+ * linux/include/asm-arm/arch-pnx4008/system.h
+ *
+ * Copyright (C) 2003 Philips Semiconductors
+ * Copyright (C) 2005 MontaVista Software, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#ifndef __ASM_ARCH_SYSTEM_H
+#define __ASM_ARCH_SYSTEM_H
+
+#include <asm/hardware.h>
+#include <asm/io.h>
+#include <asm/arch/platform.h>
+
+static void arch_idle(void)
+{
+        cpu_do_idle();
+}
+
+static inline void arch_reset(char mode)
+{
+        cpu_reset(0);
+}
+
+#endif
diff --git a/include/asm-arm/arch-pnx4008/timex.h b/include/asm-arm/arch-pnx4008/timex.h
new file mode 100644
index 000000000000..ee470a39089a
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/timex.h
@@ -0,0 +1,73 @@
+/*
+ * include/asm-arm/arch-pnx4008/timex.h
+ *
+ * PNX4008 timers header file
+ *
+ * Author: Dmitry Chigirev <source@mvista.com>
+ *
+ * 2005 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+#ifndef __PNX4008_TIMEX_H
+#define __PNX4008_TIMEX_H
+
+#include <asm/hardware.h>
+#include <asm/io.h>
+
+#define CLOCK_TICK_RATE         1000000
+
+#define TICKS2USECS(x)  (x)
+
+/* MilliSecond Timer - Chapter 21 Page 202 */
+
+#define MSTIM_INT     IO_ADDRESS((PNX4008_MSTIMER_BASE + 0x0))
+#define MSTIM_CTRL    IO_ADDRESS((PNX4008_MSTIMER_BASE + 0x4))
+#define MSTIM_COUNTER IO_ADDRESS((PNX4008_MSTIMER_BASE + 0x8))
+#define MSTIM_MCTRL   IO_ADDRESS((PNX4008_MSTIMER_BASE + 0x14))
+#define MSTIM_MATCH0  IO_ADDRESS((PNX4008_MSTIMER_BASE + 0x18))
+#define MSTIM_MATCH1  IO_ADDRESS((PNX4008_MSTIMER_BASE + 0x1c))
+
+/* High Speed Timer - Chpater 22, Page 205 */
+
+#define HSTIM_INT     IO_ADDRESS((PNX4008_HSTIMER_BASE + 0x0))
+#define HSTIM_CTRL    IO_ADDRESS((PNX4008_HSTIMER_BASE + 0x4))
+#define HSTIM_COUNTER IO_ADDRESS((PNX4008_HSTIMER_BASE + 0x8))
+#define HSTIM_PMATCH  IO_ADDRESS((PNX4008_HSTIMER_BASE + 0xC))
+#define HSTIM_PCOUNT  IO_ADDRESS((PNX4008_HSTIMER_BASE + 0x10))
+#define HSTIM_MCTRL   IO_ADDRESS((PNX4008_HSTIMER_BASE + 0x14))
+#define HSTIM_MATCH0  IO_ADDRESS((PNX4008_HSTIMER_BASE + 0x18))
+#define HSTIM_MATCH1  IO_ADDRESS((PNX4008_HSTIMER_BASE + 0x1c))
+#define HSTIM_MATCH2  IO_ADDRESS((PNX4008_HSTIMER_BASE + 0x20))
+#define HSTIM_CCR     IO_ADDRESS((PNX4008_HSTIMER_BASE + 0x28))
+#define HSTIM_CR0     IO_ADDRESS((PNX4008_HSTIMER_BASE + 0x2C))
+#define HSTIM_CR1     IO_ADDRESS((PNX4008_HSTIMER_BASE + 0x30))
+
+/* IMPORTANT: both timers are UPCOUNTING */
+
+/* xSTIM_MCTRL bit definitions */
+#define MR0_INT        1
+#define RESET_COUNT0   (1<<1)
+#define STOP_COUNT0    (1<<2)
+#define MR1_INT        (1<<3)
+#define RESET_COUNT1   (1<<4)
+#define STOP_COUNT1    (1<<5)
+#define MR2_INT        (1<<6)
+#define RESET_COUNT2   (1<<7)
+#define STOP_COUNT2    (1<<8)
+
+/* xSTIM_CTRL bit definitions */
+#define COUNT_ENAB     1
+#define RESET_COUNT    (1<<1)
+#define DEBUG_EN       (1<<2)
+
+/* xSTIM_INT bit definitions */
+#define MATCH0_INT     1
+#define MATCH1_INT     (1<<1)
+#define MATCH2_INT     (1<<2)
+#define RTC_TICK0      (1<<4)
+#define RTC_TICK1      (1<<5)
+
+#endif
diff --git a/include/asm-arm/arch-pnx4008/uncompress.h b/include/asm-arm/arch-pnx4008/uncompress.h
new file mode 100644
index 000000000000..8fa4d24b72b4
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/uncompress.h
@@ -0,0 +1,46 @@
+/*
+ *  linux/include/asm-arm/arch-pnx4008/uncompress.h
+ *
+ *  Copyright (C) 1999 ARM Limited
+ *  Copyright (C) 2006 MontaVista Software, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define UART5_BASE 0x40090000
+
+#define UART5_DR    (*(volatile unsigned char *) (UART5_BASE))
+#define UART5_FR    (*(volatile unsigned char *) (UART5_BASE + 18))
+
+static __inline__ void putc(char c)
+{
+        while (UART5_FR & (1 << 5))
+                barrier();
+
+        UART5_DR = c;
+}
+
+/*
+ * This does not append a newline
+ */
+static inline void flush(void)
+{
+}
+
+/*
+ * nothing to do
+ */
+#define arch_decomp_setup()
+#define arch_decomp_wdog()
diff --git a/include/asm-arm/arch-pnx4008/vmalloc.h b/include/asm-arm/arch-pnx4008/vmalloc.h
new file mode 100644
index 000000000000..140d925f6f37
--- /dev/null
+++ b/include/asm-arm/arch-pnx4008/vmalloc.h
@@ -0,0 +1,20 @@
+/*
+ * include/asm-arm/arch-pnx4008/vmalloc.h
+ *
+ * Author: Vitaly Wool <source@mvista.com>
+ *
+ * 2006 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+/*
+ * Just any arbitrary offset to the start of the vmalloc VM area: the
+ * current 8MB value just means that there will be a 8MB "hole" after the
+ * physical memory until the kernel virtual memory starts.  That means that
+ * any out-of-bounds memory accesses will hopefully be caught.
+ * The vmalloc() routines leaves a hole of 4kB between each vmalloced
+ * area for the same reason. ;)
+ */
+#define VMALLOC_END       (PAGE_OFFSET + 0x10000000)
diff --git a/include/asm-arm/arch-pxa/idp.h b/include/asm-arm/arch-pxa/idp.h
index e7ef497417bb..b6952534a4e1 100644
--- a/include/asm-arm/arch-pxa/idp.h
+++ b/include/asm-arm/arch-pxa/idp.h
@@ -15,7 +15,6 @@
  *             Changes for 2.6 kernel.
  */
 
-#include <linux/config.h>
 
 /*
  * Note: this file must be safe to include in assembly files
diff --git a/include/asm-arm/arch-pxa/irqs.h b/include/asm-arm/arch-pxa/irqs.h
index 67af238a8f8e..f3bc70eee35b 100644
--- a/include/asm-arm/arch-pxa/irqs.h
+++ b/include/asm-arm/arch-pxa/irqs.h
@@ -10,7 +10,6 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/config.h>
 
 #ifdef CONFIG_PXA27x
 #define PXA_IRQ_SKIP    0
diff --git a/include/asm-arm/arch-pxa/pxa-regs.h b/include/asm-arm/arch-pxa/pxa-regs.h
index c8f53a71c076..6650d4decaeb 100644
--- a/include/asm-arm/arch-pxa/pxa-regs.h
+++ b/include/asm-arm/arch-pxa/pxa-regs.h
@@ -13,7 +13,6 @@
 #ifndef __PXA_REGS_H
 #define __PXA_REGS_H
 
-#include <linux/config.h>
 
 /*
  * PXA Chip selects
diff --git a/include/asm-arm/arch-pxa/timex.h b/include/asm-arm/arch-pxa/timex.h
index aa125ec56a32..2473bb51d0a6 100644
--- a/include/asm-arm/arch-pxa/timex.h
+++ b/include/asm-arm/arch-pxa/timex.h
@@ -10,7 +10,6 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/config.h>
 
 #if defined(CONFIG_PXA25x)
 /* PXA250/210 timer base */
diff --git a/include/asm-arm/arch-realview/smp.h b/include/asm-arm/arch-realview/smp.h
index fc87783e8e8b..515819efd046 100644
--- a/include/asm-arm/arch-realview/smp.h
+++ b/include/asm-arm/arch-realview/smp.h
@@ -1,7 +1,6 @@
 #ifndef ASMARM_ARCH_SMP_H
 #define ASMARM_ARCH_SMP_H
 
-#include <linux/config.h>
 
 #include <asm/hardware/gic.h>
 
diff --git a/include/asm-arm/arch-s3c2410/dma.h b/include/asm-arm/arch-s3c2410/dma.h
index b011e14f3bc6..72964f9b8414 100644
--- a/include/asm-arm/arch-s3c2410/dma.h
+++ b/include/asm-arm/arch-s3c2410/dma.h
@@ -18,7 +18,6 @@
 #ifndef __ASM_ARCH_DMA_H
 #define __ASM_ARCH_DMA_H __FILE__
 
-#include <linux/config.h>
 #include <linux/sysdev.h>
 #include "hardware.h"
 
diff --git a/include/asm-arm/arch-s3c2410/map.h b/include/asm-arm/arch-s3c2410/map.h
index c380d264a847..5e4c8c37bc66 100644
--- a/include/asm-arm/arch-s3c2410/map.h
+++ b/include/asm-arm/arch-s3c2410/map.h
@@ -126,9 +126,18 @@
 #define S3C24XX_SZ_IIS     SZ_1M
 
 /* GPIO ports */
-#define S3C24XX_VA_GPIO    S3C2410_ADDR(0x00E00000)
+
+/* the calculation for the VA of this must ensure that
+ * it is the same distance apart from the UART in the
+ * phsyical address space, as the initial mapping for the IO
+ * is done as a 1:1 maping. This puts it (currently) at
+ * 0xF6800000, which is not in the way of any current mapping
+ * by the base system.
+*/
+
 #define S3C2400_PA_GPIO    (0x15600000)
 #define S3C2410_PA_GPIO    (0x56000000)
+#define S3C24XX_VA_GPIO    ((S3C2410_PA_GPIO - S3C24XX_PA_UART) + S3C24XX_VA_UART)
 #define S3C24XX_SZ_GPIO    SZ_1M
 
 /* RTC */
diff --git a/include/asm-arm/arch-s3c2410/regs-clock.h b/include/asm-arm/arch-s3c2410/regs-clock.h
index 34360706e016..6c92faffe985 100644
--- a/include/asm-arm/arch-s3c2410/regs-clock.h
+++ b/include/asm-arm/arch-s3c2410/regs-clock.h
@@ -114,7 +114,7 @@ s3c2410_get_pll(unsigned int pllval, unsigned int baseclk)
 
 #endif /* __ASSEMBLY__ */
 
-#ifdef CONFIG_CPU_S3C2440
+#if defined(CONFIG_CPU_S3C2440) || defined(CONFIG_CPU_S3C2442)
 
 /* extra registers */
 #define S3C2440_CAMDIVN     S3C2410_CLKREG(0x18)
@@ -136,7 +136,9 @@ s3c2410_get_pll(unsigned int pllval, unsigned int baseclk)
 #define S3C2440_CAMDIVN_HCLK4_HALF   (1<<9)
 #define S3C2440_CAMDIVN_DVSEN        (1<<12)
 
-#endif /* CONFIG_CPU_S3C2440 */
+#define S3C2442_CAMDIVN_CAMCLK_DIV3  (1<<5)
+
+#endif /* CONFIG_CPU_S3C2440 or CONFIG_CPU_S3C2442 */
 
 
 #endif /* __ASM_ARM_REGS_CLOCK */
diff --git a/include/asm-arm/arch-s3c2410/regs-gpio.h b/include/asm-arm/arch-s3c2410/regs-gpio.h
index d2574084697f..5f10334f06bf 100644
--- a/include/asm-arm/arch-s3c2410/regs-gpio.h
+++ b/include/asm-arm/arch-s3c2410/regs-gpio.h
@@ -450,12 +450,14 @@
 #define S3C2410_GPD0_OUTP       (0x01 << 0)
 #define S3C2410_GPD0_VD8        (0x02 << 0)
 #define S3C2400_GPD0_VFRAME     (0x02 << 0)
+#define S3C2442_GPD0_nSPICS1    (0x03 << 0)
 
 #define S3C2410_GPD1            S3C2410_GPIONO(S3C2410_GPIO_BANKD, 1)
 #define S3C2410_GPD1_INP        (0x00 << 2)
 #define S3C2410_GPD1_OUTP       (0x01 << 2)
 #define S3C2410_GPD1_VD9        (0x02 << 2)
 #define S3C2400_GPD1_VM         (0x02 << 2)
+#define S3C2442_GPD1_SPICLK1    (0x03 << 2)
 
 #define S3C2410_GPD2            S3C2410_GPIONO(S3C2410_GPIO_BANKD, 2)
 #define S3C2410_GPD2_INP        (0x00 << 4)
@@ -858,6 +860,7 @@
 #define S3C2410_GPG12_OUTP    (0x01 << 24)
 #define S3C2410_GPG12_EINT20  (0x02 << 24)
 #define S3C2410_GPG12_XMON    (0x03 << 24)
+#define S3C2442_GPG12_nSPICS0 (0x03 << 24)
 
 #define S3C2410_GPG13         S3C2410_GPIONO(S3C2410_GPIO_BANKG, 13)
 #define S3C2410_GPG13_INP     (0x00 << 26)
@@ -943,6 +946,7 @@
 #define S3C2410_GPH9_INP      (0x00 << 18)
 #define S3C2410_GPH9_OUTP     (0x01 << 18)
 #define S3C2410_GPH9_CLKOUT0  (0x02 << 18)
+#define S3C2442_GPH9_nSPICS0  (0x03 << 18)
 
 #define S3C2410_GPH10         S3C2410_GPIONO(S3C2410_GPIO_BANKH, 10)
 #define S3C2410_GPH10_INP     (0x00 << 20)
@@ -1051,6 +1055,7 @@
 #define S3C2410_GSTATUS1_IDMASK    (0xffff0000)
 #define S3C2410_GSTATUS1_2410      (0x32410000)
 #define S3C2410_GSTATUS1_2440      (0x32440000)
+#define S3C2410_GSTATUS1_2442      (0x32440aaa)
 
 #define S3C2410_GSTATUS2_WTRESET   (1<<2)
 #define S3C2410_GSTATUS2_OFFRESET  (1<<1)
diff --git a/include/asm-arm/arch-s3c2410/uncompress.h b/include/asm-arm/arch-s3c2410/uncompress.h
index a6f6a0e44afa..8e152a05e533 100644
--- a/include/asm-arm/arch-s3c2410/uncompress.h
+++ b/include/asm-arm/arch-s3c2410/uncompress.h
@@ -22,7 +22,6 @@
 #ifndef __ASM_ARCH_UNCOMPRESS_H
 #define __ASM_ARCH_UNCOMPRESS_H
 
-#include <linux/config.h>
 
 /* defines for UART registers */
 #include "asm/arch/regs-serial.h"
@@ -82,7 +81,8 @@ static void putc(int ch)
                 while (1) {
                         level = uart_rd(S3C2410_UFSTAT);
 
-                        if (cpuid == S3C2410_GSTATUS1_2440) {
+                        if (cpuid == S3C2410_GSTATUS1_2440 ||
+                            cpuid == S3C2410_GSTATUS1_2442) {
                                 level &= S3C2440_UFSTAT_TXMASK;
                                 level >>= S3C2440_UFSTAT_TXSHIFT;
                         } else {
@@ -130,7 +130,7 @@ static void arch_decomp_wdog_start(void)
 {
         __raw_writel(WDOG_COUNT, S3C2410_WTDAT);
         __raw_writel(WDOG_COUNT, S3C2410_WTCNT);
-        __raw_writel(S3C2410_WTCON_ENABLE | S3C2410_WTCON_DIV128 | S3C2410_WTCON_RSTEN | S3C2410_WTCON_PRESCALE(0x40), S3C2410_WTCON);
+        __raw_writel(S3C2410_WTCON_ENABLE | S3C2410_WTCON_DIV128 | S3C2410_WTCON_RSTEN | S3C2410_WTCON_PRESCALE(0x80), S3C2410_WTCON);
 }
 
 #else
diff --git a/include/asm-arm/arch-sa1100/assabet.h b/include/asm-arm/arch-sa1100/assabet.h
index 1f59b368c3f6..d6a1bb5b4944 100644
--- a/include/asm-arm/arch-sa1100/assabet.h
+++ b/include/asm-arm/arch-sa1100/assabet.h
@@ -12,7 +12,6 @@
 #ifndef __ASM_ARCH_ASSABET_H
 #define __ASM_ARCH_ASSABET_H
 
-#include <linux/config.h>
 
 /* System Configuration Register flags */
 
diff --git a/include/asm-arm/arch-sa1100/cerf.h b/include/asm-arm/arch-sa1100/cerf.h
index 356d5ba88991..9a19c3d07c1e 100644
--- a/include/asm-arm/arch-sa1100/cerf.h
+++ b/include/asm-arm/arch-sa1100/cerf.h
@@ -10,7 +10,6 @@
 #ifndef _INCLUDE_CERF_H_
 #define _INCLUDE_CERF_H_
 
-#include <linux/config.h>
 
 #define CERF_ETH_IO                     0xf0000000
 #define CERF_ETH_IRQ IRQ_GPIO26
diff --git a/include/asm-arm/arch-sa1100/collie.h b/include/asm-arm/arch-sa1100/collie.h
index d49e5ff63ca4..14a344aa3cc7 100644
--- a/include/asm-arm/arch-sa1100/collie.h
+++ b/include/asm-arm/arch-sa1100/collie.h
@@ -13,7 +13,6 @@
 #ifndef __ASM_ARCH_COLLIE_H
 #define __ASM_ARCH_COLLIE_H
 
-#include <linux/config.h>
 
 #define COLLIE_SCP_CHARGE_ON    SCOOP_GPCR_PA11
 #define COLLIE_SCP_DIAG_BOOT1   SCOOP_GPCR_PA12
diff --git a/include/asm-arm/arch-sa1100/dma.h b/include/asm-arm/arch-sa1100/dma.h
index 02575d72ac6b..6b7917a2e77a 100644
--- a/include/asm-arm/arch-sa1100/dma.h
+++ b/include/asm-arm/arch-sa1100/dma.h
@@ -10,7 +10,6 @@
 #ifndef __ASM_ARCH_DMA_H
 #define __ASM_ARCH_DMA_H
 
-#include <linux/config.h>
 #include "hardware.h"
 
 
diff --git a/include/asm-arm/arch-sa1100/hardware.h b/include/asm-arm/arch-sa1100/hardware.h
index ee008a5484f3..1abd7cfc8bce 100644
--- a/include/asm-arm/arch-sa1100/hardware.h
+++ b/include/asm-arm/arch-sa1100/hardware.h
@@ -12,7 +12,6 @@
 #ifndef __ASM_ARCH_HARDWARE_H
 #define __ASM_ARCH_HARDWARE_H
 
-#include <linux/config.h>
 
 #define UNCACHEABLE_ADDR        0xfa050000
 
diff --git a/include/asm-arm/arch-sa1100/ide.h b/include/asm-arm/arch-sa1100/ide.h
index 2153538069c7..98b10bcf9f1b 100644
--- a/include/asm-arm/arch-sa1100/ide.h
+++ b/include/asm-arm/arch-sa1100/ide.h
@@ -9,7 +9,6 @@
  *              architectures.
  */
 
-#include <linux/config.h>
 #include <asm/irq.h>
 #include <asm/hardware.h>
 #include <asm/mach-types.h>
diff --git a/include/asm-arm/arch-sa1100/irqs.h b/include/asm-arm/arch-sa1100/irqs.h
index eabd3be3d705..d7940683efb1 100644
--- a/include/asm-arm/arch-sa1100/irqs.h
+++ b/include/asm-arm/arch-sa1100/irqs.h
@@ -7,7 +7,6 @@
  *
  * 2001/11/14   RMK     Cleaned up and standardised a lot of the IRQs.
  */
-#include <linux/config.h>
 
 #define IRQ_GPIO0               0
 #define IRQ_GPIO1               1
diff --git a/include/asm-arm/arch-sa1100/memory.h b/include/asm-arm/arch-sa1100/memory.h
index a29fac1387ca..1ff172dc8e33 100644
--- a/include/asm-arm/arch-sa1100/memory.h
+++ b/include/asm-arm/arch-sa1100/memory.h
@@ -7,7 +7,6 @@
 #ifndef __ASM_ARCH_MEMORY_H
 #define __ASM_ARCH_MEMORY_H
 
-#include <linux/config.h>
 #include <asm/sizes.h>
 
 /*
diff --git a/include/asm-arm/arch-sa1100/system.h b/include/asm-arm/arch-sa1100/system.h
index 0f0612f79b2b..aef91e3b63fe 100644
--- a/include/asm-arm/arch-sa1100/system.h
+++ b/include/asm-arm/arch-sa1100/system.h
@@ -3,7 +3,6 @@
  *
  * Copyright (c) 1999 Nicolas Pitre <nico@cam.org>
  */
-#include <linux/config.h>
 #include <asm/hardware.h>
 
 static inline void arch_idle(void)
diff --git a/include/asm-arm/atomic.h b/include/asm-arm/atomic.h
index 3d7283d84405..4b0ce3e7de9a 100644
--- a/include/asm-arm/atomic.h
+++ b/include/asm-arm/atomic.h
@@ -11,7 +11,6 @@
 #ifndef __ASM_ARM_ATOMIC_H
 #define __ASM_ARM_ATOMIC_H
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 
 typedef struct { volatile int counter; } atomic_t;
diff --git a/include/asm-arm/bug.h b/include/asm-arm/bug.h
index 5ab8216f5204..7fb02138f585 100644
--- a/include/asm-arm/bug.h
+++ b/include/asm-arm/bug.h
@@ -2,7 +2,6 @@
 #define _ASMARM_BUG_H
 
 #include <linux/config.h>
-#include <linux/stddef.h>
 
 #ifdef CONFIG_BUG
 #ifdef CONFIG_DEBUG_BUGVERBOSE
diff --git a/include/asm-arm/cacheflush.h b/include/asm-arm/cacheflush.h
index 746be56b1b70..fe0c744e0266 100644
--- a/include/asm-arm/cacheflush.h
+++ b/include/asm-arm/cacheflush.h
@@ -10,7 +10,6 @@
 #ifndef _ASMARM_CACHEFLUSH_H
 #define _ASMARM_CACHEFLUSH_H
 
-#include <linux/config.h>
 #include <linux/sched.h>
 #include <linux/mm.h>
 
diff --git a/include/asm-arm/cpu.h b/include/asm-arm/cpu.h
index 751bc7462074..715426b9b08e 100644
--- a/include/asm-arm/cpu.h
+++ b/include/asm-arm/cpu.h
@@ -10,7 +10,6 @@
 #ifndef __ASM_ARM_CPU_H
 #define __ASM_ARM_CPU_H
 
-#include <linux/config.h>
 #include <linux/percpu.h>
 
 struct cpuinfo_arm {
diff --git a/include/asm-arm/dma-mapping.h b/include/asm-arm/dma-mapping.h
index 63ca7412a462..55eb4dc3253d 100644
--- a/include/asm-arm/dma-mapping.h
+++ b/include/asm-arm/dma-mapping.h
@@ -3,7 +3,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/mm.h> /* need struct page */
 
 #include <asm/scatterlist.h>
diff --git a/include/asm-arm/dma.h b/include/asm-arm/dma.h
index 49c01e2bf7c8..9f2c5305c260 100644
--- a/include/asm-arm/dma.h
+++ b/include/asm-arm/dma.h
@@ -3,7 +3,6 @@
 
 typedef unsigned int dmach_t;
 
-#include <linux/config.h>
 #include <linux/spinlock.h>
 #include <asm/system.h>
 #include <asm/scatterlist.h>
diff --git a/include/asm-arm/elf.h b/include/asm-arm/elf.h
index 2d44b42d1847..71061ca5c5d0 100644
--- a/include/asm-arm/elf.h
+++ b/include/asm-arm/elf.h
@@ -1,7 +1,6 @@
 #ifndef __ASMARM_ELF_H
 #define __ASMARM_ELF_H
 
-#include <linux/config.h>
 
 /*
  * ELF register definitions..
diff --git a/include/asm-arm/fpstate.h b/include/asm-arm/fpstate.h
index 52bae088a185..132c3c5628b2 100644
--- a/include/asm-arm/fpstate.h
+++ b/include/asm-arm/fpstate.h
@@ -11,7 +11,6 @@
 #ifndef __ASM_ARM_FPSTATE_H
 #define __ASM_ARM_FPSTATE_H
 
-#include <linux/config.h>
 
 #ifndef __ASSEMBLY__
 
diff --git a/include/asm-arm/glue.h b/include/asm-arm/glue.h
index 223e0d6c41be..0cc5d3b10ce2 100644
--- a/include/asm-arm/glue.h
+++ b/include/asm-arm/glue.h
@@ -15,7 +15,6 @@
  */
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #ifdef __STDC__
 #define ____glue(name,fn)       name##fn
diff --git a/include/asm-arm/hardirq.h b/include/asm-arm/hardirq.h
index 1cbb173bf5b1..182310b99195 100644
--- a/include/asm-arm/hardirq.h
+++ b/include/asm-arm/hardirq.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_HARDIRQ_H
 #define __ASM_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/cache.h>
 #include <linux/threads.h>
 #include <asm/irq.h>
diff --git a/include/asm-arm/hardware/dec21285.h b/include/asm-arm/hardware/dec21285.h
index 6685e3fb97b1..546f7077be9c 100644
--- a/include/asm-arm/hardware/dec21285.h
+++ b/include/asm-arm/hardware/dec21285.h
@@ -18,7 +18,6 @@
 #define DC21285_PCI_IO                  0x7c000000
 #define DC21285_PCI_MEM                 0x80000000
 
-#include <linux/config.h>
 #ifndef __ASSEMBLY__
 #include <asm/hardware.h>
 #define DC21285_IO(x)           ((volatile unsigned long *)(ARMCSR_BASE+(x)))
diff --git a/include/asm-arm/hardware/iomd.h b/include/asm-arm/hardware/iomd.h
index 82fa2c279a18..396e55ad06c6 100644
--- a/include/asm-arm/hardware/iomd.h
+++ b/include/asm-arm/hardware/iomd.h
@@ -13,7 +13,6 @@
 #ifndef __ASMARM_HARDWARE_IOMD_H
 #define __ASMARM_HARDWARE_IOMD_H
 
-#include <linux/config.h>
 
 #ifndef __ASSEMBLY__
 
diff --git a/include/asm-arm/leds.h b/include/asm-arm/leds.h
index 88ce4124f854..12290ea55801 100644
--- a/include/asm-arm/leds.h
+++ b/include/asm-arm/leds.h
@@ -13,7 +13,6 @@
 #ifndef ASM_ARM_LEDS_H
 #define ASM_ARM_LEDS_H
 
-#include <linux/config.h>
 
 typedef enum {
         led_idle_start,
diff --git a/include/asm-arm/mach/serial_at91rm9200.h b/include/asm-arm/mach/serial_at91rm9200.h
index 98f4b0cb883c..a0269de12079 100644
--- a/include/asm-arm/mach/serial_at91rm9200.h
+++ b/include/asm-arm/mach/serial_at91rm9200.h
@@ -7,7 +7,6 @@
  *
  *  Low level machine dependent UART functions.
  */
-#include <linux/config.h>
 
 struct uart_port;
 
diff --git a/include/asm-arm/mach/serial_sa1100.h b/include/asm-arm/mach/serial_sa1100.h
index 9162018585df..20c22bb218d9 100644
--- a/include/asm-arm/mach/serial_sa1100.h
+++ b/include/asm-arm/mach/serial_sa1100.h
@@ -7,7 +7,6 @@
  *
  * Low level machine dependent UART functions.
  */
-#include <linux/config.h>
 
 struct uart_port;
 struct uart_info;
diff --git a/include/asm-arm/mach/time.h b/include/asm-arm/mach/time.h
index 96c6db7dd0e1..9f28073559e8 100644
--- a/include/asm-arm/mach/time.h
+++ b/include/asm-arm/mach/time.h
@@ -50,6 +50,7 @@ struct sys_timer {
 #define DYN_TICK_ENABLED        (1 << 1)
 
 struct dyn_tick_timer {
+        spinlock_t      lock;
         unsigned int    state;                  /* Current state */
         int             (*enable)(void);        /* Enables dynamic tick */
         int             (*disable)(void);       /* Disables dynamic tick */
diff --git a/include/asm-arm/memory.h b/include/asm-arm/memory.h
index 209289407595..731e321a57d1 100644
--- a/include/asm-arm/memory.h
+++ b/include/asm-arm/memory.h
@@ -22,7 +22,6 @@
 #define UL(x) (x)
 #endif
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <asm/arch/memory.h>
 #include <asm/sizes.h>
diff --git a/include/asm-arm/page.h b/include/asm-arm/page.h
index a404d2bf0c68..66cfeb5290ea 100644
--- a/include/asm-arm/page.h
+++ b/include/asm-arm/page.h
@@ -10,7 +10,6 @@
 #ifndef _ASMARM_PAGE_H
 #define _ASMARM_PAGE_H
 
-#include <linux/config.h>
 
 /* PAGE_SHIFT determines the page size */
 #define PAGE_SHIFT              12
diff --git a/include/asm-arm/pci.h b/include/asm-arm/pci.h
index ead3ced38cb8..f21abd4ddac6 100644
--- a/include/asm-arm/pci.h
+++ b/include/asm-arm/pci.h
@@ -2,7 +2,6 @@
 #define ASMARM_PCI_H
 
 #ifdef __KERNEL__
-#include <linux/config.h>
 #include <asm-generic/pci-dma-compat.h>
 
 #include <asm/hardware.h> /* for PCIBIOS_MIN_* */
diff --git a/include/asm-arm/proc-fns.h b/include/asm-arm/proc-fns.h
index 106045edb862..e9310895e79d 100644
--- a/include/asm-arm/proc-fns.h
+++ b/include/asm-arm/proc-fns.h
@@ -13,7 +13,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 /*
  * Work out if we need multiple CPU support
diff --git a/include/asm-arm/ptrace.h b/include/asm-arm/ptrace.h
index 77adb7fa169b..2bebe3dc0a30 100644
--- a/include/asm-arm/ptrace.h
+++ b/include/asm-arm/ptrace.h
@@ -10,7 +10,6 @@
 #ifndef __ASM_ARM_PTRACE_H
 #define __ASM_ARM_PTRACE_H
 
-#include <linux/config.h>
 
 #define PTRACE_GETREGS          12
 #define PTRACE_SETREGS          13
diff --git a/include/asm-arm/smp.h b/include/asm-arm/smp.h
index fe45f7f61223..f67acce387e7 100644
--- a/include/asm-arm/smp.h
+++ b/include/asm-arm/smp.h
@@ -10,7 +10,6 @@
 #ifndef __ASM_ARM_SMP_H
 #define __ASM_ARM_SMP_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/cpumask.h>
 #include <linux/thread_info.h>
diff --git a/include/asm-arm/system.h b/include/asm-arm/system.h
index 7c9568d30307..9c744ae6c6e3 100644
--- a/include/asm-arm/system.h
+++ b/include/asm-arm/system.h
@@ -3,7 +3,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #define CPU_ARCH_UNKNOWN        0
 #define CPU_ARCH_ARMv3          1
diff --git a/include/asm-arm/tlbflush.h b/include/asm-arm/tlbflush.h
index 728992451dd1..d97fc76189a5 100644
--- a/include/asm-arm/tlbflush.h
+++ b/include/asm-arm/tlbflush.h
@@ -10,7 +10,6 @@
 #ifndef _ASMARM_TLBFLUSH_H
 #define _ASMARM_TLBFLUSH_H
 
-#include <linux/config.h>
 
 #ifndef CONFIG_MMU
 
diff --git a/include/asm-arm/unistd.h b/include/asm-arm/unistd.h
index cbf39a56dbe7..1e891f860ef3 100644
--- a/include/asm-arm/unistd.h
+++ b/include/asm-arm/unistd.h
@@ -13,8 +13,6 @@
 #ifndef __ASM_ARM_UNISTD_H
 #define __ASM_ARM_UNISTD_H
 
-#include <linux/linkage.h>
-
 #define __NR_OABI_SYSCALL_BASE  0x900000
 
 #if defined(__thumb__) || defined(__ARM_EABI__)
@@ -378,6 +376,9 @@
 #undef __NR_ipc
 #endif
 
+#ifdef __KERNEL__
+#include <linux/linkage.h>
+
 #define __sys2(x) #x
 #define __sys1(x) __sys2(x)
 
@@ -526,7 +527,6 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5, type6 arg6
   __syscall_return(type,__res);                                         \
 }
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_STAT64
 #define __ARCH_WANT_SYS_GETHOSTNAME
@@ -547,7 +547,6 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5, type6 arg6
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_SYS_SOCKETCALL
 #endif
-#endif
 
 #ifdef __KERNEL_SYSCALLS__
 
@@ -571,7 +570,7 @@ asmlinkage long sys_rt_sigaction(int sig,
                                 struct sigaction __user *oact,
                                 size_t sigsetsize);
 
-#endif
+#endif /* __KERNEL_SYSCALLS__ */
 
 /*
  * "Conditional" syscalls
@@ -581,4 +580,5 @@ asmlinkage long sys_rt_sigaction(int sig,
  */
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 
+#endif /* __KERNEL__ */
 #endif /* __ASM_ARM_UNISTD_H */
diff --git a/include/asm-arm26/atomic.h b/include/asm-arm26/atomic.h
index 1552c8653990..97e944fe1cff 100644
--- a/include/asm-arm26/atomic.h
+++ b/include/asm-arm26/atomic.h
@@ -20,7 +20,6 @@
 #ifndef __ASM_ARM_ATOMIC_H
 #define __ASM_ARM_ATOMIC_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_SMP
 #error SMP is NOT supported
diff --git a/include/asm-arm26/bug.h b/include/asm-arm26/bug.h
index 7177c7399967..8545d58b0475 100644
--- a/include/asm-arm26/bug.h
+++ b/include/asm-arm26/bug.h
@@ -1,7 +1,6 @@
 #ifndef _ASMARM_BUG_H
 #define _ASMARM_BUG_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_BUG
 #ifdef CONFIG_DEBUG_BUGVERBOSE
diff --git a/include/asm-arm26/dma.h b/include/asm-arm26/dma.h
index 995e223e43a1..4326ba85eb72 100644
--- a/include/asm-arm26/dma.h
+++ b/include/asm-arm26/dma.h
@@ -3,7 +3,6 @@
 
 typedef unsigned int dmach_t;
 
-#include <linux/config.h>
 #include <linux/spinlock.h>
 #include <asm/system.h>
 #include <asm/memory.h>
diff --git a/include/asm-arm26/hardirq.h b/include/asm-arm26/hardirq.h
index 87c19d2bb6a8..e717742ffce0 100644
--- a/include/asm-arm26/hardirq.h
+++ b/include/asm-arm26/hardirq.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_HARDIRQ_H
 #define __ASM_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/cache.h>
 #include <linux/threads.h>
 #include <asm/irq.h>
diff --git a/include/asm-arm26/hardware.h b/include/asm-arm26/hardware.h
index 82fc55e2a009..801df0bde8b7 100644
--- a/include/asm-arm26/hardware.h
+++ b/include/asm-arm26/hardware.h
@@ -16,7 +16,6 @@
 #ifndef __ASM_HARDWARE_H
 #define __ASM_HARDWARE_H
 
-#include <linux/config.h>
 
 
 /*
diff --git a/include/asm-arm26/io.h b/include/asm-arm26/io.h
index 02f94d88a124..2aa033bd0678 100644
--- a/include/asm-arm26/io.h
+++ b/include/asm-arm26/io.h
@@ -22,7 +22,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <asm/byteorder.h>
 #include <asm/memory.h>
diff --git a/include/asm-arm26/leds.h b/include/asm-arm26/leds.h
index 88ce4124f854..12290ea55801 100644
--- a/include/asm-arm26/leds.h
+++ b/include/asm-arm26/leds.h
@@ -13,7 +13,6 @@
 #ifndef ASM_ARM_LEDS_H
 #define ASM_ARM_LEDS_H
 
-#include <linux/config.h>
 
 typedef enum {
         led_idle_start,
diff --git a/include/asm-arm26/mach-types.h b/include/asm-arm26/mach-types.h
index b34045b78128..0aeaedcbac96 100644
--- a/include/asm-arm26/mach-types.h
+++ b/include/asm-arm26/mach-types.h
@@ -6,7 +6,6 @@
 #ifndef __ASM_ARM_MACH_TYPE_H
 #define __ASM_ARM_MACH_TYPE_H
 
-#include <linux/config.h>
 
 #ifndef __ASSEMBLY__
 extern unsigned int __machine_arch_type;
diff --git a/include/asm-arm26/page.h b/include/asm-arm26/page.h
index d3f23ac4d468..fa19de28fda0 100644
--- a/include/asm-arm26/page.h
+++ b/include/asm-arm26/page.h
@@ -1,7 +1,6 @@
 #ifndef _ASMARM_PAGE_H
 #define _ASMARM_PAGE_H
 
-#include <linux/config.h>
 
 #ifdef __KERNEL__
 #ifndef __ASSEMBLY__
diff --git a/include/asm-arm26/pgtable.h b/include/asm-arm26/pgtable.h
index a590250277f8..19ac9101a6bb 100644
--- a/include/asm-arm26/pgtable.h
+++ b/include/asm-arm26/pgtable.h
@@ -13,7 +13,6 @@
 
 #include <asm-generic/4level-fixup.h>
 
-#include <linux/config.h>
 #include <asm/memory.h>
 
 /*
diff --git a/include/asm-arm26/serial.h b/include/asm-arm26/serial.h
index 5fc747d1b501..dd86a716cb0b 100644
--- a/include/asm-arm26/serial.h
+++ b/include/asm-arm26/serial.h
@@ -14,7 +14,6 @@
 #ifndef __ASM_SERIAL_H
 #define __ASM_SERIAL_H
 
-#include <linux/config.h>
 
 /*
  * This assumes you have a 1.8432 MHz clock for your UART.
diff --git a/include/asm-arm26/smp.h b/include/asm-arm26/smp.h
index 5ca771631fd8..38349ec8b61b 100644
--- a/include/asm-arm26/smp.h
+++ b/include/asm-arm26/smp.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_SMP_H
 #define __ASM_SMP_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_SMP
 #error SMP not supported
diff --git a/include/asm-arm26/sysirq.h b/include/asm-arm26/sysirq.h
index cad250c7b9ec..81dca90d9a3f 100644
--- a/include/asm-arm26/sysirq.h
+++ b/include/asm-arm26/sysirq.h
@@ -11,7 +11,6 @@
  *   04-04-1998 PJB     Merged arc and a5k versions
  */
 
-#include <linux/config.h>
 
 #if defined(CONFIG_ARCH_A5K)
 #define IRQ_PRINTER             0
diff --git a/include/asm-arm26/system.h b/include/asm-arm26/system.h
index 702884926a55..d1f69d706198 100644
--- a/include/asm-arm26/system.h
+++ b/include/asm-arm26/system.h
@@ -3,7 +3,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 /*
  * This is used to ensure the compiler did actually allocate the register we
diff --git a/include/asm-arm26/unistd.h b/include/asm-arm26/unistd.h
index be4c2fb9c049..70eb6d91cfd0 100644
--- a/include/asm-arm26/unistd.h
+++ b/include/asm-arm26/unistd.h
@@ -14,8 +14,6 @@
 #ifndef __ASM_ARM_UNISTD_H
 #define __ASM_ARM_UNISTD_H
 
-#include <linux/linkage.h>
-
 #define __NR_SYSCALL_BASE       0x900000
 
 /*
@@ -312,6 +310,9 @@
 #define __ARM_NR_cacheflush             (__ARM_NR_BASE+2)
 #define __ARM_NR_usr26                  (__ARM_NR_BASE+3)
 
+#ifdef __KERNEL__
+#include <linux/linkage.h>
+
 #define __sys2(x) #x
 #define __sys1(x) __sys2(x)
 
@@ -443,7 +444,6 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5, type6 arg6
   __syscall_return(type,__res);                                         \
 }
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_STAT64
@@ -462,7 +462,6 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5, type6 arg6
 #define __ARCH_WANT_SYS_SIGPENDING
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
-#endif
 
 #ifdef __KERNEL_SYSCALLS__
 
@@ -486,7 +485,7 @@ asmlinkage long sys_rt_sigaction(int sig,
                                 struct sigaction __user *oact,
                                 size_t sigsetsize);
 
-#endif
+#endif /* __KERNEL_SYSCALLS__ */
 
 /*
  * "Conditional" syscalls
@@ -496,4 +495,5 @@ asmlinkage long sys_rt_sigaction(int sig,
  */
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 
+#endif /* __KERNEL__ */
 #endif /* __ASM_ARM_UNISTD_H */
diff --git a/include/asm-cris/arch-v10/io.h b/include/asm-cris/arch-v10/io.h
index dd39198ec67d..11ef5b53d84e 100644
--- a/include/asm-cris/arch-v10/io.h
+++ b/include/asm-cris/arch-v10/io.h
@@ -2,7 +2,6 @@
 #define _ASM_ARCH_CRIS_IO_H
 
 #include <asm/arch/svinto.h>
-#include <linux/config.h>
 
 /* Etrax shadow registers - which live in arch/cris/kernel/shadows.c */
 
diff --git a/include/asm-cris/arch-v10/page.h b/include/asm-cris/arch-v10/page.h
index 407e6e68f49e..7d8307aed7f3 100644
--- a/include/asm-cris/arch-v10/page.h
+++ b/include/asm-cris/arch-v10/page.h
@@ -1,7 +1,6 @@
 #ifndef _CRIS_ARCH_PAGE_H
 #define _CRIS_ARCH_PAGE_H
 
-#include <linux/config.h>
 
 #ifdef __KERNEL__
 
diff --git a/include/asm-cris/arch-v10/system.h b/include/asm-cris/arch-v10/system.h
index 1ac7b639b1b0..4a9cd36c9e16 100644
--- a/include/asm-cris/arch-v10/system.h
+++ b/include/asm-cris/arch-v10/system.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_CRIS_ARCH_SYSTEM_H
 #define __ASM_CRIS_ARCH_SYSTEM_H
 
-#include <linux/config.h>
 
 /* read the CPU version register */
 
diff --git a/include/asm-cris/arch-v32/io.h b/include/asm-cris/arch-v32/io.h
index 043c9ce5294e..5efe4d949001 100644
--- a/include/asm-cris/arch-v32/io.h
+++ b/include/asm-cris/arch-v32/io.h
@@ -4,7 +4,6 @@
 #include <asm/arch/hwregs/reg_map.h>
 #include <asm/arch/hwregs/reg_rdwr.h>
 #include <asm/arch/hwregs/gio_defs.h>
-#include <linux/config.h>
 
 enum crisv32_io_dir
 {
diff --git a/include/asm-cris/arch-v32/irq.h b/include/asm-cris/arch-v32/irq.h
index d35aa8174c2f..eeb0a80262c8 100644
--- a/include/asm-cris/arch-v32/irq.h
+++ b/include/asm-cris/arch-v32/irq.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_ARCH_IRQ_H
 #define _ASM_ARCH_IRQ_H
 
-#include <linux/config.h>
 #include "hwregs/intr_vect.h"
 
 /* Number of non-cpu interrupts. */
diff --git a/include/asm-cris/arch-v32/page.h b/include/asm-cris/arch-v32/page.h
index 77827bc17cca..fa454fe12425 100644
--- a/include/asm-cris/arch-v32/page.h
+++ b/include/asm-cris/arch-v32/page.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_CRIS_ARCH_PAGE_H
 #define _ASM_CRIS_ARCH_PAGE_H
 
-#include <linux/config.h>
 
 #ifdef __KERNEL__
 
diff --git a/include/asm-cris/arch-v32/processor.h b/include/asm-cris/arch-v32/processor.h
index 32bf2e538ced..5553b0cd02bf 100644
--- a/include/asm-cris/arch-v32/processor.h
+++ b/include/asm-cris/arch-v32/processor.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_CRIS_ARCH_PROCESSOR_H
 #define _ASM_CRIS_ARCH_PROCESSOR_H
 
-#include <linux/config.h>
 
 /* Return current instruction pointer. */
 #define current_text_addr() \
diff --git a/include/asm-cris/arch-v32/system.h b/include/asm-cris/arch-v32/system.h
index a3d75d581e2f..d20e2d6d64a3 100644
--- a/include/asm-cris/arch-v32/system.h
+++ b/include/asm-cris/arch-v32/system.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_CRIS_ARCH_SYSTEM_H
 #define _ASM_CRIS_ARCH_SYSTEM_H
 
-#include <linux/config.h>
 
 /* Read the CPU version register. */
 static inline unsigned long rdvr(void)
diff --git a/include/asm-cris/eshlibld.h b/include/asm-cris/eshlibld.h
index 2b577cde17eb..10ce36cf79a9 100644
--- a/include/asm-cris/eshlibld.h
+++ b/include/asm-cris/eshlibld.h
@@ -32,7 +32,6 @@
 /* We have dependencies all over the place for the host system
    for xsim being a linux system, so let's not pretend anything
    else with #ifdef:s here until fixed.  */
-#include <linux/config.h>
 #include <linux/limits.h>
 
 /* Maybe do sanity checking if file input. */
diff --git a/include/asm-cris/etraxgpio.h b/include/asm-cris/etraxgpio.h
index 80ee10f70d43..5d0028dba7c6 100644
--- a/include/asm-cris/etraxgpio.h
+++ b/include/asm-cris/etraxgpio.h
@@ -25,7 +25,6 @@
 #ifndef _ASM_ETRAXGPIO_H
 #define _ASM_ETRAXGPIO_H
 
-#include <linux/config.h>
 /* etraxgpio _IOC_TYPE, bits 8 to 15 in ioctl cmd */
 #ifdef CONFIG_ETRAX_ARCH_V10
 #define ETRAXGPIO_IOCTYPE 43
diff --git a/include/asm-cris/fasttimer.h b/include/asm-cris/fasttimer.h
index 69522028baa5..a3a77132ce32 100644
--- a/include/asm-cris/fasttimer.h
+++ b/include/asm-cris/fasttimer.h
@@ -5,7 +5,6 @@
  * This may be useful in other OS than Linux so use 2 space indentation...
  * Copyright (C) 2000, 2002 Axis Communications AB
  */
-#include <linux/config.h>
 #include <linux/time.h> /* struct timeval */
 #include <linux/timex.h>
 
diff --git a/include/asm-cris/page.h b/include/asm-cris/page.h
index 3787633e6209..81832e9e157f 100644
--- a/include/asm-cris/page.h
+++ b/include/asm-cris/page.h
@@ -1,7 +1,6 @@
 #ifndef _CRIS_PAGE_H
 #define _CRIS_PAGE_H
 
-#include <linux/config.h>
 #include <asm/arch/page.h>
 
 /* PAGE_SHIFT determines the page size */
diff --git a/include/asm-cris/pci.h b/include/asm-cris/pci.h
index 2064bc1de074..b2ac8a331da1 100644
--- a/include/asm-cris/pci.h
+++ b/include/asm-cris/pci.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_CRIS_PCI_H
 #define __ASM_CRIS_PCI_H
 
-#include <linux/config.h>
 
 #ifdef __KERNEL__
 #include <linux/mm.h>           /* for struct page */
diff --git a/include/asm-cris/pgtable.h b/include/asm-cris/pgtable.h
index 70a832514f62..5d76c1c0d6c9 100644
--- a/include/asm-cris/pgtable.h
+++ b/include/asm-cris/pgtable.h
@@ -9,7 +9,6 @@
 #include <asm-generic/pgtable-nopmd.h>
 
 #ifndef __ASSEMBLY__
-#include <linux/config.h>
 #include <linux/sched.h>
 #include <asm/mmu.h>
 #endif
diff --git a/include/asm-cris/processor.h b/include/asm-cris/processor.h
index 961e2bceadbc..568da1deceb9 100644
--- a/include/asm-cris/processor.h
+++ b/include/asm-cris/processor.h
@@ -10,7 +10,6 @@
 #ifndef __ASM_CRIS_PROCESSOR_H
 #define __ASM_CRIS_PROCESSOR_H
 
-#include <linux/config.h>
 #include <asm/system.h>
 #include <asm/page.h>
 #include <asm/ptrace.h>
diff --git a/include/asm-cris/rtc.h b/include/asm-cris/rtc.h
index 97c13039834a..cb4bf9217fee 100644
--- a/include/asm-cris/rtc.h
+++ b/include/asm-cris/rtc.h
@@ -4,7 +4,6 @@
 #define __RTC_H__
 
 
-#include <linux/config.h>
 
 #ifdef CONFIG_ETRAX_DS1302
    /* Dallas DS1302 clock/calendar register numbers. */
diff --git a/include/asm-cris/tlbflush.h b/include/asm-cris/tlbflush.h
index c52238005b55..0569612477e3 100644
--- a/include/asm-cris/tlbflush.h
+++ b/include/asm-cris/tlbflush.h
@@ -1,7 +1,6 @@
 #ifndef _CRIS_TLBFLUSH_H
 #define _CRIS_TLBFLUSH_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <asm/processor.h>
 #include <asm/pgtable.h>
diff --git a/include/asm-cris/unistd.h b/include/asm-cris/unistd.h
index bb2dfe480213..c2954e90aa24 100644
--- a/include/asm-cris/unistd.h
+++ b/include/asm-cris/unistd.h
@@ -295,11 +295,11 @@
 #define __NR_request_key        287
 #define __NR_keyctl             288
 
-#define NR_syscalls 289
+#ifdef __KERNEL__
 
+#define NR_syscalls 289
 
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_OLD_STAT
@@ -379,12 +379,10 @@ asmlinkage long sys_rt_sigaction(int sig,
  * complaints.  We don't want to use -fno-builtin, so just use a
  * different name when in the kernel.
  */
-#ifdef __KERNEL__
 #define _exit kernel_syscall_exit
-#endif
 static inline _syscall1(int,_exit,int,exitcode)
 static inline _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
-#endif
+#endif /* __KERNEL_SYSCALLS__ */
 
 
 /*
@@ -395,4 +393,5 @@ static inline _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
  */
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 
+#endif /* __KERNEL__ */
 #endif /* _ASM_CRIS_UNISTD_H_ */
diff --git a/include/asm-frv/atomic.h b/include/asm-frv/atomic.h
index 5d9f84bfdcad..9a4ff03c3969 100644
--- a/include/asm-frv/atomic.h
+++ b/include/asm-frv/atomic.h
@@ -14,7 +14,6 @@
 #ifndef _ASM_ATOMIC_H
 #define _ASM_ATOMIC_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <asm/spr-regs.h>
 
diff --git a/include/asm-frv/bitops.h b/include/asm-frv/bitops.h
index 6344d06390b9..980ae1b0cd28 100644
--- a/include/asm-frv/bitops.h
+++ b/include/asm-frv/bitops.h
@@ -14,7 +14,6 @@
 #ifndef _ASM_BITOPS_H
 #define _ASM_BITOPS_H
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <asm/byteorder.h>
 #include <asm/system.h>
diff --git a/include/asm-frv/bug.h b/include/asm-frv/bug.h
index 451712cc3060..6b1b44d71028 100644
--- a/include/asm-frv/bug.h
+++ b/include/asm-frv/bug.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_BUG_H
 #define _ASM_BUG_H
 
-#include <linux/config.h>
 #include <linux/linkage.h>
 
 #ifdef CONFIG_BUG
diff --git a/include/asm-frv/cache.h b/include/asm-frv/cache.h
index cf69b6373b34..2797163b8f4f 100644
--- a/include/asm-frv/cache.h
+++ b/include/asm-frv/cache.h
@@ -12,7 +12,6 @@
 #ifndef __ASM_CACHE_H
 #define __ASM_CACHE_H
 
-#include <linux/config.h>
 
 /* bytes per L1 cache line */
 #define L1_CACHE_SHIFT          (CONFIG_FRV_L1_CACHE_SHIFT)
diff --git a/include/asm-frv/dma.h b/include/asm-frv/dma.h
index d8f9a2f21521..18d6bb8f84fc 100644
--- a/include/asm-frv/dma.h
+++ b/include/asm-frv/dma.h
@@ -14,7 +14,6 @@
 
 //#define DMA_DEBUG 1
 
-#include <linux/config.h>
 #include <linux/interrupt.h>
 
 #undef MAX_DMA_CHANNELS         /* don't use kernel/dma.c */
diff --git a/include/asm-frv/elf.h b/include/asm-frv/elf.h
index 7d2098f0476b..38656da00e40 100644
--- a/include/asm-frv/elf.h
+++ b/include/asm-frv/elf.h
@@ -12,7 +12,6 @@
 #ifndef __ASM_ELF_H
 #define __ASM_ELF_H
 
-#include <linux/config.h>
 #include <asm/ptrace.h>
 #include <asm/user.h>
 
diff --git a/include/asm-frv/fpu.h b/include/asm-frv/fpu.h
index b1178f8ca5ce..d73c60b56641 100644
--- a/include/asm-frv/fpu.h
+++ b/include/asm-frv/fpu.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_FPU_H
 #define __ASM_FPU_H
 
-#include <linux/config.h>
 
 /*
  * MAX floating point unit state size (FSAVE/FRESTORE)
diff --git a/include/asm-frv/hardirq.h b/include/asm-frv/hardirq.h
index 685123981e8b..7581b5a7559a 100644
--- a/include/asm-frv/hardirq.h
+++ b/include/asm-frv/hardirq.h
@@ -12,7 +12,6 @@
 #ifndef __ASM_HARDIRQ_H
 #define __ASM_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/irq.h>
 
diff --git a/include/asm-frv/highmem.h b/include/asm-frv/highmem.h
index 295f74a57f22..cfbf7d3a1feb 100644
--- a/include/asm-frv/highmem.h
+++ b/include/asm-frv/highmem.h
@@ -17,7 +17,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/init.h>
 #include <asm/mem-layout.h>
 #include <asm/spr-regs.h>
diff --git a/include/asm-frv/ide.h b/include/asm-frv/ide.h
index ae031eaa3dd2..f0bd2cb250c1 100644
--- a/include/asm-frv/ide.h
+++ b/include/asm-frv/ide.h
@@ -14,7 +14,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <asm/setup.h>
 #include <asm/io.h>
 #include <asm/irq.h>
diff --git a/include/asm-frv/io.h b/include/asm-frv/io.h
index 01247cb2bc39..b56eba59e3cd 100644
--- a/include/asm-frv/io.h
+++ b/include/asm-frv/io.h
@@ -17,7 +17,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <asm/virtconvert.h>
 #include <asm/string.h>
diff --git a/include/asm-frv/irq.h b/include/asm-frv/irq.h
index 2c16d8dc02fd..58b619215a50 100644
--- a/include/asm-frv/irq.h
+++ b/include/asm-frv/irq.h
@@ -12,7 +12,6 @@
 #ifndef _ASM_IRQ_H_
 #define _ASM_IRQ_H_
 
-#include <linux/config.h>
 
 /*
  * the system has an on-CPU PIC and another PIC on the FPGA and other PICs on other peripherals,
diff --git a/include/asm-frv/mmu_context.h b/include/asm-frv/mmu_context.h
index 4fb9ea3c5bc9..72edcaaccd5d 100644
--- a/include/asm-frv/mmu_context.h
+++ b/include/asm-frv/mmu_context.h
@@ -12,7 +12,6 @@
 #ifndef _ASM_MMU_CONTEXT_H
 #define _ASM_MMU_CONTEXT_H
 
-#include <linux/config.h>
 #include <asm/setup.h>
 #include <asm/page.h>
 #include <asm/pgalloc.h>
diff --git a/include/asm-frv/page.h b/include/asm-frv/page.h
index dc0f7e08a4c2..134cc0cdf6c2 100644
--- a/include/asm-frv/page.h
+++ b/include/asm-frv/page.h
@@ -3,7 +3,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <asm/virtconvert.h>
 #include <asm/mem-layout.h>
 #include <asm/sections.h>
diff --git a/include/asm-frv/pci.h b/include/asm-frv/pci.h
index 598b0c6b695d..f35a4511e7b9 100644
--- a/include/asm-frv/pci.h
+++ b/include/asm-frv/pci.h
@@ -13,7 +13,6 @@
 #ifndef ASM_PCI_H
 #define ASM_PCI_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <asm/scatterlist.h>
 #include <asm-generic/pci-dma-compat.h>
diff --git a/include/asm-frv/pgalloc.h b/include/asm-frv/pgalloc.h
index 1bd28f41bfa8..ce982a6c610f 100644
--- a/include/asm-frv/pgalloc.h
+++ b/include/asm-frv/pgalloc.h
@@ -15,7 +15,6 @@
 #ifndef _ASM_PGALLOC_H
 #define _ASM_PGALLOC_H
 
-#include <linux/config.h>
 #include <asm/setup.h>
 #include <asm/virtconvert.h>
 
diff --git a/include/asm-frv/pgtable.h b/include/asm-frv/pgtable.h
index d1c3b182c691..7af7485e889e 100644
--- a/include/asm-frv/pgtable.h
+++ b/include/asm-frv/pgtable.h
@@ -16,7 +16,6 @@
 #ifndef _ASM_PGTABLE_H
 #define _ASM_PGTABLE_H
 
-#include <linux/config.h>
 #include <asm/mem-layout.h>
 #include <asm/setup.h>
 #include <asm/processor.h>
diff --git a/include/asm-frv/processor.h b/include/asm-frv/processor.h
index 5228c18b7f78..1c4dba1c5f57 100644
--- a/include/asm-frv/processor.h
+++ b/include/asm-frv/processor.h
@@ -12,7 +12,6 @@
 #ifndef _ASM_PROCESSOR_H
 #define _ASM_PROCESSOR_H
 
-#include <linux/config.h>
 #include <asm/mem-layout.h>
 
 #ifndef __ASSEMBLY__
diff --git a/include/asm-frv/segment.h b/include/asm-frv/segment.h
index 61222f00dfc1..e3616a6f941d 100644
--- a/include/asm-frv/segment.h
+++ b/include/asm-frv/segment.h
@@ -12,7 +12,6 @@
 #ifndef _ASM_SEGMENT_H
 #define _ASM_SEGMENT_H
 
-#include <linux/config.h>
 
 #ifndef __ASSEMBLY__
 
diff --git a/include/asm-frv/serial.h b/include/asm-frv/serial.h
index 6917d556a1e1..dbb825998689 100644
--- a/include/asm-frv/serial.h
+++ b/include/asm-frv/serial.h
@@ -6,7 +6,6 @@
  *
  * Based on linux/include/asm-i386/serial.h
  */
-#include <linux/config.h>
 #include <asm/serial-regs.h>
 
 /*
diff --git a/include/asm-frv/smp.h b/include/asm-frv/smp.h
index 5ca771631fd8..38349ec8b61b 100644
--- a/include/asm-frv/smp.h
+++ b/include/asm-frv/smp.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_SMP_H
 #define __ASM_SMP_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_SMP
 #error SMP not supported
diff --git a/include/asm-frv/system.h b/include/asm-frv/system.h
index 1734ed91bcdc..351863dfd06e 100644
--- a/include/asm-frv/system.h
+++ b/include/asm-frv/system.h
@@ -12,7 +12,6 @@
 #ifndef _ASM_SYSTEM_H
 #define _ASM_SYSTEM_H
 
-#include <linux/config.h> /* get configuration macros */
 #include <linux/linkage.h>
 #include <asm/atomic.h>
 
diff --git a/include/asm-frv/tlbflush.h b/include/asm-frv/tlbflush.h
index bc3462625084..da3a3179a85d 100644
--- a/include/asm-frv/tlbflush.h
+++ b/include/asm-frv/tlbflush.h
@@ -12,7 +12,6 @@
 #ifndef _ASM_TLBFLUSH_H
 #define _ASM_TLBFLUSH_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <asm/processor.h>
 
diff --git a/include/asm-frv/types.h b/include/asm-frv/types.h
index 2560f596a75d..1b6d1923b25b 100644
--- a/include/asm-frv/types.h
+++ b/include/asm-frv/types.h
@@ -46,7 +46,6 @@ typedef unsigned long long __u64;
 
 #ifndef __ASSEMBLY__
 
-#include <linux/config.h>
 
 typedef signed char s8;
 typedef unsigned char u8;
diff --git a/include/asm-frv/unaligned.h b/include/asm-frv/unaligned.h
index a0d199bf01d9..dc8e9c9bf6bd 100644
--- a/include/asm-frv/unaligned.h
+++ b/include/asm-frv/unaligned.h
@@ -12,7 +12,6 @@
 #ifndef _ASM_UNALIGNED_H
 #define _ASM_UNALIGNED_H
 
-#include <linux/config.h>
 
 /*
  * Unaligned accesses on uClinux can't be performed in a fault handler - the
diff --git a/include/asm-frv/unistd.h b/include/asm-frv/unistd.h
index 2662a3e12dc4..7c2e712c3b73 100644
--- a/include/asm-frv/unistd.h
+++ b/include/asm-frv/unistd.h
@@ -317,6 +317,8 @@
 #define __NR_pselect6           308
 #define __NR_ppoll              309
 
+#ifdef __KERNEL__
+
 #define NR_syscalls 310
 
 /*
@@ -477,9 +479,8 @@ static inline pid_t wait(int * wait_stat)
         return waitpid(-1,wait_stat,0);
 }
 
-#endif
+#endif /* __KERNEL_SYSCALLS__ */
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 /* #define __ARCH_WANT_OLD_READDIR */
 #define __ARCH_WANT_OLD_STAT
@@ -503,7 +504,6 @@ static inline pid_t wait(int * wait_stat)
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
-#endif
 
 /*
  * "Conditional" syscalls
@@ -515,4 +515,5 @@ static inline pid_t wait(int * wait_stat)
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 #endif
 
+#endif /* __KERNEL__ */
 #endif /* _ASM_UNISTD_H_ */
diff --git a/include/asm-frv/virtconvert.h b/include/asm-frv/virtconvert.h
index a29a0aec291f..59788fa2a813 100644
--- a/include/asm-frv/virtconvert.h
+++ b/include/asm-frv/virtconvert.h
@@ -17,7 +17,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <asm/setup.h>
 
 #ifdef CONFIG_MMU
diff --git a/include/asm-generic/bug.h b/include/asm-generic/bug.h
index 1a565a9d2fa7..0cd9711895fa 100644
--- a/include/asm-generic/bug.h
+++ b/include/asm-generic/bug.h
@@ -2,7 +2,6 @@
 #define _ASM_GENERIC_BUG_H
 
 #include <linux/compiler.h>
-#include <linux/config.h>
 
 #ifdef CONFIG_BUG
 #ifndef HAVE_ARCH_BUG
diff --git a/include/asm-generic/dma-mapping.h b/include/asm-generic/dma-mapping.h
index 1b356207712c..b541e48cc545 100644
--- a/include/asm-generic/dma-mapping.h
+++ b/include/asm-generic/dma-mapping.h
@@ -7,7 +7,6 @@
 #ifndef _ASM_GENERIC_DMA_MAPPING_H
 #define _ASM_GENERIC_DMA_MAPPING_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_PCI
 
diff --git a/include/asm-generic/fcntl.h b/include/asm-generic/fcntl.h
index b663520dcdc4..c154b9d6e7e5 100644
--- a/include/asm-generic/fcntl.h
+++ b/include/asm-generic/fcntl.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_GENERIC_FCNTL_H
 #define _ASM_GENERIC_FCNTL_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 
 /* open/fcntl - O_SYNC is only implemented on blocks devices and on files
diff --git a/include/asm-generic/local.h b/include/asm-generic/local.h
index 9291c24f5819..ab469297272c 100644
--- a/include/asm-generic/local.h
+++ b/include/asm-generic/local.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_GENERIC_LOCAL_H
 #define _ASM_GENERIC_LOCAL_H
 
-#include <linux/config.h>
 #include <linux/percpu.h>
 #include <linux/hardirq.h>
 #include <asm/atomic.h>
diff --git a/include/asm-generic/signal.h b/include/asm-generic/signal.h
index 9418d6e9b8cd..dae1d8720076 100644
--- a/include/asm-generic/signal.h
+++ b/include/asm-generic/signal.h
@@ -1,3 +1,8 @@
+#ifndef __ASM_GENERIC_SIGNAL_H
+#define __ASM_GENERIC_SIGNAL_H
+
+#include <linux/compiler.h>
+
 #ifndef SIG_BLOCK
 #define SIG_BLOCK          0    /* for blocking signals */
 #endif
@@ -19,3 +24,5 @@ typedef __restorefn_t __user *__sigrestore_t;
 #define SIG_IGN ((__force __sighandler_t)1)     /* ignore signal */
 #define SIG_ERR ((__force __sighandler_t)-1)    /* error return from signal */
 #endif
+
+#endif /* __ASM_GENERIC_SIGNAL_H */
diff --git a/include/asm-generic/tlb.h b/include/asm-generic/tlb.h
index cdd4145243cd..867d9008fafa 100644
--- a/include/asm-generic/tlb.h
+++ b/include/asm-generic/tlb.h
@@ -13,7 +13,6 @@
 #ifndef _ASM_GENERIC__TLB_H
 #define _ASM_GENERIC__TLB_H
 
-#include <linux/config.h>
 #include <linux/swap.h>
 #include <asm/pgalloc.h>
 #include <asm/tlbflush.h>
diff --git a/include/asm-h8300/bitops.h b/include/asm-h8300/bitops.h
index 574f57b6c4d1..d76299c98b81 100644
--- a/include/asm-h8300/bitops.h
+++ b/include/asm-h8300/bitops.h
@@ -6,7 +6,6 @@
  * Copyright 2002, Yoshinori Sato
  */
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <asm/system.h>
 
diff --git a/include/asm-h8300/dma.h b/include/asm-h8300/dma.h
index 3708681b7ddc..3edbaaaedf5b 100644
--- a/include/asm-h8300/dma.h
+++ b/include/asm-h8300/dma.h
@@ -1,7 +1,6 @@
 #ifndef _H8300_DMA_H
 #define _H8300_DMA_H 
  
-#include <linux/config.h>
 
 /*
  * Set number of channels of DMA on ColdFire for different implementations.
diff --git a/include/asm-h8300/elf.h b/include/asm-h8300/elf.h
index f4af1553a55f..7ba6a0af447c 100644
--- a/include/asm-h8300/elf.h
+++ b/include/asm-h8300/elf.h
@@ -5,7 +5,6 @@
  * ELF register definitions..
  */
 
-#include <linux/config.h>
 #include <asm/ptrace.h>
 #include <asm/user.h>
 
diff --git a/include/asm-h8300/hardirq.h b/include/asm-h8300/hardirq.h
index e961bfe201b8..18fa7931e09f 100644
--- a/include/asm-h8300/hardirq.h
+++ b/include/asm-h8300/hardirq.h
@@ -2,7 +2,6 @@
 #define __H8300_HARDIRQ_H
 
 #include <linux/kernel.h>
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
diff --git a/include/asm-h8300/io.h b/include/asm-h8300/io.h
index 1773e373e9c6..91b7487cb7ae 100644
--- a/include/asm-h8300/io.h
+++ b/include/asm-h8300/io.h
@@ -3,7 +3,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <asm/virtconvert.h>
 
 #if defined(CONFIG_H83007) || defined(CONFIG_H83068)
diff --git a/include/asm-h8300/keyboard.h b/include/asm-h8300/keyboard.h
index b05d11387ae5..fbad65e8a5c0 100644
--- a/include/asm-h8300/keyboard.h
+++ b/include/asm-h8300/keyboard.h
@@ -7,7 +7,6 @@
 #ifndef _H8300_KEYBOARD_H
 #define _H8300_KEYBOARD_H
 
-#include <linux/config.h>
 
 /* dummy i.e. no real keyboard */
 #define kbd_setkeycode(x...)    (-ENOSYS)
diff --git a/include/asm-h8300/mmu_context.h b/include/asm-h8300/mmu_context.h
index 23b555b7b4b9..855721a5dcc9 100644
--- a/include/asm-h8300/mmu_context.h
+++ b/include/asm-h8300/mmu_context.h
@@ -1,7 +1,6 @@
 #ifndef __H8300_MMU_CONTEXT_H
 #define __H8300_MMU_CONTEXT_H
 
-#include <linux/config.h>
 #include <asm/setup.h>
 #include <asm/page.h>
 #include <asm/pgalloc.h>
diff --git a/include/asm-h8300/page.h b/include/asm-h8300/page.h
index 6472c9f88227..f9f9d3eea8ed 100644
--- a/include/asm-h8300/page.h
+++ b/include/asm-h8300/page.h
@@ -1,7 +1,6 @@
 #ifndef _H8300_PAGE_H
 #define _H8300_PAGE_H
 
-#include <linux/config.h>
 
 /* PAGE_SHIFT determines the page size */
 
diff --git a/include/asm-h8300/page_offset.h b/include/asm-h8300/page_offset.h
index 8cc6e17218a8..f8706463008c 100644
--- a/include/asm-h8300/page_offset.h
+++ b/include/asm-h8300/page_offset.h
@@ -1,4 +1,3 @@
 
-#include <linux/config.h>
 #define PAGE_OFFSET_RAW         0x00000000
 
diff --git a/include/asm-h8300/param.h b/include/asm-h8300/param.h
index 126dddf72359..c25806ed1fb3 100644
--- a/include/asm-h8300/param.h
+++ b/include/asm-h8300/param.h
@@ -1,7 +1,6 @@
 #ifndef _H8300_PARAM_H
 #define _H8300_PARAM_H
 
-#include <linux/config.h>
 
 #ifndef HZ
 #define HZ 100
diff --git a/include/asm-h8300/pgtable.h b/include/asm-h8300/pgtable.h
index f6e296fc1297..8b7c6857998b 100644
--- a/include/asm-h8300/pgtable.h
+++ b/include/asm-h8300/pgtable.h
@@ -3,7 +3,6 @@
 
 #include <asm-generic/4level-fixup.h>
 
-#include <linux/config.h>
 #include <linux/slab.h>
 #include <asm/processor.h>
 #include <asm/page.h>
diff --git a/include/asm-h8300/processor.h b/include/asm-h8300/processor.h
index c6f0a7108ef3..c7e2f454b83a 100644
--- a/include/asm-h8300/processor.h
+++ b/include/asm-h8300/processor.h
@@ -17,7 +17,6 @@
  */
 #define current_text_addr() ({ __label__ _l; _l: &&_l;})
 
-#include <linux/config.h>
 #include <asm/segment.h>
 #include <asm/fpu.h>
 #include <asm/ptrace.h>
diff --git a/include/asm-h8300/semaphore-helper.h b/include/asm-h8300/semaphore-helper.h
index 29e0fbf1acb7..4fea36be5fd8 100644
--- a/include/asm-h8300/semaphore-helper.h
+++ b/include/asm-h8300/semaphore-helper.h
@@ -10,7 +10,6 @@
  * m68k version by Andreas Schwab
  */
 
-#include <linux/config.h>
 #include <linux/errno.h>
 
 /*
diff --git a/include/asm-h8300/shm.h b/include/asm-h8300/shm.h
index bec758524839..ed6623c0545d 100644
--- a/include/asm-h8300/shm.h
+++ b/include/asm-h8300/shm.h
@@ -1,7 +1,6 @@
 #ifndef _H8300_SHM_H
 #define _H8300_SHM_H
 
-#include <linux/config.h>
 
 /* format of page table entries that correspond to shared memory pages
    currently out in swap space (see also mm/swap.c):
diff --git a/include/asm-h8300/system.h b/include/asm-h8300/system.h
index 8e81cf665e75..134e0929fce5 100644
--- a/include/asm-h8300/system.h
+++ b/include/asm-h8300/system.h
@@ -1,7 +1,6 @@
 #ifndef _H8300_SYSTEM_H
 #define _H8300_SYSTEM_H
 
-#include <linux/config.h> /* get configuration macros */
 #include <linux/linkage.h>
 
 /*
diff --git a/include/asm-h8300/unaligned.h b/include/asm-h8300/unaligned.h
index 8a93961173c3..ffb67f472070 100644
--- a/include/asm-h8300/unaligned.h
+++ b/include/asm-h8300/unaligned.h
@@ -1,7 +1,6 @@
 #ifndef __H8300_UNALIGNED_H
 #define __H8300_UNALIGNED_H
 
-#include <linux/config.h>
 
 /* Use memmove here, so gcc does not insert a __builtin_memcpy. */
 
diff --git a/include/asm-h8300/unistd.h b/include/asm-h8300/unistd.h
index adb05159379b..226dd596c2da 100644
--- a/include/asm-h8300/unistd.h
+++ b/include/asm-h8300/unistd.h
@@ -292,6 +292,8 @@
 #define __NR_request_key        287
 #define __NR_keyctl             288
 
+#ifdef __KERNEL__
+
 #define NR_syscalls 289
 
 
@@ -460,7 +462,6 @@ type name(atype a, btype b, ctype c, dtype d, etype e, ftype f)	\
   __syscall_return(type, __res);                        \
 }
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_OLD_STAT
@@ -483,7 +484,6 @@ type name(atype a, btype b, ctype c, dtype d, etype e, ftype f)	\
 #define __ARCH_WANT_SYS_SIGPENDING
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
-#endif
 
 #ifdef __KERNEL_SYSCALLS__
 
@@ -534,7 +534,7 @@ asmlinkage long sys_rt_sigaction(int sig,
                                 struct sigaction __user *oact,
                                 size_t sigsetsize);
 
-#endif
+#endif /* __KERNEL_SYSCALLS__ */
 
 /*
  * "Conditional" syscalls
@@ -543,4 +543,5 @@ asmlinkage long sys_rt_sigaction(int sig,
   asm (".weak\t_" #name "\n"                            \
        ".set\t_" #name ",_sys_ni_syscall");
 
+#endif /* __KERNEL__ */
 #endif /* _ASM_H8300_UNISTD_H_ */
diff --git a/include/asm-h8300/virtconvert.h b/include/asm-h8300/virtconvert.h
index 3b344c1dfe0f..ee7d5ea10065 100644
--- a/include/asm-h8300/virtconvert.h
+++ b/include/asm-h8300/virtconvert.h
@@ -7,7 +7,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <asm/setup.h>
 #include <asm/page.h>
 
diff --git a/include/asm-i386/apic.h b/include/asm-i386/apic.h
index 288233fd77d7..cc9b940fb7e8 100644
--- a/include/asm-i386/apic.h
+++ b/include/asm-i386/apic.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_APIC_H
 #define __ASM_APIC_H
 
-#include <linux/config.h>
 #include <linux/pm.h>
 #include <asm/fixmap.h>
 #include <asm/apicdef.h>
diff --git a/include/asm-i386/atomic.h b/include/asm-i386/atomic.h
index 4ddce5296a78..4f061fa73794 100644
--- a/include/asm-i386/atomic.h
+++ b/include/asm-i386/atomic.h
@@ -1,7 +1,6 @@
 #ifndef __ARCH_I386_ATOMIC__
 #define __ARCH_I386_ATOMIC__
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <asm/processor.h>
 
diff --git a/include/asm-i386/bitops.h b/include/asm-i386/bitops.h
index 08deaeee6be9..1c780fa1e762 100644
--- a/include/asm-i386/bitops.h
+++ b/include/asm-i386/bitops.h
@@ -5,7 +5,6 @@
  * Copyright 1992, Linus Torvalds.
  */
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <asm/alternative.h>
 
diff --git a/include/asm-i386/bug.h b/include/asm-i386/bug.h
index 8f79de19eb94..8062cdbf2587 100644
--- a/include/asm-i386/bug.h
+++ b/include/asm-i386/bug.h
@@ -1,7 +1,6 @@
 #ifndef _I386_BUG_H
 #define _I386_BUG_H
 
-#include <linux/config.h>
 
 /*
  * Tell the user there is some problem.
diff --git a/include/asm-i386/bugs.h b/include/asm-i386/bugs.h
index 50233e0345fb..2a9e4ee5904d 100644
--- a/include/asm-i386/bugs.h
+++ b/include/asm-i386/bugs.h
@@ -17,7 +17,6 @@
  *      void check_bugs(void);
  */
 
-#include <linux/config.h>
 #include <linux/init.h>
 #include <asm/processor.h>
 #include <asm/i387.h>
diff --git a/include/asm-i386/byteorder.h b/include/asm-i386/byteorder.h
index a0d73f48d5be..a45470a8b74a 100644
--- a/include/asm-i386/byteorder.h
+++ b/include/asm-i386/byteorder.h
@@ -8,7 +8,6 @@
 
 /* For avoiding bswap on i386 */
 #ifdef __KERNEL__
-#include <linux/config.h>
 #endif
 
 static __inline__ __attribute_const__ __u32 ___arch__swab32(__u32 x)
diff --git a/include/asm-i386/cache.h b/include/asm-i386/cache.h
index ca15c9c665cf..57c62f414158 100644
--- a/include/asm-i386/cache.h
+++ b/include/asm-i386/cache.h
@@ -4,7 +4,6 @@
 #ifndef __ARCH_I386_CACHE_H
 #define __ARCH_I386_CACHE_H
 
-#include <linux/config.h>
 
 /* L1 cache line size */
 #define L1_CACHE_SHIFT  (CONFIG_X86_L1_CACHE_SHIFT)
diff --git a/include/asm-i386/dma.h b/include/asm-i386/dma.h
index f24b2bba2831..d23aac8e1a50 100644
--- a/include/asm-i386/dma.h
+++ b/include/asm-i386/dma.h
@@ -8,7 +8,6 @@
 #ifndef _ASM_DMA_H
 #define _ASM_DMA_H
 
-#include <linux/config.h>
 #include <linux/spinlock.h>     /* And spinlocks */
 #include <asm/io.h>             /* need byte IO */
 #include <linux/delay.h>
diff --git a/include/asm-i386/fixmap.h b/include/asm-i386/fixmap.h
index cfb1c61d3b9c..f7e068f4d2f9 100644
--- a/include/asm-i386/fixmap.h
+++ b/include/asm-i386/fixmap.h
@@ -13,7 +13,6 @@
 #ifndef _ASM_FIXMAP_H
 #define _ASM_FIXMAP_H
 
-#include <linux/config.h>
 
 /* used by vmalloc.c, vsyscall.lds.S.
  *
diff --git a/include/asm-i386/hardirq.h b/include/asm-i386/hardirq.h
index ee754d359734..0e358dc405f8 100644
--- a/include/asm-i386/hardirq.h
+++ b/include/asm-i386/hardirq.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_HARDIRQ_H
 #define __ASM_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/irq.h>
 
diff --git a/include/asm-i386/highmem.h b/include/asm-i386/highmem.h
index 0fd331306b60..e9a34ebc25d5 100644
--- a/include/asm-i386/highmem.h
+++ b/include/asm-i386/highmem.h
@@ -20,7 +20,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/interrupt.h>
 #include <linux/threads.h>
 #include <asm/kmap_types.h>
diff --git a/include/asm-i386/hpet.h b/include/asm-i386/hpet.h
index 7f1a8a6ee32f..af5d435519d1 100644
--- a/include/asm-i386/hpet.h
+++ b/include/asm-i386/hpet.h
@@ -27,7 +27,6 @@
 #include <asm/processor.h>
 
 #include <linux/timex.h>
-#include <linux/config.h>
 
 #include <asm/fixmap.h>
 
diff --git a/include/asm-i386/hw_irq.h b/include/asm-i386/hw_irq.h
index 622815bf3243..95d3fd090298 100644
--- a/include/asm-i386/hw_irq.h
+++ b/include/asm-i386/hw_irq.h
@@ -12,7 +12,6 @@
  *      <tomsoft@informatik.tu-chemnitz.de>
  */
 
-#include <linux/config.h>
 #include <linux/profile.h>
 #include <asm/atomic.h>
 #include <asm/irq.h>
diff --git a/include/asm-i386/ide.h b/include/asm-i386/ide.h
index 454440193eac..73465d2892b9 100644
--- a/include/asm-i386/ide.h
+++ b/include/asm-i386/ide.h
@@ -13,7 +13,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #ifndef MAX_HWIFS
 # ifdef CONFIG_BLK_DEV_IDEPCI
diff --git a/include/asm-i386/io.h b/include/asm-i386/io.h
index 79670bb4b0c7..b3724fe93ff1 100644
--- a/include/asm-i386/io.h
+++ b/include/asm-i386/io.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_IO_H
 #define _ASM_IO_H
 
-#include <linux/config.h>
 #include <linux/string.h>
 #include <linux/compiler.h>
 
diff --git a/include/asm-i386/io_apic.h b/include/asm-i386/io_apic.h
index d92e253f7f6f..5092e819b8a2 100644
--- a/include/asm-i386/io_apic.h
+++ b/include/asm-i386/io_apic.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_IO_APIC_H
 #define __ASM_IO_APIC_H
 
-#include <linux/config.h>
 #include <asm/types.h>
 #include <asm/mpspec.h>
 
diff --git a/include/asm-i386/irq.h b/include/asm-i386/irq.h
index 5169d7af456f..331726b41128 100644
--- a/include/asm-i386/irq.h
+++ b/include/asm-i386/irq.h
@@ -10,7 +10,6 @@
  *      <tomsoft@informatik.tu-chemnitz.de>
  */
 
-#include <linux/config.h>
 #include <linux/sched.h>
 /* include comes from machine specific directory */
 #include "irq_vectors.h"
diff --git a/include/asm-i386/kmap_types.h b/include/asm-i386/kmap_types.h
index 6886a0c3fedf..806aae3c5338 100644
--- a/include/asm-i386/kmap_types.h
+++ b/include/asm-i386/kmap_types.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_KMAP_TYPES_H
 #define _ASM_KMAP_TYPES_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_DEBUG_HIGHMEM
 # define D(n) __KM_FENCE_##n ,
diff --git a/include/asm-i386/mach-summit/mach_apic.h b/include/asm-i386/mach-summit/mach_apic.h
index 3d6d12937e1f..9fd073286289 100644
--- a/include/asm-i386/mach-summit/mach_apic.h
+++ b/include/asm-i386/mach-summit/mach_apic.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_MACH_APIC_H
 #define __ASM_MACH_APIC_H
 
-#include <linux/config.h>
 #include <asm/smp.h>
 
 #define esr_disable (1)
diff --git a/include/asm-i386/mmu_context.h b/include/asm-i386/mmu_context.h
index bf08218357ea..62b7bf184094 100644
--- a/include/asm-i386/mmu_context.h
+++ b/include/asm-i386/mmu_context.h
@@ -1,7 +1,6 @@
 #ifndef __I386_SCHED_H
 #define __I386_SCHED_H
 
-#include <linux/config.h>
 #include <asm/desc.h>
 #include <asm/atomic.h>
 #include <asm/pgalloc.h>
diff --git a/include/asm-i386/mtrr.h b/include/asm-i386/mtrr.h
index 64cf937c7e33..5a46de08efea 100644
--- a/include/asm-i386/mtrr.h
+++ b/include/asm-i386/mtrr.h
@@ -23,7 +23,6 @@
 #ifndef _LINUX_MTRR_H
 #define _LINUX_MTRR_H
 
-#include <linux/config.h>
 #include <linux/ioctl.h>
 #include <linux/errno.h>
 
diff --git a/include/asm-i386/page.h b/include/asm-i386/page.h
index 30f52a2263ba..e3a552fa5538 100644
--- a/include/asm-i386/page.h
+++ b/include/asm-i386/page.h
@@ -12,7 +12,6 @@
 #ifdef __KERNEL__
 #ifndef __ASSEMBLY__
 
-#include <linux/config.h>
 
 #ifdef CONFIG_X86_USE_3DNOW
 
@@ -137,9 +136,9 @@ extern int page_is_ram(unsigned long pagenr);
         ((current->personality & READ_IMPLIES_EXEC) ? VM_EXEC : 0 ) | \
                  VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC)
 
-#endif /* __KERNEL__ */
-
 #include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
+#endif /* __KERNEL__ */
+
 #endif /* _I386_PAGE_H */
diff --git a/include/asm-i386/param.h b/include/asm-i386/param.h
index 095580f3a45c..745dc5bd0fbc 100644
--- a/include/asm-i386/param.h
+++ b/include/asm-i386/param.h
@@ -2,7 +2,6 @@
 #define _ASMi386_PARAM_H
 
 #ifdef __KERNEL__
-# include <linux/config.h>
 # define HZ             CONFIG_HZ       /* Internal kernel timer frequency */
 # define USER_HZ        100             /* .. some user interfaces are in "ticks" */
 # define CLOCKS_PER_SEC         (USER_HZ)       /* like times() */
diff --git a/include/asm-i386/pci.h b/include/asm-i386/pci.h
index 78c85985aee3..64b6d0baedbc 100644
--- a/include/asm-i386/pci.h
+++ b/include/asm-i386/pci.h
@@ -1,7 +1,6 @@
 #ifndef __i386_PCI_H
 #define __i386_PCI_H
 
-#include <linux/config.h>
 
 #ifdef __KERNEL__
 #include <linux/mm.h>           /* for struct page */
diff --git a/include/asm-i386/pgalloc.h b/include/asm-i386/pgalloc.h
index 0380c3dc1f7e..4b1e61359f89 100644
--- a/include/asm-i386/pgalloc.h
+++ b/include/asm-i386/pgalloc.h
@@ -1,7 +1,6 @@
 #ifndef _I386_PGALLOC_H
 #define _I386_PGALLOC_H
 
-#include <linux/config.h>
 #include <asm/fixmap.h>
 #include <linux/threads.h>
 #include <linux/mm.h>           /* for struct page */
diff --git a/include/asm-i386/pgtable.h b/include/asm-i386/pgtable.h
index 672c3f76b9df..09697fec3d2b 100644
--- a/include/asm-i386/pgtable.h
+++ b/include/asm-i386/pgtable.h
@@ -1,7 +1,6 @@
 #ifndef _I386_PGTABLE_H
 #define _I386_PGTABLE_H
 
-#include <linux/config.h>
 
 /*
  * The Linux memory management assumes a three-level page table setup. On
diff --git a/include/asm-i386/processor.h b/include/asm-i386/processor.h
index 805f0dcda468..4df3818e4122 100644
--- a/include/asm-i386/processor.h
+++ b/include/asm-i386/processor.h
@@ -17,7 +17,6 @@
 #include <asm/msr.h>
 #include <asm/system.h>
 #include <linux/cache.h>
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <asm/percpu.h>
 #include <linux/cpumask.h>
diff --git a/include/asm-i386/serial.h b/include/asm-i386/serial.h
index e1ecfccb743b..bd67480ca109 100644
--- a/include/asm-i386/serial.h
+++ b/include/asm-i386/serial.h
@@ -2,7 +2,6 @@
  * include/asm-i386/serial.h
  */
 
-#include <linux/config.h>
 
 /*
  * This assumes you have a 1.8432 MHz clock for your UART.
diff --git a/include/asm-i386/smp.h b/include/asm-i386/smp.h
index 61d3ab9db70c..142d10e34ade 100644
--- a/include/asm-i386/smp.h
+++ b/include/asm-i386/smp.h
@@ -5,7 +5,6 @@
  * We need the APIC definitions automatically as part of 'smp.h'
  */
 #ifndef __ASSEMBLY__
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/threads.h>
 #include <linux/cpumask.h>
diff --git a/include/asm-i386/spinlock.h b/include/asm-i386/spinlock.h
index d76b7693cf1d..04ba30234c48 100644
--- a/include/asm-i386/spinlock.h
+++ b/include/asm-i386/spinlock.h
@@ -4,7 +4,6 @@
 #include <asm/atomic.h>
 #include <asm/rwlock.h>
 #include <asm/page.h>
-#include <linux/config.h>
 #include <linux/compiler.h>
 
 /*
diff --git a/include/asm-i386/string.h b/include/asm-i386/string.h
index bb5f88a27f7a..b9277361954b 100644
--- a/include/asm-i386/string.h
+++ b/include/asm-i386/string.h
@@ -2,7 +2,6 @@
 #define _I386_STRING_H_
 
 #ifdef __KERNEL__
-#include <linux/config.h>
 /*
  * On a 486 or Pentium, we are better off not using the
  * byte string operations. But on a 386 or a PPro the
diff --git a/include/asm-i386/system.h b/include/asm-i386/system.h
index 19cc79c9a35d..0249f912a29c 100644
--- a/include/asm-i386/system.h
+++ b/include/asm-i386/system.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_SYSTEM_H
 #define __ASM_SYSTEM_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <asm/segment.h>
 #include <asm/cpufeature.h>
diff --git a/include/asm-i386/thread_info.h b/include/asm-i386/thread_info.h
index 1f7d48c9ba3f..8420ed12491e 100644
--- a/include/asm-i386/thread_info.h
+++ b/include/asm-i386/thread_info.h
@@ -9,7 +9,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <asm/page.h>
 
diff --git a/include/asm-i386/timex.h b/include/asm-i386/timex.h
index 292b5a68f627..d434984303ca 100644
--- a/include/asm-i386/timex.h
+++ b/include/asm-i386/timex.h
@@ -6,7 +6,6 @@
 #ifndef _ASMi386_TIMEX_H
 #define _ASMi386_TIMEX_H
 
-#include <linux/config.h>
 #include <asm/processor.h>
 
 #ifdef CONFIG_X86_ELAN
diff --git a/include/asm-i386/tlbflush.h b/include/asm-i386/tlbflush.h
index ab216e1370ef..d57ca5c540b6 100644
--- a/include/asm-i386/tlbflush.h
+++ b/include/asm-i386/tlbflush.h
@@ -1,7 +1,6 @@
 #ifndef _I386_TLBFLUSH_H
 #define _I386_TLBFLUSH_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <asm/processor.h>
 
diff --git a/include/asm-i386/types.h b/include/asm-i386/types.h
index e50a08bd7ced..4b4b295ccdb9 100644
--- a/include/asm-i386/types.h
+++ b/include/asm-i386/types.h
@@ -35,7 +35,6 @@ typedef unsigned long long __u64;
 
 #ifndef __ASSEMBLY__
 
-#include <linux/config.h>
 
 typedef signed char s8;
 typedef unsigned char u8;
diff --git a/include/asm-i386/uaccess.h b/include/asm-i386/uaccess.h
index 371457b1ceb6..1ec65523ea5e 100644
--- a/include/asm-i386/uaccess.h
+++ b/include/asm-i386/uaccess.h
@@ -4,7 +4,6 @@
 /*
  * User space memory access functions
  */
-#include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/thread_info.h>
 #include <linux/prefetch.h>
diff --git a/include/asm-i386/unistd.h b/include/asm-i386/unistd.h
index eb4b152c82fc..de2ccc149e34 100644
--- a/include/asm-i386/unistd.h
+++ b/include/asm-i386/unistd.h
@@ -323,6 +323,8 @@
 #define __NR_tee                315
 #define __NR_vmsplice           316
 
+#ifdef __KERNEL__
+
 #define NR_syscalls 317
 
 /*
@@ -422,7 +424,6 @@ __asm__ volatile ("push %%ebp ; push %%ebx ; movl 4(%2),%%ebp ; " \
 __syscall_return(type,__res); \
 }
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_OLD_STAT
@@ -446,7 +447,6 @@ __syscall_return(type,__res); \
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
-#endif
 
 #ifdef __KERNEL_SYSCALLS__
 
@@ -485,7 +485,7 @@ asmlinkage long sys_rt_sigaction(int sig,
                                 struct sigaction __user *oact,
                                 size_t sigsetsize);
 
-#endif
+#endif /* __KERNEL_SYSCALLS__ */
 
 /*
  * "Conditional" syscalls
@@ -497,4 +497,5 @@ asmlinkage long sys_rt_sigaction(int sig,
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 #endif
 
+#endif /* __KERNEL__ */
 #endif /* _ASM_I386_UNISTD_H_ */
diff --git a/include/asm-ia64/asmmacro.h b/include/asm-ia64/asmmacro.h
index edf2cebb2969..c22b4658fc61 100644
--- a/include/asm-ia64/asmmacro.h
+++ b/include/asm-ia64/asmmacro.h
@@ -6,7 +6,6 @@
  *      David Mosberger-Tang <davidm@hpl.hp.com>
  */
 
-#include <linux/config.h>
 
 #define ENTRY(name)                             \
         .align 32;                              \
diff --git a/include/asm-ia64/cache.h b/include/asm-ia64/cache.h
index f0a104db8f20..e7482bd628ff 100644
--- a/include/asm-ia64/cache.h
+++ b/include/asm-ia64/cache.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_IA64_CACHE_H
 #define _ASM_IA64_CACHE_H
 
-#include <linux/config.h>
 
 /*
  * Copyright (C) 1998-2000 Hewlett-Packard Co
diff --git a/include/asm-ia64/delay.h b/include/asm-ia64/delay.h
index bba702076391..a30a62f235e1 100644
--- a/include/asm-ia64/delay.h
+++ b/include/asm-ia64/delay.h
@@ -12,7 +12,6 @@
  * Copyright (C) 1999 Don Dugger <don.dugger@intel.com>
  */
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/compiler.h>
diff --git a/include/asm-ia64/dma-mapping.h b/include/asm-ia64/dma-mapping.h
index df67d40801de..99a8f8e1218c 100644
--- a/include/asm-ia64/dma-mapping.h
+++ b/include/asm-ia64/dma-mapping.h
@@ -5,7 +5,6 @@
  * Copyright (C) 2003-2004 Hewlett-Packard Co
  *      David Mosberger-Tang <davidm@hpl.hp.com>
  */
-#include <linux/config.h>
 #include <asm/machvec.h>
 
 #define dma_alloc_coherent      platform_dma_alloc_coherent
diff --git a/include/asm-ia64/dma.h b/include/asm-ia64/dma.h
index 3be1b4925e18..dad3a735df8b 100644
--- a/include/asm-ia64/dma.h
+++ b/include/asm-ia64/dma.h
@@ -6,7 +6,6 @@
  *      David Mosberger-Tang <davidm@hpl.hp.com>
  */
 
-#include <linux/config.h>
 
 #include <asm/io.h>             /* need byte IO */
 
diff --git a/include/asm-ia64/elf.h b/include/asm-ia64/elf.h
index 446fce036fd9..25f9835d5459 100644
--- a/include/asm-ia64/elf.h
+++ b/include/asm-ia64/elf.h
@@ -8,7 +8,6 @@
  *      David Mosberger-Tang <davidm@hpl.hp.com>
  */
 
-#include <linux/config.h>
 
 #include <asm/fpu.h>
 #include <asm/page.h>
diff --git a/include/asm-ia64/hardirq.h b/include/asm-ia64/hardirq.h
index 33ef8f096d95..140e495b8e0e 100644
--- a/include/asm-ia64/hardirq.h
+++ b/include/asm-ia64/hardirq.h
@@ -6,7 +6,6 @@
  *      David Mosberger-Tang <davidm@hpl.hp.com>
  */
 
-#include <linux/config.h>
 
 #include <linux/threads.h>
 #include <linux/irq.h>
diff --git a/include/asm-ia64/ia32.h b/include/asm-ia64/ia32.h
index f8044a1169cd..5ff8d74c3e00 100644
--- a/include/asm-ia64/ia32.h
+++ b/include/asm-ia64/ia32.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_IA64_IA32_H
 #define _ASM_IA64_IA32_H
 
-#include <linux/config.h>
 
 #include <asm/ptrace.h>
 #include <asm/signal.h>
diff --git a/include/asm-ia64/ide.h b/include/asm-ia64/ide.h
index 93f45c5f189f..e928675de352 100644
--- a/include/asm-ia64/ide.h
+++ b/include/asm-ia64/ide.h
@@ -13,7 +13,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #include <linux/irq.h>
 
diff --git a/include/asm-ia64/intrinsics.h b/include/asm-ia64/intrinsics.h
index 8089f955e5d2..3a95aa432e99 100644
--- a/include/asm-ia64/intrinsics.h
+++ b/include/asm-ia64/intrinsics.h
@@ -9,7 +9,6 @@
  */
 
 #ifndef __ASSEMBLY__
-#include <linux/config.h>
 
 /* include compiler specific intrinsics */
 #include <asm/ia64regs.h>
diff --git a/include/asm-ia64/kmap_types.h b/include/asm-ia64/kmap_types.h
index bc777525fa12..5d1658aa2b3b 100644
--- a/include/asm-ia64/kmap_types.h
+++ b/include/asm-ia64/kmap_types.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_IA64_KMAP_TYPES_H
 #define _ASM_IA64_KMAP_TYPES_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_DEBUG_HIGHMEM
 # define D(n) __KM_FENCE_##n ,
diff --git a/include/asm-ia64/machvec.h b/include/asm-ia64/machvec.h
index a9c995a86c21..0df72a134c8b 100644
--- a/include/asm-ia64/machvec.h
+++ b/include/asm-ia64/machvec.h
@@ -10,7 +10,6 @@
 #ifndef _ASM_IA64_MACHVEC_H
 #define _ASM_IA64_MACHVEC_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 
 /* forward declarations: */
diff --git a/include/asm-ia64/meminit.h b/include/asm-ia64/meminit.h
index 46501b01a5c5..894bc4d89dc0 100644
--- a/include/asm-ia64/meminit.h
+++ b/include/asm-ia64/meminit.h
@@ -7,7 +7,6 @@
  * for more details.
  */
 
-#include <linux/config.h>
 
 /*
  * Entries defined so far:
diff --git a/include/asm-ia64/nodedata.h b/include/asm-ia64/nodedata.h
index 9978c7ce7549..a140310bf84d 100644
--- a/include/asm-ia64/nodedata.h
+++ b/include/asm-ia64/nodedata.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_IA64_NODEDATA_H
 #define _ASM_IA64_NODEDATA_H
 
-#include <linux/config.h>
 #include <linux/numa.h>
 
 #include <asm/percpu.h>
diff --git a/include/asm-ia64/numa.h b/include/asm-ia64/numa.h
index dae6aeb7b119..e5a8260593a5 100644
--- a/include/asm-ia64/numa.h
+++ b/include/asm-ia64/numa.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_IA64_NUMA_H
 #define _ASM_IA64_NUMA_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_NUMA
 
diff --git a/include/asm-ia64/page.h b/include/asm-ia64/page.h
index 2087825eefa4..f5a949ec6e1e 100644
--- a/include/asm-ia64/page.h
+++ b/include/asm-ia64/page.h
@@ -7,7 +7,6 @@
  *      David Mosberger-Tang <davidm@hpl.hp.com>
  */
 
-#include <linux/config.h>
 
 #include <asm/intrinsics.h>
 #include <asm/types.h>
diff --git a/include/asm-ia64/param.h b/include/asm-ia64/param.h
index 5e1e0d2d7baf..49c62dd5eccf 100644
--- a/include/asm-ia64/param.h
+++ b/include/asm-ia64/param.h
@@ -19,7 +19,6 @@
 #define MAXHOSTNAMELEN  64      /* max length of hostname */
 
 #ifdef __KERNEL__
-# include <linux/config.h>      /* mustn't include <linux/config.h> outside of #ifdef __KERNEL__ */
 # ifdef CONFIG_IA64_HP_SIM
   /*
    * Yeah, simulating stuff is slow, so let us catch some breath between
diff --git a/include/asm-ia64/percpu.h b/include/asm-ia64/percpu.h
index 2b14dee29ce7..ae357d504fba 100644
--- a/include/asm-ia64/percpu.h
+++ b/include/asm-ia64/percpu.h
@@ -12,7 +12,6 @@
 # define THIS_CPU(var)  (per_cpu__##var)  /* use this to mark accesses to per-CPU variables... */
 #else /* !__ASSEMBLY__ */
 
-#include <linux/config.h>
 
 #include <linux/threads.h>
 
diff --git a/include/asm-ia64/pgalloc.h b/include/asm-ia64/pgalloc.h
index f2f233846476..9cb68e9b377e 100644
--- a/include/asm-ia64/pgalloc.h
+++ b/include/asm-ia64/pgalloc.h
@@ -13,7 +13,6 @@
  * Copyright (C) 2000, Goutham Rao <goutham.rao@intel.com>
  */
 
-#include <linux/config.h>
 
 #include <linux/compiler.h>
 #include <linux/mm.h>
diff --git a/include/asm-ia64/pgtable.h b/include/asm-ia64/pgtable.h
index c0f8144f2349..eaac08d5e0bd 100644
--- a/include/asm-ia64/pgtable.h
+++ b/include/asm-ia64/pgtable.h
@@ -12,7 +12,6 @@
  *      David Mosberger-Tang <davidm@hpl.hp.com>
  */
 
-#include <linux/config.h>
 
 #include <asm/mman.h>
 #include <asm/page.h>
diff --git a/include/asm-ia64/processor.h b/include/asm-ia64/processor.h
index b3bd58e80690..265f4824db0e 100644
--- a/include/asm-ia64/processor.h
+++ b/include/asm-ia64/processor.h
@@ -13,7 +13,6 @@
  * 06/16/00     A. Mallick      added csd/ssd/tssd for ia32 support
  */
 
-#include <linux/config.h>
 
 #include <asm/intrinsics.h>
 #include <asm/kregs.h>
diff --git a/include/asm-ia64/ptrace.h b/include/asm-ia64/ptrace.h
index 9471cdc3f4c0..415abb23b210 100644
--- a/include/asm-ia64/ptrace.h
+++ b/include/asm-ia64/ptrace.h
@@ -54,7 +54,6 @@
  * This is because ar.ec is saved as part of ar.pfs.
  */
 
-#include <linux/config.h>
 
 #include <asm/fpu.h>
 #ifndef ASM_OFFSETS_C
diff --git a/include/asm-ia64/smp.h b/include/asm-ia64/smp.h
index a3914352c995..719ff309ce09 100644
--- a/include/asm-ia64/smp.h
+++ b/include/asm-ia64/smp.h
@@ -10,7 +10,6 @@
 #ifndef _ASM_IA64_SMP_H
 #define _ASM_IA64_SMP_H
 
-#include <linux/config.h>
 #include <linux/init.h>
 #include <linux/threads.h>
 #include <linux/kernel.h>
diff --git a/include/asm-ia64/sn/simulator.h b/include/asm-ia64/sn/simulator.h
index 16a48b5a039c..c3fd3eb25768 100644
--- a/include/asm-ia64/sn/simulator.h
+++ b/include/asm-ia64/sn/simulator.h
@@ -8,7 +8,6 @@
 #ifndef _ASM_IA64_SN_SIMULATOR_H
 #define _ASM_IA64_SN_SIMULATOR_H
 
-#include <linux/config.h>
 
 #define SNMAGIC 0xaeeeeeee8badbeefL
 #define IS_MEDUSA()                     ({long sn; asm("mov %0=cpuid[%1]" : "=r"(sn) : "r"(2)); sn == SNMAGIC;})
diff --git a/include/asm-ia64/sn/sn_cpuid.h b/include/asm-ia64/sn/sn_cpuid.h
index 749deb2ca6c1..a676dd9ace3e 100644
--- a/include/asm-ia64/sn/sn_cpuid.h
+++ b/include/asm-ia64/sn/sn_cpuid.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_IA64_SN_SN_CPUID_H
 #define _ASM_IA64_SN_SN_CPUID_H
 
-#include <linux/config.h>
 #include <linux/smp.h>
 #include <asm/sn/addrs.h>
 #include <asm/sn/pda.h>
diff --git a/include/asm-ia64/sn/sn_sal.h b/include/asm-ia64/sn/sn_sal.h
index 51aca022cf39..8c865e43f609 100644
--- a/include/asm-ia64/sn/sn_sal.h
+++ b/include/asm-ia64/sn/sn_sal.h
@@ -12,7 +12,6 @@
  */
 
 
-#include <linux/config.h>
 #include <asm/sal.h>
 #include <asm/sn/sn_cpuid.h>
 #include <asm/sn/arch.h>
diff --git a/include/asm-ia64/sn/xpc.h b/include/asm-ia64/sn/xpc.h
index aa3b8ace9030..8406f1ef4caf 100644
--- a/include/asm-ia64/sn/xpc.h
+++ b/include/asm-ia64/sn/xpc.h
@@ -15,7 +15,6 @@
 #define _ASM_IA64_SN_XPC_H
 
 
-#include <linux/config.h>
 #include <linux/interrupt.h>
 #include <linux/sysctl.h>
 #include <linux/device.h>
diff --git a/include/asm-ia64/string.h b/include/asm-ia64/string.h
index 43502d3b57e5..85fd65c52a8c 100644
--- a/include/asm-ia64/string.h
+++ b/include/asm-ia64/string.h
@@ -9,7 +9,6 @@
  *      David Mosberger-Tang <davidm@hpl.hp.com>
  */
 
-#include <linux/config.h>       /* remove this once we remove the A-step workaround... */
 
 #define __HAVE_ARCH_STRLEN      1 /* see arch/ia64/lib/strlen.S */
 #define __HAVE_ARCH_MEMSET      1 /* see arch/ia64/lib/memset.S */
diff --git a/include/asm-ia64/system.h b/include/asm-ia64/system.h
index 2f3620593687..65db43ce4de6 100644
--- a/include/asm-ia64/system.h
+++ b/include/asm-ia64/system.h
@@ -12,7 +12,6 @@
  * Copyright (C) 1999 Asit Mallick <asit.k.mallick@intel.com>
  * Copyright (C) 1999 Don Dugger <don.dugger@intel.com>
  */
-#include <linux/config.h>
 
 #include <asm/kregs.h>
 #include <asm/page.h>
diff --git a/include/asm-ia64/tlb.h b/include/asm-ia64/tlb.h
index 834370b9dea1..26edcb750f9f 100644
--- a/include/asm-ia64/tlb.h
+++ b/include/asm-ia64/tlb.h
@@ -37,7 +37,6 @@
  *      }
  *      tlb_finish_mmu(tlb, start, end);        // finish unmap for address space MM
  */
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <linux/pagemap.h>
 #include <linux/swap.h>
diff --git a/include/asm-ia64/tlbflush.h b/include/asm-ia64/tlbflush.h
index a35b323bae4c..cf9acb9bb1fb 100644
--- a/include/asm-ia64/tlbflush.h
+++ b/include/asm-ia64/tlbflush.h
@@ -6,7 +6,6 @@
  *      David Mosberger-Tang <davidm@hpl.hp.com>
  */
 
-#include <linux/config.h>
 
 #include <linux/mm.h>
 
diff --git a/include/asm-ia64/unistd.h b/include/asm-ia64/unistd.h
index 7107763168bf..632f2eedf72c 100644
--- a/include/asm-ia64/unistd.h
+++ b/include/asm-ia64/unistd.h
@@ -294,7 +294,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #define NR_syscalls                     279 /* length of syscall table */
 
diff --git a/include/asm-m32r/assembler.h b/include/asm-m32r/assembler.h
index 1a1aa17edd33..47041d19d4a8 100644
--- a/include/asm-m32r/assembler.h
+++ b/include/asm-m32r/assembler.h
@@ -9,7 +9,6 @@
  * This file contains M32R architecture specific macro definitions.
  */
 
-#include <linux/config.h>
 
 #ifndef __STR
 #ifdef __ASSEMBLY__
diff --git a/include/asm-m32r/atomic.h b/include/asm-m32r/atomic.h
index 3122fe106f05..f5a7d7301c72 100644
--- a/include/asm-m32r/atomic.h
+++ b/include/asm-m32r/atomic.h
@@ -9,7 +9,6 @@
  *    Copyright (C) 2004  Hirokazu Takata <takata at linux-m32r.org>
  */
 
-#include <linux/config.h>
 #include <asm/assembler.h>
 #include <asm/system.h>
 
diff --git a/include/asm-m32r/bitops.h b/include/asm-m32r/bitops.h
index 902a366101a5..66ab672162cd 100644
--- a/include/asm-m32r/bitops.h
+++ b/include/asm-m32r/bitops.h
@@ -11,7 +11,6 @@
  *    Copyright (C) 2004  Hirokazu Takata <takata at linux-m32r.org>
  */
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <asm/assembler.h>
 #include <asm/system.h>
diff --git a/include/asm-m32r/cacheflush.h b/include/asm-m32r/cacheflush.h
index e57427b6e249..8b261b49149e 100644
--- a/include/asm-m32r/cacheflush.h
+++ b/include/asm-m32r/cacheflush.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_M32R_CACHEFLUSH_H
 #define _ASM_M32R_CACHEFLUSH_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 
 extern void _flush_cache_all(void);
diff --git a/include/asm-m32r/hardirq.h b/include/asm-m32r/hardirq.h
index 5da830ec1587..cb8aa762f235 100644
--- a/include/asm-m32r/hardirq.h
+++ b/include/asm-m32r/hardirq.h
@@ -2,7 +2,6 @@
 #ifndef __ASM_HARDIRQ_H
 #define __ASM_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/irq.h>
 
diff --git a/include/asm-m32r/ide.h b/include/asm-m32r/ide.h
index f7aa96970d18..219a0f74eff3 100644
--- a/include/asm-m32r/ide.h
+++ b/include/asm-m32r/ide.h
@@ -15,7 +15,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #ifndef MAX_HWIFS
 # ifdef CONFIG_BLK_DEV_IDEPCI
diff --git a/include/asm-m32r/irq.h b/include/asm-m32r/irq.h
index ca943954572a..2f93f4743add 100644
--- a/include/asm-m32r/irq.h
+++ b/include/asm-m32r/irq.h
@@ -2,7 +2,6 @@
 #ifndef _ASM_M32R_IRQ_H
 #define _ASM_M32R_IRQ_H
 
-#include <linux/config.h>
 
 #if defined(CONFIG_PLAT_M32700UT_Alpha) || defined(CONFIG_PLAT_USRV)
 /*
diff --git a/include/asm-m32r/kmap_types.h b/include/asm-m32r/kmap_types.h
index 7429591010b6..0524d89edb0f 100644
--- a/include/asm-m32r/kmap_types.h
+++ b/include/asm-m32r/kmap_types.h
@@ -3,7 +3,6 @@
 
 /* Dummy header just to define km_type. */
 
-#include <linux/config.h>
 
 #ifdef CONFIG_DEBUG_HIGHMEM
 # define D(n) __KM_FENCE_##n ,
diff --git a/include/asm-m32r/m32104ut/m32104ut_pld.h b/include/asm-m32r/m32104ut/m32104ut_pld.h
index a4eac20553df..6ba4ddf7dcf7 100644
--- a/include/asm-m32r/m32104ut/m32104ut_pld.h
+++ b/include/asm-m32r/m32104ut/m32104ut_pld.h
@@ -15,7 +15,6 @@
 #ifndef _M32104UT_M32104UT_PLD_H
 #define _M32104UT_M32104UT_PLD_H
 
-#include <linux/config.h>
 
 #if defined(CONFIG_PLAT_M32104UT)
 #define PLD_PLAT_BASE           0x02c00000
diff --git a/include/asm-m32r/m32700ut/m32700ut_lan.h b/include/asm-m32r/m32700ut/m32700ut_lan.h
index 50545ec9c42c..c050b19e8101 100644
--- a/include/asm-m32r/m32700ut/m32700ut_lan.h
+++ b/include/asm-m32r/m32700ut/m32700ut_lan.h
@@ -15,7 +15,6 @@
 #ifndef _M32700UT_M32700UT_LAN_H
 #define _M32700UT_M32700UT_LAN_H
 
-#include <linux/config.h>
 
 #ifndef __ASSEMBLY__
 /*
diff --git a/include/asm-m32r/m32700ut/m32700ut_lcd.h b/include/asm-m32r/m32700ut/m32700ut_lcd.h
index ede6c77bd5e6..4da4e822e2f3 100644
--- a/include/asm-m32r/m32700ut/m32700ut_lcd.h
+++ b/include/asm-m32r/m32700ut/m32700ut_lcd.h
@@ -15,7 +15,6 @@
 #ifndef _M32700UT_M32700UT_LCD_H
 #define _M32700UT_M32700UT_LCD_H
 
-#include <linux/config.h>
 
 #ifndef __ASSEMBLY__
 /*
diff --git a/include/asm-m32r/m32700ut/m32700ut_pld.h b/include/asm-m32r/m32700ut/m32700ut_pld.h
index f5e479486696..f35f9159acff 100644
--- a/include/asm-m32r/m32700ut/m32700ut_pld.h
+++ b/include/asm-m32r/m32700ut/m32700ut_pld.h
@@ -15,7 +15,6 @@
 #ifndef _M32700UT_M32700UT_PLD_H
 #define _M32700UT_M32700UT_PLD_H
 
-#include <linux/config.h>
 
 #if defined(CONFIG_PLAT_M32700UT_Alpha)
 #define PLD_PLAT_BASE           0x08c00000
diff --git a/include/asm-m32r/m32r.h b/include/asm-m32r/m32r.h
index b133ca61acf1..decfc59907c7 100644
--- a/include/asm-m32r/m32r.h
+++ b/include/asm-m32r/m32r.h
@@ -7,7 +7,6 @@
  * Copyright (C) 2003, 2004  Renesas Technology Corp.
  */
 
-#include <linux/config.h>
 
 /* Chip type */
 #if defined(CONFIG_CHIP_XNUX_MP) || defined(CONFIG_CHIP_XNUX2_MP)
diff --git a/include/asm-m32r/mmu.h b/include/asm-m32r/mmu.h
index 9c00eb78ee50..cf3f6d78ac66 100644
--- a/include/asm-m32r/mmu.h
+++ b/include/asm-m32r/mmu.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_M32R_MMU_H
 #define _ASM_M32R_MMU_H
 
-#include <linux/config.h>
 
 #if !defined(CONFIG_MMU)
 typedef struct {
diff --git a/include/asm-m32r/mmu_context.h b/include/asm-m32r/mmu_context.h
index 3634c5361a9b..542302eb6bcb 100644
--- a/include/asm-m32r/mmu_context.h
+++ b/include/asm-m32r/mmu_context.h
@@ -3,7 +3,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #include <asm/m32r.h>
 
@@ -15,7 +14,6 @@
 
 #ifndef __ASSEMBLY__
 
-#include <linux/config.h>
 #include <asm/atomic.h>
 #include <asm/pgalloc.h>
 #include <asm/mmu.h>
diff --git a/include/asm-m32r/opsput/opsput_lan.h b/include/asm-m32r/opsput/opsput_lan.h
index 7a2a839eedab..61948296f445 100644
--- a/include/asm-m32r/opsput/opsput_lan.h
+++ b/include/asm-m32r/opsput/opsput_lan.h
@@ -15,7 +15,6 @@
 #ifndef _OPSPUT_OPSPUT_LAN_H
 #define _OPSPUT_OPSPUT_LAN_H
 
-#include <linux/config.h>
 
 #ifndef __ASSEMBLY__
 /*
diff --git a/include/asm-m32r/opsput/opsput_lcd.h b/include/asm-m32r/opsput/opsput_lcd.h
index 3a883e3d7187..44cfd7fe2d88 100644
--- a/include/asm-m32r/opsput/opsput_lcd.h
+++ b/include/asm-m32r/opsput/opsput_lcd.h
@@ -15,7 +15,6 @@
 #ifndef _OPSPUT_OPSPUT_LCD_H
 #define _OPSPUT_OPSPUT_LCD_H
 
-#include <linux/config.h>
 
 #ifndef __ASSEMBLY__
 /*
diff --git a/include/asm-m32r/opsput/opsput_pld.h b/include/asm-m32r/opsput/opsput_pld.h
index 2018e6925035..46296fe1ec1a 100644
--- a/include/asm-m32r/opsput/opsput_pld.h
+++ b/include/asm-m32r/opsput/opsput_pld.h
@@ -15,7 +15,6 @@
 #ifndef _OPSPUT_OPSPUT_PLD_H
 #define _OPSPUT_OPSPUT_PLD_H
 
-#include <linux/config.h>
 
 #define PLD_PLAT_BASE           0x1cc00000
 
diff --git a/include/asm-m32r/page.h b/include/asm-m32r/page.h
index 9ddbc087dbc5..9688be003620 100644
--- a/include/asm-m32r/page.h
+++ b/include/asm-m32r/page.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_M32R_PAGE_H
 #define _ASM_M32R_PAGE_H
 
-#include <linux/config.h>
 
 /* PAGE_SHIFT determines the page size */
 #define PAGE_SHIFT      12
diff --git a/include/asm-m32r/pgalloc.h b/include/asm-m32r/pgalloc.h
index 6da309b6fda7..e09a86c3cadf 100644
--- a/include/asm-m32r/pgalloc.h
+++ b/include/asm-m32r/pgalloc.h
@@ -3,7 +3,6 @@
 
 /* $Id$ */
 
-#include <linux/config.h>
 #include <linux/mm.h>
 
 #include <asm/io.h>
diff --git a/include/asm-m32r/pgtable-2level.h b/include/asm-m32r/pgtable-2level.h
index 861727c20e8f..be0f167e344a 100644
--- a/include/asm-m32r/pgtable-2level.h
+++ b/include/asm-m32r/pgtable-2level.h
@@ -3,7 +3,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 /*
  * traditional M32R two-level paging structure:
diff --git a/include/asm-m32r/pgtable.h b/include/asm-m32r/pgtable.h
index 75740debcd01..1983b7f4527a 100644
--- a/include/asm-m32r/pgtable.h
+++ b/include/asm-m32r/pgtable.h
@@ -20,7 +20,6 @@
 
 #ifndef __ASSEMBLY__
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <asm/processor.h>
 #include <asm/addrspace.h>
diff --git a/include/asm-m32r/processor.h b/include/asm-m32r/processor.h
index 09fd1813e780..32755bf136de 100644
--- a/include/asm-m32r/processor.h
+++ b/include/asm-m32r/processor.h
@@ -14,7 +14,6 @@
  */
 
 #include <linux/kernel.h>
-#include <linux/config.h>
 #include <asm/cache.h>
 #include <asm/ptrace.h>  /* pt_regs */
 
diff --git a/include/asm-m32r/ptrace.h b/include/asm-m32r/ptrace.h
index 53c792452dfc..a07fa90314d2 100644
--- a/include/asm-m32r/ptrace.h
+++ b/include/asm-m32r/ptrace.h
@@ -12,7 +12,6 @@
  *   Copyright (C) 2001-2002, 2004  Hirokazu Takata <takata at linux-m32r.org>
  */
 
-#include <linux/config.h>
 #include <asm/m32r.h>           /* M32R_PSW_BSM, M32R_PSW_BPM */
 
 /* 0 - 13 are integer registers (general purpose registers).  */
diff --git a/include/asm-m32r/rtc.h b/include/asm-m32r/rtc.h
index ec3cdf666c68..6b2b837c5978 100644
--- a/include/asm-m32r/rtc.h
+++ b/include/asm-m32r/rtc.h
@@ -4,7 +4,6 @@
 #define __RTC_H__
 
 
-#include <linux/config.h>
 
    /* Dallas DS1302 clock/calendar register numbers. */
 #  define RTC_SECONDS      0
diff --git a/include/asm-m32r/semaphore.h b/include/asm-m32r/semaphore.h
index 81750edc8916..41e45d7b87ef 100644
--- a/include/asm-m32r/semaphore.h
+++ b/include/asm-m32r/semaphore.h
@@ -12,7 +12,6 @@
  * Copyright (C) 2004, 2006  Hirokazu Takata <takata at linux-m32r.org>
  */
 
-#include <linux/config.h>
 #include <linux/wait.h>
 #include <linux/rwsem.h>
 #include <asm/assembler.h>
diff --git a/include/asm-m32r/serial.h b/include/asm-m32r/serial.h
index 1bf480f58493..5ac244c72f15 100644
--- a/include/asm-m32r/serial.h
+++ b/include/asm-m32r/serial.h
@@ -3,7 +3,6 @@
 
 /* include/asm-m32r/serial.h */
 
-#include <linux/config.h>
 
 #define BASE_BAUD       115200
 
diff --git a/include/asm-m32r/sigcontext.h b/include/asm-m32r/sigcontext.h
index 942b8a30937d..73025c0c41a1 100644
--- a/include/asm-m32r/sigcontext.h
+++ b/include/asm-m32r/sigcontext.h
@@ -3,7 +3,6 @@
 
 /* $Id$ */
 
-#include <linux/config.h>
 
 struct sigcontext {
         /* CPU registers */
diff --git a/include/asm-m32r/smp.h b/include/asm-m32r/smp.h
index 1184293e5712..650d2558c304 100644
--- a/include/asm-m32r/smp.h
+++ b/include/asm-m32r/smp.h
@@ -3,7 +3,6 @@
 
 /* $Id$ */
 
-#include <linux/config.h>
 
 #ifdef CONFIG_SMP
 #ifndef __ASSEMBLY__
diff --git a/include/asm-m32r/spinlock.h b/include/asm-m32r/spinlock.h
index 7de7def28da9..f94c1a673569 100644
--- a/include/asm-m32r/spinlock.h
+++ b/include/asm-m32r/spinlock.h
@@ -9,7 +9,6 @@
  *    Copyright (C) 2004  Hirokazu Takata <takata at linux-m32r.org>
  */
 
-#include <linux/config.h>       /* CONFIG_DEBUG_SPINLOCK, CONFIG_SMP */
 #include <linux/compiler.h>
 #include <asm/atomic.h>
 #include <asm/page.h>
diff --git a/include/asm-m32r/system.h b/include/asm-m32r/system.h
index e55013f378e5..33567e8bfe6b 100644
--- a/include/asm-m32r/system.h
+++ b/include/asm-m32r/system.h
@@ -10,7 +10,6 @@
  * Copyright (C) 2004, 2006  Hirokazu Takata <takata at linux-m32r.org>
  */
 
-#include <linux/config.h>
 #include <asm/assembler.h>
 
 #ifdef __KERNEL__
diff --git a/include/asm-m32r/timex.h b/include/asm-m32r/timex.h
index abf12e7ffbf3..e89bfd17db51 100644
--- a/include/asm-m32r/timex.h
+++ b/include/asm-m32r/timex.h
@@ -9,7 +9,6 @@
  * m32r architecture timex specifications
  */
 
-#include <linux/config.h>
 
 #define CLOCK_TICK_RATE (CONFIG_BUS_CLOCK / CONFIG_TIMER_DIVIDE)
 #define CLOCK_TICK_FACTOR       20      /* Factor of both 1000000 and CLOCK_TICK_RATE */
diff --git a/include/asm-m32r/tlbflush.h b/include/asm-m32r/tlbflush.h
index bc7c407dbd92..ae4494960593 100644
--- a/include/asm-m32r/tlbflush.h
+++ b/include/asm-m32r/tlbflush.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_M32R_TLBFLUSH_H
 #define _ASM_M32R_TLBFLUSH_H
 
-#include <linux/config.h>
 #include <asm/m32r.h>
 
 /*
diff --git a/include/asm-m32r/uaccess.h b/include/asm-m32r/uaccess.h
index 819cc28a94f7..26e978c7e3b4 100644
--- a/include/asm-m32r/uaccess.h
+++ b/include/asm-m32r/uaccess.h
@@ -11,7 +11,6 @@
 /*
  * User space memory access functions
  */
-#include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/thread_info.h>
 #include <asm/page.h>
diff --git a/include/asm-m32r/unistd.h b/include/asm-m32r/unistd.h
index be0eb014c3b0..cc31790d8077 100644
--- a/include/asm-m32r/unistd.h
+++ b/include/asm-m32r/unistd.h
@@ -295,6 +295,8 @@
 #define __NR_kexec_load         283
 #define __NR_waitid             284
 
+#ifdef __KERNEL__
+
 #define NR_syscalls 285
 
 /* user-visible error numbers are in the range -1 - -124: see
@@ -405,7 +407,6 @@ __asm__ __volatile__ (\
 __syscall_return(type,__res); \
 }
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_STAT64
 #define __ARCH_WANT_SYS_ALARM
@@ -421,7 +422,6 @@ __syscall_return(type,__res); \
 #define __ARCH_WANT_SYS_OLD_GETRLIMIT /*will be unused*/
 #define __ARCH_WANT_SYS_OLDUMOUNT
 #define __ARCH_WANT_SYS_RT_SIGACTION
-#endif
 
 #ifdef __KERNEL_SYSCALLS__
 
@@ -470,4 +470,5 @@ asmlinkage long sys_rt_sigaction(int sig,
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 #endif
 
+#endif /* __KERNEL__ */
 #endif /* _ASM_M32R_UNISTD_H */
diff --git a/include/asm-m68k/atomic.h b/include/asm-m68k/atomic.h
index 732d696d31a6..d5eed64cb833 100644
--- a/include/asm-m68k/atomic.h
+++ b/include/asm-m68k/atomic.h
@@ -1,7 +1,6 @@
 #ifndef __ARCH_M68K_ATOMIC__
 #define __ARCH_M68K_ATOMIC__
 
-#include <linux/config.h>
 
 #include <asm/system.h> /* local_irq_XXX() */
 
diff --git a/include/asm-m68k/bug.h b/include/asm-m68k/bug.h
index 072ce274d537..7b60776cc966 100644
--- a/include/asm-m68k/bug.h
+++ b/include/asm-m68k/bug.h
@@ -1,7 +1,6 @@
 #ifndef _M68K_BUG_H
 #define _M68K_BUG_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_BUG
 #ifdef CONFIG_DEBUG_BUGVERBOSE
diff --git a/include/asm-m68k/dma-mapping.h b/include/asm-m68k/dma-mapping.h
index b1920c703d82..dffd59cf1364 100644
--- a/include/asm-m68k/dma-mapping.h
+++ b/include/asm-m68k/dma-mapping.h
@@ -1,7 +1,6 @@
 #ifndef _M68K_DMA_MAPPING_H
 #define _M68K_DMA_MAPPING_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_PCI
 #include <asm-generic/dma-mapping.h>
diff --git a/include/asm-m68k/dma.h b/include/asm-m68k/dma.h
index d5266a886226..d0c9e61e57b4 100644
--- a/include/asm-m68k/dma.h
+++ b/include/asm-m68k/dma.h
@@ -1,7 +1,6 @@
 #ifndef _M68K_DMA_H
 #define _M68K_DMA_H 1
 
-#include <linux/config.h>
 
 /* it's useless on the m68k, but unfortunately needed by the new
    bootmem allocator (but this should do it for this) */
diff --git a/include/asm-m68k/dvma.h b/include/asm-m68k/dvma.h
index 5978f87b0a8a..e1112de5a5e3 100644
--- a/include/asm-m68k/dvma.h
+++ b/include/asm-m68k/dvma.h
@@ -9,7 +9,6 @@
 #ifndef __M68K_DVMA_H
 #define __M68K_DVMA_H
 
-#include <linux/config.h>
 
 #define DVMA_PAGE_SHIFT 13
 #define DVMA_PAGE_SIZE  (1UL << DVMA_PAGE_SHIFT)
diff --git a/include/asm-m68k/elf.h b/include/asm-m68k/elf.h
index 38bf8347f14d..eb63b85f9336 100644
--- a/include/asm-m68k/elf.h
+++ b/include/asm-m68k/elf.h
@@ -5,7 +5,6 @@
  * ELF register definitions..
  */
 
-#include <linux/config.h>
 #include <asm/ptrace.h>
 #include <asm/user.h>
 
diff --git a/include/asm-m68k/entry.h b/include/asm-m68k/entry.h
index 0396495cd97d..f8f6b185d793 100644
--- a/include/asm-m68k/entry.h
+++ b/include/asm-m68k/entry.h
@@ -1,7 +1,6 @@
 #ifndef __M68K_ENTRY_H
 #define __M68K_ENTRY_H
 
-#include <linux/config.h>
 #include <asm/setup.h>
 #include <asm/page.h>
 
diff --git a/include/asm-m68k/fpu.h b/include/asm-m68k/fpu.h
index 3bcf85065c19..59701d7b4e78 100644
--- a/include/asm-m68k/fpu.h
+++ b/include/asm-m68k/fpu.h
@@ -1,7 +1,6 @@
 #ifndef __M68K_FPU_H
 #define __M68K_FPU_H
 
-#include <linux/config.h>
 
 /*
  * MAX floating point unit state size (FSAVE/FRESTORE)
diff --git a/include/asm-m68k/hardirq.h b/include/asm-m68k/hardirq.h
index 5e1c5826c83d..394ee946015c 100644
--- a/include/asm-m68k/hardirq.h
+++ b/include/asm-m68k/hardirq.h
@@ -1,7 +1,6 @@
 #ifndef __M68K_HARDIRQ_H
 #define __M68K_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/cache.h>
 
diff --git a/include/asm-m68k/ide.h b/include/asm-m68k/ide.h
index 36118fd01867..365f76fb8013 100644
--- a/include/asm-m68k/ide.h
+++ b/include/asm-m68k/ide.h
@@ -31,7 +31,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #include <asm/setup.h>
 #include <asm/io.h>
diff --git a/include/asm-m68k/io.h b/include/asm-m68k/io.h
index dcfaa352d34c..5e0fcf41804d 100644
--- a/include/asm-m68k/io.h
+++ b/include/asm-m68k/io.h
@@ -23,7 +23,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <asm/raw_io.h>
 #include <asm/virtconvert.h>
diff --git a/include/asm-m68k/irq.h b/include/asm-m68k/irq.h
index 9ac047c400c4..b4f48b2a6a57 100644
--- a/include/asm-m68k/irq.h
+++ b/include/asm-m68k/irq.h
@@ -1,7 +1,6 @@
 #ifndef _M68K_IRQ_H_
 #define _M68K_IRQ_H_
 
-#include <linux/config.h>
 #include <linux/interrupt.h>
 
 /*
diff --git a/include/asm-m68k/mc146818rtc.h b/include/asm-m68k/mc146818rtc.h
index 11442095a8cf..11fe12ddb913 100644
--- a/include/asm-m68k/mc146818rtc.h
+++ b/include/asm-m68k/mc146818rtc.h
@@ -4,7 +4,6 @@
 #ifndef _ASM_MC146818RTC_H
 #define _ASM_MC146818RTC_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_ATARI
 /* RTC in Atari machines */
diff --git a/include/asm-m68k/mmu_context.h b/include/asm-m68k/mmu_context.h
index 661191d15c81..231d11bd8e32 100644
--- a/include/asm-m68k/mmu_context.h
+++ b/include/asm-m68k/mmu_context.h
@@ -1,7 +1,6 @@
 #ifndef __M68K_MMU_CONTEXT_H
 #define __M68K_MMU_CONTEXT_H
 
-#include <linux/config.h>
 
 static inline void enter_lazy_tlb(struct mm_struct *mm, struct task_struct *tsk)
 {
diff --git a/include/asm-m68k/motorola_pgtable.h b/include/asm-m68k/motorola_pgtable.h
index 1628723458f5..1ccc7338a54b 100644
--- a/include/asm-m68k/motorola_pgtable.h
+++ b/include/asm-m68k/motorola_pgtable.h
@@ -1,7 +1,6 @@
 #ifndef _MOTOROLA_PGTABLE_H
 #define _MOTOROLA_PGTABLE_H
 
-#include <linux/config.h>
 
 /*
  * Definitions for MMU descriptors
diff --git a/include/asm-m68k/openprom.h b/include/asm-m68k/openprom.h
index efbfb0bec6e2..869ab9176e9f 100644
--- a/include/asm-m68k/openprom.h
+++ b/include/asm-m68k/openprom.h
@@ -8,7 +8,6 @@
  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  */
 
-#include <linux/config.h>
 
 /* Empirical constants... */
 #ifdef CONFIG_SUN3
diff --git a/include/asm-m68k/page.h b/include/asm-m68k/page.h
index f206dfbc1d48..db017f838c29 100644
--- a/include/asm-m68k/page.h
+++ b/include/asm-m68k/page.h
@@ -1,7 +1,6 @@
 #ifndef _M68K_PAGE_H
 #define _M68K_PAGE_H
 
-#include <linux/config.h>
 
 /* PAGE_SHIFT determines the page size */
 #ifndef CONFIG_SUN3
diff --git a/include/asm-m68k/page_offset.h b/include/asm-m68k/page_offset.h
index 86d3c2845ad4..1cbdb7f30ac2 100644
--- a/include/asm-m68k/page_offset.h
+++ b/include/asm-m68k/page_offset.h
@@ -1,4 +1,3 @@
-#include <linux/config.h>
 
 /* This handles the memory map.. */
 #ifndef CONFIG_SUN3
diff --git a/include/asm-m68k/pgalloc.h b/include/asm-m68k/pgalloc.h
index b468b7958aaa..a9cfb4b99d88 100644
--- a/include/asm-m68k/pgalloc.h
+++ b/include/asm-m68k/pgalloc.h
@@ -2,7 +2,6 @@
 #ifndef M68K_PGALLOC_H
 #define M68K_PGALLOC_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <linux/highmem.h>
 #include <asm/setup.h>
diff --git a/include/asm-m68k/pgtable.h b/include/asm-m68k/pgtable.h
index add129e93fd7..f3aa05377987 100644
--- a/include/asm-m68k/pgtable.h
+++ b/include/asm-m68k/pgtable.h
@@ -3,7 +3,6 @@
 
 #include <asm-generic/4level-fixup.h>
 
-#include <linux/config.h>
 #include <asm/setup.h>
 
 #ifndef __ASSEMBLY__
diff --git a/include/asm-m68k/processor.h b/include/asm-m68k/processor.h
index 7982285e84ed..352799e71f08 100644
--- a/include/asm-m68k/processor.h
+++ b/include/asm-m68k/processor.h
@@ -13,7 +13,6 @@
  */
 #define current_text_addr() ({ __label__ _l; _l: &&_l;})
 
-#include <linux/config.h>
 #include <linux/thread_info.h>
 #include <asm/segment.h>
 #include <asm/fpu.h>
diff --git a/include/asm-m68k/semaphore-helper.h b/include/asm-m68k/semaphore-helper.h
index 1516a642f9a5..eef30ba0b499 100644
--- a/include/asm-m68k/semaphore-helper.h
+++ b/include/asm-m68k/semaphore-helper.h
@@ -9,7 +9,6 @@
  * m68k version by Andreas Schwab
  */
 
-#include <linux/config.h>
 #include <linux/errno.h>
 
 /*
diff --git a/include/asm-m68k/serial.h b/include/asm-m68k/serial.h
index 3fe29f8b0194..2b90d6e69070 100644
--- a/include/asm-m68k/serial.h
+++ b/include/asm-m68k/serial.h
@@ -6,7 +6,6 @@
  *
  */
 
-#include <linux/config.h>
 
 /*
  * This assumes you have a 1.8432 MHz clock for your UART.
diff --git a/include/asm-m68k/setup.h b/include/asm-m68k/setup.h
index a89aa84073e5..7facc9a46e74 100644
--- a/include/asm-m68k/setup.h
+++ b/include/asm-m68k/setup.h
@@ -23,7 +23,6 @@
 #ifndef _M68K_SETUP_H
 #define _M68K_SETUP_H
 
-#include <linux/config.h>
 
 
     /*
diff --git a/include/asm-m68k/shm.h b/include/asm-m68k/shm.h
index 3fa2f368fc1a..fa56ec84a126 100644
--- a/include/asm-m68k/shm.h
+++ b/include/asm-m68k/shm.h
@@ -1,7 +1,6 @@
 #ifndef _M68K_SHM_H
 #define _M68K_SHM_H
 
-#include <linux/config.h>
 
 /* format of page table entries that correspond to shared memory pages
    currently out in swap space (see also mm/swap.c):
diff --git a/include/asm-m68k/system.h b/include/asm-m68k/system.h
index 64d3481df74c..d6dd8052cd6f 100644
--- a/include/asm-m68k/system.h
+++ b/include/asm-m68k/system.h
@@ -1,7 +1,6 @@
 #ifndef _M68K_SYSTEM_H
 #define _M68K_SYSTEM_H
 
-#include <linux/config.h> /* get configuration macros */
 #include <linux/linkage.h>
 #include <linux/kernel.h>
 #include <asm/segment.h>
diff --git a/include/asm-m68k/tlbflush.h b/include/asm-m68k/tlbflush.h
index 8e61ccffe13a..31678831ee47 100644
--- a/include/asm-m68k/tlbflush.h
+++ b/include/asm-m68k/tlbflush.h
@@ -1,7 +1,6 @@
 #ifndef _M68K_TLBFLUSH_H
 #define _M68K_TLBFLUSH_H
 
-#include <linux/config.h>
 
 #ifndef CONFIG_SUN3
 
diff --git a/include/asm-m68k/unistd.h b/include/asm-m68k/unistd.h
index c2554bcd1747..f236fe92156f 100644
--- a/include/asm-m68k/unistd.h
+++ b/include/asm-m68k/unistd.h
@@ -285,6 +285,8 @@
 #define __NR_request_key        280
 #define __NR_keyctl             281
 
+#ifdef __KERNEL__
+
 #define NR_syscalls             282
 
 /* user-visible error numbers are in the range -1 - -124: see
@@ -383,7 +385,6 @@ __asm__ __volatile__ ("trap  #0" \
 __syscall_return(type,__res); \
 }
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_OLD_STAT
@@ -406,7 +407,6 @@ __syscall_return(type,__res); \
 #define __ARCH_WANT_SYS_SIGPENDING
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
-#endif
 
 #ifdef __KERNEL_SYSCALLS__
 
@@ -451,7 +451,7 @@ asmlinkage long sys_rt_sigaction(int sig,
                                 struct sigaction __user *oact,
                                 size_t sigsetsize);
 
-#endif
+#endif /* __KERNEL_SYSCALLS__ */
 
 /*
  * "Conditional" syscalls
@@ -461,4 +461,5 @@ asmlinkage long sys_rt_sigaction(int sig,
  */
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 
+#endif /* __KERNEL__ */
 #endif /* _ASM_M68K_UNISTD_H_ */
diff --git a/include/asm-m68k/virtconvert.h b/include/asm-m68k/virtconvert.h
index 8c4e8037b898..83a87c9b1a16 100644
--- a/include/asm-m68k/virtconvert.h
+++ b/include/asm-m68k/virtconvert.h
@@ -7,7 +7,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <asm/setup.h>
 #include <asm/page.h>
diff --git a/include/asm-m68knommu/bitops.h b/include/asm-m68knommu/bitops.h
index 0b68ccd327f7..d7fa7d9c0e0f 100644
--- a/include/asm-m68knommu/bitops.h
+++ b/include/asm-m68knommu/bitops.h
@@ -5,7 +5,6 @@
  * Copyright 1992, Linus Torvalds.
  */
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <asm/byteorder.h>      /* swab32 */
 #include <asm/system.h>         /* save_flags */
diff --git a/include/asm-m68knommu/coldfire.h b/include/asm-m68knommu/coldfire.h
index 6190f77b1e6c..2fabca91df83 100644
--- a/include/asm-m68knommu/coldfire.h
+++ b/include/asm-m68knommu/coldfire.h
@@ -12,7 +12,6 @@
 #define coldfire_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /*
  *      Define the processor support peripherals base address.
diff --git a/include/asm-m68knommu/commproc.h b/include/asm-m68knommu/commproc.h
index e522ca8193a2..0161ebb5d883 100644
--- a/include/asm-m68knommu/commproc.h
+++ b/include/asm-m68knommu/commproc.h
@@ -17,7 +17,6 @@
 #ifndef __CPM_360__
 #define __CPM_360__
 
-#include <linux/config.h>
 
 /* CPM Command register masks: */
 #define CPM_CR_RST      ((ushort)0x8000)
diff --git a/include/asm-m68knommu/dma-mapping.h b/include/asm-m68knommu/dma-mapping.h
index a6c42ba48da6..5622b855a577 100644
--- a/include/asm-m68knommu/dma-mapping.h
+++ b/include/asm-m68knommu/dma-mapping.h
@@ -1,7 +1,6 @@
 #ifndef _M68KNOMMU_DMA_MAPPING_H
 #define _M68KNOMMU_DMA_MAPPING_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_PCI
 #include <asm-generic/dma-mapping.h>
diff --git a/include/asm-m68knommu/dma.h b/include/asm-m68knommu/dma.h
index 43e98c96a5c2..3338001abb40 100644
--- a/include/asm-m68knommu/dma.h
+++ b/include/asm-m68knommu/dma.h
@@ -3,7 +3,6 @@
  
 //#define       DMA_DEBUG       1
 
-#include <linux/config.h>
 
 #ifdef CONFIG_COLDFIRE
 /*
diff --git a/include/asm-m68knommu/elf.h b/include/asm-m68knommu/elf.h
index 9919487703bc..40b1ed6827db 100644
--- a/include/asm-m68knommu/elf.h
+++ b/include/asm-m68knommu/elf.h
@@ -5,7 +5,6 @@
  * ELF register definitions..
  */
 
-#include <linux/config.h>
 #include <asm/ptrace.h>
 #include <asm/user.h>
 
diff --git a/include/asm-m68knommu/elia.h b/include/asm-m68knommu/elia.h
index f18b8e9d8c36..e037d4e2de33 100644
--- a/include/asm-m68knommu/elia.h
+++ b/include/asm-m68knommu/elia.h
@@ -12,7 +12,6 @@
 #define elia_h
 /****************************************************************************/
 
-#include <linux/config.h>
 #include <asm/coldfire.h>
 
 #ifdef CONFIG_eLIA
diff --git a/include/asm-m68knommu/entry.h b/include/asm-m68knommu/entry.h
index 06f5aa70b0b5..c2553d26273d 100644
--- a/include/asm-m68knommu/entry.h
+++ b/include/asm-m68knommu/entry.h
@@ -1,7 +1,6 @@
 #ifndef __M68KNOMMU_ENTRY_H
 #define __M68KNOMMU_ENTRY_H
 
-#include <linux/config.h>
 #include <asm/setup.h>
 #include <asm/page.h>
 
diff --git a/include/asm-m68knommu/fpu.h b/include/asm-m68knommu/fpu.h
index 225082991a03..b16b2e4fca2a 100644
--- a/include/asm-m68knommu/fpu.h
+++ b/include/asm-m68knommu/fpu.h
@@ -1,7 +1,6 @@
 #ifndef __M68KNOMMU_FPU_H
 #define __M68KNOMMU_FPU_H
 
-#include <linux/config.h>
 
 /*
  * MAX floating point unit state size (FSAVE/FRESTORE)
diff --git a/include/asm-m68knommu/hardirq.h b/include/asm-m68knommu/hardirq.h
index 476180f4cba2..980075bab792 100644
--- a/include/asm-m68knommu/hardirq.h
+++ b/include/asm-m68knommu/hardirq.h
@@ -1,7 +1,6 @@
 #ifndef __M68K_HARDIRQ_H
 #define __M68K_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/cache.h>
 #include <linux/threads.h>
 #include <asm/irq.h>
diff --git a/include/asm-m68knommu/io.h b/include/asm-m68knommu/io.h
index e08f2ee4b4a2..8df4cee2a0cd 100644
--- a/include/asm-m68knommu/io.h
+++ b/include/asm-m68knommu/io.h
@@ -3,7 +3,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 /*
  * These are for ISA/PCI shared memory _only_ and should never be used
diff --git a/include/asm-m68knommu/irq.h b/include/asm-m68knommu/irq.h
index 20c48ec858a4..2b408842a30e 100644
--- a/include/asm-m68knommu/irq.h
+++ b/include/asm-m68knommu/irq.h
@@ -1,7 +1,6 @@
 #ifndef _M68K_IRQ_H_
 #define _M68K_IRQ_H_
 
-#include <linux/config.h>
 #include <asm/ptrace.h>
 
 #ifdef CONFIG_COLDFIRE
diff --git a/include/asm-m68knommu/m5206sim.h b/include/asm-m68knommu/m5206sim.h
index d1e7509021c5..7e3594dea88b 100644
--- a/include/asm-m68knommu/m5206sim.h
+++ b/include/asm-m68knommu/m5206sim.h
@@ -12,7 +12,6 @@
 #define m5206sim_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /*
  *      Define the 5206 SIM register set addresses.
diff --git a/include/asm-m68knommu/m520xsim.h b/include/asm-m68knommu/m520xsim.h
index 6dc62869e62b..1dac22ea95ba 100644
--- a/include/asm-m68knommu/m520xsim.h
+++ b/include/asm-m68knommu/m520xsim.h
@@ -11,7 +11,6 @@
 #define m520xsim_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /*
  *  Define the 5282 SIM register set addresses.
diff --git a/include/asm-m68knommu/m523xsim.h b/include/asm-m68knommu/m523xsim.h
index 926cfb805df7..bf397313e93f 100644
--- a/include/asm-m68knommu/m523xsim.h
+++ b/include/asm-m68knommu/m523xsim.h
@@ -11,7 +11,6 @@
 #define m523xsim_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /*
  *      Define the 523x SIM register set addresses.
diff --git a/include/asm-m68knommu/m5272sim.h b/include/asm-m68knommu/m5272sim.h
index b40875362f46..6217edc21139 100644
--- a/include/asm-m68knommu/m5272sim.h
+++ b/include/asm-m68knommu/m5272sim.h
@@ -12,7 +12,6 @@
 #define m5272sim_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /*
  *      Define the 5272 SIM register set addresses.
diff --git a/include/asm-m68knommu/m527xsim.h b/include/asm-m68knommu/m527xsim.h
index e7878d0f7d7a..1f63ab3fb3e6 100644
--- a/include/asm-m68knommu/m527xsim.h
+++ b/include/asm-m68knommu/m527xsim.h
@@ -11,7 +11,6 @@
 #define m527xsim_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /*
  *      Define the 5270/5271 SIM register set addresses.
diff --git a/include/asm-m68knommu/m528xsim.h b/include/asm-m68knommu/m528xsim.h
index 610774a17f70..1a3b1ae06b1e 100644
--- a/include/asm-m68knommu/m528xsim.h
+++ b/include/asm-m68knommu/m528xsim.h
@@ -11,7 +11,6 @@
 #define m528xsim_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /*
  *      Define the 5280/5282 SIM register set addresses.
diff --git a/include/asm-m68knommu/mcfcache.h b/include/asm-m68knommu/mcfcache.h
index 9cb401421835..45d1ac57ea82 100644
--- a/include/asm-m68knommu/mcfcache.h
+++ b/include/asm-m68knommu/mcfcache.h
@@ -11,7 +11,6 @@
 #define __M68KNOMMU_MCFCACHE_H
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /*
  *      The different ColdFire families have different cache arrangments.
diff --git a/include/asm-m68knommu/mcfdma.h b/include/asm-m68knommu/mcfdma.h
index b93f8ba8a248..ea729e81a6be 100644
--- a/include/asm-m68knommu/mcfdma.h
+++ b/include/asm-m68knommu/mcfdma.h
@@ -11,7 +11,6 @@
 #define mcfdma_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /*
  *      Get address specific defines for this Coldfire member.
diff --git a/include/asm-m68knommu/mcfmbus.h b/include/asm-m68knommu/mcfmbus.h
index 4762589e858a..13df9d41bd1a 100644
--- a/include/asm-m68knommu/mcfmbus.h
+++ b/include/asm-m68knommu/mcfmbus.h
@@ -11,7 +11,6 @@
 
 #ifndef mcfmbus_h
 #define mcfmbus_h
-#include <linux/config.h>
 
 
 #define MCFMBUS_BASE            0x280
diff --git a/include/asm-m68knommu/mcfne.h b/include/asm-m68knommu/mcfne.h
index a71b1c8cb4f8..c920ccdb61fe 100644
--- a/include/asm-m68knommu/mcfne.h
+++ b/include/asm-m68knommu/mcfne.h
@@ -18,7 +18,6 @@
 #define mcfne_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /*
  *      Support for NE2000 clones devices in ColdFire based boards.
diff --git a/include/asm-m68knommu/mcfpci.h b/include/asm-m68knommu/mcfpci.h
index d6229047d06e..f1507dd06ec6 100644
--- a/include/asm-m68knommu/mcfpci.h
+++ b/include/asm-m68knommu/mcfpci.h
@@ -12,7 +12,6 @@
 #define mcfpci_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 #ifdef CONFIG_PCI
 
diff --git a/include/asm-m68knommu/mcfpit.h b/include/asm-m68knommu/mcfpit.h
index a685f1b45401..0d2672dd518a 100644
--- a/include/asm-m68knommu/mcfpit.h
+++ b/include/asm-m68knommu/mcfpit.h
@@ -11,7 +11,6 @@
 #define mcfpit_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /*
  *      Get address specific defines for the 5270/5271, 5280/5282, and 5208.
diff --git a/include/asm-m68knommu/mcfsim.h b/include/asm-m68knommu/mcfsim.h
index 81d74a31dc43..97a0c2734a72 100644
--- a/include/asm-m68knommu/mcfsim.h
+++ b/include/asm-m68knommu/mcfsim.h
@@ -12,7 +12,6 @@
 #define mcfsim_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /*
  *      Include 5204, 5206/e, 5235, 5249, 5270/5271, 5272, 5280/5282,
diff --git a/include/asm-m68knommu/mcfsmc.h b/include/asm-m68knommu/mcfsmc.h
index 2583900b9591..2d7a4dbd9683 100644
--- a/include/asm-m68knommu/mcfsmc.h
+++ b/include/asm-m68knommu/mcfsmc.h
@@ -17,7 +17,6 @@
  *      allow 8 bit accesses. So this code is 16bit access only.
  */
 
-#include <linux/config.h>
 
 #undef  outb
 #undef  inb
diff --git a/include/asm-m68knommu/mcftimer.h b/include/asm-m68knommu/mcftimer.h
index 0f47164c33a9..68bf33ac10d1 100644
--- a/include/asm-m68knommu/mcftimer.h
+++ b/include/asm-m68knommu/mcftimer.h
@@ -12,7 +12,6 @@
 #define mcftimer_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /*
  *      Get address specific defines for this ColdFire member.
diff --git a/include/asm-m68knommu/mcfuart.h b/include/asm-m68knommu/mcfuart.h
index b016fad83119..8040e43786be 100644
--- a/include/asm-m68knommu/mcfuart.h
+++ b/include/asm-m68knommu/mcfuart.h
@@ -12,7 +12,6 @@
 #define mcfuart_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /*
  *      Define the base address of the UARTS within the MBAR address
diff --git a/include/asm-m68knommu/mcfwdebug.h b/include/asm-m68knommu/mcfwdebug.h
index 6ceae103596b..27f70e45d700 100644
--- a/include/asm-m68knommu/mcfwdebug.h
+++ b/include/asm-m68knommu/mcfwdebug.h
@@ -10,7 +10,6 @@
 #ifndef mcfdebug_h
 #define mcfdebug_h
 /****************************************************************************/
-#include <linux/config.h>
 
 /* Define the debug module registers */
 #define MCFDEBUG_CSR    0x0                     /* Configuration status         */
diff --git a/include/asm-m68knommu/mmu_context.h b/include/asm-m68knommu/mmu_context.h
index 1e080eca9ca8..6c077d3a2572 100644
--- a/include/asm-m68knommu/mmu_context.h
+++ b/include/asm-m68knommu/mmu_context.h
@@ -1,7 +1,6 @@
 #ifndef __M68KNOMMU_MMU_CONTEXT_H
 #define __M68KNOMMU_MMU_CONTEXT_H
 
-#include <linux/config.h>
 #include <asm/setup.h>
 #include <asm/page.h>
 #include <asm/pgalloc.h>
diff --git a/include/asm-m68knommu/nettel.h b/include/asm-m68knommu/nettel.h
index 9bda307e6544..0299f6a2deeb 100644
--- a/include/asm-m68knommu/nettel.h
+++ b/include/asm-m68knommu/nettel.h
@@ -13,7 +13,6 @@
 #define nettel_h
 /****************************************************************************/
 
-#include <linux/config.h>
 
 /****************************************************************************/
 #ifdef CONFIG_NETtel
diff --git a/include/asm-m68knommu/page.h b/include/asm-m68knommu/page.h
index 942dfbead27f..a22bf5a88160 100644
--- a/include/asm-m68knommu/page.h
+++ b/include/asm-m68knommu/page.h
@@ -1,7 +1,6 @@
 #ifndef _M68KNOMMU_PAGE_H
 #define _M68KNOMMU_PAGE_H
 
-#include <linux/config.h>
 
 /* PAGE_SHIFT determines the page size */
 
diff --git a/include/asm-m68knommu/page_offset.h b/include/asm-m68knommu/page_offset.h
index 2b45645e9b29..8ed6d7b7d9d1 100644
--- a/include/asm-m68knommu/page_offset.h
+++ b/include/asm-m68knommu/page_offset.h
@@ -1,5 +1,4 @@
 
-#include <linux/config.h>
 
 /* This handles the memory map.. */
 
diff --git a/include/asm-m68knommu/param.h b/include/asm-m68knommu/param.h
index 3f57d5db81f5..4c9904d6512e 100644
--- a/include/asm-m68knommu/param.h
+++ b/include/asm-m68knommu/param.h
@@ -1,7 +1,6 @@
 #ifndef _M68KNOMMU_PARAM_H
 #define _M68KNOMMU_PARAM_H
 
-#include <linux/config.h>
 
 #if defined(CONFIG_CLEOPATRA)
 #define HZ 1000
diff --git a/include/asm-m68knommu/pgtable.h b/include/asm-m68knommu/pgtable.h
index 00893055e6c2..549ad231efad 100644
--- a/include/asm-m68knommu/pgtable.h
+++ b/include/asm-m68knommu/pgtable.h
@@ -7,7 +7,6 @@
  * (C) Copyright 2000-2002, Greg Ungerer <gerg@snapgear.com>
  */
 
-#include <linux/config.h>
 #include <linux/slab.h>
 #include <asm/processor.h>
 #include <asm/page.h>
diff --git a/include/asm-m68knommu/processor.h b/include/asm-m68knommu/processor.h
index ba393b1a023b..278b00bc60c5 100644
--- a/include/asm-m68knommu/processor.h
+++ b/include/asm-m68knommu/processor.h
@@ -13,7 +13,6 @@
  */
 #define current_text_addr() ({ __label__ _l; _l: &&_l;})
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <asm/types.h>
 #include <asm/segment.h>
diff --git a/include/asm-m68knommu/semaphore-helper.h b/include/asm-m68knommu/semaphore-helper.h
index a6586417c1c2..43da7bc483c7 100644
--- a/include/asm-m68knommu/semaphore-helper.h
+++ b/include/asm-m68knommu/semaphore-helper.h
@@ -9,7 +9,6 @@
  * m68k version by Andreas Schwab
  */
 
-#include <linux/config.h>
 
 /*
  * These two _must_ execute atomically wrt each other.
diff --git a/include/asm-m68knommu/system.h b/include/asm-m68knommu/system.h
index 6338afc850ba..2bbe2db00a22 100644
--- a/include/asm-m68knommu/system.h
+++ b/include/asm-m68knommu/system.h
@@ -1,7 +1,6 @@
 #ifndef _M68KNOMMU_SYSTEM_H
 #define _M68KNOMMU_SYSTEM_H
 
-#include <linux/config.h> /* get configuration macros */
 #include <linux/linkage.h>
 #include <asm/segment.h>
 #include <asm/entry.h>
diff --git a/include/asm-m68knommu/unaligned.h b/include/asm-m68knommu/unaligned.h
index 8876f034ea64..869e9dd24f54 100644
--- a/include/asm-m68knommu/unaligned.h
+++ b/include/asm-m68knommu/unaligned.h
@@ -1,7 +1,6 @@
 #ifndef __M68K_UNALIGNED_H
 #define __M68K_UNALIGNED_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_COLDFIRE
 
diff --git a/include/asm-m68knommu/unistd.h b/include/asm-m68knommu/unistd.h
index 5373988a7e51..1b2abdf281e1 100644
--- a/include/asm-m68knommu/unistd.h
+++ b/include/asm-m68knommu/unistd.h
@@ -286,6 +286,8 @@
 #define __NR_request_key        280
 #define __NR_keyctl             281
  
+#ifdef __KERNEL__
+
 #define NR_syscalls             282
 
 /* user-visible error numbers are in the range -1 - -122: see
@@ -437,7 +439,6 @@ type name(atype a, btype b, ctype c, dtype d, etype e)				\
   return (type)__res;                                                           \
 }
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_OLD_STAT
@@ -460,7 +461,6 @@ type name(atype a, btype b, ctype c, dtype d, etype e)				\
 #define __ARCH_WANT_SYS_SIGPENDING
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
-#endif
 
 #ifdef __KERNEL_SYSCALLS__
 
@@ -515,7 +515,7 @@ asmlinkage long sys_rt_sigaction(int sig,
                                 struct sigaction __user *oact,
                                 size_t sigsetsize);
 
-#endif
+#endif /* __KERNEL_SYSCALLS__ */
 
 /*
  * "Conditional" syscalls
@@ -525,4 +525,5 @@ asmlinkage long sys_rt_sigaction(int sig,
  */
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 
+#endif /* __KERNEL__ */
 #endif /* _ASM_M68K_UNISTD_H_ */
diff --git a/include/asm-mips/a.out.h b/include/asm-mips/a.out.h
index 2b3dc3bed4da..ef33c3f13484 100644
--- a/include/asm-mips/a.out.h
+++ b/include/asm-mips/a.out.h
@@ -10,7 +10,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #endif
 
diff --git a/include/asm-mips/addrspace.h b/include/asm-mips/addrspace.h
index 0cc6c7060f3c..45c706e34df1 100644
--- a/include/asm-mips/addrspace.h
+++ b/include/asm-mips/addrspace.h
@@ -10,7 +10,6 @@
 #ifndef _ASM_ADDRSPACE_H
 #define _ASM_ADDRSPACE_H
 
-#include <linux/config.h>
 #include <spaces.h>
 
 /*
diff --git a/include/asm-mips/arc/types.h b/include/asm-mips/arc/types.h
index bbb725c366fb..b9adcd6f0860 100644
--- a/include/asm-mips/arc/types.h
+++ b/include/asm-mips/arc/types.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_ARC_TYPES_H
 #define _ASM_ARC_TYPES_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_ARC32
 
diff --git a/include/asm-mips/asm.h b/include/asm-mips/asm.h
index 4b090f3142e0..e3038a4599ee 100644
--- a/include/asm-mips/asm.h
+++ b/include/asm-mips/asm.h
@@ -17,7 +17,6 @@
 #ifndef __ASM_ASM_H
 #define __ASM_ASM_H
 
-#include <linux/config.h>
 #include <asm/sgidefs.h>
 
 #ifndef CAT
diff --git a/include/asm-mips/asmmacro.h b/include/asm-mips/asmmacro.h
index f54aa147ec19..2c42f6b00a49 100644
--- a/include/asm-mips/asmmacro.h
+++ b/include/asm-mips/asmmacro.h
@@ -8,7 +8,6 @@
 #ifndef _ASM_ASMMACRO_H
 #define _ASM_ASMMACRO_H
 
-#include <linux/config.h>
 #include <asm/hazards.h>
 
 #ifdef CONFIG_32BIT
diff --git a/include/asm-mips/atomic.h b/include/asm-mips/atomic.h
index 2c8b853376c9..13d44e14025a 100644
--- a/include/asm-mips/atomic.h
+++ b/include/asm-mips/atomic.h
@@ -17,7 +17,6 @@
  * <linux/spinlock.h> we have to include <linux/spinlock.h> outside the
  * main big wrapper ...
  */
-#include <linux/config.h>
 #include <linux/spinlock.h>
 
 #ifndef _ASM_ATOMIC_H
diff --git a/include/asm-mips/bcache.h b/include/asm-mips/bcache.h
index 446102b34f4e..3646a3f2ed38 100644
--- a/include/asm-mips/bcache.h
+++ b/include/asm-mips/bcache.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_BCACHE_H
 #define _ASM_BCACHE_H
 
-#include <linux/config.h>
 
 /* Some R4000 / R4400 / R4600 / R5000 machines may have a non-dma-coherent,
    chipset implemented caches.  On machines with other CPUs the CPU does the
diff --git a/include/asm-mips/bitops.h b/include/asm-mips/bitops.h
index d2f444537e4b..098cec263681 100644
--- a/include/asm-mips/bitops.h
+++ b/include/asm-mips/bitops.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_BITOPS_H
 #define _ASM_BITOPS_H
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <linux/types.h>
 #include <asm/bug.h>
diff --git a/include/asm-mips/bug.h b/include/asm-mips/bug.h
index 87d49a5bdc63..7b4739dc8f3f 100644
--- a/include/asm-mips/bug.h
+++ b/include/asm-mips/bug.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_BUG_H
 #define __ASM_BUG_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_BUG
 
diff --git a/include/asm-mips/bugs.h b/include/asm-mips/bugs.h
index cb2ea7c15c7a..0d7f9c1f5546 100644
--- a/include/asm-mips/bugs.h
+++ b/include/asm-mips/bugs.h
@@ -7,7 +7,6 @@
 #ifndef _ASM_BUGS_H
 #define _ASM_BUGS_H
 
-#include <linux/config.h>
 #include <linux/delay.h>
 #include <asm/cpu.h>
 #include <asm/cpu-info.h>
diff --git a/include/asm-mips/byteorder.h b/include/asm-mips/byteorder.h
index aefc02f16fd8..eee83cbdf2b0 100644
--- a/include/asm-mips/byteorder.h
+++ b/include/asm-mips/byteorder.h
@@ -8,7 +8,6 @@
 #ifndef _ASM_BYTEORDER_H
 #define _ASM_BYTEORDER_H
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <asm/types.h>
 
diff --git a/include/asm-mips/cache.h b/include/asm-mips/cache.h
index 55e19f2ff0e0..37f175c42bb5 100644
--- a/include/asm-mips/cache.h
+++ b/include/asm-mips/cache.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_CACHE_H
 #define _ASM_CACHE_H
 
-#include <linux/config.h>
 #include <kmalloc.h>
 
 #define L1_CACHE_SHIFT          CONFIG_MIPS_L1_CACHE_SHIFT
diff --git a/include/asm-mips/checksum.h b/include/asm-mips/checksum.h
index b09f8971e95d..a5e6050ec0f3 100644
--- a/include/asm-mips/checksum.h
+++ b/include/asm-mips/checksum.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_CHECKSUM_H
 #define _ASM_CHECKSUM_H
 
-#include <linux/config.h>
 #include <linux/in6.h>
 
 #include <asm/uaccess.h>
diff --git a/include/asm-mips/cpu-features.h b/include/asm-mips/cpu-features.h
index 254e11ed247b..881ce1f9803d 100644
--- a/include/asm-mips/cpu-features.h
+++ b/include/asm-mips/cpu-features.h
@@ -9,7 +9,6 @@
 #ifndef __ASM_CPU_FEATURES_H
 #define __ASM_CPU_FEATURES_H
 
-#include <linux/config.h>
 
 #include <asm/cpu.h>
 #include <asm/cpu-info.h>
diff --git a/include/asm-mips/cpu-info.h b/include/asm-mips/cpu-info.h
index 6572ac703662..a2f0c8ea9160 100644
--- a/include/asm-mips/cpu-info.h
+++ b/include/asm-mips/cpu-info.h
@@ -12,7 +12,6 @@
 #ifndef __ASM_CPU_INFO_H
 #define __ASM_CPU_INFO_H
 
-#include <linux/config.h>
 #include <asm/cache.h>
 
 #ifdef CONFIG_SGI_IP27
diff --git a/include/asm-mips/ddb5xxx/ddb5477.h b/include/asm-mips/ddb5xxx/ddb5477.h
index a438548e6ef3..c5af4b73fdd7 100644
--- a/include/asm-mips/ddb5xxx/ddb5477.h
+++ b/include/asm-mips/ddb5xxx/ddb5477.h
@@ -17,7 +17,6 @@
 #ifndef __ASM_DDB5XXX_DDB5477_H
 #define __ASM_DDB5XXX_DDB5477_H
 
-#include <linux/config.h>
 
 /*
  * This contains macros that are specific to DDB5477 or renamed from
diff --git a/include/asm-mips/ddb5xxx/ddb5xxx.h b/include/asm-mips/ddb5xxx/ddb5xxx.h
index 2f1b191c6fff..e97fcc8d548b 100644
--- a/include/asm-mips/ddb5xxx/ddb5xxx.h
+++ b/include/asm-mips/ddb5xxx/ddb5xxx.h
@@ -18,7 +18,6 @@
 #ifndef __ASM_DDB5XXX_DDB5XXX_H
 #define __ASM_DDB5XXX_DDB5XXX_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 
 /*
diff --git a/include/asm-mips/debug.h b/include/asm-mips/debug.h
index 930f2b75e766..1fd5a2b39445 100644
--- a/include/asm-mips/debug.h
+++ b/include/asm-mips/debug.h
@@ -15,7 +15,6 @@
 #ifndef _ASM_DEBUG_H
 #define _ASM_DEBUG_H
 
-#include <linux/config.h>
 
 /*
  * run-time macros for catching spurious errors.  Eable CONFIG_RUNTIME_DEBUG in
diff --git a/include/asm-mips/dec/prom.h b/include/asm-mips/dec/prom.h
index 1384dd0964b9..b9c8203688d5 100644
--- a/include/asm-mips/dec/prom.h
+++ b/include/asm-mips/dec/prom.h
@@ -15,7 +15,6 @@
 #ifndef _ASM_DEC_PROM_H
 #define _ASM_DEC_PROM_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 
 #include <asm/addrspace.h>
diff --git a/include/asm-mips/delay.h b/include/asm-mips/delay.h
index 928f30f8c45c..ea77050f8e3a 100644
--- a/include/asm-mips/delay.h
+++ b/include/asm-mips/delay.h
@@ -10,7 +10,6 @@
 #ifndef _ASM_DELAY_H
 #define _ASM_DELAY_H
 
-#include <linux/config.h>
 #include <linux/param.h>
 #include <linux/smp.h>
 #include <asm/compiler.h>
diff --git a/include/asm-mips/dma.h b/include/asm-mips/dma.h
index 6aaf9939a716..e85849ac165f 100644
--- a/include/asm-mips/dma.h
+++ b/include/asm-mips/dma.h
@@ -12,7 +12,6 @@
 #ifndef _ASM_DMA_H
 #define _ASM_DMA_H
 
-#include <linux/config.h>
 #include <asm/io.h>                     /* need byte IO */
 #include <linux/spinlock.h>             /* And spinlocks */
 #include <linux/delay.h>
diff --git a/include/asm-mips/elf.h b/include/asm-mips/elf.h
index bdc9de2df1ef..ebd6bfb19d66 100644
--- a/include/asm-mips/elf.h
+++ b/include/asm-mips/elf.h
@@ -8,7 +8,6 @@
 #ifndef _ASM_ELF_H
 #define _ASM_ELF_H
 
-#include <linux/config.h>
 
 /* ELF header e_flags defines. */
 /* MIPS architecture level. */
diff --git a/include/asm-mips/fcntl.h b/include/asm-mips/fcntl.h
index 43d047a9a6af..787220e6c1fc 100644
--- a/include/asm-mips/fcntl.h
+++ b/include/asm-mips/fcntl.h
@@ -8,7 +8,6 @@
 #ifndef _ASM_FCNTL_H
 #define _ASM_FCNTL_H
 
-#include <linux/config.h>
 
 #define O_APPEND        0x0008
 #define O_SYNC          0x0010
diff --git a/include/asm-mips/fixmap.h b/include/asm-mips/fixmap.h
index 73a3028dd9f9..1cadefbbc037 100644
--- a/include/asm-mips/fixmap.h
+++ b/include/asm-mips/fixmap.h
@@ -13,7 +13,6 @@
 #ifndef _ASM_FIXMAP_H
 #define _ASM_FIXMAP_H
 
-#include <linux/config.h>
 #include <asm/page.h>
 #ifdef CONFIG_HIGHMEM
 #include <linux/threads.h>
diff --git a/include/asm-mips/fpu.h b/include/asm-mips/fpu.h
index 8bf510a27c64..58c561a9ec6b 100644
--- a/include/asm-mips/fpu.h
+++ b/include/asm-mips/fpu.h
@@ -10,7 +10,6 @@
 #ifndef _ASM_FPU_H
 #define _ASM_FPU_H
 
-#include <linux/config.h>
 #include <linux/sched.h>
 #include <linux/thread_info.h>
 
diff --git a/include/asm-mips/futex.h b/include/asm-mips/futex.h
index 1f94640becc4..ed023eae0674 100644
--- a/include/asm-mips/futex.h
+++ b/include/asm-mips/futex.h
@@ -3,7 +3,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/futex.h>
 #include <asm/errno.h>
 #include <asm/uaccess.h>
diff --git a/include/asm-mips/hazards.h b/include/asm-mips/hazards.h
index dadc05188db7..66943c451c1d 100644
--- a/include/asm-mips/hazards.h
+++ b/include/asm-mips/hazards.h
@@ -10,7 +10,6 @@
 #ifndef _ASM_HAZARDS_H
 #define _ASM_HAZARDS_H
 
-#include <linux/config.h>
 
 #ifdef __ASSEMBLY__
 
diff --git a/include/asm-mips/highmem.h b/include/asm-mips/highmem.h
index 8cf598402492..c976bfaaba83 100644
--- a/include/asm-mips/highmem.h
+++ b/include/asm-mips/highmem.h
@@ -19,7 +19,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <asm/kmap_types.h>
diff --git a/include/asm-mips/interrupt.h b/include/asm-mips/interrupt.h
index 4bb9c06f4410..a99d6867510f 100644
--- a/include/asm-mips/interrupt.h
+++ b/include/asm-mips/interrupt.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_INTERRUPT_H
 #define _ASM_INTERRUPT_H
 
-#include <linux/config.h>
 #include <asm/hazards.h>
 
 __asm__ (
diff --git a/include/asm-mips/io.h b/include/asm-mips/io.h
index 6b17eb9d79a5..df624e1ee6e2 100644
--- a/include/asm-mips/io.h
+++ b/include/asm-mips/io.h
@@ -12,7 +12,6 @@
 #ifndef _ASM_IO_H
 #define _ASM_IO_H
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
diff --git a/include/asm-mips/ip32/machine.h b/include/asm-mips/ip32/machine.h
index e440fdf4b232..1b631b8da6f8 100644
--- a/include/asm-mips/ip32/machine.h
+++ b/include/asm-mips/ip32/machine.h
@@ -10,7 +10,6 @@
 #ifndef _ASM_IP32_MACHINE_H
 #define _ASM_IP32_MACHINE_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_SGI_IP32
 
diff --git a/include/asm-mips/irq.h b/include/asm-mips/irq.h
index dde677f02bc0..d35c61776a02 100644
--- a/include/asm-mips/irq.h
+++ b/include/asm-mips/irq.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_IRQ_H
 #define _ASM_IRQ_H
 
-#include <linux/config.h>
 #include <linux/linkage.h>
 
 #include <asm/mipsmtregs.h>
diff --git a/include/asm-mips/isadep.h b/include/asm-mips/isadep.h
index 7bb003511d9e..24c6cda79377 100644
--- a/include/asm-mips/isadep.h
+++ b/include/asm-mips/isadep.h
@@ -5,7 +5,6 @@
  *
  * Copyright (c) 1998 Harald Koerfgen
  */
-#include <linux/config.h>
 
 #ifndef __ASM_ISADEP_H
 #define __ASM_ISADEP_H
diff --git a/include/asm-mips/jmr3927/irq.h b/include/asm-mips/jmr3927/irq.h
index b0c325a22343..fe551f33a74f 100644
--- a/include/asm-mips/jmr3927/irq.h
+++ b/include/asm-mips/jmr3927/irq.h
@@ -12,7 +12,6 @@
 
 #ifndef __ASSEMBLY__
 
-#include <linux/config.h>
 #include <asm/irq.h>
 
 struct tb_irq_space {
diff --git a/include/asm-mips/kmap_types.h b/include/asm-mips/kmap_types.h
index 6886a0c3fedf..806aae3c5338 100644
--- a/include/asm-mips/kmap_types.h
+++ b/include/asm-mips/kmap_types.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_KMAP_TYPES_H
 #define _ASM_KMAP_TYPES_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_DEBUG_HIGHMEM
 # define D(n) __KM_FENCE_##n ,
diff --git a/include/asm-mips/local.h b/include/asm-mips/local.h
index c38844f615fc..9e2d43bae388 100644
--- a/include/asm-mips/local.h
+++ b/include/asm-mips/local.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_LOCAL_H
 #define _ASM_LOCAL_H
 
-#include <linux/config.h>
 #include <linux/percpu.h>
 #include <asm/atomic.h>
 
diff --git a/include/asm-mips/mach-au1x00/au1000.h b/include/asm-mips/mach-au1x00/au1000.h
index 4686e17c206c..582acd8adb81 100644
--- a/include/asm-mips/mach-au1x00/au1000.h
+++ b/include/asm-mips/mach-au1x00/au1000.h
@@ -35,7 +35,6 @@
 #ifndef _AU1000_H_
 #define _AU1000_H_
 
-#include <linux/config.h>
 
 #ifndef _LANGUAGE_ASSEMBLY
 
diff --git a/include/asm-mips/mach-au1x00/au1xxx.h b/include/asm-mips/mach-au1x00/au1xxx.h
index b7b46dd9b929..947135941033 100644
--- a/include/asm-mips/mach-au1x00/au1xxx.h
+++ b/include/asm-mips/mach-au1x00/au1xxx.h
@@ -23,7 +23,6 @@
 #ifndef _AU1XXX_H_
 #define _AU1XXX_H_
 
-#include <linux/config.h>
 
 #include <asm/mach-au1x00/au1000.h>
 
diff --git a/include/asm-mips/mach-au1x00/au1xxx_dbdma.h b/include/asm-mips/mach-au1x00/au1xxx_dbdma.h
index b327bcd3fee1..d5b38a247e5a 100644
--- a/include/asm-mips/mach-au1x00/au1xxx_dbdma.h
+++ b/include/asm-mips/mach-au1x00/au1xxx_dbdma.h
@@ -34,7 +34,6 @@
 #ifndef _AU1000_DBDMA_H_
 #define _AU1000_DBDMA_H_
 
-#include <linux/config.h>
 
 #ifndef _LANGUAGE_ASSEMBLY
 
diff --git a/include/asm-mips/mach-au1x00/au1xxx_ide.h b/include/asm-mips/mach-au1x00/au1xxx_ide.h
index e867b4ef96d1..301e71300779 100644
--- a/include/asm-mips/mach-au1x00/au1xxx_ide.h
+++ b/include/asm-mips/mach-au1x00/au1xxx_ide.h
@@ -29,7 +29,6 @@
  * Note: for more information, please refer "AMD Alchemy Au1200/Au1550 IDE
  *       Interface and Linux Device Driver" Application Note.
  */
-#include <linux/config.h>
 
 #ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
         #define DMA_WAIT_TIMEOUT        100
diff --git a/include/asm-mips/mach-au1x00/au1xxx_psc.h b/include/asm-mips/mach-au1x00/au1xxx_psc.h
index 8e5fb3c7da4d..5c3e2a38ce12 100644
--- a/include/asm-mips/mach-au1x00/au1xxx_psc.h
+++ b/include/asm-mips/mach-au1x00/au1xxx_psc.h
@@ -33,7 +33,6 @@
 #ifndef _AU1000_PSC_H_
 #define _AU1000_PSC_H_
 
-#include <linux/config.h>
 
 /* The PSC base addresses.  */
 #ifdef CONFIG_SOC_AU1550
diff --git a/include/asm-mips/mach-au1x00/ioremap.h b/include/asm-mips/mach-au1x00/ioremap.h
index d3ec6274575a..098fca4289bb 100644
--- a/include/asm-mips/mach-au1x00/ioremap.h
+++ b/include/asm-mips/mach-au1x00/ioremap.h
@@ -9,7 +9,6 @@
 #ifndef __ASM_MACH_AU1X00_IOREMAP_H
 #define __ASM_MACH_AU1X00_IOREMAP_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 
 #ifdef CONFIG_64BIT_PHYS_ADDR
diff --git a/include/asm-mips/mach-cobalt/cpu-feature-overrides.h b/include/asm-mips/mach-cobalt/cpu-feature-overrides.h
index ace8c5ef9701..e0e08fc5d7f7 100644
--- a/include/asm-mips/mach-cobalt/cpu-feature-overrides.h
+++ b/include/asm-mips/mach-cobalt/cpu-feature-overrides.h
@@ -8,7 +8,6 @@
 #ifndef __ASM_COBALT_CPU_FEATURE_OVERRIDES_H
 #define __ASM_COBALT_CPU_FEATURE_OVERRIDES_H
 
-#include <linux/config.h>
 
 #define cpu_has_tlb             1
 #define cpu_has_4kex            1
diff --git a/include/asm-mips/mach-db1x00/db1x00.h b/include/asm-mips/mach-db1x00/db1x00.h
index 7b28b23f91ce..8fbb4b42a8b5 100644
--- a/include/asm-mips/mach-db1x00/db1x00.h
+++ b/include/asm-mips/mach-db1x00/db1x00.h
@@ -28,7 +28,6 @@
 #ifndef __ASM_DB1X00_H
 #define __ASM_DB1X00_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_MIPS_DB1550
 #define BCSR_KSEG1_ADDR 0xAF000000
diff --git a/include/asm-mips/mach-generic/ide.h b/include/asm-mips/mach-generic/ide.h
index e3315359500a..6eba2e576aaa 100644
--- a/include/asm-mips/mach-generic/ide.h
+++ b/include/asm-mips/mach-generic/ide.h
@@ -15,7 +15,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/pci.h>
 #include <linux/stddef.h>
 #include <asm/processor.h>
diff --git a/include/asm-mips/mach-generic/kmalloc.h b/include/asm-mips/mach-generic/kmalloc.h
index 373d66dee9d7..410ab5f6c563 100644
--- a/include/asm-mips/mach-generic/kmalloc.h
+++ b/include/asm-mips/mach-generic/kmalloc.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_MACH_GENERIC_KMALLOC_H
 #define __ASM_MACH_GENERIC_KMALLOC_H
 
-#include <linux/config.h>
 
 #ifndef CONFIG_DMA_COHERENT
 /*
diff --git a/include/asm-mips/mach-generic/spaces.h b/include/asm-mips/mach-generic/spaces.h
index b849d8dd7e78..0ae9997bc9a8 100644
--- a/include/asm-mips/mach-generic/spaces.h
+++ b/include/asm-mips/mach-generic/spaces.h
@@ -10,7 +10,6 @@
 #ifndef _ASM_MACH_GENERIC_SPACES_H
 #define _ASM_MACH_GENERIC_SPACES_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_32BIT
 
diff --git a/include/asm-mips/mach-ip22/spaces.h b/include/asm-mips/mach-ip22/spaces.h
index 8385f716798d..ab20c026fd19 100644
--- a/include/asm-mips/mach-ip22/spaces.h
+++ b/include/asm-mips/mach-ip22/spaces.h
@@ -10,7 +10,6 @@
 #ifndef _ASM_MACH_IP22_SPACES_H
 #define _ASM_MACH_IP22_SPACES_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_32BIT
 
diff --git a/include/asm-mips/mach-ip32/cpu-feature-overrides.h b/include/asm-mips/mach-ip32/cpu-feature-overrides.h
index f0ef1ac9ecd7..2a3de092bf13 100644
--- a/include/asm-mips/mach-ip32/cpu-feature-overrides.h
+++ b/include/asm-mips/mach-ip32/cpu-feature-overrides.h
@@ -9,7 +9,6 @@
 #ifndef __ASM_MACH_IP32_CPU_FEATURE_OVERRIDES_H
 #define __ASM_MACH_IP32_CPU_FEATURE_OVERRIDES_H
 
-#include <linux/config.h>
 
 /*
  * R5000 has an interesting "restriction":  ll(d)/sc(d)
diff --git a/include/asm-mips/mach-ip32/kmalloc.h b/include/asm-mips/mach-ip32/kmalloc.h
index 9d2d4d9ac036..f6198a21fba1 100644
--- a/include/asm-mips/mach-ip32/kmalloc.h
+++ b/include/asm-mips/mach-ip32/kmalloc.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_MACH_IP32_KMALLOC_H
 #define __ASM_MACH_IP32_KMALLOC_H
 
-#include <linux/config.h>
 
 #if defined(CONFIG_CPU_R5000) || defined (CONFIG_CPU_RM7000)
 #define ARCH_KMALLOC_MINALIGN   32
diff --git a/include/asm-mips/mach-mips/cpu-feature-overrides.h b/include/asm-mips/mach-mips/cpu-feature-overrides.h
index 12c937283bb4..e960679f54ba 100644
--- a/include/asm-mips/mach-mips/cpu-feature-overrides.h
+++ b/include/asm-mips/mach-mips/cpu-feature-overrides.h
@@ -9,7 +9,6 @@
 #ifndef __ASM_MACH_MIPS_CPU_FEATURE_OVERRIDES_H
 #define __ASM_MACH_MIPS_CPU_FEATURE_OVERRIDES_H
 
-#include <linux/config.h>
 
 /*
  * CPU feature overrides for MIPS boards
diff --git a/include/asm-mips/mach-mips/irq.h b/include/asm-mips/mach-mips/irq.h
index f8579696ca54..083d9c512a04 100644
--- a/include/asm-mips/mach-mips/irq.h
+++ b/include/asm-mips/mach-mips/irq.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_MACH_MIPS_IRQ_H
 #define __ASM_MACH_MIPS_IRQ_H
 
-#include <linux/config.h>
 
 #define NR_IRQS 256
 
diff --git a/include/asm-mips/mach-pb1x00/pb1550.h b/include/asm-mips/mach-pb1x00/pb1550.h
index 9578ead11e8a..9a4955ce3b4a 100644
--- a/include/asm-mips/mach-pb1x00/pb1550.h
+++ b/include/asm-mips/mach-pb1x00/pb1550.h
@@ -27,7 +27,6 @@
 #ifndef __ASM_PB1550_H
 #define __ASM_PB1550_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 
 #define DBDMA_AC97_TX_CHAN DSCR_CMD0_PSC1_TX
diff --git a/include/asm-mips/mach-sim/cpu-feature-overrides.h b/include/asm-mips/mach-sim/cpu-feature-overrides.h
index d9653e47d5fc..d736bdadb6df 100644
--- a/include/asm-mips/mach-sim/cpu-feature-overrides.h
+++ b/include/asm-mips/mach-sim/cpu-feature-overrides.h
@@ -8,7 +8,6 @@
 #ifndef __ASM_MACH_SIM_CPU_FEATURE_OVERRIDES_H
 #define __ASM_MACH_SIM_CPU_FEATURE_OVERRIDES_H
 
-#include <linux/config.h>
 
 /*
  * CPU feature overrides for MIPS boards
diff --git a/include/asm-mips/mips-boards/generic.h b/include/asm-mips/mips-boards/generic.h
index fa8b913cc3e0..b98f1658cfd0 100644
--- a/include/asm-mips/mips-boards/generic.h
+++ b/include/asm-mips/mips-boards/generic.h
@@ -20,7 +20,6 @@
 #ifndef __ASM_MIPS_BOARDS_GENERIC_H
 #define __ASM_MIPS_BOARDS_GENERIC_H
 
-#include <linux/config.h>
 #include <asm/addrspace.h>
 #include <asm/byteorder.h>
 #include <asm/mips-boards/bonito64.h>
diff --git a/include/asm-mips/mipsregs.h b/include/asm-mips/mipsregs.h
index 98b68089aa53..673977901ed3 100644
--- a/include/asm-mips/mipsregs.h
+++ b/include/asm-mips/mipsregs.h
@@ -13,7 +13,6 @@
 #ifndef _ASM_MIPSREGS_H
 #define _ASM_MIPSREGS_H
 
-#include <linux/config.h>
 #include <linux/linkage.h>
 #include <asm/hazards.h>
 
diff --git a/include/asm-mips/mmu_context.h b/include/asm-mips/mmu_context.h
index 6e09f4c87211..18b69de87daa 100644
--- a/include/asm-mips/mmu_context.h
+++ b/include/asm-mips/mmu_context.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_MMU_CONTEXT_H
 #define _ASM_MMU_CONTEXT_H
 
-#include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
diff --git a/include/asm-mips/mmzone.h b/include/asm-mips/mmzone.h
index f6bd2e0c45a1..dc231c89bef9 100644
--- a/include/asm-mips/mmzone.h
+++ b/include/asm-mips/mmzone.h
@@ -5,7 +5,6 @@
 #ifndef _ASM_MMZONE_H_
 #define _ASM_MMZONE_H_
 
-#include <linux/config.h>
 #include <asm/page.h>
 #include <mmzone.h>
 
diff --git a/include/asm-mips/module.h b/include/asm-mips/module.h
index 2af496c78c12..399d03f1c4fc 100644
--- a/include/asm-mips/module.h
+++ b/include/asm-mips/module.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_MODULE_H
 #define _ASM_MODULE_H
 
-#include <linux/config.h>
 #include <linux/list.h>
 #include <asm/uaccess.h>
 
diff --git a/include/asm-mips/msgbuf.h b/include/asm-mips/msgbuf.h
index a1533959742e..0d6c7f14de31 100644
--- a/include/asm-mips/msgbuf.h
+++ b/include/asm-mips/msgbuf.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_MSGBUF_H
 #define _ASM_MSGBUF_H
 
-#include <linux/config.h>
 
 /*
  * The msqid64_ds structure for the MIPS architecture.
diff --git a/include/asm-mips/paccess.h b/include/asm-mips/paccess.h
index 46f2d23d2697..147844ef103b 100644
--- a/include/asm-mips/paccess.h
+++ b/include/asm-mips/paccess.h
@@ -13,7 +13,6 @@
 #ifndef _ASM_PACCESS_H
 #define _ASM_PACCESS_H
 
-#include <linux/config.h>
 #include <linux/errno.h>
 
 #ifdef CONFIG_32BIT
diff --git a/include/asm-mips/page.h b/include/asm-mips/page.h
index 3d262c01521c..6b97744f00cd 100644
--- a/include/asm-mips/page.h
+++ b/include/asm-mips/page.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_PAGE_H
 #define _ASM_PAGE_H
 
-#include <linux/config.h>
 
 #ifdef __KERNEL__
 
diff --git a/include/asm-mips/pci.h b/include/asm-mips/pci.h
index 6c9ad8171a77..c4d68bebdca6 100644
--- a/include/asm-mips/pci.h
+++ b/include/asm-mips/pci.h
@@ -6,7 +6,6 @@
 #ifndef _ASM_PCI_H
 #define _ASM_PCI_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 
 #ifdef __KERNEL__
diff --git a/include/asm-mips/pgalloc.h b/include/asm-mips/pgalloc.h
index fe1df572318b..582c1fe6cc4a 100644
--- a/include/asm-mips/pgalloc.h
+++ b/include/asm-mips/pgalloc.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_PGALLOC_H
 #define _ASM_PGALLOC_H
 
-#include <linux/config.h>
 #include <linux/highmem.h>
 #include <linux/mm.h>
 
diff --git a/include/asm-mips/pgtable-32.h b/include/asm-mips/pgtable-32.h
index 087c20769256..4b26d8528133 100644
--- a/include/asm-mips/pgtable-32.h
+++ b/include/asm-mips/pgtable-32.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_PGTABLE_32_H
 #define _ASM_PGTABLE_32_H
 
-#include <linux/config.h>
 #include <asm/addrspace.h>
 #include <asm/page.h>
 
diff --git a/include/asm-mips/pgtable-64.h b/include/asm-mips/pgtable-64.h
index 2faf5c9ff127..e3db93212eab 100644
--- a/include/asm-mips/pgtable-64.h
+++ b/include/asm-mips/pgtable-64.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_PGTABLE_64_H
 #define _ASM_PGTABLE_64_H
 
-#include <linux/config.h>
 #include <linux/linkage.h>
 
 #include <asm/addrspace.h>
diff --git a/include/asm-mips/pgtable-bits.h b/include/asm-mips/pgtable-bits.h
index 01e76e932e3f..7494ba91112a 100644
--- a/include/asm-mips/pgtable-bits.h
+++ b/include/asm-mips/pgtable-bits.h
@@ -10,7 +10,6 @@
 #ifndef _ASM_PGTABLE_BITS_H
 #define _ASM_PGTABLE_BITS_H
 
-#include <linux/config.h>
 
 /*
  * Note that we shift the lower 32bits of each EntryLo[01] entry
diff --git a/include/asm-mips/pgtable.h b/include/asm-mips/pgtable.h
index be75cca20e8d..a36ca1be17f2 100644
--- a/include/asm-mips/pgtable.h
+++ b/include/asm-mips/pgtable.h
@@ -8,7 +8,6 @@
 #ifndef _ASM_PGTABLE_H
 #define _ASM_PGTABLE_H
 
-#include <linux/config.h>
 #ifdef CONFIG_32BIT
 #include <asm/pgtable-32.h>
 #endif
diff --git a/include/asm-mips/prefetch.h b/include/asm-mips/prefetch.h
index 71293ec1657c..17850834ccb0 100644
--- a/include/asm-mips/prefetch.h
+++ b/include/asm-mips/prefetch.h
@@ -8,7 +8,6 @@
 #ifndef __ASM_PREFETCH_H
 #define __ASM_PREFETCH_H
 
-#include <linux/config.h>
 
 /*
  * R5000 and RM5200 implements pref and prefx instructions but they're nops, so
diff --git a/include/asm-mips/processor.h b/include/asm-mips/processor.h
index 83936469fe87..5f80ba71ab92 100644
--- a/include/asm-mips/processor.h
+++ b/include/asm-mips/processor.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_PROCESSOR_H
 #define _ASM_PROCESSOR_H
 
-#include <linux/config.h>
 #include <linux/cpumask.h>
 #include <linux/threads.h>
 
diff --git a/include/asm-mips/ptrace.h b/include/asm-mips/ptrace.h
index fa9d8713c12a..4113316ee0da 100644
--- a/include/asm-mips/ptrace.h
+++ b/include/asm-mips/ptrace.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_PTRACE_H
 #define _ASM_PTRACE_H
 
-#include <linux/config.h>
 
 #include <asm/isadep.h>
 
diff --git a/include/asm-mips/reg.h b/include/asm-mips/reg.h
index 6173004cc88e..634b55d7e7f6 100644
--- a/include/asm-mips/reg.h
+++ b/include/asm-mips/reg.h
@@ -12,7 +12,6 @@
 #ifndef __ASM_MIPS_REG_H
 #define __ASM_MIPS_REG_H
 
-#include <linux/config.h>
 
 #if defined(CONFIG_32BIT) || defined(WANT_COMPAT_REG_H)
 
diff --git a/include/asm-mips/resource.h b/include/asm-mips/resource.h
index 1fba00c22077..87cb3085269c 100644
--- a/include/asm-mips/resource.h
+++ b/include/asm-mips/resource.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_RESOURCE_H
 #define _ASM_RESOURCE_H
 
-#include <linux/config.h>
 
 /*
  * These five resource limit IDs have a MIPS/Linux-specific ordering,
diff --git a/include/asm-mips/serial.h b/include/asm-mips/serial.h
index 7196ceb0e948..584bd9c0ab2e 100644
--- a/include/asm-mips/serial.h
+++ b/include/asm-mips/serial.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_SERIAL_H
 #define _ASM_SERIAL_H
 
-#include <linux/config.h>
 
 /*
  * This assumes you have a 1.8432 MHz clock for your UART.
diff --git a/include/asm-mips/sgiarcs.h b/include/asm-mips/sgiarcs.h
index 722b77a8c5e5..ddb859d05257 100644
--- a/include/asm-mips/sgiarcs.h
+++ b/include/asm-mips/sgiarcs.h
@@ -12,7 +12,6 @@
 #ifndef _ASM_SGIARCS_H
 #define _ASM_SGIARCS_H
 
-#include <linux/config.h>
 #include <asm/types.h>
 #include <asm/arc/types.h>
 
diff --git a/include/asm-mips/sibyte/board.h b/include/asm-mips/sibyte/board.h
index 900edcbeec37..3dfe29ed42a8 100644
--- a/include/asm-mips/sibyte/board.h
+++ b/include/asm-mips/sibyte/board.h
@@ -19,7 +19,6 @@
 #ifndef _SIBYTE_BOARD_H
 #define _SIBYTE_BOARD_H
 
-#include <linux/config.h>
 
 #if defined(CONFIG_SIBYTE_SWARM) || defined(CONFIG_SIBYTE_PTSWARM) || \
     defined(CONFIG_SIBYTE_CRHONE) || defined(CONFIG_SIBYTE_CRHINE) || \
diff --git a/include/asm-mips/sibyte/carmel.h b/include/asm-mips/sibyte/carmel.h
index b5e7dae19f0f..57c53e62a37a 100644
--- a/include/asm-mips/sibyte/carmel.h
+++ b/include/asm-mips/sibyte/carmel.h
@@ -18,7 +18,6 @@
 #ifndef __ASM_SIBYTE_CARMEL_H
 #define __ASM_SIBYTE_CARMEL_H
 
-#include <linux/config.h>
 
 #include <asm/sibyte/sb1250.h>
 #include <asm/sibyte/sb1250_int.h>
diff --git a/include/asm-mips/sibyte/sentosa.h b/include/asm-mips/sibyte/sentosa.h
index 824605847af4..64c47874f32d 100644
--- a/include/asm-mips/sibyte/sentosa.h
+++ b/include/asm-mips/sibyte/sentosa.h
@@ -18,7 +18,6 @@
 #ifndef __ASM_SIBYTE_SENTOSA_H
 #define __ASM_SIBYTE_SENTOSA_H
 
-#include <linux/config.h>
 #include <asm/sibyte/sb1250.h>
 #include <asm/sibyte/sb1250_int.h>
 
diff --git a/include/asm-mips/sibyte/swarm.h b/include/asm-mips/sibyte/swarm.h
index 06e1d528e03a..86db37e5ad85 100644
--- a/include/asm-mips/sibyte/swarm.h
+++ b/include/asm-mips/sibyte/swarm.h
@@ -18,7 +18,6 @@
 #ifndef __ASM_SIBYTE_SWARM_H
 #define __ASM_SIBYTE_SWARM_H
 
-#include <linux/config.h>
 #include <asm/sibyte/sb1250.h>
 #include <asm/sibyte/sb1250_int.h>
 
diff --git a/include/asm-mips/siginfo.h b/include/asm-mips/siginfo.h
index 2ba313d94a78..2e32949bd674 100644
--- a/include/asm-mips/siginfo.h
+++ b/include/asm-mips/siginfo.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_SIGINFO_H
 #define _ASM_SIGINFO_H
 
-#include <linux/config.h>
 
 #define __ARCH_SIGEV_PREAMBLE_SIZE (sizeof(long) + 2*sizeof(int))
 #undef __ARCH_SI_TRAPNO /* exception code needs to fill this ...  */
diff --git a/include/asm-mips/signal.h b/include/asm-mips/signal.h
index d8349e4b55ee..a1f3a3fa9bd6 100644
--- a/include/asm-mips/signal.h
+++ b/include/asm-mips/signal.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_SIGNAL_H
 #define _ASM_SIGNAL_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 
 #define _NSIG           128
diff --git a/include/asm-mips/sim.h b/include/asm-mips/sim.h
index 9c2af1b00e19..67c4fe52bb42 100644
--- a/include/asm-mips/sim.h
+++ b/include/asm-mips/sim.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_SIM_H
 #define _ASM_SIM_H
 
-#include <linux/config.h>
 
 #include <asm/asm-offsets.h>
 
diff --git a/include/asm-mips/smp.h b/include/asm-mips/smp.h
index e14e4b69de21..1608fd71d6f7 100644
--- a/include/asm-mips/smp.h
+++ b/include/asm-mips/smp.h
@@ -11,7 +11,6 @@
 #ifndef __ASM_SMP_H
 #define __ASM_SMP_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_SMP
 
diff --git a/include/asm-mips/sn/addrs.h b/include/asm-mips/sn/addrs.h
index 6c8a5577ddf1..8fa0af6b68d2 100644
--- a/include/asm-mips/sn/addrs.h
+++ b/include/asm-mips/sn/addrs.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_SN_ADDRS_H
 #define _ASM_SN_ADDRS_H
 
-#include <linux/config.h>
 
 #ifndef __ASSEMBLY__
 #include <linux/types.h>
diff --git a/include/asm-mips/sn/agent.h b/include/asm-mips/sn/agent.h
index d6df13aaed49..ac4ea85c3a5c 100644
--- a/include/asm-mips/sn/agent.h
+++ b/include/asm-mips/sn/agent.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_SGI_SN_AGENT_H
 #define _ASM_SGI_SN_AGENT_H
 
-#include <linux/config.h>
 #include <linux/topology.h>
 #include <asm/sn/addrs.h>
 #include <asm/sn/arch.h>
diff --git a/include/asm-mips/sn/arch.h b/include/asm-mips/sn/arch.h
index d247a819de7f..51174af6ac52 100644
--- a/include/asm-mips/sn/arch.h
+++ b/include/asm-mips/sn/arch.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_SN_ARCH_H
 #define _ASM_SN_ARCH_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <asm/sn/types.h>
 #ifdef CONFIG_SGI_IP27
diff --git a/include/asm-mips/sn/io.h b/include/asm-mips/sn/io.h
index 13326453efc9..ab2fa8cd2627 100644
--- a/include/asm-mips/sn/io.h
+++ b/include/asm-mips/sn/io.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_SN_IO_H
 #define _ASM_SN_IO_H
 
-#include <linux/config.h>
 #if defined (CONFIG_SGI_IP27)
 #include <asm/sn/sn0/hubio.h>
 #endif
diff --git a/include/asm-mips/sn/klconfig.h b/include/asm-mips/sn/klconfig.h
index dc706268d2cf..52238e65af8e 100644
--- a/include/asm-mips/sn/klconfig.h
+++ b/include/asm-mips/sn/klconfig.h
@@ -27,7 +27,6 @@
  *      that offsets of existing fields do not change.
  */
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <asm/sn/types.h>
 
diff --git a/include/asm-mips/sn/kldir.h b/include/asm-mips/sn/kldir.h
index 97ad52e3cbc7..0573cbffc104 100644
--- a/include/asm-mips/sn/kldir.h
+++ b/include/asm-mips/sn/kldir.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_SN_KLDIR_H
 #define _ASM_SN_KLDIR_H
 
-#include <linux/config.h>
 
 /*
  * The kldir memory area resides at a fixed place in each node's memory and
diff --git a/include/asm-mips/sn/launch.h b/include/asm-mips/sn/launch.h
index b67699c0c475..b7c2226312c6 100644
--- a/include/asm-mips/sn/launch.h
+++ b/include/asm-mips/sn/launch.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_SN_LAUNCH_H
 #define _ASM_SN_LAUNCH_H
 
-#include <linux/config.h>
 #include <asm/sn/types.h>
 #include <asm/sn/addrs.h>
 
diff --git a/include/asm-mips/sn/mapped_kernel.h b/include/asm-mips/sn/mapped_kernel.h
index 59edb20f8ec5..c3dd5d0d525f 100644
--- a/include/asm-mips/sn/mapped_kernel.h
+++ b/include/asm-mips/sn/mapped_kernel.h
@@ -20,7 +20,6 @@
  * code. So no jumps can be done before we have switched to using
  * cksseg addresses.
  */
-#include <linux/config.h>
 #include <asm/addrspace.h>
 
 #define REP_BASE        CAC_BASE
diff --git a/include/asm-mips/sn/sn0/addrs.h b/include/asm-mips/sn/sn0/addrs.h
index 2c4b758f6736..9e8cc52910f6 100644
--- a/include/asm-mips/sn/sn0/addrs.h
+++ b/include/asm-mips/sn/sn0/addrs.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_SN_SN0_ADDRS_H
 #define _ASM_SN_SN0_ADDRS_H
 
-#include <linux/config.h>
 
 /*
  * SN0 (on a T5) Address map
diff --git a/include/asm-mips/sn/sn0/arch.h b/include/asm-mips/sn/sn0/arch.h
index f7c43fa24aa8..f734f2007f24 100644
--- a/include/asm-mips/sn/sn0/arch.h
+++ b/include/asm-mips/sn/sn0/arch.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_SN_SN0_ARCH_H
 #define _ASM_SN_SN0_ARCH_H
 
-#include <linux/config.h>
 
 #ifndef SN0XXL  /* 128 cpu SMP max */
 /*
diff --git a/include/asm-mips/sn/sn0/hubmd.h b/include/asm-mips/sn/sn0/hubmd.h
index 1006aa26d771..14c225d80664 100644
--- a/include/asm-mips/sn/sn0/hubmd.h
+++ b/include/asm-mips/sn/sn0/hubmd.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_SN_SN0_HUBMD_H
 #define _ASM_SN_SN0_HUBMD_H
 
-#include <linux/config.h>
 
 /*
  * Hub Memory/Directory interface registers
diff --git a/include/asm-mips/stackframe.h b/include/asm-mips/stackframe.h
index c4856a874965..513aa5133830 100644
--- a/include/asm-mips/stackframe.h
+++ b/include/asm-mips/stackframe.h
@@ -10,7 +10,6 @@
 #ifndef _ASM_STACKFRAME_H
 #define _ASM_STACKFRAME_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 
 #include <asm/asm.h>
diff --git a/include/asm-mips/string.h b/include/asm-mips/string.h
index 907da600fddd..436e3ad352d9 100644
--- a/include/asm-mips/string.h
+++ b/include/asm-mips/string.h
@@ -10,7 +10,6 @@
 #ifndef _ASM_STRING_H
 #define _ASM_STRING_H
 
-#include <linux/config.h>
 
 /*
  * Most of the inline functions are rather naive implementations so I just
diff --git a/include/asm-mips/system.h b/include/asm-mips/system.h
index 261f71d16a07..130333d7c4ee 100644
--- a/include/asm-mips/system.h
+++ b/include/asm-mips/system.h
@@ -12,7 +12,6 @@
 #ifndef _ASM_SYSTEM_H
 #define _ASM_SYSTEM_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 
 #include <asm/addrspace.h>
diff --git a/include/asm-mips/thread_info.h b/include/asm-mips/thread_info.h
index f8d97dafd2f4..ae8ada5b42a9 100644
--- a/include/asm-mips/thread_info.h
+++ b/include/asm-mips/thread_info.h
@@ -9,7 +9,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #ifndef __ASSEMBLY__
 
diff --git a/include/asm-mips/tlbflush.h b/include/asm-mips/tlbflush.h
index bb4ae3cdcbf1..276be77c3e85 100644
--- a/include/asm-mips/tlbflush.h
+++ b/include/asm-mips/tlbflush.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_TLBFLUSH_H
 #define __ASM_TLBFLUSH_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 
 /*
diff --git a/include/asm-mips/tx4927/toshiba_rbtx4927.h b/include/asm-mips/tx4927/toshiba_rbtx4927.h
index 6ce1e9475f99..94bef03d9635 100644
--- a/include/asm-mips/tx4927/toshiba_rbtx4927.h
+++ b/include/asm-mips/tx4927/toshiba_rbtx4927.h
@@ -27,7 +27,6 @@
 #ifndef __ASM_TX4927_TOSHIBA_RBTX4927_H
 #define __ASM_TX4927_TOSHIBA_RBTX4927_H
 
-#include <linux/config.h>
 #include <asm/tx4927/tx4927.h>
 #include <asm/tx4927/tx4927_mips.h>
 #ifdef CONFIG_PCI
diff --git a/include/asm-mips/types.h b/include/asm-mips/types.h
index cd2813d8e136..2b52e180c6f2 100644
--- a/include/asm-mips/types.h
+++ b/include/asm-mips/types.h
@@ -52,7 +52,6 @@ typedef unsigned long long __u64;
 
 #ifndef __ASSEMBLY__
 
-#include <linux/config.h>
 
 typedef __signed char s8;
 typedef unsigned char u8;
diff --git a/include/asm-mips/uaccess.h b/include/asm-mips/uaccess.h
index b96f3e0f3933..1cdd4eeb2f73 100644
--- a/include/asm-mips/uaccess.h
+++ b/include/asm-mips/uaccess.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_UACCESS_H
 #define _ASM_UACCESS_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/thread_info.h>
diff --git a/include/asm-mips/unistd.h b/include/asm-mips/unistd.h
index 1068fe9a0a58..8bb0bb9b2e68 100644
--- a/include/asm-mips/unistd.h
+++ b/include/asm-mips/unistd.h
@@ -905,6 +905,8 @@
 #define __NR_N32_Linux                  6000
 #define __NR_N32_Linux_syscalls         268
 
+#ifdef __KERNEL__
+
 #ifndef __ASSEMBLY__
 
 /* XXX - _foo needs to be __foo, while __NR_bar could be _NR_bar. */
@@ -1168,9 +1170,6 @@ type name (atype a,btype b,ctype c,dtype d,etype e,ftype f) \
 
 #endif /* (_MIPS_SIM == _MIPS_SIM_NABI32) || (_MIPS_SIM == _MIPS_SIM_ABI64) */
 
-#ifdef __KERNEL__
-
-#include <linux/config.h>
 
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
@@ -1197,7 +1196,6 @@ type name (atype a,btype b,ctype c,dtype d,etype e,ftype f) \
 # ifdef CONFIG_MIPS32_O32
 #  define __ARCH_WANT_COMPAT_SYS_TIME
 # endif
-#endif
 
 #ifdef __KERNEL_SYSCALLS__
 
@@ -1248,4 +1246,5 @@ asmlinkage long sys_rt_sigaction(int sig,
  */
 #define cond_syscall(x) asm(".weak\t" #x "\n" #x "\t=\tsys_ni_syscall")
 
+#endif /* __KERNEL__ */
 #endif /* _ASM_UNISTD_H */
diff --git a/include/asm-mips/vr41xx/vrc4173.h b/include/asm-mips/vr41xx/vrc4173.h
index 4d41a9c091d4..96fdcd54cec7 100644
--- a/include/asm-mips/vr41xx/vrc4173.h
+++ b/include/asm-mips/vr41xx/vrc4173.h
@@ -24,7 +24,6 @@
 #ifndef __NEC_VRC4173_H
 #define __NEC_VRC4173_H
 
-#include <linux/config.h>
 #include <asm/io.h>
 
 /*
diff --git a/include/asm-mips/war.h b/include/asm-mips/war.h
index 70636b41832c..3ac146c019c9 100644
--- a/include/asm-mips/war.h
+++ b/include/asm-mips/war.h
@@ -8,7 +8,6 @@
 #ifndef _ASM_WAR_H
 #define _ASM_WAR_H
 
-#include <linux/config.h>
 
 /*
  * Another R4600 erratum.  Due to the lack of errata information the exact
diff --git a/include/asm-mips/wbflush.h b/include/asm-mips/wbflush.h
index c3bef50f37a8..eadc0ac47e24 100644
--- a/include/asm-mips/wbflush.h
+++ b/include/asm-mips/wbflush.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_WBFLUSH_H
 #define _ASM_WBFLUSH_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_CPU_HAS_WB
 
diff --git a/include/asm-parisc/atomic.h b/include/asm-parisc/atomic.h
index 403ea97316cf..48bf9b8ab8ff 100644
--- a/include/asm-parisc/atomic.h
+++ b/include/asm-parisc/atomic.h
@@ -5,7 +5,6 @@
 #ifndef _ASM_PARISC_ATOMIC_H_
 #define _ASM_PARISC_ATOMIC_H_
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <asm/system.h>
 
diff --git a/include/asm-parisc/cache.h b/include/asm-parisc/cache.h
index c831665473cb..7d22fa206fc4 100644
--- a/include/asm-parisc/cache.h
+++ b/include/asm-parisc/cache.h
@@ -5,7 +5,6 @@
 #ifndef __ARCH_PARISC_CACHE_H
 #define __ARCH_PARISC_CACHE_H
 
-#include <linux/config.h>
 
 /*
  * PA 2.0 processors have 64-byte cachelines; PA 1.1 processors have
diff --git a/include/asm-parisc/cacheflush.h b/include/asm-parisc/cacheflush.h
index 76b6b7d6046a..0b459cdfbd6f 100644
--- a/include/asm-parisc/cacheflush.h
+++ b/include/asm-parisc/cacheflush.h
@@ -1,7 +1,6 @@
 #ifndef _PARISC_CACHEFLUSH_H
 #define _PARISC_CACHEFLUSH_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <asm/cache.h>  /* for flush_user_dcache_range_asm() proto */
 
diff --git a/include/asm-parisc/dma-mapping.h b/include/asm-parisc/dma-mapping.h
index 74d4ac6f2151..1e387e1dad30 100644
--- a/include/asm-parisc/dma-mapping.h
+++ b/include/asm-parisc/dma-mapping.h
@@ -1,7 +1,6 @@
 #ifndef _PARISC_DMA_MAPPING_H
 #define _PARISC_DMA_MAPPING_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <asm/cacheflush.h>
 #include <asm/scatterlist.h>
diff --git a/include/asm-parisc/dma.h b/include/asm-parisc/dma.h
index 31fd10df43a7..9979c3cb3745 100644
--- a/include/asm-parisc/dma.h
+++ b/include/asm-parisc/dma.h
@@ -9,7 +9,6 @@
 #ifndef _ASM_DMA_H
 #define _ASM_DMA_H
 
-#include <linux/config.h>
 #include <asm/io.h>             /* need byte IO */
 #include <asm/system.h> 
 
diff --git a/include/asm-parisc/io.h b/include/asm-parisc/io.h
index 244f6b8883f4..b9eb245b8874 100644
--- a/include/asm-parisc/io.h
+++ b/include/asm-parisc/io.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_IO_H
 #define _ASM_IO_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <asm/pgtable.h>
 
diff --git a/include/asm-parisc/irq.h b/include/asm-parisc/irq.h
index b0a30e2c9813..377ba90c7d02 100644
--- a/include/asm-parisc/irq.h
+++ b/include/asm-parisc/irq.h
@@ -7,7 +7,6 @@
 #ifndef _ASM_PARISC_IRQ_H
 #define _ASM_PARISC_IRQ_H
 
-#include <linux/config.h>
 #include <linux/cpumask.h>
 #include <asm/types.h>
 
diff --git a/include/asm-parisc/kmap_types.h b/include/asm-parisc/kmap_types.h
index 6886a0c3fedf..806aae3c5338 100644
--- a/include/asm-parisc/kmap_types.h
+++ b/include/asm-parisc/kmap_types.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_KMAP_TYPES_H
 #define _ASM_KMAP_TYPES_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_DEBUG_HIGHMEM
 # define D(n) __KM_FENCE_##n ,
diff --git a/include/asm-parisc/page.h b/include/asm-parisc/page.h
index c0dd461fb8f1..0695bc958d56 100644
--- a/include/asm-parisc/page.h
+++ b/include/asm-parisc/page.h
@@ -10,7 +10,6 @@
 
 
 #ifdef __KERNEL__
-#include <linux/config.h>
 
 #if defined(CONFIG_PARISC_PAGE_SIZE_4KB)
 # define PAGE_SHIFT     12      /* 4k */
diff --git a/include/asm-parisc/param.h b/include/asm-parisc/param.h
index f4694d452dd6..07cb9b93cfe2 100644
--- a/include/asm-parisc/param.h
+++ b/include/asm-parisc/param.h
@@ -2,7 +2,6 @@
 #define _ASMPARISC_PARAM_H
 
 #ifdef __KERNEL__
-#include <linux/config.h>
 # ifdef CONFIG_PA20
 #  define HZ            1000            /* Faster machines */
 # else
diff --git a/include/asm-parisc/pci.h b/include/asm-parisc/pci.h
index 77bbafb7f73e..8b631f47eb25 100644
--- a/include/asm-parisc/pci.h
+++ b/include/asm-parisc/pci.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_PARISC_PCI_H
 #define __ASM_PARISC_PCI_H
 
-#include <linux/config.h>
 #include <asm/scatterlist.h>
 
 
diff --git a/include/asm-parisc/pdc.h b/include/asm-parisc/pdc.h
index 0a3face6c480..08364f957e7a 100644
--- a/include/asm-parisc/pdc.h
+++ b/include/asm-parisc/pdc.h
@@ -1,7 +1,6 @@
 #ifndef _PARISC_PDC_H
 #define _PARISC_PDC_H
 
-#include <linux/config.h>
 
 /*
  *      PDC return values ...
diff --git a/include/asm-parisc/pgtable.h b/include/asm-parisc/pgtable.h
index aec089eb8b85..b6bcc672ba80 100644
--- a/include/asm-parisc/pgtable.h
+++ b/include/asm-parisc/pgtable.h
@@ -3,7 +3,6 @@
 
 #include <asm-generic/4level-fixup.h>
 
-#include <linux/config.h>
 #include <asm/fixmap.h>
 
 #ifndef __ASSEMBLY__
diff --git a/include/asm-parisc/processor.h b/include/asm-parisc/processor.h
index 89f2f1c16c12..ca49dc91f4fc 100644
--- a/include/asm-parisc/processor.h
+++ b/include/asm-parisc/processor.h
@@ -9,7 +9,6 @@
 #define __ASM_PARISC_PROCESSOR_H
 
 #ifndef __ASSEMBLY__
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/spinlock_types.h>
 
diff --git a/include/asm-parisc/psw.h b/include/asm-parisc/psw.h
index 4334d6ca2add..5a3e23c9ce63 100644
--- a/include/asm-parisc/psw.h
+++ b/include/asm-parisc/psw.h
@@ -1,6 +1,5 @@
 #ifndef _PARISC_PSW_H
 
-#include <linux/config.h>
 
 #define PSW_I   0x00000001
 #define PSW_D   0x00000002
diff --git a/include/asm-parisc/smp.h b/include/asm-parisc/smp.h
index dbdbd2e9fdf9..d4c0e26afcd1 100644
--- a/include/asm-parisc/smp.h
+++ b/include/asm-parisc/smp.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_SMP_H
 #define __ASM_SMP_H
 
-#include <linux/config.h>
 
 #if defined(CONFIG_SMP)
 
diff --git a/include/asm-parisc/system.h b/include/asm-parisc/system.h
index a5a973c0c07f..863876134b2c 100644
--- a/include/asm-parisc/system.h
+++ b/include/asm-parisc/system.h
@@ -1,7 +1,6 @@
 #ifndef __PARISC_SYSTEM_H
 #define __PARISC_SYSTEM_H
 
-#include <linux/config.h>
 #include <asm/psw.h>
 
 /* The program status word as bitfields.  */
diff --git a/include/asm-parisc/tlbflush.h b/include/asm-parisc/tlbflush.h
index 825994a90e2d..f662e837dea1 100644
--- a/include/asm-parisc/tlbflush.h
+++ b/include/asm-parisc/tlbflush.h
@@ -3,7 +3,6 @@
 
 /* TLB flushing routines.... */
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <asm/mmu_context.h>
 
diff --git a/include/asm-parisc/unistd.h b/include/asm-parisc/unistd.h
index 0e1a30be2e30..12b867238a47 100644
--- a/include/asm-parisc/unistd.h
+++ b/include/asm-parisc/unistd.h
@@ -792,6 +792,7 @@
 #define HPUX_GATEWAY_ADDR       0xC0000004
 #define LINUX_GATEWAY_ADDR      0x100
 
+#ifdef __KERNEL__
 #ifndef __ASSEMBLY__
 
 #define SYS_ify(syscall_name)   __NR_##syscall_name
@@ -934,7 +935,6 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5)	\
     return K_INLINE_SYSCALL(name, 5, arg1, arg2, arg3, arg4, arg5);     \
 }
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_STAT64
 #define __ARCH_WANT_SYS_ALARM
@@ -956,7 +956,6 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5)	\
 #define __ARCH_WANT_SYS_SIGPENDING
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
-#endif
 
 /* mmap & mmap2 take 6 arguments */
 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,type5,arg5,type6,arg6) \
@@ -1056,4 +1055,5 @@ asmlinkage long sys_rt_sigaction(int sig,
  */
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 
+#endif /* __KERNEL__ */
 #endif /* _ASM_PARISC_UNISTD_H_ */
diff --git a/include/asm-powerpc/abs_addr.h b/include/asm-powerpc/abs_addr.h
index c5c3259e0f86..4aa220718b19 100644
--- a/include/asm-powerpc/abs_addr.h
+++ b/include/asm-powerpc/abs_addr.h
@@ -2,7 +2,6 @@
 #define _ASM_POWERPC_ABS_ADDR_H
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 /*
  * c 2001 PPC 64 Team, IBM Corp
diff --git a/include/asm-powerpc/cache.h b/include/asm-powerpc/cache.h
index 6379c2df5c40..642be62cf393 100644
--- a/include/asm-powerpc/cache.h
+++ b/include/asm-powerpc/cache.h
@@ -3,7 +3,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 /* bytes per L1 cache line */
 #if defined(CONFIG_8xx) || defined(CONFIG_403GCX)
diff --git a/include/asm-powerpc/dma-mapping.h b/include/asm-powerpc/dma-mapping.h
index 2ac63f569592..2ab9baf78bb4 100644
--- a/include/asm-powerpc/dma-mapping.h
+++ b/include/asm-powerpc/dma-mapping.h
@@ -8,7 +8,6 @@
 #define _ASM_DMA_MAPPING_H
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/cache.h>
 /* need struct page definitions */
diff --git a/include/asm-powerpc/dma.h b/include/asm-powerpc/dma.h
index 4bb57fe37097..7a4374bdbef4 100644
--- a/include/asm-powerpc/dma.h
+++ b/include/asm-powerpc/dma.h
@@ -22,7 +22,6 @@
  * with a grain of salt.
  */
 
-#include <linux/config.h>
 #include <asm/io.h>
 #include <linux/spinlock.h>
 #include <asm/system.h>
diff --git a/include/asm-powerpc/eeh.h b/include/asm-powerpc/eeh.h
index 868c7139dbff..e9c86b1eedab 100644
--- a/include/asm-powerpc/eeh.h
+++ b/include/asm-powerpc/eeh.h
@@ -21,7 +21,6 @@
 #define _PPC64_EEH_H
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/string.h>
diff --git a/include/asm-powerpc/elf.h b/include/asm-powerpc/elf.h
index 94d228f9c6ac..99c18b71aa82 100644
--- a/include/asm-powerpc/elf.h
+++ b/include/asm-powerpc/elf.h
@@ -3,14 +3,14 @@
 
 #ifdef __KERNEL__
 #include <linux/sched.h>        /* for task_struct */
+#include <asm/page.h>
+#include <asm/string.h>
 #endif
 
 #include <asm/types.h>
 #include <asm/ptrace.h>
 #include <asm/cputable.h>
 #include <asm/auxvec.h>
-#include <asm/page.h>
-#include <asm/string.h>
 
 /* PowerPC relocations defined by the ABIs */
 #define R_PPC_NONE              0
@@ -129,7 +129,7 @@ typedef elf_greg_t32 elf_gregset_t32[ELF_NGREG];
   /* Assumption: ELF_ARCH == EM_PPC and ELF_CLASS == ELFCLASS32 */
   typedef elf_greg_t32 elf_greg_t;
   typedef elf_gregset_t32 elf_gregset_t;
-# define elf_addr_t u32
+# define elf_addr_t __u32
 #endif /* ELF_ARCH */
 
 /* Floating point registers */
@@ -161,6 +161,7 @@ typedef elf_vrreg_t elf_vrregset_t[ELF_NVRREG];
 typedef elf_vrreg_t elf_vrregset_t32[ELF_NVRREG32];
 #endif
 
+#ifdef __KERNEL__
 /*
  * This is used to ensure we don't load something for the wrong architecture.
  */
@@ -176,8 +177,6 @@ typedef elf_vrreg_t elf_vrregset_t32[ELF_NVRREG32];
 
 #define ELF_ET_DYN_BASE         (0x08000000)
 
-#ifdef __KERNEL__
-
 /* Common routine for both 32-bit and 64-bit processes */
 static inline void ppc_elf_core_copy_regs(elf_gregset_t elf_regs,
                                             struct pt_regs *regs)
diff --git a/include/asm-powerpc/floppy.h b/include/asm-powerpc/floppy.h
index 608164c39efb..7e2d169ee856 100644
--- a/include/asm-powerpc/floppy.h
+++ b/include/asm-powerpc/floppy.h
@@ -11,7 +11,6 @@
 #define __ASM_POWERPC_FLOPPY_H
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <asm/machdep.h>
 
 #define fd_inb(port)            inb_p(port)
diff --git a/include/asm-powerpc/hw_irq.h b/include/asm-powerpc/hw_irq.h
index 26b89d859c56..ce0f7db63c16 100644
--- a/include/asm-powerpc/hw_irq.h
+++ b/include/asm-powerpc/hw_irq.h
@@ -6,7 +6,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/errno.h>
 #include <asm/ptrace.h>
 #include <asm/processor.h>
diff --git a/include/asm-powerpc/ide.h b/include/asm-powerpc/ide.h
index da5f640480cf..b09b42af6a1e 100644
--- a/include/asm-powerpc/ide.h
+++ b/include/asm-powerpc/ide.h
@@ -22,7 +22,6 @@
 #endif
 
 #ifndef  __powerpc64__
-#include <linux/config.h>
 #include <linux/hdreg.h>
 #include <linux/ioport.h>
 #include <asm/io.h>
diff --git a/include/asm-powerpc/iommu.h b/include/asm-powerpc/iommu.h
index 18ca29e9105a..2acf7b29ef06 100644
--- a/include/asm-powerpc/iommu.h
+++ b/include/asm-powerpc/iommu.h
@@ -22,7 +22,6 @@
 #define _ASM_IOMMU_H
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <asm/types.h>
 #include <linux/spinlock.h>
 #include <linux/device.h>
diff --git a/include/asm-powerpc/irq.h b/include/asm-powerpc/irq.h
index 7bc6d73b2823..1e9f25330307 100644
--- a/include/asm-powerpc/irq.h
+++ b/include/asm-powerpc/irq.h
@@ -9,7 +9,6 @@
  * 2 of the License, or (at your option) any later version.
  */
 
-#include <linux/config.h>
 #include <linux/threads.h>
 
 #include <asm/types.h>
diff --git a/include/asm-powerpc/iseries/iseries_io.h b/include/asm-powerpc/iseries/iseries_io.h
index 496aa852b617..f29009bd63c9 100644
--- a/include/asm-powerpc/iseries/iseries_io.h
+++ b/include/asm-powerpc/iseries/iseries_io.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_POWERPC_ISERIES_ISERIES_IO_H
 #define _ASM_POWERPC_ISERIES_ISERIES_IO_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_PPC_ISERIES
 #include <linux/types.h>
diff --git a/include/asm-powerpc/machdep.h b/include/asm-powerpc/machdep.h
index 0f9254c18914..3e7d37aa4a6d 100644
--- a/include/asm-powerpc/machdep.h
+++ b/include/asm-powerpc/machdep.h
@@ -9,7 +9,6 @@
  * 2 of the License, or (at your option) any later version.
  */
 
-#include <linux/config.h>
 #include <linux/seq_file.h>
 #include <linux/init.h>
 #include <linux/dma-mapping.h>
diff --git a/include/asm-powerpc/mmzone.h b/include/asm-powerpc/mmzone.h
index 88d70bae7769..d484ca94cb7c 100644
--- a/include/asm-powerpc/mmzone.h
+++ b/include/asm-powerpc/mmzone.h
@@ -8,7 +8,6 @@
 #define _ASM_MMZONE_H_
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 /*
  * generic non-linear memory support:
diff --git a/include/asm-powerpc/paca.h b/include/asm-powerpc/paca.h
index 706325f99a84..3c6f644d49b4 100644
--- a/include/asm-powerpc/paca.h
+++ b/include/asm-powerpc/paca.h
@@ -16,7 +16,6 @@
 #define _ASM_POWERPC_PACA_H
 #ifdef __KERNEL__
 
-#include        <linux/config.h>
 #include        <asm/types.h>
 #include        <asm/lppaca.h>
 #include        <asm/mmu.h>
diff --git a/include/asm-powerpc/page.h b/include/asm-powerpc/page.h
index 2fbecebe1c92..f0469b961359 100644
--- a/include/asm-powerpc/page.h
+++ b/include/asm-powerpc/page.h
@@ -11,7 +11,6 @@
  */
 
 #ifdef __KERNEL__
-#include <linux/config.h>
 #include <asm/asm-compat.h>
 
 /*
diff --git a/include/asm-powerpc/pgtable.h b/include/asm-powerpc/pgtable.h
index e9f1f4627e6b..964e312a1ffc 100644
--- a/include/asm-powerpc/pgtable.h
+++ b/include/asm-powerpc/pgtable.h
@@ -12,7 +12,6 @@
  */
 
 #ifndef __ASSEMBLY__
-#include <linux/config.h>
 #include <linux/stddef.h>
 #include <asm/processor.h>              /* For TASK_SIZE */
 #include <asm/mmu.h>
diff --git a/include/asm-powerpc/ppc_asm.h b/include/asm-powerpc/ppc_asm.h
index dd1c0a913d5f..a940cfe040da 100644
--- a/include/asm-powerpc/ppc_asm.h
+++ b/include/asm-powerpc/ppc_asm.h
@@ -5,7 +5,6 @@
 #define _ASM_POWERPC_PPC_ASM_H
 
 #include <linux/stringify.h>
-#include <linux/config.h>
 #include <asm/asm-compat.h>
 
 #ifndef __ASSEMBLY__
diff --git a/include/asm-powerpc/prom.h b/include/asm-powerpc/prom.h
index 97ef1cd71a4d..f4e2ca6fd53f 100644
--- a/include/asm-powerpc/prom.h
+++ b/include/asm-powerpc/prom.h
@@ -15,7 +15,6 @@
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  */
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/proc_fs.h>
 #include <asm/atomic.h>
diff --git a/include/asm-powerpc/smp.h b/include/asm-powerpc/smp.h
index 4a716f707cf6..068f119aa298 100644
--- a/include/asm-powerpc/smp.h
+++ b/include/asm-powerpc/smp.h
@@ -17,7 +17,6 @@
 #define _ASM_POWERPC_SMP_H
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/cpumask.h>
 #include <linux/kernel.h>
diff --git a/include/asm-powerpc/smu.h b/include/asm-powerpc/smu.h
index 2dc93632f210..51e65fc46a03 100644
--- a/include/asm-powerpc/smu.h
+++ b/include/asm-powerpc/smu.h
@@ -5,7 +5,6 @@
  * Definitions for talking to the SMU chip in newer G5 PowerMacs
  */
 #ifdef __KERNEL__
-#include <linux/config.h>
 #include <linux/list.h>
 #endif
 #include <linux/types.h>
diff --git a/include/asm-powerpc/spu.h b/include/asm-powerpc/spu.h
index 7cfcff3ef027..95713f397357 100644
--- a/include/asm-powerpc/spu.h
+++ b/include/asm-powerpc/spu.h
@@ -24,7 +24,6 @@
 #define _SPU_H
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/kref.h>
 #include <linux/workqueue.h>
 
diff --git a/include/asm-powerpc/thread_info.h b/include/asm-powerpc/thread_info.h
index 88b553c6b26c..d339e2e88b11 100644
--- a/include/asm-powerpc/thread_info.h
+++ b/include/asm-powerpc/thread_info.h
@@ -21,7 +21,6 @@
 #define THREAD_SIZE             (1 << THREAD_SHIFT)
 
 #ifndef __ASSEMBLY__
-#include <linux/config.h>
 #include <linux/cache.h>
 #include <asm/processor.h>
 #include <asm/page.h>
diff --git a/include/asm-powerpc/time.h b/include/asm-powerpc/time.h
index 912118db13ae..4463148c659f 100644
--- a/include/asm-powerpc/time.h
+++ b/include/asm-powerpc/time.h
@@ -14,7 +14,6 @@
 #define __POWERPC_TIME_H
 
 #ifdef __KERNEL__
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/percpu.h>
 
diff --git a/include/asm-powerpc/timex.h b/include/asm-powerpc/timex.h
index c02d15aced91..3b9a8e786806 100644
--- a/include/asm-powerpc/timex.h
+++ b/include/asm-powerpc/timex.h
@@ -7,7 +7,6 @@
  * PowerPC architecture timex specifications
  */
 
-#include <linux/config.h>
 #include <asm/cputable.h>
 
 #define CLOCK_TICK_RATE 1024000 /* Underlying HZ */
diff --git a/include/asm-powerpc/tlb.h b/include/asm-powerpc/tlb.h
index 601a53cf96d5..4e2a834683fb 100644
--- a/include/asm-powerpc/tlb.h
+++ b/include/asm-powerpc/tlb.h
@@ -13,7 +13,6 @@
 #define _ASM_POWERPC_TLB_H
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #ifndef __powerpc64__
 #include <asm/pgtable.h>
 #endif
diff --git a/include/asm-powerpc/tlbflush.h b/include/asm-powerpc/tlbflush.h
index a2998eee37bb..93c7d0c7230f 100644
--- a/include/asm-powerpc/tlbflush.h
+++ b/include/asm-powerpc/tlbflush.h
@@ -17,7 +17,6 @@
  */
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 struct mm_struct;
 
diff --git a/include/asm-powerpc/topology.h b/include/asm-powerpc/topology.h
index 87362a05542b..19c575f39164 100644
--- a/include/asm-powerpc/topology.h
+++ b/include/asm-powerpc/topology.h
@@ -2,7 +2,6 @@
 #define _ASM_POWERPC_TOPOLOGY_H
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 struct sys_device;
 struct device_node;
diff --git a/include/asm-powerpc/types.h b/include/asm-powerpc/types.h
index baabba96e313..d6fb56b80453 100644
--- a/include/asm-powerpc/types.h
+++ b/include/asm-powerpc/types.h
@@ -64,7 +64,6 @@ typedef struct {
 
 #ifndef __ASSEMBLY__
 
-#include <linux/config.h>
 
 typedef signed char s8;
 typedef unsigned char u8;
diff --git a/include/asm-powerpc/unistd.h b/include/asm-powerpc/unistd.h
index edde2462bf52..eb66eae6616f 100644
--- a/include/asm-powerpc/unistd.h
+++ b/include/asm-powerpc/unistd.h
@@ -324,12 +324,12 @@
 #define __NR_get_robust_list    299
 #define __NR_set_robust_list    300
 
+#ifdef __KERNEL__
+
 #define __NR_syscalls           301
 
-#ifdef __KERNEL__
 #define __NR__exit __NR_exit
 #define NR_syscalls     __NR_syscalls
-#endif
 
 #ifndef __ASSEMBLY__
 
@@ -441,9 +441,7 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5, type6 arg6
         __syscall_nr(6, type, name, arg1, arg2, arg3, arg4, arg5, arg6); \
 }
 
-#ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/compiler.h>
 #include <linux/linkage.h>
@@ -499,8 +497,8 @@ extern int execve(const char *file, char **argv, char **envp);
 #define cond_syscall(x) asm(".weak\t." #x "\n\t.set\t." #x ",.sys_ni_syscall")
 #endif
 
-#endif          /* __KERNEL__ */
 
 #endif          /* __ASSEMBLY__ */
+#endif          /* __KERNEL__ */
 
 #endif /* _ASM_PPC_UNISTD_H_ */
diff --git a/include/asm-powerpc/vga.h b/include/asm-powerpc/vga.h
index f8d350aabf1a..eadaf2f3d032 100644
--- a/include/asm-powerpc/vga.h
+++ b/include/asm-powerpc/vga.h
@@ -12,7 +12,6 @@
 
 #include <asm/io.h>
 
-#include <linux/config.h>
 
 #if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_MDA_CONSOLE)
 
diff --git a/include/asm-powerpc/vio.h b/include/asm-powerpc/vio.h
index 0544ece51761..be14c59846f9 100644
--- a/include/asm-powerpc/vio.h
+++ b/include/asm-powerpc/vio.h
@@ -15,7 +15,6 @@
 #define _ASM_POWERPC_VIO_H
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/device.h>
diff --git a/include/asm-ppc/amigahw.h b/include/asm-ppc/amigahw.h
index 8c98945e7dc1..90fd1274d727 100644
--- a/include/asm-ppc/amigahw.h
+++ b/include/asm-ppc/amigahw.h
@@ -2,7 +2,6 @@
 #ifndef __ASMPPC_AMIGAHW_H
 #define __ASMPPC_AMIGAHW_H
 
-#include <linux/config.h>
 #include <asm-m68k/amigahw.h>
 
 #undef CHIP_PHYSADDR
diff --git a/include/asm-ppc/bootinfo.h b/include/asm-ppc/bootinfo.h
index 93d955c70d65..2ace4a74f263 100644
--- a/include/asm-ppc/bootinfo.h
+++ b/include/asm-ppc/bootinfo.h
@@ -9,7 +9,6 @@
 #ifndef _PPC_BOOTINFO_H
 #define _PPC_BOOTINFO_H
 
-#include <linux/config.h>
 #include <asm/page.h>
 
 #if defined(CONFIG_APUS) && !defined(__BOOTER__)
diff --git a/include/asm-ppc/commproc.h b/include/asm-ppc/commproc.h
index 31f362966a58..3247bea5fc2b 100644
--- a/include/asm-ppc/commproc.h
+++ b/include/asm-ppc/commproc.h
@@ -17,7 +17,6 @@
 #ifndef __CPM_8XX__
 #define __CPM_8XX__
 
-#include <linux/config.h>
 #include <asm/8xx_immap.h>
 #include <asm/ptrace.h>
 
diff --git a/include/asm-ppc/ibm403.h b/include/asm-ppc/ibm403.h
index bf6efa0417ab..c9c5d539cfdb 100644
--- a/include/asm-ppc/ibm403.h
+++ b/include/asm-ppc/ibm403.h
@@ -12,7 +12,6 @@
 #ifndef __ASM_IBM403_H__
 #define __ASM_IBM403_H__
 
-#include <linux/config.h>
 
 #if defined(CONFIG_403GCX)
 
diff --git a/include/asm-ppc/ibm44x.h b/include/asm-ppc/ibm44x.h
index 3acc382cc83f..7818b54b6e37 100644
--- a/include/asm-ppc/ibm44x.h
+++ b/include/asm-ppc/ibm44x.h
@@ -17,7 +17,6 @@
 #ifndef __ASM_IBM44x_H__
 #define __ASM_IBM44x_H__
 
-#include <linux/config.h>
 
 #ifndef NR_BOARD_IRQS
 #define NR_BOARD_IRQS 0
diff --git a/include/asm-ppc/ibm4xx.h b/include/asm-ppc/ibm4xx.h
index 38f99710752b..cf62b69cb69a 100644
--- a/include/asm-ppc/ibm4xx.h
+++ b/include/asm-ppc/ibm4xx.h
@@ -14,7 +14,6 @@
 #ifndef __ASM_IBM4XX_H__
 #define __ASM_IBM4XX_H__
 
-#include <linux/config.h>
 #include <asm/types.h>
 
 #ifdef CONFIG_40x
diff --git a/include/asm-ppc/io.h b/include/asm-ppc/io.h
index b919d8fb7d98..89c6f1bc3aab 100644
--- a/include/asm-ppc/io.h
+++ b/include/asm-ppc/io.h
@@ -2,7 +2,6 @@
 #ifndef _PPC_IO_H
 #define _PPC_IO_H
 
-#include <linux/config.h>
 #include <linux/string.h>
 #include <linux/types.h>
 
diff --git a/include/asm-ppc/machdep.h b/include/asm-ppc/machdep.h
index e1a0a7b213d7..da7746738aee 100644
--- a/include/asm-ppc/machdep.h
+++ b/include/asm-ppc/machdep.h
@@ -2,7 +2,6 @@
 #ifndef _PPC_MACHDEP_H
 #define _PPC_MACHDEP_H
 
-#include <linux/config.h>
 #include <linux/init.h>
 #include <linux/kexec.h>
 
diff --git a/include/asm-ppc/mmu.h b/include/asm-ppc/mmu.h
index 9205db404c7a..0a70b05b3afb 100644
--- a/include/asm-ppc/mmu.h
+++ b/include/asm-ppc/mmu.h
@@ -6,7 +6,6 @@
 #ifndef _PPC_MMU_H_
 #define _PPC_MMU_H_
 
-#include <linux/config.h>
 
 #ifndef __ASSEMBLY__
 
diff --git a/include/asm-ppc/mmu_context.h b/include/asm-ppc/mmu_context.h
index 4f152cca13c1..94f2bf71310d 100644
--- a/include/asm-ppc/mmu_context.h
+++ b/include/asm-ppc/mmu_context.h
@@ -2,7 +2,6 @@
 #ifndef __PPC_MMU_CONTEXT_H
 #define __PPC_MMU_CONTEXT_H
 
-#include <linux/config.h>
 #include <asm/atomic.h>
 #include <asm/bitops.h>
 #include <asm/mmu.h>
diff --git a/include/asm-ppc/mpc8260.h b/include/asm-ppc/mpc8260.h
index 6ba69a86b9dd..4b93481e7679 100644
--- a/include/asm-ppc/mpc8260.h
+++ b/include/asm-ppc/mpc8260.h
@@ -8,7 +8,6 @@
 #ifndef __ASM_PPC_MPC8260_H__
 #define __ASM_PPC_MPC8260_H__
 
-#include <linux/config.h>
 
 #ifdef CONFIG_8260
 
diff --git a/include/asm-ppc/mpc83xx.h b/include/asm-ppc/mpc83xx.h
index 3c23fc43bfbc..02ed2c325714 100644
--- a/include/asm-ppc/mpc83xx.h
+++ b/include/asm-ppc/mpc83xx.h
@@ -17,7 +17,6 @@
 #ifndef __ASM_MPC83xx_H__
 #define __ASM_MPC83xx_H__
 
-#include <linux/config.h>
 #include <asm/mmu.h>
 
 #ifdef CONFIG_83xx
diff --git a/include/asm-ppc/mpc85xx.h b/include/asm-ppc/mpc85xx.h
index f47002a60edf..c25bdd9debf8 100644
--- a/include/asm-ppc/mpc85xx.h
+++ b/include/asm-ppc/mpc85xx.h
@@ -17,7 +17,6 @@
 #ifndef __ASM_MPC85xx_H__
 #define __ASM_MPC85xx_H__
 
-#include <linux/config.h>
 #include <asm/mmu.h>
 
 #ifdef CONFIG_85xx
diff --git a/include/asm-ppc/mpc8xx.h b/include/asm-ppc/mpc8xx.h
index 3515a7fa6c89..adcce33f20ae 100644
--- a/include/asm-ppc/mpc8xx.h
+++ b/include/asm-ppc/mpc8xx.h
@@ -8,7 +8,6 @@
 #ifndef __CONFIG_8xx_DEFS
 #define __CONFIG_8xx_DEFS
 
-#include <linux/config.h>
 
 #ifdef CONFIG_8xx
 
diff --git a/include/asm-ppc/mv64x60.h b/include/asm-ppc/mv64x60.h
index 4f2405b83612..663edbee3e91 100644
--- a/include/asm-ppc/mv64x60.h
+++ b/include/asm-ppc/mv64x60.h
@@ -17,7 +17,6 @@
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/slab.h>
-#include <linux/config.h>
 
 #include <asm/byteorder.h>
 #include <asm/io.h>
diff --git a/include/asm-ppc/ocp.h b/include/asm-ppc/ocp.h
index 983116f59d90..3be5d760ffcd 100644
--- a/include/asm-ppc/ocp.h
+++ b/include/asm-ppc/ocp.h
@@ -26,7 +26,6 @@
 
 #include <linux/init.h>
 #include <linux/list.h>
-#include <linux/config.h>
 #include <linux/devfs_fs_kernel.h>
 #include <linux/device.h>
 
diff --git a/include/asm-ppc/open_pic.h b/include/asm-ppc/open_pic.h
index ec2f46629ca2..a4fe962d9f73 100644
--- a/include/asm-ppc/open_pic.h
+++ b/include/asm-ppc/open_pic.h
@@ -12,7 +12,6 @@
 #ifndef _PPC_KERNEL_OPEN_PIC_H
 #define _PPC_KERNEL_OPEN_PIC_H
 
-#include <linux/config.h>
 #include <linux/irq.h>
 
 #define OPENPIC_SIZE    0x40000
diff --git a/include/asm-ppc/page.h b/include/asm-ppc/page.h
index 0fb68a0b0181..0b19af82507f 100644
--- a/include/asm-ppc/page.h
+++ b/include/asm-ppc/page.h
@@ -1,7 +1,6 @@
 #ifndef _PPC_PAGE_H
 #define _PPC_PAGE_H
 
-#include <linux/config.h>
 #include <asm/asm-compat.h>
 
 /* PAGE_SHIFT determines the page size */
@@ -15,7 +14,6 @@
 #define PAGE_MASK       (~((1 << PAGE_SHIFT) - 1))
 
 #ifdef __KERNEL__
-#include <linux/config.h>
 
 /* This must match what is in arch/ppc/Makefile */
 #define PAGE_OFFSET     CONFIG_KERNEL_START
diff --git a/include/asm-ppc/pc_serial.h b/include/asm-ppc/pc_serial.h
index 8f994f9f8857..81a2d0fdaf00 100644
--- a/include/asm-ppc/pc_serial.h
+++ b/include/asm-ppc/pc_serial.h
@@ -9,7 +9,6 @@
  * anyone using any of those on a PPC platform.  -- paulus
  */
 
-#include <linux/config.h>
 
 /*
  * This assumes you have a 1.8432 MHz clock for your UART.
diff --git a/include/asm-ppc/pgalloc.h b/include/asm-ppc/pgalloc.h
index bdefd1c4a558..44d88a98e87c 100644
--- a/include/asm-ppc/pgalloc.h
+++ b/include/asm-ppc/pgalloc.h
@@ -2,7 +2,6 @@
 #ifndef _PPC_PGALLOC_H
 #define _PPC_PGALLOC_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 
 extern void __bad_pte(pmd_t *pmd);
diff --git a/include/asm-ppc/pgtable.h b/include/asm-ppc/pgtable.h
index 570b355162fa..9cb83679836c 100644
--- a/include/asm-ppc/pgtable.h
+++ b/include/asm-ppc/pgtable.h
@@ -4,7 +4,6 @@
 
 #include <asm-generic/4level-fixup.h>
 
-#include <linux/config.h>
 
 #ifndef __ASSEMBLY__
 #include <linux/sched.h>
diff --git a/include/asm-ppc/ppc4xx_dma.h b/include/asm-ppc/ppc4xx_dma.h
index 46a086fff816..935d1e05366b 100644
--- a/include/asm-ppc/ppc4xx_dma.h
+++ b/include/asm-ppc/ppc4xx_dma.h
@@ -24,7 +24,6 @@
 #ifndef __ASMPPC_PPC4xx_DMA_H
 #define __ASMPPC_PPC4xx_DMA_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <asm/mmu.h>
 #include <asm/ibm4xx.h>
diff --git a/include/asm-ppc/ppc4xx_pic.h b/include/asm-ppc/ppc4xx_pic.h
index c16c7f81cfd8..e44261206f8b 100644
--- a/include/asm-ppc/ppc4xx_pic.h
+++ b/include/asm-ppc/ppc4xx_pic.h
@@ -17,7 +17,6 @@
 #ifndef __PPC4XX_PIC_H__
 #define __PPC4XX_PIC_H__
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/irq.h>
 
diff --git a/include/asm-ppc/serial.h b/include/asm-ppc/serial.h
index b74af5461564..8a59f8871f32 100644
--- a/include/asm-ppc/serial.h
+++ b/include/asm-ppc/serial.h
@@ -6,7 +6,6 @@
 #ifndef __ASM_SERIAL_H__
 #define __ASM_SERIAL_H__
 
-#include <linux/config.h>
 
 #if defined(CONFIG_EV64260)
 #include <platforms/ev64260.h>
diff --git a/include/asm-ppc/smp.h b/include/asm-ppc/smp.h
index 30e9268a888c..0b7fa89589df 100644
--- a/include/asm-ppc/smp.h
+++ b/include/asm-ppc/smp.h
@@ -10,7 +10,6 @@
 #ifndef _PPC_SMP_H
 #define _PPC_SMP_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/bitops.h>
 #include <linux/errno.h>
diff --git a/include/asm-ppc/time.h b/include/asm-ppc/time.h
index c86112323c9f..f7eadf6ac806 100644
--- a/include/asm-ppc/time.h
+++ b/include/asm-ppc/time.h
@@ -9,7 +9,6 @@
 #ifndef __ASM_TIME_H__
 #define __ASM_TIME_H__
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/rtc.h>
 #include <linux/threads.h>
diff --git a/include/asm-s390/bitops.h b/include/asm-s390/bitops.h
index ca092ffb7a95..4d2b126ba159 100644
--- a/include/asm-s390/bitops.h
+++ b/include/asm-s390/bitops.h
@@ -12,7 +12,6 @@
  *    Copyright (C) 1992, Linus Torvalds
  *
  */
-#include <linux/config.h>
 #include <linux/compiler.h>
 
 /*
diff --git a/include/asm-s390/cmb.h b/include/asm-s390/cmb.h
index dae1dd4fb937..2d09950a9c11 100644
--- a/include/asm-s390/cmb.h
+++ b/include/asm-s390/cmb.h
@@ -47,7 +47,7 @@ struct cmbdata {
 /* reset channel measurement block */
 #define BIODASDRESETCMB         _IO(DASD_IOCTL_LETTER,34)
 /* read channel measurement data */
-#define BIODASDREADCMB          _IOWR(DASD_IOCTL_LETTER,32,u64)
+#define BIODASDREADCMB          _IOWR(DASD_IOCTL_LETTER,32,__u64)
 /* read channel measurement data */
 #define BIODASDREADALLCMB       _IOWR(DASD_IOCTL_LETTER,33,struct cmbdata)
 
diff --git a/include/asm-s390/debug.h b/include/asm-s390/debug.h
index 23450ed4b571..7f1ef99fd1e1 100644
--- a/include/asm-s390/debug.h
+++ b/include/asm-s390/debug.h
@@ -9,7 +9,6 @@
 #ifndef DEBUG_H
 #define DEBUG_H
 
-#include <linux/config.h>
 #include <linux/fs.h>
 #include <linux/string.h>
 
diff --git a/include/asm-s390/hardirq.h b/include/asm-s390/hardirq.h
index 6792c559a124..e84b7ef54aac 100644
--- a/include/asm-s390/hardirq.h
+++ b/include/asm-s390/hardirq.h
@@ -12,7 +12,6 @@
 #ifndef __ASM_HARDIRQ_H
 #define __ASM_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/sched.h>
 #include <linux/cache.h>
diff --git a/include/asm-s390/idals.h b/include/asm-s390/idals.h
index 8038858b86bb..e82c10efe65a 100644
--- a/include/asm-s390/idals.h
+++ b/include/asm-s390/idals.h
@@ -13,7 +13,6 @@
 #ifndef _S390_IDALS_H
 #define _S390_IDALS_H
 
-#include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/err.h>
 #include <linux/types.h>
diff --git a/include/asm-s390/local.h b/include/asm-s390/local.h
index cf8189009c30..86745a1b29bb 100644
--- a/include/asm-s390/local.h
+++ b/include/asm-s390/local.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_LOCAL_H
 #define _ASM_LOCAL_H
 
-#include <linux/config.h>
 #include <linux/percpu.h>
 #include <asm/atomic.h>
 
diff --git a/include/asm-s390/lowcore.h b/include/asm-s390/lowcore.h
index bea727904287..596c8b172104 100644
--- a/include/asm-s390/lowcore.h
+++ b/include/asm-s390/lowcore.h
@@ -124,7 +124,6 @@
 
 #ifndef __ASSEMBLY__
 
-#include <linux/config.h>
 #include <asm/processor.h>
 #include <linux/types.h>
 #include <asm/sigp.h>
diff --git a/include/asm-s390/page.h b/include/asm-s390/page.h
index 3b1138ac7e79..b2628dc5c490 100644
--- a/include/asm-s390/page.h
+++ b/include/asm-s390/page.h
@@ -9,7 +9,6 @@
 #ifndef _S390_PAGE_H
 #define _S390_PAGE_H
 
-#include <asm/setup.h>
 #include <asm/types.h>
 
 /* PAGE_SHIFT determines the page size */
@@ -20,6 +19,7 @@
 #define PAGE_DEFAULT_KEY        (PAGE_DEFAULT_ACC << 4)
 
 #ifdef __KERNEL__
+#include <asm/setup.h>
 #ifndef __ASSEMBLY__
 
 #ifndef __s390x__
@@ -189,9 +189,9 @@ page_get_storage_key(unsigned long addr)
 #define VM_DATA_DEFAULT_FLAGS   (VM_READ | VM_WRITE | VM_EXEC | \
                                  VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC)
 
-#endif /* __KERNEL__ */
-
 #include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
+#endif /* __KERNEL__ */
+
 #endif /* _S390_PAGE_H */
diff --git a/include/asm-s390/pgalloc.h b/include/asm-s390/pgalloc.h
index e28aaf28e4a8..3002fda89d33 100644
--- a/include/asm-s390/pgalloc.h
+++ b/include/asm-s390/pgalloc.h
@@ -13,7 +13,6 @@
 #ifndef _S390_PGALLOC_H
 #define _S390_PGALLOC_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/gfp.h>
 #include <linux/mm.h>
diff --git a/include/asm-s390/posix_types.h b/include/asm-s390/posix_types.h
index 61788de3c0c3..b94c98856e12 100644
--- a/include/asm-s390/posix_types.h
+++ b/include/asm-s390/posix_types.h
@@ -76,24 +76,36 @@ typedef struct {
 } __kernel_fsid_t;
 
 
-#if defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2)
-
-#ifndef _S390_BITOPS_H
-#include <asm/bitops.h>
-#endif
-
-#undef  __FD_SET
-#define __FD_SET(fd,fdsetp)  set_bit((fd),(fdsetp)->fds_bits)
-
-#undef  __FD_CLR
-#define __FD_CLR(fd,fdsetp)  clear_bit((fd),(fdsetp)->fds_bits)
-
-#undef  __FD_ISSET
-#define __FD_ISSET(fd,fdsetp)  test_bit((fd),(fdsetp)->fds_bits)
+#ifdef __KERNEL__
+
+#undef __FD_SET
+static inline void __FD_SET(unsigned long fd, __kernel_fd_set *fdsetp)
+{
+        unsigned long _tmp = fd / __NFDBITS;
+        unsigned long _rem = fd % __NFDBITS;
+        fdsetp->fds_bits[_tmp] |= (1UL<<_rem);
+}
+
+#undef __FD_CLR
+static inline void __FD_CLR(unsigned long fd, __kernel_fd_set *fdsetp)
+{
+        unsigned long _tmp = fd / __NFDBITS;
+        unsigned long _rem = fd % __NFDBITS;
+        fdsetp->fds_bits[_tmp] &= ~(1UL<<_rem);
+}
+
+#undef __FD_ISSET
+static inline int __FD_ISSET(unsigned long fd, const __kernel_fd_set *fdsetp)
+{
+        unsigned long _tmp = fd / __NFDBITS;
+        unsigned long _rem = fd % __NFDBITS;
+        return (fdsetp->fds_bits[_tmp] & (1UL<<_rem)) != 0;
+}
 
 #undef  __FD_ZERO
-#define __FD_ZERO(fdsetp) (memset ((fdsetp), 0, sizeof(*(fd_set *)(fdsetp))))
+#define __FD_ZERO(fdsetp) \
+        ((void) memset ((__ptr_t) (fdsetp), 0, sizeof (__kernel_fd_set)))
 
-#endif     /* defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2)*/
+#endif     /* __KERNEL__ */
 
 #endif
diff --git a/include/asm-s390/ptrace.h b/include/asm-s390/ptrace.h
index a949cc077cc7..4d75d77b0f99 100644
--- a/include/asm-s390/ptrace.h
+++ b/include/asm-s390/ptrace.h
@@ -181,11 +181,8 @@
 #define PTRACE_OLDSETOPTIONS         21
 
 #ifndef __ASSEMBLY__
-#include <linux/config.h>
 #include <linux/stddef.h>
 #include <linux/types.h>
-#include <asm/setup.h>
-#include <asm/page.h>
 
 typedef union
 {
@@ -301,6 +298,9 @@ typedef struct
 } s390_regs;
 
 #ifdef __KERNEL__
+#include <asm/setup.h>
+#include <asm/page.h>
+
 /*
  * The pt_regs struct defines the way the registers are stored on
  * the stack during a system call.
diff --git a/include/asm-s390/sfp-machine.h b/include/asm-s390/sfp-machine.h
index 3c79b5384f44..de69dfa46fbb 100644
--- a/include/asm-s390/sfp-machine.h
+++ b/include/asm-s390/sfp-machine.h
@@ -25,7 +25,6 @@
 #ifndef _SFP_MACHINE_H
 #define _SFP_MACHINE_H
    
-#include <linux/config.h>
 
 #define _FP_W_TYPE_SIZE         32
 #define _FP_W_TYPE              unsigned long
diff --git a/include/asm-s390/smp.h b/include/asm-s390/smp.h
index 444dae5912e6..657646054c5e 100644
--- a/include/asm-s390/smp.h
+++ b/include/asm-s390/smp.h
@@ -10,7 +10,6 @@
 #ifndef __ASM_SMP_H
 #define __ASM_SMP_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/cpumask.h>
 #include <linux/bitops.h>
diff --git a/include/asm-s390/system.h b/include/asm-s390/system.h
index 6a89dbb03c1e..71a0732cd518 100644
--- a/include/asm-s390/system.h
+++ b/include/asm-s390/system.h
@@ -11,7 +11,6 @@
 #ifndef __ASM_SYSTEM_H
 #define __ASM_SYSTEM_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <asm/types.h>
 #include <asm/ptrace.h>
diff --git a/include/asm-s390/tlbflush.h b/include/asm-s390/tlbflush.h
index 1bb73b0e61fa..73cd85bebfb2 100644
--- a/include/asm-s390/tlbflush.h
+++ b/include/asm-s390/tlbflush.h
@@ -1,7 +1,6 @@
 #ifndef _S390_TLBFLUSH_H
 #define _S390_TLBFLUSH_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <asm/processor.h>
 
diff --git a/include/asm-s390/types.h b/include/asm-s390/types.h
index 5738ad63537c..ae2951cc83ac 100644
--- a/include/asm-s390/types.h
+++ b/include/asm-s390/types.h
@@ -58,7 +58,6 @@ typedef __signed__ long saddr_t;
 
 #ifndef __ASSEMBLY__
 
-#include <linux/config.h>
 
 typedef signed char s8;
 typedef unsigned char u8;
diff --git a/include/asm-s390/unistd.h b/include/asm-s390/unistd.h
index 41c2792ff6b0..e21443d3ea1d 100644
--- a/include/asm-s390/unistd.h
+++ b/include/asm-s390/unistd.h
@@ -392,6 +392,8 @@
 
 #endif
 
+#ifdef __KERNEL__
+
 /* user-visible error numbers are in the range -1 - -122: see <asm-s390/errno.h> */
 
 #define __syscall_return(type, res)                          \
@@ -546,7 +548,6 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4,    \
         __syscall_return(type,__res);                        \
 }
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_SYS_ALARM
@@ -573,11 +574,9 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4,    \
 #   define __ARCH_WANT_COMPAT_SYS_TIME
 #   define __ARCH_WANT_COMPAT_SYS_RT_SIGSUSPEND
 # endif
-#endif
 
 #ifdef __KERNEL_SYSCALLS__
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <linux/types.h>
 #include <asm/ptrace.h>
@@ -625,7 +624,7 @@ asmlinkage long sys_rt_sigaction(int sig,
                                 struct sigaction __user *oact,
                                 size_t sigsetsize);
 
-#endif
+#endif /* __KERNEL_SYSCALLS__ */
 
 /*
  * "Conditional" syscalls
@@ -635,4 +634,5 @@ asmlinkage long sys_rt_sigaction(int sig,
  */
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 
+#endif /* __KERNEL__ */
 #endif /* _ASM_S390_UNISTD_H_ */
diff --git a/include/asm-s390/vtoc.h b/include/asm-s390/vtoc.h
index d1de5b7ebb0b..3a5267d90d29 100644
--- a/include/asm-s390/vtoc.h
+++ b/include/asm-s390/vtoc.h
@@ -177,27 +177,27 @@ struct vtoc_format7_label
 } __attribute__ ((packed));
 
 struct vtoc_cms_label {
-        u8 label_id[4];         /* Label identifier */
-        u8 vol_id[6];           /* Volid */
-        u16 version_id;         /* Version identifier */
-        u32 block_size;         /* Disk block size */
-        u32 origin_ptr;         /* Disk origin pointer */
-        u32 usable_count;       /* Number of usable cylinders/blocks */
-        u32 formatted_count;    /* Maximum number of formatted cylinders/
+        __u8 label_id[4];               /* Label identifier */
+        __u8 vol_id[6];         /* Volid */
+        __u16 version_id;               /* Version identifier */
+        __u32 block_size;               /* Disk block size */
+        __u32 origin_ptr;               /* Disk origin pointer */
+        __u32 usable_count;     /* Number of usable cylinders/blocks */
+        __u32 formatted_count;  /* Maximum number of formatted cylinders/
                                  * blocks */
-        u32 block_count;        /* Disk size in CMS blocks */
-        u32 used_count;         /* Number of CMS blocks in use */
-        u32 fst_size;           /* File Status Table (FST) size */
-        u32 fst_count;          /* Number of FSTs per CMS block */
-        u8 format_date[6];      /* Disk FORMAT date */
-        u8 reserved1[2];
-        u32 disk_offset;        /* Disk offset when reserved*/
-        u32 map_block;          /* Allocation Map Block with next hole */
-        u32 hblk_disp;          /* Displacement into HBLK data of next hole */
-        u32 user_disp;          /* Displacement into user part of Allocation
+        __u32 block_count;      /* Disk size in CMS blocks */
+        __u32 used_count;               /* Number of CMS blocks in use */
+        __u32 fst_size;         /* File Status Table (FST) size */
+        __u32 fst_count;                /* Number of FSTs per CMS block */
+        __u8 format_date[6];    /* Disk FORMAT date */
+        __u8 reserved1[2];
+        __u32 disk_offset;      /* Disk offset when reserved*/
+        __u32 map_block;                /* Allocation Map Block with next hole */
+        __u32 hblk_disp;                /* Displacement into HBLK data of next hole */
+        __u32 user_disp;                /* Displacement into user part of Allocation
                                  * map */
-        u8 reserved2[4];
-        u8 segment_name[8];     /* Name of shared segment */
+        __u8 reserved2[4];
+        __u8 segment_name[8];   /* Name of shared segment */
 } __attribute__ ((packed));
 
 #endif /* _ASM_S390_VTOC_H */
diff --git a/include/asm-s390/z90crypt.h b/include/asm-s390/z90crypt.h
new file mode 100644
index 000000000000..31a2439b07bd
--- /dev/null
+++ b/include/asm-s390/z90crypt.h
@@ -0,0 +1,212 @@
+/*
+ *  include/asm-s390/z90crypt.h
+ *
+ *  z90crypt 1.3.3 (user-visible header)
+ *
+ *  Copyright (C)  2001, 2005 IBM Corporation
+ *  Author(s): Robert Burroughs
+ *             Eric Rossman (edrossma@us.ibm.com)
+ *
+ *  Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __ASM_S390_Z90CRYPT_H
+#define __ASM_S390_Z90CRYPT_H
+#include <linux/ioctl.h>
+
+#define z90crypt_VERSION 1
+#define z90crypt_RELEASE 3      // 2 = PCIXCC, 3 = rewrite for coding standards
+#define z90crypt_VARIANT 3      // 3 = CEX2A support
+
+/**
+ * struct ica_rsa_modexpo
+ *
+ * Requirements:
+ * - outputdatalength is at least as large as inputdatalength.
+ * - All key parts are right justified in their fields, padded on
+ *   the left with zeroes.
+ * - length(b_key) = inputdatalength
+ * - length(n_modulus) = inputdatalength
+ */
+struct ica_rsa_modexpo {
+        char __user *   inputdata;
+        unsigned int    inputdatalength;
+        char __user *   outputdata;
+        unsigned int    outputdatalength;
+        char __user *   b_key;
+        char __user *   n_modulus;
+};
+
+/**
+ * struct ica_rsa_modexpo_crt
+ *
+ * Requirements:
+ * - inputdatalength is even.
+ * - outputdatalength is at least as large as inputdatalength.
+ * - All key parts are right justified in their fields, padded on
+ *   the left with zeroes.
+ * - length(bp_key)     = inputdatalength/2 + 8
+ * - length(bq_key)     = inputdatalength/2
+ * - length(np_key)     = inputdatalength/2 + 8
+ * - length(nq_key)     = inputdatalength/2
+ * - length(u_mult_inv) = inputdatalength/2 + 8
+ */
+struct ica_rsa_modexpo_crt {
+        char __user *   inputdata;
+        unsigned int    inputdatalength;
+        char __user *   outputdata;
+        unsigned int    outputdatalength;
+        char __user *   bp_key;
+        char __user *   bq_key;
+        char __user *   np_prime;
+        char __user *   nq_prime;
+        char __user *   u_mult_inv;
+};
+
+#define Z90_IOCTL_MAGIC 'z'  // NOTE:  Need to allocate from linux folks
+
+/**
+ * Interface notes:
+ *
+ * The ioctl()s which are implemented (along with relevant details)
+ * are:
+ *
+ *   ICARSAMODEXPO
+ *     Perform an RSA operation using a Modulus-Exponent pair
+ *     This takes an ica_rsa_modexpo struct as its arg.
+ *
+ *     NOTE: please refer to the comments preceding this structure
+ *           for the implementation details for the contents of the
+ *           block
+ *
+ *   ICARSACRT
+ *     Perform an RSA operation using a Chinese-Remainder Theorem key
+ *     This takes an ica_rsa_modexpo_crt struct as its arg.
+ *
+ *     NOTE: please refer to the comments preceding this structure
+ *           for the implementation details for the contents of the
+ *           block
+ *
+ *   Z90STAT_TOTALCOUNT
+ *     Return an integer count of all device types together.
+ *
+ *   Z90STAT_PCICACOUNT
+ *     Return an integer count of all PCICAs.
+ *
+ *   Z90STAT_PCICCCOUNT
+ *     Return an integer count of all PCICCs.
+ *
+ *   Z90STAT_PCIXCCMCL2COUNT
+ *     Return an integer count of all MCL2 PCIXCCs.
+ *
+ *   Z90STAT_PCIXCCMCL3COUNT
+ *     Return an integer count of all MCL3 PCIXCCs.
+ *
+ *   Z90STAT_CEX2CCOUNT
+ *     Return an integer count of all CEX2Cs.
+ *
+ *   Z90STAT_CEX2ACOUNT
+ *     Return an integer count of all CEX2As.
+ *
+ *   Z90STAT_REQUESTQ_COUNT
+ *     Return an integer count of the number of entries waiting to be
+ *     sent to a device.
+ *
+ *   Z90STAT_PENDINGQ_COUNT
+ *     Return an integer count of the number of entries sent to a
+ *     device awaiting the reply.
+ *
+ *   Z90STAT_TOTALOPEN_COUNT
+ *     Return an integer count of the number of open file handles.
+ *
+ *   Z90STAT_DOMAIN_INDEX
+ *     Return the integer value of the Cryptographic Domain.
+ *
+ *   Z90STAT_STATUS_MASK
+ *     Return an 64 element array of unsigned chars for the status of
+ *     all devices.
+ *       0x01: PCICA
+ *       0x02: PCICC
+ *       0x03: PCIXCC_MCL2
+ *       0x04: PCIXCC_MCL3
+ *       0x05: CEX2C
+ *       0x06: CEX2A
+ *       0x0d: device is disabled via the proc filesystem
+ *
+ *   Z90STAT_QDEPTH_MASK
+ *     Return an 64 element array of unsigned chars for the queue
+ *     depth of all devices.
+ *
+ *   Z90STAT_PERDEV_REQCNT
+ *     Return an 64 element array of unsigned integers for the number
+ *     of successfully completed requests per device since the device
+ *     was detected and made available.
+ *
+ *   ICAZ90STATUS (deprecated)
+ *     Return some device driver status in a ica_z90_status struct
+ *     This takes an ica_z90_status struct as its arg.
+ *
+ *     NOTE: this ioctl() is deprecated, and has been replaced with
+ *           single ioctl()s for each type of status being requested
+ *
+ *   Z90STAT_PCIXCCCOUNT (deprecated)
+ *     Return an integer count of all PCIXCCs (MCL2 + MCL3).
+ *     This is DEPRECATED now that MCL3 PCIXCCs are treated differently from
+ *     MCL2 PCIXCCs.
+ *
+ *   Z90QUIESCE (not recommended)
+ *     Quiesce the driver.  This is intended to stop all new
+ *     requests from being processed.  Its use is NOT recommended,
+ *     except in circumstances where there is no other way to stop
+ *     callers from accessing the driver.  Its original use was to
+ *     allow the driver to be "drained" of work in preparation for
+ *     a system shutdown.
+ *
+ *     NOTE: once issued, this ban on new work cannot be undone
+ *           except by unloading and reloading the driver.
+ */
+
+/**
+ * Supported ioctl calls
+ */
+#define ICARSAMODEXPO   _IOC(_IOC_READ|_IOC_WRITE, Z90_IOCTL_MAGIC, 0x05, 0)
+#define ICARSACRT       _IOC(_IOC_READ|_IOC_WRITE, Z90_IOCTL_MAGIC, 0x06, 0)
+
+/* DEPRECATED status calls (bound for removal at some point) */
+#define ICAZ90STATUS    _IOR(Z90_IOCTL_MAGIC, 0x10, struct ica_z90_status)
+#define Z90STAT_PCIXCCCOUNT     _IOR(Z90_IOCTL_MAGIC, 0x43, int)
+
+/* unrelated to ICA callers */
+#define Z90QUIESCE      _IO(Z90_IOCTL_MAGIC, 0x11)
+
+/* New status calls */
+#define Z90STAT_TOTALCOUNT      _IOR(Z90_IOCTL_MAGIC, 0x40, int)
+#define Z90STAT_PCICACOUNT      _IOR(Z90_IOCTL_MAGIC, 0x41, int)
+#define Z90STAT_PCICCCOUNT      _IOR(Z90_IOCTL_MAGIC, 0x42, int)
+#define Z90STAT_PCIXCCMCL2COUNT _IOR(Z90_IOCTL_MAGIC, 0x4b, int)
+#define Z90STAT_PCIXCCMCL3COUNT _IOR(Z90_IOCTL_MAGIC, 0x4c, int)
+#define Z90STAT_CEX2CCOUNT      _IOR(Z90_IOCTL_MAGIC, 0x4d, int)
+#define Z90STAT_CEX2ACOUNT      _IOR(Z90_IOCTL_MAGIC, 0x4e, int)
+#define Z90STAT_REQUESTQ_COUNT  _IOR(Z90_IOCTL_MAGIC, 0x44, int)
+#define Z90STAT_PENDINGQ_COUNT  _IOR(Z90_IOCTL_MAGIC, 0x45, int)
+#define Z90STAT_TOTALOPEN_COUNT _IOR(Z90_IOCTL_MAGIC, 0x46, int)
+#define Z90STAT_DOMAIN_INDEX    _IOR(Z90_IOCTL_MAGIC, 0x47, int)
+#define Z90STAT_STATUS_MASK     _IOR(Z90_IOCTL_MAGIC, 0x48, char[64])
+#define Z90STAT_QDEPTH_MASK     _IOR(Z90_IOCTL_MAGIC, 0x49, char[64])
+#define Z90STAT_PERDEV_REQCNT   _IOR(Z90_IOCTL_MAGIC, 0x4a, int[64])
+
+#endif /* __ASM_S390_Z90CRYPT_H */
diff --git a/include/asm-sh/bug.h b/include/asm-sh/bug.h
index 70508a360cd6..1b4fc52a59e8 100644
--- a/include/asm-sh/bug.h
+++ b/include/asm-sh/bug.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_SH_BUG_H
 #define __ASM_SH_BUG_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_BUG
 /*
diff --git a/include/asm-sh/checksum.h b/include/asm-sh/checksum.h
index 5ebd0f24299e..fa03b30c4269 100644
--- a/include/asm-sh/checksum.h
+++ b/include/asm-sh/checksum.h
@@ -9,7 +9,6 @@
  * Copyright (C) 1999 by Kaz Kojima & Niibe Yutaka
  */
 
-#include <linux/config.h>
 #include <linux/in6.h>
 
 /*
diff --git a/include/asm-sh/dma-mapping.h b/include/asm-sh/dma-mapping.h
index 48f1f42c5d14..124968f9866e 100644
--- a/include/asm-sh/dma-mapping.h
+++ b/include/asm-sh/dma-mapping.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_SH_DMA_MAPPING_H
 #define __ASM_SH_DMA_MAPPING_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <asm/scatterlist.h>
 #include <asm/cacheflush.h>
diff --git a/include/asm-sh/dma.h b/include/asm-sh/dma.h
index a118a0d43053..e62a6d0ed932 100644
--- a/include/asm-sh/dma.h
+++ b/include/asm-sh/dma.h
@@ -11,7 +11,6 @@
 #define __ASM_SH_DMA_H
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/spinlock.h>
 #include <linux/wait.h>
 #include <linux/sysdev.h>
diff --git a/include/asm-sh/fixmap.h b/include/asm-sh/fixmap.h
index 509224bdba28..412bccaa07e6 100644
--- a/include/asm-sh/fixmap.h
+++ b/include/asm-sh/fixmap.h
@@ -13,7 +13,6 @@
 #ifndef _ASM_FIXMAP_H
 #define _ASM_FIXMAP_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <asm/page.h>
 #ifdef CONFIG_HIGHMEM
diff --git a/include/asm-sh/hardirq.h b/include/asm-sh/hardirq.h
index f2fdf0f760e5..715ee237fc77 100644
--- a/include/asm-sh/hardirq.h
+++ b/include/asm-sh/hardirq.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_SH_HARDIRQ_H
 #define __ASM_SH_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/irq.h>
 
diff --git a/include/asm-sh/hd64461/hd64461.h b/include/asm-sh/hd64461/hd64461.h
index c457ca277a42..87f13d24c630 100644
--- a/include/asm-sh/hd64461/hd64461.h
+++ b/include/asm-sh/hd64461/hd64461.h
@@ -5,7 +5,6 @@
  *      Copyright (C) 2000 YAEGASHI Takeshi
  *      Hitachi HD64461 companion chip support
  */
-#include <linux/config.h>
 
 /* Constants for PCMCIA mappings */
 #define HD64461_PCC_WINDOW      0x01000000
diff --git a/include/asm-sh/hd64465/hd64465.h b/include/asm-sh/hd64465/hd64465.h
index c672032b72c9..cfd0e803d2a2 100644
--- a/include/asm-sh/hd64465/hd64465.h
+++ b/include/asm-sh/hd64465/hd64465.h
@@ -11,7 +11,6 @@
  * Derived from <asm/hd64461.h> which bore the message:
  * Copyright (C) 2000 YAEGASHI Takeshi
  */
-#include <linux/config.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 
diff --git a/include/asm-sh/ide.h b/include/asm-sh/ide.h
index 711dad4cb48b..9f8e9142dc33 100644
--- a/include/asm-sh/ide.h
+++ b/include/asm-sh/ide.h
@@ -14,7 +14,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #define ide_default_io_ctl(base)        (0)
 
diff --git a/include/asm-sh/io.h b/include/asm-sh/io.h
index 2c3afe71323d..894e64b2d5f0 100644
--- a/include/asm-sh/io.h
+++ b/include/asm-sh/io.h
@@ -23,7 +23,6 @@
  *  inb   by default expands to _inb, but the machine specific code may
  *        define it to __inb if it chooses.
  */
-#include <linux/config.h>
 #include <asm/cache.h>
 #include <asm/system.h>
 #include <asm/addrspace.h>
diff --git a/include/asm-sh/irq.h b/include/asm-sh/irq.h
index 42b8394c04ed..611e67cd0627 100644
--- a/include/asm-sh/irq.h
+++ b/include/asm-sh/irq.h
@@ -11,7 +11,6 @@
  *
  */
 
-#include <linux/config.h>
 #include <asm/machvec.h>
 #include <asm/ptrace.h>         /* for pt_regs */
 
diff --git a/include/asm-sh/keyboard.h b/include/asm-sh/keyboard.h
index 1103df003243..31dcc4fa5f28 100644
--- a/include/asm-sh/keyboard.h
+++ b/include/asm-sh/keyboard.h
@@ -5,7 +5,6 @@
  */
 
 #include <linux/kd.h>
-#include <linux/config.h>
 #include <asm/machvec.h>
 
 #ifdef CONFIG_SH_MPC1211
diff --git a/include/asm-sh/kmap_types.h b/include/asm-sh/kmap_types.h
index 2492ba07148f..84d565c696be 100644
--- a/include/asm-sh/kmap_types.h
+++ b/include/asm-sh/kmap_types.h
@@ -3,7 +3,6 @@
 
 /* Dummy header just to define km_type. */
 
-#include <linux/config.h>
 
 #ifdef CONFIG_DEBUG_HIGHMEM
 # define D(n) __KM_FENCE_##n ,
diff --git a/include/asm-sh/machvec.h b/include/asm-sh/machvec.h
index 550c50a7359e..550501fa4fed 100644
--- a/include/asm-sh/machvec.h
+++ b/include/asm-sh/machvec.h
@@ -10,7 +10,6 @@
 #ifndef _ASM_SH_MACHVEC_H
 #define _ASM_SH_MACHVEC_H 1
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/time.h>
 
diff --git a/include/asm-sh/machvec_init.h b/include/asm-sh/machvec_init.h
index 9e7de808f7f8..e397798ebd94 100644
--- a/include/asm-sh/machvec_init.h
+++ b/include/asm-sh/machvec_init.h
@@ -12,7 +12,6 @@
 #ifndef __SH_MACHVEC_INIT_H
 #define __SH_MACHVEC_INIT_H
 
-#include <linux/config.h>
 
 /*
  * In a GENERIC kernel, we have lots of these vectors floating about,
diff --git a/include/asm-sh/mpc1211/dma.h b/include/asm-sh/mpc1211/dma.h
index 0a2fdab3e454..e506d1aaa0d0 100644
--- a/include/asm-sh/mpc1211/dma.h
+++ b/include/asm-sh/mpc1211/dma.h
@@ -8,7 +8,6 @@
 #ifndef _ASM_MPC1211_DMA_H
 #define _ASM_MPC1211_DMA_H
 
-#include <linux/config.h>
 #include <linux/spinlock.h>     /* And spinlocks */
 #include <asm/io.h>             /* need byte IO */
 #include <linux/delay.h>
diff --git a/include/asm-sh/overdrive/overdrive.h b/include/asm-sh/overdrive/overdrive.h
index aa62ae68c55c..fc746c244f83 100644
--- a/include/asm-sh/overdrive/overdrive.h
+++ b/include/asm-sh/overdrive/overdrive.h
@@ -6,7 +6,6 @@
  *
  */
 
-#include <linux/config.h>
 
 #ifndef __OVERDRIVE_H__
 #define __OVERDRIVE_H__
diff --git a/include/asm-sh/page.h b/include/asm-sh/page.h
index 9c89287c3e56..a5559e38744e 100644
--- a/include/asm-sh/page.h
+++ b/include/asm-sh/page.h
@@ -13,7 +13,6 @@
    [ P4 control   ]             0xE0000000
  */
 
-#include <linux/config.h>
 
 /* PAGE_SHIFT determines the page size */
 #define PAGE_SHIFT      12
diff --git a/include/asm-sh/pgtable.h b/include/asm-sh/pgtable.h
index bb0efb31a8cb..dcd23a03683d 100644
--- a/include/asm-sh/pgtable.h
+++ b/include/asm-sh/pgtable.h
@@ -8,7 +8,6 @@
  * Copyright (C) 2002, 2003, 2004 Paul Mundt
  */
 
-#include <linux/config.h>
 #include <asm/pgtable-2level.h>
 
 /*
diff --git a/include/asm-sh/serial.h b/include/asm-sh/serial.h
index f51e232d5cd9..8734590d27e8 100644
--- a/include/asm-sh/serial.h
+++ b/include/asm-sh/serial.h
@@ -7,7 +7,6 @@
 #ifndef _ASM_SERIAL_H
 #define _ASM_SERIAL_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 
 #ifdef CONFIG_SH_EC3104
diff --git a/include/asm-sh/smp.h b/include/asm-sh/smp.h
index f19a8b3b69a6..f57c4fe9692a 100644
--- a/include/asm-sh/smp.h
+++ b/include/asm-sh/smp.h
@@ -10,7 +10,6 @@
 #ifndef __ASM_SH_SMP_H
 #define __ASM_SH_SMP_H
 
-#include <linux/config.h>
 #include <linux/bitops.h>
 #include <linux/cpumask.h>
 
diff --git a/include/asm-sh/system.h b/include/asm-sh/system.h
index bb0330499bdf..b752e5cbb830 100644
--- a/include/asm-sh/system.h
+++ b/include/asm-sh/system.h
@@ -6,7 +6,6 @@
  * Copyright (C) 2002 Paul Mundt
  */
 
-#include <linux/config.h>
 
 /*
  *      switch_to() should switch tasks to task nr n, first
diff --git a/include/asm-sh/types.h b/include/asm-sh/types.h
index 488552f43b2a..3c09dd4ca31c 100644
--- a/include/asm-sh/types.h
+++ b/include/asm-sh/types.h
@@ -35,7 +35,6 @@ typedef unsigned long long __u64;
 
 #ifndef __ASSEMBLY__
 
-#include <linux/config.h>
 
 typedef __signed__ char s8;
 typedef unsigned char u8;
diff --git a/include/asm-sh/unistd.h b/include/asm-sh/unistd.h
index 05520cebda12..76b5430cb458 100644
--- a/include/asm-sh/unistd.h
+++ b/include/asm-sh/unistd.h
@@ -304,6 +304,8 @@
 
 #define NR_syscalls 293
 
+#ifdef __KERNEL__
+
 /* user-visible error numbers are in the range -1 - -124: see <asm-sh/errno.h> */
 
 #define __syscall_return(type, res) \
@@ -420,7 +422,6 @@ __asm__ __volatile__ ("trapa	#0x16" \
 __syscall_return(type,__sc0); \
 }
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_OLD_STAT
@@ -443,7 +444,6 @@ __syscall_return(type,__sc0); \
 #define __ARCH_WANT_SYS_SIGPENDING
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
-#endif
 
 #ifdef __KERNEL_SYSCALLS__
 
@@ -513,7 +513,7 @@ asmlinkage long sys_rt_sigaction(int sig,
                                 struct sigaction __user *oact,
                                 size_t sigsetsize);
 
-#endif
+#endif /* __KERNEL_SYSCALLS__ */
 
 /*
  * "Conditional" syscalls
@@ -525,4 +525,5 @@ asmlinkage long sys_rt_sigaction(int sig,
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 #endif
 
+#endif /* __KERNEL__ */
 #endif /* __ASM_SH_UNISTD_H */
diff --git a/include/asm-sh/watchdog.h b/include/asm-sh/watchdog.h
index f0cf4be21655..09ca41972a11 100644
--- a/include/asm-sh/watchdog.h
+++ b/include/asm-sh/watchdog.h
@@ -13,7 +13,6 @@
 #ifdef __KERNEL__
 
 #include <linux/types.h>
-#include <linux/config.h>
 #include <asm/cpu/watchdog.h>
 #include <asm/io.h>
 
diff --git a/include/asm-sh64/bug.h b/include/asm-sh64/bug.h
index 5d659ec28e10..81f722efeb63 100644
--- a/include/asm-sh64/bug.h
+++ b/include/asm-sh64/bug.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_SH64_BUG_H
 #define __ASM_SH64_BUG_H
 
-#include <linux/config.h>
 
 /*
  * Tell the user there is some problem, then force a segfault (in process
diff --git a/include/asm-sh64/dma-mapping.h b/include/asm-sh64/dma-mapping.h
index cc9a2e86f5b4..a74a49e47922 100644
--- a/include/asm-sh64/dma-mapping.h
+++ b/include/asm-sh64/dma-mapping.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_SH_DMA_MAPPING_H
 #define __ASM_SH_DMA_MAPPING_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <asm/scatterlist.h>
 #include <asm/io.h>
diff --git a/include/asm-sh64/hardirq.h b/include/asm-sh64/hardirq.h
index ad2330e41fd5..555fd7a35108 100644
--- a/include/asm-sh64/hardirq.h
+++ b/include/asm-sh64/hardirq.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_SH64_HARDIRQ_H
 #define __ASM_SH64_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/irq.h>
 
diff --git a/include/asm-sh64/ide.h b/include/asm-sh64/ide.h
index 852f50afe39c..c9d84d5f772e 100644
--- a/include/asm-sh64/ide.h
+++ b/include/asm-sh64/ide.h
@@ -15,7 +15,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 /* Without this, the initialisation of PCI IDE cards end up calling
  * ide_init_hwif_ports, which won't work. */
diff --git a/include/asm-sh64/irq.h b/include/asm-sh64/irq.h
index f815b43df845..1ca49e29288a 100644
--- a/include/asm-sh64/irq.h
+++ b/include/asm-sh64/irq.h
@@ -12,7 +12,6 @@
  *
  */
 
-#include <linux/config.h>
 
 /*
  * Encoded IRQs are not considered worth to be supported.
diff --git a/include/asm-sh64/mmu_context.h b/include/asm-sh64/mmu_context.h
index 991cfda4cdf6..8c860dab2d0e 100644
--- a/include/asm-sh64/mmu_context.h
+++ b/include/asm-sh64/mmu_context.h
@@ -26,7 +26,6 @@
  */
 extern unsigned long mmu_context_cache;
 
-#include <linux/config.h>
 #include <asm/page.h>
 
 
diff --git a/include/asm-sh64/page.h b/include/asm-sh64/page.h
index e4937cdabebd..34fb34754ae6 100644
--- a/include/asm-sh64/page.h
+++ b/include/asm-sh64/page.h
@@ -17,7 +17,6 @@
  *
  */
 
-#include <linux/config.h>
 
 /* PAGE_SHIFT determines the page size */
 #define PAGE_SHIFT      12
diff --git a/include/asm-sh64/param.h b/include/asm-sh64/param.h
index d18cc87c1a80..f409adb41540 100644
--- a/include/asm-sh64/param.h
+++ b/include/asm-sh64/param.h
@@ -12,7 +12,6 @@
 #ifndef __ASM_SH64_PARAM_H
 #define __ASM_SH64_PARAM_H
 
-#include <linux/config.h>
 
 #ifdef __KERNEL__
 # ifdef CONFIG_SH_WDT
diff --git a/include/asm-sh64/pgtable.h b/include/asm-sh64/pgtable.h
index 57af6b3eb271..54c7821893f5 100644
--- a/include/asm-sh64/pgtable.h
+++ b/include/asm-sh64/pgtable.h
@@ -22,7 +22,6 @@
 #include <asm/processor.h>
 #include <asm/page.h>
 #include <linux/threads.h>
-#include <linux/config.h>
 
 struct vm_area_struct;
 
diff --git a/include/asm-sh64/system.h b/include/asm-sh64/system.h
index 3002e988180c..7606f6e1f01e 100644
--- a/include/asm-sh64/system.h
+++ b/include/asm-sh64/system.h
@@ -14,7 +14,6 @@
  *
  */
 
-#include <linux/config.h>
 #include <asm/registers.h>
 #include <asm/processor.h>
 
diff --git a/include/asm-sh64/unistd.h b/include/asm-sh64/unistd.h
index 1f8f394ae371..9a1590fffc15 100644
--- a/include/asm-sh64/unistd.h
+++ b/include/asm-sh64/unistd.h
@@ -344,6 +344,8 @@
 #define __NR_inotify_add_watch  319
 #define __NR_inotify_rm_watch   320
 
+#ifdef __KERNEL__ 
+
 #define NR_syscalls 321
 
 /* user-visible error numbers are in the range -1 - -125: see <asm-sh64/errno.h> */
@@ -486,7 +488,6 @@ __asm__ __volatile__ ("!dummy	%0 %1 %2 %3 %4 %5 %6"		   	    \
 __syscall_return(type,__sc0);                                               \
 }
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_OLD_STAT
@@ -509,7 +510,6 @@ __syscall_return(type,__sc0); 						    \
 #define __ARCH_WANT_SYS_SIGPENDING
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
-#endif
 
 #ifdef __KERNEL_SYSCALLS__
 
@@ -550,7 +550,7 @@ static inline pid_t wait(int * wait_stat)
 {
         return waitpid(-1,wait_stat,0);
 }
-#endif
+#endif /* __KERNEL_SYSCALLS__ */
 
 /*
  * "Conditional" syscalls
@@ -562,4 +562,5 @@ static inline pid_t wait(int * wait_stat)
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 #endif
 
+#endif /* __KERNEL__ */
 #endif /* __ASM_SH64_UNISTD_H */
diff --git a/include/asm-sparc/asmmacro.h b/include/asm-sparc/asmmacro.h
index 0d4b65bd252b..a619a4d97aae 100644
--- a/include/asm-sparc/asmmacro.h
+++ b/include/asm-sparc/asmmacro.h
@@ -6,7 +6,6 @@
 #ifndef _SPARC_ASMMACRO_H
 #define _SPARC_ASMMACRO_H
 
-#include <linux/config.h>
 #include <asm/btfixup.h>
 #include <asm/asi.h>
 
diff --git a/include/asm-sparc/atomic.h b/include/asm-sparc/atomic.h
index e1033170bd3a..731fa56e0c37 100644
--- a/include/asm-sparc/atomic.h
+++ b/include/asm-sparc/atomic.h
@@ -10,7 +10,6 @@
 #ifndef __ARCH_SPARC_ATOMIC__
 #define __ARCH_SPARC_ATOMIC__
 
-#include <linux/config.h>
 
 typedef struct { volatile int counter; } atomic_t;
 
diff --git a/include/asm-sparc/bugs.h b/include/asm-sparc/bugs.h
index e652f89e0eff..a0f939beeea1 100644
--- a/include/asm-sparc/bugs.h
+++ b/include/asm-sparc/bugs.h
@@ -5,7 +5,6 @@
  */
 
 #include <asm/cpudata.h>
-#include <linux/config.h>
 
 extern unsigned long loops_per_jiffy;
 
diff --git a/include/asm-sparc/cacheflush.h b/include/asm-sparc/cacheflush.h
index 4901217008c0..fc632f811cd8 100644
--- a/include/asm-sparc/cacheflush.h
+++ b/include/asm-sparc/cacheflush.h
@@ -1,7 +1,6 @@
 #ifndef _SPARC_CACHEFLUSH_H
 #define _SPARC_CACHEFLUSH_H
 
-#include <linux/config.h>
 #include <linux/mm.h>           /* Common for other includes */
 // #include <linux/kernel.h> from pgalloc.h
 // #include <linux/sched.h>  from pgalloc.h
diff --git a/include/asm-sparc/delay.h b/include/asm-sparc/delay.h
index 7ec8e9f7ad4f..48aa70eef997 100644
--- a/include/asm-sparc/delay.h
+++ b/include/asm-sparc/delay.h
@@ -7,7 +7,6 @@
 #ifndef __SPARC_DELAY_H
 #define __SPARC_DELAY_H
 
-#include <linux/config.h>
 #include <asm/cpudata.h>
 
 static inline void __delay(unsigned long loops)
diff --git a/include/asm-sparc/dma-mapping.h b/include/asm-sparc/dma-mapping.h
index d7c3b0f0a901..6db83dc93cb7 100644
--- a/include/asm-sparc/dma-mapping.h
+++ b/include/asm-sparc/dma-mapping.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_SPARC_DMA_MAPPING_H
 #define _ASM_SPARC_DMA_MAPPING_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_PCI
 #include <asm-generic/dma-mapping.h>
diff --git a/include/asm-sparc/dma.h b/include/asm-sparc/dma.h
index 8ec206aa5f2e..407b3614468a 100644
--- a/include/asm-sparc/dma.h
+++ b/include/asm-sparc/dma.h
@@ -7,7 +7,6 @@
 #ifndef _ASM_SPARC_DMA_H
 #define _ASM_SPARC_DMA_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 
diff --git a/include/asm-sparc/elf.h b/include/asm-sparc/elf.h
index 4a71d7c1eace..83a3dd15a6ed 100644
--- a/include/asm-sparc/elf.h
+++ b/include/asm-sparc/elf.h
@@ -6,7 +6,6 @@
  * ELF register definitions..
  */
 
-#include <linux/config.h>
 #include <asm/ptrace.h>
 
 #ifdef __KERNEL__
diff --git a/include/asm-sparc/fixmap.h b/include/asm-sparc/fixmap.h
index 9de52b4d2cfb..f18fc0755adf 100644
--- a/include/asm-sparc/fixmap.h
+++ b/include/asm-sparc/fixmap.h
@@ -13,7 +13,6 @@
 #ifndef _ASM_FIXMAP_H
 #define _ASM_FIXMAP_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <asm/page.h>
 #ifdef CONFIG_HIGHMEM
diff --git a/include/asm-sparc/hardirq.h b/include/asm-sparc/hardirq.h
index 2a668c479f68..4f63ed8df551 100644
--- a/include/asm-sparc/hardirq.h
+++ b/include/asm-sparc/hardirq.h
@@ -7,7 +7,6 @@
 #ifndef __SPARC_HARDIRQ_H
 #define __SPARC_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/spinlock.h>
 #include <linux/cache.h>
diff --git a/include/asm-sparc/ide.h b/include/asm-sparc/ide.h
index 64d810385ea4..a6d735a1310e 100644
--- a/include/asm-sparc/ide.h
+++ b/include/asm-sparc/ide.h
@@ -11,7 +11,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <asm/pgtable.h>
 #include <asm/io.h>
 #include <asm/psr.h>
diff --git a/include/asm-sparc/irq.h b/include/asm-sparc/irq.h
index cee356b0dae3..dbc687403208 100644
--- a/include/asm-sparc/irq.h
+++ b/include/asm-sparc/irq.h
@@ -7,7 +7,6 @@
 #ifndef _SPARC_IRQ_H
 #define _SPARC_IRQ_H
 
-#include <linux/config.h>
 #include <linux/linkage.h>
 #include <linux/threads.h>     /* For NR_CPUS */
 #include <linux/interrupt.h>
diff --git a/include/asm-sparc/mostek.h b/include/asm-sparc/mostek.h
index 59b86bc793bf..bd92a78f4937 100644
--- a/include/asm-sparc/mostek.h
+++ b/include/asm-sparc/mostek.h
@@ -9,7 +9,6 @@
 #ifndef _SPARC_MOSTEK_H
 #define _SPARC_MOSTEK_H
 
-#include <linux/config.h>
 #include <asm/idprom.h>
 #include <asm/io.h>
 
diff --git a/include/asm-sparc/page.h b/include/asm-sparc/page.h
index ec3274b7ddf4..5bab8a7c25ce 100644
--- a/include/asm-sparc/page.h
+++ b/include/asm-sparc/page.h
@@ -8,7 +8,6 @@
 #ifndef _SPARC_PAGE_H
 #define _SPARC_PAGE_H
 
-#include <linux/config.h>
 #ifdef CONFIG_SUN4
 #define PAGE_SHIFT   13
 #else
diff --git a/include/asm-sparc/pgalloc.h b/include/asm-sparc/pgalloc.h
index 126800acd10d..a449cd4912d1 100644
--- a/include/asm-sparc/pgalloc.h
+++ b/include/asm-sparc/pgalloc.h
@@ -2,7 +2,6 @@
 #ifndef _SPARC_PGALLOC_H
 #define _SPARC_PGALLOC_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
 
diff --git a/include/asm-sparc/pgtable.h b/include/asm-sparc/pgtable.h
index 9eea8f4d41f0..226c6475c9a2 100644
--- a/include/asm-sparc/pgtable.h
+++ b/include/asm-sparc/pgtable.h
@@ -11,7 +11,6 @@
 
 #include <asm-generic/4level-fixup.h>
 
-#include <linux/config.h>
 #include <linux/spinlock.h>
 #include <linux/swap.h>
 #include <asm/types.h>
diff --git a/include/asm-sparc/sfp-machine.h b/include/asm-sparc/sfp-machine.h
index b4ca2d94bf08..ecfc86a4a725 100644
--- a/include/asm-sparc/sfp-machine.h
+++ b/include/asm-sparc/sfp-machine.h
@@ -25,7 +25,6 @@
 #ifndef _SFP_MACHINE_H
 #define _SFP_MACHINE_H
 
-#include <linux/config.h>
    
 #define _FP_W_TYPE_SIZE         32
 #define _FP_W_TYPE              unsigned long
diff --git a/include/asm-sparc/smp.h b/include/asm-sparc/smp.h
index 98c46e3fbe8a..5a1b7e4e7cc9 100644
--- a/include/asm-sparc/smp.h
+++ b/include/asm-sparc/smp.h
@@ -6,7 +6,6 @@
 #ifndef _SPARC_SMP_H
 #define _SPARC_SMP_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <asm/head.h>
 #include <asm/btfixup.h>
diff --git a/include/asm-sparc/system.h b/include/asm-sparc/system.h
index 58dd162927bb..cb7dda1e5e91 100644
--- a/include/asm-sparc/system.h
+++ b/include/asm-sparc/system.h
@@ -1,10 +1,8 @@
 /* $Id: system.h,v 1.86 2001/10/30 04:57:10 davem Exp $ */
-#include <linux/config.h>
 
 #ifndef __SPARC_SYSTEM_H
 #define __SPARC_SYSTEM_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/threads.h>      /* NR_CPUS */
 #include <linux/thread_info.h>
diff --git a/include/asm-sparc/timer.h b/include/asm-sparc/timer.h
index b16eb739dddb..cb1fa1d1f184 100644
--- a/include/asm-sparc/timer.h
+++ b/include/asm-sparc/timer.h
@@ -4,7 +4,6 @@
  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  */
 
-#include <linux/config.h>
 
 #ifndef _SPARC_TIMER_H
 #define _SPARC_TIMER_H
diff --git a/include/asm-sparc/tlbflush.h b/include/asm-sparc/tlbflush.h
index 5643ca31ead9..4a3b66618e75 100644
--- a/include/asm-sparc/tlbflush.h
+++ b/include/asm-sparc/tlbflush.h
@@ -1,7 +1,6 @@
 #ifndef _SPARC_TLBFLUSH_H
 #define _SPARC_TLBFLUSH_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 // #include <asm/processor.h>
 
diff --git a/include/asm-sparc/unistd.h b/include/asm-sparc/unistd.h
index 45a576507785..2553762465ca 100644
--- a/include/asm-sparc/unistd.h
+++ b/include/asm-sparc/unistd.h
@@ -319,6 +319,7 @@
 #define __NR_set_robust_list    300
 #define __NR_get_robust_list    301
 
+#ifdef __KERNEL__
 /* WARNING: You MAY NOT add syscall numbers larger than 301, since
  *          all of the syscall tables in the Sparc kernel are
  *          sized to have 301 entries (starting at zero).  Therefore
@@ -455,7 +456,6 @@ errno = -__res; \
 return -1; \
 }
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_STAT64
@@ -477,7 +477,6 @@ return -1; \
 #define __ARCH_WANT_SYS_SIGPENDING
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
-#endif
 
 #ifdef __KERNEL_SYSCALLS__
 
@@ -534,4 +533,5 @@ asmlinkage long sys_rt_sigaction(int sig,
  */
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 
+#endif /* __KERNEL__ */
 #endif /* _SPARC_UNISTD_H */
diff --git a/include/asm-sparc/vac-ops.h b/include/asm-sparc/vac-ops.h
index 9e0172323042..ab6f53b913ea 100644
--- a/include/asm-sparc/vac-ops.h
+++ b/include/asm-sparc/vac-ops.h
@@ -8,7 +8,6 @@
  * Copyright (C) 1994, David S. Miller (davem@caip.rutgers.edu)
  */
 
-#include <linux/config.h>
 #include <asm/sysen.h>
 #include <asm/contregs.h>
 #include <asm/asi.h>
diff --git a/include/asm-sparc/winmacro.h b/include/asm-sparc/winmacro.h
index 557257eef3f9..096f3d3d90c3 100644
--- a/include/asm-sparc/winmacro.h
+++ b/include/asm-sparc/winmacro.h
@@ -7,7 +7,6 @@
 #ifndef _SPARC_WINMACRO_H
 #define _SPARC_WINMACRO_H
 
-#include <linux/config.h>
 #include <asm/ptrace.h>
 
 /* Store the register window onto the 8-byte aligned area starting
diff --git a/include/asm-sparc64/atomic.h b/include/asm-sparc64/atomic.h
index 468eb48d8142..2f0bec26a695 100644
--- a/include/asm-sparc64/atomic.h
+++ b/include/asm-sparc64/atomic.h
@@ -8,7 +8,6 @@
 #ifndef __ARCH_SPARC64_ATOMIC__
 #define __ARCH_SPARC64_ATOMIC__
 
-#include <linux/config.h>
 #include <linux/types.h>
 
 typedef struct { volatile int counter; } atomic_t;
diff --git a/include/asm-sparc64/bitops.h b/include/asm-sparc64/bitops.h
index 71944b0f09de..3d5e1af84723 100644
--- a/include/asm-sparc64/bitops.h
+++ b/include/asm-sparc64/bitops.h
@@ -7,7 +7,6 @@
 #ifndef _SPARC64_BITOPS_H
 #define _SPARC64_BITOPS_H
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <asm/byteorder.h>
 
diff --git a/include/asm-sparc64/bugs.h b/include/asm-sparc64/bugs.h
index 360dd04ed8e4..120422fdb02f 100644
--- a/include/asm-sparc64/bugs.h
+++ b/include/asm-sparc64/bugs.h
@@ -4,7 +4,6 @@
  *  Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
  */
 
-#include <linux/config.h>
 
 extern unsigned long loops_per_jiffy;
 
diff --git a/include/asm-sparc64/cacheflush.h b/include/asm-sparc64/cacheflush.h
index b3f61659ba81..745d1ab60371 100644
--- a/include/asm-sparc64/cacheflush.h
+++ b/include/asm-sparc64/cacheflush.h
@@ -1,7 +1,6 @@
 #ifndef _SPARC64_CACHEFLUSH_H
 #define _SPARC64_CACHEFLUSH_H
 
-#include <linux/config.h>
 #include <asm/page.h>
 
 #ifndef __ASSEMBLY__
diff --git a/include/asm-sparc64/delay.h b/include/asm-sparc64/delay.h
index 2901ea0c342d..a4aae6f80627 100644
--- a/include/asm-sparc64/delay.h
+++ b/include/asm-sparc64/delay.h
@@ -11,7 +11,6 @@
 #ifndef __SPARC64_DELAY_H
 #define __SPARC64_DELAY_H
 
-#include <linux/config.h>
 #include <linux/param.h>
 #include <asm/cpudata.h>
 
diff --git a/include/asm-sparc64/dma-mapping.h b/include/asm-sparc64/dma-mapping.h
index a8d39f23d43b..3c2b5bc8650b 100644
--- a/include/asm-sparc64/dma-mapping.h
+++ b/include/asm-sparc64/dma-mapping.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_SPARC64_DMA_MAPPING_H
 #define _ASM_SPARC64_DMA_MAPPING_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_PCI
 
diff --git a/include/asm-sparc64/dma.h b/include/asm-sparc64/dma.h
index 1aab3c8dce2b..27f65972b3bb 100644
--- a/include/asm-sparc64/dma.h
+++ b/include/asm-sparc64/dma.h
@@ -7,7 +7,6 @@
 #ifndef _ASM_SPARC64_DMA_H
 #define _ASM_SPARC64_DMA_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/spinlock.h>
diff --git a/include/asm-sparc64/floppy.h b/include/asm-sparc64/floppy.h
index 6a95d5d0c576..07ccd6f04b52 100644
--- a/include/asm-sparc64/floppy.h
+++ b/include/asm-sparc64/floppy.h
@@ -10,7 +10,6 @@
 #ifndef __ASM_SPARC64_FLOPPY_H
 #define __ASM_SPARC64_FLOPPY_H
 
-#include <linux/config.h>
 #include <linux/init.h>
 
 #include <asm/page.h>
diff --git a/include/asm-sparc64/ide.h b/include/asm-sparc64/ide.h
index c393f815b0be..55149cf933c2 100644
--- a/include/asm-sparc64/ide.h
+++ b/include/asm-sparc64/ide.h
@@ -10,7 +10,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <asm/pgalloc.h>
 #include <asm/io.h>
 #include <asm/spitfire.h>
diff --git a/include/asm-sparc64/irq.h b/include/asm-sparc64/irq.h
index de33d6e1afb5..fa164d37ee3f 100644
--- a/include/asm-sparc64/irq.h
+++ b/include/asm-sparc64/irq.h
@@ -8,7 +8,6 @@
 #ifndef _SPARC64_IRQ_H
 #define _SPARC64_IRQ_H
 
-#include <linux/config.h>
 #include <linux/linkage.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
diff --git a/include/asm-sparc64/kprobes.h b/include/asm-sparc64/kprobes.h
index e4efe652b54b..e9bb26f770ed 100644
--- a/include/asm-sparc64/kprobes.h
+++ b/include/asm-sparc64/kprobes.h
@@ -1,7 +1,6 @@
 #ifndef _SPARC64_KPROBES_H
 #define _SPARC64_KPROBES_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/percpu.h>
 
diff --git a/include/asm-sparc64/mc146818rtc.h b/include/asm-sparc64/mc146818rtc.h
index 75bd572b35fe..e9c0fcc25c6f 100644
--- a/include/asm-sparc64/mc146818rtc.h
+++ b/include/asm-sparc64/mc146818rtc.h
@@ -4,7 +4,6 @@
 #ifndef __ASM_SPARC64_MC146818RTC_H
 #define __ASM_SPARC64_MC146818RTC_H
 
-#include <linux/config.h>
 #include <asm/io.h>
 
 #ifndef RTC_PORT
diff --git a/include/asm-sparc64/mmu.h b/include/asm-sparc64/mmu.h
index 2d4f2ea9568a..70af4b6ce136 100644
--- a/include/asm-sparc64/mmu.h
+++ b/include/asm-sparc64/mmu.h
@@ -1,7 +1,6 @@
 #ifndef __MMU_H
 #define __MMU_H
 
-#include <linux/config.h>
 #include <asm/page.h>
 #include <asm/const.h>
 #include <asm/hypervisor.h>
diff --git a/include/asm-sparc64/oplib.h b/include/asm-sparc64/oplib.h
index c754676e13ef..dea3e73f0955 100644
--- a/include/asm-sparc64/oplib.h
+++ b/include/asm-sparc64/oplib.h
@@ -9,7 +9,6 @@
 #ifndef __SPARC64_OPLIB_H
 #define __SPARC64_OPLIB_H
 
-#include <linux/config.h>
 #include <asm/openprom.h>
 
 /* OBP version string. */
diff --git a/include/asm-sparc64/page.h b/include/asm-sparc64/page.h
index aabb21906724..fdf0ceb76028 100644
--- a/include/asm-sparc64/page.h
+++ b/include/asm-sparc64/page.h
@@ -3,7 +3,6 @@
 #ifndef _SPARC64_PAGE_H
 #define _SPARC64_PAGE_H
 
-#include <linux/config.h>
 #include <asm/const.h>
 
 #if defined(CONFIG_SPARC64_PAGE_SIZE_8KB)
diff --git a/include/asm-sparc64/param.h b/include/asm-sparc64/param.h
index a1cd4974630b..f0125cf5a9df 100644
--- a/include/asm-sparc64/param.h
+++ b/include/asm-sparc64/param.h
@@ -1,7 +1,6 @@
 #ifndef _ASMSPARC64_PARAM_H
 #define _ASMSPARC64_PARAM_H
 
-#include <linux/config.h>
 
 #ifdef __KERNEL__
 # define HZ             CONFIG_HZ       /* Internal kernel timer frequency */
diff --git a/include/asm-sparc64/pgalloc.h b/include/asm-sparc64/pgalloc.h
index 12e4a273bd43..010f9cd0a672 100644
--- a/include/asm-sparc64/pgalloc.h
+++ b/include/asm-sparc64/pgalloc.h
@@ -2,7 +2,6 @@
 #ifndef _SPARC64_PGALLOC_H
 #define _SPARC64_PGALLOC_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/mm.h>
diff --git a/include/asm-sparc64/pgtable.h b/include/asm-sparc64/pgtable.h
index cd464f469a2c..4e218814bb3c 100644
--- a/include/asm-sparc64/pgtable.h
+++ b/include/asm-sparc64/pgtable.h
@@ -14,7 +14,6 @@
 
 #include <asm-generic/pgtable-nopud.h>
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <asm/types.h>
 #include <asm/spitfire.h>
diff --git a/include/asm-sparc64/processor.h b/include/asm-sparc64/processor.h
index c6896b88283e..66dd2fa0e319 100644
--- a/include/asm-sparc64/processor.h
+++ b/include/asm-sparc64/processor.h
@@ -13,7 +13,6 @@
  */
 #define current_text_addr() ({ void *pc; __asm__("rd %%pc, %0" : "=r" (pc)); pc; })
 
-#include <linux/config.h>
 #include <asm/asi.h>
 #include <asm/a.out.h>
 #include <asm/pstate.h>
diff --git a/include/asm-sparc64/siginfo.h b/include/asm-sparc64/siginfo.h
index df17e47abc1c..c96e6c30f8b0 100644
--- a/include/asm-sparc64/siginfo.h
+++ b/include/asm-sparc64/siginfo.h
@@ -11,7 +11,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/compat.h>
 
 #ifdef CONFIG_COMPAT
diff --git a/include/asm-sparc64/signal.h b/include/asm-sparc64/signal.h
index e3059bb4a465..fdc42a14d4e6 100644
--- a/include/asm-sparc64/signal.h
+++ b/include/asm-sparc64/signal.h
@@ -6,7 +6,6 @@
 
 #ifdef __KERNEL__
 #ifndef __ASSEMBLY__
-#include <linux/config.h>
 #include <linux/personality.h>
 #include <linux/types.h>
 #include <linux/compat.h>
diff --git a/include/asm-sparc64/smp.h b/include/asm-sparc64/smp.h
index 89d86ecaab24..388249b751c3 100644
--- a/include/asm-sparc64/smp.h
+++ b/include/asm-sparc64/smp.h
@@ -6,7 +6,6 @@
 #ifndef _SPARC64_SMP_H
 #define _SPARC64_SMP_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <asm/asi.h>
 #include <asm/starfire.h>
diff --git a/include/asm-sparc64/spinlock.h b/include/asm-sparc64/spinlock.h
index 508c416e9d6a..bd5ffc76bc7e 100644
--- a/include/asm-sparc64/spinlock.h
+++ b/include/asm-sparc64/spinlock.h
@@ -6,7 +6,6 @@
 #ifndef __SPARC64_SPINLOCK_H
 #define __SPARC64_SPINLOCK_H
 
-#include <linux/config.h>
 #include <linux/threads.h>      /* For NR_CPUS */
 
 #ifndef __ASSEMBLY__
diff --git a/include/asm-sparc64/system.h b/include/asm-sparc64/system.h
index a18ec87a52c1..4ca68600c670 100644
--- a/include/asm-sparc64/system.h
+++ b/include/asm-sparc64/system.h
@@ -2,7 +2,6 @@
 #ifndef __SPARC64_SYSTEM_H
 #define __SPARC64_SYSTEM_H
 
-#include <linux/config.h>
 #include <asm/ptrace.h>
 #include <asm/processor.h>
 #include <asm/visasm.h>
diff --git a/include/asm-sparc64/timer.h b/include/asm-sparc64/timer.h
index edc8e08c3a39..d435594df786 100644
--- a/include/asm-sparc64/timer.h
+++ b/include/asm-sparc64/timer.h
@@ -9,7 +9,6 @@
 
 #include <linux/types.h>
 
-#include <linux/config.h>
 
 struct sparc64_tick_ops {
         void (*init_tick)(unsigned long);
diff --git a/include/asm-sparc64/tlb.h b/include/asm-sparc64/tlb.h
index 61c01882b562..7af1e1109c49 100644
--- a/include/asm-sparc64/tlb.h
+++ b/include/asm-sparc64/tlb.h
@@ -1,7 +1,6 @@
 #ifndef _SPARC64_TLB_H
 #define _SPARC64_TLB_H
 
-#include <linux/config.h>
 #include <linux/swap.h>
 #include <asm/pgalloc.h>
 #include <asm/tlbflush.h>
diff --git a/include/asm-sparc64/tlbflush.h b/include/asm-sparc64/tlbflush.h
index e3a7c453b500..3487328570ed 100644
--- a/include/asm-sparc64/tlbflush.h
+++ b/include/asm-sparc64/tlbflush.h
@@ -1,7 +1,6 @@
 #ifndef _SPARC64_TLBFLUSH_H
 #define _SPARC64_TLBFLUSH_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <asm/mmu_context.h>
 
diff --git a/include/asm-sparc64/ttable.h b/include/asm-sparc64/ttable.h
index 2d5e3c464df5..f2352606a79f 100644
--- a/include/asm-sparc64/ttable.h
+++ b/include/asm-sparc64/ttable.h
@@ -2,7 +2,6 @@
 #ifndef _SPARC64_TTABLE_H
 #define _SPARC64_TTABLE_H
 
-#include <linux/config.h>
 #include <asm/utrap.h>
 
 #ifdef __ASSEMBLY__
diff --git a/include/asm-sparc64/unistd.h b/include/asm-sparc64/unistd.h
index 998ef4ab0e06..badc73fdcb97 100644
--- a/include/asm-sparc64/unistd.h
+++ b/include/asm-sparc64/unistd.h
@@ -321,6 +321,7 @@
 #define __NR_set_robust_list    300
 #define __NR_get_robust_list    301
 
+#ifdef __KERNEL__
 /* WARNING: You MAY NOT add syscall numbers larger than 301, since
  *          all of the syscall tables in the Sparc kernel are
  *          sized to have 301 entries (starting at zero).  Therefore
@@ -487,7 +488,6 @@ asmlinkage long sys_rt_sigaction(int sig,
 
 #endif /* __KERNEL_SYSCALLS__ */
 
-#ifdef __KERNEL__
 /* sysconf options, for SunOS compatibility */
 #define   _SC_ARG_MAX             1
 #define   _SC_CHILD_MAX           2
@@ -521,7 +521,6 @@ asmlinkage long sys_rt_sigaction(int sig,
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
 #define __ARCH_WANT_COMPAT_SYS_RT_SIGSUSPEND
-#endif
 
 /*
  * "Conditional" syscalls
@@ -531,4 +530,5 @@ asmlinkage long sys_rt_sigaction(int sig,
  */
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 
+#endif /* __KERNEL__ */
 #endif /* _SPARC64_UNISTD_H */
diff --git a/include/asm-um/a.out.h b/include/asm-um/a.out.h
index 7c26265e1d7a..50cee7b296f4 100644
--- a/include/asm-um/a.out.h
+++ b/include/asm-um/a.out.h
@@ -1,7 +1,6 @@
 #ifndef __UM_A_OUT_H
 #define __UM_A_OUT_H
 
-#include "linux/config.h"
 #include "asm/arch/a.out.h"
 #include "choose-mode.h"
 
diff --git a/include/asm-um/cache.h b/include/asm-um/cache.h
index 3d0587075521..19e1bdd67416 100644
--- a/include/asm-um/cache.h
+++ b/include/asm-um/cache.h
@@ -1,7 +1,6 @@
 #ifndef __UM_CACHE_H
 #define __UM_CACHE_H
 
-#include <linux/config.h>
 
 #if defined(CONFIG_UML_X86) && !defined(CONFIG_64BIT)
 # define L1_CACHE_SHIFT         (CONFIG_X86_L1_CACHE_SHIFT)
diff --git a/include/asm-um/elf-ppc.h b/include/asm-um/elf-ppc.h
index 2998cf925042..99711134e477 100644
--- a/include/asm-um/elf-ppc.h
+++ b/include/asm-um/elf-ppc.h
@@ -1,7 +1,6 @@
 #ifndef __UM_ELF_PPC_H
 #define __UM_ELF_PPC_H
 
-#include "linux/config.h"
 
 extern long elf_aux_hwcap;
 #define ELF_HWCAP (elf_aux_hwcap)
diff --git a/include/asm-um/fixmap.h b/include/asm-um/fixmap.h
index ae0ca3932d50..d352a35cfafb 100644
--- a/include/asm-um/fixmap.h
+++ b/include/asm-um/fixmap.h
@@ -1,7 +1,6 @@
 #ifndef __UM_FIXMAP_H
 #define __UM_FIXMAP_H
 
-#include <linux/config.h>
 #include <asm/kmap_types.h>
 #include <asm/archparam.h>
 #include <asm/elf.h>
diff --git a/include/asm-um/hardirq.h b/include/asm-um/hardirq.h
index 1224b2690a23..313ebb8a2566 100644
--- a/include/asm-um/hardirq.h
+++ b/include/asm-um/hardirq.h
@@ -3,7 +3,6 @@
 #ifndef __ASM_UM_HARDIRQ_H
 #define __ASM_UM_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/irq.h>
 
diff --git a/include/asm-um/linkage.h b/include/asm-um/linkage.h
index e3d62dcbd356..78b862472b36 100644
--- a/include/asm-um/linkage.h
+++ b/include/asm-um/linkage.h
@@ -3,7 +3,6 @@
 
 #include "asm/arch/linkage.h"
 
-#include <linux/config.h>
 
 /* <linux/linkage.h> will pick sane defaults */
 #ifdef CONFIG_GPROF
diff --git a/include/asm-um/mmu_context.h b/include/asm-um/mmu_context.h
index 9a0e48eb542e..f709c784bf12 100644
--- a/include/asm-um/mmu_context.h
+++ b/include/asm-um/mmu_context.h
@@ -7,7 +7,6 @@
 #define __UM_MMU_CONTEXT_H
 
 #include "linux/sched.h"
-#include "linux/config.h"
 #include "choose-mode.h"
 #include "um_mmu.h"
 
diff --git a/include/asm-um/page.h b/include/asm-um/page.h
index 41364330aff1..4296d3135aa9 100644
--- a/include/asm-um/page.h
+++ b/include/asm-um/page.h
@@ -9,7 +9,6 @@
 
 struct page;
 
-#include <linux/config.h>
 #include <asm/vm-flags.h>
 
 /* PAGE_SHIFT determines the page size */
diff --git a/include/asm-um/pgalloc.h b/include/asm-um/pgalloc.h
index ea49411236dc..34ab268ef40e 100644
--- a/include/asm-um/pgalloc.h
+++ b/include/asm-um/pgalloc.h
@@ -8,7 +8,6 @@
 #ifndef __UM_PGALLOC_H
 #define __UM_PGALLOC_H
 
-#include "linux/config.h"
 #include "linux/mm.h"
 #include "asm/fixmap.h"
 
diff --git a/include/asm-um/processor-generic.h b/include/asm-um/processor-generic.h
index da07a69ce82a..824c28896382 100644
--- a/include/asm-um/processor-generic.h
+++ b/include/asm-um/processor-generic.h
@@ -10,7 +10,6 @@ struct pt_regs;
 
 struct task_struct;
 
-#include "linux/config.h"
 #include "asm/ptrace.h"
 #include "choose-mode.h"
 #include "registers.h"
diff --git a/include/asm-um/ptrace-generic.h b/include/asm-um/ptrace-generic.h
index 503484305e67..a36f5371b36b 100644
--- a/include/asm-um/ptrace-generic.h
+++ b/include/asm-um/ptrace-generic.h
@@ -8,7 +8,6 @@
 
 #ifndef __ASSEMBLY__
 
-#include "linux/config.h"
 
 #define pt_regs pt_regs_subarch
 #define show_regs show_regs_subarch
diff --git a/include/asm-um/smp.h b/include/asm-um/smp.h
index aeda6657f366..ca552261ed1f 100644
--- a/include/asm-um/smp.h
+++ b/include/asm-um/smp.h
@@ -3,7 +3,6 @@
 
 #ifdef CONFIG_SMP
 
-#include "linux/config.h"
 #include "linux/bitops.h"
 #include "asm/current.h"
 #include "linux/cpumask.h"
diff --git a/include/asm-um/thread_info.h b/include/asm-um/thread_info.h
index f166b9837c6a..261e2f4528f6 100644
--- a/include/asm-um/thread_info.h
+++ b/include/asm-um/thread_info.h
@@ -8,7 +8,6 @@
 
 #ifndef __ASSEMBLY__
 
-#include <linux/config.h>
 #include <asm/processor.h>
 #include <asm/types.h>
 
diff --git a/include/asm-v850/atomic.h b/include/asm-v850/atomic.h
index 166df00457ea..e4e57de08f73 100644
--- a/include/asm-v850/atomic.h
+++ b/include/asm-v850/atomic.h
@@ -14,7 +14,6 @@
 #ifndef __V850_ATOMIC_H__
 #define __V850_ATOMIC_H__
 
-#include <linux/config.h>
 
 #include <asm/system.h>
 
diff --git a/include/asm-v850/bitops.h b/include/asm-v850/bitops.h
index 1f6fd5ab4177..1fa99baf4e25 100644
--- a/include/asm-v850/bitops.h
+++ b/include/asm-v850/bitops.h
@@ -14,7 +14,6 @@
 #define __V850_BITOPS_H__
 
 
-#include <linux/config.h>
 #include <linux/compiler.h>     /* unlikely  */
 #include <asm/byteorder.h>      /* swab32 */
 #include <asm/system.h>         /* interrupt enable/disable */
diff --git a/include/asm-v850/dma-mapping.h b/include/asm-v850/dma-mapping.h
index c63fb50ec9ef..1cc42c603a1b 100644
--- a/include/asm-v850/dma-mapping.h
+++ b/include/asm-v850/dma-mapping.h
@@ -1,7 +1,6 @@
 #ifndef __V850_DMA_MAPPING_H__
 #define __V850_DMA_MAPPING_H__
 
-#include <linux/config.h>
 
 #ifdef CONFIG_PCI
 #include <asm-generic/dma-mapping.h>
diff --git a/include/asm-v850/hardirq.h b/include/asm-v850/hardirq.h
index d98488cd5af1..04e20127c5af 100644
--- a/include/asm-v850/hardirq.h
+++ b/include/asm-v850/hardirq.h
@@ -1,7 +1,6 @@
 #ifndef __V850_HARDIRQ_H__
 #define __V850_HARDIRQ_H__
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/cache.h>
 
diff --git a/include/asm-v850/machdep.h b/include/asm-v850/machdep.h
index 98d8bf63970e..f1e3b8b91508 100644
--- a/include/asm-v850/machdep.h
+++ b/include/asm-v850/machdep.h
@@ -14,7 +14,6 @@
 #ifndef __V850_MACHDEP_H__
 #define __V850_MACHDEP_H__
 
-#include <linux/config.h>
 
 /* chips */
 #ifdef CONFIG_V850E_MA1
diff --git a/include/asm-v850/pgtable.h b/include/asm-v850/pgtable.h
index 3cf8775ce85f..1ea2a900f0f8 100644
--- a/include/asm-v850/pgtable.h
+++ b/include/asm-v850/pgtable.h
@@ -3,7 +3,6 @@
 
 #include <asm-generic/4level-fixup.h>
 
-#include <linux/config.h>
 #include <asm/page.h>
 
 
diff --git a/include/asm-v850/processor.h b/include/asm-v850/processor.h
index 2d31308935a0..6965b66ccaed 100644
--- a/include/asm-v850/processor.h
+++ b/include/asm-v850/processor.h
@@ -14,7 +14,6 @@
 #ifndef __V850_PROCESSOR_H__
 #define __V850_PROCESSOR_H__
 
-#include <linux/config.h>
 #ifndef __ASSEMBLY__ /* <linux/thread_info.h> is not asm-safe.  */
 #include <linux/thread_info.h>
 #endif
diff --git a/include/asm-v850/serial.h b/include/asm-v850/serial.h
index 8c2a609ba2b0..36d8f4cbbf39 100644
--- a/include/asm-v850/serial.h
+++ b/include/asm-v850/serial.h
@@ -6,7 +6,6 @@
  * Copyright (C) 1999 by Ralf Baechle
  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
  */ 
-#include <linux/config.h>
 
 #ifdef CONFIG_RTE_CB_ME2
 
diff --git a/include/asm-v850/unistd.h b/include/asm-v850/unistd.h
index 82460a7bb233..bcb44bfe577a 100644
--- a/include/asm-v850/unistd.h
+++ b/include/asm-v850/unistd.h
@@ -14,8 +14,6 @@
 #ifndef __V850_UNISTD_H__
 #define __V850_UNISTD_H__
 
-#include <asm/clinkage.h>
-
 #define __NR_restart_syscall      0
 #define __NR_exit                 1
 #define __NR_fork                 2
@@ -237,10 +235,9 @@
    except the syscall number (r12).  */
 #define SYSCALL_SHORT_CLOBBERS  SYSCALL_CLOBBERS, "r13", "r14"
 
+#ifdef __KERNEL__
 
-/* User programs sometimes end up including this header file
-   (indirectly, via uClibc header files), so I'm a bit nervous just
-   including <linux/compiler.h>.  */
+#include <asm/clinkage.h>
 
 #define __syscall_return(type, res)                                           \
   do {                                                                        \
@@ -368,7 +365,6 @@ type name (atype a, btype b, ctype c, dtype d, etype e, ftype f)	      \
 }
                 
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_STAT64
@@ -389,7 +385,6 @@ type name (atype a, btype b, ctype c, dtype d, etype e, ftype f)	      \
 #define __ARCH_WANT_SYS_SIGPENDING
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
-#endif
 
 #ifdef __KERNEL_SYSCALLS__
 
@@ -440,7 +435,7 @@ asmlinkage long sys_rt_sigaction(int sig,
                                 struct sigaction __user *oact,
                                 size_t sigsetsize);
 
-#endif
+#endif /* __KERNEL_SYSCALLS__ */
 
 /*
  * "Conditional" syscalls
@@ -455,4 +450,5 @@ asmlinkage long sys_rt_sigaction(int sig,
   void name (void) __attribute__ ((weak, alias ("sys_ni_syscall")));
 #endif
 
+#endif /* __KERNEL__ */
 #endif /* __V850_UNISTD_H__ */
diff --git a/include/asm-v850/v850e_uart.h b/include/asm-v850/v850e_uart.h
index 5930d5990b19..5182fb4cc989 100644
--- a/include/asm-v850/v850e_uart.h
+++ b/include/asm-v850/v850e_uart.h
@@ -19,7 +19,6 @@
 #ifndef __V850_V850E_UART_H__
 #define __V850_V850E_UART_H__
 
-#include <linux/config.h>
 #include <linux/termios.h>
 
 #include <asm/v850e_utils.h>
diff --git a/include/asm-x86_64/apic.h b/include/asm-x86_64/apic.h
index bdbd8935612a..a731be2204d2 100644
--- a/include/asm-x86_64/apic.h
+++ b/include/asm-x86_64/apic.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_APIC_H
 #define __ASM_APIC_H
 
-#include <linux/config.h>
 #include <linux/pm.h>
 #include <asm/fixmap.h>
 #include <asm/apicdef.h>
diff --git a/include/asm-x86_64/atomic.h b/include/asm-x86_64/atomic.h
index cecbf7baa6aa..bd3fa67ed835 100644
--- a/include/asm-x86_64/atomic.h
+++ b/include/asm-x86_64/atomic.h
@@ -1,7 +1,6 @@
 #ifndef __ARCH_X86_64_ATOMIC__
 #define __ARCH_X86_64_ATOMIC__
 
-#include <linux/config.h>
 #include <asm/types.h>
 
 /* atomic_t should be 32 bit signed type */
diff --git a/include/asm-x86_64/bitops.h b/include/asm-x86_64/bitops.h
index 79212128d0f7..e9bf933d25d0 100644
--- a/include/asm-x86_64/bitops.h
+++ b/include/asm-x86_64/bitops.h
@@ -5,7 +5,6 @@
  * Copyright 1992, Linus Torvalds.
  */
 
-#include <linux/config.h>
 
 #ifdef CONFIG_SMP
 #define LOCK_PREFIX "lock ; "
diff --git a/include/asm-x86_64/bugs.h b/include/asm-x86_64/bugs.h
index 59bc68925d0f..d86c5dd689fa 100644
--- a/include/asm-x86_64/bugs.h
+++ b/include/asm-x86_64/bugs.h
@@ -10,7 +10,6 @@
  *      void check_bugs(void);
  */
 
-#include <linux/config.h>
 #include <asm/processor.h>
 #include <asm/i387.h>
 #include <asm/msr.h>
diff --git a/include/asm-x86_64/cache.h b/include/asm-x86_64/cache.h
index f8dff1c67538..ed8a9d25272d 100644
--- a/include/asm-x86_64/cache.h
+++ b/include/asm-x86_64/cache.h
@@ -4,7 +4,6 @@
 #ifndef __ARCH_X8664_CACHE_H
 #define __ARCH_X8664_CACHE_H
 
-#include <linux/config.h>
 
 /* L1 cache line size */
 #define L1_CACHE_SHIFT  (CONFIG_X86_L1_CACHE_SHIFT)
diff --git a/include/asm-x86_64/calling.h b/include/asm-x86_64/calling.h
index fc2c5a6c262a..6f4f63af96e1 100644
--- a/include/asm-x86_64/calling.h
+++ b/include/asm-x86_64/calling.h
@@ -2,7 +2,6 @@
  * Some macros to handle stack frames in assembly.
  */ 
 
-#include <linux/config.h>
 
 #define R15 0
 #define R14 8
diff --git a/include/asm-x86_64/dma-mapping.h b/include/asm-x86_64/dma-mapping.h
index 49a81a66516e..498f66df36b9 100644
--- a/include/asm-x86_64/dma-mapping.h
+++ b/include/asm-x86_64/dma-mapping.h
@@ -6,7 +6,6 @@
  * documentation.
  */
 
-#include <linux/config.h>
 
 #include <asm/scatterlist.h>
 #include <asm/io.h>
diff --git a/include/asm-x86_64/dma.h b/include/asm-x86_64/dma.h
index 6f2a817b6a7c..c556208d3dd7 100644
--- a/include/asm-x86_64/dma.h
+++ b/include/asm-x86_64/dma.h
@@ -8,7 +8,6 @@
 #ifndef _ASM_DMA_H
 #define _ASM_DMA_H
 
-#include <linux/config.h>
 #include <linux/spinlock.h>     /* And spinlocks */
 #include <asm/io.h>             /* need byte IO */
 #include <linux/delay.h>
diff --git a/include/asm-x86_64/dwarf2.h b/include/asm-x86_64/dwarf2.h
index 07654bd155bf..0744db777676 100644
--- a/include/asm-x86_64/dwarf2.h
+++ b/include/asm-x86_64/dwarf2.h
@@ -1,7 +1,6 @@
 #ifndef _DWARF2_H
 #define _DWARF2_H 1
 
-#include <linux/config.h>
 
 #ifndef __ASSEMBLY__
 #warning "asm/dwarf2.h should be only included in pure assembly files"
diff --git a/include/asm-x86_64/fixmap.h b/include/asm-x86_64/fixmap.h
index 7b286bd21d1d..0b4ffbd1a125 100644
--- a/include/asm-x86_64/fixmap.h
+++ b/include/asm-x86_64/fixmap.h
@@ -11,7 +11,6 @@
 #ifndef _ASM_FIXMAP_H
 #define _ASM_FIXMAP_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <asm/apicdef.h>
 #include <asm/page.h>
diff --git a/include/asm-x86_64/hardirq.h b/include/asm-x86_64/hardirq.h
index 8689951e3503..64a65ce2f41f 100644
--- a/include/asm-x86_64/hardirq.h
+++ b/include/asm-x86_64/hardirq.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_HARDIRQ_H
 #define __ASM_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/irq.h>
 #include <asm/pda.h>
diff --git a/include/asm-x86_64/hw_irq.h b/include/asm-x86_64/hw_irq.h
index 0df1715dee71..3de96fd86a70 100644
--- a/include/asm-x86_64/hw_irq.h
+++ b/include/asm-x86_64/hw_irq.h
@@ -17,7 +17,6 @@
  */
 
 #ifndef __ASSEMBLY__
-#include <linux/config.h>
 #include <asm/atomic.h>
 #include <asm/irq.h>
 #include <linux/profile.h>
diff --git a/include/asm-x86_64/ia32.h b/include/asm-x86_64/ia32.h
index e6b7f2234e43..0190b7c4e319 100644
--- a/include/asm-x86_64/ia32.h
+++ b/include/asm-x86_64/ia32.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_X86_64_IA32_H
 #define _ASM_X86_64_IA32_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_IA32_EMULATION
 
diff --git a/include/asm-x86_64/io.h b/include/asm-x86_64/io.h
index a05da8a50bfd..70e91fe76344 100644
--- a/include/asm-x86_64/io.h
+++ b/include/asm-x86_64/io.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_IO_H
 #define _ASM_IO_H
 
-#include <linux/config.h>
 
 /*
  * This file contains the definitions for the x86 IO instructions
diff --git a/include/asm-x86_64/io_apic.h b/include/asm-x86_64/io_apic.h
index 52484e82c641..fb7a0909a174 100644
--- a/include/asm-x86_64/io_apic.h
+++ b/include/asm-x86_64/io_apic.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_IO_APIC_H
 #define __ASM_IO_APIC_H
 
-#include <linux/config.h>
 #include <asm/types.h>
 #include <asm/mpspec.h>
 
diff --git a/include/asm-x86_64/mmu_context.h b/include/asm-x86_64/mmu_context.h
index 19f0c83d0792..af03b9f852d6 100644
--- a/include/asm-x86_64/mmu_context.h
+++ b/include/asm-x86_64/mmu_context.h
@@ -1,7 +1,6 @@
 #ifndef __X86_64_MMU_CONTEXT_H
 #define __X86_64_MMU_CONTEXT_H
 
-#include <linux/config.h>
 #include <asm/desc.h>
 #include <asm/atomic.h>
 #include <asm/pgalloc.h>
diff --git a/include/asm-x86_64/mmzone.h b/include/asm-x86_64/mmzone.h
index 6944e7122df5..70bb9969766e 100644
--- a/include/asm-x86_64/mmzone.h
+++ b/include/asm-x86_64/mmzone.h
@@ -4,7 +4,6 @@
 #ifndef _ASM_X86_64_MMZONE_H
 #define _ASM_X86_64_MMZONE_H 1
 
-#include <linux/config.h>
 
 #ifdef CONFIG_NUMA
 
diff --git a/include/asm-x86_64/mtrr.h b/include/asm-x86_64/mtrr.h
index 66ac1c0f27e1..d6135b2549bf 100644
--- a/include/asm-x86_64/mtrr.h
+++ b/include/asm-x86_64/mtrr.h
@@ -23,9 +23,7 @@
 #ifndef _LINUX_MTRR_H
 #define _LINUX_MTRR_H
 
-#include <linux/config.h>
 #include <linux/ioctl.h>
-#include <linux/compat.h>
 
 #define MTRR_IOCTL_BASE 'M'
 
@@ -102,11 +100,10 @@ static __inline__ int mtrr_del_page (int reg, unsigned long base,
     return -ENODEV;
 }
 
-#  endif
-
-#endif
+#endif /* CONFIG_MTRR */
 
 #ifdef CONFIG_COMPAT
+#include <linux/compat.h>
 
 struct mtrr_sentry32
 {
@@ -138,4 +135,6 @@ struct mtrr_gentry32
 
 #endif /* CONFIG_COMPAT */
 
+#endif /* __KERNEL__ */
+
 #endif  /*  _LINUX_MTRR_H  */
diff --git a/include/asm-x86_64/page.h b/include/asm-x86_64/page.h
index 408185bac351..f7bf875aae40 100644
--- a/include/asm-x86_64/page.h
+++ b/include/asm-x86_64/page.h
@@ -1,7 +1,6 @@
 #ifndef _X86_64_PAGE_H
 #define _X86_64_PAGE_H
 
-#include <linux/config.h>
 
 /* PAGE_SHIFT determines the page size */
 #define PAGE_SHIFT      12
@@ -136,9 +135,9 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 
 #define __HAVE_ARCH_GATE_AREA 1 
 
-#endif /* __KERNEL__ */
-
 #include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
+#endif /* __KERNEL__ */
+
 #endif /* _X86_64_PAGE_H */
diff --git a/include/asm-x86_64/param.h b/include/asm-x86_64/param.h
index 5956b23b57c2..a728786c3c7c 100644
--- a/include/asm-x86_64/param.h
+++ b/include/asm-x86_64/param.h
@@ -2,7 +2,6 @@
 #define _ASMx86_64_PARAM_H
 
 #ifdef __KERNEL__
-# include <linux/config.h>
 # define HZ            CONFIG_HZ        /* Internal kernel timer frequency */
 # define USER_HZ       100              /* .. some user interfaces are in "ticks */
 #define CLOCKS_PER_SEC        (USER_HZ)       /* like times() */
diff --git a/include/asm-x86_64/pci.h b/include/asm-x86_64/pci.h
index 8a05af264d18..2db0620d5449 100644
--- a/include/asm-x86_64/pci.h
+++ b/include/asm-x86_64/pci.h
@@ -1,7 +1,6 @@
 #ifndef __x8664_PCI_H
 #define __x8664_PCI_H
 
-#include <linux/config.h>
 #include <asm/io.h>
 
 #ifdef __KERNEL__
diff --git a/include/asm-x86_64/processor.h b/include/asm-x86_64/processor.h
index 37a3ec433ee5..3061a38a3b1d 100644
--- a/include/asm-x86_64/processor.h
+++ b/include/asm-x86_64/processor.h
@@ -12,7 +12,6 @@
 #include <asm/types.h>
 #include <asm/sigcontext.h>
 #include <asm/cpufeature.h>
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <asm/msr.h>
 #include <asm/current.h>
diff --git a/include/asm-x86_64/serial.h b/include/asm-x86_64/serial.h
index dc752eafa681..b0496e0d72a6 100644
--- a/include/asm-x86_64/serial.h
+++ b/include/asm-x86_64/serial.h
@@ -2,7 +2,6 @@
  * include/asm-x86_64/serial.h
  */
 
-#include <linux/config.h>
 
 /*
  * This assumes you have a 1.8432 MHz clock for your UART.
diff --git a/include/asm-x86_64/smp.h b/include/asm-x86_64/smp.h
index a4fdaeb5c397..7686b9b25aef 100644
--- a/include/asm-x86_64/smp.h
+++ b/include/asm-x86_64/smp.h
@@ -5,7 +5,6 @@
  * We need the APIC definitions automatically as part of 'smp.h'
  */
 #ifndef __ASSEMBLY__
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/cpumask.h>
 #include <linux/bitops.h>
diff --git a/include/asm-x86_64/spinlock.h b/include/asm-x86_64/spinlock.h
index fe484a699cc3..5d8a5e3589ff 100644
--- a/include/asm-x86_64/spinlock.h
+++ b/include/asm-x86_64/spinlock.h
@@ -4,7 +4,6 @@
 #include <asm/atomic.h>
 #include <asm/rwlock.h>
 #include <asm/page.h>
-#include <linux/config.h>
 
 /*
  * Your basic SMP spinlocks, allowing only a single CPU anywhere
diff --git a/include/asm-x86_64/swiotlb.h b/include/asm-x86_64/swiotlb.h
index 60757efd1353..5f9a01805821 100644
--- a/include/asm-x86_64/swiotlb.h
+++ b/include/asm-x86_64/swiotlb.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_SWIOTLB_H
 #define _ASM_SWTIOLB_H 1
 
-#include <linux/config.h>
 
 #include <asm/dma-mapping.h>
 
diff --git a/include/asm-x86_64/system.h b/include/asm-x86_64/system.h
index 397598980228..f48e0dad8b3d 100644
--- a/include/asm-x86_64/system.h
+++ b/include/asm-x86_64/system.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_SYSTEM_H
 #define __ASM_SYSTEM_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <asm/segment.h>
 
diff --git a/include/asm-x86_64/tlbflush.h b/include/asm-x86_64/tlbflush.h
index 4a9c20ea9b10..d16d5b60f419 100644
--- a/include/asm-x86_64/tlbflush.h
+++ b/include/asm-x86_64/tlbflush.h
@@ -1,7 +1,6 @@
 #ifndef _X8664_TLBFLUSH_H
 #define _X8664_TLBFLUSH_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 #include <asm/processor.h>
 
diff --git a/include/asm-x86_64/topology.h b/include/asm-x86_64/topology.h
index 9db54e9d17bb..80c4e44d011c 100644
--- a/include/asm-x86_64/topology.h
+++ b/include/asm-x86_64/topology.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_X86_64_TOPOLOGY_H
 #define _ASM_X86_64_TOPOLOGY_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_NUMA
 
diff --git a/include/asm-x86_64/uaccess.h b/include/asm-x86_64/uaccess.h
index bddffcb591b8..1e1fa003daa3 100644
--- a/include/asm-x86_64/uaccess.h
+++ b/include/asm-x86_64/uaccess.h
@@ -4,7 +4,6 @@
 /*
  * User space memory access functions
  */
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
diff --git a/include/asm-x86_64/unistd.h b/include/asm-x86_64/unistd.h
index feb77cb8c044..0aff22bdbb21 100644
--- a/include/asm-x86_64/unistd.h
+++ b/include/asm-x86_64/unistd.h
@@ -618,6 +618,8 @@ __SYSCALL(__NR_sync_file_range, sys_sync_file_range)
 #define __NR_vmsplice           278
 __SYSCALL(__NR_vmsplice, sys_vmsplice)
 
+#ifdef __KERNEL__
+
 #define __NR_syscall_max __NR_vmsplice
 
 #ifndef __NO_STUBS
@@ -635,7 +637,6 @@ do { \
         return (type) (res); \
 } while (0)
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_OLD_STAT
 #define __ARCH_WANT_SYS_ALARM
@@ -657,7 +658,6 @@ do { \
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_TIME
 #define __ARCH_WANT_COMPAT_SYS_TIME
-#endif
 
 #ifndef __KERNEL_SYSCALLS__
 
@@ -821,7 +821,7 @@ asmlinkage long sys_pipe(int *fildes);
 
 #endif /* __KERNEL_SYSCALLS__ */
 
-#if !defined(__ASSEMBLY__) && defined(__KERNEL__)
+#ifndef __ASSEMBLY__
 
 #include <linux/linkage.h>
 #include <linux/compiler.h>
@@ -848,4 +848,5 @@ asmlinkage long sys_rt_sigaction(int sig,
  */
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 
+#endif /* __KERNEL__ */
 #endif
diff --git a/include/asm-xtensa/atomic.h b/include/asm-xtensa/atomic.h
index fe105a123924..5c2672021068 100644
--- a/include/asm-xtensa/atomic.h
+++ b/include/asm-xtensa/atomic.h
@@ -13,7 +13,6 @@
 #ifndef _XTENSA_ATOMIC_H
 #define _XTENSA_ATOMIC_H
 
-#include <linux/config.h>
 #include <linux/stringify.h>
 
 typedef struct { volatile int counter; } atomic_t;
diff --git a/include/asm-xtensa/checksum.h b/include/asm-xtensa/checksum.h
index 81a797ae3abe..bdc00ae9be48 100644
--- a/include/asm-xtensa/checksum.h
+++ b/include/asm-xtensa/checksum.h
@@ -11,7 +11,6 @@
 #ifndef _XTENSA_CHECKSUM_H
 #define _XTENSA_CHECKSUM_H
 
-#include <linux/config.h>
 #include <linux/in6.h>
 #include <xtensa/config/core.h>
 
diff --git a/include/asm-xtensa/delay.h b/include/asm-xtensa/delay.h
index 1bc601ec3621..e1d8c9e010c1 100644
--- a/include/asm-xtensa/delay.h
+++ b/include/asm-xtensa/delay.h
@@ -12,7 +12,6 @@
 #ifndef _XTENSA_DELAY_H
 #define _XTENSA_DELAY_H
 
-#include <linux/config.h>
 #include <asm/processor.h>
 #include <asm/param.h>
 
diff --git a/include/asm-xtensa/dma.h b/include/asm-xtensa/dma.h
index 1c22b0234586..db2633f67789 100644
--- a/include/asm-xtensa/dma.h
+++ b/include/asm-xtensa/dma.h
@@ -11,7 +11,6 @@
 #ifndef _XTENSA_DMA_H
 #define _XTENSA_DMA_H
 
-#include <linux/config.h>
 #include <asm/io.h>             /* need byte IO */
 #include <xtensa/config/core.h>
 
diff --git a/include/asm-xtensa/hardirq.h b/include/asm-xtensa/hardirq.h
index aa9c1adf68d7..87cb19d1b10c 100644
--- a/include/asm-xtensa/hardirq.h
+++ b/include/asm-xtensa/hardirq.h
@@ -11,7 +11,6 @@
 #ifndef _XTENSA_HARDIRQ_H
 #define _XTENSA_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/cache.h>
 #include <asm/irq.h>
 
diff --git a/include/asm-xtensa/ide.h b/include/asm-xtensa/ide.h
index b523cd4a486e..6b912742a42d 100644
--- a/include/asm-xtensa/ide.h
+++ b/include/asm-xtensa/ide.h
@@ -14,7 +14,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #ifndef MAX_HWIFS
 # define MAX_HWIFS      1
diff --git a/include/asm-xtensa/io.h b/include/asm-xtensa/io.h
index c5c13985bbe1..556e5eed34f5 100644
--- a/include/asm-xtensa/io.h
+++ b/include/asm-xtensa/io.h
@@ -12,7 +12,6 @@
 #define _XTENSA_IO_H
 
 #ifdef __KERNEL__
-#include <linux/config.h>
 #include <asm/byteorder.h>
 
 #include <linux/types.h>
diff --git a/include/asm-xtensa/irq.h b/include/asm-xtensa/irq.h
index d984e955938f..049fde7e752d 100644
--- a/include/asm-xtensa/irq.h
+++ b/include/asm-xtensa/irq.h
@@ -11,7 +11,6 @@
 #ifndef _XTENSA_IRQ_H
 #define _XTENSA_IRQ_H
 
-#include <linux/config.h>
 #include <asm/platform/hardware.h>
 
 #include <xtensa/config/core.h>
diff --git a/include/asm-xtensa/mmu_context.h b/include/asm-xtensa/mmu_context.h
index 364a7b057bfa..af683a74a4ec 100644
--- a/include/asm-xtensa/mmu_context.h
+++ b/include/asm-xtensa/mmu_context.h
@@ -13,7 +13,6 @@
 #ifndef _XTENSA_MMU_CONTEXT_H
 #define _XTENSA_MMU_CONTEXT_H
 
-#include <linux/config.h>
 #include <linux/stringify.h>
 
 #include <asm/pgtable.h>
diff --git a/include/asm-xtensa/page.h b/include/asm-xtensa/page.h
index 992bac5c1258..40f4c6c3f580 100644
--- a/include/asm-xtensa/page.h
+++ b/include/asm-xtensa/page.h
@@ -14,7 +14,6 @@
 #ifdef __KERNEL__
 
 #include <asm/processor.h>
-#include <linux/config.h>
 
 /*
  * PAGE_SHIFT determines the page size
diff --git a/include/asm-xtensa/pgalloc.h b/include/asm-xtensa/pgalloc.h
index 734a8d060395..d56ddf2055e1 100644
--- a/include/asm-xtensa/pgalloc.h
+++ b/include/asm-xtensa/pgalloc.h
@@ -13,7 +13,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/threads.h>
 #include <linux/highmem.h>
 #include <asm/processor.h>
diff --git a/include/asm-xtensa/platform.h b/include/asm-xtensa/platform.h
index 36163894bc20..48135a9718b0 100644
--- a/include/asm-xtensa/platform.h
+++ b/include/asm-xtensa/platform.h
@@ -13,7 +13,6 @@
 #ifndef _XTENSA_PLATFORM_H
 #define _XTENSA_PLATFORM_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/pci.h>
 
diff --git a/include/asm-xtensa/system.h b/include/asm-xtensa/system.h
index b29f7ae6a08a..f986170bd2a1 100644
--- a/include/asm-xtensa/system.h
+++ b/include/asm-xtensa/system.h
@@ -11,7 +11,6 @@
 #ifndef _XTENSA_SYSTEM_H
 #define _XTENSA_SYSTEM_H
 
-#include <linux/config.h>
 #include <linux/stringify.h>
 
 #include <asm/processor.h>
diff --git a/include/asm-xtensa/unistd.h b/include/asm-xtensa/unistd.h
index 6b39d6609d9c..5e1b99dc4ab3 100644
--- a/include/asm-xtensa/unistd.h
+++ b/include/asm-xtensa/unistd.h
@@ -11,8 +11,6 @@
 #ifndef _XTENSA_UNISTD_H
 #define _XTENSA_UNISTD_H
 
-#include <linux/linkage.h>
-
 #define __NR_spill                0
 #define __NR_exit                 1
 #define __NR_read                 3
@@ -221,21 +219,9 @@
 #define SYSXTENSA_COUNT            5    /* count of syscall0 functions*/
 
 #ifdef __KERNEL__
-#define __syscall_return(type, res) return ((type)(res))
-#else
-#define __syscall_return(type, res) \
-do { \
-        if ((unsigned long)(res) >= (unsigned long)(-125)) { \
-        /* Avoid using "res" which is declared to be in register r2; \
-         * errno might expand to a function call and clobber it.  */ \
-                int __err = -(res); \
-                errno = __err; \
-                res = -1; \
-        } \
-        return (type) (res); \
-} while (0)
-#endif
+#include <linux/linkage.h>
 
+#define __syscall_return(type, res) return ((type)(res))
 
 /* Tensilica's xt-xcc compiler is much more agressive at code
  * optimization than gcc.  Multiple __asm__ statements are
@@ -429,11 +415,10 @@ static __inline__ _syscall3(int,execve,const char*,file,char**,argv,char**,envp)
  */
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall");
 
-#ifdef __KERNEL__
 #define __ARCH_WANT_STAT64
 #define __ARCH_WANT_SYS_UTIME
 #define __ARCH_WANT_SYS_LLSEEK
 #define __ARCH_WANT_SYS_RT_SIGACTION
-#endif
+#endif /* __KERNEL__ */
 
 #endif  /* _XTENSA_UNISTD_H */
diff --git a/include/linux/acct.h b/include/linux/acct.h
index 9a66401073fc..3d54fbcf969e 100644
--- a/include/linux/acct.h
+++ b/include/linux/acct.h
@@ -16,7 +16,6 @@
 #define _LINUX_ACCT_H
 
 #include <linux/types.h>
-#include <linux/jiffies.h>
 
 #include <asm/param.h>
 #include <asm/byteorder.h>
@@ -116,7 +115,6 @@ struct acct_v3
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #ifdef CONFIG_BSD_PROCESS_ACCT
 struct vfsmount;
@@ -165,6 +163,7 @@ typedef struct acct acct_t;
 #endif  /* __KERNEL */
 
 #ifdef __KERNEL__
+#include <linux/jiffies.h>
 /*
  * Yet another set of HZ to *HZ helper functions.
  * See <linux/jiffies.h> for the original.
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index d3bc25e6d27d..1cf0b91d05bd 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -25,7 +25,6 @@
 #ifndef _LINUX_ACPI_H
 #define _LINUX_ACPI_H
 
-#include <linux/config.h>
 
 #ifdef  CONFIG_ACPI
 
diff --git a/include/linux/affs_hardblocks.h b/include/linux/affs_hardblocks.h
index 3fb869939d82..f1b948c1f592 100644
--- a/include/linux/affs_hardblocks.h
+++ b/include/linux/affs_hardblocks.h
@@ -1,45 +1,47 @@
 #ifndef AFFS_HARDBLOCKS_H
 #define AFFS_HARDBLOCKS_H
 
+#include <linux/types.h>
+
 /* Just the needed definitions for the RDB of an Amiga HD. */
 
 struct RigidDiskBlock {
-        u32     rdb_ID;
+        __u32   rdb_ID;
         __be32  rdb_SummedLongs;
-        s32     rdb_ChkSum;
-        u32     rdb_HostID;
+        __s32   rdb_ChkSum;
+        __u32   rdb_HostID;
         __be32  rdb_BlockBytes;
-        u32     rdb_Flags;
-        u32     rdb_BadBlockList;
+        __u32   rdb_Flags;
+        __u32   rdb_BadBlockList;
         __be32  rdb_PartitionList;
-        u32     rdb_FileSysHeaderList;
-        u32     rdb_DriveInit;
-        u32     rdb_Reserved1[6];
-        u32     rdb_Cylinders;
-        u32     rdb_Sectors;
-        u32     rdb_Heads;
-        u32     rdb_Interleave;
-        u32     rdb_Park;
-        u32     rdb_Reserved2[3];
-        u32     rdb_WritePreComp;
-        u32     rdb_ReducedWrite;
-        u32     rdb_StepRate;
-        u32     rdb_Reserved3[5];
-        u32     rdb_RDBBlocksLo;
-        u32     rdb_RDBBlocksHi;
-        u32     rdb_LoCylinder;
-        u32     rdb_HiCylinder;
-        u32     rdb_CylBlocks;
-        u32     rdb_AutoParkSeconds;
-        u32     rdb_HighRDSKBlock;
-        u32     rdb_Reserved4;
+        __u32   rdb_FileSysHeaderList;
+        __u32   rdb_DriveInit;
+        __u32   rdb_Reserved1[6];
+        __u32   rdb_Cylinders;
+        __u32   rdb_Sectors;
+        __u32   rdb_Heads;
+        __u32   rdb_Interleave;
+        __u32   rdb_Park;
+        __u32   rdb_Reserved2[3];
+        __u32   rdb_WritePreComp;
+        __u32   rdb_ReducedWrite;
+        __u32   rdb_StepRate;
+        __u32   rdb_Reserved3[5];
+        __u32   rdb_RDBBlocksLo;
+        __u32   rdb_RDBBlocksHi;
+        __u32   rdb_LoCylinder;
+        __u32   rdb_HiCylinder;
+        __u32   rdb_CylBlocks;
+        __u32   rdb_AutoParkSeconds;
+        __u32   rdb_HighRDSKBlock;
+        __u32   rdb_Reserved4;
         char    rdb_DiskVendor[8];
         char    rdb_DiskProduct[16];
         char    rdb_DiskRevision[4];
         char    rdb_ControllerVendor[8];
         char    rdb_ControllerProduct[16];
         char    rdb_ControllerRevision[4];
-        u32     rdb_Reserved5[10];
+        __u32   rdb_Reserved5[10];
 };
 
 #define IDNAME_RIGIDDISK        0x5244534B      /* "RDSK" */
@@ -47,16 +49,16 @@ struct RigidDiskBlock {
 struct PartitionBlock {
         __be32  pb_ID;
         __be32  pb_SummedLongs;
-        s32     pb_ChkSum;
-        u32     pb_HostID;
+        __s32   pb_ChkSum;
+        __u32   pb_HostID;
         __be32  pb_Next;
-        u32     pb_Flags;
-        u32     pb_Reserved1[2];
-        u32     pb_DevFlags;
-        u8      pb_DriveName[32];
-        u32     pb_Reserved2[15];
+        __u32   pb_Flags;
+        __u32   pb_Reserved1[2];
+        __u32   pb_DevFlags;
+        __u8    pb_DriveName[32];
+        __u32   pb_Reserved2[15];
         __be32  pb_Environment[17];
-        u32     pb_EReserved[15];
+        __u32   pb_EReserved[15];
 };
 
 #define IDNAME_PARTITION        0x50415254      /* "PART" */
diff --git a/include/linux/agpgart.h b/include/linux/agpgart.h
index 6d59c8efe3be..bfb8ec791b7b 100644
--- a/include/linux/agpgart.h
+++ b/include/linux/agpgart.h
@@ -27,8 +27,6 @@
 #ifndef _AGP_H
 #define _AGP_H 1
 
-#include <linux/agp_backend.h>
-
 #define AGPIOC_BASE       'A'
 #define AGPIOC_INFO       _IOR (AGPIOC_BASE, 0, struct agp_info*)
 #define AGPIOC_ACQUIRE    _IO  (AGPIOC_BASE, 1)
@@ -112,6 +110,7 @@ typedef struct _agp_unbind {
 
 #else                           /* __KERNEL__ */
 #include <linux/mutex.h>
+#include <linux/agp_backend.h>
 
 #define AGPGART_MINOR 175
 
diff --git a/include/linux/amba/clcd.h b/include/linux/amba/clcd.h
index 9cf64b1b688b..29c0448265cf 100644
--- a/include/linux/amba/clcd.h
+++ b/include/linux/amba/clcd.h
@@ -9,7 +9,6 @@
  * License.  See the file COPYING in the main directory of this archive
  * for more details.
  */
-#include <linux/config.h>
 #include <linux/fb.h>
 
 /*
diff --git a/include/linux/atmdev.h b/include/linux/atmdev.h
index b203ea82a0a8..1eb238affb12 100644
--- a/include/linux/atmdev.h
+++ b/include/linux/atmdev.h
@@ -209,7 +209,6 @@ struct atm_cirange {
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/wait.h> /* wait_queue_head_t */
 #include <linux/time.h> /* struct timeval */
 #include <linux/net.h>
diff --git a/include/linux/audit.h b/include/linux/audit.h
index b74c148f14e3..e051ff9c5b50 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -24,8 +24,7 @@
 #ifndef _LINUX_AUDIT_H_
 #define _LINUX_AUDIT_H_
 
-#include <linux/sched.h>
-#include <linux/elf.h>
+#include <linux/elf-em.h>
 
 /* The netlink messages for the audit system is divided into blocks:
  * 1000 - 1099 are for commanding the audit system
@@ -83,7 +82,12 @@
 #define AUDIT_CONFIG_CHANGE     1305    /* Audit system configuration change */
 #define AUDIT_SOCKADDR          1306    /* sockaddr copied as syscall arg */
 #define AUDIT_CWD               1307    /* Current working directory */
+#define AUDIT_EXECVE            1309    /* execve arguments */
 #define AUDIT_IPC_SET_PERM      1311    /* IPC new permissions record type */
+#define AUDIT_MQ_OPEN           1312    /* POSIX MQ open record type */
+#define AUDIT_MQ_SENDRECV       1313    /* POSIX MQ send/receive record type */
+#define AUDIT_MQ_NOTIFY         1314    /* POSIX MQ notify record type */
+#define AUDIT_MQ_GETSETATTR     1315    /* POSIX MQ get/set attribute record type */
 
 #define AUDIT_AVC               1400    /* SE Linux avc denial or grant */
 #define AUDIT_SELINUX_ERR       1401    /* Internal SE Linux Errors */
@@ -151,6 +155,7 @@
 #define AUDIT_SE_TYPE   15      /* security label type */
 #define AUDIT_SE_SEN    16      /* security label sensitivity label */
 #define AUDIT_SE_CLR    17      /* security label clearance label */
+#define AUDIT_PPID      18
 
                                 /* These are ONLY useful when checking
                                  * at syscall exit time (AUDIT_AT_EXIT). */
@@ -159,6 +164,7 @@
 #define AUDIT_INODE     102
 #define AUDIT_EXIT      103
 #define AUDIT_SUCCESS   104     /* exit >= 0; value ignored */
+#define AUDIT_WATCH     105
 
 #define AUDIT_ARG0      200
 #define AUDIT_ARG1      (AUDIT_ARG0+1)
@@ -273,16 +279,21 @@ struct audit_rule {		/* for AUDIT_LIST, AUDIT_ADD, and AUDIT_DEL */
 };
 
 #ifdef __KERNEL__
+#include <linux/sched.h>
 
 struct audit_sig_info {
         uid_t           uid;
         pid_t           pid;
+        char            ctx[0];
 };
 
 struct audit_buffer;
 struct audit_context;
 struct inode;
 struct netlink_skb_parms;
+struct linux_binprm;
+struct mq_attr;
+struct mqstat;
 
 #define AUDITSC_INVALID 0
 #define AUDITSC_SUCCESS 1
@@ -297,15 +308,19 @@ extern void audit_syscall_entry(int arch,
                                 int major, unsigned long a0, unsigned long a1,
                                 unsigned long a2, unsigned long a3);
 extern void audit_syscall_exit(int failed, long return_code);
-extern void audit_getname(const char *name);
+extern void __audit_getname(const char *name);
 extern void audit_putname(const char *name);
-extern void __audit_inode(const char *name, const struct inode *inode, unsigned flags);
+extern void __audit_inode(const char *name, const struct inode *inode);
 extern void __audit_inode_child(const char *dname, const struct inode *inode,
                                 unsigned long pino);
-static inline void audit_inode(const char *name, const struct inode *inode,
-                               unsigned flags) {
+static inline void audit_getname(const char *name)
+{
         if (unlikely(current->audit_context))
-                __audit_inode(name, inode, flags);
+                __audit_getname(name);
+}
+static inline void audit_inode(const char *name, const struct inode *inode) {
+        if (unlikely(current->audit_context))
+                __audit_inode(name, inode);
 }
 static inline void audit_inode_child(const char *dname, 
                                      const struct inode *inode, 
@@ -320,13 +335,61 @@ extern void auditsc_get_stamp(struct audit_context *ctx,
                               struct timespec *t, unsigned int *serial);
 extern int  audit_set_loginuid(struct task_struct *task, uid_t loginuid);
 extern uid_t audit_get_loginuid(struct audit_context *ctx);
-extern int audit_ipc_obj(struct kern_ipc_perm *ipcp);
-extern int audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode, struct kern_ipc_perm *ipcp);
+extern int __audit_ipc_obj(struct kern_ipc_perm *ipcp);
+extern int __audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode);
+extern int audit_bprm(struct linux_binprm *bprm);
 extern int audit_socketcall(int nargs, unsigned long *args);
 extern int audit_sockaddr(int len, void *addr);
 extern int audit_avc_path(struct dentry *dentry, struct vfsmount *mnt);
-extern void audit_signal_info(int sig, struct task_struct *t);
 extern int audit_set_macxattr(const char *name);
+extern int __audit_mq_open(int oflag, mode_t mode, struct mq_attr __user *u_attr);
+extern int __audit_mq_timedsend(mqd_t mqdes, size_t msg_len, unsigned int msg_prio, const struct timespec __user *u_abs_timeout);
+extern int __audit_mq_timedreceive(mqd_t mqdes, size_t msg_len, unsigned int __user *u_msg_prio, const struct timespec __user *u_abs_timeout);
+extern int __audit_mq_notify(mqd_t mqdes, const struct sigevent __user *u_notification);
+extern int __audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat);
+
+static inline int audit_ipc_obj(struct kern_ipc_perm *ipcp)
+{
+        if (unlikely(current->audit_context))
+                return __audit_ipc_obj(ipcp);
+        return 0;
+}
+static inline int audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode)
+{
+        if (unlikely(current->audit_context))
+                return __audit_ipc_set_perm(qbytes, uid, gid, mode);
+        return 0;
+}
+static inline int audit_mq_open(int oflag, mode_t mode, struct mq_attr __user *u_attr)
+{
+        if (unlikely(current->audit_context))
+                return __audit_mq_open(oflag, mode, u_attr);
+        return 0;
+}
+static inline int audit_mq_timedsend(mqd_t mqdes, size_t msg_len, unsigned int msg_prio, const struct timespec __user *u_abs_timeout)
+{
+        if (unlikely(current->audit_context))
+                return __audit_mq_timedsend(mqdes, msg_len, msg_prio, u_abs_timeout);
+        return 0;
+}
+static inline int audit_mq_timedreceive(mqd_t mqdes, size_t msg_len, unsigned int __user *u_msg_prio, const struct timespec __user *u_abs_timeout)
+{
+        if (unlikely(current->audit_context))
+                return __audit_mq_timedreceive(mqdes, msg_len, u_msg_prio, u_abs_timeout);
+        return 0;
+}
+static inline int audit_mq_notify(mqd_t mqdes, const struct sigevent __user *u_notification)
+{
+        if (unlikely(current->audit_context))
+                return __audit_mq_notify(mqdes, u_notification);
+        return 0;
+}
+static inline int audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat)
+{
+        if (unlikely(current->audit_context))
+                return __audit_mq_getsetattr(mqdes, mqstat);
+        return 0;
+}
 #else
 #define audit_alloc(t) ({ 0; })
 #define audit_free(t) do { ; } while (0)
@@ -334,19 +397,24 @@ extern int audit_set_macxattr(const char *name);
 #define audit_syscall_exit(f,r) do { ; } while (0)
 #define audit_getname(n) do { ; } while (0)
 #define audit_putname(n) do { ; } while (0)
-#define __audit_inode(n,i,f) do { ; } while (0)
+#define __audit_inode(n,i) do { ; } while (0)
 #define __audit_inode_child(d,i,p) do { ; } while (0)
-#define audit_inode(n,i,f) do { ; } while (0)
+#define audit_inode(n,i) do { ; } while (0)
 #define audit_inode_child(d,i,p) do { ; } while (0)
 #define auditsc_get_stamp(c,t,s) do { BUG(); } while (0)
 #define audit_get_loginuid(c) ({ -1; })
 #define audit_ipc_obj(i) ({ 0; })
-#define audit_ipc_set_perm(q,u,g,m,i) ({ 0; })
+#define audit_ipc_set_perm(q,u,g,m) ({ 0; })
+#define audit_bprm(p) ({ 0; })
 #define audit_socketcall(n,a) ({ 0; })
 #define audit_sockaddr(len, addr) ({ 0; })
 #define audit_avc_path(dentry, mnt) ({ 0; })
-#define audit_signal_info(s,t) do { ; } while (0)
 #define audit_set_macxattr(n) do { ; } while (0)
+#define audit_mq_open(o,m,a) ({ 0; })
+#define audit_mq_timedsend(d,l,p,t) ({ 0; })
+#define audit_mq_timedreceive(d,l,p,t) ({ 0; })
+#define audit_mq_notify(d,n) ({ 0; })
+#define audit_mq_getsetattr(d,s) ({ 0; })
 #endif
 
 #ifdef CONFIG_AUDIT
@@ -364,8 +432,11 @@ extern void		    audit_log_end(struct audit_buffer *ab);
 extern void                 audit_log_hex(struct audit_buffer *ab,
                                           const unsigned char *buf,
                                           size_t len);
-extern void                 audit_log_untrustedstring(struct audit_buffer *ab,
+extern const char *         audit_log_untrustedstring(struct audit_buffer *ab,
                                                       const char *string);
+extern const char *         audit_log_n_untrustedstring(struct audit_buffer *ab,
+                                                        size_t n,
+                                                        const char *string);
 extern void                 audit_log_d_path(struct audit_buffer *ab,
                                              const char *prefix,
                                              struct dentry *dentry,
@@ -383,8 +454,8 @@ extern int  audit_receive_filter(int type, int pid, int uid, int seq,
 #define audit_log_end(b) do { ; } while (0)
 #define audit_log_hex(a,b,l) do { ; } while (0)
 #define audit_log_untrustedstring(a,s) do { ; } while (0)
+#define audit_log_n_untrustedstring(a,n,s) do { ; } while (0)
 #define audit_log_d_path(b,p,d,v) do { ; } while (0)
-#define audit_panic(m) do { ; } while (0)
 #endif
 #endif
 #endif
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 59e1259b1c40..5d327313a9f7 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_BLKDEV_H
 #define _LINUX_BLKDEV_H
 
-#include <linux/config.h>
 #include <linux/major.h>
 #include <linux/genhd.h>
 #include <linux/list.h>
diff --git a/include/linux/blkpg.h b/include/linux/blkpg.h
index be5d0f4ad24c..faf8a45af210 100644
--- a/include/linux/blkpg.h
+++ b/include/linux/blkpg.h
@@ -24,6 +24,7 @@
  *
  * For today, only the partition stuff - aeb, 990515
  */
+#include <linux/compiler.h>
 #include <linux/ioctl.h>
 
 #define BLKPG      _IO(0x12,105)
diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
index b34d3e73d5ea..eb1a867ed245 100644
--- a/include/linux/blktrace_api.h
+++ b/include/linux/blktrace_api.h
@@ -1,7 +1,6 @@
 #ifndef BLKTRACE_H
 #define BLKTRACE_H
 
-#include <linux/config.h>
 #include <linux/blkdev.h>
 #include <linux/relay.h>
 
diff --git a/include/linux/blockgroup_lock.h b/include/linux/blockgroup_lock.h
index 0137ee5dd43c..8607312983bd 100644
--- a/include/linux/blockgroup_lock.h
+++ b/include/linux/blockgroup_lock.h
@@ -6,7 +6,6 @@
  * Simple hashed spinlocking.
  */
 
-#include <linux/config.h>
 #include <linux/spinlock.h>
 #include <linux/cache.h>
 
diff --git a/include/linux/cache.h b/include/linux/cache.h
index cc4b3aafad9a..4552504c0228 100644
--- a/include/linux/cache.h
+++ b/include/linux/cache.h
@@ -2,7 +2,6 @@
 #define __LINUX_CACHE_H
 
 #include <linux/kernel.h>
-#include <linux/config.h>
 #include <asm/cache.h>
 
 #ifndef L1_CACHE_ALIGN
diff --git a/include/linux/coda.h b/include/linux/coda.h
index bbc5afcd7db6..b5cf0780c51a 100644
--- a/include/linux/coda.h
+++ b/include/linux/coda.h
@@ -59,7 +59,6 @@ Mellon the rights to redistribute these changes without encumbrance.
 #ifndef _CODA_HEADER_
 #define _CODA_HEADER_
 
-#include <linux/config.h>
 
 /* Catch new _KERNEL defn for NetBSD and DJGPP/__CYGWIN32__ */
 #if defined(__NetBSD__) || \
diff --git a/include/linux/compat.h b/include/linux/compat.h
index 6d3a654be1ae..dda1697ec753 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -4,7 +4,6 @@
  * These are the type definitions for the architecture specific
  * syscall compatibility layer.
  */
-#include <linux/config.h>
 
 #ifdef CONFIG_COMPAT
 
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index f23d3c6fc2c0..9b4f11094937 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -78,6 +78,7 @@ extern void __chk_io_ptr(void __iomem *);
 
 #endif /* __ASSEMBLY__ */
 
+#ifdef __KERNEL__
 /*
  * Allow us to mark functions as 'deprecated' and have gcc emit a nice
  * warning for each use, in hopes of speeding the functions removal.
@@ -127,6 +128,16 @@ extern void __chk_io_ptr(void __iomem *);
 # define __attribute_pure__     /* unimplemented */
 #endif
 
+#ifndef noinline
+#define noinline
+#endif
+
+#ifndef __always_inline
+#define __always_inline inline
+#endif
+
+#endif /* __KERNEL__ */
+
 /*
  * From the GCC manual:
  *
@@ -145,12 +156,4 @@ extern void __chk_io_ptr(void __iomem *);
 # define __attribute_const__    /* unimplemented */
 #endif
 
-#ifndef noinline
-#define noinline
-#endif
-
-#ifndef __always_inline
-#define __always_inline inline
-#endif
-
 #endif /* __LINUX_COMPILER_H */
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 17866d7e2b71..5aa95011f7e6 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -15,7 +15,6 @@
 #define _LINUX_CPUFREQ_H
 
 #include <linux/mutex.h>
-#include <linux/config.h>
 #include <linux/notifier.h>
 #include <linux/threads.h>
 #include <linux/device.h>
diff --git a/include/linux/cramfs_fs.h b/include/linux/cramfs_fs.h
index a8948f34b776..a41f38428c37 100644
--- a/include/linux/cramfs_fs.h
+++ b/include/linux/cramfs_fs.h
@@ -1,13 +1,7 @@
 #ifndef __CRAMFS_H
 #define __CRAMFS_H
 
-#ifndef __KERNEL__
-
-typedef unsigned char u8;
-typedef unsigned short u16;
-typedef unsigned int u32;
-
-#endif
+#include <linux/types.h>
 
 #define CRAMFS_MAGIC            0x28cd3d45      /* some random number */
 #define CRAMFS_SIGNATURE        "Compressed ROMFS"
@@ -33,9 +27,9 @@ typedef unsigned int u32;
  * Reasonably terse representation of the inode data.
  */
 struct cramfs_inode {
-        u32 mode:CRAMFS_MODE_WIDTH, uid:CRAMFS_UID_WIDTH;
+        __u32 mode:CRAMFS_MODE_WIDTH, uid:CRAMFS_UID_WIDTH;
         /* SIZE for device files is i_rdev */
-        u32 size:CRAMFS_SIZE_WIDTH, gid:CRAMFS_GID_WIDTH;
+        __u32 size:CRAMFS_SIZE_WIDTH, gid:CRAMFS_GID_WIDTH;
         /* NAMELEN is the length of the file name, divided by 4 and
            rounded up.  (cramfs doesn't support hard links.) */
         /* OFFSET: For symlinks and non-empty regular files, this
@@ -44,27 +38,27 @@ struct cramfs_inode {
            see README).  For non-empty directories it is the offset
            (divided by 4) of the inode of the first file in that
            directory.  For anything else, offset is zero. */
-        u32 namelen:CRAMFS_NAMELEN_WIDTH, offset:CRAMFS_OFFSET_WIDTH;
+        __u32 namelen:CRAMFS_NAMELEN_WIDTH, offset:CRAMFS_OFFSET_WIDTH;
 };
 
 struct cramfs_info {
-        u32 crc;
-        u32 edition;
-        u32 blocks;
-        u32 files;
+        __u32 crc;
+        __u32 edition;
+        __u32 blocks;
+        __u32 files;
 };
 
 /*
  * Superblock information at the beginning of the FS.
  */
 struct cramfs_super {
-        u32 magic;                      /* 0x28cd3d45 - random number */
-        u32 size;                       /* length in bytes */
-        u32 flags;                      /* feature flags */
-        u32 future;                     /* reserved for future use */
-        u8 signature[16];               /* "Compressed ROMFS" */
+        __u32 magic;                    /* 0x28cd3d45 - random number */
+        __u32 size;                     /* length in bytes */
+        __u32 flags;                    /* feature flags */
+        __u32 future;                   /* reserved for future use */
+        __u8 signature[16];             /* "Compressed ROMFS" */
         struct cramfs_info fsid;        /* unique filesystem info */
-        u8 name[16];                    /* user-defined name */
+        __u8 name[16];                  /* user-defined name */
         struct cramfs_inode root;       /* root inode data */
 };
 
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index 0ab1bc1152ca..5a0470e36111 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -17,7 +17,6 @@
 #ifndef _LINUX_CRYPTO_H
 #define _LINUX_CRYPTO_H
 
-#include <linux/config.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
diff --git a/include/linux/cyclomx.h b/include/linux/cyclomx.h
index 300d704bdb9a..b88f7f428e58 100644
--- a/include/linux/cyclomx.h
+++ b/include/linux/cyclomx.h
@@ -24,7 +24,6 @@
 * 1998/08/08    acme            Version 0.0.1
 */
 
-#include <linux/config.h>
 #include <linux/wanrouter.h>
 #include <linux/spinlock.h>
 
diff --git a/include/linux/dcookies.h b/include/linux/dcookies.h
index 1d68428c925d..0fe7cdf326f7 100644
--- a/include/linux/dcookies.h
+++ b/include/linux/dcookies.h
@@ -9,7 +9,6 @@
 #ifndef DCOOKIES_H
 #define DCOOKIES_H
  
-#include <linux/config.h>
 
 #ifdef CONFIG_PROFILING
  
diff --git a/include/linux/devfs_fs_kernel.h b/include/linux/devfs_fs_kernel.h
index 89810e73d256..0d74a6f22abc 100644
--- a/include/linux/devfs_fs_kernel.h
+++ b/include/linux/devfs_fs_kernel.h
@@ -2,7 +2,6 @@
 #define _LINUX_DEVFS_FS_KERNEL_H
 
 #include <linux/fs.h>
-#include <linux/config.h>
 #include <linux/spinlock.h>
 #include <linux/types.h>
 
diff --git a/include/linux/device.h b/include/linux/device.h
index e8e53b9accc6..b2e5da2b637b 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -11,7 +11,6 @@
 #ifndef _DEVICE_H_
 #define _DEVICE_H_
 
-#include <linux/config.h>
 #include <linux/ioport.h>
 #include <linux/kobject.h>
 #include <linux/klist.h>
diff --git a/include/linux/divert.h b/include/linux/divert.h
index 6919b09133d4..8fb4e9de6843 100644
--- a/include/linux/divert.h
+++ b/include/linux/divert.h
@@ -27,10 +27,10 @@ struct divert_blk
 {
         int             divert;  /* are we active */
         unsigned int protos;    /* protocols */
-        u16             tcp_dst[MAX_DIVERT_PORTS]; /* specific tcp dst ports to divert */
-        u16             tcp_src[MAX_DIVERT_PORTS]; /* specific tcp src ports to divert */
-        u16             udp_dst[MAX_DIVERT_PORTS]; /* specific udp dst ports to divert */
-        u16             udp_src[MAX_DIVERT_PORTS]; /* specific udp src ports to divert */
+        __u16           tcp_dst[MAX_DIVERT_PORTS]; /* specific tcp dst ports to divert */
+        __u16           tcp_src[MAX_DIVERT_PORTS]; /* specific tcp src ports to divert */
+        __u16           udp_dst[MAX_DIVERT_PORTS]; /* specific udp dst ports to divert */
+        __u16           udp_src[MAX_DIVERT_PORTS]; /* specific udp src ports to divert */
 };
 
 /*
@@ -40,12 +40,12 @@ struct divert_blk
 
 typedef union _divert_cf_arg
 {
-        s16             int16;
-        u16             uint16;
-        s32             int32;
-        u32             uint32;
-        s64             int64;
-        u64             uint64;
+        __s16           int16;
+        __u16           uint16;
+        __s32           int32;
+        __u32           uint32;
+        __s64           int64;
+        __u64           uint64;
         void    __user *ptr;
 } divert_cf_arg;
 
diff --git a/include/linux/dmi.h b/include/linux/dmi.h
index 64fd6c366604..b2cd2071d432 100644
--- a/include/linux/dmi.h
+++ b/include/linux/dmi.h
@@ -2,7 +2,6 @@
 #define __DMI_H__
 
 #include <linux/list.h>
-#include <linux/config.h>
 
 enum dmi_field {
         DMI_NONE,
diff --git a/include/linux/dnotify.h b/include/linux/dnotify.h
index f134a01975c7..102a902b4396 100644
--- a/include/linux/dnotify.h
+++ b/include/linux/dnotify.h
@@ -18,7 +18,6 @@ struct dnotify_struct {
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #ifdef CONFIG_DNOTIFY
 
diff --git a/include/linux/elf-em.h b/include/linux/elf-em.h
new file mode 100644
index 000000000000..114a96d25652
--- /dev/null
+++ b/include/linux/elf-em.h
@@ -0,0 +1,44 @@
+#ifndef _LINUX_ELF_EM_H
+#define _LINUX_ELF_EM_H
+
+/* These constants define the various ELF target machines */
+#define EM_NONE         0
+#define EM_M32          1
+#define EM_SPARC        2
+#define EM_386          3
+#define EM_68K          4
+#define EM_88K          5
+#define EM_486          6       /* Perhaps disused */
+#define EM_860          7
+#define EM_MIPS         8       /* MIPS R3000 (officially, big-endian only) */
+#define EM_MIPS_RS4_BE  10      /* MIPS R4000 big-endian */
+#define EM_PARISC       15      /* HPPA */
+#define EM_SPARC32PLUS  18      /* Sun's "v8plus" */
+#define EM_PPC          20      /* PowerPC */
+#define EM_PPC64        21       /* PowerPC64 */
+#define EM_SH           42      /* SuperH */
+#define EM_SPARCV9      43      /* SPARC v9 64-bit */
+#define EM_IA_64        50      /* HP/Intel IA-64 */
+#define EM_X86_64       62      /* AMD x86-64 */
+#define EM_S390         22      /* IBM S/390 */
+#define EM_CRIS         76      /* Axis Communications 32-bit embedded processor */
+#define EM_V850         87      /* NEC v850 */
+#define EM_M32R         88      /* Renesas M32R */
+#define EM_H8_300       46      /* Renesas H8/300,300H,H8S */
+#define EM_FRV          0x5441  /* Fujitsu FR-V */
+
+/*
+ * This is an interim value that we will use until the committee comes
+ * up with a final number.
+ */
+#define EM_ALPHA        0x9026
+
+/* Bogus old v850 magic number, used by old tools. */
+#define EM_CYGNUS_V850  0x9080
+/* Bogus old m32r magic number, used by old tools. */
+#define EM_CYGNUS_M32R  0x9041
+/* This is the old interim value for S/390 architecture */
+#define EM_S390_OLD     0xA390
+
+
+#endif /* _LINUX_ELF_EM_H */
diff --git a/include/linux/elf.h b/include/linux/elf.h
index d3bfacb24496..b70d1d2c8d28 100644
--- a/include/linux/elf.h
+++ b/include/linux/elf.h
@@ -3,6 +3,7 @@
 
 #include <linux/types.h>
 #include <linux/auxvec.h>
+#include <linux/elf-em.h>
 #include <asm/elf.h>
 
 #ifndef elf_read_implies_exec
@@ -55,64 +56,6 @@ typedef __s64	Elf64_Sxword;
 #define ET_LOPROC 0xff00
 #define ET_HIPROC 0xffff
 
-/* These constants define the various ELF target machines */
-#define EM_NONE  0
-#define EM_M32   1
-#define EM_SPARC 2
-#define EM_386   3
-#define EM_68K   4
-#define EM_88K   5
-#define EM_486   6   /* Perhaps disused */
-#define EM_860   7
-
-#define EM_MIPS         8       /* MIPS R3000 (officially, big-endian only) */
-
-#define EM_MIPS_RS4_BE 10       /* MIPS R4000 big-endian */
-
-#define EM_PARISC      15       /* HPPA */
-
-#define EM_SPARC32PLUS 18       /* Sun's "v8plus" */
-
-#define EM_PPC         20       /* PowerPC */
-#define EM_PPC64       21       /* PowerPC64 */
-
-#define EM_SH          42       /* SuperH */
-
-#define EM_SPARCV9     43       /* SPARC v9 64-bit */
-
-#define EM_IA_64        50      /* HP/Intel IA-64 */
-
-#define EM_X86_64       62      /* AMD x86-64 */
-
-#define EM_S390         22      /* IBM S/390 */
-
-#define EM_CRIS         76      /* Axis Communications 32-bit embedded processor */
-
-#define EM_V850         87      /* NEC v850 */
-
-#define EM_M32R         88      /* Renesas M32R */
-
-#define EM_H8_300       46      /* Renesas H8/300,300H,H8S */
-
-/*
- * This is an interim value that we will use until the committee comes
- * up with a final number.
- */
-#define EM_ALPHA        0x9026
-
-/* Bogus old v850 magic number, used by old tools.  */
-#define EM_CYGNUS_V850  0x9080
-
-/* Bogus old m32r magic number, used by old tools.  */
-#define EM_CYGNUS_M32R  0x9041
-
-/*
- * This is the old interim value for S/390 architecture
- */
-#define EM_S390_OLD     0xA390
-
-#define EM_FRV          0x5441          /* Fujitsu FR-V */
-
 /* This is the info that is needed to parse the dynamic section of the file */
 #define DT_NULL         0
 #define DT_NEEDED       1
diff --git a/include/linux/errqueue.h b/include/linux/errqueue.h
index 174582fedb8b..408118a07763 100644
--- a/include/linux/errqueue.h
+++ b/include/linux/errqueue.h
@@ -21,7 +21,6 @@ struct sock_extended_err
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <net/ip.h>
 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
 #include <linux/ipv6.h>
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index 93535f093216..cf2abeca92a0 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -15,24 +15,24 @@
 
 /* This should work for both 32 and 64 bit userland. */
 struct ethtool_cmd {
-        u32     cmd;
-        u32     supported;      /* Features this interface supports */
-        u32     advertising;    /* Features this interface advertises */
-        u16     speed;          /* The forced speed, 10Mb, 100Mb, gigabit */
-        u8      duplex;         /* Duplex, half or full */
-        u8      port;           /* Which connector port */
-        u8      phy_address;
-        u8      transceiver;    /* Which transceiver to use */
-        u8      autoneg;        /* Enable or disable autonegotiation */
-        u32     maxtxpkt;       /* Tx pkts before generating tx int */
-        u32     maxrxpkt;       /* Rx pkts before generating rx int */
-        u32     reserved[4];
+        __u32   cmd;
+        __u32   supported;      /* Features this interface supports */
+        __u32   advertising;    /* Features this interface advertises */
+        __u16   speed;          /* The forced speed, 10Mb, 100Mb, gigabit */
+        __u8    duplex;         /* Duplex, half or full */
+        __u8    port;           /* Which connector port */
+        __u8    phy_address;
+        __u8    transceiver;    /* Which transceiver to use */
+        __u8    autoneg;        /* Enable or disable autonegotiation */
+        __u32   maxtxpkt;       /* Tx pkts before generating tx int */
+        __u32   maxrxpkt;       /* Rx pkts before generating rx int */
+        __u32   reserved[4];
 };
 
 #define ETHTOOL_BUSINFO_LEN     32
 /* these strings are set to whatever the driver author decides... */
 struct ethtool_drvinfo {
-        u32     cmd;
+        __u32   cmd;
         char    driver[32];     /* driver short name, "tulip", "eepro100" */
         char    version[32];    /* driver version string */
         char    fw_version[32]; /* firmware version string, if applicable */
@@ -40,53 +40,53 @@ struct ethtool_drvinfo {
                                 /* For PCI devices, use pci_name(pci_dev). */
         char    reserved1[32];
         char    reserved2[16];
-        u32     n_stats;        /* number of u64's from ETHTOOL_GSTATS */
-        u32     testinfo_len;
-        u32     eedump_len;     /* Size of data from ETHTOOL_GEEPROM (bytes) */
-        u32     regdump_len;    /* Size of data from ETHTOOL_GREGS (bytes) */
+        __u32   n_stats;        /* number of u64's from ETHTOOL_GSTATS */
+        __u32   testinfo_len;
+        __u32   eedump_len;     /* Size of data from ETHTOOL_GEEPROM (bytes) */
+        __u32   regdump_len;    /* Size of data from ETHTOOL_GREGS (bytes) */
 };
 
 #define SOPASS_MAX      6
 /* wake-on-lan settings */
 struct ethtool_wolinfo {
-        u32     cmd;
-        u32     supported;
-        u32     wolopts;
-        u8      sopass[SOPASS_MAX]; /* SecureOn(tm) password */
+        __u32   cmd;
+        __u32   supported;
+        __u32   wolopts;
+        __u8    sopass[SOPASS_MAX]; /* SecureOn(tm) password */
 };
 
 /* for passing single values */
 struct ethtool_value {
-        u32     cmd;
-        u32     data;
+        __u32   cmd;
+        __u32   data;
 };
 
 /* for passing big chunks of data */
 struct ethtool_regs {
-        u32     cmd;
-        u32     version; /* driver-specific, indicates different chips/revs */
-        u32     len; /* bytes */
-        u8      data[0];
+        __u32   cmd;
+        __u32   version; /* driver-specific, indicates different chips/revs */
+        __u32   len; /* bytes */
+        __u8    data[0];
 };
 
 /* for passing EEPROM chunks */
 struct ethtool_eeprom {
-        u32     cmd;
-        u32     magic;
-        u32     offset; /* in bytes */
-        u32     len; /* in bytes */
-        u8      data[0];
+        __u32   cmd;
+        __u32   magic;
+        __u32   offset; /* in bytes */
+        __u32   len; /* in bytes */
+        __u8    data[0];
 };
 
 /* for configuring coalescing parameters of chip */
 struct ethtool_coalesce {
-        u32     cmd;    /* ETHTOOL_{G,S}COALESCE */
+        __u32   cmd;    /* ETHTOOL_{G,S}COALESCE */
 
         /* How many usecs to delay an RX interrupt after
          * a packet arrives.  If 0, only rx_max_coalesced_frames
          * is used.
          */
-        u32     rx_coalesce_usecs;
+        __u32   rx_coalesce_usecs;
 
         /* How many packets to delay an RX interrupt after
          * a packet arrives.  If 0, only rx_coalesce_usecs is
@@ -94,21 +94,21 @@ struct ethtool_coalesce {
          * to zero as this would cause RX interrupts to never be
          * generated.
          */
-        u32     rx_max_coalesced_frames;
+        __u32   rx_max_coalesced_frames;
 
         /* Same as above two parameters, except that these values
          * apply while an IRQ is being serviced by the host.  Not
          * all cards support this feature and the values are ignored
          * in that case.
          */
-        u32     rx_coalesce_usecs_irq;
-        u32     rx_max_coalesced_frames_irq;
+        __u32   rx_coalesce_usecs_irq;
+        __u32   rx_max_coalesced_frames_irq;
 
         /* How many usecs to delay a TX interrupt after
          * a packet is sent.  If 0, only tx_max_coalesced_frames
          * is used.
          */
-        u32     tx_coalesce_usecs;
+        __u32   tx_coalesce_usecs;
 
         /* How many packets to delay a TX interrupt after
          * a packet is sent.  If 0, only tx_coalesce_usecs is
@@ -116,22 +116,22 @@ struct ethtool_coalesce {
          * to zero as this would cause TX interrupts to never be
          * generated.
          */
-        u32     tx_max_coalesced_frames;
+        __u32   tx_max_coalesced_frames;
 
         /* Same as above two parameters, except that these values
          * apply while an IRQ is being serviced by the host.  Not
          * all cards support this feature and the values are ignored
          * in that case.
          */
-        u32     tx_coalesce_usecs_irq;
-        u32     tx_max_coalesced_frames_irq;
+        __u32   tx_coalesce_usecs_irq;
+        __u32   tx_max_coalesced_frames_irq;
 
         /* How many usecs to delay in-memory statistics
          * block updates.  Some drivers do not have an in-memory
          * statistic block, and in such cases this value is ignored.
          * This value must not be zero.
          */
-        u32     stats_block_coalesce_usecs;
+        __u32   stats_block_coalesce_usecs;
 
         /* Adaptive RX/TX coalescing is an algorithm implemented by
          * some drivers to improve latency under low packet rates and
@@ -140,18 +140,18 @@ struct ethtool_coalesce {
          * not implemented by the driver causes these values to be
          * silently ignored.
          */
-        u32     use_adaptive_rx_coalesce;
-        u32     use_adaptive_tx_coalesce;
+        __u32   use_adaptive_rx_coalesce;
+        __u32   use_adaptive_tx_coalesce;
 
         /* When the packet rate (measured in packets per second)
          * is below pkt_rate_low, the {rx,tx}_*_low parameters are
          * used.
          */
-        u32     pkt_rate_low;
-        u32     rx_coalesce_usecs_low;
-        u32     rx_max_coalesced_frames_low;
-        u32     tx_coalesce_usecs_low;
-        u32     tx_max_coalesced_frames_low;
+        __u32   pkt_rate_low;
+        __u32   rx_coalesce_usecs_low;
+        __u32   rx_max_coalesced_frames_low;
+        __u32   tx_coalesce_usecs_low;
+        __u32   tx_max_coalesced_frames_low;
 
         /* When the packet rate is below pkt_rate_high but above
          * pkt_rate_low (both measured in packets per second) the
@@ -162,43 +162,43 @@ struct ethtool_coalesce {
          * is above pkt_rate_high, the {rx,tx}_*_high parameters are
          * used.
          */
-        u32     pkt_rate_high;
-        u32     rx_coalesce_usecs_high;
-        u32     rx_max_coalesced_frames_high;
-        u32     tx_coalesce_usecs_high;
-        u32     tx_max_coalesced_frames_high;
+        __u32   pkt_rate_high;
+        __u32   rx_coalesce_usecs_high;
+        __u32   rx_max_coalesced_frames_high;
+        __u32   tx_coalesce_usecs_high;
+        __u32   tx_max_coalesced_frames_high;
 
         /* How often to do adaptive coalescing packet rate sampling,
          * measured in seconds.  Must not be zero.
          */
-        u32     rate_sample_interval;
+        __u32   rate_sample_interval;
 };
 
 /* for configuring RX/TX ring parameters */
 struct ethtool_ringparam {
-        u32     cmd;    /* ETHTOOL_{G,S}RINGPARAM */
+        __u32   cmd;    /* ETHTOOL_{G,S}RINGPARAM */
 
         /* Read only attributes.  These indicate the maximum number
          * of pending RX/TX ring entries the driver will allow the
          * user to set.
          */
-        u32     rx_max_pending;
-        u32     rx_mini_max_pending;
-        u32     rx_jumbo_max_pending;
-        u32     tx_max_pending;
+        __u32   rx_max_pending;
+        __u32   rx_mini_max_pending;
+        __u32   rx_jumbo_max_pending;
+        __u32   tx_max_pending;
 
         /* Values changeable by the user.  The valid values are
          * in the range 1 to the "*_max_pending" counterpart above.
          */
-        u32     rx_pending;
-        u32     rx_mini_pending;
-        u32     rx_jumbo_pending;
-        u32     tx_pending;
+        __u32   rx_pending;
+        __u32   rx_mini_pending;
+        __u32   rx_jumbo_pending;
+        __u32   tx_pending;
 };
 
 /* for configuring link flow control parameters */
 struct ethtool_pauseparam {
-        u32     cmd;    /* ETHTOOL_{G,S}PAUSEPARAM */
+        __u32   cmd;    /* ETHTOOL_{G,S}PAUSEPARAM */
 
         /* If the link is being auto-negotiated (via ethtool_cmd.autoneg
          * being true) the user may set 'autonet' here non-zero to have the
@@ -210,9 +210,9 @@ struct ethtool_pauseparam {
          * then {rx,tx}_pause force the driver to use/not-use pause
          * flow control.
          */
-        u32     autoneg;
-        u32     rx_pause;
-        u32     tx_pause;
+        __u32   autoneg;
+        __u32   rx_pause;
+        __u32   tx_pause;
 };
 
 #define ETH_GSTRING_LEN         32
@@ -223,10 +223,10 @@ enum ethtool_stringset {
 
 /* for passing string sets for data tagging */
 struct ethtool_gstrings {
-        u32     cmd;            /* ETHTOOL_GSTRINGS */
-        u32     string_set;     /* string set id e.c. ETH_SS_TEST, etc*/
-        u32     len;            /* number of strings in the string set */
-        u8      data[0];
+        __u32   cmd;            /* ETHTOOL_GSTRINGS */
+        __u32   string_set;     /* string set id e.c. ETH_SS_TEST, etc*/
+        __u32   len;            /* number of strings in the string set */
+        __u8    data[0];
 };
 
 enum ethtool_test_flags {
@@ -236,26 +236,28 @@ enum ethtool_test_flags {
 
 /* for requesting NIC test and getting results*/
 struct ethtool_test {
-        u32     cmd;            /* ETHTOOL_TEST */
-        u32     flags;          /* ETH_TEST_FL_xxx */
-        u32     reserved;
-        u32     len;            /* result length, in number of u64 elements */
-        u64     data[0];
+        __u32   cmd;            /* ETHTOOL_TEST */
+        __u32   flags;          /* ETH_TEST_FL_xxx */
+        __u32   reserved;
+        __u32   len;            /* result length, in number of u64 elements */
+        __u64   data[0];
 };
 
 /* for dumping NIC-specific statistics */
 struct ethtool_stats {
-        u32     cmd;            /* ETHTOOL_GSTATS */
-        u32     n_stats;        /* number of u64's being returned */
-        u64     data[0];
+        __u32   cmd;            /* ETHTOOL_GSTATS */
+        __u32   n_stats;        /* number of u64's being returned */
+        __u64   data[0];
 };
 
 struct ethtool_perm_addr {
-        u32     cmd;            /* ETHTOOL_GPERMADDR */
-        u32     size;
-        u8      data[0];
+        __u32   cmd;            /* ETHTOOL_GPERMADDR */
+        __u32   size;
+        __u8    data[0];
 };
 
+#ifdef __KERNEL__
+
 struct net_device;
 
 /* Some generic methods drivers may use in their ethtool_ops */
@@ -371,6 +373,7 @@ struct ethtool_ops {
         u32     (*get_ufo)(struct net_device *);
         int     (*set_ufo)(struct net_device *, u32);
 };
+#endif /* __KERNEL__ */
 
 /* CMDs currently supported */
 #define ETHTOOL_GSET            0x00000001 /* Get settings. */
diff --git a/include/linux/ext2_fs.h b/include/linux/ext2_fs.h
index f7bd1c7ebefb..facf34e98954 100644
--- a/include/linux/ext2_fs.h
+++ b/include/linux/ext2_fs.h
@@ -17,7 +17,6 @@
 #define _LINUX_EXT2_FS_H
 
 #include <linux/types.h>
-#include <linux/ext2_fs_sb.h>
 
 /*
  * The second extended filesystem constants/structures
@@ -70,6 +69,7 @@
 #define EXT2_SUPER_MAGIC        0xEF53
 
 #ifdef __KERNEL__
+#include <linux/ext2_fs_sb.h>
 static inline struct ext2_sb_info *EXT2_SB(struct super_block *sb)
 {
         return sb->s_fs_info;
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index 3ade6a4e3bdd..757d54d8f1a5 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -17,11 +17,6 @@
 #define _LINUX_EXT3_FS_H
 
 #include <linux/types.h>
-#include <linux/ext3_fs_i.h>
-#include <linux/ext3_fs_sb.h>
-
-
-struct statfs;
 
 /*
  * The second extended filesystem constants/structures
@@ -487,6 +482,8 @@ struct ext3_super_block {
 };
 
 #ifdef __KERNEL__
+#include <linux/ext3_fs_i.h>
+#include <linux/ext3_fs_sb.h>
 static inline struct ext3_sb_info * EXT3_SB(struct super_block *sb)
 {
         return sb->s_fs_info;
@@ -664,6 +661,8 @@ struct ext3_dir_entry_2 {
 #define DX_HASH_HALF_MD4        1
 #define DX_HASH_TEA             2
 
+#ifdef __KERNEL__
+
 /* hash info structure used by the directory hash */
 struct dx_hash_info
 {
@@ -675,7 +674,6 @@ struct dx_hash_info
 
 #define EXT3_HTREE_EOF  0x7fffffff
 
-#ifdef __KERNEL__
 /*
  * Control parameters used by ext3_htree_next_block
  */
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 1d80ba747484..2d5a112e8404 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -6,7 +6,6 @@
  * structures etc.
  */
 
-#include <linux/config.h>
 #include <linux/limits.h>
 #include <linux/ioctl.h>
 
diff --git a/include/linux/fsnotify.h b/include/linux/fsnotify.h
index 11438eff4d44..cc5dec70c32c 100644
--- a/include/linux/fsnotify.h
+++ b/include/linux/fsnotify.h
@@ -54,19 +54,20 @@ static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir,
 
         if (isdir)
                 isdir = IN_ISDIR;
-        inotify_inode_queue_event(old_dir, IN_MOVED_FROM|isdir,cookie,old_name);
-        inotify_inode_queue_event(new_dir, IN_MOVED_TO|isdir, cookie, new_name);
+        inotify_inode_queue_event(old_dir, IN_MOVED_FROM|isdir,cookie,old_name,
+                                  source);
+        inotify_inode_queue_event(new_dir, IN_MOVED_TO|isdir, cookie, new_name,
+                                  source);
 
         if (target) {
-                inotify_inode_queue_event(target, IN_DELETE_SELF, 0, NULL);
+                inotify_inode_queue_event(target, IN_DELETE_SELF, 0, NULL, NULL);
                 inotify_inode_is_dead(target);
         }
 
         if (source) {
-                inotify_inode_queue_event(source, IN_MOVE_SELF, 0, NULL);
+                inotify_inode_queue_event(source, IN_MOVE_SELF, 0, NULL, NULL);
         }
-        audit_inode_child(old_name, source, old_dir->i_ino);
-        audit_inode_child(new_name, target, new_dir->i_ino);
+        audit_inode_child(new_name, source, new_dir->i_ino);
 }
 
 /*
@@ -85,7 +86,7 @@ static inline void fsnotify_nameremove(struct dentry *dentry, int isdir)
  */
 static inline void fsnotify_inoderemove(struct inode *inode)
 {
-        inotify_inode_queue_event(inode, IN_DELETE_SELF, 0, NULL);
+        inotify_inode_queue_event(inode, IN_DELETE_SELF, 0, NULL, NULL);
         inotify_inode_is_dead(inode);
 }
 
@@ -95,7 +96,8 @@ static inline void fsnotify_inoderemove(struct inode *inode)
 static inline void fsnotify_create(struct inode *inode, struct dentry *dentry)
 {
         inode_dir_notify(inode, DN_CREATE);
-        inotify_inode_queue_event(inode, IN_CREATE, 0, dentry->d_name.name);
+        inotify_inode_queue_event(inode, IN_CREATE, 0, dentry->d_name.name,
+                                  dentry->d_inode);
         audit_inode_child(dentry->d_name.name, dentry->d_inode, inode->i_ino);
 }
 
@@ -106,7 +108,7 @@ static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry)
 {
         inode_dir_notify(inode, DN_CREATE);
         inotify_inode_queue_event(inode, IN_CREATE | IN_ISDIR, 0, 
-                                  dentry->d_name.name);
+                                  dentry->d_name.name, dentry->d_inode);
         audit_inode_child(dentry->d_name.name, dentry->d_inode, inode->i_ino);
 }
 
@@ -123,7 +125,7 @@ static inline void fsnotify_access(struct dentry *dentry)
 
         dnotify_parent(dentry, DN_ACCESS);
         inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
-        inotify_inode_queue_event(inode, mask, 0, NULL);
+        inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
 }
 
 /*
@@ -139,7 +141,7 @@ static inline void fsnotify_modify(struct dentry *dentry)
 
         dnotify_parent(dentry, DN_MODIFY);
         inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
-        inotify_inode_queue_event(inode, mask, 0, NULL);
+        inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
 }
 
 /*
@@ -154,7 +156,7 @@ static inline void fsnotify_open(struct dentry *dentry)
                 mask |= IN_ISDIR;
 
         inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
-        inotify_inode_queue_event(inode, mask, 0, NULL);        
+        inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
 }
 
 /*
@@ -172,7 +174,7 @@ static inline void fsnotify_close(struct file *file)
                 mask |= IN_ISDIR;
 
         inotify_dentry_parent_queue_event(dentry, mask, 0, name);
-        inotify_inode_queue_event(inode, mask, 0, NULL);
+        inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
 }
 
 /*
@@ -187,7 +189,7 @@ static inline void fsnotify_xattr(struct dentry *dentry)
                 mask |= IN_ISDIR;
 
         inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
-        inotify_inode_queue_event(inode, mask, 0, NULL);
+        inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
 }
 
 /*
@@ -234,7 +236,7 @@ static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid)
         if (in_mask) {
                 if (S_ISDIR(inode->i_mode))
                         in_mask |= IN_ISDIR;
-                inotify_inode_queue_event(inode, in_mask, 0, NULL);
+                inotify_inode_queue_event(inode, in_mask, 0, NULL, NULL);
                 inotify_dentry_parent_queue_event(dentry, in_mask, 0,
                                                   dentry->d_name.name);
         }
diff --git a/include/linux/ftape.h b/include/linux/ftape.h
index 72faeec9f6e1..7e7038cba86a 100644
--- a/include/linux/ftape.h
+++ b/include/linux/ftape.h
@@ -35,7 +35,6 @@
 #include <linux/mm.h>
 #endif
 #include <linux/types.h>
-#include <linux/config.h>
 #include <linux/mtio.h>
 
 #define FT_SECTOR(x)            (x+1)   /* sector offset into real sector */
diff --git a/include/linux/gameport.h b/include/linux/gameport.h
index 71e7b2847cb3..2cdba0c23957 100644
--- a/include/linux/gameport.h
+++ b/include/linux/gameport.h
@@ -9,6 +9,7 @@
  * the Free Software Foundation.
  */
 
+#ifdef __KERNEL__
 #include <asm/io.h>
 #include <linux/list.h>
 #include <linux/mutex.h>
@@ -154,6 +155,8 @@ static inline void gameport_register_driver(struct gameport_driver *drv)
 
 void gameport_unregister_driver(struct gameport_driver *drv);
 
+#endif /* __KERNEL__ */
+
 #define GAMEPORT_MODE_DISABLED          0
 #define GAMEPORT_MODE_RAW               1
 #define GAMEPORT_MODE_COOKED            2
@@ -169,6 +172,8 @@ void gameport_unregister_driver(struct gameport_driver *drv);
 #define GAMEPORT_ID_VENDOR_GRAVIS       0x0009
 #define GAMEPORT_ID_VENDOR_GUILLEMOT    0x000a
 
+#ifdef __KERNEL__
+
 static inline void gameport_trigger(struct gameport *gameport)
 {
         if (gameport->trigger)
@@ -219,4 +224,5 @@ static inline void gameport_set_poll_interval(struct gameport *gameport, unsigne
 void gameport_start_polling(struct gameport *gameport);
 void gameport_stop_polling(struct gameport *gameport);
 
+#endif /* __KERNEL__ */
 #endif
diff --git a/include/linux/generic_serial.h b/include/linux/generic_serial.h
index 652611a4bdcd..e25384561955 100644
--- a/include/linux/generic_serial.h
+++ b/include/linux/generic_serial.h
@@ -12,6 +12,7 @@
 #ifndef GENERIC_SERIAL_H
 #define GENERIC_SERIAL_H
 
+#ifdef __KERNEL__
 #include <linux/mutex.h>
 
 struct real_driver {
@@ -54,6 +55,7 @@ struct gs_port {
   spinlock_t              driver_lock;
 };
 
+#endif /* __KERNEL__ */
 
 /* Flags */
 /* Warning: serial.h defines some ASYNC_ flags, they say they are "only"
@@ -75,7 +77,7 @@ struct gs_port {
 #define GS_DEBUG_FLOW    0x00000020
 #define GS_DEBUG_WRITE   0x00000040
 
-
+#ifdef __KERNEL__
 void gs_put_char(struct tty_struct *tty, unsigned char ch);
 int  gs_write(struct tty_struct *tty, 
              const unsigned char *buf, int count);
@@ -94,5 +96,5 @@ int  gs_init_port(struct gs_port *port);
 int  gs_setserial(struct gs_port *port, struct serial_struct __user *sp);
 int  gs_getserial(struct gs_port *port, struct serial_struct __user *sp);
 void gs_got_break(struct gs_port *port);
-
+#endif /* __KERNEL__ */
 #endif
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 2ef845b35175..3498a0c68184 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -9,13 +9,7 @@
  *              <drew@colorado.edu>
  */
 
-#include <linux/config.h>
 #include <linux/types.h>
-#include <linux/major.h>
-#include <linux/device.h>
-#include <linux/smp.h>
-#include <linux/string.h>
-#include <linux/fs.h>
 
 enum {
 /* These three have identical behaviour; use the second one if DOS FDISK gets
@@ -61,6 +55,12 @@ struct partition {
 #endif
 
 #ifdef __KERNEL__
+#include <linux/major.h>
+#include <linux/device.h>
+#include <linux/smp.h>
+#include <linux/string.h>
+#include <linux/fs.h>
+
 struct partition {
         unsigned char boot_ind;         /* 0x80 - active */
         unsigned char head;             /* starting head */
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 3ac452945a7d..cc9e60844484 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -4,7 +4,6 @@
 #include <linux/mmzone.h>
 #include <linux/stddef.h>
 #include <linux/linkage.h>
-#include <linux/config.h>
 
 struct vm_area_struct;
 
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index eab537091f2a..114ae583cca9 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -1,7 +1,6 @@
 #ifndef LINUX_HARDIRQ_H
 #define LINUX_HARDIRQ_H
 
-#include <linux/config.h>
 #include <linux/preempt.h>
 #include <linux/smp_lock.h>
 #include <asm/hardirq.h>
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index 892c4ea1b425..85ce7ef9a512 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_HIGHMEM_H
 #define _LINUX_HIGHMEM_H
 
-#include <linux/config.h>
 #include <linux/fs.h>
 #include <linux/mm.h>
 
diff --git a/include/linux/highuid.h b/include/linux/highuid.h
index 53ecac3905e8..434e56246f67 100644
--- a/include/linux/highuid.h
+++ b/include/linux/highuid.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_HIGHUID_H
 #define _LINUX_HIGHUID_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 
 /*
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 306acf1dc6d5..7d2a1b974c5e 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -127,7 +127,7 @@ extern ktime_t hrtimer_get_next_event(void);
 
 static inline int hrtimer_active(const struct hrtimer *timer)
 {
-        return timer->node.rb_parent != HRTIMER_INACTIVE;
+        return rb_parent(&timer->node) != &timer->node;
 }
 
 /* Forward a hrtimer so it expires after now: */
diff --git a/include/linux/i2c-algo-ite.h b/include/linux/i2c-algo-ite.h
index 26a8b89855f1..0073fe96c76e 100644
--- a/include/linux/i2c-algo-ite.h
+++ b/include/linux/i2c-algo-ite.h
@@ -29,7 +29,7 @@
 #ifndef I2C_ALGO_ITE_H
 #define I2C_ALGO_ITE_H 1
 
-#include <linux/i2c.h>
+#include <linux/types.h>
 
 /* Example of a sequential read request:
         struct i2c_iic_msg s_msg; 
@@ -49,6 +49,9 @@ struct i2c_iic_msg {
         char *buf;      /* pointer to msg data */
 };
 
+#ifdef __KERNEL__
+struct i2c_adapter;
+
 struct i2c_algo_iic_data {
         void *data;             /* private data for lolevel routines    */
         void (*setiic) (void *data, int ctl, int val);
@@ -65,5 +68,5 @@ struct i2c_algo_iic_data {
 
 int i2c_iic_add_bus(struct i2c_adapter *);
 int i2c_iic_del_bus(struct i2c_adapter *);
-
+#endif /* __KERNEL__ */
 #endif /* I2C_ALGO_ITE_H */
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 1635ee25918f..0510430e00db 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -20,14 +20,15 @@
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
 /* ------------------------------------------------------------------------- */
 
-/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and
+/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and
    Frodo Looijaard <frodol@dds.nl> */
 
 #ifndef _LINUX_I2C_H
 #define _LINUX_I2C_H
 
-#include <linux/module.h>
 #include <linux/types.h>
+#ifdef __KERNEL__ 
+#include <linux/module.h>
 #include <linux/i2c-id.h>
 #include <linux/mod_devicetable.h>
 #include <linux/device.h>       /* for struct device */
@@ -354,6 +355,7 @@ static inline int i2c_adapter_id(struct i2c_adapter *adap)
 {
         return adap->nr;
 }
+#endif /* __KERNEL__ */
 
 /*
  * I2C Message - used for pure i2c transaction, also from /dev interface
@@ -469,6 +471,7 @@ union i2c_smbus_data {
 #define I2C_SMBUS       0x0720  /* SMBus-level access */
 
 /* ----- I2C-DEV: char device interface stuff ------------------------- */
+#ifdef __KERNEL__
 
 #define I2C_MAJOR       89              /* Device major number          */
 
@@ -646,5 +649,5 @@ static unsigned short *forces[] = { force, force_##chip1,		\
                                     force_##chip6, force_##chip7,       \
                                     force_##chip8, NULL };              \
 I2C_CLIENT_INSMOD_COMMON
-
+#endif /* __KERNEL__ */
 #endif /* _LINUX_I2C_H */
diff --git a/include/linux/i2o-dev.h b/include/linux/i2o-dev.h
index 36fd18cdad28..c2519df1b6dc 100644
--- a/include/linux/i2o-dev.h
+++ b/include/linux/i2o-dev.h
@@ -13,7 +13,7 @@
  * This header file defines the I2O APIs that are available to both
  * the kernel and user level applications.  Kernel specific structures
  * are defined in i2o_osm. OSMs should include _only_ i2o_osm.h which
- * automatically includs this file.
+ * automatically includes this file.
  *
  */
 
@@ -23,14 +23,7 @@
 /* How many controllers are we allowing */
 #define MAX_I2O_CONTROLLERS     32
 
-//#include <linux/ioctl.h>
-#ifndef __KERNEL__
-
-typedef unsigned char u8;
-typedef unsigned short u16;
-typedef unsigned int u32;
-
-#endif                          /* __KERNEL__ */
+#include <linux/ioctl.h>
 
 /*
  * I2O Control IOCTLs and structures
@@ -53,7 +46,7 @@ typedef unsigned int u32;
 
 struct i2o_cmd_passthru32 {
         unsigned int iop;       /* IOP unit number */
-        u32 msg;                /* message */
+        __u32 msg;              /* message */
 };
 
 struct i2o_cmd_passthru {
@@ -138,53 +131,53 @@ typedef struct i2o_sg_io_hdr {
 #define I2O_BUS_UNKNOWN 0x80
 
 typedef struct _i2o_pci_bus {
-        u8 PciFunctionNumber;
-        u8 PciDeviceNumber;
-        u8 PciBusNumber;
-        u8 reserved;
-        u16 PciVendorID;
-        u16 PciDeviceID;
+        __u8 PciFunctionNumber;
+        __u8 PciDeviceNumber;
+        __u8 PciBusNumber;
+        __u8 reserved;
+        __u16 PciVendorID;
+        __u16 PciDeviceID;
 } i2o_pci_bus;
 
 typedef struct _i2o_local_bus {
-        u16 LbBaseIOPort;
-        u16 reserved;
-        u32 LbBaseMemoryAddress;
+        __u16 LbBaseIOPort;
+        __u16 reserved;
+        __u32 LbBaseMemoryAddress;
 } i2o_local_bus;
 
 typedef struct _i2o_isa_bus {
-        u16 IsaBaseIOPort;
-        u8 CSN;
-        u8 reserved;
-        u32 IsaBaseMemoryAddress;
+        __u16 IsaBaseIOPort;
+        __u8 CSN;
+        __u8 reserved;
+        __u32 IsaBaseMemoryAddress;
 } i2o_isa_bus;
 
 typedef struct _i2o_eisa_bus_info {
-        u16 EisaBaseIOPort;
-        u8 reserved;
-        u8 EisaSlotNumber;
-        u32 EisaBaseMemoryAddress;
+        __u16 EisaBaseIOPort;
+        __u8 reserved;
+        __u8 EisaSlotNumber;
+        __u32 EisaBaseMemoryAddress;
 } i2o_eisa_bus;
 
 typedef struct _i2o_mca_bus {
-        u16 McaBaseIOPort;
-        u8 reserved;
-        u8 McaSlotNumber;
-        u32 McaBaseMemoryAddress;
+        __u16 McaBaseIOPort;
+        __u8 reserved;
+        __u8 McaSlotNumber;
+        __u32 McaBaseMemoryAddress;
 } i2o_mca_bus;
 
 typedef struct _i2o_other_bus {
-        u16 BaseIOPort;
-        u16 reserved;
-        u32 BaseMemoryAddress;
+        __u16 BaseIOPort;
+        __u16 reserved;
+        __u32 BaseMemoryAddress;
 } i2o_other_bus;
 
 typedef struct _i2o_hrt_entry {
-        u32 adapter_id;
-        u32 parent_tid:12;
-        u32 state:4;
-        u32 bus_num:8;
-        u32 bus_type:8;
+        __u32 adapter_id;
+        __u32 parent_tid:12;
+        __u32 state:4;
+        __u32 bus_num:8;
+        __u32 bus_type:8;
         union {
                 i2o_pci_bus pci_bus;
                 i2o_local_bus local_bus;
@@ -196,66 +189,66 @@ typedef struct _i2o_hrt_entry {
 } i2o_hrt_entry;
 
 typedef struct _i2o_hrt {
-        u16 num_entries;
-        u8 entry_len;
-        u8 hrt_version;
-        u32 change_ind;
+        __u16 num_entries;
+        __u8 entry_len;
+        __u8 hrt_version;
+        __u32 change_ind;
         i2o_hrt_entry hrt_entry[1];
 } i2o_hrt;
 
 typedef struct _i2o_lct_entry {
-        u32 entry_size:16;
-        u32 tid:12;
-        u32 reserved:4;
-        u32 change_ind;
-        u32 device_flags;
-        u32 class_id:12;
-        u32 version:4;
-        u32 vendor_id:16;
-        u32 sub_class;
-        u32 user_tid:12;
-        u32 parent_tid:12;
-        u32 bios_info:8;
-        u8 identity_tag[8];
-        u32 event_capabilities;
+        __u32 entry_size:16;
+        __u32 tid:12;
+        __u32 reserved:4;
+        __u32 change_ind;
+        __u32 device_flags;
+        __u32 class_id:12;
+        __u32 version:4;
+        __u32 vendor_id:16;
+        __u32 sub_class;
+        __u32 user_tid:12;
+        __u32 parent_tid:12;
+        __u32 bios_info:8;
+        __u8 identity_tag[8];
+        __u32 event_capabilities;
 } i2o_lct_entry;
 
 typedef struct _i2o_lct {
-        u32 table_size:16;
-        u32 boot_tid:12;
-        u32 lct_ver:4;
-        u32 iop_flags;
-        u32 change_ind;
+        __u32 table_size:16;
+        __u32 boot_tid:12;
+        __u32 lct_ver:4;
+        __u32 iop_flags;
+        __u32 change_ind;
         i2o_lct_entry lct_entry[1];
 } i2o_lct;
 
 typedef struct _i2o_status_block {
-        u16 org_id;
-        u16 reserved;
-        u16 iop_id:12;
-        u16 reserved1:4;
-        u16 host_unit_id;
-        u16 segment_number:12;
-        u16 i2o_version:4;
-        u8 iop_state;
-        u8 msg_type;
-        u16 inbound_frame_size;
-        u8 init_code;
-        u8 reserved2;
-        u32 max_inbound_frames;
-        u32 cur_inbound_frames;
-        u32 max_outbound_frames;
+        __u16 org_id;
+        __u16 reserved;
+        __u16 iop_id:12;
+        __u16 reserved1:4;
+        __u16 host_unit_id;
+        __u16 segment_number:12;
+        __u16 i2o_version:4;
+        __u8 iop_state;
+        __u8 msg_type;
+        __u16 inbound_frame_size;
+        __u8 init_code;
+        __u8 reserved2;
+        __u32 max_inbound_frames;
+        __u32 cur_inbound_frames;
+        __u32 max_outbound_frames;
         char product_id[24];
-        u32 expected_lct_size;
-        u32 iop_capabilities;
-        u32 desired_mem_size;
-        u32 current_mem_size;
-        u32 current_mem_base;
-        u32 desired_io_size;
-        u32 current_io_size;
-        u32 current_io_base;
-        u32 reserved3:24;
-        u32 cmd_status:8;
+        __u32 expected_lct_size;
+        __u32 iop_capabilities;
+        __u32 desired_mem_size;
+        __u32 current_mem_size;
+        __u32 current_mem_base;
+        __u32 desired_io_size;
+        __u32 current_io_size;
+        __u32 current_io_base;
+        __u32 reserved3:24;
+        __u32 cmd_status:8;
 } i2o_status_block;
 
 /* Event indicator mask flags */
diff --git a/include/linux/ide.h b/include/linux/ide.h
index a8bef1d1371c..77e66d055f5b 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -6,7 +6,6 @@
  *  Copyright (C) 1994-2002  Linus Torvalds & authors
  */
 
-#include <linux/config.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
 #include <linux/hdreg.h>
diff --git a/include/linux/if_fddi.h b/include/linux/if_fddi.h
index 1288a161bc0b..e0a150046208 100644
--- a/include/linux/if_fddi.h
+++ b/include/linux/if_fddi.h
@@ -102,6 +102,7 @@ struct fddihdr
                 } hdr;
         } __attribute__ ((packed));
 
+#ifdef __KERNEL__
 /* Define FDDI statistics structure */
 struct fddi_statistics {
 
@@ -193,5 +194,6 @@ struct fddi_statistics {
         __u32   port_ler_flag[2];
         __u32   port_hardware_present[2];
         };
+#endif /* __KERNEL__ */
 
 #endif  /* _LINUX_IF_FDDI_H */
diff --git a/include/linux/if_frad.h b/include/linux/if_frad.h
index 395f0aad9cbf..f272a80caa3e 100644
--- a/include/linux/if_frad.h
+++ b/include/linux/if_frad.h
@@ -24,7 +24,6 @@
 #ifndef _FRAD_H_
 #define _FRAD_H_
 
-#include <linux/config.h>
 #include <linux/if.h>
 
 #if defined(CONFIG_DLCI) || defined(CONFIG_DLCI_MODULE)
diff --git a/include/linux/if_tr.h b/include/linux/if_tr.h
index 5502f597cf0e..2f94cf2c7abb 100644
--- a/include/linux/if_tr.h
+++ b/include/linux/if_tr.h
@@ -43,7 +43,6 @@ struct trh_hdr {
 };
 
 #ifdef __KERNEL__
-#include <linux/config.h>
 #include <linux/skbuff.h>
 
 static inline struct trh_hdr *tr_hdr(const struct sk_buff *skb)
diff --git a/include/linux/init.h b/include/linux/init.h
index 93dcbe1abb4c..6667785dd1ff 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_INIT_H
 #define _LINUX_INIT_H
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 
 /* These macros are used to mark some functions or 
diff --git a/include/linux/inotify.h b/include/linux/inotify.h
index 09e00433c78e..d4f48c6402e6 100644
--- a/include/linux/inotify.h
+++ b/include/linux/inotify.h
@@ -67,20 +67,66 @@ struct inotify_event {
 
 #include <linux/dcache.h>
 #include <linux/fs.h>
-#include <linux/config.h>
+
+/*
+ * struct inotify_watch - represents a watch request on a specific inode
+ *
+ * h_list is protected by ih->mutex of the associated inotify_handle.
+ * i_list, mask are protected by inode->inotify_mutex of the associated inode.
+ * ih, inode, and wd are never written to once the watch is created.
+ *
+ * Callers must use the established inotify interfaces to access inotify_watch
+ * contents.  The content of this structure is private to the inotify
+ * implementation.
+ */
+struct inotify_watch {
+        struct list_head        h_list; /* entry in inotify_handle's list */
+        struct list_head        i_list; /* entry in inode's list */
+        atomic_t                count;  /* reference count */
+        struct inotify_handle   *ih;    /* associated inotify handle */
+        struct inode            *inode; /* associated inode */
+        __s32                   wd;     /* watch descriptor */
+        __u32                   mask;   /* event mask for this watch */
+};
+
+struct inotify_operations {
+        void (*handle_event)(struct inotify_watch *, u32, u32, u32,
+                             const char *, struct inode *);
+        void (*destroy_watch)(struct inotify_watch *);
+};
 
 #ifdef CONFIG_INOTIFY
 
+/* Kernel API for producing events */
+
 extern void inotify_d_instantiate(struct dentry *, struct inode *);
 extern void inotify_d_move(struct dentry *);
 extern void inotify_inode_queue_event(struct inode *, __u32, __u32,
-                                      const char *);
+                                      const char *, struct inode *);
 extern void inotify_dentry_parent_queue_event(struct dentry *, __u32, __u32,
                                               const char *);
 extern void inotify_unmount_inodes(struct list_head *);
 extern void inotify_inode_is_dead(struct inode *);
 extern u32 inotify_get_cookie(void);
 
+/* Kernel Consumer API */
+
+extern struct inotify_handle *inotify_init(const struct inotify_operations *);
+extern void inotify_init_watch(struct inotify_watch *);
+extern void inotify_destroy(struct inotify_handle *);
+extern __s32 inotify_find_watch(struct inotify_handle *, struct inode *,
+                                struct inotify_watch **);
+extern __s32 inotify_find_update_watch(struct inotify_handle *, struct inode *,
+                                       u32);
+extern __s32 inotify_add_watch(struct inotify_handle *, struct inotify_watch *,
+                               struct inode *, __u32);
+extern int inotify_rm_watch(struct inotify_handle *, struct inotify_watch *);
+extern int inotify_rm_wd(struct inotify_handle *, __u32);
+extern void inotify_remove_watch_locked(struct inotify_handle *,
+                                        struct inotify_watch *);
+extern void get_inotify_watch(struct inotify_watch *);
+extern void put_inotify_watch(struct inotify_watch *);
+
 #else
 
 static inline void inotify_d_instantiate(struct dentry *dentry,
@@ -94,7 +140,8 @@ static inline void inotify_d_move(struct dentry *dentry)
 
 static inline void inotify_inode_queue_event(struct inode *inode,
                                              __u32 mask, __u32 cookie,
-                                             const char *filename)
+                                             const char *filename,
+                                             struct inode *n_inode)
 {
 }
 
@@ -117,6 +164,62 @@ static inline u32 inotify_get_cookie(void)
         return 0;
 }
 
+static inline struct inotify_handle *inotify_init(const struct inotify_operations *ops)
+{
+        return ERR_PTR(-EOPNOTSUPP);
+}
+
+static inline void inotify_init_watch(struct inotify_watch *watch)
+{
+}
+
+static inline void inotify_destroy(struct inotify_handle *ih)
+{
+}
+
+static inline __s32 inotify_find_watch(struct inotify_handle *ih, struct inode *inode,
+                                       struct inotify_watch **watchp)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline __s32 inotify_find_update_watch(struct inotify_handle *ih,
+                                              struct inode *inode, u32 mask)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline __s32 inotify_add_watch(struct inotify_handle *ih,
+                                      struct inotify_watch *watch,
+                                      struct inode *inode, __u32 mask)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int inotify_rm_watch(struct inotify_handle *ih,
+                                   struct inotify_watch *watch)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int inotify_rm_wd(struct inotify_handle *ih, __u32 wd)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline void inotify_remove_watch_locked(struct inotify_handle *ih,
+                                               struct inotify_watch *watch)
+{
+}
+
+static inline void get_inotify_watch(struct inotify_watch *watch)
+{
+}
+
+static inline void put_inotify_watch(struct inotify_watch *watch)
+{
+}
+
 #endif  /* CONFIG_INOTIFY */
 
 #endif  /* __KERNEL __ */
diff --git a/include/linux/input.h b/include/linux/input.h
index ce1a756c4c30..b32c2b6e53f6 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -15,6 +15,7 @@
 #else
 #include <sys/time.h>
 #include <sys/ioctl.h>
+#include <sys/types.h>
 #include <asm/types.h>
 #endif
 
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 2c08fdc2bdf7..9e0fefd7884a 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -2,7 +2,6 @@
 #ifndef _LINUX_INTERRUPT_H
 #define _LINUX_INTERRUPT_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/linkage.h>
 #include <linux/bitops.h>
diff --git a/include/linux/ipmi.h b/include/linux/ipmi.h
index 0a84b56935c2..5653b2f23b6a 100644
--- a/include/linux/ipmi.h
+++ b/include/linux/ipmi.h
@@ -36,7 +36,6 @@
 
 #include <linux/ipmi_msgdefs.h>
 #include <linux/compiler.h>
-#include <linux/device.h>
 
 /*
  * This file describes an interface to an IPMI driver.  You have to
@@ -210,6 +209,7 @@ struct kernel_ipmi_msg
  */
 #include <linux/list.h>
 #include <linux/module.h>
+#include <linux/device.h>
 
 #ifdef CONFIG_PROC_FS
 #include <linux/proc_fs.h>
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index 1263d8cb3c18..297853c841b4 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -1,7 +1,6 @@
 #ifndef _IPV6_H
 #define _IPV6_H
 
-#include <linux/config.h>
 #include <linux/in6.h>
 #include <asm/byteorder.h>
 
diff --git a/include/linux/irq.h b/include/linux/irq.h
index ee2a82a572f7..42c9cd562860 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -9,7 +9,6 @@
  * Thanks. --rmk
  */
 
-#include <linux/config.h>
 #include <linux/smp.h>
 
 #if !defined(CONFIG_S390)
diff --git a/include/linux/irq_cpustat.h b/include/linux/irq_cpustat.h
index af93505ec2ec..77e4bac29287 100644
--- a/include/linux/irq_cpustat.h
+++ b/include/linux/irq_cpustat.h
@@ -9,7 +9,6 @@
  * Keith Owens <kaos@ocs.com.au> July 2000.
  */
 
-#include <linux/config.h>
 
 /*
  * Simple wrappers reducing source bloat.  Define all irq_stat fields
diff --git a/include/linux/isapnp.h b/include/linux/isapnp.h
index 26c64c286f42..1e8728a9ee8a 100644
--- a/include/linux/isapnp.h
+++ b/include/linux/isapnp.h
@@ -22,7 +22,6 @@
 #ifndef LINUX_ISAPNP_H
 #define LINUX_ISAPNP_H
 
-#include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/pnp.h>
 
diff --git a/include/linux/isdn.h b/include/linux/isdn.h
index 53eaee96065b..62991148d5a5 100644
--- a/include/linux/isdn.h
+++ b/include/linux/isdn.h
@@ -146,7 +146,6 @@ typedef struct {
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
 #include <linux/major.h>
diff --git a/include/linux/isdn/tpam.h b/include/linux/isdn/tpam.h
index 9f65bea49d11..d18dd0dc570d 100644
--- a/include/linux/isdn/tpam.h
+++ b/include/linux/isdn/tpam.h
@@ -26,7 +26,6 @@
 #define _TPAM_H_
 
 #include <linux/types.h>
-#include <linux/pci.h>
 
 /* IOCTL commands */
 #define TPAM_CMD_DSPLOAD        0x0001
diff --git a/include/linux/isdn_ppp.h b/include/linux/isdn_ppp.h
index 26b00a76e135..8687a7dc0632 100644
--- a/include/linux/isdn_ppp.h
+++ b/include/linux/isdn_ppp.h
@@ -67,7 +67,6 @@ struct isdn_ppp_comp_data {
 #ifdef __KERNEL__
 
 
-#include <linux/config.h>
 
 #ifdef CONFIG_IPPP_FILTER
 #include <linux/filter.h>
diff --git a/include/linux/isdnif.h b/include/linux/isdnif.h
index 04e10f9f14f8..b9b5a684ed69 100644
--- a/include/linux/isdnif.h
+++ b/include/linux/isdnif.h
@@ -54,7 +54,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/skbuff.h>
 
 /***************************************************************************/
diff --git a/include/linux/jffs2.h b/include/linux/jffs2.h
index cf792bb3c726..c6f70660b371 100644
--- a/include/linux/jffs2.h
+++ b/include/linux/jffs2.h
@@ -65,6 +65,18 @@
 
 #define JFFS2_NODETYPE_SUMMARY (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 6)
 
+#define JFFS2_NODETYPE_XATTR (JFFS2_FEATURE_INCOMPAT | JFFS2_NODE_ACCURATE | 8)
+#define JFFS2_NODETYPE_XREF (JFFS2_FEATURE_INCOMPAT | JFFS2_NODE_ACCURATE | 9)
+
+/* XATTR Related */
+#define JFFS2_XPREFIX_USER              1       /* for "user." */
+#define JFFS2_XPREFIX_SECURITY          2       /* for "security." */
+#define JFFS2_XPREFIX_ACL_ACCESS        3       /* for "system.posix_acl_access" */
+#define JFFS2_XPREFIX_ACL_DEFAULT       4       /* for "system.posix_acl_default" */
+#define JFFS2_XPREFIX_TRUSTED           5       /* for "trusted.*" */
+
+#define JFFS2_ACL_VERSION               0x0001
+
 // Maybe later...
 //#define JFFS2_NODETYPE_CHECKPOINT (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 3)
 //#define JFFS2_NODETYPE_OPTIONS (JFFS2_FEATURE_RWCOMPAT_COPY | JFFS2_NODE_ACCURATE | 4)
@@ -82,11 +94,11 @@
 
 typedef struct {
         uint32_t v32;
-} __attribute__((packed))  jint32_t;
+} __attribute__((packed)) jint32_t;
 
 typedef struct {
         uint32_t m;
-} __attribute__((packed))  jmode_t;
+} __attribute__((packed)) jmode_t;
 
 typedef struct {
         uint16_t v16;
@@ -99,7 +111,7 @@ struct jffs2_unknown_node
         jint16_t nodetype;
         jint32_t totlen; /* So we can skip over nodes we don't grok */
         jint32_t hdr_crc;
-} __attribute__((packed));
+};
 
 struct jffs2_raw_dirent
 {
@@ -117,7 +129,7 @@ struct jffs2_raw_dirent
         jint32_t node_crc;
         jint32_t name_crc;
         uint8_t name[0];
-} __attribute__((packed));
+};
 
 /* The JFFS2 raw inode structure: Used for storage on physical media.  */
 /* The uid, gid, atime, mtime and ctime members could be longer, but
@@ -149,6 +161,32 @@ struct jffs2_raw_inode
         jint32_t data_crc;   /* CRC for the (compressed) data.  */
         jint32_t node_crc;   /* CRC for the raw inode (excluding data)  */
         uint8_t data[0];
+};
+
+struct jffs2_raw_xattr {
+        jint16_t magic;
+        jint16_t nodetype;      /* = JFFS2_NODETYPE_XATTR */
+        jint32_t totlen;
+        jint32_t hdr_crc;
+        jint32_t xid;           /* XATTR identifier number */
+        jint32_t version;
+        uint8_t xprefix;
+        uint8_t name_len;
+        jint16_t value_len;
+        jint32_t data_crc;
+        jint32_t node_crc;
+        uint8_t data[0];
+} __attribute__((packed));
+
+struct jffs2_raw_xref
+{
+        jint16_t magic;
+        jint16_t nodetype;      /* = JFFS2_NODETYPE_XREF */
+        jint32_t totlen;
+        jint32_t hdr_crc;
+        jint32_t ino;           /* inode number */
+        jint32_t xid;           /* XATTR identifier number */
+        jint32_t node_crc;
 } __attribute__((packed));
 
 struct jffs2_raw_summary
@@ -163,14 +201,22 @@ struct jffs2_raw_summary
         jint32_t sum_crc;       /* summary information crc */
         jint32_t node_crc;      /* node crc */
         jint32_t sum[0];        /* inode summary info */
-} __attribute__((packed));
+};
 
 union jffs2_node_union
 {
         struct jffs2_raw_inode i;
         struct jffs2_raw_dirent d;
+        struct jffs2_raw_xattr x;
+        struct jffs2_raw_xref r;
         struct jffs2_raw_summary s;
         struct jffs2_unknown_node u;
 };
 
+/* Data payload for device nodes. */
+union jffs2_device_node {
+        jint16_t old;
+        jint32_t new;
+};
+
 #endif /* __LINUX_JFFS2_H__ */
diff --git a/include/linux/joystick.h b/include/linux/joystick.h
index 5fd20ddd7ae3..e2d3a18af456 100644
--- a/include/linux/joystick.h
+++ b/include/linux/joystick.h
@@ -111,25 +111,25 @@ struct js_corr {
 #define JS_SET_ALL              8
 
 struct JS_DATA_TYPE {
-        int32_t buttons;
-        int32_t x;
-        int32_t y;
+        __s32 buttons;
+        __s32 x;
+        __s32 y;
 };
 
 struct JS_DATA_SAVE_TYPE_32 {
-        int32_t JS_TIMEOUT;
-        int32_t BUSY;
-        int32_t JS_EXPIRETIME;
-        int32_t JS_TIMELIMIT;
+        __s32 JS_TIMEOUT;
+        __s32 BUSY;
+        __s32 JS_EXPIRETIME;
+        __s32 JS_TIMELIMIT;
         struct JS_DATA_TYPE JS_SAVE;
         struct JS_DATA_TYPE JS_CORR;
 };
 
 struct JS_DATA_SAVE_TYPE_64 {
-        int32_t JS_TIMEOUT;
-        int32_t BUSY;
-        int64_t JS_EXPIRETIME;
-        int64_t JS_TIMELIMIT;
+        __s32 JS_TIMEOUT;
+        __s32 BUSY;
+        __s64 JS_EXPIRETIME;
+        __s64 JS_TIMELIMIT;
         struct JS_DATA_TYPE JS_SAVE;
         struct JS_DATA_TYPE JS_CORR;
 };
diff --git a/include/linux/kallsyms.h b/include/linux/kallsyms.h
index 9bbd04092365..54e2549f96ba 100644
--- a/include/linux/kallsyms.h
+++ b/include/linux/kallsyms.h
@@ -5,7 +5,6 @@
 #ifndef _LINUX_KALLSYMS_H
 #define _LINUX_KALLSYMS_H
 
-#include <linux/config.h>
 
 #define KSYM_NAME_LEN 127
 
diff --git a/include/linux/kernel_stat.h b/include/linux/kernel_stat.h
index b46249082cca..43e895f1cabe 100644
--- a/include/linux/kernel_stat.h
+++ b/include/linux/kernel_stat.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_KERNEL_STAT_H
 #define _LINUX_KERNEL_STAT_H
 
-#include <linux/config.h>
 #include <asm/irq.h>
 #include <linux/smp.h>
 #include <linux/threads.h>
diff --git a/include/linux/kmod.h b/include/linux/kmod.h
index e4a231549407..0db22a1ab474 100644
--- a/include/linux/kmod.h
+++ b/include/linux/kmod.h
@@ -20,7 +20,6 @@
  */
 
 #include <linux/stddef.h>
-#include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/compiler.h>
 
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
index 778adc0fa640..8bf6702da2a0 100644
--- a/include/linux/kprobes.h
+++ b/include/linux/kprobes.h
@@ -29,7 +29,6 @@
  *              <jkenisto@us.ibm.com>  and Prasanna S Panchamukhi
  *              <prasanna@in.ibm.com> added function-return probes.
  */
-#include <linux/config.h>
 #include <linux/list.h>
 #include <linux/notifier.h>
 #include <linux/smp.h>
diff --git a/include/linux/linkage.h b/include/linux/linkage.h
index c08c9983e840..932021f872d5 100644
--- a/include/linux/linkage.h
+++ b/include/linux/linkage.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_LINKAGE_H
 #define _LINUX_LINKAGE_H
 
-#include <linux/config.h>
 #include <asm/linkage.h>
 
 #ifdef __cplusplus
diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
index 6b2684763fc7..aa4fe905bb4d 100644
--- a/include/linux/lockd/lockd.h
+++ b/include/linux/lockd/lockd.h
@@ -11,7 +11,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/in.h>
 #include <linux/fs.h>
 #include <linux/kref.h>
diff --git a/include/linux/lockd/nlm.h b/include/linux/lockd/nlm.h
index 869b630cba24..d9d46e442538 100644
--- a/include/linux/lockd/nlm.h
+++ b/include/linux/lockd/nlm.h
@@ -9,7 +9,6 @@
 #ifndef LINUX_LOCKD_NLM_H
 #define LINUX_LOCKD_NLM_H
 
-#include <linux/config.h>
 
 /* Maximum file offset in file_lock.fl_end */
 # define NLM_OFFSET_MAX         ((s32) 0x7fffffff)
diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h
index f5fdca1d67e6..72440f0a443d 100644
--- a/include/linux/mempolicy.h
+++ b/include/linux/mempolicy.h
@@ -28,7 +28,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/mmzone.h>
 #include <linux/slab.h>
 #include <linux/rbtree.h>
diff --git a/include/linux/migrate.h b/include/linux/migrate.h
index ff0a64073ebc..6789c4940c9c 100644
--- a/include/linux/migrate.h
+++ b/include/linux/migrate.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_MIGRATE_H
 #define _LINUX_MIGRATE_H
 
-#include <linux/config.h>
 #include <linux/mm.h>
 
 #ifdef CONFIG_MIGRATION
diff --git a/include/linux/mii.h b/include/linux/mii.h
index 68f5a0f392dd..beddc6d3b0f6 100644
--- a/include/linux/mii.h
+++ b/include/linux/mii.h
@@ -9,7 +9,6 @@
 #define __LINUX_MII_H__
 
 #include <linux/types.h>
-#include <linux/if.h>
 
 /* Generic MII registers. */
 
@@ -136,6 +135,20 @@
 #define LPA_1000FULL            0x0800  /* Link partner 1000BASE-T full duplex */
 #define LPA_1000HALF            0x0400  /* Link partner 1000BASE-T half duplex */
 
+/* This structure is used in all SIOCxMIIxxx ioctl calls */
+struct mii_ioctl_data {
+        __u16           phy_id;
+        __u16           reg_num;
+        __u16           val_in;
+        __u16           val_out;
+};
+
+#ifdef __KERNEL__ 
+
+#include <linux/if.h>
+
+struct ethtool_cmd;
+
 struct mii_if_info {
         int phy_id;
         int advertising;
@@ -151,9 +164,6 @@ struct mii_if_info {
         void (*mdio_write) (struct net_device *dev, int phy_id, int location, int val);
 };
 
-struct ethtool_cmd;
-struct mii_ioctl_data;
-
 extern int mii_link_ok (struct mii_if_info *mii);
 extern int mii_nway_restart (struct mii_if_info *mii);
 extern int mii_ethtool_gset(struct mii_if_info *mii, struct ethtool_cmd *ecmd);
@@ -168,16 +178,6 @@ extern int generic_mii_ioctl(struct mii_if_info *mii_if,
                              unsigned int *duplex_changed);
 
 
-
-/* This structure is used in all SIOCxMIIxxx ioctl calls */
-struct mii_ioctl_data {
-        u16             phy_id;
-        u16             reg_num;
-        u16             val_in;
-        u16             val_out;
-};
-
-
 static inline struct mii_ioctl_data *if_mii(struct ifreq *rq)
 {
         return (struct mii_ioctl_data *) &rq->ifr_ifru;
@@ -235,5 +235,5 @@ static inline unsigned int mii_duplex (unsigned int duplex_lock,
         return 0;
 }
 
-
+#endif /* __KERNEL__ */
 #endif /* __LINUX_MII_H__ */
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 1154684209a4..e2fa375e478e 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -7,7 +7,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/gfp.h>
 #include <linux/list.h>
 #include <linux/mmzone.h>
diff --git a/include/linux/mman.h b/include/linux/mman.h
index 18a5689ef748..87920a0852a3 100644
--- a/include/linux/mman.h
+++ b/include/linux/mman.h
@@ -1,10 +1,6 @@
 #ifndef _LINUX_MMAN_H
 #define _LINUX_MMAN_H
 
-#include <linux/config.h>
-#include <linux/mm.h>
-
-#include <asm/atomic.h>
 #include <asm/mman.h>
 
 #define MREMAP_MAYMOVE  1
@@ -13,6 +9,12 @@
 #define OVERCOMMIT_GUESS                0
 #define OVERCOMMIT_ALWAYS               1
 #define OVERCOMMIT_NEVER                2
+
+#ifdef __KERNEL__
+#include <linux/mm.h>
+
+#include <asm/atomic.h>
+
 extern int sysctl_overcommit_memory;
 extern int sysctl_overcommit_ratio;
 extern atomic_t vm_committed_space;
@@ -63,5 +65,5 @@ calc_vm_flag_bits(unsigned long flags)
                _calc_vm_trans(flags, MAP_EXECUTABLE, VM_EXECUTABLE) |
                _calc_vm_trans(flags, MAP_LOCKED,     VM_LOCKED    );
 }
-
+#endif /* __KERNEL__ */
 #endif /* _LINUX_MMAN_H */
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 2d8337150493..9742e3c16222 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -4,7 +4,6 @@
 #ifdef __KERNEL__
 #ifndef __ASSEMBLY__
 
-#include <linux/config.h>
 #include <linux/spinlock.h>
 #include <linux/list.h>
 #include <linux/wait.h>
diff --git a/include/linux/module.h b/include/linux/module.h
index eaec13ddd667..c2d89e037af0 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -6,7 +6,6 @@
  * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
  * Rewritten again by Rusty Russell, 2002
  */
-#include <linux/config.h>
 #include <linux/sched.h>
 #include <linux/spinlock.h>
 #include <linux/list.h>
@@ -557,13 +556,4 @@ static inline void module_remove_driver(struct device_driver *driver)
 
 #define __MODULE_STRING(x) __stringify(x)
 
-/* Use symbol_get and symbol_put instead.  You'll thank me. */
-#define HAVE_INTER_MODULE
-extern void __deprecated inter_module_register(const char *,
-                struct module *, const void *);
-extern void __deprecated inter_module_unregister(const char *);
-extern const void * __deprecated inter_module_get_request(const char *,
-                const char *);
-extern void __deprecated inter_module_put(const char *);
-
 #endif /* _LINUX_MODULE_H */
diff --git a/include/linux/msg.h b/include/linux/msg.h
index 903e0ab8101f..acc7c174ff00 100644
--- a/include/linux/msg.h
+++ b/include/linux/msg.h
@@ -2,7 +2,6 @@
 #define _LINUX_MSG_H
 
 #include <linux/ipc.h>
-#include <linux/list.h>
 
 /* ipcs ctl commands */
 #define MSG_STAT 11
@@ -63,6 +62,7 @@ struct msginfo {
 #define MSGSEG (__MSGSEG <= 0xffff ? __MSGSEG : 0xffff)
 
 #ifdef __KERNEL__
+#include <linux/list.h>
 
 /* one msg_msg structure for each message */
 struct msg_msg {
diff --git a/include/linux/mtd/cfi.h b/include/linux/mtd/cfi.h
index 23a568910341..09bfae6938b3 100644
--- a/include/linux/mtd/cfi.h
+++ b/include/linux/mtd/cfi.h
@@ -7,7 +7,6 @@
 #ifndef __MTD_CFI_H__
 #define __MTD_CFI_H__
 
-#include <linux/config.h>
 #include <linux/delay.h>
 #include <linux/types.h>
 #include <linux/interrupt.h>
diff --git a/include/linux/mtd/inftl.h b/include/linux/mtd/inftl.h
index d7eaa40e5ab0..6977780e548f 100644
--- a/include/linux/mtd/inftl.h
+++ b/include/linux/mtd/inftl.h
@@ -46,7 +46,7 @@ struct INFTLrecord {
         unsigned int nb_blocks;         /* number of physical blocks */
         unsigned int nb_boot_blocks;    /* number of blocks used by the bios */
         struct erase_info instr;
-        struct nand_oobinfo oobinfo;
+        struct nand_ecclayout oobinfo;
 };
 
 int INFTL_mount(struct INFTLrecord *s);
diff --git a/include/linux/mtd/map.h b/include/linux/mtd/map.h
index 7dfd6e1fcde7..28d461d862bd 100644
--- a/include/linux/mtd/map.h
+++ b/include/linux/mtd/map.h
@@ -5,7 +5,6 @@
 #ifndef __LINUX_MTD_MAP_H__
 #define __LINUX_MTD_MAP_H__
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/list.h>
 #include <linux/string.h>
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
index b6f2fdae65c6..9b7a2b525d63 100644
--- a/include/linux/mtd/mtd.h
+++ b/include/linux/mtd/mtd.h
@@ -13,7 +13,6 @@
 #error This is a kernel header. Perhaps include mtd-user.h instead?
 #endif
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/uio.h>
@@ -56,18 +55,69 @@ struct mtd_erase_region_info {
         u_int32_t numblocks;            /* Number of blocks of erasesize in this region */
 };
 
+/*
+ * oob operation modes
+ *
+ * MTD_OOB_PLACE:       oob data are placed at the given offset
+ * MTD_OOB_AUTO:        oob data are automatically placed at the free areas
+ *                      which are defined by the ecclayout
+ * MTD_OOB_RAW:         mode to read raw data+oob in one chunk. The oob data
+ *                      is inserted into the data. Thats a raw image of the
+ *                      flash contents.
+ */
+typedef enum {
+        MTD_OOB_PLACE,
+        MTD_OOB_AUTO,
+        MTD_OOB_RAW,
+} mtd_oob_mode_t;
+
+/**
+ * struct mtd_oob_ops - oob operation operands
+ * @mode:       operation mode
+ *
+ * @len:        number of bytes to write/read. When a data buffer is given
+ *              (datbuf != NULL) this is the number of data bytes. When
+ +              no data buffer is available this is the number of oob bytes.
+ *
+ * @retlen:     number of bytes written/read. When a data buffer is given
+ *              (datbuf != NULL) this is the number of data bytes. When
+ +              no data buffer is available this is the number of oob bytes.
+ *
+ * @ooblen:     number of oob bytes per page
+ * @ooboffs:    offset of oob data in the oob area (only relevant when
+ *              mode = MTD_OOB_PLACE)
+ * @datbuf:     data buffer - if NULL only oob data are read/written
+ * @oobbuf:     oob data buffer
+ */
+struct mtd_oob_ops {
+        mtd_oob_mode_t  mode;
+        size_t          len;
+        size_t          retlen;
+        size_t          ooblen;
+        uint32_t        ooboffs;
+        uint8_t         *datbuf;
+        uint8_t         *oobbuf;
+};
+
 struct mtd_info {
         u_char type;
         u_int32_t flags;
         u_int32_t size;  // Total size of the MTD
 
-        /* "Major" erase size for the device. Naïve users may take this
+        /* "Major" erase size for the device. Naïve users may take this
          * to be the only erase size available, or may use the more detailed
          * information below if they desire
          */
         u_int32_t erasesize;
+        /* Minimal writable flash unit size. In case of NOR flash it is 1 (even
+         * though individual bits can be cleared), in case of NAND flash it is
+         * one NAND page (or half, or one-fourths of it), in case of ECC-ed NOR
+         * it is of ECC block size, etc. It is illegal to have writesize = 0.
+         * Any driver registering a struct mtd_info must ensure a writesize of
+         * 1 or larger.
+         */
+        u_int32_t writesize;
 
-        u_int32_t oobblock;  // Size of OOB blocks (e.g. 512)
         u_int32_t oobsize;   // Amount of OOB data per block (e.g. 16)
         u_int32_t ecctype;
         u_int32_t eccsize;
@@ -79,7 +129,6 @@ struct mtd_info {
          * MTD_PROGRAM_REGIONS flag is set.
          * (Maybe we should have an union for those?)
          */
-#define MTD_PROGREGION_SIZE(mtd)  (mtd)->oobblock
 #define MTD_PROGREGION_CTRLMODE_VALID(mtd)  (mtd)->oobsize
 #define MTD_PROGREGION_CTRLMODE_INVALID(mtd)  (mtd)->ecctype
 
@@ -87,9 +136,8 @@ struct mtd_info {
         char *name;
         int index;
 
-        // oobinfo is a nand_oobinfo structure, which can be set by iotcl (MEMSETOOBINFO)
-        struct nand_oobinfo oobinfo;
-        u_int32_t oobavail;  // Number of bytes in OOB area available for fs
+        /* ecc layout structure pointer - read only ! */
+        struct nand_ecclayout *ecclayout;
 
         /* Data for variable erase regions. If numeraseregions is zero,
          * it means that the whole device has erasesize as given above.
@@ -112,11 +160,10 @@ struct mtd_info {
         int (*read) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
         int (*write) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf);
 
-        int (*read_ecc) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf, u_char *eccbuf, struct nand_oobinfo *oobsel);
-        int (*write_ecc) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf, u_char *eccbuf, struct nand_oobinfo *oobsel);
-
-        int (*read_oob) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
-        int (*write_oob) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf);
+        int (*read_oob) (struct mtd_info *mtd, loff_t from,
+                         struct mtd_oob_ops *ops);
+        int (*write_oob) (struct mtd_info *mtd, loff_t to,
+                         struct mtd_oob_ops *ops);
 
         /*
          * Methods to access the protection register area, present in some
@@ -130,17 +177,11 @@ struct mtd_info {
         int (*write_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
         int (*lock_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len);
 
-        /* kvec-based read/write methods. We need these especially for NAND flash,
-           with its limited number of write cycles per erase.
+        /* kvec-based read/write methods.
            NB: The 'count' parameter is the number of _vectors_, each of
            which contains an (ofs, len) tuple.
         */
-        int (*readv) (struct mtd_info *mtd, struct kvec *vecs, unsigned long count, loff_t from, size_t *retlen);
-        int (*readv_ecc) (struct mtd_info *mtd, struct kvec *vecs, unsigned long count, loff_t from,
-                size_t *retlen, u_char *eccbuf, struct nand_oobinfo *oobsel);
         int (*writev) (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count, loff_t to, size_t *retlen);
-        int (*writev_ecc) (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count, loff_t to,
-                size_t *retlen, u_char *eccbuf, struct nand_oobinfo *oobsel);
 
         /* Sync */
         void (*sync) (struct mtd_info *mtd);
@@ -159,6 +200,9 @@ struct mtd_info {
 
         struct notifier_block reboot_notifier;  /* default mode before reboot */
 
+        /* ECC status information */
+        struct mtd_ecc_stats ecc_stats;
+
         void *priv;
 
         struct module *owner;
@@ -192,20 +236,6 @@ int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
 int default_mtd_readv(struct mtd_info *mtd, struct kvec *vecs,
                       unsigned long count, loff_t from, size_t *retlen);
 
-#define MTD_ERASE(mtd, args...) (*(mtd->erase))(mtd, args)
-#define MTD_POINT(mtd, a,b,c,d) (*(mtd->point))(mtd, a,b,c, (u_char **)(d))
-#define MTD_UNPOINT(mtd, arg) (*(mtd->unpoint))(mtd, (u_char *)arg)
-#define MTD_READ(mtd, args...) (*(mtd->read))(mtd, args)
-#define MTD_WRITE(mtd, args...) (*(mtd->write))(mtd, args)
-#define MTD_READV(mtd, args...) (*(mtd->readv))(mtd, args)
-#define MTD_WRITEV(mtd, args...) (*(mtd->writev))(mtd, args)
-#define MTD_READECC(mtd, args...) (*(mtd->read_ecc))(mtd, args)
-#define MTD_WRITEECC(mtd, args...) (*(mtd->write_ecc))(mtd, args)
-#define MTD_READOOB(mtd, args...) (*(mtd->read_oob))(mtd, args)
-#define MTD_WRITEOOB(mtd, args...) (*(mtd->write_oob))(mtd, args)
-#define MTD_SYNC(mtd) do { if (mtd->sync) (*(mtd->sync))(mtd);  } while (0)
-
-
 #ifdef CONFIG_MTD_PARTITIONS
 void mtd_erase_callback(struct erase_info *instr);
 #else
@@ -226,7 +256,7 @@ static inline void mtd_erase_callback(struct erase_info *instr)
 
 #ifdef CONFIG_MTD_DEBUG
 #define DEBUG(n, args...)                               \
-        do {                                            \
+        do {                                            \
                 if (n <= CONFIG_MTD_DEBUG_VERBOSE)      \
                         printk(KERN_INFO args);         \
         } while(0)
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index da5e67b3fc70..66559272ebcb 100644
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -11,52 +11,15 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- *  Info:
- *   Contains standard defines and IDs for NAND flash devices
+ * Info:
+ *      Contains standard defines and IDs for NAND flash devices
  *
- *  Changelog:
- *   01-31-2000 DMW     Created
- *   09-18-2000 SJH     Moved structure out of the Disk-On-Chip drivers
- *                      so it can be used by other NAND flash device
- *                      drivers. I also changed the copyright since none
- *                      of the original contents of this file are specific
- *                      to DoC devices. David can whack me with a baseball
- *                      bat later if I did something naughty.
- *   10-11-2000 SJH     Added private NAND flash structure for driver
- *   10-24-2000 SJH     Added prototype for 'nand_scan' function
- *   10-29-2001 TG      changed nand_chip structure to support
- *                      hardwarespecific function for accessing control lines
- *   02-21-2002 TG      added support for different read/write adress and
- *                      ready/busy line access function
- *   02-26-2002 TG      added chip_delay to nand_chip structure to optimize
- *                      command delay times for different chips
- *   04-28-2002 TG      OOB config defines moved from nand.c to avoid duplicate
- *                      defines in jffs2/wbuf.c
- *   08-07-2002 TG      forced bad block location to byte 5 of OOB, even if
- *                      CONFIG_MTD_NAND_ECC_JFFS2 is not set
- *   08-10-2002 TG      extensions to nand_chip structure to support HW-ECC
- *
- *   08-29-2002 tglx    nand_chip structure: data_poi for selecting
- *                      internal / fs-driver buffer
- *                      support for 6byte/512byte hardware ECC
- *                      read_ecc, write_ecc extended for different oob-layout
- *                      oob layout selections: NAND_NONE_OOB, NAND_JFFS2_OOB,
- *                      NAND_YAFFS_OOB
- *  11-25-2002 tglx     Added Manufacturer code FUJITSU, NATIONAL
- *                      Split manufacturer and device ID structures
- *
- *  02-08-2004 tglx     added option field to nand structure for chip anomalities
- *  05-25-2004 tglx     added bad block table support, ST-MICRO manufacturer id
- *                      update of nand_chip structure description
- *  01-17-2005 dmarlin  added extended commands for AG-AND device and added option
- *                      for BBT_AUTO_REFRESH.
- *  01-20-2005 dmarlin  added optional pointer to hardware specific callback for
- *                      extra error status checks.
+ * Changelog:
+ *      See git changelog.
  */
 #ifndef __LINUX_MTD_NAND_H
 #define __LINUX_MTD_NAND_H
 
-#include <linux/config.h>
 #include <linux/wait.h>
 #include <linux/spinlock.h>
 #include <linux/mtd/mtd.h>
@@ -67,10 +30,6 @@ extern int nand_scan (struct mtd_info *mtd, int max_chips);
 /* Free resources held by the NAND device */
 extern void nand_release (struct mtd_info *mtd);
 
-/* Read raw data from the device without ECC */
-extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len, size_t ooblen);
-
-
 /* The maximum number of NAND chips in an array */
 #define NAND_MAX_CHIPS          8
 
@@ -79,44 +38,45 @@ extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_
  * adjust this accordingly.
  */
 #define NAND_MAX_OOBSIZE        64
+#define NAND_MAX_PAGESIZE       2048
 
 /*
  * Constants for hardware specific CLE/ALE/NCE function
-*/
+ *
+ * These are bits which can be or'ed to set/clear multiple
+ * bits in one go.
+ */
 /* Select the chip by setting nCE to low */
-#define NAND_CTL_SETNCE         1
-/* Deselect the chip by setting nCE to high */
-#define NAND_CTL_CLRNCE         2
+#define NAND_NCE                0x01
 /* Select the command latch by setting CLE to high */
-#define NAND_CTL_SETCLE         3
-/* Deselect the command latch by setting CLE to low */
-#define NAND_CTL_CLRCLE         4
+#define NAND_CLE                0x02
 /* Select the address latch by setting ALE to high */
-#define NAND_CTL_SETALE         5
-/* Deselect the address latch by setting ALE to low */
-#define NAND_CTL_CLRALE         6
-/* Set write protection by setting WP to high. Not used! */
-#define NAND_CTL_SETWP          7
-/* Clear write protection by setting WP to low. Not used! */
-#define NAND_CTL_CLRWP          8
+#define NAND_ALE                0x04
+
+#define NAND_CTRL_CLE           (NAND_NCE | NAND_CLE)
+#define NAND_CTRL_ALE           (NAND_NCE | NAND_ALE)
+#define NAND_CTRL_CHANGE        0x80
 
 /*
  * Standard NAND flash commands
  */
 #define NAND_CMD_READ0          0
 #define NAND_CMD_READ1          1
+#define NAND_CMD_RNDOUT         5
 #define NAND_CMD_PAGEPROG       0x10
 #define NAND_CMD_READOOB        0x50
 #define NAND_CMD_ERASE1         0x60
 #define NAND_CMD_STATUS         0x70
 #define NAND_CMD_STATUS_MULTI   0x71
 #define NAND_CMD_SEQIN          0x80
+#define NAND_CMD_RNDIN          0x85
 #define NAND_CMD_READID         0x90
 #define NAND_CMD_ERASE2         0xd0
 #define NAND_CMD_RESET          0xff
 
 /* Extended commands for large page devices */
 #define NAND_CMD_READSTART      0x30
+#define NAND_CMD_RNDOUTSTART    0xE0
 #define NAND_CMD_CACHEDPROG     0x15
 
 /* Extended commands for AG-AND device */
@@ -138,6 +98,8 @@ extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_
 #define NAND_CMD_STATUS_RESET   0x7f
 #define NAND_CMD_STATUS_CLEAR   0xff
 
+#define NAND_CMD_NONE           -1
+
 /* Status bits */
 #define NAND_STATUS_FAIL        0x01
 #define NAND_STATUS_FAIL_N1     0x02
@@ -148,21 +110,12 @@ extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_
 /*
  * Constants for ECC_MODES
  */
-
-/* No ECC. Usage is not recommended ! */
-#define NAND_ECC_NONE           0
-/* Software ECC 3 byte ECC per 256 Byte data */
-#define NAND_ECC_SOFT           1
-/* Hardware ECC 3 byte ECC per 256 Byte data */
-#define NAND_ECC_HW3_256        2
-/* Hardware ECC 3 byte ECC per 512 Byte data */
-#define NAND_ECC_HW3_512        3
-/* Hardware ECC 3 byte ECC per 512 Byte data */
-#define NAND_ECC_HW6_512        4
-/* Hardware ECC 8 byte ECC per 512 Byte data */
-#define NAND_ECC_HW8_512        6
-/* Hardware ECC 12 byte ECC per 2048 Byte data */
-#define NAND_ECC_HW12_2048      7
+typedef enum {
+        NAND_ECC_NONE,
+        NAND_ECC_SOFT,
+        NAND_ECC_HW,
+        NAND_ECC_HW_SYNDROME,
+} nand_ecc_modes_t;
 
 /*
  * Constants for Hardware ECC
@@ -201,6 +154,10 @@ extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_
  * bits from adjacent blocks from 'leaking' in altering data.
  * This happens with the Renesas AG-AND chips, possibly others.  */
 #define BBT_AUTO_REFRESH        0x00000080
+/* Chip does not require ready check on read. True
+ * for all large page devices, as they do not support
+ * autoincrement.*/
+#define NAND_NO_READRDY         0x00000100
 
 /* Options valid for Samsung large page devices */
 #define NAND_SAMSUNG_LP_OPTIONS \
@@ -219,18 +176,12 @@ extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_
 /* Use a flash based bad block table. This option is passed to the
  * default bad block table function. */
 #define NAND_USE_FLASH_BBT      0x00010000
-/* The hw ecc generator provides a syndrome instead a ecc value on read
- * This can only work if we have the ecc bytes directly behind the
- * data bytes. Applies for DOC and AG-AND Renesas HW Reed Solomon generators */
-#define NAND_HWECC_SYNDROME     0x00020000
 /* This option skips the bbt scan during initialization. */
-#define NAND_SKIP_BBTSCAN       0x00040000
+#define NAND_SKIP_BBTSCAN       0x00020000
 
 /* Options set by nand scan */
-/* Nand scan has allocated oob_buf */
-#define NAND_OOBBUF_ALLOC       0x40000000
-/* Nand scan has allocated data_buf */
-#define NAND_DATABUF_ALLOC      0x80000000
+/* Nand scan has allocated controller struct */
+#define NAND_CONTROLLER_ALLOC   0x80000000
 
 
 /*
@@ -264,45 +215,102 @@ struct nand_hw_control {
 };
 
 /**
+ * struct nand_ecc_ctrl - Control structure for ecc
+ * @mode:       ecc mode
+ * @steps:      number of ecc steps per page
+ * @size:       data bytes per ecc step
+ * @bytes:      ecc bytes per step
+ * @total:      total number of ecc bytes per page
+ * @prepad:     padding information for syndrome based ecc generators
+ * @postpad:    padding information for syndrome based ecc generators
+ * @hwctl:      function to control hardware ecc generator. Must only
+ *              be provided if an hardware ECC is available
+ * @calculate:  function for ecc calculation or readback from ecc hardware
+ * @correct:    function for ecc correction, matching to ecc generator (sw/hw)
+ * @read_page:  function to read a page according to the ecc generator requirements
+ * @write_page: function to write a page according to the ecc generator requirements
+ */
+struct nand_ecc_ctrl {
+        nand_ecc_modes_t        mode;
+        int                     steps;
+        int                     size;
+        int                     bytes;
+        int                     total;
+        int                     prepad;
+        int                     postpad;
+        struct nand_ecclayout   *layout;
+        void                    (*hwctl)(struct mtd_info *mtd, int mode);
+        int                     (*calculate)(struct mtd_info *mtd,
+                                             const uint8_t *dat,
+                                             uint8_t *ecc_code);
+        int                     (*correct)(struct mtd_info *mtd, uint8_t *dat,
+                                           uint8_t *read_ecc,
+                                           uint8_t *calc_ecc);
+        int                     (*read_page)(struct mtd_info *mtd,
+                                             struct nand_chip *chip,
+                                             uint8_t *buf);
+        void                    (*write_page)(struct mtd_info *mtd,
+                                              struct nand_chip *chip,
+                                              const uint8_t *buf);
+        int                     (*read_oob)(struct mtd_info *mtd,
+                                            struct nand_chip *chip,
+                                            int page,
+                                            int sndcmd);
+        int                     (*write_oob)(struct mtd_info *mtd,
+                                             struct nand_chip *chip,
+                                             int page);
+};
+
+/**
+ * struct nand_buffers - buffer structure for read/write
+ * @ecccalc:    buffer for calculated ecc
+ * @ecccode:    buffer for ecc read from flash
+ * @oobwbuf:    buffer for write oob data
+ * @databuf:    buffer for data - dynamically sized
+ * @oobrbuf:    buffer to read oob data
+ *
+ * Do not change the order of buffers. databuf and oobrbuf must be in
+ * consecutive order.
+ */
+struct nand_buffers {
+        uint8_t ecccalc[NAND_MAX_OOBSIZE];
+        uint8_t ecccode[NAND_MAX_OOBSIZE];
+        uint8_t oobwbuf[NAND_MAX_OOBSIZE];
+        uint8_t databuf[NAND_MAX_PAGESIZE];
+        uint8_t oobrbuf[NAND_MAX_OOBSIZE];
+};
+
+/**
  * struct nand_chip - NAND Private Flash Chip Data
  * @IO_ADDR_R:          [BOARDSPECIFIC] address to read the 8 I/O lines of the flash device
  * @IO_ADDR_W:          [BOARDSPECIFIC] address to write the 8 I/O lines of the flash device
  * @read_byte:          [REPLACEABLE] read one byte from the chip
- * @write_byte:         [REPLACEABLE] write one byte to the chip
  * @read_word:          [REPLACEABLE] read one word from the chip
- * @write_word:         [REPLACEABLE] write one word to the chip
  * @write_buf:          [REPLACEABLE] write data from the buffer to the chip
  * @read_buf:           [REPLACEABLE] read data from the chip into the buffer
  * @verify_buf:         [REPLACEABLE] verify buffer contents against the chip data
  * @select_chip:        [REPLACEABLE] select chip nr
  * @block_bad:          [REPLACEABLE] check, if the block is bad
  * @block_markbad:      [REPLACEABLE] mark the block bad
- * @hwcontrol:          [BOARDSPECIFIC] hardwarespecific function for accesing control-lines
+ * @cmd_ctrl:           [BOARDSPECIFIC] hardwarespecific funtion for controlling
+ *                      ALE/CLE/nCE. Also used to write command and address
  * @dev_ready:          [BOARDSPECIFIC] hardwarespecific function for accesing device ready/busy line
  *                      If set to NULL no access to ready/busy is available and the ready/busy information
  *                      is read from the chip status register
  * @cmdfunc:            [REPLACEABLE] hardwarespecific function for writing commands to the chip
  * @waitfunc:           [REPLACEABLE] hardwarespecific function for wait on ready
- * @calculate_ecc:      [REPLACEABLE] function for ecc calculation or readback from ecc hardware
- * @correct_data:       [REPLACEABLE] function for ecc correction, matching to ecc generator (sw/hw)
- * @enable_hwecc:       [BOARDSPECIFIC] function to enable (reset) hardware ecc generator. Must only
- *                      be provided if a hardware ECC is available
+ * @ecc:                [BOARDSPECIFIC] ecc control ctructure
  * @erase_cmd:          [INTERN] erase command write function, selectable due to AND support
  * @scan_bbt:           [REPLACEABLE] function to scan bad block table
- * @eccmode:            [BOARDSPECIFIC] mode of ecc, see defines
- * @eccsize:            [INTERN] databytes used per ecc-calculation
- * @eccbytes:           [INTERN] number of ecc bytes per ecc-calculation step
- * @eccsteps:           [INTERN] number of ecc calculation steps per page
  * @chip_delay:         [BOARDSPECIFIC] chip dependent delay for transfering data from array to read regs (tR)
- * @chip_lock:          [INTERN] spinlock used to protect access to this structure and the chip
  * @wq:                 [INTERN] wait queue to sleep on if a NAND operation is in progress
- * @state:              [INTERN] the current state of the NAND device
+ * @state:              [INTERN] the current state of the NAND device
  * @page_shift:         [INTERN] number of address bits in a page (column address bits)
  * @phys_erase_shift:   [INTERN] number of address bits in a physical eraseblock
  * @bbt_erase_shift:    [INTERN] number of address bits in a bbt entry
  * @chip_shift:         [INTERN] number of address bits in one chip
- * @data_buf:           [INTERN] internal buffer for one page + oob
- * @oob_buf:            [INTERN] oob buffer for one eraseblock
+ * @datbuf:             [INTERN] internal buffer for one page + oob
+ * @oobbuf:             [INTERN] oob buffer for one eraseblock
  * @oobdirty:           [INTERN] indicates that oob_buf must be reinitialized
  * @data_poi:           [INTERN] pointer to a data buffer
  * @options:            [BOARDSPECIFIC] various chip options. They can partly be set to inform nand_scan about
@@ -312,12 +320,13 @@ struct nand_hw_control {
  * @chipsize:           [INTERN] the size of one chip for multichip arrays
  * @pagemask:           [INTERN] page number mask = number of (pages / chip) - 1
  * @pagebuf:            [INTERN] holds the pagenumber which is currently in data_buf
- * @autooob:            [REPLACEABLE] the default (auto)placement scheme
+ * @ecclayout:          [REPLACEABLE] the default ecc placement scheme
  * @bbt:                [INTERN] bad block table pointer
  * @bbt_td:             [REPLACEABLE] bad block table descriptor for flash lookup
  * @bbt_md:             [REPLACEABLE] bad block table mirror descriptor
  * @badblock_pattern:   [REPLACEABLE] bad block scan pattern used for initial bad block scan
- * @controller:         [OPTIONAL] a pointer to a hardware controller structure which is shared among multiple independend devices
+ * @controller:         [REPLACEABLE] a pointer to a hardware controller structure
+ *                      which is shared among multiple independend devices
  * @priv:               [OPTIONAL] pointer to private chip date
  * @errstat:            [OPTIONAL] hardware specific function to perform additional error status checks
  *                      (determine if errors are correctable)
@@ -325,58 +334,57 @@ struct nand_hw_control {
 
 struct nand_chip {
         void  __iomem   *IO_ADDR_R;
-        void  __iomem   *IO_ADDR_W;
+        void  __iomem   *IO_ADDR_W;
 
-        u_char          (*read_byte)(struct mtd_info *mtd);
-        void            (*write_byte)(struct mtd_info *mtd, u_char byte);
+        uint8_t         (*read_byte)(struct mtd_info *mtd);
         u16             (*read_word)(struct mtd_info *mtd);
-        void            (*write_word)(struct mtd_info *mtd, u16 word);
-
-        void            (*write_buf)(struct mtd_info *mtd, const u_char *buf, int len);
-        void            (*read_buf)(struct mtd_info *mtd, u_char *buf, int len);
-        int             (*verify_buf)(struct mtd_info *mtd, const u_char *buf, int len);
+        void            (*write_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
+        void            (*read_buf)(struct mtd_info *mtd, uint8_t *buf, int len);
+        int             (*verify_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
         void            (*select_chip)(struct mtd_info *mtd, int chip);
         int             (*block_bad)(struct mtd_info *mtd, loff_t ofs, int getchip);
         int             (*block_markbad)(struct mtd_info *mtd, loff_t ofs);
-        void            (*hwcontrol)(struct mtd_info *mtd, int cmd);
-        int             (*dev_ready)(struct mtd_info *mtd);
-        void            (*cmdfunc)(struct mtd_info *mtd, unsigned command, int column, int page_addr);
-        int             (*waitfunc)(struct mtd_info *mtd, struct nand_chip *this, int state);
-        int             (*calculate_ecc)(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code);
-        int             (*correct_data)(struct mtd_info *mtd, u_char *dat, u_char *read_ecc, u_char *calc_ecc);
-        void            (*enable_hwecc)(struct mtd_info *mtd, int mode);
+        void            (*cmd_ctrl)(struct mtd_info *mtd, int dat,
+                                    unsigned int ctrl);
+        int             (*dev_ready)(struct mtd_info *mtd);
+        void            (*cmdfunc)(struct mtd_info *mtd, unsigned command, int column, int page_addr);
+        int             (*waitfunc)(struct mtd_info *mtd, struct nand_chip *this);
         void            (*erase_cmd)(struct mtd_info *mtd, int page);
         int             (*scan_bbt)(struct mtd_info *mtd);
-        int             eccmode;
-        int             eccsize;
-        int             eccbytes;
-        int             eccsteps;
-        int             chip_delay;
-        spinlock_t      chip_lock;
-        wait_queue_head_t wq;
-        nand_state_t    state;
-        int             page_shift;
+        int             (*errstat)(struct mtd_info *mtd, struct nand_chip *this, int state, int status, int page);
+
+        int             chip_delay;
+        unsigned int    options;
+
+        int             page_shift;
         int             phys_erase_shift;
         int             bbt_erase_shift;
         int             chip_shift;
-        u_char          *data_buf;
-        u_char          *oob_buf;
-        int             oobdirty;
-        u_char          *data_poi;
-        unsigned int    options;
-        int             badblockpos;
         int             numchips;
         unsigned long   chipsize;
         int             pagemask;
         int             pagebuf;
-        struct nand_oobinfo     *autooob;
+        int             badblockpos;
+
+        nand_state_t    state;
+
+        uint8_t         *oob_poi;
+        struct nand_hw_control  *controller;
+        struct nand_ecclayout   *ecclayout;
+
+        struct nand_ecc_ctrl ecc;
+        struct nand_buffers buffers;
+        struct nand_hw_control hwcontrol;
+
+        struct mtd_oob_ops ops;
+
         uint8_t         *bbt;
         struct nand_bbt_descr   *bbt_td;
         struct nand_bbt_descr   *bbt_md;
+
         struct nand_bbt_descr   *badblock_pattern;
-        struct nand_hw_control  *controller;
+
         void            *priv;
-        int             (*errstat)(struct mtd_info *mtd, struct nand_chip *this, int state, int status, int page);
 };
 
 /*
@@ -388,19 +396,19 @@ struct nand_chip {
 #define NAND_MFR_NATIONAL       0x8f
 #define NAND_MFR_RENESAS        0x07
 #define NAND_MFR_STMICRO        0x20
-#define NAND_MFR_HYNIX          0xad
+#define NAND_MFR_HYNIX          0xad
 
 /**
  * struct nand_flash_dev - NAND Flash Device ID Structure
  *
- * @name:       Identify the device type
- * @id:         device ID code
- * @pagesize:   Pagesize in bytes. Either 256 or 512 or 0
+ * @name:       Identify the device type
+ * @id:         device ID code
+ * @pagesize:   Pagesize in bytes. Either 256 or 512 or 0
  *              If the pagesize is 0, then the real pagesize
  *              and the eraseize are determined from the
  *              extended id bytes in the chip
- * @erasesize:  Size of an erase block in the flash device.
- * @chipsize:   Total chipsize in Mega Bytes
+ * @erasesize:  Size of an erase block in the flash device.
+ * @chipsize:   Total chipsize in Mega Bytes
  * @options:    Bitfield to store chip relevant options
  */
 struct nand_flash_dev {
@@ -415,7 +423,7 @@ struct nand_flash_dev {
 /**
  * struct nand_manufacturers - NAND Flash Manufacturer ID Structure
  * @name:       Manufacturer name
- * @id:         manufacturer ID code of device.
+ * @id:         manufacturer ID code of device.
 */
 struct nand_manufacturers {
         int id;
@@ -455,7 +463,7 @@ struct nand_bbt_descr {
         int     veroffs;
         uint8_t version[NAND_MAX_CHIPS];
         int     len;
-        int     maxblocks;
+        int     maxblocks;
         int     reserved_block_code;
         uint8_t *pattern;
 };
@@ -494,14 +502,14 @@ struct nand_bbt_descr {
 /* The maximum number of blocks to scan for a bbt */
 #define NAND_BBT_SCAN_MAXBLOCKS 4
 
-extern int nand_scan_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd);
-extern int nand_update_bbt (struct mtd_info *mtd, loff_t offs);
-extern int nand_default_bbt (struct mtd_info *mtd);
-extern int nand_isbad_bbt (struct mtd_info *mtd, loff_t offs, int allowbbt);
-extern int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbbt);
-extern int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
-                             size_t * retlen, u_char * buf, u_char * oob_buf,
-                             struct nand_oobinfo *oobsel, int flags);
+extern int nand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd);
+extern int nand_update_bbt(struct mtd_info *mtd, loff_t offs);
+extern int nand_default_bbt(struct mtd_info *mtd);
+extern int nand_isbad_bbt(struct mtd_info *mtd, loff_t offs, int allowbbt);
+extern int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr,
+                           int allowbbt);
+extern int nand_do_read(struct mtd_info *mtd, loff_t from, size_t len,
+                        size_t * retlen, uint8_t * buf);
 
 /*
 * Constants for oob configuration
@@ -509,4 +517,53 @@ extern int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
 #define NAND_SMALL_BADBLOCK_POS         5
 #define NAND_LARGE_BADBLOCK_POS         0
 
+/**
+ * struct platform_nand_chip - chip level device structure
+ *
+ * @nr_chips:           max. number of chips to scan for
+ * @chip_offs:          chip number offset
+ * @nr_partitions:      number of partitions pointed to by partitions (or zero)
+ * @partitions:         mtd partition list
+ * @chip_delay:         R/B delay value in us
+ * @options:            Option flags, e.g. 16bit buswidth
+ * @ecclayout:          ecc layout info structure
+ * @priv:               hardware controller specific settings
+ */
+struct platform_nand_chip {
+        int                     nr_chips;
+        int                     chip_offset;
+        int                     nr_partitions;
+        struct mtd_partition    *partitions;
+        struct nand_ecclayout   *ecclayout;
+        int                     chip_delay;
+        unsigned int            options;
+        void                    *priv;
+};
+
+/**
+ * struct platform_nand_ctrl - controller level device structure
+ *
+ * @hwcontrol:          platform specific hardware control structure
+ * @dev_ready:          platform specific function to read ready/busy pin
+ * @select_chip:        platform specific chip select function
+ * @priv_data:          private data to transport driver specific settings
+ *
+ * All fields are optional and depend on the hardware driver requirements
+ */
+struct platform_nand_ctrl {
+        void            (*hwcontrol)(struct mtd_info *mtd, int cmd);
+        int             (*dev_ready)(struct mtd_info *mtd);
+        void            (*select_chip)(struct mtd_info *mtd, int chip);
+        void            *priv;
+};
+
+/* Some helpers to access the data structures */
+static inline
+struct platform_nand_chip *get_platform_nandchip(struct mtd_info *mtd)
+{
+        struct nand_chip *chip = mtd->priv;
+
+        return chip->priv;
+}
+
 #endif /* __LINUX_MTD_NAND_H */
diff --git a/include/linux/mtd/ndfc.h b/include/linux/mtd/ndfc.h
new file mode 100644
index 000000000000..d0558a982628
--- /dev/null
+++ b/include/linux/mtd/ndfc.h
@@ -0,0 +1,67 @@
+/*
+ *  linux/include/linux/mtd/ndfc.h
+ *
+ *  Copyright (c) 2006 Thomas Gleixner <tglx@linutronix.de>
+ *
+ * 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.
+ *
+ *  Info:
+ *   Contains defines, datastructures for ndfc nand controller
+ *
+ */
+#ifndef __LINUX_MTD_NDFC_H
+#define __LINUX_MTD_NDFC_H
+
+/* NDFC Register definitions */
+#define NDFC_CMD                0x00
+#define NDFC_ALE                0x04
+#define NDFC_DATA               0x08
+#define NDFC_ECC                0x10
+#define NDFC_BCFG0              0x30
+#define NDFC_BCFG1              0x34
+#define NDFC_BCFG2              0x38
+#define NDFC_BCFG3              0x3c
+#define NDFC_CCR                0x40
+#define NDFC_STAT               0x44
+#define NDFC_HWCTL              0x48
+#define NDFC_REVID              0x50
+
+#define NDFC_STAT_IS_READY      0x01000000
+
+#define NDFC_CCR_RESET_CE       0x80000000 /* CE Reset */
+#define NDFC_CCR_RESET_ECC      0x40000000 /* ECC Reset */
+#define NDFC_CCR_RIE            0x20000000 /* Interrupt Enable on Device Rdy */
+#define NDFC_CCR_REN            0x10000000 /* Enable wait for Rdy in LinearR */
+#define NDFC_CCR_ROMEN          0x08000000 /* Enable ROM In LinearR */
+#define NDFC_CCR_ARE            0x04000000 /* Auto-Read Enable */
+#define NDFC_CCR_BS(x)          (((x) & 0x3) << 24) /* Select Bank on CE[x] */
+#define NDFC_CCR_BS_MASK        0x03000000 /* Select Bank */
+#define NDFC_CCR_ARAC0          0x00000000 /* 3 Addr, 1 Col 2 Row 512b page */
+#define NDFC_CCR_ARAC1          0x00001000 /* 4 Addr, 1 Col 3 Row 512b page */
+#define NDFC_CCR_ARAC2          0x00002000 /* 4 Addr, 2 Col 2 Row 2K page */
+#define NDFC_CCR_ARAC3          0x00003000 /* 5 Addr, 2 Col 3 Row 2K page */
+#define NDFC_CCR_ARAC_MASK      0x00003000 /* Auto-Read mode Addr Cycles */
+#define NDFC_CCR_RPG            0x0000C000 /* Auto-Read Page */
+#define NDFC_CCR_EBCC           0x00000004 /* EBC Configuration Completed */
+#define NDFC_CCR_DHC            0x00000002 /* Direct Hardware Control Enable */
+
+#define NDFC_BxCFG_EN           0x80000000 /* Bank Enable */
+#define NDFC_BxCFG_CED          0x40000000 /* nCE Style */
+#define NDFC_BxCFG_SZ_MASK      0x08000000 /* Bank Size */
+#define NDFC_BxCFG_SZ_8BIT      0x00000000 /* 8bit */
+#define NDFC_BxCFG_SZ_16BIT     0x08000000 /* 16bit */
+
+#define NDFC_MAX_BANKS          4
+
+struct ndfc_controller_settings {
+        uint32_t        ccr_settings;
+        uint64_t        ndfc_erpn;
+};
+
+struct ndfc_chip_settings {
+        uint32_t        bank_settings;
+};
+
+#endif
diff --git a/include/linux/mtd/nftl.h b/include/linux/mtd/nftl.h
index d35d2c21ff3e..bcf2fb3fa4a7 100644
--- a/include/linux/mtd/nftl.h
+++ b/include/linux/mtd/nftl.h
@@ -37,7 +37,7 @@ struct NFTLrecord {
         unsigned int nb_blocks;         /* number of physical blocks */
         unsigned int nb_boot_blocks;    /* number of blocks used by the bios */
         struct erase_info instr;
-        struct nand_oobinfo oobinfo;
+        struct nand_ecclayout oobinfo;
 };
 
 int NFTL_mount(struct NFTLrecord *s);
diff --git a/include/linux/mtd/onenand.h b/include/linux/mtd/onenand.h
index 7419b5fab133..9ce9a48db444 100644
--- a/include/linux/mtd/onenand.h
+++ b/include/linux/mtd/onenand.h
@@ -35,6 +35,8 @@ typedef enum {
         FL_SYNCING,
         FL_UNLOCKING,
         FL_LOCKING,
+        FL_RESETING,
+        FL_OTPING,
         FL_PM_SUSPENDED,
 } onenand_state_t;
 
@@ -75,7 +77,7 @@ struct onenand_bufferram {
  * @param chip_lock     [INTERN] spinlock used to protect access to this structure and the chip
  * @param wq            [INTERN] wait queue to sleep on if a OneNAND operation is in progress
  * @param state         [INTERN] the current state of the OneNAND device
- * @param autooob       [REPLACEABLE] the default (auto)placement scheme
+ * @param ecclayout     [REPLACEABLE] the default ecc placement scheme
  * @param bbm           [REPLACEABLE] pointer to Bad Block Management
  * @param priv          [OPTIONAL] pointer to private chip date
  */
@@ -111,9 +113,9 @@ struct onenand_chip {
         onenand_state_t         state;
         unsigned char           *page_buf;
 
-        struct nand_oobinfo     *autooob;
+        struct nand_ecclayout   *ecclayout;
 
-        void                    *bbm;
+        void                    *bbm;
 
         void                    *priv;
 };
@@ -130,6 +132,9 @@ struct onenand_chip {
 #define ONENAND_SET_SYS_CFG1(v, this)                                   \
         (this->write_word(v, this->base + ONENAND_REG_SYS_CFG1))
 
+/* Check byte access in OneNAND */
+#define ONENAND_CHECK_BYTE_ACCESS(addr)         (addr & 0x1)
+
 /*
  * Options bits
  */
diff --git a/include/linux/mtd/onenand_regs.h b/include/linux/mtd/onenand_regs.h
index d7832ef8ed63..4a72818d2545 100644
--- a/include/linux/mtd/onenand_regs.h
+++ b/include/linux/mtd/onenand_regs.h
@@ -112,6 +112,7 @@
 #define ONENAND_CMD_LOCK_TIGHT          (0x2C)
 #define ONENAND_CMD_ERASE               (0x94)
 #define ONENAND_CMD_RESET               (0xF0)
+#define ONENAND_CMD_OTP_ACCESS          (0x65)
 #define ONENAND_CMD_READID              (0x90)
 
 /* NOTE: Those are not *REAL* commands */
@@ -152,6 +153,8 @@
 #define ONENAND_CTRL_ERASE              (1 << 11)
 #define ONENAND_CTRL_ERROR              (1 << 10)
 #define ONENAND_CTRL_RSTB               (1 << 7)
+#define ONENAND_CTRL_OTP_L              (1 << 6)
+#define ONENAND_CTRL_OTP_BL             (1 << 5)
 
 /*
  * Interrupt Status Register F241h (R)
@@ -177,4 +180,9 @@
 #define ONENAND_ECC_2BIT                (1 << 1)
 #define ONENAND_ECC_2BIT_ALL            (0xAAAA)
 
+/*
+ * One-Time Programmable (OTP)
+ */
+#define ONENAND_OTP_LOCK_OFFSET         (14)
+
 #endif  /* __ONENAND_REG_H */
diff --git a/include/linux/mtd/partitions.h b/include/linux/mtd/partitions.h
index b03f512d51b9..da6b3d6f12a7 100644
--- a/include/linux/mtd/partitions.h
+++ b/include/linux/mtd/partitions.h
@@ -41,7 +41,7 @@ struct mtd_partition {
         u_int32_t size;                 /* partition size */
         u_int32_t offset;               /* offset within the master MTD space */
         u_int32_t mask_flags;           /* master MTD flags to mask out for this partition */
-        struct nand_oobinfo *oobsel;    /* out of band layout for this partition (NAND only)*/
+        struct nand_ecclayout *ecclayout;       /* out of band layout for this partition (NAND only)*/
         struct mtd_info **mtdp;         /* pointer to store the MTD object */
 };
 
diff --git a/include/linux/mtd/physmap.h b/include/linux/mtd/physmap.h
index c7b8bcdef013..86831e3594f6 100644
--- a/include/linux/mtd/physmap.h
+++ b/include/linux/mtd/physmap.h
@@ -15,33 +15,26 @@
  */
 
 #ifndef __LINUX_MTD_PHYSMAP__
-
-#include <linux/config.h>
-
-#if defined(CONFIG_MTD_PHYSMAP)
+#define __LINUX_MTD_PHYSMAP__
 
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
 #include <linux/mtd/partitions.h>
 
-/*
- * The map_info for physmap.  Board can override size, buswidth, phys,
- * (*set_vpp)(), etc in their initial setup routine.
- */
-extern struct map_info physmap_map;
+struct physmap_flash_data {
+        unsigned int            width;
+        void                    (*set_vpp)(struct map_info *, int);
+        unsigned int            nr_parts;
+        struct mtd_partition    *parts;
+};
 
 /*
  * Board needs to specify the exact mapping during their setup time.
  */
-static inline void physmap_configure(unsigned long addr, unsigned long size, int bankwidth, void (*set_vpp)(struct map_info *, int) )
-{
-        physmap_map.phys = addr;
-        physmap_map.size = size;
-        physmap_map.bankwidth = bankwidth;
-        physmap_map.set_vpp = set_vpp;
-}
+void physmap_configure(unsigned long addr, unsigned long size,
+                int bankwidth, void (*set_vpp)(struct map_info *, int) );
 
-#if defined(CONFIG_MTD_PARTITIONS)
+#ifdef CONFIG_MTD_PARTITIONS
 
 /*
  * Machines that wish to do flash partition may want to call this function in
@@ -55,7 +48,5 @@ static inline void physmap_configure(unsigned long addr, unsigned long size, int
 void physmap_set_partitions(struct mtd_partition *parts, int num_parts);
 
 #endif /* defined(CONFIG_MTD_PARTITIONS) */
-#endif /* defined(CONFIG_MTD) */
 
 #endif /* __LINUX_MTD_PHYSMAP__ */
-
diff --git a/include/linux/mtd/xip.h b/include/linux/mtd/xip.h
index 220d50bb71cd..e9d40bdde48c 100644
--- a/include/linux/mtd/xip.h
+++ b/include/linux/mtd/xip.h
@@ -18,7 +18,6 @@
 #ifndef __LINUX_MTD_XIP_H__
 #define __LINUX_MTD_XIP_H__
 
-#include <linux/config.h>
 
 #ifdef CONFIG_MTD_XIP
 
diff --git a/include/linux/nbd.h b/include/linux/nbd.h
index a6ce409ec6fc..1d7cdd20b553 100644
--- a/include/linux/nbd.h
+++ b/include/linux/nbd.h
@@ -77,11 +77,11 @@ struct nbd_device {
  * server. All data are in network byte order.
  */
 struct nbd_request {
-        u32 magic;
-        u32 type;       /* == READ || == WRITE  */
+        __u32 magic;
+        __u32 type;     /* == READ || == WRITE  */
         char handle[8];
-        u64 from;
-        u32 len;
+        __u64 from;
+        __u32 len;
 }
 #ifdef __GNUC__
         __attribute__ ((packed))
@@ -93,8 +93,8 @@ struct nbd_request {
  * it has completed an I/O request (or an error occurs).
  */
 struct nbd_reply {
-        u32 magic;
-        u32 error;              /* 0 = ok, else error   */
+        __u32 magic;
+        __u32 error;            /* 0 = ok, else error   */
         char handle[8];         /* handle you got from request  */
 };
 #endif
diff --git a/include/linux/ncp_fs.h b/include/linux/ncp_fs.h
index 96dc237b8f03..b208f0cd556b 100644
--- a/include/linux/ncp_fs.h
+++ b/include/linux/ncp_fs.h
@@ -12,8 +12,6 @@
 #include <linux/in.h>
 #include <linux/types.h>
 
-#include <linux/ncp_fs_i.h>
-#include <linux/ncp_fs_sb.h>
 #include <linux/ipx.h>
 #include <linux/ncp_no.h>
 
@@ -146,7 +144,8 @@ struct ncp_nls_ioctl
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
+#include <linux/ncp_fs_i.h>
+#include <linux/ncp_fs_sb.h>
 
 /* undef because public define in umsdos_fs.h (ncp_fs.h isn't public) */
 #undef PRINTK
diff --git a/include/linux/net.h b/include/linux/net.h
index 84a490e5f0a1..385e68f5bd93 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -18,9 +18,7 @@
 #ifndef _LINUX_NET_H
 #define _LINUX_NET_H
 
-#include <linux/config.h>
 #include <linux/wait.h>
-#include <linux/stringify.h>
 #include <asm/socket.h>
 
 struct poll_table_struct;
@@ -57,6 +55,7 @@ typedef enum {
 #define __SO_ACCEPTCON  (1 << 16)       /* performed a listen           */
 
 #ifdef __KERNEL__
+#include <linux/stringify.h>
 
 #define SOCK_ASYNC_NOSPACE      0
 #define SOCK_ASYNC_WAITDATA     1
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index e432b743dda2..5e8e2d50429a 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -34,7 +34,6 @@
 #include <asm/cache.h>
 #include <asm/byteorder.h>
 
-#include <linux/config.h>
 #include <linux/device.h>
 #include <linux/percpu.h>
 #include <linux/dmaengine.h>
diff --git a/include/linux/netfilter.h b/include/linux/netfilter.h
index b31a9bca9361..10168e26a846 100644
--- a/include/linux/netfilter.h
+++ b/include/linux/netfilter.h
@@ -40,7 +40,6 @@
 #endif
 
 #ifdef __KERNEL__
-#include <linux/config.h>
 #ifdef CONFIG_NETFILTER
 
 extern void netfilter_init(void);
diff --git a/include/linux/netfilter/xt_conntrack.h b/include/linux/netfilter/xt_conntrack.h
index 34f63cf2e293..4c2d9945ca54 100644
--- a/include/linux/netfilter/xt_conntrack.h
+++ b/include/linux/netfilter/xt_conntrack.h
@@ -42,7 +42,7 @@ struct ip_conntrack_old_tuple
                 } u;
 
                 /* The protocol. */
-                u16 protonum;
+                __u16 protonum;
         } dst;
 };
 
diff --git a/include/linux/netfilter_arp.h b/include/linux/netfilter_arp.h
index a3f8977f7f12..92bc6ddcbf73 100644
--- a/include/linux/netfilter_arp.h
+++ b/include/linux/netfilter_arp.h
@@ -5,7 +5,6 @@
  * (C)2002 Rusty Russell IBM -- This code is GPL.
  */
 
-#include <linux/config.h>
 #include <linux/netfilter.h>
 
 /* There is no PF_ARP. */
diff --git a/include/linux/netfilter_bridge.h b/include/linux/netfilter_bridge.h
index a75b84bb9a88..87764022cc67 100644
--- a/include/linux/netfilter_bridge.h
+++ b/include/linux/netfilter_bridge.h
@@ -4,7 +4,6 @@
 /* bridge-specific defines for netfilter. 
  */
 
-#include <linux/config.h>
 #include <linux/netfilter.h>
 #if defined(__KERNEL__) && defined(CONFIG_BRIDGE_NETFILTER)
 #include <asm/atomic.h>
diff --git a/include/linux/netfilter_ipv4.h b/include/linux/netfilter_ipv4.h
index 85301c5e8d24..ce02c984f3ba 100644
--- a/include/linux/netfilter_ipv4.h
+++ b/include/linux/netfilter_ipv4.h
@@ -5,7 +5,6 @@
  * (C)1998 Rusty Russell -- This code is GPL.
  */
 
-#include <linux/config.h>
 #include <linux/netfilter.h>
 
 /* only for userspace compatibility */
diff --git a/include/linux/netfilter_ipv4/ip_conntrack.h b/include/linux/netfilter_ipv4/ip_conntrack.h
index e0e9951eb8c3..51dbec1892c8 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack.h
@@ -4,7 +4,6 @@
 #include <linux/netfilter/nf_conntrack_common.h>
 
 #ifdef __KERNEL__
-#include <linux/config.h>
 #include <linux/netfilter_ipv4/ip_conntrack_tuple.h>
 #include <linux/bitops.h>
 #include <linux/compiler.h>
diff --git a/include/linux/netfilter_ipv4/listhelp.h b/include/linux/netfilter_ipv4/listhelp.h
index 360429f48737..5d92cf044d91 100644
--- a/include/linux/netfilter_ipv4/listhelp.h
+++ b/include/linux/netfilter_ipv4/listhelp.h
@@ -1,6 +1,5 @@
 #ifndef _LISTHELP_H
 #define _LISTHELP_H
-#include <linux/config.h>
 #include <linux/list.h>
 
 /* Header to do more comprehensive job than linux/list.h; assume list
diff --git a/include/linux/nfs.h b/include/linux/nfs.h
index ca2ffa6ae1d5..54af92c1c70b 100644
--- a/include/linux/nfs.h
+++ b/include/linux/nfs.h
@@ -7,9 +7,6 @@
 #ifndef _LINUX_NFS_H
 #define _LINUX_NFS_H
 
-#include <linux/sunrpc/msg_prot.h>
-#include <linux/string.h>
-
 #define NFS_PROGRAM     100003
 #define NFS_PORT        2049
 #define NFS_MAXDATA     8192
@@ -129,7 +126,10 @@ enum nfs_ftype {
         NFFIFO = 8
 };
 
-#if defined(__KERNEL__)
+#ifdef __KERNEL__
+#include <linux/sunrpc/msg_prot.h>
+#include <linux/string.h>
+
 /*
  * This is the kernel NFS client file handle representation
  */
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index 1477fc857f6b..5f681d534295 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -14,7 +14,6 @@
 #define _LINUX_NFS4_H
 
 #include <linux/types.h>
-#include <linux/list.h>
 
 #define NFS4_VERIFIER_SIZE      8
 #define NFS4_FHSIZE             128
@@ -97,6 +96,9 @@ enum nfs4_acl_whotype {
         NFS4_ACL_WHO_EVERYONE,
 };
 
+#ifdef __KERNEL__
+#include <linux/list.h>
+
 struct nfs4_ace {
         uint32_t        type;
         uint32_t        flag;
@@ -345,8 +347,6 @@ enum lock_type4 {
 #define NFS4_MINOR_VERSION 0
 #define NFS4_DEBUG 1
 
-#ifdef __KERNEL__
-
 /* Index of predefined Linux client operations */
 
 enum {
diff --git a/include/linux/nfsd/nfsd.h b/include/linux/nfsd/nfsd.h
index ec7c2e872d72..2dcad295fece 100644
--- a/include/linux/nfsd/nfsd.h
+++ b/include/linux/nfsd/nfsd.h
@@ -10,7 +10,6 @@
 #ifndef LINUX_NFSD_NFSD_H
 #define LINUX_NFSD_NFSD_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/unistd.h>
 #include <linux/dirent.h>
diff --git a/include/linux/nfsd/nfsfh.h b/include/linux/nfsd/nfsfh.h
index 0798b7781a6e..f9edcd2ff3c8 100644
--- a/include/linux/nfsd/nfsfh.h
+++ b/include/linux/nfsd/nfsfh.h
@@ -16,7 +16,6 @@
 
 #include <asm/types.h>
 #ifdef __KERNEL__
-# include <linux/config.h>
 # include <linux/types.h>
 # include <linux/string.h>
 # include <linux/fs.h>
diff --git a/include/linux/nfsd/syscall.h b/include/linux/nfsd/syscall.h
index 781efbf94ed3..dae0faea2807 100644
--- a/include/linux/nfsd/syscall.h
+++ b/include/linux/nfsd/syscall.h
@@ -11,7 +11,6 @@
 
 #include <asm/types.h>
 #ifdef __KERNEL__
-# include <linux/config.h>
 # include <linux/types.h>
 # include <linux/in.h>
 #endif 
diff --git a/include/linux/numa.h b/include/linux/numa.h
index e481feb1bfd8..a31a7301b159 100644
--- a/include/linux/numa.h
+++ b/include/linux/numa.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_NUMA_H
 #define _LINUX_NUMA_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_NODES_SHIFT
 #define NODES_SHIFT     CONFIG_NODES_SHIFT
diff --git a/include/linux/parport.h b/include/linux/parport.h
index 008d736a6c9a..d42737eeee06 100644
--- a/include/linux/parport.h
+++ b/include/linux/parport.h
@@ -96,7 +96,6 @@ typedef enum {
 /* The rest is for the kernel only */
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/jiffies.h>
 #include <linux/proc_fs.h>
 #include <linux/spinlock.h>
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 6fd36cb09160..6c4bc773f7b7 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -17,8 +17,6 @@
 #ifndef LINUX_PCI_H
 #define LINUX_PCI_H
 
-#include <linux/mod_devicetable.h>
-
 /* Include the pci register defines */
 #include <linux/pci_regs.h>
 
@@ -46,8 +44,9 @@
 
 #ifdef __KERNEL__
 
+#include <linux/mod_devicetable.h>
+
 #include <linux/types.h>
-#include <linux/config.h>
 #include <linux/ioport.h>
 #include <linux/list.h>
 #include <linux/errno.h>
diff --git a/include/linux/percpu_counter.h b/include/linux/percpu_counter.h
index 682525511c9e..66b5de404f22 100644
--- a/include/linux/percpu_counter.h
+++ b/include/linux/percpu_counter.h
@@ -6,7 +6,6 @@
  * WARNING: these things are HUGE.  4 kbytes per counter on 32-way P4.
  */
 
-#include <linux/config.h>
 #include <linux/spinlock.h>
 #include <linux/smp.h>
 #include <linux/threads.h>
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 66be58902b17..658c1b93d5bb 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -23,7 +23,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/list.h>
 #include <asm/atomic.h>
 
diff --git a/include/linux/pm_legacy.h b/include/linux/pm_legacy.h
index 008932d73c35..78027c533b94 100644
--- a/include/linux/pm_legacy.h
+++ b/include/linux/pm_legacy.h
@@ -1,7 +1,6 @@
 #ifndef __LINUX_PM_LEGACY_H__
 #define __LINUX_PM_LEGACY_H__
 
-#include <linux/config.h>
 
 #ifdef CONFIG_PM_LEGACY
 
diff --git a/include/linux/pmu.h b/include/linux/pmu.h
index 217d3daf7336..ecce5912f4d6 100644
--- a/include/linux/pmu.h
+++ b/include/linux/pmu.h
@@ -6,7 +6,6 @@
  * Copyright (C) 1998 Paul Mackerras.
  */
 
-#include <linux/config.h>
 
 #define PMU_DRIVER_VERSION      2
 
diff --git a/include/linux/ppp_defs.h b/include/linux/ppp_defs.h
index 402056cd049d..c6b13ff85028 100644
--- a/include/linux/ppp_defs.h
+++ b/include/linux/ppp_defs.h
@@ -42,8 +42,6 @@
 #ifndef _PPP_DEFS_H_
 #define _PPP_DEFS_H_
 
-#include <linux/crc-ccitt.h>
-
 /*
  * The basic PPP frame.
  */
@@ -97,7 +95,11 @@
 
 #define PPP_INITFCS     0xffff  /* Initial FCS value */
 #define PPP_GOODFCS     0xf0b8  /* Good final FCS value */
+
+#ifdef __KERNEL__
+#include <linux/crc-ccitt.h>
 #define PPP_FCS(fcs, c) crc_ccitt_byte(fcs, c)
+#endif
 
 /*
  * Extended asyncmap - allows any character to be escaped.
@@ -179,12 +181,4 @@ struct ppp_idle {
     time_t recv_idle;           /* time since last NP packet received */
 };
 
-#ifndef __P
-#ifdef __STDC__
-#define __P(x)  x
-#else
-#define __P(x)  ()
-#endif
-#endif
-
 #endif /* _PPP_DEFS_H_ */
diff --git a/include/linux/preempt.h b/include/linux/preempt.h
index 5769d14d1e6a..d0926d63406c 100644
--- a/include/linux/preempt.h
+++ b/include/linux/preempt.h
@@ -6,7 +6,6 @@
  * preempt_count (used for kernel preemption, interrupt count, etc.)
  */
 
-#include <linux/config.h>
 #include <linux/thread_info.h>
 #include <linux/linkage.h>
 
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 4b47a0253425..5810d28fbed9 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_PROC_FS_H
 #define _LINUX_PROC_FS_H
 
-#include <linux/config.h>
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/spinlock.h>
diff --git a/include/linux/profile.h b/include/linux/profile.h
index 1f2fea6640a4..e633004ae052 100644
--- a/include/linux/profile.h
+++ b/include/linux/profile.h
@@ -4,7 +4,6 @@
 #ifdef __KERNEL__
 
 #include <linux/kernel.h>
-#include <linux/config.h>
 #include <linux/init.h>
 #include <linux/cpumask.h>
 #include <asm/errno.h>
diff --git a/include/linux/quota.h b/include/linux/quota.h
index 2dab71e1c3d1..b8fbf26eb885 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -37,8 +37,6 @@
 
 #include <linux/errno.h>
 #include <linux/types.h>
-#include <linux/spinlock.h>
-#include <linux/mutex.h>
 
 #define __DQUOT_VERSION__       "dquot_6.5.1"
 #define __DQUOT_NUM_VERSION__   6*10000+5*100+1
@@ -133,6 +131,8 @@ struct if_dqinfo {
 };
 
 #ifdef __KERNEL__
+#include <linux/spinlock.h>
+#include <linux/mutex.h>
 
 #include <linux/dqblk_xfs.h>
 #include <linux/dqblk_v1.h>
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index 21e5a9124856..5110201a4159 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -10,7 +10,6 @@
 #ifndef _LINUX_QUOTAOPS_
 #define _LINUX_QUOTAOPS_
 
-#include <linux/config.h>
 #include <linux/smp_lock.h>
 
 #include <linux/fs.h>
diff --git a/include/linux/rbtree.h b/include/linux/rbtree.h
index 4b7cc4fe366d..f37006f21664 100644
--- a/include/linux/rbtree.h
+++ b/include/linux/rbtree.h
@@ -99,19 +99,36 @@ static inline struct page * rb_insert_page_cache(struct inode * inode,
 
 struct rb_node
 {
-        struct rb_node *rb_parent;
-        int rb_color;
+        unsigned long  rb_parent_color;
 #define RB_RED          0
 #define RB_BLACK        1
         struct rb_node *rb_right;
         struct rb_node *rb_left;
-};
+} __attribute__((aligned(sizeof(long))));
+    /* The alignment might seem pointless, but allegedly CRIS needs it */
 
 struct rb_root
 {
         struct rb_node *rb_node;
 };
 
+
+#define rb_parent(r)   ((struct rb_node *)((r)->rb_parent_color & ~3))
+#define rb_color(r)   ((r)->rb_parent_color & 1)
+#define rb_is_red(r)   (!rb_color(r))
+#define rb_is_black(r) rb_color(r)
+#define rb_set_red(r)  do { (r)->rb_parent_color &= ~1; } while (0)
+#define rb_set_black(r)  do { (r)->rb_parent_color |= 1; } while (0)
+
+static inline void rb_set_parent(struct rb_node *rb, struct rb_node *p)
+{
+        rb->rb_parent_color = (rb->rb_parent_color & 3) | (unsigned long)p;
+}
+static inline void rb_set_color(struct rb_node *rb, int color)
+{
+        rb->rb_parent_color = (rb->rb_parent_color & ~1) | color;
+}
+
 #define RB_ROOT (struct rb_root) { NULL, }
 #define rb_entry(ptr, type, member) container_of(ptr, type, member)
 
@@ -131,8 +148,7 @@ extern void rb_replace_node(struct rb_node *victim, struct rb_node *new,
 static inline void rb_link_node(struct rb_node * node, struct rb_node * parent,
                                 struct rb_node ** rb_link)
 {
-        node->rb_parent = parent;
-        node->rb_color = RB_RED;
+        node->rb_parent_color = (unsigned long )parent;
         node->rb_left = node->rb_right = NULL;
 
         *rb_link = node;
diff --git a/include/linux/reiserfs_xattr.h b/include/linux/reiserfs_xattr.h
index 5353afb11db3..5e961035c725 100644
--- a/include/linux/reiserfs_xattr.h
+++ b/include/linux/reiserfs_xattr.h
@@ -2,8 +2,6 @@
   File: linux/reiserfs_xattr.h
 */
 
-#include <linux/config.h>
-#include <linux/init.h>
 #include <linux/xattr.h>
 
 /* Magic value in header */
@@ -15,6 +13,7 @@ struct reiserfs_xattr_header {
 };
 
 #ifdef __KERNEL__
+#include <linux/init.h>
 
 struct reiserfs_xattr_handler {
         char *prefix;
diff --git a/include/linux/relay.h b/include/linux/relay.h
index 4bcc1531d6a9..24accb483849 100644
--- a/include/linux/relay.h
+++ b/include/linux/relay.h
@@ -10,7 +10,6 @@
 #ifndef _LINUX_RELAY_H
 #define _LINUX_RELAY_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/wait.h>
diff --git a/include/linux/rio.h b/include/linux/rio.h
index c7e907faae9c..d93857056cb9 100644
--- a/include/linux/rio.h
+++ b/include/linux/rio.h
@@ -17,7 +17,6 @@
 #ifdef __KERNEL__
 
 #include <linux/types.h>
-#include <linux/config.h>
 #include <linux/ioport.h>
 #include <linux/list.h>
 #include <linux/errno.h>
diff --git a/include/linux/rio_drv.h b/include/linux/rio_drv.h
index f54772d0e7f8..7adb2a1aac92 100644
--- a/include/linux/rio_drv.h
+++ b/include/linux/rio_drv.h
@@ -16,7 +16,6 @@
 #ifdef __KERNEL__
 
 #include <linux/types.h>
-#include <linux/config.h>
 #include <linux/ioport.h>
 #include <linux/list.h>
 #include <linux/errno.h>
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index d6b9bcd1384c..2d4c81a220db 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -4,7 +4,6 @@
  * Declarations for Reverse Mapping functions in mm/rmap.c
  */
 
-#include <linux/config.h>
 #include <linux/list.h>
 #include <linux/slab.h>
 #include <linux/mm.h>
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index df0cdd41085c..facd9ee37b76 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -909,7 +909,6 @@ struct tcamsg
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/mutex.h>
 
 extern size_t rtattr_strlcpy(char *dest, const struct rtattr *rta, size_t size);
diff --git a/include/linux/rwsem.h b/include/linux/rwsem.h
index bfb988885002..f99fe90732ab 100644
--- a/include/linux/rwsem.h
+++ b/include/linux/rwsem.h
@@ -13,7 +13,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <asm/system.h>
diff --git a/include/linux/scc.h b/include/linux/scc.h
index 885a4a02b23c..3495bd953cc6 100644
--- a/include/linux/scc.h
+++ b/include/linux/scc.h
@@ -3,7 +3,6 @@
 #ifndef _SCC_H
 #define _SCC_H
 
-#include <linux/config.h>
 
 /* selection of hardware types */
 
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 29b7d4f87d20..267f15257040 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1,9 +1,46 @@
 #ifndef _LINUX_SCHED_H
 #define _LINUX_SCHED_H
 
+#include <linux/auxvec.h>       /* For AT_VECTOR_SIZE */
+
+/*
+ * cloning flags:
+ */
+#define CSIGNAL         0x000000ff      /* signal mask to be sent at exit */
+#define CLONE_VM        0x00000100      /* set if VM shared between processes */
+#define CLONE_FS        0x00000200      /* set if fs info shared between processes */
+#define CLONE_FILES     0x00000400      /* set if open files shared between processes */
+#define CLONE_SIGHAND   0x00000800      /* set if signal handlers and blocked signals shared */
+#define CLONE_PTRACE    0x00002000      /* set if we want to let tracing continue on the child too */
+#define CLONE_VFORK     0x00004000      /* set if the parent wants the child to wake it up on mm_release */
+#define CLONE_PARENT    0x00008000      /* set if we want to have the same parent as the cloner */
+#define CLONE_THREAD    0x00010000      /* Same thread group? */
+#define CLONE_NEWNS     0x00020000      /* New namespace group? */
+#define CLONE_SYSVSEM   0x00040000      /* share system V SEM_UNDO semantics */
+#define CLONE_SETTLS    0x00080000      /* create a new TLS for the child */
+#define CLONE_PARENT_SETTID     0x00100000      /* set the TID in the parent */
+#define CLONE_CHILD_CLEARTID    0x00200000      /* clear the TID in the child */
+#define CLONE_DETACHED          0x00400000      /* Unused, ignored */
+#define CLONE_UNTRACED          0x00800000      /* set if the tracing process can't force CLONE_PTRACE on this clone */
+#define CLONE_CHILD_SETTID      0x01000000      /* set the TID in the child */
+#define CLONE_STOPPED           0x02000000      /* Start in stopped state */
+
+/*
+ * Scheduling policies
+ */
+#define SCHED_NORMAL            0
+#define SCHED_FIFO              1
+#define SCHED_RR                2
+#define SCHED_BATCH             3
+
+#ifdef __KERNEL__
+
+struct sched_param {
+        int sched_priority;
+};
+
 #include <asm/param.h>  /* for HZ */
 
-#include <linux/config.h>
 #include <linux/capability.h>
 #include <linux/threads.h>
 #include <linux/kernel.h>
@@ -37,31 +74,15 @@
 #include <linux/rcupdate.h>
 #include <linux/futex.h>
 
-#include <linux/auxvec.h>       /* For AT_VECTOR_SIZE */
+#include <linux/time.h>
+#include <linux/param.h>
+#include <linux/resource.h>
+#include <linux/timer.h>
+#include <linux/hrtimer.h>
 
-struct exec_domain;
+#include <asm/processor.h>
 
-/*
- * cloning flags:
- */
-#define CSIGNAL         0x000000ff      /* signal mask to be sent at exit */
-#define CLONE_VM        0x00000100      /* set if VM shared between processes */
-#define CLONE_FS        0x00000200      /* set if fs info shared between processes */
-#define CLONE_FILES     0x00000400      /* set if open files shared between processes */
-#define CLONE_SIGHAND   0x00000800      /* set if signal handlers and blocked signals shared */
-#define CLONE_PTRACE    0x00002000      /* set if we want to let tracing continue on the child too */
-#define CLONE_VFORK     0x00004000      /* set if the parent wants the child to wake it up on mm_release */
-#define CLONE_PARENT    0x00008000      /* set if we want to have the same parent as the cloner */
-#define CLONE_THREAD    0x00010000      /* Same thread group? */
-#define CLONE_NEWNS     0x00020000      /* New namespace group? */
-#define CLONE_SYSVSEM   0x00040000      /* share system V SEM_UNDO semantics */
-#define CLONE_SETTLS    0x00080000      /* create a new TLS for the child */
-#define CLONE_PARENT_SETTID     0x00100000      /* set the TID in the parent */
-#define CLONE_CHILD_CLEARTID    0x00200000      /* clear the TID in the child */
-#define CLONE_DETACHED          0x00400000      /* Unused, ignored */
-#define CLONE_UNTRACED          0x00800000      /* set if the tracing process can't force CLONE_PTRACE on this clone */
-#define CLONE_CHILD_SETTID      0x01000000      /* set the TID in the child */
-#define CLONE_STOPPED           0x02000000      /* Start in stopped state */
+struct exec_domain;
 
 /*
  * List of flags we want to share for kernel threads,
@@ -103,13 +124,6 @@ extern unsigned long nr_uninterruptible(void);
 extern unsigned long nr_active(void);
 extern unsigned long nr_iowait(void);
 
-#include <linux/time.h>
-#include <linux/param.h>
-#include <linux/resource.h>
-#include <linux/timer.h>
-#include <linux/hrtimer.h>
-
-#include <asm/processor.h>
 
 /*
  * Task state bitmask. NOTE! These bits are also
@@ -156,20 +170,6 @@ extern unsigned long nr_iowait(void);
 /* Task command name length */
 #define TASK_COMM_LEN 16
 
-/*
- * Scheduling policies
- */
-#define SCHED_NORMAL            0
-#define SCHED_FIFO              1
-#define SCHED_RR                2
-#define SCHED_BATCH             3
-
-struct sched_param {
-        int sched_priority;
-};
-
-#ifdef __KERNEL__
-
 #include <linux/spinlock.h>
 
 /*
@@ -494,7 +494,7 @@ struct user_struct {
         atomic_t processes;     /* How many processes does this user have? */
         atomic_t files;         /* How many open files does this user have? */
         atomic_t sigpending;    /* How many pending signals does this user have? */
-#ifdef CONFIG_INOTIFY
+#ifdef CONFIG_INOTIFY_USER
         atomic_t inotify_watches; /* How many inotify watches does this user have? */
         atomic_t inotify_devs;  /* How many inotify devs does this user have opened? */
 #endif
diff --git a/include/linux/seccomp.h b/include/linux/seccomp.h
index cd2773b29a64..3e8b1cf54303 100644
--- a/include/linux/seccomp.h
+++ b/include/linux/seccomp.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_SECCOMP_H
 #define _LINUX_SECCOMP_H
 
-#include <linux/config.h>
 
 #ifdef CONFIG_SECCOMP
 
diff --git a/include/linux/sem.h b/include/linux/sem.h
index 3c1f1120fe88..9aaffb0b1d81 100644
--- a/include/linux/sem.h
+++ b/include/linux/sem.h
@@ -2,7 +2,6 @@
 #define _LINUX_SEM_H
 
 #include <linux/ipc.h>
-#include <asm/atomic.h>
 
 /* semop flags */
 #define SEM_UNDO        0x1000  /* undo the operation on exit */
@@ -78,6 +77,7 @@ struct  seminfo {
 #define SEMUSZ  20              /* sizeof struct sem_undo */
 
 #ifdef __KERNEL__
+#include <asm/atomic.h>
 
 struct task_struct;
 
diff --git a/include/linux/seqlock.h b/include/linux/seqlock.h
index 5a095572881d..7bc5c7c12b54 100644
--- a/include/linux/seqlock.h
+++ b/include/linux/seqlock.h
@@ -26,7 +26,6 @@
  * by Keith Owens and Andrea Arcangeli
  */
 
-#include <linux/config.h>
 #include <linux/spinlock.h>
 #include <linux/preempt.h>
 
diff --git a/include/linux/serialP.h b/include/linux/serialP.h
index 2b9e6b9554d5..e811a615f696 100644
--- a/include/linux/serialP.h
+++ b/include/linux/serialP.h
@@ -19,7 +19,6 @@
  * For definitions of the flags field, see tty.h
  */
 
-#include <linux/config.h>
 #include <linux/termios.h>
 #include <linux/workqueue.h>
 #include <linux/interrupt.h>
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index bd14858121ea..94b9286cf6bd 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -132,7 +132,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <linux/interrupt.h>
 #include <linux/circ_buf.h>
diff --git a/include/linux/signal.h b/include/linux/signal.h
index 70739f51a09f..1e4ce7225eee 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -1,12 +1,12 @@
 #ifndef _LINUX_SIGNAL_H
 #define _LINUX_SIGNAL_H
 
-#include <linux/list.h>
-#include <linux/spinlock.h>
 #include <asm/signal.h>
 #include <asm/siginfo.h>
 
 #ifdef __KERNEL__
+#include <linux/list.h>
+#include <linux/spinlock.h>
 
 /*
  * These values of sa_flags are used only by the kernel as part of the
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 93e4db221585..66f8819f9568 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -14,7 +14,6 @@
 #ifndef _LINUX_SKBUFF_H
 #define _LINUX_SKBUFF_H
 
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/compiler.h>
 #include <linux/time.h>
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 2d985d59c7b8..9dc93163e065 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -11,7 +11,6 @@
 
 typedef struct kmem_cache kmem_cache_t;
 
-#include        <linux/config.h>        /* kmalloc_sizes.h needs CONFIG_ options */
 #include        <linux/gfp.h>
 #include        <linux/init.h>
 #include        <linux/types.h>
diff --git a/include/linux/smb_fs.h b/include/linux/smb_fs.h
index 621a3d3662f3..367d6c3e8ed4 100644
--- a/include/linux/smb_fs.h
+++ b/include/linux/smb_fs.h
@@ -10,8 +10,6 @@
 #define _LINUX_SMB_FS_H
 
 #include <linux/smb.h>
-#include <linux/smb_fs_i.h>
-#include <linux/smb_fs_sb.h>
 
 /*
  * ioctl commands
@@ -24,6 +22,8 @@
 
 
 #ifdef __KERNEL__
+#include <linux/smb_fs_i.h>
+#include <linux/smb_fs_sb.h>
 
 #include <linux/fs.h>
 #include <linux/pagemap.h>
diff --git a/include/linux/smp.h b/include/linux/smp.h
index e2fa3ab4afc5..c93c3fe4308c 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -6,7 +6,6 @@
  *              Alan Cox. <alan@redhat.com>
  */
 
-#include <linux/config.h>
 
 extern void cpu_idle(void);
 
diff --git a/include/linux/smp_lock.h b/include/linux/smp_lock.h
index fa1ff3b165fe..cf715a40d833 100644
--- a/include/linux/smp_lock.h
+++ b/include/linux/smp_lock.h
@@ -1,7 +1,6 @@
 #ifndef __LINUX_SMPLOCK_H
 #define __LINUX_SMPLOCK_H
 
-#include <linux/config.h>
 #ifdef CONFIG_LOCK_KERNEL
 #include <linux/sched.h>
 #include <linux/spinlock.h>
diff --git a/include/linux/socket.h b/include/linux/socket.h
index 9ab2ddd80221..361409094649 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -18,8 +18,6 @@ struct __kernel_sockaddr_storage {
 
 #if defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2)
 
-#include <linux/config.h>               /* for CONFIG_COMPAT */
-#include <linux/linkage.h>
 #include <asm/socket.h>                 /* arch-dependent defines       */
 #include <linux/sockios.h>              /* the SIOCxxx I/O controls     */
 #include <linux/uio.h>                  /* iovec support                */
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index 799be6747944..ae23beef9cc9 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -46,7 +46,6 @@
  *  linux/spinlock.h:     builds the final spin_*() APIs.
  */
 
-#include <linux/config.h>
 #include <linux/preempt.h>
 #include <linux/linkage.h>
 #include <linux/compiler.h>
diff --git a/include/linux/stop_machine.h b/include/linux/stop_machine.h
index 151a803ed0ed..5bfc553bdb21 100644
--- a/include/linux/stop_machine.h
+++ b/include/linux/stop_machine.h
@@ -4,7 +4,6 @@
    very heavy lock, which is equivalent to grabbing every spinlock
    (and more).  So the "read" side to such a lock is anything which
    diables preeempt. */
-#include <linux/config.h>
 #include <linux/cpu.h>
 #include <asm/system.h>
 
diff --git a/include/linux/sunrpc/auth.h b/include/linux/sunrpc/auth.h
index be4772ed43c0..a6de332e57d4 100644
--- a/include/linux/sunrpc/auth.h
+++ b/include/linux/sunrpc/auth.h
@@ -11,7 +11,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/sunrpc/sched.h>
 #include <linux/sunrpc/msg_prot.h>
 #include <linux/sunrpc/xdr.h>
diff --git a/include/linux/sunrpc/debug.h b/include/linux/sunrpc/debug.h
index 1a42d902bc11..e4729aa67654 100644
--- a/include/linux/sunrpc/debug.h
+++ b/include/linux/sunrpc/debug.h
@@ -9,19 +9,6 @@
 #ifndef _LINUX_SUNRPC_DEBUG_H_
 #define _LINUX_SUNRPC_DEBUG_H_
 
-#include <linux/config.h>
-
-#include <linux/timer.h>
-#include <linux/workqueue.h>
-
-/*
- * Enable RPC debugging/profiling.
- */
-#ifdef CONFIG_SYSCTL
-#define  RPC_DEBUG
-#endif
-/* #define  RPC_PROFILE */
-
 /*
  * RPC debug facilities
  */
@@ -41,6 +28,17 @@
 
 #ifdef __KERNEL__
 
+#include <linux/timer.h>
+#include <linux/workqueue.h>
+
+/*
+ * Enable RPC debugging/profiling.
+ */
+#ifdef CONFIG_SYSCTL
+#define  RPC_DEBUG
+#endif
+/* #define  RPC_PROFILE */
+
 /*
  * Debugging macros etc
  */
diff --git a/include/linux/sunrpc/stats.h b/include/linux/sunrpc/stats.h
index d93c24b47f3f..5fa0f2084307 100644
--- a/include/linux/sunrpc/stats.h
+++ b/include/linux/sunrpc/stats.h
@@ -9,7 +9,6 @@
 #ifndef _LINUX_SUNRPC_STATS_H
 #define _LINUX_SUNRPC_STATS_H
 
-#include <linux/config.h>
 #include <linux/proc_fs.h>
 
 struct rpc_stat {
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index 37c1c76fd547..96e31aa64cc7 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -6,7 +6,6 @@
 #endif
 #include <linux/swap.h>
 #include <linux/notifier.h>
-#include <linux/config.h>
 #include <linux/init.h>
 #include <linux/pm.h>
 
diff --git a/include/linux/swap.h b/include/linux/swap.h
index f03c24719302..aca9bfae208f 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_SWAP_H
 #define _LINUX_SWAP_H
 
-#include <linux/config.h>
 #include <linux/spinlock.h>
 #include <linux/linkage.h>
 #include <linux/mmzone.h>
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 60d49e5456e7..bd67a4413df7 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -54,7 +54,6 @@ struct compat_stat;
 struct compat_timeval;
 struct robust_list_head;
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/aio_abi.h>
 #include <linux/capability.h>
diff --git a/include/linux/sysrq.h b/include/linux/sysrq.h
index ea819b89c235..4812ff60561c 100644
--- a/include/linux/sysrq.h
+++ b/include/linux/sysrq.h
@@ -11,7 +11,6 @@
  *      based upon discusions in irc://irc.openprojects.net/#kernelnewbies
  */
 
-#include <linux/config.h>
 
 struct pt_regs;
 struct tty_struct;
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index c90daa5da6c3..420a689c3fb4 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -160,7 +160,6 @@ struct tcp_info
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/skbuff.h>
 #include <net/sock.h>
 #include <net/inet_connection_sock.h>
diff --git a/include/linux/threads.h b/include/linux/threads.h
index e646bcdf2614..38d1a5d6568e 100644
--- a/include/linux/threads.h
+++ b/include/linux/threads.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_THREADS_H
 #define _LINUX_THREADS_H
 
-#include <linux/config.h>
 
 /*
  * The default limit for the nr of threads is now in
diff --git a/include/linux/timer.h b/include/linux/timer.h
index 0a485beba9f5..c982304dbafd 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_TIMER_H
 #define _LINUX_TIMER_H
 
-#include <linux/config.h>
 #include <linux/list.h>
 #include <linux/spinlock.h>
 #include <linux/stddef.h>
diff --git a/include/linux/timex.h b/include/linux/timex.h
index 03914b7e41b1..34d3ccff7bbb 100644
--- a/include/linux/timex.h
+++ b/include/linux/timex.h
@@ -53,7 +53,6 @@
 #ifndef _LINUX_TIMEX_H
 #define _LINUX_TIMEX_H
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <linux/time.h>
 
diff --git a/include/linux/tty.h b/include/linux/tty.h
index f13f49afe198..e898eeb94166 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -16,7 +16,6 @@
                    consoles 16 and higher (since it returns a short) */
 
 #ifdef __KERNEL__
-#include <linux/config.h>
 #include <linux/fs.h>
 #include <linux/major.h>
 #include <linux/termios.h>
diff --git a/include/linux/types.h b/include/linux/types.h
index 1046c7ad86d9..a5e46e783ffa 100644
--- a/include/linux/types.h
+++ b/include/linux/types.h
@@ -2,7 +2,6 @@
 #define _LINUX_TYPES_H
 
 #ifdef  __KERNEL__
-#include <linux/config.h>
 
 #define BITS_TO_LONGS(bits) \
         (((bits)+BITS_PER_LONG-1)/BITS_PER_LONG)
diff --git a/include/linux/udp.h b/include/linux/udp.h
index 85a55658831c..bdd39be09406 100644
--- a/include/linux/udp.h
+++ b/include/linux/udp.h
@@ -35,7 +35,6 @@ struct udphdr {
 #define UDP_ENCAP_ESPINUDP      2 /* draft-ietf-ipsec-udp-encaps-06 */
 
 #ifdef __KERNEL__
-#include <linux/config.h>
 #include <linux/types.h>
 
 #include <net/inet_sock.h>
diff --git a/include/linux/ufs_fs.h b/include/linux/ufs_fs.h
index 843aeaaa79d4..86b5b4271b5a 100644
--- a/include/linux/ufs_fs.h
+++ b/include/linux/ufs_fs.h
@@ -32,7 +32,6 @@
 
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/time.h>
 #include <linux/stat.h>
 #include <linux/fs.h>
 
diff --git a/include/linux/unistd.h b/include/linux/unistd.h
index 10ed9834b822..c18c60f3254e 100644
--- a/include/linux/unistd.h
+++ b/include/linux/unistd.h
@@ -1,7 +1,9 @@
 #ifndef _LINUX_UNISTD_H_
 #define _LINUX_UNISTD_H_
 
+#ifdef __KERNEL__
 extern int errno;
+#endif
 
 /*
  * Include machine specific syscallX macros
diff --git a/include/linux/usb.h b/include/linux/usb.h
index e34e5e3dce52..1f492c0c7047 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -10,7 +10,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/errno.h>        /* for -ENODEV */
 #include <linux/delay.h>        /* for mdelay() */
 #include <linux/interrupt.h>    /* for in_interrupt() */
diff --git a/include/linux/usb_usual.h b/include/linux/usb_usual.h
index b2d08984a9f7..608487a62c98 100644
--- a/include/linux/usb_usual.h
+++ b/include/linux/usb_usual.h
@@ -9,7 +9,6 @@
 #ifndef __LINUX_USB_USUAL_H
 #define __LINUX_USB_USUAL_H
 
-#include <linux/config.h>
 
 /* We should do this for cleanliness... But other usb_foo.h do not do this. */
 /* #include <linux/usb.h> */
diff --git a/include/linux/usbdevice_fs.h b/include/linux/usbdevice_fs.h
index 8859f0b41543..7b7aadb69092 100644
--- a/include/linux/usbdevice_fs.h
+++ b/include/linux/usbdevice_fs.h
@@ -123,6 +123,7 @@ struct usbdevfs_hub_portinfo {
         char port [127];        /* e.g. port 3 connects to device 27 */
 };
 
+#ifdef __KERNEL__
 #ifdef CONFIG_COMPAT
 #include <linux/compat.h>
 struct usbdevfs_urb32 {
@@ -147,6 +148,7 @@ struct usbdevfs_ioctl32 {
         compat_caddr_t data;
 };
 #endif
+#endif /* __KERNEL__ */
 
 #define USBDEVFS_CONTROL           _IOWR('U', 0, struct usbdevfs_ctrltransfer)
 #define USBDEVFS_BULK              _IOWR('U', 2, struct usbdevfs_bulktransfer)
diff --git a/include/linux/vt_buffer.h b/include/linux/vt_buffer.h
index 1f7ba3629053..057db7d2f448 100644
--- a/include/linux/vt_buffer.h
+++ b/include/linux/vt_buffer.h
@@ -13,7 +13,6 @@
 #ifndef _LINUX_VT_BUFFER_H_
 #define _LINUX_VT_BUFFER_H_
 
-#include <linux/config.h>
 
 #if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_MDA_CONSOLE)
 #include <asm/vga.h>
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
index fab5aed8ca31..940d0261a545 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -6,7 +6,6 @@
  * with information needed by the vt package
  */
 
-#include <linux/config.h>
 #include <linux/vt.h>
 #include <linux/kd.h>
 #include <linux/tty.h>
diff --git a/include/linux/wait.h b/include/linux/wait.h
index d28518236b62..544e855c7c02 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -19,7 +19,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/list.h>
 #include <linux/stddef.h>
 #include <linux/spinlock.h>
diff --git a/include/linux/wanrouter.h b/include/linux/wanrouter.h
index 1b6b76a4eb54..2cd05013edfc 100644
--- a/include/linux/wanrouter.h
+++ b/include/linux/wanrouter.h
@@ -44,8 +44,6 @@
 * Jan 02, 1997  Gene Kozin      Initial version (based on wanpipe.h).
 *****************************************************************************/
 
-#include <linux/spinlock.h>       /* Support for SMP Locking */
-
 #ifndef _ROUTER_H
 #define _ROUTER_H
 
@@ -457,6 +455,8 @@ typedef struct wanif_conf
 #include <linux/fs.h>           /* support for device drivers */
 #include <linux/proc_fs.h>      /* proc filesystem pragmatics */
 #include <linux/netdevice.h>    /* support for network drivers */
+#include <linux/spinlock.h>     /* Support for SMP Locking */
+
 /*----------------------------------------------------------------------------
  * WAN device data space.
  */
diff --git a/include/mtd/mtd-abi.h b/include/mtd/mtd-abi.h
index b5994ea56a5a..31329fce1ff5 100644
--- a/include/mtd/mtd-abi.h
+++ b/include/mtd/mtd-abi.h
@@ -7,8 +7,9 @@
 #ifndef __MTD_ABI_H__
 #define __MTD_ABI_H__
 
-#ifndef __KERNEL__ /* Urgh. The whole point of splitting this out into
-                    separate files was to avoid #ifdef __KERNEL__ */
+#ifndef __KERNEL__ 
+/* Urgh. The whole point of splitting this out into
+   separate files was to avoid #ifdef __KERNEL__ */
 #define __user
 #endif
 
@@ -28,28 +29,17 @@ struct mtd_oob_buf {
 #define MTD_ROM                 2
 #define MTD_NORFLASH            3
 #define MTD_NANDFLASH           4
-#define MTD_PEROM               5
 #define MTD_DATAFLASH           6
-#define MTD_OTHER               14
-#define MTD_UNKNOWN             15
-
-#define MTD_CLEAR_BITS          1       // Bits can be cleared (flash)
-#define MTD_SET_BITS            2       // Bits can be set
-#define MTD_ERASEABLE           4       // Has an erase function
-#define MTD_WRITEB_WRITEABLE    8       // Direct IO is possible
-#define MTD_VOLATILE            16      // Set for RAMs
-#define MTD_XIP                 32      // eXecute-In-Place possible
-#define MTD_OOB                 64      // Out-of-band data (NAND flash)
-#define MTD_ECC                 128     // Device capable of automatic ECC
-#define MTD_NO_VIRTBLOCKS       256     // Virtual blocks not allowed
-#define MTD_PROGRAM_REGIONS     512     // Configurable Programming Regions
+
+#define MTD_WRITEABLE           0x400   /* Device is writeable */
+#define MTD_BIT_WRITEABLE       0x800   /* Single bits can be flipped */
+#define MTD_NO_ERASE            0x1000  /* No erase necessary */
 
 // Some common devices / combinations of capabilities
 #define MTD_CAP_ROM             0
-#define MTD_CAP_RAM             (MTD_CLEAR_BITS|MTD_SET_BITS|MTD_WRITEB_WRITEABLE)
-#define MTD_CAP_NORFLASH        (MTD_CLEAR_BITS|MTD_ERASEABLE)
-#define MTD_CAP_NANDFLASH       (MTD_CLEAR_BITS|MTD_ERASEABLE|MTD_OOB)
-#define MTD_WRITEABLE           (MTD_CLEAR_BITS|MTD_SET_BITS)
+#define MTD_CAP_RAM             (MTD_WRITEABLE | MTD_BIT_WRITEABLE | MTD_NO_ERASE)
+#define MTD_CAP_NORFLASH        (MTD_WRITEABLE | MTD_BIT_WRITEABLE)
+#define MTD_CAP_NANDFLASH       (MTD_WRITEABLE)
 
 
 // Types of automatic ECC/Checksum available
@@ -74,7 +64,7 @@ struct mtd_info_user {
         uint32_t flags;
         uint32_t size;   // Total size of the MTD
         uint32_t erasesize;
-        uint32_t oobblock;  // Size of OOB blocks (e.g. 512)
+        uint32_t writesize;
         uint32_t oobsize;   // Amount of OOB data per block (e.g. 16)
         uint32_t ecctype;
         uint32_t eccsize;
@@ -94,12 +84,12 @@ struct otp_info {
         uint32_t locked;
 };
 
-#define MEMGETINFO              _IOR('M', 1, struct mtd_info_user)
-#define MEMERASE                _IOW('M', 2, struct erase_info_user)
-#define MEMWRITEOOB             _IOWR('M', 3, struct mtd_oob_buf)
-#define MEMREADOOB              _IOWR('M', 4, struct mtd_oob_buf)
-#define MEMLOCK                 _IOW('M', 5, struct erase_info_user)
-#define MEMUNLOCK               _IOW('M', 6, struct erase_info_user)
+#define MEMGETINFO              _IOR('M', 1, struct mtd_info_user)
+#define MEMERASE                _IOW('M', 2, struct erase_info_user)
+#define MEMWRITEOOB             _IOWR('M', 3, struct mtd_oob_buf)
+#define MEMREADOOB              _IOWR('M', 4, struct mtd_oob_buf)
+#define MEMLOCK                 _IOW('M', 5, struct erase_info_user)
+#define MEMUNLOCK               _IOW('M', 6, struct erase_info_user)
 #define MEMGETREGIONCOUNT       _IOR('M', 7, int)
 #define MEMGETREGIONINFO        _IOWR('M', 8, struct region_info_user)
 #define MEMSETOOBSEL            _IOW('M', 9, struct nand_oobinfo)
@@ -109,8 +99,15 @@ struct otp_info {
 #define OTPSELECT               _IOR('M', 13, int)
 #define OTPGETREGIONCOUNT       _IOW('M', 14, int)
 #define OTPGETREGIONINFO        _IOW('M', 15, struct otp_info)
-#define OTPLOCK         _IOR('M', 16, struct otp_info)
+#define OTPLOCK                 _IOR('M', 16, struct otp_info)
+#define ECCGETLAYOUT            _IOR('M', 17, struct nand_ecclayout)
+#define ECCGETSTATS             _IOR('M', 18, struct mtd_ecc_stats)
+#define MTDFILEMODE             _IO('M', 19)
 
+/*
+ * Obsolete legacy interface. Keep it in order not to break userspace
+ * interfaces
+ */
 struct nand_oobinfo {
         uint32_t useecc;
         uint32_t eccbytes;
@@ -118,4 +115,46 @@ struct nand_oobinfo {
         uint32_t eccpos[32];
 };
 
+struct nand_oobfree {
+        uint32_t offset;
+        uint32_t length;
+};
+
+#define MTD_MAX_OOBFREE_ENTRIES 8
+/*
+ * ECC layout control structure. Exported to userspace for
+ * diagnosis and to allow creation of raw images
+ */
+struct nand_ecclayout {
+        uint32_t eccbytes;
+        uint32_t eccpos[64];
+        uint32_t oobavail;
+        struct nand_oobfree oobfree[MTD_MAX_OOBFREE_ENTRIES];
+};
+
+/**
+ * struct mtd_ecc_stats - error correction status
+ *
+ * @corrected:  number of corrected bits
+ * @failed:     number of uncorrectable errors
+ * @badblocks:  number of bad blocks in this partition
+ * @bbtblocks:  number of blocks reserved for bad block tables
+ */
+struct mtd_ecc_stats {
+        uint32_t corrected;
+        uint32_t failed;
+        uint32_t badblocks;
+        uint32_t bbtblocks;
+};
+
+/*
+ * Read/write file modes for access to MTD
+ */
+enum mtd_file_modes {
+        MTD_MODE_NORMAL = MTD_OTP_OFF,
+        MTD_MODE_OTP_FACTORY = MTD_OTP_FACTORY,
+        MTD_MODE_OTP_USER = MTD_OTP_USER,
+        MTD_MODE_RAW,
+};
+
 #endif /* __MTD_ABI_H__ */
diff --git a/include/mtd/mtd-user.h b/include/mtd/mtd-user.h
index 1c13fc7161fe..713f34d3e62e 100644
--- a/include/mtd/mtd-user.h
+++ b/include/mtd/mtd-user.h
@@ -16,5 +16,6 @@ typedef struct mtd_info_user mtd_info_t;
 typedef struct erase_info_user erase_info_t;
 typedef struct region_info_user region_info_t;
 typedef struct nand_oobinfo nand_oobinfo_t;
+typedef struct nand_ecclayout nand_ecclayout_t;
 
 #endif /* __MTD_USER_H__ */
diff --git a/include/net/addrconf.h b/include/net/addrconf.h
index 750e2508dd90..3d71251b3eca 100644
--- a/include/net/addrconf.h
+++ b/include/net/addrconf.h
@@ -45,7 +45,6 @@ struct prefix_info {
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/netdevice.h>
 #include <net/if_inet6.h>
 #include <net/ipv6.h>
diff --git a/include/net/af_unix.h b/include/net/af_unix.h
index 427dac94bc7e..795f81f9ec7f 100644
--- a/include/net/af_unix.h
+++ b/include/net/af_unix.h
@@ -1,7 +1,6 @@
 #ifndef __LINUX_NET_AFUNIX_H
 #define __LINUX_NET_AFUNIX_H
 
-#include <linux/config.h>
 #include <linux/socket.h>
 #include <linux/un.h>
 #include <linux/mutex.h>
diff --git a/include/net/ax25.h b/include/net/ax25.h
index 5bd997487054..7cd528e9d668 100644
--- a/include/net/ax25.h
+++ b/include/net/ax25.h
@@ -6,7 +6,6 @@
 #ifndef _AX25_H
 #define _AX25_H 
 
-#include <linux/config.h>
 #include <linux/ax25.h>
 #include <linux/spinlock.h>
 #include <linux/timer.h>
diff --git a/include/net/compat.h b/include/net/compat.h
index e65cbedb6abc..9859b60280d5 100644
--- a/include/net/compat.h
+++ b/include/net/compat.h
@@ -1,7 +1,6 @@
 #ifndef NET_COMPAT_H
 #define NET_COMPAT_H
 
-#include <linux/config.h>
 
 struct sock;
 
diff --git a/include/net/dst.h b/include/net/dst.h
index 5161e89017f9..36d54fc248b0 100644
--- a/include/net/dst.h
+++ b/include/net/dst.h
@@ -8,7 +8,6 @@
 #ifndef _NET_DST_H
 #define _NET_DST_H
 
-#include <linux/config.h>
 #include <linux/netdevice.h>
 #include <linux/rtnetlink.h>
 #include <linux/rcupdate.h>
diff --git a/include/net/icmp.h b/include/net/icmp.h
index e7c3f20fbafc..05f8ff7d9316 100644
--- a/include/net/icmp.h
+++ b/include/net/icmp.h
@@ -18,7 +18,6 @@
 #ifndef _ICMP_H
 #define _ICMP_H
 
-#include <linux/config.h>
 #include <linux/icmp.h>
 
 #include <net/inet_sock.h>
diff --git a/include/net/inet6_hashtables.h b/include/net/inet6_hashtables.h
index 59f0c83d55a2..bc6a71dce984 100644
--- a/include/net/inet6_hashtables.h
+++ b/include/net/inet6_hashtables.h
@@ -14,7 +14,6 @@
 #ifndef _INET6_HASHTABLES_H
 #define _INET6_HASHTABLES_H
 
-#include <linux/config.h>
 
 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
 #include <linux/in6.h>
diff --git a/include/net/inet_hashtables.h b/include/net/inet_hashtables.h
index 135d80fd658e..98e0bb3014fe 100644
--- a/include/net/inet_hashtables.h
+++ b/include/net/inet_hashtables.h
@@ -14,7 +14,6 @@
 #ifndef _INET_HASHTABLES_H
 #define _INET_HASHTABLES_H
 
-#include <linux/config.h>
 
 #include <linux/interrupt.h>
 #include <linux/ipv6.h>
diff --git a/include/net/inet_sock.h b/include/net/inet_sock.h
index 883eb529ef8e..1f4a9a60d4cc 100644
--- a/include/net/inet_sock.h
+++ b/include/net/inet_sock.h
@@ -16,7 +16,6 @@
 #ifndef _INET_SOCK_H
 #define _INET_SOCK_H
 
-#include <linux/config.h>
 
 #include <linux/string.h>
 #include <linux/types.h>
diff --git a/include/net/inet_timewait_sock.h b/include/net/inet_timewait_sock.h
index e837f98fdb50..600cb543550d 100644
--- a/include/net/inet_timewait_sock.h
+++ b/include/net/inet_timewait_sock.h
@@ -15,7 +15,6 @@
 #ifndef _INET_TIMEWAIT_SOCK_
 #define _INET_TIMEWAIT_SOCK_
 
-#include <linux/config.h>
 
 #include <linux/list.h>
 #include <linux/module.h>
diff --git a/include/net/ip.h b/include/net/ip.h
index ead233c9540d..98f908400771 100644
--- a/include/net/ip.h
+++ b/include/net/ip.h
@@ -22,7 +22,6 @@
 #ifndef _IP_H
 #define _IP_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/ip.h>
 #include <linux/in.h>
diff --git a/include/net/ip_fib.h b/include/net/ip_fib.h
index e000fa2cd5f6..a095d1dec7a4 100644
--- a/include/net/ip_fib.h
+++ b/include/net/ip_fib.h
@@ -16,7 +16,6 @@
 #ifndef _NET_IP_FIB_H
 #define _NET_IP_FIB_H
 
-#include <linux/config.h>
 #include <net/flow.h>
 #include <linux/seq_file.h>
 
diff --git a/include/net/ip_mp_alg.h b/include/net/ip_mp_alg.h
index 77225735cbd4..ac747b64734c 100644
--- a/include/net/ip_mp_alg.h
+++ b/include/net/ip_mp_alg.h
@@ -7,7 +7,6 @@
 #ifndef _NET_IP_MP_ALG_H
 #define _NET_IP_MP_ALG_H
 
-#include <linux/config.h>
 #include <linux/ip_mp_alg.h>
 #include <net/flow.h>
 #include <net/route.h>
diff --git a/include/net/ip_vs.h b/include/net/ip_vs.h
index 7d2674fde19a..3b57b159b653 100644
--- a/include/net/ip_vs.h
+++ b/include/net/ip_vs.h
@@ -248,7 +248,6 @@ struct ip_vs_daemon_user {
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/list.h>                 /* for struct list_head */
 #include <linux/spinlock.h>             /* for struct rwlock_t */
 #include <asm/atomic.h>                 /* for struct atomic_t */
diff --git a/include/net/ipv6.h b/include/net/ipv6.h
index 4abedb8eaece..a8fdf7970b37 100644
--- a/include/net/ipv6.h
+++ b/include/net/ipv6.h
@@ -104,7 +104,6 @@ struct frag_hdr {
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <net/sock.h>
 
 /* sysctls */
diff --git a/include/net/irda/irda.h b/include/net/irda/irda.h
index 1880e46ecc9b..1cb0607fcbb9 100644
--- a/include/net/irda/irda.h
+++ b/include/net/irda/irda.h
@@ -26,7 +26,6 @@
 #ifndef NET_IRDA_H
 #define NET_IRDA_H
 
-#include <linux/config.h>
 #include <linux/skbuff.h>               /* struct sk_buff */
 #include <linux/kernel.h>
 #include <linux/if.h>                   /* sa_family_t in <linux/irda.h> */
diff --git a/include/net/irda/irda_device.h b/include/net/irda/irda_device.h
index 92c828029cd8..0575c59a5c96 100644
--- a/include/net/irda/irda_device.h
+++ b/include/net/irda/irda_device.h
@@ -39,7 +39,6 @@
 #ifndef IRDA_DEVICE_H
 #define IRDA_DEVICE_H
 
-#include <linux/config.h>
 #include <linux/tty.h>
 #include <linux/netdevice.h>
 #include <linux/spinlock.h>
diff --git a/include/net/irda/irlap.h b/include/net/irda/irlap.h
index 2127cae1e0a6..e77eb88d9226 100644
--- a/include/net/irda/irlap.h
+++ b/include/net/irda/irlap.h
@@ -27,7 +27,6 @@
 #ifndef IRLAP_H
 #define IRLAP_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
diff --git a/include/net/irda/irlmp.h b/include/net/irda/irlmp.h
index c0c895d379ba..11ecfa58a648 100644
--- a/include/net/irda/irlmp.h
+++ b/include/net/irda/irlmp.h
@@ -29,7 +29,6 @@
 
 #include <asm/param.h>  /* for HZ */
 
-#include <linux/config.h>
 #include <linux/types.h>
 
 #include <net/irda/irda.h>
diff --git a/include/net/irda/irlmp_frame.h b/include/net/irda/irlmp_frame.h
index eb3ad158c023..c463f8bca856 100644
--- a/include/net/irda/irlmp_frame.h
+++ b/include/net/irda/irlmp_frame.h
@@ -26,7 +26,6 @@
 #ifndef IRMLP_FRAME_H
 #define IRMLP_FRAME_H
 
-#include <linux/config.h>
 #include <linux/skbuff.h>
 
 #include <net/irda/discovery.h>
diff --git a/include/net/irda/qos.h b/include/net/irda/qos.h
index 9ae3d6bc2423..cc577dc0a0ef 100644
--- a/include/net/irda/qos.h
+++ b/include/net/irda/qos.h
@@ -31,7 +31,6 @@
 #ifndef IRDA_QOS_H
 #define IRDA_QOS_H
 
-#include <linux/config.h>
 #include <linux/skbuff.h>
 
 #include <net/irda/parameters.h>
diff --git a/include/net/ndisc.h b/include/net/ndisc.h
index 91fa271a0064..d3915dabe6de 100644
--- a/include/net/ndisc.h
+++ b/include/net/ndisc.h
@@ -37,7 +37,6 @@ enum {
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 #include <linux/compiler.h>
 #include <linux/icmpv6.h>
 #include <linux/in6.h>
diff --git a/include/net/netfilter/nf_conntrack.h b/include/net/netfilter/nf_conntrack.h
index 411117815807..1fbd8193d5f1 100644
--- a/include/net/netfilter/nf_conntrack.h
+++ b/include/net/netfilter/nf_conntrack.h
@@ -15,7 +15,6 @@
 #include <linux/netfilter/nf_conntrack_common.h>
 
 #ifdef __KERNEL__
-#include <linux/config.h>
 #include <linux/bitops.h>
 #include <linux/compiler.h>
 #include <asm/atomic.h>
diff --git a/include/net/pkt_act.h b/include/net/pkt_act.h
index b225d8472b7e..cf5e4d2e4c21 100644
--- a/include/net/pkt_act.h
+++ b/include/net/pkt_act.h
@@ -4,7 +4,6 @@
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <linux/bitops.h>
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
diff --git a/include/net/protocol.h b/include/net/protocol.h
index 6dc5970612d7..bcaee39bd2ff 100644
--- a/include/net/protocol.h
+++ b/include/net/protocol.h
@@ -24,7 +24,6 @@
 #ifndef _PROTOCOL_H
 #define _PROTOCOL_H
 
-#include <linux/config.h>
 #include <linux/in6.h>
 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
 #include <linux/ipv6.h>
diff --git a/include/net/raw.h b/include/net/raw.h
index d83571fe4c69..e4af59781949 100644
--- a/include/net/raw.h
+++ b/include/net/raw.h
@@ -17,7 +17,6 @@
 #ifndef _RAW_H
 #define _RAW_H
 
-#include <linux/config.h>
 
 #include <net/protocol.h>
 
diff --git a/include/net/red.h b/include/net/red.h
index 2ed4358e3295..5ccdbb3d4722 100644
--- a/include/net/red.h
+++ b/include/net/red.h
@@ -1,7 +1,6 @@
 #ifndef __NET_SCHED_RED_H
 #define __NET_SCHED_RED_H
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <net/pkt_sched.h>
 #include <net/inet_ecn.h>
diff --git a/include/net/route.h b/include/net/route.h
index 98c915abdec8..c4a068692dcc 100644
--- a/include/net/route.h
+++ b/include/net/route.h
@@ -24,7 +24,6 @@
 #ifndef _ROUTE_H
 #define _ROUTE_H
 
-#include <linux/config.h>
 #include <net/dst.h>
 #include <net/inetpeer.h>
 #include <net/flow.h>
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index 7b6ec9986715..b0e9108a4e18 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -1,7 +1,6 @@
 #ifndef __NET_SCHED_GENERIC_H
 #define __NET_SCHED_GENERIC_H
 
-#include <linux/config.h>
 #include <linux/netdevice.h>
 #include <linux/types.h>
 #include <linux/rcupdate.h>
diff --git a/include/net/sctp/sctp.h b/include/net/sctp/sctp.h
index b2b40f951ae6..237f82b05e40 100644
--- a/include/net/sctp/sctp.h
+++ b/include/net/sctp/sctp.h
@@ -63,7 +63,6 @@
  */
 
 
-#include <linux/config.h>
 
 #ifdef TEST_FRAME
 #undef CONFIG_PROC_FS
diff --git a/include/net/sock.h b/include/net/sock.h
index 96565ff0de6a..d10dfecb6cbd 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -40,7 +40,6 @@
 #ifndef _SOCK_H
 #define _SOCK_H
 
-#include <linux/config.h>
 #include <linux/list.h>
 #include <linux/timer.h>
 #include <linux/cache.h>
diff --git a/include/net/tcp.h b/include/net/tcp.h
index bfc71f954bbe..5f4eb5c79689 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -21,7 +21,6 @@
 #define TCP_DEBUG 1
 #define FASTRETRANS_DEBUG 1
 
-#include <linux/config.h>
 #include <linux/list.h>
 #include <linux/tcp.h>
 #include <linux/slab.h>
diff --git a/include/pcmcia/ss.h b/include/pcmcia/ss.h
index 5e0a01ab2216..ede639812f8a 100644
--- a/include/pcmcia/ss.h
+++ b/include/pcmcia/ss.h
@@ -15,7 +15,6 @@
 #ifndef _LINUX_SS_H
 #define _LINUX_SS_H
 
-#include <linux/config.h>
 #include <linux/device.h>
 #include <linux/sched.h>        /* task_struct, completion */
 #include <linux/mutex.h>
diff --git a/include/scsi/scsi_transport_fc.h b/include/scsi/scsi_transport_fc.h
index 5626225bd3ae..6d28b0317657 100644
--- a/include/scsi/scsi_transport_fc.h
+++ b/include/scsi/scsi_transport_fc.h
@@ -27,7 +27,6 @@
 #ifndef SCSI_TRANSPORT_FC_H
 #define SCSI_TRANSPORT_FC_H
 
-#include <linux/config.h>
 #include <linux/sched.h>
 #include <scsi/scsi.h>
 
diff --git a/include/scsi/scsi_transport_spi.h b/include/scsi/scsi_transport_spi.h
index 5e1d61913d4e..302680c0c0de 100644
--- a/include/scsi/scsi_transport_spi.h
+++ b/include/scsi/scsi_transport_spi.h
@@ -20,7 +20,6 @@
 #ifndef SCSI_TRANSPORT_SPI_H
 #define SCSI_TRANSPORT_SPI_H
 
-#include <linux/config.h>
 #include <linux/transport_class.h>
 #include <linux/mutex.h>
 
diff --git a/include/sound/driver.h b/include/sound/driver.h
index 89c6a73f3920..3c522e59a33c 100644
--- a/include/sound/driver.h
+++ b/include/sound/driver.h
@@ -26,7 +26,6 @@
 #include "config.h"
 #endif
 
-#include <linux/config.h>
 
 /* number of supported soundcards */
 #ifdef CONFIG_SND_DYNAMIC_MINORS
diff --git a/include/sound/hdsp.h b/include/sound/hdsp.h
index 25e1951a9955..dec6b1dc37ea 100644
--- a/include/sound/hdsp.h
+++ b/include/sound/hdsp.h
@@ -30,13 +30,13 @@ enum HDSP_IO_Type {
 };
 
 struct hdsp_peak_rms {
-        u32 input_peaks[26];
-        u32 playback_peaks[26];
-        u32 output_peaks[28];
-        u64 input_rms[26];
-        u64 playback_rms[26];
+        __u32 input_peaks[26];
+        __u32 playback_peaks[26];
+        __u32 output_peaks[28];
+        __u64 input_rms[26];
+        __u64 playback_rms[26];
         /* These are only used for H96xx cards */
-        u64 output_rms[26];
+        __u64 output_rms[26];
 };
 
 #define SNDRV_HDSP_IOCTL_GET_PEAK_RMS _IOR('H', 0x40, struct hdsp_peak_rms)
diff --git a/include/video/edid.h b/include/video/edid.h
index b913f196131d..f6a42d6c2e2d 100644
--- a/include/video/edid.h
+++ b/include/video/edid.h
@@ -3,7 +3,6 @@
 
 #ifdef __KERNEL__
 
-#include <linux/config.h>
 
 #ifdef CONFIG_X86
 struct edid_info {
diff --git a/include/video/vga.h b/include/video/vga.h
index 700d6c8eb736..b49a5120ca2d 100644
--- a/include/video/vga.h
+++ b/include/video/vga.h
@@ -17,7 +17,6 @@
 #ifndef __linux_video_vga_h__
 #define __linux_video_vga_h__
 
-#include <linux/config.h>
 #include <linux/types.h>
 #include <asm/io.h>
 #ifndef CONFIG_AMIGA
diff --git a/init/Kconfig b/init/Kconfig
index 3b36a1d53656..df864a358221 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -182,7 +182,8 @@ config AUDITSYSCALL
         help
           Enable low-overhead system-call auditing infrastructure that
           can be used independently or with another kernel subsystem,
-          such as SELinux.
+          such as SELinux.  To use audit's filesystem watch feature, please
+          ensure that INOTIFY is configured.
 
 config IKCONFIG
         bool "Kernel .config support"
@@ -389,9 +390,6 @@ config SLOB
         default !SLAB
         bool
 
-config OBSOLETE_INTERMODULE
-        tristate
-
 menu "Loadable module support"
 
 config MODULES
diff --git a/init/do_mounts.c b/init/do_mounts.c
index f4b7b9d278cd..21b3b8f33a72 100644
--- a/init/do_mounts.c
+++ b/init/do_mounts.c
@@ -409,6 +409,10 @@ void __init prepare_namespace(void)
 
         if (saved_root_name[0]) {
                 root_device_name = saved_root_name;
+                if (!strncmp(root_device_name, "mtd", 3)) {
+                        mount_block_root(root_device_name, root_mountflags);
+                        goto out;
+                }
                 ROOT_DEV = name_to_dev_t(root_device_name);
                 if (strncmp(root_device_name, "/dev/", 5) == 0)
                         root_device_name += 5;
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index 41ecbd440fed..1511714a9585 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -8,6 +8,8 @@
  * Lockless receive & send, fd based notify:
  *                          Manfred Spraul          (manfred@colorfullife.com)
  *
+ * Audit:                   George Wilson           (ltcgcw@us.ibm.com)
+ *
  * This file is released under the GPL.
  */
 
@@ -24,6 +26,7 @@
 #include <linux/skbuff.h>
 #include <linux/netlink.h>
 #include <linux/syscalls.h>
+#include <linux/audit.h>
 #include <linux/signal.h>
 #include <linux/mutex.h>
 
@@ -657,6 +660,10 @@ asmlinkage long sys_mq_open(const char __user *u_name, int oflag, mode_t mode,
         char *name;
         int fd, error;
 
+        error = audit_mq_open(oflag, mode, u_attr);
+        if (error != 0)
+                return error;
+
         if (IS_ERR(name = getname(u_name)))
                 return PTR_ERR(name);
 
@@ -814,6 +821,10 @@ asmlinkage long sys_mq_timedsend(mqd_t mqdes, const char __user *u_msg_ptr,
         long timeout;
         int ret;
 
+        ret = audit_mq_timedsend(mqdes, msg_len, msg_prio, u_abs_timeout);
+        if (ret != 0)
+                return ret;
+
         if (unlikely(msg_prio >= (unsigned long) MQ_PRIO_MAX))
                 return -EINVAL;
 
@@ -896,6 +907,10 @@ asmlinkage ssize_t sys_mq_timedreceive(mqd_t mqdes, char __user *u_msg_ptr,
         struct mqueue_inode_info *info;
         struct ext_wait_queue wait;
 
+        ret = audit_mq_timedreceive(mqdes, msg_len, u_msg_prio, u_abs_timeout);
+        if (ret != 0)
+                return ret;
+
         timeout = prepare_timeout(u_abs_timeout);
 
         ret = -EBADF;
@@ -975,6 +990,10 @@ asmlinkage long sys_mq_notify(mqd_t mqdes,
         struct mqueue_inode_info *info;
         struct sk_buff *nc;
 
+        ret = audit_mq_notify(mqdes, u_notification);
+        if (ret != 0)
+                return ret;
+
         nc = NULL;
         sock = NULL;
         if (u_notification != NULL) {
@@ -1115,6 +1134,9 @@ asmlinkage long sys_mq_getsetattr(mqd_t mqdes,
         omqstat = info->attr;
         omqstat.mq_flags = filp->f_flags & O_NONBLOCK;
         if (u_mqstat) {
+                ret = audit_mq_getsetattr(mqdes, &mqstat);
+                if (ret != 0)
+                        goto out;
                 if (mqstat.mq_flags & O_NONBLOCK)
                         filp->f_flags |= O_NONBLOCK;
                 else
diff --git a/ipc/msg.c b/ipc/msg.c
index 7d1340ccb16b..00f015a092d2 100644
--- a/ipc/msg.c
+++ b/ipc/msg.c
@@ -454,6 +454,11 @@ asmlinkage long sys_msgctl (int msqid, int cmd, struct msqid_ds __user *buf)
         err = audit_ipc_obj(ipcp);
         if (err)
                 goto out_unlock_up;
+        if (cmd==IPC_SET) {
+                err = audit_ipc_set_perm(setbuf.qbytes, setbuf.uid, setbuf.gid, setbuf.mode);
+                if (err)
+                        goto out_unlock_up;
+        }
 
         err = -EPERM;
         if (current->euid != ipcp->cuid && 
@@ -468,10 +473,6 @@ asmlinkage long sys_msgctl (int msqid, int cmd, struct msqid_ds __user *buf)
         switch (cmd) {
         case IPC_SET:
         {
-                err = audit_ipc_set_perm(setbuf.qbytes, setbuf.uid, setbuf.gid, setbuf.mode, ipcp);
-                if (err)
-                        goto out_unlock_up;
-
                 err = -EPERM;
                 if (setbuf.qbytes > msg_ctlmnb && !capable(CAP_SYS_RESOURCE))
                         goto out_unlock_up;
diff --git a/ipc/sem.c b/ipc/sem.c
index 7919f8ece6ba..fce0bc8b5ad6 100644
--- a/ipc/sem.c
+++ b/ipc/sem.c
@@ -828,6 +828,11 @@ static int semctl_down(int semid, int semnum, int cmd, int version, union semun
         if (err)
                 goto out_unlock;
 
+        if (cmd == IPC_SET) {
+                err = audit_ipc_set_perm(0, setbuf.uid, setbuf.gid, setbuf.mode);
+                if (err)
+                        goto out_unlock;
+        }
         if (current->euid != ipcp->cuid && 
             current->euid != ipcp->uid && !capable(CAP_SYS_ADMIN)) {
                 err=-EPERM;
@@ -844,9 +849,6 @@ static int semctl_down(int semid, int semnum, int cmd, int version, union semun
                 err = 0;
                 break;
         case IPC_SET:
-                err = audit_ipc_set_perm(0, setbuf.uid, setbuf.gid, setbuf.mode, ipcp);
-                if (err)
-                        goto out_unlock;
                 ipcp->uid = setbuf.uid;
                 ipcp->gid = setbuf.gid;
                 ipcp->mode = (ipcp->mode & ~S_IRWXUGO)
diff --git a/ipc/shm.c b/ipc/shm.c
index 809896851902..4f133d24030f 100644
--- a/ipc/shm.c
+++ b/ipc/shm.c
@@ -643,7 +643,7 @@ asmlinkage long sys_shmctl (int shmid, int cmd, struct shmid_ds __user *buf)
                 err = audit_ipc_obj(&(shp->shm_perm));
                 if (err)
                         goto out_unlock_up;
-                err = audit_ipc_set_perm(0, setbuf.uid, setbuf.gid, setbuf.mode, &(shp->shm_perm));
+                err = audit_ipc_set_perm(0, setbuf.uid, setbuf.gid, setbuf.mode);
                 if (err)
                         goto out_unlock_up;
                 err=-EPERM;
diff --git a/kernel/Makefile b/kernel/Makefile
index 58908f9d156a..f6ef00f4f90f 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -20,7 +20,6 @@ obj-$(CONFIG_SMP) += cpu.o spinlock.o
 obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock.o
 obj-$(CONFIG_UID16) += uid16.o
 obj-$(CONFIG_MODULES) += module.o
-obj-$(CONFIG_OBSOLETE_INTERMODULE) += intermodule.o
 obj-$(CONFIG_KALLSYMS) += kallsyms.o
 obj-$(CONFIG_PM) += power/
 obj-$(CONFIG_BSD_PROCESS_ACCT) += acct.o
diff --git a/kernel/audit.c b/kernel/audit.c
index df57b493e1cb..7dfac7031bd7 100644
--- a/kernel/audit.c
+++ b/kernel/audit.c
@@ -56,6 +56,7 @@
 #include <linux/skbuff.h>
 #include <linux/netlink.h>
 #include <linux/selinux.h>
+#include <linux/inotify.h>
 
 #include "audit.h"
 
@@ -89,6 +90,7 @@ static int	audit_backlog_wait_overflow = 0;
 /* The identity of the user shutting down the audit system. */
 uid_t           audit_sig_uid = -1;
 pid_t           audit_sig_pid = -1;
+u32             audit_sig_sid = 0;
 
 /* Records can be lost in several ways:
    0) [suppressed in audit_alloc]
@@ -102,6 +104,12 @@ static atomic_t    audit_lost = ATOMIC_INIT(0);
 /* The netlink socket. */
 static struct sock *audit_sock;
 
+/* Inotify handle. */
+struct inotify_handle *audit_ih;
+
+/* Hash for inode-based rules */
+struct list_head audit_inode_hash[AUDIT_INODE_BUCKETS];
+
 /* The audit_freelist is a list of pre-allocated audit buffers (if more
  * than AUDIT_MAXFREE are in use, the audit buffer is freed instead of
  * being placed on the freelist). */
@@ -114,10 +122,8 @@ static struct task_struct *kauditd_task;
 static DECLARE_WAIT_QUEUE_HEAD(kauditd_wait);
 static DECLARE_WAIT_QUEUE_HEAD(audit_backlog_wait);
 
-/* The netlink socket is only to be read by 1 CPU, which lets us assume
- * that list additions and deletions never happen simultaneously in
- * auditsc.c */
-DEFINE_MUTEX(audit_netlink_mutex);
+/* Serialize requests from userspace. */
+static DEFINE_MUTEX(audit_cmd_mutex);
 
 /* AUDIT_BUFSIZ is the size of the temporary buffer used for formatting
  * audit records.  Since printk uses a 1024 byte buffer, this buffer
@@ -250,7 +256,7 @@ static int audit_set_rate_limit(int limit, uid_t loginuid, u32 sid)
                         "audit_rate_limit=%d old=%d by auid=%u",
                         limit, old, loginuid);
         audit_rate_limit = limit;
-        return old;
+        return 0;
 }
 
 static int audit_set_backlog_limit(int limit, uid_t loginuid, u32 sid)
@@ -273,7 +279,7 @@ static int audit_set_backlog_limit(int limit, uid_t loginuid, u32 sid)
                         "audit_backlog_limit=%d old=%d by auid=%u",
                         limit, old, loginuid);
         audit_backlog_limit = limit;
-        return old;
+        return 0;
 }
 
 static int audit_set_enabled(int state, uid_t loginuid, u32 sid)
@@ -299,7 +305,7 @@ static int audit_set_enabled(int state, uid_t loginuid, u32 sid)
                         "audit_enabled=%d old=%d by auid=%u",
                         state, old, loginuid);
         audit_enabled = state;
-        return old;
+        return 0;
 }
 
 static int audit_set_failure(int state, uid_t loginuid, u32 sid)
@@ -327,7 +333,7 @@ static int audit_set_failure(int state, uid_t loginuid, u32 sid)
                         "audit_failure=%d old=%d by auid=%u",
                         state, old, loginuid);
         audit_failure = state;
-        return old;
+        return 0;
 }
 
 static int kauditd_thread(void *dummy)
@@ -363,9 +369,52 @@ static int kauditd_thread(void *dummy)
                         remove_wait_queue(&kauditd_wait, &wait);
                 }
         }
+}
+
+int audit_send_list(void *_dest)
+{
+        struct audit_netlink_list *dest = _dest;
+        int pid = dest->pid;
+        struct sk_buff *skb;
+
+        /* wait for parent to finish and send an ACK */
+        mutex_lock(&audit_cmd_mutex);
+        mutex_unlock(&audit_cmd_mutex);
+
+        while ((skb = __skb_dequeue(&dest->q)) != NULL)
+                netlink_unicast(audit_sock, skb, pid, 0);
+
+        kfree(dest);
+
         return 0;
 }
 
+struct sk_buff *audit_make_reply(int pid, int seq, int type, int done,
+                                 int multi, void *payload, int size)
+{
+        struct sk_buff  *skb;
+        struct nlmsghdr *nlh;
+        int             len = NLMSG_SPACE(size);
+        void            *data;
+        int             flags = multi ? NLM_F_MULTI : 0;
+        int             t     = done  ? NLMSG_DONE  : type;
+
+        skb = alloc_skb(len, GFP_KERNEL);
+        if (!skb)
+                return NULL;
+
+        nlh              = NLMSG_PUT(skb, pid, seq, t, size);
+        nlh->nlmsg_flags = flags;
+        data             = NLMSG_DATA(nlh);
+        memcpy(data, payload, size);
+        return skb;
+
+nlmsg_failure:                  /* Used by NLMSG_PUT */
+        if (skb)
+                kfree_skb(skb);
+        return NULL;
+}
+
 /**
  * audit_send_reply - send an audit reply message via netlink
  * @pid: process id to send reply to
@@ -383,29 +432,13 @@ void audit_send_reply(int pid, int seq, int type, int done, int multi,
                       void *payload, int size)
 {
         struct sk_buff  *skb;
-        struct nlmsghdr *nlh;
-        int             len = NLMSG_SPACE(size);
-        void            *data;
-        int             flags = multi ? NLM_F_MULTI : 0;
-        int             t     = done  ? NLMSG_DONE  : type;
-
-        skb = alloc_skb(len, GFP_KERNEL);
+        skb = audit_make_reply(pid, seq, type, done, multi, payload, size);
         if (!skb)
                 return;
-
-        nlh              = NLMSG_PUT(skb, pid, seq, t, size);
-        nlh->nlmsg_flags = flags;
-        data             = NLMSG_DATA(nlh);
-        memcpy(data, payload, size);
-
         /* Ignore failure. It'll only happen if the sender goes away,
            because our timeout is set to infinite. */
         netlink_unicast(audit_sock, skb, pid, 0);
         return;
-
-nlmsg_failure:                  /* Used by NLMSG_PUT */
-        if (skb)
-                kfree_skb(skb);
 }
 
 /*
@@ -451,7 +484,9 @@ static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
         struct audit_buffer     *ab;
         u16                     msg_type = nlh->nlmsg_type;
         uid_t                   loginuid; /* loginuid of sender */
-        struct audit_sig_info   sig_data;
+        struct audit_sig_info   *sig_data;
+        char                    *ctx;
+        u32                     len;
 
         err = audit_netlink_ok(NETLINK_CB(skb).eff_cap, msg_type);
         if (err)
@@ -503,12 +538,9 @@ static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
                 if (status_get->mask & AUDIT_STATUS_PID) {
                         int old   = audit_pid;
                         if (sid) {
-                                char *ctx = NULL;
-                                u32 len;
-                                int rc;
-                                if ((rc = selinux_ctxid_to_string(
+                                if ((err = selinux_ctxid_to_string(
                                                 sid, &ctx, &len)))
-                                        return rc;
+                                        return err;
                                 else
                                         audit_log(NULL, GFP_KERNEL,
                                                 AUDIT_CONFIG_CHANGE,
@@ -523,10 +555,10 @@ static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
                         audit_pid = status_get->pid;
                 }
                 if (status_get->mask & AUDIT_STATUS_RATE_LIMIT)
-                        audit_set_rate_limit(status_get->rate_limit,
+                        err = audit_set_rate_limit(status_get->rate_limit,
                                                          loginuid, sid);
                 if (status_get->mask & AUDIT_STATUS_BACKLOG_LIMIT)
-                        audit_set_backlog_limit(status_get->backlog_limit,
+                        err = audit_set_backlog_limit(status_get->backlog_limit,
                                                         loginuid, sid);
                 break;
         case AUDIT_USER:
@@ -544,8 +576,6 @@ static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
                                                  "user pid=%d uid=%u auid=%u",
                                                  pid, uid, loginuid);
                                 if (sid) {
-                                        char *ctx = NULL;
-                                        u32 len;
                                         if (selinux_ctxid_to_string(
                                                         sid, &ctx, &len)) {
                                                 audit_log_format(ab, 
@@ -584,10 +614,21 @@ static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
                                            loginuid, sid);
                 break;
         case AUDIT_SIGNAL_INFO:
-                sig_data.uid = audit_sig_uid;
-                sig_data.pid = audit_sig_pid;
+                err = selinux_ctxid_to_string(audit_sig_sid, &ctx, &len);
+                if (err)
+                        return err;
+                sig_data = kmalloc(sizeof(*sig_data) + len, GFP_KERNEL);
+                if (!sig_data) {
+                        kfree(ctx);
+                        return -ENOMEM;
+                }
+                sig_data->uid = audit_sig_uid;
+                sig_data->pid = audit_sig_pid;
+                memcpy(sig_data->ctx, ctx, len);
+                kfree(ctx);
                 audit_send_reply(NETLINK_CB(skb).pid, seq, AUDIT_SIGNAL_INFO, 
-                                0, 0, &sig_data, sizeof(sig_data));
+                                0, 0, sig_data, sizeof(*sig_data) + len);
+                kfree(sig_data);
                 break;
         default:
                 err = -EINVAL;
@@ -629,20 +670,30 @@ static void audit_receive(struct sock *sk, int length)
         struct sk_buff  *skb;
         unsigned int qlen;
 
-        mutex_lock(&audit_netlink_mutex);
+        mutex_lock(&audit_cmd_mutex);
 
         for (qlen = skb_queue_len(&sk->sk_receive_queue); qlen; qlen--) {
                 skb = skb_dequeue(&sk->sk_receive_queue);
                 audit_receive_skb(skb);
                 kfree_skb(skb);
         }
-        mutex_unlock(&audit_netlink_mutex);
+        mutex_unlock(&audit_cmd_mutex);
 }
 
+#ifdef CONFIG_AUDITSYSCALL
+static const struct inotify_operations audit_inotify_ops = {
+        .handle_event   = audit_handle_ievent,
+        .destroy_watch  = audit_free_parent,
+};
+#endif
 
 /* Initialize audit support at boot time. */
 static int __init audit_init(void)
 {
+#ifdef CONFIG_AUDITSYSCALL
+        int i;
+#endif
+
         printk(KERN_INFO "audit: initializing netlink socket (%s)\n",
                audit_default ? "enabled" : "disabled");
         audit_sock = netlink_kernel_create(NETLINK_AUDIT, 0, audit_receive,
@@ -661,6 +712,16 @@ static int __init audit_init(void)
         selinux_audit_set_callback(&selinux_audit_rule_update);
 
         audit_log(NULL, GFP_KERNEL, AUDIT_KERNEL, "initialized");
+
+#ifdef CONFIG_AUDITSYSCALL
+        audit_ih = inotify_init(&audit_inotify_ops);
+        if (IS_ERR(audit_ih))
+                audit_panic("cannot initialize inotify handle");
+
+        for (i = 0; i < AUDIT_INODE_BUCKETS; i++)
+                INIT_LIST_HEAD(&audit_inode_hash[i]);
+#endif
+
         return 0;
 }
 __initcall(audit_init);
@@ -690,10 +751,12 @@ static void audit_buffer_free(struct audit_buffer *ab)
                 kfree_skb(ab->skb);
 
         spin_lock_irqsave(&audit_freelist_lock, flags);
-        if (++audit_freelist_count > AUDIT_MAXFREE)
+        if (audit_freelist_count > AUDIT_MAXFREE)
                 kfree(ab);
-        else
+        else {
+                audit_freelist_count++;
                 list_add(&ab->list, &audit_freelist);
+        }
         spin_unlock_irqrestore(&audit_freelist_lock, flags);
 }
 
@@ -988,28 +1051,76 @@ void audit_log_hex(struct audit_buffer *ab, const unsigned char *buf,
         skb_put(skb, len << 1); /* new string is twice the old string */
 }
 
+/*
+ * Format a string of no more than slen characters into the audit buffer,
+ * enclosed in quote marks.
+ */
+static void audit_log_n_string(struct audit_buffer *ab, size_t slen,
+                               const char *string)
+{
+        int avail, new_len;
+        unsigned char *ptr;
+        struct sk_buff *skb;
+
+        BUG_ON(!ab->skb);
+        skb = ab->skb;
+        avail = skb_tailroom(skb);
+        new_len = slen + 3;     /* enclosing quotes + null terminator */
+        if (new_len > avail) {
+                avail = audit_expand(ab, new_len);
+                if (!avail)
+                        return;
+        }
+        ptr = skb->tail;
+        *ptr++ = '"';
+        memcpy(ptr, string, slen);
+        ptr += slen;
+        *ptr++ = '"';
+        *ptr = 0;
+        skb_put(skb, slen + 2); /* don't include null terminator */
+}
+
 /**
- * audit_log_unstrustedstring - log a string that may contain random characters
+ * audit_log_n_unstrustedstring - log a string that may contain random characters
  * @ab: audit_buffer
+ * @len: lenth of string (not including trailing null)
  * @string: string to be logged
  *
  * This code will escape a string that is passed to it if the string
  * contains a control character, unprintable character, double quote mark,
  * or a space. Unescaped strings will start and end with a double quote mark.
  * Strings that are escaped are printed in hex (2 digits per char).
+ *
+ * The caller specifies the number of characters in the string to log, which may
+ * or may not be the entire string.
  */
-void audit_log_untrustedstring(struct audit_buffer *ab, const char *string)
+const char *audit_log_n_untrustedstring(struct audit_buffer *ab, size_t len,
+                                        const char *string)
 {
         const unsigned char *p = string;
 
         while (*p) {
                 if (*p == '"' || *p < 0x21 || *p > 0x7f) {
-                        audit_log_hex(ab, string, strlen(string));
-                        return;
+                        audit_log_hex(ab, string, len);
+                        return string + len + 1;
                 }
                 p++;
         }
-        audit_log_format(ab, "\"%s\"", string);
+        audit_log_n_string(ab, len, string);
+        return p + 1;
+}
+
+/**
+ * audit_log_unstrustedstring - log a string that may contain random characters
+ * @ab: audit_buffer
+ * @string: string to be logged
+ *
+ * Same as audit_log_n_unstrustedstring(), except that strlen is used to
+ * determine string length.
+ */
+const char *audit_log_untrustedstring(struct audit_buffer *ab, const char *string)
+{
+        return audit_log_n_untrustedstring(ab, strlen(string), string);
 }
 
 /* This is a helper-function to print the escaped d_path */
diff --git a/kernel/audit.h b/kernel/audit.h
index 6f733920fd32..8323e4132a33 100644
--- a/kernel/audit.h
+++ b/kernel/audit.h
@@ -19,9 +19,9 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include <linux/mutex.h>
 #include <linux/fs.h>
 #include <linux/audit.h>
+#include <linux/skbuff.h>
 
 /* 0 = no checking
    1 = put_count checking
@@ -53,6 +53,18 @@ enum audit_state {
 };
 
 /* Rule lists */
+struct audit_parent;
+
+struct audit_watch {
+        atomic_t                count;  /* reference count */
+        char                    *path;  /* insertion path */
+        dev_t                   dev;    /* associated superblock device */
+        unsigned long           ino;    /* associated inode number */
+        struct audit_parent     *parent; /* associated parent */
+        struct list_head        wlist;  /* entry in parent->watches list */
+        struct list_head        rules;  /* associated rules */
+};
+
 struct audit_field {
         u32                             type;
         u32                             val;
@@ -70,6 +82,9 @@ struct audit_krule {
         u32                     buflen; /* for data alloc on list rules */
         u32                     field_count;
         struct audit_field      *fields;
+        struct audit_field      *inode_f; /* quick access to an inode field */
+        struct audit_watch      *watch; /* associated watch */
+        struct list_head        rlist;  /* entry in audit_watch.rules list */
 };
 
 struct audit_entry {
@@ -78,15 +93,53 @@ struct audit_entry {
         struct audit_krule      rule;
 };
 
-
 extern int audit_pid;
-extern int audit_comparator(const u32 left, const u32 op, const u32 right);
 
+#define AUDIT_INODE_BUCKETS     32
+extern struct list_head audit_inode_hash[AUDIT_INODE_BUCKETS];
+
+static inline int audit_hash_ino(u32 ino)
+{
+        return (ino & (AUDIT_INODE_BUCKETS-1));
+}
+
+extern int audit_comparator(const u32 left, const u32 op, const u32 right);
+extern int audit_compare_dname_path(const char *dname, const char *path,
+                                    int *dirlen);
+extern struct sk_buff *     audit_make_reply(int pid, int seq, int type,
+                                             int done, int multi,
+                                             void *payload, int size);
 extern void                 audit_send_reply(int pid, int seq, int type,
                                              int done, int multi,
                                              void *payload, int size);
 extern void                 audit_log_lost(const char *message);
 extern void                 audit_panic(const char *message);
-extern struct mutex audit_netlink_mutex;
 
+struct audit_netlink_list {
+        int pid;
+        struct sk_buff_head q;
+};
+
+int audit_send_list(void *);
+
+struct inotify_watch;
+extern void audit_free_parent(struct inotify_watch *);
+extern void audit_handle_ievent(struct inotify_watch *, u32, u32, u32,
+                                const char *, struct inode *);
 extern int selinux_audit_rule_update(void);
+
+#ifdef CONFIG_AUDITSYSCALL
+extern void __audit_signal_info(int sig, struct task_struct *t);
+static inline void audit_signal_info(int sig, struct task_struct *t)
+{
+        if (unlikely(audit_pid && t->tgid == audit_pid))
+                __audit_signal_info(sig, t);
+}
+extern enum audit_state audit_filter_inodes(struct task_struct *,
+                                            struct audit_context *);
+extern void audit_set_auditable(struct audit_context *);
+#else
+#define audit_signal_info(s,t)
+#define audit_filter_inodes(t,c) AUDIT_DISABLED
+#define audit_set_auditable(c)
+#endif
diff --git a/kernel/auditfilter.c b/kernel/auditfilter.c
index 7c134906d689..4c99d2c586ed 100644
--- a/kernel/auditfilter.c
+++ b/kernel/auditfilter.c
@@ -22,13 +22,59 @@
 #include <linux/kernel.h>
 #include <linux/audit.h>
 #include <linux/kthread.h>
+#include <linux/mutex.h>
+#include <linux/fs.h>
+#include <linux/namei.h>
 #include <linux/netlink.h>
+#include <linux/sched.h>
+#include <linux/inotify.h>
 #include <linux/selinux.h>
 #include "audit.h"
 
-/* There are three lists of rules -- one to search at task creation
- * time, one to search at syscall entry time, and another to search at
- * syscall exit time. */
+/*
+ * Locking model:
+ *
+ * audit_filter_mutex:
+ *              Synchronizes writes and blocking reads of audit's filterlist
+ *              data.  Rcu is used to traverse the filterlist and access
+ *              contents of structs audit_entry, audit_watch and opaque
+ *              selinux rules during filtering.  If modified, these structures
+ *              must be copied and replace their counterparts in the filterlist.
+ *              An audit_parent struct is not accessed during filtering, so may
+ *              be written directly provided audit_filter_mutex is held.
+ */
+
+/*
+ * Reference counting:
+ *
+ * audit_parent: lifetime is from audit_init_parent() to receipt of an IN_IGNORED
+ *      event.  Each audit_watch holds a reference to its associated parent.
+ *
+ * audit_watch: if added to lists, lifetime is from audit_init_watch() to
+ *      audit_remove_watch().  Additionally, an audit_watch may exist
+ *      temporarily to assist in searching existing filter data.  Each
+ *      audit_krule holds a reference to its associated watch.
+ */
+
+struct audit_parent {
+        struct list_head        ilist;  /* entry in inotify registration list */
+        struct list_head        watches; /* associated watches */
+        struct inotify_watch    wdata;  /* inotify watch data */
+        unsigned                flags;  /* status flags */
+};
+
+/*
+ * audit_parent status flags:
+ *
+ * AUDIT_PARENT_INVALID - set anytime rules/watches are auto-removed due to
+ * a filesystem event to ensure we're adding audit watches to a valid parent.
+ * Technically not needed for IN_DELETE_SELF or IN_UNMOUNT events, as we cannot
+ * receive them while we have nameidata, but must be used for IN_MOVE_SELF which
+ * we can receive while holding nameidata.
+ */
+#define AUDIT_PARENT_INVALID    0x001
+
+/* Audit filter lists, defined in <linux/audit.h> */
 struct list_head audit_filter_list[AUDIT_NR_FILTERS] = {
         LIST_HEAD_INIT(audit_filter_list[0]),
         LIST_HEAD_INIT(audit_filter_list[1]),
@@ -41,9 +87,53 @@ struct list_head audit_filter_list[AUDIT_NR_FILTERS] = {
 #endif
 };
 
+static DEFINE_MUTEX(audit_filter_mutex);
+
+/* Inotify handle */
+extern struct inotify_handle *audit_ih;
+
+/* Inotify events we care about. */
+#define AUDIT_IN_WATCH IN_MOVE|IN_CREATE|IN_DELETE|IN_DELETE_SELF|IN_MOVE_SELF
+
+void audit_free_parent(struct inotify_watch *i_watch)
+{
+        struct audit_parent *parent;
+
+        parent = container_of(i_watch, struct audit_parent, wdata);
+        WARN_ON(!list_empty(&parent->watches));
+        kfree(parent);
+}
+
+static inline void audit_get_watch(struct audit_watch *watch)
+{
+        atomic_inc(&watch->count);
+}
+
+static void audit_put_watch(struct audit_watch *watch)
+{
+        if (atomic_dec_and_test(&watch->count)) {
+                WARN_ON(watch->parent);
+                WARN_ON(!list_empty(&watch->rules));
+                kfree(watch->path);
+                kfree(watch);
+        }
+}
+
+static void audit_remove_watch(struct audit_watch *watch)
+{
+        list_del(&watch->wlist);
+        put_inotify_watch(&watch->parent->wdata);
+        watch->parent = NULL;
+        audit_put_watch(watch); /* match initial get */
+}
+
 static inline void audit_free_rule(struct audit_entry *e)
 {
         int i;
+
+        /* some rules don't have associated watches */
+        if (e->rule.watch)
+                audit_put_watch(e->rule.watch);
         if (e->rule.fields)
                 for (i = 0; i < e->rule.field_count; i++) {
                         struct audit_field *f = &e->rule.fields[i];
@@ -60,6 +150,50 @@ static inline void audit_free_rule_rcu(struct rcu_head *head)
         audit_free_rule(e);
 }
 
+/* Initialize a parent watch entry. */
+static struct audit_parent *audit_init_parent(struct nameidata *ndp)
+{
+        struct audit_parent *parent;
+        s32 wd;
+
+        parent = kzalloc(sizeof(*parent), GFP_KERNEL);
+        if (unlikely(!parent))
+                return ERR_PTR(-ENOMEM);
+
+        INIT_LIST_HEAD(&parent->watches);
+        parent->flags = 0;
+
+        inotify_init_watch(&parent->wdata);
+        /* grab a ref so inotify watch hangs around until we take audit_filter_mutex */
+        get_inotify_watch(&parent->wdata);
+        wd = inotify_add_watch(audit_ih, &parent->wdata, ndp->dentry->d_inode,
+                               AUDIT_IN_WATCH);
+        if (wd < 0) {
+                audit_free_parent(&parent->wdata);
+                return ERR_PTR(wd);
+        }
+
+        return parent;
+}
+
+/* Initialize a watch entry. */
+static struct audit_watch *audit_init_watch(char *path)
+{
+        struct audit_watch *watch;
+
+        watch = kzalloc(sizeof(*watch), GFP_KERNEL);
+        if (unlikely(!watch))
+                return ERR_PTR(-ENOMEM);
+
+        INIT_LIST_HEAD(&watch->rules);
+        atomic_set(&watch->count, 1);
+        watch->path = path;
+        watch->dev = (dev_t)-1;
+        watch->ino = (unsigned long)-1;
+
+        return watch;
+}
+
 /* Initialize an audit filterlist entry. */
 static inline struct audit_entry *audit_init_entry(u32 field_count)
 {
@@ -107,6 +241,43 @@ static char *audit_unpack_string(void **bufp, size_t *remain, size_t len)
         return str;
 }
 
+/* Translate an inode field to kernel respresentation. */
+static inline int audit_to_inode(struct audit_krule *krule,
+                                 struct audit_field *f)
+{
+        if (krule->listnr != AUDIT_FILTER_EXIT ||
+            krule->watch || krule->inode_f)
+                return -EINVAL;
+
+        krule->inode_f = f;
+        return 0;
+}
+
+/* Translate a watch string to kernel respresentation. */
+static int audit_to_watch(struct audit_krule *krule, char *path, int len,
+                          u32 op)
+{
+        struct audit_watch *watch;
+
+        if (!audit_ih)
+                return -EOPNOTSUPP;
+
+        if (path[0] != '/' || path[len-1] == '/' ||
+            krule->listnr != AUDIT_FILTER_EXIT ||
+            op & ~AUDIT_EQUAL ||
+            krule->inode_f || krule->watch) /* 1 inode # per rule, for hash */
+                return -EINVAL;
+
+        watch = audit_init_watch(path);
+        if (unlikely(IS_ERR(watch)))
+                return PTR_ERR(watch);
+
+        audit_get_watch(watch);
+        krule->watch = watch;
+
+        return 0;
+}
+
 /* Common user-space to kernel rule translation. */
 static inline struct audit_entry *audit_to_entry_common(struct audit_rule *rule)
 {
@@ -128,8 +299,11 @@ static inline struct audit_entry *audit_to_entry_common(struct audit_rule *rule)
 #endif
                 ;
         }
-        if (rule->action != AUDIT_NEVER && rule->action != AUDIT_POSSIBLE &&
-            rule->action != AUDIT_ALWAYS)
+        if (unlikely(rule->action == AUDIT_POSSIBLE)) {
+                printk(KERN_ERR "AUDIT_POSSIBLE is deprecated\n");
+                goto exit_err;
+        }
+        if (rule->action != AUDIT_NEVER && rule->action != AUDIT_ALWAYS)
                 goto exit_err;
         if (rule->field_count > AUDIT_MAX_FIELDS)
                 goto exit_err;
@@ -158,6 +332,7 @@ exit_err:
 static struct audit_entry *audit_rule_to_entry(struct audit_rule *rule)
 {
         struct audit_entry *entry;
+        struct audit_field *f;
         int err = 0;
         int i;
 
@@ -172,14 +347,37 @@ static struct audit_entry *audit_rule_to_entry(struct audit_rule *rule)
                 f->type = rule->fields[i] & ~(AUDIT_NEGATE|AUDIT_OPERATORS);
                 f->val = rule->values[i];
 
-                if (f->type & AUDIT_UNUSED_BITS ||
-                    f->type == AUDIT_SE_USER ||
-                    f->type == AUDIT_SE_ROLE ||
-                    f->type == AUDIT_SE_TYPE ||
-                    f->type == AUDIT_SE_SEN ||
-                    f->type == AUDIT_SE_CLR) {
-                        err = -EINVAL;
+                err = -EINVAL;
+                switch(f->type) {
+                default:
                         goto exit_free;
+                case AUDIT_PID:
+                case AUDIT_UID:
+                case AUDIT_EUID:
+                case AUDIT_SUID:
+                case AUDIT_FSUID:
+                case AUDIT_GID:
+                case AUDIT_EGID:
+                case AUDIT_SGID:
+                case AUDIT_FSGID:
+                case AUDIT_LOGINUID:
+                case AUDIT_PERS:
+                case AUDIT_ARCH:
+                case AUDIT_MSGTYPE:
+                case AUDIT_DEVMAJOR:
+                case AUDIT_DEVMINOR:
+                case AUDIT_EXIT:
+                case AUDIT_SUCCESS:
+                case AUDIT_ARG0:
+                case AUDIT_ARG1:
+                case AUDIT_ARG2:
+                case AUDIT_ARG3:
+                        break;
+                case AUDIT_INODE:
+                        err = audit_to_inode(&entry->rule, f);
+                        if (err)
+                                goto exit_free;
+                        break;
                 }
 
                 entry->rule.vers_ops = (f->op & AUDIT_OPERATORS) ? 2 : 1;
@@ -196,6 +394,18 @@ static struct audit_entry *audit_rule_to_entry(struct audit_rule *rule)
                 }
         }
 
+        f = entry->rule.inode_f;
+        if (f) {
+                switch(f->op) {
+                case AUDIT_NOT_EQUAL:
+                        entry->rule.inode_f = NULL;
+                case AUDIT_EQUAL:
+                        break;
+                default:
+                        goto exit_free;
+                }
+        }
+
 exit_nofree:
         return entry;
 
@@ -210,6 +420,7 @@ static struct audit_entry *audit_data_to_entry(struct audit_rule_data *data,
 {
         int err = 0;
         struct audit_entry *entry;
+        struct audit_field *f;
         void *bufp;
         size_t remain = datasz - sizeof(struct audit_rule_data);
         int i;
@@ -235,6 +446,29 @@ static struct audit_entry *audit_data_to_entry(struct audit_rule_data *data,
                 f->se_str = NULL;
                 f->se_rule = NULL;
                 switch(f->type) {
+                case AUDIT_PID:
+                case AUDIT_UID:
+                case AUDIT_EUID:
+                case AUDIT_SUID:
+                case AUDIT_FSUID:
+                case AUDIT_GID:
+                case AUDIT_EGID:
+                case AUDIT_SGID:
+                case AUDIT_FSGID:
+                case AUDIT_LOGINUID:
+                case AUDIT_PERS:
+                case AUDIT_ARCH:
+                case AUDIT_MSGTYPE:
+                case AUDIT_PPID:
+                case AUDIT_DEVMAJOR:
+                case AUDIT_DEVMINOR:
+                case AUDIT_EXIT:
+                case AUDIT_SUCCESS:
+                case AUDIT_ARG0:
+                case AUDIT_ARG1:
+                case AUDIT_ARG2:
+                case AUDIT_ARG3:
+                        break;
                 case AUDIT_SE_USER:
                 case AUDIT_SE_ROLE:
                 case AUDIT_SE_TYPE:
@@ -260,6 +494,37 @@ static struct audit_entry *audit_data_to_entry(struct audit_rule_data *data,
                         } else
                                 f->se_str = str;
                         break;
+                case AUDIT_WATCH:
+                        str = audit_unpack_string(&bufp, &remain, f->val);
+                        if (IS_ERR(str))
+                                goto exit_free;
+                        entry->rule.buflen += f->val;
+
+                        err = audit_to_watch(&entry->rule, str, f->val, f->op);
+                        if (err) {
+                                kfree(str);
+                                goto exit_free;
+                        }
+                        break;
+                case AUDIT_INODE:
+                        err = audit_to_inode(&entry->rule, f);
+                        if (err)
+                                goto exit_free;
+                        break;
+                default:
+                        goto exit_free;
+                }
+        }
+
+        f = entry->rule.inode_f;
+        if (f) {
+                switch(f->op) {
+                case AUDIT_NOT_EQUAL:
+                        entry->rule.inode_f = NULL;
+                case AUDIT_EQUAL:
+                        break;
+                default:
+                        goto exit_free;
                 }
         }
 
@@ -291,7 +556,7 @@ static struct audit_rule *audit_krule_to_rule(struct audit_krule *krule)
 
         rule = kmalloc(sizeof(*rule), GFP_KERNEL);
         if (unlikely(!rule))
-                return ERR_PTR(-ENOMEM);
+                return NULL;
         memset(rule, 0, sizeof(*rule));
 
         rule->flags = krule->flags | krule->listnr;
@@ -322,7 +587,7 @@ static struct audit_rule_data *audit_krule_to_data(struct audit_krule *krule)
 
         data = kmalloc(sizeof(*data) + krule->buflen, GFP_KERNEL);
         if (unlikely(!data))
-                return ERR_PTR(-ENOMEM);
+                return NULL;
         memset(data, 0, sizeof(*data));
 
         data->flags = krule->flags | krule->listnr;
@@ -343,6 +608,10 @@ static struct audit_rule_data *audit_krule_to_data(struct audit_krule *krule)
                         data->buflen += data->values[i] =
                                 audit_pack_string(&bufp, f->se_str);
                         break;
+                case AUDIT_WATCH:
+                        data->buflen += data->values[i] =
+                                audit_pack_string(&bufp, krule->watch->path);
+                        break;
                 default:
                         data->values[i] = f->val;
                 }
@@ -378,6 +647,10 @@ static int audit_compare_rule(struct audit_krule *a, struct audit_krule *b)
                         if (strcmp(a->fields[i].se_str, b->fields[i].se_str))
                                 return 1;
                         break;
+                case AUDIT_WATCH:
+                        if (strcmp(a->watch->path, b->watch->path))
+                                return 1;
+                        break;
                 default:
                         if (a->fields[i].val != b->fields[i].val)
                                 return 1;
@@ -391,6 +664,32 @@ static int audit_compare_rule(struct audit_krule *a, struct audit_krule *b)
         return 0;
 }
 
+/* Duplicate the given audit watch.  The new watch's rules list is initialized
+ * to an empty list and wlist is undefined. */
+static struct audit_watch *audit_dupe_watch(struct audit_watch *old)
+{
+        char *path;
+        struct audit_watch *new;
+
+        path = kstrdup(old->path, GFP_KERNEL);
+        if (unlikely(!path))
+                return ERR_PTR(-ENOMEM);
+
+        new = audit_init_watch(path);
+        if (unlikely(IS_ERR(new))) {
+                kfree(path);
+                goto out;
+        }
+
+        new->dev = old->dev;
+        new->ino = old->ino;
+        get_inotify_watch(&old->parent->wdata);
+        new->parent = old->parent;
+
+out:
+        return new;
+}
+
 /* Duplicate selinux field information.  The se_rule is opaque, so must be
  * re-initialized. */
 static inline int audit_dupe_selinux_field(struct audit_field *df,
@@ -422,8 +721,11 @@ static inline int audit_dupe_selinux_field(struct audit_field *df,
 /* Duplicate an audit rule.  This will be a deep copy with the exception
  * of the watch - that pointer is carried over.  The selinux specific fields
  * will be updated in the copy.  The point is to be able to replace the old
- * rule with the new rule in the filterlist, then free the old rule. */
-static struct audit_entry *audit_dupe_rule(struct audit_krule *old)
+ * rule with the new rule in the filterlist, then free the old rule.
+ * The rlist element is undefined; list manipulations are handled apart from
+ * the initial copy. */
+static struct audit_entry *audit_dupe_rule(struct audit_krule *old,
+                                           struct audit_watch *watch)
 {
         u32 fcount = old->field_count;
         struct audit_entry *entry;
@@ -442,6 +744,8 @@ static struct audit_entry *audit_dupe_rule(struct audit_krule *old)
         for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
                 new->mask[i] = old->mask[i];
         new->buflen = old->buflen;
+        new->inode_f = old->inode_f;
+        new->watch = NULL;
         new->field_count = old->field_count;
         memcpy(new->fields, old->fields, sizeof(struct audit_field) * fcount);
 
@@ -463,68 +767,409 @@ static struct audit_entry *audit_dupe_rule(struct audit_krule *old)
                 }
         }
 
+        if (watch) {
+                audit_get_watch(watch);
+                new->watch = watch;
+        }
+
         return entry;
 }
 
-/* Add rule to given filterlist if not a duplicate.  Protected by
- * audit_netlink_mutex. */
+/* Update inode info in audit rules based on filesystem event. */
+static void audit_update_watch(struct audit_parent *parent,
+                               const char *dname, dev_t dev,
+                               unsigned long ino, unsigned invalidating)
+{
+        struct audit_watch *owatch, *nwatch, *nextw;
+        struct audit_krule *r, *nextr;
+        struct audit_entry *oentry, *nentry;
+        struct audit_buffer *ab;
+
+        mutex_lock(&audit_filter_mutex);
+        list_for_each_entry_safe(owatch, nextw, &parent->watches, wlist) {
+                if (audit_compare_dname_path(dname, owatch->path, NULL))
+                        continue;
+
+                /* If the update involves invalidating rules, do the inode-based
+                 * filtering now, so we don't omit records. */
+                if (invalidating &&
+                    audit_filter_inodes(current, current->audit_context) == AUDIT_RECORD_CONTEXT)
+                        audit_set_auditable(current->audit_context);
+
+                nwatch = audit_dupe_watch(owatch);
+                if (unlikely(IS_ERR(nwatch))) {
+                        mutex_unlock(&audit_filter_mutex);
+                        audit_panic("error updating watch, skipping");
+                        return;
+                }
+                nwatch->dev = dev;
+                nwatch->ino = ino;
+
+                list_for_each_entry_safe(r, nextr, &owatch->rules, rlist) {
+
+                        oentry = container_of(r, struct audit_entry, rule);
+                        list_del(&oentry->rule.rlist);
+                        list_del_rcu(&oentry->list);
+
+                        nentry = audit_dupe_rule(&oentry->rule, nwatch);
+                        if (unlikely(IS_ERR(nentry)))
+                                audit_panic("error updating watch, removing");
+                        else {
+                                int h = audit_hash_ino((u32)ino);
+                                list_add(&nentry->rule.rlist, &nwatch->rules);
+                                list_add_rcu(&nentry->list, &audit_inode_hash[h]);
+                        }
+
+                        call_rcu(&oentry->rcu, audit_free_rule_rcu);
+                }
+
+                ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE);
+                audit_log_format(ab, "audit updated rules specifying watch=");
+                audit_log_untrustedstring(ab, owatch->path);
+                audit_log_format(ab, " with dev=%u ino=%lu\n", dev, ino);
+                audit_log_end(ab);
+
+                audit_remove_watch(owatch);
+                goto add_watch_to_parent; /* event applies to a single watch */
+        }
+        mutex_unlock(&audit_filter_mutex);
+        return;
+
+add_watch_to_parent:
+        list_add(&nwatch->wlist, &parent->watches);
+        mutex_unlock(&audit_filter_mutex);
+        return;
+}
+
+/* Remove all watches & rules associated with a parent that is going away. */
+static void audit_remove_parent_watches(struct audit_parent *parent)
+{
+        struct audit_watch *w, *nextw;
+        struct audit_krule *r, *nextr;
+        struct audit_entry *e;
+
+        mutex_lock(&audit_filter_mutex);
+        parent->flags |= AUDIT_PARENT_INVALID;
+        list_for_each_entry_safe(w, nextw, &parent->watches, wlist) {
+                list_for_each_entry_safe(r, nextr, &w->rules, rlist) {
+                        e = container_of(r, struct audit_entry, rule);
+                        list_del(&r->rlist);
+                        list_del_rcu(&e->list);
+                        call_rcu(&e->rcu, audit_free_rule_rcu);
+
+                        audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
+                                 "audit implicitly removed rule from list=%d\n",
+                                  AUDIT_FILTER_EXIT);
+                }
+                audit_remove_watch(w);
+        }
+        mutex_unlock(&audit_filter_mutex);
+}
+
+/* Unregister inotify watches for parents on in_list.
+ * Generates an IN_IGNORED event. */
+static void audit_inotify_unregister(struct list_head *in_list)
+{
+        struct audit_parent *p, *n;
+
+        list_for_each_entry_safe(p, n, in_list, ilist) {
+                list_del(&p->ilist);
+                inotify_rm_watch(audit_ih, &p->wdata);
+                /* the put matching the get in audit_do_del_rule() */
+                put_inotify_watch(&p->wdata);
+        }
+}
+
+/* Find an existing audit rule.
+ * Caller must hold audit_filter_mutex to prevent stale rule data. */
+static struct audit_entry *audit_find_rule(struct audit_entry *entry,
+                                           struct list_head *list)
+{
+        struct audit_entry *e, *found = NULL;
+        int h;
+
+        if (entry->rule.watch) {
+                /* we don't know the inode number, so must walk entire hash */
+                for (h = 0; h < AUDIT_INODE_BUCKETS; h++) {
+                        list = &audit_inode_hash[h];
+                        list_for_each_entry(e, list, list)
+                                if (!audit_compare_rule(&entry->rule, &e->rule)) {
+                                        found = e;
+                                        goto out;
+                                }
+                }
+                goto out;
+        }
+
+        list_for_each_entry(e, list, list)
+                if (!audit_compare_rule(&entry->rule, &e->rule)) {
+                        found = e;
+                        goto out;
+                }
+
+out:
+        return found;
+}
+
+/* Get path information necessary for adding watches. */
+static int audit_get_nd(char *path, struct nameidata **ndp,
+                        struct nameidata **ndw)
+{
+        struct nameidata *ndparent, *ndwatch;
+        int err;
+
+        ndparent = kmalloc(sizeof(*ndparent), GFP_KERNEL);
+        if (unlikely(!ndparent))
+                return -ENOMEM;
+
+        ndwatch = kmalloc(sizeof(*ndwatch), GFP_KERNEL);
+        if (unlikely(!ndwatch)) {
+                kfree(ndparent);
+                return -ENOMEM;
+        }
+
+        err = path_lookup(path, LOOKUP_PARENT, ndparent);
+        if (err) {
+                kfree(ndparent);
+                kfree(ndwatch);
+                return err;
+        }
+
+        err = path_lookup(path, 0, ndwatch);
+        if (err) {
+                kfree(ndwatch);
+                ndwatch = NULL;
+        }
+
+        *ndp = ndparent;
+        *ndw = ndwatch;
+
+        return 0;
+}
+
+/* Release resources used for watch path information. */
+static void audit_put_nd(struct nameidata *ndp, struct nameidata *ndw)
+{
+        if (ndp) {
+                path_release(ndp);
+                kfree(ndp);
+        }
+        if (ndw) {
+                path_release(ndw);
+                kfree(ndw);
+        }
+}
+
+/* Associate the given rule with an existing parent inotify_watch.
+ * Caller must hold audit_filter_mutex. */
+static void audit_add_to_parent(struct audit_krule *krule,
+                                struct audit_parent *parent)
+{
+        struct audit_watch *w, *watch = krule->watch;
+        int watch_found = 0;
+
+        list_for_each_entry(w, &parent->watches, wlist) {
+                if (strcmp(watch->path, w->path))
+                        continue;
+
+                watch_found = 1;
+
+                /* put krule's and initial refs to temporary watch */
+                audit_put_watch(watch);
+                audit_put_watch(watch);
+
+                audit_get_watch(w);
+                krule->watch = watch = w;
+                break;
+        }
+
+        if (!watch_found) {
+                get_inotify_watch(&parent->wdata);
+                watch->parent = parent;
+
+                list_add(&watch->wlist, &parent->watches);
+        }
+        list_add(&krule->rlist, &watch->rules);
+}
+
+/* Find a matching watch entry, or add this one.
+ * Caller must hold audit_filter_mutex. */
+static int audit_add_watch(struct audit_krule *krule, struct nameidata *ndp,
+                           struct nameidata *ndw)
+{
+        struct audit_watch *watch = krule->watch;
+        struct inotify_watch *i_watch;
+        struct audit_parent *parent;
+        int ret = 0;
+
+        /* update watch filter fields */
+        if (ndw) {
+                watch->dev = ndw->dentry->d_inode->i_sb->s_dev;
+                watch->ino = ndw->dentry->d_inode->i_ino;
+        }
+
+        /* The audit_filter_mutex must not be held during inotify calls because
+         * we hold it during inotify event callback processing.  If an existing
+         * inotify watch is found, inotify_find_watch() grabs a reference before
+         * returning.
+         */
+        mutex_unlock(&audit_filter_mutex);
+
+        if (inotify_find_watch(audit_ih, ndp->dentry->d_inode, &i_watch) < 0) {
+                parent = audit_init_parent(ndp);
+                if (IS_ERR(parent)) {
+                        /* caller expects mutex locked */
+                        mutex_lock(&audit_filter_mutex);
+                        return PTR_ERR(parent);
+                }
+        } else
+                parent = container_of(i_watch, struct audit_parent, wdata);
+
+        mutex_lock(&audit_filter_mutex);
+
+        /* parent was moved before we took audit_filter_mutex */
+        if (parent->flags & AUDIT_PARENT_INVALID)
+                ret = -ENOENT;
+        else
+                audit_add_to_parent(krule, parent);
+
+        /* match get in audit_init_parent or inotify_find_watch */
+        put_inotify_watch(&parent->wdata);
+        return ret;
+}
+
+/* Add rule to given filterlist if not a duplicate. */
 static inline int audit_add_rule(struct audit_entry *entry,
-                                  struct list_head *list)
+                                 struct list_head *list)
 {
         struct audit_entry *e;
+        struct audit_field *inode_f = entry->rule.inode_f;
+        struct audit_watch *watch = entry->rule.watch;
+        struct nameidata *ndp, *ndw;
+        int h, err, putnd_needed = 0;
+
+        if (inode_f) {
+                h = audit_hash_ino(inode_f->val);
+                list = &audit_inode_hash[h];
+        }
 
-        /* Do not use the _rcu iterator here, since this is the only
-         * addition routine. */
-        list_for_each_entry(e, list, list) {
-                if (!audit_compare_rule(&entry->rule, &e->rule))
-                        return -EEXIST;
+        mutex_lock(&audit_filter_mutex);
+        e = audit_find_rule(entry, list);
+        mutex_unlock(&audit_filter_mutex);
+        if (e) {
+                err = -EEXIST;
+                goto error;
+        }
+
+        /* Avoid calling path_lookup under audit_filter_mutex. */
+        if (watch) {
+                err = audit_get_nd(watch->path, &ndp, &ndw);
+                if (err)
+                        goto error;
+                putnd_needed = 1;
+        }
+
+        mutex_lock(&audit_filter_mutex);
+        if (watch) {
+                /* audit_filter_mutex is dropped and re-taken during this call */
+                err = audit_add_watch(&entry->rule, ndp, ndw);
+                if (err) {
+                        mutex_unlock(&audit_filter_mutex);
+                        goto error;
+                }
+                h = audit_hash_ino((u32)watch->ino);
+                list = &audit_inode_hash[h];
         }
 
         if (entry->rule.flags & AUDIT_FILTER_PREPEND) {
                 list_add_rcu(&entry->list, list);
+                entry->rule.flags &= ~AUDIT_FILTER_PREPEND;
         } else {
                 list_add_tail_rcu(&entry->list, list);
         }
+        mutex_unlock(&audit_filter_mutex);
 
-        return 0;
+        if (putnd_needed)
+                audit_put_nd(ndp, ndw);
+
+        return 0;
+
+error:
+        if (putnd_needed)
+                audit_put_nd(ndp, ndw);
+        if (watch)
+                audit_put_watch(watch); /* tmp watch, matches initial get */
+        return err;
 }
 
-/* Remove an existing rule from filterlist.  Protected by
- * audit_netlink_mutex. */
+/* Remove an existing rule from filterlist. */
 static inline int audit_del_rule(struct audit_entry *entry,
                                  struct list_head *list)
 {
         struct audit_entry  *e;
+        struct audit_field *inode_f = entry->rule.inode_f;
+        struct audit_watch *watch, *tmp_watch = entry->rule.watch;
+        LIST_HEAD(inotify_list);
+        int h, ret = 0;
+
+        if (inode_f) {
+                h = audit_hash_ino(inode_f->val);
+                list = &audit_inode_hash[h];
+        }
 
-        /* Do not use the _rcu iterator here, since this is the only
-         * deletion routine. */
-        list_for_each_entry(e, list, list) {
-                if (!audit_compare_rule(&entry->rule, &e->rule)) {
-                        list_del_rcu(&e->list);
-                        call_rcu(&e->rcu, audit_free_rule_rcu);
-                        return 0;
+        mutex_lock(&audit_filter_mutex);
+        e = audit_find_rule(entry, list);
+        if (!e) {
+                mutex_unlock(&audit_filter_mutex);
+                ret = -ENOENT;
+                goto out;
+        }
+
+        watch = e->rule.watch;
+        if (watch) {
+                struct audit_parent *parent = watch->parent;
+
+                list_del(&e->rule.rlist);
+
+                if (list_empty(&watch->rules)) {
+                        audit_remove_watch(watch);
+
+                        if (list_empty(&parent->watches)) {
+                                /* Put parent on the inotify un-registration
+                                 * list.  Grab a reference before releasing
+                                 * audit_filter_mutex, to be released in
+                                 * audit_inotify_unregister(). */
+                                list_add(&parent->ilist, &inotify_list);
+                                get_inotify_watch(&parent->wdata);
+                        }
                 }
         }
-        return -ENOENT;         /* No matching rule */
+
+        list_del_rcu(&e->list);
+        call_rcu(&e->rcu, audit_free_rule_rcu);
+
+        mutex_unlock(&audit_filter_mutex);
+
+        if (!list_empty(&inotify_list))
+                audit_inotify_unregister(&inotify_list);
+
+out:
+        if (tmp_watch)
+                audit_put_watch(tmp_watch); /* match initial get */
+
+        return ret;
 }
 
 /* List rules using struct audit_rule.  Exists for backward
  * compatibility with userspace. */
-static int audit_list(void *_dest)
+static void audit_list(int pid, int seq, struct sk_buff_head *q)
 {
-        int pid, seq;
-        int *dest = _dest;
+        struct sk_buff *skb;
         struct audit_entry *entry;
         int i;
 
-        pid = dest[0];
-        seq = dest[1];
-        kfree(dest);
-
-        mutex_lock(&audit_netlink_mutex);
-
-        /* The *_rcu iterators not needed here because we are
-           always called with audit_netlink_mutex held. */
+        /* This is a blocking read, so use audit_filter_mutex instead of rcu
+         * iterator to sync with list writers. */
         for (i=0; i<AUDIT_NR_FILTERS; i++) {
                 list_for_each_entry(entry, &audit_filter_list[i], list) {
                         struct audit_rule *rule;
@@ -532,33 +1177,41 @@ static int audit_list(void *_dest)
                         rule = audit_krule_to_rule(&entry->rule);
                         if (unlikely(!rule))
                                 break;
-                        audit_send_reply(pid, seq, AUDIT_LIST, 0, 1,
+                        skb = audit_make_reply(pid, seq, AUDIT_LIST, 0, 1,
                                          rule, sizeof(*rule));
+                        if (skb)
+                                skb_queue_tail(q, skb);
                         kfree(rule);
                 }
         }
-        audit_send_reply(pid, seq, AUDIT_LIST, 1, 1, NULL, 0);
-        
-        mutex_unlock(&audit_netlink_mutex);
-        return 0;
+        for (i = 0; i < AUDIT_INODE_BUCKETS; i++) {
+                list_for_each_entry(entry, &audit_inode_hash[i], list) {
+                        struct audit_rule *rule;
+
+                        rule = audit_krule_to_rule(&entry->rule);
+                        if (unlikely(!rule))
+                                break;
+                        skb = audit_make_reply(pid, seq, AUDIT_LIST, 0, 1,
+                                         rule, sizeof(*rule));
+                        if (skb)
+                                skb_queue_tail(q, skb);
+                        kfree(rule);
+                }
+        }
+        skb = audit_make_reply(pid, seq, AUDIT_LIST, 1, 1, NULL, 0);
+        if (skb)
+                skb_queue_tail(q, skb);
 }
 
 /* List rules using struct audit_rule_data. */
-static int audit_list_rules(void *_dest)
+static void audit_list_rules(int pid, int seq, struct sk_buff_head *q)
 {
-        int pid, seq;
-        int *dest = _dest;
+        struct sk_buff *skb;
         struct audit_entry *e;
         int i;
 
-        pid = dest[0];
-        seq = dest[1];
-        kfree(dest);
-
-        mutex_lock(&audit_netlink_mutex);
-
-        /* The *_rcu iterators not needed here because we are
-           always called with audit_netlink_mutex held. */
+        /* This is a blocking read, so use audit_filter_mutex instead of rcu
+         * iterator to sync with list writers. */
         for (i=0; i<AUDIT_NR_FILTERS; i++) {
                 list_for_each_entry(e, &audit_filter_list[i], list) {
                         struct audit_rule_data *data;
@@ -566,15 +1219,30 @@ static int audit_list_rules(void *_dest)
                         data = audit_krule_to_data(&e->rule);
                         if (unlikely(!data))
                                 break;
-                        audit_send_reply(pid, seq, AUDIT_LIST_RULES, 0, 1,
-                                         data, sizeof(*data));
+                        skb = audit_make_reply(pid, seq, AUDIT_LIST_RULES, 0, 1,
+                                         data, sizeof(*data) + data->buflen);
+                        if (skb)
+                                skb_queue_tail(q, skb);
                         kfree(data);
                 }
         }
-        audit_send_reply(pid, seq, AUDIT_LIST_RULES, 1, 1, NULL, 0);
+        for (i=0; i< AUDIT_INODE_BUCKETS; i++) {
+                list_for_each_entry(e, &audit_inode_hash[i], list) {
+                        struct audit_rule_data *data;
 
-        mutex_unlock(&audit_netlink_mutex);
-        return 0;
+                        data = audit_krule_to_data(&e->rule);
+                        if (unlikely(!data))
+                                break;
+                        skb = audit_make_reply(pid, seq, AUDIT_LIST_RULES, 0, 1,
+                                         data, sizeof(*data) + data->buflen);
+                        if (skb)
+                                skb_queue_tail(q, skb);
+                        kfree(data);
+                }
+        }
+        skb = audit_make_reply(pid, seq, AUDIT_LIST_RULES, 1, 1, NULL, 0);
+        if (skb)
+                skb_queue_tail(q, skb);
 }
 
 /**
@@ -592,7 +1260,7 @@ int audit_receive_filter(int type, int pid, int uid, int seq, void *data,
                          size_t datasz, uid_t loginuid, u32 sid)
 {
         struct task_struct *tsk;
-        int *dest;
+        struct audit_netlink_list *dest;
         int err = 0;
         struct audit_entry *entry;
 
@@ -605,18 +1273,22 @@ int audit_receive_filter(int type, int pid, int uid, int seq, void *data,
                  * happen if we're actually running in the context of auditctl
                  * trying to _send_ the stuff */
                  
-                dest = kmalloc(2 * sizeof(int), GFP_KERNEL);
+                dest = kmalloc(sizeof(struct audit_netlink_list), GFP_KERNEL);
                 if (!dest)
                         return -ENOMEM;
-                dest[0] = pid;
-                dest[1] = seq;
+                dest->pid = pid;
+                skb_queue_head_init(&dest->q);
 
+                mutex_lock(&audit_filter_mutex);
                 if (type == AUDIT_LIST)
-                        tsk = kthread_run(audit_list, dest, "audit_list");
+                        audit_list(pid, seq, &dest->q);
                 else
-                        tsk = kthread_run(audit_list_rules, dest,
-                                          "audit_list_rules");
+                        audit_list_rules(pid, seq, &dest->q);
+                mutex_unlock(&audit_filter_mutex);
+
+                tsk = kthread_run(audit_send_list, dest, "audit_send_list");
                 if (IS_ERR(tsk)) {
+                        skb_queue_purge(&dest->q);
                         kfree(dest);
                         err = PTR_ERR(tsk);
                 }
@@ -632,6 +1304,7 @@ int audit_receive_filter(int type, int pid, int uid, int seq, void *data,
 
                 err = audit_add_rule(entry,
                                      &audit_filter_list[entry->rule.listnr]);
+
                 if (sid) {
                         char *ctx = NULL;
                         u32 len;
@@ -712,7 +1385,43 @@ int audit_comparator(const u32 left, const u32 op, const u32 right)
         return 0;
 }
 
+/* Compare given dentry name with last component in given path,
+ * return of 0 indicates a match. */
+int audit_compare_dname_path(const char *dname, const char *path,
+                             int *dirlen)
+{
+        int dlen, plen;
+        const char *p;
 
+        if (!dname || !path)
+                return 1;
+
+        dlen = strlen(dname);
+        plen = strlen(path);
+        if (plen < dlen)
+                return 1;
+
+        /* disregard trailing slashes */
+        p = path + plen - 1;
+        while ((*p == '/') && (p > path))
+                p--;
+
+        /* find last path component */
+        p = p - dlen + 1;
+        if (p < path)
+                return 1;
+        else if (p > path) {
+                if (*--p != '/')
+                        return 1;
+                else
+                        p++;
+        }
+
+        /* return length of path's directory component */
+        if (dirlen)
+                *dirlen = p - path;
+        return strncmp(p, dname, dlen);
+}
 
 static int audit_filter_user_rules(struct netlink_skb_parms *cb,
                                    struct audit_krule *rule,
@@ -744,7 +1453,6 @@ static int audit_filter_user_rules(struct netlink_skb_parms *cb,
         }
         switch (rule->action) {
         case AUDIT_NEVER:    *state = AUDIT_DISABLED;       break;
-        case AUDIT_POSSIBLE: *state = AUDIT_BUILD_CONTEXT;  break;
         case AUDIT_ALWAYS:   *state = AUDIT_RECORD_CONTEXT; break;
         }
         return 1;
@@ -826,32 +1534,65 @@ static inline int audit_rule_has_selinux(struct audit_krule *rule)
 int selinux_audit_rule_update(void)
 {
         struct audit_entry *entry, *n, *nentry;
+        struct audit_watch *watch;
         int i, err = 0;
 
-        /* audit_netlink_mutex synchronizes the writers */
-        mutex_lock(&audit_netlink_mutex);
+        /* audit_filter_mutex synchronizes the writers */
+        mutex_lock(&audit_filter_mutex);
 
         for (i = 0; i < AUDIT_NR_FILTERS; i++) {
                 list_for_each_entry_safe(entry, n, &audit_filter_list[i], list) {
                         if (!audit_rule_has_selinux(&entry->rule))
                                 continue;
 
-                        nentry = audit_dupe_rule(&entry->rule);
+                        watch = entry->rule.watch;
+                        nentry = audit_dupe_rule(&entry->rule, watch);
                         if (unlikely(IS_ERR(nentry))) {
                                 /* save the first error encountered for the
                                  * return value */
                                 if (!err)
                                         err = PTR_ERR(nentry);
                                 audit_panic("error updating selinux filters");
+                                if (watch)
+                                        list_del(&entry->rule.rlist);
                                 list_del_rcu(&entry->list);
                         } else {
+                                if (watch) {
+                                        list_add(&nentry->rule.rlist,
+                                                 &watch->rules);
+                                        list_del(&entry->rule.rlist);
+                                }
                                 list_replace_rcu(&entry->list, &nentry->list);
                         }
                         call_rcu(&entry->rcu, audit_free_rule_rcu);
                 }
         }
 
-        mutex_unlock(&audit_netlink_mutex);
+        mutex_unlock(&audit_filter_mutex);
 
         return err;
 }
+
+/* Update watch data in audit rules based on inotify events. */
+void audit_handle_ievent(struct inotify_watch *i_watch, u32 wd, u32 mask,
+                         u32 cookie, const char *dname, struct inode *inode)
+{
+        struct audit_parent *parent;
+
+        parent = container_of(i_watch, struct audit_parent, wdata);
+
+        if (mask & (IN_CREATE|IN_MOVED_TO) && inode)
+                audit_update_watch(parent, dname, inode->i_sb->s_dev,
+                                   inode->i_ino, 0);
+        else if (mask & (IN_DELETE|IN_MOVED_FROM))
+                audit_update_watch(parent, dname, (dev_t)-1, (unsigned long)-1, 1);
+        /* inotify automatically removes the watch and sends IN_IGNORED */
+        else if (mask & (IN_DELETE_SELF|IN_UNMOUNT))
+                audit_remove_parent_watches(parent);
+        /* inotify does not remove the watch, so remove it manually */
+        else if(mask & IN_MOVE_SELF) {
+                audit_remove_parent_watches(parent);
+                inotify_remove_watch_locked(audit_ih, i_watch);
+        } else if (mask & IN_IGNORED)
+                put_inotify_watch(i_watch);
+}
diff --git a/kernel/auditsc.c b/kernel/auditsc.c
index 1c03a4ed1b27..b097ccb4eb7e 100644
--- a/kernel/auditsc.c
+++ b/kernel/auditsc.c
@@ -3,7 +3,7 @@
  *
  * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina.
  * Copyright 2005 Hewlett-Packard Development Company, L.P.
- * Copyright (C) 2005 IBM Corporation
+ * Copyright (C) 2005, 2006 IBM Corporation
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -29,6 +29,9 @@
  * this file -- see entry.S) is based on a GPL'd patch written by
  * okir@suse.de and Copyright 2003 SuSE Linux AG.
  *
+ * POSIX message queue support added by George Wilson <ltcgcw@us.ibm.com>,
+ * 2006.
+ *
  * The support of additional filter rules compares (>, <, >=, <=) was
  * added by Dustin Kirkland <dustin.kirkland@us.ibm.com>, 2005.
  *
@@ -49,6 +52,7 @@
 #include <linux/module.h>
 #include <linux/mount.h>
 #include <linux/socket.h>
+#include <linux/mqueue.h>
 #include <linux/audit.h>
 #include <linux/personality.h>
 #include <linux/time.h>
@@ -59,6 +63,8 @@
 #include <linux/list.h>
 #include <linux/tty.h>
 #include <linux/selinux.h>
+#include <linux/binfmts.h>
+#include <linux/syscalls.h>
 
 #include "audit.h"
 
@@ -76,6 +82,9 @@ extern int audit_enabled;
  * path_lookup. */
 #define AUDIT_NAMES_RESERVED 7
 
+/* Indicates that audit should log the full pathname. */
+#define AUDIT_NAME_FULL -1
+
 /* When fs/namei.c:getname() is called, we store the pointer in name and
  * we don't let putname() free it (instead we free all of the saved
  * pointers at syscall exit time).
@@ -83,8 +92,9 @@ extern int audit_enabled;
  * Further, in fs/namei.c:path_lookup() we store the inode and device. */
 struct audit_names {
         const char      *name;
+        int             name_len;       /* number of name's characters to log */
+        unsigned        name_put;       /* call __putname() for this name */
         unsigned long   ino;
-        unsigned long   pino;
         dev_t           dev;
         umode_t         mode;
         uid_t           uid;
@@ -100,6 +110,33 @@ struct audit_aux_data {
 
 #define AUDIT_AUX_IPCPERM       0
 
+struct audit_aux_data_mq_open {
+        struct audit_aux_data   d;
+        int                     oflag;
+        mode_t                  mode;
+        struct mq_attr          attr;
+};
+
+struct audit_aux_data_mq_sendrecv {
+        struct audit_aux_data   d;
+        mqd_t                   mqdes;
+        size_t                  msg_len;
+        unsigned int            msg_prio;
+        struct timespec         abs_timeout;
+};
+
+struct audit_aux_data_mq_notify {
+        struct audit_aux_data   d;
+        mqd_t                   mqdes;
+        struct sigevent         notification;
+};
+
+struct audit_aux_data_mq_getsetattr {
+        struct audit_aux_data   d;
+        mqd_t                   mqdes;
+        struct mq_attr          mqstat;
+};
+
 struct audit_aux_data_ipcctl {
         struct audit_aux_data   d;
         struct ipc_perm         p;
@@ -110,6 +147,13 @@ struct audit_aux_data_ipcctl {
         u32                     osid;
 };
 
+struct audit_aux_data_execve {
+        struct audit_aux_data   d;
+        int argc;
+        int envc;
+        char mem[0];
+};
+
 struct audit_aux_data_socketcall {
         struct audit_aux_data   d;
         int                     nargs;
@@ -148,7 +192,7 @@ struct audit_context {
         struct audit_aux_data *aux;
 
                                 /* Save things to print about task_struct */
-        pid_t               pid;
+        pid_t               pid, ppid;
         uid_t               uid, euid, suid, fsuid;
         gid_t               gid, egid, sgid, fsgid;
         unsigned long       personality;
@@ -160,12 +204,13 @@ struct audit_context {
 #endif
 };
 
-
+/* Determine if any context name data matches a rule's watch data */
 /* Compare a task_struct with an audit_rule.  Return 1 on match, 0
  * otherwise. */
 static int audit_filter_rules(struct task_struct *tsk,
                               struct audit_krule *rule,
                               struct audit_context *ctx,
+                              struct audit_names *name,
                               enum audit_state *state)
 {
         int i, j, need_sid = 1;
@@ -179,6 +224,10 @@ static int audit_filter_rules(struct task_struct *tsk,
                 case AUDIT_PID:
                         result = audit_comparator(tsk->pid, f->op, f->val);
                         break;
+                case AUDIT_PPID:
+                        if (ctx)
+                                result = audit_comparator(ctx->ppid, f->op, f->val);
+                        break;
                 case AUDIT_UID:
                         result = audit_comparator(tsk->uid, f->op, f->val);
                         break;
@@ -224,7 +273,10 @@ static int audit_filter_rules(struct task_struct *tsk,
                         }
                         break;
                 case AUDIT_DEVMAJOR:
-                        if (ctx) {
+                        if (name)
+                                result = audit_comparator(MAJOR(name->dev),
+                                                          f->op, f->val);
+                        else if (ctx) {
                                 for (j = 0; j < ctx->name_count; j++) {
                                         if (audit_comparator(MAJOR(ctx->names[j].dev),  f->op, f->val)) {
                                                 ++result;
@@ -234,7 +286,10 @@ static int audit_filter_rules(struct task_struct *tsk,
                         }
                         break;
                 case AUDIT_DEVMINOR:
-                        if (ctx) {
+                        if (name)
+                                result = audit_comparator(MINOR(name->dev),
+                                                          f->op, f->val);
+                        else if (ctx) {
                                 for (j = 0; j < ctx->name_count; j++) {
                                         if (audit_comparator(MINOR(ctx->names[j].dev), f->op, f->val)) {
                                                 ++result;
@@ -244,16 +299,22 @@ static int audit_filter_rules(struct task_struct *tsk,
                         }
                         break;
                 case AUDIT_INODE:
-                        if (ctx) {
+                        if (name)
+                                result = (name->ino == f->val);
+                        else if (ctx) {
                                 for (j = 0; j < ctx->name_count; j++) {
-                                        if (audit_comparator(ctx->names[j].ino, f->op, f->val) ||
-                                            audit_comparator(ctx->names[j].pino, f->op, f->val)) {
+                                        if (audit_comparator(ctx->names[j].ino, f->op, f->val)) {
                                                 ++result;
                                                 break;
                                         }
                                 }
                         }
                         break;
+                case AUDIT_WATCH:
+                        if (name && rule->watch->ino != (unsigned long)-1)
+                                result = (name->dev == rule->watch->dev &&
+                                          name->ino == rule->watch->ino);
+                        break;
                 case AUDIT_LOGINUID:
                         result = 0;
                         if (ctx)
@@ -294,7 +355,6 @@ static int audit_filter_rules(struct task_struct *tsk,
         }
         switch (rule->action) {
         case AUDIT_NEVER:    *state = AUDIT_DISABLED;       break;
-        case AUDIT_POSSIBLE: *state = AUDIT_BUILD_CONTEXT;  break;
         case AUDIT_ALWAYS:   *state = AUDIT_RECORD_CONTEXT; break;
         }
         return 1;
@@ -311,7 +371,7 @@ static enum audit_state audit_filter_task(struct task_struct *tsk)
 
         rcu_read_lock();
         list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_TASK], list) {
-                if (audit_filter_rules(tsk, &e->rule, NULL, &state)) {
+                if (audit_filter_rules(tsk, &e->rule, NULL, NULL, &state)) {
                         rcu_read_unlock();
                         return state;
                 }
@@ -341,8 +401,47 @@ static enum audit_state audit_filter_syscall(struct task_struct *tsk,
                 int bit  = AUDIT_BIT(ctx->major);
 
                 list_for_each_entry_rcu(e, list, list) {
-                        if ((e->rule.mask[word] & bit) == bit
-                                        && audit_filter_rules(tsk, &e->rule, ctx, &state)) {
+                        if ((e->rule.mask[word] & bit) == bit &&
+                            audit_filter_rules(tsk, &e->rule, ctx, NULL,
+                                               &state)) {
+                                rcu_read_unlock();
+                                return state;
+                        }
+                }
+        }
+        rcu_read_unlock();
+        return AUDIT_BUILD_CONTEXT;
+}
+
+/* At syscall exit time, this filter is called if any audit_names[] have been
+ * collected during syscall processing.  We only check rules in sublists at hash
+ * buckets applicable to the inode numbers in audit_names[].
+ * Regarding audit_state, same rules apply as for audit_filter_syscall().
+ */
+enum audit_state audit_filter_inodes(struct task_struct *tsk,
+                                     struct audit_context *ctx)
+{
+        int i;
+        struct audit_entry *e;
+        enum audit_state state;
+
+        if (audit_pid && tsk->tgid == audit_pid)
+                return AUDIT_DISABLED;
+
+        rcu_read_lock();
+        for (i = 0; i < ctx->name_count; i++) {
+                int word = AUDIT_WORD(ctx->major);
+                int bit  = AUDIT_BIT(ctx->major);
+                struct audit_names *n = &ctx->names[i];
+                int h = audit_hash_ino((u32)n->ino);
+                struct list_head *list = &audit_inode_hash[h];
+
+                if (list_empty(list))
+                        continue;
+
+                list_for_each_entry_rcu(e, list, list) {
+                        if ((e->rule.mask[word] & bit) == bit &&
+                            audit_filter_rules(tsk, &e->rule, ctx, n, &state)) {
                                 rcu_read_unlock();
                                 return state;
                         }
@@ -352,6 +451,11 @@ static enum audit_state audit_filter_syscall(struct task_struct *tsk,
         return AUDIT_BUILD_CONTEXT;
 }
 
+void audit_set_auditable(struct audit_context *ctx)
+{
+        ctx->auditable = 1;
+}
+
 static inline struct audit_context *audit_get_context(struct task_struct *tsk,
                                                       int return_valid,
                                                       int return_code)
@@ -365,12 +469,22 @@ static inline struct audit_context *audit_get_context(struct task_struct *tsk,
 
         if (context->in_syscall && !context->auditable) {
                 enum audit_state state;
+
                 state = audit_filter_syscall(tsk, context, &audit_filter_list[AUDIT_FILTER_EXIT]);
+                if (state == AUDIT_RECORD_CONTEXT) {
+                        context->auditable = 1;
+                        goto get_context;
+                }
+
+                state = audit_filter_inodes(tsk, context);
                 if (state == AUDIT_RECORD_CONTEXT)
                         context->auditable = 1;
+
         }
 
+get_context:
         context->pid = tsk->pid;
+        context->ppid = sys_getppid();  /* sic.  tsk == current in all cases */
         context->uid = tsk->uid;
         context->gid = tsk->gid;
         context->euid = tsk->euid;
@@ -413,7 +527,7 @@ static inline void audit_free_names(struct audit_context *context)
 #endif
 
         for (i = 0; i < context->name_count; i++) {
-                if (context->names[i].name)
+                if (context->names[i].name && context->names[i].name_put)
                         __putname(context->names[i].name);
         }
         context->name_count = 0;
@@ -606,7 +720,7 @@ static void audit_log_exit(struct audit_context *context, struct task_struct *ts
                 tty = "(none)";
         audit_log_format(ab,
                   " a0=%lx a1=%lx a2=%lx a3=%lx items=%d"
-                  " pid=%d auid=%u uid=%u gid=%u"
+                  " ppid=%d pid=%d auid=%u uid=%u gid=%u"
                   " euid=%u suid=%u fsuid=%u"
                   " egid=%u sgid=%u fsgid=%u tty=%s",
                   context->argv[0],
@@ -614,6 +728,7 @@ static void audit_log_exit(struct audit_context *context, struct task_struct *ts
                   context->argv[2],
                   context->argv[3],
                   context->name_count,
+                  context->ppid,
                   context->pid,
                   context->loginuid,
                   context->uid,
@@ -630,11 +745,48 @@ static void audit_log_exit(struct audit_context *context, struct task_struct *ts
                         continue; /* audit_panic has been called */
 
                 switch (aux->type) {
+                case AUDIT_MQ_OPEN: {
+                        struct audit_aux_data_mq_open *axi = (void *)aux;
+                        audit_log_format(ab,
+                                "oflag=0x%x mode=%#o mq_flags=0x%lx mq_maxmsg=%ld "
+                                "mq_msgsize=%ld mq_curmsgs=%ld",
+                                axi->oflag, axi->mode, axi->attr.mq_flags,
+                                axi->attr.mq_maxmsg, axi->attr.mq_msgsize,
+                                axi->attr.mq_curmsgs);
+                        break; }
+
+                case AUDIT_MQ_SENDRECV: {
+                        struct audit_aux_data_mq_sendrecv *axi = (void *)aux;
+                        audit_log_format(ab,
+                                "mqdes=%d msg_len=%zd msg_prio=%u "
+                                "abs_timeout_sec=%ld abs_timeout_nsec=%ld",
+                                axi->mqdes, axi->msg_len, axi->msg_prio,
+                                axi->abs_timeout.tv_sec, axi->abs_timeout.tv_nsec);
+                        break; }
+
+                case AUDIT_MQ_NOTIFY: {
+                        struct audit_aux_data_mq_notify *axi = (void *)aux;
+                        audit_log_format(ab,
+                                "mqdes=%d sigev_signo=%d",
+                                axi->mqdes,
+                                axi->notification.sigev_signo);
+                        break; }
+
+                case AUDIT_MQ_GETSETATTR: {
+                        struct audit_aux_data_mq_getsetattr *axi = (void *)aux;
+                        audit_log_format(ab,
+                                "mqdes=%d mq_flags=0x%lx mq_maxmsg=%ld mq_msgsize=%ld "
+                                "mq_curmsgs=%ld ",
+                                axi->mqdes,
+                                axi->mqstat.mq_flags, axi->mqstat.mq_maxmsg,
+                                axi->mqstat.mq_msgsize, axi->mqstat.mq_curmsgs);
+                        break; }
+
                 case AUDIT_IPC: {
                         struct audit_aux_data_ipcctl *axi = (void *)aux;
                         audit_log_format(ab, 
-                                 " qbytes=%lx iuid=%u igid=%u mode=%x",
-                                 axi->qbytes, axi->uid, axi->gid, axi->mode);
+                                 "ouid=%u ogid=%u mode=%x",
+                                 axi->uid, axi->gid, axi->mode);
                         if (axi->osid != 0) {
                                 char *ctx = NULL;
                                 u32 len;
@@ -652,19 +804,18 @@ static void audit_log_exit(struct audit_context *context, struct task_struct *ts
                 case AUDIT_IPC_SET_PERM: {
                         struct audit_aux_data_ipcctl *axi = (void *)aux;
                         audit_log_format(ab,
-                                " new qbytes=%lx new iuid=%u new igid=%u new mode=%x",
+                                "qbytes=%lx ouid=%u ogid=%u mode=%x",
                                 axi->qbytes, axi->uid, axi->gid, axi->mode);
-                        if (axi->osid != 0) {
-                                char *ctx = NULL;
-                                u32 len;
-                                if (selinux_ctxid_to_string(
-                                                axi->osid, &ctx, &len)) {
-                                        audit_log_format(ab, " osid=%u",
-                                                        axi->osid);
-                                        call_panic = 1;
-                                } else
-                                        audit_log_format(ab, " obj=%s", ctx);
-                                kfree(ctx);
+                        break; }
+
+                case AUDIT_EXECVE: {
+                        struct audit_aux_data_execve *axi = (void *)aux;
+                        int i;
+                        const char *p;
+                        for (i = 0, p = axi->mem; i < axi->argc; i++) {
+                                audit_log_format(ab, "a%d=", i);
+                                p = audit_log_untrustedstring(ab, p);
+                                audit_log_format(ab, "\n");
                         }
                         break; }
 
@@ -700,8 +851,7 @@ static void audit_log_exit(struct audit_context *context, struct task_struct *ts
                 }
         }
         for (i = 0; i < context->name_count; i++) {
-                unsigned long ino  = context->names[i].ino;
-                unsigned long pino = context->names[i].pino;
+                struct audit_names *n = &context->names[i];
 
                 ab = audit_log_start(context, GFP_KERNEL, AUDIT_PATH);
                 if (!ab)
@@ -709,33 +859,47 @@ static void audit_log_exit(struct audit_context *context, struct task_struct *ts
 
                 audit_log_format(ab, "item=%d", i);
 
-                audit_log_format(ab, " name=");
-                if (context->names[i].name)
-                        audit_log_untrustedstring(ab, context->names[i].name);
-                else
-                        audit_log_format(ab, "(null)");
-
-                if (pino != (unsigned long)-1)
-                        audit_log_format(ab, " parent=%lu",  pino);
-                if (ino != (unsigned long)-1)
-                        audit_log_format(ab, " inode=%lu",  ino);
-                if ((pino != (unsigned long)-1) || (ino != (unsigned long)-1))
-                        audit_log_format(ab, " dev=%02x:%02x mode=%#o" 
-                                         " ouid=%u ogid=%u rdev=%02x:%02x", 
-                                         MAJOR(context->names[i].dev), 
-                                         MINOR(context->names[i].dev), 
-                                         context->names[i].mode, 
-                                         context->names[i].uid, 
-                                         context->names[i].gid, 
-                                         MAJOR(context->names[i].rdev), 
-                                         MINOR(context->names[i].rdev));
-                if (context->names[i].osid != 0) {
+                if (n->name) {
+                        switch(n->name_len) {
+                        case AUDIT_NAME_FULL:
+                                /* log the full path */
+                                audit_log_format(ab, " name=");
+                                audit_log_untrustedstring(ab, n->name);
+                                break;
+                        case 0:
+                                /* name was specified as a relative path and the
+                                 * directory component is the cwd */
+                                audit_log_d_path(ab, " name=", context->pwd,
+                                                 context->pwdmnt);
+                                break;
+                        default:
+                                /* log the name's directory component */
+                                audit_log_format(ab, " name=");
+                                audit_log_n_untrustedstring(ab, n->name_len,
+                                                            n->name);
+                        }
+                } else
+                        audit_log_format(ab, " name=(null)");
+
+                if (n->ino != (unsigned long)-1) {
+                        audit_log_format(ab, " inode=%lu"
+                                         " dev=%02x:%02x mode=%#o"
+                                         " ouid=%u ogid=%u rdev=%02x:%02x",
+                                         n->ino,
+                                         MAJOR(n->dev),
+                                         MINOR(n->dev),
+                                         n->mode,
+                                         n->uid,
+                                         n->gid,
+                                         MAJOR(n->rdev),
+                                         MINOR(n->rdev));
+                }
+                if (n->osid != 0) {
                         char *ctx = NULL;
                         u32 len;
                         if (selinux_ctxid_to_string(
-                                context->names[i].osid, &ctx, &len)) {
-                                audit_log_format(ab, " osid=%u",
-                                                context->names[i].osid);
+                                n->osid, &ctx, &len)) {
+                                audit_log_format(ab, " osid=%u", n->osid);
                                 call_panic = 2;
                         } else
                                 audit_log_format(ab, " obj=%s", ctx);
@@ -908,11 +1072,11 @@ void audit_syscall_exit(int valid, long return_code)
  * Add a name to the list of audit names for this context.
  * Called from fs/namei.c:getname().
  */
-void audit_getname(const char *name)
+void __audit_getname(const char *name)
 {
         struct audit_context *context = current->audit_context;
 
-        if (!context || IS_ERR(name) || !name)
+        if (IS_ERR(name) || !name)
                 return;
 
         if (!context->in_syscall) {
@@ -925,6 +1089,8 @@ void audit_getname(const char *name)
         }
         BUG_ON(context->name_count >= AUDIT_NAMES);
         context->names[context->name_count].name = name;
+        context->names[context->name_count].name_len = AUDIT_NAME_FULL;
+        context->names[context->name_count].name_put = 1;
         context->names[context->name_count].ino  = (unsigned long)-1;
         ++context->name_count;
         if (!context->pwd) {
@@ -991,11 +1157,10 @@ static void audit_inode_context(int idx, const struct inode *inode)
  * audit_inode - store the inode and device from a lookup
  * @name: name being audited
  * @inode: inode being audited
- * @flags: lookup flags (as used in path_lookup())
  *
  * Called from fs/namei.c:path_lookup().
  */
-void __audit_inode(const char *name, const struct inode *inode, unsigned flags)
+void __audit_inode(const char *name, const struct inode *inode)
 {
         int idx;
         struct audit_context *context = current->audit_context;
@@ -1021,20 +1186,13 @@ void __audit_inode(const char *name, const struct inode *inode, unsigned flags)
                 ++context->ino_count;
 #endif
         }
+        context->names[idx].ino   = inode->i_ino;
         context->names[idx].dev   = inode->i_sb->s_dev;
         context->names[idx].mode  = inode->i_mode;
         context->names[idx].uid   = inode->i_uid;
         context->names[idx].gid   = inode->i_gid;
         context->names[idx].rdev  = inode->i_rdev;
         audit_inode_context(idx, inode);
-        if ((flags & LOOKUP_PARENT) && (strcmp(name, "/") != 0) && 
-            (strcmp(name, ".") != 0)) {
-                context->names[idx].ino   = (unsigned long)-1;
-                context->names[idx].pino  = inode->i_ino;
-        } else {
-                context->names[idx].ino   = inode->i_ino;
-                context->names[idx].pino  = (unsigned long)-1;
-        }
 }
 
 /**
@@ -1056,51 +1214,40 @@ void __audit_inode_child(const char *dname, const struct inode *inode,
 {
         int idx;
         struct audit_context *context = current->audit_context;
+        const char *found_name = NULL;
+        int dirlen = 0;
 
         if (!context->in_syscall)
                 return;
 
         /* determine matching parent */
-        if (dname)
-                for (idx = 0; idx < context->name_count; idx++)
-                        if (context->names[idx].pino == pino) {
-                                const char *n;
-                                const char *name = context->names[idx].name;
-                                int dlen = strlen(dname);
-                                int nlen = name ? strlen(name) : 0;
-
-                                if (nlen < dlen)
-                                        continue;
-                                
-                                /* disregard trailing slashes */
-                                n = name + nlen - 1;
-                                while ((*n == '/') && (n > name))
-                                        n--;
-
-                                /* find last path component */
-                                n = n - dlen + 1;
-                                if (n < name)
-                                        continue;
-                                else if (n > name) {
-                                        if (*--n != '/')
-                                                continue;
-                                        else
-                                                n++;
-                                }
-
-                                if (strncmp(n, dname, dlen) == 0)
-                                        goto update_context;
+        if (!dname)
+                goto update_context;
+        for (idx = 0; idx < context->name_count; idx++)
+                if (context->names[idx].ino == pino) {
+                        const char *name = context->names[idx].name;
+
+                        if (!name)
+                                continue;
+
+                        if (audit_compare_dname_path(dname, name, &dirlen) == 0) {
+                                context->names[idx].name_len = dirlen;
+                                found_name = name;
+                                break;
                         }
+                }
 
-        /* catch-all in case match not found */
+update_context:
         idx = context->name_count++;
-        context->names[idx].name  = NULL;
-        context->names[idx].pino  = pino;
 #if AUDIT_DEBUG
         context->ino_count++;
 #endif
+        /* Re-use the name belonging to the slot for a matching parent directory.
+         * All names for this context are relinquished in audit_free_names() */
+        context->names[idx].name = found_name;
+        context->names[idx].name_len = AUDIT_NAME_FULL;
+        context->names[idx].name_put = 0;       /* don't call __putname() */
 
-update_context:
         if (inode) {
                 context->names[idx].ino   = inode->i_ino;
                 context->names[idx].dev   = inode->i_sb->s_dev;
@@ -1109,7 +1256,8 @@ update_context:
                 context->names[idx].gid   = inode->i_gid;
                 context->names[idx].rdev  = inode->i_rdev;
                 audit_inode_context(idx, inode);
-        }
+        } else
+                context->names[idx].ino   = (unsigned long)-1;
 }
 
 /**
@@ -1142,18 +1290,23 @@ void auditsc_get_stamp(struct audit_context *ctx,
  */
 int audit_set_loginuid(struct task_struct *task, uid_t loginuid)
 {
-        if (task->audit_context) {
-                struct audit_buffer *ab;
-
-                ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_LOGIN);
-                if (ab) {
-                        audit_log_format(ab, "login pid=%d uid=%u "
-                                "old auid=%u new auid=%u",
-                                task->pid, task->uid, 
-                                task->audit_context->loginuid, loginuid);
-                        audit_log_end(ab);
+        struct audit_context *context = task->audit_context;
+
+        if (context) {
+                /* Only log if audit is enabled */
+                if (context->in_syscall) {
+                        struct audit_buffer *ab;
+
+                        ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_LOGIN);
+                        if (ab) {
+                                audit_log_format(ab, "login pid=%d uid=%u "
+                                        "old auid=%u new auid=%u",
+                                        task->pid, task->uid,
+                                        context->loginuid, loginuid);
+                                audit_log_end(ab);
+                        }
                 }
-                task->audit_context->loginuid = loginuid;
+                context->loginuid = loginuid;
         }
         return 0;
 }
@@ -1170,16 +1323,193 @@ uid_t audit_get_loginuid(struct audit_context *ctx)
 }
 
 /**
- * audit_ipc_obj - record audit data for ipc object
- * @ipcp: ipc permissions
+ * __audit_mq_open - record audit data for a POSIX MQ open
+ * @oflag: open flag
+ * @mode: mode bits
+ * @u_attr: queue attributes
  *
  * Returns 0 for success or NULL context or < 0 on error.
  */
-int audit_ipc_obj(struct kern_ipc_perm *ipcp)
+int __audit_mq_open(int oflag, mode_t mode, struct mq_attr __user *u_attr)
 {
-        struct audit_aux_data_ipcctl *ax;
+        struct audit_aux_data_mq_open *ax;
+        struct audit_context *context = current->audit_context;
+
+        if (!audit_enabled)
+                return 0;
+
+        if (likely(!context))
+                return 0;
+
+        ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
+        if (!ax)
+                return -ENOMEM;
+
+        if (u_attr != NULL) {
+                if (copy_from_user(&ax->attr, u_attr, sizeof(ax->attr))) {
+                        kfree(ax);
+                        return -EFAULT;
+                }
+        } else
+                memset(&ax->attr, 0, sizeof(ax->attr));
+
+        ax->oflag = oflag;
+        ax->mode = mode;
+
+        ax->d.type = AUDIT_MQ_OPEN;
+        ax->d.next = context->aux;
+        context->aux = (void *)ax;
+        return 0;
+}
+
+/**
+ * __audit_mq_timedsend - record audit data for a POSIX MQ timed send
+ * @mqdes: MQ descriptor
+ * @msg_len: Message length
+ * @msg_prio: Message priority
+ * @abs_timeout: Message timeout in absolute time
+ *
+ * Returns 0 for success or NULL context or < 0 on error.
+ */
+int __audit_mq_timedsend(mqd_t mqdes, size_t msg_len, unsigned int msg_prio,
+                        const struct timespec __user *u_abs_timeout)
+{
+        struct audit_aux_data_mq_sendrecv *ax;
+        struct audit_context *context = current->audit_context;
+
+        if (!audit_enabled)
+                return 0;
+
+        if (likely(!context))
+                return 0;
+
+        ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
+        if (!ax)
+                return -ENOMEM;
+
+        if (u_abs_timeout != NULL) {
+                if (copy_from_user(&ax->abs_timeout, u_abs_timeout, sizeof(ax->abs_timeout))) {
+                        kfree(ax);
+                        return -EFAULT;
+                }
+        } else
+                memset(&ax->abs_timeout, 0, sizeof(ax->abs_timeout));
+
+        ax->mqdes = mqdes;
+        ax->msg_len = msg_len;
+        ax->msg_prio = msg_prio;
+
+        ax->d.type = AUDIT_MQ_SENDRECV;
+        ax->d.next = context->aux;
+        context->aux = (void *)ax;
+        return 0;
+}
+
+/**
+ * __audit_mq_timedreceive - record audit data for a POSIX MQ timed receive
+ * @mqdes: MQ descriptor
+ * @msg_len: Message length
+ * @msg_prio: Message priority
+ * @abs_timeout: Message timeout in absolute time
+ *
+ * Returns 0 for success or NULL context or < 0 on error.
+ */
+int __audit_mq_timedreceive(mqd_t mqdes, size_t msg_len,
+                                unsigned int __user *u_msg_prio,
+                                const struct timespec __user *u_abs_timeout)
+{
+        struct audit_aux_data_mq_sendrecv *ax;
+        struct audit_context *context = current->audit_context;
+
+        if (!audit_enabled)
+                return 0;
+
+        if (likely(!context))
+                return 0;
+
+        ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
+        if (!ax)
+                return -ENOMEM;
+
+        if (u_msg_prio != NULL) {
+                if (get_user(ax->msg_prio, u_msg_prio)) {
+                        kfree(ax);
+                        return -EFAULT;
+                }
+        } else
+                ax->msg_prio = 0;
+
+        if (u_abs_timeout != NULL) {
+                if (copy_from_user(&ax->abs_timeout, u_abs_timeout, sizeof(ax->abs_timeout))) {
+                        kfree(ax);
+                        return -EFAULT;
+                }
+        } else
+                memset(&ax->abs_timeout, 0, sizeof(ax->abs_timeout));
+
+        ax->mqdes = mqdes;
+        ax->msg_len = msg_len;
+
+        ax->d.type = AUDIT_MQ_SENDRECV;
+        ax->d.next = context->aux;
+        context->aux = (void *)ax;
+        return 0;
+}
+
+/**
+ * __audit_mq_notify - record audit data for a POSIX MQ notify
+ * @mqdes: MQ descriptor
+ * @u_notification: Notification event
+ *
+ * Returns 0 for success or NULL context or < 0 on error.
+ */
+
+int __audit_mq_notify(mqd_t mqdes, const struct sigevent __user *u_notification)
+{
+        struct audit_aux_data_mq_notify *ax;
+        struct audit_context *context = current->audit_context;
+
+        if (!audit_enabled)
+                return 0;
+
+        if (likely(!context))
+                return 0;
+
+        ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
+        if (!ax)
+                return -ENOMEM;
+
+        if (u_notification != NULL) {
+                if (copy_from_user(&ax->notification, u_notification, sizeof(ax->notification))) {
+                        kfree(ax);
+                        return -EFAULT;
+                }
+        } else
+                memset(&ax->notification, 0, sizeof(ax->notification));
+
+        ax->mqdes = mqdes;
+
+        ax->d.type = AUDIT_MQ_NOTIFY;
+        ax->d.next = context->aux;
+        context->aux = (void *)ax;
+        return 0;
+}
+
+/**
+ * __audit_mq_getsetattr - record audit data for a POSIX MQ get/set attribute
+ * @mqdes: MQ descriptor
+ * @mqstat: MQ flags
+ *
+ * Returns 0 for success or NULL context or < 0 on error.
+ */
+int __audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat)
+{
+        struct audit_aux_data_mq_getsetattr *ax;
         struct audit_context *context = current->audit_context;
 
+        if (!audit_enabled)
+                return 0;
+
         if (likely(!context))
                 return 0;
 
@@ -1187,6 +1517,30 @@ int audit_ipc_obj(struct kern_ipc_perm *ipcp)
         if (!ax)
                 return -ENOMEM;
 
+        ax->mqdes = mqdes;
+        ax->mqstat = *mqstat;
+
+        ax->d.type = AUDIT_MQ_GETSETATTR;
+        ax->d.next = context->aux;
+        context->aux = (void *)ax;
+        return 0;
+}
+
+/**
+ * audit_ipc_obj - record audit data for ipc object
+ * @ipcp: ipc permissions
+ *
+ * Returns 0 for success or NULL context or < 0 on error.
+ */
+int __audit_ipc_obj(struct kern_ipc_perm *ipcp)
+{
+        struct audit_aux_data_ipcctl *ax;
+        struct audit_context *context = current->audit_context;
+
+        ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
+        if (!ax)
+                return -ENOMEM;
+
         ax->uid = ipcp->uid;
         ax->gid = ipcp->gid;
         ax->mode = ipcp->mode;
@@ -1207,14 +1561,11 @@ int audit_ipc_obj(struct kern_ipc_perm *ipcp)
  *
  * Returns 0 for success or NULL context or < 0 on error.
  */
-int audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode, struct kern_ipc_perm *ipcp)
+int __audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode)
 {
         struct audit_aux_data_ipcctl *ax;
         struct audit_context *context = current->audit_context;
 
-        if (likely(!context))
-                return 0;
-
         ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
         if (!ax)
                 return -ENOMEM;
@@ -1223,7 +1574,6 @@ int audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode,
         ax->uid = uid;
         ax->gid = gid;
         ax->mode = mode;
-        selinux_get_ipc_sid(ipcp, &ax->osid);
 
         ax->d.type = AUDIT_IPC_SET_PERM;
         ax->d.next = context->aux;
@@ -1231,6 +1581,39 @@ int audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode,
         return 0;
 }
 
+int audit_bprm(struct linux_binprm *bprm)
+{
+        struct audit_aux_data_execve *ax;
+        struct audit_context *context = current->audit_context;
+        unsigned long p, next;
+        void *to;
+
+        if (likely(!audit_enabled || !context))
+                return 0;
+
+        ax = kmalloc(sizeof(*ax) + PAGE_SIZE * MAX_ARG_PAGES - bprm->p,
+                                GFP_KERNEL);
+        if (!ax)
+                return -ENOMEM;
+
+        ax->argc = bprm->argc;
+        ax->envc = bprm->envc;
+        for (p = bprm->p, to = ax->mem; p < MAX_ARG_PAGES*PAGE_SIZE; p = next) {
+                struct page *page = bprm->page[p / PAGE_SIZE];
+                void *kaddr = kmap(page);
+                next = (p + PAGE_SIZE) & ~(PAGE_SIZE - 1);
+                memcpy(to, kaddr + (p & (PAGE_SIZE - 1)), next - p);
+                to += next - p;
+                kunmap(page);
+        }
+
+        ax->d.type = AUDIT_EXECVE;
+        ax->d.next = context->aux;
+        context->aux = (void *)ax;
+        return 0;
+}
+
+
 /**
  * audit_socketcall - record audit data for sys_socketcall
  * @nargs: number of args
@@ -1325,19 +1708,20 @@ int audit_avc_path(struct dentry *dentry, struct vfsmount *mnt)
  * If the audit subsystem is being terminated, record the task (pid)
  * and uid that is doing that.
  */
-void audit_signal_info(int sig, struct task_struct *t)
+void __audit_signal_info(int sig, struct task_struct *t)
 {
         extern pid_t audit_sig_pid;
         extern uid_t audit_sig_uid;
-
-        if (unlikely(audit_pid && t->tgid == audit_pid)) {
-                if (sig == SIGTERM || sig == SIGHUP) {
-                        struct audit_context *ctx = current->audit_context;
-                        audit_sig_pid = current->pid;
-                        if (ctx)
-                                audit_sig_uid = ctx->loginuid;
-                        else
-                                audit_sig_uid = current->uid;
-                }
+        extern u32 audit_sig_sid;
+
+        if (sig == SIGTERM || sig == SIGHUP || sig == SIGUSR1) {
+                struct task_struct *tsk = current;
+                struct audit_context *ctx = tsk->audit_context;
+                audit_sig_pid = tsk->pid;
+                if (ctx)
+                        audit_sig_uid = ctx->loginuid;
+                else
+                        audit_sig_uid = tsk->uid;
+                selinux_get_task_sid(tsk, &audit_sig_sid);
         }
 }
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index 01fa2ae98a85..18324305724a 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -393,7 +393,7 @@ static void __remove_hrtimer(struct hrtimer *timer, struct hrtimer_base *base)
         if (base->first == &timer->node)
                 base->first = rb_next(&timer->node);
         rb_erase(&timer->node, &base->active);
-        timer->node.rb_parent = HRTIMER_INACTIVE;
+        rb_set_parent(&timer->node, &timer->node);
 }
 
 /*
@@ -582,7 +582,7 @@ void hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
                 clock_id = CLOCK_MONOTONIC;
 
         timer->base = &bases[clock_id];
-        timer->node.rb_parent = HRTIMER_INACTIVE;
+        rb_set_parent(&timer->node, &timer->node);
 }
 EXPORT_SYMBOL_GPL(hrtimer_init);
 
diff --git a/kernel/intermodule.c b/kernel/intermodule.c
deleted file mode 100644
index 55b1e5b85db9..000000000000
--- a/kernel/intermodule.c
+++ /dev/null
@@ -1,184 +0,0 @@
-/* Deprecated, do not use.  Moved from module.c to here. --RR */
-
-/* Written by Keith Owens <kaos@ocs.com.au> Oct 2000 */
-#include <linux/module.h>
-#include <linux/kmod.h>
-#include <linux/spinlock.h>
-#include <linux/list.h>
-#include <linux/slab.h>
-
-/* inter_module functions are always available, even when the kernel is
- * compiled without modules.  Consumers of inter_module_xxx routines
- * will always work, even when both are built into the kernel, this
- * approach removes lots of #ifdefs in mainline code.
- */
-
-static struct list_head ime_list = LIST_HEAD_INIT(ime_list);
-static DEFINE_SPINLOCK(ime_lock);
-static int kmalloc_failed;
-
-struct inter_module_entry {
-        struct list_head list;
-        const char *im_name;
-        struct module *owner;
-        const void *userdata;
-};
-
-/**
- * inter_module_register - register a new set of inter module data.
- * @im_name: an arbitrary string to identify the data, must be unique
- * @owner: module that is registering the data, always use THIS_MODULE
- * @userdata: pointer to arbitrary userdata to be registered
- *
- * Description: Check that the im_name has not already been registered,
- * complain if it has.  For new data, add it to the inter_module_entry
- * list.
- */
-void inter_module_register(const char *im_name, struct module *owner, const void *userdata)
-{
-        struct list_head *tmp;
-        struct inter_module_entry *ime, *ime_new;
-
-        if (!(ime_new = kzalloc(sizeof(*ime), GFP_KERNEL))) {
-                /* Overloaded kernel, not fatal */
-                printk(KERN_ERR
-                        "Aiee, inter_module_register: cannot kmalloc entry for '%s'\n",
-                        im_name);
-                kmalloc_failed = 1;
-                return;
-        }
-        ime_new->im_name = im_name;
-        ime_new->owner = owner;
-        ime_new->userdata = userdata;
-
-        spin_lock(&ime_lock);
-        list_for_each(tmp, &ime_list) {
-                ime = list_entry(tmp, struct inter_module_entry, list);
-                if (strcmp(ime->im_name, im_name) == 0) {
-                        spin_unlock(&ime_lock);
-                        kfree(ime_new);
-                        /* Program logic error, fatal */
-                        printk(KERN_ERR "inter_module_register: duplicate im_name '%s'", im_name);
-                        BUG();
-                }
-        }
-        list_add(&(ime_new->list), &ime_list);
-        spin_unlock(&ime_lock);
-}
-
-/**
- * inter_module_unregister - unregister a set of inter module data.
- * @im_name: an arbitrary string to identify the data, must be unique
- *
- * Description: Check that the im_name has been registered, complain if
- * it has not.  For existing data, remove it from the
- * inter_module_entry list.
- */
-void inter_module_unregister(const char *im_name)
-{
-        struct list_head *tmp;
-        struct inter_module_entry *ime;
-
-        spin_lock(&ime_lock);
-        list_for_each(tmp, &ime_list) {
-                ime = list_entry(tmp, struct inter_module_entry, list);
-                if (strcmp(ime->im_name, im_name) == 0) {
-                        list_del(&(ime->list));
-                        spin_unlock(&ime_lock);
-                        kfree(ime);
-                        return;
-                }
-        }
-        spin_unlock(&ime_lock);
-        if (kmalloc_failed) {
-                printk(KERN_ERR
-                        "inter_module_unregister: no entry for '%s', "
-                        "probably caused by previous kmalloc failure\n",
-                        im_name);
-                return;
-        }
-        else {
-                /* Program logic error, fatal */
-                printk(KERN_ERR "inter_module_unregister: no entry for '%s'", im_name);
-                BUG();
-        }
-}
-
-/**
- * inter_module_get - return arbitrary userdata from another module.
- * @im_name: an arbitrary string to identify the data, must be unique
- *
- * Description: If the im_name has not been registered, return NULL.
- * Try to increment the use count on the owning module, if that fails
- * then return NULL.  Otherwise return the userdata.
- */
-static const void *inter_module_get(const char *im_name)
-{
-        struct list_head *tmp;
-        struct inter_module_entry *ime;
-        const void *result = NULL;
-
-        spin_lock(&ime_lock);
-        list_for_each(tmp, &ime_list) {
-                ime = list_entry(tmp, struct inter_module_entry, list);
-                if (strcmp(ime->im_name, im_name) == 0) {
-                        if (try_module_get(ime->owner))
-                                result = ime->userdata;
-                        break;
-                }
-        }
-        spin_unlock(&ime_lock);
-        return(result);
-}
-
-/**
- * inter_module_get_request - im get with automatic request_module.
- * @im_name: an arbitrary string to identify the data, must be unique
- * @modname: module that is expected to register im_name
- *
- * Description: If inter_module_get fails, do request_module then retry.
- */
-const void *inter_module_get_request(const char *im_name, const char *modname)
-{
-        const void *result = inter_module_get(im_name);
-        if (!result) {
-                request_module("%s", modname);
-                result = inter_module_get(im_name);
-        }
-        return(result);
-}
-
-/**
- * inter_module_put - release use of data from another module.
- * @im_name: an arbitrary string to identify the data, must be unique
- *
- * Description: If the im_name has not been registered, complain,
- * otherwise decrement the use count on the owning module.
- */
-void inter_module_put(const char *im_name)
-{
-        struct list_head *tmp;
-        struct inter_module_entry *ime;
-
-        spin_lock(&ime_lock);
-        list_for_each(tmp, &ime_list) {
-                ime = list_entry(tmp, struct inter_module_entry, list);
-                if (strcmp(ime->im_name, im_name) == 0) {
-                        if (ime->owner)
-                                module_put(ime->owner);
-                        spin_unlock(&ime_lock);
-                        return;
-                }
-        }
-        spin_unlock(&ime_lock);
-        printk(KERN_ERR "inter_module_put: no entry for '%s'", im_name);
-        BUG();
-}
-
-EXPORT_SYMBOL(inter_module_register);
-EXPORT_SYMBOL(inter_module_unregister);
-EXPORT_SYMBOL(inter_module_get_request);
-EXPORT_SYMBOL(inter_module_put);
-
-MODULE_LICENSE("GPL");
-
diff --git a/kernel/signal.c b/kernel/signal.c
index e5f8aea78ffe..1b3c921737e2 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -23,12 +23,12 @@
 #include <linux/syscalls.h>
 #include <linux/ptrace.h>
 #include <linux/signal.h>
-#include <linux/audit.h>
 #include <linux/capability.h>
 #include <asm/param.h>
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
 #include <asm/siginfo.h>
+#include "audit.h"      /* audit_signal_info() */
 
 /*
  * SLAB caches for signal bits.
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index e82726faeeff..0d656e61621d 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -150,7 +150,7 @@ extern ctl_table random_table[];
 #ifdef CONFIG_UNIX98_PTYS
 extern ctl_table pty_table[];
 #endif
-#ifdef CONFIG_INOTIFY
+#ifdef CONFIG_INOTIFY_USER
 extern ctl_table inotify_table[];
 #endif
 
@@ -1028,7 +1028,7 @@ static ctl_table fs_table[] = {
                 .mode           = 0644,
                 .proc_handler   = &proc_doulongvec_minmax,
         },
-#ifdef CONFIG_INOTIFY
+#ifdef CONFIG_INOTIFY_USER
         {
                 .ctl_name       = FS_INOTIFY,
                 .procname       = "inotify",
diff --git a/kernel/user.c b/kernel/user.c
index 2116642f42c6..4b1eb745afa1 100644
--- a/kernel/user.c
+++ b/kernel/user.c
@@ -140,7 +140,7 @@ struct user_struct * alloc_uid(uid_t uid)
                 atomic_set(&new->processes, 0);
                 atomic_set(&new->files, 0);
                 atomic_set(&new->sigpending, 0);
-#ifdef CONFIG_INOTIFY
+#ifdef CONFIG_INOTIFY_USER
                 atomic_set(&new->inotify_watches, 0);
                 atomic_set(&new->inotify_devs, 0);
 #endif
diff --git a/lib/rbtree.c b/lib/rbtree.c
index 14b791ac5089..1e55ba1c2edf 100644
--- a/lib/rbtree.c
+++ b/lib/rbtree.c
@@ -26,60 +26,66 @@
 static void __rb_rotate_left(struct rb_node *node, struct rb_root *root)
 {
         struct rb_node *right = node->rb_right;
+        struct rb_node *parent = rb_parent(node);
 
         if ((node->rb_right = right->rb_left))
-                right->rb_left->rb_parent = node;
+                rb_set_parent(right->rb_left, node);
         right->rb_left = node;
 
-        if ((right->rb_parent = node->rb_parent))
+        rb_set_parent(right, parent);
+
+        if (parent)
         {
-                if (node == node->rb_parent->rb_left)
-                        node->rb_parent->rb_left = right;
+                if (node == parent->rb_left)
+                        parent->rb_left = right;
                 else
-                        node->rb_parent->rb_right = right;
+                        parent->rb_right = right;
         }
         else
                 root->rb_node = right;
-        node->rb_parent = right;
+        rb_set_parent(node, right);
 }
 
 static void __rb_rotate_right(struct rb_node *node, struct rb_root *root)
 {
         struct rb_node *left = node->rb_left;
+        struct rb_node *parent = rb_parent(node);
 
         if ((node->rb_left = left->rb_right))
-                left->rb_right->rb_parent = node;
+                rb_set_parent(left->rb_right, node);
         left->rb_right = node;
 
-        if ((left->rb_parent = node->rb_parent))
+        rb_set_parent(left, parent);
+
+        if (parent)
         {
-                if (node == node->rb_parent->rb_right)
-                        node->rb_parent->rb_right = left;
+                if (node == parent->rb_right)
+                        parent->rb_right = left;
                 else
-                        node->rb_parent->rb_left = left;
+                        parent->rb_left = left;
         }
         else
                 root->rb_node = left;
-        node->rb_parent = left;
+        rb_set_parent(node, left);
 }
 
 void rb_insert_color(struct rb_node *node, struct rb_root *root)
 {
         struct rb_node *parent, *gparent;
 
-        while ((parent = node->rb_parent) && parent->rb_color == RB_RED)
+        while ((parent = rb_parent(node)) && rb_is_red(parent))
         {
-                gparent = parent->rb_parent;
+                gparent = rb_parent(parent);
 
                 if (parent == gparent->rb_left)
                 {
                         {
                                 register struct rb_node *uncle = gparent->rb_right;
-                                if (uncle && uncle->rb_color == RB_RED)
+                                if (uncle && rb_is_red(uncle))
                                 {
-                                        uncle->rb_color = RB_BLACK;
-                                        parent->rb_color = RB_BLACK;
-                                        gparent->rb_color = RB_RED;
+                                        rb_set_black(uncle);
+                                        rb_set_black(parent);
+                                        rb_set_red(gparent);
                                         node = gparent;
                                         continue;
                                 }
@@ -94,17 +100,17 @@ void rb_insert_color(struct rb_node *node, struct rb_root *root)
                                 node = tmp;
                         }
 
-                        parent->rb_color = RB_BLACK;
-                        gparent->rb_color = RB_RED;
+                        rb_set_black(parent);
+                        rb_set_red(gparent);
                         __rb_rotate_right(gparent, root);
                 } else {
                         {
                                 register struct rb_node *uncle = gparent->rb_left;
-                                if (uncle && uncle->rb_color == RB_RED)
+                                if (uncle && rb_is_red(uncle))
                                 {
-                                        uncle->rb_color = RB_BLACK;
-                                        parent->rb_color = RB_BLACK;
-                                        gparent->rb_color = RB_RED;
+                                        rb_set_black(uncle);
+                                        rb_set_black(parent);
+                                        rb_set_red(gparent);
                                         node = gparent;
                                         continue;
                                 }
@@ -119,13 +125,13 @@ void rb_insert_color(struct rb_node *node, struct rb_root *root)
                                 node = tmp;
                         }
 
-                        parent->rb_color = RB_BLACK;
-                        gparent->rb_color = RB_RED;
+                        rb_set_black(parent);
+                        rb_set_red(gparent);
                         __rb_rotate_left(gparent, root);
                 }
         }
 
-        root->rb_node->rb_color = RB_BLACK;
+        rb_set_black(root->rb_node);
 }
 EXPORT_SYMBOL(rb_insert_color);
 
@@ -134,43 +140,40 @@ static void __rb_erase_color(struct rb_node *node, struct rb_node *parent,
 {
         struct rb_node *other;
 
-        while ((!node || node->rb_color == RB_BLACK) && node != root->rb_node)
+        while ((!node || rb_is_black(node)) && node != root->rb_node)
         {
                 if (parent->rb_left == node)
                 {
                         other = parent->rb_right;
-                        if (other->rb_color == RB_RED)
+                        if (rb_is_red(other))
                         {
-                                other->rb_color = RB_BLACK;
-                                parent->rb_color = RB_RED;
+                                rb_set_black(other);
+                                rb_set_red(parent);
                                 __rb_rotate_left(parent, root);
                                 other = parent->rb_right;
                         }
-                        if ((!other->rb_left ||
-                             other->rb_left->rb_color == RB_BLACK)
-                            && (!other->rb_right ||
-                                other->rb_right->rb_color == RB_BLACK))
+                        if ((!other->rb_left || rb_is_black(other->rb_left)) &&
+                            (!other->rb_right || rb_is_black(other->rb_right)))
                         {
-                                other->rb_color = RB_RED;
+                                rb_set_red(other);
                                 node = parent;
-                                parent = node->rb_parent;
+                                parent = rb_parent(node);
                         }
                         else
                         {
-                                if (!other->rb_right ||
-                                    other->rb_right->rb_color == RB_BLACK)
+                                if (!other->rb_right || rb_is_black(other->rb_right))
                                 {
-                                        register struct rb_node *o_left;
+                                        struct rb_node *o_left;
                                         if ((o_left = other->rb_left))
-                                                o_left->rb_color = RB_BLACK;
-                                        other->rb_color = RB_RED;
+                                                rb_set_black(o_left);
+                                        rb_set_red(other);
                                         __rb_rotate_right(other, root);
                                         other = parent->rb_right;
                                 }
-                                other->rb_color = parent->rb_color;
-                                parent->rb_color = RB_BLACK;
+                                rb_set_color(other, rb_color(parent));
+                                rb_set_black(parent);
                                 if (other->rb_right)
-                                        other->rb_right->rb_color = RB_BLACK;
+                                        rb_set_black(other->rb_right);
                                 __rb_rotate_left(parent, root);
                                 node = root->rb_node;
                                 break;
@@ -179,38 +182,35 @@ static void __rb_erase_color(struct rb_node *node, struct rb_node *parent,
                 else
                 {
                         other = parent->rb_left;
-                        if (other->rb_color == RB_RED)
+                        if (rb_is_red(other))
                         {
-                                other->rb_color = RB_BLACK;
-                                parent->rb_color = RB_RED;
+                                rb_set_black(other);
+                                rb_set_red(parent);
                                 __rb_rotate_right(parent, root);
                                 other = parent->rb_left;
                         }
-                        if ((!other->rb_left ||
-                             other->rb_left->rb_color == RB_BLACK)
-                            && (!other->rb_right ||
-                                other->rb_right->rb_color == RB_BLACK))
+                        if ((!other->rb_left || rb_is_black(other->rb_left)) &&
+                            (!other->rb_right || rb_is_black(other->rb_right)))
                         {
-                                other->rb_color = RB_RED;
+                                rb_set_red(other);
                                 node = parent;
-                                parent = node->rb_parent;
+                                parent = rb_parent(node);
                         }
                         else
                         {
-                                if (!other->rb_left ||
-                                    other->rb_left->rb_color == RB_BLACK)
+                                if (!other->rb_left || rb_is_black(other->rb_left))
                                 {
                                         register struct rb_node *o_right;
                                         if ((o_right = other->rb_right))
-                                                o_right->rb_color = RB_BLACK;
-                                        other->rb_color = RB_RED;
+                                                rb_set_black(o_right);
+                                        rb_set_red(other);
                                         __rb_rotate_left(other, root);
                                         other = parent->rb_left;
                                 }
-                                other->rb_color = parent->rb_color;
-                                parent->rb_color = RB_BLACK;
+                                rb_set_color(other, rb_color(parent));
+                                rb_set_black(parent);
                                 if (other->rb_left)
-                                        other->rb_left->rb_color = RB_BLACK;
+                                        rb_set_black(other->rb_left);
                                 __rb_rotate_right(parent, root);
                                 node = root->rb_node;
                                 break;
@@ -218,7 +218,7 @@ static void __rb_erase_color(struct rb_node *node, struct rb_node *parent,
                 }
         }
         if (node)
-                node->rb_color = RB_BLACK;
+                rb_set_black(node);
 }
 
 void rb_erase(struct rb_node *node, struct rb_root *root)
@@ -238,48 +238,41 @@ void rb_erase(struct rb_node *node, struct rb_root *root)
                 while ((left = node->rb_left) != NULL)
                         node = left;
                 child = node->rb_right;
-                parent = node->rb_parent;
-                color = node->rb_color;
+                parent = rb_parent(node);
+                color = rb_color(node);
 
                 if (child)
-                        child->rb_parent = parent;
-                if (parent)
-                {
-                        if (parent->rb_left == node)
-                                parent->rb_left = child;
-                        else
-                                parent->rb_right = child;
-                }
-                else
-                        root->rb_node = child;
-
-                if (node->rb_parent == old)
+                        rb_set_parent(child, parent);
+                if (parent == old) {
+                        parent->rb_right = child;
                         parent = node;
-                node->rb_parent = old->rb_parent;
-                node->rb_color = old->rb_color;
+                } else
+                        parent->rb_left = child;
+
+                node->rb_parent_color = old->rb_parent_color;
                 node->rb_right = old->rb_right;
                 node->rb_left = old->rb_left;
 
-                if (old->rb_parent)
+                if (rb_parent(old))
                 {
-                        if (old->rb_parent->rb_left == old)
-                                old->rb_parent->rb_left = node;
+                        if (rb_parent(old)->rb_left == old)
+                                rb_parent(old)->rb_left = node;
                         else
-                                old->rb_parent->rb_right = node;
+                                rb_parent(old)->rb_right = node;
                 } else
                         root->rb_node = node;
 
-                old->rb_left->rb_parent = node;
+                rb_set_parent(old->rb_left, node);
                 if (old->rb_right)
-                        old->rb_right->rb_parent = node;
+                        rb_set_parent(old->rb_right, node);
                 goto color;
         }
 
-        parent = node->rb_parent;
-        color = node->rb_color;
+        parent = rb_parent(node);
+        color = rb_color(node);
 
         if (child)
-                child->rb_parent = parent;
+                rb_set_parent(child, parent);
         if (parent)
         {
                 if (parent->rb_left == node)
@@ -327,6 +320,8 @@ EXPORT_SYMBOL(rb_last);
 
 struct rb_node *rb_next(struct rb_node *node)
 {
+        struct rb_node *parent;
+
         /* If we have a right-hand child, go down and then left as far
            as we can. */
         if (node->rb_right) {
@@ -342,15 +337,17 @@ struct rb_node *rb_next(struct rb_node *node)
            ancestor is a right-hand child of its parent, keep going
            up. First time it's a left-hand child of its parent, said
            parent is our 'next' node. */
-        while (node->rb_parent && node == node->rb_parent->rb_right)
-                node = node->rb_parent;
+        while ((parent = rb_parent(node)) && node == parent->rb_right)
+                node = parent;
 
-        return node->rb_parent;
+        return parent;
 }
 EXPORT_SYMBOL(rb_next);
 
 struct rb_node *rb_prev(struct rb_node *node)
 {
+        struct rb_node *parent;
+
         /* If we have a left-hand child, go down and then right as far
            as we can. */
         if (node->rb_left) {
@@ -362,17 +359,17 @@ struct rb_node *rb_prev(struct rb_node *node)
 
         /* No left-hand children. Go up till we find an ancestor which
            is a right-hand child of its parent */
-        while (node->rb_parent && node == node->rb_parent->rb_left)
-                node = node->rb_parent;
+        while ((parent = rb_parent(node)) && node == parent->rb_left)
+                node = parent;
 
-        return node->rb_parent;
+        return parent;
 }
 EXPORT_SYMBOL(rb_prev);
 
 void rb_replace_node(struct rb_node *victim, struct rb_node *new,
                      struct rb_root *root)
 {
-        struct rb_node *parent = victim->rb_parent;
+        struct rb_node *parent = rb_parent(victim);
 
         /* Set the surrounding nodes to point to the replacement */
         if (parent) {
@@ -384,9 +381,9 @@ void rb_replace_node(struct rb_node *victim, struct rb_node *new,
                 root->rb_node = new;
         }
         if (victim->rb_left)
-                victim->rb_left->rb_parent = new;
+                rb_set_parent(victim->rb_left, new);
         if (victim->rb_right)
-                victim->rb_right->rb_parent = new;
+                rb_set_parent(victim->rb_right, new);
 
         /* Copy the pointers/colour from the victim to the replacement */
         *new = *victim;
diff --git a/security/keys/key.c b/security/keys/key.c
index b6061fa29da7..3fdc49c6a02c 100644
--- a/security/keys/key.c
+++ b/security/keys/key.c
@@ -211,12 +211,12 @@ static inline void key_alloc_serial(struct key *key)
                         key->serial = 2;
                 key_serial_next = key->serial + 1;
 
-                if (!parent->rb_parent)
+                if (!rb_parent(parent))
                         p = &key_serial_tree.rb_node;
-                else if (parent->rb_parent->rb_left == parent)
-                        p = &parent->rb_parent->rb_left;
+                else if (rb_parent(parent)->rb_left == parent)
+                        p = &(rb_parent(parent)->rb_left);
                 else
-                        p = &parent->rb_parent->rb_right;
+                        p = &(rb_parent(parent)->rb_right);
 
                 parent = rb_next(parent);
                 if (!parent)
diff --git a/security/selinux/ss/services.c b/security/selinux/ss/services.c
index c284dbb8b8c0..e9548bc049e1 100644
--- a/security/selinux/ss/services.c
+++ b/security/selinux/ss/services.c
@@ -1980,7 +1980,7 @@ int selinux_audit_rule_match(u32 ctxid, u32 field, u32 op,
                 break;
         case AUDIT_SE_SEN:
         case AUDIT_SE_CLR:
-                level = (op == AUDIT_SE_SEN ?
+                level = (field == AUDIT_SE_SEN ?
                          &ctxt->range.level[0] : &ctxt->range.level[1]);
                 switch (op) {
                 case AUDIT_EQUAL: